小白IT：从0~明白带你体验python中做上帝感觉--一切皆对象，处处是多态——面向对象

Python 面向对象从0到基础

回合制<人狗大战>游戏，通过函数实现

'''
函数
    制作一个人狗大战游戏。
        人：名字，血量，攻击力，性别
        狗：名字，血量，攻击力，品种
'''
def Person(name,hp,attack,gender):
    dic = {
     'name': name, 'health': hp, 'attack': attack, 'gender': gender}

    def fight(dog):
        dog['health'] -= dic['attack']
        print('%s攻击了%s,%s掉了%s点血'%(dic['name'],dog['name'],dog['name'],dic['attack']))
    dic['fight'] = fight
    return dic

def Dog(name,hp,attack,kind):
    dic = {
     'name': name, 'health': hp, 'attack': attack, 'kind': kind}

    def bite(person):
        person['health'] -= dic['attack']
        print('%s攻击了%s，%s掉了%s点血.'%(dic['name'],person['health'],person['name'],dic['attack']))
    dic['bite'] = bite
    return dic

# 互相打斗
alex = Person('alex',300,30,'buxiang')
hei = Dog('xiaohei',200,20,'hashiqi')
# print(alex)
# print(hei)

alex['fight'](hei)
print(hei['health'])
hei['bite'](alex)
print(alex['health'])
1.``通过两个模子，捏造出两个具体的对象，``  ``抽象：只能知道某一具有共同属性的事物整体``  ``具体：可以描述某一个对象属性的具体的值``2.``通过将特定的方法定义在各自的函数中，为方法限制使用范围，其他对象不能随意调用``3.``面向对象编程：：``  ``思考这个程序有几个抽象类型``  ``描述这个类型具有的属性和动作``  ``将属性和动作封装到这个类型中

一.面向对象

**优点：**解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

**缺点：**可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

在python 中面向对象的程序设计并不是全部。

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

1 面向过程VS面向对象**

**优点：**极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

**缺点：**一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

2 了解一些名词：

类、对象、实例、实例化

类：具有相同特征的一类事物(人、狗、老虎)

对象／实例：具体的某一个事物（隔壁阿花、楼下旺财）

实例化：类——>对象的过程（这在生活中表现的不明显，我们在后面再慢慢解释）

3 类

在使用了函数之后，我们可以减少代码冗余，合理组织程序结构，提升了代码的扩张性。

但是仅仅用函数还不能完全达到隔离数据资源，组织程序结构的目的，也就是当我们需要多个函数操作相同的数据资源时，这些数据资源只针对对这几个函数使用。我们并不想使这些数据被全局调用。

这个时候函数已经无法满足我们的要求了，类就可以帮助我们组织数据，并封装来类中，供类中的函数使用，使代码更加简洁，清晰。

类的声明

def functionName(args):
     '函数文档字符串'
      函数体

