python面向物件編程的基本概念-有解無憂

作者|HIMANSHI SINGH
編譯|VK
來源|Analytics Vidhya

介紹

在學習面向物件編程時，我決定深入研究它的歷史，結果發現它很迷人，術語“面向物件編程”(OOP)是Alan Kay 在1966年研究生院時提出的，

Simula語言是第一種具有面向物件編程特點的編程語言，它是在1967年開發的，用于制作模擬程式，其中最重要的資訊稱為物件，

盡管OOPS自20世紀60年代初就在市場上，但在20世紀90年代，OOPS開始因為C++而增長，

除此之外，這種編程技術已經被包括Python在內的各種編程語言所采用，它的應用幾乎遍及所有領域，如實時系統、人工智能、專家系統、CS系統、面向物件資料庫等等，

因此，在本文中，我將解釋Python中面向物件編程的基本概念，

什么是面向物件編程？

面向物件編程(OOP)就是創建“物件”，物件是一組相互關聯的變數和函式，這些變數通常稱為物件的屬性，函式稱為物件的行為，這些物件為程式提供了一個更好、更清晰的結構，

例如，汽車可以是一個物件，如果我們把汽車當作一個物件，那么它的屬性就是——顏色、型號、價格、品牌等等，它的行為/函式是加速、減速、換擋，

另一個例子——如果我們把狗當作一個物體，那么它的屬性就是——它的顏色、品種、名字、體重等，而它的行為/函式是行走、吠叫、玩耍等，

面向物件編程因其在編程中實作了物件、隱藏、繼承等現實物體而聞名，它使可視化更容易，因為它接近真實世界的場景，

面向物件編程(OOP)與面向程序編程(POP)

OOP和程序式編程的基本區別是

一種思考POP的方法就是你做檸檬水的方式，制作檸檬水的程序包括——首先根據需要取水，然后在水中加入糖，然后在混合物中加入檸檬汁，最后將整個溶液混合，這樣你的檸檬水就準備好了，同樣，POP也需要一定的步驟，程式程式由函陣列成，這意味著在POP方法中，程式被劃分為特定于不同任務的函式，這些功能按特定的順序排列，程式的控制按順序進行，
而OOP程式是由物件組成的，面向物件方法將程式劃分為物件，這些物件是將現實世界物件的屬性和行為捆綁在一起的物體，
POP只適用于小任務，因為隨著程式長度的增加，代碼的復雜性也隨之增加，最后變成了一個函式網，而且，它變得很難除錯，OOP通過更清晰、以更不復雜的結構來解決這個問題，它允許以繼承的形式重新使用代碼，
另一個重要的是，在面向程序的編程中，所有函式都可以訪問所有資料，這意味著缺乏安全性，假設你想保護來自世界各地的憑據或任何其他關鍵資訊，那么程式化方法就不能為你提供這種安全性，因為這個OOP幫助你實作了一個稱為封裝的驚人功能，它允許我們隱藏資料，不用擔心，在本文的后半部分，我將詳細介紹這一點以及面向物件編程的其他概念，現在，只需理解OOP支持安全性，POP不支持，
編程語言如C、Pascal和Basic使用程序方法，而java、Python、JavaScript、PHP、Scala和C++是提供面向物件方法的主要語言，

OOPs的主要概念

在本節中，我們將深入探討OOP的基本概念，我們將討論以下主題

類
物件
方法
繼承
封裝
多型性
資料抽象

1.什么是類？

這個問題的直接答案是：類是物件的集合，與原始資料結構不同，類是用戶定義的資料結構，它們使代碼更易于管理，

讓我們看看如何定義下面的類

class class_name:
    class body

我們用關鍵字“class”在類名和分號后面定義一個類，在使用縮進之后，我們會考慮有縮進的所有東西，為了讓這更容易理解，讓我們看一個例子，

以汽車展廳為例，你要存盤每輛車的詳細資訊，讓我們首先定義一個類

class Car:
    pass

就這樣！

注意：我用pass陳述句代替了它的主體，因為主要目的是展示如何定義一個類，而不是它應該包含什么，

在詳細介紹之前，首先要了解物件和實體化，

