python初探
??
python近兩年似乎已經(jīng)很熱了，不了解一下怎么能行呢，似乎python最大的優(yōu)點(diǎn)就是簡潔、易懂、優(yōu)雅。目前豆瓣、知乎等后臺服務(wù)使用的也都是python語言。 python一般可以用于網(wǎng)站服務(wù)、小工具、數(shù)據(jù)分析等工作。它作為高級語言，和js一樣，是解釋型語言，所以運(yùn)行速度上會比較慢，但是在網(wǎng)絡(luò)服務(wù)上，相對于網(wǎng)速的緩慢，運(yùn)行速度也就不是很大的問題了。?
python環(huán)境安裝
在windows環(huán)境下，我們可以進(jìn)入這里下載安裝，安裝的過程中需要勾選添加到環(huán)境變量，這樣，在命令行操作過程中就不會出現(xiàn)問題了。 安裝完成后，打開命令行，輸入python，就進(jìn)入交互模式了，輸入exit()，即可退出python環(huán)境。 另外，這個安裝的python環(huán)境就是最為通用的python解釋器cpython，之所以稱為cpython，是因?yàn)檫@個解釋器是通過c語言編寫的。
?
?
簡單的例子
我們在運(yùn)行中，輸入cmd進(jìn)入的是命令行模式，而如果輸入python，就可以進(jìn)入python交互模式，因此如果我們希望運(yùn)行python代碼，就需要進(jìn)入python交互模式，上面的圖片也就是python交互模式。
我們還可以在進(jìn)入python交互模式后，輸入 print('hello world!') ，即這是python的輸出字符串的語法，當(dāng)然，我們也可以使用print輸出多個字符串，需要使用逗號隔開，如 print('hello', 'world', 'wayne')，并且其中也是可以接受數(shù)字的，如print(200)。?
另外，我們可以編輯一個.py后綴的python文件，然后在命令行下運(yùn)行，即 python foo.py就可以執(zhí)行這個foo.py文件了。
?
如上，我在sublime編輯器中新建一個foo.py，其中python語句是沒有分號和花括號的，因?yàn)檫@樣更加接近于自然語言。 然后在命令行中運(yùn)行:
這樣，一個簡單的python程序就出來了。?
?
?
輸入輸出
python中的輸入輸出也是非常簡單的。?
輸出就是使用print，可以接受多個參數(shù)，參數(shù)的類型可以是數(shù)字也可是字符串，當(dāng)然字符串中可以有\(zhòng)t和\n等。
輸入當(dāng)然也是交互中必不可少的，為name()，這個在執(zhí)行之后，會提示用戶輸入，name()函數(shù)可以接受一個字符串作為參數(shù)，如name('請輸入你的名字：')，舉例如下：
name = input('請輸入你的名字:') print('你好，', name)?
python基礎(chǔ)知識
? python作為計(jì)算機(jī)語言，那么語言就必須要計(jì)算機(jī)理解，必須有一定的規(guī)則，而不是像自然語言很隨意。python的語法是比較簡單的，采用的時特有的縮進(jìn)的方式，并且沒有像js那樣分號作為語句的結(jié)束，且語句在使用 : （冒號）結(jié)尾時，縮進(jìn)的語句視為代碼塊，縮進(jìn)沒有特定的要求，但是一般以4個空格為準(zhǔn)，且python是大小寫敏感的。?python中使用#作為注釋的標(biāo)志。且python中不需要聲明變量，直接使用就可以了。如下所示：
num = input('請輸入一個數(shù)字') if int(num) > 0:print('您輸入的數(shù)字大于0') elif int(num) < 0:print('您輸入的數(shù)字小于0') else:print('您輸入的數(shù)字等于0')我們可以看到python中的else if需要寫成elif，否則會報(bào)錯，這樣也正是python簡潔的體現(xiàn)，而通過input()函數(shù)輸入的是一個字符串，在直接判斷與0的大小時會出錯，所以我們可以使用int()來講字符串強(qiáng)制轉(zhuǎn)化為數(shù)字，就可以進(jìn)一步的比較了。 如下：
?
python中的數(shù)據(jù)類型和其他語言都是大同小異的，包括整數(shù)、浮點(diǎn)數(shù)、字符串、布爾值以及運(yùn)算。其中布爾值有些許不同，如True表示真，而False表示假，第一個字母需要大寫，另外，我們可以使用 and、 or、 not 來表示布爾值的與、或、非運(yùn)算，這使得python更加接近自然語言。python中使用None表示空值。 它的變量同樣是大小寫英文、數(shù)字和_組合，且不能使用數(shù)字作為開頭 。?python是動態(tài)語言，因?yàn)樗淖兞款愋秃蚸s一樣是可以變動的，而不像java。 另外，python中的除法有兩種，一種是普通的 / ，這種方法不管除數(shù)和被除數(shù)為整數(shù)或者浮點(diǎn)數(shù)，得到的結(jié)果都是浮點(diǎn)數(shù)；而 // 這種除法得到的結(jié)果總是整數(shù)。同樣，python使用 % 作為求余的操作符。?
?
?
python字符串和編碼
對于字符串而言，最為復(fù)雜的就是編碼問題了，因?yàn)橛?jì)算機(jī)只能處理0/1數(shù)字，所以要處理文本，就必須先把文本轉(zhuǎn)換為數(shù)字才能處理。
1個字節(jié)是8個bit，所以一個字節(jié)能表示的最大的整數(shù)是255，也就是說用一個字節(jié)編碼的方式可以最多表示255種字符。而最早是美國人發(fā)明了計(jì)算機(jī)，他們使用的語言只有a-zA-Z和其他字符一共127個，即ASCII編碼。但對于十萬個漢字的編碼，顯然ASCII編碼是做不到，而兩個字節(jié)可以表示6萬多種字符，所以，中文的編碼至少需要2個字節(jié)，于是中國制定了GB2312編碼。 但世界上有上百種文字，日本要把日文編到Shift_jis中，韓國把韓文編到Euc-kr中，顯然，這樣就沒有了統(tǒng)一的標(biāo)準(zhǔn)，而使得有多種文字編碼的文本中，很可能出現(xiàn)亂碼的情況。
因此，Unicode編碼應(yīng)運(yùn)而生，即union code，統(tǒng)一的編碼，這種編碼包含了各國文字，使得文本可以通用，而不必?fù)?dān)心出現(xiàn)亂碼的情況，Unicode編碼一般是兩個字節(jié)，但兩個字節(jié)只能表示6萬多字符，所以有時也會有四個字節(jié)的情況，但對于常用的文字，一般都是兩個字節(jié)。但如果一直使用Unicode編碼，問題是如果通篇英文，Unicode編碼會比ASCII編碼多出一倍的存儲空間，這是非常浪費(fèi)的，于是，又出現(xiàn)了 UTF-8編碼，這種編碼把一個unicode字符根據(jù)不同的數(shù)字大小編為1 - 6個字節(jié)，常用的英文字母還是1個字節(jié)（可以將ASCII編碼看做UTF-8編碼的一部分），而漢字通常是3個字節(jié)，所以如果傳輸中包含了大量的英文字符，使用UTF-8編碼會更加節(jié)省空間。
實(shí)際上，在計(jì)算機(jī)內(nèi)存中，統(tǒng)一使用Unicode編碼，當(dāng)需要保存到硬盤或者傳輸?shù)臅r候，就轉(zhuǎn)換成UTF-8編碼，如瀏覽網(wǎng)頁的時候，服務(wù)器會把動態(tài)生成的Unicode內(nèi)容轉(zhuǎn)換成UTF-8再傳輸?shù)綖g覽器。這樣我們也就理解HTML文件中 <meta charset="UTF-8"/>的含義了。
而python中字符串也是Unicode編碼的，即它支持多種語言，而不會出現(xiàn)亂碼。對于單個字符的編碼，python提供了ord()函數(shù)獲取字符的整數(shù)表示（Unicode編碼的整數(shù)表示），chr()函數(shù)把編碼轉(zhuǎn)換為對應(yīng)的字符。?
而如果我們知道字符的整數(shù)編碼，還可以用十六進(jìn)制來寫str，如
>>> '\u4e2d\u6587' '中文'其中，\u這個轉(zhuǎn)義字符表示Unicode編碼，而4e2d是十六進(jìn)制的編碼，即中這個漢子用了兩個字節(jié)來表示，同樣文也用了兩個字節(jié)來表示。
另外，Python中提供了encode()函數(shù)和decode()函數(shù)來進(jìn)行編碼和解碼，len()函數(shù)來返回字符長度。
?
? 在python中，也經(jīng)常需要格式化，和c語言是非常類似的，%s為字符串，%d為整數(shù)，%f為浮點(diǎn)數(shù)，%x為十六進(jìn)制數(shù)，并且如果在表示中有%我們需要進(jìn)行轉(zhuǎn)義%%，另外，如果不知道該用哪個占位符，統(tǒng)一使用%s就可以了。format()函數(shù)也是同樣的表達(dá)方式，但相對于前者還是稍顯復(fù)雜，如下所示：
?
?
使用list和tuple
在c++中有List和tuple這兩種數(shù)據(jù)類型，而在python中同樣也有。 list比tuple有更多的操作方法，但是tupple一旦定義不能被改變，因而更加安全，下面做簡單介紹。?
如上所示，我們可以直接定義rel = ['wayne', 'hedy', 'baby']這個list，使用len()函數(shù)可以獲取這個list的長度，使用rel[0]這種下標(biāo)可以獲取其中的元素，通過append()可以將元素添加到末尾，通過pop()可以彈出（刪除）最后一個元素，我們還可以通過insert()將元素插入到指定位置，使用pop(num)將指定位置的元素刪除，并且使用 rel[num] = str的方式直接替換list中的某個元素。 因此，list數(shù)據(jù)類型還是非常方便，操作起來更為簡單、強(qiáng)大。?
?
?
tupple和list非常類似，只是在定義的時候使用的時()而非[]，并且最為本質(zhì)的區(qū)別在于tupple一旦定義只能訪問不能修改，當(dāng)然也就沒有append、insert、pop這些方法了，優(yōu)點(diǎn)就是更安全，如果可以使用tupple就盡量不要使用list。?
可以看到，我們定義了rel之后，只能進(jìn)行訪問，而在試圖修改時發(fā)生了錯誤。?
?
循環(huán)
python中有兩種循環(huán)。一種是使用for...in循環(huán)，另外一種便是while循環(huán)。
rel = ['wayne', 'hedy', 'baby'] for name in rel:print(name, '\n')以上是使用for...in循環(huán)rel這個list，注意，以為for下一行縮進(jìn)，所以for語句后有 : （冒號）。
另外，python中提供了range函數(shù)，如list(range(50))?可以生成一個0到49的list，而不需要我們手寫了。同樣，for...in也可以使用range，如下：
max = int(input('請輸入一個正整數(shù)：')) sum = 0 for a in range(max + 1):sum = sum + a print('1到%d' % max, '的和為：',sum )運(yùn)行結(jié)果如下所示：
?
而while循環(huán)和其他語言的循環(huán)也是類似的，如下所示：
import time n = int(input('請輸入一個正整數(shù)：')) while n > 0:print(n, 's\n')time.sleep(1)n = n - 1 print('over!')?這里我們在python文件中直接引入了time模塊，通過time模塊的sleep函數(shù)使得程序在運(yùn)行到這一語句時暫停1s中而繼續(xù)運(yùn)行。
同樣的，在python中也可以正常使用break和continue關(guān)鍵詞。
?
?
dict和set
在c++中提供了map這樣的數(shù)據(jù)結(jié)構(gòu)，這種數(shù)據(jù)結(jié)構(gòu)是含有多個k-v對，具有一一映射的特點(diǎn)，而在python中也提供了同樣的數(shù)據(jù)結(jié)構(gòu)，只是名稱為dict，即dictionary字典，使用起來非常簡單。且list使用的時[]，tuple使用的時()，這里的dict使用的是{}，如下：
如上所示，我們使用{}來定義這個dict，并且可以使用d[key]的方式獲取到它的值，另外dict提供了get方法來查找相應(yīng)的value，當(dāng)然，如果不存在，則什么也不會返回。 且可以通過d[key]的方式來添加映射。 通過pop()函數(shù)來刪除其中的某個k-v對。注意：dict中的key是不能重復(fù)的。
?
那么set是怎么樣定義的呢？set和dict非常類似，但是set中只有key而沒有value，相同點(diǎn)在于key都是不能重復(fù)的，如果重復(fù)，則也會自動過濾， set有add方法添加key， 通過remove方法刪除，?set可以看成數(shù)學(xué)意義上的無序和無重復(fù)元素的集合，因此，兩個set可以做數(shù)學(xué)意義上的交集、并集等操作。 如下所示：
如上所示：我們可以看到，set()函數(shù)中實(shí)際上就是一個list，通過add添加key，通過remove刪除key，通過s1 = s來賦值，且兩個set之間可以進(jìn)行并集和交集的運(yùn)算。
? ? ? ?
另外，我們可以看到，這里s3本來是有重復(fù)數(shù)字的，但在建立后生成時，重復(fù)數(shù)字會自動被刪除，這便是set的一大特點(diǎn)。
python函數(shù)
python中內(nèi)置了很多函數(shù)，比如之前的chr()等，這些函數(shù)是可以直接調(diào)用的，文檔中查看更多內(nèi)置函數(shù)。https://docs.python.org/3/library/functions.html#abs
比如abs即求絕對值的函數(shù)、max函數(shù)返回多個參數(shù)中最大的一個、min函數(shù)等等。 更多示范可以看另外一篇文章。
python切片
即和js中的slice方法是類似的，但是python中是沒有slice的，而是使用了更為簡單的方式，如下：
>>> L = [0,1,2,3,4,5,6,7,8,9,10] >>> L[0:3] [0, 1, 2] >>> L[:3] [0, 1, 2] >>> L[2:4] [2, 3] >>> L[-2:] [9, 10] >>> L = list(range(20)) >>> L [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] >>> L[0::2] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] >>> L[::2] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] >>> "wayne-zhu"[0:5] 'wayne' >>> t = (1, 56, 74, 85, 9) >>> t[0:3] (1, 56, 74)即對于list而言，指定開始和結(jié)束的后一個位置，即可進(jìn)行切片；
? ? ? ?如果是從0開始，則數(shù)字0是可以省略的；
? ? ? ?如果是負(fù)數(shù)，就是從倒數(shù)第幾個開始，最后一個是-1；
? ? ? ?我們還可以指定每隔幾個數(shù)取出一個數(shù)出來；
? ? ? ?字符串也可以看成一種list，也是可以用類似的方法的；
tupple和list一樣，只是tupple不可變，但也是可以使用這樣的方法。?
?
下面是使用python定義的trim函數(shù)，實(shí)現(xiàn)方式如下：
def trim(str):old = stri = 0while True:if str[i] == ' ':str = str[1:]else:breakj = len(str) - 1while True:if str[j] == ' ':str = str[0:j]j = len(str) - 1else:breakprint(old,'trim之后為：',str,'trim之后的字符長度為', len(str))trim(' wayne ')我們首先將str保存起來，然后對字符串的前半部分進(jìn)行處理 - 如果第一個字符是空格就slice； 對于字符串的后半部分做出同樣的處理。 結(jié)果如下：
C:\Users\Administrator\Desktop>python foo.pywayne trim之后為： wayne trim之后的字符長度為 5?
?
python迭代
在js、c、c++等編程語言中，for循環(huán)都是大同小異的，如for(int i = 0; i < 10; i++)，而在python中，for循環(huán)變得更加抽象了，如下所示：
d = {'wayne': 22, 'hedy': 18, 'baby': 0} print('key:') for key in d:print(key)print('\nvalue')for value in d.values():print(value)print('\nkey and value') for k,v in d.items():print(k, v)結(jié)果如下：
key: wayne hedy babyvalue 22 18 0key and value wayne 22 hedy 18 baby 0
另外，字符串也是可迭代對象。?
print('\n 字符串的迭代：') s = 'wayne-zhu' for ch in s:print(ch)這樣，可以依次將字符打印出來。
那么我們?nèi)绾闻袛嘁粋€對象是否為可迭代對象呢？可以通過collections模塊的Iterable類型判斷：
from collections import Iterable print(isinstance('wayne', Iterable)) #True print(isinstance([1, 2, 3], Iterable)) #True print(isinstance(888, Iterable)) #False如上所示，我們通過isinstance就可以判斷了。這里其實(shí)是判斷'wayne'、[1, 2, 3]、888是否是Iterable這個類的實(shí)例。?該函數(shù)返回一個布爾值，True或者False。
?
另外，list是沒有下標(biāo)的，我們怎么實(shí)現(xiàn)呢？可以使用enumerate()函數(shù)，如下所示：
L = [666, 888, 520, 521, 1314] for k,v in enumerate(L):print(k, v)最終結(jié)果如下所示：
0 666 1 888 2 520 3 521 4 1314可以看到，這樣我們就可以獲得下標(biāo)了。?
?
練習(xí)： 使用迭代的方法獲得一個list中的最大值和最小值，并返回這個list的tupple：
L = [666, 888, 520, 521, 1314] max = L[0] min = L[0] for k,v in enumerate(L):if L[k] > max:max = L[k]if L[k] < min:min = L[k]print(max, min) print(tuple(L))結(jié)果如下；
1314 520 (666, 888, 520, 521, 1314)?
?
?
python列表生成式
生成1到10的列表，使用下面的語法：
>>> list(range(1, 11)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
如果要生成[1 * 1, ... 10 * 10]的列表呢？
>>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]上面這種語法是常見的，即直接將迭代式子寫在[]中，前半部分是我們所需要的表達(dá)式 。
?
另外，對于字符串而言，我們通常需要生成某個字符的全排列，可以這樣：
>>> [m + n for m in 'xyz' for n in 'xyz'] ['xx', 'xy', 'xz', 'yx', 'yy', 'yz', 'zx', 'zy', 'zz']上面的式子就生成了xyz的全排列，xx、xy、xz、yx、yy、yz、zx、zy、zz， 當(dāng)然我們還可以生成不同字符串之間的全排列，這是非常有用的。
?
下面的代碼還可以將list中的所有字母編程小寫：
>>> L = ['WAYNE', 'HEDY', 'BABY'] >>> [s.lower() for s in L] ['wayne', 'hedy', 'baby']其中 lower() 函數(shù)是將字符串轉(zhuǎn)化為小寫， 而upper()函數(shù)可以將字符串轉(zhuǎn)化為大寫，如下所示：
>>> wayne = ['wayne', 'hedy', 'baby'] >>> [s.upper() for s in wayne] ['WAYNE', 'HEDY', 'BABY']注意：上面的s.upper()也可以寫成 str.upper(s)， lower同理。
?
另外，如果我們的L為['Wayne', 'Hedy', 18, None]如果直接使用列表生成式會因?yàn)?8不是字符串而出錯：
>>> L = ['Wayne', 'Hedy', 18, None] >>> [str.lower(i) for i in L] Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 1, in <listcomp> TypeError: descriptor 'lower' requires a 'str' object but received a 'int'我們試著使用if語句以及isinstance來修改：
>>> [str.lower(i) for i in L if isinstance(i, str)] ['wayne', 'hedy']即在這個列表生成式中直接加入if語句，然后使用isinstance判斷i是否是str(字符串)類型即可。
?
?
python生成器
??? 創(chuàng)建一個列表就會打印出所有的元素，而如果這個列表的元素很多而我們僅僅需要訪問其中的前幾個元素，那么生成整個列表就會造成浪費(fèi)。 而如果列表元素可以按照某種方法算法推算出來，那么我們是否可以在循環(huán)的過程中不斷地推算出后續(xù)的元素呢？這樣就不必創(chuàng)建完整的list，而節(jié)省了大量的空間。 在python中一邊循環(huán)一邊計(jì)算后續(xù)元素的機(jī)制，就稱為生成器。
比如，我們創(chuàng)建了一個1到100的list，如下：
>>> list(range(1, 100)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]但如果我們只需要1到100的前幾個元素，那么后續(xù)元素占用的內(nèi)存就造成了浪費(fèi)。 而生成器（generator）是下面這樣的：
>>> g = (x for x in range(1, 100)) >>> g <generator object <genexpr> at 0x02C41E70>如果我們希望訪問其元素，可以使用next()進(jìn)行訪問，next函數(shù)接受一個參數(shù)，即這個生成器g，如下所示：
>>> next(g) 1 >>> next(g) 2 >>> next(g) 3 >>> next(g) 4 >>> next(g) 5如上所示，每調(diào)用一次next()函數(shù)，就會返回生成器的下一個元素，生成之后，才會給這個元素分配內(nèi)存，這樣便大大節(jié)省了內(nèi)存空間，即做到按需分配。
又比如下面的生成器：
>>> g = (x for x in range(1, 5)) >>> g <generator object <genexpr> at 0x02C6F0F0> >>> next(g) 1 >>> next(g) 2 >>> next(g) 3 >>> next(g) 4 >>> next(g) Traceback (most recent call last):File "<stdin>", line 1, in <module> StopIteration可以看到，這里我們定義了元素從1到4的生成器，打印g，顯示g為一個generator，然后調(diào)用next()函數(shù)，返回generator的元素，每調(diào)用一次，返回下一個元素，但是當(dāng)最后一個元素4已經(jīng)打印出來后，再調(diào)用next()，就會報(bào)錯：即stopIteration，停止遍歷。
當(dāng)然，更多情況下，我們還可以使用for來遍歷生成器，因?yàn)樯善魇强杀闅v的，如下：
g = (x * x for x in range(1, 5)) for n in g:print(n)打印出的結(jié)果如下所示：
C:\Users\Administrator\Desktop>python foo.py 1 4 9 16
上面，我們都是直接使用()加表達(dá)式生成了一個生成器，但如果推算較為復(fù)雜的情況下，我們還可以使用函數(shù)的方式。 首先，我們可以看到如果斐波那契數(shù)列的函數(shù)生成：
def fib(max):n, a, b = 0, 0, 1while (n < max):print(b)a, b = b, a + bn = n + 1return 'done'fib(5) # 1 1 2 3 5- 這里需要注意：python中定義變量更為簡潔，即這里的n, a, b = 0, 0, 1簡潔的一句代碼便定義了三個變量
- a, b = b, a + b的定義也是非常簡潔，這里沒有使用中間變量保存a，而是使用了tupple的數(shù)據(jù)結(jié)構(gòu)，即t = (b, a + b)、 a = t[0]、 b = t[1]。
?
而如果我們這里將 print(b) 修改為 yield(b)， 就是一個生成器了。 對于生成器來說，每次yield的時候，都會暫停，必須使用next()才能繼續(xù)執(zhí)行下面的程序。所以就成了生成器了。而對于生成器來說，我們使用for..in來調(diào)用會更加方便一些：
def fib(max):n, a, b = 0, 0, 1while (n < max):yield(b)a, b = b, a + bn = n + 1return 'done'g = fib(5) # 1 1 2 3 5for x in g:print(x)如上所示：我們可以看到這時的fib就是一個生成器了，且可以使用for...in遍歷。
?
python迭代器
之前我們提到過："abc"、[]等都是Iterable（可迭代的），但是他們并不是迭代器，如下所示：
>>> from collections import Iterable >>> isinstance([], Iterable) True >>> isinstance({}, Iterable) True >>> isinstance('abc', Iterable) True >>> isinstance((x for x in range(1, 10)), Iterable) True >>> isinstance(628, Iterable) False我們可以看到：[]、{}、'abc'、(x for x in range(1, 10))都是可迭代的，只有628這個數(shù)字肯定不是的。如果換做迭代器呢？
from collections import Iterator # 注意：這里import要換做Iterator print(isinstance({}, Iterator)) #False print(isinstance('abc', Iterator)) #False print(isinstance((x for x in range(1, 10)), Iterator)) #True print(isinstance(628, Iterator)) #False這里，我們可以看到，只有（x for x in range(1, 10)）是迭代器，其他都不是迭代器，這是為什么呢？
>>> g = (x for x in range(1, 10)) >>> next(g) 1 >>> next(g) 2 >>> next(g) 3 >>> next(g) 4我們可以看到，(x for x in range(1, 10))這個表達(dá)式可以調(diào)用next函數(shù)，知道最后元素迭代完成，會報(bào)錯：stopIteration。?
而'abc'呢？如下所示：
>>> g = 'abc' >>> g 'abc' >>> next(g) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: 'str' object is not an iterator如上所示：使用'abc'的next函數(shù)時，會直接報(bào)錯：'str' object is not an iterator。即字符串不是一個迭代器。 對于list、disc也同樣如此，所以這里只有tupple才是Iterator。
>>> g = {'wayne':22, 'hedy': 18} >>> g {'wayne': 22, 'hedy': 18} >>> next(g) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: 'dict' object is not an iterator? ? ? ? ?于是有：?可以被next()函數(shù)調(diào)用并不斷返回下一個值的對象稱為迭代器：Iterator。
但是，我們是可以將非Iterator強(qiáng)制轉(zhuǎn)換為Iterator的。使用iter()函數(shù)即可。但前提是它們必須是Iterable，對于628這樣的not Iterable的類型，使用iter()也是無濟(jì)于事的。 如下所示：
>>> s = 'abc' >>> s 'abc' >>> i = iter(s) >>> i <str_iterator object at 0x039F4670> >>> next(i) 'a' >>> next(i) 'b' >>> next(i) 'c'628不是Iterable，如下：
>>> n = 628 >>> i = iter(n) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: 'int' object is not iterable可以看到，對于int類型的628，如果使用iter，也是會報(bào)錯的 ---?'int' object is not iterable
?
那為什么list不是Iterator呢？ 這是因?yàn)镮terator是惰性的，并沒有一次性獲取到所有的數(shù)據(jù)，是無限制的，而list是一開始就存儲了數(shù)據(jù)。
?
?
高階函數(shù)
即函數(shù)中接受函數(shù)作為參數(shù)的函數(shù)就是高階函數(shù)。 如map、filter等。又如sorted函數(shù)，如下：
>>> sorted([35, -56, 85, 69]) [-56, 35, 69, 85] # 如上，這里沒有接受函數(shù)作為參數(shù)，只是按照從小到大的排序>>> sorted([35, -56, 85, 69], key=abs) [35, -56, 69, 85] # 這里我們接受了abs函數(shù)作為第二個參數(shù)，即按照其絕對值大小進(jìn)行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob'] #這里我們直接對字符串進(jìn)行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ['about', 'bob', 'Credit', 'Zoo'] #這里我們將所有的字符串按照轉(zhuǎn)化為小寫字母之后進(jìn)行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']
#如果我們希望反向，只需要再添加一個參數(shù) -- reverse = True
?
在python中，也是存在匿名函數(shù)的概念的，如下：
>>> f = lambda x: x * x >>> f(5) 25如上所示： 等式右邊的就是一個匿名函數(shù)，而 lambda 關(guān)鍵詞就表示在聲明一個匿名函數(shù)，冒號之前的x表示接受的參數(shù)，之后表示返回的值。
?
?python裝飾器
如下所示：定義一個now函數(shù)，因?yàn)楹瘮?shù)是一個對象，所以可以賦值給f（另外一個變量），然后我們再調(diào)用這個函數(shù)即可。
>>> def now(): ... print('20180324') ... >>> f = now >>> f() 20180324
在python中，我們可以調(diào)用now或者f的__name__屬性，以獲取到該函數(shù)的函數(shù)名：如下：
那什么是裝飾器呢？比如，我們希望函數(shù)調(diào)用前后自動打印日志， 但是又不希望修改now()函數(shù)的定義，這種在代碼運(yùn)行期間動態(tài)增加功能的方式，稱之為裝飾器。并需要用到@的Python語法。
下面我就定義一個裝飾器函數(shù)用于打印日志：
def log(func):def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper這個裝飾器函數(shù)就是一個高階函數(shù)（接受一個函數(shù)作為參數(shù)），然后定義了一個wrapper函數(shù)返回fun()執(zhí)行后的結(jié)果。然后我們將Log置于函數(shù)的定義處：
def log(func):def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper@log def now():print('20180324')now()我們執(zhí)行之后，得到如下結(jié)果：
call now(): 20180324至于上面的格式，即將@log放在了now函數(shù)的定義之前，相當(dāng)于在定義之后執(zhí)行了函數(shù) now = log(now)，即把這個now函數(shù)從新進(jìn)行了包裝、修飾，即為裝飾器函數(shù)。因此，我們寫成下面的方式也是可以的：
def log(func):def wrapper():print('call %s():' % func.__name__)return func()return wrapper@log def now():print('20180324')now()之前添加了的一些參數(shù)是為了更多的使用擴(kuò)展性。即now()函數(shù)執(zhí)行之后，即調(diào)用了這個裝飾器函數(shù)@log，返回了wrapper函數(shù)，最后我們調(diào)用now()，就執(zhí)行了這個wrapper函數(shù)，并返回結(jié)果。
這里，我們可以將@log解釋為如下的執(zhí)行方式:
def log(func):def wrapper():print('call %s' % func.__name__)return func()return wrapperdef now():print('20180324')now = log(now) # 這樣，會fanhuiwrapper函數(shù)，然后調(diào)用now，就是執(zhí)行了wrapper函數(shù)，首先打印了內(nèi)容，再執(zhí)行真正的now函數(shù)。now()
上面是最簡單的方式，而如果這個裝飾器自身需要接受參數(shù)，那么如果使用上面的這種方式就無法滿足了，我們必須再包裹一層函數(shù)，如下所示：
def log(text):def decorator(func):def wrapper():print('call %s %s' % (text, func.__name__))return func()return wrapperreturn decorator @log('extro') def now():print('20180324')now()思路非常明確，即包含了一層decorator函數(shù)，我們將text傳給裝飾器，實(shí)際上，@log('extro')的另外一種真是的寫法如下：
def log(text):def decorator(func):def wrapper():print('call %s %s' % (text, func.__name__))return func()return wrapperreturn decorator def now():print('20180324')now = log('extor')(now)now()最終的結(jié)果如下：
call extor now 20180324
但這里還是有問題的，當(dāng)我們在程序的最后加上 print(now.__name__)的時候，我們可以發(fā)現(xiàn)最終輸出的時 wrapper 而不是 now，這不是我們希望看到的，而我們修改之后最終的結(jié)果如下：
import functoolsdef log(text):def decorator(func):@functools.wraps(func)def wrapper():print('call %s %s' % (text, func.__name__))return func()return wrapperreturn decorator def now():print('20180324')now = log('extor')(now)now()print(now.__name__)?
?
?
python偏函數(shù)
偏函數(shù)還是很好理解的，我們從一個簡單的例子說起。
比如我們可以使用int('1000')將字符串'1000'轉(zhuǎn)化為數(shù)字，這個轉(zhuǎn)化過程默認(rèn)是十進(jìn)制的。 而如果我們希望轉(zhuǎn)化為2進(jìn)制的，我們可以這樣調(diào)用：int('1000', base=2)或者是int('1000', 2)。?但是如果我們需要大量的轉(zhuǎn)化為二進(jìn)制數(shù)字的調(diào)用，每次都int('1000', 2)難免比較麻煩，所以我們可以封裝為一個函數(shù)再調(diào)用，如下：
def int2(str):return int(str, base=2)print(int2('100')) #4 print(int2('10')) #2 print(int2('1')) #1如上所示，這樣，我們就可以很輕松的進(jìn)行轉(zhuǎn)化了。但python中的functools模塊本身有這個作用，如下：
import functools int2 = functools.partial(int, base=2)print(int2('100')) #4 print(int2('10')) #2 print(int2('1')) #1即這里我們使用了functools.partial函數(shù)，這就是偏函數(shù)，即把一個函數(shù)的某些參數(shù)給固定住（也就是設(shè)置為默認(rèn)值），返回一個新的函數(shù)，調(diào)用這個函數(shù)會更加簡答。而我們也可以繼續(xù)個性化，如下：
import functools int2 = functools.partial(int, base=2)print(int2('100',base=10)) #100 print(int2('10')) #2 print(int2('1')) #1如上，可以看出來，這個和我們上面自己定義的int2是相同的，總之，偏函數(shù)可以固定住某些參數(shù)，使我們的操作更加簡單。
?
?
?
?
python模塊
和JavaScript是類似的，大多數(shù)編程語言都是要進(jìn)行模塊化開發(fā)的，因?yàn)楫?dāng)工程越來越復(fù)雜的時候，不可能始終使用一個文件，而是根據(jù)程序塊的不同作用分配到模塊中，這樣，有利于開發(fā)的高效性，另外，同一個模塊還可以在多處使用，這樣有利于提高程序的重用性，python也不例外。?
python中，一個.py文件就可以看做一個python模塊，模塊很好地解決了變量命名沖突的問題，并且通過模塊，但當(dāng)模塊多時，也不可避免出現(xiàn)重名，在python中也就有了包的概念，如一個mymodule包，下面有util.py模塊、anto.py模塊，并且一定還有一個__init__.py模塊，如果沒有，Python將不認(rèn)為mymodule是一個包，通過這個包，我們的模塊名稱更具辨識性，如util.py模塊又稱為mymodule.util模塊等等。
使用模塊我們很清楚，直接import 即可，但是如果自定義一個自己的模塊呢？如下所示（該文件名為hello.py）：
'my first module'__author__ = 'Wayne Zhu'import sysdef test():args = sys.argvif len(args) == 1:print('hello world!')elif len(args) == 2:print('hello %s' % args[1])else:print('Too many arguments!')if __name__ == '__main__':test()Ok！ 這就是一個標(biāo)準(zhǔn)的模塊了，其中'my first module'是這個py文件的第一個字符串，默認(rèn)為該文件的說明性注釋； 而__author__ = 'Wayne Zhu'中的__author__是專有變量，是聲明這個文件的作者，接下來我們引入了sys模塊，通過這個模塊我們可以獲得用戶在命令行輸入的參數(shù)；最后我們判斷__name__是否為__main__，如果是執(zhí)行當(dāng)前文件，則是，作為入口文件，當(dāng)然是main，如果是被其他Python文件調(diào)用，則不是。
其中，sys的argv參數(shù)是命令行的參數(shù)，如python hello，則argv是一個list，且數(shù)量至少為1，這里就是['hello']，而如果用戶執(zhí)行時是 python hello wayne-zhu，則sys.argv的元素個數(shù)為2，即['hello', 'wayne-zhu']。
該模塊如果被直接調(diào)用，最終的結(jié)果如下：
C:\Users\Administrator\Desktop>python hello.py hello world!C:\Users\Administrator\Desktop>python hello.py wayne-zhu hello wayne-zhuC:\Users\Administrator\Desktop>python hello.py wayne hedy Too many arguments!而如果我們是在python交互環(huán)境中引入hello模塊，則不會有輸出，如下：
>>> import hello >>> hello.test() hello world!但是我們可以直接通過hello調(diào)用test函數(shù)。?
?
?
python變量
這里主要說的還是變量的可訪問性。
- 公開變量，abc/foo等，這些變量是公開的，允許被模塊內(nèi)外訪問的。
- 模塊內(nèi)變量/私有變量，_abc、_foo等，即簡單的通過_來確定，但實(shí)際上語法并沒有限制，只是方便程序員觀察使用。
- 特殊變量，__name__、__author__等，這些變量和公開變量并沒有什么區(qū)別，只是他們有特殊的用途，如__author__表示當(dāng)前模塊的作者名; __name__和'__main__'判斷是否相等來判斷是直接執(zhí)行還是間接調(diào)用。
比如上面的例子中，_private_1和_private2是模塊內(nèi)使用的，而greeting是暴露出去的，可以被其他的模塊使用。
hello.py如下：
'my first module'__author__ = 'Wayne Zhu'import sysdef test():args = sys.argvif len(args) == 1:print('hello world!')elif len(args) == 2:print('hello %s' % args[1])else:print('Too many arguments!')def speak(str='great!'):print(str)if __name__ == '__main__':test() View Codefoo.py如下：
import hello hello.test() hello.speak('I am handsome')當(dāng)我們執(zhí)行foo.py時，最終的結(jié)果如下：
hello world! I am handsome可見，我們成功的在foo.py中引用了hello模塊，并使用了hello模塊暴露的speak函數(shù)和test函數(shù)，但是根據(jù)hello模塊test編寫形式而言，test主要是為了作模塊內(nèi)測試的，并非暴露給其他模塊使用。但語法上并沒有任何問題。
?
安裝第三方模塊
? 我們在命令行中輸入pip，如果正常，則說明可以通過pip安裝第三方模塊，這個和前端中的npm是類似的，并且，一般的開發(fā)者如果要提供自己的模塊，需要到pypi.python.org中注冊，和前端需要到npm.org中注冊時一樣的，比如我們要安裝該庫的名稱是 Pillow，那么安裝Pillow的命令就是：
pip install Pillow如下所示：
C:\Users\Administrator\Desktop>pip install Pillow Collecting PillowDownloading Pillow-5.0.0-cp36-cp36m-win32.whl (1.4MB)100% |████████████████████████████████| 1.4MB 655kB/s Installing collected packages: Pillow Successfully installed Pillow-5.0.0 You are using pip version 9.0.1, however version 9.0.3 is available. You should consider upgrading via the 'python -m pip install --upgrade pip' command.但是，這里下載的位置在C:\Users\Administrator\AppData\Local\Programs\Python\Python36-32\Lib\site-packages，所以，如果我們希望自己新建一個py文件可以import Pillow，就必須要將Pillow這個文件夾放在和當(dāng)前py文件的同級目錄下，否則就引入不了。
同樣的，Flask這個web框架就是python框架，安裝如下：
pip install flask然后，我們再新建下面這個文件：
from flask import Flaskapp = Flask(__name__)@app.route('/') def hello_world():return 'Hello Flask!'if __name__ == '__main__':app.run()然后在命令行中執(zhí)行這個文件：
C:\Users\Administrator\Desktop>python foo.py* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)于是我們就可以看到瀏覽器如下：
即通過這個Flask庫，我們就自己快速搭建了一個服務(wù)器。但是我們可以發(fā)現(xiàn)一個問題，就是每次在我們修改文件內(nèi)容時，比如返回 Hello Wayne!，然后我們?nèi)ニ⑿聻g覽器，但顯示內(nèi)容并沒有刷新，這是因?yàn)槲覀?strong>沒有開啟DEBUG模式，如果要開啟，我們需要在環(huán)境變量中添加 FLASK_DEBUG, 值為1，如下：
這樣，我們在運(yùn)行該文件時，內(nèi)容時這樣的：
C:\Users\Administrator\Desktop>python foo.py* Restarting with stat* Debugger is active!* Debugger PIN: 109-984-470* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) 即調(diào)試模式開啟，我們就可以進(jìn)行調(diào)試了。且每次我們修改文件并保存后，服務(wù)器就會重啟，然后我們刷新瀏覽器，內(nèi)容就會發(fā)生改變了！這方面的使用還是比node更加方便一些。
另外還有很多有用的模塊，如果我們都這樣下載，未免太慢，所以推薦使用Anaconda，這個平臺一旦下載就意味著下載了數(shù)十個庫文件，這樣是非常有用的，我們可以在這里下載。
安裝完成之后，輸入python，我們就可以看到Anaconda的相關(guān)信息了。然后，對于一些常見的模塊我們就不需要再自己下載，而是直接使用即可。但有些情況下，安裝之后輸入python還是沒用，這時我們可以將anaconda的安裝路徑加入到path中即可，如：
?
?
注意：現(xiàn)在，不下載也是可以的，最多全部下載一遍，不適用Anaconada也是一樣的，不必過分糾結(jié)。
?
另外，之前我們說過：每次install一個模塊之后，可以通過everything這個工具找到該文件，然后將當(dāng)前python文件和庫文件放在同級目錄下才可以使用，但這樣比較麻煩，我們可以將存放install的庫的路徑加入到sys模塊的path變量中，這樣我們就不用每次都把下載到的文件再手動放在一起了。
import sys >>> sys.path ['', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages'] >>> sys.path.append('C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\Lib\\site-packages')我們可以看到： 這里的sys.path是一個list，所以可以使用append方法來添加元素。
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
參考文章：廖雪峰博客、python文檔
總結(jié)
- 上一篇： The SDK platform-too
- 下一篇： 知物由学 | 干货！一文了解安卓APP逆