1.迭代器和生成器

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

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

实例：

# 斐波拉切数列
# 1,1,2,3,5,8,13,21....
def xu_lie(n):
    pre_1 = 1
    pre_2 = 1
    for x in range(1, n+1):
        if x == 1 or x == 2:
            current = 1
            yield current
            continue
        current = pre_1 + pre_2
        pre_1, pre_2 = pre_2, current
        # print(current)
        yield current

xulie = xu_lie(10)
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())

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

2.认识面向对象

1.什么是类：对拥有相同属性和方法的对象的封装
类是抽象的
类中相同的属性的值是不能确定的

2.什么是对象：对象就是类的实例
对象是具体的
对象的属性是确定的

如果说人是一个类，那么余婷就是一个对象
如果说电脑是一个类，我桌上的这台mac就是一个对象

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

3.类的声明

class 类名(父类)：
     属性
     方法

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

3.1.声明一个类Person

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

    def sleep(self):
        print('在睡觉，(¦3[▓▓] 晚安')

3.2.声明对象

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

 per1 = Person()
    print(per1)
    per1.sleep()
    per1.eat()

    # 一个类可以有多个对象
    per2 = Person()
    print(per2)
    per2.eat()

4.对象的属性

4.1对象属性的声明

class 类名:
     def init(self):
          self.属性名 = 初值
          self.属性名2 = 初值2

class Person:
    """人类"""
    """
    a.init方法是系统自带的一个方法，这个方法不能直接调用，通过类创建对象的时候，系统会自动调用这个方法
      init方法的作用是对对象属性进行初始化
    b.通过构造方法创建对象的时候，一定要保证，init方法中除了self外，其它的参数都必须有值
    """

    def __init__(self, name1='', age1=0, sex1='男'):
        # 在这个地方声明对象的属性
        # print(name1)
        # print('====')
        # 在init方法中声明对象的属性
        """
        name、age和sex就是Person这个类的对象属性。类的对象属性，需要通过对象来使用
        """
        self.name = name1
        self.age = age1
        self.sex = sex1
if __name__ == '__main__':
    # 注意：构造方法中的参数，实质是传给init方法的参数
    p1 = Person('xxx', 18)
    # 通过对象使用对象属性
    print(p1.name, p1.age, p1.sex)

    p2 = Person('骆浩', 33, '男')
    print(p2.name, p2.age, p2.sex)

    # 创建对象的时候可以不给属性赋值
    p3 = Person()
    p4 = Person(sex1='女')

5.对象属性的增删改查

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

5.1.查(获取属性）

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

    # 如果设置了default的值，那么当属性不存在的时候不会报错，并且返回默认值
    print(getattr(dog1, 'abc', None))

5.2.改(修改属性的值)

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

    dog1.__setattr__('color', 'black')
    print(dog1.color)
    setattr(dog1, 'color', 'blue')
    print(dog1.color)

5.3.增

"""
    方法一：对象.属性 = 值（属性不存在，就是天津）
    注意：属性是添加给对象的，而不是类的
    """
    dog1.name = '大黄'
    print(dog1.name)
    # dog2 = Dog()
    # print(dog2.name)

    dog1.__setattr__('type', '哈士奇')
    print(dog1.type)
    setattr(dog1, 'sex', '公')
    print(dog1.sex)

5.4删（删除对象属性）

"""
    方法一：del 对象.属性
    方法二：__delattr__(属性名)和delattr(对象名, 属性名)
    注意：只是删除对象的属性，不会影响到类的其它对象
    """
    del dog1.age
    # print(dog1.age)  # AttributeError: 'Dog' object has no attribute 'age'

    dog1.__delattr__('sex')
    # print(dog1.sex)
    delattr(dog1, 'type')
    # print(dog1.type)

练习

"""
练习：声明一个学生类，拥有属性：姓名、性别、年龄。方法：学习
1.声明学生类的对象，声明的时候就给姓名、性别和年龄赋值
2.通过三种方式分别获取姓名、性别和年龄，并且打印
3.给学生对象添加一个属性，电话
4.修改学生的年龄
5.删除学生的性别
"""
class Student():
    def __init__(self, name='', sex='', age=0):
        self.name = name
        self.sex = sex
        self.age = age

    def study(self):
        print('%s在学习中' % self.name)

stu1 = Student('xxx', '男', 18)
stu1.study()

print(stu1.name)
print(stu1.__getattribute__('sex'))
print(getattr(stu1, 'age'))

stu1.tel = '123'
print(getattr(stu1, 'tel'))
setattr(stu1, 'id', '111')
print(stu1.id)

stu1.age = 22
print(stu1.age)
setattr(stu1, 'id', '222')
print(stu1.id)

del stu1.sex
# delattr(stu1, 'sex')

6.slots魔法

功能:就是约束类中的对象属性

class Person:
    """人类"""
    # __slots__的功能:就是约束类中的对象属性
    __slots__ = ('name', 'age', 'sex', 'id')
    def __init__(self, name='', age=0):
        self.name = name
        self.age = age
        # self.tel = 123  # AttributeError: 'Person' object has no attribute 'tel'

    # 自定义对象的打印格式
    def __str__(self):
        return 'name:%s age:%d address:0x%x' % (self.name, self.age, id(self))


if __name__ == '__main__':
    p1 = Person('xx', 20)
    # p1.names = 'aa'  # AttributeError: 'Person' object has no attribute 'names'
    # p1.sex = '男'
    print(p1)

7.类中的方法

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

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

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

补充：ctr + r --> 查找替换
ctr + f --> 查找

class MyPerson:
    """人类"""
    # number是类字段（人类的数量）
    number = 0

    def __init__(self, name='', age=0):
        self.name = name
        self.age = age

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

    @classmethod
    def hurt_earth(cls):
        # cls指向的是调用这个方法的类，使用cls可以当成类来使用
        pt = cls('张三')  # 可以使用cls创建对象
        print(pt.name)
        print(pt.number)  # 可以通过cls使用类的字段
        print('人类破坏环境')

    #protect_earth是一个静态方法
    @staticmethod
    def protect_earth():
        pt = MyPerson()
        print(pt.number)
        print('人类保护地球')


if __name__ == '__main__':
    # 1.类的字段要用类来使用
    print(MyPerson.number)

    # 2.对象的属性通过对象来使用
    p1 = MyPerson('xxx', 18)
    print(p1.name)
    # 3.对象方法用对象调用
    p1.eat('面条')

    p2 = MyPerson('aaa')
    p2.eat('火锅')

    # 4.类方法通过类来调用
    MyPerson.hurt_earth()

    # 5.静态方法通过类来调用
    MyPerson.protect_earth()