类

1. 多态

不同的子类对象,调用相同的父类方法,产生不同的执行结果

关键字: 继承改写

class Soldier():def attack(self):passdef back(self):pass# 陆军
class Army(Soldier):def attack(self):print("[陆军]搏击,ufc,无限制格斗,太极,八卦,占星,制作八卦符")def back(self):print("[陆军]白天晨跑10公里,也行800百公里")# 海军
class Navy(Soldier):def attack(self):print("[海军]潜泳水下30个小时,手捧鱼雷,亲自送到敌人的老挝,炸掉敌人的碉堡")def back(self):print("[海军]每小时在海底夜行800公里,游的比鲨鱼还快")# 空军
class AirForce(Soldier):    def attack(self):print("[空军]空中夺导弹,手撕飞机,在空中打飞机,精准弹幕")def back(self):print("[空军]高中跳伞,落地成盒")# 实例化陆军对象
army_obj = Army()
# 实例化海军对象
navy_obj = Navy()
# 实例化空军对象
af_obj = AirForce()lst = [army_obj,navy_obj,af_obj]
strvar = """
1.所有兵种开始攻击训练
2.所有兵种开始撤退训练
3.空军练习攻击,其他兵种练习撤退
"""
print(strvar)
num = input("将军请下令,选择训练的种类")
for i in lst:if num == "1":i.attack()elif num == "2":i.back()elif num == "3":if isinstance(i,AirForce):i.attack()else:i.back()else:print("将军~ 风太大 我听不见~")break

2. _new_ 魔术方法

触发时机: 实例化类生成对象的时候触发 (触发时机在__init__之前)

功能: 控制对象的创建过程

参数: 至少一个 cls 接受当前的类 , 其他根据情况决定

返回值: 通常返回对象或None

# (1)基本语法
class MyClass2():pty = 100
obj2= MyClass2()class MyClass():def __new__(cls):print(cls)# 类.方法(自定义类) => 借助父类object创建MyClass这个类的对象obj = object.__new__(cls)# (1) 借助父类object创建自己类的一个对象# return obj# (2) 返回其他类的对象# return obj2# (3) 不返回任何对象return Noneobj = MyClass()
print(obj)
# print(obj.pty)# (2) __new__ 触发时机快于构造方法
"""
__new__  用来创建对象
__init__ 用来初始化对象
先创建对象,才能在初始化对象,所以__new__快于__init__
"""
class Boat():def __new__(cls):print(2)return object.__new__(cls)def __init__(self):print(1)obj = Boat()# (3) __new__ 和 __init__ 参数一一对应# 单个参数的情况
class Boat():def __new__(cls,name):return object.__new__(cls)def __init__(self,name):self.name = nameobj = Boat("友谊的小船说裂开就裂开")
print(obj.name)# 多个参数的情况
class Boat():def __new__(cls,*args,**kwargs):return object.__new__(cls)def __init__(self,name,color,shangpai):self.name = nameself.color = colorself.shangpai = shangpaiobj = Boat("泰坦尼克号","屎绿色","京A66688")
print(obj.name)
print(obj.color)
print(obj.shangpai)# (4) 注意点
print("<======================>")
"""如果返回的对象不是自己本类中的对象,不会触发本类的构造方法"""
class MyClass():pty = 200
obj = MyClass()class Boat():def __new__(cls,*args,**kwargs):# return object.__new__(cls)# return objreturn Nonedef __init__(self):print("构造方法被触发")
obj = Boat()
print(obj)

3. 单态模式

一个类 , 无论实例化多少个对象 , 都有且只有一个

优点: 节省内存空间 , 提升执行效率

针对于不要额外对该对象添加成员的场景 (比如: mysql增删改查)

