四时宝库

一、定义 class

class Person:
    代码块

//实例化             
person_class = Person()       

二、类的方法

1. 自定义方法

使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self, 且为第一个参数，self 代表的是类的实例。self代表类的实例，而非类

class Person:
    def info(self):
        print('自定义方法')

//实例化             
person_class = Person()   
person_class.info()

2. 类自带的方法

• __init__() ：构造函数，在生成对象时调用
• __del__() ： 析构函数，释放对象时使用
• __str__()：调用print 会执行类中的__str__方法
• __new__()：类定义时调用
• __repr__()： 打印，转换
• __setitem__ ()：按照索引赋值，对应 [key]=value，例如：列表中的lit[2]=21321
• __getitem__()： 按照索引获取值，对应 []，例如：列表中的lit[2]，需要有返回值
• __delitem__()： 按照索引获取值，对应 del，例如：del list[2]
• __len__()： 获得长度
• __cmp__()：比较运算
• __call__()：创建实例时候调用
• __add__()： 加运算，对象相加，需要有返回值
• __sub__()：减运算，对象相减，需要有返回值
• __mul__()：乘运算，对象相乘，需要有返回值
• __truediv__()：除运算，对象相除，需要有返回值
• __floordiv__()：除运算，向下取整，数据中有浮点数则返回浮点数，对象相除，需要有返回值
• __mod__()：求余运算，对象求余，需要有返回值
• __pow__()：乘方，对象乘方，需要有返回值
• __iadd__()：+=，对象+=，需要有返回值
• __isub__()：-=，对象-=，需要有返回值
• __abs__()：绝对值，对应abs()
• __bool__()：与内置函数bool()一样，必须返回布尔
• __bytes__()：与内置函数bytes()一样
• __complex__()：与内置函数complex()一样，必须返回复数
• __float__()：与内置函数float()一样，必须返回实数
• __hash__()：与内置函数hash()一样
• __reversed__()：与内置函数reversed()一样
• __subclasses__()：返回该类的所有子类
• __iter_()：可迭代对象，需要返回一个迭代器iter()
• __next_()：对应迭代器的__next_，next()
• __aiter__()、__anext__：异步迭代对象，与asyncio配合使用
• __aenter__()、__aexit__()：对asyncio with语句中的环境进行控制，叫做异步上下文管理器
• __class__：返回对象所属的类
• __dict__：对象所包含的属性与值的字典
• __enter__()、__exit__()：异步上下文管理器

3. 定义私有方法，方法名称前加上前缀 __

class Person:
    def __private_info(self):
        print('自定义方法')
    def info(self):
        self.__private_info()

//实例化             
person_class = Person()
perso_class.info()
perso_class.__private_info()//报错

4. 静态方法，可以被类直接调用

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

    @staticmethod
    def test():
        print(21321)
zhangsan = Person('张三')
Person.test()
zhangsan.test()

5. 类方法，可以被类直接调用，cls参数表为类名

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

    @classmethod
    def test(cls): #cls类名
        print(21321)
zhangsan = Person('张三')
Person.test()
zhangsan.test()

6. 属性方法，可以像属性一样调用的方法

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

    @property
    def test(self):
        print(21321)
zhangsan = Person('张三')
zhangsan.test

class Person:
    def __init__(self, name):
        self.__name = name
        
    def test1(self):
        print('test1')

    def test2(self,par):
        print(par)

    def test3(self):
        print('test3')
    test = property(fget=test1,fset=test2,fdel=test3)

zhangsan = Person('张三')

zhangsan.test //执行test1
zhangsan.test = 'test2' //执行test2
del zhangsan.test //执行test3

三、类的属性

1. 实例属性，实例属性用于区分不同的实例

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

//实例化             
zhangsan = Person('张三')
zhangsan.age = 10
//删除实例属性
 del zhangsan.name

2. 类属性，类属性是每个实例的共有属性

class Person:
    name='张三'

