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)