關(guān)注頭條號，私信回復(fù)資料會有意外驚喜呦………………最后一張照片有資料呦。

---

Python神奇指南目錄

簡介

搭建與初始化

在自定義類中運用操作符

神奇方法比較

神奇方法數(shù)字

描述自定義類

控制屬性訪問

制作自定義序列

反射

可調(diào)用對象

上下文管理器

構(gòu)建描述符對象

簡介

何為神奇方法呢？它們是面向Python中的一切，是一些特殊的方法允許在自己的定義類中定義增加“神奇”的功能。它們總是使用雙下劃線（比如__init__或__lt__），但它們的文檔沒有很好地把它們表現(xiàn)出來。所有這些神奇方法都出現(xiàn)在Python的官方文檔中，但內(nèi)容相對分散，組織結(jié)構(gòu)也顯得松散。還有你會難以發(fā)現(xiàn)一個實例（雖然他們被設(shè)計很棒，在語言參考中被詳細描述，可之后就會伴隨著枯燥的語法描述等）。

為了彌補Python官方文檔的這些缺陷，作者整理了這篇有關(guān)magic method的文章，旨在用作教程、復(fù)習(xí)或參考文檔。

搭建與初始化

相信大家都熟悉這個最基礎(chǔ)的神奇方法__init__。它令你能自定義一個對象的初始化行為。而當(dāng)我調(diào)用x=SomeClass()時，__init__并不是最先被調(diào)用的。實際上有一個叫做__new__的方法，事實上是它創(chuàng)建了實例，它傳遞任何參數(shù)給初始化程序來達到創(chuàng)建的目的。在對象生命周期結(jié)束時，調(diào)用__del__。讓我們更近地觀察下這3個神奇方法吧：

