https://www.cnblogs.com/harrylyx/p/12388692.html

一,、Python基礎(chǔ)

Python是對象有類型,，變量無類型的動(dòng)態(tài)類型語言，追求簡單優(yōu)雅易讀,?？梢栽诮K端中逐行運(yùn)行,，也可以編寫成大型的面向?qū)ο蟮墓こ?。在開始寫之前，注意Python 2.X中,，開頭要寫上#coding:utf-8,，并且Python通過縮進(jìn)知道一個(gè)特定的代碼塊于周圍的代碼保持獨(dú)立。所用的空格數(shù)很重要,，因此應(yīng)該使用編輯器確定縮進(jìn),，并且不要手動(dòng)改變空格數(shù)。根據(jù)PEP的規(guī)定,，必須使用4個(gè)空格來表示每級縮排,。使用Tab字符和其它數(shù)目的空格雖然都可以編譯通過，但不符合編碼規(guī)范,。

1.數(shù)字和字符

1. Python本身支持整數(shù)與浮點(diǎn)數(shù),，計(jì)算如下表

強(qiáng)制類型轉(zhuǎn)換使用int(num)與float(num)進(jìn)行。

2. 字符串

使用引號(hào)包裹,，例如：

>>> 'python'
'python'
>>> "python"
'python'

可見可以使用兩種引號(hào)進(jìn)行創(chuàng)建,，這樣的好處是可以創(chuàng)建本身就包含引號(hào)的字符串，而不用使用轉(zhuǎn)義符,?？梢栽陔p引號(hào)包裹的字符串使用單引號(hào)，或者在單引號(hào)包裹的字符串中使用雙引號(hào)：

>>> "'She' is a boy."
"'She' is a boy."
>>> 'A "boy" likes her.'
'A "boy" likes her.'

還可以使用三個(gè)單引號(hào)創(chuàng)建字符串：

>>> '''
... 我們?nèi)タ礋熁鸷脝?... 去,，去看那
... 繁花之中如何再生繁花
... 夢境之上如何再現(xiàn)夢境
... '''
'\n我們?nèi)タ礋熁鸷脝醆n去,，去看那\n繁花之中如何再生繁花\n夢境之上如何再現(xiàn)夢境\n'

• 在字符串中使用str(value)進(jìn)行強(qiáng)制類型轉(zhuǎn)換,。

• 使用\進(jìn)行轉(zhuǎn)義

>>> print('a\tbc')
a       bc

• 使用+進(jìn)行拼接

>>> a = 'apple'
>>> b = 'pen'
>>> a + ' ' + b
'apple pen'

• 使用*復(fù)制

>>> s = 'apple'
>>> s * 3
'appleappleapple'

• 使用[]提取字符

>>> letters = 'abcdefg'
>>> letters[0]
'a'
>>> letters[4]
'e'

• 使用[start:end:step]分片

# [:] 提取全部
# [start:] 從start到結(jié)尾
# [:end] 從開頭到end - 1
# [start:end] 從strat到end - 1
# [start:end:step] 從start到end - 1,，每step個(gè)字符提取一個(gè)
>>> letters = 'abcdefghijklmn'
>>> letters[:]
'abcdefghijklmn'
>>> letters[3:]
'defghijklmn'
>>> letters[:3]
'abc'
>>> letters[3:7]
'defg'
>>> letters[0:4:2]
'ac'
>>> letters[-1::]
'n'
>>> letters[::-1]
'nmlkjihgfedcba'

• 使用len(value)獲得長度

>>> letters = 'abcdefghijklmn'
>>> len(letters)
14

• 使用split(value)進(jìn)行分割,，value填寫分割字符，返回一個(gè)列表

>>> letters = 'a,b,c,d,e,f'
>>> letters.split(',')
['a', 'b', 'c', 'd', 'e', 'f']

• 同樣可以使用join()將列表進(jìn)行合并成字符串

>>> letters_list = letters.split(',')
>>> ','.join(letters_list)
'a,b,c,d,e,f'

