建站
咨詢
售后
建站咨詢
新聞中心
據(jù)說：
創(chuàng)新互聯(lián)公司主要從事成都網(wǎng)站建設(shè)、成都網(wǎng)站設(shè)計、網(wǎng)頁設(shè)計、企業(yè)做網(wǎng)站、公司建網(wǎng)站等業(yè)務(wù)。立足成都服務(wù)南海,10年網(wǎng)站建設(shè)經(jīng)驗,價格優(yōu)惠、服務(wù)專業(yè),歡迎來電咨詢建站服務(wù):13518219792
2019年， 浙江信息技術(shù)高考可以考python了；
2018年， Python 進入了小學生的教材；
2018年， 全國計算機等級考試，可以考python 了；
據(jù)外媒報道，微軟正考慮添加 Python 為官方的一種 Excel 腳本語言
……
Python作為一種編程語言，被稱為“膠水語言”，更被擁躉們譽為“最美麗”的編程語言，從云端到客戶端，再到物聯(lián)網(wǎng)終端，無所不在，同時還是人工智能優(yōu)選的編程語言。
因此，從全棧的角度看， Python 是一門必備的語言，因為它是除了驅(qū)動和操作系統(tǒng)外，其他都可以做好。
不積跬步無以至千里，不積小流無以成江海?！?荀子《勸學》
語法
Python使用空格或制表符縮進的方式分隔代碼，Python 2 僅有31個保留字，而且沒有分號、begin、end等標記。
可以組織成打油詩， 更方便記憶：
- Global is class，def not pass。
- if eilf else， del as break。
- raise in while，import from yield，
- try for print，return and assert。
- exec except with lambda,
- finally or continue……
python中沒有提供定義常量的保留字，可以自己定義一個常量類來實現(xiàn)常量的功能。python中有3種表示字符串類型的方式，即單引號、雙引號、三引號。單引號和雙引號的作用是相同的，python程序員更喜歡用單引號，C/Java程序員則習慣使用雙引號表示字符串。三引號中可以輸入單引號、雙引號或換行等字符。python不支持自增運算符和自減運算符，其他運算符和表達式都是類似的，尤其是分支判斷和循環(huán)。
Python的文件類型分為3種，即源代碼、字節(jié)代碼和優(yōu)化代碼。這些都可以直接運行，不需要進行預編譯或連接。
數(shù)據(jù)類型
Python中的基本數(shù)據(jù)類型有布爾類型，整數(shù)，浮點數(shù)和字符串等。
Python 中的數(shù)據(jù)結(jié)構(gòu)主要有元組（tuple），列表（list）和字典（dictionary）。元組、列表和字符串都屬于序列,是具有索引和切片能力的集合。
元組初始化后不可修改，是寫保護的。元組往往代表一行數(shù)據(jù)，而元組中的元素代表不同的數(shù)據(jù)項，可以把元組看做不可修改的數(shù)組。
- tuple_name=(“you”,”me”,”him”,”her”)
列表可轉(zhuǎn)換為元組，是傳統(tǒng)意義上的數(shù)組，可以實現(xiàn)添加、刪除和查找操作，元素的值可以被修改。
- list_name=[“you”,”me”,”him”,”her”]
字典是鍵值對,相對于哈希表。
- dict_name={“y”:”you”, “m”:”me”, “hi”:”him”, “he”:”her”}
列表推導（List Comprehensions）是構(gòu)建列表的快捷方式, 可讀性較好且效率更高. 運用列表生成式，可以快速生成list，例如 得到當前目錄下的所有目錄和文件：
- >>> import os
- >>> [d for d in os.listdir('.')]
也可以通過一個list推導出另一個list，代碼簡潔，例如 將一個列表中的元素都變成小寫：
- >>> L = ['Hello', 'World', 'IBM', 'Apple']
- >>> [s.lower() for s in L]
通過這些基本類型，可以組成更有針對性需求的數(shù)據(jù)結(jié)構(gòu)，例如字典嵌套形成的樹等， 針對更復雜的數(shù)據(jù)結(jié)構(gòu)， Python 中提供了大量的庫。
類與繼承
python用class來定義一個類，當所需的數(shù)據(jù)結(jié)構(gòu)不能用簡單類型來表示時，就需要定義類，然后利用定義的類創(chuàng)建對象。當一個對象被創(chuàng)建后，包含了三方面的特性，即對象的句柄、屬性和方法。創(chuàng)建對象的方法：
- abel = Abel()
- Abel.do()
類的方法同樣分為公有方法和私有方法。私有函數(shù)不能被該類之外的函數(shù)調(diào)用，私有的方法也不能被外部的類或函數(shù)調(diào)用。python使用函數(shù)”staticmethod()“或”@ staticmethod“的方法把普通的函數(shù)轉(zhuǎn)換為靜態(tài)方法，相當于全局函數(shù)。python的構(gòu)造函數(shù)名為init，析構(gòu)函數(shù)名為del。繼承的使用方法：
- class AbelApp(abel):
- def …
Python 中的變量名解析遵循LEGB原則，本地作用域（Local），上一層結(jié)構(gòu)中的def或Lambda的本地作用域（Enclosing），全局作用域（Global），內(nèi)置作用域（Builtin），按順序查找。
和變量解析不同，Python 會按照特定的順序遍歷繼承樹，就是方法解析順序（Method Resolution Order，MRO）。類都有一個名為mro 的屬性，值是一個元組，按照方法解析順序列出各個超類，從當前類一直向上，直到 object 類。
Python 中有一種特殊的類是元類（metaclass）。元類是由“type”衍生而出，所以父類需要傳入type，元類的操作都在 new中完成。通過元類創(chuàng)建的類，第一個參數(shù)是父類，第二個參數(shù)是metaclass。
包與模塊
python程序由包(package)、模塊(module)和函數(shù)組成。包是由一系列模塊組成的集合。包必須含有一個init.py文件，它用于標識當前文件夾是一個包。
模塊是處理某一類問題的函數(shù)和類的集合。模塊把一組相關(guān)的函數(shù)或代碼組織到一個文件中，一個文件即是一個模塊。模塊由代碼、函數(shù)和類組成。導入模塊使用import語句，不過模塊不限于此，還可以被 import 語句導入的模塊共有以下四類:
- 使用Python寫的程序( .py文件)
- C或C++擴展(已編譯為共享庫或DLL文件)
- 包(包含多個模塊)
- 內(nèi)建模塊(使用C編寫并已鏈接到Python解釋器內(nèi))
Python 提供內(nèi)建函數(shù)__import__動態(tài)加載 module,import 本質(zhì)上是調(diào)用 __import__加載 module 的， 函數(shù)原型如下：
- __import__(name, globals={}, locals={}, fromlist=[], level=-1)
例如，加載名為 abel的目錄下所有模塊：
- def loadModules():
- res = {}
- import os
- lst = os.listdir("abel")
- dir = []
- for d in lst:
- s = os.path.abspath("abel") + os.sep + d
- if os.path.isdir(s) and os.path.exists(s + os.sep + "__init__.py"):
- dir.append(d)
- # load the modules
- for d in dir:
- res[d] = __import__("abel." + d, fromlist = ["*"])
- return res
需要注意的是，如果輸入的參數(shù)如果帶有 “.”，采用 __import__直接導入 module 容易造成意想不到的結(jié)果。 OpenStack 的 oslo.utils 封裝了 __import__，支持動態(tài)導入 class, object 等。
命名規(guī)范
Python 中的naming convention 以及 coding standard 有很多好的實踐，例如Google 的Python 編程規(guī)范等。 就命名規(guī)范而言， 可以參見Python之父Guido推薦的規(guī)范，見下表：
迭代器
迭代是數(shù)據(jù)處理的基礎(chǔ)， 采用一種惰性獲取數(shù)據(jù)的方式, 即按需一次獲取一個數(shù)據(jù)，這就是迭代器模式. 迭代器是一個帶狀態(tài)的對象，檢查一個對象 a 是否是迭代對象, 最準確的方法是調(diào)用 iter(a) , 如果不可迭代, 則拋出 TypeError 異常.
標準的迭代器接口有兩個方法:
- __next__: 返回下一個可用元素, 如沒有, 拋出StopIteration 異常.
- __iter__: 返回self , 以便在應該使用可迭代對象的地方使用迭代器.
可迭代對象一定不能是自身的迭代器. 也就是說, 可迭代對象必須實現(xiàn) __iter__方法, 但不能實現(xiàn) __next__ 方法.
實現(xiàn)一個斐波那契數(shù)列的迭代器例子如下：
- class Fibonacci:
- def __init__(self):
- self.prevous = 0
- self.current = 1
- def __iter__(self):
- return self
- def __next__(self):
- value = self.current
- self.current = self.prevous + self.current
- self.prevous = value
- return value
迭代器就是實現(xiàn)了工廠模式的對象，有很多關(guān)于迭代器的例子，比如itertools函數(shù)返回的都是迭代器對象。
生成器
生成器算得上是Python中最吸引人的特性之一，生成器其實是一種特殊的迭代器，但不需要寫__iter__()和__next__()方法了，只需要一個yiled關(guān)鍵字即可。python中的 yield 關(guān)鍵字, 用于構(gòu)建生成器(generator), 其作用與迭代器一樣. 還以斐波那契數(shù)列為例：
- def Fibonacci():
- prevous, current = 0, 1
- while True:
- yield current
- prevous, current = current, current + prevous
所有的生成器都是迭代器, 都實現(xiàn)了迭代器的接口。 一般地，只要python函數(shù)的定義體中使用了 yield 關(guān)鍵字, 該函數(shù)就是生成器函數(shù). 調(diào)用生成器函數(shù)時, 會返回一個生成器對象。也就是說, 生成器函數(shù)是生成器工廠。
生成器函數(shù)會創(chuàng)建一個生成器對象, 包裝生成器函數(shù)的定義體. 把生成器傳給 next(…) 函數(shù)時, 生成器函數(shù)會向前執(zhí)行函數(shù)體中下一個 yield 語句, 返回產(chǎn)出的值, 并在函數(shù)定義體的當前位置暫停.
需要注意的是， 在協(xié)程中, yield 通常出現(xiàn)在表達式的右邊(data = yield), 可以產(chǎn)出值, 也可以不產(chǎn)出(如果yield后面沒有表達式, 那么會出None)。 協(xié)程可能會從調(diào)用方接收數(shù)據(jù), 調(diào)用方把數(shù)據(jù)提供給協(xié)程使用 通過的是 .send(data) 方法. 而不是 next(…) . 通常, 調(diào)用方會把值推送給協(xié)程.
生成器調(diào)用方是一直獲取數(shù)據(jù), 而協(xié)程調(diào)用方可以向它傳入數(shù)據(jù), 協(xié)程也不一定要產(chǎn)出數(shù)據(jù)。不管數(shù)據(jù)如何流動, yield 都是一種流程控制工具, 使用它可以實現(xiàn)寫作式多任務(wù)即，協(xié)程可以把控制器讓步給中心調(diào)度程序, 從而激活其他的協(xié)程.
描述符
描述符是一種創(chuàng)建托管屬性的方法，托管屬性還可用于保護屬性不受修改，或自動更新某個依賴屬性的值。描述符是一種在多個屬性上重復利用同一個存取邏輯的方式，能劫持那些本應對于self.__dict__的操作。在其他編程語言中，描述符被稱作 setter 和 getter，用于獲得 (Get) 和設(shè)置 (Set) 一個私有變量。Python 沒有私有變量的概念，而描述符可以作為一種 Python 的方式來實現(xiàn)與私有變量類似的功能。
靜態(tài)方法、類方法、property都是構(gòu)建描述符的類。創(chuàng)建描述符的方式主要有3種：
1.創(chuàng)建一個類并覆蓋任意一個描述符方法：__set__、__ get__ 和 __delete__。當需要某個描述符跨多個不同的類和屬性的時候，例如類型驗證，則使用該方法，例如：
- class MyNameDescriptor(object):
- def __init__(self):
- self._myname = ''
- def __get__(self, instance, owner):
- return self._myname def __set__(self, instance, myname):
- self._myname = myname.getText() def __delete__(self, instance):
- del self._myname
2.使用屬性類型可以更加簡單、靈活地創(chuàng)建描述符。通過使用 property()，可以輕松地為任意屬性創(chuàng)建可用的描述符。
- class Student(object):
- def __init__(self):
- self._sname = ''
- def fget(self):
- return self._sname def fset(self, value):
- self._sname = value.title() def fdel(self):
- del self._sname
- name = property(fget, fset, fdel, "This is the property.")
3.使用屬性描述符，它結(jié)合了屬性類型方法和 Python裝飾器。
- class Student(object):
- def __init__(self):
- self._sname = ''
- @property
- def name(self):
- return self._sname @name.setter
- def name(self, value):
- self._sname = value.title() @name.deleter
- def name(self):
- del self._sname
另外，還可以在運行時動態(tài)創(chuàng)建描述符。 描述符有很多經(jīng)典的應用，例如Protobuf。
裝飾器
裝飾器(Decorator)是可調(diào)用的對象, 其參數(shù)是另一個函數(shù)(被裝飾的函數(shù)). 裝飾器可能會處理被裝飾的函數(shù), 然后把它返回, 或者將其替換成另一個函數(shù)或可調(diào)用對象.實際上裝飾器就是一個高階函數(shù)，它接收一個函數(shù)作為參數(shù)，然后返回一個新函數(shù)。
裝飾器有兩大特征:
- 把被裝飾的函數(shù)替換成其他函數(shù)
- 裝飾器在加載模塊時立即執(zhí)行
python內(nèi)置了三個用于裝飾方法的函數(shù): property、classmethod 和 staticmethod. 當裝飾器不關(guān)心被裝飾函數(shù)的參數(shù)，或是被裝飾函數(shù)的參數(shù)多種多樣的時候，可變參數(shù)非常適合使用。
如果一個函數(shù)被多個裝飾器修飾，其實應該是該函數(shù)先被最里面的裝飾器修飾，變成另一個函數(shù)后，再次被裝飾器修飾。例如：
- def second(func):
- print "running 2nd decorator"
- def wrapper():
- func()
- return wrapper
- def fisrt(func):
- print "running 1st decorator"
- def wrapper():
- func()
- return wrapper
- @second
- @first
- def myfunction():
- print "running myfunction"
就擴展功能而言，裝飾器模式比子類化更加靈活。
在設(shè)計模式中，具體的裝飾器實例要包裝具體組件的實例，即裝飾器和所裝飾的組件接口一致，對使用該組件的客戶端透明，并將客戶端的請求轉(zhuǎn)發(fā)給該組件，并且可能在轉(zhuǎn)發(fā)前后執(zhí)行一些額外的操作，透明性使得可以遞歸嵌套多個裝飾器，從而可以添加任意多個功能。裝飾器模式和Python裝飾器之間并不是一對一的等價關(guān)系，Python裝飾器函數(shù)更為強大，不僅僅可以實現(xiàn)裝飾器模式。
Lambda
Python 不是純萃的函數(shù)式編程語言，但本身提供了一些函數(shù)式編程的特性，像 map、reduce、filter等都支持函數(shù)作為參數(shù)，lambda 函數(shù)函數(shù)則是函數(shù)式編程中的翹楚。
Lambda 函數(shù)又稱匿名函數(shù)，在某種意義上，return語句隱含在lambda中。和其他很多語言相比，Python 的 lambda 限制很多，最嚴重的是它只能由一條表達式組成。lambda規(guī)范必須包含只有一個表達式，表達式必須返回一個值，由lambda創(chuàng)建一個匿名函數(shù)隱式地返回表達式的返回值。
在PySpark 中經(jīng)常會用到使用Lambda 的操作，例如：
li = [1, 2, 3, 4, 5]
### 列表中國年的每個元素加5
map(lambda x: x+5, li)
### 返回其中的偶數(shù)
filter(lambda x: x % 2 == 0, li) # [2, 4]
### 返回所有元素的乘積
reduce(lambda x, y: x * y, li)
lambda 可以接收任意多個參數(shù) (包括可選參數(shù)) 并且返回單個表達式的值。
本質(zhì)上，Lambda 函數(shù)是一個只與輸入?yún)?shù)有關(guān)的抽象代碼樹片段。在很多語言里，lambda 函數(shù)的調(diào)用會被套上一層接口，還會形成閉包，在 lambda 函數(shù)構(gòu)造的同時就可以完成，之后 lambda 函數(shù)內(nèi)部就是完全靜態(tài)的。而一般的函數(shù)還要加上存儲局部變量的區(qū)域，對外部環(huán)境的操作，以及命名，大部分語言強制了一般函數(shù)必須與名字綁定。
線程
python是支持多線程的, python的線程就是C語言的一個pthread，并通過操作系統(tǒng)調(diào)度算法進行調(diào)度。 python 的thread模塊是輕量級的，而threading模塊是對thread做了一些封裝，方便使用。threading 經(jīng)常和Queue結(jié)合使用,Queue模塊中提供了同步的、線程安全的隊列類，包括FIFO隊列，LIFO隊列，和優(yōu)先級隊列等。這些隊列都實現(xiàn)了鎖，能夠在多線程中直接使用，可以使用隊列來實現(xiàn)線程間的同步。
運行線程(線程中包含name屬性)的兩種常用方式如下:
- 在構(gòu)造函數(shù)中傳入用于線程運行的函數(shù)
- 在子類中重寫threading.Thread基類中run()方法(只需重寫init()和run()方法)
實現(xiàn)一個守護線程的簡單例子如下：
- class MyThread(threading.Thread):
- def run(self):
- time.sleep(30)
- print 'thread %s finished.' % self.name
- def MyDaemons():
- print 'start thread:'
- for i in range(5):
- t = MyThread()
- t.setDaemon(1)
- t.start()
- print 'end thread.'
- if __name__ == '__main__':
- MyDaemons()
為了避免線程不同步造成數(shù)據(jù)不同步，可以對資源進行加鎖，也就是訪問資源的線程需要獲得鎖，才能訪問。threading 模塊中提供了一個 Lock 功能。從Python3.X開始，標準庫為提供了concurrent.futures模塊，其中的ThreadPoolExecutor和ProcessPoolExecutor兩個類，實現(xiàn)了對threading和multiprocessing的進一步抽象，對編寫線程池提供了直接支持。
線程在python 被詬病的是，由于GIL的機制致使多線程不能利用機器多核的特性。其實，GIL并不是Python的特性，只是在實現(xiàn)Python解析器(CPython)的時侯所引入的。盡管Python完全支持多線程編程， 但解釋器的C語言實現(xiàn)部分在完全并行執(zhí)行時并不是線程安全的，解釋器被一個全局鎖即GIL保護著，它確保任何時候都只有一個Python線程執(zhí)行。
在多線程環(huán)境中，Python 虛擬機按以下方式執(zhí)行:
設(shè)置GIL
切換到一個線程去執(zhí)行
運行指定的字節(jié)碼指令集合
線程主動讓出控制
把線程設(shè)置完睡眠狀態(tài)
解鎖GIL
再次重復以上步驟
因此，Python的多線程在多核CPU上，只對于IO密集型計算產(chǎn)生正面效果；而當有至少有一個CPU密集型線程存在，那么多線程效率會由于GIL而大幅下降。
GC
Python 中的GC為可配置的垃圾回收器提供了一個接口。通過它可以禁用回收器、調(diào)整回收頻率以及設(shè)置debug選項，也為用戶能夠查看那些無法回收的對象。
需要了解GC 的兩個重要函數(shù)是gc.collect（） 和 gc.set_threshold（）。
gc.collect([generation])觸發(fā)回收行為，返回unreachable object的數(shù)量。generation可選參數(shù)，用于指定回收第幾代垃圾回收，由此也可看出python使用的是分代垃圾回收。如果不提供參數(shù)，表示對整個堆進行回收，即Full GC。
gc.set_threshold(threshold0[,threshold1[,threshold2)設(shè)置不同代的回收頻率，GC會把生命周期不同的對象分別放到3種代去管理回收，generation 0即傳說中的年輕代，generation 1為老年代等。
一般地，通過比較上次回收之后，比較分配的資源數(shù)和釋放的資源數(shù)來決定是否啟動回收，比如，當分配的資源減去釋放的資源數(shù)超過閾值0時，回收年輕代的對象。相應的，可以通過gc.get_referents(*objs)得到對objs任一對象引用的所有對象列表。
在要求極限性能的情況下，并確保程序不會造成對象循環(huán)引用的時候，可以禁掉垃圾回收器。通過使用gc.disable()，可以禁掉自動垃圾回收器。
1. gc.enable()：激活GC
2. gc.disable()：禁用GC
3. gc.isenabled():檢查是否激活
同時，可以用gc.set_debug(gc.DEBUG_LEAK)來調(diào)試有內(nèi)存泄露的程序。除此之外，還有DEBUG_SAVEALL，該選項能夠讓被回收的對象保存在gc.garbage里面，以便檢查。
調(diào)試
iPDB是一個不錯的工具，通過 pip install ipdb 安裝該工具，然后在你的代碼中import ipdb; ipdb.set_trace()，然后在程序運行時，會獲得一個交互式提示，每次執(zhí)行程序的一行并且檢查變量。示例代碼如下：
- import ipdb
- ipdb.set_trace()
- ipdb.set_trace(context=5) # will show five lines of code
- # instead of the default three lines
- ipdb.pm()
- ipdb.run('x[0] = 3')
- result = ipdb.runcall(function, arg0, arg1, kwarg='foo')
- result = ipdb.runeval('f(1,2) - 3')
另外，python內(nèi)置了一個很好的追蹤模塊，當希望搞清其他程序的內(nèi)部構(gòu)造的時候，這個功能非常有用。
- python -m trace --trace tracing.py
在一些場合，可以使用pycallgraph來追蹤性能問題，它可以創(chuàng)建函數(shù)調(diào)用時間和次數(shù)的圖表。同時，objgraph對于查找內(nèi)存泄露非常有用。
當然， 在Python 程序員八榮八恥中談到“以打印日志為榮 , 以單步跟蹤為恥“，日志在很多時候都是調(diào)試的不二法門。
性能優(yōu)化中的雕蟲小技
從時空的角度看，優(yōu)化通常包含兩方面的內(nèi)容：減小代碼的體積，提高代碼的運行效率。
一個良好的算法往往對性能起到關(guān)鍵作用，因此性能改進的首要點是對算法的改進。在算法的時間復雜度排序上依次是：
O(1) -> O(log n) -> O(n) -> O(n log n) -> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!)
因此能在時間復雜度上對算法進行一定的改進，對性能的提高不言而喻。
Python 字典中查找操作的復雜度為O(1)，而list 實際是個數(shù)組，在list 中查找需要遍歷整個表，其復雜度為O(n)，因此對成員的讀操作字典要比列表 更快。在需要多數(shù)據(jù)成員進行頻繁訪問的時候，字典是一個較好的選擇。set的union， intersection，difference操作要比list的迭代要快。因此如果涉及到求list交集，并集或者差的問題可以轉(zhuǎn)換為set來操作。
對循環(huán)的優(yōu)化所遵循的原則是盡量減少循環(huán)過程中的計算量，有多重循環(huán)的盡量將內(nèi)層的計算提到上一層。 在循環(huán)的時候使用 xrange 而不是 range，因為 xrange() 在序列中每次調(diào)用只產(chǎn)生一個整數(shù)元素。而 range() 將直接返回完整的元素列表，用于循環(huán)時會有不必要的開銷。另外，while 1 要比 while True 更快。另外，要充分利用Lazy if-evaluation的特性，也就是說如果存在條件表達式if x and y，在 x 為false的情況下y表達式的值將不再計算。
python中的字符串對象是不可改變的，因此對任何字符串的操作如拼接，修改等都將產(chǎn)生一個新的字符串對象，而不是基于原字符串，因此這種持續(xù)的copy會在一定程度上影響python的性能。因此，在字符串連接的使用盡量使用join()而不是+，當對字符串處理的時候，選擇內(nèi)置函數(shù)，對字符進行格式化比直接串聯(lián)讀取要快，盡量使用列表推導和生成器表達式。
優(yōu)化的前提是需要了解性能瓶頸在什么地方，對于比較復雜的代碼可以借助一些工具來定位，如profile。profile的使用非常簡單，只需要在使用之前進行import即可。對于profile的剖析數(shù)據(jù)，如果以二進制文件的時候保存結(jié)果的時候，可以通過pstats模塊進行文本報表分析，它支持多種形式的報表輸出，是文本界面下一個較為實用的工具。
Python性能優(yōu)化除了改進算法，選用合適的數(shù)據(jù)結(jié)構(gòu)之外，還可以將關(guān)鍵python代碼部分重寫成C擴展模塊，或者選用在性能上更為優(yōu)化的解釋器等。
強大的庫
Python最棒的地方之一，就是大量的第三方庫，覆蓋之廣，令人驚嘆。Python 庫有一個缺陷就是默認會進行全局安裝。為了使每個項目都有一個獨立的環(huán)境，需要使用工具virtualenv，再用包管理工具pip和virtualenv配合工作。
盡管都可以求助于google或者baidu，但還要不自量力，按照個人認知給出一個列表，如下：
雖然羅列很多，但終歸是滄海一粟，重要的是，這些都是開源的。
不是小結(jié)的小結(jié)
語法數(shù)據(jù)，類與繼承；
包與模塊，規(guī)范命名；
描述裝飾，迭代生成；
Lambda GC， 并發(fā)線程；
調(diào)試優(yōu)化，類庫無窮；
人生苦短，Python 編程。
【本文來自專欄作者“老曹”的原創(chuàng)文章，作者微信公眾號：喔家ArchiSelf,id:wrieless-com】
標題名稱：老曹的文章：全棧必備你需要了解的Python編程基礎(chǔ)
文章轉(zhuǎn)載：http://fisionsoft.com.cn/article/cojssdd.html
