yield关键字和生成器
生成器：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
yield current
# print(current)
continue
current = pre_1+pre_2
pre_1,pre_2=pre_2,current
# print(current)
yield current
if __name__ == '__main__':
x = (i for i in range(10))
print(x)
print(x.__next__()) #生成0
print(x.__next__()) #生成1
print('===')
print(x.__next__()) #生成2
number = 0
xulie = xu_lie(10)
print(xulie,type(xulie))
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())
for x in xulie:
print('*',x)
结果：
at 0x02810750>
0
1
===
2
1
1
2
3
5
* 8
* 13
* 21
* 34
* 55
什么是面向对象
什么是类：对拥有相同属性和功能的对象的封装
类是抽象
类中相同的属性的值是不能确定的什么是对象：对象就是类的实例
对象是具体
对象的属性是确定的
如果说人是一个类，那么我就是人的一个对象
如果电脑是一个类，我桌上的这台电脑就是一个对象
如果说杯子是一个类型，我桌上这个透明的水杯就是一个对象面向对象编程
面向过程编程：一步一步的写代码实现功能 --> 工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能函数 --> 工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题 --> 工具：类和对象
类的声明
- 类的声明：
class 类名（父类）：
属性
方法
- class：python中声明类的关键字
- 类名：标识符，类名的首字母大写，驼峰式命名
- （）：类要继承自其他的类，需要写括号，括号里面是父类的名字。可以省略
- 属性：对象属性和类的字段 --- 保存数据
- 方法：实质就是声明在类中的函数 --- 实现功能
class Person:
"""类的说明：人类"""
#声明两个对象方法，需要使用对象来调用
"""
对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统会自动给self传参）
谁来调用这个方法，self就是谁
"""
def eat(self):
print('=',self)
print('在吃饭')
def sleep(self):
print('在睡觉，(～﹃～)~zZ')
if __name__ == '__main__':
# 2.声明对象
p1 = Person()
print(p1)
# 一个类可以有多个对象
p2 = Person()
print(p2)
#对象可以调用对象方法
p1.eat()
p1.sleep()
p2.eat()
p2.sleep()
- 声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法）
对象名= 类名（）
- 类对象可以通过点语法使用类中声明的对象的方法和属性
- 对象.方法名（）
- 对象.属性名
对象的属性
- 对象属性的声明
- class 类名：
def init(self):
self.属性名 = 初值
self.属性名2 = 初值2
class Person:
"""人类"""
"""
init方法是系统自带的一个方法，这个方法不能直接调用，通过类创建对象的时候系统会自动调用这个方法
init方法的作用是对对象的属性进行初始化
通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其他的每个参数都必须有值
"""
def __init__(self,name1='',age1=0,sex1='man'):
# 在这个地方声明对象的属性
# print('***')
# print(name1)
# print(age1)
# 在init方法中声明对象的属性
"""
name、age和sex就是Person这个类的对象属性。类的对象属性，需要通过对象来使用
"""
self.name = name1
self.age = age1
self.sex = sex1
if __name__ == '__main__':
# 注意：构造方法中的参数，实质是传给init方法的参数的
p1 = Person('dalao',18)
# 通过对象使用对象属性
print(p1.name,p1.age,p1.sex)
p2 = Person('罗昊',30)
print(p2.sex,p2.name)
# 创建对象的时候不给属性赋值
p3 = Person(age1=10)
print(p3.age)
结果：
dalao 18 man
man 罗昊
10
对象属性的增删改查
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的值，那么当属性不存在的时候不会报错，并且返回默认值
print(getattr(dog1, 'abc','无名氏'))
# 2.改（修改属性的值）
"""
方法一： 对象.属性 = 新值
方法二： 对象.__setattr__(属性名，新值) 和 setattr（对象，属性名新值）
"""
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color','blue')
print(dog1.color)
setattr(dog1,'color','writa')
print(dog1.color)
# 3.增加
"""
方法一： 对象.属性 = 值（属性不存在）
注意：属性是添加给对象的，而不是类的
方法二： 对象.__setattr__(属性名，新值) 和 setattr（对象，属性名新值）
"""
dog1.name = '土狗'
print(dog1.name)
dog1.__setattr__('type','哈士奇')
print(dog1.type)
setattr(dog1, 'sex', '公')
print(dog1.sex)
# 4.删（删除对象的属性）
"""
方法一： del 对象.属性
注意：删除属性也是删的具体某个对象的属性。不会影响这个类的其他对象
方法二： delattr(对象,属性名)
"""
del dog1.age
# print(dog1.age) 报错：AttributeError: 'Dog' object has no attribute 'age'
delattr(dog1,'color')
# print(dog1.color)
结果：
3 black
3
3
无名氏
4
blue
writa
土狗
哈士奇
公
练习：
- 声明一个学生类，拥有属性：姓名、性别、年龄。方法：学习
- 声明学生类的对象，声明的时候就给姓名、性别和年龄赋值
- 通过三种方式分别获取姓名、性别和年龄，并且打印
- 给学生对象添加一个属性，电话
- 修改学生年龄
- 删除学生的性别
class Student:
def __init__(self, name='小王', sex='男', age='15'):
self.name = name
self.sex = sex
self.age = age
def study(self):
print( '%s正在学习'% self.name)
student1 = Student()
print(student1.name,student1.sex,student1.age)
print(student1.__getattribute__('name'))
print(student1.__getattribute__('sex'))
print(student1.__getattribute__('age'))
getattr(student1,'name')
getattr(student1,'sex')
getattr(student1,'age')
student1.tel = 110
print(student1.tel)
student1.__setattr__('id',1805001)
setattr(student1,'hobby','football')
student1.age = 20
print(student1.age)
del student1.sex
# print(student1.sex)
student1.study()
结果：
小王 男 15
小王
男
15
110
20
小王正在学习
_slots_和_str_用法
class Person():
# __slots__的功能：就是约束类中的对象的属性。
__slots__ = ('name','age','sex','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 = Person('小王',20)
# p1.name = '老王'
p1.sex = 'woman'
print(p1)
结果：
小王,20
类中的方法
属性：对象的属性（属性）、类的属性（类的字段）
对象属性：属于对象的，不同对象对应的值可能不一样(对象属性，通过对象来使用)
类的字段：声明在类里面，函数外面。类的属性属于类()
方法：对象方法（方法）、类方法、静态方法
对象方法：自带一个self参数，一般要通过对象去调用
类方法：
- 使用@classmethod修饰
2. 自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3. 类方法要通过类来调用
静态方法：
1.使用@staticmethod修饰
2.没有默认参数
3.静态方法要通过类来调用怎么选择用对象方法、类方法、静态方法？
if 如果实现函数的功能需要使用对象的属性，就声明成对象方法；
elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法
elif 如果实现函数的功能既不需要对象的属性也不需要类的字段，就声明成静态方法
class Person:
# number是类字段
number = 0
def __init__(self,name='',age= 0):
# name和age是对象属性
self.name = name
self.age = age
# eat1方法是对象方法
def eat1(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('人类破坏环境..')
@staticmethod
def protect_earth():
print('人类保护地球')
if __name__ == '__main__':
# 类的字段要用类来使用
print(Person.number)
# 对象的属性要通过对象来使用
p1 = Person('小明')
# 对象方法用对象调用
p1.eat1('方便面')
print(p1.name,p1.age)
p2 = Person('小网')
p2.eat1('串串')
# 类方法通过类来调用
Person.hurt_earth()
# 静态方法通过类来调用
Person.protect_earth()
结果：
0
小明在吃方便面
小明 0
小网在吃串串
李四
0
人类破坏环境..
人类保护地球
练习：
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.class_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)
结果：
name:孝利
age:23
name:孝利 age:23
面向对象练习
1.声明一个电脑类：
属性：品牌、颜色、内存大小
方法：打游戏、写代码、看视频
a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性
class Computer:
def __init__(self,brand='联想',color='black',memory='64G'):
self.brand = brand
self.color = color
self.memory = memory
def game(self):
print('可以打游戏')
def write_code(self):
print('可以写代码')
def movie(self):
print('可以看电影')
if __name__ == '__main__':
# 声明一个对象
com1 = Computer()
# 修改对象品牌
com1.brand = '华硕'
print(com1.brand)
setattr(com1,'brand','苹果')
print(com1.brand)
# 获取内存大小
print(com1.memory)
print(getattr(com1,'memory'))
# 添加对象属性
com1.screen_size = '15.7'
print(com1.screen_size)
setattr(com1, 'CPU', 'i7')
print(com1.CPU)
# 删除对象属性
del com1.color
delattr(com1,'screen_size')
结果：
华硕
苹果
64G
64G
15.7
i7
2.声明一个人的类和狗的类：
狗的属性：名字、颜色、年龄 狗的方法：叫唤
人的属性：名字、年龄、狗 人的方法：遛狗
a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄
class Dog:
def __init__(self,name='',color='',age=''):
self.name = name
self.color = color
self.age = age
def bark(self):
print('%s在叫唤'%self.name)
class Person:
def __init__(self,name='',dog='',age=15):
self.name = name
self.age = age
self.dog = dog
def walk_the_dog(self):
print('%s在溜着%s'%(self.name,self.dog))
if __name__ == '__main__':
dog1 = Dog('大黄','yellow','5')
p1 = Person('小明', dog1.name)
p1.walk_the_dog()
dog1.bark()
结果：
小明在溜着大黄
大黄在叫唤
3.声明一个矩形类：
属性：长、宽 方法：计算周长和面积
a.创建不同的矩形，并且打印其周长和面积
class Rectangle:
def __init__(self,width,height):
self.width = width
self.height = height
def perimeter(self):
perimeter1 = (self.width+self.height)*2
print('周长为%s'%perimeter1)
def area(self):
area1 = self.width*self.height
print('面积为%s'%area1)
if __name__ == '__main__':
r1 = Rectangle(10,20)
r2 = Rectangle(5, 5)
r1.perimeter()
r1.area()
r2.perimeter()
r2.area()
结果：
周长为60
面积为200
周长为20
面积为25
4.创建一个学生类：
属性：姓名，年龄，学号 方法：答到，展示学生信息
创建一个班级类：
属性：学生，班级名 方法：添加学生，删除学生，点名，根据姓名查看学生信息，展示班级的所有学生信息
5.写一个类，封装所有和数学运算相关的功能（包含常用功能和常用值，例如：pi,e等）
import math
class Function:
def __init__(self,x,y=0):
self.x = x
self.y = y
def pow(self):
print('%s的%s次方是%d' %(self.x, self.y, (self.x**self.y)))
def perimeter(self):
perimeter1 = self.x*2*math.pi
print('圆周长为%s'%perimeter1)
def area(self):
area1 = self.x*math.pi**2
print('圆面积为%s'%area1)
if __name__ == '__main__':
m1 = Function(2,4)
m1.pow()
m2 = Function(3)
m2.perimeter()
m2.area()
结果：
2的4次方是16
圆周长为18.84955592153876
圆面积为29.608813203268074