一天速成Python教程

一、Python基礎

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

1.數字和字符

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

運算符	描述	示例	運算結果
+	加	7 + 2	9
-	減	7 - 2	5
*	乘	7 * 2	14
/	浮點數除法	7 / 2	3.5
//	整數除法	7 // 2	3
%	求余	7 % 2	1
**	冪	7 ** 2	49

強制類型轉換使用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

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

異常	描述
NameError	嘗試訪問一個沒有申明的變量
ZeroDivisionError	除數為0
SyntaxError	語法錯誤
IndexError	索引超出序列范圍
KeyError	請求一個不存在的字典關鍵字
IOError	輸入輸出錯誤（比如你要讀的文件不存在）
AttributeError	嘗試訪問未知的對象屬性

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