• 最后,，可以使用`replace(sub, newsub, n), sub是需要被替換的子串,，newsub是用于替換的新子串,n是需要替換多少處

>>> setup = 'a boy likes playing basketball.'
>>> setup.replace('boy','girl')
'a girl likes playing basketball.'
>>> setup.replace('a', 'b')
'b boy likes plbying bbsketbbll.'
>>> setup.replace('a', 'b', 1)
'b boy likes playing basketball.'

2.語句

1.import語句，導(dǎo)入模塊使用,，兩種形式：

形式1：import module-name,。import后面跟空格，然后是模塊名稱,，例如：import os

形式2：from module1 import module11,。module1是一個(gè)大模塊，里面還有子模塊module11,，只想用module11,，就這么寫了。

2.條件語句：

if...elif...else語句

if 條件1:
執(zhí)行的內(nèi)容1
elif 條件2:
執(zhí)行的內(nèi)容2
elif 條件3：
執(zhí)行的內(nèi)容3
else:
執(zhí)行的內(nèi)容4

3.循環(huán)語句：

for語句

for 循環(huán)規(guī)則：
操作語句

for循環(huán)所應(yīng)用的對象,，應(yīng)該是可迭代的,。

判斷一個(gè)對象是否可迭代使用collections模塊的Iterable類型判斷：

>>> from collections import Iterable
>>> isinstance('abc',Iterable)
True
>>> isinstance([1,2,3,4],Iterable)
True
>>> isinstance(1234,Iterable)
False

while語句

和C語言中大同小異，只不過可以使用while...else...,同理,，在for語句中也可以使用for... else...

#test.py
a = 3
b = 2
while a > b:
print('a>b')
a -= 1
else:
print('a<b')

$ python test.py
a>b
a<b

循環(huán)（loop）,，指的是在滿足條件的情況下，重復(fù)執(zhí)行同一段代碼,。比如,，while語句。

迭代（iterate）,，指的是按照某種順序逐個(gè)訪問列表中的每一項(xiàng),。比如，for語句,。

遞歸（recursion）,，指的是一個(gè)函數(shù)不斷調(diào)用自身的行為。比如,，以編程方式輸出著名的斐波納契數(shù)列,。

遍歷（traversal），指的是按照一定的規(guī)則訪問樹形結(jié)構(gòu)中的每個(gè)節(jié)點(diǎn),，而且每個(gè)節(jié)點(diǎn)都只訪問一次,。

3.函數(shù)

1.定義函數(shù)

使用def:函數(shù)的開頭，define的縮寫,，后面跟函數(shù)名稱和參數(shù),，最后一點(diǎn)要加“：”冒號(hào),。例如 def add(x,y):

2.函式體的第一個(gè)語句可以是字串（即為注釋）; 這個(gè)字串就是函式的文檔字符串, 或稱為 docstring。例如：

def split_data_set(dataSet, axis, value):
"""
輸入：數(shù)據(jù)集,，選擇維度,，選擇值
輸出：劃分?jǐn)?shù)據(jù)集
描述：按照給定特征劃分?jǐn)?shù)據(jù)集；去除選擇維度中等于選擇值的項(xiàng)
"""

3.命名規(guī)范,，這里參考PEP8

b（單個(gè)小寫字母）

B（單個(gè)大寫字母）

小寫（小寫）

lower_case_with_underscores（含底線的小寫）

大寫（UPPERCASE）

UPPER_CASE_WITH_UNDERSCORES（含底線的大寫）

大寫字母（字首大寫,，又稱CapWords或CamelCase - 如此稱呼是因?yàn)樽帜缚雌饋砥閸绮黄絒4]），有時(shí)也稱為StudlyCaps,。

注意：如果有縮寫字,，將縮寫字的每個(gè)字母大寫。也就是寫HTTPServerError比HttpServerError好,。

mixedCase（類似字首大寫,，只差開頭單字的第一個(gè)字母是小寫）

Capitalized_Words_With_Underscores（字首大寫加底線）

來自命名慣例

4.參數(shù)與變量

形參與實(shí)參：

函數(shù)名后面的括號(hào)里如果有變量，它們通常被稱為“形參”,。調(diào)用函數(shù)的時(shí)候,，給函數(shù)提供的值叫做“實(shí)參”，或者“參數(shù)”,。個(gè)人理解,，實(shí)參是在函數(shù)調(diào)用前就實(shí)際存在的參數(shù)，而形參是在調(diào)用函數(shù)的時(shí)候,，用于將實(shí)參的值傳入函數(shù)用的,。

參數(shù)與變量的區(qū)別，每個(gè)形參的名稱均可作為過程內(nèi)的局部變量,。形參名稱的使用方法與其他任何變量的使用方法相同,。
實(shí)參表示在您調(diào)用過程時(shí)傳遞給過程形參的值。

局部變量與全局變量：

在函數(shù)里面的就是局部變量,，在函數(shù)外面的就是局部變量,。在C和JAVA中主要是有一個(gè)主函數(shù)或主方法開始運(yùn)行的地方，而Python并沒有,，Python是逐行運(yùn)行的,。但可以使用if __name__ == '__main__'來規(guī)定當(dāng)前程序的程序入口是什么，防止模塊之間相互引用導(dǎo)致入口混亂,。

4.初級內(nèi)建函數(shù)

1.print(value, seq=' ', end='\n') 在Python 3.X中,，為一個(gè)函數(shù)，其中參數(shù)seq=' '為分隔符,，參數(shù)end='\n'為結(jié)尾換行符號(hào),，可以自己修改。

Tips:

print實(shí)質(zhì)是將輸出重定向到sys.stdout.write標(biāo)準(zhǔn)輸出，可以修改參數(shù)file,，指定輸出到文件,。

print()是同步阻塞的，所以頻繁的print會(huì)大大降低程序運(yùn)行速度,，比如在訓(xùn)練模型時(shí)注意減少print的次數(shù),。

2.id(obj)查看對象內(nèi)存地址。

3.type(obj)查看對象的類型,。

4.round(value, n)四舍五入到小數(shù)點(diǎn)后n位,。

5.a = input(msg)打印出msg,，并從鍵盤輸入一個(gè)變量賦值給a,，a為str類型。

6.dir(module)查看module模塊的工具（方法）,。

7.help(math.pow)查看math工具下pow工具的幫助,，按q返回交互模式。

使用例子：

# -*- coding:utf-8 -*-

import sys
import math
import time

integer_1 = 1
float_2 = 2.35
string = 'abc'

print(id(integer_1))	#查看內(nèi)存地址
print(type(integer_1), type(float_2), type(string), sep='|') #查看類型,，并用|分割
print(round(float_2))	#四舍五入
print(dir(math))	#查看math下的方法

input_test = input("請輸入")
print(input_test, type(input_test))	#輸入測試,，并打印類型

help(math.pow)

輸出：

94520588557952
<class 'int'>|<class 'float'>|<class 'str'>
2
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
請輸入3
3 <class 'str'>

Help on built-in function pow in module math:

pow(...)
pow(x, y)

Return x**y (x to the power of y).
(END)

二、Python容器：列表,、元組,、字典與集合

1.列表

1.使用[]或list()來創(chuàng)建列表

>>> [1,2,3,4,5] #使用[]創(chuàng)建
[1, 2, 3, 4, 5]
>>> list(12345) #不可迭代報(bào)錯(cuò)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> list('1,2,3,4,5') #按照字符分割
['1', ',', '2', ',', '3', ',', '4', ',', '5']
>>> list('12345')
['1', '2', '3', '4', '5']

如果使用list()是不允許將不可迭代的轉(zhuǎn)換成列表，如果是可迭代的,，例如字符串,，則會(huì)按照字符分割成列表。

2.使用[offset]選取元素,，并修改,。

>>> l = [1,2,3,4,5]
>>> l[0] #選取
1
>>> l[0] = 2 #修改
>>> l
[2, 2, 3, 4, 5]
>>> matrix = [[1,2,3], #創(chuàng)建三階行列式
...           [4,5,6],
...           [7,8,9]]
>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> matrix[0][0] #和矩陣寫法一樣，行優(yōu)先,，只不過從0開始
1

list類似于數(shù)組,，但數(shù)組只有一個(gè)類型，而list里面可以包含多個(gè)類型,。列表的一個(gè)重要特征：列表是可以修改的,。這種修改，不是復(fù)制一個(gè)新的,，而是在原地進(jìn)行修改,。

3.使用append()與extend()擴(kuò)充列表

列表擴(kuò)容的函數(shù)append()和extend()都是原地修改列表,所以沒有返回值，所以不能賦給某個(gè)變量,。

>>> lst1 = [1,2,3]
>>> lst1.append(["lyx","xyl"])
>>> lst1
[1, 2, 3, ['lyx', 'xyl']]  #append的結(jié)果
>>> len(lst1)
4

>>> lst2 = [1,2,3]
>>> lst2.extend(["lyx","xyl"])
>>> lst2
[1, 2, 3, 'lyx', 'xyl']   #extend的結(jié)果
>>> len(lst2)
5

總結(jié)以下就是append是整建制地追加,，extend是個(gè)體化擴(kuò)編。

4.使用insert()插入，使用del,remove()與pop()刪除

>>> lst = [1,2,3,4]
>>> lst.insert(0,0)
>>> lst
[0, 1, 2, 3, 4]
>>> lst.insert(3,3.5)
>>> lst
[0, 1, 2, 3.5, 3, 4]
>>> lst.insert(10,5)
>>> lst
[0, 1, 2, 3.5, 3, 4, 5]

使用insert(offset,value),當(dāng)offset為0時(shí)則插入到頭部,，當(dāng)offset超過了尾部,，則會(huì)插入到最后，并不會(huì)引起異常,。

>>> lst = [1,2,3,4,5]
>>> del lst[0]
>>> lst
[2, 3, 4, 5]
>>> lst.remove(3)
>>> lst
[2, 4, 5]
>>> lst.pop()
5
>>> lst
[2, 4]

使用del則是刪除指定位置的元素,，使用remove()則是刪除指定值的數(shù)，使用pop()則是彈棧操作,，返回最后一位元素,，即棧頂元素。

5.使用in判斷元素是否存在,，count()記錄特定值出現(xiàn)次數(shù),，index()查詢具有特定值的元素位置

>>> word = [1,2,3,4,5,1,1,2]
>>> 1 in word
True
>>> 6 in word
False
>>> word.count(1)
3
>>> word.index(1)
0
>>> word.index(1,1)
5
>>> word.index(1,6)
6

index(str, beg=0, end=len(string)),其中beg規(guī)定開始索引，end默認(rèn)為列表長度,，返回開始索引位置后第一次出現(xiàn)的str的位置,。

6.使用sort()與sorted()排列數(shù)組

默認(rèn)都是升序排列，加上參數(shù)reverse=True則降序排列,。

• sort()會(huì)對原列表進(jìn)行排序,，改變原列表內(nèi)容。
• sorted()則會(huì)返回排序好的列表副本,，原列表內(nèi)容不變,。

>>> lst = [4,3,2,5,2,1,5,7,0]
>>> lst_copy = sorted(lst)
>>> lst_copy
[0, 1, 2, 2, 3, 4, 5, 5, 7]
>>> lst
[4, 3, 2, 5, 2, 1, 5, 7, 0]
>>> lst.sort()
>>> lst
[0, 1, 2, 2, 3, 4, 5, 5, 7]
>>> lst.sort(reverse=True)
>>> lst
[7, 5, 5, 4, 3, 2, 2, 1, 0]

7.使用=賦值，copy()復(fù)制

>>> a = [1,2,3]
>>> b = a
>>> b
[1, 2, 3]
>>> a[0] = 0
>>> b
[0, 2, 3]
>>> c = a.copy() #使用copy()復(fù)制
>>> d = list(a) #使用list()函數(shù)復(fù)制
>>> f = a[:] #使用列表分片
>>> a[0] = 1
>>> c
[0, 2, 3]
>>> d
[0, 2, 3]
>>> f
[0, 2, 3]

即使用=賦值后,，b與a是同一個(gè)對象,，修改任意一個(gè)都會(huì)修改對方，使用copy(),list()與[:]都可以做到創(chuàng)建一個(gè)新對象的作用,。

8.使用range()生成列表

在Python3中,，range()的返回值已經(jīng)變?yōu)?code>range類型，不再是原來的list類型,，但依舊可以使用list函數(shù)轉(zhuǎn)換過去,。range(start, end, step)，即生成一個(gè)從start開始,，end - 1結(jié)束的列表,，step為步長，多用于循環(huán)之中,。

>>> range(0,5)
range(0, 5)
>>> type(range(0,5))
<class 'range'>
>>> for i in range(0,5):
...     print(i)
...
0
1
2
3
4

2.元組

1.使用()與tuple()創(chuàng)建元組

>>> tup = [1,2,3]
>>> tup =  tuple(tup)
>>> tup
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
>>> tup[0]
1
>>> tup[0] = 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元組與列表使用方法基本都是相同的,，但最大的區(qū)別就是一旦創(chuàng)建元組就不能修改，所以所有修改列表的操作元組這里都不能用,，dir(tuple)可知,，對元組進(jìn)行操作的只有['count','index'],。所以使用場景就是元組的占用空間小，你不會(huì)意外修改元組的值和它可以作為字典的鍵,。

3.字典

字典與列表類似,，可以原地修改，即它是可變的,，但它的順序無關(guān)緊要,，因?yàn)槠浔举|(zhì)就是鍵值對。在字典中的“鍵”,，必須是不可變的數(shù)據(jù)類型,；“值”可以是任意數(shù)據(jù)類型。

1.使用{}與dict()來創(chuàng)建字典

>>> mydict = {"1":"a","2":"b"} #初始化字典
>>> mydict
{'1': 'a', '2': 'b'}
>>> lst = [[1,2],[3,4],[5,6]] #將二維列表轉(zhuǎn)換成字典
>>> mydict = dict(lst)
>>> mydict
{1: 2, 3: 4, 5: 6}
>>> string = ('12','34','56') #將雙字符的字符串元組轉(zhuǎn)換成字典
>>> mydict = dict(string)
>>> mydict
{'1': '2', '3': '4', '5': '6'}

2.使用[key]添加或修改元素,，使用in判斷鍵是否存在于字典

>>> mydict = {1: 2, 3: 4, 5: 6}
>>> mydict[7] = 8
>>> mydict
{1: 2, 3: 4, 5: 6, 7: 8}
>>> if 2 in mydict:
...     mydict[2] = 0
... else:
...     mydict[3] = 0
...
>>> mydict
{1: 2, 3: 0, 5: 6, 7: 8}

3.使用update()合并字典

>>> a = {1:2,3:4}
>>> a
{1: 2, 3: 4}
>>> b = {5:6,7:8}
>>> b
{5: 6, 7: 8}
>>> a.update(b)
>>> a
{1: 2, 3: 4, 5: 6, 7: 8}
>>> c = {1:'a'}	#如果使用同樣的鍵,，則新歸入字典的值會(huì)取代原有的值
>>> a.update(c)
>>> a
{1: 'a', 3: 4, 5: 6, 7: 8}

4.使用del刪除指定鍵元素與clear()清空字典

>>> a
{1: 'a', 3: 4, 5: 6, 7: 8}
>>> del a[1]
>>> a
{3: 4, 5: 6, 7: 8}
>>> a.clear()
>>> a
{}

5.使用[key]與get()獲取元素

>>> a = {1:2,3:4}
>>> a[1]
2
>>> a[2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 2
>>> a.get(1)
2
>>> a.get(2)

使用[key]獲取，如果鍵不存在則會(huì)拋出異常,，所以改用get()方法,，不存在的話會(huì)返回None。

6.使用keys(),，values()與items()

>>> a = {1: 2, 3: 4, 5: 6, 7: 8}
>>> a.keys() #使用keys()返回所有key值
dict_keys([1, 3, 5, 7])
>>> type(a.keys())
<class 'dict_keys'>
>>> list(a.keys())
[1, 3, 5, 7]
>>> a.values() #使用values()返回所有value值
dict_values([2, 4, 6, 8])
>>> a.items() #使用items()返回所有鍵值對
dict_items([(1, 2), (3, 4), (5, 6), (7, 8)])

我們可以看到，在Python3中,，返回的類型已經(jīng)變成'dict_keys'等等這種方法,，這樣做的目的是list占用空間較大，且效率不高,，所以如果需要用到list,，再使用list函數(shù)即可。

4.集合

集合的概念與數(shù)學(xué)中的集合概念是相同的,，即集合中的元素是互異的,。

1.使用{}與set()創(chuàng)建集合

>>> s = {1,2,3,4,1}
>>> s
{1, 2, 3, 4}
>>> a = [1,1,1,2,3,4,3,3,4,5]
>>> s = set(a)
>>> s
{1, 2, 3, 4, 5}

可見，在Python中去重是非常簡單的事情,，直接轉(zhuǎn)換成集合就行了,。

同樣也可以使用in來判斷一個(gè)元素是否存在于集合之中，這里就不在舉例,。

2.集合中運(yùn)算

>>> a = {1,2,3}
>>> b = {2,3}
>>> a > b #使用>=與<=判斷是否是子集,，使用>與<判斷是否是真子集
True
>>> a > a
False
>>> a & b #使用&做交集
{2, 3}
>>> a | b #使用|做并集
{1, 2, 3}
>>> a - b #使用-做差集
{1}
>>> b - a
set()
>>> b ^ a #使用^做異或集
{1}

5.進(jìn)一步的內(nèi)建函數(shù)

1.zip(*iterables),使用它可以做到并行迭代，舉例說明：

>>> a = (1,2,3)
>>> b = (4,5,6)
>>> for i,j in zip(a,b):
...     print(i,j)
...
1 4
2 5
3 6

所以可以使用其進(jìn)行生成字典操作：

>>> a = (1,2,3)
>>> b = (4,5,6)
>>> dict(zip(a,b))
{1: 4, 2: 5, 3: 6}

2.map(function, iterable, ...),類似于MapReduce中的Map階段,，即將后面的iterable作用于前面的function,，舉例說明：

>>> def add(x):
...     return x + 10
...
>>> lst = [1,2,3,4]
>>> map(add, lst)
<map object at 0x000002C359ACC9B0>
>>> list(map(add, lst))
[11, 12, 13, 14]

同樣我們可以看到，在Python3中返回的是一個(gè)map對象,，依舊是節(jié)省時(shí)間的作用,，也就是lazy evaluation。

3.enumerate(iterable, start=0),其實(shí)就是枚舉，具體看下面的例子:

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

6.可變長度的函數(shù)參數(shù)

在Python中,，有兩種變長參數(shù),，分別是元組（非關(guān)鍵字參數(shù)）和字典（關(guān)鍵字參數(shù)）。其調(diào)用方式是：func( *args, **kwargs )
因?yàn)橛袝r(shí)候不知道傳進(jìn)去多少個(gè)參數(shù),，所以要用可變長的參數(shù),，在參數(shù)前加一個(gè)星號(hào)*代表傳入的參數(shù)會(huì)被儲(chǔ)存為元組，加兩個(gè)星號(hào)**代表傳入的會(huì)被儲(chǔ)存為字典,，要使用鍵值對的方式傳入,，具體見下例

>>> def print_args(*args):
...     print('tuple',args)
...
>>> print_args() #如果不傳參，則返回空的tuple()
tuple ()
>>> print_args(1,3,12,'asd',[1,2])
tuple (1, 3, 12, 'asd', [1, 2])
>>> def print_kwargs(**kwargs):
...     print('dict',kwargs)
...
>>> print_kwargs(a='a',b='b',c='c')
dict {'a': 'a', 'b': 'b', 'c': 'c'}

那么這樣做有什么用呢,？下面舉一些例子說明：

#轉(zhuǎn)置一個(gè)矩陣
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix = list(map(list, zip(*matrix)))
>>> matrix
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

zip(*value)因?yàn)樵诤瘮?shù)調(diào)用中使用*list/tuple的方式表示將list/tuple分開,，作為位置參數(shù)傳遞給對應(yīng)函數(shù)，所以起到了轉(zhuǎn)置矩陣的作用,。

三,、Python高級用法

1.列表推導(dǎo)式

例如我們要?jiǎng)?chuàng)建一個(gè)0到10的列表，那么我們可能首先會(huì)想到使用range()

>>> list(range(0,11))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

然而更加Pythonic的方法是使用列表推導(dǎo)式,，即[expression for item in iterable if condition],舉例說明

>>> [x for x in range(0,11)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> [x**2 for x in range(0,11)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x**2 for x in range(0,11) if x < 5]
[0, 1, 4, 9, 16]

這里我們可以用它構(gòu)建一個(gè)空的二維數(shù)組,，即一個(gè)m*n的矩陣

>>> [[0 for col in range(5)] for row in range(3)]
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

再舉一個(gè)例子，取出有相同值的列表中第n次出現(xiàn)的下標(biāo)

>>> nums = [1,2,3,2,1,3,4,5,6,1,3,5,6,4,2,1]
>>> index = [idx for idx, e in enumerate(nums) if e == 1] #其中idx是下標(biāo),，1為目標(biāo)值,，即取出了所有1的位置下標(biāo)
>>> index
[0, 4, 9, 15]

2.匿名函數(shù)：lambda()函數(shù)

Python中，為實(shí)現(xiàn)函數(shù)式編程,，lambda不能少,，它是用于語句表達(dá)的匿名函數(shù)，可以用來代替小的函數(shù),，下面舉例說明,。

#判斷一個(gè)數(shù)是否是偶數(shù)
>>> f = lambda x: True if x % 2 == 0 else False
>>> print(f(4))
True
>>> print(f(5))
False

#字典按values排序
>>> dict = {'four': 4, 'three': 3, 'two': 2, 'one': 1}
>>> dict_lst = sorted(dict.items(), key=lambda x:x[1])
>>> dict_lst
[('one', 1), ('two', 2), ('three', 3), ('four', 4)]

3.日期與時(shí)間

使用python處理日期與時(shí)間，需要用到datetime模塊,，例如獲取當(dāng)前時(shí)間

>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now)
2018-01-17 19:55:50.371107

很多時(shí)候使用時(shí)間戳來表示時(shí)間,，我們把1970年1月1日 00:00:00 UTC+00:00時(shí)區(qū)的時(shí)刻稱為epoch time，記為0（1970年以前的時(shí)間timestamp為負(fù)數(shù)）,，當(dāng)前時(shí)間就是相對于epoch time的秒數(shù),，稱為timestamp。

>>> now.timestamp()
1516190150.371107
#相應(yīng)的轉(zhuǎn)回來使用
>>> t = now.timestamp()
>>> print(datetime.fromtimestamp(t))
2018-01-17 19:55:50.371107
#還可以轉(zhuǎn)成UTC時(shí)間
>>> print(datetime.utcfromtimestamp(t))
2018-01-17 11:55:50.371107

然而這些都是datetime類型的數(shù)據(jù),，不便于處理,，所以我們要將其轉(zhuǎn)換成字符串類型，字符串'%Y-%m-%d %H:%M:%S'規(guī)定了日期和時(shí)間部分的格式,。

>>> print(now.strftime('%Y-%m-%d %H:%M:%S'))
2018-01-17 19:55:50
>>> print(now.strftime('%Y-%m-%d'))
2018-01-17
>>> print(now.strftime('%Y%m%d'))
20180117
#當(dāng)然也可以字符串轉(zhuǎn)datetime
>>> now = now.strftime('%Y%m%d')
>>> now
'20180117'
>>> now = datetime.strptime(now, '%Y%m%d')
>>> now
datetime.datetime(2018, 1, 17, 0, 0)

可以隨意調(diào)整你需要的格式,。

有時(shí)我們還會(huì)用到時(shí)間的運(yùn)算,，這里必須結(jié)合datetime和timedelta

>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2018, 1, 17, 20, 3, 53, 221673)
>>> now + timedelta(hours=1)
datetime.datetime(2018, 1, 17, 21, 3, 53, 221673)
>>> now - timedelta(days=7)
datetime.datetime(2018, 1, 10, 20, 3, 53, 221673)
>>> (now - timedelta(days=7)).strftime('%Y-%m-%d-%H-%M-%S')
'2018-01-10-20-03-53'
>>> (now - timedelta(days=7)).strftime('%Y-%m-%d-%H-%M-%S').split('-')
['2018', '01', '10', '20', '03', '53']

把分隔符號(hào)統(tǒng)一便于分隔，分隔成list后便于進(jìn)行時(shí)間粒度劃分處理,。

最后一個(gè)實(shí)用的是判斷星期幾：

>>> from datetime import datetime
>>> text = '2012-09-20'
>>> y = datetime.strptime(text, '%Y-%m-%d')
>>> y.weekday()
3

4.高級內(nèi)建函數(shù)

1.reduce(function, iterable[, initializer]),有map當(dāng)然就會(huì)有reduce,，在Python3中，reduce()已經(jīng)從全局命名空間中移除,，放到了functools模塊中,，如果要是用，需要用from functools import reduce引入之,。

map是上下運(yùn)算,，reduce是橫著逐個(gè)元素進(jìn)行運(yùn)算，下面舉個(gè)例子：

#基礎(chǔ)用法
>>> reduce(lambda x,y: x+y,[1,2,3,4,5])
15
#進(jìn)階
>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> list(zip(a,b))
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
>>> sum(x*y for x,y in zip(a,b))
130
>>> reduce(lambda x,y:x+y,map(lambda x,y:x*y,a,b))
130

2.filter(function, iterable),filter的中文含義是“過濾器”,，在python中,，它就是起到了過濾器的作用。

>>> numbers = range(-5,5)
>>> numbers
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

>>> filter(lambda x: x>0, numbers) 
[1, 2, 3, 4]

>>> [x for x in numbers if x>0]     #與上面那句等效
[1, 2, 3, 4]

3.yield生成器,，返回值 變?yōu)橐粋€(gè)生成器對象

#例如輸出斐波那契數(shù)列前N個(gè)數(shù)字
>>> def fab(max):
...     n, a, b = 0, 0, 1
...     while n < max:
...         print(b)
...         a, b = b, a + b
...         n = n + 1
...
>>> fab(5)
1
1
2
3
5
#修改后變?yōu)?>>> def fab(max):
...     n, a, b = 0, 0, 1
...     while n < max:
...         yield(b)
...         a, b = b, a + b
...         n = n + 1
...
>>> fab(5)
<generator object fab at 0x000002C359B6F410>
>>> for i in fab(5):
...     print(i)
...
1
1
2
3
5

這樣做的好處是它不是全部存在內(nèi)存里,，它只在要調(diào)用的時(shí)候在內(nèi)存里生成，這樣就能和上述一樣做到lazy evaluation,需要的時(shí)候才迭代,。

5.文件操作

1.打開文件：

fp = open("test.txt",w)
直接打開一個(gè)文件,，如果文件不存在則創(chuàng)建文件
關(guān)于open 模式：

w 以寫方式打開，
a 以追加模式打開 (從 EOF 開始, 必要時(shí)創(chuàng)建新文件)
r+ 以讀寫模式打開
w+ 以讀寫模式打開 (參見 w )
a+ 以讀寫模式打開 (參見 a )

2.關(guān)閉文件：

使用file.close()或者with open("131.txt","w") as f:來關(guān)閉,，建議使用第二種操作

>>> with open("131.txt","w") as f:
...     f.write("This is a file")
...
14

3.read/readline/readlines

• read：如果指定了參數(shù)size,，就按照該指定長度從文件中讀取內(nèi)容，否則,，就讀取全文。被讀出來的內(nèi)容,，全部塞到一個(gè)字符串里面,。這樣有好處，就是東西都到內(nèi)存里面了,，隨時(shí)取用,，比較快捷；也是因?yàn)檫@點(diǎn),，如果文件內(nèi)容太多了,，內(nèi)存會(huì)吃不消的。
• readline：那個(gè)可選參數(shù)size的含義同上,。它則是以行為單位返回字符串,，也就是每次只讀一行，依次循環(huán),，如果不限定size,，直到最后一個(gè)返回的是空字符串,，意味著到文件末尾了(EOF)。
• readlines：size同上,。它返回的是以行為單位的列表,，即相當(dāng)于先執(zhí)行readline()，得到每一行,，然后把這一行的字符串作為列表中的元素塞到一個(gè)列表中,，最后將此列表返回。

>>> with open("airport_gz_passenger_24.csv","r") as f:
...    text = f.read()
...
>>> text = text.split('\n')
>>> text[0]
'passengerCount,WIFIAPTag,slice10min'
>>> with open("airport_gz_passenger_24.csv","r") as f:
...     f.readline()
...
'passengerCount,WIFIAPTag,slice10min\n'
>>> with open("airport_gz_passenger_24.csv","r") as f:
...     text = f.readlines()
...
>>> text[0]
'passengerCount,WIFIAPTag,slice10min\n'

5.多進(jìn)程實(shí)現(xiàn)并行處理

在Python中使用multiprocessing模塊來實(shí)現(xiàn)多進(jìn)程,，下面舉例說明

#一個(gè)簡單的查找程序
import multiprocessing
import time

def find(flag):
    num = 99
    if flag == 0:
    	s1 = time.time()
    for i in range(0, 101):
    	time.sleep(0.1)
        if num == i:
            print("順序找到")
            print("耗時(shí)" + str(time.time() - s1))
    if flag == 1:
    	s2 = time.time()
    for i in range(101, 0, -1):
    	time.sleep(0.1)
		if num == i:
            print("逆序找到")
            print("耗時(shí)" + str(time.time() - s2))

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 2)
    for i in range(2):
        pool.apply_async(find, (i, )) #維持執(zhí)行的進(jìn)程總數(shù)為processes,，當(dāng)一個(gè)進(jìn)程執(zhí)行完畢后會(huì)添加新的進(jìn)程進(jìn)去
        print("開始")
        pool.close()
        pool.join() #調(diào)用join之前，先調(diào)用close函數(shù),，否則會(huì)出錯(cuò),。執(zhí)行完close后不會(huì)有新的進(jìn)程加入到pool,join函數(shù)等待所有子進(jìn)程結(jié)束
    print("結(jié)束")

結(jié)果如下：

C:\Users\Cabbage\Desktop\畢業(yè)設(shè)計(jì)\code\first>python mulprocess_1.py
開始
逆序找到
耗時(shí)0.30155348777770996
順序找到
耗時(shí)10.043102502822876
結(jié)束

6.異常處理

1.錯(cuò)誤與異常

語法錯(cuò)誤，或者稱之為解析錯(cuò)誤：

>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax

異常

即使一條語句或表達(dá)式在語法上是正確的,，在運(yùn)行它的時(shí)候,，也有可能發(fā)生錯(cuò)誤。在執(zhí)行期間檢測到的錯(cuò)誤被稱為異常并且程序不會(huì)無條件地崩潰：你很快就會(huì)知道如何在 Python 程序中處理它們,。然而大多數(shù)異常都不會(huì)被程序處理,，導(dǎo)致產(chǎn)生類似下面的錯(cuò)誤信息：

>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

最后一行的錯(cuò)誤消息指示發(fā)生了什么事。異常有不同的類型,下面列出常見異常：

2.使用try...except處理異常

拋出異常

可以通過編程來選擇處理部分異常,?？匆幌孪旅娴睦樱鼤?huì)一直要求用戶輸入直到輸入一個(gè)合法的整數(shù)為止,，但允許用戶中斷這個(gè)程序（使用Control-C或系統(tǒng)支持的任何方法）,；注意用戶產(chǎn)生的中斷引發(fā)的是 KeyboardInterrupt 異常。

while True:
try:
x = int(input("輸入一個(gè)數(shù)字： "))
break
except ValueError:
print("這不是數(shù)字,，重新輸入,。")

輸出為：

C:\Users\Cabbage\Desktop\畢業(yè)設(shè)計(jì)\code\first>python error.py
輸入一個(gè)數(shù)字： a
這不是數(shù)字，重新輸入,。
輸入一個(gè)數(shù)字： b
這不是數(shù)字,，重新輸入。
輸入一個(gè)數(shù)字： 1

引發(fā)異常

raise語句允許程序員強(qiáng)行引發(fā)一個(gè)指定的異常,。例如：

inputValue = input("請輸入a,b或c:")
if inputValue in "abc":
print(inputValue)
else:
raise(ValueError)

結(jié)果為：

C:\Users\Cabbage\Desktop\畢業(yè)設(shè)計(jì)\code\first>python raise.py
請輸入a,b或c:f
Traceback (most recent call last):
File "raise.py", line 5, in <module>
raise(ValueError)
ValueError

C:\Users\Cabbage\Desktop\畢業(yè)設(shè)計(jì)\code\first>python raise.py
請輸入a,b或c:a