python学习之老男孩python全栈第九期_day023知识点总结——类和对象命名空间、组合

一. 类和对象命名空间
类里 可以定义两种属性：
    1. 静态属性
    2. 动态属性

class Course:
    language = 'Chinese'
    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

python = Course('egon', 'python', '6 months', 20000)

print(Course.language)
Course.language = 'English'         # 这种方式可以修改静态属性，但通过Course.__dict__['language'] = 'English' 修改不了
print(Course.language)

linux = Course('oldboy', 'linux', '6 months', 18000)
print(python.language)

python.language = 'INS'
print(Course.language)
print(python.language)
print(linux.language)

print(python.__dict__)
print(linux.__dict__)

 # linux 比python少了一个language，说明python创建了一个language = 'INS',
 # 但Course里面的language并不会变
 # 但这样的话就永远用不到Course里面的language了
 # 把python里面的删除就可以了：
 del python.language
 print(python.language)

对于 不可变数据类型 来说，类变量最好用类操作，而不适合用对象操作
对于 可变数据类型 来说，对象名的修改是共享的，重新赋值是独立的

类中的静态变量，可以被对象和类调用

上面说的是对于不可变类型，那么对于可变数据类型呢？

class Course:
    language = ['Chinese']
    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

python = Course('egon', 'python', '6 months', 20000)

Course.language[0] = 'English'
print(Course.language)

linux = Course('oldboy', 'linux', '6 months', 18000)

# python.language[0] = 'INS'
# print(Course.language)
# print(python.language)
# print(linux.language)               # 三个都变成了'INS', 列表里面的值改变了，但不改变列表所在的内存地址

# 但是，如果这样写
python.language = ['Ins']
print(Course.language)
print(python.language)          # 依然只有python.language变了， 相当于 重新赋值
print(linux.language)

# 创建一个类，每实例化一个对象就记录下来
# 最终所有的对象共享这个数据

class Foo:
    count = 0
    def __init__(self):
        Foo.count += 1
f1 = Foo()
f2 = Foo()
f3 = Foo()
print(f1.count)
print(f2.count)
print(f3.count)
print(Foo.count)            # 通过类名就可以知道实例化了多少个对象

# 函数名不要和静态属性重名

# 认识绑定方法

def func():pass
print(func)

class Foo:
    def func(self):
        print('func')
f1 = Foo()
print(Foo.func)
print(f1.func)
print(f1)

二. 组合

 # 面向对象的三大特性：继承 多态 封装 -- 之后学
 # 组合
 # 人狗大战

 class Dogs:
     def __init__(self,name ,HP, aggr, kind):
         self.name = name
         self.HP = HP
         self.aggr = aggr
         self.kind = kind

     def bite(self,person):
         person.HP -= self.aggr

 class Person:
     def __init__(self,name ,HP, aggr, sex):
         self.name = name
         self.HP = HP
         self.aggr = aggr
         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, naijiu, price):
         self.name = name
         self.aggr = aggr
         self.naijiu = naijiu
         self.price = price

     def hand_18(self, peason):
         if self.naijiu > 0:
             peason.HP -= self.aggr * 2
             self.naijiu -= 1
 alex = Person('alex', 100, 1, '不详')
 jin = Person('金老板', 200, 2, '泰迪')
 weapon = Weapon('打狗棒', 5, 100, 9.9)

 # 装备
     # 增加伤害
     # 增加血量
 # 给alex装备打狗棒
 # 打不过金老板，于是 充钱买装备
 alex.money += 1000
 alex.get_weapon(weapon)
 print(alex.weapon)
 print(alex.aggr)
 alex.attack(jin)
 print(jin.HP)

 alex.weapon.hand_18(jin)
 print(jin.HP)

 # 组合：一个对象的属性值是另外一个类的对象
 #       alex.weapon 是 Weapon 类的一个对象

三. 组合的一些小练习

 创建一个圆环类

 from math import pi
 class Circle:
     def __init__(self, r):
         self.r = r
     def area(self):
         return self.r ** 2 * pi
     def perimeter(self):
         return 2 * pi * self.r

 class Ring:
     def __init__(self,outside_r, inside_r):
         self.outside_c = Circle(outside_r)
         self.inside_c = Circle(inside_r)
     def area(self):
         return self.outside_c.area() - self.inside_c.area()
     def perimeter(self):
         return self.outside_c.perimeter() + self.inside_c.perimeter()

 ring = Ring(20, 10)
 print(ring.area())
 print(ring.perimeter())

---

 # 创建一个老师类
 # 老师有生日
 # 生日也是一个类：年、月、日 三个属性
 # 组合实现

 class Teacher:
     def __init__(self,name, age, sex, birthday):
         self.name = name
         self.age = age
         self.sex = sex
         self.bir = birthday
         self.course = Course('python','6 month',20000)

 class Course:
     def __init__(self, course_name, period, price):
         self.name = course_name            # 课程名字
         self.period = period        # 课程周期
         self.price = price          # 课程价格

 class Birthday:
     def __init__(self, year, month, day):
         self.year = year
         self.month = month
         self.day = day
 birthday = Birthday(2017, 3, 20)
 teacher = Teacher('KID', 21, '女', birthday)
 print(teacher.name)
 print(teacher.bir.year)
 print(teacher.bir.month)
 print(teacher.course.price)