面向对象面向对象基础面向对象三大特性一.继承二、多态三、封装（最重要）四、内置方法五、英雄乱斗案列六、@property装饰器七、类方法

目录

• 面向对象基础
  • 一、定义类名的规范
  • 二、查看名称空间
  • 三、对象的绑定方法
  • 四、对象面子查找顺序
  • 五、新式类与经典类
• 面向对象三大特性
• 一.继承
  • 1.什么是继承？
  • 2.继承与抽象
  • 3.继承与代码的重用性
  • 4.派生
  • 5.继承的顺序
  • 6.issubcalss 判断是否为谁的子类
  • 7.isinstance判断数据结构的类型
  • 8.子类继承父类，并添加或重写的两种方法
  • 9.检查super的继承顺序mro()方法
  • 10.钻石继承（棱形继承）
• 二、多态
  • 1.鸭子类型
• 三、封装（最重要）
  • 1.封装原则
  • 2.封装好处
  • 3.私有属性和私有方法
    • 1.私有属性
    • 2.私有方法
    • 3.访问限制机制
  • 4.封装与扩展性
  • 5.组合
    • 1.普通方法
    • 2.组合方法
• 四、内置方法
  • 1.自定义比较对象双下__gt__大于，双下__lt__小于，双下__eq__等于
  • 2.上下文管理双下__enter__进入文件时，双下__exit__离开
  • 3.双下__str__转字符串时触发
  • 4.双下__del__删除时触发
  • 5.双下__slots__优化对象内存
  • 6.双下__call__方法
• 五、英雄乱斗案列
• 六、@property装饰器
• 七、类方法
  • 1.@classmethod装饰符
  • 2.super子类访问父类方法
  • 3.组合
  • 4.反射
  • 5.元类
    • 1.什么是元类?
    • 2.为什么要使用元类？
    • 3.如何用元类

目录

• 面向对象基础
  • 一、定义类名的规范
  • 二、查看名称空间
  • 三、对象的绑定方法
  • 四、对象面子查找顺序
  • 五、新式类与经典类
• 面向对象三大特性
• 一.继承
  • 1.什么是继承？
  • 2.继承与抽象
  • 3.继承与代码的重用性
  • 4.派生
  • 5.继承的顺序
  • 6.issubcalss 判断是否为谁的子类
  • 7.isinstance判断数据结构的类型
  • 8.子类继承父类，并添加或重写的两种方法
  • 9.检查super的继承顺序mro()方法
  • 10.钻石继承（棱形继承）
• 二、多态
  • 1.鸭子类型
• 三、封装（最重要）
  • 1.封装原则
  • 2.封装好处
  • 3.私有属性和私有方法
    • 1.私有属性
    • 2.私有方法
    • 3.访问限制机制
  • 4.封装与扩展性
  • 5.组合
    • 1.普通方法
    • 2.组合方法
• 四、内置方法
  • 1.自定义比较对象双下__gt__大于，双下__lt__小于，双下__eq__等于
  • 2.上下文管理双下__enter__进入文件时，双下__exit__离开
  • 3.双下__str__转字符串时触发
  • 4.双下__del__删除时触发
  • 5.双下__slots__优化对象内存
  • 6.双下__call__方法
• 五、英雄乱斗案列
• 六、@property装饰器
• 七、类方法
  • 1.@classmethod装饰符
  • 2.super子类访问父类方法
  • 3.组合
  • 4.反射
  • 5.元类
    • 1.什么是元类?
    • 2.为什么要使用元类？
    • 3.如何用元类

面向对象基础

一、定义类名的规范

驼峰命名法

二、查看名称空间

def func():
    pass

class dog():
    pass

print(func.__dict__)   # {}
print(dog.__dict__)   # {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'dog' objects>, '__weakref__': <attribute '__weakref__' of 'dog' objects>, '__doc__': None}

三、对象的绑定方法