# (1) 基本语法
class SingleTon():__obj = Nonedef __new__(cls):if cls.__obj is None:# 把创建出来的对象赋值给私有成员__objcls.__obj = object.__new__(cls)return cls.__objobj1 = SingleTon()
obj2 = SingleTon()
obj3 = SingleTon()
print(obj1,obj2,obj3)"""
第一次实例化对象时候, 创建一个对象赋值给cls.__obj,返回 cls.__obj
第二次实例化对象时候, 判定cls.__obj is None: 不成立, 直接返回上一次创建好的那一个对象
第三次实例化对象时候, 判定cls.__obj is None: 不成立, 直接返回上一次创建好的那一个对象
"""# (2) 单态模式 + 构造方式
class SingleTon():__obj = Nonedef __new__(cls,*args,**kwargs):if cls.__obj is None:cls.__obj = object.__new__(cls)return cls.__objdef __init__(self,name):    self.name = nameobj1 = SingleTon("宋云杰")
obj2 = SingleTon("戈隆")
print(obj1.name)
print(obj2.name)
print(aaa)
"""
obj1 = SingleTon(宋云杰) self.name = 宋云杰
obj2 = SingleTon(戈隆)   self.name = "戈隆"
self 代表的是本对象第一次实例化对象时候,创建一个对象,赋值name为宋云杰
第二次实例化对象时候,因为 cls.__obj is None不满足,返回上一个创建好的对象
为上一个对象的name这个属性赋值 为戈隆
obj1 和 obj2 所指代的对象是同一个对象obj1.name => 戈隆
obj2.name => 戈隆
"""
"""
戈隆
戈隆
"""

4. 练习

