1、迭代器，生成器

生成器

a.可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个数据，里面的数据只能从前往后一个一个的生成，
不能跳跃。生成的数据不能再生成了

b.获取生成器里面的数据，需要使用next()方法

c.只要函数声明中有yied关键字，函数就不再是一个单纯的函数，而变成一个生成器

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__())

输出：
=: 3
=: 5
=: 8
=: 13
=: 21
=: 34
=: 55

2、认识面向对象

类：对拥共同属性的方法的对象的封装（抽象）
对象：对象就是类的实例（具体）

类的声明

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

类名：标识符，类名的首字母大写，驼峰式命名
（）：类要继承其他的类需要写括号，括号里面是父类的名字。可以省略

属性：对象属性和类的字段---->保存数据
方法：实质就是声明在类中的函数 ----> 实现功能

self:对象的默认参数，谁调用它self就是谁

3、对象的属性

对象的属性声明

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

init :对属性进行初始化，init方法中除了self以外，其他的每个参数都必须有值

    def __init__(self,name1,age1):
#         在这个地方声明对象的属性
        print('===')
        print(name1)

构造方法中的参数，实质是传给init方法的参数的

4、对象属性的増删改查

查看属性

方法一：对象.属性（如果属性不存在会报错）

方法二：对象._ _ getattribute _ _(属性名）和getattr（对象，属性名）
和 setattr（对象，属性名）

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

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

修改属性的值

方法一： 对象.属性 = 新值

方法二： 对象._ _ setattr _ _(属性名，新值）

删除对象的属性

del 对象.属性

 del dog1.age
  print(dog1.age) #AttributeError: 'Dog' object has no attribute 'age'

delattr（对象，属性）

delattr(dog1,'color')
 print(dog1.color)

5.slot魔法

slots的功能：就是约束类中的对象的属性。

__slots__ = ('name','age','sex')
    def __init__(self,name='',age = 0):
        self.name = name
        self .age = age
        # self.tel = 123  'Person' object has no attribute 'tel'

6、类中的方法

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

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

类方法：1.使用@classmethod修饰
2.自带一个cls参数，并且这个参数不用传参,谁来调用这个方法，cls就指向谁
3.类方法要通过类来调用

静态方法：1.使用@staticmethod修饰
2.没有默认参数
3.静态方法通过类调用

自定义对象的打印格式
def str(self):
return self.name+','+str(self.age)

class Person:
#     number是类的字段
    number = 0
    def __init__(self,name = '',age = 0):

        # age name、是对象属性
        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('人类破坏环境！！')

        print(cls.number)  #可以通过cls使用类的字段


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


if __name__ == '__main__':
    print(Person.number)

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

    p1.eat('面条')

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

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

    # 5.静态方法通过类调用
    Person.protect_earth()
输出：0
小明
小明在吃面条
小红在吃火锅
张三
人类破坏环境！！
0
人类保护地球

练习：
写一个班级类，属性:班级名、学生；功能：添加学生，查找学生。

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

        def __str__(self):
            return 'name:%s age:%d'%(self.name,self.age)


    class Class():
        def __init__(self, name='', students=[]):
            self.name = name
            self.students = students

        def add_student(self):
            name =input('name:')
            age = input('age:')

            # 根据输入的信息创建学生对象
            stu = Student(name,int(age))
                #   添加学生
            self.students.append(stu)


    cls1 =Class('py1805')
    cls1.add_student()
    print(cls1.students[0])