摘要：用匿名函數(shù)有個(gè)好處，因?yàn)楹瘮?shù)沒有名字，不必?fù)?dān)心函數(shù)名沖突。和不同的是，把傳入的函數(shù)依次作用于每個(gè)元素，然后根據(jù)返回值是還是決定保留還是丟棄該元素。字符串給出當(dāng)前平臺(tái)使用的行終止符。程序中間的退出，為正常退出。

列表生成式

函數(shù)的參數(shù)類型

lambda函數(shù)

map, reduce, filter, sorted函數(shù)

eval, exec, join, zip函數(shù)

itertools中的函數(shù)

copy與deepcopy函數(shù)

模塊

os、sys模塊

迭代器

生成器

迭代器

參考網(wǎng)站：

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

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

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

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

Python官網(wǎng)的itertools說明： https://docs.python.org/3.6/l...

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

copy模塊官網(wǎng)：https://docs.python.org/3.5/l...

列表生成式即List Comprehensions，是Python內(nèi)置的非常簡單卻強(qiáng)大的可以用來創(chuàng)建list的生成式。一般是利用原有的數(shù)據(jù)結(jié)構(gòu)來生成新的列表。

# 利用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)]

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

# 兩層循環(huán)，三層循環(huán)，....
[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中定義函數(shù)，其參數(shù)類型有：

位置參數(shù)

默認(rèn)參數(shù)

可變參數(shù)

關(guān)鍵字參數(shù)

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

可變參數(shù)以*開頭，允許傳入0個(gè)或任意個(gè)參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時(shí)自動(dòng)組裝為一個(gè)tuple。關(guān)鍵字參數(shù)以**開頭，允許傳入0個(gè)或任意個(gè)參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時(shí)自動(dòng)組裝為一個(gè)dict。若默認(rèn)參數(shù)與可變參數(shù)放在一起，則接受完默認(rèn)參數(shù)后，其后參數(shù)為可變參數(shù)。

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

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"))
# 下面的參數(shù)使用有誤，位置參數(shù)指定名稱的必須放在未指定名稱的后面
print(person(name="Jack", 25, "NY"))

默認(rèn)參數(shù)必須放在非默認(rèn)參數(shù)的后面,可以該表默認(rèn)參數(shù)的值

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

可變參數(shù)以*開頭，允許傳入0個(gè)或任意個(gè)參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時(shí)自動(dòng)組裝為一個(gè)tuple。函數(shù)參數(shù)的長度是可以變化的， 例如內(nèi)置的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))
# 利用*號(hào)來分解參數(shù)
print(var_sum(*[1,2,3,4,5]))

若位置參數(shù)或默認(rèn)參數(shù)與可變參數(shù)放在一起，則接受完位置參數(shù)或默認(rèn)參數(shù)后，其后參數(shù)為可變參數(shù)。

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)

關(guān)鍵字參數(shù)以**開頭，允許傳入0個(gè)或任意個(gè)參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時(shí)自動(dòng)組裝為一個(gè)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函數(shù)即為匿名函數(shù)，用關(guān)鍵字lambda表示，冒號(hào)（：）前面的為參數(shù)，后面為返回值,不用寫return.

如：

lambda x: x*x

匿名函數(shù)有個(gè)限制，就是只能有一個(gè)表達(dá)式，一般一行代碼，不用寫return，返回值就是該表達(dá)式的結(jié)果。

用匿名函數(shù)有個(gè)好處，因?yàn)楹瘮?shù)沒有名字，不必?fù)?dān)心函數(shù)名沖突。此外，匿名函數(shù)也是一個(gè)函數(shù)對(duì)象，也可以把匿名函數(shù)賦值給一個(gè)變量，再利用變量來調(diào)用該函數(shù)，即函數(shù)也是變量，此為函數(shù)式編程(functional programming)思想。

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

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

可以直接作用于for循環(huán)的對(duì)象統(tǒng)稱為可迭代對(duì)象：Iterable.

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

# map函數(shù)： 一一映射
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所有數(shù)字轉(zhuǎn)為字符串：

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

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

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

比方說對(duì)一個(gè)序列求和，就可以用reduce實(shí)現(xiàn)：

# 導(dǎo)入reduce, 這很重要
from functools import reduce

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

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

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

作業(yè)： 利用reduce將序列[1, 3, 5, 7, 9]轉(zhuǎn)化為整數(shù)13579.

map, reduce的一個(gè)復(fù)雜例子：

將字符串列表["1", "3", "5", "7", "9"]轉(zhuǎn)化為整數(shù)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內(nèi)建的filter()函數(shù)用于過濾序列。

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

例如，在一個(gè)list中，刪掉偶數(shù)，只保留奇數(shù)，可以這么寫：

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

Python內(nèi)置的sorted()函數(shù)就可以對(duì)list進(jìn)行排序。

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

此外，sorted()函數(shù)還可以接收一個(gè)key函數(shù)來實(shí)現(xiàn)自定義的排序，例如按絕對(duì)值大小排序：

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

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

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