'''
class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
class Data:
    pass

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法，也叫动态属性
        print("person is walking...")

类的作用：属性引用和实例化

属性引用（类名.属性）

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

person
<function Person.walk at 0x0000022683F1B0D0>

定义函数和类的区别

• 定义函数只检测语法不执行函数体代码
• 定义类会立刻执行类体代码，会产生类的名称空间，将类体代码执行过程中产生的名字都存放到类的名称空间中。

将变量存储到名称空间是方便我们后续取出使用。

类属性的查看

# 查看类中的变量的方法（一）
print(Person.__dict__['name'])

# 查看类中的变量的方法（一）--常用
print(Person.name)

# 调用方法，对象名.方法名()
print(egg.walk())   

类属性的修改

class Dog:
    def __init__(self,name,blood,attack,kind):
        self.name = name  # 向对象的内存空间中添加属性
        self.blood = blood  # 可以通过self在类的内部完成
        self.attack = attack
        self.kind = kind

# 向对象的内存空间中添加属性
#   1.通过self在类的内部完成
#   2.通过对象名在类的外部完成
hei = Dog('hei',300,30,'hashiqi')
hua = Dog('hua',400,40,'shamoye')
hei.food = 'single狗粮'

# 在类的外部通过对象名在修改属性的值
hei.blood = 305
print(hei.__dict__)

# 在类的外面删除属性
del hei.food

print(hei.__dict__)

类属性的补充

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

类属性的补充

4 对象

self参数

self：在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做。
因为你乱改别人就不认识。

self的本质

self本质就是对象本身，将对象本身自动传进方法中，本质上是将对象的命名空间中的变量传入方法。所以在方法中可以直接使用对象.变量名，而不需要再把这些变量当参数传入了。

对象相关知识

类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

实例化的过程就是类——>对象的过程

原本我们只有一个Person类，在这个过程中，产生了一个egg对象，有自己具体的名字、攻击力和生命值。

语法：对象名 = 类名(参数)

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;
        
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

egg = Person('egon')  #类名()就等于在执行Person.__init__()
#执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。

对象方法

Python 内置属性：

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

----------------------------------------------
class Person(object):

    def __int__(self, name):
        self.name = name


class Employee(Person):
    """
    所有员工的基类
    """
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    def displayCount(self):
        print("Total Employee %d" % Employee.empCount)

    def displayEmployee(self):
        print("Name : ", self.name, ", Salary: ", self.salary)


print("Employee.__doc__:", Employee.__doc__)

print("Employee.__name__:", Employee.__name__)

print("Employee.__module__:", Employee.__module__)

print("Employee.__bases__:", Employee.__bases__)

print("Employee.__dict__:", Employee.__dict__)

回到咱们的人狗大战：现在我们需要对我们的类做出一点点改变
人类除了可以走路之外，还应该具备一些攻击技能。

```python
class Dog:  # 狗模子--类
    a = 1000  # 静态变量，这个类中变量，是所有对象共享的值。
    def __init__(self,name, health, ad,kind):  # 初始化方法
        print('初始化属性')
        # self.__dict__['name'] = name
        # self.__dict__['health'] = hp
        # self.__dict__['color'] = color
        self.name = name  # 实例变量/对象属性
        self.health = health
        self.attack = ad
        self.kind = kind

hei = Dog('xiaohei', 20, 1,'hashiqi')  # 具体化，实例化对象
# print(dog1.__dict__['name']) 
# print(dog1.__dict__['hp'])
print(hei.name)  # 引用实例对象 引用对象的属性class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):  
        # 人可以攻击狗，这里的狗也是一个对象。
        # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivity

对象是关于类而实际存在的一个例子，即实例

对象/实例只有一种作用：属性引用

egg = Person('egon',10,1000)
print(egg.name)
print(egg.aggressivity)
print(egg.life_value)

当然了，你也可以引用一个方法，因为方法也是一个属性，只不过是一个类似函数的属性，我们也管它叫动态属性。
引用动态属性并不是执行这个方法，要想调用方法和调用函数是一样的，都需要在后面加上括号。

注意：类中的方法是绑定给对象使用的，类和对象都可以使用。

函数方法理解类

def Person(*args,**kwargs):
    self = {
     }
    def attack(self,dog):
        dog['life_value'] -= self['aggressivity']

    def __init__(name,aggressivity,life_value):
        self['name'] = name
        self['aggressivity'] = aggressivity
        self['life_value'] = life_value
        self['attack'] = attack

    __init__(*args,**kwargs)
    return self

egg = Person('egon',78,10)
print(egg['name'])

类&对象定义及调用的固定模式

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

5.类和对象名称空间

1.类定义中，内部第一个缩进的所有代码都是在该py文件被调用或者被执行的时候同时也被执行了，这里和函数有区别，而内部方法中的代码只会在方法被调用时才会被执行。
2.类中的代码永远是从上到下一次执行的

类的名称空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性。

类的本质就是一个用来存储类属性和对象方法的名称空间。

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

其中类的数据属性是共享给所有对象的

而类的动态属性是绑定到所有对象的

对象名称空间

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性。

对象的本质就是一个用来存储对象属性的名称空间。

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类…最后都找不到就抛出异常

# 类 和 对象 存储在两块命名空间里的
class Student:
    country = 'China'
    def __init__(self,name,country):
        self.name = name
        self.country = country


zhang = Student('zhangyao','东北人')
zou = Student('zoulu','新疆人')

print(Student.country)
print(zhang.country)
print(zou.country)

# 对象去找类空间中的名字的前提，是自己内部空间没有这个变量.

对于类中静态变量的使用：

如果在方法中使用静态变量，需要用<类名>.<静态变量名>或者self.<静态变量名>
如果需要修改静态变量的值，要使用<类名>.<静态变量名>修改，这样所有的内部方法都可以感知到改变

# 家庭收入统计类
class Family:
    money = 0
    def __init__(self,name):
        self.name = name    

    def salary(self,salary):
        Family.money += salary#如果在方法中使用静态变量，需要用<类名>.<静态变量名>或者self.<静态变量名>@要使用<类名>.<静态变量名>修改


father = Family('father')
mother = Family('mother')
for i in range(10):
    father.salary(6000)
    mother.salary(4000)
print(f'家庭年收入{Family.money}元')#家庭年收入100000元

修改对象属性时：

只要是对一个对象.名字直接重新赋值，那么就是在这个对象的空间内创建了新的属性
只要是对一个可变的数据类型内部的数据修改，那么所有的对象和类还是共享这个改变后的结果.

class List_modify:
    l = [0]
    def __init__(self,name):
        self.name = name

b1 = List_modify('yanhaiqing')
b2 = List_modify('sunjingjing')
b1.l[0] += 1
print(b2.l[0])  # 1

b1.l = [1,2,3]
print(b1.l) #[1, 2, 3]
print(b2.l)  # [1]

1
[1, 2, 3]
[1]

#只要是对一个可变的数据类型内部的数据修改
class List_modify:
    l = [0]
    def __init__(self,name):
        self.name = name

b1 = List_modify('yanhaiqing')
b2 = List_modify('sunjingjing')
b1.l[0] += 1
print(b2.l[0])  # 1

**b1.l[0] = [1,2,3]
print(b1.l)#[[1, 2, 3]]
print(b2.l)  # [[1, 2, 3]]

class A:
    name = 'alex'
    def __init__(self):pass

    def change(self):
        self.name = 'wupeiqi'

    def change1(self):
        A.name = 'wupeiqi'


a = A()
a.change()
print(A.name)  # alex
a.change1()
print(A.name)  # wupeiqi

6.面向对象的组合用法

class Weapon:
    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称;
        self.weapon = Weapon()  # 给角色绑定一个武器;
        
egg = Person('egon')
egg.weapon.prick() 
#egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法

1 圆形和圆环的组合

# 圆形类
class Circle:
    def __init__(self,radius):
        self.radius = radius

    def area(self):
        return 3.14*self.radius**2

    def perimeter(self):
        return 3.14*2*self.radius

# 圆环类

class Double_circle:
    def __init__(self,circle1,circle2):
        if circle1.radius >= circle2.radius:
            self.circle1 = circle1
            self.circle2 = circle2
        else:
            self.circle1 = circle2
            self.circle2 = circle1

    def area(self):
        res = self.circle1.area() - self.circle2.area()
        return round(res,2)# 内置方法 round （数，保留几位小数）

    def perimeter(self):
        res = self.circle1.perimeter() + self.circle2.perimeter()
        return round(res,2)# 内置方法 round （数，保留几位小数）


c1 = Circle(6)
c2 = Circle(5)
dc = Double_circle(c1,c2)
print(dc.area())
print(dc.perimeter())

34.54
69.12

分析：
组合：一个类的对象是另一个类对象的属性（方法）

圆形类的对象 是圆环类对象的outer属性的值，计算圆形相关数据的公式只和Circle类在一起.
其余的用到公式的地方都是通过circle类来使用的，公式与其他类之间的关系是一个“松耦合”关系.

2 学生和课程的组合

# 学生和课程

class Course:
    def __init__(self,name,price,period):
        self.name =name
        self.price = price
        self.period = period


class Student:
    def __init__(self,name,num,course):
        self.name = name
        self.num = num
        self.course = course

python = Course('python', 25000,'6 months')

s1 = Student('renshilong',10086,python)
s2 = Student('renxitong',10065,python)
s3 = Student('dongpeng',10064,python)

print(s1.course.price)

python.price = 30000
print(s1.course.price)
python.period = '7 months'
print(s2.course.period)
25000
30000
7 months

3 扩展

'''
扩展：
s3学生对象中：
    self.name = 'dongpeng', 'dongpeng' 是一个字符串对象
这里就是将字符串对象'dongpeng'当做s3对象的属性，也就是名字
    slef.name.strip()，self.name可以使用字符串类的方法。
    所以说其实这里也可以是Student类和字符串str类的组合
一切皆对象
'''

'''
s3学生对象中：
    self.price = 25000, 25000 是一个字符串对象
这里也是将整型对象25000当做s3对象的价格属性
    slef.price同样也可以使用整型int类的方法。
    这里也算是Student类和整型int类的组合
