python面對對象編程

基本概念

class類

一個類便是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具有的屬性（variables(data)）、共同的方法

Object 對象 
一個對象便是一個類的實例化後實例，一個類必須通過實例化後方可在程序中調用，一個類能夠實例化多個對象，每一個對象亦能夠有不一樣的屬性，就像人類是指全部人，每一個人是指具體的對象，人與人以前有共性，亦有不一樣

Encapsulation 封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含着類的數據和方法

Inheritance 繼承
一個類能夠派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承

Polymorphism 多態

一個接口，多種實現

類的建立

class Car(object):

    def __init__(self,type,price):
        self.type = type
        self.price = price

    def carinfo(self):
        print("type:%s,price:%d"%(self.type,self.price))

tesla = Car('tesla',2000)
jeep = Car('jeep',1000)

tesla.carinfo()
jeep.carinfo()

對象之間的交互

class Garen:
    camp = 'Demacia'

    def __init__(self,name,aggressivity = 58,life_value = 455): #初始攻擊力和生命值
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self,enemy):   #普通攻擊技能，攻擊敵人
        enemy.life_value -= self.aggressivity    #根據攻擊力，減掉敵人生命值

class Riven:
    camp = 'Noxus'

    def __init__(self,name,aggressivity = 54,life_value = 4514):
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self,enemy):
        enemy.life_value -= self.aggressivity

g1 = Garen('蓋倫')
r1 = Riven("瑞文")

print(g1.life_value)
r1.attack(g1)     #交互
print(g1.life_value)

繼承

繼承指的是類與類之間的關係，是一種什麼是什麼的關係，功能之一就是用來解決代碼重用問題

繼承是一種建立新類的方式，在python中，新建的類能夠繼承一個或多個父類，父類又可稱爲基類或超類，新建的類稱爲派生類或子類

 

 

 

class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s is eating..." % self.name)
    def talk(self):
        print("%s is talking..." % self.name)
    def sleep(self):
        print("%s is sleeping..." % self.name)

class Man(People):
    def __init__(self,name,age,money):
        super(Man,self).__init__(name,age)
        self.money  = money
        print("%s 一出生就有%s money" %(self.name,self.money))
    def sleep(self):
        print("man is sleeping ")

class Woman(People):
    def get_birth(self):
        print("%s is born a baby...." % self.name)

m1 = Man("jack",22,10000)
m1.sleep()
w1 = Woman("alex",26)
w1.get_birth()

組合

組合與繼承都是有效地利用已有類的資源的重要方式。可是兩者的概念和使用場景皆不一樣

1.繼承的方式

經過繼承創建了派生類與基類之間的關係，它是一種'是'的關係，好比白馬是馬，人是動物。

當類之間有不少相同的功能，提取這些共同的功能作成基類，用繼承比較好，好比老師是人，學生是人

2.組合的方式

用組合的方式創建了類與組合的類之間的關係，它是一種‘有’的關係,好比教授有生日，教授教python和linux課程，教授有學生s一、s二、s3...

class Equip():
    def file(self):
        print('release fire skill')

class Riven():
    camp = 'Noxus'
    def __init__(self,name):
        self.name = name
        self.equip = Equip()   #用Equip類產生一個裝備,賦值給實例的equip屬性

r1 = Riven('瑞文')
r1.equip.file()    #可使用組合的類產生的對象所持有的方法


結果：
release fire skill

繼承與組合例子：

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

class Course(object):
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price
    def tell_info(self):
        print('%s %s %s'%(self.name,self.period,self.price))

class Teacher(People):
    def __init__(self,name,age,sex,job):
        super(Teacher, self).__init__(name,age,sex)
        self.job = job
        self.course = []
        self.students = []

class Student(People):
    def __init__(self,name,age,sex):
        super(Student, self).__init__(name,age,sex)
        self.course = []

#老師和學生對象
jack = Teacher('jack',18,'male','c++')
s1 = Student('derek',12,'female')
#課程
python = Course('python','3mons',3000)
linux = Course('linux','4mons',5000)
#爲老師和學生添加課程
jack.course.append(python)
jack.course.append(linux)
s1.course.append(linux)
#爲老師添加學生
jack.students.append(s1)
#使用
for obj in jack.course:
    obj.tell_info()

3.私有屬性

方法

1.靜態方法(@staticmethod)

靜態方法是不能夠訪問實例變量或類變量的，一個不能訪問實例變量和類變量的方法，其實至關於跟類自己已經沒什麼關係了

class Dog(object):

    def __init__(self,name):
        self.name = name
    @staticmethod
    def eat():
        print('is eating')

d = Dog('xiaohei')
d.eat()

2.類方法(@classmethod)

class Dog(object):

    def __init__(self,name):
        self.name = name
    @classmethod
    def eat(cls):
        print('is eating')

d = Dog('xiaohei')
d.eat()

3.屬性方法(@property)

class Dog(object):

    def __init__(self,name):
        self.name = name
    @property
    def eat(self):
        print('is eating')

d = Dog('xiaohei')
d.eat

把一個方法變成一個靜態屬性，由於eat此時已經變成一個靜態屬性了， 不是方法了， 想調用已經不須要加()號了，直接d.eat就能夠了

多態

 所謂多態：定義時的類型和運行時的類型不同，此時就成爲多態

class F1(object):
    def show(self):
        print 'F1.show'

class S1(F1):

    def show(self):
        print 'S1.show'

class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj)   # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show

s2_obj = S2()
Func(s2_obj)   # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show

 

類的特殊方法

表示類的描述信息

1.__doc__

class Func():
    """ 這裏顯示的是描述信息 """

    def func(self):
        pass
print(Func.__doc__)


結果：
這裏顯示的是描述信息

2.__str__

若是一個類中定義了__str__方法，那麼在打印 對象 時，默認輸出該方法的返回值。

class Foo:
    def __str__(self):
        return 'alex li'
obj = Foo()
print(obj)
7
結果：
alex li

3.反射

hasattr：判斷一個對象是否有對應字符串方法

getattr:獲取方法

setattr:添加方法

delattr：刪除方法

def bulk(self):   #添加的方法
    print("%s is yelling...." %self.name)

class Dog(object):
    def __init__(self,name):
        self.name = name

    def eat(self,food):
        print("%s is eating..."%self.name,food)


d = Dog("NiuHanYang")
choice = input(">>:").strip()

if hasattr(d,choice):    #輸入的字符串，判斷是否有對應字符串的方法
    func1 = getattr(d,choice)
    func1('')
else:
    setattr(d,choice,bulk) #d.talk = bulk   #經過setattr在類外部添加方法
    func2 = getattr(d, choice)
    func2(d)

# if hasattr(d.choice):   #刪除
#     delattr(d.choice)

4.__del__

建立對象後，python解釋器默認調用__init__()方法；

當刪除一個對象時，python解釋器也會默認調用一個方法，這個方法爲__del__()方法