《python小白入門系列教程》

有物件嗎？

沒有就new 一個

今天我們要用python new 一個物件

面向程序VS面向物件

1）面向程序

核心是程序（流水線式思維），程序即解決問題的步驟，面向程序的設計就好比精心設計好一條流水線，考慮周全什么時候處理什么東西，

**優點是：**極大的降低了寫程式的復雜度，只需要順著要執行的步驟，堆疊代碼即可，

**缺點是：**一套流水線或者流程就是用來解決一個問題，代碼牽一發而動全身，

**應用場景：**一旦完成基本很少改變的場景，著名的例子有Linux內核，git，以及Apache HTTP Server等，

2）面向物件

核心是物件（上帝式思維），要理解物件為何物，必須把自己當成上帝，上帝眼里世間存在的萬物皆為物件，不存在的也可以創造出來，

面向物件的程式設計好比如來設計西游記，如來要解決的問題是把經書傳給東土大唐，如來想了想解決這個問題需要四個人：唐僧，沙和尚，豬八戒，孫悟空，每個人都有各自的特征和技能（這就是物件的概念，特征和技能分別對應物件的屬性和方法）

然而這并不好玩，于是如來又安排了一群妖魔鬼怪，為了防止師徒四人在取經路上被搞死，又安排了一群神仙保駕護航，這些都是物件，然后取經開始，師徒四人與妖魔鬼怪神仙互相纏斗著直到最后取得真經，如來根本不會管師徒四人按照什么流程去取，

**優點是：解決了程式的擴展性，**對某一個物件單獨修改，會立刻反映到整個體系中，如對游戲中一個人物引數的特征和技能修改都很容易，

**缺點：可控性差，**無法向面向程序的程式設計流水線式的可以很精準的預測問題的處理流程與結果，面向物件的程式一旦開始就由物件之間的互動解決問題，即便是上帝也無法預測最終結果，于是我們經常看到一個游戲人某一引數的修改極有可能導致陰霸的技能出現，一刀砍死3個人，這個游戲就失去平衡，

**應用場景：**需求經常變化的軟體，一般需求的變化都集中在用戶層，互聯網應用，企業內部軟體，游戲等都是面向物件的程式設計大顯身手的好地方，

self

類方法與普通函式只有一種特定的區別——前者必須多加一個引數在引數串列開頭，這個名字必須添加到引數串列的開頭，但是你不用在你呼叫這個功能時為這個引數賦值，Python 會為它提供，這種特定的變數參考的是物件本身，按照慣例，它被賦予 self這一名稱，

盡管你可以為這一引數賦予任何名稱，但是強烈推薦你使用 self 這一名稱——其它的任何一種名稱絕對會引人皺眉，使用一個標準名稱能帶來諸多好處——任何一位你的程式的讀者能夠立即認出它，甚至是專門的 IDE（Integrated Development Environments，集成開發環境）也可以為你提供幫助，只要你使用了 self 這一名稱，

針對 C++/Java/C# 程式員的提示 Python 中的 self 相當于 C++ 中的 this 指標以及 Java 與 C# 中的 this 參考，

你一定會在想 Python 是如何給 self 賦值的，以及為什么你不必給它一個值，一個例子或許會讓這些疑問得到解答，假設你有一個 MyClass 的類，這個類下有一個實體 myobject ，當你呼叫一個這個物件的方法，如myobject.method(arg1, arg2) 時，Python 將會自動將其轉換成 MyClass.method(myobject, arg1, arg2) ——這就是 self 的全部特殊之處所在，

這同時意味著，如果你有一個沒有引數的方法，你依舊必須擁有一個引數—— self ，

類

最簡單的類（Class）可以通過下面的案例來展示（保存為 oop_simplestclass.py ）：

class Person
    : pass # 一個空的代碼塊 

p = Person() 
print(p)

輸出：

python oop_simplestclass.py 
<__main__.Person instance at 0x10171f518>
它是如何作業的

我們通過使用 class 陳述句與這個類的名稱來創建一個新類，在它之后是一個縮進的陳述句塊，代表這個類的主體，在本案例中，我們創建的是一個空代碼塊，使用 pass 陳述句予以標明，

