Python 的高級特性

切片

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

>>> 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的倍數(shù) [0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99]

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

迭代 Iteration

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

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

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

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

列表生成式

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

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

for循環(huán)后面還可以加上if判斷。

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

還可以使用兩層循環(huán)，可以生成全排列。

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

生成器

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

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

生成generator有兩個辦法。

1、只要把一個列表生成式的[]改成()，就創(chuàng)建了一個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保存的是算法，每次調(diào)用next(g)，就計算出g的下一個元素的值，直到計算到最后一個元素，沒有更多的元素時，拋出StopIteration的錯誤。通常，可以使用for循環(huán)來遍歷生成器中的內(nèi)容。

2、如果算法比較復(fù)雜，可以使用函數(shù)來實現(xiàn)。

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

如果一個函數(shù)定義中包含yield關(guān)鍵字，那么這個函數(shù)就不再是一個普通函數(shù)，而是一個generator。函數(shù)是順序執(zhí)行，遇到return語句或者最后一行函數(shù)語句就返回。而變成generator的函數(shù)，在每次調(diào)用next()的時候執(zhí)行，遇到y(tǒng)ield語句返回，再次執(zhí)行時從上次返回的yield語句處繼續(xù)執(zhí)行。

迭代器

這里主要區(qū)分?Iterable?和?Iterator?。

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

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

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

函數(shù)式編程

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

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

Python對函數(shù)式編程提供部分支持。

高階函數(shù) High order function

變量可以指向函數(shù)

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

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

函數(shù)名也是變量

Python中函數(shù)名其實就是指向函數(shù)的變量。

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

傳入函數(shù)

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

map / reduce

Python內(nèi)建了map()和reduce()函數(shù)。map()函數(shù)接收兩個參數(shù)，一個是函數(shù)，一個是Iterable，map將傳入的函數(shù)依次作用到序列的每個元素，并把結(jié)果作為新的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把一個函數(shù)作用在一個序列[x1, x2, x3, ...]上，這個函數(shù)必須接收兩個參數(shù)，reduce把結(jié)果繼續(xù)和序列的下一個元素做累積計算，其效果就是reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)。

filter

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

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

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

sorted 排序算法

排序是程序中經(jīng)常用到的算法。無論使用冒泡排序還是快速排序，排序的核心是比較兩個元素的大小。Python內(nèi)置的sorted()函數(shù)就可以對list進行排序。sorted()函數(shù)也是一個高階函數(shù)，它還可以接收一個key函數(shù)來實現(xiàn)自定義的排序，例如按絕對值大小排序。key指定的函數(shù)將作用于list的每一個元素上，并根據(jù)key函數(shù)返回的結(jié)果進行排序。要進行反向排序，不必改動key函數(shù)，可以傳入第三個參數(shù)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]

函數(shù)作為返回值

高階函數(shù)除了可以接受函數(shù)作為參數(shù)外，還可以把函數(shù)作為結(jié)果值返回。如下示例，調(diào)用lazy_sum時，返回的并不是求和結(jié)果，而是求和函數(shù)。這種結(jié)構(gòu)稱為閉包 Closure。

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

返回閉包時牢記的一點就是：返回函數(shù)不要引用任何循環(huán)變量，或者后續(xù)會發(fā)生變化的變量。

匿名函數(shù)

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

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

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

裝飾器

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

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

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

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

把@log放到now()函數(shù)的定義處，相當(dāng)于執(zhí)行了語句:now = log(now)

對于上面這種寫法，如果調(diào)用__name__方法，返回的函數(shù)名為 wrapper ，需要用Python內(nèi)置的 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

偏函數(shù)

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

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

如上例子，通過使用偏函數(shù)，我們相當(dāng)于對函數(shù)做了一個包裝，默認輸入了一些函數(shù)參數(shù)，減少了后續(xù)調(diào)用時輸入的參數(shù)個數(shù)。實現(xiàn)這個功能，可以借助 functools。

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

模塊

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

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

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

使用模塊

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

#!/usr/bin/env python3 #標(biāo)準(zhǔn)注釋 # -*- coding: utf-8 -*- #表示.py文件本身使用標(biāo)準(zhǔn)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()

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

作用域

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

安裝第三方模塊

在Python中，安裝第三方模塊，是通過包管理工具pip完成的。在命令提示符窗口下嘗試運行pip，如果Windows提示未找到命令，可以重新運行安裝程序添加pip。

注意：Mac或Linux上有可能并存Python 3.x和Python 2.x，因此對應(yīng)的pip命令是pip3。

一般來說，第三方庫都會在Python官方的pypi.python.org網(wǎng)站注冊，要安裝一個第三方庫，必須先知道該庫的名稱，可以在官網(wǎng)或者pypi上搜索，比如Pillow的名稱叫Pillow，因此，安裝Pillow的命令就是

pip install Pillow

總結(jié)

以上是生活随笔為你收集整理的Python3.6学习笔记（二）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。