摘要：用匿名函數有個好處，因為函數沒有名字，不必擔心函數名沖突。和不同的是，把傳入的函數依次作用于每個元素，然后根據返回值是還是決定保留還是丟棄該元素。字符串給出當前平臺使用的行終止符。程序中間的退出，為正常退出。

列表生成式

函數的參數類型

lambda函數

map, reduce, filter, sorted函數

eval, exec, join, zip函數

itertools中的函數

copy與deepcopy函數

模塊

os、sys模塊

迭代器

生成器

迭代器

參考網站：

Python3教程： https://www.python-course.eu/...

Python之函數參數的使用：https://blog.csdn.net/jclian9...

廖雪峰Python教程: https://www.liaoxuefeng.com/w...

Python之淺談exec函數： https://blog.csdn.net/jclian9...

Python官網的itertools說明： https://docs.python.org/3.6/l...

Python-copy()與deepcopy()區別: https://blog.csdn.net/qq_3290...

copy模塊官網：https://docs.python.org/3.5/l...

列表生成式即List Comprehensions，是Python內置的非常簡單卻強大的可以用來創建list的生成式。一般是利用原有的數據結構來生成新的列表。

# 利用range()生成[1,2,...,9,10]
list(range(1,11))

# 生成[1x1, 2x2, 3x3, ..., 10x10]
[x * x for x in range(1, 11)]
# 可以通過占位符_代表列表中的元素
[_*_ for _ in range(1,11)]

# 篩選出僅偶數的平方, 在for循環后加上if判斷語句
[x * x for x in range(1, 11) if x % 2 == 0]
# 利用占位符簡化
[_*_ for _ in range(1, 11) if not _%2]

# 兩層循環，三層循環，....
[m + n for m in "ABC" for n in "XYZ"]
[x+y+z for x in  "ab" for y in "cd" for z in "ef"]

# 遍歷字典，生成列表
d = {"x": "A", "y": "B", "z": "C" }
[k + "=" + v for k, v in d.items()]

在Python中定義函數，其參數類型有：

位置參數

默認參數

可變參數

關鍵字參數

這4種參數都可以一起使用，或者只用其中某些，但是請注意，參數定義的順序必須是：位置參數、默認參數、可變參數和關鍵字參數。

可變參數以*開頭，允許傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。關鍵字參數以**開頭，允許傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個dict。若默認參數與可變參數放在一起，則接受完默認參數后，其后參數為可變參數。

位置參數指定名稱的必須放在未指定名稱的后面

def person(name,age,city):
    s = "info: name=%s, age=%s, city=%s"%(name,age,city)
    return s

print(person("Jack", 25, "NY"))
print(person(name="Jack", age=25, city="NY"))
print(person("Jack", 25, city="NY"))
# 下面的參數使用有誤，位置參數指定名稱的必須放在未指定名稱的后面
print(person(name="Jack", 25, "NY"))

默認參數必須放在非默認參數的后面,可以該表默認參數的值

def person(name, city, age=18):
    s = "info: name=%s, age=%s, city=%s"%(name,age,city)
    return s

print(person("Jack", "NY"))
print(person("Jack", "NY", 20))

可變參數以*開頭，允許傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。函數參數的長度是可以變化的， 例如內置的sum, min, max等

def var_sum(*args):
    sum = 0
    for i in args:
        sum += i

    return sum

print(var_sum(1,2,3))
print(var_sum(1,2,3,4))
# 利用*號來分解參數
print(var_sum(*[1,2,3,4,5]))

若位置參數或默認參數與可變參數放在一起，則接受完位置參數或默認參數后，其后參數為可變參數。

def var_sum(a, *args):
    sum = 0
    for i in args:
        sum += i

    print("a is %s, sum is %s"%(a,sum))

var_sum(1,2)
var_sum(1,2,3)

關鍵字參數以**開頭，允許傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個dict。

def test_args(**kwargs):
    print("-"*20)
    for key in kwargs:
        print("key:", key, ",value:", kwargs[key])

    print()

test_args(a=1,b=2)
test_args(a=1,b=2,c=3)

lambda函數即為匿名函數，用關鍵字lambda表示，冒號（：）前面的為參數，后面為返回值,不用寫return.

如：

lambda x: x*x

匿名函數有個限制，就是只能有一個表達式，一般一行代碼，不用寫return，返回值就是該表達式的結果。

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

f = lambda x: x*x
f(5)

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

可以直接作用于for循環的對象統稱為可迭代對象：Iterable.