一切皆对象
'''

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

二 面向对象三大特征

继承又分为单继承和多继承

单继承

子类只继承一个父类的属性和方法的继承方式，称为单继承

class Animal:  #定义父类
    def __init__(self,name,kind):
        self.name = name
        self.kind = kind

    def eat(self,food):
        print(f'{self.name} is eating {food}')


class Cat(Animal):  #单继承，基类是Animal，派生类是Cat
    pass

class Dog(Animal):
    pass

hua = Cat('小花','橘猫')
print(hua.name)
print(hua.kind)
hua.eat('xiaoyugan')

单继承中父类属性的调用

方法一

# 第一种方法：直接调用父类的__init__方法，需要手动传self参数

class Animal:
    def __init__(self, name, kind):
        self.name = name
        self.kind = kind

    def eat(self, food):
        print(f'{self.name} is eating {food}')

class Cat(Animal):
    def __init__(self, name, kind, eye_color):
        Animal.__init__(self,name,kind)  # 第一种方法，直接调用父类的__init__方法，需要手动传self参数
        self.eye_color = eye_color  # 派生属性

方法二（推荐）

# 第二种方法：使用super().__init__()，寻找父类，或者超类，super自动帮你传入self，参数里面不需自行传self

class Animal:
    def __init__(self, name, kind):
        self.name = name
        self.kind = kind

    def eat(self, food):
        print(f'{self.name} is eating {food}')

class Cat(Animal):
    def __init__(self, name, kind, eye_color):
        super().__init__(name,kind) # 第二种方法，使用super().__init__()方法，相当于执行了父类的init方法
        # super(Cat,self).__init__(name,kind)
        self.eye_color = eye_color  # 派生属性

子类使用父类的属性和方法时：

1.想要使用某一个属性或方法，如果自己有，就用自己的；如果自己没有，就用父类的；如果父类也没有，就报错。

2.如果想使用的属性或方法父类和子类都有，既想使用子类的，也想使用父类的，调用父类方法时使用：

• 父类名.方法名(self,参数1,参数2)
• super().方法名(参数1,参数2)

多继承

子类继承多个父类的属性和方法的继承方式，称为多继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ez8NNsxm-1588939803910)(https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif)]

class Fly_animal:  # 父类1
    def fly(self):pass
class Walk_animal:  # 父类2
    def walk(self):pass
class Swin_animal:  # 父类3
    def swim(self):pass

class Frog(Walk_animal,Swin_animal):  # 多继承
    pass
class Tiger(Walk_animal,Swin_animal):  # 多继承
    pass
class Swan(Fly_animal,Swin_animal,Walk_animal):  # 多继承
    pass
class Parrot(Fly_animal,Walk_animal):  # 多继承
    def talk(self):
        pass

多继承中的继承顺序问题

1.python中类可以继承多个类，Java和C#中则只能继承一个类

2.python的类如果继承了多个类，那么期寻找方法的方式有两种，深度优先和广度优先

当类是经典类时，多继承情况下， 会按照深度优先的方式查找

当类是新式类时，多继承情况下， 会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含更多的功能，也是之后推荐的写法，如果当前类或者父类继承了object类，那么该类就是新式类，否则便是经典类。

继承实例

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

继承原理

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1. 子类会先于父类被检查
2. 多个父类会根据它们在列表中的顺序被检查
3. 如果对下一个类存在两个合法的选择,选择第一个父类

钻石继承问题：

class A(object):
    def func(self):
        print('a')

class B(A):
    def func(self):
        print('b')

class C(A):
    def func(self):
        print('c')

class D(B,C):
    def func(self):
        print('d')

d = D()
d.func()

乌龟继承问题

# 乌龟继承问题
class A(object):
    def func(self):
        print('a')

class B(A):
    def func(self):
        print('b')

class C(A):
    def func(self):
        print('c')

class D(B):
    def func(self):
        print('d')

class E(C):
    def func(self):
        print('e')

class F(D,E):
    def func(self):
        print('f')

f = F()
f.func()

C3算法

# C3算法实现的过程：
class A(object):
    def func(self):
        print('a')

class B(A):
    def func(self):
        print('b')

class C(A):
    def func(self):
        print('c')

class F(object):
    def func(self):
        print('f')

class D(A,F):
    def func(self):
        print('d')

class E(B,C,F):
    def func(self):
        print('e')

class G(C,D):
    def func(self):
        print('g')

class H(G,E):
    def func(self):
        print('h')


print(H.mro())


'''
C3算法：从顶点往下依次提取继承图上节点继承顺序链
A = [AO]
B = B,B节点的父类对应的继承顺序
B = B,A节点继承顺序
B = B,[AO]


当前节点提取顺序链分两种情况：
    第一种：该节点只有一条继承顺序链：
        1.如果这条顺序链从左到右第一个类节点，在后面的继承循序中不再出现，就可以把这个点提取到等式左边
        2.按这个方法依次提取完后得到的就是该节点的继承顺序链
    第二种：有多条继承顺序链
        1.如果第一个顺序链从左到右的第一个类节点
        2.如果该类节点不再出现在后面的继承顺序中，或者在后面其他的继承顺序链中也是第一个
        3.那么就可以把这个点提取出来，作为继承顺序中的第一个类节点
        4.如果该节点不满足，就跳过该顺序链，判断下一个顺序链的第一个是否满足，满足提出来。
        5.按照这个方法对所有顺序链的首节点去判断。
        
按照上述规则可以提取D点的顺序链，E点的顺序链

l(D) = D + [BAO]
所以D节点的继承顺序链：[DBAO]

l(E) = E + [CAO]
所以E节点的继承循序链：[ECAO]

最终归结到F点：出现了两条继承顺序链
l(F) = F + [DBAO] + [ECAO]
[F] = [DBAO] + [ECAO]
[FD] = [BAO] + [ECAO]
[FDB] = [AO] + [ECAO]
[FDBE] = [AO] + [CAO]
[FDBEC] = [AO] + [AO]
[FDBECA] = [O] + [O]
[FDBECAO]

最终得到的F节点的继承顺序链就是： FDBECAO