__new__(cls, […)

一個對象的實例化時__new__是第一個被調(diào)用的方法。在類中傳遞其他任何參數(shù)到__init__。__new__很少被使用，這樣做確實有其目的，特別是當(dāng)一個子類繼承一個不可改變的類型(一個元組或一個字符串)時。

__init__(self, […)

類的初始化。創(chuàng)建對象后，python解釋器默認(rèn)調(diào)用__init__()方法。無論主構(gòu)造函數(shù)調(diào)用什么，它都會被傳遞。__init__幾乎在Python類定義中普遍使用。

__del__(self)

如果__new__和__init__構(gòu)成了對象的構(gòu)造函數(shù)，__ del__就是析構(gòu)函數(shù)。當(dāng)刪除一個對象時，python解釋器也會默認(rèn)調(diào)用__del__()方法。在python中，對于開發(fā)者來說很少會直接銷毀對象(如果需要，應(yīng)該使用del關(guān)鍵字銷毀)。Python的內(nèi)存管理機制能夠很好的勝任這份工作。也就是說,不管是手動調(diào)用del還是由python自動回收都會觸發(fā)__del__方法執(zhí)行。

如下，是是__init__和__del__的例子：

from os.path import join

class FileObject:

'''對文件對象的包裝，確保文件在關(guān)閉時得到刪除'''

def __init__(self, filepath='~', filename='sample.txt'):

# 按filepath，讀寫模式打開名為filename的文件

self.file=open(join(filepath,filename), 'r+')

def __del__(self):

self.file.close()

del self.file

在自定義類中運用操作符

神奇方法比較：

Python有一大堆magic method，旨在使用運算符實現(xiàn)對象之間的直觀比較，而非別扭的方法調(diào)用。它們還提供了一種方法來覆蓋用于對象比較的默認(rèn)Python行為。下面是這些方法的列表以及它們的作用:

__cmp__(self, other)

__cmp__是神奇方法中最基礎(chǔ)的一個。實際上它實現(xiàn)所有比較操作符行為(<,==,!=,等)，但它有可能不按你想要的方法工作(例如，一個實例是否等于另一個這取決于比較的準(zhǔn)則，以及一個實例是否大于其他的這也取決于其他的準(zhǔn)則)。如果self < other，那__cmp__應(yīng)當(dāng)返回一個負整數(shù)；如果self == other，則返回0；如果self > other，則返回正整數(shù)。它通常是最好的定義，而不需要你一次就全定義好它們，但當(dāng)你需要用類似的準(zhǔn)則進行所有的比較時，__cmp__會是一個很好的方式，幫你節(jié)省重復(fù)性和提高明確度。

__eq__(self, other)

定義了相等操作符，==的行為。

__ne__(self, other)

定義了不相等操作符，!=的行為。

__lt__(self, other)

定義了小于操作符，<的行為。

__gt__(self, other)

定義了大于操作符，>的行為。

__le__(self, other)

定義了小于等于操作符，<=的行為。

__ge__(self, other)

定義了大于等于操作符，>=的行為。

舉一個例子，設(shè)想對單詞進行類定義。我們可能希望按照內(nèi)部對字符串的默認(rèn)比較行為，即字典序(通過字母)來比較單詞，也希望能夠基于某些其他的準(zhǔn)則，像是長度或音節(jié)數(shù)。在本例中，我們通過單詞長度排序，以下給出實現(xiàn)：

class Word(str):

'''單詞類，比較定義是基于單詞長度的'''

def __new__(cls, word):

# 注意，我們使用了__new__,這是因為str是一個不可變類型，

# 所以我們必須更早地初始化它（在創(chuàng)建時）

if ' ' in word:

print "單詞內(nèi)含有空格，截斷到第一部分"

word = word[:word.index(' ')] # 在出現(xiàn)第一個空格之前全是字符了現(xiàn)在

return str.__new__(cls, word)

def __gt__(self, other):

return len(self) > len(other)

def __lt__(self, other):

return len(self) < len(other)

def __ge__(self, other):

return len(self) >= len(other)

def __le__(self, other):

return len(self) <= len(other)

神奇方法數(shù)字：

就像你可以通過重載比較操作符的途徑來創(chuàng)建你自己的類實例，你同樣可以重載數(shù)字操作符。

一元操作符：

一元運算和函數(shù)僅有一個操作數(shù)，比如負數(shù)，絕對值等。

__pos__(self)

實現(xiàn)一元正數(shù)的行為(如：+some_object)

__neg__(self)

實現(xiàn)負數(shù)的行為(如: -some_object)

__abs__(self)

實現(xiàn)內(nèi)建abs()函數(shù)的行為

__invert__(self)

實現(xiàn)用~操作符進行的取反行為。

常規(guī)算數(shù)操作符：

現(xiàn)在我們涵蓋了基本的二元運算符:+，-，*等等。其中大部分都是不言自明的。

__add__(self, other)

實現(xiàn)加法

__sub__(self, other)

實現(xiàn)減法

__mul__(self, other)

實現(xiàn)乘法

__floordiv__(self, other)

實現(xiàn)地板除法，使用//操作符

__div__(self, other)

實現(xiàn)傳統(tǒng)除法，使用/操作符

__truediv__(self, other)

實現(xiàn)真正除法。注意，只有當(dāng)你from __future__ import division時才會有效

__mod__(self, other)

實現(xiàn)求模，使用%操作符

__divmod__(self, other)

實現(xiàn)內(nèi)建函數(shù)divmod()的行為

__pow__(self, other)

實現(xiàn)乘方，使用**操作符

__lshift__(self, other)

實現(xiàn)左按位位移，使用<<操作符

__rshift__(self, other)

實現(xiàn)右按位位移，使用>>操作符

__and__(self, other)

實現(xiàn)按位與，使用&操作符

__or__(self, other)

實現(xiàn)按位或，使用|操作符

__xor__(self, other)

實現(xiàn)按位異或，使用^操作符

反射算數(shù)操作符：

首先舉個例子：some_object + other。這是“常規(guī)的”加法。而反射其實相當(dāng)于一回事，除了操作數(shù)改變了改變下位置：other + some_object。在大多數(shù)情況下，反射算術(shù)操作的結(jié)果等價于常規(guī)算術(shù)操作，所以你盡可以在剛重載完__radd__就調(diào)用__add__。干脆痛快：

__radd__(self, other)

實現(xiàn)反射加法

__rsub__(self, other)

實現(xiàn)反射減法

__rmul__(self, other)

實現(xiàn)反射乘法

__rfloordiv__(self, other)

實現(xiàn)反射地板除，用//操作符

__rdiv__(self, other)

實現(xiàn)傳統(tǒng)除法，用/操作符

__rturediv__(self, other)

實現(xiàn)真實除法，注意，只有當(dāng)你from __future__ import division時才會有效

__rmod__(self, other)

實現(xiàn)反射求模，用%操作符

__rdivmod__(self, other)

實現(xiàn)內(nèi)置函數(shù)divmod()的長除行為，當(dāng)調(diào)用divmod(other,self)時被調(diào)用

__rpow__(self, other)

實現(xiàn)反射乘方，用**操作符

__rlshift__(self, other)

實現(xiàn)反射的左按位位移，使用<<操作符

__rrshift__(self, other)

實現(xiàn)反射的右按位位移，使用>>操作符

__rand__(self, other)

實現(xiàn)反射的按位與，使用&操作符

__ror__(self, other)

實現(xiàn)反射的按位或，使用|操作符

__rxor__(self, other)

實現(xiàn)反射的按位異或，使用^操作符

增量賦值：

Python也有各種各樣的神奇方法允許用戶自定義增量賦值行為。

這些方法都不會有返回值，因為賦值在Python中不會有任何返回值。反而它們只是改變類的狀態(tài)。列表如下：

__rxor__(self, other)

實現(xiàn)加法和賦值

__isub__(self, other)

實現(xiàn)減法和賦值

__imul__(self, other)

實現(xiàn)乘法和賦值

__ifloordiv__(self, other)

實現(xiàn)地板除和賦值，用//=操作符

__idiv__(self, other)

實現(xiàn)傳統(tǒng)除法和賦值，用/=操作符

__iturediv__(self, other)

實現(xiàn)真實除法和賦值，注意，只有當(dāng)你from __future__ import division時才會有效

__imod__(self, other)

實現(xiàn)求模和賦值，用%=操作符

__ipow__(self, other)

實現(xiàn)乘方和賦值，用**=操作符

__ilshift__(self, other)

實現(xiàn)左按位位移和賦值，使用<<=操作符

__irshift__(self, other)

實現(xiàn)右按位位移和賦值，使用>>=操作符

__iand__(self, other)

實現(xiàn)按位與和賦值，使用&=操作符

__ior__(self, other)

實現(xiàn)按位或和賦值，使用|=操作符

__ixor__(self, other)

實現(xiàn)按位異或和賦值，使用^=操作符

類型轉(zhuǎn)換的神奇方法：

Python也有一組神奇方法被設(shè)計用來實現(xiàn)內(nèi)置類型轉(zhuǎn)換函數(shù)的行為，如float()。

__int__(self)

實現(xiàn)到int的類型轉(zhuǎn)換

__long__(self)

實現(xiàn)到long的類型轉(zhuǎn)換

__float__(self)

實現(xiàn)到float的類型轉(zhuǎn)換

__complex__(self)

實現(xiàn)到復(fù)數(shù)的類型轉(zhuǎn)換

__oct__(self)

實現(xiàn)到8進制的類型轉(zhuǎn)換

__hex__(self)

實現(xiàn)到16進制的類型轉(zhuǎn)換

__index__(self)

實現(xiàn)一個當(dāng)對象被切片到int的類型轉(zhuǎn)換。如果你自定義了一個數(shù)值類型，考慮到它可能被切片，所以你應(yīng)該重載__index__。

__trunc__(self)

當(dāng)math.trunc(self)被調(diào)用時調(diào)用。__trunc__應(yīng)當(dāng)返回一個整型的截斷，(通常是long)。

__coerce__(self, other)

該方法用來實現(xiàn)混合模式的算術(shù)。如果類型轉(zhuǎn)換不可能那__coerce__應(yīng)當(dāng)返回None。否則，它應(yīng)當(dāng)返回一對包含self和other（2元組），且調(diào)整到具有相同的類型。

描述自定義類

用一個字符串來說明一個類這通常是有用的。在Python中提供了一些方法讓你可以在你自己的類中自定義內(nèi)建函數(shù)返回你的類行為的描述。

__str__(self)

當(dāng)你定義的類中一個實例調(diào)用了str()，用于給它定義行為

__repr__(self)

當(dāng)你定義的類中一個實例調(diào)用了repr()，用于給它定義行為。str()和repr()主要的區(qū)別在于它的閱讀對象。repr()產(chǎn)生的輸出主要為計算機可讀(在很多情況下，這甚至可能是一些有效的Python代碼)，而str()則是為了讓人類可讀。

__unicode__(self)

當(dāng)你定義的類中一個實例調(diào)用了unicode()，用于給它定義行為。unicode()像是str(),只不過它返回一個unicode字符串。警惕！如果用戶用你的類中的一個實例調(diào)用了str(),而你僅定義了__unicode__(),那它是不會工作的。以防萬一，你應(yīng)當(dāng)總是定義好__str__()，哪怕用戶不會使用unicode。

__hash__(self)

當(dāng)你定義的類中一個實例調(diào)用了hash()，用于給它定義行為。它必須返回一個整型，而且它的結(jié)果是用于來在字典中作為快速鍵比對。

__nonzero__(self)

當(dāng)你定義的類中一個實例調(diào)用了bool()，用于給它定義行為。返回True或False，取決于你是否考慮一個實例是True或False的。

我們已經(jīng)相當(dāng)漂亮地干完了神奇方法無聊的部分(無示例)，至此我們已經(jīng)討論了一些基礎(chǔ)的神奇方法，是時候讓我們向高級話題移動了。

控制屬性訪問

Python通過神奇的方法實現(xiàn)了大量的封裝，而不是通過明確的方法或字段修飾符。例如：

__getattr__(self, name)

你可以為用戶在試圖訪問不存在（不論是存在或尚未建立）的類屬性時定義其行為。這對捕捉和重定向常見的拼寫錯誤，給出使用屬性警告是有用的（只要你愿意，你仍舊可選計算，返回那個屬性）或拋出一個AttributeError異常。這個方法只適用于訪問一個不存在的屬性，所以，這不算一個真正封裝的解決之道。

__setattr__(self, name, value)

不像__getattr__，__setattr__是一個封裝的解決方案。它允許你為一個屬性賦值時候的行為，不論這個屬性是否存在。這意味著你可以給屬性值的任意變化自定義規(guī)則。然而，你需要在意的是你要小心使用__setattr__,在稍后的列表中會作為例子給出。

__delattr__

這等價于__setattr__,但是作為刪除類屬性而不是set它們。它需要相同的預(yù)防措施，就像__setattr__，防止無限遞歸（當(dāng)在__delattr__中調(diào)用del self.name會引起無限遞歸）。

__getattribute__(self, name)

__getattribute__良好地適合它的同伴們__setattr__和__delattr__。可我卻不建議你使用它。

__getattribute__只能在新式類中使用（在Python的最新版本中，所有的類都是新式類，在稍舊的版本中你可以通過繼承object類來創(chuàng)建一個新式類。它允許你定規(guī)則，在任何時候不管一個類屬性的值那時候是否可訪問的。）它會因為他的同伴中的出錯連坐受到某些無限遞歸問題的困擾（這時你可以通過調(diào)用基類的__getattribute__方法來防止發(fā)生）。當(dāng)__getattribute__被實現(xiàn)而又只調(diào)用了該方法如果__getattribute__被顯式調(diào)用或拋出一個AttributeError異常，同時也主要避免了對__getattr__的依賴。這個方法可以使用，不過我不推薦它是因為它有一個小小的用例(雖說比較少見，但我們需要特殊行為以獲取一個值而不是賦值)以及它真的很難做到實現(xiàn)0bug。

你可以很容易地在你自定義任何類屬性訪問方法時引發(fā)一個問題。參考這個例子：

def __setattr__(self, name, value):

self.name = value

# 當(dāng)每次給一個類屬性賦值時，會調(diào)用__setattr__(),這就形成了遞歸

# 因為它真正的含義是 self.__setattr__('name', value)

# 所以這方法不停地調(diào)用它自己，變成了一個無法退出的遞歸最終引發(fā)crash

def __setattr__(self, name, value):

self.__dict__[name] = value # 給字典中的name賦值

# 在此自定義行為

以下是一個關(guān)于特殊屬性訪問方法的實際例子（注意，我們使用super因為并非所有類都有__dict__類屬性）：

class AccessCounter:

'''一個類包含一個值和實現(xiàn)了一個訪問計數(shù)器。

當(dāng)值每次發(fā)生變化時，計數(shù)器+1'''

def __init__(self, val):

super(AccessCounter, self).__setattr__('counter',0)

super(AccessCounter, self).__setattr__('value', val)

def __setattr__(self, name, value):

if name == 'value':

super(AccessCounter, self).__setattr__('counter', self.counter + 1)

# Make this unconditional.

# 如果你想阻止其他屬性被創(chuàng)建，拋出AttributeError(name)異常

super(AccessCounter, self).__setattr__(name, value)

def __delattr__(self, name)

if name == 'value':

super(AccessCounter, self).__setattr__('counter', self.counter + 1)

super(AccessCounter, self).__delattr__(name)

制作自定義序列

很有多種方式可以讓你的類表現(xiàn)得像內(nèi)建序列(字典，元組，列表，字符串等)。這些是我迄今為止最喜歡的神奇方法了，因為不合理的控制它們賦予了你一種魔術(shù)般地讓你的類實例整個全局函數(shù)數(shù)組漂亮工作的方式。

__len__(self)

返回容器的長度。部分protocol同時支持可變和不可變?nèi)萜?/p>

__getitem__(self, key)

定義當(dāng)某一個item被訪問時的行為，使用self[key]表示法。這個同樣也是部分可變和不可變?nèi)萜鱬rotocol。這也可拋出適當(dāng)?shù)漠惓?TypeError 當(dāng)key的類型錯誤，或沒有值對應(yīng)Key時。

