生成器和面向对象
2018-07-31 本文已影响0人
pubalabala
生成器
"""__author__ == Jefferson"""
'''
生成器:
a. 可以看成一个存储多个数据的容器, 需要里面的数据的时候就生成一个, 里面的数据只能从前往后一个一个的生成,
不能跳跃, 也不能从后往前, 生成的数据不会重复生成
b. 获取生成器里面的数据, 需要使用__next__()方法
c. 只要函数中有yield关键字, 函数就不再是一个单纯的函数, 而变成一个生成器
和列表相比: 列表存数据, 数据必须实实在在存在的数据, 一个数据会占一定的内存空间.
生成器存数据, 存的是产生数据的算法, 没有数据占用内存空间
'''
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
if __name__ == '__main__':
#x = (i for i in range(10))
#x就啊是一个生成器, 用来生成数据
x=xu_lie(10)
print(x)
print(x.__next__())
print(x.__next__())
x.__next__()
print(x.__next__())
for i in x:
print(i)
面向对象
- 什么是类: 对拥有相同属性的方法的对象的封装
- 什么是对象: 对象就是类的实例
对象是具体实例
对象的属性是确定的 - 面向对象编程
面向过程编程: 一步一步的写代码实现功能 工具: 逻辑和算法
函数式编程: 面对问题考虑有没有拥有某种功能函数 工具函数
面向对象编程: 面对问题考虑有没有相应的对象来解决这个问题 工具: 类和对象
类的声明
"""__author__ == Jefferson"""
'''
类的声明:
class 类名(父类):
属性
方法
class: python中声明类的关键字
类名: 标识符, 类名的首字母大写, 驼峰式命名
(): 类要继承自其他的类, 需要写括号, 括号里面是父类的名字, 可以省略
属性: 对象属性和类的字段 --- 保存数据
方法: 实质是声明在类中的函数 --- 实现功能
'''
#声明类
class Person:
'''类的说明'''
#声明对象方法, 需要使用对象来调用
#对象方法默认都有一个默认参数self, 在调用方法的时候, 这个参数可以不用传参, 系统会自动传参
#self就是指定谁来调用这个方法
def eat(self):
print('self',self)
print('吃饭( o=^•ェ•)o ┏━┓!')
def sleep(self):
print('self', self)
print('睡觉💤!')
if __name__ == '__main__':
#声明对象
#通过类的构造方法去创建对象(构造方法: 与类名同名的方法就是构造方法, 自动生成)
#对象名 = 类名()
#一个类可以有多个对象
#类对象可以通过点语法使用类中声明的对象的方法和属性
#对象名.方法名()
#对象名.属性名
person1 = Person()
print(person1)
person1.eat()
person1.sleep()
person2 = Person()
person2.eat()
person2.sleep()
对象的属性
"""__author__ == Jefferson"""
class Person:
'''类的说明'''
#构造方法
def __init__(self,name,age):
#在这个地方声明对象的属性
#在init方法中声明对象的属性
#name. age和sex就是Person这个类的对象属性, 类的对象属性需要通过对象来使用
print('===')
print(name)
self.name = name
self.age = age
self.sex = '男'
def eat(self):
print('self',self)
print('吃饭( o=^•ェ•)o ┏━┓!')
def sleep(self):
print('self', self)
print('睡觉💤!')
if __name__ == '__main__':
person = Person('psl',21)
print(person)
person.sex = '女'
print(person.name,person.age,person.sex)
对象的增删查改
"""__author__ == Jefferson"""
class Dog:
'''狗'''
def __init__(self,age = 0, color = 'yellow'):
self.age = age
self.color = color
class Student:
def __init__(self, name = '', sex = '男', age = 0):
self.name = name
self.sex = sex
self.age = age
def study(self):
print('我爱学习, 学习使我快乐')
if __name__ == '__main__':
dog1 = Dog(3,'white')
#查(获取属性) 对象.属性
'''
方法一: 对象.属性(如果属性不存在会报错)
方法二: 对象.__getattribute__(属性名)和getattr(对象, 属性名)
'''
print(dog1.age,dog1.color)
print(dog1.__getattribute__('age'))
print(getattr(dog1,'age'))
#如果设置了default的值,那么当属性不存在的时候不会报错并且返回默认值
print(getattr(dog1,'abc','无名氏'))
#改(修改属性的值) 对象.属性 = 新值
'''
方法一: 对象.属性 = 新值
方法二: 对象.__setatter__(属性名,新值)和 setatter(对象名,属性,新值)
'''
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color', 'black')
print(dog1.color)
setattr(dog1,'color','blue')
print(dog1.color)
#增 对象.属性 = 值(属性不存在)
#注意: 属性是添加到指定对象的,而不是在类中添加该属性
dog1.name = '魏二狗'
print(dog1.name)
#删(删除对象的属性)
'''
方法一: del 对象.属性
方法二:
注意: 删除属性也是删除具体某个对象的属性, 不会影响类的其他对象
'''
#del dog1.age
dog1.__delattr__('age')
'''
练习: 声明一个学生类, 拥有属性: 姓名, 性别, 年龄, 方法: 学习
1. 声明学生类的对象, 声明的时候就给姓名,性别和年龄赋值
2. 通过三种方式分别获取姓名, 性别和年龄, 并且打印
3. 给学生对象添加一个属性: 电话
4. 修改学生的年龄
5. 删除学生的性别
'''
student = Student('魏盼','女',21)
print(student.name,student.sex,student.age)
print(student.__getattribute__('name'),student.__getattribute__('sex'),student.__getattribute__('age'))
print(getattr(student,'name'),getattr(student,'sex'),getattr(student,'age'))
student.tel = '123456678'
print(student.tel)
student.age = 23
print(student.age)
student.__delattr__('sex')
Student.study(student)
slots魔法
"""__author__ == Jefferson"""
class Person:
#__slots__的功能: 约束类中的对象的属性
__slots__ = ('name','age','sex')
def __init__(self, name = '', age = 0):
self.name = name
self.age = age
#self.tel = 1234
#自定义打印的格式
def __str__(self):
return 'name:%s,age:%d,id:0x%x'%(self.name,self.age,id(self))
if __name__ == '__main__':
person1 = Person('小王',20)
person1.name = '老王'
person1.sex = '男'
print(person1)
类中的方法
"""__author__ == Jefferson"""
'''
属性: 对象的属性(属性), 类的属性(类的字段)
对象属性: 属于对象的, 不同对象对应的值可能不一样
类的字段: 声明在类里面, 函数外面, 类的属性属于类(类的字段, 通过类来使用)
方法: 对象方法(方法), 类方法, 静态函数
对象方法: 自带一个self参数, 一般要通过对象去调用
类方法: 使用@classmethod修饰, 自带一个cls参数, 并且这个参数不用传参, 谁来调用这个方法, cls就指向谁
静态方法: 使用@classmethod修饰, 没有默认参数, 静态方法要通过类来调用
'''
class Test(object):
x = 123
def __init__(self):
self.y = 456
def bar1(self):
print('Hello world')
@classmethod
def bar2(cls):
print('Bad world')
@staticmethod
def bar3():
print('====')
def foo1(self):
print(self.x)
print(self.y)
self.bar1()
self.bar2()
self.bar3()
@classmethod
def foo2(cls):
print(cls.x)
#print(cls.y)
#cls.bar1()
cls.bar2()
cls.bar3()
@staticmethod
def foo3(obj):
print(obj.x)
print(obj.y)
obj.bar1()
obj.bar2()
obj.bar3()
t = Test()
t.foo1()
t.foo2()
Test.foo3(t)
'''
结果:
123
456
Hello world
Bad world
====
123
Bad world
====
123
456
Hello world
Bad world
====
'''
# 实例方法可以调用类中的所有属性, 类方法不可调用实例属性和方法, 但可以调用类属性和类方法, 静态方法就是普通的方法, 可以通过实例和类名来调用.
'''
怎样选择对象方法, 类方法, 静态方法?
如果实现函数的功能需要使用对象的属性,就声明成对象方法,
如果实现函数的功能需要使用类的字段或者调用类的方法, 就声明成类方法,
如果实现函数功能既不需要对象的属性, 也不需要类的字段, 就声明成静态方法.
'''
class Person:
#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('张三')
print(pt.name)
print('魏盼不是人类!')
@staticmethod
def protect_earth():
print('魏盼是狗!')
class Students:
def __init__(self, name = '',age = '0',sex = '男'):
self.name = name
self.age = age
self.sex = sex
def __str__(self):
return self.name+','+self.age+','+self.sex
class Class1:
def __init__(self, name = '',students = []):
self.name = name
self.students = students
def addStu(self):
stuName = input('学生姓名:')
stuAge = input('学生年龄:')
stuSex = input('学生性别:')
student = Students(stuName,stuAge,stuSex)
self.students.append(student)
def __str__(self):
return self.name + '学生列表:' + str(self.students)
if __name__ == '__main__':
#类的字段使用类来使用
print(Person.number)
person = Person('魏盼')
#对象的属性通过对象来使用
print(person.name,person.age)
person.eat('shi')
#类方法通过类来调用
Person.hurt_earth()
#静态方法通过类来调用
Person.protect_earth()
c = Class1('一班')
c.addStu()
c.addStu()
for i in c.students:
print(i)
练习
- 声明一个电脑类：
属性：品牌、颜色、内存大小
方法：打游戏、写代码、看视频
a. 创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b. 通过attr相关方法去获取、修改、添加和删除它的属性
"""__author__ == Jefferson"""
class Computer:
def __init__(self,brand = '', color = '黑色', memory = '4G'):
self.brand = brand
self.color = color
self.memory = memory
def play(self):
print('使用内存为%s的%s%s电脑打游戏'%(self.memory,self.color,self.brand))
def code(self):
print('使用内存为%s的%s%s电脑写代码' % (self.memory, self.color, self.brand))
def watch(self):
print('使用内存为%s的%s%s电脑看视屏' % (self.memory, self.color, self.brand))
def __str__(self):
return '品牌:'+self.brand + ' 颜色:' + self.color+' 内存大小:'+self.memory
if __name__ == '__main__':
computer = Computer('神舟',memory='8G')
#通过对象点方式获取属性
print('构造参数:',computer.brand,computer.color,computer.memory)
#通过对象点方式修改属性
computer.brand = '联想'
computer.memory = '4G'
print('通过对象点方式修改后:',computer)
#通过对象点方式添加属性
computer.size = '14寸'
print('通过对象点方式添加尺寸后:',computer,'尺寸:' + computer.size)
#通过对象点方式删除属性
try:
del computer.memory
print('通过对象点方式删除属性后: 尺寸:'+computer.size,computer)
except:
print('\n出现错误!')
computer = Computer('联想', '红色', '8G')
#通过attr相关方法获取属性
print('通过__getattribute__()方法获取构造属性:', computer.__getattribute__('brand'),computer.__getattribute__('color'),computer.__getattribute__('memory'))
print('通过getattr()方法获取构造属性:',getattr(computer,'brand'),getattr(computer,'color'),getattr(computer,'memory'))
#通过attr相关方法修改属性
computer.__setattr__('brand', '戴尔')
computer.__setattr__('color', '白色')
print('使用对象.__setattr__()方法修改属性', computer)
setattr(computer,'brand','神舟')
setattr(computer,'memory','4G')
print('使用setattr()方法修改属性后:',computer)
#通过attr相关方法添加属性
computer.__setattr__('size','14寸')
print('通过__setattr__()添加尺寸:',computer,'尺寸:'+computer.__getattribute__('size'))
setattr(computer,'price', '5900RMB')
print('通过setattr()添加价格:',computer,'尺寸:'+computer.__getattribute__('size'),'价格'+getattr(computer,'price'))
#通过attr相关方法删除属性
try:
computer.__delattr__(computer,'color')
print('通过__delattr__()方法删除属性后:',computer.__getattribute__(computer,'color'))
except:
print('读取颜色出现错误!')
try:
delattr(computer,'memory')
print('通过delattr()方法删除内存属性后:',getattr(computer,'memory'))
except:
print('读取内存错误!')
运行结果:
E:\Python\Python37\python.exe D:/PSL/study/Python/Workplace/train/day12/homework.py
构造参数: 神舟 黑色 8G
通过对象点方式修改后: 品牌:联想 颜色:黑色 内存大小:4G
通过对象点方式添加尺寸后: 品牌:联想 颜色:黑色 内存大小:4G 尺寸:14寸
通过对象点方式删除属性后: 尺寸:14寸
出现错误!
通过__getattribute__()方法获取构造属性: 联想 红色 8G
通过getattr()方法获取构造属性: 联想 红色 8G
使用对象.__setattr__()方法修改属性 品牌:戴尔 颜色:白色 内存大小:8G
使用setattr()方法修改属性后: 品牌:神舟 颜色:白色 内存大小:4G
通过__setattr__()添加尺寸: 品牌:神舟 颜色:白色 内存大小:4G 尺寸:14寸
通过setattr()添加价格: 品牌:神舟 颜色:白色 内存大小:4G 尺寸:14寸 价格5900RMB
读取颜色出现错误!
读取内存错误!
Process finished with exit code 0
- 声明一个人的类和狗的类：
狗的属性：名字、颜色、年龄 狗的方法：叫唤
人的属性：名字、年龄、狗 人的方法：遛狗
a. 创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄
"""__author__ == Jefferson"""
class Dog:
def __init__(self, name = '', color = '', age = '0'):
self.name = name
self.color = color
self.age = age
def yell(self):
print(self.name+': wang! wang! wang!')
class Person:
def __init__(self, name = '', age = '0', dog = Dog()):
self.name = name
self.age = age
self.dog = dog
def walk_dog(self):
print('%s在遛%s!'%(self.name,self.dog.name))
if __name__ == '__main__':
dog = Dog('大黄','黄色','2')
person = Person('小明','21',dog)
person.walk_dog()
运行结果:
小明在遛大黄!
- 声明一个矩形类：
属性：长、宽 方法：计算周长和面积
a. 创建不同的矩形，并且打印其周长和面积
"""__author__ == Jefferson"""
class Rect:
def __init__(self,width = 0, height = 0):
self.width = width
self.height = height
def count(self):
print('宽%s高%s的矩形面积为%s:'%(self.width,self.height,self.width*self.height))
print('宽%s高%s的矩形周长为%s:'%(self.width,self.height,(self.width+self.height)*2))
if __name__ == '__main__':
rect1 = Rect(3,7)
rect2 = Rect(343,645)
rect1.count()
rect2.count()
运行结果:
宽3高7的矩形面积为21:
宽3高7的矩形周长为20:
宽343高645的矩形面积为221235:
宽343高645的矩形周长为1976:
- 创建一个学生类：
属性：姓名，年龄，学号 方法：答到，展示学生信息
创建一个班级类：
属性：学生，班级名 方法：添加学生，删除学生，点名
"""__author__ == Jefferson"""
class Student:
def __init__(self,name = '', number = '0000',age = '0'):
self.name = name
self.age = age
self.number = number
def display(self):
print('学生姓名:',self.name,'\n年龄:',self.age,'\n学号:',self.number)
def answer(self):
print('%s: 到!'%self.name)
class Class:
def __init__(self,students = [], classname = ''):
self.students = students
self.classname = classname
def add_stu(self):
stu_name = input('请输入学生姓名:')
stu_age = input('请输入学生年龄:')
stu_number = input('请输入学号:')
student = Student(stu_name,stu_number,stu_name)
self.students.append(student)
def del_stu(self):
stu_number = input('请输入要删除学生的学号:')
for item in self.students:
if item.number == stu_number:
self.students.remove(item)
print('学生<%s, %s>已删除!'%(item.number,item.name))
break
def call_name(self):
print('%s班开始点名'%self.classname)
for item in self.students:
print('%s!'%item.name)
item.answer()
print('点名完毕!')
if __name__ == '__main__':
cla = Class(classname='Python')
cla.add_stu()
cla.add_stu()
cla.add_stu()
cla.add_stu()
print('%s班学生信息:'%cla.classname)
for item in cla.students:
item.display()
cla.call_name()
cla.del_stu()
cla.call_name()
运行结果:
请输入学生姓名:张三
请输入学生年龄:21
请输入学号:0001
请输入学生姓名:李四
请输入学生年龄:23
请输入学号:0003
请输入学生姓名:王五
请输入学生年龄:23
请输入学号:0002
请输入学生姓名:赵六
请输入学生年龄:20
请输入学号:0005
Python班学生信息:
学生姓名: 张三
年龄: 张三
学号: 0001
学生姓名: 李四
年龄: 李四
学号: 0003
学生姓名: 王五
年龄: 王五
学号: 0002
学生姓名: 赵六
年龄: 赵六
学号: 0005
Python班开始点名
张三!
张三: 到!
李四!
李四: 到!
王五!
王五: 到!
赵六!
赵六: 到!
点名完毕!
请输入要删除学生的学号:0002
学生<0002, 王五>已删除!
Python班开始点名
张三!
张三: 到!
李四!
李四: 到!
赵六!
赵六: 到!
点名完毕!
- 写一个类，封装所有和数学运算相关的功能（包含常用功能和常用值，例如：pi,e等）
"""__author__ == Jefferson"""
import math
class MathMethod:
pi = math.pi
e = math.e
@staticmethod
def add(*number):
result = 0
for item in number:
result += item
return result
@staticmethod
def sub(*number):
result = number[0]*2
for item in number:
result -= item
return result
@staticmethod
def mul(*number):
result = 1
for item in number:
result *= item
return result
@staticmethod
def div(*number):
result = number[0]
for index in range(1, len(number)):
if number[index] == 0:
return '除了第一个数,其余均不能为0!'
result /= number[index]
return result
if __name__ == '__main__':
print('e:',MathMethod.e)
print('pi:',MathMethod.pi)
print('加法:',MathMethod.add(34,24,56))
print('减法:',MathMethod.sub(56,34,2))
print('乘法:',MathMethod.mul(45,34,22))
print('除法:',MathMethod.div(45,34,2))
运行结果:
e: 2.718281828459045
pi: 3.141592653589793
加法: 114
减法: 20
乘法: 33660
除法: 0.6617647058823529
- 写一个班级类，属性：班级名、学生；功能：添加学生、删除学生、根据姓名查看学生信息，展示班级的所有学生信息
"""__author__ == Jefferson"""
class Student:
def __init__(self,name = '', number = '0000',age = '0'):
self.name = name
self.age = age
self.number = number
def display(self):
print('学生姓名:',self.name,'\n年龄:',self.age,'\n学号:',self.number)
def answer(self):
print('%s: 到!'%self.name)
class Class:
def __init__(self,students = [], classname = ''):
self.students = students
self.classname = classname
def add_stu(self):
stu_name = input('请输入学生姓名:')
stu_age = input('请输入学生年龄:')
stu_number = input('请输入学号:')
student = Student(stu_name,stu_number,stu_name)
self.students.append(student)
def del_stu(self):
stu_number = input('请输入要删除学生的学号:')
for item in self.students:
if item.number == stu_number:
self.students.remove(item)
print('学生<%s, %s>已删除!'%(item.number,item.name))
break
def find_name(self):
stu_name = input('请输入学生姓名进行查找')
for item in self.students:
if item.name == stu_name:
item.display()
def display(self):
print('%s班学生信息:' % self.classname)
for item in self.students:
item.display()
if __name__ == '__main__':
cla = Class(classname='Python')
cla.add_stu()
cla.add_stu()
cla.add_stu()
cla.add_stu()
cla.display()
cla.find_name()
cla.del_stu()
cla.display()
运行结果:
请输入学生姓名:张三
请输入学生年龄:21
请输入学号:0003
请输入学生姓名:李四
请输入学生年龄:20
请输入学号:0001
请输入学生姓名:王五
请输入学生年龄:20
请输入学号:0006
请输入学生姓名:张三
请输入学生年龄:23
请输入学号:0007
Python班学生信息:
学生姓名: 张三
年龄: 张三
学号: 0003
学生姓名: 李四
年龄: 李四
学号: 0001
学生姓名: 王五
年龄: 王五
学号: 0006
学生姓名: 张三
年龄: 张三
学号: 0007
请输入学生姓名进行查找张三
学生姓名: 张三
年龄: 张三
学号: 0003
学生姓名: 张三
年龄: 张三
学号: 0007
请输入要删除学生的学号:0003
学生<0003, 张三>已删除!
Python班学生信息:
学生姓名: 李四
年龄: 李四
学号: 0001
学生姓名: 王五
年龄: 王五
学号: 0006
学生姓名: 张三
年龄: 张三
学号: 0007
