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，大做業，後補