2.物件和物件實體化

當我們定義一個類時，只會創建物件的描述或藍圖，在這個程序中沒有記憶體分配，而物件實體具有記憶體分配，它包含真實的資料或資訊，

實體化是創建一個類的實體，讓我們創建上面定義的類的物件-

obj1 = Car()

這樣就創建了一個物件實體，請注意，你可以根據你的選擇更改物件名稱，

嘗試列印此物件

print(obj1)

因為我們的類是空的，所以它回傳存盤物件的地址，即0x7fc5e677b6d8

在繼續學習之前，你還需要了解類的建構式，

類建構式

到目前為止，我們有一輛空的車，是時候把車的特征填滿我們的類了，類建構式的作業是在創建類的物件時將值分配給類的資料成員，

一輛車可以有不同的屬性，如名稱、顏色、型號、品牌、發動機功率、重量、價格等，我們將僅選擇其中幾項以便于理解，

class Car:
    def __init__(self, name, color):
        self.name = name
        self.color = color

因此，car或任何其他物件的屬性必須位于一個我們稱為 __init__( )的方法中，此方法也稱為建構式方法，每當類的物件被構造時，就呼叫建構式方法，

現在，讓我們來討論一下 __init__( )方法的引數，所以，這個方法的第一個引數必須是self，然后才是剩下的引數

建構式方法中的兩個陳述句是

self.name = name
self.color = color:

這將創建新的屬性，即name和color，然后將引數的值分配給它們，“self”關鍵字表示類的實體，通過使用“self”關鍵字，我們可以訪問類的屬性和方法，它在方法定義和變數初始化中很有用，“self”在每次定義方法時都顯式使用，

注意：你也可以在此方法之外創建屬性，但是這些屬性對整個類都是通用的，必須給它們賦值，

假設你的展廳中的所有汽車都是Sedan，而不是一次又一次地指定它，你可以通過創建一個屬性來將car_type的值固定為Sedan，

class Car:
    car_type = "Sedan"                 #類屬性
    def __init__(self, name, color):
        self.name = name               #實體屬性
        self.color = color             #實體屬性

這里，實體屬性是指建構式方法中的屬性，在這個例子中是self.name 和 self.color，類屬性是指建構式方法之外的屬性，在這個例子中是car_type，

3.類方法

到目前為止，我們已經添加了汽車的屬性，現在是時候添加一些行為了，方法是我們用來描述物件行為的函式，它們也在類中定義，請看下面的代碼

class Car:   
    car_type = "Sedan" 

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def description(self):                 
        return f"The {self.name} car gives the mileage of {self.mileage}km/l"

    def max_speed(self, speed):
        return f"The {self.name} runs at the maximum speed of {speed}km/hr"

在類中定義的方法(而不是建構式方法)稱為實體方法，此外，這里有兩個實體方法，description()和max_speed()，

description()—此方法回傳一個字串，其中包含汽車的描述，如名稱和里程數，此方法沒有其他引數，此方法正在使用實體屬性，
max_speed()—此方法有一個附加引數，并回傳一個顯示車輛名稱及其速度的字串，

請注意，附加引數speed沒有使用“self”關鍵字，因為speed不是一個實體變數，所以我們不使用self關鍵字作為前綴，讓我們為上面描述的類創建一個物件，

obj2 = Car("Honda City",24.1)
print(obj2.description())
print(obj2.max_speed(150))

我們所做的是創建一個類car的物件并傳遞所需的引數，為了使用object_name.method_name().

description()方法沒有任何附加引數，因此在呼叫它時沒有傳遞任何引數，

max_speed()方法有一個附加引數，因此我們在呼叫它時傳遞了一個引數，

注意：三件重要的事要記住

可以創建一個類的任意數量的物件，
如果方法需要n個引數，而你沒有傳遞相同數量的引數，則會發生錯誤，
引數的順序很重要，

讓我們一個個來看看

創建一個類的多個物件

class Car:
    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def max_speed(self, speed):
        return f"The {self.name} runs at the maximum speed of {speed}km/hr"

Honda = Car("Honda City",21.4)
print(Honda.max_speed(150))

