面向过程:
- 优点:极大地降低了写程序的复杂度,只需要顺着要执行的步骤堆叠代码即可;
- 缺点:一个流水线的程序只能解决一个问题,应对变化较多的场景,会极大地增加工作量;
- 应用场景:一般用于那种一旦完成就基本很少改变的场景,著名的例子有Linux内核,git,以及Apache HTTP Server等
面向对象:
- 优点:封装性较好,程序的可扩展性较高。对某一个对象进行单独修改,会立刻反映到整个体系中。
- 缺点:可控性差,无法精准的预测问题的处理流程和结果。面向对象的程序一旦开始就由对象之间的交互解决问题。
- 应用场景:经常需求变化的软件,一般需求的变化都集中在应用层,如游戏,企业内部软件,互联网应用等都是面向对象的程序大显身手的好地方
python中,用变量表示特征,用函数表示技能,因而具有相同特征和技能的一类事物就是“类“(即“类“具有相同的变量和函数),对象则是这类事物中的具体一个。
类的两种作用:属性引用和实例化(PS:argument翻译过来是实参,parameter翻译过来是形参)
**
**
关于类的例子和介绍:
class Person(): #定义一个类
role = "person" # 定义类的属性,即人的角色属性为人
def __init__(self,name,aggressivity,life_value):# 在实例化时,自动将对象(即lxl)传给__init__的第一个参数;也可以起别的名字,但是通用的是self,尽量不要改
self.name = name # 由于__init__有四个参数,因此在进行实例化时,除了不用传参数self外;其他三个参数均应定义,将定义的name参数传递给对象的name属性
self.aggressivity = aggressivity #同上
self.life_value = life_value #同上
def walk(self): #方法(动态属性)名为walk,定义一个走路方法,也即定义的一个函数
print("person is walking")#
lxl = Person('lixinglong',80,100) # 类名+()等于执行类中的__init__()函数
print(Person.role) #查看人的属性,print(Person.name)是不合法的,因为Person类并没有定义类的name属性
print(Person.walk) #引用人的走路方法,注意这里不是调用,并不执行walk函数
print(lxl.walk())#调用人的走路方法,这里会执行walk函数,调用方法的语法是:对象名+方法+()
print(lxl.role) #查看对象的role的属性,这种情况下会于Person.role一致
print(lxl.name) #查看对象的属性,使用语法为:对象名.属性名
print(lxl.aggressivity)#同上
print(lxl.life_value)#同上
输出结果:(print(lxl.walk()) 时除了输出person is walking外还会输出一个None,暂时还未找到原理)
person
<function Person.walk at 0x10f979f28>
person is walking
None
person
lixinglong
80
100
将上述的使用class实现的功能使用面向过程的方式来实现就是:
def Person(*args,**kwargs): ## *args为任何多个无名参数,接收参数是一个tuple类型,**kwargs为关键字参数,接收参数是一个dict类型;在同时传递*args和**kwargs参数时,*args参数必须在**kwargs参数前面。
## 此函数中lxl=Person('lixinglong',80,100)未传入关键字参数,即传入了一个只含有三个元素的tuple类型参数
self = {}
def __init__(name,aggressivity,life_value):
self['name'] = name
self['aggressivity'] = aggressivity
self['life_value'] = life_value
def walk():
print('person is walking')
__init__(*args,**kwargs)
return self
lxl = Person('lixinglong',80,100)
print(lxl['name'])
print(lxl['aggressivity'])
print(lxl['life_value'])
#### 输出结果 ####
lixinglong
80
100
同时传递*args 和**kwargs参数:
def Person(*args,**kwargs):
self = {}
def __init__(name,aggressivity,life_value,m):
print(m) ##这种情况就同时传递了*args和**kwargs参数
self['name'] = name
self['aggressivity'] = aggressivity
self['life_value'] = life_value
def walk():
print('person is walking')
__init__(*args,**kwargs)
return self
lxl = Person('lixinglong',80,100,{'name1':'lixinglong','c':3})##传递了tuple类型参数('lixinglong',80,100);##和dict类型参数{'name1':'lixinglong','c':3}
print(lxl['name'])
print(lxl['aggressivity'])
print(lxl['life_value'])
#### 输出结果 ####
{'name1': 'lixinglong', 'c': 3}
lixinglong
80
100
对象之间的交互:
人狗大战的一个简单例子:
class Person(object): #定义一个 Person 类
role = 'person' #角色属性
def __init__(self,name,aggressivity,life_value,money): #初始化该类的属性
self.name = name
self.aggressivity = aggressivity
self.life_value = life_value
self.money = money
def attack(self,dog): #定义该类的动态属性(方法),人可以攻击狗,需要传入被攻击方的 对象(在当前程序中即dog类的实例化)
dog.life_value -= self.aggressivity
class Dog(object): #定义一个 Dog 类
role = 'animal' #角色属性
def __init__(self,name,aggressivity,life_value,breed):#初始化该类的各属性
self.name = name
self.aggressivity = aggressivity
self.life_value = life_value
self.breed = breed
def bite(self,person): #定义该类的动态属性(方法),狗可以咬人,需要传入被咬的对象(当前程序中即person类的实例化)
person.life_value -= self.aggressivity
class Weapon(object): #定义一个 Weapon 类
role = 'weapon' #角色属性
def __init__(self,name,price,aggressivity):#初始化该类的属性
self.name = name
self.aggressivity = aggressivity
self.price = price
def update(self,obj): #定义该类的动态属性(方法),可以被购买,需要传入购买方的对象,购买后人物角色会被更新,即增加攻击力,并扣除人物的金币
obj.aggressivity += self.aggressivity
obj.money -= self.price
def skill(self,obj): #定义该类的另一动态属性(方法),该武器具有技能,可以对其他对象使用,此程序中即person使用weapon的技能攻击dog
obj.life_value = max(0,obj.life_value - 200) #对象被攻击后,生命值下降200,但最小生命值应为0
class Drink(object): #定义一个drink 饮料类
role = 'add the life_value'#角色属性
def __init__(self,name,price,life_value):#初始化该类的属性
self.name = name
self.price = price
self.life_value = life_value
def buying(self,obj): #定义动态属性(方法),即drink被购买,需传入购买对象,以扣除购买对象的金币
obj.money -= self.price
def using(self,obj):#定义动态属性(方法),即drink被使用,需要传入使用的对象,以增加使用对象的生命值
obj.life_value += self.life_value
##### 测试交互 ####
if __name__ == '__main__':
lxl = Person('李兴龙',100,400,1000) #实例化Person类的对象 lxl
xb = Dog('小白',40,200,'大白熊') #实例化Dog类对象 xb
cmao = Weapon('屠龙刀',300,80) #实例化一个武器
drinks = Drink('止痛药',200,40) #实例化饮料
print(lxl.name,lxl.aggressivity,lxl.life_value,lxl.money)#观测初始Person对象的各属性值
print(xb.name,xb.aggressivity,xb.life_value,xb.breed)#观测初始Dog对象的各属性值
if lxl.money >= cmao.price: #如果lxl的金币高于武器的价格,则进行一次购买
cmao.update(lxl) #购买后通过Weapon类的update方法更新人物的相应属性
lxl.weapon = cmao #将Weapon的实例化对象传给lxl.weapon属性,后续就可以通过lxl.weapon来调用Weapon类的方法
else:
print('The money is not enough, please recharge')
print(lxl.name,lxl.aggressivity,lxl.life_value,lxl.money) #观测购买武器后lxl的各属性值
lxl.attack(xb) #lxl攻击了xb一次
xb.bite(lxl) #xb咬了lxl一口
print(lxl.name,lxl.aggressivity,lxl.life_value,lxl.money)
print(xb.name,xb.aggressivity,xb.life_value,xb.breed) #观测两个对象打了一架后的各属性值
if lxl.money >= drinks.price: #如果lxl的金币高于武器的金币,则进行购买,并使用
drinks.buying(lxl)
drinks.using(lxl)
print(lxl.name,lxl.aggressivity,lxl.life_value,lxl.money)#观测lxl购买并使用drinks后的各属性值
lxl.weapon.skill(xb) #lxl不甘心被xb咬了一口,发动weapon的技能攻击了xb
print(xb.name,xb.aggressivity,xb.life_value,xb.breed) #观测被weapon攻击后xb的各属性值
输出:
李兴龙 100 400 1000 #初始时lxl的 攻击力:100 生命值:400 金币:10000
小白 40 200 大白熊 #初始时xb的 攻击力:40 生命值:200
李兴龙 180 400 700 #lxl买了一把屠龙刀后 攻击力:180 生命值:400 金币:700
李兴龙 180 360 700 #lxl跟xb打了一架后 lxl的 攻击力:180 生命值:360 金币:700
小白 40 20 大白熊 #xb跟lxl打了一架后 xb的 攻击力:40 生命值:20
李兴龙 180 400 500 #lxl买了一瓶饮料并使用后 其 攻击力:180 生命值:400 金币:500
小白 40 0 大白熊 #lxl使用屠龙刀砍了xb一刀后,xb的 攻击力:40 生命值:0