一文帶你理解Python中面向?qū)ο缶幊蘋OP的概念

更新時(shí)間：2023年08月28日 10:21:27 作者：python收藏家

在Python中,面向?qū)ο缶幊蹋∣OP）是一種在編程中使用對(duì)象和類的編程范式,它旨在實(shí)現(xiàn)現(xiàn)實(shí)世界的實(shí)體,下面我們就一起來(lái)看看它的相關(guān)知識(shí)吧

在Python中，面向?qū)ο缶幊蹋∣OP）是一種在編程中使用對(duì)象和類的編程范式。它旨在實(shí)現(xiàn)現(xiàn)實(shí)世界的實(shí)體，如繼承，多態(tài)性，封裝等。在編程中，OOP的主要概念是將數(shù)據(jù)和處理數(shù)據(jù)的函數(shù)綁定在一起作為一個(gè)單元，這樣代碼的其他部分就不能訪問(wèn)這些數(shù)據(jù)。

Python中的OOP概念：

類

對(duì)象
繼承
多態(tài)
封裝
數(shù)據(jù)抽象

1. 類

類是對(duì)象的集合。類包含創(chuàng)建對(duì)象所依據(jù)的藍(lán)圖或原型。它是一個(gè)包含一些屬性和方法的邏輯實(shí)體。

為了理解創(chuàng)建類的必要性，讓我們考慮一個(gè)示例，假設(shè)您希望跟蹤可能具有不同屬性（如品種和年齡）的狗的數(shù)量。如果使用列表，則第一個(gè)元素可以是狗的品種，而第二個(gè)元素可以表示其年齡。假設(shè)有100只不同的狗，那么你怎么知道哪個(gè)元素應(yīng)該是哪個(gè)？如果你想給這些狗添加其他屬性呢？這缺乏組織性，這正是類的需要。

關(guān)于Python類的一些要點(diǎn)：

類由關(guān)鍵字class創(chuàng)建。
屬性是屬于類的變量。
屬性始終是公共的，可以使用點(diǎn)（.）操作。例如：Myclass.Myattribute

類定義語(yǔ)法：

class ClassName:
# Statement-1
.
.
.
# Statement-N

在Python中創(chuàng)建空類

class Dog:
    pass

在上面的例子中，我們使用class關(guān)鍵字創(chuàng)建了一個(gè)名為Dog的類。

2. 對(duì)象

對(duì)象是具有與之相關(guān)聯(lián)的狀態(tài)和行為的實(shí)體。它可以是任何現(xiàn)實(shí)世界對(duì)象，如鼠標(biāo)、鍵盤、椅子、桌子、筆等。整數(shù)、字符串、浮點(diǎn)數(shù)、偶數(shù)數(shù)組和字典都是對(duì)象。更具體地，任何單個(gè)整數(shù)或任何單個(gè)字符串都是對(duì)象。數(shù)字12是一個(gè)對(duì)象，字符串“Hello，world”是一個(gè)對(duì)象，列表是一個(gè)可以容納其他對(duì)象的對(duì)象，依此類推。

對(duì)象由以下部分組成：

狀態(tài)：由對(duì)象的屬性表示。它還反映了對(duì)象的屬性。
行為：它由對(duì)象的方法表示。它還反映了一個(gè)對(duì)象對(duì)其他對(duì)象的響應(yīng)。
身份：它為對(duì)象提供唯一的名稱，并使一個(gè)對(duì)象能夠與其他對(duì)象交互。

為了理解狀態(tài)、行為和身份，讓我們以類dog為例（如上所述）。

身份可以被認(rèn)為是狗的名字。

狀態(tài)或?qū)傩钥梢员徽J(rèn)為是狗的品種、年齡或顏色。

行為可以被認(rèn)為是狗在吃東西還是睡覺。

創(chuàng)建對(duì)象

這將創(chuàng)建一個(gè)名為obj的對(duì)象，它屬于上面定義的Dog類。在深入研究對(duì)象和類之前，讓我們了解一些基本的關(guān)鍵字，這些關(guān)鍵字將在處理對(duì)象和類時(shí)使用。

obj = Dog()

Python 中的self理解

1.類方法在方法定義中必須有一個(gè)額外的第一個(gè)參數(shù)。我們?cè)谡{(diào)用方法時(shí)不給予這個(gè)參數(shù)一個(gè)值，Python提供了它

2.如果我們有一個(gè)不帶參數(shù)的方法，那么我們?nèi)匀槐仨氂幸粋€(gè)參數(shù)。

3.這類似于C++中的this指針和Java中的this引用。

當(dāng)我們調(diào)用這個(gè)對(duì)象的方法myobject.method（arg 1，arg 2）時(shí)，Python會(huì)自動(dòng)將其轉(zhuǎn)換為MyClass.method（myobject，arg 1，arg 2）–這就是特殊的self的全部?jī)?nèi)容。

Python __init__方法

__init__方法類似于C++和Java中的構(gòu)造函數(shù)。一個(gè)類的對(duì)象被實(shí)例化，它就運(yùn)行。該方法可用于對(duì)對(duì)象進(jìn)行任何初始化?，F(xiàn)在讓我們定義一個(gè)類，并使用self和__init__方法創(chuàng)建一些對(duì)象。

創(chuàng)建具有類和實(shí)例屬性的類和對(duì)象

class Dog:
    # class attribute
    attr1 = "mammal"
    # Instance attribute
    def __init__(self, name):
        self.name = name
# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
# Accessing class attributes
print("Rodger is a {}".format(Rodger.__class__.attr1))
print("Tommy is also a {}".format(Tommy.__class__.attr1))
# Accessing instance attributes
print("My name is {}".format(Rodger.name))
print("My name is {}".format(Tommy.name))

