?

本人做過8年的Java開發，后來有接觸了2年的python，這兩種語言各有各的味道。Java就像德國戰車，各種精密的零件配合起來龐大無比力拔山兮！python像紅色法拉利，沒有戰車那么強悍的戰斗力但是靈活迅捷充滿藝術之美。

我想通過兩篇博文來好好的深挖一下python，第一篇從深層次的細節入手再“深度學習”一次python；第二篇從宏觀原則上來分析下到底怎么寫python代碼才能把它寫成一輛法拉利（至少達到保時捷的要求吧），而不是寫成一輛BYD。

?

?

首先，我們要對python充滿信心，經過碼農門的精雕吸啄，我們可以讓程序及有很好的可讀性，又能很簡單的解決問題，這就是藝術之美。

先看個快排的例子：

def quicksort(array) :less, lagger = [],[]if len(array)<=1 :return arrayelement = array.pop()for obj in array :if obj <= element : less.append(obj)else : lagger.append(obj)return quicksort(less) + [element] + quicksort(lagger)

如果有種語法簡練而且可讀性很好的感覺，那么就說明我們寫的代碼是合格的。

為了寫出更多合格的代碼，我們必須深挖一些python語言的細節，python到底能干什么，還有哪些我們沒有pick up的知識點？本文講跟大家一一過濾一遍。

?

1 變量交換

Java中需要定義個中間變量，先把其中一個賦值給中間變量，然后互換，再然后把中間變量的賦值給另一個。

Python直接：x,y=y,x

在底層是根據右邊的表達式先生成了一個tuple(y,x)，然后按順序賦值給左邊的變量。

?

2 %占位符

在3個以內的占位%使我們能夠接受的，一旦更多的字符變量就會讓程序的可讀性變得很差，我們就需要換另一種寫法了：

people = {'name':'chalie','age':20,'male':'he','county':'USA'} print('%(name)s is %(age)d years old, and %(male)s comes from %(county)s' %(people))

?

3 學習一些高質量的模塊

多了解一些符合Pythonic的模塊（flask、requests等），可以最大程度的簡化代碼，并提高可讀性。

關于flask我打算單獨拿出一個主題好好講解一次,歡迎持續關注.

?

4 python的斷言 x=1 y=2 assert x==y, 'not equal'

低層實現是：

if __debug__ and not x==y :raise AssertionError('not equal')

雖然我們可以通過python –O xxx.py的方式運行時忽視斷言，但是并不會優化字節碼，所以斷言的使用要慎重，不是越多越好。

?

5 枚舉

Python的枚舉與其它語言的枚舉并沒有特別之處，這里單獨拿出來強調一下是因為畢竟這是python3.4版本才添加進來的特性，需要學習下如何使用
import enum class myEnum(enum.Enum) :Zero = 0One = 1Two = 2Other = 99if __name__ == '__main__':oneEnum = myEnum.One.valuefourEnum = myEnum['Other'].valueprint(oneEnum)print(fourEnum)

?

6 類型檢查

由于python底層是強對象而語法上是弱對象類型，所以必要時候需要做好類型檢查，格式如下：

class typeA :passclass typeB:passif __name__ == '__main__':a = typeA()b = typeB()print(isinstance(a,(typeA)))print(isinstance(b, (typeA)))

PS：類型檢查與python的鴨子原理又是背道而馳的，所以只需要做理解，不到萬不得已不建議使用，只要知道有這個能力就好。

?

7 yield

先從表面來看，有寫過oracle存儲過程經歷的開發人員對yield最好的類比就是存過里面的游標，它是一個生成器，里面將會不斷的吐出內容，直到所有內容吐完后游標會關閉。而且它是延時執行的，也就是說不像集合那樣是一直占用內存的，只有當游標打開處理每個數據的時候才會真正被執行。

案例代碼：

