迭代器和生成器
生成器：可以看成是一个可以存储多个数据的容器，需要数据的时候
生成一个。里面的数据只能从前往后一个一个生成，不能跳跃，也不饿从后往前
生成后的数据不能再生成
获取生成器里面的数据需要使用__next__()方法
只要在函数申明中有yield关键字，函数就不再是一个单独的函数
而是变成一个生成器-保存一个有规律的容器
和列表比较：列表存数据，一个数据会占一定的内存空间
生成器存数据，存的是产生数据的算法
def xu_lie(n):
pre_1 =1
pre_2 =1
for x in range(1,n+1):
if x ==1 or x==2:
curent=1
yield curent
continue
curent =pre_1+pre_2
pre_1,pre_2=pre_2,curent
# print(curent)
yield curent
xulie = xu_lie(10)
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())
1
1
2
3
if __name__ == '__main__':
list1 = [12,23,4,5,56]
x = (i for i in list1)
# x就是一个生成器，用来产生数据
print(x.__next__())
print(x.__next__())
y = (j for j in range(10) if j%2==0)
print(y.__next__())
print(y.__next__())
print(y.__next__())
12
23
0
2
4
def fun(n):
if n ==1:
a = 1
return a
yield a
print(fun(1))
<generator object fun at 0x7f747ba46360>
def list_d(n):
x =0
while x<=n:
yield x
x +=1
lis = list_d(10)
print(lis.__next__())
print(lis.__next__())
0
1
面向对象
1.什么是类：对拥有相同属性和方法的对象的封装
2.什么是对象：对象就是类的实例
3.面向对象编程
面向过程编程：一步一步的写代码实现功能--工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数 工具：函数
面向对象编程：面对问题考虑相应的对象来解决问题-->类和对象
4.类的申明
class 类名:
属性
方法
class 类名(父类)
类名：标识符，类名首字母大写，驼峰式名 MySum
类名():类要继承自其它的类，括号里面是父类的名字
属性：对象属性和类的字段--保存数据
方法：申明在类中的函数---实现功能
class Person:
"""
类的说明
"""
创建方法时，默认有参数self，通过对象调用时不用传参
系统会自动传一个参数，哪个对象调用方法，self就是指向那个对象
的地址
def eat(self):
print('在吃饭')
print(self)
def sleep(self):
print('(:3[▓▓]快醒醒开学了')
if __name__ == '__main__':
# 申明对象
# 对象名=类名()
#通过类的构造方法去创建对象,构造方法（名字和类名同名的方法）
a = Person()
print(a)
a.eat()
a.sleep()
#类对象可以同.使用类中申明的方法和属性
#对象.方法() 对象.属性名
对象的属性
# 对象属性的申明
'''
class 类名:
def __init__(self):
self.属性名1 = 初值1
self.属性名2 = 初值2
'''
class Person:
# init方法时系统自带的一个方法，这个方法不能直接调用
# 通过类创建对象的时候，系统会自动调用这个方法
# init方法的作业是对对象的属性进行初始化
# 通过构造方法创建对象的时候一定要保证init方法中除了self外，其他的每个参数都必须有值
def __init__(self,name,age,sex):
# 在init中申明对象的属性
# print('aaa',name)
self.name = name
self.age = age
self.sex = sex
#类的对象属性，需要通过对象来使用
if __name__ == '__main__':
# 构造方法的参数实质是传个init方法的参数的
a = Person('付波','24','男')
print('%s是个%s的单身%s'%(a.name,a.age,a.sex))
#对象增删查改
"""__author__== God"""
class Dog:
def __init__(self,species,color,age=3):
self.species = species
self.color = color
self.age = age
if __name__ == '__main__':
# 查，如果属性不存在 报错
dog1 = Dog('德牧','黑背','2')
print('my god is%s,it\'s color '
'is %s,and it\'s%s yeras old'%(dog1.species,dog1.color,dog1.age))
# 其他查看属性的方法
# 对象.__getattribute__('属性名')
# getattr(对象名,'属性名')
print(dog1.__getattribute__('age'))
print(getattr(dog1,'age'))
# 修改
dog2 = Dog('金毛','yellwo')
dog2.age = 1
#对象.__setattr__(属性名,'新值')
dog2.__setattr__('species','法斗')
#setattr(对象，属性名，新值)
setattr(dog2,'color','white')
print(dog2.color)
print(dog2.age)
print(dog2.species)
#增加
#属性是添加给对象的，而不是类
dog2.sex = '0'
print(dog2.sex)
#
dog2.__setattr__('food','狗粮')
print(dog2.food)
setattr(dog2,'hobby','sleep')
print(dog2.hobby)
#删除
#删除对象属性
'''
del 对象.属性
删除属性是删除具体某个对象的属性，不会影响类的其他对象
'''
del dog1.age
dog1.__delattr__('species')
delattr(dog1,'color')
练习
class Student:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def study(self):
print('%s study day day up'%self.name)
if __name__ == '__main__':
student1 = Student('李祥',19,'男')
print('学生1的名字是%s，今年%d岁了，单身老%s人'%(student1.name,student1.age,student1.sex))
student1.study()
print(student1.__getattribute__('name'))
print(getattr(student1,'age'))
student1.__setattr__('name','程李明')
print(student1.name)
setattr(student1,'sex','0')
print(student1.sex)
写一个班级类，属性：班级名、学生；功能：添加学生、删除学生、根据姓名查看学生信息，展示班级的所有学生信息
from random import randint
class Student:
def __init__(self,name,age,id,sex):
self.name = name
self.age = age
self.sex = sex
self.id = id
def __str__(self):
return str('name is %s,age is %d,id is %s,sex is %s'%(self.name,self.age,self.id,self.sex))
class Class:
def __init__(self,name='',students=[]):
self.class_name = name
self.students = students
def add_student(self):
name = input('student\'name')
age = input('student\'age')
sex = input('student\'sex')
id = 'py1805'+str(randint(1,100)).rjust(3,'0')
# 根据输入的信息创建学生对象
stu = Student(name,int(age),id,sex)
#添加学生 self得到Class的对象属性
self.students.append(stu)
def check_student(self):
input_info = input('input the student\'s name or id')
for item in self.students:
if input_info == item.name or input_info == item.id:
print(item)
def check_all_student(self):
for item in self.students:
print(item)
def del_student(self):
input_info = input('input the student\'s name or id')
for item in self.students[:]:
if input_info == item.name or input_info == item.id:
self.students.remove(item)
# cls1 = Class('py1805')
# cls1.add_student()
# print(cls1.students[0])
# cls1.check_student()
# cls1.del_student()
# print(cls1.students)
while True:
print('*'*50)
clsone = Class('py1805')
print('1.添加学生\n2.查找学生\n3.删除学生\n4.查看所有学生\nq.退出')
choose = input('>>>')
if choose=='1':
while True:
clsone.add_student()
print('1.继续添加\n2.返回上级')
choose1 = input('>>>')
if choose1 !='1'or choose1=='2':
break
continue
elif choose=='2':
while True:
clsone.check_student()
print('1.继续查看\n2.返回上级')
choose2 = input('>>>')
if choose2 != '1' or choose2 == '2':
break
continue
elif choose =='3':
while True:
clsone.del_student()
print('1.继续删除\n2.返回上级')
choose3 = input('>>>')
if choose3 != '1' or choose3 == '2':
break
continue
elif choose=='4':
while True:
clsone.check_all_student()
print('1.返回上级')
choose4 = input('>>>')
if choose4==1:
break
break
else:
break
slots魔法
class Person(object):
# __slots__=(属性名)的功能：约束类中的属性。使对象只能对()有的属性进行操作
__slots__ = ('name','age','sex')
def __init__(self,name,age):
self.name =name
self.age =age
def __str__(self):
# 自定义对象的打印格式
# id():是Python的内置函数，功能是获取变量的地址
return str(hex(id(self)))
if __name__ == '__main__':
p1 = Person('李祥',20)
p1.name = '猪打野'
p1.sex = '男'
print(p1.name)
print(p1.sex)
print(p1)
p2 = Person('d4lx',20)
print(p2)
类中方法
'''
属性：对象的属性、类的属性(类的字段)
对象属性的特点：属于对象的,不同的对象对应的值可能不一样(通过对象来使用)
类的字段：申明在类中，函数外面。类属性属于类(类的字段，通过类来使用)
方法：对象方法(方法)、类方法、静态函数
对象方法：自带一个self参数，一般通过对象调用
类方法：@classmethod关键字下的函数是类方法
语法：cls是系统自带参数，并且这个参数不用传参
@classmethod
def fun1(cls):
pass
静态函数:使用@staticmethod修饰，没有默认参数，通过类调用
语法：
@staticmethod
def fun2():
pass
静态函数没有默认参数
怎么选择用对象方法、类方法、静态方法
如果实现函数的功能需要使用对象的属性，就申明成对象方法
如果实现函数的功能需要使用类的字段，或者调用类的方法，就声明成类方法
如果实现函数的功能既不需要对象的属性，也不需要类的字段，就申明成静态方法
class Person:
# number是类字段,只能通过类使用 Person.number
number = 0
@classmethod
# cls指向的是调用这个方法的类，cls可以当成类来使用
def hurt_earth(cls,name):
print('%s最牛逼。。。。'%name)
pt = cls('张三')
# 使用cls创建对象
print(pt.name)
print(cls.number)
#可以通过cls使用类的字段
@classmethod
def fun1(cls):
print('天下第一。')
@staticmethod
def fun2():
print('吹牛逼。')
def __init__(self,name='',age=0):
# name和age都是对象属性
self.name = name
self.age = age
# 对象方法
def eat(self,food):
print('%s在吃%s'%(self.name,food))
if __name__ == '__main__':
# 类的字段通过类来使用
print(Person.number)
# 对象的属性通过对象使用
print(Person().name)
p1 = Person('aa',18)
# 对象调对象方法
p1.eat('shit')
print(Person('bb',18).eat('shit'))
# 类调用类方法
Person.hurt_earth('老子')
Person.fun1()
# 静态方法通过类来调用
Person.fun2()
# pycharm快捷键 ctrl+r-->查找替换
# Ctrl+f-->查找