然后，我們通過采用類的名稱后跟一對括號的方法，給這個類創建一個物件，為了驗證我們的操作是否成功，我們通過直接將它們列印出來來確認變數的型別，結果告訴我們我們在 Person 類的 __main__ 模塊 中擁有了一個實體，

要注意到在本例中還會列印出計算機記憶體中存盤你的物件的地址，案例中給出的地址會與你在你的電腦上所能看見的地址不相同，因為 Python 會在它找到的任何空間來存盤物件，

方法

我們已經在前面討論過類與物件一如函式那般都可以帶有方法（Method），唯一的不同在于我們還擁有一個額外的 self 變數，現在讓我們來看看下面的例子（保存為 oop_method.py ），


class Person: 
    def say_hi(self): 
        print('Hello, 大家好?') 

p = Person() 
p.say_hi() 
# 前面兩行同樣可以寫作 
# Person().say_hi()

輸出：

 python oop_method.py 
 Hello, 大家好?
它是如何作業的

這里我們就能看見 self 是如何行動的了，要注意到 say_hi 這一方法不需要引數，但是依舊在函式定義中擁有 self 變數，

init 方法

在 Python 的類中，有不少方法的名稱具有著特殊的意義，現在我們要了解的就是 __init__ 方法的意義，

__init__ 方法會在類的物件被實體化時立即運行，這一方法可以對任何你想進行操作的目標物件進行初始化操作，這里你要注意在 init 前后加上的雙下劃線，

案例（保存為 oop_init.py ）：

class Person: 
    def __init__(self, name): 
        self.name = name 
    def say_hi(self):
        print('Hello, 我的名字是', self.name) 
        
p = Person('木木') 
p.say_hi() 
# 前面兩行同時也能寫作 
# Person('Swaroop').say_hi()

輸出：

 python oop_init.py 
 Hello, 我的名字是木木
它是如何作業的

在本例中，我們定義一個接受 name 引數（當然還有 self 引數）的 __init__ 方法，在這里，我們創建了一個欄位，同樣稱為 name ，要注意到盡管它們的名字都是“name”，但這是兩個不相同的變數，雖說如此，但這并不會造成任何問題**，因為 self.name 中的點號意味著這個叫作“name”的東西是某個叫作“self”的物件的一部分，**而另一個 name 則是一個區域變量，由于我們已經如上這般明確指出了我們所指的是哪一個名字，所以它不會引發混亂，

當我們在 Person 類下創建新的實體 p 時，我們采用的方法是先寫下類的名稱，后跟括在括號中的引數，形如：p = Person('木木') ，

我們不會顯式地呼叫 __init__ 方法，這正是這個方法的特殊之處所在，

現在，我們可以使用我們方法中的 self.name 欄位了，使用的方法在 say_hi 方法中已經作過說明，

類變數與物件變數

我們已經討論過了類與物件的功能部分（即方法），現在讓我們來學習它們的資料部分，數據部分——也就是欄位——只不過是系結到類與物件的命名空間的普通變數，這就代表著這些名稱僅在這些類與物件所存在的背景關系中有效，這就是它們被稱作“命名空間”的原因，

**欄位（Field）**有兩種型別——類變數與物件變數，它們根據究竟是類還是物件擁有這些變數來進行分類，

**類變數（Class Variable）**是共享的（Shared）——它們可以被屬于該類的所有實體訪問，該類變數只擁有一個副本，當任何一個物件對類變數作出改變時，發生的變動將在其它所有實體中都會得到體現

**物件變數（Object variable）**由類的每一個獨立的物件或實體所擁有，在這種情況下，每個物件都擁有屬于它自己的欄位的副本，也就是說，它們不會被共享，也不會以任何方式與其它不同實體中的相同名稱的欄位產生關聯，下面一個例子可以幫助你理解（保存為 oop_objvar.py ）：