舉例說明，比如我們有一個函數f(x)=x^2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：

# map函數： 一一映射
def f(x):
    return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(r)

# 利用lambda簡化上述代碼

list(map(lambda x: x*x, range(1, 11)))

再例如： 把list所有數字轉為字符串：

list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

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

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方說對一個序列求和，就可以用reduce實現：

# 導入reduce, 這很重要
from functools import reduce

def add(x, y):
    return x + y

reduce(add, [1, 3, 5, 7, 9])

# 利用lambda函數簡化
reduce(lambda x,y: x+y, range(1,10,2))

作業： 利用reduce將序列[1, 3, 5, 7, 9]轉化為整數13579.

map, reduce的一個復雜例子：

將字符串列表["1", "3", "5", "7", "9"]轉化為整數13579

from functools import reduce

a = ["1", "3", "5", "7", "9"]
t = reduce(lambda x,y: 10*x+y, map(int, a))
print(t)

Python內建的filter()函數用于過濾序列。

和map()類似，filter()也接收一個函數和一個序列。和map()不同的是，filter()把傳入的函數依次作用于每個元素，然后根據返回值是True還是False決定保留還是丟棄該元素。

例如，在一個list中，刪掉偶數，只保留奇數，可以這么寫：

list(filter(lambda x: x%2 == 1, [1, 2, 4, 5, 6, 9, 10, 15]))

Python內置的sorted()函數就可以對list進行排序。

sorted([36, 5, -12, 9, -21])

此外，sorted()函數還可以接收一個key函數來實現自定義的排序，例如按絕對值大小排序：

sorted([36, 5, -12, 9, -21], key=abs)
sorted(["bob", "about", "Zoo", "Credit"], key=str.lower, reverse=True)

高階函數，就是讓函數的參數能夠接收別的函數。map, reduce, filter, sorted都是高階函數。

Python中的join函數有兩個，分別為: join()和os.path.join()，具體作用如下：

join()： 連接字符串數組。將字符串、元組、列表中的元素以指定的字符(分隔符)連接生成一個新的字符串

os.path.join()： 將多個路徑組合后返回

字符串中的join()函數的使用方法：

"sep".join(seq)

sep：分隔符?？梢詾榭铡?seq：要連接的元素序列。 返回一個新的字符串。

seq = ["hello","good","boy","Dido"]

print(" ".join(seq))
print("*".join(seq))

zip() 函數用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。

如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。

# basic use of zip
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))

# zip for loops
for i,j in zip(x,y):
    print(i, "->", j)

# unzip the list
a = [(1,2,3), (3,4,5)]
x2, y2, z2 = zip(*a)
print(x2)
print(y2)
print(z2)

# transpose a matrix
mtx = [(1, 2),
       (3, 4),
       (5, 6)]
print(list(zip(*mtx)))

# clustering a data series into n-length groups idiom
seq = range(1, 10)
print(list(zip(*[iter(seq)]*3)))

# dict and zip
keys = ["spam", "eggs"]
vals = [42, 1729]
d = dict(zip(keys, vals))
print(d)

eval函數用來計算字符串表達式的值

t = eval("23")
print(t)
print(type(t))

print(eval("(1+2)*(3+4)"))

exec()是Python的內置函數，不同于eval()函數只能執行計算數學表達式的結果的功能，exec()能夠動態地執行復雜的Python代碼，能夠十分強大。

簡單例子：

# 執行簡單的Python語句
i = 12
j = 13
exec("answer=i*j")
print("Answer is %s"%answer)

# 執行復雜的Python語句
func = "def fact(n):
	return 1 if n==1 else n*fact(n-1)"
exec(func)
a = fact(5)
print(a)

exec函數還可以執行儲存在其他文件中的Python代碼，例如位于E盤的eg.txt,如下：

def fact(n):
    if n==1:
        return 1
    else:
        return n*fact(n-1)
t = fact(6)
print(t)

利用exec函數執行eg.txt中的代碼：

with open("E://eg.txt", "r") as f:
    s = f.read()

exec(s)

還可以在exec()函數中加入參數,參數的傳遞可以寫成字典(dict)形式。

x = 10

expr = """
z = 30
sum = x + y + z
print(sum)
"""

def func():
    y = 20
    exec(expr)
    exec(expr, {"x": 1, "y": 2})
    exec(expr, {"x": 1, "y": 2}, {"y": 3, "z": 4})

func()

輸出結果為：

60 
33 
34

Python的內建模塊itertools提供了非常有用的用于操作迭代對象的函數。