join()： 連接字符串?dāng)?shù)組。將字符串、元組、列表中的元素以指定的字符(分隔符)連接生成一個(gè)新的字符串

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

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

"sep".join(seq)

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

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

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

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

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

# 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函數(shù)用來計(jì)算字符串表達(dá)式的值

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

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

exec()是Python的內(nèi)置函數(shù)，不同于eval()函數(shù)只能執(zhí)行計(jì)算數(shù)學(xué)表達(dá)式的結(jié)果的功能，exec()能夠動(dòng)態(tài)地執(zhí)行復(fù)雜的Python代碼，能夠十分強(qiáng)大。

簡單例子：

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

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

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

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

利用exec函數(shù)執(zhí)行eg.txt中的代碼：

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

exec(s)

還可以在exec()函數(shù)中加入?yún)?shù),參數(shù)的傳遞可以寫成字典(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()

輸出結(jié)果為：

60 
33 
34

Python的內(nèi)建模塊itertools提供了非常有用的用于操作迭代對(duì)象的函數(shù)。

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

groupby()函數(shù)

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

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

實(shí)際上挑選規(guī)則是通過函數(shù)完成的，只要作用于函數(shù)的兩個(gè)元素返回的值相等，這兩個(gè)元素就被認(rèn)為是在一組的，而函數(shù)返回值作為組的key。

另一個(gè)例子

# 按身高歸類
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))

作業(yè)： 對(duì)于一組身高的數(shù)據(jù)（list），利用上面代碼給出的身高標(biāo)準(zhǔn)，將所以的tall, short, middle歸為一類。注意與groupby()函數(shù)的區(qū)別。

tee()函數(shù)

把一個(gè)迭代器分為n個(gè)迭代器, 返回一個(gè)元組.默認(rèn)是兩個(gè)

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

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

例子：

from copy import copy, deepcopy

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

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

# cop1是否與cop2內(nèi)容相同
print(cop1 == cop2)
# cop1是否與cop2為同一個(gè)引用
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)

輸出結(jié)果：

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中，一個(gè)Python文件就是一個(gè)模塊。

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

把相關(guān)的代碼分配到一個(gè)模塊里能讓你的代碼更好用，更易懂。

模塊能定義函數(shù)，類和變量，模塊里也能包含可執(zhí)行的代碼。

一個(gè)簡單的模塊例子：

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模塊包含普遍的操作系統(tǒng)功能。

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

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

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

os.putenv(key, value) 設(shè)置一個(gè)環(huán)境變量值

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

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

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

os.linesep 字符串給出當(dāng)前平臺(tái)使用的行終止符。例如，Windows使用"rn"，Linux使用"n"而Mac使用"r"。

os.curdir: 返回當(dāng)前目錄（".")

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

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

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

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

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

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

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

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

sys模塊提供了一系列有關(guān)Python運(yùn)行環(huán)境的變量和函數(shù)。

sys.argv: 實(shí)現(xiàn)從終端向程序傳遞參數(shù)。

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

sys.getdefaultencoding(): 獲取系統(tǒng)當(dāng)前編碼，一般默認(rèn)為ascii。

sys.setdefaultencoding(): 設(shè)置系統(tǒng)默認(rèn)編碼，執(zhí)行dir（sys）時(shí)不會(huì)看到這個(gè)方法，在解釋器中執(zhí)行不通過，可以先執(zhí)行reload(sys)，在執(zhí)行 setdefaultencoding("utf8")，此時(shí)將系統(tǒng)默認(rèn)編碼設(shè)置為utf8。（見設(shè)置系統(tǒng)默認(rèn)編碼 ）

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

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

sys.platform: 獲取當(dāng)前系統(tǒng)平臺(tái)。

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

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

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

創(chuàng)建generator的辦法：

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

yield關(guān)鍵字

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

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

# 獲取下一個(gè)返回值
# 當(dāng)沒有更多元素時(shí)，會(huì)拋出StopIteration錯(cuò)誤
print(next(g))
print(next(g))
print(next(g))

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

# 普通方法生成斐波拉契數(shù)列
# 前幾個(gè)斐波拉契數(shù)
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創(chuàng)建生成器
# 注意yield的執(zhí)行流程
def fib2(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return "done"

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

generator和函數(shù)的執(zhí)行流程不一樣。函數(shù)是順序執(zhí)行，遇到return語句或者最后一行函數(shù)語句就返回。而變成generator的函數(shù)，在每次調(diào)用next()的時(shí)候執(zhí)行，遇到y(tǒng)ield語句返回，再次執(zhí)行時(shí)從上次返回的yield語句處繼續(xù)執(zhí)行。

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循環(huán)的數(shù)據(jù)類型有以下幾種：

集合數(shù)據(jù)類型，如list、tuple、dict、set、str等；

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

這些可以直接作用于for循環(huán)的對(duì)象統(tǒng)稱為可迭代對(duì)象：==Iterable==。

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

from collections import Iterable

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

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

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

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

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

可以被next()函數(shù)調(diào)用并不斷返回下一個(gè)值的對(duì)象稱為迭代器：Iterator。

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

from collections import Iterator

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

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

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

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

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

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