现在有个需求，需要制作一个人狗大战游戏
角色
人
基础属性
name
sex
hp
mp
ad
狗
基础属性
name
kind
hp
ad
生成这些角色的属性需要字典
bob = {'name':'bob','sex':'man','hp':10,'mp':10,'ad':1}
dog = {'name':'新新','kind':'金毛','hp':99999,'ad':99999}
如果是多人多狗游戏，我们需要给每个人都创建字典，太麻烦而且字典的key无法固定
所以我们制造一个模子，刻画一个人应该有的属性，固定属性和key值
def Person(name,sex,hp,mp,ad):
info_dic = {'name':name,'sex':sex,'hp':hp,'mp':mp,'ad':ad}
return info_dic
def attack(person,dog):
print('%s攻击了%s'%(person['name'],dog['name']))
dog['hp'] -= person['ad']
def Dog(name,kind,hp,ad):
info_dic = {'name':name,'kind':kind,'hp':hp,'ad':ad}
return info_dic
def bite(dog,person):
print('%s咬了%s'%(dog['name'],person['name']))
person['hp'] -= dog['ad']
alex = Person('alex','man',10,10,0.1)
print(alex)
yuan = Person('yuan','male',100,100,1)
print(yuan)
jin = Dog('新新','金毛',9999,9999)
print(jin)
attack(alex,jin)
print(jin['hp'])
bite(jin,alex)
bite(alex,jin)
上边的例子可以改写成
def Person(name,sex,hp,mp,ad):
person = {'name':name,'sex':sex,'hp':hp,'mp':mp,'ad':ad}
def attack(dog):
print('%s攻击了%s'%(person['name'],dog['name']))
dog['hp'] -= person['ad']
person['attack'] = attack
return person
def Dog(name,kind,hp,ad):
dog = {'name':name,'kind':kind,'hp':hp,'ad':ad}
def bite(person):
print('%s咬了%s'%(dog['name'],person['name']))
person['hp'] -= dog['ad']
dog['bite'] = bite
return dog
alex = Person('alex','man',10,10,0.1)
jin = Dog('新新','金毛',9999,9999)
print(alex)
alex['attack'](jin)
print(jin)
jin['bite'](alex)
通过上边的事例可以发现
面向对象编程
人狗大战
角色分开：人-狗
人的基础属性给人：人模子
狗的基础属性给狗：狗模子
模子：类(抽象的)
框架，不是具体的拥有某些属性值的物体
而是规范一类物体有哪些共同的属性和方法
调用模子得到的结果：对象(具体的值)
根据模子的规范，填上具体的值就是一个对象
python中一切皆对象
类的定义方法：(类只做两件事,实例化对象(对象=类名()),查看类中的属性(类名.(静态/类)属性名())
class 类名(首字母大写):
类体
对象名 = 类名(实例化过程的值)
例子
class Person:
pass
print(Person)
结果
<class '__main__.Person'>
object 对象=类名
例子：
class Person:
pass
a = Person()
print(a)
结果
<__main__.Person object at 0x00000164423AEA90>
class Person:
def __init__(self,name,sex,hp,mp,ad):
#本身就存在的内置方法
#self是一块内存空间
print(name,sex,hp,mp,ad)
bob = Person('bob','man',10,10,0.1)
类名()相当于执行类中的__init__方法
但self与bob有什么关系呢?
class Person:
AAA = 'Linux' #静态属性/类属性(属于类的,所有属于这个类的对象都共这个共同的属性)
def __init__(self,name,sex,hp,mp,ad):
self.name = name #属性，属性对象的值(对象属性)
self.sex = sex
self.hp = hp
self.mp = mp
self.ad = ad
bob(对象) = Person('bob','man',10,10,0.1) #实例化
yuan = Person('yuan','male',100,100,2)
print('bob--->',bob)
# 类 -->实例化-->对象(实例)
print(bob.name)
print(bob.sex)
print(bob.hp)
print(bob.mp)
print(bob.ad)
print('bob,yuan',bob,yuan)
print(Person.AAA,bob.AAA)
结果
bob---> <__main__.Person object at 0x000001D9A3824780>
bob
man
10
10
0.1
bob,yuan <__main__.Person object at 0x000001D9A3824780> <__main__.Person object at 0x000001D9A38247F0>
Linux Linux
调用
class Person:
def __init__(self,name,sex,hp,mp,ad):
self.name = name
self.sex = sex
self.hp = hp
self.mp = mp
self.ad = ad
def attack(self): #动态属性,一个函数在类当中定义函数就是方法,方法自带self参数
print('%s发起了攻击'%self.name)
bob = Person('bob','man',10,10,0.1)
bob.attack() #Person.attack(bob)
结果
bob发起了攻击
对象能够完成的事情
操作对象的属性
调用对象的方法
类:具有相同属性和方法的一类事务(框架 模子)
对象
对象是类中一个具体的例子(拥有具体的属性值和具体的方法)
对象就是类的实例化,类的实例
实例：实例完全和对象是一样的
实例化：是由类创建对象的过程
类名能做什么?
实例化
调用类中的静态属性
实例化的过程: 对象名 = 类名(参数)
1.创建一个属于对象的空间
2.将这个空间的地址和参数传递给__init__方法
3.执行init方法
4.将对象的空间返回给对象名
静态属性: 所有的这个类的对象都共有的属性\
对象能做什么?
调用对象的属性
调用类中的方法(动态属性)
对象的属性: 存储在实例化之后创建的空间中的所有变量都是对象的属性
每一次实例化产生的空间都是独立的,每一个对象都有自己的属性值
动态属性: 定义在类中的函数,自带一个self,就是调用这个方法的对象本身
对象的属性操作
class Person:
def __init__(self,name,sex,hp,mp,ad):
self.name = name
self.sex = sex
self.hp = hp
self.mp = mp
self.ad = ad
def attack(self):
print('%s发起了攻击'%self.name)
class Dog:
def __init__(self,name,kind,hp,ad):
self.name = name
self.kind = kind
self.hp = hp
self.ad = ad
bob = Person('bob',None,10,10,0.1)
jin = Dog('新新','金毛',9999,9999)
print(bob.__dict__)
bob.__dict__['name'] = 'jrey'
print(bob.name)
结果
{'name': 'bob', 'sex': None, 'hp': 10, 'mp': 10, 'ad': 0.1}
jrey
查
print(bob.hp)
改
bob.hp = 99
print(bob.hp)
增
bob.level = 1
print(bob.level)
删
del bob.level
# print(bob.level)
两个类的对象之间的交互
# 人打狗,狗掉血 attack
# 狗咬人,人掉血 bite
class Person: # 类
def __init__(self,name,sex,hp,mp,ad):
self.name = name
self.sex = sex
self.hp = hp
self.mp = mp
self.ad = ad
def attack(self,dog):
print('%s攻击了%s'%(self.name,dog.name))
dog.hp -= self.ad
class Dog:
def __init__(self,name,kind,hp,ad):
self.name = name
self.kind = kind
self.hp = hp
self.ad = ad
def bite(self,person):
print('%s咬人%s'%(self.name,person.name))
person.hp -= self.ad
if person.hp <= 0 :
print('%s死了'%person.name)
person.hp = 0
#实例化一些对象
bob = Person('bob',None,10,10,0.1)
haha = Dog('新新','金毛',9999,998)
print(haha.hp)
bob.attack(haha) # Person.attack(bob,haha)
print(haha.hp)
print(bob.hp)
haha.bite(bob)
print(bob.hp)
结果
9999
bob攻击了新新
9998.9
10
新新咬人bob
bob死了
0