__setitem__(self, key, value)

定義當(dāng)某一個item被賦值時候的行為，使用self[key]=value表示法。這也是部分可變和不可變?nèi)萜鱬rotocol。再一次重申，你應(yīng)當(dāng)在適當(dāng)之處拋出KeyError和TypeError異常。

__delitem__(self, key)

定義當(dāng)某一個item被刪除（例如 del self[key]）時的行為。這僅是部分可變?nèi)萜鞯膒rotocol。在一個無效key被使用后，你必須拋出一個合適的異常。

__iter__(self)

應(yīng)該給容器返回一個迭代器。迭代器會返回若干內(nèi)容,大多使用內(nèi)建函數(shù)iter()表示。當(dāng)一個容器使用形如for x in container:的循環(huán)。迭代器本身就是其對象，同時也要定義好一個__iter__方法來返回自身。

__reversed__(self)

當(dāng)定義調(diào)用內(nèi)建函數(shù)reversed()時的行為。應(yīng)該返回一個反向版本的列表。

__contains__(self, item)

__contains__為成員關(guān)系，用in和not in測試時定義行為。那你會問這個為何不是一個序列的protocol的一部分？這是因為當(dāng)__contains__未定義，Python就會遍歷序列，如果遇到正在尋找的item就會返回True。