//实例化             
lisi = Person()
lisi.name='李四'
//删除类属性
del Person.name

3. 私有属性，属性名称前加上前缀 __

class Person:
    def __init__(self, name):
        self.__name = name  
 
zhangsan = Person('张三')
print(zhangsan.__name)//报错

4. 通过 set/get 方法访问私有属性

class Person:
    def __init__(self, name):
        self.__name = name
    def get_name(self):    
        return self.__name    
    def set_name(self,name):    
        return self.__name        
 
zhangsan = Person('张三')
zhangsan.__name = '王五'//修改私有属性
zhangsan.set_name('李四')//修改私有属性
print(zhangsan.get_name())//获取私有属性

5. 静态属性，静态属性作用域为类

class Person:
    person_type = '人'
    def __init__(self, name):
        self.__name = name
zhangsan = Person('张三')
zhangsan.person_type
Person.person_type

四、类的继承

1. 继承

一定要用super(ZhangSan, self).__init__(name, age) 去初始化父类，否则，继承自Person的ZhangSan子类将没 name和age两个属性。

函数super(ZhangSan, self)将返回当前类继承的父类，即Personl，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不能再写出self。

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

    def info(self):
        print(self.name, self.age)



class ZhangSan(Person):
    def __init__(self,name, age, job):
        super(ZhangSan, self).__init__(name, age)
        self.job = job


zhangsan = ZhangSan('张三', 19, '学生')
zhangsan.info()

2. 子类方法重构

class ZhangSan(Person):
    def __init__(self,name, age, job):
        super(ZhangSan, self).__init__(name, age)  # 不要忘记从Animal类引入属性
        self.job = job

    def info(self):
        print(self.name, self.age,self.job)

3. 判断子类和父类关系

#isinstance() 判断变量类型
print(isinstance(zhangsan,ZhangSan))

4. 每一个类，都可以继承object基类

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

    def info(self):
        print(self.name, self.age)

5. 类的多继承

• 继承从左到右执行
• 调用supper()，super会调用所有父类的方法，多继承super执行顺序为__mro__执行顺序
• 多继承，如果出现继承共同的父类建议使用supper()，如果出现继承多个父类建议使用 className.__init__(self, name,age,**agrs)
• 多继承时，最好携带不定长参数，防止多继承的父级存在差异性参数报错

# 共同继承父类 Person
class Person:
    def __init__(self, name, age, **kwargs):
        self.name = name
        self.age = age
        print(f'我叫{name}，年龄{age}')

    def info(self):
        print(self.name, self.age)


class Male(Person):
    def __init__(self, name, age, **kwargs):
        self.father = '父亲'
        self.father_name = kwargs.get('fatherName')
        super().__init__(name, age, **kwargs)  # Female的__init__，不调用super().__init_无法进入Female的__init__
        print(f'父亲姓名：{self.father_name}')


class Female(Person):
    def __init__(self, name, age, **kwargs):
        self.mother = '母亲'
        self.mother_name = kwargs.get('motherName')
        super().__init__(name, age, **kwargs)  # Person的__init__
        print(f'母亲姓名：{self.mother_name}')


class ZhangSan(Male, Female):
    def __init__(self, name, age, job, **kwargs):
        super().__init__(name, age, **kwargs)  # male的__init__
        self.job = job


zhangsan = ZhangSan('张三', 19, '学生', motherName='李四', fatherName='张五')

print(ZhangSan.__mro__) #super().__init__会按照mro顺序执行

#继承多个父类
class Person:
    def __init__(self, name):
        self.name = name
        print(self.name, 'Person')


class Person1:
    def __init__(self, name):
        self.name = name
        print(self.name, 'Person1')


class Son1(Person):
    def __init__(self, name, age):
        self.age = age
        super().__init__(name)  # Person的__init__
        print(f'{self.name}：{self.age}')

    def test(self):
        print('Person_test')


