Python3.6學習筆記（二）

Python 的高級特性

切片

對于指定索引范圍取值的操作，Python提供了slice方法，類似于Excel中數據透視表的切片器。

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack’]    #聲明一個List，取前三個值
>>> L[0:3]    #表示從0開始，到3為止，但是不包括3，后面還可以再接:加上步長
['Michael', 'Sarah', 'Tracy’]
>>> S=list(range(100))    #聲明一個0-99的list
>>> S[0:100:9]            #取9的倍數
[0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99]

tuple也是一種list，唯一區別是tuple不可變。因此，tuple也可以用切片操作，只是操作的結果仍是tuple。

迭代 Iteration

給定一個list或tulp，可以通過for循環來遍歷，這稱之為迭代。Python中的迭代類似于Javascript，而與PHP或Java采用下標迭代的方式不同。對于Python來說，dict、set、字符串等都是可迭代對象，都可以使用for循環。只要作用于一個可迭代對象，for循環就可以正常運行，而我們不太關心該對象究竟是list還是其他數據類型。

判斷一個對象是否可迭代，通過collections模塊的Iterable類型判斷。

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整數是否可迭代
False

Python內置的enumerate函數可以把一個list變成索引-元素對，這樣就可以在for循環中同時迭代索引和元素本身。

列表生成式

列表生成式即List Comprehensions，是Python內置的非常簡單卻強大的可以用來創建list的生成式。寫列表生成式時，把要生成的元素放到前面，后面跟for循環，就可以把list創建出來，十分有用，多寫幾次，很快就可以熟悉這種語法。

tiangan = '甲乙丙丁戊己庚辛壬癸'
dizhi = '子丑寅卯辰巳午未申酉戌亥'jiazi = [tiangan[x % len(tiangan)] + dizhi[x % len(dizhi)] for x in range(60)]

for循環后面還可以加上if判斷。

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

還可以使用兩層循環，可以生成全排列。

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', ‘CZ']

生成器

通過列表生成式，我們可以直接創建一個列表。但是，受到內存限制，列表容量肯定是有限的。而且，創建一個包含100萬個元素的列表，不僅占用很大的存儲空間，如果我們僅僅需要訪問前面幾個元素，那后面絕大多數元素占用的空間都白白浪費了。

所以，如果列表元素可以按照某種算法推算出來，那我們是否可以在循環的過程中不斷推算出后續的元素呢？這樣就不必創建完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱為生成器：generator。

生成generator有兩個辦法。

1、只要把一個列表生成式的[]改成()，就創建了一個generator。

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最后一個元素，沒有更多的元素時，拋出StopIteration的錯誤。通常，可以使用for循環來遍歷生成器中的內容。

2、如果算法比較復雜，可以使用函數來實現。

def fib(max):n, a, b = 0, 0, 1while n < max:yield ba, b = b, a + bn = n + 1return 'done'

如果一個函數定義中包含yield關鍵字，那么這個函數就不再是一個普通函數，而是一個generator。函數是順序執行，遇到return語句或者最后一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

迭代器

這里主要區分?Iterable?和?Iterator?。

對于?Iterable?的數據類型，稱之為可迭代對象，可以使用for循環遍歷，包括list、tuple、dict、set、str、生成器以及帶yield的Generator Function。可以使用?isinstance()?函數判斷是否為 Iterable 。

迭代器不僅可以使用for循環，還可以使用next()函數不斷調用返回下一個值，直到最后拋出StopIteration錯誤表示無法繼續返回下一個值了。這樣，就可以把數據流看作一個有序序列，我們不知道序列的長度，但是可以通過不斷的計算獲取下一個值。

可以使用?iter()?函數把?list、dict、str等Iterable變成Iterator。

函數式編程

我之前熟悉的PHP、C，編寫程序多是通過將任務分解為一個個Function，然后組合起來解決問題的，這種分解稱為面向過程的程序設計，而函數是面向過程的程序設計的基本單元。

函數式編程（Functional Programming）其思想更接近數學計算。函數式編程就是一種抽象程度很高的編程范式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變量的程序設計語言，由于函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。

Python對函數式編程提供部分支持。

高階函數 High order function

變量可以指向函數

這個對我真是有點顛覆，看下面的例子。

>> abs(-10)
10
>>> abs
<built-in function abs>
>>> f = abs
>>> f(-10)
10

函數名也是變量

Python中函數名其實就是指向函數的變量。

>>> abs=10
>>> abs
10
>>> abs(-10)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> f(-10)
10

傳入函數

函數的參數如果接收一個指向函數的變量，就變成了一個函數接收另一個函數作為參數，這種函數稱為高階函數。函數式編程就是指這種高度抽象的編程范式

map / reduce

Python內建了map()和reduce()函數。map()函數接收兩個參數，一個是函數，一個是Iterable，map將傳入的函數依次作用到序列的每個元素，并把結果作為新的Iterator返回。

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce把一個函數作用在一個序列[x1, x2, x3, ...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素做累積計算，其效果就是reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)。

filter

Python內建的函數filter()用于過濾序列，其接收一個函數和一個序列，并把傳入的函數作用于每個元素，然后根據返回值是True還是False決定是保留還是丟棄該元素。

