Python面向?qū)ο筮M(jìn)階學(xué)習(xí)
在前面的章節(jié)我們已經(jīng)了解了面向?qū)ο蟮娜腴T知識，知道了如何定義類，如何創(chuàng)建對象以及如何給對象發(fā)消息。為了能夠更好的使用面向?qū)ο缶幊趟枷脒M(jìn)行程序開發(fā)，我們還需要對Python中的面向?qū)ο缶幊踢M(jìn)行更為深入的了解。
@property裝飾器
之前我們討論過Python中屬性和方法訪問權(quán)限的問題，雖然我們不建議將屬性設(shè)置為私有的，但是如果直接將屬性暴露給外界也是有問題的，比如我們沒有辦法檢查賦給屬性的值是否有效。我們之前的建議是將屬性命名以單下劃線開頭，通過這種方式來暗示屬性是受保護(hù)的，不建議外界直接訪問，那么如果想訪問屬性可以通過屬性的getter（訪問器）和setter（修改器）方法進(jìn)行對應(yīng)的操作。如果要做到這點(diǎn)，就可以考慮使用@property包裝器來包裝getter和setter方法，使得對屬性的訪問既安全又方便，代碼如下所示。
class Person(object):
def __init__(self, name, age):
self._name = name
self._age = age
# 訪問器 - getter方法
@property
def name(self):
return self._name
# 訪問器 - getter方法
@property
def age(self):
return self._age
# 修改器 - setter方法
@age.setter
def age(self, age):
self._age = age
def play(self):
if self._age <= 16:
print('%s正在玩飛行棋.' % self._name)
else:
print('%s正在玩斗地主.' % self._name)
def main():
person = Person('王大錘', 12)
person.play()
person.age = 22
person.play()
# person.name = '白元芳' # AttributeError: can't set attribute
if __name__ == '__main__':
main()
__slots__魔法
我們講到這里，不知道大家是否已經(jīng)意識到，Python是一門動態(tài)語言。通常，動態(tài)語言允許我們在程序運(yùn)行時(shí)給對象綁定新的屬性或方法，當(dāng)然也可以對已經(jīng)綁定的屬性和方法進(jìn)行解綁定。但是如果我們需要限定自定義類型的對象只能綁定某些屬性，可以通過在類中定義__slots__變量來進(jìn)行限定。需要注意的是__slots__的限定只對當(dāng)前類的對象生效，對子類并不起任何作用。
class Person(object):
# 限定Person對象只能綁定_name, _age和_gender屬性
__slots__ = ('_name', '_age', '_gender')
def __init__(self, name, age):
self._name = name
self._age = age
@property
def name(self):
return self._name
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def play(self):
if self._age <= 16:
print('%s正在玩飛行棋.' % self._name)
else:
print('%s正在玩斗地主.' % self._name)
def main():
person = Person('王大錘', 22)
person.play()
person._gender = '男'
# AttributeError: 'Person' object has no attribute '_is_gay'
# person._is_gay = True
靜態(tài)方法和類方法
之前，我們在類中定義的方法都是對象方法，也就是說這些方法都是發(fā)送給對象的消息。實(shí)際上，我們寫在類中的方法并不需要都是對象方法，例如我們定義一個(gè)“三角形”類，通過傳入三條邊長來構(gòu)造三角形，并提供計(jì)算周長和面積的方法，但是傳入的三條邊長未必能構(gòu)造出三角形對象，因此我們可以先寫一個(gè)方法來驗(yàn)證三條邊長是否可以構(gòu)成三角形，這個(gè)方法很顯然就不是對象方法，因?yàn)樵谡{(diào)用這個(gè)方法時(shí)三角形對象尚未創(chuàng)建出來（因?yàn)槎疾恢廊龡l邊能不能構(gòu)成三角形），所以這個(gè)方法是屬于三角形類而并不屬于三角形對象的。我們可以使用靜態(tài)方法來解決這類問題，代碼如下所示。
from math import sqrt
class Triangle(object):
def __init__(self, a, b, c):
self._a = a
self._b = b
self._c = c
@staticmethod
def is_valid(a, b, c):
return a + b > c and b + c > a and a + c > b
def perimeter(self):
return self._a + self._b + self._c
def area(self):
half = self.perimeter() / 2
return sqrt(half * (half - self._a) *
(half - self._b) * (half - self._c))
def main():
a, b, c = 3, 4, 5
# 靜態(tài)方法和類方法都是通過給類發(fā)消息來調(diào)用的
if Triangle.is_valid(a, b, c):
t = Triangle(a, b, c)
print(t.perimeter())
# 也可以通過給類發(fā)消息來調(diào)用對象方法但是要傳入接收消息的對象作為參數(shù)
# print(Triangle.perimeter(t))
print(t.area())
# print(Triangle.area(t))
else:
print('無法構(gòu)成三角形.')
if __name__ == '__main__':
main()
和靜態(tài)方法比較類似，Python還可以在類中定義類方法，類方法的第一個(gè)參數(shù)約定名為cls，它代表的是當(dāng)前類相關(guān)的信息的對象（類本身也是一個(gè)對象，有的地方也稱之為類的元數(shù)據(jù)對象），通過這個(gè)參數(shù)我們可以獲取和類相關(guān)的信息并且可以創(chuàng)建出類的對象，代碼如下所示。
from time import time, localtime, sleep
class Clock(object):
"""數(shù)字時(shí)鐘"""
def __init__(self, hour=0, minute=0, second=0):
self._hour = hour
self._minute = minute
self._second = second
@classmethod
def now(cls):
ctime = localtime(time())
return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
def run(self):
"""走字"""
self._second += 1
if self._second == 60:
self._second = 0
self._minute += 1
if self._minute == 60:
self._minute = 0
self._hour += 1
if self._hour == 24:
self._hour = 0
def show(self):
"""顯示時(shí)間"""
return '%02d:%02d:%02d' % \
(self._hour, self._minute, self._second)
def main():
# 通過類方法創(chuàng)建對象并獲取系統(tǒng)時(shí)間
clock = Clock.now()
while True:
print(clock.show())
sleep(1)
clock.run()
if __name__ == '__main__':
main()
類之間的關(guān)系
簡單的說，類和類之間的關(guān)系有三種：is-a、has-a和use-a關(guān)系。
is-a關(guān)系也叫繼承或泛化，比如學(xué)生和人的關(guān)系、手機(jī)和電子產(chǎn)品的關(guān)系都屬于繼承關(guān)系。
has-a關(guān)系通常稱之為關(guān)聯(lián)，比如部門和員工的關(guān)系，汽車和引擎的關(guān)系都屬于關(guān)聯(lián)關(guān)系；關(guān)聯(lián)關(guān)系如果是整體和部分的關(guān)聯(lián)，那么我們稱之為聚合關(guān)系；如果整體進(jìn)一步負(fù)責(zé)了部分的生命周期（整體和部分是不可分割的，同時(shí)同在也同時(shí)消亡），那么這種就是最強(qiáng)的關(guān)聯(lián)關(guān)系，我們稱之為合成關(guān)系。
use-a關(guān)系通常稱之為依賴，比如司機(jī)有一個(gè)駕駛的行為（方法），其中（的參數(shù)）使用到了汽車，那么司機(jī)和汽車的關(guān)系就是依賴關(guān)系。
我們可以使用一種叫做UML（統(tǒng)一建模語言）的東西來進(jìn)行面向?qū)ο蠼?，其中一?xiàng)重要的工作就是把類和類之間的關(guān)系用標(biāo)準(zhǔn)化的圖形符號描述出來。關(guān)于UML我們在這里不做詳細(xì)的介紹，有興趣的讀者可以自行閱讀《UML面向?qū)ο笤O(shè)計(jì)基礎(chǔ)》一書。
利用類之間的這些關(guān)系，我們可以在已有類的基礎(chǔ)上來完成某些操作，也可以在已有類的基礎(chǔ)上創(chuàng)建新的類，這些都是實(shí)現(xiàn)代碼復(fù)用的重要手段。復(fù)用現(xiàn)有的代碼不僅可以減少開發(fā)的工作量，也有利于代碼的管理和維護(hù)，這是我們在日常工作中都會使用到的技術(shù)手段。
繼承和多態(tài)
剛才我們提到了，可以在已有類的基礎(chǔ)上創(chuàng)建新類，這其中的一種做法就是讓一個(gè)類從另一個(gè)類那里將屬性和方法直接繼承下來，從而減少重復(fù)代碼的編寫。提供繼承信息的我們稱之為父類，也叫超類或基類；得到繼承信息的我們稱之為子類，也叫派生類或衍生類。子類除了繼承父類提供的屬性和方法，還可以定義自己特有的屬性和方法，所以子類比父類擁有的更多的能力，在實(shí)際開發(fā)中，我們經(jīng)常會用子類對象去替換掉一個(gè)父類對象，這是面向?qū)ο缶幊讨幸粋€(gè)常見的行為，對應(yīng)的原則稱之為里氏替換原則。下面我們先看一個(gè)繼承的例子。
class Person(object):
"""人"""
def __init__(self, name, age):
self._name = name
self._age = age
@property
def name(self):
return self._name
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def play(self):
print('%s正在愉快的玩耍.' % self._name)
def watch_av(self):
if self._age >= 18:
print('%s正在觀看愛情動作片.' % self._name)
else:
print('%s只能觀看《熊出沒》.' % self._name)
class Student(Person):
"""學(xué)生"""
def __init__(self, name, age, grade):
super().__init__(name, age)
self._grade = grade
@property
def grade(self):
return self._grade
@grade.setter
def grade(self, grade):
self._grade = grade
def study(self, course):
print('%s的%s正在學(xué)習(xí)%s.' % (self._grade, self._name, course))
class Teacher(Person):
"""老師"""
def __init__(self, name, age, title):
super().__init__(name, age)
self._title = title
@property
def title(self):
return self._title
@title.setter
def title(self, title):
self._title = title
def teach(self, course):
print('%s%s正在講%s.' % (self._name, self._title, course))
def main():
stu = Student('王大錘', 15, '初三')
stu.study('數(shù)學(xué)')
stu.watch_av()
t = Teacher('駱昊', 38, '老叫獸')
t.teach('Python程序設(shè)計(jì)')
t.watch_av()
if __name__ == '__main__':
main()
子類在繼承了父類的方法后，可以對父類已有的方法給出新的實(shí)現(xiàn)版本，這個(gè)動作稱之為方法重寫（override）。通過方法重寫我們可以讓父類的同一個(gè)行為在子類中擁有不同的實(shí)現(xiàn)版本，當(dāng)我們調(diào)用這個(gè)經(jīng)過子類重寫的方法時(shí)，不同的子類對象會表現(xiàn)出不同的行為，這個(gè)就是多態(tài)（poly-morphism）。
from abc import ABCMeta, abstractmethod
class Pet(object, metaclass=ABCMeta):
"""寵物"""
def __init__(self, nickname):
self._nickname = nickname
@abstractmethod
def make_voice(self):
"""發(fā)出聲音"""
pass
class Dog(Pet):
"""狗"""
def make_voice(self):
print('%s: 汪汪汪...' % self._nickname)
class Cat(Pet):
"""貓"""
def make_voice(self):
print('%s: 喵...喵...' % self._nickname)
def main():
pets = [Dog('旺財(cái)'), Cat('凱蒂'), Dog('大黃')]
for pet in pets:
pet.make_voice()
if __name__ == '__main__':
main()
在上面的代碼中，我們將Pet類處理成了一個(gè)抽象類，所謂抽象類就是不能夠創(chuàng)建對象的類，這種類的存在就是專門為了讓其他類去繼承它。Python從語法層面并沒有像Java或C#那樣提供對抽象類的支持，但是我們可以通過abc模塊的ABCMeta元類和abstractmethod包裝器來達(dá)到抽象類的效果，如果一個(gè)類中存在抽象方法那么這個(gè)類就不能夠?qū)嵗▌?chuàng)建對象）。上面的代碼中，Dog和Cat兩個(gè)子類分別對Pet類中的make_voice抽象方法進(jìn)行了重寫并給出了不同的實(shí)現(xiàn)版本，當(dāng)我們在main函數(shù)中調(diào)用該方法時(shí)，這個(gè)方法就表現(xiàn)出了多態(tài)行為（同樣的方法做了不同的事情）。
綜合案例
案例1：奧特曼打小怪獸
from abc import ABCMeta, abstractmethod
from random import randint, randrange
class Fighter(object, metaclass=ABCMeta):
"""戰(zhàn)斗者"""
# 通過__slots__魔法限定對象可以綁定的成員變量
__slots__ = ('_name', '_hp')
def __init__(self, name, hp):
"""初始化方法
:param name: 名字
:param hp: 生命值
"""
self._name = name
self._hp = hp
@property
def name(self):
return self._name
@property
def hp(self):
return self._hp
@hp.setter
def hp(self, hp):
self._hp = hp if hp >= 0 else 0
@property
def alive(self):
return self._hp > 0
@abstractmethod
def attack(self, other):
"""攻擊
:param other: 被攻擊的對象
"""
pass
class Ultraman(Fighter):
"""奧特曼"""
__slots__ = ('_name', '_hp', '_mp')
def __init__(self, name, hp, mp):
"""初始化方法
:param name: 名字
:param hp: 生命值
:param mp: 魔法值
"""
super().__init__(name, hp)
self._mp = mp
def attack(self, other):
other.hp -= randint(15, 25)
def huge_attack(self, other):
"""究極必殺技(打掉對方至少50點(diǎn)或四分之三的血)
:param other: 被攻擊的對象
:return: 使用成功返回True否則返回False
"""
if self._mp >= 50:
self._mp -= 50
injury = other.hp * 3 // 4
injury = injury if injury >= 50 else 50
other.hp -= injury
return True
else:
self.attack(other)
return False
def magic_attack(self, others):
"""魔法攻擊
:param others: 被攻擊的群體
:return: 使用魔法成功返回True否則返回False
"""
if self._mp >= 20:
self._mp -= 20
for temp in others:
if temp.alive:
temp.hp -= randint(10, 15)
return True
else:
return False
def resume(self):
"""恢復(fù)魔法值"""
incr_point = randint(1, 10)
self._mp += incr_point
return incr_point
def __str__(self):
return '~~~%s奧特曼~~~\n' % self._name + \
'生命值: %d\n' % self._hp + \
'魔法值: %d\n' % self._mp
class Monster(Fighter):
"""小怪獸"""
__slots__ = ('_name', '_hp')
def attack(self, other):
other.hp -= randint(10, 20)
def __str__(self):
return '~~~%s小怪獸~~~\n' % self._name + \
'生命值: %d\n' % self._hp
def is_any_alive(monsters):
"""判斷有沒有小怪獸是活著的"""
for monster in monsters:
if monster.alive > 0:
return True
return False
def select_alive_one(monsters):
"""選中一只活著的小怪獸"""
monsters_len = len(monsters)
while True:
index = randrange(monsters_len)
monster = monsters[index]
if monster.alive > 0:
return monster
def display_info(ultraman, monsters):
"""顯示奧特曼和小怪獸的信息"""
print(ultraman)
for monster in monsters:
print(monster, end='')
def main():
u = Ultraman('駱昊', 1000, 120)
m1 = Monster('狄仁杰', 250)
m2 = Monster('白元芳', 500)
m3 = Monster('王大錘', 750)
ms = [m1, m2, m3]
fight_round = 1
while u.alive and is_any_alive(ms):
print('========第%02d回合========' % fight_round)
m = select_alive_one(ms) # 選中一只小怪獸
skill = randint(1, 10) # 通過隨機(jī)數(shù)選擇使用哪種技能
if skill <= 6: # 60%的概率使用普通攻擊
print('%s使用普通攻擊打了%s.' % (u.name, m.name))
u.attack(m)
print('%s的魔法值恢復(fù)了%d點(diǎn).' % (u.name, u.resume()))
elif skill <= 9: # 30%的概率使用魔法攻擊(可能因魔法值不足而失敗)
if u.magic_attack(ms):
print('%s使用了魔法攻擊.' % u.name)
else:
print('%s使用魔法失敗.' % u.name)
else: # 10%的概率使用究極必殺技(如果魔法值不足則使用普通攻擊)
if u.huge_attack(m):
print('%s使用究極必殺技虐了%s.' % (u.name, m.name))
else:
print('%s使用普通攻擊打了%s.' % (u.name, m.name))
print('%s的魔法值恢復(fù)了%d點(diǎn).' % (u.name, u.resume()))
if m.alive > 0: # 如果選中的小怪獸沒有死就回?fù)魥W特曼
print('%s回?fù)袅?s.' % (m.name, u.name))
m.attack(u)
display_info(u, ms) # 每個(gè)回合結(jié)束后顯示奧特曼和小怪獸的信息
fight_round += 1
print('\n========戰(zhàn)斗結(jié)束!========\n')
if u.alive > 0:
print('%s奧特曼勝利!' % u.name)
else:
print('小怪獸勝利!')
if __name__ == '__main__':
main()
案例2：撲克游戲
import random
class Card(object):
"""一張牌"""
def __init__(self, suite, face):
self._suite = suite
self._face = face
@property
def face(self):
return self._face
@property
def suite(self):
return self._suite
def __str__(self):
if self._face == 1:
face_str = 'A'
elif self._face == 11:
face_str = 'J'
elif self._face == 12:
face_str = 'Q'
elif self._face == 13:
face_str = 'K'
else:
face_str = str(self._face)
return '%s%s' % (self._suite, face_str)
def __repr__(self):
return self.__str__()
class Poker(object):
"""一副牌"""
def __init__(self):
self._cards = [Card(suite, face)
for suite in '♠♥♣♦'
for face in range(1, 14)]
self._current = 0
@property
def cards(self):
return self._cards
def shuffle(self):
"""洗牌(隨機(jī)亂序)"""
self._current = 0
random.shuffle(self._cards)
@property
def next(self):
"""發(fā)牌"""
card = self._cards[self._current]
self._current += 1
return card
@property
def has_next(self):
"""還有沒有牌"""
return self._current < len(self._cards)
class Player(object):
"""玩家"""
def __init__(self, name):
self._name = name
self._cards_on_hand = []
@property
def name(self):
return self._name
@property
def cards_on_hand(self):
return self._cards_on_hand
def get(self, card):
"""摸牌"""
self._cards_on_hand.append(card)
def arrange(self, card_key):
"""玩家整理手上的牌"""
self._cards_on_hand.sort(key=card_key)
# 排序規(guī)則-先根據(jù)花色再根據(jù)點(diǎn)數(shù)排序
def get_key(card):
return (card.suite, card.face)
def main():
p = Poker()
p.shuffle()
players = [Player('東邪'), Player('西毒'), Player('南帝'), Player('北丐')]
for _ in range(13):
for player in players:
player.get(p.next)
for player in players:
print(player.name + ':', end=' ')
player.arrange(get_key)
print(player.cards_on_hand)
if __name__ == '__main__':
main()
說明： 大家可以自己嘗試在上面代碼的基礎(chǔ)上寫一個(gè)簡單的撲克游戲，例如21點(diǎn)(Black Jack)，游戲的規(guī)則可以自己在網(wǎng)上找一找。
案例3：工資結(jié)算系統(tǒng)
"""
某公司有三種類型的員工 分別是部門經(jīng)理、程序員和銷售員
需要設(shè)計(jì)一個(gè)工資結(jié)算系統(tǒng) 根據(jù)提供的員工信息來計(jì)算月薪
部門經(jīng)理的月薪是每月固定15000元
程序員的月薪按本月工作時(shí)間計(jì)算 每小時(shí)150元
銷售員的月薪是1200元的底薪加上銷售額5%的提成
"""
from abc import ABCMeta, abstractmethod
class Employee(object, metaclass=ABCMeta):
"""員工"""
def __init__(self, name):
"""
初始化方法
:param name: 姓名
"""
self._name = name
@property
def name(self):
return self._name
@abstractmethod
def get_salary(self):
"""
獲得月薪
:return: 月薪
"""
pass
class Manager(Employee):
"""部門經(jīng)理"""
def get_salary(self):
return 15000.0
class Programmer(Employee):
"""程序員"""
def __init__(self, name, working_hour=0):
super().__init__(name)
self._working_hour = working_hour
@property
def working_hour(self):
return self._working_hour
@working_hour.setter
def working_hour(self, working_hour):
self._working_hour = working_hour if working_hour > 0 else 0
def get_salary(self):
return 150.0 * self._working_hour
class Salesman(Employee):
"""銷售員"""
def __init__(self, name, sales=0):
super().__init__(name)
self._sales = sales
@property
def sales(self):
return self._sales
@sales.setter
def sales(self, sales):
self._sales = sales if sales > 0 else 0
def get_salary(self):
return 1200.0 + self._sales * 0.05
def main():
emps = [
Manager('劉備'), Programmer('諸葛亮'),
Manager('曹操'), Salesman('荀彧'),
Salesman('呂布'), Programmer('張遼'),
Programmer('趙云')
]
for emp in emps:
if isinstance(emp, Programmer):
emp.working_hour = int(input('請輸入%s本月工作時(shí)間: ' % emp.name))
elif isinstance(emp, Salesman):
emp.sales = float(input('請輸入%s本月銷售額: ' % emp.name))
# 同樣是接收get_salary這個(gè)消息但是不同的員工表現(xiàn)出了不同的行為(多態(tài))
print('%s本月工資為: ￥%s元' %
(emp.name, emp.get_salary()))
if __name__ == '__main__':
main()
相關(guān)文章
Python寫的一個(gè)簡單DNS服務(wù)器實(shí)例
這篇文章主要介紹了Python寫的一個(gè)簡單DNS服務(wù)器實(shí)例,需要的朋友可以參考下2014-06-06
Python根據(jù)歐拉角求旋轉(zhuǎn)矩陣的實(shí)例
今天小編就為大家分享一篇Python根據(jù)歐拉角求旋轉(zhuǎn)矩陣的實(shí)例，具有很好的參考價(jià)值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-01-01
Tkinter中的Frame控件是一個(gè)用于組織和管理其他控件的容器,它可以將其他控件放置在自己內(nèi)部,用于創(chuàng)建更復(fù)雜的用戶界面,要創(chuàng)建一個(gè)Frame控件,可以使用Tkinter的Frame類,所以本文就通過一個(gè)簡單的示例給大家介紹一下2023-08-08
本文主要介紹了pycharm中執(zhí)行.sh文件的方法步驟，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2023-02-02
Python3實(shí)現(xiàn)zip分卷壓縮過程解析
這篇文章主要介紹了Python3實(shí)現(xiàn)zip分卷壓縮過程解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2019-10-10
這篇文章主要為大家詳細(xì)介紹了python監(jiān)控文件，并且發(fā)送告警郵件，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2018-06-06
Python numpy.array()生成相同元素?cái)?shù)組的示例
今天小編就為大家分享一篇Python numpy.array()生成相同元素?cái)?shù)組的示例，具有很好的參考價(jià)值，希望對大家有所幫助。一起跟隨小編過來看看吧2018-11-11
Django自帶用戶認(rèn)證系統(tǒng)使用方法解析
這篇文章主要介紹了Django自帶用戶認(rèn)證系統(tǒng)使用方法解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2020-11-11
初學(xué)者學(xué)習(xí)Python好還是Java好
在本篇文章里小編給大家分享的是關(guān)于初學(xué)者學(xué)習(xí)Python好還是Java好的相關(guān)內(nèi)容，需要的朋友們可以學(xué)習(xí)下。2020-05-05
這篇文章主要介紹了python如何在字典中插入或增加一個(gè)字典問題,具有很好的參考價(jià)值,希望對大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2024-03-03