day13-面向对象
2024-10-08 18:41:39
#解决同一类问题，使用面向对象的思想。类是制造对象的模具，类是抽象的，我们能知道它有哪些属性（name,age,saraly），但不知道具体的属性值。
#看下面代码：类Penson制造了实例化对象ret，它有具体的属性值。
# 一、
class Penson: #类名首字母大写。这里Penson或Penson()都可以。
job = 'programmer' #类属性(静态属性) def __init__(self,*args): #这四行代码是属性，__init__是初始化方法，self是空字典，args是必须传参数的元组。__init__方法让属性接收传入的参数。
self.name = args[0] #self增加属性(添加键值对)。
self.age = args[1]
self.saraly = args[2] #self返回给Penson,而ret = Penson,所以ret = Penson = self。 def func(self,n): #这两行代码是方法。
print('{},{}岁，年收入{}万，每天学习最少{}个小时'.format(self.name,self.age,self.saraly,n)) #类名.属性名 调用属性：self.name ret = Penson('xiaoming',30,80) #此操作是实例化，ret是实例化对象。如果类Penson没有__init__方法，就不需要传参：ret = Penson()就可以了。
ret.func(2) #调用方法。对象名.方法名(参数)相当于类名.方法名(实例化对象,参数)：Penson.func(ret,2) 。结果是：xiaoming,30岁，年收入80万，每天学习最少2个小时
ret = Penson('tom',20,10)
ret.func(3) #结果是：tom,20岁，年收入10万，每天学习最少3个小时
#面向对象的好处：方便增加人物、代码精简、方便修改。
print(Penson.job) #查看类属性
print(ret.job) #查看类属性
print(ret.name) #查看属性
print(ret.age) #查看属性
print(ret.saraly)#查看属性
print(ret.__dict__) #查看所有属性，结果是{'name': 'tom', 'age': 20, 'saraly': 10},除了类属性：job = 'programmer'。
ret.name = 'marry' #修改属性
print(ret.name) #marry # 二、验证self是字典、ret = self：
class Penson:
def __init__(self,name):
print(self.__dict__) #结果是{}
self.name = name
print(self.__dict__) #结果是{'name': 'xiaoming'},证明self是字典。
print(id(self.__dict__)) #
def func(self,n):
print('{},32岁，年收入100万，每天学习最少{}个小时'.format(self.name,n))
ret = Penson('xiaoming')
ret.func(3)
print(id(ret.__dict__)) #8376656，ret.__dict__和self.__dict__地址一样，证明ret = self。 # 三、练习：传入不同的半径，计算面积和周长：
from math import pi
class Math:
def __init__(self,r):
self.r = r
def areas(self):
print('面积是{}'.format(pi*self.r**2))
def perimeter(self):
print('周长是%s,%s'%(self.r*2*pi,self.r))
ret = Math(2)
ret.areas()
ret.perimeter()
ret = Math(1)
ret.areas()
ret.perimeter() # 四、命名空间：类的命名空间讲述的是对象的类属性修改或重新赋值之后，对类属性的影响。
#数字，字符串，布尔都是不可变数据类型
#1.不可变数据类型：重新赋值是单独的。
class Penson:
job = 'programmer' #'programmer'是字符串，是不可变数据类型。类属性(静态属性、静态变量)存在于类的命名空间当中。
def __init__(self,*args):
self.name = args[0]
self.age = args[1]
self.saraly = args[2]
def func(self,n):
print('{},{}岁，年收入{}万，每天学习最少{}个小时'.format(self.name,self.age,self.saraly,n))
ret = Penson('xiaoming',30,80)
ret1 = Penson('tom',30,80)
print(Penson.job) #programmer
print(ret.job) #programmer
print(ret1.job) #programmer
ret1.job = 'teacher' #字符串无法修改，此操作是重新赋值，相当于增加新的类属性（新对象）
print(Penson.job) #programmer
print(ret.job) #programmer
print(ret1.job) #teacher
del ret1.job #删除ret1的类属性，它的类属性变回‘programmer’
print(Penson.job) #programmer
print(ret.job) #programmer
print(ret1.job) #programmer #2.可变数据类型：修改是共享的，重新赋值是单独的。
#2.1 修改是共享的：
class Penson:
job = ['programmer'] #列表是可变数据类型。
def __init__(self,*args):
self.name = args[0]
self.age = args[1]
self.saraly = args[2]
def func(self,n):
print('{},{}岁，年收入{}万，每天学习最少{}个小时'.format(self.name,self.age,self.saraly,n))
ret = Penson('xiaoming',30,80)
ret1 = Penson('tom',30,80)
print(Penson.job) #['programmer']
print(ret.job) #['programmer']
print(ret1.job) #['programmer']
ret1.job[0] = 'teacher' #修改ret1的类属性，没有增加新属性。
print(Penson.job) #['teacher']
print(ret.job) #['teacher']
print(ret1.job) #['teacher']
del ret1.job[0] #删除ret1的类属性，Penson、ret、ret1的类属性变成空列表[]
print(Penson.job) #[]
print(ret.job) #[]
print(ret1.job) #[] #2.2 重新赋值是单独的：
ret = Penson('xiaoming',30,80)
ret1 = Penson('tom',30,80)
print(Penson.job) #['programmer']
print(ret.job) #['programmer']
print(ret1.job) #['programmer']
ret1.job = ['teacher'] #重新赋值，相当于增加新属性，新属性是ret1自己的，没共享给Penson和ret.
print(Penson.job) #['programmer']
print(ret.job) #['programmer']
print(ret1.job) #['teacher']
del ret1.job #删除ret1的类属性，ret1的类属性变回['programmer']
print(Penson.job) #['programmer']
print(ret.job) #['programmer']
print(ret1.job) #['programmer'] #3.1 练习：数字是不可变数据类型
class Family:
money = 0
mother = Family()
father = Family()
mother.money += 1000
father.money += 1000
print(mother.money) #1000,妈妈的钱进了自己的账。因为mother在自己的命名空间当中创建了新的属性。
print(father.money) #1000,爸爸的钱也进了自己的账。
print(Family.money) #家庭进账是0，因为mother、father、Penson是不同的命名空间。参考下面代码： class Family:
money = 0
def work(self):
Family.money += 1000 #类属性(静态属性、静态变量)存在于类的命名空间当中
mother = Family()
father = Family()
mother.work()
father.work()
print(mother.money) #
print(father.money) #
print(Family.money) # #3.2 练习：创建一个类，每实例化一个对象就计数，最后所有对象都共享这个数据。
class Penson:
count = 0
def __init__(self):
Penson.count += 1 #类属性(静态属性、静态变量)存在于类的命名空间当中
func1 = Penson() #一调用Penson就启动__init__方法。
func2 = Penson()
print(func1.count) #
print(func2.count) #
func3 = Penson()
print(func1.count) #
print(func2.count) #
print(func3.count) # #五.在类的外面进行属性的增删改查：
class Penson:
a = 100000
def __init__(self):
self.money = 0
poor = Penson()
print(poor.money) #
poor.rmb = 8000000 #增加新属性:对象增加新属性，Penson没有这个属性。
print(poor.rmb) #8000000 ，查看属性
print(poor.__dict__) #{'money': 0, 'rmb': 8000000}，查看除了类属性之外的所有属性，类属性是a = 100000。
del poor.money #删除属性
print(poor.__dict__) #{'rmb': 8000000}
poor.rmb = 10000000 # 修改属性
print(poor.__dict__) #{'rmb': 10000000}
print(poor.a) # #六：练习：人狗大战：
# 1.面向对象的交互(Penson类里面有Dog类的对象，Dog类里面有Penson类的对象)
# 2.组合：对象属性是另外一个类的对象。
class Penson:
def __init__(self,name,aggr,hp): #姓名、攻击力、血
self.name = name
self.aggr = aggr
self.hp = hp
self.money = 0
def attack(self,dog): #定义攻击技能。
dog.hp -= self.aggr #人攻击狗，狗掉血。狗掉的血等于人的攻击力。另外一个类的对象属性dog.hp可以在本类当中修改。
def get_weapon(self,weapon): #定义得到装备技能。调用此技能，就可以得到装备。
if self.money > weapon.money: #得到装备之前，要判断人的钱是否多于装备的钱
self.money -= weapon.money
self.weapon = weapon #增加装备属性(得到装备)。组合：对象属性是另外一个类的对象。
else:
print('余额不足，请先充值') class Dog:
def __init__(self,name,aggr,hp):
self.name = name
self.aggr = aggr
self.hp = hp
def bite(self,penson):
penson.hp -= self.aggr #狗咬人，人掉血。 class Weapon:
def __init__(self,name,aggr,count,money):
self.name = name
self.aggr = aggr
self.count = count #装备可用的攻击次数
self.money = money
def att(self,dog):
if self.count >0: #攻击狗之前，要先判断装备的攻击次数是否大于0
dog.hp -= self.aggr
self.count -= 1
else:
print('装备可用的攻击次数为0') alex = Penson('alex',20,10)
alex.money = 1000 #充值
jin = Dog('jin',200,50)
w = Weapon('打狗棒',10,3,900)
alex.attack(jin)
print(jin.hp) #50-20=30
alex.get_weapon(w) #调用装备，得到装备。把w传给Penson类里面def get_weapon(self,weapon)这句代码的weapon.
alex.weapon.att(jin) #使用装备攻击狗。因为在Penson类里面，self.weapon = weapon,对象属性是另外一个类的对象，所以alex.weapon.att(jin)相当于w.att(jin)，调用Weapon类的att技能。
#因为w.att(jin)装备攻击狗，不符合逻辑，而人调用装备，得到装备，使用装备攻击狗才是符合逻辑的，所以要想办法把w传给人，那么，人增加对象属性就可以了:self.weapon = w。
print(jin.hp) #30-10=20
jin.bite(alex)
print(alex.hp)
#人调用装备--得到装备--利用装备的技能攻击狗：
def get_weapon(self,weapon): #定义调用装备技能
self.weapon = weapon # 得到装备
alex.get_weapon(w) #人调用装备--装备传入给人
alex.weapon.att(jin) #利用装备的技能攻击狗 #七.组合：对象属性是另外一个类的对象,这样就可以调用另外一个类的对象方法了。反过来，对象方法可以被另外一个类的对象属性引用。
from math import pi
class Math:
def __init__(self,r):
self.r = r
def areas(self):
return pi*self.r**2
def perimeter(self):
return 2*pi*self.r class Circle:
def __init__(self,outside_r,inside_r):
self.outside_c = Math(outside_r) #组合：对象属性是另外一个类的对象。
self.inside_c = Math(inside_r)
def areas(self):
return self.outside_c.areas()-self.inside_c.areas() #调用另外一个类的对象方法 c = Circle(20,10)
print(c.areas()) #八.在类的内部操作类属性：
class Goods:
discount = 0.8
def price(self, goods, price):
print('{}的折后价是{}元'.format(goods,int(price * Goods.discount))) #Goods.discount类名.类属性才可以操作。 g = Goods()
g.price('苹果', 5) #苹果的折后价是4元
最新文章
- es-redis
- SqlServer时间格式化
- 64位centos下安装python的PIL模块
- iOS10 UI教程基改变视图的外观与视图的可见性
- Leetcode: Number of Boomerangs
- python2.7.6 , setuptools pip install, 报错：UnicodeDecodeError:'ascii' codec can't decode byte
- document.body、document.documentElement和window获取视窗大小的区别
- bzoj1079
- jQuery.access源码分析
- firefox无法使用yslow的解决方案
- Python 字典和json的本质区别（个人理解）
- 比MySQL快6倍 深度解析国内首个云原生数据库POLARDB的“王者荣耀”
- python装饰器的详细解析
- Socket入门笔记 用TcpClient实现一个简易聊天室
- VMware虚拟机里centos7下安装mysql5.6并授权远程连接Navicat
- Android DevArt3：SingleTask启动模式探究:首先从MainActivity启动案例入口AActivity，并在A中启动BActivity，从B启动CActivity， 再从C中又启动AActivity， 最后在A中启动B，现在按两次back键，然后回到的是哪个Activity？ 答案是，回到MainActivity。
- Linux架构和目录-基础篇
- YBT 5.2 树形动态规划
- 利用jquery mobiscroll插件选择日期、select、treeList的具体运用
- Android中include标签的使用（打开引用布局，隐藏当前布局）