一、生成器
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
二、类和对象
1.定义
-
类：对拥有相同功能和属性的对象的封装
-
对象：类的实例
2.声明
-
类的声明：
类的声明：
class 类名(父类):
属性
方法
解说
class: python中声明类的关键字
类名： 标识符，类名的首字母大写，驼峰式命名
( ): 类要继承自其它的类，需要写括号，括号里面是父类的名字。可以省略
属性： 对象属性和类的字段 --- 保存数据
方法： 实质就是声明在类中的函数 --- 实现功能
实例：
1.声明类Person
class Person:
"""类的说明:人类"""
# 声明两个对象方法，需要使用对象来调用
"""
对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统会自动给self传参）
谁来调用这个方法，self就是谁
"""
def eat(self):
print('self:', self)
print('在吃饭')
def sleep(self):
print('在睡觉')
-
对象的声明
声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法，自动生成的）
对象名 = 类名()类对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名()
对象.属性名
实例
# 1.声明类Person
class Person:
"""类的说明:人类"""
# 声明两个对象方法，需要使用对象来调用
"""
对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统会自动给self传参）
谁来调用这个方法，self就是谁
"""
def eat(self):
print('self:', self)
print('在吃饭')
def sleep(self):
print('在睡觉')
# 2. 声明对象
p1 = Person()
print('p1:',p1)
# 一个类可以有多个对象
p2 = Person()
print('p2:',p2)
# 对象可以调用对象方法
p1.eat()
p2.eat()
p1.sleep()
p2.sleep()
3.对象属性的声明
对象属性的声明
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
def run(self, n):
print(self.name)
print(n)
# 注意：构造方法中的参数，实质是传给init方法的参数的
p1 = Person('yuting', 18)
p1.run(100)
# 通过对象使用对象属性
print(p1.name, p1.age, p1.sex)
p2 = Person('女神', 30)
print(p2.sex, p2.name)
"""通过不同的方式创建对象"""
# 创建对象的时候不给属性赋值
p3 = Person()
p4 = Person('')
4.增删改查
class Dog:
"""狗类"""
def __init__(self, age=0, color='yellow'):
self.age = age
self.color = color
dog1 = Dog(3,'white')
# 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', '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)
# dog2 = Dog()
# print(dog2.name)
# 4.删（删除对象的属性）
"""
方法一： del 对象.属性
注意：删除属性也是删的具体某个对象的属性。不会影响这个类的其他对象
"""
# del dog1.age
# print(dog1.age) # AttributeError: 'Dog' object has no attribute 'age'
# dog1.__delattr__('age')
# print(dog1.age) # AttributeError: 'Dog' object has no attribute 'age'
delattr(dog1, 'color')
# print(dog1.color) # 'Dog' object has no attribute 'color'
"""
练习：声明一个学生类，拥有属性：姓名、性别、年龄。方法：学习
1.声明学生类的对象，声明的时候就给姓名、性别和年龄赋值
2.通过三种方式分别获取姓名、性别和年龄，并且打印
3.给学生对象添加一个属性，电话
4.修改学生的年龄
5.删除学生的性别
"""
class Student:
def __init__(self, name='', age=0, sex=''):
self.name = name
self.sex = sex
self.age = age
def study(self):
print('%s学习' % self.name)
stu1 = Student('小明', 30, '男')
print(stu1.name)
print(stu1.__getattribute__('age'))
print(getattr(stu1, 'sex'))
stu1.tel = '123333'
stu1.age = 35
del stu1.sex
stu1.study()
5.类中的方法
-
属性
a.对象属性： 属于对象的，不同对象对应的值可能不一样(对象属性，通过对象来使用)
b.类的字段: 声明在类里面，函数外面。类的属性属于类(类的字段，通过类来使用)
-
方法（对象方法(方法)、类方法、静态函数）
对象方法：自带一个self参数，一般要通过对象去调用
类方法：1.使用@classmethod修饰
2.自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3.类方法要通过类来调用
静态方法：1.使用@staticmethod修饰
2.没有默认参数
3.静态方法要通过类来调用
-
如何选择方法：
怎么选择用对象方法、类方法、静态方法？
i如果实现函数的功能需要使用对象的属性，就声明成对象方法；如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法
如果实现函数功能既不需要对象的属性也不需要类的字段，就声明成静态方法
易竹小居士.jpg