注意点：在画继承图的时候，在左边的父节点在继承中需要写在多继承括号的前边。如果不一致的话，运行和算出的结果会出现问题。
'''

注意点：

在多继承中，super就只和mro顺序有关系，和父类、子类没有关系，其实本质上，单继承也是这样，只不过，单继承中，父类和子类的关系和mro顺序是一致的.

查看继承

>>> Cat.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(,)
>>> Frog.__bases__
(, )

提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

>>> Animal.__bases__
(,)
>>>Walk_animal.__bases__
(,)

继承与抽象（先抽象再继承）

抽象即抽取类似或者说比较像的部分。

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类；

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

继承与重用性

==========================第一部分
例如

　　猫可以：吃、喝、爬树

　　狗可以：吃、喝、看家

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：


#猫和狗有大量相同的内容
class 猫：

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 爬树(self):
        # do something



class 狗：

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 看家(self):
        #do something


==========================第二部分
上述代码不难看出，吃、喝是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝

　　   猫：爬树（猫继承动物的功能）

　　   狗：看家（狗继承动物的功能）

伪代码如下：
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 爬树(self):
        print '喵喵叫'

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

    def 看家(self):
        print '汪汪叫'


==========================第三部分
#继承的代码实现
class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def climb(self):
        print('爬树')

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'

    def look_after_house(self):
        print('汪汪叫')


# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

使用继承来解决代码重用的例子

在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时

我们不可能从头开始写一个类B，这就用到了类的继承的概念。

通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用

提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.

派生

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

class Animal:
    '''
    人和狗都是动物，所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有自己的昵称;
        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;
        self.life_value = life_value  # 人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    '''
    狗类，继承Animal类
    '''
    def bite(self, people):
        '''
        派生：狗有咬人的技能
        :param people:  
        '''
        people.life_value -= self.aggressivity

class Person(Animal):
    '''
    人类，继承Animal
    '''
    def attack(self, dog):
        '''
        派生：人有攻击的技能
        :param dog: 
        '''
        dog.life_value -= self.aggressivity

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)

抽象类和接口类

抽象类

概念：python中用来规范子类实现统一方法的特殊形式的类，只能被继承，不能被实例化，同java一样，同样需要借助模块实现。

为什么使用抽象类：

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。通过抽象类使子类相同作用的方法实现一致的调用方式，有助于代码的可读性和规范性。

python中抽象类的实现

抽象类的范式：
    class <类名>(metaclass = ABCMeta):
        @abstractmethod
        def <规定方法名1>(self):pass
        
        @abstractmethod
        def <规定方法名2>(self):pass
        
        @abstractmethod
        def <规定方法名2>(self):pass

abc抽象类–霸道遵循

#一切皆文件
import abc #利用abc模块实现抽象类----父类怎么定义---子类必须按照父类方式定义 --差一点就会报错

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

接口类

认识：python中没有接口的专用语法，只是通过多继承，模仿接口的效果，也就是说继承多个抽象类的时候，这些抽象类就是所说的接口类

继承的两种用途：

1、继承基类的方法，并做出自己的改变或者扩展（代码重用）

2、声明某个子类兼容于某基类，定义一个接口类interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能。

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

1.做出良好的抽象类，2.规定兼容接口 3.调用者可以无需关心具体实现细节，可以一视同仁处理实现特定接口的所有对象。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

from abc import ABCMeta,abstractmethod

#做出一个良好的抽象
class Payment(metaclass=ABCMeta):  # 抽象类
    def __init__(self,name,money):
        self.name = name
        self.money = money

    @abstractmethod  # 如果我必须要实现pay方法，那么我需要给pay加以装饰器
    def pay(self):
        pass  # 创建的这个pay并没有内容
              # 之所以写一个pay是为了规定所有子类一定要实现一个pay方法

    @abstractmethod
    def back(self):
        pass

#微信支付
class Wechatpay(Payment):
    def pay(self):
        print(f'{self.name}通过微信支付了{self.money}元')

    def back(self):
        print('退款')

#支付宝支付
class Alipay(Payment):
    def pay(self):
        print(f'{self.name}通过支付宝支付{self.money}元')
    def back(self):
        print('退款')

#苹果支付
class Applepay(Payment):
    # def fuqian(self):  # TypeError: Can't instantiate abstract class Applepay with abstract methods pay
    #     print(f'{self.name}通过苹果支付支付{self.money}元')

    def pay(self):
        print(f'{self.name}通过苹果支付支付{self.money}元')

    def back(self):
        print('退款')

#调用者无需关心具体实现细节，可以一视同仁的处理实现了特定接口的所有对象
app = Applepay('alex',4000000)
ali = Alipay('alex',3000000)
wcp = Wechatpay('alex',2000000)

def pay(person):
    person.pay()

def back(person):
    person.back()

app.pay()

依赖倒置原则：

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；
细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程

在python中根本就没有一个叫做interface的关键字，上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全可以不用去实现接口 ，如果非要去模仿接口的概念，可以借助第三方模块：

http://pypi.python.org/pypi/zope.interfacetwisted的twisted\internet\interface.py里使用zope.interface

文档https://zopeinterface.readthedocs.io/en/latest/

设计模式：https://github.com/faif/python-patterns

接口提取了一群类共同的函数，可以把接口当做一个函数的集合。

然后让子类去实现接口中的函数。

这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。

再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样

抽象类和接口类关系

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计

在python中，并没有接口类这种东西，即便不通过专门的模块定义接口，我们也应该有一些基本的概念。

1.多继承问题

在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口

接口隔离原则：
使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。

2.方法的实现

在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

多态

广义上的多态：一类食物具有多种形态的现象

如，动物有多种形态：人，狗，猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

侠义的多态：在函数接受参数的时候，接受的多个类的对象同属于一个父类。

多态性

****多态动态绑定：****多态性是指在不考虑实例类型的情况下使用实例

在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。
也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

鸭子类型

Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种行为来编写程序。

如：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系

'''
python当中编写程序的一种特殊情况
    其他语言中，正常我们说一个数据类型具有某个特点，通常是通过继承来实现，如：
        继承迭代器类，来表明自身是一个迭代器类型
        继承可哈希的类，表明自身是一个可哈希的类型
    但是python所有的这些都不是通过继承来完成的
        我们只是通过一种约定俗成的潜规则约定，如果具有__iter__,__next__就是迭代器。
        如果具有__hash__方法就是可哈希类型
        具有__len__方法就是可计算长度类型