__concat__(self, other)

最后，你可通過__concat__定義你的序列和另外一個序列的連接。應(yīng)該從self和other返回一個新構(gòu)建的序列。當(dāng)調(diào)用2個序列時__concat__涉及操作符+

在我們的例子中，讓我們看一下一個list實現(xiàn)的某些基礎(chǔ)功能性的構(gòu)建。可能會讓你想起你使用的其他語言（比如Haskell）。

class FunctionalList:

'''類覆蓋了一個list的某些額外的功能性魔法，像head，

tail，init，last，drop，and take'''

def __init__(self, values=None):

if values is None:

self.values = []

else:

self.values = values

def __len__(self):

return len(self.values)

def __getitem__(self, key):

# 如果key是非法的類型和值，那么list valuse會拋出異常

return self.values[key]

def __setitem__(self, key, value):

self.values[key] = value

def __delitem__(self, key):

del self.values[key]

def __iter__(self):

return iter(self.values)

def __reversed__(self):

return reversed(self.values)

def append(self, value):

self.values.append(value)

def head(self):

# 獲得第一個元素

return self.values[0]

def tail(self):

# 獲得在第一個元素后的其他所有元素

return self.values[1:]

def init(self):

# 獲得除最后一個元素的序列

return self.values[:-1]

def last(last):