def dofunction(numList):for i in numList :yield i*iif __name__ == '__main__' :numList = [1,2,3,4,5]for x in dofunction(numList) :print(x)

本質上是用了協程，每send一次執行到下一個yield，全代碼應該如下：

if __name__ == '__main__' :numList = [1,2,3,4,5]pump = dofunction(numList)while 1:try:print(pump.send(None))except StopIteration :break

本篇后面有對生成器的詳細介紹，看到后面就會理解yield的原理了

?

8熟悉list和字典的操作，掌握最簡潔的方式來處理內容 myList = [[1,2], [3,4], [5,6], [7,8], [9,0]] for i,listValue in enumerate(myList) :print('%d index , value is %s' %(i,str(listValue)))myMap = {'A':1,'B':2,'C':3,'D':4} for key,mapValue in myMap.items() :print('%s key , value is %s' % (key, str(mapValue)))

9 __init__.py文件

?

作用1：指明當前目錄是個python的包

作用2：級聯導入。我不知道我取的“級聯導入”這個名字正確與否，網上有很多種叫法，我給他的叫法就是級聯導入吧。

我現在的目錄情況是這樣的：

digit想要調用mianshi這個包里的內容，其中mianshi內還包含一個叫taxi的子包。digit、mianshi、taxi目錄下都有一個__init__.py文件，有這個文件它們這寫目錄才能被稱為是python的包。

假設init里是空的，digit中需要這樣才能導入我想要使用的python模塊或函數對象 from mianshi.taxi import arrayTest import mianshi.aop 如果我在mianshi目錄下的init文件添加下行 from mianshi.taxi import arrayTest

我只要在digit中import mianshi就可以直接使用arrayTest模塊了。

OK，叨叨了這么多，思路就是一個,init文件更像是個API接口或者叫API路由，它里面的內容非必須的，你當然可以饒過它自己在外層想用啥導入啥。但是在面向服務編程的思想來考慮，作為一個包，我不需要調用我的客戶端關心我內部是放在那個模塊下它們之間的引入關系是什么樣子的，我只要把我提供服務的能力暴漏在init中就可以了。個人認為這是init設計的初中，面向服務編程。

如果想把所有模塊和函數都公開，也不需要一條條的寫，直接在init中添加 __all__ = ['aop','hello','duck'] 2018-04-05補充：
作用3：人如其名，做初始化處理。 在flask那本狗書中有__init__.py的一種使用場景，對項目進行初始化，并在其中定義了工程方法，方便包外程序調用。

?

10 上下文管理器 with語句

__enter__()方法在語句執行之前進入運行時上下文，__exit__()在

語句體執行完后從運行時上下文退出。With語句的語法如下： with context_expression [as target(s)]:with-body 自己實現個案例如下： class AddContext(object) :def __init__(self,x,y):self.x = xself.y = ydef __enter__(self):print('Transformation')return selfdef __exit__(self, exc_type, exc_val, exc_tb):if exc_type is None:print('Success')return Falseelif exc_type is ValueError :print('Value Error')return Trueelse:print('Other Error')return Truedef doAdd(self):return int(self.x)+int(self.y)if __name__ == '__main__':with AddContext('1','3') as addContext:print(addContext.doAdd())with AddContext('1','a') as addContext:print(addContext.doAdd())

運行結果是：

Transformation 4 Success Transformation Value Error

整個處理過程是：構建對象à調用__enter()__函數并將返回值給as后的變量à執行with-body的內容，上面案例就是調用了doAdd()方法à所有都處理完后調用__exit()__函數。

常用的場景如處理文件讀寫： with open(‘text.txt’,’w’) as file :file.write(‘Hello world’)

省去了try finally關閉流等一些列體力活。

?

?

11 python對空值的判斷

直接看代碼： a = 0 b = {} c = [] d = None e = '' if a or b or c or d or e :print('True') else:print('False')

輸出為False