由对象来调用类内部的函数，称之为对象的绑定方法。
    对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。

四、对象面子查找顺序

自己——类——报错

对象名字的查找顺序：  *******
    1.对象.属性，会先找对象自己的。
    2.若对象没有，会去找类的。
    3.若类没有，则会报错。
'''

五、新式类与经典类

- 新式类:
    1.凡是继承object的类或子孙类都是新式类。
    2.在python3中所有的类都默认继承object，都是新式类。

- 经典类:
    1.在python2中才会有经典类与新式类之分。
    2.在python2中，凡是没有继承object的类，都是经典类。

面向对象三大特性

一.继承

1.什么是继承？

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类（super），新建的类称为派生类或子类

python中继承分为：单继承和多继承

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

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

2.继承与抽象

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

抽象分成两个层次：

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

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

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

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

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

3.继承与代码的重用性

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

　　猫可以：吃、喝、爬树

　　狗可以：吃、喝、看家

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


#猫和狗有大量相同的内容
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()

4.派生

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

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)

1.super():调用父类的属性

class A:
    def hahaha(self):
        print('A')

class B(A):
    def hahaha(self):
        super().hahaha()
        #super(B,self).hahaha()
        #A.hahaha(self)
        print('B')

a = A()
b = B()
b.hahaha()
super(B,b).hahaha()

5.继承的顺序

在python2经典类中继承的顺序是： 深度优先

在python3新式类中继承的顺序是： 广度优先

6.issubcalss 判断是否为谁的子类

issubclass(a,B)：判断a是不是B的子类
参数a:子类
参数B：父类

issubclass 判断传入的obj是不是Animal的子类

def manage(obj):

    if issubclass(type(obj), Animal):
        obj.eat()
    else:
        print('不是动物')

7.isinstance判断数据结构的类型

isinstance(a,int) 判断类型
参数a:要判断的对象
参数int:判断的类型

isinstance案例：

def add_num(a, b):
    # if type(a) == int and type(b) == int:   # 等于下面一句
    if isinstance(a,int) and isinstance(b,int):
        return a+b
    else:
        print("不能相加")

print(add_num('你', 12))
#结果：不能相加

2.isinstance案例：

class Animal:

    def eat(self):
        print("动物吃东西。。。")

class Pig(Animal):
    def eat(self):
        print('猪什么都吃 ，不挑食')

class Tree:
    def light(self):
        print('植物光合作业...')
shu = Tree()
manage(shu)
#结果：不是动物



pig = Pig()
manage(pig)


#结果：猪什么都吃 ，不挑食

8.子类继承父类，并添加或重写的两种方法

1.父类.__init__方法

class Animal():
    def __init__(self, name, eat, run):
        self.name = name
        self.eat = eat
        self.run = run
        print(f'{self.name}会{self.eat}')
        print(f'{self.name}会{self.run}')

class Sunwukong(Animal):
    def __init__(self, name, eat, run, aa):
        Animal.__init__(self,name, eat, run)
        self.aa = aa

    def skill(self):
        print(self.name,'有72变化，筋斗云，如意金箍棒')

sun = Sunwukong('齐天大圣','吃','跑','sb')

sun.skill()

# 结果：
齐天大圣会吃
齐天大圣会跑
齐天大圣 有72变化，筋斗云，如意金箍棒

2.super().__init方法

class Animal():
    def __init__(self, name, eat, run):
        self.name = name
        self.eat = eat
        self.run = run
        print(f'{self.name}会{self.eat}')
        print(f'{self.name}会{self.run}')

class Sunwukong(Animal):
    def __init__(self, name, eat, run, aa):
        super().__init__(name, eat, run)
        self.aa = aa

    def skill(self):
        print(self.aa,'有72变化，筋斗云，如意金箍棒')

sun = Sunwukong('齐天大圣','吃','跑','sb')
sun.skill()

# 结果 ：
齐天大圣会吃
齐天大圣会跑
sb 有72变化，筋斗云，如意金箍棒

9.检查super的继承顺序mro()方法

在python3中提供了一个查找新式类查找顺序的内置方法.
mro(): 会把当前类的继承关系列出来
多继承的情况下: 从左到右

class A:
    def test(self):
        print('from A.test')
        super().test()
class B:
    def test(self):
        print('from B.test')
class C(A, B):
    pass

c = C()
# 检查super的继承顺序
print(C.mro())

# 结果：
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

10.钻石继承（棱形继承）

1.python的类可以继承多个类，JAVA,C#只能继承一个类
2.python的类如果继承了多个类，那么寻找方式有两种，分别是：深度优先和广度优先

3.继承顺序

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中才分新式类与经典类

二、多态

多态：一种事务具备多种不同下形态
官方解释：多个不同对象可以响应同一个方法，产生不同的结果

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

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')

1.鸭子类型

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

例子1：类名不一样，类中定义的方法一样：响应同一种方法，产生不同的结果

class Mouse:
    def open(self):
        print("鼠标开机.....")

    def close(self):
        print("鼠标关机了...")

    def read(self):
        print("获取了光标位置....")

    def write(self):
        print("鼠标不支持写入....")



def pc(usb_device):
    usb_device.open()
    usb_device.read()
    usb_device.write()
    usb_device.close()

m = Mouse()
# 将鼠标传给电脑
pc(m)

class KeyBoard:
    def open(self):
        print("键盘开机.....")

    def close(self):
        print("键盘关机了...")

    def read(self):
        print("获取了按键字符....")

    def write(self):
        print("可以写入灯光颜色....")

# 来了一个键盘对象
k = KeyBoard()
pc(k)


class UDisk:

    def open(self):
        print("U盘启动了...")

    def close(self):
        print("U盘关闭了...")

    def read(self):
        print("读出数据")

    def write(self):
        print("写入数据")

u = UDisk()
pc(u)

例子2：二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用

class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

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

三、封装（最重要）

封装：

1.面向对象最重要的是封装

2.隐藏对象的属性和实现细节，仅对外提供公共访问方式

1.封装原则

1.将不需要对外提供的内容都隐藏起来

2.把属性都隐藏，提供公共方法对其访问。

2.封装好处

1.讲变化隔离

2.便于使用

3.提高复用性

4.提高安全性

3.私有属性和私有方法

私有属性、私有方法：1.让一些关键的数据，变成私有更加的安全
2.不是随意可以更改的
3.在属性，和方法前面加’__‘,变成私有，那么外界就不可以直接调用修改。
4.但是：在类的内部可以定义一个函数，方法调用修改。使用者直接调用这个函数就可以了。这个函数就是接口
5.可以在这个函数、方法加条件限制，而不是任意的改动

例子：定义成私有属性，在函数内部可以修改，那么用户调用这个函数也就可以直接修改私有属性，但是可以给这个函数加‘条件’，比如下面：小于300可以修改，否则不能修改

class student:

    def __init__(self, name, max):
        self.name = name
        self.__max = max
        # print(self.__max)

    def max(self, new_max):
        if new_max < 300:   # 增加修改的条件
            print('修改成功')
            self.__max = new_max
            print(self.__max)
        else:
            print('修改失败')

jeff =student('jeff',100)

jeff.max(200)
# jeff.max(500)

1.私有属性

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

***原理: 替换变量名称 方法名 替换为：_类名__方法名***

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__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是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

2.私有方法

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

#正常情况
class A:
    def fa(self):
        print('from A')
    def test(self):
        self.fa()

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

b=B()
b.test()
from B
 

#把fa定义成私有的，即__fa
class A:
    def __fa(self): #在定义时就变形为_A__fa
        print('from A')
    def test(self):
        self.__fa() #只会与自己所在的类为准,即调用_A__fa

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

b=B()
b.test()
from A

3.访问限制机制

把内部方法、属性私有化，让外面不能直接调用，二十通过内部给的一个接口调用。这个接口可以控制调用方法的顺序，条件等

class ATM:
    # 取钱功能:
    # 1.插入磁卡
    def __insert_card(self):
        print('开始插卡...')
        pass

    # 2.输入密码
    def __input_pwd(self):
        print('输入密码...')
        pass

    # 3.输入取款金额
    def __input_bal(self):
        print('输入取款金额...')
        pass

    # 4.吐钱
    def __output_money(self):
        print('开始吐钱...')
        pass

    # 5.打印流水账单
    def __print_flow(self):
        print('打印流水账单...')
        pass

    # 取款顺序规范接口:控制内部方法调用的顺序
    def withdraw(self):
        # 1.插入磁卡
        self.__insert_card()

        # 2.输入密码
        self.__input_pwd()

        # 3.输入取款金额
        self.__input_bal()

        # 4.吐钱
        self.__output_money()

        # 5.打印流水账单
        self.__print_flow()

# 生成一个对象
amt_obj = ATM()
amt_obj.withdraw()  # 内部给的一个接口

# 结果：
开始插卡...
输入密码...
输入取款金额...
开始吐钱...
打印流水账单...

4.封装与扩展性

#类的设计者
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()

5.组合

'''
夺命三问:
    1.什么是组合？
        组合指的是一个对象中，包含另一个或多个对象。

    2.为什么要用组合？
        减少代码的冗余。

    3.如何使用组合？