class Son2(Person1):
    def __init__(self, name, gender, *args):
        self.gender = gender
        super().__init__(name)  # Person1的__init__
        print(f'{self.name}：{self.gender}')

    def test(self):
        print('Person1_test')

    def test1(self):
        print('Person1_test1')


class GrandSon(Son1, Son2):
    def __init__(self, name, age, gender):
        # super().__init__(name,age) # Son1的__init__，从这个例子可以看出多继承中super调用的是第一个父类的__init__
        #从test和test1，可以看出super().function会执行第一个父类的function，否则会向下继续找其他父类的_function方法
        super().test()
        super().test1()
        Son1.__init__(self, name, age)  # Son1的__init__
        Son2.__init__(self, name, gender)  # Son2的__init__

五、metaclass

1. 类是一个对象，是由type创建的

class Foo:
    def func(self):
        print(123)
#等同于
def Func(self):
    print(123)
Foo = type('Foo',(object,),{'func':Func}})    

2. 自定义类的创建

class MyType(type):
    def __init__(self,*args,**kwargs): #self为Func
        print(123)
        
class Func(metaclass=MyType):
    def test(self):
        print('哈哈哈')    

3. 单例模式：某个类在整个系统中只存在一个实例的一种设计模式

class MyType(type):
    __instance = None
    def __call__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = type.__call__(cls, *args, **kwargs)
        return cls.__instance


class Func(metaclass=MyType):
    def foo(self):
        pass


a = Func()
b = Func()

print(id(a) == id(b))

六、构建可迭代的对象

1. 迭代器

迭代器是一个可以记住遍历位置的对象，因此不会像列表那样一次性全部生成，而是可以等到用的时候才生成，因此节省了大量的内存资源。迭代器对象从集合中的第一个元素开始访问，直到所有的元素被访问完；迭代器有三个方法iter()、next()、__next_()，next()等同于__next_()

• 示例

list_1 = [1,2,3,4,5]

list_iter = iter(list_1) #拿到迭代对象中的迭代器

print(next(list_iter)) # next 一次获取迭代器中的值
print(next(list_iter))
print(next(list_iter))
print(next(list_iter))
print(next(list_iter))
print(next(list_iter)) # 运行到这里会报错，因为迭代器中的值已经取出来完

• 解决报错 使用while循环

list_1 = [1,2,3,4,5]

list_iter = iter(list_1)
# for循环内部实现，这里只是演示了for循环内部h实现；实际应用for循环就行
while True:
    try:
        print(next(list_iter))
    except StopIteration:
        break        

2. 迭代对象

• python内置迭代对象：string、list、dict、tuple、set
• 判断迭代对象和迭代器

from collections.abc import Iterator,Iterable

list_1 = [1,2,3,4,5]

list_iter = iter(list_1)

print(isinstance(list_1,Iterator)) # 检测list_1是否为迭代器
print(isinstance(list_1,Iterable)) # 检测list_1是否为迭代对象

print(isinstance(list_iter,Iterator)) # 检测list_iter是否为迭代器
print(isinstance(list_iter,Iterable)) # 检测list_iter是否为迭代对象

#根据打印结果可得出，迭代对象不一定是迭代器，但是迭代器一定是迭代对象

3. 构建可迭代对象

class MyIterable:
    def __init__(self):
        self.__list = list()
        self.__map_count = 0

    def add_item(self):
        name = input('请输入姓名：')
        age = input('请输入年龄：')
        job = input('请输入职业：')
        self.__list.append({
            'name': name,
            'age': age,
            'job': job
        })

    def __iter__(self):
        return self # return出迭代对象

    def __next__(self):
        if self.__map_count < len(self.__list):
            res = self.__list[self.__map_count]
            self.__map_count+=1
            return res
        else:
            raise StopIteration


my_iterable = MyIterable()

for _ in range(3):
    my_iterable.add_item()

for item in my_iterable:
    print(item)