低層判斷是先調用一個類的 __nonzero()__函數，該函數返回boolean類型或者0/1；如果沒有定義__nonzero()__函數將會調用__len()__函數，該函數返回內容的長度，如果返回0則認為為空。如果既沒有定義nonzero()函數也沒有定義len()函數，則返回True，也就是非空。

?

?

12 字符串的連接+和join

這個就像Java中的String和StringBuffer的區別了，點到為止，大家都應該懂。

?

13 str()函數和repr()函數的區別

在效果上大部分是相同的，但是兩個側重點不一樣，str()像是Java的toString，側重的描述信息；repr()是面向python解析器的，是準確性的。這兩個函數分別調用對象內置的__str()__函數和__repr()__函數，如果__str()__不存在的話就用__repr()__來代替。

?

14 sort()和sorted()的區別

這兩個函數功能類似，但是使用方法大不相同。

Sort()是列表list自帶的方法，而且是對列表內部進行排序，并不會產生新的對象。

Sorted()是個輔助函數，入參是需要排序的對象，出參是排序完成后的對象。

先通過下面例子了解下區別： listx = ['C','B','D','A'] tupley = ('C','B','D','A') print(listx.sort()) print(listx) newy = sorted(tupley) print(newy) 結果是： None ['A', 'B', 'C', 'D'] ['A', 'B', 'C', 'D']

因為tuple是不能改變的，而sort()是內部的排序，所以tuple就沒有sort()功能，只能通過sorted()進行排序產生新的列表。

我使用他們兩個的原則是：能用sort就用sort，因為它簡單而且省資源，不能用sort就來用sorted，因為sorted功能太強大能處理很多sort處理不了的事情。

下面代碼我要嘗試給一個班級的考試結果排個名詞：

oldMap = {'Tony':99,'Ivy':79,'Eva':56,'Charlie':100,'Lucy':95} newMap = sorted(oldMap.items(),key=lambda item : item[1],reverse=True) print(newMap) 結果： [('Charlie', 100), ('Tony', 99), ('Lucy', 95), ('Ivy', 79), ('Eva', 56)]

?

15 積極使用collections模塊，里面提供了很多集合操作的輔助函數

例如Counter： oldList = ['ab','bc',3,'d','bc',90,'e',3] from collections import Counter print(Counter(oldList)) textCounter = Counter('Hello World') print(textCounter) #update定義有些異議，這里應該是insert或者append的意思 textCounter.update('This is a new Hello World') print(textCounter.most_common(3)) 結果： Counter({'bc': 2, 3: 2, 'ab': 1, 'd': 1, 90: 1, 'e': 1}) Counter({'l': 3, 'o': 2, 'H': 1, 'e': 1, ' ': 1, 'W': 1, 'r': 1, 'd': 1}) [('l', 6), (' ', 6), ('o', 4)]

如果不使用collections里的工具，我們自己去實現就要用嵌套循環或者匿名函數之類的才可以達到效果，代碼會又臭又長。

?

16 configparser

configparser管理python運行時配置文件的模塊，就像Java項目中的properties或yml文件那樣，不過configparser管理的文件有自己的格式。

代碼：