耦合度:
    耦: 莲藕 ---> 藕断丝连
    - 耦合度越高: 程序的可扩展性越低。
    - 耦合度越低: 程序的可扩展性越高。

总结:
    - 继承:
        继承是类与类的关系，子类继承父类的属性/方法，子类与父类是一种 “从属” 关系。

    - 组合:
        组合是对象与对象的关系，一个对象拥有另一个对象中的属性/方法，是一种什么有什么的关系。

ps:添加额外的年月日

1.普通方法

代码莲藕，不容易修改和后期的维护

class People:
    def __init__(self, name, age, sex, year, month, day):
        self.name = name
        self.age = age
        self.sex = sex
        self.year = year
        self.month = month
        self.day = day

    def tell_birth(self):
        print(f'''
        ===== 出生年月日 =====
            年: {self.year}
            月: {self.month}
            日: {self.day}
        ''')
# 老师类
class Teacher(People):
    def __init__(self, name, age, sex, year, month, day):
        super().__init__(name, age, sex, year, month, day)
# 学生类
class Student(People):
    def __init__(self, name, age, sex, year, month, day):
        super().__init__(name, age, sex, year, month, day)


tea1 = Teacher('tank', 17, 'male', 2002, 6, 6)
stu1 = Student('HCY', 109, 'female', 1910, 11, 11)

