Python3 面向?qū)ο?/p>

--------------------------------------------------------------------------------

一丶面向?qū)ο蠹夹g簡介

?類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

?方法：類中定義的函數(shù)。

?類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數(shù)體之外。類變量通常不作為實例變量使用。

?數(shù)據(jù)成員：類變量或者實例變量用于處理類及其實例對象的相關的數(shù)據(jù)。

?方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

?局部變量：定義在方法中的變量，只作用于當前實例的類。

?實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱為實例變量，是在類聲明的內(nèi)部但是在類的其他成員方法之外聲明的。

?繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。

?實例化：創(chuàng)建一個類的實例，類的具體對象。

?對象：通過類定義的數(shù)據(jù)結構實例。對象包括兩個數(shù)據(jù)成員（類變量和實例變量）和方法。

和其它編程語言相比，Python 在盡可能不增加新的語法和語義的情況下加入了類機制。

Python中的類提供了面向?qū)ο缶幊痰乃谢竟δ?#xff1a;類的繼承機制允許多個基類，派生類可以覆蓋基類中的任何方法，方法中可以調(diào)用基類中的同名方法。

對象可以包含任意數(shù)量和類型的數(shù)據(jù)。

1.類中帶下劃線開頭的變量特點

類中的方法，其實就是類中的函數(shù)，可以分為：實例方法，類方法，靜態(tài)方法。方法和字段一樣，也是屬于類的屬性，所以也具有運行中修改的特效， 但一般不推薦這樣做。

我在類的基本語法中，介紹了構造器方法：__init__ 、__new__；解構器方法：__del__;

注意，這里雖然是以兩個下劃線（__）開頭，但同時以兩個下劃線（__）結尾，這里表明其是一個‘魔法方法'，關于類中的魔法方法，將起一篇進行說明。

但是，如果單純只以兩個下劃線開始，則依然是私有化的意思，看代碼示例：

class Test(object):

def __scolia__(self): # 一個類似魔術方法，并不是私有化

return 'scolia'

def __good(self): # 私有方法

return 'good'

a = Test()

print a.__scolia__() # 魔法方法可以在直接訪問

print a.__good() # 私有方法不能直接訪問

同樣的，和字段私有化一樣，我們也可能同特殊手段進行強制訪問：

print a._Test__good() # 強制訪問

當然，私有方法也可以在類的內(nèi)部訪問，和私有字段一樣。

所以說，屬性的私有化都是對訪問入口進行混淆，同樣的，也不建議強制訪問私有屬性。

也許這里的‘魔法方法'看起來并不‘魔法'，詳情將以后解釋。

--------------------------------------------------------------------------------

實例方法：

在 __init__ 構造器中，提起過其是一個實例方法，實例方法的特點就是：

1.方法的第一個參數(shù)必須是 self，當然這是約定俗成的寫法，你可以將 self 換成 abc 之類的，但是為了別的程序員能看得懂，還是統(tǒng)一用 self 吧。這里的 self 代表實例本身，也就是說如果我實例化時使用的是： a = Test() ,那么 self 就代表 a 這個實例，我們可以在很多構造器中看到類似self.scolia = 'good'的寫法，其實這個寫法和在類外面 a.scolia = 'good' 效果一樣，是為了添加屬性，只不過 __init__ 方法是實例化時自動調(diào)用的函數(shù)，所以適合進行初始屬性的創(chuàng)建。

2.實例方法在調(diào)用的時候，self 是自動傳遞的，所以不需要我們再處理。

3.實例方法一般要有實例才能調(diào)用，當然也有特殊的調(diào)用方法。

代碼示例：

class Test(object):

def __init__(self, a, b): # 構造器在實例創(chuàng)建時進行屬性的初始化

self.a = int(a)

self.b = int(b)

def abc(self, c): # 實例方法

print self.a + self.b + int(c) # 因為self是自動傳遞的，所以我們可以在實例方法中調(diào)用實例的屬性

a = Test(123, 321) # 我們只要為 a 和 b 傳參就行了

a.abc(666) # 同樣的，只要為 c 傳參

這里，將引入一個綁定 (binding) 的概念，其主要和方法的調(diào)用有關。

首先，我們知道方法是類的屬性，而不是實例的屬性，在上篇博文類的屬性和實例的屬性中我們也討論過這個問題。