# coding=UTF-8 
class Robot: 
    """表示有一個帶有名字的機器人，"""
    # 一個類變數，用來計數機器人的數量 
    population = 0
    def __init__(self, name): 
        """初始化資料""" 
        self.name = name 
        print("初始化 {})".format(self.name)) 

        # 當有人被創建時，機器人 
        # 將會增加人口數量 
        Robot.population += 1
    def die(self): 
        """我掛了，""" 
        print("{} 被銷毀了!".format(self.name)) 
        
        Robot.population -= 1 
        
        if Robot.population == 0: 
            print("{} 是最后一個機器人".format(self.name)) 
        else:
            print("還有 {:d} 個機器人在作業.".format( Robot.population))
            
    def say_hi(self): 
        """來自機器人的誠摯問候 
        沒問題，你做得到，""" 
        print("大家好，我的主人叫我{}.".format(self.name))
    
    @classmethod 
    def how_many(cls): 
        """列印出當前的機器人，人口數量""" 
        print("現在還有{:d} 個機器人.".format(cls.population))

droid1 = Robot("R2-D2") 
droid1.say_hi() 
Robot.how_many()

droid2 = Robot("C-3PO") 
droid2.say_hi() 
Robot.how_many()

print("\n機器人正在努力作業.\n")

print("機器人已經完成它的使命我們要銷毀它.") 
droid1.die() 
droid2.die()

Robot.how_many()

輸出

python oop_objvar.py 
(初始化 R2-D2) 
大家好，我的主人叫我 R2-D2. 
還有 1個機器人在作業. 

(初始化 C-3PO) 
大家好，我的主人叫我 C-3PO. 
還有  2 個機器人在作業.  

機器人正在努力作業. 

機器人已經完成它的使命我們要銷毀它.

R2-D2 被銷毀了! 
還有 1 個機器人在作業.
C-3PO 被銷毀了! 
C-3PO 是最后一個機器人
還有0個機器人在作業.

它是如何作業的

這是一個比較長的案例，但是它有助于展現類與物件變數的本質，在本例中， population 屬于 Robot 類，因此它是一個類變數，name 變數屬于一個物件（通過使用 self 分配），因此它是一個物件變數，

因此，我們通過 Robot.population 而非 self.population 參考 population 類變數，我們對于 name 物件變數采用 self.name 標記法加以稱呼，這是這個物件中所具有的方法，要記住這個類變數與物件變數之間的簡單區別，同時你還要注意當一個物件變數與一個類變數名稱相同時，類變數將會被隱藏，

除了 Robot.popluation ，我們還可以使用 self.__class__.population ，因為每個物件都通過 self.__class__ 屬性來參考它的類，

how_many 實際上是一個屬于類而非屬于物件的方法，這就意味著我們可以將它定義為一個 classmethod（類方法）或是一個 staticmethod（靜態方法），這取決于我們是否需要知道這一方法屬于哪個類，由于我們已經參考了一個類變數，因此我們使用 classmethod（類方法），

我們使用裝飾器（Decorator）將how_many方法標記為類方法，

你可以將裝飾器想象為呼叫一個包裝器函式的快捷方式，因此啟用

@classmethod 裝飾器等價于呼叫：

how_many = classmethod(how_many)

你會觀察到 __init__ 方法會使用一個名字以初始化 Robot 實體，在這一方法中，我們將 population 按 1 往上增長，因為我們多增加了一臺機器人，你還會觀察到 self.name 的值是指定給每個物件的，這體現了物件變數的本質，

你需要記住你只能使用 self 來參考同一物件的變數與方法，這被稱作屬性參考，

在本程式中，我們還會看見針對類和方法的檔案字串（DocStrings）的使用方式，我們可以在運行時通過 Robot.__doc__ 訪問類的檔案字串，對于方法的檔案字串，則可以使用 Robot.say_hi.__doc__ ，

在 die 方法中，我們簡單地將 Robot.population 的計數按 1 向下減少，

所有的類成員都是公開的，但有一個例外：如果你使用資料成員并在其名字中使用雙下劃線作為前綴，形成諸如 __privatevar 這樣的形式，Python 會使用名稱調整使其有效地成為一個私有變數，

因此，你需要遵循這樣的約定：任何在類或物件之中使用的變數其命名應以下劃線開頭，其它所有非此格式的名稱都將是公開的，并可以為其它任何類或物件所使用，請記得這只是一個約定，Python 并不強制如此（除了雙下劃線前綴這點），

所有類成員（包括資料成員）都是公開的，并且 Python 中所有的方法都是虛擬的（Virtual），

繼承