def is_odd(n):return n % 2 == 1list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

注意到filter()函數返回的是一個Iterator，也就是一個惰性序列，所以要強迫filter()完成計算結果，需要用list()函數獲得所有結果并返回list。

sorted 排序算法

排序是程序中經常用到的算法。無論使用冒泡排序還是快速排序，排序的核心是比較兩個元素的大小。Python內置的sorted()函數就可以對list進行排序。sorted()函數也是一個高階函數，它還可以接收一個key函數來實現自定義的排序，例如按絕對值大小排序。key指定的函數將作用于list的每一個元素上，并根據key函數返回的結果進行排序。要進行反向排序，不必改動key函數，可以傳入第三個參數reverse=True。

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

函數作為返回值

高階函數除了可以接受函數作為參數外，還可以把函數作為結果值返回。如下示例，調用lazy_sum時，返回的并不是求和結果，而是求和函數。這種結構稱為閉包 Closure。

def lazy_sum(*args):def sum():ax = 0for n in args:ax = ax + nreturn axreturn sum

返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者后續會發生變化的變量。

匿名函數

在Python中，對匿名函數提供了有限支持。還是以map()函數為例，計算f(x)=x2時，除了定義一個f(x)的函數外，還可以直接傳入匿名函數。關鍵字lambda表示匿名函數，冒號前面的x表示函數參數。匿名函數有個限制，就是只能有一個表達式，不用寫return，返回值就是該表達式的結果。

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

用匿名函數有個好處，因為函數沒有名字，不必擔心函數名沖突。此外，匿名函數也是一個函數對象，也可以把匿名函數賦值給一個變量，再利用變量來調用該函數。

裝飾器

函數對象有一個__name__屬性，可以拿到函數的名字。現在，假設我們要增強now()函數的功能，比如，在函數調用前后自動打印日志，但又不希望修改now()函數的定義，這種在代碼運行期間動態增加功能的方式，稱之為“裝飾器”（Decorator）。

def log(func):def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper

借助Python的@語法，把decorator置于函數的定義處。

@log
def now():print('2015-3-25')>>> now()
call now():    #調用now()函數，不僅會運行now()函數本身，還會在運行now()函數前打印一行日志
2015-3-25

把@log放到now()函數的定義處，相當于執行了語句:now = log(now)

對于上面這種寫法，如果調用__name__方法，返回的函數名為 wrapper ，需要用Python內置的 functools.wraps 來解決。

import functoolsdef log(func):
    @functools.wraps(func)def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper

import functoolsdef log(text):def decorator(func):
        @functools.wraps(func)def wrapper(*args, **kw):print('%s %s():' % (text, func.__name__))return func(*args, **kw)return wrapperreturn decorator

偏函數

Python 的 functools 提供了很多有用的功能，其中一個就是偏函數（Partial function）。

def int2(x, base=2):return int(x, base)>>> int2('1000000')
64
>>> int2('1010101')
85

如上例子，通過使用偏函數，我們相當于對函數做了一個包裝，默認輸入了一些函數參數，減少了后續調用時輸入的參數個數。實現這個功能，可以借助 functools。

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
>>> int2('1000000', base=10)
1000000

模塊

任何語言要實現一個項目，都離不開文件組織管理。在Python中，一個.py文件就稱之為一個模塊（Module）。使用模塊可以提高代碼的可維護性，也可以避免函數名和變量名沖突。但是也要注意，盡量不要與內置函數名字沖突。為了避免模塊名沖突，Python又引入了按目錄來組織模塊的方法，稱為包（Package）。

引入了包以后，只要頂層的包名不與別人沖突，那所有模塊都不會與別人沖突。每一個包目錄下面都會有一個__init__.py的文件，這個文件是必須存在的，否則，Python就把這個目錄當成普通目錄，而不是一個包。init.py可以是空文件，也可以有Python代碼，因為__init__.py本身就是一個模塊。類似的，可以有多級目錄，組成多級層次的包結構。

自己創建模塊時要注意命名，不能和Python自帶的模塊名稱沖突。例如，系統自帶了sys模塊，自己的模塊就不可命名為sys.py，否則將無法導入系統自帶的sys模塊。

使用模塊

看一段代碼，引用了sys模塊，定義了hello模塊。

#!/usr/bin/env python3    #標準注釋
# -*- coding: utf-8 -*-   #表示.py文件本身使用標準UTF-8編碼' a test module '__author__ = 'Michael Liao'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()

導入sys模塊后，我們就有了變量sys指向該模塊，利用sys這個變量，就可以訪問sys模塊的所有功能。

作用域

正常的函數和變量名是公開的（public），可以被直接引用，比如：abc，x123，PI等。類似__xxx__這樣的變量是特殊變量，可以被直接引用，但是有特殊用途。類似_xxx和__xxx這樣的函數或變量就是非公開的（private），不應該被直接引用。之所以我們說，private函數和變量“不應該”被直接引用，而不是“不能”被直接引用，是因為Python并沒有一種方法可以完全限制訪問private函數或變量，但是，從編程習慣上不應該引用private函數或變量。