'''

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

封装**

封装就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。

作用：1. 将变化隔离； 2. 便于使用；3. 提高复用性； 4. 提高安全性

封装原则

• 将不需要对外提供的内容都隐藏起来；
• 把属性都隐藏，提供公共方法对其访问。

私有概念

python中利用双下划线开头的方式降属性或者方法隐藏起来，也就是变成自己私有的，也成为私有化

私有化的实现本质；

class Goods:
    def __init__(self,name,price):
        self.name = name
        self.__price = price  # 私有属性

    def get_price(self):
        print(self.__price)

apple = Goods('苹果',5)
print(apple.__dict__)  # 字典中仍然有价格的属性
print(apple._Goods__price)  # 私有的形成

私有化的本质其实只是将私有化的变量或者方法名变形改名，变成了_类名__属性名/方法名，从而使的在类外部无法直接查看或者引用到。

设置私有变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

class Goods:
    def __init__(self,name,price):
        self.name = name
        self.__price = price

    def get_price(self):
        return self.__price

apple = Goods('苹果',5)
print(Goods.__dict__)
print(apple.get_price())
# print(apple._Goods__price)  # 不常规调用方法

class Role:
    __country = 'China'

    def func(self):
        print(self.__country)

# print(Role.__country)  # 报错：不能在类的外部引用变量

Role().func()

注意的问题：

1. 这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2. 变形的过程只在类的内部生效,在定义后的赋值操作，不会变形。

私有方法

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

import hashlib

class Auth:
    def __init__(self,user,pwd):
        self.username = user
        self.password = pwd

    def __md5_code(self):
        md5 = hashlib.md5(self.username.encode('utf-8'))
        md5.update(self.password.encode('utf-8'))
        return md5.hexdigest()

    def login(self):
        username = 'alex'
        password = 'ee838c58e5bb3c9e687065edd0ec454f'
        if self.username == username and password == self.__md5_code():
            return True

user = input('>>>')
pwd = input('>>>')
alex = Auth(user,pwd)
# alex.__md5_code()  # 报错，私有的方法不能在类的外部使用。
# alex._Auth__md5_code()  # 不报错
ret = alex.login()
if ret:
    print('登陆成功')

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

实现单例模式方式有多种：使用模块，使用装饰器，使用类，这里举一个使用类创建单例模式。

class SingleIns:
    # 创建一个私有变量来指向实例化开辟的空间，也就是self，实例本身
    __instance=None
    def __new__(cls,*args,**kwargs):

        # 如果没有实例过，通过object的__new__方法创建一个空间，赋值给__instance
        if cls.__instance is None:
            cls.__instance=object.__new__(cls)

        # 如果有实例，就返回之前存储好的实例
        return cls.__instance


    def __init__(self,name=None,age=None):
        self.name=name
        self.age=age
        # 如果设置了age，则改动age，没有设置age的话使用默认age
        if age:
            self.age=age

封装和扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

property属性

概念：一种特殊的属性，访问时会执行一段功能（函数）然后返回值

通俗讲：就是将类的方法伪装成类的属性

'''
例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86
'''

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)

import math
class Circle:
    def __init__(self,radius): #圆的半径radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #计算面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''

例二：圆的周长和面积

注意：此时的特性area和perimeter不能被赋值

c.area=3 为特性area赋值 ‘’’ 抛出异常: AttributeError: can’t set attribute ‘’’

为什么使用property

对象的某些值经常是通过方法进行进行计算得出的，但是这个值从常理来讲更加符合一个对象的属性

通过property将其装饰称属性后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则。

此外

ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

property本质

一个静态属性property本质就是实现了get，set，delete三种方法

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

#只有在属性AAA定义property后才能定AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

'修改私有化属性，将property伪装后的方法再次伪装，接收参数传入类中，再修改私有属性'
class Goods:
    discount = 0.8
    def __init__(self, name, price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price * self.discount # 只支持obj.price的方式查看这个结果，不支持修改，也不支持删除

    @price.setter
    def price(self,value):
        self.__price = value


apple = Goods('苹果', 5)
banana = Goods('香蕉',10)
apple.price = 16  # 对应的调用的是被setter装饰的price方法
print(apple.price)  # 对应调用的是被property装饰的price方法

'''
总结：
如果我们定义的是普通的变量或者属性：
    这个属性可以直接从外部访问
    可以进行任意的修改 obj.attr = 123
    甚至可以删除 del obj.attr
      
如果这个属性被私有化：把一个属性加上双下划线 __属性名
    这个属性在类外面无法看见
    1.但有个场景：我们允许别人看，但不许修改
        __属性
        @property装饰的属性名
        def 属性():pass
    2.另一个场景：我们允许别人看见，也允许别人修改，但是要按照一定规则（数据类型，范围等等） 
        __属性
        @property
        def 属性():pass
        
        @属性.setter
        def 属性(self,value):
            加条件规则
            修改 __属性 
            
    3.如果我们允许别人删除。
         __属性
        @property
        def 属性():pass

        @属性.deleter
        def 属性(self,value):
            加条件规则
            删除 __属性 
