一、迭代器和生成器

生成器：

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

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

#1.1,1,2,3,5,8,13
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
            # print(current)
            continue
        current = pre_1+pre_2
        pre_1,pre_2 = pre_2,current
        # print(current)
        yield current
xu_lie = xu_lie(10)
print(xu_lie.__next__())


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

结果

1
<generator object <genexpr> at 0x00000246A2173570> <class 'generator'>
0

二、认识面向对象

1.什么是类：对拥有相同属性的方法的对象的封装

类是抽象的
类中相同的属性的值是不能确定的

2.什么是对象：对象就是类的实例

对象是具体
对象的属性是确定的
如果说人是一个类那么老张就是人的一个对象，那么老吴也是一个对象
如果说电脑是一个类，我桌上的这台mac就是一个对象
如果说杯子是一个类，我桌上这个粉色的杯子就是一个对象

3.面向对象编程

面向过程编程：一步一步的写代码实现功能-->工具：逻辑和算法

函数式编程：面对问题考虑有没有某种功能函数-->工具：函数

面向对象编程：面对问题考虑有没有相应的对象来解决这个问题-->工具：类和对象

三、类的声明

类的声明：
class 类名(父类):
    属性
    方法

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

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

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

1.声明类Person

class Person:
"""类的说明：人类"""
#声明两个对象方法，需要使用对象来调用

对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统会自动给self传参）
谁来调用这个方法，self就是谁

    def eat(self):
        print('在吃饭')
    def sleep(self):
        print('在睡觉')



if __name__ == '__main__':
    ####2.声明对象
    p1 = Person()
    print(p1)
    #一个类可以有多个对象
    p2 = Person()
    print(p2)
    #对象可以调用对象方法
    p1.eat()
    p2.eat()

结果

<__main__.Person object at 0x0000017039C53F98>
<__main__.Person object at 0x0000017039C53FD0>
在吃饭
在吃饭

四、对象的属性

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

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

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

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

    p2  = Person('盖伦',18)
    print(p2.name)
   #创建对象的时候不给属性赋值
    p3 = Person()
    print(p3.name,p3.age)
    p4 = Person(sex = '男')
    print(p4.sex)

结果

===
zhangsan
zhangsan 18 男
===
盖伦
盖伦
===

 18
===

男

五、对象属性的增删改查

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

if __name__ == '__main__':
    dog1 = Dog('小花',3,'black')
 ####1.查(获取属性)
   
    方法1：对象.属性(如果属性不存在会报错)
    方法2：对象.__getattribute__(属性名)和getattr(对象，属性名,默认值)
    

    print(dog1.name,dog1.age,dog1.color)
    print(dog1.__getattribute__('age'))
    print(getattr(dog1,'age'))

    #如果设置了default法人值，难么当属性不存在的时候不会报错，并且返回默认值
    print(getattr(dog1, 'age','无名氏'))

   ####2.改(修改属性的值)

    方法1：对象.属性 = 新值
    方法2：对象.__setattr__(属性名,新值)和setattr(对象，属性名，新值)
     dog1.age = 4
    print(dog1.age)
    dog1.__setattr__('color','blue')
    print(dog1.color)
    setattr(dog1,'color','white')
    print(dog1.color)

   ####3.增加
   
    方法1：对象.属性 = 值(属性不存在)
    属性是添加给对象的，而不是类的
    方法2：对象.__setattr__(属性，值)和setattr(对象，属性，值)

    dog1.size = 'big'
    print(dog1.size)

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

    ####4.删(删除对象的属性 )

    方法1：del 对象.属性
    注意：删除属性也是具体某个对象的属性，不会影响这个类的其他对象
    

    # del dog1.name
    # print(dog1.name)
    # dog1.__delattr__('name')
    # print(dog1.name)
    # delattr(dog1.color)

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

        def  study(self):
            print('好好学习天天向上')


    one_student=Student('小花','男',18)
    #方法1
    print(one_student.name,one_student.sex,one_student.age)
    #方法2
    print(one_student.__getattribute__('name'))
    print(one_student.__getattribute__('sex'))
    print(one_student.__getattribute__('age'))
    #方法3
    print(getattr(one_student,'name'))
    print(getattr(one_student, 'sex'))
    print(getattr(one_student, 'age'))
    #添加一个属性
    setattr(one_student,'number',1123)
    print(one_student.number)
    #修改学生年龄
    setattr(one_student,'age',20)
    print(one_student.age)
    #删除学生性别
    delattr(one_student,'sex')
    #学生学习
    one_student.study()

结果

小花 男 18
小花
男
18
小花
男
18
1123
20
好好学习天天向上

六、slots-魔法

class Person:
    #__slots__的功能：约束类中的对象的属性。
    __slots__ = ('name','age','sex')
    def __init__(self,name = '',age = 0):
        self.name = name
        self.age = age

    #自定义对象的打印格式
    """id()：是python的内置函数，功能是获取变量的地址"""
    def __str__(self):
        return self.name
if __name__ == '__main__':
    p1 = Person('小王',20)
    # p1.names = '老王'
    p1.sex = '男'
    print(p1)

结果

小王

七、类中的方法

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

方法：对象方法(方法)、类方法、静态方法
对象方法：自带一个self参数，一般要通过对象去调用
类方法：

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

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

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

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

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

class Person:
    #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))
    #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():
        print('人类保护地球')


if __name__ == '__main__':
    #1.类的字段要用类来使用
    print(Person.number)
    #2.对象的属性要通过对象来使用
    p1 = Person('小明')
    print(p1.name,p1.age)
    #3.对象的方法要通过对象来调用
    p1.eat('面条')
    #4.类方法通过类来调用
    Person.hurt_earth()
    #5.静态方法通过类来调用
    Person.protect_earth()