day23:类的命名空间和组合

1，类属性：静态属性，方法：动态属性；双下init方法，每当我们调用类的时候就会自动的触发这个方法，默认传self，在init方法里面可以对self赋值；在类的内部，self就是一个对象，我们自己实例化的对象是类外部的对象

2，Python入门，给你一个需求，能翻译成Python语言，就入门了；面向对象入门，当你见到一个需求，能分析出这个问题是否适合用面向对象解决，如果适合，能有一些想法，怎么设计这个类，有几个属性，方法等等

3，一定要选好最适合的编程方式，不是所有的都适合用面向对象来解决的，面向对象只是一种编程思想，并没有高端低端之分。

4，是否可以用对象名来调用静态属性呢？可以的

5，类中的函数名和对象，最终都是一个名字而已，都是一个内存地址。定义了一个类以后，会创建一个这个类名的命名空间，在这个空间内，放名字

6，有了对象一定可以找到类（类对象指针），有了类找不到对象，单线联系，对象自己的空间里面没有的时候，回去类的空间里面找

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

linux = Course('lisa','linux',6,20000)
linux.language = "japanese"   # 这个是给对象新添加了一个属性

print(linux.__dict__)
del linux.language #删除这个属性
Course.language = 'English'  # 这个是修改了雷属性
print(Course.__dict__)

# {'teacher': 'lisa', 'name': 'linux', 'period': 6, 'price': 20000, 'language': 'japanese'}
# {'__module__': '__main__', 'lan

7,对于静态属性不可变数据类型来说，类变量最后用类名来操作，用对象来操作的话，只不过给对象添加了新的属性；对于可变数据类型，可以用对象和类的索引来操作

8，绑定方法，这个对象提供的所有的数据，这个方法都可以去调用了，这种情况下，才产生了绑定方法。绑定的意思其实就是把这个对象当做self传进去了，也有非绑定方法，目前我们还没有见到。

def func():pass

class Foo():
    def func(self):
        print('func')

f1 = Foo()

# 打印内存地址
print(func)
print(Foo.func)
print(f1.func)
print(f1)

# <function func at 0x103bfa840>
# <function Foo.func at 0x103bfa6a8>
# <bound method Foo.func of <__main__.Foo object at 0x103b2f390>>
# <__main__.Foo object at 0x1044ac390>
# 这个函数是这个类的绑定方法

9，对象找名字的时候，如果类里面没有，是不可以找全局的的，最高找到类。类里面就是一个独立的，他不能一级一级网上找了

10，import一个包，相当于类的实例化过程，后面的点调用，类似于对象访问方法，访问属性。

11，类的特性：面向对象的三大特性：继承，多态和封装

12，一种类里面的用法，组合，这个我们其实一直在用，只不过不知道他就叫做组合。

13，组合：一个对象的属性值是另外一个类的对象（alex.weapon这个是weapon类的对象），组合的调用方式会出现两个点的调用

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,gender):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.gender = gender
        self.money = 0

    def attack(self,dog):
        dog.hp -= self.aggr

    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.weapon = weapon # 这个是组合使用的关键点
            self.aggr += weapon.aggr
            weapon.njd -= 1
            self.money -= weapon.price
        else:
            print('money is not enough')

class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd
        self.price = price

    # 给武器定义一个大招
    def handl18(self,person):
        person.hp -= self.aggr *2
        self.njd -=1

alex = Person('alex',10,1000,'male')
alex.money += 1000 # 充钱买武器
jin = Dog('jin',5,600,'teddy')
w = Weapon('dagou-stick',100 ,3,998)

jin.bite(alex)
print(alex.hp)

alex.attack(jin)
print(jin.hp)

alex.get_weapon(w)
print(alex.weapon)
alex.attack(jin)
print(jin.hp)
alex.weapon.handl18(jin)  # 组合
print(jin.hp)

14，组合练习，计算圆环的周长和面积

from math import pi

class Circle:
    def __init__(self,radius):
        self.radius = radius

    def area(self):
        return self.radius**2 *pi

    def perimeter(self):
        return 2 *pi *self.radius

class Ring():
    def __init__(self,big_circle,small_circle):
        self.big_circle = big_circle
        self.small_circle = small_circle

    def area(self):
        return self.big_circle.area() - self.small_circle.area()  # 组合的应用

    def perimeter(self):
        return self.big_circle.perimeter() + self.small_circle.perimeter()

big_circle = Circle(10)
small_circle = Circle(5)
ring = Ring(big_circle, small_circle)
print(ring.area())
print(ring.perimeter())

15,稍微改进一点的圆环

from math import pi

class Circle:
    def __init__(self,radius):
        self.radius = radius

    def area(self):
        return self.radius**2 *pi

    def perimeter(self):
        return 2 *pi *self.radius

class Ring():
    def __init__(self,big_r,small_r):
        self.big_circle = Circle(big_r)
        self.small_circle = Circle(small_r)

    def area(self):
        return self.big_circle.area() - self.small_circle.area()  # 组合的应用

    def perimeter(self):
        return self.big_circle.perimeter() + self.small_circle.perimeter()

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

16，组合练习二

class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

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

class Teacher:
    def __init__(self,name,age,gender,birthday):
        self.name = name
        self.age = age
        self.gender = gender
        self.birthday = birthday
        self.course = Course(self,'python',6,20000)  # 实现了双向关联，当然不是必须的

b =  Birthday(2018,3,2)
lisa = Teacher('lisa',30,'female',b)
c = Course(lisa,'linux',3,15000)
print(lisa.birthday.day)
print(c.teacher.name)  # 双向关联
print(lisa.course.price)

17，大作业，后补