面向物件編程的一大優點是對代碼的重用，重用的一種實作方法就是通過繼承機制，繼承最好是想象成在類之間實作型別與子型別

繼承是一種創建新類的方式，在python中，新建的類可以繼承一個或多個父類，父類又可稱為基類或超類，新建的類稱為派生類或子類

現在假設你希望撰寫一款程式來追蹤一所大學里的老師和學生，有一些特征是他們都具有的，例如姓名、年齡和地址，另外一些特征是他們獨有的，一如教師的薪水、課程與假期，學生的成績和學費，

你可以為每一種型別創建兩個獨立的類，并對它們進行處理，但增添一條共有特征就意味著將其添加進兩個獨立的類，這很快就會使程式變得笨重，

一個更好的方法是創建一個公共類叫作 SchoolMember ，然后讓教師和學生從這個類中繼承，也就是說他們將成為這一類的子型別，而我們就可以向這些子型別中添加某些該類獨有的特征，

同時還需要注意的是我們重用父類的代碼，但我們不需要再在其它類中重復它們，當我們使用獨立型別時才會必要地重復這些代碼，

在上文設想的情況中， SchoolMember 類會被稱作基類（Base Class）或是超類（Superclass），Teacher 和 Student 類會被稱作派生類或是子類（Subclass），

我們將通過下面的程式作為案例來進行了解（保存為 oop_subclass.py ）：

# coding=UTF-8 
class SchoolMember: 
    '''代表任何學校里的成員，''' 
    def __init__(self, name, age): 
        self.name = name 
        self.age = age 
        print('(初始化學校成員: {})'.format(self.name)) 
        
    def tell(self): 
        '''告訴我有關我的細節，''' 
        print('姓名:"{}" 年齡:"{}"'.format(self.name, self.age), end=" ") 
      
        
class Teacher(SchoolMember): 
     '''代表一位老師，''' 
    def __init__(self, name, age, salary): 
        SchoolMember.__init__(self, name, age) 
        self.salary = salary print('(初始化教師: {})'.format(self.name)) 
        
    def tell(self): 
        SchoolMember.tell(self) 
        print('薪資: "{:d}"'.format(self.salary)) 
        
        
class Student(SchoolMember): 
    '''代表一位學生，'''
    def __init__(self, name, age, marks): 
        SchoolMember.__init__(self, name, age) 
        self.marks = marks
        print('(初始化學生: {})'.format(self.name)) 
                
    def tell(self): 
        SchoolMember.tell(self) 
        print('分數: "{:d}"'.format(self.marks)) 
        
t = Teacher('曾老師', 30, 30000) 
s = Student('小明', 20, 75) 

# 列印一行空白行 
print() 

members = [t, s] 
for member in members: 
    # 對全體師生作業 
    member.tell()

輸出：

python oop_subclass.py 
(初始化學校成員: 曾老師) 
(初始化教師: 曾老師) 
(初始化學校成員: 小明) 
(初始化學生: 小明) 

姓名:"曾老師" 年齡:"30" 薪資: "30000" 
姓名:"小明" Age:"20" 分數: "75"

它是如何作業的

要想使用繼承，在定義類時我們需要在類后面跟一個包含基類名稱的元組，

然后，我們會注意到基類的\ __init__ 方法是通過 self變數被顯式呼叫的，因此我們可以初始化物件的基類部分，

下面這一點很重要，需要牢記——因為我們在 Teacher 和 Student 子類中定義了 __init__ 方法，Python 不會自動呼叫基類 SchoolMember 的建構式，你必須自己顯式地呼叫它，

相反，如果我們沒有在一個子類中定義一個 __init__ 方法，Python 將會自動呼叫基類的構造函式，

我們會觀察到，我們可以通過在方法名前面加上基類名作為前綴，再傳入 self 和其余變量，來呼叫基類的方法，

在這里你需要注意，當我們使用 SchoolMember 類的 tell 方法時，我們可以將 Teacher 或 Student 的實體看作 SchoolMember 的實體，

同時，你會發現被呼叫的是子型別的 tell 方法，而不是SchoolMember 的 tell 方法，理解這一問題的一種思路是 Python 總會從當前的實際型別中開始尋找方法，在本例中即是如此，如果它找不到對應的方法，它就會在該類所屬的基本類中依順序逐個尋找屬于基本類的方法，這個基本類是在定義子類時后跟的元組指定的，