其次，方法只有在其所屬的類擁有實例時，才能被調(diào)用。當一個類存在實例后，方法才被認為是綁定到這個實例。沒有實例的時候，方法是未綁定的。

最后，任何一個方法定義的第一個參數(shù)都是變量 self ，它表示調(diào)用此方法的實例對象。

很明顯這里的綁定針對的是實例方法。因為如果沒有實例的話，self 就無法傳遞，這將導致參數(shù)的不足，當然就無法調(diào)用了。

但是，我們可以自己傳遞 self 來調(diào)用未綁定的方法。調(diào)用未綁定的方法通常是在我們繼承了一個父類后， 我們覆蓋了父類中的某個方法，但是為了實現(xiàn)代碼重用，我們又想在子類中調(diào)用父類的方法。單純的復制父類中的代碼明顯不是一個好選擇， 除了浪費系統(tǒng)資源之外，還有可能在復制的時候出錯，而且以后修改父類的代碼之后，還要修改相應子類中的代碼，實在太低效，這個時候就是調(diào)用未綁定方法的場景。

代碼示例：

class abc(object):

def __init__(self, a):

self.a = -int(a)

class Test(abc):

def __init__(self, a, b):

abc.__init__(self, a) # 調(diào)用父類的構造器，并手動傳遞 self

self.b = b

def fangfa(self):

print self.a + self.b # 屬性 a 由父類的構造器創(chuàng)建，b 由子類構造器創(chuàng)建

a = Test(123, 321) # 我們只創(chuàng)建了子類的實例，而沒有創(chuàng)建父類的實例

a.fangfa()

本來我們沒有創(chuàng)建父類的示例，是無法調(diào)用父類的實例方法的，但是我們手動傳遞了實例方法需要的 self 參數(shù)，就可以實現(xiàn)調(diào)用了。

這里的順序是，我們創(chuàng)建了 Test 的實例，其 self 是自動傳遞的，故 Test 的構造方法 __init__(self, a, b) 中 self 就代表實例 a，而我們又調(diào)用了父類的 abc.__init__(self, a) 這里的 self 就是子類的實例 a ，參數(shù) a 就是我們傳的 123，而父類中 self.a = -int(a) ;最后我們可在子類的方法中調(diào)用 self.a 這個屬性。

2.Python面向?qū)ο蟮娜筇匦?/p>

一、繼承

面向?qū)ο笾械睦^承就是繼承的類直接擁有被繼承類的屬性而不需要在自己的類體中重新再寫一遍，其中被繼承的類叫做父類、基類，繼承的類叫做派生類、子類。在python3中如果不指定繼承哪個類，默認就會繼承Object類，而繼承了Object類的類就叫做新式類，而在python2中如果不指定繼承哪個類也不會默認去繼承Object類，而沒有繼承Object類的類就叫做經(jīng)典類。經(jīng)典類和新式類的不同就在于對方法的搜索順序不同，經(jīng)典類是深度優(yōu)先即先找自己類內(nèi)，如果沒有就找左邊第一個父類，沒找到繼續(xù)從這個父類的父類中找依次類推直到找到最上一級的父類也沒找到再找左邊第二個父類，然后再重復之前的過程，直到所有父類找一遍沒找到就報錯；而新式類是廣度優(yōu)先，當下一個類可以通過其他類找到時就先不去找它，而是找繼承關系中與它的子類同級的其他類，依次類推直到最后找到object類沒有找到指定方法就報錯。新式類搜索順序圖示如下，還可以通過類名.mro()查看新式類繼承中的屬性搜索順序

二、單繼承與多繼承

在其他語言中只支持單繼承即class 類名(父類名)，而python支持多繼承，用逗號將多個父類隔開即class 類名(父類名1,父類名2,。。。。)

三、繼承與抽象

抽象就是把一類事物的共有特性提取出來，繼承則是把父類的屬性拿過來并且還擁有自己的屬性。抽象是包含的范圍越來越大，共性越來越少，繼承則是包含的返回越來越小，共性越來越多。我們定義父類的過程就是抽象，定義子類的過程就是繼承。

四、父類方法重寫

