一、生成器

生成器：
a、可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个，里面的数据只能从前往后一个一个的生成，不能跳跃，也不能从后往前，且生成的数据，不能再生成。
b、获取生成器里面的数据，需要使用 ' __next __ '()方法或next(生成器)方法
c、只要函数声明中有 yield关键字，函数就不再是一个单纯的函数，而变成一个生成器（generator）.

和列表比较：列表存数据，数据必须是实实在在存在的数据，一个数据会占一定的内存空间。生成器存数据，存的是产生数据的算法，没有数据去占内存空间。

if __name__ == '__main__':
    x = (i for i in range(10))
    #  x就是一个生成器，用来产生数据
    print(x)
    print(x.__next__())
    print(x.__next__())
    print('===--===')
    print(next(x))

其中iter()函数用来生成迭代器

二、认识面向对象

1、什么是类：

对拥有相同属性的方法的对象的封装类是抽象的类中相同的属性的值是不能确定的

2、什么是对象：

对象就是类的实例，对象是具体，对象的属性是确定的

3、面向对象编程

面向过程编程：一步一步的写代码实现功能-->工具：逻辑和算法
函数是编程：面对问题考虑有没有拥有某种功能函数 -->工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题 -->工具：类和对象

三、类的声明

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类的声明：（格式）
class 类名（父类）：
属性
方法

class:Python中声明类的关键字
类名：标识符，类名的首字母大写，驼峰式命名
（）:类要继承自其它的类，需要写括号，括号里面是父类的名字，可以省略
属性：对象属性和类的字段---保存数据
方法：实质就是声明在类中的函数 ---实现功能

1、声明类

class Person:
    """类的说明：人类"""
 声明两个对象方法，需要使用对象来调用, 对象方法默认都有一个参数self，在调用方法的时候，
这个参数不用传参（系统会自动给self传参）,谁来调用这个方法，self就是谁.
    def eat(self):
        print('self', self)
        print('在吃饭')
    def sleep(self):
        print('在睡觉，(¦3[▓▓] 晚安')

声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法，自动生成的）
对象名= 类名()
类对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名（）
对象.属性名

if __name__ == '__main__':
    # 2、声明对象
    P1 = Person()
    P1.eat()
    print('P1')
    P2 = Person()
    P2.eat()

    # 一个类可以有多个对象
    Person.eat(2)   直接调用的话，要给self传一个参数

四、对象的属性

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
实例变量：定义在方法中的变量，只作用于当前实例的类。
对象属性的声明（格式）
class 类名：
def __ init__(self):
（缩进）self.属性名 = 初值
（缩进）self.属性名2 = 初值2
# 1、init方法是系统自带的一个方法，这个方法不能直接调用，通过类创建对象的时候系统会自动调用这个方法， init方法的作用是对对象的属性进行初始化。
# 2、通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其他的每个参数都必须有值。

class Person:
    def __init__(self, name1, age1): 
        # 在这里声明对象的属性
        print('====')
        print(name1)
        # 在init方法中声明对象的属性
        self.name = name1
        self.age = age1
        self.sex = '女'

name, age 和sex就是Person这个类的对象属性，类的对象属性需要通过对象来使用

if __name__ == '__main__':
   # 注意;构造方法中的参数，实质是传给init方法的参数的
   p1 = Person('赌圣', 18)
   # 通过对象使用对象属性
   print(p1.name, p1.age, p1.sex)

五、对象属性的增删改查

class Dog:
    """狗类"""
    def __init__(self, age=0, color='blue'):
        self.age = age
        self.color = color

if __name__ == '__main__':
    dog1 = Dog(3, 'white')

1、查（获取属性）

"""方法一：对象.属性（如果属性不存在，会报错）"""
print(dog1.age, dog1.color)
"""方法二：对象.__getattribute__(属性名)和getattr(对象，属性名，默认值)"""
dog1.__getattribute__('age')
getattr(dog1, 'age')

如果设置了default的值， 那么当属性不存在的时候不会报错，并且返回默认值

2、改（修改对象属性的值）。

"""方法一：对象.属性 = 新值"""
dog1.age = 4
print(dog1.age)
"""方法二： 对象.__setattr__(属性名，新值)"""
dog1.__setattr__('color', 'black')
print(dog1.color)
setattr(dog1, 'color', 'red')
print(dog1.color)

3、增加

"""
对象.属性 = 值（属性不存在）
注意：属性是添加给对象的，而不是类的
"""
dog1.name = '千户'
dog1.__setattr__('type', '哈士奇')
print(dog1.type)
setattr(dog1, 'sex', '公')
print(dog1.sex)

4、删（删除对象的属性）

del 对象.属性（属性要存在，才能删除）
注意：删除属性也是删的具体某个对象的属性。不会影响这个类其他对象

del dog1.age
dog1.__delattr__('sex')
delattr(dog1, 'color')

六、slots魔法

class Person:
    """__slots__的功能：就是约束类中的对象的属性"""
    __slots__ = ('name', 'age')
    def __init__(self, name='', age=0):
        self.name = name
        self.age = age
 自定义对象的打印格式
    """id():是python的内置函数，功能是获取变量的地址"""
    def __str__(self):
        return '人类'+' '+str(id(self))

if __name__ == '__main__':
    p1 = Person('小王', 20)
    p1.name = '老王'
    print(p1)
人类 32594520

七、类中的方法

属性：对象的属性（属性）、类的属性（内的字段）
对象属性：属于对象的，不同对象对应的值可能不一样（对象属性，通过对象来使用）
类的字段：声明在类里面，函数外面。类的属性属于类（）

方法：对象方法（方法）、类方法、静态函数
对象方法：自带一个self参数，一般要通过对象去调用
类方法：1、使用@classmethod修饰，
2、自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3、类方法要通过类来调用

静态方法:1、使用@staticmethod修饰
2、没有默认参数
3、静态方法要通过类来调用

怎么选择用对象方法、类方法、静态方法？
如果实现函数的功能需要使用对象的属性，就声明成对象方法；
如果实现函数的功能需要使用类的字段或调用类的方法，就声明成类方法；
如果实现函数功能既不需要对象的属性也不需要类的字段，就声明成静态方法

补充 :ctr +r 查找替换

class Person:
   ---- number是类字段-----
    number = 214321

    def __init__(self, name='', age=0):
        ------ name和age是对象属性------
        self.name = name
        self.age = age

 ------- eat方法是对象方法------
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    -------hurt_earth就是一个类方法-------
    @classmethod
    def hurt_earth(cls):
      -----cls指向的是调用这个方法的类，cls可以当成类来使用----
        pt = cls('张三')  # 可以使用cls创建对象
        print(pt.name)
        print(cls.number)  # 可以通过cls使用类的字段
        print('human hurt earth!')

     -----protect-----
    @staticmethod
    def protect_earth():
        print('人来保护地球')

if __name__ == '__main__':
    ----- 类的字段要用类来使用-----
    print(Person.number)

    ----- 对象的属性要通过对象来使用----
    p1 = Person()
    print(p1.name, p1.age)

    -----对象的方法用对象调用----
    p1 = Person('欧力给')
    p1.eat('面条')

    ----类方法通过类调用-----
    Person.hurt_earth()

   ----静态方法通过类来调用----
    Person.protect_earth()