python类的命名空间可以存_python笔记(18)--类的命名空间、实例化绑定方法和类的组合用法...

内容目录：

类的命名空间

实例化的绑定方法

类的组合用法

面向对象回顾：

示例一：人狗大战：

class Dog:

def __init__(self,name,blood,aggr,kind):

self.name = name

self.blood = blood

self.aggr = aggr

self.kind = kind

def bite(self,person):

#狗咬人，人掉血

person.hp -= self.aggr

print('狗咬人，人剩了%s血'%(person.hp))

class Person:

def __init__(self,name,blood,aggr,sex):

#self就是一个可以存储很多属性的大字典

self.name = name

self.hp = blood

self.aggr = aggr

self.sex = sex

def attack(self,dog):

dog.blood -= self.aggr

print('人打狗，狗剩了%s血'%(dog.blood))

jin = Dog('金老板',100,20,'teddy')

alex = Person('alex',1000,10,'男')

Dog.bite(jin,alex)

Person.attack(alex,jin)

示例二：计算圆的周长和面积：

from math import pi

class Circle:

def __init__(self,r):

self.r = r

def area(self):

return pi*(self.r**2)

def perimeter(self):

return 2*pi*self.r

obj = Circle(5)

area = obj.area()

perimeter = obj.perimeter()

print(area,perimeter)

定义类

class 类名: #-----定义类

变量 ： #-----类属性，静态属性

def 函数: #-----方法，动态属性

init方法

python帮我们创建了一个对象self

每当我们调用类的时候都会自动触发这个方法，默认传self

在init方法里可以对self进行赋值

self是什么 self拥有属性都属于对象

在类的内部，self就是一个对象

实例化

对象 = 类(参数是init方法的)

实例 = 对象

两者之间没有区别

对象查看属性

对象.属性名

对象调用方法

对象.方法名(参数)

内容详细：

1.类的命名空间

类中的静态变量，可以被实例后的对象和类本身调用

类中的变量无法被实例化后的对象修改

对于不可变数据类型来说，类变量最好用类名操作

对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

class Course:

language = 'Chinese'

pice = ['北京','上海']

def __init__(self,teacher,course_name,period,price):

self.teacher = teacher

self.name = course_name

self.period = period

self.price = price

def func(self):

pass

Course.language = 'English'

# Course.__dict__['language'] = 'CHINA' #不能修改内部默认的字典，修改无效

print(Course.language) # English

python = Course('alec','python','6 months',2000)

linux = Course('oldboy','linux','4 months',1000)

#对于类中静态不可变类型来说，实例化对象不可修改类中静态变量，只能重新在自己开辟的空间中创建赋值

python.language = 'python' #重新开辟内存空间，重新赋值language = 'python'

print(Course.language,python.language) #English python

linux.language = 'linux' #重新开辟内存空间，重新赋值language = 'linux'

print(Course.language,linux.language) #English linux

#对于类中静态可变类型来说，实例化对象修改了相当于对类中变量修改

python.pice[0] = '郑州'

print(Course.pice,python.pice) #['郑州', '上海'] ['郑州', '上海']

linux.pice[1] = '广州'

print(Course.pice,linux.pice) #['郑州', '广州'] ['郑州', '广州']

练习：

创建一个类，每实例化一个对象就计数一次。最终所有的对象共享这个数据

class Foo:

count = 0

def __init__(self):

Foo.count += 1

f1 = Foo()

f2 = Foo()

print(f1.count) #2

print(f2.count) #2

f3 = Foo()

print(f1.count) #3

2.实例化的绑定方法

实例化调用方式时，内存空间为重新开辟后的地址

class Foo:

def func(self):

print('func')

def inner(self):

pass

f1 = Foo()

print(Foo.func) #

print(f1.func) #>

print(f1.inner) #>

#实例化调用方法bound到类中的方法

3.类的组合用法

组合：最起码为两个类以上才能用到组合

class Dog:

def __init__(self,name,aggr,hp,kind):

self.name = name

self.aggr = aggr

self.hp = hp

self.kind = kind

def bite(self,person):

person.hp -= self.aggr

class Person:

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

self.name = name

self.aggr = aggr

self.hp = hp

self.sex = sex

self.money = 0

def attack(self,dog):

dog.hp -= self.aggr

def get_weapon(self,weapon):

if self.money >= weapon.price:

self.money -= weapon.price

self.weapon = weapon

self.aggr += weapon.aggr

else:

print('余额不足')

class Weapon:

def __init__(self,name,aggr,njd,price):

self.name = name

self.aggr = aggr

self.njd = njd

self.price = price

def hand18(self,person):

if self.njd >=0:

person.hp -= self.aggr * 2

self.njd -= 1

alex = Person('alex',10,100,'男')

jin = Dog('金老板',100,500,'teddy')

w = Weapon('打狗棒',100,3,998)

alex.money += 1000

alex.get_weapon(w)

print(alex.aggr)

alex.attack(jin)

print(jin.hp)

alex.weapon.hand18(jin)#两个类组合

print(jin.hp)