# 獲得最后一個元素

return self.values[-1]

def drop(self, n):

# 獲得除前n個元素的序列

return self.values[n:]

def take(self, n):

# 獲得前n個元素

return self.values[:n]

反射

你也可以通過定義神奇方法來控制如何反射使用內(nèi)建函數(shù)isinstance()和issubclass()的行為。這些神奇方法是：

__instancecheck__(self, instance)

檢查一個實例是否是你定義類中的一個實例(比如，isinstance(instance, class))

__subclasscheck__(self, subclass)

檢查一個類是否是你定義類的子類（比如，issubclass(subclass, class)）

可調(diào)用對象

這是Python中一個特別的神奇方法，它允許你的類實例像函數(shù)。所以你可以“調(diào)用”它們，把他們當(dāng)做參數(shù)傳遞給函數(shù)等等。這是另一個強大又便利的特性讓Python的編程變得更可愛了。

__call__(self, [args…])

允許類實例像函數(shù)一樣被調(diào)用。本質(zhì)上，這意味著x()等價于x.__call__()。注意，__call__需要的參數(shù)數(shù)目是可變的，也就是說可以對任何函數(shù)按你的喜好定義參數(shù)的數(shù)目定義__call__。

__call__可能對于那些經(jīng)常改變狀態(tài)的實例來說是極其有用的。“調(diào)用”實例是一種順應(yīng)直覺且優(yōu)雅的方式來改變對象的狀態(tài)。下面一個例子是一個類表示一個實體在一個平面上的位置：