# 第一题
class Person():animal = '高级动物'soul = '有灵魂'language = '语言'def __init__(self,country,name,sex,age,height):self.country = countryself.name = nameself.sex = sexself.age = ageself.height = heightdef eat(self):print("{}在吃饭".format(self.name))def sleep():passdef work():passp1 =  Person("中国","alex","未知",42,175)
p2 =  Person("美国","武大","男",35,160)
p3 =  Person("中文","宋云杰","男",18,130)
p4 =  Person(p1.country,p2.name,p3.sex,p2.age,p3.height)p1.eat()
p2.eat()
p3.eat()
print(p1.animal)
print(p2.soul)
print(p3.language)# 第二题
class MyClass():def __init__(self,name,age,sex):self.name = nameself.age = ageself.sex = sexdef print_func(self):strvar = """
{who}，{age}，{sex}，上山去砍柴
{who}，{age}，{sex}，开车去东北
{who}，{age}，{sex}，最爱大保健"""print(strvar.format(who=self.name,age=self.age,sex=self.sex))obj = MyClass("小明","10岁","男")
obj.print_func()# 第三题
class Game_role():def __init__(self,name,ad,hp):self.name = nameself.ad = adself.hp = hpdef attack(self,obj):print('{}攻击{},{}掉了{}血,  还剩{}血'.format(self.name,obj.name,obj.name,self.ad,obj.hp-self.ad))gailun = Game_role("盖伦",10,100)
jianhao = Game_role("剑豪",20,80)
gailun.attack(jianhao)  # self -> gailun  obj -> jianhao# 第四题
import math
class Circle():def __init__(self,r):self.r = rdef zhouchang(self):return 2 * math.pi * self.rdef mianji(self):return math.pi * pow(self.r,2)obj = Circle(10)
print(obj.zhouchang())
print(obj.mianji())# 第五题
class A():abc = 5class B():def __init__(self,obj):self.pty = objobj1 = A()
obj2 = B(obj1)
print(obj2.pty)
print(obj2.pty.abc)# 简答题
# 1.类或对象是否能做字典的key   可以~
# 2.简述python的私有成员是如何实现的  改名策略[_类+私有成员名]
# 3.私有成员能在类的外部使用么?能在子类中使用么?不行 不行# # 1.读程序写结果.(不执行)
class StarkConfig(object):def __init__(self,num):self.num = numdef changelist(self,request):print(self.num,request)class RoleConfig(StarkConfig):def changelist(self,request):print('666')# 创建了一个列表,列表中有三个对象(实例)
config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
for item in config_obj_list:print(item.num) # 1 2 3print("<====================>")
# 2.读程序写结果.(不执行)
class StarkConfig(object):def __init__(self,num):self.num = numdef changelist(self,request):print(self.num,request)class RoleConfig(StarkConfig):pass# 创建了一个列表,列表中有三个对象(实例)
config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
for item in config_obj_list:item.changelist(168) # 1 168 2 168 3 168
print(config_obj_list[0].num) # 1# 3.读程序写结果.(不执行)
print("<====================>")
class StarkConfig(object):def __init__(self,num):self.num = numdef changelist(self,request):print(self.num,request)class RoleConfig(StarkConfig):def changelist(self,request):print(666,self.num)config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
for item in config_obj_list:item.changelist(168) # 1,168 | 2,168 |  666,3# 4.读程序写结果.(不执行)
print("<====================>")
class StarkConfig(object):def __init__(self,num):self.num = numdef changelist(self,request):print(self.num,request)def run(self):self.changelist(999)class RoleConfig(StarkConfig):def changelist(self,request):print(666,self.num)config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
config_obj_list[1].run()   #2 999
config_obj_list[2].run()   #666 3# 5.读程序写结果.(不执行)
print("<====================>")
class StarkConfig(object):def __init__(self,num):self.num = numdef changelist(self,request):print(self.num,request)def run(self):self.changelist(999)class RoleConfig(StarkConfig):def changelist(self,request):print(666,self.num)class AdminSite(object):def __init__(self):self._registry = {}def register(self,k,v):self._registry[k] = vsite = AdminSite()
print(len(site._registry))  # 0
site.register('range',666)  # self._registry[range] = 666
site.register('shilei',438) # self._registry[shilei] = 438
print(len(site._registry))  # 2site.register('lyd',StarkConfig(19))# self._registry[lyd] = StarkConfig(19)
site.register('yjl',StarkConfig(20))# self._registry[yjl] = StarkConfig(20)
site.register('fgz',RoleConfig(33)) # self._registry[fgz] = RoleConfig(33)
print(len(site._registry))   # 5
print(site._registry)# 6.读程序写结果.(不执行)
print("<====================>")
class StarkConfig():def __init__(self,num):self.num = numdef changelist(self,request):print(self.num,request)def run(self):self.changelist(999)class RoleConfig(StarkConfig):def changelist(self,request): # request = 5print(666,self.num,request)class AdminSite():def __init__(self):self._registry = {}def register(self,k,v):self._registry[k] = vsite = AdminSite()
site.register('lyd',StarkConfig(19))
site.register('yjl',StarkConfig(20))
site.register('fgz',RoleConfig(33)) # num 33for k,row in site._registry.items():row.changelist(5) # 19 5 | 20 5 | 666 33 5
for k,row in site._registry.items():row.run() # 19 , 999 | 20 , 999 | 666 33 999# 7.读程序写结果.(不执行)
"""
在类中为当前对象添加了私有成员.
"""
print("<====================>")
class JustCounter:__secretCount = 0def count(self):print(self.__secretCount) # 1.获取类当中的私有成员 0 | 2. 获取的是对象中的私有成员 1self.__secretCount += 1 # self.__secretCount = self.__secretCount + 1 = 0 + 1 = 1 # 给对象中的私有成员赋值def count3():print(JustCounter.__secretCount)  # 0# JustCounter.__secretCount = JustCounter.__secretCount + 1 = 0 + 1 = 1JustCounter.__secretCount += 1print(JustCounter.__secretCount) # 1class Bars(JustCounter):def count2(self):print(self.__secretCount)"""
#  情况一
counter1 = JustCounter()
counter1.count() # 0
counter1.count() # 1
JustCounter.count3()  # 0 1#  情况二
counter2 = Bars()
counter2.count() # 0
counter2.count() # 1#  情况三
# JustCounter.count3() # 0 1
"""

5. 连贯操作

通过 ‘.’ 不停的调用下一个对象的操作就是连贯操作

class MyClass1():pth1 = 10class MyClass2():def __init__(self,obj):self.obj = objobj = MyClass1()
obj2 = MyClass2(obj)
# 对象.对象.属性
print(obj2.obj.pth1)class MyClass1():pty1 = 101def func1(self):print("我是func1函数")class MyClass2():def __init__(self,obj):self.pty2 = obj    def func2(self):print("我是func2函数")class MyClass3():pty3 = 103    def __init__(self,obj):self.pty3 = obj def func2(self):print("我是func3函数")obj1 = MyClass1()
obj2 = MyClass2(obj1)
obj3 = MyClass3(obj2)  # 使用obj3调用func1方法?
# 对象.pty3 => obj2  | obj2.pty2 => obj1  |  obj1.func1()
obj3.pty3.pty2.func1()
print(obj3.pty3.pty2.pty1)
obj3.pty3.func2()

6. 小人射击游戏

面向对象的核心思想: 把对象当作程序中的一个最小单元 , 让对象操作一切

'''
弹夹: 属性: 子弹数量方法: 无枪:     属性: 弹夹方法: 射击人: 属性: 枪方法: 1. 射击  2. 换子弹
'''# main 文件
from package.bulletbox import BulletBox
from package.gun import Gun
from package.person import Person# 先创建弹夹
danjia = BulletBox(20)
# 再创建一杆枪
ak47 = Gun(danjia)
# 最后创建一个人
songyunjie = Person(ak47,'宋云杰')# 小人射击
if __name__ == '__main__':# 射击songyunjie.fire(15)# 填充songyunjie.fillcount(10)# 再射击songyunjie.fire(15)# package 包下的模块
# 1. bulletbox 模块
class BulletBox():def __init__(self,bulletcount):self.bulletcount = bulletcount# 2. gun 模块
class Gun():def __init__(self,bulletbox):# 存放的是弹夹对象self.bulletbox = bulletboxdef shoot(self,shootcount):if self.bulletbox.bulletcount < shootcount:print('对不起,请先填充子弹~')else:# 剩余的子弹 = 总的子弹数量 - 射击的数量self.bulletbox.bulletcount -= shootcountprint('突' * shootcount , '你射出了{}发,还剩下{}发'.format(shootcount,self.bulletbox.bulletcount))# 3. 人类
class Person():def __init__(self,gun,name):self.gun = gunself.name = name# 填充子弹def fillcount(self,fillnum):# 往弹夹里面塞子弹# self.枪对象 -> 弹夹对象 -> 弹夹数量属性self.gun.bulletbox.bulletcount += fillnum# 射击def fire(self,num):print('{}此刻正在野外射击~'.format(self.name))# 枪对象.shootself.gun.shoot(num)

python-多态_new魔法方法_单态模式_连贯操作相关推荐

python深度讲解_《深度剖析CPython解释器》21. Python类机制的深度解析(第五部分): 全方位介绍Python中的魔法方法，一网打尽...
楔子下面我们来看一下Python中的魔法方法,我们知道Python将操作符都抽象成了一个魔法方法(magic method),实例对象进行操作时,实际上会调用魔法方法.也正因为如此,numpy才得以 ...
刻意练习：Python基础 -- Task11. 魔法方法
背景我们准备利用17天时间,将 "Python基础的刻意练习" 分为如下任务: Task01:变量.运算符与数据类型(1day) Task02:条件与循环(1day) Task0 ...
python入门——P41魔法方法：构造和析构
魔法方法总是被双下划线包围魔法方法是面向对象Python的一切魔法方法的强大,体现在他们总能在合适的时候自动调用 __init__(self[, -]) 在实例被构造初始就需要属性,对一个对象进行 ...
从零开始学Python编程之魔法方法
大家好,我是岛上程序猿,欢迎关注! Python中的魔法方法是一种特殊方法,以双下划线开头和结尾,并且可以在类定义中定义,用于执行特定的操作.在本文中,我们将介绍魔法方法的作用.如何使用它们以及Pyt ...
Python的类和对象的介绍，定义类和对象，定义实例方法和属性以及Python中的魔法方法
Day09新手小白学python 第九节 Python的类和对象的介绍,定义类和对象,定义实例方法和属性以及Python中的魔法方法目录 Day09新手小白学python 前言一.面向对象介绍二 ...
python 魔法方法常用的有_【Python】面向对象常用魔法方法集合
最近发现同学们的问题保持了一致,都是在问我一些魔法方法的使用及意义,所以在这里也是专门给大家整理一份魔法方法的详解及使用集合. 众所周知,方法是需要调用执行的,而魔法方法则不一样,他无需你的调用,在特 ...
Python面向对象、魔法方法
文章目录写在篇前封装继承单继承 Mixin 抽象多态特殊方法&属性特殊属性魔法方法辅助知识 OOP实用函数迭代器生成器写在篇前 OOP(Object Oriented ...
python类的魔法方法基础
参考:小甲鱼视频作用:对类进行"刷机"级的修改魔法方法的标志:①被__xxx__两条下划线包围:如典型的__init__ 1.__init__(self,....) 问:在定义 ...
python中的魔法方法__new___Python魔法方法会调用new方法吗？
Python中的sort()方法用于数组排序,本文以实例形式对此加以详细说明:一.基本形式列表有自己的sort方法,其对列表进行原址排序,既然是原址排序,那显然元组不可能拥有这种方法,因为元组是不可修 ...
python 类对象魔法方法概念+习题
类对象类对象是c++和java中都有的内容,python定义类的简单语法如下: class 类名: -类变量或者方法 Python 的类定义有点像函数定义,都是以冒号:作为类体的开始,以统一缩进 ...

python-多态_new魔法方法_单态模式_连贯操作

类