01-迭代器和生成器
- 生成器：
a.可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个，里面的数据只能从前往后一个一个的生成
不能跳跃，也不能从后往前。生成过的数据不能再生成了
b.获取生成器里面的数据，需要使用next（）方法，一次只能获取一个
c.只要函数声明中有yield关键字，函数就不再是一个单纯的函数，而是变成一个生成器
和列表比较：列表存数据，数据必须是实实在在存在的数据，一个数据会占一定的内存空间。
生成器存数据，存的是产生数据的算法
# 1，1，2，3，5，8，13，21，34，55....
def func1():
if False:
yield 100
print(100)
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__())
for x in xulie:
print('===',x)
if __name__ == '__main__':
x = (i for i in range(10))
# x就是一个生成器，用来产生数据
print(x)
print(x.__next__())
print(x.__next__())
print('======')
num = 100
print(x.__next__())
print(x.__next__())
02-认识面向对象
- 1.什么是类：对拥有共同属性和功能的对象的封装
类是抽象的 - 2.什么是对象：对象就是类的实例
对象是具体的
对象的属性是确定的
如果说人是一个类，那么小明就是人的一个对象
如果说电脑是一个类，那么我桌上的电脑就是一个对象
如果说杯子是一个类，我桌上的杯子就是一个对象
- 3.面向对象编程
面向过程编程：一步一步的写代码实现功能-->工具：逻辑和算法
函数式编程：面对问题，考虑有没有拥有某种功能的函数-->工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题-->工具：类和对象
03-类的声明
类的声明：
class 类名(父类)：
属性
方法
class：python中声明类的关键字
类名：标识符，类名的首字母大写，驼峰式命名
（）：类如果继承自其他类，需要写括号，括号里面是父类的名字，可以省略
属性：对象属性和类的字段 --- 保存数据
方法：实质就是声明在类中的函数---实现功能
- 1.声明类Person
声明两个对象方法，需要使用对象来调用
对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参，系统会自动给self传参
谁来调用这个方法，self就是谁
class Person:
"""类的说明：人类"""
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法）
对象名 = 类名（）类的对象可以点语法使用类中声明的对象的方法和属性
对象.方法名（）
对象.属性名
if __name__ == '__main__':
# 2.声明对象
p1 = Person()
print(p1)
# 一个类可以有多个对象
p2 = Person()
print(p2)
# 对象可以调用对象方法
p1.eat()
p1.sleep()
04-对象的属性
对象属性的声明
class 类名:
def init(self):
self.属性名 = 初值
self.属性名 = 初值2
- class Person:
"""人类"""
"""
1.init方法是系统自带的一个方法，这个方法不能直接调用，而是通过类创建对象的时候系统自动调用这个方法
init方法的作用是对对象的属性进行初始化
2.通过构造方法创建对象的时候，一定要保证，init方法中，除了self以外，其他的每个参数都必须有值
"""
def __init__(self,name1,age1,sex):
# 在这个地方声明对象的属性
# 在init方法中声明对象的属性
"""
name、age和sex就是Person这个类的对象属性，类的对象属性需要通过对象来使用
"""
self.name = name1
self.age = age1
self.sex = sex
if __name__ == '__main__':
# 注意：构造方法中的参数，实质是传给init方法的参数的
p1 = Person('xzq',18,'男')
# 通过对象使用对象属性
print(p1.name,p1.age,p1.sex)
"""通过不同的方式创建对象"""
# 创建对象的时候不给属性赋值
p3 = Person(1,1,1)
05-对象属性的增删改查
class Dog:
"""狗类"""
def __init__(self,age = 0,color = 'black'):
self.age = age
self.color = color
if __name__ == '__main__':
dog1 = Dog(3,'white')
1.查（获取属性）
"""
方法一：对象.属性（如果属性不存在，会报错）
方法二：对象.__getattribute__(属性名)和getattr(对象，属性名，默认值)
"""
print(dog1.age,dog1.color)
print(dog1.__getattribute__('age'))
print(getattr(dog1,'age'))
# 如果设置了默认值，那么当属性不存在的时候不会报错，并且返回默认值
print(getattr(dog1,'abc','无名氏'))
# 2.改（修改属性的值）
"""
方法一：对象.属性 = 新值
方法二：对象.__setattr__(属性名，新值）和setattr（对象，属性名，值）
"""
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color','yellow')
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)
#
# delattr(dog1,'color')
# print(dog1.color)
print('========')
- 练习
声明一个学生类，拥有属性：姓名，性别，年龄。方法：学习
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)
student1 = Student()
# 方法一：
print(student1.name,student1.sex,student1.age)
# 方法二：
print(student1.__getattribute__('name'),student1.__getattribute__('sex'),student1.__getattribute__('age'))
# 方法三：
print(getattr(student1,'name'),getattr(student1,'sex'),getattr(student1,'age'))
student1.tel = '123456789'
student1.age = 15
del student1.sex
06-slots魔法
class Person:
# __slots__ 的功能：就是约束类中对象的属性。
__slots__ = ('name','age','sex')
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.sex = '男'
print(p1)
p2 = Person('小花',10)
print(p2)
07-类中的方法
属性：对象的属性（属性）、类的属性（类的字段）
对象属性：属于对象的，不同对象对应的值可能不一样（对象属性，通过对象来使用）
类的字段：声明在类里面，函数外面。类的属性属于类（类的字段，通过类来使用）方法：对象方法（方法）、类方法、静态函数
对象方法：自带一个self参数，一般要通过对象去调用
类方法：
1.使用@classmethod修饰
2.自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3.类方法要通过类来调用静态函数：1.使用@staticmethod修饰
2.没有默认参数
3.静态方法要通过类来调用怎么选择用对象方法、类方法、静态方法？
if 如果实现函数的功能需要使用对象的属性，就声明成对象方法
elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法
else 如果实现函数功能既不需要对象的属性也不需要类的字段，就声明成静态方法
补充：ctr + r --> 查找替换
ctr + f --> 查找
class Person:
# number是类字段
number = 61
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()
- 练习：
写一个班级类，属性：班级名、学生；功能：添加学生
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[0])
