一、迭代器和生成器

1.生成器：

（1）可以看成是一个可以储存多个数据的容器，需要里面的数据时就生成一个，里面的数据只能从前往后一个一个的生成，不会能跳跃，也不能从后往前，而且生成后的数据也不能再生成

（2）next:获取生成器里的数据，格式：__next__()

（3）函数声明中有yield关键字，函数就不再是一个单纯的函数，而是变成一个生成器,遇到yield就返回一个值

2.和列表比较：

（1）列表存数据，数据必须是实实在在存在的数据，一个数据会占一定的内存空间
（2）生成器存数据，存的不是数据，而是数据产生的算法，没有数据占内存空间

#1,1,2,3,5,8,13...
方法1：
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
            print(current)
            continue
        current=pre_1+pre_2
        pre_1,pre_2=pre_2,current
        print(current)

xu_lie(10)
"""
结果：
1
1
2
3
5
8
13
21
34
55
"""

方法2：
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
        yield current
xulie=xu_lie(10)
print(xulie.__next__())  #1
print(xulie.__next__())  #1
print(xulie.__next__())  #2

for x in xulie :
    print('--',x)
"""
结果：
-- 3
-- 5
-- 8
-- 13
-- 21
-- 34
-- 55
"""


if __name__ == '__main__':
    x=(i for i in range(10))
    # x就是一个生成器，用来产生数据
    print(x,type(x))   #<generator object <genexpr> at 0x008B7F30> <class 'generator'>
    print(x.__next__())  #0
    print(x.__next__())  #1
    print('=========')
    print(x.__next__())  #2

面向对象

1.什么是类

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

2.什么是对象

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

例如：
人是类，老王就是人的一个对象；
如果说电脑是一个类，我桌上的这台mac就是一个对象
如果说杯子是一个类型，我桌上这个粉色的杯子就是一个对象

3.面向对象编程

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

三、类的声明和对象的声明

1.类的声明：

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

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

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

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

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

2.声明对象：

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

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

#2.声明对象
    p1=Person()
    print(p1)  #<__main__.Person object at 0x0205D310>
    #一个类可以有多个对象
    p2=Person()
    print(p2)  #<__main__.Person object at 0x00723490>

    #对象可以调用对象方法
    p1.eat()  #在吃饭
    p2.sleep()  #在睡觉

四、对象属性

对象属性的声明：

calss 类名：
    def__init__(self)
        self.属性名=初值
        self.属性名2=初值2

class Preson:
    """人类"""
    """
    1.init方法是系统自带的一个方法，这个方法不能直接调用，通过类创建对象的时候系统会自动调用这个方法
    init方法的作用是对对象的属性进行初始化
    2.通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其他的每个参数都必须有值
    """
    def __init__(self,name1='',age1=0,sex='女'):
        #在这里申明对象属性，
        print('--------')
        print(name1 )
        #在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=Preson('zl',18)

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

    p2=Preson('骆昊',30)
    print(p2.name,p2.age)   # 骆昊 30

    """通过不同的方式创建对象"""
    #创建对象的时候不给属性赋值(有默认值)
    p3=Preson()
    #
    p4=Preson('大牛')

    p5=Preson(sex='男')

五、对象属性的增删改查

class Dog:
    """狗类"""

    def __init__(self,age=0,color='yellow'):
        self.age=age
        self.color=color
dog1 =Dog(3,'pink')

1.查（获取属性）
    """
    (1)对象.属性   --->查找时，如果属性不存在会报错
    (2)对象.__getattribute__(属性名) 
    (3)getattr(对象，属性名，默认值)
    """

    print(dog1.age,dog1.color)

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

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



2.改（修改属性的值）
    """
    （1）对象.属性=新值
    （2）对象.__setattr__(属性名，新值) 
    (3)setattr(对象，属性名，新值)
    """

    dog1.age=4
    print(dog1.age)   #4

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

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

3.增加
    """
    对象.属性=值（属性不存在即添加）
    注意：属性是添加给对象的，而不是类的
    """
    dog1.name='大黄'
    print(dog1.name)   #大黄

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

    setattr(dog1,'sex','公狗')
    print(dog1.sex)

