一天速成Python教程

一、Python基礎

Python是物件有型別，變數無型別的動態型別語言，追求簡單優雅易讀，可以在終端中逐行運行，也可以撰寫成大型的面向物件的工程，在開始寫之前，注意Python 2.X中，開頭要寫上#coding:utf-8，并且Python通過縮進知道一個特定的代碼塊于周圍的代碼保持獨立，所用的空格數很重要，因此應該使用編輯器確定縮進，并且不要手動改變空格數，根據PEP的規定，必須使用4個空格來表示每級縮排，使用Tab字符和其它數目的空格雖然都可以編譯通過，但不符合編碼規范，

1.數字和字符

1. Python本身支持整數與浮點數，計算如下表

強制型別轉換使用int(num)與float(num)進行，

2. 字串

使用引號包裹，例如：

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

可見可以使用兩種引號進行創建，這樣的好處是可以創建本身就包含引號的字串，而不用使用轉義符，可以在雙引號包裹的字串使用單引號，或者在單引號包裹的字串中使用雙引號：

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

還可以使用三個單引號創建字串：

>>> '''
... 我們去看煙火好嗎
... 去，去看那
... 繁花之中如何再生繁花
... 夢境之上如何再現夢境
... '''
'\n我們去看煙火好嗎\n去，去看那\n繁花之中如何再生繁花\n夢境之上如何再現夢境\n'

• 在字串中使用str(value)進行強制型別轉換，

• 使用\進行轉義

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

• 使用+進行拼接

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

• 使用*復制

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

• 使用[]提取字符

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

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

# [:] 提取全部
# [start:] 從start到結尾
# [:end] 從開頭到end - 1
# [start:end] 從strat到end - 1
# [start:end:step] 從start到end - 1，每step個字符提取一個
>>> 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)進行分割，value填寫分割字符，回傳一個串列

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

• 同樣可以使用join()將串列進行合并成字串

>>> 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陳述句，匯入模塊使用，兩種形式：

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

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

2.條件陳述句：

if...elif...else陳述句

if 條件1:
執行的內容1
elif 條件2:
執行的內容2
elif 條件3：
執行的內容3
else:
執行的內容4

3.回圈陳述句：

for陳述句

for 回圈規則：
操作陳述句

for回圈所應用的物件，應該是可迭代的，

判斷一個物件是否可迭代使用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

回圈（loop），指的是在滿足條件的情況下，重復執行同一段代碼，比如，while陳述句，

迭代（iterate），指的是按照某種順序逐個訪問串列中的每一項，比如，for陳述句，

遞回（recursion），指的是一個函式不斷呼叫自身的行為，比如，以編程方式輸出著名的斐波納契數列，

遍歷（traversal），指的是按照一定的規則訪問樹形結構中的每個節點，而且每個節點都只訪問一次，

3.函式

1.定義函式

使用def:函式的開頭，define的縮寫，后面跟函式名稱和引數，最后一點要加“：”冒號，例如 def add(x,y):

2.函式體的第一個陳述句可以是字串（即為注釋）; 這個字串就是函式的檔案字串, 或稱為 docstring，例如：

def split_data_set(dataSet, axis, value):
"""
輸入：資料集，選擇維度，選擇值
輸出：劃分資料集
描述：按照給定特征劃分資料集；去除選擇維度中等于選擇值的項
"""

3.命名規范，這里參考PEP8

b（單個小寫字母）

B（單個大寫字母）

小寫（小寫）

lower_case_with_underscores（含底線的小寫）

大寫（UPPERCASE）

UPPER_CASE_WITH_UNDERSCORES（含底線的大寫）

大寫字母（字首大寫，又稱CapWords或CamelCase - 如此稱呼是因為字母看起來崎嶇不平[4]），有時也稱為StudlyCaps，

注意：如果有縮寫字，將縮寫字的每個字母大寫，也就是寫HTTPServerError比HttpServerError好，

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

Capitalized_Words_With_Underscores（字首大寫加底線）

來自命名慣例

4.引數與變數

形參與實參：

函式名后面的括號里如果有變數，它們通常被稱為“形參”，呼叫函式的時候，給函式提供的值叫做“實參”，或者“引數”，個人理解，實參是在函式呼叫前就實際存在的引數，而形參是在呼叫函式的時候，用于將實參的值傳入函式用的，

引數與變數的區別，每個形參的名稱均可作為程序內的區域變數，形參名稱的使用方法與其他任何變數的使用方法相同，
實參表示在您呼叫程序時傳遞給程序形參的值，

區域變數與全域變數：

在函式里面的就是區域變數，在函式外面的就是區域變數，在C和JAVA中主要是有一個主函式或主方法開始運行的地方，而Python并沒有，Python是逐行運行的，但可以使用if __name__ == '__main__'來規定當前程式的程式入口是什么，防止模塊之間相互參考導致入口混亂，

4.初級內建函式

1.print(value, seq=' ', end='\n') 在Python 3.X中，為一個函式，其中引數seq=' '為分隔符，引數end='\n'為結尾換行符號，可以自己修改，

Tips:

print實質是將輸出重定向到sys.stdout.write標準輸出，可以修改引數file，指定輸出到檔案，

