面向對象的命名空間

屬性:靜態屬性(直接和類名關聯的對象或者直接定義在class下的變量)、對象屬性(在類內和self關聯，在類外和對象名關聯的變量)

類名操作變量 不管操作可變還是不可變數據類型 都是類中對應的變量發生變化
對象名操作靜態變量
引用變量:先在自己的命名空間中查找，找不到就去類的命名空間找
修改變量:
如果是對可變數據類型中的元素進行修改，那麽全局生效
如果是對變量進行重新賦值，那麽只是在對象自己的命名空間裏增加了一個新的屬性

class Foo:
    country = ‘China‘
    country_lst = [‘China‘]
    def __init__(self,name):
        self.name = name

alex = Foo(‘alexander‘)
egg = Foo(‘egon‘)
alex.age = 90
Foo.role = ‘Person‘
print(Foo.country)
print(alex.name)
print(egg.name)
print(alex.country)
print(alex.role)
alex.country = ‘印度‘
print(alex.country)  # 印度
print(egg.country)  # China
print(Foo.country)  # China
del alex.country
alex.country_lst.append(‘印度‘)
print(alex.country_lst)  # [‘China‘, ‘印度‘]
print(egg.country_lst)  # [‘China‘, ‘印度‘]
print(Foo.country_lst)  # [‘China‘, ‘印度‘]

設計一個類，統計這個類被實例化的次數，且所有的對象共享這個屬性

class Foo:
    count = 0
    def __init__(self):
        Foo.count += 1

f1 = Foo()
f2 = Foo()
print(f1.count)

對象使用名字的順序:先用自己的，再用類的
對象可以使用類的
而類無法使用對象的

組合

組合:什麽有什麽的關系
一個對象的屬性是另外一個類的對象

class Teacher:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

# 老師有生日:年月日
class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
birthday1 = Birthday(1968,12,31)
boss_gold = Teacher(‘太亮‘,40,‘不詳‘)
boss_gold.birth = birthday1
boss_gold.birth.year
# 將一個類的對象擁有的屬性 再將其定義成一個類以提高代碼的復用

class Teacher:
    def __init__(self,name,age,sex,year,month,day):
        self.name = name
        self.age = age
        self.sex = sex
        self.birth = Birthday(year,month,day)
class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
boss_gold = Teacher(‘太亮‘,40,‘不詳‘,1968,12,31)

圓和圓環

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

class Ring:
    def __init__(self,outer_r,inner_r):
        self.outer_circle = Circle(outer_r)
        self.inner_circle = Circle(inner_r)
    def perimeter(self):
        return self.outer_circle.perimeter()+self.inner_circle.perimeter()
    def area(self):
        return self.outer_circle.area()-self.inner_circle.area()

r1 = Ring(10,5)
print(r1.area())

人狗大戰組合

class Dog:  # 定義一個狗類
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵稱;
        self.breed = breed  # 每一只狗都有自己的品種;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻擊力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;
    def bite(self,person):
        person.life_value -= self.aggressivity

class Person:  # 定義一個人類
    def __init__(self, name, aggressivity, life_value,money):
        self.name = name  # 每一個角色都有自己的昵稱;
        self.aggressivity = aggressivity  # 每一個角色都有自己的攻擊力;
        self.life_value = life_value  # 每一個角色都有自己的生命值;
        self.money = money
    def attack(self,dog):
        dog.life_value -= self.aggressivity
    def get_weapon(self,weapon_obj):
        if self.money > weapon_obj.price:
            self.money -= weapon_obj.price
            self.weapon = weapon_obj
            self.aggressivity += weapon_obj.aggr

boss_gold = Person(‘金老板‘,5,250,100)
huang = Dog(‘大黃‘,‘藏獒‘,100,3000)
huang.bite(boss_gold)
print(boss_gold.life_value)
# 人有武器——組合
class Weapon:
    def __init__(self,name,price,aggr):
        self.name = name
        self.price = price
        self.aggr = aggr
dgb = Weapon(‘打狗棒‘,99.8,100)
boss_gold.get_weapon(dgb)

繼承

繼承:至少兩個類 什麽是什麽的關系，為了避免幾個類之間有相同的代碼
父類:Animal
子類:Dog、Person

class Animal:
    def __init__(self,name, aggressivity, life_value):
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value
class Dog(Animal):
    def bite(self,person):
        person.life_value -= self.aggressivity
class Person(Animal):
    def attack(self,dog):
        dog.life_value -= self.aggressivity

huang = Dog(‘大黃‘,100,3000)  # __init__ 找父類
boss_gold = Person(‘金‘,10,100)

查看繼承的類

print(Dog.__bases__)  # (<class ‘__main__.Animal‘>,)
print(Animal.__bases__)  # (<class ‘object‘>,)

python兩種類:經典類 新式類
python3 所有類都是新式類——都默認繼承object class Animal(object): == class Animal:
python2 經典類和新式類並存：
class Animal: 經典類 —— 繼承順序 個別使用方法
class Animal(object): 新式類

兩個類中有相同的代碼
繼承:把相同的代碼放在父類中，子類的對象在子類中沒有找到方法的時候，使用父類的
單繼承和多繼承

class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
    pass

父類 超類 基類
子類 派生類
抽象和繼承

面向對象進階：命名空間和組合