python days_python 19 days

python 19 days

_init_、面向对象、初始面向对象、面向对象的命名空间

例题：

人狗大战

角色：人和狗

人：名字、性别、血量(hp)、攻击力(ad)

狗：名字、品种(kind)、血量(hp)、攻击力(ad)

defPerson(name,sex,hp,ad):#创造了一个模子

#约束了一个人必须拥有的属性

#规范了这些属性的名字

#简化了用户的操作

person ={'name': name,'sex': sex,'hp': hp,'ad': ad

}def attack(dog): #人攻击狗

#狗掉血，是人的攻击力

#狗的血 人的攻击力

print('%s攻击了%s' % (person['name'], dog['name']))

dog['hp'] -= person['ad']print('%s掉了%s点血，%s剩余血量%s' %(dog['name'], person['ad'], dog['name'], dog['hp']))

person['attack'] =attackreturnpersondefDog(name,kind,hp,ad):

dog={'name': name,'kind': kind,'hp': hp,'ad': ad

}def bite(person): #狗咬人

print('%s咬了%s' % (dog['name'], person['name']))if person['hp'] <= dog['ad']:

person['hp'] =0print('%s剩余血量已为0，game over' % person['name'])else:

person['hp'] -= dog['ad']print('%s掉了%s点血，%s剩余血量%s' % (person['name'], dog['ad'], person['name'], person['hp']))

dog['bite'] =bitereturndog

alex= Person('alex',None,10,1)

egon= Person('egon',None,20,2)

taibai= Dog('哮天犬','teddy',100,50)

alex['attack'](taibai)

taibai['bite'](alex)

例题展示

alex攻击了哮天犬

哮天犬掉了1点血，哮天犬剩余血量99

哮天犬咬了alex

alex剩余血量已为0，game over

结果展示

面向对象的思路：

不着急直接去计算/操作代码获取结果；

从一个大的问题中 要到要描述的角色；

将角色的属性和行为抽象出来；

形成一个模子；

后期用到角色的时候 都围绕这个模子来操作。

类 ：

一类抽象的事务，是描述了一类事务有哪些属性或者行为，但是不具体 —— 模子

实例=对象：

就是一个依托于类的规范存在的，被赋予了具体属性值的实际存在的物体

实例化：

由一个类产生一个对象/实例的过程。

初始面向对象

创造一个函数              用 def

创造一个类                 用class

class Person:

Country = 'China'   # 静态属性

def __init__(self,name,sex,hp,ad):

print('self -->',self)

obj = Person('alex', None, 10, 1)  # 对象 = 类名()

print('obj -->', obj)

Person 是一个类名

Person 中可以放两个东西：

静态属性        变量

动态属性(方法)  函数,自带一个叫做self的形参

类名可以做两件事情

查看静态属性和动态属性

print(Person.Country) # 变量的值

print(Person.func)    # 函数的地址

Person.func(0)  # Person调用方法：self也是一个需要传的参数

print(Person.__dict__)

创造一个对象object 对象 = 类名()

首先要创造一个对象

会自动的触发__init__，将创造出来的对象的地址传给self

执行init中的代码

将self指向的地址再返回给调用者

classPerson:def __init__(self,name,sex,hp,ad): #初始化方法

self.user =name

self.sex=sex

self.hp=hp

self.ad=addefattack(self,dog):print('%s攻击了%s'%(self.user,dog.user))

dog.hp-=self.adprint('%s掉了%s点血，当前血量为%s'%(dog.user,self.ad,dog.hp))#classDog:def __init__(self,name,kind,hp,ad): #初始化方法

self.user =name

self.kind=kind

self.hp=hp

self.ad=addefbite(self,person):print('%s咬了%s' %(self.user, person.user))

person.hp-=self.adif person.hp>0:print('%s掉了%s点血，当前血量为%s' %(person.user, self.ad, person.hp))else:

person.hp=0print('%s掉了%s点血，当前血量已为0' %(person.user, self.ad))

alex= Person('alex', None, 10, 1) #实例化

egon = Person('egon', None, 10, 1) #实例化

taibai = Dog('哮天犬','teddy', 100, 50) #实例化#print(alex.user)#print(egon.user)#print(taibai.user)

alex.attack(taibai) #<==>Person.attack(alex,taibai)

print(taibai.hp)

例题展示

alex攻击了哮天犬

哮天犬掉了1点血，当前血量为9999

结果展示

Person Dog 类

alex egon taibai 对象 实例

面向对象的命名空间：

对象名可以调用静态属性

对象名可以调用方法

class Person:

Country = 'China'

def __init__(self,name):

self.name = name

def attack(self):

print('attack')

类

静态属性

动态属性 ： 特殊的__init__方法，attack方法

对象

对象属性 name

classPerson:

Country= 'China'

def __init__(self,name):

self.name=name

alex= Person('alex')

egon= Person('egon')

alex.Country= '印度' #往alex的对象内存中存了一个印度

print(alex.Country)print(egon.Country)print(Person.Country)classPerson:

Country= ['China']def __init__(self,name):

self.name=name

alex= Person('alex')

egon= Person('egon')

alex.Country[0]= '印度'

print(Person.Country)print(egon.Country)

例题展示

印度

China

China

['印度']

['印度']

结果展示

首先静态变量之所以出现 ： 所有的对象都共享的值

调整静态变量的值 ： 直接用类名去调整 是最准确的

对象对一个静态变量重新赋值的过程

实际上是在对象所在的内存空间中添加了一个同名属性而已

方法并没有真正存储在对象的空间中

之所以能找到，是因为每一个对象在创建之初都有一个执行类的指针

类名

查看修改静态属性

实例化

对象名

查看对象的属性

调用方法

对象使用名字的特点 ： 自己有的时候用自己的 自己没有的时候用类中的