'''

三 面向对象内置方法

classmethod方法

概念：将一个方法从对象方法变成一个类方法

使用场景：

1.我们不想实例化就能修改类中的静态变量/类变量
2.此时根本不会和self有任何关联
3.这时传入self参数对我们没有用处
4.我们希望接收的参数是这类

class Goods:
    __discount = 0.8

    def __init__(self,name,price):
        self.name = name
        self.__price = price

    @classmethod
    def change_discount(cls,value):
        cls.__discount = value

    @classmethod
    def get_discount(cls):
        return cls.__discount

Goods.change_discount(2)

print(Goods.get_discount())

classmethod帮我们做的就是，自动获取当前类的名字，并将类名传入对象方法第一个参数，在改动私有静态变量的时候，就不需要在传入类名了。和self的功能一样，只是self获取的是对象名，而cls获取的是类名。但是本质上这个名字可以改，只不过默认用cls。

staticmethod方法

概念：声明这个方法只是一个普通的不会使用任何和这个类中的变量相关的方法

类似场景：学生帐号登录

应该是先获取学生用户名和密码，判断登录是否成功
如果成功后，才会进行实例化，创造一个学生。
而不是先创造一个学生，再判断登录是否成功，或者是不是一个学生，这样有违逻辑
staticmethod可以使方法变成静态方法，可以不实例化的时候就可以调用。

# login登录

class Student:
    def __init__(self,name):
        self.name = name

    @staticmethod
    def login():
        pass

此时的Student.login()可以当普通方法使用，不需要实例化在使用

class Foo:
    def func(self):
        print('in father')


class Son(Foo):
    def func(self):
        print('in son')

s = Son()
s.func()
# 请说出上面一段代码的输出并解释原因？

class A:
    __role = 'CHINA'
    @classmethod
    def show_role(cls):
        print(cls.__role)

    @staticmethod
    def get_role():
        return A.__role

    @property
    def role(self):
        return self.__role

a = A()
print(a.role)
print(a.get_role())
a.show_role()
# __role在类中有哪些身份？
# 以上代码分别输出哪些内容？
# 这三个装饰器分别起了什么作用？有哪些区别？

四 面向对象进阶**

所以软件的开发其实一整套规范，我们所学的只是其中的一小部分，一个完整的开发过程，需要明确每个阶段的任务，在保证一个阶段正确的前提下再进行下一个阶段的工作，称之为软件工程

面向对象的软件工程包括下面几个部：

1.面向对象分析（object oriented analysis ，OOA）

软件工程中的系统分析阶段，要求分析员和用户结合在一起，对用户的需求做出精确的分析和明确的表述，从大的方面解析软件系统应该做什么，而不是怎么去做。面向对象的分析要按照面向对象的概念和方法，在对任务的分析中，从客观存在的事物和事物之间的关系，贵南出有关的对象（对象的‘特征’和‘技能’）以及对象之间的联系，并将具有相同属性和行为的对象用一个类class来标识。

建立一个能反映这是工作情况的需求模型，此时的模型是粗略的。

2 面向对象设计（object oriented design，OOD）

根据面向对象分析阶段形成的需求模型，对每一部分分别进行具体的设计。

首先是类的设计，类的设计可能包含多个层次（利用继承与派生机制）。然后以这些类为基础提出程序设计的思路和方法，包括对算法的设计。

在设计阶段并不牵涉任何一门具体的计算机语言，而是用一种更通用的描述工具（如伪代码或流程图）来描述

3 面向对象编程（object oriented programming，OOP）

根据面向对象设计的结果，选择一种计算机语言把它写成程序，可以是python

4 面向对象测试（object oriented test，OOT）

在写好程序后交给用户使用前，必须对程序进行严格的测试，测试的目的是发现程序中的错误并修正它。

面向对的测试是用面向对象的方法进行测试，以类作为测试的基本单元。

5 面向对象维护（object oriendted soft maintenance，OOSM）

正如对任何产品都需要进行售后服务和维护一样，软件在使用时也会出现一些问题，或者软件商想改进软件的性能，这就需要修改程序。

由于使用了面向对象的方法开发程序，使用程序的维护比较容易。

因为对象的封装性，修改一个对象对其他的对象影响很小，利用面向对象的方法维护程序，大大提高了软件维护的效率，可扩展性高。

在面向对象方法中，最早发展的肯定是面向对象编程(OOP),那时OOA和OOD都还没有发展起来，因此程序设计者为了写出面向对象的程序，还必须深入到分析和设计领域，尤其是设计领域，那时的OOP实际上包含了现在的OOD和OOP两个阶段，这对程序设计者要求比较高，许多人感到很难掌握。

现在设计一个大的软件，是严格按照面向对象软件工程的5个阶段进行的，这个5个阶段的工作不是由一个人从头到尾完成的，而是由不同的人分别完成，这样OOP阶段的任务就比较简单了。程序编写者只需要根据OOd提出的思路，用面向对象语言编写出程序既可。

在一个大型软件开发过程中，OOP只是很小的一个部分。

对于全栈开发的你来说，这五个阶段都有了，对于简单的问题，不必严格按照这个5个阶段进行，往往由程序设计者按照面向对象的方法进行程序设计，包括类的设计和程序的设计

几个概念的说明**

2.很多人喜欢说面向对象三大特性（这是从哪传出来的，封装，多态，继承？漏洞太多太多，好吧暂且称为三大特性），那么我在基于面向对象编程时，我一定要让我定义的类中完整的包含这三种特性，这样写肯定是好的程序

好家伙，我说降龙十八掌有十八掌，那么你每次跟人干仗都要从第一掌打到第18掌这才显得你会了是么：面对敌人，你打到第三掌对方就已经倒下了，你说，不行，你给老子起来，老子还没有show完…

3.类有类属性，实例有实例属性，所以我们在定义class时一定要定义出那么几个类属性，想不到怎么办，那就使劲的想，定义的越多越牛逼

这就犯了一个严重的错误，程序越早面向对象，死的越早，为啥面向对象，因为我们要将数据与功能结合到一起，程序整体的结构都没有出来，或者说需要考虑的问题你都没有搞清楚个八九不离十，你就开始面向对象了，这就导致了，你在那里干想，自以为想通了，定义了一堆属性，结果后来又都用不到，或者想不通到底应该定义啥，那就一直想吧，想着想着就疯了。

你见过哪家公司要开发一个软件，上来就开始写，肯定是频繁的开会讨论计划，请看第八节。

.面向对象常用术语

抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。

对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。

封装/接口

封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。

注意：封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”

真正的封装是，经过深入的思考，做出良好的抽象，给出“完整且最小”的接口，并使得内部细节可以对外透明

（注意：对外透明的意思是**，**外部调用者可以顺利的得到自己想要的任何功能，完全意识不到内部细节的存在）

合成

合成扩充了对类的 述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。

派生/继承/继承结构

派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。
继承描述了子类属性从祖先类继承这样一种方式
继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。

泛化/特化

基于继承
泛化表示所有子类与其父类及祖先类有一样的特点。
特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。

多态与多态性

多态指的是同一种事物的多种状态：水这种事物有多种不同的状态：冰，水蒸气

多态性的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。

冰，水蒸气，都继承于水，它们都有一个同名的方法就是变成云，但是冰.变云(),与水蒸气.变云()是截然不同的过程，虽然调用的方法都一样

自省/反射

自省也称作反射，这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,name__及__doc

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

python面向对象中的反射：通过字符串数据类型的形式操作对象相关的属性。python中一切事物都是对象（都可以使用反射）

反射的四个函数：

• hasattr() 判断对象中是否有某属性，返回True/False
• getattr() 获取对象中的属性，没有的话报错
• setattr() 为对象的添加属性并赋值，如setattr(object, ‘attribute’, value)
• delattr() 删除对象的某个属性

下列方法适用于类和对象（一切皆对象，类也是）

# hasattr
def hasattr(*args, **kwargs): # real signature unknown
    """
    Return whether the object has an attribute with the given name.
    
    This is done by calling getattr(obj, name) and catching AttributeError.
    """
    pass

# getattr
def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value
    
    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

# setattr
def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.
    
    setattr(x, 'y', v) is equivalent to ``x.y = v''
    """
    pass

# delattr
def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.
    
    delattr(x, 'y') is equivalent to ``del x.y''
    """
    pass

class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))

#获取属性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')
func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__)
print(obj.show_name(obj))

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')
delattr(obj,'show_name111')#不存在,则报错

print(obj.__dict__)

四个方法的使用演示

.getattr四种使用场景：**

'''
使用类反射
'''
class A:
    Country = '中国'

    @classmethod
    def show(cls):
        print('国家：',cls.Country)

print(getattr(A,'Country'))
A.show()
getattr(A,'show')()

'''
使用模块反射
'''
import re
ret1 = re.findall('\d+','asf44asdf351531asdfasd15f3')
getattr(re,'findall')  # == re.findall
ret2 = getattr(re,'findall')('\d+','asf44asdf351531asd3f5asd15f3')
print(ret1,ret2)


import time
# time.time # == getattr(time,'time')

print(time.time())
print(getattr(time,'time')())

'''
反射文本内容
只要是出现在文件全局变量中的名字都可以通过getattr(modules[__name__],字符串数据类型的名字)
'''

from sys import modules

# print(modules)  # 是一个DICT，KEY是模块的名字,value就是这个模块对应的文件地址

import re
print(re)  # 
print(modules['re'])
# 两者拿到的是同一个内容

print(re.findall)
print(modules['re'].findall)


a = 1
b = 2
while True:
    name = input('变量名：')
    print(__name__)
    print(getattr(modules[__name__],name))
    print(getattr(modules['__main__'],name))
    # 上面两句在本文件中是等效的

.setattr和delattr**

小结：

'''
1.hasattr和getattr(重要)
    只要是a.b这种结构,都可以使用反射
    用对象\类\模块反射,都只有以下场景
    这种结构有两种场景
        a.b   b是属性或者变量值
            getattr(a,'b')   == a.b
        a.b()  b是函数或者方法
            a.b()
                getattr(a,'b')()
            a.b(arg1,arg2)
                getattr(a,'b')(arg1,arg2)
            a.b(*args,**kwargs)
                getattr(a,'b')(*args,**kwargs)
    如果是本文件中的内容,不符合a.b这种结构
        直接调用func()
            getattr(sys.modules[__name__],'func')()
        直接使用类名 Person()
            getattr(sys.modules[__name__],'Person')()
        直接使用变量名 print(a)
            getattr(sys.modules[__name__],'a')
    所有的getattr都应该和hasattr一起使用
        if hasattr():
             getattr()
         