我們把子類有而父類沒有的方法叫做子類的派生方法，而父類有子類也有的方法叫做對父類方法的重寫，因為按照類方法的搜索順序一個方法如果在子類中有就不會再從父類中找了，結果就是父類中的方法無法調(diào)用了，如果既想執(zhí)行父類中的方法同時在子類中又能定義新功能，就需要先把父類中的這個方法單獨繼承過來，在python中只能使用父類名.方法名(self,父類的其他參數(shù))的方式，在python3中可以使用super函數(shù)來實現(xiàn)，比如super().父類方法名(除self外的其他參數(shù))，其實在super函數(shù)中還需要傳入子類名和子類對象（在類中用self）,但是我們使用時不需要特意去傳，除非在類外單獨調(diào)用父類的方法。注意在繼承父類方法時父類的參數(shù)除了需要在父類的方法中傳遞還需要在子類重寫的方法中傳遞

class Animal:

def __init__(self,name,life_value,aggr):

self.name=name

self.life_value=life_value

self.aggr=aggr

def eat(self):

self.life_value+=10

class Person(Animal):

def __init__(self,money,name,life_value,aggr):

super().__init__(name,life_value,aggr)

self.money=money

def attack(self,obj):

obj.life_value-=self.aggr

五、接口類

接口類是用于規(guī)范子類的方法名定義用的，繼承接口類的子類可以不存在任何邏輯上的關系但是都需要實現(xiàn)某些共同的方法，為了讓這些子類的方法名能夠統(tǒng)一以便之后調(diào)用這些方法時不需要關注具體的對象就用接口類規(guī)范了這些方法的名字，子類一旦繼承了接口類就必須實現(xiàn)接口類中定義的方法，否則在子類實例化的時候就會報錯，而接口類本身則不需要實現(xiàn)去實現(xiàn)這些方法。

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):

@abstractmethod

def pay(self,money):pass

class Wechatpay(Payment):

def pay(self,money): #子類中必須定義接口類中有的方法，否則實例化會報錯

pass

w1=Wechatpay()

六、抽象類

抽象類的作用和接口類一樣，只是繼承它的子類一般存在一些邏輯上的關系，且抽象類中的方法可以去實現(xiàn)，子類在重寫時用super函數(shù)調(diào)用抽象類的方法即可，同時在用抽象類時使用單繼承，使用接口類時使用多繼承

七、多態(tài)

多態(tài)就是不同的對象可以調(diào)用相同的方法然后得到不同的結果，有點類似接口類的感覺，在python中處處體現(xiàn)著多態(tài)，比如不管你是列表還是字符串還是數(shù)字都可以使用+和*。

八、封裝

封裝就是把類中的屬性和方法定義為私有的，方法就是在屬性名或方法名前加雙下劃線，而一旦這樣定義了屬性或方法名后，python會自動將其轉換為_類名__屬性名（方法名）的格式，在類的內(nèi)部調(diào)用還是用雙下劃線加屬性名或方法名，在類的外部調(diào)用就要用_類名__屬性名（方法名）。父類的私有屬性和方法，子類無法對其進行修改。

九、類的裝飾器

property屬性裝飾器：將類內(nèi)的方法的調(diào)用方式和屬性一樣，這個裝飾器還有和其配套的setter、deleter。

class Demo:

@property

def p(self):

print('property func')

@p.setter

def p(self,num):

print('property_setter')

@p.deleter

def p(self):

print('在刪除')

d=Demo()

d.p

d.p=10

del d.p

--------------------------------------------------------------------------------------

property func

property_setter

在刪除

staticmethod靜態(tài)方法裝飾器：將類內(nèi)的方法變成普通的函數(shù)，或者把類外的函數(shù)放到類內(nèi)當作方法調(diào)用

class A:

@staticmethod

def sum(): #這個方法跟普通函數(shù)沒有區(qū)別

print('staticmethod')

A.sum() #用類名調(diào)用

--------------------------------------------------------------------------------------

staticmethod

classmethod類方法裝飾器：該方法用于操作類屬性，無法操作對象屬性

class A:

role='male'

@classmethod

def sum(cls): #用于操作類屬性

print(cls.role)

A.sum() #用類名調(diào)用

--------------------------------------------------------------------------------------

male

十、isinstance和type的區(qū)別以及issubclass