itertools模塊提供的全部是處理迭代功能的函數，它們的返回值不是list，而是Iterator，只有用for循環迭代的時候才真正計算。

groupby()函數

groupby()把迭代器中相鄰的重復元素挑出來放在一起：

for key, group in itertools.groupby("AAABBBCCAAA"):
     print(key, list(group))

A ["A", "A", "A"]
B ["B", "B", "B"]
C ["C", "C"]
A ["A", "A", "A"]

實際上挑選規則是通過函數完成的，只要作用于函數的兩個元素返回的值相等，這兩個元素就被認為是在一組的，而函數返回值作為組的key。

另一個例子

# 按身高歸類
from itertools import *

def height_class(h):
    if h>180:
        return "tall"
    elif h<160:
        return "short"
    else:
        return "middle"

friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]

for m,n in groupby(friends,key = height_class):
    print(m)
    print(list(n))

作業： 對于一組身高的數據（list），利用上面代碼給出的身高標準，將所以的tall, short, middle歸為一類。注意與groupby()函數的區別。

tee()函數

把一個迭代器分為n個迭代器, 返回一個元組.默認是兩個

from itertools import *
a = "hello"
c, d, e = tee(iter(a), 3)
for i, j, k in zip(c, d, e):
    print(i, j, k)

copy: 淺拷貝(shallow copy), deepcopy: 深拷貝(deep copy).

我們尋常意義的復制就是深復制，即將被復制對象完全再復制一遍作為獨立的新個體多帶帶存在。所以改變原有被復制對象不會對已經復制出來的新對象產生影響。
而淺復制并不會產生一個獨立的對象多帶帶存在，他只是將原有的數據塊打上一個新標簽，所以當其中一個標簽被改變的時候，數據塊就會發生變化，另一個標簽也會隨之改變。這就和我們尋常意義上的復制有所不同了。
對于簡單的 object，用 shallow copy 和 deep copy 沒區別
復雜的 object， 如 list 中套著 list 的情況，shallow copy 中的 子list，并未從原 object 真的「獨立」出來。也就是說，如果你改變原 object 的子 list 中的一個元素，你的 copy 就會跟著一起變。這跟我們直覺上對「復制」的理解不同。

例子：

from copy import copy, deepcopy

#origin 里邊有三個元素：1,2,[3, 4]
origin = [1, 2, [3, 4]]

# cop1為淺拷貝，cop2為深拷貝
cop1 = copy(origin)
cop2 = deepcopy(origin)

# cop1是否與cop2內容相同
print(cop1 == cop2)
# cop1是否與cop2為同一個引用
print(cop1 is cop2)

# 改變origin中嵌套列表中的元素
origin[2][0] = "hey"

# 查看輸出
print(origin)
print(cop1)
print(cop2)

# 改變origin中嵌套列表中的元素
origin[1] = "hello"

# 查看輸出
print(origin)
print(cop1)
print(cop2)

輸出結果：

True
False
[1, 2, ["hey", 4]]
[1, 2, ["hey", 4]]
[1, 2, [3, 4]]
[1, "hello", ["hey", 4]]
[1, 2, ["hey", 4]]
[1, 2, [3, 4]]

在Python中，一個Python文件就是一個模塊。

模塊讓你能夠有邏輯地組織你的 Python 代碼段。

把相關的代碼分配到一個模塊里能讓你的代碼更好用，更易懂。

模塊能定義函數，類和變量，模塊里也能包含可執行的代碼。

一個簡單的模塊例子：

hello.py

def say_hello(name):
    s = "hello, %s!"%name
    return s

使用模塊：

import module

from module import ...

import hello

print(hello.say_hello("Lee"))

from hello import say_hello

print(say_hello("Jack"))

os模塊包含普遍的操作系統功能。

os.sep 可以取代操作系統特定的路徑分隔符。windows下為 “”
os.name字符串指示你正在使用的平臺。比如對于Windows，它是"nt"，而對于Linux/Unix用戶，它是"posix"。

os.getcwd() 函數得到當前工作目錄，即當前Python腳本工作的目錄路徑。

os.getenv() 獲取一個環境變量，如果沒有返回none

os.putenv(key, value) 設置一個環境變量值

os.listdir(path) 返回指定目錄下的所有文件和目錄名。

os.remove(path) 函數用來刪除一個文件。

os.system(command) 函數用來運行shell命令。

os.linesep 字符串給出當前平臺使用的行終止符。例如，Windows使用"rn"，Linux使用"n"而Mac使用"r"。

