面向对象回顾：
示例一：人狗大战：
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方法
self是什么 self拥有属性都属于对象
实例化
实例 = 对象
对象查看属性
对象调用方法
类中的静态变量，可以被实例后的对象和类本身调用
类中的变量无法被实例化后的对象修改
对于不可变数据类型来说，类变量最好用类名操作
对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的
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
实例化调用方式时，内存空间为重新开辟后的地址
class Foo:
def func(self):
print(‘func‘)
def inner(self):
pass
f1 = Foo()
print(Foo.func) #<function Foo.func at 0x000002C48D8FBA60>
print(f1.func) #<bound method Foo.func of <__main__.Foo object at 0x000002C48D8F9470>>
print(f1.inner) #<bound method Foo.inner of <__main__.Foo object at 0x000002C48D8F9470>>
#实例化调用方法bound到类中的方法
组合：最起码为两个类以上才能用到组合
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)
python笔记(18)--类的命名空间、实例化绑定方法和类的组合用法
原文：https://www.cnblogs.com/lynlearnde/p/12912258.html