print()是同步阻塞的，所以頻繁的print會大大降低程式運行速度，比如在訓練模型時注意減少print的次數，

2.id(obj)查看物件記憶體地址，

3.type(obj)查看物件的型別，

4.round(value, n)四舍五入到小數點后n位，

5.a = input(msg)列印出msg，并從鍵盤輸入一個變數賦值給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))	#查看記憶體地址
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()來創建串列

>>> [1,2,3,4,5] #使用[]創建
[1, 2, 3, 4, 5]
>>> list(12345) #不可迭代報錯
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()是不允許將不可迭代的轉換成串列，如果是可迭代的，例如字串，則會按照字符分割成串列，

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

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

list類似于陣列，但陣列只有一個型別，而list里面可以包含多個型別，串列的一個重要特征：串列是可以修改的，這種修改，不是復制一個新的，而是在原地進行修改，

3.使用append()與extend()擴充串列

串列擴容的函式append()和extend()都是原地修改串列,所以沒有回傳值，所以不能賦給某個變數，

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

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

總結以下就是append是整建制地追加，extend是個體化擴編，

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),當offset為0時則插入到頭部，當offset超過了尾部，則會插入到最后，并不會引起例外，

>>> 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()則是洗掉指定值的數，使用pop()則是彈堆疊操作，回傳最后一位元素，即堆疊頂元素，

5.使用in判斷元素是否存在，count()記錄特定值出現次數，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規定開始索引，end默認為串列長度，回傳開始索引位置后第一次出現的str的位置，

6.使用sort()與sorted()排列陣列

默認都是升序排列，加上引數reverse=True則降序排列，

• sort()會對原串列進行排序，改變原串列內容，
• sorted()則會回傳排序好的串列副本，原串列內容不變，

>>> 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()復制

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

即使用=賦值后，b與a是同一個物件，修改任意一個都會修改對方，使用copy(),list()與[:]都可以做到創建一個新物件的作用，

8.使用range()生成串列

在Python3中，range()的回傳值已經變為range型別，不再是原來的list型別，但依舊可以使用list函式轉換過去，range(start, end, step)，即生成一個從start開始，end - 1結束的串列，step為步長，多用于回圈之中，

>>> 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()創建元組

>>> 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

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

3.字典

字典與串列類似，可以原地修改，即它是可變的，但它的順序無關緊要，因為其本質就是鍵值對，在字典中的“鍵”，必須是不可變的資料型別；“值”可以是任意資料型別，

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

>>> mydict = {"1":"a","2":"b"} #初始化字典
>>> mydict
{'1': 'a', '2': 'b'}
>>> lst = [[1,2],[3,4],[5,6]] #將二維串列轉換成字典
>>> mydict = dict(lst)
>>> mydict
{1: 2, 3: 4, 5: 6}
>>> string = ('12','34','56') #將雙字符的字串元組轉換成字典
>>> 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'}	#如果使用同樣的鍵，則新歸入字典的值會取代原有的值
>>> 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]獲取，如果鍵不存在則會拋出例外，所以改用get()方法，不存在的話會回傳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中，回傳的型別已經變成'dict_keys'等等這種方法，這樣做的目的是list占用空間較大，且效率不高，所以如果需要用到list，再使用list函式即可，

4.集合

集合的概念與數學中的集合概念是相同的，即集合中的元素是互異的，

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

>>> 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中去重是非常簡單的事情，直接轉換成集合就行了，

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

2.集合中運算

>>> 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.進一步的內建函式

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

所以可以使用其進行生成字典操作：

>>> 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中回傳的是一個map物件，依舊是節省時間的作用，也就是lazy evaluation，

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

>>> 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.可變長度的函式引數

在Python中，有兩種變長引數，分別是元組（非關鍵字引數）和字典（關鍵字引數），其呼叫方式是：func( *args, **kwargs )
因為有時候不知道傳進去多少個引數，所以要用可變長的引數，在引數前加一個星號*代表傳入的引數會被儲存為元組，加兩個星號**代表傳入的會被儲存為字典，要使用鍵值對的方式傳入，具體見下例

>>> 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'}

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

#轉置一個矩陣
>>> 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)因為在函式呼叫中使用*list/tuple的方式表示將list/tuple分開，作為位置引數傳遞給對應函式，所以起到了轉置矩陣的作用，

三、Python高級用法

1.串列推導式

例如我們要創建一個0到10的串列，那么我們可能首先會想到使用range()

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

然而更加Pythonic的方法是使用串列推導式，即[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]

這里我們可以用它構建一個空的二維陣列，即一個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]]

再舉一個例子，取出有相同值的串列中第n次出現的下標

>>> 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是下標，1為目標值，即取出了所有1的位置下標
>>> index
[0, 4, 9, 15]

2.匿名函式：lambda()函式

Python中，為實作函式式編程，lambda不能少，它是用于陳述句表達的匿名函式，可以用來代替小的函式，下面舉例說明，

#判斷一個數是否是偶數
>>> 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.日期與時間

使用python處理日期與時間，需要用到datetime模塊，例如獲取當前時間

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

