Python 中的面向對象編程 · ZetCode 中文系列教程

# Python 中的面向對象編程 > 原文： [http://zetcode.com/lang/python/oop/](http://zetcode.com/lang/python/oop/) 在 Python 教程的這一部分中，我們將討論 Python 中的面向對象編程。那里有三種廣泛使用的編程示例：過程編程，函數編程和面向對象的編程。 Python 支持所有三種編程示例。 ## 面向對象編程面向對象編程（OOP）是一種使用對象及其相互作用設計應用和計算機程序的編程示例。 OOP 中有一些基本的編程概念： * 抽象 * 多態 * 封裝 * 繼承抽象通過建模適合該問題的類來簡化復雜的現實。多態是將運算符或函數以不同方式用于不同數據輸入的過程。封裝對其他對象隱藏了類的實現細節。繼承是一種使用已經定義的類形成新類的方法。 ## Python 對象 Python 中的所有內容都是一個對象。對象是 Python OOP 程序的基本構建塊。 `object_types.py` ```py #!/usr/bin/env python # object_types.py import sys def function(): pass print(type(1)) print(type("")) print(type([])) print(type({})) print(type(())) print(type(object)) print(type(function)) print(type(sys)) ``` 在此示例中，我們顯示所有這些實體實際上都是對象。 `type()`函數返回指定對象的類型。 ```py $ ./object_types.py <class 'int'> <class 'str'> <class 'list'> <class 'dict'> <class 'tuple'> <class 'type'> <class 'function'> <class 'module'> ``` 整數，字符串，列表，字典，元組，函數和模塊是 Python 對象。 ## Python `class`關鍵字先前的對象都是 Python 編程語言的內置對象。用戶定義的對象是使用`class`關鍵字創建的。該類是定義未來對象性質的藍圖。從類中，我們構造實例。實例是從特定類創建的特定對象。例如，`Huck`可能是`Dog`類的實例。 `first_object.py` ```py #!/usr/bin/env python # first_object.py class First: pass fr = First() print(type(fr)) print(type(First)) ``` 這是我們的頭等艙。該類的主體暫時留空。按照慣例，給類起一個以大寫字母開頭的名稱。 ```py class First: pass ``` 在這里，我們定義`First`類。請注意，默認情況下，所有類均從基`object`繼承。 ```py fr = First() ``` 在這里，我們創建`First`類的新實例。換句話說，我們實例化了`First`類。 `fr`是對我們新對象的引用。 ```py $ ./first_object.py <class '__main__.First'> <class 'type'> ``` 在這里，我們看到`fr`是`First`類的實例對象。在類內部，我們可以定義屬性和方法。屬性是對象的特征。例如，這可以是雇員的工資。方法定義了我們可以對對象執行的操作。一種方法可以定義取消帳戶。從技術上講，屬性是變量，方法是在類內部定義的函數。 ## Python 對象初始化稱為`__init__()`的特殊方法用于初始化對象。 `object_initialization.py` ```py #!/usr/bin/env python # object_initialization.py class Being: def __init__(self): print("Being is initialized") Being() ``` 我們有一個`Being`類。創建對象后立即自動調用特殊方法`__init__()`。 ```py $ ./object_initialization.py Being is initialized ``` 這是示例輸出。 ## Python 對象屬性屬性是對象的特征。在`__init__()`方法中設置屬性。 `attributes.py` ```py #!/usr/bin/env python # attributes.py class Cat: def __init__(self, name): self.name = name missy = Cat('Missy') lucky = Cat('Lucky') print(missy.name) print(lucky.name) ``` 在此代碼示例中，我們有一個`Cat`類。創建對象后立即自動調用特殊方法`__init__()`。 ```py def __init__(self, name): ``` 類定義中的每個方法都以對實例對象的引用開頭。按照慣例，它的名稱為`self`。 `self`名稱沒有什么特別的。例如，我們可以這樣命名。第二個參數`name`是自變量。該值在類初始化期間傳遞。 ```py self.name = name ``` 在這里，我們將屬性傳遞給實例對象。 ```py missy = Cat('Missy') lucky = Cat('Lucky') ``` 在這里，我們創建兩個對象：貓`Missy`和`Lucky`。參數的數量必須與類定義的`__init__()`方法相對應。 `"Missy"`和`"Lucky"`字符串成為`__init__()`方法的`name`參數。 ```py print(missy.name) print(lucky.name) ``` 在這里，我們打印兩個貓對象的屬性。一個類的每個實例可以有自己的屬性。 ```py $ ./attributes.py Missy Lucky ``` 可以動態分配屬性，而不僅僅是在初始化過程中。下一個示例對此進行了說明。 `attributes_dynamic.py` ```py #!/usr/bin/env python # attributes_dynamic.py class Person: pass p = Person() p.age = 24 p.name = "Peter" print("{0} is {1} years old".format(p.name, p.age)) ``` 我們定義并創建一個空的`Person`類。 ```py p.age = 24 p.name = "Peter" ``` 在這里，我們動態創建兩個屬性：`age`和`name`。 ```py $ ./attributes_dynamic.py 24 is Peter years old ``` ## Python 類屬性到目前為止，我們一直在討論實例屬性。在 Python 中，還有所謂的類對象屬性。類的所有實例的類對象屬性都相同。 `class_attribute.py` ```py #!/usr/bin/env python # class_attribute.py class Cat: species = 'mammal' def __init__(self, name, age): self.name = name self.age = age missy = Cat('Missy', 3) lucky = Cat('Lucky', 5) print(missy.name, missy.age) print(lucky.name, lucky.age) print(Cat.species) print(missy.__class__.species) print(lucky.__class__.species) ``` 在我們的示例中，我們有兩只具有特定`name`和`age`屬性的貓。兩只貓都有一些共同之處。小姐和幸運者都是哺乳動物。這反映在類級別屬性`species`中。該屬性是在類主體中的任何方法名稱之外定義的。 ```py print(Cat.species) print(missy.__class__.species) ``` 有兩種方法可以訪問類對象屬性：通過`Cat`類的名稱，或借助特殊的`__class__`屬性。 ```py $ ./class_attribute.py Missy 3 Lucky 5 mammal mammal mammal ``` ## Python 方法方法是在類主體內定義的函數。它們用于通過對象的屬性執行操作。在 OOP 范式的封裝概念中，方法至關重要。例如，我們的`AccessDatabase`類中可能有一個`connect()`方法。我們無需知道方法連接如何準確地連接到數據庫。我們只知道它用于連接數據庫。這對于劃分編程中的職責至關重要，尤其是在大型應用中。 `methods.py` ```py #!/usr/bin/env python # methods.py class Circle: pi = 3.141592 def __init__(self, radius=1): self.radius = radius def area(self): return self.radius * self.radius * Circle.pi def setRadius(self, radius): self.radius = radius def getRadius(self): return self.radius c = Circle() c.setRadius(5) print(c.getRadius()) print(c.area()) ``` 在代碼示例中，我們有一個`Circle`類。我們定義了三種新方法。 ```py def area(self): return self.radius * self.radius * Circle.pi ``` `area()`方法返回圓的面積。 ```py def setRadius(self, radius): self.radius = radius ``` `setRadius()`方法為`radius`屬性設置新值。 ```py def getRadius(self): return self.radius ``` `getRadius()`方法返回當前半徑。 ```py c.setRadius(5) ``` 在實例對象上調用該方法。 `c`對象與類定義的`self`參數配對。數字 5 與`radius`參數配對。 ```py $ ./methods.py 5 78.5398 ``` 在 Python 中，我們可以通過兩種方式調用方法。有有界的和無界的方法調用。 `bound_unbound_methods.py` ```py #!/usr/bin/env python # bound_unbound_methods.py class Methods: def __init__(self): self.name = 'Methods' def getName(self): return self.name m = Methods() print(m.getName()) print(Methods.getName(m)) ``` 在此示例中，我們演示了兩個方法調用。 ```py print(m.getName()) ``` 這是綁定的方法調用。 Python 解釋器會自動將`m`實例與`self`參數配對。 ```py print(Methods.getName(m)) ``` 這是無界的方法調用。實例對象已顯式提供給`getName()`方法。 ```py $ ./bound_unbound_methods.py Methods Methods ``` ## Python 繼承繼承是一種使用已經定義的類形成新類的方法。新形成的類稱為派生的類，我們從中衍生的類稱為基類。繼承的重要好處是代碼重用和降低程序的復雜性。派生類（后代）將覆蓋或擴展基類（祖先）的功能。 `inheritance.py` ```py #!/usr/bin/env python # inheritance.py class Animal: def __init__(self): print("Animal created") def whoAmI(self): print("Animal") def eat(self): print("Eating") class Dog(Animal): def __init__(self): super().__init__() print("Dog created") def whoAmI(self): print("Dog") def bark(self): print("Woof!") d = Dog() d.whoAmI() d.eat() d.bark() ``` 在此示例中，我們有兩個類：`Animal`和`Dog`。 `Animal`是基類，`Dog`是派生類。派生類繼承基類的功能。通過`eat()`方法顯示。派生的類修改了基類的現有行為，如`whoAmI()`方法所示。最后，派生類通過定義新的`bark()`方法來擴展基類的功能。 ```py class Dog(Animal): def __init__(self): super().__init__() print("Dog created") ``` 我們將祖先類放在子孫類名稱之后的圓括號中。如果派生類提供了自己的`__init__()`方法，并且我們想調用父構造器，則必須借助`super`函數顯式調用基類`__init__()`方法。 ```py $ ./inherit.py Animal created Dog created Dog Eating Woof! ``` ## Python 多態多態是對不同的數據輸入以不同方式使用運算符或函數的過程。實際上，多態意味著如果類 B 從類 A 繼承，則不必繼承關于類 A 的所有內容；它可以完成 A 類所做的某些事情。 `basic_polymorphism.py` ```py #!/usr/bin/env python # basic_polymorphism.py a = "alfa" b = (1, 2, 3, 4) c = ['o', 'm', 'e', 'g', 'a'] print(a[2]) print(b[1]) print(c[3]) ``` Python 在內置類型中廣泛使用了多態。在這里，我們對三種不同的數據類型使用相同的索引運算符。 ```py $ ./basic_polymorphism.py f 2 g ``` 多態在處理繼承時最常用。 `polymorphism.py` ```py #!/usr/bin/env python # polymorphism.py class Animal: def __init__(self, name=''): self.name = name def talk(self): pass class Cat(Animal): def talk(self): print("Meow!") class Dog(Animal): def talk(self): print("Woof!") a = Animal() a.talk() c = Cat("Missy") c.talk() d = Dog("Rocky") d.talk() ``` 在這里，我們有兩種：狗和貓。兩者都是動物。 `Dog`類和`Cat`類繼承了`Animal`類。它們具有`talk()`方法，可以為它們提供不同的輸出。 ```py $ ./polymorphism.py Meow! Woof! ``` ## Python 特殊方法 Python 編程語言中的類可以使用特殊的方法名稱來實現某些操作。這些方法不是直接調用，而是通過特定的語言語法調用。這類似于在 C++ 或 Ruby 中所謂的運算符重載。 `special_methods.py` ```py #!/usr/bin/env python # special_methods.py class Book: def __init__(self, title, author, pages): print("A book is created") self.title = title self.author = author self.pages = pages def __str__(self): return "Title:{0} , author:{1}, pages:{2} ".format( self.title, self.author, self.pages) def __len__(self): return self.pages def __del__(self): print("A book is destroyed") book = Book("Inside Steve's Brain", "Leander Kahney", 304) print(book) print(len(book)) del book ``` 在我們的代碼示例中，我們有一個`book`類。在這里，我們介紹四種特殊方法：`__init__()`，`__str__()`，`__len__()`和`__del__()`。 ```py book = Book("Inside Steve's Brain", "Leander Kahney", 304) ``` 在這里，我們稱為`__init__()`方法。該方法創建`Book`類的新實例。 ```py print(book) ``` `print`關鍵字調用`__str__()`方法。此方法應返回對象的非正式字符串表示形式。 ```py print(len(book)) ``` `len()`函數調用`__len__()`方法。就我們而言，我們打印書的頁數。 ```py del book ``` `del`關鍵字刪除一個對象。它調用其`__del__()`方法。在下一個示例中，我們實現一個向量類并演示對其的加法和減法運算。 `vector.py` ```py #!/usr/bin/env python # vector.py class Vector: def __init__(self, data): self.data = data def __str__(self): return repr(self.data) def __add__(self, other): data = [] for j in range(len(self.data)): data.append(self.data[j] + other.data[j]) return Vector(data) def __sub__(self, other): data = [] for j in range(len(self.data)): data.append(self.data[j] - other.data[j]) return Vector(data) x = Vector([1, 2, 3]) y = Vector([3, 0, 2]) print(x + y) print(y - x) ``` 該示例介紹了`__add__`和`__sub__`方法。 ```py def __add__(self, other): data = [] for j in range(len(self.data)): data.append(self.data[j] + other.data[j]) return Vector(data) ``` 在這里，我們實現向量的加法運算。當我們使用`+`運算符添加兩個`Vector`對象時，將調用`__add__()`方法。在這里，我們將各個向量的每個成員相加。 ```py $ ./vector.py [4, 2, 5] [2, -2, -1] ``` 這是輸出。在 Python 教程的這一部分中，我們介紹了 Python 中的面向對象編程。