4.删除（删除对象的属性）
    """
    del 对象.属性
    注意：删除属性也是删除具体某个对象的属性，不会影响这个类的其他对象
    
    """
    del dog1.age
    # print(dog1.age)  #AttributeError: 'Dog' object has no attribute 'age'

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

    delattr(dog1,'color')
    # print(dog1.color)   #AttributeError: 'Dog' object has no attribute 'age'

练习：声明一个学生类，拥有属性：姓名，性别，年龄，方法：学习
1.声明学生类的对象，声明的时候就给姓名，性别和年龄赋值
2.通过三种方式分别获取姓名，性别，年龄，并且打印
3.给学生对象添加一个属性，电话
4.修改学生的年龄
5.删除学生的性别

class Student:

    def __init__(self,name='',sex='女',age=18):
        self.name=name
        self.sex=sex
        self.age=age

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

stu1=Student('张三','男',20)

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

stu1.tel='123'

stu1.age=18

del stu1.sex

stu1.study()

六、slots魔法

class Person:

   ** (__slots__的功能：就是约束类中的对象的属性)**

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

    #自定义对象的打印格式
    """
    id():是python的内置函数，功能是获取变量的地址
    """
    def __str__(self):
        return 'name:%s age:%d address:0x%x' % (self.name, self.age, id(self))


if __name__ == '__main__':
    p1=Person('小王',20)
    # p1.names='老王'  #AttributeError: 'Person' object has no attribute 'names'
    p1.sex='男'

    print(p1)   #name:小王 age:20 address:0x632fd0

七、类中的方法

1.属性：对象的属性（属性），类的属性（类的字段）

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

2.方法：对象方法（方法）、类方法、静态方法

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

3.怎么选择用对象方法、类方法、静态方法？

if 如果实现函数的功能需要使用对象的属性，就声明成对象方法

elif 不使用对象属性的前提下，如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法

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

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

class Person:
    #number是类的字段
    number=0

    def __init__(self,name=''):
        #name是对象属性
        self.name=name

    #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)  #0   #可以通过cls使用类的字段

        print('人类破坏环境')

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


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

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

    #3.对象方法通过对象去调用
    p1.eat('面')   #笑笑在吃面

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

    #4.类方法通过类来调用
    Person.hurt_earth()   #人类破坏环境

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

练习：1.写一个班级类，属性：班级名，学生，功能：添加学生，查找学生

class Student:
    """学生类"""
    def __init__(self,name='',age=0):
        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.students=students
        self.class_name=name


    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()
students = cls1.students
stu = students[0]
print(stu.name)

总结：

1.生成器和生成式
（i for i in range(10)) 等于 def func():
for i in range(10):
yield i
(i+100 for i in range(10))
(i for i in range(10) if i%2==0)

2.面向对象
类和对象
(1)类：拥有相同属性和功能（方法）的对象的集合（抽象的）
(2)对象：类的实例（具体的）

类的声明：
class 类名（父类）：--->（驼峰，首字母大写）
属性
方法
声明不执行内容，使用时才执行

创建对象：
对象名=类名（）

属性：
对象的属性：通过对象使用--->对象. --->init方法，self.属性名=值
类的属性（类的字段）:通过类的适应--->类里面函数外面，属性名=值

属性的增删改查

init方法：
（1）用来初始化对象的属性
（2）通过类创建对象的时候，系统自动调用init方法，创建对象的时候，保证init中每个参数都要有值，否则报错

方法：
对象方法：自带一个self参数，不用传参,通过对象调用
类方法：@classmethod 自带一个cls参数，调用时不用赋值，通过类调用
静态方法：@staticmethod 通过类调用

注意：如果函数的参数是对象（列表，字典，类的对象），传参的时候，传的是地址，如果函数中要对对象的内容进行修改，传参的时候传对象的拷贝（列表就切片[:]）

    def func1(list1):
        list1.append(10)
        print(list1)   #[1, 2, 3, 4, 10]

    def func2(lista):
        lista.append(20)
        print(lista)   #[1, 2, 3, 4, 20]

    list11 = [1, 2, 3, 4]
    func1(list11[:])
    func2(list11[:])
    print(list11)    #[1, 2, 3, 4]