輸出

Rodger is a mammal
Tommy is also a mammal
My name is Rodger
My name is Tommy

使用方法創(chuàng)建類和對(duì)象

這里，Dog類定義了兩個(gè)屬性：

attr1是設(shè)置為值“mammal”的類屬性。類屬性由類的所有實(shí)例共享。

__init__是一個(gè)特殊的方法（構(gòu)造函數(shù)），用于初始化Dog類的實(shí)例。它需要兩個(gè)參數(shù)：self（引用正在創(chuàng)建的實(shí)例）和name（表示狗的名字）。name參數(shù)用于為Dog的每個(gè)實(shí)例分配一個(gè)name屬性。

class Dog:
    # class attribute
    attr1 = "mammal"
    # Instance attribute
    def __init__(self, name):
        self.name = name
    def speak(self):
        print("My name is {}".format(self.name))
# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
# Accessing class methods
Rodger.speak()
Tommy.speak()

輸出：

My name is Rodger
My name is Tommy

3. 繼承

繼承是一個(gè)類從另一個(gè)類派生或繼承屬性的能力。派生屬性的類稱為派生類或子類，從中派生屬性的類稱為基類或父類。繼承的好處是：

它很好地代表了現(xiàn)實(shí)世界的關(guān)系。
它提供了代碼的可重用性。我們不必一遍又一遍地寫同樣的代碼。此外，它允許我們?cè)诓恍薷念惖那闆r下向類添加更多功能。
它本質(zhì)上是可傳遞的，這意味著如果類B從另一個(gè)類A繼承，那么B的所有子類都將自動(dòng)從類A繼承。

繼承的類型

單一繼承：?jiǎn)渭?jí)繼承使派生類能夠從單親類繼承特性。
多級(jí)繼承：多級(jí)繼承使派生類能夠從直接父類繼承屬性，而直接父類又從父類繼承屬性。
分層繼承：分層繼承使多個(gè)派生類能夠從父類繼承屬性。
多重繼承：多級(jí)繼承使一個(gè)派生類能夠從多個(gè)基類繼承屬性。

# parent class
class Person(object):
	# __init__ is known as the constructor
	def __init__(self, name, idnumber):
		self.name = name
		self.idnumber = idnumber
	def display(self):
		print(self.name)
		print(self.idnumber)
	def details(self):
		print("My name is {}".format(self.name))
		print("IdNumber: {}".format(self.idnumber))
# child class
class Employee(Person):
	def __init__(self, name, idnumber, salary, post):
		self.salary = salary
		self.post = post
		# invoking the __init__ of the parent class
		Person.__init__(self, name, idnumber)
	def details(self):
		print("My name is {}".format(self.name))
		print("IdNumber: {}".format(self.idnumber))
		print("Post: {}".format(self.post))
# creation of an object variable or an instance
a = Employee('Rahul', 886012, 200000, "Intern")
# calling a function of the class Person using
# its instance
a.display()
a.details()

輸出：

Rahul
886012
My name is Rahul
IdNumber: 886012
Post: Intern

在上面，我們創(chuàng)建了兩個(gè)類，即Person（父類）和Employee（子類）。Employee類繼承自Person類。我們可以通過(guò)employee類使用person類的方法，如上面代碼中的display函數(shù)所示。子類也可以修改父類的行為，如通過(guò)details（）方法所看到的。

4. 多態(tài)

多態(tài)僅僅意味著具有多種形式。例如，我們需要確定給定種類的鳥是否會(huì)飛，使用多態(tài)性，我們可以使用單個(gè)函數(shù)來(lái)完成這一點(diǎn)。

class Bird:
	def intro(self):
		print("There are many types of birds.")
	def flight(self):
		print("Most of the birds can fly but some cannot.")
class sparrow(Bird):
	def flight(self):
		print("Sparrows can fly.")
class ostrich(Bird):
	def flight(self):
		print("Ostriches cannot fly.")
obj_bird = Bird()
obj_spr = sparrow()
obj_ost = ostrich()
obj_bird.intro()
obj_bird.flight()
obj_spr.intro()
obj_spr.flight()
obj_ost.intro()
obj_ost.flight()

輸出

There are many types of birds.
Most of the birds can fly but some cannot.
There are many types of birds.
Sparrows can fly.
There are many types of birds.
Ostriches cannot fly.

這段代碼演示了Python類中繼承和方法重寫的概念。它展示了子類如何重寫父類中定義的方法以提供特定的行為，同時(shí)仍然從父類繼承其他方法。

5. 封裝

封裝是面向?qū)ο缶幊蹋∣OP）中的基本概念之一。它描述了包裝數(shù)據(jù)的思想以及在一個(gè)單元內(nèi)處理數(shù)據(jù)的方法。這就限制了直接訪問(wèn)變量和方法，并可以防止意外修改數(shù)據(jù)。為了防止意外更改，對(duì)象的變量只能由對(duì)象的方法更改。這些類型的變量被稱為私有變量。

類是封裝的一個(gè)例子，因?yàn)樗庋b了所有的數(shù)據(jù)，如成員函數(shù)，變量等。

# Creating a Base class
class Base:
	def __init__(self):
		self.a = "GeeksforGeeks"
		self.__c = "GeeksforGeeks"
# Creating a derived class
class Derived(Base):
	def __init__(self):
		# Calling constructor of
		# Base class
		Base.__init__(self)
		print("Calling private member of base class: ")
		print(self.__c)
# Driver code
obj1 = Base()
print(obj1.a)
# Uncommenting print(obj1.c) will
# raise an AttributeError
# Uncommenting obj2 = Derived() will
# also raise an AtrributeError as
# private member of base class
# is called inside derived class

輸出