import configparser#演示configparser的寫 configWrite = configparser.RawConfigParser()configWrite.add_section('Section1') configWrite.set('Section1','ip','192.168.225.133') configWrite.set('Section1','port','21') configWrite.set('Section1','username','admin') configWrite.set('Section1','password','admin123') configWrite.set('Section1','url','%(username)s %(password)s@%(ip)s:%(port)s') configWrite.set('Section1','nothing')with open('C:\\python\\tmp\\test.cfg','w') as configfile:configWrite.write(configfile)#演示configparser的讀 configReader = configparser.RawConfigParser() configReader.read('C:\\python\\tmp\\test.cfg') #這個輸出并沒有帶入我們要的參數 print(configReader.get('Section1','url')) configReader = configparser.ConfigParser() configReader.read('C:\\python\\tmp\\test.cfg') #這個輸出有了我們想要的內容 print(configReader.get('Section1','url')) configReader.set('Section1','ip','localhost') print(configReader.get('Section1','url')) print(configReader.get('Section1','nothing'))
生成的文件test.cfg內容如下： [Section1] ip = 192.168.225.133 port = 21 username = admin password = admin123 url = %(username)s %(password)s@%(ip)s:%(port)s nothing = None
運行結果： %(username)s %(password)s@%(ip)s:%(port)s admin admin123@192.168.225.133:21 admin admin123@localhost:21 None
? 17 xml解析 Python對于xml解析方式有基于流式的sax解析（xml.sax）、基于內存構建的dom解析（xml.dom）、推薦使用的ElementTree解析（xml.etree.ElementTree）

篇幅問題，可以重點再去了解下ElementTree，特別是它自帶的輔助工具函數.

?

?

18 python的序列化

Java有自己的序列化和反序列化方式,Python也一樣,Python負責序列化的模塊是pickle,分為dump和load兩個動作.

代碼案例: import pickle datalist = ['A','c',3,'5'] with open('C:\\python\\tmp\\data.dat','wb') as file :pickle.dump(datalist,file) with open('C:\\python\\tmp\\data.dat','rb') as file :out = pickle.load(file) print(out) print(type(out)) dumpData = pickle.dumps(datalist) rebuildEntity = pickle.loads(dumpData) print(rebuildEntity) print(type(rebuildEntity))
結果: ['A', 'c', 3, '5'] <class 'list'> ['A', 'c', 3, '5'] <class 'list'>

從代碼可讀和簡潔性來講非常完美,但是pickle致命的缺陷是只能在python之間玩耍,如果要跨語言需要用json xml等方式.隨著微服務化的火爆以及RestFul接口的流行,Json儼然已經成為最熱門的跨平臺的序列化方式.

代碼:

datalist = ['A','c',3,'5']import json jsonStr = json.dumps(datalist) print(jsonStr) rebuildEntity = json.loads(jsonStr) print(rebuildEntity) print(type(rebuildEntity))

結果:

["A", "c", 3, "5"] ['A', 'c', 3, '5'] <class 'list'>

可以看出json與pickle一樣都是dump和load兩個動作(python的鴨子原理..),所以理解和使用起來方便無比.

既然Json和Pickle都可以做序列化,我們把它們之間的優缺點領出來對比下,就可以知道什么場景下需要用哪種序列化了.

Pickle:

優點:二進制流,效率高,可以方便處理復雜類型(它有個叫cPickle的兄弟,效率更高)

缺點:只python內部使用,無法跨平臺

Json:

優點:跨平臺,可讀性高

缺點:復雜類型很難處理,效率低

下圖是json、pickle、cPickle性能上的差距：

?

19 python的日志

關于python的日志,我主要用了python自帶的logging模塊,但是由于日志的重要性以及其篇幅和代碼比較多,我單獨拆開了一篇專門介紹python日志《logging—python日志之深入淺出》.

?

20 單利模式的實現

按照Java的思想來設計單利模式，我會這么去寫： import threadingclass Singleton(object) :_singleInstance = Nonelocker = threading.Lock()def __new__(cls, *args, **kwargs):if cls._singleInstance is None :cls.locker.acquire()try :cls._singleInstance = super(Singleton, cls).__new__(cls, *args, **kwargs)finally:cls.locker.release()return cls._singleInstanceif __name__ == '__main__' :entity_x = Singleton()entity_y = Singleton()print(entity_x is entity_y)

但是它存在一些缺陷：第一，子類可以覆蓋__new__使其失去單利性，第二，__init__方法還是會多次初始化，這不是單利模式的本質。

所以python中最好的單利模式是利用模塊，模塊是天然的單利模式，我想要單利的部分單獨拆分成一個模塊，模塊single.py:

class Singleton(object) :pass__entity = Singleton()def getSingleEntity():return __entity

調用時直接引入single.py既可：

from pyart import singleif __name__ == '__main__' :entityx = single.getSingleEntity()entityy = single.getSingleEntity()print(entityx is entityy)

?

21 python中的訂閱發布

先看一段Java代碼：

public static void main(String[] args) {HashMap<String, String> myMap = new HashMap<String, String>();myMap.put("myKey","myValue");System.out.println(myMap.get("noKey"));}

結果打印是null，因為我們的map里沒有這個鍵值對。

?

再回頭看一段python代碼：

myDict = {'myKey':'myValue'} print(myDict['noKey'])

結果報錯了：KeyError: 'noKey'

所以python中用dictionary（字典）來定義這種鍵值對模式，而不是用java里的table或者map，是有原因的，他們當key找不到的時候給出的處理結果完全不同，所以寫過java的同學在用python的字典時要特別小心，不要入坑。Python中與map相似的key不存在時返回空的是另一個類型“defaultdict”，我們利用它來寫一個訂閱發布模式。

from collections import defaultdictroute_table = defaultdict(list)class Broker(object):# 訂閱，不準重復訂閱def sub(self, topic, callback):if callback in route_table[topic]: returnroute_table[topic].append(callback)# 消費def pub(self, topic, *a, **kw):for func in route_table[topic]:func(*a, **kw)def comsumer1(name) :print('comsumer1 %s' %name)def comsumer2(name) :print('comsumer2 %s' %name)if __name__ == '__main__' :broker = Broker()broker.sub('myjob',comsumer1)broker.sub('myjob', comsumer2)broker.pub('myjob','input')broker.pub('myjob', 'input2') 結果是： comsumer1 input comsumer2 input comsumer1 input2 comsumer2 input2

代碼很好理解，有個細節需要注意下：

defaultdict(list)，有點泛型的意思，對應java的是HashMap<String,List>，這樣解釋好理解吧，它可以是string、dict、int等各種類型。

?

Python有很多上層封裝的很好的、語法更簡潔的輪子可以用，像訂閱發布我們可以用blinker來搞定，代碼：

import blinkerdef comsumer(name):print('comsumer %s' %name)if __name__ == '__main__':mycomsumer = blinker.signal('myjob')mycomsumer.connect(comsumer)myproducer = blinker.signal('myjob')#證明是單利模式print(mycomsumer is myproducer)myproducer.send('Hello')

怎么樣，使用起來可讀性更好更簡潔了吧！mycomsumer和myproducer是同一個實例，所以signal里是單利模式，消費者通過connect進行訂閱，生產者通過send進行發布。

?

訂閱發布的意義在于功能上解耦，connect方法的入參是個函數，我可以丟任何的函數給隊列，而整個隊列只需要維護好主題（title）就好，幫我做好轉發。所以當你的應用場景是要對某個信息做很多種不確定操作，可以考慮考慮訂閱發布模式。

?

?

22 python中的工廠模式

代碼：

class Animal(object):def run(self):print('Animal is running')class Ant(object):def run(self):print('Ant is running')class Ship(object):def run(self):print('Ship is running')class Bee(object):def run(self):print('Bee is running')class Snake(object):def run(self):print('Snake is running')class AnimalFactory(object):__animalMap = {'ant':Ant,'ship':Ship,'bee':Bee,'snake':Snake}def __new__(cls, name):if name in cls.__animalMap.keys():return cls.__animalMap[name]()else:return Animal()if __name__ == '__main__':AnimalFactory('ship').run()AnimalFactory('duck').run()

23 LEGB法則

這個法則不是什么新鮮貨，Java語言中也有，涉及到參數的作用域，以及在當前位置按范圍從小大到搜索變量的規則：localàenclosingàglobalàbuild-in.也就是說從本函數內先找，找不到就去嵌套作用域里去找，還是找不到就去模塊的global里面找（包括導入進來的），還是找不到就去內置的里面去找(有點像java里的lang包)