Skoda = Car("Skoda Octavia",13)
print(Skoda.max_speed(210))

引數數目錯誤

class Car:

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage

Honda = Car("Honda City")
print(Honda)

因為我們沒有提供第二個引數，所以我們得到了這個錯誤，

引數順序

class Car:

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def description(self):                
        return f"The {self.name} car gives the mileage of {self.mileage}km/l"

Honda = Car(24.1,"Honda City")
print(Honda.description())

搞混了！因為我們改變了論點的順序，

現在，面向物件編程有四個基本概念：繼承、封裝、多型和資料抽象，為了理解OOPs，了解所有這些非常重要，到目前為止，我們已經介紹了面向物件編程的基本知識，讓我們進一步深入，

4. Python類中的繼承

繼承是一個類繼承另一個類的屬性和方法的程序，被繼承的類稱為父類，從父類繼承屬性的類是子類，

有趣的是，除了繼承的屬性和方法外，子類可以有自己的屬性和方法，

如何繼承父類？使用以下語法：

class parent_class:
body of parent class

class child_class( parent_class):
body of child class

讓我們看看實作

class Car:          #父類

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def description(self):                
        return f"The {self.name} car gives the mileage of {self.mileage}km/l"

class BMW(Car):     #子類
    pass

class Audi(Car):     #子類
    def audi_desc(self):
        return "This is the description method of class Audi."

obj1 = BMW("BMW 7-series",39.53)
print(obj1.description())

obj2 = Audi("Audi A8 L",14)
print(obj2.description())
print(obj2.audi_desc())

我們創建了兩個子類，即“BMW”和“Audi”，它們繼承了父類“Car”的方法和屬性，在BMW類我們沒有提供額外的特征和函式，而Audi內部的一個附加方法，

注意在obj1.description()和obj2.description()的幫助下，父類的實體方法description()是如何被子類的物件訪問的，此外，還可以使用obj2.Audi_desc()訪問Audi類的單獨方法，

5.封裝

正如我在文章開頭部分提到的，封裝是確保安全性的一種方法，基本上，它將資料隱藏起來，不讓外人訪問，例如，如果我們想讓某些值不被客戶或任何未經授權的人訪問，那么封裝就是確保這一點的方法，

你可以在方法或屬性的名稱前使用一個下劃線( _ ) 來宣告受保護的方法或屬性，例如 self._name或def _method()；這兩行都說明屬性和方法是受保護的，不應在類和子類的訪問之外使用，而是可以由類方法和物件訪問，

Python只是將‘_‘ 用作編碼約定，告訴你應該在類的范圍內使用這些屬性/方法，你仍然可以像往常一樣訪問定義為受保護的變數和方法，

現在，為了實際防止從類范圍之外訪問屬性/方法，可以使用“私有成員”，若要將屬性/方法宣告為私有成員，請在前綴中使用雙下劃線( __ ) ，例如– self.__name或def __method()；這兩行都說明屬性和方法是私有的，不能從類外部進行訪問，

class car:

    def __init__(self, name, mileage):
        self._name = name                #受保護屬性
        self.mileage = mileage 

    def description(self):                
        return f"The {self._name} car gives the mileage of {self.mileage}km/l"

obj = car("BMW 7-series",39.53)

#通過類方法訪問受保護變數
print(obj.description())

#直接從外部訪問受保護變數
print(obj._name)
print(obj.mileage)

請注意我們如何訪問受保護的變數而沒有任何錯誤，很明顯，對變數的訪問仍然是公開的，讓我們看看封裝是如何作業的

class Car:

    def __init__(self, name, mileage):
        self.__name = name              #私有變數
        self.mileage = mileage 

    def description(self):                
        return f"The {self.__name} car gives the mileage of {self.mileage}km/l"

obj = Car("BMW 7-series",39.53)

#通過類方法訪問私有變數
print(obj.description())

#直接從外部訪問私有變數
print(obj.mileage)
print(obj.__name)

當我們嘗試使用description()方法訪問私有變數時，沒有遇到任何錯誤，但是當我們嘗試直接在類外部訪問私有變數時，Python給出了一個錯誤，宣告：car物件沒有屬性''__name'，

