一、迭代器和生成器
生成器：a.可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个,里面的数据只能从前往后一个一个德地生成，不能跳跃，也不能从后往前，生成后的数据不能再生成
b.获取生成器里面的数据，需要使用next()方法
c.只要函数声明中有yield关键字，函数就不再是一个单纯的函数，而是一个生成器和列表比较：列表存数据必须是实实在在存在的数据，一个数据会占一定的内存空间
生成器存数据，存的是产生数据的算法，没有数据去占用内存空间
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)
yield 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__())
print(xu_lie.__next__())
print(xu_lie.__next__())
print(xu_lie.__next__())
print(xu_lie.__next__())
print('-'*20)
if __name__ == '__main__':
x = (i for i in range(10))
# x 就是一个生成器，用来产生数据
print(x)
print(x.__next__())
print(x.__next__())
print('-'*20)
num = 100
print(x.__next__())
结果：
1
1
2
3
5
--------------------
at 0x0C166BA0>
0
1
--------------------
2
二、认识面对对象
1.什么是类:对拥有相同属性和方法的对象的封装
类是抽象的
类中相同的属性的值是不能确定的
2.什么是对象：对象就是类的示例
对象是具体
对象中的属性得知是确定的
3.面向对象编程
面向过程编程：一步一步写代码实现功能 --- 工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数 --- 工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题 --- 工具：类和对象
举例：
如果人是一个类那么你就是人的一个对象，老王也是人的一个对象
如果说电脑是一个类，我桌上的电脑就是一个对象
如果说杯子是一个类，你手上的白色的杯子就是一个对象
三、类的声明
1.类的声明：
- 格式：
class 类名：
属性
方法
class 类名(父类):
属性
方法
class：python中声明类的关键字
类名: 标识符，类名的首字母大写，驼峰式命名
()：类如果继承自其它的类，需要些括号，括号里面是父类的名字(可以省略)
属性：对象属性和类的字段 --- 保存数据
方法：实质就是声明在类中的函数 --- 实现功能
示例：
1.声明
class Human:
"""类的说明:人类"""
# 声明两个对象方法，需要使用对象来使用
# 对象方法默认都有一个参数self,在调用方法的时候，这个参数不用传参(系统会自动给self传参)
# 谁来调用这个方法，self就是谁
def eat(self):
print('self:', self)
print('在吃饭')
def sleep(self):
print('在睡觉')
"""
声明对象：
通过类的构造方法创建对象(名字额类名同名的方法就是构造方法,自动生成的)
对象名 = 类名()
类对象可以通过点语法使用类中声明的对象方法和属性
对象.方法名()
对象.属性()
"""
if __name__ == '__main__':
# 2.声明对象
yh = Human()
print(yh)
# 一个类可以有多个对象
yw = Human()
print(yw)
# 对象可以调用对象方法
yh.eat()
yw.eat()
yh.sleep()
yw.sleep()
结果：
<__main__.Human object at 0x03260870>
<__main__.Human object at 0x03406DB0>
self: <__main__.Human object at 0x03260870>
在吃饭
self: <__main__.Human object at 0x03406DB0>
在吃饭
在睡觉
在睡觉
四、对象的属性
对象属性的声明：
class 类名：
def ___init__(self):
self.属性名 = 初值
self.属性名2 = 初值2
···
示例：
class Human:
"""人类"""
# init方法是系统自带的一个方法，这个方法不能直接调用，而是通过类创建对象的时候系统对自动调用这个方法
# init方法的作用是对对象的属性进行初始化
# 通过构造方法创建对象的时候，一定要保证init方法中除了self以外，其他每个参数都必须有值
def __init__(self, name='', age=0, sex='♀'):
# 在这个地方声明对象的属性
print('-'*20)
print(name)
# 在init方法中声明对象的属性
"""
name、age和sex就是Human这个类的对象属性。
类的对象属性，需要通过对象来使用
"""
self.name = name
self.age = age
self.sex = sex
if __name__ == '__main__':
# 注意：构造方法中的参数，实质是传给init方法的参数的
yh = Human('yh', 22, '♂')
# 通过对象使用对象属性
print(yh.name)
print(yh.age)
print(yh.sex)
p1 = Human()
p2 = Human('(●´З｀●)')
p3 = Human(sex='♂')
结果：
--------------------
yh
yh
22
♂
--------------------
--------------------
(●´З｀●)
--------------------
五、对象的属性的增删改查
class Dog:
"""狗类"""
def __init__(self, age=0, color='yellow'):
self.age = age
self.color = color
if __name__ == '__main__':
dog1 = Dog(3, 'black')
# 1.查（获取属性）
"""
方法一：对象.属性(如果属性不存在会报错)
方法二：对象.__getattribute__(属性名) 和 getattr(对象，属性名,默认值)
"""
# 方法一
print(dog1.age, dog1.color)
# 方法二
print(dog1.__getattribute__('age'))
print(getattr(dog1, 'age'))
# 如果设置default的值，当属性不存在的时候，返回default的值
print(getattr(dog1, 'a', None))
# 2.改（修改对象属性的值）
"""
方法一：对象.属性 = 新值
方法二：对象.__setattr__(属性名，新值) 和 setattr(对象， 属性名， 新值)
"""
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color', 'white')
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
dog1.__delattr__('type')
delattr(dog1, 'sex')
结果：
3 black
3
3
None
4
white
blue
小白
腊肠
公
六、slots
class Human:
# 限制类中的对象的属性
__slots__ = ('name', 'age', 'sex', 'tel', 'id')
def __init__(self, name='', age=0):
self.name = name
self.age = age
# 自定义对象的打印格式
# id():是python内置函数，功能是获取变量的地址
def __str__(self):
return self.name + str(self.age)
if __name__ == '__main__':
p1 = Human('老王', 20)
# p1.names = '小王'
p1.sex = '♂'
print(p1, type(p1))
p2 = p1
print(p2, type(p2))
结果：
老王20
老王20
七、类中的方法
属性：对象的属性、类的属性(类的字段)
对象属性：属于对象的，不同对象对应的值可能不一样(对象属性，通过对象使用)
类的字段：声明在类里面，函数外面。类的属性属于类(类的字段，通过类来使用)
方法：对象方法(方法)、类方法、静态函数
对象方法：自带一个self参数，一般通过对象去调用
类方法:
1.使用@classmethod修饰，
2.自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3.类方法通过类来调用静态方法:
1.使用@staticmethod修饰
2.没有默认参数
3.静态方法要通过类来调用
- 怎么选择用对象方法、类方法、静态方法
if 如果实现函数的功能需要使用对象的属性，就声明为对象方法；
elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明为类方法；
else 如果实现函数功能既不需要对象的属性，也不需要类的字段或者方法，就声明成静态方法。
补充：
ctr + f --- 查找
ctr + r --- 查找替换
示例：
class Human:
# number是类字段
number = 7
def __init__(self, name='', age=0):
# name 和 age是对象属性
self.name = name
self.age = age
# eat方法是对象方法
def eat(self, food):
print(self.name + '在吃凸O.O凸' + food)
@classmethod
def destroy_environment(cls):
# cls指向调用这个方法的类，cls可以当成类来使用
# 可以使用cls来创建对象
pt = cls('嘤嘤怪')
print(pt)
print(cls.number) # 可以通过cls来使用类的字段
print('人类破坏环境!')
# 静态方法
@staticmethod
def protect_earth():
print(Human.number)
print('人类保护地球')
if __name__ == '__main__':
# 1.类的字段要用类来使用
print(Human.number)
# 2.对象的属性要通过对象来使用
print(Human().name, Human().age)
# 3.对象方法用对象调用
p1 = Human('小王')
p1.eat('面条')
p2 = Human('老王')
p2.eat('火锅')
# 4.类方法通过类名来调用
Human.destroy_environment()
# 5.静态方法通过类来调用
Human.protect_earth()
结果：
7
0
小王在吃凸O.O凸面条
老王在吃凸O.O凸火锅
<__main__.Human object at 0x0C9704D0>
7
人类破坏环境!
7
人类保护地球