這個設計基本都是編程語言通用的方式，不難理解，這里點出來是因為這知識點經常被拿來面試，而且LEGB簡寫乍一聽有點懵圈。

?

?

24 MRO與多繼承

又一個繞口的英文簡寫（Method Resolution Order方法解析順序），這個知識點還一個問法就是python的菱形繼承。

因為python不像java那樣是單繼承，所以很容易出現菱形繼承，一旦出現這種樣式的繼承很難判斷函數來自那個爹或者爺爺。

網上大量的資料在介紹，古典型怎么個結果，新類型怎么個結果，我在python3.6里都試驗過就一個結果（不要跟我講默認是新類型，默認的就是我們要學的，記太多過去的東西不容易混淆么）。

當調用D的getValue()時，按照D繼承時括號中從左到右的順序，先找到就哪個；當D調用show()時，按照血緣關系近的那個，也就是按照爹C的而不是爺爺A的。

就這一個規則，記住就好。

?

?

25 property講解

在Java中，持久層入庫的實體類，或者action層處理表單的form類都屬于pojo類的寫法，java代碼如下

public class Tester {public static final String HELLO = "hello";private String name;private int age;public String getName() {return HELLO+name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {if(age>120 || age<0) {throw new RuntimeException("age is error");}this.age = age;} }

變量私有，提供公共的get set方法來操作變量，而且可以在get set中添加轉換和校驗等。

Python中同樣會遇到這種場景，我們當然可以仍然使用getset方法來寫我們的代碼，但是這失去了python編程的特點，我們想直接通過操作屬性的方式來操作get set方法，于是乎借助下property。

python代碼如下：

class Tester(object):hello = 'hello 'def __init__(self,name,age):self._name = nameself._age = agedef name_get(self):return self.__class__.hello+self._namedef name_set(self,name):self._name = namedef age_get(self):return self._agedef age_set(self,age):if age>120 or age<0 :raise AssertionError('age is error')n = property(name_get,name_set)a = property(age_get, age_set)if __name__ == '__main__':tester = Tester('yejingtao',20)print(tester.n)tester.n='lucy'print(tester.n)tester.a=130輸出結果： hello yejingtao hello lucy AssertionError: age is error

我個人比較推崇這種寫法，網上還介紹了一種寫法，個人覺得不如上面這種可讀性高，也給大家敲個案例：

class Tester(object):hello = 'hello 'def __init__(self,name,age):self._name = nameself._age = age@propertydef name(self):return self.__class__.hello+self._name@name.setterdef name(self,name):self._name = name@propertydef age(self):return self._age@age.setterdef age(self,age):if age>120 or age<0 :raise AssertionError('age is error')if __name__ == '__main__':tester = Tester('yejingtao',20)print(tester.name)tester.name='lucy'print(tester.name)tester.age=130

?

26 Python的迭代器（iterator）和生成器（generator）

我們在python中經常通過for i in XXX這種格式來處理數據，用起來很爽，集合、迭代器、生成器都可以被for來處理，所以他們經常會被混淆，這里我們就好好解釋下它們的區別和各自的原理。

首先把集合單獨拿出來，集合與迭代器和生成器不同的是它是要實實在在將內容load到內存的，在處理大批量數據的時候對內存消耗非常大；而后兩者有點像游標的設計，調用時一個個的吐數據來處理，所以性能上后兩者要優于集合類型。

?

迭代器，主要包含__iter__和__next__兩個方法，__iter__方法為了讓調用方通過iter()函數來獲取到迭代器本身，所以一般返回self自己；__next__方法是每次迭代真正執行的邏輯。

代碼如下：

class MyIterator(object) :def __init__(self,start):self.start = start#被iter()調用，返回self自己def __iter__(self):print('Invoke __iter__ function')return self#被next()調用def __next__(self):print('Invoke __next__ function')self.start+=1return self.start#調用迭代器 def mokeFor(times):myIter = iter(MyIterator(0))while times>0 :print(next(myIter))times -=1mokeFor(5)num = 5 iterator = MyIterator(5) for i in iterator:print(i)num-=1if num==0 : break

執行結果：

Invoke __iter__ function Invoke __next__ function 1 Invoke __next__ function 2 Invoke __next__ function 3 Invoke __next__ function 4 Invoke __next__ function 5 Invoke __iter__ function Invoke __next__ function 6 Invoke __next__ function 7 Invoke __next__ function 8 Invoke __next__ function 9 Invoke __next__ function 10

我們可以看到mokeFor里面先通過iter()調用了迭代器的__iter__函數獲取到迭代器自己，然后每次next()調用了迭代器內部的__next__函數完成真正的業務。

案例后面直接用for循環來處理迭代器，與mokeFor對比后可以猜的出來for內部也是iter()和next()的過程。

?

生成器與迭代器的原理完全不同，是通過協程yield關鍵字和next()、send()方法來操作的，讓我們來看個例子：

def MyGenerator(start,times) :while times>0 :start += 1print('befor yield')inputVal = yield startprint('after yield %s' %inputVal)times-=1generator = MyGenerator(0,999) print('------') print(next(generator)) print('------') print(generator.send('send1')) print('------') print(next(generator)) print('------') print(generator.send('send2')) print('------') print(generator.close()) print('------') #print(generator.send('send3'))

執行結果：

------ befor yield 1 ------ after yield send1 befor yield 2 ------ after yield None befor yield 3 ------ after yield send2 befor yield 4 ------ None ------

看不懂沒關系，我們把重點部分拿出來詳細講解下：

記住3個規則：

第一，??yield所在語句等號左邊是輸入，yield后面的是輸出

第二，??obj.send(val)函數send里面就是對應著上面的輸入，而next(obj)相當于obj.send(None)，所以無論是send和next基本可以看成是等價的

第三，??每next或者send一次，就會停在我紅框標注的地方，從右往左執行，只執行到返回輸出的地方(標注了“前”的那一部分)。

?

好記住了這些原理再回頭根據日志對照下吧，就很好理解為什么是這種輸出了。

生成器還有個close()函數，一旦執行后相當于協程結束了，再來next或者send就會報錯：“StopIteration”

?

生成器還有個優點，通過簡單加工可以被with調用，例如：

@contextmanager def MyGenerator() :print('--start--')yield 'for print'print('--end--')myGenerator = MyGenerator() with myGenerator as g:print(g)

?

27 又一個簡寫新名詞（GIL）

GIL：Global InterpreterLock的縮寫，中文叫全局解析器鎖，這個鎖限制了同一時間只能有一個線程在執行。對的你沒有聽錯，換句話說就是：python不支持多線程。

你可能說明明有threading包啊，語法上是支持多線程的啊，可惜現實是那都是假象，python的多線程用通信行業的專業名詞來講是“時分多址”，所有的thread按照時間短競爭享用1個線程~。

你可能會問，這么個二貨東西為什么還要保留這個限制？其實python語言發展方向上是想拋棄它，但是由于歷史的包袱太重所以還得需要幾個大版本的迭代后才能完成吧。

所以python所謂的高并發，什么協程、多線程、多進程，其實只有多進程才是真正意義上多CPU運算，協程和多線程都是單CPU的，所以在處理CPU密集型的場景時需要考慮多進程來處理，但是進程的維護又是很大的消耗，不如真正的多線程來的好。

簡然之吧，不得不說python在處理高并發CPU密集型運算這方面是個很乏力的語言，不客氣的講“基本是個廢物”！

總結

以上是生活随笔為你收集整理的Python之美—技术细节篇的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。