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
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__())
2.认识面向对象
1.什么是类:对拥有相同属性和方法的对象的封装
类是抽象的
类中相同的属性的值是不能确定的
2.什么是对象:对象就是类的实例
对象是具体的
对象的属性是确定的
如果说人是一个类,那么余婷就是一个对象
如果说电脑是一个类,我桌上的这台mac就是一个对象
3.面向对象编程
面向过程编程:一步一步的写代码实现功能 --> 工具:逻辑和算法
函数式编程:面对问题考虑有没有拥有某种功能的函数 --> 工具:函数
面向对象编程:面对问题考虑有没有相应的对象来解决这个问题 --> 工具:类和对象
3.类的声明
class 类名(父类):
属性
方法
class:Python中声明类的关键字
类名:标识符,类名首字母大写,驼峰式命名
():类要继承自其它的类,需要写括号,括号里面是父类名
属性:对象属性和类的字段 --- 保存数据
方法:实质就是声明在类中的函数 --- 实现功能
3.1.声明一个类Person
class Person:
"""
类的说明:人类
"""
# 声明对象方法,需要使用对象来调用
# 对象方法默认都有一个参数self,在调用方法的时候,不用传参(系统会自动给self传参)
# 谁来调用这个方法,self就是谁
def eat(self):
print('在吃饭')
def sleep(self):
print('在睡觉,(¦3[▓▓] 晚安')
3.2.声明对象
通过类的构造方法去创建对象(名字和类名同名的方法就是构造方法,自动生成)
对象名 = 类名()
类的对象可以通过点语法使用类中声明的对象方法和属性
对象.方法名()
对象.属性名
per1 = Person()
print(per1)
per1.sleep()
per1.eat()
# 一个类可以有多个对象
per2 = Person()
print(per2)
per2.eat()
4.对象的属性
4.1对象属性的声明
class 类名:
def init(self):
self.属性名 = 初值
self.属性名2 = 初值2
class Person:
"""人类"""
"""
a.init方法是系统自带的一个方法,这个方法不能直接调用,通过类创建对象的时候,系统会自动调用这个方法
init方法的作用是对对象属性进行初始化
b.通过构造方法创建对象的时候,一定要保证,init方法中除了self外,其它的参数都必须有值
"""
def __init__(self, name1='', age1=0, sex1='男'):
# 在这个地方声明对象的属性
# print(name1)
# print('====')
# 在init方法中声明对象的属性
"""
name、age和sex就是Person这个类的对象属性。类的对象属性,需要通过对象来使用
"""
self.name = name1
self.age = age1
self.sex = sex1
if __name__ == '__main__':
# 注意:构造方法中的参数,实质是传给init方法的参数
p1 = Person('xxx', 18)
# 通过对象使用对象属性
print(p1.name, p1.age, p1.sex)
p2 = Person('骆浩', 33, '男')
print(p2.name, p2.age, p2.sex)
# 创建对象的时候可以不给属性赋值
p3 = Person()
p4 = Person(sex1='女')
5.对象属性的增删改查
class Dog:
"""狗类"""
def __init__(self, age1=0, color1='yellow'):
self.age = age1
self.color = color1
5.1.查(获取属性)
"""
方法一:对象.属性(如果属性不存在,会报错)
方法二:对象.__getattribute__(属性名) 和 getattr(对象名, 属性)
"""
print(dog1.age, dog1.color)
print(dog1.__getattribute__('age'))
print(getattr(dog1, 'age'))
# 如果设置了default的值,那么当属性不存在的时候不会报错,并且返回默认值
print(getattr(dog1, 'abc', None))
5.2.改(修改属性的值)
"""
方法一:对象.属性 = 新值
方法二:对象.__setattr__(属性名, 新值)和setattr(对象名, 属性名, 新值)
"""
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color', 'black')
print(dog1.color)
setattr(dog1, 'color', 'blue')
print(dog1.color)
5.3.增
"""
方法一:对象.属性 = 值(属性不存在,就是天津)
注意:属性是添加给对象的,而不是类的
"""
dog1.name = '大黄'
print(dog1.name)
# dog2 = Dog()
# print(dog2.name)
dog1.__setattr__('type', '哈士奇')
print(dog1.type)
setattr(dog1, 'sex', '公')
print(dog1.sex)
5.4删(删除对象属性)
"""
方法一:del 对象.属性
方法二:__delattr__(属性名)和delattr(对象名, 属性名)
注意:只是删除对象的属性,不会影响到类的其它对象
"""
del dog1.age
# print(dog1.age) # AttributeError: 'Dog' object has no attribute 'age'
dog1.__delattr__('sex')
# print(dog1.sex)
delattr(dog1, 'type')
# print(dog1.type)
练习
"""
练习:声明一个学生类,拥有属性:姓名、性别、年龄。方法:学习
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('xxx', '男', 18)
stu1.study()
print(stu1.name)
print(stu1.__getattribute__('sex'))
print(getattr(stu1, 'age'))
stu1.tel = '123'
print(getattr(stu1, 'tel'))
setattr(stu1, 'id', '111')
print(stu1.id)
stu1.age = 22
print(stu1.age)
setattr(stu1, 'id', '222')
print(stu1.id)
del stu1.sex
# delattr(stu1, 'sex')
6.slots魔法
功能:就是约束类中的对象属性
class Person:
"""人类"""
# __slots__的功能:就是约束类中的对象属性
__slots__ = ('name', 'age', 'sex', 'id')
def __init__(self, name='', age=0):
self.name = name
self.age = age
# self.tel = 123 # AttributeError: 'Person' object has no attribute 'tel'
# 自定义对象的打印格式
def __str__(self):
return 'name:%s age:%d address:0x%x' % (self.name, self.age, id(self))
if __name__ == '__main__':
p1 = Person('xx', 20)
# p1.names = 'aa' # AttributeError: 'Person' object has no attribute 'names'
# p1.sex = '男'
print(p1)
7.类中的方法
属性:对象的属性、类的属性(字段)
对象属性:属于对象的,不同对象对应的值可能不一样(对象属性通过对象来使用)
类的字段:声明在类里面,函数外面。类的属性属于类(类的字段,通过类来使用)
方法:对象的方法、类方法、静态函数
对象方法:自带一个self参数,一般要通过对象去调用
类方法:1.使用@classmethod修饰
2.自带一个cls参数,并且这个参数不用传参,谁来调用cls就指向谁
3.类方法要通过类来调用
静态函数:1.使用@staticmethod修饰
2.没有默认参数
3.静态方法要通过类来调用
怎么选择用对象方法、类方法、静态方法?
对象方法:如果实现函数的功能需要使用对象的属性,就声明成对象方法
类方法:如果实现函数的功能需要使用类的字段,或者调用类的方法,就声明成类方法
静态方法:如果实现函数功能即不需要对象属性,也不需要类的字段,就声明成静态方法
补充:ctr + r --> 查找替换
ctr + f --> 查找
class MyPerson:
"""人类"""
# number是类字段(人类的数量)
number = 0
def __init__(self, name='', age=0):
self.name = name
self.age = age
# eat方法是对象方法
def eat(self, food):
print('%s在吃%s' % (self.name, food))
@classmethod
def hurt_earth(cls):
# cls指向的是调用这个方法的类,使用cls可以当成类来使用
pt = cls('张三') # 可以使用cls创建对象
print(pt.name)
print(pt.number) # 可以通过cls使用类的字段
print('人类破坏环境')
#protect_earth是一个静态方法
@staticmethod
def protect_earth():
pt = MyPerson()
print(pt.number)
print('人类保护地球')
if __name__ == '__main__':
# 1.类的字段要用类来使用
print(MyPerson.number)
# 2.对象的属性通过对象来使用
p1 = MyPerson('xxx', 18)
print(p1.name)
# 3.对象方法用对象调用
p1.eat('面条')
p2 = MyPerson('aaa')
p2.eat('火锅')
# 4.类方法通过类来调用
MyPerson.hurt_earth()
# 5.静态方法通过类来调用
MyPerson.protect_earth()
网友评论