2.setattr 只用来修改或者添加属性\变量,不能用来处理函数或者是其他方法
    a.b = value
    setattr(a,'b',value)

3.delattr 只用来删除 属性\变量
    del a.b 删除属性  相当于删除了a对象当中的b属性
    delattr(a,'b')
'''

五、内置方法**

1.isinstance(obj,cls)和issubclass(sub,super)**

class Foo(object):
    pass 
class Bar(Foo):
    pass 
issubclass(Bar, Foo)

**2.isinstance(obj,type)*判断一个对象是不是属于某一个类，是返回True，不是返回False

class Foo(object):
     pass  
obj = Foo()  
isinstance(obj, Foo)

**3.type(obj)：**返回obj的类型.

4.isinstace和type的区别

isinstance(obj,类)，承认继承关系，包含父类以及父类的父类
　　类 = type(obj)，只承认实例化这个对象的类（不承认继承关系）

a = 1
ret1 = type(a) is int
ret2 = isinstance(a,int)
print(ret1)  # True
print(ret2)  # True

class User(object):pass
class VIPUser(User):pass

alex = VIPUser()
ret1 = type(alex) is User
ret2 = isinstance(alex,User)
print(ret1,ret2)  # False True

ret1 = type(alex) is VIPUser
ret2 = isinstance(alex,VIPUser)
print(ret1,ret2)  # True True

class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')


    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

5.getattribute**

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattribute__(self, item):
        print('不管是否存在,我都会执行')

f1=Foo(10)
f1.x
f1.xxxxxx

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('执行的是我')
        # return self.__dict__[item]
    def __getattribute__(self, item):
        print('不管是否存在,我都会执行')
        raise AttributeError('哈哈')

f1=Foo(10)
f1.x
f1.xxxxxx

#当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError

6__repr__:

如果__str__不存在的情况下，打印对象或者使用对象拼接打印，会自动调用的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-numgZWzR-1588939803922)(https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif)]

class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period

    def __repr__(self):  # 备胎
        """__str__存在，则优先使用__str__,
        __str__不存在，则使用__repr__，充当备用"""
        return '%s,%s,%s'%(self.name,self.price,self.period)

    def __str__(self):
        """打印这个对象的时候自动调用 __str__方法"""
        """发生字符串拼接，并打印的情况下，会自动调用__str__方法"""
        return self.name

python = Course('python',25000,'6 months')


print('course %s'%python)
print(f'course {python}')
print('course {}'.format(python))
print('course %r'%python)
print(repr(python))

小结：

1.如果__str__存在，__repr__也存在
    那么print(obj)、str(obj)和使用格式化format,%s两种方式拼接后打印，调用的都是__str__
    而repr(obj)和%r格式化字符串拼接打印，都会调用__repr__
2.如果__str__不存在，而__repr__存在
    那么print(obj),字符串格式化format,%s,%r和repr(obj)都调用__repr__
3.如果__str__存在，而__repr__不存在，
    那么print(obj)和使用字符串格式化format,%s这两种方式，调用的都是__str__
    repr(obj)和%r格式化字符串，都会打印出内存地址

继承中__repr__和__str__使用顺序

class Course(object):
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period

    def __repr__(self):   # 备胎
        return '%s,%s,%s'%(self.name,self.price,self.period)

    # def __str__(self):
    #     return self.name

class Python(Course):
    pass
    # def __repr__(self):   # 备胎
    #     return '%s--%s--%s'%(self.name,self.price,self.period)

    # def __str__(self):
    #     return '全栈开发 :'+self.name

py20 = Python('python',25000,'6 months')
print(py20)
'''
打印对象时
先找自己的__str__,如果没有,会去找父类中的__str__，
如果出了object之外的所有父类都没有__str__，再回来找自己的__repr__，
如果没有，再找父类的，如果除了object外所有的父类都没有__repr__方法，
则会去object中寻找__str__，最后会去object中寻找__repr__.
'''

为何使用__str__,repr

在打印对象的时候，不用显示用户不关心的内存地址了

增强了用户的体验

使用场景：

当我们我们需要频繁打印对象中的属性，需要从类的外部做复杂的拼接，很麻烦

如果这个拼接工作在类的内部已经完成了,打印对象的时候直接就能显示

__new__方法**

创建一块属于对象的空间

在init之前执行的

class Foo:
    def __new__(cls, *args, **kwargs):
        print('in new')  # 先执行
        obj = object.__new__(cls)
        print(obj)
        return obj

    def __init__(self):  # 后执行
        print('init',self)

Foo()

'''
实例化一个Foo对象
    先开辟一块空间，使用的是Foo这个类内部的__new__
        如果我们的Foo类中是没有__new__方法
        就会调用object的__new__方法
        
    在__new__中的cls永远不能是self，因为self是在__new__执行后才被创建
        obj = object.__new__(cls) 这里被创建
    
__new__的作用：
    使用self之前，__new__在内存空间开辟一个属于这个对象的空间，并且在这个空间中存放了一个类指针，指向这个类
'''

'''
单例模式：
    一个类，无论被实例化多少次，只开辟一个空间，始终使用的是同一块内存地址