os.curdir: 返回當前目錄（".")

os.chdir(dirname): 改變工作目錄到dirname

os.path.isfile()和os.path.isdir()函數分別檢驗給出的路徑是一個文件還是目錄。

os.path.existe()函數用來檢驗給出的路徑是否真地存在

os.path.getsize(name):獲得文件大小，如果name是目錄返回0L

os.path.abspath(name):獲得絕對路徑
os.path.normpath(path):規范path字符串形式

os.path.split(path) ：將path分割成目錄和文件名二元組返回。

os.path.splitext():分離文件名與擴展名

os.path.join(path,name):連接目錄與文件名或目錄;使用“”連接
os.path.basename(path):返回文件名
os.path.dirname(path):返回文件路徑

sys模塊提供了一系列有關Python運行環境的變量和函數。

sys.argv: 實現從終端向程序傳遞參數。

sys.exit([arg]): 程序中間的退出，arg=0為正常退出。

sys.getdefaultencoding(): 獲取系統當前編碼，一般默認為ascii。

sys.setdefaultencoding(): 設置系統默認編碼，執行dir（sys）時不會看到這個方法，在解釋器中執行不通過，可以先執行reload(sys)，在執行 setdefaultencoding("utf8")，此時將系統默認編碼設置為utf8。（見設置系統默認編碼 ）

sys.getfilesystemencoding(): 獲取文件系統使用編碼方式，Windows下返回"mbcs"，mac下返回"utf-8".

sys.path: 獲取指定模塊搜索路徑的字符串集合，可以將寫好的模塊放在得到的某個路徑下，就可以在程序中import時正確找到。

sys.platform: 獲取當前系統平臺。

sys.stdin, sys.stdout, sys.stderr: stdin , stdout , 以及stderr 變量包含與標準I/O 流對應的流對象. 如果需要更好地控制輸出,而print 不能滿足你的要求, 它們就是你所需要的. 你也可以替換它們, 這時候你就可以重定向輸出和輸入到其它設備( device ), 或者以非標準的方式處理它們

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

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

創建generator的辦法：

把一個列表生成式的[]改成()

yield關鍵字

# 列表生成式
L = [x * x for x in range(10)]
print(type(L))

# 創建生成器
g = (x * x for x in range(10))
print(type(g))

# 獲取下一個返回值
# 當沒有更多元素時，會拋出StopIteration錯誤
print(next(g))
print(next(g))
print(next(g))

# for循環
for n in g:
    print(n)

# 普通方法生成斐波拉契數列
# 前幾個斐波拉契數
def fib1(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return "done"

fib1(6)

# 通過yield創建生成器
# 注意yield的執行流程
def fib2(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return "done"

# 將生成器函數賦值給變量f
f = fib2(6)
print(type(f))
for n in f:
    print(n)

generator和函數的執行流程不一樣。函數是順序執行，遇到return語句或者最后一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

def odd():
    print("step 1")
    yield 1
    print("step 2")
    yield(3)
    print("step 3")
    yield(5)

o = odd()

print(next(o))
print(next(o))
print(next(o))

可以直接作用于for循環的數據類型有以下幾種：

集合數據類型，如list、tuple、dict、set、str等；

generator，包括生成器和帶yield的generator function。

這些可以直接作用于for循環的對象統稱為可迭代對象：==Iterable==。

可以使用isinstance()判斷一個對象是否是Iterable對象：

from collections import Iterable

# 判斷空列表是否為Iterable對象
# True
print(isinstance([], Iterable))

# 判斷空集合是否為Iterable對象
# True
print(isinstance({}, Iterable))

# 判斷字符是否為Iterable對象
# True
print(isinstance("abc", Iterable))

# 判斷生成器是否為Iterable對象
# True
print(isinstance((x for x in range(10)), Iterable))

# 判斷數字否為Iterable對象
# False
print(isinstance(100, Iterable))

可以被next()函數調用并不斷返回下一個值的對象稱為迭代器：Iterator。

可以使用isinstance()判斷一個對象是否是Iterator對象：

from collections import Iterator

# 判斷生成器是否為Iterator對象
# True
print(isinstance((x for x in range(10)), Iterator))

# 判斷空列表是否為Iterator對象
# False
print(isinstance([], Iterator))

# 判斷空集合是否為Iterator對象
# False
print(isinstance({}, Iterator))

# 判斷字符串是否為Iterator對象
# False
print(isinstance("abc", Iterator))

生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator。

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