1、迭代器和生成器

---

生成器：

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

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

2、认识面向对象

---

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

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

如果说人是一个类那么张三就是人的一个对象，李四也人的一个对象

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

3、类的声明

---

类的声明：

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

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

# 1.声明类Person
class Person:
    """类的说明:人类"""

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

    def sleep(self):
        print('睡觉')

声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法，自动生成的）
对象名 = 类名()

类对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名()
对象.属性名

# 2. 声明对象
    p1 = Person()
    print('p1:',p1)

一个类可以有多个对象，对象可以调用方法----p1.eat()

4、对象的属性

---

对象属性的声明
class 类名:
    def __init__(self):
        self.属性名 = 初值
        self.属性名2 = 初值2

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

class Person:
    """人类"""
    def __init__(self, name1='', age1=0, sex='女'):
        # 在这个地方声明对象的属性
        # 在init方法中声明对象的属性
        """
        name、age和sex就是Person这个类的对象属性。类的对象属性，需要通过对象来使用
        """
        self.name = name1
        self.age = age1
        self.sex = sex

    def run(self, n):
        print(self.name)
        print(n)


if __name__ == '__main__':
    # 注意：构造方法中的参数，实质是传给init方法的参数的
    p1 = Person('yuu', 18)

    p1.run(100)

    # 通过对象使用对象属性
    print(p1.name, p1.age, p1.sex)

    p2 = Person('张三', 18)
    print(p2.sex, p2.name)

    """通过不同的方式创建对象"""
    # 创建对象的时候不给属性赋值
    p3 = Person()

    p4 = Person('李四')

    Person(sex='男', name1='yuu')

5、对象的增删改查

---

1.查（获取属性）
方法一：对象.属性 (如果属性不存在，会报错)
方法二：对象.__ getattribute __ (属性名) 和 getattr(对象, 属性名, 默认值)
！！如果设置了默认值，那么当属性不存在的时候不会报错，并且返回默认值。
2.改（修改属性的值）
方法一： 对象.属性 = 新值
方法二：对象.__ setattr (属性名,新值) 和 setattr(对象，属性名，新值)
3.增加（增加对象属性）
对象.属性 = 值（属性不存在）
注意：属性是添加给对象的，而不是类的
4.删（删除对象的属性）
方法一： del 对象.属性
方法二：对象. delatter __(属性名)
注意：删除属性也是删的具体某个对象的属性。不会影响这个类的其他对象

6、slots魔法

---

__ slots__的功能：就是约束类中的对象的属性。
__ slots__ = （a, b, c）代表类的对象属性只能有a, b, c
自定义对象的打印格式

    def __str__(self):
        return 'name:%s age:%d address:0x%x' % (self.name, self.age, id(self))

id()：是python的内置函数，功能是获取变量的地址

7、类中的方法

---

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

elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法

else 如果实现函数功能既不需要对象的属性也不需要类的字段，就声明成静态方法

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

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

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

class Person:
    # number是类字段
    number = 61

    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('人类破坏环境！！')

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



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

    # 2.对象的属性要通过对象来使用
    p1 = Person('小明')
    print(p1.name, p1.age)

    # 3.对象方法用对象调用
    p1.eat('面条')

    p2 = Person('小红')
    p2.eat('火锅')

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

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