ed': 300, 'playerAttack':
<function Fighter.<locals>.playerAttack at 0x00000000027A8A60>}
print(Monster1) #{'name': 'Monster1', 'atk': 100, 'hp': 200, 'speed': 150, 'kind': 'Monster', 'enemyFighterAttack':
<function EnemyFighter.<locals>.enemyFighterAttack at 0x0000000002138E18>}
playerFighter2['playerAttack'](Monster1) #Monster1被Player2攻击了,损失了150HP!
print(Monster1) #{'name': 'Monster1', 'atk': 100, 'hp': 50, 'speed': 150, 'kind': 'Monster', 'enemyFighterAttack':
<function EnemyFighter.<locals>.enemyFighterAttack at 0x00000000027A8E18>}
像上面Fighter和EnemyFighter函数都是定义了一类事物,直到我们调用了函数,赋值了之后才真的有了一个实实在在的事物
面向对象、面向过程、面向函数
面向对象:把整个任务封装成一个大的类,在这个类里面详细地分解执行每个步骤,只需要执行类就可以完成任务。优点是解决了程序的扩展性，对某一个对象单独修改，会立刻反映到整个体系中,比如对一个游戏中的一个人物参数的特征和技能修改都很容易。缺点是可控性差无法像面向过程的程序设计流水线式,可以很精准得预测问题的处理流程和结果,面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预知结果。因此经常我们可以看到一个新角色出现在遊戲時会出现影响游戏平衡和玩家游戏体验的场景。
面向过程:就是程序按照步骤一个一个地去执行。优点在于极大得降低了写程序的复杂难度,只要顺着要执行的步骤堆叠代码就好；
缺点是一套流水线或者流程就是解决一个问题,代码牵一发而动全身。
面向函数:就是将编程分成很多种情况,把每一种情况写成一种函数,然后要按步骤执行函数完成。
类
class Cat:
def __init__(self,*args):
self.name = args[0]
self.height = args[1]
self.weight = args[2]
self.type = args[3]
实例化一个对象再去查看它的内部属性(用法:对象名.属性名)
cat1 = Cat('jackey',20,45,'cat') #实例化一个对象
print(cat1.name) #jackey
print(cat1.height) #20
print(cat1.weight) #45
print(cat1.type) #cat
也可以用实例化名.__dict__[属性名]的方法查看属性
print(cat1.__dict__['name']) #jackey
print(cat1.__dict__['height']) #20
print(cat1.__dict__['weight']) #45
print(cat1.__dict__['type']) #cat
利用self.__dict__查看属性
class Cat:
def __init__(self,*args):
print(self.__dict__) #{} 当我们还没加入属性时,self没有内容
self.name = args[0]
self.height = args[1]
self.weight = args[2]
self.type = args[3]
print(self.__dict__) #{'name': 'jackey', 'height': 20, 'weight': 45, 'type': 'cat'}
cat1 = Cat('jackey',20,45,'cat') #实例化一个对象
print(cat1.__dict__) #{'name': 'jackey', 'height': 20, 'weight': 45, 'type': 'cat'}
__init__()中的参数self可以理解为一个字典,即一个对象,它把后面的属性name、height、weight等都存在了这个self'字典'中,再把每一个属性和它对应的值都交给我们实例化的对象
class Cat:
def __init__(self,*args):
self.name = args[0]
self.height = args[1]
self.weight = args[2]
self.type = args[3]
print(self,id(self)) #<__main__.Cat object at 0x00000000025B1DD8> 39525848
cat1 = Cat('jackey',20,45,'cat') #实例化一个对象
print(cat1,id(cat1)) #<__main__.Cat object at 0x00000000025B1DD8> 39525848
可以从执行结果看出来它们共用的是同一个内存地址
查看一个类函数内部的静态属性(用法:类名.静态属性)和调用方法(用法:对象名.方法名()):
class Cat:
Rose = 'cat' #静态属性
def __init__(self,*args):
self.name = args[0]
self.height = args[1]
self.weight = args[2]
self.type = args[3]
def Eat(self):
print('吃点什么...')
cat1 = Cat('jackey',20,45,'cat') #实例化一个对象
print(Cat.Rose) #cat
cat1.Eat() #吃点什么...
类名.__dict__
实例化名.__dict__它存储的是self里面的属性
而类名.__dict__它存储的是这个类中的所有名字
print(Cat.__dict__) #{'__module__': '__main__', '__init__': <function Cat.__init__ at 0x0000000002588950>, 'Eat': <function Cat.Eat at 0x0000000002588A60>, '__dict__': <attribute '__dict__' of 'Cat' objects>, '__weakref__': <attribute '__weakref__' of 'Cat' objects>, '__doc__': None}
print(cat1.__dict__) #'name': 'jackey', 'height': 20, 'weight': 45, 'type': 'cat'}
执行流