'''
class A:
    __flag = None
    def __new__(cls, *args, **kwargs):
        if cls.__flag is None:
            cls.__flag = object.__new__(cls)
        return cls.__flag

    def __init__(self,name=None,age=None):
        self.name = name
        self.port = 8000
        if age:
            self.age = age


a1 = A('alex',84)
print(a1)
a2 = A('alex',83)
print(a2)
a3 = A()
print(a3)

print(a1.age,a2.age,a3.age)

__del__方法:**

注意：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__

注意：是删除一个对象，执行的是对象对应类中的__del__方法

扩展：

'''python解释器垃圾自动清除机制'''

python解释器本质上是先编译，后逐行解释
在编译过程中会判断变量在后面代码中是否会再次用到
如果不会再次用到，python解释器会自动将这个变量回收，从而节省内存空间
python解释器清理内存场景：    1.主动删除 del obj    2.python解释器周期性删除    3.在程序结束之前，所有的内容都需要被清空

import time
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __del__(self):
        '''只和del obj语法有关系，在执行del obj之前会来执行以下__del__中的内容'''
        print('执行我了')

a = A('alex',84)
print(a.name)
print(a.age)
del a  # 变量a被删除了
time.time(1)

注：在所有代码都执行完后，所有的值都会被python解释器回收，释放内存

典型的应用场景：

创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中

当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

这与文件处理是一个道理：

f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态

#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt')
读写...
f.close()
很多情况下大家都容易忽略f.close,这就用到了with上下文管理

property

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

怎么用？

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

call

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

with和__enter__、exit**

1 with open('a.txt') as f:
2 　　'代码块'

上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')
        # return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')


with Open('a.txt') as f:
    print('=====>执行代码块')
    # print(f,f.name)

exit()

中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type)
        print(exc_val)
        print(exc_tb)



with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')
print('0'*100) #------------------------------->不会执行

如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True



with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')
print('0'*100) #------------------------------->会执行

class Open:
    def __init__(self,filepath,mode='r',encoding='utf-8'):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        # print('enter')
        self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        # print('exit')
        self.f.close()
        return True 
    def __getattr__(self, item):
        return getattr(self.f,item)

with Open('a.txt','w') as f:
    print(f)
    f.write('aaaaaa')
    f.wasdf #抛出异常，交给__exit__处理

用途或者说好处：

1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预

2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处

class File:
    def __enter__(self):
        print('start')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit')


with File():
    print('wahaha')

class Myfile:
    def __init__(self,path,mode='r',encoding = 'utf-8'):
        self.path = path
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        self.f = open(self.path, mode=self.mode, encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()


with Myfile('file',mode='w') as f:
    f.write('wahaha')

# 自己实现pickle
import pickle
class Mypickledump:
    def __init__(self,path,mode='ab'):
        self.path = path
        self.mode = mode

    def __enter__(self):
        self.f = open(self.path,self.mode)
        return self  # 注意这里返回的是对象本身，不是文件句柄

    def dump(self,obj):
        pickle.dump(obj,self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()


with Mypickledump('pickle_file') as pickle_obj:
    pickle_obj.dump({1,2,3})
    pickle_obj.dump({1,2,3})
    pickle_obj.dump({1,2,3})


import pickle
class Mypickleload:
    def __init__(self,path,mode='rb'):
        self.path = path
        self.mode = mode

    def __enter__(self):
        self.f = open(self.path, self.mode)
        return self

    def loaditer(self):
        while True:
            try:
                obj = pickle.load(self.f)
                yield obj
            except Exception:
                break

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

with Mypickleload('pickle_file') as pickle_obj:
    for obj in pickle_obj.loaditer():
        print(obj)

小结：

'''
如果我们使用 with 类() as f: 类中实现__enter__和__exit__方法，with 类() as f 这个语句是将类实例化，调用__enter__并将返回的结果并赋值给f，然后在with语句下方代码可以对f进行操作，操作完后，在最后执行__exit__方法。
with obj as  f:    '代码块'1.with obj ----》触发obj.__enter__(),拿到返回值2.as f----->f=返回值、3.with obj as f  等同于     f=obj.__enter__()4.执行代码块一：没有异常的情况下，整个代码块运行完毕后去触发__exit__,它的三个参数都为None二：有异常的情况下，从异常出现的位置直接触发__exit__   a：如果__exit__的返回值为True，代表吞掉了异常   b：如果__exit__的返回值不为True，代表吐出了异常   c：__exit__的的运行完毕就代表了整个with语句的执行完毕
'''

class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list('JQKA')
    suits = ['红心','方板','梅花','黑桃']

    def __init__(self):
        self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
                                        for suit in FranchDeck.suits]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))

class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list('JQKA')
    suits = ['红心','方板','梅花','黑桃']

    def __init__(self):
        self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
                                        for suit in FranchDeck.suits]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

    def __setitem__(self, key, value):
        self._cards[key] = value

deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))

from random import shuffle
shuffle(deck)
print(deck[:5])

纸牌游戏2

class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True


p_lst = []
for i in range(84):
    p_lst.append(Person('egon',i,'male'))

print(p_lst)
print(set(p_lst))

setitem,__getitem,delitem**

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

slots

'''
1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__
当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个
字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给
实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该
只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。           更多的是用来作为一个内存优化工具。

'''
class Foo:
    __slots__='x'


f1=Foo()
f1.x=1
f1.y=2#报错
print(f1.__slots__) #f1不再有__dict__

class Bar:
    __slots__=['x','y']
    
n=Bar()
n.x,n.y=1,2
n.z=3#报错

class Foo:
    __slots__=['name','age']

f1=Foo()
f1.name='alex'
f1.age=18
print(f1.__slots__)

f2=Foo()
f2.name='egon'
f2.age=19
print(f2.__slots__)

print(Foo.__dict__)
#f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存

__next__和__iter__实现迭代器协议**

class Foo:
    def __init__(self,start,stop):
        self.num=start
        self.stop=stop
    def __iter__(self):
        return self
    def __next__(self):
        if self.num >= self.stop:
            raise StopIteration
        n=self.num
        self.num+=1
        return n

f=Foo(1,5)
from collections import Iterable,Iterator
print(isinstance(f,Iterator))

for i in Foo(1,5):
    print(i)

class Range:
    def __init__(self,n,stop,step):
        self.n=n
        self.stop=stop
        self.step=step

    def __next__(self):
        if self.n >= self.stop:
            raise StopIteration
        x=self.n
        self.n+=self.step
        return x

    def __iter__(self):
        return self

for i in Range(1,7,3): #
    print(i)

class Fib:
    def __init__(self):
        self._a=0
        self._b=1

    def __iter__(self):
        return self

    def __next__(self):
        self._a,self._b=self._b,self._a + self._b
        return self._a

f1=Fib()

print(f1.__next__())
print(next(f1))
print(next(f1))

for i in f1:
    if i > 100:
        break
    print('%s ' %i,end='')

doc**

class Foo:
    '我是描述信息'
    pass

class Bar(Foo):
    pass
print(Bar.__doc__) #该属性无法继承给子类

module__和__class**

class 表示当前操作的对象的类是什么

class C:
    def __init__(self):
        self.name = ‘SB'
from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类