你仍然可以使用該屬性的修飾名稱直接訪問它，Name mangling（命名修飾）是一種從外部訪問類成員的機制，Python解釋器將任何帶有“__var”的識別符號重寫為“_ClassName__var”，使用這個你可以從外部訪問類成員，

class Car:

    def __init__(self, name, mileage):
        self.__name = name              #私有變數     
        self.mileage = mileage 

    def description(self):                
        return f"The {self.__name} car gives the mileage of {self.mileage}km/l"

obj = Car("BMW 7-series",39.53)

#通過類方法訪問私有變數
print(obj.description())

#直接從外部訪問私有變數
print(obj.mileage)
print(obj._car__name)      #名稱修飾

請注意，這個規則的設計是想處理某些情況，例如在除錯器中，但是正常編程中不推薦使用

6.多型

多型(Polymorphism)一個希臘單詞，如果我們分解Polymorphism這一術語，我們會得到“poly”(多)和“morph”(變形)形式，所以多型性意味著有多種形式，在OOP中，它指的是具有相同名稱但具有不同功能的函式，

class Audi:
  def description(self):
    print("This the description function of class AUDI.")

class BMW:
  def description(self):
    print("This the description function of class BMW.")

audi = Audi()
bmw = BMW()
for car in (audi,bmw):
 car.description()

使用物件audi呼叫函式時，將呼叫audi類的函式；使用物件bmw呼叫函式時，將呼叫bmw類的函式，

7.資料抽象

我們使用抽象來隱藏函式的內部細節或實作，只顯示其功能，這與你在不知道汽車原理的情況下知道如何駕駛汽車，或者你知道如何用開關打開或關閉燈，但你不知道插座后面發生了什么的情況類似，

任何具有至少一個抽象函式的類都是抽象類，為了首先創建一個抽象類，你需要從ABC模塊匯入ABC類，這使你可以在其中創建抽象方法，ABC代表抽象基類，

from abc import ABC

class abs_class(ABC):
    Body of the class

重要的是，不能為抽象類創建實體物件，例如-

from abc import ABC, abstractmethod

class Car(ABC):
    def __init__(self,name):
        self.name = name 

 @abstractmethod
    def price(self,x):
        pass

obj = Car("Honda City")

現在的問題是我們如何準確地使用這個抽象，答案是使用繼承，

from abc import ABC, abstractmethod

class Car(ABC):
    def __init__(self,name):
        self.name = name

    def description(self):
        print("This the description function of class car.")

    @abstractmethod
    def price(self,x):
        pass
class new(Car):
    def price(self,x):
        print(f"The {self.name}'s price is {x} lakhs.")

obj = new("Honda City")

obj.description()
obj.price(25)

Car是從ABC模塊的ABC類繼承的抽象類，注意我在抽象類中有一個抽象方法(price())和一個具體方法(description())，這是因為抽象類可以同時包含這兩種型別的函式，而普通類則不能，從這個抽象類繼承的另一個類是new，new的price()方法是我們重寫了抽象類Car的price方法，

在用戶從new()類創建物件并呼叫price()方法之后，new()類中price方法的定義就開始發揮作用了，這些定義對用戶是隱藏的，抽象方法只是提供一個宣告，需要提供子類的定義，

但是，當為new()類(即obj)的物件呼叫description()方法時，將呼叫Car的description()方法，因為它不是抽象方法，

結尾

總之，在本文中，我介紹了Python中面向物件編程的基本概念，現在你們知道OOPs和基本概念了，

原文鏈接：https://www.analyticsvidhya.com/blog/2020/09/object-oriented-programming/

歡迎關注磐創AI博客站：
http://panchuang.net/

sklearn機器學習中文官方檔案：
http://sklearn123.com/

歡迎關注磐創博客資源匯總站：
http://docs.panchuang.net/

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

標籤：其他

上一篇：計算機專業須知：大學編程相關的比賽或者證書，真正有用的是哪些？

下一篇：玩轉java多執行緒之多執行緒基礎執行緒同步機制

python面向物件編程的基本概念

介紹

目錄