class Entity:

'''描述實體的類，被調(diào)用的時候更新實體的位置'''

def __init__(self, size, x, y):

self.x, self.y = x, y

self.size = size

def __call__(self, x, y):

'''改變實體的位置'''

self.x, self.y = x, y

#省略...

上下文管理器

上下文管理允許對對象進行設(shè)置和清理動作，用with聲明進行已經(jīng)封裝的操作。上下文操作的行為取決于2個神奇方法：

__enter__(self)

定義塊用with聲明創(chuàng)建出來時上下文管理應(yīng)該在塊開始做什么。

__exit__(self, exception_type, exception_value, traceback)

定義在塊執(zhí)行（或終止）之后上下文管理應(yīng)該做什么。

你也可以使用這些方法去創(chuàng)建封裝其他對象通用的上下文管理。看下面的例子：

class Closer:

'''用with聲明一個上下文管理用一個close方法自動關(guān)閉一個對象'''

def __init__(self, obj):

self.obj = obj

def __enter__(self):

return self.obj # 綁定目標(biāo)

def __exit__(self, exception_type, exception_val, trace):

try:

self.obj.close()

except AttributeError: #obj不具備close

print 'Not closable.'

return True # 成功處理異常

以下是一個對于Closer實際應(yīng)用的一個例子，使用一個FTP連接進行的演示（一個可關(guān)閉的套接字）：

>>> from magicmethods import Closer

>>> from ftplib import :;;

>>> with Closer(FTP('ftp.somsite.com')) as conn:

... conn.dir()

...

# 省略的輸出

>>> conn.dir()

# 一個很長的AttributeError消息， 不能關(guān)閉使用的一個連接

>>> with Closer(int(5)) as i:

... i += 1

...

Not closeable.

>>> i

6

構(gòu)建描述符對象

描述符可以改變其他對象，也可以是訪問類中任一的getting,setting,deleting。

作為一個描述符，一個類必須至少實現(xiàn)__get__,__set__,和__delete__中的一個。讓我們快點看一下這些神奇方法吧：

__get__(self, instance, owner)

當(dāng)描述符的值被取回時定義其行為。instance是owner對象的一個實例，owner是所有類。

__set__(self, instance, value)

當(dāng)描述符的值被改變時定義其行為。instance是owner對象的一個實例，value是設(shè)置的描述符的值

__delete__(self, instance)

當(dāng)描述符的值被刪除時定義其行為。instance是owner對象的一個實例。

現(xiàn)在，有一個有用的描述符應(yīng)用例子：單位轉(zhuǎn)換策略

class Meter(object):

'''米描述符'''

def __init__(self, value=0.0):

self.value = float(value)

def __get__(self, instance, owner):

return self.value

def __set__(self, instance, value):

self.value = float(value)

class Foot(object):

'''英尺描述符'''

def __get__(self, instance, owner):

return instance.meter * 3.2808

def __set__(self, instance, value):

instance.meter = float(value) / 3.2808

class Distance(object):

'''表示距離的類，控制2個描述符：feet和meters'''

meter = Meter()

foot = Foot()

總結(jié)

這份指南的目標(biāo)就是讓任何人都能讀懂它，不管讀者們是否具備Python或面向?qū)ο蟮木幊探?jīng)驗。如果你正準(zhǔn)備學(xué)習(xí)Python，那你已經(jīng)獲得了編寫功能豐富、優(yōu)雅、易用的類的寶貴知識。如果你是一名中級Python程序員，你有可能已經(jīng)拾起了一些概念、策略和一些好的方法來減少你編寫的代碼量。如果你是一名Python專家，你可能已經(jīng)回顧了某些你可能已經(jīng)遺忘的知識點，或者你又又有一些新的發(fā)現(xiàn)。不管你的經(jīng)驗等級如何，希望你在這次Python神奇方法之旅中有所收獲！

很多人在問，學(xué)習(xí)Python讀什么書，這其實是一個非常通用的問題，學(xué)習(xí)分為三種方式：看書、上課，而讀書學(xué)習(xí)是最實惠也是最高效的一種，小編整理了一些Python高分書籍給大家，從0基礎(chǔ)到高級適合不同學(xué)習(xí)階段，希望大家學(xué)習(xí)愉快。獲取方式：點擊小編頭像，關(guān)注后私信回復(fù)“資料”即可下載。

總結(jié)

以上是生活随笔為你收集整理的Python学习秘籍 这些窍门就连老司机都不一定知道 值得学习的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

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