print(tea1.name, tea1.age, tea1.sex)
tea1.tell_birth()
print(stu1.name, stu1.age, stu1.sex)
stu1.tell_birth()


# 结果：
jeff 23 male

        ===== 出生年月日 =====
            年: 1996
            月: 6
            日: 5
        
陈嘉旻 20 female

        ===== 出生年月日 =====
            年: 1999
            月: 6
            日: 4

2.组合方法

扩展性高

关键之处：

1.添加一个完全独立的功能，生成对象

2.将这个独立功能的对象与其他对象绑定关系（组合）

class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
# 老师类
class Teacher(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
# 学生类
class Student(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
# 日期类
class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tell_birth(self):
        print(f'''
        ===== 出生年月日 =====
            年: {self.year}
            月: {self.month}
            日: {self.day}
        ''')
# 生成两个对象
tea1 = Teacher('jeff', 23, 'male')
date_obj = Date(1996, 6, 5)

# 两个对象绑定关系（组合）
tea1.date_obj = date_obj  

print(tea1.name, tea1.age, tea1.sex)
tea1.date_obj.tell_birth()

# 结果：
jeff 23 male

        ===== 出生年月日 =====
            年: 1996
            月: 6
            日: 5

四、内置方法

1.自定义比较对象双下__gt__大于，双下__lt__小于，双下__eq__等于

可以利用这三个自定义比较对象：
gt：greater than 大于缩写
lt：less than 小于缩写
eq：equal 等于缩写

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

    # 比较大于时触发
    def __gt__(self, other):
        return self.height > other.height

    # 比较小于时触发
    def __lt__(self, other):
        return self.age < other.age

    # 比较等于时触发
    def __eq__(self, other):
        # if self.age == other.age:  # 比较两个对象的年龄
        if self.age == other.age and self.height == other.height:  # 比较年龄和身高
            return '年龄身高一样'
        return '年龄身高不一样'


stu1 = Student("jeff", 170, 25)
stu2 = Student("make", 170, 25)

print(stu1 > stu2)
print(stu1 < stu2)
print(stu1 == stu2)

2.上下文管理双下__enter__进入文件时，双下__exit__离开

enter：1.进入文件，开打文件时执行
2.函数应该返回自己self
exit:1.退出文件、报错中断、或者代码执行完时执行
2.可以有返回值,是bool类型

class MyOpen(object):
    def __init__(self, path):
        self.path = path
    
    # 进入文件时触发
    def __enter__(self):
        self.file = open(self.path)
        print("文件打开....")
        return self
    
    # 离开文件时触发
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("文件关闭")
        # print(exc_type,exc_val,exc_tb)
        self.file.close()  # 关闭文件
        return True


with MyOpen('a.txt') as f:
    print(f.file.readline())

# f.file.readline()   # 文件已经关闭了，不能读

3.双下__str__转字符串时触发

str：再转换字符串时触发，转换结果就是该函数的返回值
使用场景：利用该函数自定义，打印格式
del :
执行时机：手动删除时立马执行，或者程序运行结束时自动执行
使用场景：当你的对象使用过程中，打开了不属于解释器的资源；例如，文件，网络端口

1._str_例子：

1.# __str__例子：
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        # 自定义打印输出
        return "这是一个person对象 name:%s age:%s" % (self.name, self.age)


p = Person("jack", 20)
print(p)

4.双下__del__删除时触发

1. __del__例子：

2.# __del__例子：
class A:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print('删除时触发')

    # 删除时关闭
    def __del__(self):
        self.file.close()


jeff = A('jeff')
del jeff
# jeff.name  # 已经删除，无法访问了

5.双下__slots__优化对象内存

slots：原理，给对象声明只有某些属性，从而删除不必要的内存，不能添加新属性
1.优化对象内存
2.限制属性数量

1.__slots__案例：slots使用

import sys
class Person:
    __slots__ = ['name']  # 声明名称空间只有name属性

    def __init__(self, name):
        self.name = name
p = Person('jeff')
print(sys.getsizeof(p))
#结果：48          #####内存减少了8

6.双下__call__方法

对象后面加括号，触发执行。

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

class Foo:

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

        print('__call__')


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

五、英雄乱斗案列

import random
import time

class Hero:
    def __init__(self, name, level, blood, att, q_hurt, w_hurt, e_hurt):
        # self.name = name
        # self.level = level
        # self.blood = blood
        # self.att = att
        # self.q_hurt = q_hurt
        # self.w_hurt = w_hurt
        # self.e_hurt = e_hurt

        # 大神写法
        lcs = locals()
        lcs.pop('self')
        self.__dict__.update(lcs) 


    def attack(self, enemy):
        enemy.blood -= self.att
        print('%s 对 %s 进行了普通攻击，造成 %s 的伤害 %s剩余: %sHP' % (self.name, enemy.name, self.att, enemy.name,enemy.blood))
        if enemy.blood <= 0:
            print('%s把%s使用普通攻击击杀了' % (self.name, enemy.name))

    def Q(self, enemy):
        enemy.blood -= self.q_hurt
        print('%s 对 %s 释放了Q技能，造成 %s 的伤害 %s剩余: %sHP'
              % (self.name, enemy.name, self.q_hurt, enemy.name, enemy.blood))
        if enemy.blood <= 0:
            print('%s把%s使用普通攻击击杀了' % (self.name, enemy.name))

    def W(self, enemy):
        enemy.blood -= self.w_hurt
        print('%s 对 %s 释放了W技能，造成 %s 的伤害 %s剩余: %sHP'
              % (self.name, enemy.name, self.w_hurt, enemy.name, enemy.blood))
        if enemy.blood <= 0:
            print('%s把%s使用普通攻击击杀了' % (self.name, enemy.name))

    def E(self, enemy):
        enemy.blood -= self.e_hurt
        print('%s 对 %s 释放了E技能，造成 %s 的伤害 %s剩余: %sHP'
              % (self.name, enemy.name, self.e_hurt, enemy.name, enemy.blood))
        if enemy.blood <= 0:
            print('%s把%s使用普通攻击击杀了' % (self.name, enemy.name))


yx1 = Hero(name='诸葛亮', level=15, blood=5000, att=100, q_hurt=1000, w_hurt=300, e_hurt=2000)
yx2 = Hero(name='后裔', level=15, blood=5000, att=2000, q_hurt=0, w_hurt=500, e_hurt=1000)
yx3 = Hero(name='王昭君', level=15, blood=5000, att=2000, q_hurt=0, w_hurt=500, e_hurt=1000)
yx4 = Hero(name='吕布', level=15, blood=5000, att=2000, q_hurt=0, w_hurt=500, e_hurt=1000)


while True:
    # 攻击方式随机
    funcs = {1: Hero.Q, 2: Hero.W, 3: Hero.E, 4: Hero.attack}
    func_index = random.randint(1, 4)
    func = funcs[func_index]

    # 英雄随机
    heros = {1: yx1, 2: yx2, 3: yx3, 4: yx4}
    heros_index = random.randint(1, len(heros))
    # 攻击英雄随机
    hero = heros[heros_index]

    # 剩余英雄，排除自己打自己（重新做个字典）
    othor_heros = {}

    # 遍历
    new_index = 1
    for k, v in heros.items():
        if v != heros[heros_index]:
            othor_heros[new_index] = v
            new_index += 1

    # 从剩余的英雄中随机挑选一个攻击
    enemy_index = random.randint(1, len(othor_heros))
    # 被攻击随机英雄
    enemy = othor_heros[enemy_index]

    # 执行
    func(hero, enemy)

    # 血量为0
    if enemy.blood <= 0:
        break
    # time.sleep(0.5)

六、@property装饰器

装饰器：为了调用方式一致，方便使用者
@property首先创建一个age对象，所以@setter、@deleter要加函数名
：这里的age是装饰方法的名称

@property(获取私有) :把一个方法伪装成普通属性，通常函数名和属性名保持一致（方便使用者调用）
@函数名.setter(修改私有）：函数名和属性名保持一致
@函数名.deleter(控制删除)：

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

    @property   # 获取属性时，触发下面
    # 获取伪装成普通属性，通常函数名伪装成属性名
    def age(self):
        return self.__age

    @age.setter  # 修改属性时，触发下面
    def age(self, new_age):
        self.__age = new_age
        print('修改成功')

    @age.deleter  # 删除属性时，触发下面
    def age(self):
        print('删除时触发的内容')

1.查看私有属性

a = A('jeff', 50)

print(a.name)
print(a.age)

结果：jeff   50

2.修改私有属性

a = A('jeff', 50)   # 定义初始

a.age = 100  #修改
print(a.age)

结果：修改成功   100

3.删出私有属性触发

a = A('jeff', 50)

del a.age

结果：删除时触发的内容

七、类方法

1.@classmethod装饰符

@classmethod # 表示下面定义的def方法是类方法，而不是实列方法

例子1：

"""把功能封装在类方法中"""

class Tool(object):
    # 使用赋值语句定义类属性，记录所有工具对象的数量
    count = 0

    @classmethod  # 表示下面定义的def方法是类方法，而不是实列方法
    def show_tool_count(cls): # cls这是个类方法
        print("对象的数量为 %d"%cls.count)
    def __init__(self,name):
        self.name = name
        # 让类属性的值+1
        Tool.count += 1

# 1.创建工具对象  
tool1 = Tool("钉子")
tool2 = Tool("水桶")
tool3 = Tool("榔头")


# 2.调用类方法
Tool.show_tool_count()
# 结果： 对象的数量为 3

例子2：

class A:
    @classmethod
    def b(cls):
        print('这是父类')


class B(A):
    def c(self):
        print('这是子类')
B.b()
# 结果：这是父类

2.super子类访问父类方法

class A:
    text = 'abc'

    def say_hai(self):
        print("hell这是父类")

class B(A):
    def say_eat(self):
        print(super().text)  # 直接调用了父类中属性
        super().say_hai()   # 直接调用了父类的方法
        print('这是子类')
aa = B()
aa.say_eat()
# 结果:
abc
hell这是父类
这是子类

3.组合

# 定义手机类
class Phone:
    def __init__(self,price,kind,color):
        self.price = price
        self.kind = kind
        self.color = color

    def call(self):
        print("正在呼叫XXXX;")

    def send_message(self):
        print("正在发送短信....")

# 定义学生类
class Student:
    def __init__(self,name,gender,phone):
        self.name = name
        self.gender = gender
        self.phone = phone

    def show_info(self):
        print("name:%s gender:%s" % (self.name,self.gender))

# 给手机添加属性
phone = Phone(1000,"apple","red")
# 给学生添加属性，并把手机交给学生
stu1 = Student("rose","male",phone)
# 学生拿着手机打电话
stu1.phone.call()
# 学生拿着手机发短信
stu1.phone.send_message()
# 结果：
正在呼叫XXXX;
正在发送短信....

4.反射

反射使用场景：

1.反射就是对属性的增删改查，但是如果直接使用内置的 dict来操作，语法繁琐，不好理解
​ 2.如果对象是别人提供的，判断这个对象是否满足要求

hasattr（p,'name'）:查找p对象中是否存在name属性
getattr（p,'name'）：取值，p对象中name属性
setattr（p,'name','jeff'）：添加，为p对象中添加name属性jeff
delattr（p,'name'）：删除，删除p对象中name属性

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

P = A('jeff')

# 查找对象中是否存在属性
if hasattr(P,'name'):
    print(getattr(P,'name',None))   # 添加之后，如果没有返回None，而不是报错

# 为对象添加属性
setattr(P,'id','123')
print(P.id)

# 删除对象属性
delattr(P,'id')
print(P.id)

5.元类

注意：只要继承了type 那么这个类就变成了一个元类

__call__在调用对象时触发

1.什么是元类?

在python中一切皆对象，那么我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类，即元类可以简称为类的类

2.为什么要使用元类？

元类是负责产生类的，所以我们学习元类或者自定义元类的目的:是为了控制类的产生过程，还可以控制对象的产生过程

3.如何用元类

创建类的方法有两种：

大前提：如果说类也是对象的话，那么用class关键字去创建类的过程也是一个实例化的过程

该实例化的目的是为了得到一个类，调用的是元类

方式一：用的默认的元类type

方式二：自定义元类继承type

class Mate(type):

    def __call__(self, *args, **kwargs):
        if args:
            raise Exception('不允许')
        return super().__call__(*args,**kwargs)

# 定义了一个元类
class A(metaclass=Mate):
    def __init__(self, name):
        self.name = name

a = A(name='jeff')
print(a.name)