组合：
表示一个类的对象作为另一个类对象的属性。
实例化的过程：
1，创建一个对象。
2，__init__ 给对象添加一些属性，对象默认的名字为self。
3，将self所指向的内存空间返回给实例化他的地方。
使用这个对象可以找到两个东西：
1，对象所在的内存中存储的属性。
2，类对象指针所指的类中的所有方法和静态属性。
对象找名字的时候：先找自己内存空间中的，再找类的。
对象没有权利修改类中的静态变量和方法。
用类名操作静态变量（属性）。
类名：实例化对象，调用静态属性，执行方法。
交互：对象可以作为参数传递给类中的方法。
组合：对象可以作为一个对象的属性。
为什么会用组合：独立的对象不能发挥他的作用，必须依赖一个对象。
class Person:
def __init__(self,name,sex,hp,ad):
self.name = name
self.sex = sex
self.hp = hp
self.ad = ad
self.money = 0
def attack(self,dog):
dog.hp -= self.ad
print('%s攻击了%s，%s掉了%s点血' % (self.name,dog.name,dog.name,self.ad))
def pay(self):
money = int(input('请输入你要充值的金额：'))
self.money += money
print('你的余额为：%s' % self.money)
def wear(self,weapon): # 装备武器
if self.money >= weapon.price:
self.weapon = weapon # 组合 给人装备了武器 武器类的对象作为了人类对象的一个属性。
self.money -= weapon.price
print('购买成功，你已经顺利装备了%s' % weapon.name)
else:
print('余额不足，请充值...')
def attack_with_weapon(self,dog):
if 'weapon' in self.__dict__:
self.weapon.skill(dog)
else:
print('请先装备武器...')
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):
person.hp -= self.ad
print('%s咬了%s，%s掉了%s点血' % (self.name,person.name,person.name,self.ad))
class Weapon:
def __init__(self,name,price,ad,level):
self.name = name
self.price = price
self.ad = ad * level
self.level = level
def skill(self,dog):
dog.hp -= self.ad
print('%s受到了%s的伤害，%s掉了%s点血' % (dog.name,self.name,dog.name,self.ad))
alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',20,50)
teddy = Dog('笨笨','teddy',150,50)
futou = Weapon('斧头',1000,100,1)
# alex.weapon.skill()
# print(alex.weapon)
# print(futou)
# futou.skill(teddy)
lis = ['攻击','充值','装备武器','使用武器']
while True:
for index,value in enumerate(lis,1):
print(index,value)
choice = int(input('请输入你的选择：'))
if choice == 1:
alex.attack(teddy)
elif choice == 2:
alex.pay()
elif choice == 3:
alex.wear(futou)
elif choice == 4:
alex.weapon.skill(teddy)
else:
print('无效序号:')
组合的实例：
# 圆形类
# 写一个圆环类 组合 圆形类 去完成 计算圆环的面积和周长
# 一个类的对象作为另一个类对象的属性
# 圆环中有圆
# 圆形类 ： 计算圆形面积 和 周长
# 圆环类 :
# 圆环的周长 ： 大圆周长加小圆周长
# 圆环的面积 : 大圆的面积 - 小圆的面积
from math import pi
class Circle:
def __init__(self,r):
self.r = r
def cir_area(self):
return pi*self.r**2
def cir_perimeter(self):
return pi*self.r*2
class Ring:
def __init__(self,max_r,min_r):
self.max_r = Circle(max_r) # 相当于实例化。self.max_r是Circle类中的一个对象。它又是Ring类中的对象的属性。
self.min_r = Circle(min_r)
def R_area(self):
return self.max_r.cir_area() - self.min_r.cir_area()
def R_perimeter(self):
return self.max_r.cir_perimeter() + self.min_r.cir_perimeter()
r1 = Ring(3,2)
print(r1.R_area())
print(r1.R_perimeter())
班级和老师的关系（组合）：
# 老师
# 姓名 年龄 性别 班级 ： s11
# 班级
# 班级名 班级人数 科目 性质
class Teacher:
def __init__(self,name,age,sex,cla):
self.name = name
self.age = age
self.sex = sex
self.cla = cla
class Cla:
def __init__(self,name,num,course,type):
self.name = name
self.num = num
self.course = course
self.type = type
cla = Cla('s11',99,'python','全栈')
teacher = Teacher('Eva',18,'女',cla)
print(teacher.cla.name)
print(teacher.cla.num)
print(teacher.cla.course)
print(teacher.cla.type)
初识继承：
单继承：
在python3中，所有类都会默认继承object类。
继承了object类的所有类都是新式类。
如果一个类没有继承任何父类，那么__bases__属性就会显示 <class 'object'>
class Parent:
pass
class Son(Parent): # 继承关系
pass
print(Son.__bases__) # 内置的属性
print(Parent.__bases__)
# (<class '__main__.Parent'>,)
# (<class 'object'>,)
多继承：
class Parent1:
pass
class Parent2(Parent1):
pass
class Parent3:
pass
class Son(Parent2,Parent3):
pass
print(Parent1.__bases__) # (<class 'object'>,)
print(Parent2.__bases__) # (<class '__main__.Parent1'>,)
print(Parent3.__bases__) # (<class 'object'>,)
print(Son.__bases__) # (<class '__main__.Parent2'>, <class '__main__.Parent3'>)
父类：基类，超类。
字类：派生类
class Animal:
role = 'Animal'
def __init__(self,name,hp,ad):
self.name = name
self.hp = hp
self.ad = ad
def eat(self):
print('%s吃药回血了' % (self.name))
class Person(Animal):
r = 'Person'
def attack(self,dog):
print('%s攻击了%s' % (self.name,dog.name))
class Dog(Animal):
def bite(self,person):
print('%s咬了%s' % (self.name,person.name))
alex = Person('a_sb',10,5) # 继承了父类中的属性。
dog = Dog('teddy',100,20) # 继承了父类中的属性。
# 继承中的派生方法。
alex.attack(dog)
dog.bite(alex)
# 继承父类的方法，前提自己没有同名方法，否则无法继承。
dog.eat() # 继承了父类中的 方法。
self.名字 的时候，不要看self当前在哪个位置，要看这个self到底是谁的对象。
class Parent:
def func(self):
print('in Parent func')
def __init__(self):
self.func()
class Son(Parent):
def func(self):
print('in Son func')
s = Son()
# in Son func
面向对象的思想：
1，不关心程序执行的过程。
2，关心的是一个程序中的角色 以及 角色与角色之间的关系。
