Python3.6學習筆記（二）

時間 2019-11-12

原文原文鏈接

Python 的高級特性

切片

對於指定索引範圍取值的操做，Python提供了slice方法，相似於Excel中數據透視表的切片器。python

>>> 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建立出來，十分有用，多寫幾回，很快就能夠熟悉這種語法。app

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有兩個辦法。

一、只要把一個列表生成式的[]改爲()，就建立了一個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循環來遍歷生成器中的內容。

二、若是算法比較複雜，可使用函數來實現。

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return '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 == 1

list(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 = 0
        for n in args:
            ax = ax + n
        return ax
    return 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 functools

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

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return 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 sys

def test():
    args = sys.argv
    if 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函數或變量。