很多時候使用時間戳來表示時間，我們把1970年1月1日 00:00:00 UTC+00:00時區的時刻稱為epoch time，記為0（1970年以前的時間timestamp為負數），當前時間就是相對于epoch time的秒數，稱為timestamp，

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

然而這些都是datetime型別的資料，不便于處理，所以我們要將其轉換成字串型別，字串'%Y-%m-%d %H:%M:%S'規定了日期和時間部分的格式，

>>> 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
#當然也可以字串轉datetime
>>> now = now.strftime('%Y%m%d')
>>> now
'20180117'
>>> now = datetime.strptime(now, '%Y%m%d')
>>> now
datetime.datetime(2018, 1, 17, 0, 0)

可以隨意調整你需要的格式，

有時我們還會用到時間的運算，這里必須結合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']

把分隔符號統一便于分隔，分隔成list后便于進行時間粒度劃分處理，

最后一個實用的是判斷星期幾：

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

4.高級內建函式

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

map是上下運算，reduce是橫著逐個元素進行運算，下面舉個例子：

#基礎用法
>>> reduce(lambda x,y: x+y,[1,2,3,4,5])
15
#進階
>>> 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生成器，回傳值 變為一個生成器物件

#例如輸出斐波那契數列前N個數字
>>> 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
#修改后變為
>>> 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

這樣做的好處是它不是全部存在記憶體里，它只在要呼叫的時候在記憶體里生成，這樣就能和上述一樣做到lazy evaluation,需要的時候才迭代，

5.檔案操作

1.打開檔案：

fp = open("test.txt",w)
直接打開一個檔案，如果檔案不存在則創建檔案
關于open 模式：

w 以寫方式打開，
a 以追加模式打開 (從 EOF 開始, 必要時創建新檔案)
r+ 以讀寫模式打開
w+ 以讀寫模式打開 (參見 w )
a+ 以讀寫模式打開 (參見 a )

2.關閉檔案：

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

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

3.read/readline/readlines

• read：如果指定了引數size，就按照該指定長度從檔案中讀取內容，否則，就讀取全文，被讀出來的內容，全部塞到一個字串里面，這樣有好處，就是東西都到記憶體里面了，隨時取用，比較快捷；也是因為這點，如果檔案內容太多了，記憶體會吃不消的，
• readline：那個可選引數size的含義同上，它則是以行為單位回傳字串，也就是每次只讀一行，依次回圈，如果不限定size，直到最后一個回傳的是空字串，意味著到檔案末尾了(EOF)，
• readlines：size同上，它回傳的是以行為單位的串列，即相當于先執行readline()，得到每一行，然后把這一行的字串作為串列中的元素塞到一個串列中，最后將此串列回傳，

>>> 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.多行程實作并行處理

在Python中使用multiprocessing模塊來實作多行程，下面舉例說明

#一個簡單的查找程式
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("耗時" + 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("耗時" + str(time.time() - s2))

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 2)
    for i in range(2):
        pool.apply_async(find, (i, )) #維持執行的行程總數為processes，當一個行程執行完畢后會添加新的行程進去
        print("開始")
        pool.close()
        pool.join() #呼叫join之前，先呼叫close函式，否則會出錯，執行完close后不會有新的行程加入到pool,join函式等待所有子行程結束
    print("結束")

結果如下：

C:\Users\Cabbage\Desktop\畢業設計\code\first>python mulprocess_1.py
開始
逆序找到
耗時0.30155348777770996
順序找到
耗時10.043102502822876
結束

6.例外處理

1.錯誤與例外

語法錯誤，或者稱之為決議錯誤：

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

例外

即使一條陳述句或運算式在語法上是正確的，在運行它的時候，也有可能發生錯誤，在執行期間檢測到的錯誤被稱為例外并且程式不會無條件地崩潰：你很快就會知道如何在 Python 程式中處理它們，然而大多數例外都不會被程式處理，導致產生類似下面的錯誤資訊：

>>> 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

最后一行的錯誤訊息指示發生了什么事，例外有不同的型別,下面列出常見例外：

2.使用try...except處理例外

拋出例外

可以通過編程來選擇處理部分例外，看一下下面的例子，它會一直要求用戶輸入直到輸入一個合法的整數為止，但允許用戶中斷這個程式（使用Control-C或系統支持的任何方法）；注意用戶產生的中斷引發的是 KeyboardInterrupt 例外，

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

輸出為：

C:\Users\Cabbage\Desktop\畢業設計\code\first>python error.py
輸入一個數字： a
這不是數字，重新輸入，
輸入一個數字： b
這不是數字，重新輸入，
輸入一個數字： 1

引發例外

raise陳述句允許程式員強行引發一個指定的例外，例如：

inputValue = https://www.cnblogs.com/harrylyx/p/input("請輸入a,b或c:")
if inputValue in "abc":
print(inputValue)
else:
raise(ValueError)

結果為：

C:\Users\Cabbage\Desktop\畢業設計\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\畢業設計\code\first>python raise.py
請輸入a,b或c:a
a

標籤：Python

上一篇：一份詳盡的 Java 問題排查工具清單，值得收藏！

下一篇：Python