isinstance和type都可以用于判斷對象和指定類間的關系，但是isinstance的判斷沒有type準確，它無法正確判斷子類的對象和其父類的關系

class A:

pass

class B(A):

pass

b=B()

print(isinstance(b,B))

print(isinstance(b,A))

print(type(b) is B)

print(type(b) is A)

--------------------------------------------------------------------------------------

True

True

True

False

issubclass用于判斷給定的兩個類，前者是否是后者的子類

十一、反射

hasattr(對象或類名，‘屬性或方法名') 判斷指定的對象或類中是否存在指定的屬性或方法，有返回True

getattr(對象或類名,'屬性或方法名') 獲取對象或類的指定屬性值或方法的內(nèi)存地址

setattr(對象或類名,‘新屬性名',新屬性值) 給對象或類添加新的屬性或方法

delattr(對象或類名,‘新屬性名') 刪除之前添加的屬性

十二、類的內(nèi)置方法

__doc__ ：輸出類的描述信息

__module__ ：表示當前操作的對象在那個模塊

__class__ ： 表示當前操作的對象的類是什么

__dict__ ：查看類或?qū)ο笾械乃谐蓡T 類調(diào)用打印類的所有屬性，不包括實例屬性。實例調(diào)用打印所有實例屬性

__str__ 格式化輸出%s輸出該方法的值

__repr__ 格式化輸出%r輸出該方法的值，并且%s在沒有__str__方法時也是輸出該方法的值

__del__ del 執(zhí)行該方法

__getitem__ 用對象加[]方式取值

class A:

def __init__(self):

self.names=['egon','alex','eva'] #可以是其他序列

def __getitem__(self, item):

print(self.names[item])

a=A()

a[1]

----------------------------------------------------------

alex

__setitem__ 添加值

__delitem__ 刪除值

__new__ 用于創(chuàng)建沒有屬性的對象，調(diào)用object的__new__即可不需要自己實現(xiàn)。可以利用該方法實現(xiàn)單例模式

__call__ 對象加括號執(zhí)行該方法

__len__ len()執(zhí)行該方法

__eq__ ==運算輸出該方法的值

__hash__ hash執(zhí)行該方法

二丶代碼實現(xiàn)（三維向量類）

class Vecter3:

def __init__(self, x=0, y=0, z=0):

self.X = x

self.Y = y

self.Z = z

def __add__(self, n):

r = Vecter3()

r.X = self.X + n.X

r.Y = self.Y + n.Y

r.Z = self.Z + n.Z

return r

def __sub__(self, n):

r = Vecter3()

r.X = self.X - n.X

r.Y = self.Y - n.Y

r.Z = self.Z - n.Z

return r

def __mul__(self, n):

r = Vecter3()

r.X = self.X * n

r.Y = self.Y * n

r.Z = self.Z * n

return r

def __truediv__(self, n):

r = Vecter3()

r.X = self.X / n

r.Y = self.Y / n

r.Z = self.Z / n

return r

def __floordiv__(self, n):

r = Vecter3()

r.X = self.X // n

r.Y = self.Y // n

r.Z = self.Z // n

return r

def show(self):

print((self.X,self.Y,self.Z))

v1 = Vecter3(1,2,3)

v2 = Vecter3(4,5,6)

v3 = v1+v2

v3.show()

v4 = v1-v2

v4.show()

v5 = v1*3

v5.show()

v6 = v1/2

v6.show()

此類可實現(xiàn)三維向量的加減乘除

運行后為

三丶代碼實現(xiàn)（程序類）

這個程序運用類與正則表達式匹配來寫，可以刪除重復的英文并輸出，這里輸入 This is my name

import re

class Good:

def __init__(self,n):

self.n = n

def love(self):

s1 = re.split(r' ',self.n)

s2 = sorted(set(s1),key=s1.index)

print(s2)

b = Good('This is is my name')#此處可自行輸入字符串

b.love()

接下來我們看運行結果

總結

以上所述是小編給大家介紹的Python面向?qū)ο罂偨Y及類與正則表達式詳解,希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！

如果你覺得本文對你有幫助，歡迎轉載，煩請注明出處，謝謝！

總結

以上是生活随笔為你收集整理的python面向对象编程的三大特性_Python面向对象总结及类与正则表达式详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。