這里有一條有關術語的注釋——如果繼承元組中有超過一個類，這種情況就會被稱作多重繼承

，

end 引數用在超類的tell() 方法的print函式中，目的是列印一行并允許下一次列印在同一行繼續，這是一個讓 print 能夠不在列印的末尾列印出 \n （新行換行符）符號的小竅門，

面向物件常用術語

抽象/實作

抽象指對現實世界問題和物體的本質表現,行為和特征建模,建立一個相關的子集,可以用于繪程式結構,從而實作這種模型，抽象不僅包括這種模型的資料屬性,還定義了這些資料的介面，

對某種抽象的實作就是對此資料及與之相關介面的現實化(realization)，現實化這個程序對于客戶程式應當是透明而且無關的，

封裝/介面

封裝描述了對資料/資訊進行隱藏的觀念,它對資料屬性提供介面和訪問函式，通過任何客戶端直接對資料的訪問,無視介面,與封裝性都是背道而馳的,除非程式員允許這些操作，作為實作的一部分,客戶端根本就不需要知道在封裝之后,資料屬性是如何組織的，在Python中,所有的類屬性都是公開的,但名字可能被“混淆”了,以阻止未經授權的訪問,但僅此而已,再沒有其他預防措施了，這就需要在設計時,對資料提供相應的介面,以免客戶程式通過不規范的操作來存取封裝的資料屬性，

注意：封裝絕不是等于“把不想讓別人看到、以后可能修改的東西用private隱藏起來”

真正的封裝是，經過深入的思考，做出良好的抽象，給出“完整且最小”的介面，并使得內部細節可以對外透明

（注意：對外透明的意思是，外部呼叫者可以順利的得到自己想要的任何功能，完全意識不到內部細節的存在）

合成

合成擴充了對類的述,使得多個不同的類合成為一個大的類,來解決現實問題，合成述了一個例外復雜的系統,比如一個類由其它類組成,更小的組件也可能是其它的類,資料屬性及行為, 所有這些合在一起,彼此是“有一個”的關系，

派生/繼承/繼承結構

派生描述了子類衍生出新的特性,新類保留已存型別別中所有需要的資料和行為,但允許修改或者其它的自定義操作,都不會修改原類的定義，
繼承描述了子類屬性從祖先類繼承這樣一種方式
繼承結構表示多“代”派生,可以述成一個“族譜”,連續的子類,與祖先類都有關系，

泛化/特化

基于繼承
泛化表示所有子類與其父類及祖先類有一樣的特點，
特化描述所有子類的自定義,也就是,什么屬性讓它與其祖先類不同，

多型與多型性

多型指的是同一種事物的多種狀態：水這種事物有多種不同的狀態：冰，水蒸氣

多型性的概念指出了物件如何通過他們共同的屬性和動作來操作及訪問,而不需考慮他們具體的類，

冰，水蒸氣，都繼承于水，它們都有一個同名的方法就是變成云，但是冰.變云(),與水蒸氣.變云()是截然不同的程序，雖然呼叫的方法都一樣

自省/反射

自省也稱作反射，這個性質展示了某物件是如何在運行期取得自身資訊的，如果傳一個物件給你,你可以查出它有什么能力,這是一項強大的特性，如果Python不支持某種形式的自省功能,dir和type內建函式,將很難正常作業，還有那些特殊屬性,像__dict__,__name__及__doc__

《python小白入門系列教程》

01-Python安裝教程與特色介紹-小白python入門基礎

02-python你應該知道這些

03python—9個基礎常識-python小白入門系列

04python—15種字串操作

05-Python—串列、元祖、字典、集合操作大全:建議收藏

06 一篇，學會python回圈與分支?

07-Python函式詳解

08-python中的包與模塊

09-python檔案處理與輸入輸出
IT入門感謝關注

練習地址：www.520mg.com/it

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/29883.html

標籤：python

上一篇：清華大佬力薦的JVM學習路線+實戰筆記+阿里真題，嚼碎吃透吊打面試官

下一篇：打造多模塊+高可用+高擴展Spring Cloud版分布式電商專案原始碼分享

10-python程式員，面向物件基礎