全國統(tǒng)一學(xué)習(xí)專線 9:00-21:00
這份資料非常純粹，只有Python的基礎(chǔ)語法，專門針對想要學(xué)習(xí)Python的小白。
Python中用#表示單行注釋，#之后的同行的內(nèi)容都會被注釋掉。
使用三個連續(xù)的雙引號表示多行注釋，兩個多行注釋標(biāo)識之間內(nèi)容會被視作是注釋。
Python當(dāng)中的數(shù)字定義和其他語言一樣：
我們分別使用+, -, *, /表示加減乘除四則運算符。
這里要注意的是，在Python2當(dāng)中，10/3這個操作會得到3，而不是3.33333。因為除數(shù)和被除數(shù)都是整數(shù)，所以Python會自動執(zhí)行整數(shù)的計算，幫我們把得到的商取整。如果是10.0 / 3，就會得到3.33333。目前Python2已經(jīng)不再維護(hù)了，可以不用關(guān)心其中的細(xì)節(jié)。
但問題是Python是一個 弱類型 的語言，如果我們在一個函數(shù)當(dāng)中得到兩個變量，是無法直接判斷它們的類型的。這就導(dǎo)致了同樣的計算符可能會得到不同的結(jié)果，這非常蛋疼。以至于程序員在運算除法的時候，往往都需要手工加上類型轉(zhuǎn)化符，將被除數(shù)轉(zhuǎn)成浮點數(shù)。
在Python3當(dāng)中撥亂反正，修正了這個問題，即使是兩個整數(shù)相除，并且可以整除的情況下，得到的結(jié)果也一定是浮點數(shù)。
如果我們想要得到整數(shù)，我們可以這么操作：
兩個除號表示 取整除 ，Python會為我們保留去除余數(shù)的結(jié)果。
除了取整除操作之外還有取余數(shù)操作，數(shù)學(xué)上稱為取模，Python中用%表示。
Python中支持 乘方運算 ，我們可以不用調(diào)用額外的函數(shù)，而使用**符號來完成：
當(dāng)運算比較復(fù)雜的時候，我們可以用括號來強制改變運算順序。
Python中用首字母大寫的True和False表示真和假。
用and表示與操作，or表示或操作，not表示非操作。而不是C++或者是Java當(dāng)中的&&, || 和！。
在Python底層， True和False其實是1和0 ，所以如果我們執(zhí)行以下操作，是不會報錯的，但是在邏輯上毫無意義。
我們用==判斷相等的操作，可以看出來True==1， False == 0.
我們要小心Python當(dāng)中的bool()這個函數(shù)，它并不是轉(zhuǎn)成bool類型的意思。如果我們執(zhí)行這個函數(shù)，那么 只有0會被視作是False，其他所有數(shù)值都是True ：
Python中用==判斷相等，>表示大于，>=表示大于等于， <表示小于，<=表示小于等于，!=表示不等。
我們可以用and和or拼裝各個邏輯運算：
注意not，and，or之間的優(yōu)先級，其中not > and > or。如果分不清楚的話，可以用括號強行改變運行順序。
關(guān)于list的判斷，我們常用的判斷有兩種，一種是剛才介紹的==，還有一種是is。我們有時候也會簡單實用is來判斷，那么這兩者有什么區(qū)別呢？我們來看下面的例子：
Python是全引用的語言，其中的對象都使用引用來表示。is判斷的就是 兩個引用是否指向同一個對象 ，而==則是判斷兩個引用指向的具體內(nèi)容是否相等。舉個例子，如果我們把引用比喻成地址的話，is就是判斷兩個變量的是否指向同一個地址，比如說都是沿河?xùn)|路XX號。而==則是判斷這兩個地址的收件人是否都叫張三。
顯然，住在同一個地址的人一定都叫張三，但是住在不同地址的兩個人也可以都叫張三，也可以叫不同的名字。所以如果a is b，那么a == b一定成立，反之則不然。
Python當(dāng)中對字符串的限制比較松， 雙引號和單引號都可以表示字符串 ，看個人喜好使用單引號或者是雙引號。我個人比較喜歡單引號，因為寫起來方便。
字符串也支持+操作，表示兩個字符串相連。除此之外，我們把兩個字符串寫在一起，即使沒有+，Python也會為我們拼接：
我們可以使用[]來查找字符串當(dāng)中某個位置的字符，用 len 來計算字符串的長度。
我們可以在字符串前面 加上f表示格式操作 ，并且在格式操作當(dāng)中也支持運算，比如可以嵌套上len函數(shù)等。不過要注意，只有Python3.6以上的版本支持f操作。
*是None的判斷，在Python當(dāng)中None也是一個對象， 所有為None的變量都會指向這個對象 。根據(jù)我們前面所說的，既然所有的None都指向同一個地址，我們需要判斷一個變量是否是None的時候，可以使用is來進(jìn)行判斷，當(dāng)然用==也是可以的，不過我們通常使用is。
理解了None之后，我們再回到之前介紹過的bool()函數(shù)，它的用途其實就是判斷值是否是空。所有類型的 默認(rèn)空值會被返回False ，否則都是True。比如0，""，[], {}, ()等。
除了上面這些值以外的所有值傳入都會得到True。
Python當(dāng)中的標(biāo)準(zhǔn)輸入輸出是 input和print 。
print會輸出一個字符串，如果傳入的不是字符串會自動調(diào)用__str__方法轉(zhuǎn)成字符串進(jìn)行輸出。 默認(rèn)輸出會自動換行 ，如果想要以不同的字符結(jié)尾代替換行，可以傳入end參數(shù)：
使用input時，Python會在命令行接收一行字符串作為輸入?？梢栽趇nput當(dāng)中傳入字符串，會被當(dāng)成提示輸出：
Python支持 三元表達(dá)式 ，但是語法和C++不同，使用if else結(jié)構(gòu)，寫成：
上段代碼等價于：
Python中用[]表示空的list，我們也可以直接在其中填充元素進(jìn)行初始化：
使用append和pop可以在list的末尾插入或者刪除元素：
list可以通過[]加上下標(biāo)訪問指定位置的元素，如果是負(fù)數(shù)，則表示 倒序訪問 。-1表示*一個元素，-2表示倒數(shù)第二個，以此類推。如果訪問的元素超過數(shù)組長度，則會出發(fā) 的錯誤。
list支持切片操作，所謂的切片則是從原list當(dāng)中 拷貝 出指定的一段。我們用start: end的格式來獲取切片，注意，這是一個 左閉右開區(qū)間 。如果留空表示全部獲取，我們也可以額外再加入一個參數(shù)表示步長，比如[1:5:2]表示從1號位置開始，步長為2獲取元素。得到的結(jié)果為[1, 3]。如果步長設(shè)置成-1則代表反向遍歷。
如果我們要指定一段區(qū)間倒序，則前面的start和end也需要反過來，例如我想要獲取[3: 6]區(qū)間的倒序，應(yīng)該寫成[6:3:-1]。
只寫一個:，表示全部拷貝，如果用is判斷拷貝前后的list會得到False。可以使用del刪除指定位置的元素，或者可以使用remove方法。
insert方法可以 指定位置插入元素 ，index方法可以查詢某個元素*次出現(xiàn)的下標(biāo)。
list可以進(jìn)行加法運算，兩個list相加表示list當(dāng)中的元素合并。 等價于使用extend 方法：
我們想要判斷元素是否在list中出現(xiàn)，可以使用 in關(guān)鍵字 ，通過使用len計算list的長度：
tuple和list非常接近，tuple通過()初始化。和list不同， tuple是不可變對象 。也就是說tuple一旦生成不可以改變。如果我們修改tuple，會引發(fā)TypeError異常。
由于小括號是有改變優(yōu)先級的含義，所以我們定義單個元素的tuple， 末尾必須加上逗號 ，否則會被當(dāng)成是單個元素：
tuple支持list當(dāng)中絕大部分操作：
我們可以用多個變量來解壓一個tuple：
解釋一下這行代碼：
我們在b的前面加上了星號， 表示這是一個list 。所以Python會在將其他變量對應(yīng)上值的情況下，將剩下的元素都賦值給b。
補充一點，tuple本身雖然是不可變的，但是 tuple當(dāng)中的可變元素是可以改變的 。比如我們有這樣一個tuple：
我們雖然不能往a當(dāng)中添加或者刪除元素，但是a當(dāng)中含有一個list，我們可以改變這個list類型的元素，這并不會觸發(fā)tuple的異常：
dict也是Python當(dāng)中經(jīng)常使用的容器，它等價于C++當(dāng)中的map，即 存儲key和value的鍵值對 。我們用{}表示一個dict，用:分隔key和value。
對 。我們用{}表示一個dict，用:分隔key和value。
dict的key必須為不可變對象，所以 list、set和dict不可以作為另一個dict的key ，否則會拋出異常：
我們同樣用[]查找dict當(dāng)中的元素，我們傳入key，獲得value，等價于get方法。
我們可以call dict當(dāng)中的keys和values方法，獲取dict當(dāng)中的所有key和value的集合，會得到一個list。在Python3.7以下版本當(dāng)中，返回的結(jié)果的順序可能和插入順序不同，在Python3.7及以上版本中，Python會保證返回的順序和插入順序一致：
我們也可以用in判斷一個key是否在dict當(dāng)中，注意只能判斷key。
如果使用[]查找不存在的key，會引發(fā)KeyError的異常。如果使用 get方法則不會引起異常，只會得到一個None ：
方法可以 為不存在的key 插入一個value，如果key已經(jīng)存在，則不會覆蓋它：
我們可以使用update方法用另外一個dict來更新當(dāng)前dict，比如a.update(b)。對于a和b交集的key會被b覆蓋，a當(dāng)中不存在的key會被插入進(jìn)來：
我們一樣可以使用del刪除dict當(dāng)中的元素，同樣只能傳入key。
Python3.5以上的版本支持使用**來解壓一個dict：
set是用來存儲 不重復(fù)元素 的容器，當(dāng)中的元素都是不同的，相同的元素會被刪除。我們可以通過set()，或者通過{}來進(jìn)行初始化。注意當(dāng)我們使用{}的時候，必須要傳入數(shù)據(jù)，否則Python會將它和dict弄混。
set當(dāng)中的元素也必須是不可變對象，因此list不能傳入set。
可以調(diào)用add方法為set插入元素：
set還可以被認(rèn)為是集合，所以它還支持一些集合交叉并補的操作。
set還支持 超集和子集的判斷 ，我們可以用大于等于和小于等于號判斷一個set是不是另一個的超集或子集：
和dict一樣，我們可以使用in判斷元素在不在set當(dāng)中。用copy可以拷貝一個set。
Python當(dāng)中的判斷語句非常簡單，并且Python不支持switch，所以即使是多個條件，我們也只能 羅列if-else 。
我們可以用in來循環(huán)迭代一個list當(dāng)中的內(nèi)容，這也是Python當(dāng)中基本的循環(huán)方式。
如果我們要循環(huán)一個范圍，可以使用range。range加上一個參數(shù)表示從0開始的序列，比如range(10)，表示[0, 10)區(qū)間內(nèi)的所有整數(shù)：
如果我們傳入兩個參數(shù)，則 代表迭代區(qū)間的首尾 。
如果我們傳入第三個元素，表示每次 循環(huán)變量自增的步長 。
如果使用enumerate函數(shù)，可以 同時迭代一個list的下標(biāo)和元素 ：
while循環(huán)和C++類似，當(dāng)條件為True時執(zhí)行，為false時退出。并且判斷條件不需要加上括號：
Python當(dāng)中使用 try和except捕獲異常 ，我們可以在except后面限制異常的類型。如果有多個類型可以寫多個except，還可以使用else語句表示其他所有的類型。finally語句內(nèi)的語法 無論是否會觸發(fā)異常都必定執(zhí)行 ：
在Python當(dāng)中我們經(jīng)常會使用資源，最常見的就是open打開一個文件。我們 打開了文件句柄就一定要關(guān)閉 ，但是如果我們手動來編碼，經(jīng)常會忘記執(zhí)行close操作。并且如果文件異常，還會觸發(fā)異常。這個時候我們可以使用with語句來代替這部分處理，使用with會 自動在with塊執(zhí)行結(jié)束或者是觸發(fā)異常時關(guān)閉打開的資源 。
以下是with的幾種用法和功能：
凡是可以使用in語句來迭代的對象都叫做 可迭代對象 ，它和迭代器不是一個含義。這里只有可迭代對象的介紹，想要了解迭代器的具體內(nèi)容，請移步傳送門：
Python——五分鐘帶你弄懂迭代器與生成器，夯實代碼能力
當(dāng)我們調(diào)用dict當(dāng)中的keys方法的時候，返回的結(jié)果就是一個可迭代對象。
我們 不能使用下標(biāo)來訪問 可迭代對象，但我們可以用iter將它轉(zhuǎn)化成迭代器，使用next關(guān)鍵字來獲取下一個元素。也可以將它轉(zhuǎn)化成list類型，變成一個list。
使用def關(guān)鍵字來定義函數(shù)，我們在傳參的時候如果指定函數(shù)內(nèi)的參數(shù)名， 可以不按照函數(shù)定義的順序 傳參：
可以在參數(shù)名之前加上*表示任意長度的參數(shù)，參數(shù)會被轉(zhuǎn)化成list：
也可以指定任意長度的關(guān)鍵字參數(shù)，在參數(shù)前加上**表示接受一個dict：
當(dāng)然我們也可以兩個都用上，這樣可以接受任何參數(shù)：
傳入?yún)?shù)的時候我們也可以使用*和**來解壓list或者是dict：
Python中的參數(shù) 可以返回多個值 ：
函數(shù)內(nèi)部定義的變量即使和全局變量重名，也 不會覆蓋全局變量的值 。想要在函數(shù)內(nèi)部使用全局變量，需要加上 global 關(guān)鍵字，表示這是一個全局變量：
Python支持 函數(shù)式編程 ，我們可以在一個函數(shù)內(nèi)部返回一個函數(shù)：
Python中可以使用lambda表示 匿名函數(shù) ，使用:作為分隔，:前面表示匿名函數(shù)的參數(shù)，:后面的是函數(shù)的返回值：
我們還可以將函數(shù)作為參數(shù)使用map和filter，實現(xiàn)元素的批量處理和過濾。關(guān)于Python中map、reduce和filter的使用，具體可以查看之前的文章：
五分鐘帶你了解map、reduce和filter
我們還可以結(jié)合循環(huán)和判斷語來給list或者是dict進(jìn)行初始化：
使用 import語句引入一個Python模塊 ，我們可以用.來訪問模塊中的函數(shù)或者是類。
我們也可以使用from import的語句，單獨引入模塊內(nèi)的函數(shù)或者是類，而不再需要寫出完整路徑。使用from import *可以引入模塊內(nèi)所有內(nèi)容（不推薦這么干）
可以使用as給模塊內(nèi)的方法或者類起別名：
我們可以使用dir查看我們用的模塊的路徑：
這么做的原因是如果我們當(dāng)前的路徑下也有一個叫做math的Python文件，那么 會覆蓋系統(tǒng)自帶的math的模塊 。這是尤其需要注意的，不小心會導(dǎo)致很多奇怪的bug。
我們來看一個完整的類，相關(guān)的介紹都在注釋當(dāng)中
以上內(nèi)容的詳細(xì)介紹之前也有過相關(guān)文章，可以查看：
Python—— slots ，property和對象命名規(guī)范
下面我們來看看Python當(dāng)中類的使用：
這里解釋一下，實例和對象可以理解成一個概念，實例的英文是instance，對象的英文是object。都是指類經(jīng)過實例化之后得到的對象。
繼承可以讓子類 繼承父類的變量以及方法 ，并且我們還可以在子類當(dāng)中指定一些屬于自己的特性，并且還可以重寫父類的一些方法。一般我們會將不同的類放在不同的文件當(dāng)中，使用import引入，一樣可以實現(xiàn)繼承。
我們創(chuàng)建一個蝙蝠類：
我們再創(chuàng)建一個蝙蝠俠的類，同時繼承Superhero和Bat：
執(zhí)行這個類：
我們可以通過yield關(guān)鍵字創(chuàng)建一個生成器，每次我們調(diào)用的時候執(zhí)行到y(tǒng)ield關(guān)鍵字處則停止。下次再次調(diào)用則還是從yield處開始往下執(zhí)行：
除了yield之外，我們還可以使用()小括號來生成一個生成器：
關(guān)于生成器和迭代器更多的內(nèi)容，可以查看下面這篇文章：
五分鐘帶你弄懂迭代器與生成器，夯實代碼能力
我們引入functools當(dāng)中的wraps之后，可以創(chuàng)建一個裝飾器。裝飾器可以在不修改函數(shù)內(nèi)部代碼的前提下，在外面包裝一層其他的邏輯:
裝飾器之前也有專門的文章詳細(xì)介紹，可以移步下面的傳送門：
一文搞定Python裝飾器，看完面試不再慌
不知道有多少小伙伴可以看到結(jié)束，原作者的確非常厲害，把Python的基本操作基本上都囊括在里面了。如果都能讀懂并且理解的話，那么Python這門語言就算是入門了。
如果你之前就有其他語言的語言基礎(chǔ)，我想本文讀完應(yīng)該不用30分鐘。當(dāng)然在30分鐘內(nèi)學(xué)會一門語言是不可能的，也不是我所提倡的。但至少通過本文我們可以做到熟悉Python的語法，知道大概有哪些操作，剩下的就要我們親自去寫代碼的時候去體會和運用了。
根據(jù)我的經(jīng)驗，在學(xué)習(xí)一門新語言的前期，不停地查閱資料是免不了的。希望本文可以作為你在使用Python時候的查閱文檔。
*，我這里有各種免費的編程類資料，有需要的及時私聊我，回復(fù)"學(xué)習(xí)"，分享給大家，正在發(fā)放中............
使用Python中的線程模塊，能夠同時運行程序的不同部分，并簡化設(shè)計。如果你已經(jīng)入門Python，并且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。
線程與進(jìn)程
什么是進(jìn)程
進(jìn)程是系統(tǒng)進(jìn)行資源分配和調(diào)度的一個獨立單位 進(jìn)程是具有一定獨立功能的程序關(guān)于某個數(shù)據(jù)集合上的一次運行活動,進(jìn)程是系統(tǒng)進(jìn)行資源分配和調(diào)度的一個獨立單位。每個進(jìn)程都有自己的獨立內(nèi)存空間，不同進(jìn)程通過進(jìn)程間通信來通信。由于進(jìn)程比較重量，占據(jù)獨立的內(nèi)存，所以上下文進(jìn)程間的切換開銷（棧、寄存器、虛擬內(nèi)存、文件句柄等）比較大，但相對比較穩(wěn)定安全。
什么是線程
CPU調(diào)度和分派的基本單位 線程是進(jìn)程的一個實體，是CPU調(diào)度和分派的基本單位,它是比進(jìn)程更小的能獨立運行的基本單位.線程自己基本上不擁有系統(tǒng)資源,只擁有一點在運行中必不可少的資源(如程序計數(shù)器,一組寄存器和棧),但是它可與同屬一個進(jìn)程的其他的線程共享進(jìn)程所擁有的全部資源。線程間通信主要通過共享內(nèi)存，上下文切換很快，資源開銷較少，但相比進(jìn)程不夠穩(wěn)定容易丟失數(shù)據(jù)。
進(jìn)程與線程的關(guān)系圖
線程與進(jìn)程的區(qū)別：
進(jìn)程
現(xiàn)實生活中，有很多的場景中的事情是同時進(jìn)行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進(jìn)行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領(lǐng)導(dǎo)來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。
注意：
多任務(wù)的概念
什么叫 多任務(wù) 呢？簡單地說，就是操作系統(tǒng)可以同時運行多個任務(wù)。打個比方，你一邊在用瀏覽器上網(wǎng)，一邊在聽MP3，一邊在用Word趕作業(yè)，這就是多任務(wù)，至少同時有3個任務(wù)正在運行。還有很多任務(wù)悄悄地在后臺同時運行著，只是桌面上沒有顯示而已。
現(xiàn)在，多核CPU已經(jīng)非常普及了，但是，即使過去的單核CPU，也可以執(zhí)行多任務(wù)。由于CPU執(zhí)行代碼都是順序執(zhí)行的，那么，單核CPU是怎么執(zhí)行多任務(wù)的呢？
答案就是操作系統(tǒng)輪流讓各個任務(wù)交替執(zhí)行，任務(wù)1執(zhí)行0.01秒，切換到任務(wù)2，任務(wù)2執(zhí)行0.01秒，再切換到任務(wù)3，執(zhí)行0.01秒，這樣反復(fù)執(zhí)行下去。表面上看，每個任務(wù)都是交替執(zhí)行的，但是，由于CPU的執(zhí)行速度實在是太快了，我們感覺就像所有任務(wù)都在同時執(zhí)行一樣。
真正的并行執(zhí)行多任務(wù)只能在多核CPU上實現(xiàn)，但是，由于任務(wù)數(shù)量遠(yuǎn)遠(yuǎn)多于CPU的核心數(shù)量，所以，操作系統(tǒng)也會自動把很多任務(wù)輪流調(diào)度到每個核心上執(zhí)行。 其實就是CPU執(zhí)行速度太快啦！以至于我們感受不到在輪流調(diào)度。
并行與并發(fā)
并行（）
并行：指兩個或兩個以上事件（或線程）在同一時刻發(fā)生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執(zhí)行。
特點
并發(fā)（）
指一個物理CPU(也可以多個物理CPU) 在若干道程序（或線程）之間多路復(fù)用，并發(fā)性是對有限物理資源強制行使多用戶共享以提高效率。
特點
.Process模塊
process模塊是一個創(chuàng)建進(jìn)程的模塊，借助這個模塊，就可以完成進(jìn)程的創(chuàng)建。
語法：Process([group [, target [, name [, args [, kwargs]]]]])
由該類實例化得到的對象，表示一個子進(jìn)程中的任務(wù)（尚未啟動）。
注意：1. 必須使用關(guān)鍵字方式來指定參數(shù)；2. args指定的為傳給target函數(shù)的位置參數(shù)，是一個元祖形式，必須有逗號。
參數(shù)介紹：
group：參數(shù)未使用，默認(rèn)值為None。
target：表示調(diào)用對象，即子進(jìn)程要執(zhí)行的任務(wù)。
args：表示調(diào)用的位置參數(shù)元祖。
kwargs：表示調(diào)用對象的字典。如kwargs = {'name':Jack, 'age':18}。
name：子進(jìn)程名稱。
代碼：
除了上面這些開啟進(jìn)程的方法之外，還有一種以繼承Process的方式開啟進(jìn)程的方式：
通過上面的研究，我們千方百計實現(xiàn)了程序的異步，讓多個任務(wù)可以同時在幾個進(jìn)程中并發(fā)處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管并發(fā)編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。
當(dāng)多個進(jìn)程使用同一份數(shù)據(jù)資源的時候，就會引發(fā)數(shù)據(jù)安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數(shù)據(jù)安全的重要性。
加鎖可以保證多個進(jìn)程修改同一塊數(shù)據(jù)時，同一時間只能有一個任務(wù)可以進(jìn)行修改，即串行的修改。加鎖犧牲了速度，但是卻保證了數(shù)據(jù)的安全。
因此我們*找尋一種解決方案能夠兼顧：1、效率高（多個進(jìn)程共享一塊內(nèi)存的數(shù)據(jù)）2、幫我們處理好鎖問題。
模塊為我們提供的基于消息的IPC通信機(jī)制：隊列和管道。隊列和管道都是將數(shù)據(jù)存放于內(nèi)存中 隊列又是基于（管道+鎖）實現(xiàn)的，可以讓我們從復(fù)雜的鎖問題中解脫出來， 我們應(yīng)該盡量避免使用共享數(shù)據(jù)，盡可能使用消息傳遞和隊列，避免處理復(fù)雜的同步和鎖問題，而且在進(jìn)程數(shù)目增多時，往往可以獲得更好的可獲展性（ 后續(xù)擴(kuò)展該內(nèi)容 ）。
線程
Python的threading模塊
Python 供了幾個用于多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創(chuàng)建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創(chuàng)建一個可以用于多個線程之間 共享數(shù)據(jù)的隊列數(shù)據(jù)結(jié)構(gòu)。
python創(chuàng)建和執(zhí)行線程
創(chuàng)建線程代碼
1. 創(chuàng)建方法一:
2. 創(chuàng)建方法二:
進(jìn)程和線程都是實現(xiàn)多任務(wù)的一種方式，例如：在同一臺計算機(jī)上能同時運行多個QQ（進(jìn)程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進(jìn)程不能共享資源，而線程共享所在進(jìn)程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進(jìn)程內(nèi)的所有線程共享全局變量，但多線程對全局變量的更改會導(dǎo)致變量值得混亂。
代碼演示:
得到的結(jié)果是：
首先需要明確的一點是GIL并不是Python的特性，它是在實現(xiàn)Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標(biāo)準(zhǔn)，但是可以用不同的編譯器來編譯成可執(zhí)行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執(zhí)行環(huán)境來執(zhí)行（其中的JPython就沒有GIL）。
那么CPython實現(xiàn)中的GIL又是什么呢？GIL全稱Global Lock為了避免誤導(dǎo)，我們還是來看一下官方給出的解釋：
主要意思為:
因此，解釋器實際上被一個全局解釋器鎖保護(hù)著，它確保任何時候都只有一個Python線程執(zhí)行。在多線程環(huán)境中，Python 虛擬機(jī)按以下方式執(zhí)行:
由于GIL的存在，Python的多線程不能稱之為嚴(yán)格的多線程。因為 多線程下每個線程在執(zhí)行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。
由于GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什么還要使用多線程呢？
由于以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由于計算機(jī)的迅速發(fā)展，現(xiàn)在的電腦幾乎都是多核CPU了，最少也是兩個核心數(shù)的，這時差別就出來了：通過之前的案例我們已經(jīng)知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優(yōu)勢，反而由于每個線程在多個CPU上是交替執(zhí)行的，導(dǎo)致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進(jìn)程只存在一把gil鎖，當(dāng)在執(zhí)行多個線程時，內(nèi)部會爭搶gil鎖，這會造成當(dāng)某一個線程沒有搶到鎖的時候會讓cpu等待，進(jìn)而不能合理利用多核cpu資源。
但是在使用多線程抓取網(wǎng)頁內(nèi)容時，遇到IO阻塞時，正在執(zhí)行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執(zhí)行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。
GIL對多線程Python程序的影響
程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什么是計算密集型和I/O密集型程序呢?
計算密集型：要進(jìn)行大量的數(shù)值計算，例如進(jìn)行上億的數(shù)字計算、計算圓周率、對視頻進(jìn)行高清解碼等等。這種計算密集型任務(wù)雖然也可以用多任務(wù)完成，但是花費的主要時間在任務(wù)切換的時間，此時CPU執(zhí)行任務(wù)的效率比較低。
IO密集型：涉及到網(wǎng)絡(luò)請求(time.sleep())、磁盤IO的任務(wù)都是IO密集型任務(wù)，這類任務(wù)的特點是CPU消耗很少，任務(wù)的大部分時間都在等待IO操作完成（因為IO的速度遠(yuǎn)遠(yuǎn)低于CPU和內(nèi)存的速度）。對于IO密集型任務(wù)，任務(wù)越多，CPU效率越高，但也有一個限度。
當(dāng)然為了避免GIL對我們程序產(chǎn)生影響，我們也可以使用，線程鎖。
Lock&RLock
常用的資源共享鎖機(jī)制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。
Lock
特點就是執(zhí)行速度慢，但是保證了數(shù)據(jù)的安全性
RLock
使用鎖代碼操作不當(dāng)就會產(chǎn)生死鎖的情況。
什么是死鎖
死鎖：當(dāng)線程A持有獨占鎖a，并嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，并嘗試獲取獨占鎖a的情況下，就會發(fā)生AB兩個線程由于互相持有對方需要的鎖，而發(fā)生的阻塞現(xiàn)象，我們稱為死鎖。即死鎖是指多個進(jìn)程因競爭資源而造成的一種僵局，若無外力作用，這些進(jìn)程都將無法向前推進(jìn)。
所以，在系統(tǒng)設(shè)計、進(jìn)程調(diào)度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配算法，避免進(jìn)程永久占據(jù)系統(tǒng)資源。
死鎖代碼
python線程間通信
如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進(jìn)行通信，不然計算結(jié)果等內(nèi)容無法取回。而實際情況中要復(fù)雜的多，多個線程間需要交換數(shù)據(jù)，才能得到正確的執(zhí)行結(jié)果。
python中Queue是消息隊列，提供線程間通信機(jī)制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用于實現(xiàn)線程通信。
在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區(qū)別就在于進(jìn)隊列、出隊列的不同。
簡單代碼演示
此時代碼會阻塞，因為queue中內(nèi)容已滿，此時可以在第四個queue.put('蘋果')后面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鐘仍然是滿的就會拋出異常，可以捕獲異常。
同理如果隊列是空的，無法獲取到內(nèi)容默認(rèn)也會阻塞，如果不阻塞可以使用queue.get_nowait()。
在掌握了 Queue 阻塞隊列的特性之后，在下面程序中就可以利用 Queue 來實現(xiàn)線程通信了。
下面演示一個生產(chǎn)者和一個消費者，當(dāng)然都可以多個
使用queue模塊，可在線程間進(jìn)行通信，并保證了線程安全。
協(xié)程
協(xié)程，又稱微線程，纖程。英文名Coroutine。
協(xié)程是python個中另外一種實現(xiàn)多任務(wù)的方式，只不過比線程更小占用更小執(zhí)行單元（理解為需要的資源）。為啥說它是一個執(zhí)行單元，因為它自帶CPU上下文。這樣只要在合適的時機(jī)， 我們可以把一個協(xié)程 切換到另一個協(xié)程。只要這個過程中保存或恢復(fù) CPU上下文那么程序還是可以運行的。
通俗的理解：在一個線程中的某個函數(shù)，可以在任何地方保存當(dāng)前函數(shù)的一些臨時變量等信息，然后切換到另外一個函數(shù)中執(zhí)行，注意不是通過調(diào)用函數(shù)的方式做到的，并且切換的次數(shù)以及什么時候再切換到原來的函數(shù)都由開發(fā)者自己確定。
在實現(xiàn)多任務(wù)時，線程切換從系統(tǒng)層面遠(yuǎn)不止保存和恢復(fù) CPU上下文這么簡單。操作系統(tǒng)為了程序運行的高效性每個線程都有自己緩存Cache等等數(shù)據(jù)，操作系統(tǒng)還會幫你做這些數(shù)據(jù)的恢復(fù)操作。所以線程的切換非常耗性能。但是協(xié)程的切換只是單純的操作CPU的上下文，所以一秒鐘切換個上百萬次系統(tǒng)都抗的住。
greenlet與gevent
為了更好使用協(xié)程來完成多任務(wù)，除了使用原生的yield完成模擬協(xié)程的工作，其實python還有的greenlet模塊和gevent模塊，使實現(xiàn)協(xié)程變的更加簡單高效。
greenlet雖說實現(xiàn)了協(xié)程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的并且能夠自動切換任務(wù)的模塊。
其原理是當(dāng)一個greenlet遇到IO(指的是input output 輸入輸出，比如網(wǎng)絡(luò)、文件操作等)操作時，比如訪問網(wǎng)絡(luò)，就自動切換到其他的greenlet，等到IO操作完成，再在適當(dāng)?shù)臅r候切換回來繼續(xù)執(zhí)行。
模擬耗時操作：
如果有耗時操作也可以換成，gevent中自己實現(xiàn)的模塊，這時候就需要打補丁了。
使用協(xié)程完成一個簡單的二手房信息的爬蟲代碼吧！
以下文章來源于Python專欄 ，作者宋宋
文章鏈接：
本文將總結(jié)之前在使用 python-docx 包處理 word 文檔時的一些理解與經(jīng)驗。
安裝
引入
python-docx 將整個文章看做是一個 Document 對象 官方文檔 - Document ，其基本結(jié)構(gòu)如下：
在 python-docx 中， run 是最基本的單位，每個 run 對象內(nèi)的文本樣式都是一致的，也就是說，在從 docx 文件生成文檔對象時， python-docx 會根據(jù)樣式的變化來將文本切分為一個個的 Run 對象。
你也可以通過它來處理表格 官方文檔 - 表格 ，基本結(jié)構(gòu)如下：
只要一個電話
我們免費為您回電