1. 迭代器和生成器
生成器：
a. 可以看成一个可以存储多个数据的容器。需要里面的数据的时候就生成一个，里面的数据只能从前往后一个一个的生成，不能跳跃也不能从后往前，生成后的数据不能再生成
b. 获取生成器里面的数据，需要使用next()方法
c. 只要函数声明中有yield关键字，函数就不再是一个单纯的函数，而变成一个生成器
和列表比较：列表存数据，数据必须是实实在在存在的数据，一个数据会占一定的内存空间。
生成器存数据，存的是产生数据的算法，没有数据去占内存空间
# 1,1,2,3,5,8,13,21...
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
xulie = xu_lie(10)
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())
if __name__ == '__main__':
x = (i for i in range(10))
# x 就是一个生成器，用来产生数据
print(x)
print(x.__next__())
print(x.__next__())
print(x.__next__())
运行结果：
1
1
2
<generator object <genexpr> at 0x0000024E84A19318>
0
1
2
2. 认识面向对象
- 什么是类：对拥有相同属性和功能的对象的封装
类是抽象
类中相同的属性的值是不能确定的 - 什么是对象：对象就是类的实例
对象是具体
对象的属性是确定的
如果人是一个类，那么张三，李四都是人的对象
如果说电脑是一个类，那么我的战神Z7-kp7sc就是一个对象
- 面向对象编程
面向过程编程：一步一步的写代码实现功能 ---> 工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数 ---> 工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题---> 工具：类和对象
3. 类的声明
类的声明：
class 类名(父类)：
属性
方法
class：python中声明类的关键字
类名：标识符，类名的首字母大写，驼峰式命名
()：类要继承自其它的类需要写括号，括号里面是父类的名字。可以省略
属性：对象属性和类的字段 --- 保存数据
方法：实质就是声明在类中的函数 --- 实现功能
1. 声明类Person
class Person:
"""类的说明：人类"""
# 声明两个对象方法，需要使用对象来调用
"""
对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统会自动给self传参）
谁来调用这个方法，self就是谁
"""
def eat(self):
print('self:', self)
print('我要吃饭饭了！')
def sleep(self):
print('我要睡觉觉了！(¦3[▓▓] 晚安！')
声明对象：
通过类的构造方法去创建对象(名字和类名同名的方法就是构造方法，自动生成的)
对象名 = 类名()
类的对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名()
对象.属性名
if __name__ == '__main__':
# 2. 声明对象
p1 = Person()
print('p1', p1)
print(p1)
# 一个类可以有多个对象
p2 = Person()
print(p2)
# 对象可以调用对象方法
p1.eat()
p2.eat()
p1.sleep()
p2.sleep()
运行结果：
p1 <__main__.Person object at 0x000002A46AC03320>
<__main__.Person object at 0x000002A46AC03320>
<__main__.Person object at 0x000002A46AC033C8>
self: <__main__.Person object at 0x000002A46AC03320>
我要吃饭饭了！
self: <__main__.Person object at 0x000002A46AC033C8>
我要吃饭饭了！
我要睡觉觉了！(¦3[▓▓] 晚安！
我要睡觉觉了！(¦3[▓▓] 晚安！
4. 对象的属性
对象属性的声明
class 类名：
def __init__(self):
self.属性名 = 初值
self.属性名2 = 初值2
class Person:
"""人类"""
"""
1. init方法是系统自带的一个方法，这个方法不能直接调用，通过类创建对象的时候系统会自动调用这个方法
init方法的作用是对对象的属性初始化
2. 通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其他的每个参数都必须有值
"""
def __init__(self, name1='', age1=0, sex='男'):
# 在这个地方声明对象的属性
# 在init方法中声明对象的属性
"""
name,age,sex就是Person这个类的对象属性。类的对象属性，需要通过对象来使用
"""
self.name = name1
self.age = age1
self.sex = sex
if __name__ == '__main__':
# 注意：构造方法中的参数，实质是传给init方法的参数的
p1 = Person('Percy', 18)
# 通过对象使用对象属性
print(p1.name, p1. age, p1.sex)
p2 = Person('Smile', 20)
print(p2.sex, p2.name, p2.age)
# 创建对象的时候不给属性赋值
p3 = Person()
p4 = Person(sex='女')
运行结果：
Percy 18 男
男 Smile 20
5. 对象属性的增删改查
class Dog:
"""狗类"""
def __init__(self, age=0, color='blue'):
self.age = age
self.color = color
if __name__ == '__main__':
dog1 = Dog(3, 'green')
# 1.查（获取属性）
"""
方法1：对象.属性（如果属性不存在，会报错）
方法2：对象.__getattribute__(属性名)和getattr(对象，属性名,默认值)
"""
print(dog1.age, dog1.color)
print(dog1.__getattribute__('age'))
print(getattr(dog1, 'age'))
# 如果设置了default的值，那么当属性不存在的时候不会报错，并且返回默认值
print(getattr(dog1, 'abc', '无名氏'))
# 2.改（修改属性的值）
"""
方法1：对象.属性 = 新值
方法2：对象.__setattr__（属性名，新值）和 setattr(对象，属性名，新值)
"""
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color', 'black')
print(dog1.color)
setattr(dog1, 'color', 'red')
print(dog1.color)
# 3.增加(增加对象的属性)
"""
对象.属性 = 值（属性不存在）
注意：属性是添加给对象的，而不是类的
"""
dog1.name = '二哈'
print(dog1.name)
dog1.__setattr__('type', '哈士奇')
print(dog1.type)
setattr(dog1, 'sex', '公狗')
print(dog1.sex)
# 4.删（删除对象的属性）
"""
方法1：del 对象.属性
注意：删除属性也是删的某个具体对象的属性，不会影响这个类的其他对象
"""
# del dog1.age
# print(dog1.age) # ---> 报错，age属性删除了
# dog1.__delattr__('age')
# print(dog1.age) # ---> 报错，age属性删除了
# delattr(dog1, 'color')
# print(dog1.color) # ---> 报错，color属性删除了
运行结果：
3 green
3
3
无名氏
4
black
red
二哈
哈士奇
公狗
练习：声明一个学生类，拥有属性：姓名，性别，年龄。方法：学习
1.声明学生类的对象，声明的时候就给姓名、性别和年龄赋值
2.通过三种方式分别获取姓名、性别和年龄，并且打印
3.给学生对象添加一个属性，电话
4.修改学生的年龄
5.删除学生的性别
class Student:
"""学生类"""
def __init__(self, name='', sex='', age=0):
self.name = name
self.sex = sex
self.age = age
def study(self):
print('%s学习' % self.name)
stu1 = Student('Percy', '男', 18)
print(stu1.name, stu1.sex, stu1.age)
print(stu1.__getattribute__('name'), stu1.__getattribute__('sex'), stu1.__getattribute__('age'))
print(getattr(stu1, 'name'), getattr(stu1, 'sex'), getattr(stu1, 'age'))
stu1.tel = '123456'
print(stu1.tel)
stu1.age = 19
print(stu1.age)
del stu1.sex
stu1.study()
运行结果：
Percy 男 18
Percy 男 18
Percy 男 18
123456
19
Percy学习
6. slots魔法
class Person:
# __slots__的功能：约束类中对象的属性。
__slots__ = ('name', 'age', 'sex')
def __init__(self, name='', age=0):
self.name = name
self.age = age
# self.tel = 123 --->slots 魔法中没有tel这个属性，报错
# 自定义对象的打印格式
"""
id():是python的内置函数，功能是获取变量的地址
"""
def __str__(self):
return self.name + ',' + str(self.age) + ',' + str(id(self))
if __name__ == '__main__':
p1 = Person('小王', 20)
# p1.names = '老王' --->报错，没有这个names属性
p1.sex = '男'
print(p1)
运行结果：
小王,20,1385837533832
7. 类中的方法
属性：对象的属性（属性）、类的属性（字段）
对象属性：属于对象，不同对象对应的值可能不一样（对象属性，通过对象来使用）
类的字段：声明在类里面，函数外面。类的属性属于类（类的字段，通过类来使用）
方法：对象方法（方法）、类方法、静态函数
对象方法：自带一个self参数，一般通过对象去调用
类方法：
- 使用@classmethod修饰
- 自带一个 cls 参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
- 类方法要通过类来调用
静态方法：
- 使用@staticmethod修饰
- 没有默认参数
- 静态方法要通过类来调用
怎么选择用对象方法、类方法、静态方法？
如果实现函数的功能需要使用对象的属性，就声明成对象方法；
如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法
如果实现函数功能既不需要对象的属性也不需要类的字段，就声明成静态方法
class Person:
# number 是类字段
number = 0
def __init__(self, name='', age=0):
# name和age是对象属性
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('米线')
p2 = Person('小王')
p2.eat('火锅')
# 4.类方法通过类来调用
Person.hurt_earth()
# 5.静态方法通过类来调用
Person.protect_earth()
运行结果：
0
小张 0
小张在吃米线
小王在吃火锅
张三
0
污染环境!!!
保护地球
练习：
写一个班级类，属性：班级名、学生；功能：添加学生
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.classname = 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()
students = cls1.students
stu = students[0]
print(stu.name)
运行结果：
name:Percy
age:18
Percy
作业：
- 声明一个电脑类：
属性：品牌、颜色、内存大小
方法：打游戏、写代码、看视频
a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性
"""__author__ = Percy"""
"""
1.声明一个电脑类：
属性：品牌、颜色、内存大小
方法：打游戏、写代码、看视频
a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性
"""
class Computer:
def __init__(self, brand='', color='', memory=''):
self.brand = brand
self.color = color
self.memory = memory
def play(self):
print('Percy在用%s玩游戏' % self.brand)
def write_code(self):
print('Percy正在写代码')
def watch_video(self):
print('Percy正在看快乐大本营')
if __name__ == '__main__':
p1 = Computer('战神', 'black', '256GB SSD+1Tb HDD')
print('品牌：', p1.brand)
p1.color = 'red'
print('颜色：', p1.color)
p1.price = 6500
print('价格：', p1.price)
del p1.memory
print('---------------')
print('品牌：', p1.__getattribute__('brand'))
setattr(p1, 'color', 'blue')
print('颜色：', p1.color)
setattr(p1, 'price', 6500)
print('价格：', p1.price)
p1.__delattr__('color')
运行结果：
品牌： 战神
颜色： red
价格： 6500
---------------
品牌： 战神
颜色： blue
价格： 6500
- 声明一个人的类和狗的类：
狗的属性：名字、颜色、年龄 狗的方法：叫唤
人的属性：名字、年龄、狗 人的方法：遛狗
a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄
"""__author__ = Percy"""
"""
2.声明一个人的类和狗的类：
狗的属性：名字、颜色、年龄 狗的方法：叫唤
人的属性：名字、年龄、狗 人的方法：遛狗
a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄
"""
class Dog:
def __init__(self, d_name='', d_color='', d_age=0):
self.d_name = d_name
self.d_color = d_color
self.d_age = d_age
def cry_out(self):
print('%s正在叫唤' % self.d_name)
class Person:
def __init__(self, p_name='', p_age=0, p_dog=[]):
self.p_name = p_name
self.p_age = p_age
self.p_dog = p_dog
def walk_the_dog(self):
print('%s正在遛%s' % (self.p_name, p_dog))
if __name__ == '__main__':
p = Person('小明')
d1 = Dog('大黄')
p_dog = d1.d_name
print(p.walk_the_dog())
运行结果：
小明正在遛大黄
None
- 声明一个矩形类：
属性：长、宽 方法：计算周长和面积
a.创建不同的矩形，并且打印其周长和面积
"""__author__ = Percy"""
"""
3.声明一个矩形类：
属性：长、宽 方法：计算周长和面积
a.创建不同的矩形，并且打印其周长和面积
"""
class Rect:
def __init__(self, length=0, width=0):
self.length = length
self.width = width
def rect_per(self):
per = 2 * (self.length + self.width)
print('周长为：%f' % per)
def rect_area(self):
area = self.length * self.width
print('面积为：%f' % area)
if __name__ == '__main__':
r1 = Rect(2, 3)
r1.rect_per()
r1.rect_area()
r2 = Rect(1.5, 2.1)
r2.rect_per()
r2.rect_area()
运行结果：
周长为：10.000000
面积为：6.000000
周长为：7.200000
面积为：3.150000
- 创建一个学生类：
属性：姓名，年龄，学号 方法：答到，展示学生信息
创建一个班级类：
属性：学生，班级名 方法：添加学生，删除学生，点名
"""__author__ = Percy"""
"""
4.创建一个学生类：
属性：姓名，年龄，学号 方法：答到，展示学生信息
创建一个班级类：
属性：学生，班级名 方法：添加学生，删除学生，点名
"""
from random import randint
class Student:
def __init__(self, name='', age=0):
self.name = name
self.age = age
self.num = 'Py1805' + str(randint(0, 50))
def replied(self):
print('%s已答道' % self.name)
def show(self):
print('%s的信息为：姓名：%s，年龄：%d，学号：%s' % (self.name, self.name, self.age, self.num))
class Class:
def __init__(self, students=[], class_name=''):
self.students = students
self.class_name = class_name
def add_stu(self):
new_name = input('姓名：')
new_age = input('年龄：')
new_num = input('学号：')
stu = Student(new_name, int(new_age), new_num)
self.students.append(stu)
print('学生%s添加成功！' % stu.name)
def del_stu(self):
del_name = input('请输入要删除的学生的姓名：')
d_stu = Student(del_name)
del d_stu
print('学生%s删除成功！'% del_name)
def call_name(self):
c_name = input('请输入要点名的学生：')
print('点名%s' % c_name)
if __name__ == '__main__':
s1 = Student('Percy', 18)
s1.replied()
s1.show()
add1 = Class('Py1805')
add1.add_stu()
students = add1.students
stu = students[0]
del1 = Class('Py1805')
del1.del_stu()
students = del1.students
call1 = Class()
call1.call_name()
运行结果：
Percy已答道
Percy的信息为：姓名：Percy，年龄：18，学号：Py180522
姓名：Percy
年龄：18
学生Percy添加成功！
请输入要删除的学生的姓名：Percy
学生Percy删除成功！
请输入要点名的学生：Percy
点名Percy
- 写一个类，封装所有和数学运算相关的功能（包含常用功能和常用值，例如：pi,e等）
"""__author__ = Percy"""
"""
5.写一个类，封装所有和数学运算相关的功能（包含常用功能和常用值，例如：pi,e等）
"""
class Math:
"""数学类"""
pi = 3.1415926
e = 2.718
@staticmethod
def sum(*number):
"""求和"""
sum1 = 0
for x in number:
sum1 += x
return sum1
@classmethod
def circle_area(cls, r):
"""圆面积"""
return r**2 * cls.pi
if __name__ == '__main__':
print(Math.sum(1, 2, 3))
print(Math.circle_area(2))
print(Math.pi)
运行结果：
6
12.5663704
3.1415926
