python第一類函數(shù) python第一節(jié)

python常用函數(shù)包有哪些？

一些python常用函數(shù)包：

創(chuàng)新新互聯(lián)，憑借十余年的網(wǎng)站設計制作、網(wǎng)站設計經驗，本著真心·誠心服務的企業(yè)理念服務于成都中小企業(yè)設計網(wǎng)站有1000+案例。做網(wǎng)站建設，選創(chuàng)新互聯(lián)。

1、Urllib3

Urllib3是一個 Python 的 HTTP 客戶端，它擁有 Python 標準庫中缺少的許多功能：

線程安全

連接池

客戶端 SSL/TLS 驗證

使用分段編碼上傳文件

用來重試請求和處理 HTTP 重定向的助手

支持 gzip 和 deflate 編碼

HTTP 和 SOCKS 的代理支持

2、Six

six 是一個是 Python 2 和 3 的兼容性庫。這個項目旨在支持可同時運行在 Python 2 和 3 上的代碼庫。它提供了許多可簡化 Python 2 和 3 之間語法差異的函數(shù)。

3、botocore、boto3、s3transfer、awscli

Botocore是 AWS 的底層接口。Botocore是 Boto3 庫（#22）的基礎，后者讓你可以使用 Amazon S3 和 Amazon EC2 一類的服務。Botocore 還是 AWS-CLI 的基礎，后者為 AWS 提供統(tǒng)一的命令行界面。

S3transfer（#7）是用于管理 Amazon S3 傳輸?shù)?Python 庫。它正在積極開發(fā)中，其介紹頁面不推薦人們現(xiàn)在使用，或者至少等版本固定下來再用，因為其 API 可能發(fā)生變化，在次要版本之間都可能更改。Boto3、AWS-CLI和其他許多項目都依賴s3transfer。

4、Pip

pip是“Pip Installs Packages”的首字母遞歸縮寫。

pip很容易使用。要安裝一個包只需pip install package name即可，而刪除包只需pip uninstall package name即可。

最大優(yōu)點之一是它可以獲取包列表，通常以requirements.txt文件的形式獲取。該文件能選擇包含所需版本的詳細規(guī)范。大多數(shù) Python 項目都包含這樣的文件。

如果結合使用pip與virtualenv（列表中的 #57），就可以創(chuàng)建可預測的隔離環(huán)境，同時不會干擾底層系統(tǒng)，反之亦然。

5、Python-dateutil

python-dateutil模塊提供了對標準datetime模塊的強大擴展。我的經驗是，常規(guī)的Python datetime缺少哪些功能，python-dateutil就能補足那一塊。

6、Requests

Requests建立在我們的 #1 庫——urllib3基礎上。它讓 Web 請求變得非常簡單。相比urllib3來說，很多人更喜歡這個包。而且使用它的最終用戶可能也比urllib3更多。后者更偏底層，并且考慮到它對內部的控制級別，它一般是作為其他項目的依賴項。

7、Certifi

近年來，幾乎所有網(wǎng)站都轉向 SSL，你可以通過地址欄中的小鎖符號來識別它。加了小鎖意味著與該站點的通信是安全和加密的，能防止竊聽行為。

8、Idna

根據(jù)其 PyPI 頁面，idna提供了“對 RFC5891 中指定的應用程序中國際化域名（IDNA）協(xié)議的支持?！?/p>

IDNA的核心是兩個函數(shù)：ToASCII和ToUnicode。ToASCII會將國際 Unicode 域轉換為 ASCII 字符串。ToUnicode則逆轉該過程。在IDNA包中，這些函數(shù)稱為idna.encode()和idna.decode()

9、PyYAML

YAML是一種數(shù)據(jù)序列化格式。它的設計宗旨是讓人類和計算機都能很容易地閱讀代碼——人類很容易讀寫它的內容，計算機也可以解析它。

PyYAML是 Python 的YAML解析器和發(fā)射器，這意味著它可以讀寫YAML。它會把任何 Python 對象寫成YAML：列表、字典，甚至是類實例都包括在內。

10、Pyasn1

像上面的IDNA一樣，這個項目也非常有用：

ASN.1 類型和 DER/BER/CER 編碼（X.208）的純 Python 實現(xiàn)

所幸這個已有數(shù)十年歷史的標準有很多信息可用。ASN.1是 Abstract Syntax Notation One 的縮寫，它就像是數(shù)據(jù)序列化的教父。它來自電信行業(yè)。也許你知道協(xié)議緩沖區(qū)或 Apache Thrift？這就是它們的 1984 年版本。

11、Docutils

Docutils是一個模塊化系統(tǒng)，用來將純文本文檔處理為很多有用的格式，例如 HTML、XML 和 LaTeX 等。Docutils能讀取reStructuredText格式的純文本文檔，這種格式是類似于 MarkDown 的易讀標記語法。

12、Chardet

你可以用chardet模塊來檢測文件或數(shù)據(jù)流的字符集。比如說，需要分析大量隨機文本時，這會很有用。但你也可以在處理遠程下載的數(shù)據(jù)，但不知道用的是什么字符集時使用它。

13、RSA

rsa包是一個純 Python 的 RSA 實現(xiàn)。它支持：

加密和解密

簽名和驗證簽名

根據(jù) PKCS#1 1.5 版生成密鑰

它既可以用作 Python 庫，也能在命令行中使用。

14、Jmespath

JMESPath，發(fā)音為“James path”，使 Python 中的 JSON 更容易使用。它允許你聲明性地指定如何從 JSON 文檔中提取元素。

15、Setuptools

它是用于創(chuàng)建 Python 包的工具。不過，其文檔很糟糕。它沒有清晰描述它的用途，并且文檔中包含無效鏈接。最好的信息源是這個站點，特別是這個創(chuàng)建 Python 包的指南。

16、Pytz

像dateutils一樣，這個庫可幫助你處理日期和時間。有時候，時區(qū)處理起來可能很麻煩。幸好有這樣的包，可以讓事情變得簡單些。

17、Futures

從 Python 3.2 開始，python 提供current.futures模塊，可幫助你實現(xiàn)異步執(zhí)行。futures 包是該庫適用于 Python 2 的 backport。它不適用于 Python3 用戶，因為 Python 3 原生提供了該模塊。

18、Colorama

使用 Colorama，你可以為終端添加一些顏色：

更多Python知識請關注Python自學網(wǎng)

Python 里為什么函數(shù)可以返回一個函數(shù)內部定義的函數(shù)

“在Python中，函數(shù)本身也是對象”

這一本質。那不妨慢慢來，從最基本的概念開始，討論一下這個問題：

1. Python中一切皆對象

這恐怕是學習Python最有用的一句話。想必你已經知道Python中的list, tuple, dict等內置數(shù)據(jù)結構，當你執(zhí)行：

alist = [1, 2, 3]

時，你就創(chuàng)建了一個列表對象，并且用alist這個變量引用它：

當然你也可以自己定義一個類:

class House(object):

def __init__(self, area, city):

self.area = area

self.city = city

def sell(self, price):

[...] #other code

return price

然后創(chuàng)建一個類的對象：

house = House(200, 'Shanghai')

OK，你立馬就在上海有了一套200平米的房子，它有一些屬性(area, city)，和一些方法(__init__, self)：

2. 函數(shù)是第一類對象

和list, tuple, dict以及用House創(chuàng)建的對象一樣，當你定義一個函數(shù)時，函數(shù)也是對象：

def func(a, b):

return a+b

在全局域，函數(shù)對象被函數(shù)名引用著，它接收兩個參數(shù)a和b，計算這兩個參數(shù)的和作為返回值。

所謂第一類對象，意思是可以用標識符給對象命名，并且對象可以被當作數(shù)據(jù)處理，例如賦值、作為參數(shù)傳遞給函數(shù)，或者作為返回值return 等

因此，你完全可以用其他變量名引用這個函數(shù)對象：

add = func

這樣，你就可以像調用func(1, 2)一樣，通過新的引用調用函數(shù)了：

print func(1, 2)

print add(1, 2) #the same as func(1, 2)

或者將函數(shù)對象作為參數(shù)，傳遞給另一個函數(shù)：

def caller_func(f):

return f(1, 2)

if __name__ == "__main__":

print caller_func(func)

可以看到，

函數(shù)對象func作為參數(shù)傳遞給caller_func函數(shù)，傳參過程類似于一個賦值操作f=func；

于是func函數(shù)對象，被caller_func函數(shù)作用域中的局部變量f引用，f實際指向了函數(shù)func；cc

當執(zhí)行return f(1, 2)的時候，相當于執(zhí)行了return func(1, 2)；

因此輸出結果為3。

3. 函數(shù)對象 vs 函數(shù)調用

無論是把函數(shù)賦值給新的標識符，還是作為參數(shù)傳遞給新的函數(shù)，針對的都是函數(shù)對象本身，而不是函數(shù)的調用。

用一個更加簡單，但從外觀上看，更容易產生混淆的例子來說明這個問題。例如定義了下面這個函數(shù)：

def func():

return "hello,world"

然后分別執(zhí)行兩次賦值：

ref1 = func #將函數(shù)對象賦值給ref1

ref2 = func() #調用函數(shù)，將函數(shù)的返回值("hello,world"字符串)賦值給ref2

很多初學者會混淆這兩種賦值，通過Python內建的type函數(shù)，可以查看一下這兩次賦值的結果：

In [4]: type(ref1)

Out[4]: function

In [5]: type(ref2)

Out[5]: str

可以看到，ref1引用了函數(shù)對象本身，而ref2則引用了函數(shù)的返回值。通過內建的callable函數(shù)，可以進一步驗證ref1是可調用的，而ref2是不可調用的：

In [9]: callable(ref1)

Out[9]: True

In [10]: callable(ref2)

Out[10]: False

傳參的效果與之類似。

4. 閉包LEGB法則

所謂閉包，就是將組成函數(shù)的語句和這些語句的執(zhí)行環(huán)境打包在一起時，得到的對象

聽上去的確有些復雜，還是用一個栗子來幫助理解一下。假設我們在foo.py模塊中做了如下定義：

#foo.py

filename = "foo.py"

def call_func(f):

return f() #如前面介紹的，f引用一個函數(shù)對象，然后調用它

在另一個func.py模塊中，寫下了這樣的代碼：

#func.py

import foo #導入foo.py

filename = "func.py"

def show_filename():

return "filename: %s" % filename

if __name__ == "__main__":

print foo.call_func(show_filename) #注意：實際發(fā)生調用的位置，是在foo.call_func函數(shù)中

當我們用python func.py命令執(zhí)行func.py時輸出結果為：

chiyu@chiyu-PC:~$ python func.py

filename:func.py

很顯然show_filename()函數(shù)使用的filename變量的值，是在與它相同環(huán)境(func.py模塊)中定義的那個。盡管foo.py模塊中也定義了同名的filename變量，而且實際調用show_filename的位置也是在foo.py的call_func內部。

而對于嵌套函數(shù)，這一機制則會表現(xiàn)的更加明顯：閉包將會捕捉內層函數(shù)執(zhí)行所需的整個環(huán)境：

#enclosed.py

import foo

def wrapper():

filename = "enclosed.py"

def show_filename():

return "filename: %s" % filename

print foo.call_func(show_filename) #輸出：filename: enclosed.py

實際上，每一個函數(shù)對象，都有一個指向了該函數(shù)定義時所在全局名稱空間的__globals__屬性：

#show_filename inside wrapper

#show_filename.__globals__

{

'__builtins__': module '__builtin__' (built-in), #內建作用域環(huán)境

'__file__': 'enclosed.py',

'wrapper': function wrapper at 0x7f84768b6578, #直接外圍環(huán)境

'__package__': None,

'__name__': '__main__',

'foo': module 'foo' from '/home/chiyu/foo.pyc', #全局環(huán)境

'__doc__': None

}

當代碼執(zhí)行到show_filename中的return "filename: %s" % filename語句時，解析器按照下面的順序查找filename變量：

Local - 本地函數(shù)(show_filename)內部，通過任何方式賦值的，而且沒有被global關鍵字聲明為全局變量的filename變量；

Enclosing - 直接外圍空間(上層函數(shù)wrapper)的本地作用域，查找filename變量(如果有多層嵌套，則由內而外逐層查找，直至最外層的函數(shù))；

Global - 全局空間(模塊enclosed.py)，在模塊頂層賦值的filename變量；

Builtin - 內置模塊(__builtin__)中預定義的變量名中查找filename變量；

在任何一層先找到了符合要求的filename變量，則不再向更外層查找。如果直到Builtin層仍然沒有找到符合要求的變量，則拋出NameError異常。這就是變量名解析的：LEGB法則。

總結：

閉包最重要的使用價值在于：封存函數(shù)執(zhí)行的上下文環(huán)境；

閉包在其捕捉的執(zhí)行環(huán)境(def語句塊所在上下文)中，也遵循LEGB規(guī)則逐層查找，直至找到符合要求的變量，或者拋出異常。

5. 裝飾器語法糖(syntax sugar)

那么閉包和裝飾器又有什么關系呢？

上文提到閉包的重要特性：封存上下文，這一特性可以巧妙的被用于現(xiàn)有函數(shù)的包裝，從而為現(xiàn)有函數(shù)更加功能。而這就是裝飾器。

還是舉個例子，代碼如下：

#alist = [1, 2, 3, ..., 100] -- 1+2+3+...+100 = 5050

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

我們定義了一個函數(shù)lazy_sum，作用是對alist中的所有元素求和后返回。alist假設為1到100的整數(shù)列表：

alist = range(1, 101)

但是出于某種原因，我并不想馬上返回計算結果，而是在之后的某個地方，通過顯示的調用輸出結果。于是我用一個wrapper函數(shù)對其進行包裝：

def wrapper():

alist = range(1, 101)

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函數(shù)對象

if __name__ == "__main__":

lazy_sum() #5050

這是一個典型的Lazy Evaluation的例子。我們知道，一般情況下，局部變量在函數(shù)返回時，就會被垃圾回收器回收，而不能再被使用。但是這里的alist卻沒有，它隨著lazy_sum函數(shù)對象的返回被一并返回了(這個說法不準確，實際是包含在了lazy_sum的執(zhí)行環(huán)境中，通過__globals__)，從而延長了生命周期。

當在if語句塊中調用lazy_sum()的時候，解析器會從上下文中(這里是Enclosing層的wrapper函數(shù)的局部作用域中)找到alist列表，計算結果，返回5050。

當你需要動態(tài)的給已定義的函數(shù)增加功能時，比如：參數(shù)檢查，類似的原理就變得很有用：

def add(a, b):

return a+b

這是很簡單的一個函數(shù)：計算a+b的和返回，但我們知道Python是 動態(tài)類型+強類型 的語言，你并不能保證用戶傳入的參數(shù)a和b一定是兩個整型，他有可能傳入了一個整型和一個字符串類型的值：

In [2]: add(1, 2)

Out[2]: 3

In [3]: add(1.2, 3.45)

Out[3]: 4.65

In [4]: add(5, 'hello')

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()

---- 1 add(5, 'hello')

/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)

1 def add(a, b):

---- 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是，解析器無情的拋出了一個TypeError異常。

動態(tài)類型：在運行期間確定變量的類型，python確定一個變量的類型是在你第一次給他賦值的時候；

強類型：有強制的類型定義，你有一個整數(shù)，除非顯示的類型轉換，否則絕不能將它當作一個字符串(例如直接嘗試將一個整型和一個字符串做+運算)；

因此，為了更加優(yōu)雅的使用add函數(shù)，我們需要在執(zhí)行+運算前，對a和b進行參數(shù)檢查。這時候裝飾器就顯得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):

return a + b

def checkParams(fn):

def wrapper(a, b):

if isinstance(a, (int, float)) and isinstance(b, (int, float)): #檢查參數(shù)a和b是否都為整型或浮點型

return fn(a, b) #是則調用fn(a, b)返回計算結果

#否則通過logging記錄錯誤信息，并友好退出

logging.warning("variable 'a' and 'b' cannot be added")

return

return wrapper #fn引用add，被封存在閉包的執(zhí)行環(huán)境中返回

if __name__ == "__main__":

#將add函數(shù)對象傳入，fn指向add

#等號左側的add，指向checkParams的返回值wrapper

add = checkParams(add)

add(3, 'hello') #經過類型檢查，不會計算結果，而是記錄日志并退出

注意checkParams函數(shù)：

首先看參數(shù)fn，當我們調用checkParams(add)的時候，它將成為函數(shù)對象add的一個本地(Local)引用；

在checkParams內部，我們定義了一個wrapper函數(shù)，添加了參數(shù)類型檢查的功能，然后調用了fn(a, b)，根據(jù)LEGB法則，解釋器將搜索幾個作用域，并最終在(Enclosing層)checkParams函數(shù)的本地作用域中找到fn；

注意最后的return wrapper，這將創(chuàng)建一個閉包，fn變量(add函數(shù)對象的一個引用)將會封存在閉包的執(zhí)行環(huán)境中，不會隨著checkParams的返回而被回收；

當調用add = checkParams(add)時，add指向了新的wrapper對象，它添加了參數(shù)檢查和記錄日志的功能，同時又能夠通過封存的fn，繼續(xù)調用原始的add進行+運算。

因此調用add(3, 'hello')將不會返回計算結果，而是打印出日志：

chiyu@chiyu-PC:~$ python func.py

WARNING:root:variable 'a' and 'b' cannot be added

有人覺得add = checkParams(add)這樣的寫法未免太過麻煩，于是python提供了一種更優(yōu)雅的寫法，被稱為語法糖：

@checkParams

def add(a, b):

return a + b

這只是一種寫法上的優(yōu)化，解釋器仍然會將它轉化為add = checkParams(add)來執(zhí)行。

6. 回歸問題

def addspam(fn):

def new(*args):

print "spam,spam,spam"

return fn(*args)

return new

@addspam

def useful(a,b):

print a**2+b**2

首先看第二段代碼：

@addspam裝飾器，相當于執(zhí)行了useful = addspam(useful)。在這里題主有一個理解誤區(qū)：傳遞給addspam的參數(shù)，是useful這個函數(shù)對象本身，而不是它的一個調用結果；

再回到addspam函數(shù)體：

return new 返回一個閉包，fn被封存在閉包的執(zhí)行環(huán)境中，不會隨著addspam函數(shù)的返回被回收；

而fn此時是useful的一個引用，當執(zhí)行return fn(*args)時，實際相當于執(zhí)行了return useful(*args)；

最后附上一張代碼執(zhí)行過程中的引用關系圖，希望能幫助你理解：

到底什么是Python？最好能和其他語言進行對比

Python 是一種解釋型語言。這就是說，與C 語言和C 的衍生語言不同，Python 代碼在運行之前不需要編譯。其他解釋型語言還包括PHP 和Ruby。

- Python 是動態(tài)類型語言，指的是你在聲明變量時，不需要說明變量的類型。你可以直接編寫類似x=111 和x="I’m a string"這樣的代碼，程序不會報錯。

- Python 非常適合面向對象的編程（OOP），因為它支持通過組合（composition）與繼承（inheritance）的方式定義類（class）。

- Python 中沒有訪問說明符（access specifier，類似C++中的public 和private），這么設計的依據(jù)是“大家都是成年人了”。

- 在Python 語言中，函數(shù)是第一類對象（first-class objects）。這指的是它們可以被指定給變量，函數(shù)既能返回函數(shù)類型，也可以接受函數(shù)作為輸入。類（class）也是第一類對象。

- Python 代碼編寫快，但是運行速度比編譯語言通常要慢。好在Python 允許加入基于C語言編寫的擴展，因此我們能夠優(yōu)化代碼，消除瓶頸，這點通常是可以實現(xiàn)的。numpy 就是一個很好地例子，它的運行速度真的非?？?，因為很多算術運算其實并不是通過Python 實現(xiàn)的。

- Python 用途非常廣泛——網(wǎng)絡應用，自動化，科學建模，大數(shù)據(jù)應用，等等。它也常被用作“膠水語言”，幫助其他語言和組件改善運行狀況。

- Python 讓困難的事情變得容易，因此程序員可以專注于算法和數(shù)據(jù)結構的設計，而不用處理底層的細節(jié)。

黑馬程序員含有全套的介紹，并且有和其他語言的對比。他們很多公開課也說過。我就是看黑馬的課學的Python，祝好

python 迭代器和生成器的區(qū)別

Num01–迭代器

定義：

對于list、string、tuple、dict等這些容器對象,使用for循環(huán)遍歷是很方便的。在后臺for語句對容器對象調用iter()函數(shù)。iter()是python內置函數(shù)。

iter()函數(shù)會返回一個定義了next()方法的迭代器對象，它在容器中逐個訪問容器內的元素。next()也是python內置函數(shù)。在沒有后續(xù)元素時，next()會拋出一個StopIteration異常，通知for語句循環(huán)結束。

迭代器是用來幫助我們記錄每次迭代訪問到的位置，當我們對迭代器使用next()函數(shù)的時候，迭代器會向我們返回它所記錄位置的下一個位置的數(shù)據(jù)。實際上，在使用next()函數(shù)的時候，調用的就是迭代器對象的_next_方法（Python3中是對象的_next_方法，Python2中是對象的next()方法）。所以，我們要想構造一個迭代器，就要實現(xiàn)它的_next_方法。但這還不夠，python要求迭代器本身也是可迭代的，所以我們還要為迭代器實現(xiàn)_iter_方法，而_iter_方法要返回一個迭代器，迭代器自身正是一個迭代器，所以迭代器的_iter_方法返回自身self即可。

一些術語的解釋：

1，迭代器協(xié)議：對象需要提供next()方法，它要么返回迭代中的下一項，要么就引起一個StopIteration異常，以終止迭代。

2，可迭代對象：實現(xiàn)了迭代器協(xié)議對象。list、tuple、dict都是Iterable（可迭代對象），但不是Iterator（迭代器對象）。但可以使用內建函數(shù)iter()，把這些都變成Iterable（可迭代器對象）。

3，for item in Iterable 循環(huán)的本質就是先通過iter()函數(shù)獲取可迭代對象Iterable的迭代器，然后對獲取到的迭代器不斷調用next()方法來獲取下一個值并將其賦值給item，當遇到StopIteration的異常后循環(huán)結束

Python自帶容器對象案例：

# 隨便定義一個listlistArray=[1,2,3]# 使用iter()函數(shù)iterName=iter(listArray)

print(iterName)# 結果如下：是一個列表list的迭代器# list_iterator object at 0x0000017B0D984278print(next(iterName))

print(next(iterName))

print(next(iterName))

print(next(iterName))#沒有迭代到下一個元素，直接拋出異常# 1# 2# 3# Traceback (most recent call last):# File "Test07.py", line 32, in module# StopIteration123456789101112131415161718

Python中一個實現(xiàn)了_iter_方法和_next_方法的類對象，就是迭代器，如下案例是計算菲波那切數(shù)列的案例

class Fib(object):

def __init__(self, max):

super(Fib, self).__init__()

self.max = max def __iter__(self):

self.a = 0

self.b = 1

return self def __next__(self):

fib = self.a if fib self.max: raise StopIteration

self.a, self.b = self.b, self.a + self.b return fib# 定義一個main函數(shù)，循環(huán)遍歷每一個菲波那切數(shù)def main():

# 20以內的數(shù)

fib = Fib(20) for i in fib:

print(i)# 測試if __name__ == '__main__':

main()12345678910111213141516171819202122232425262728

解釋說明：

在本類的實現(xiàn)中，定義了一個_iter_(self)方法，這個方法是在for循環(huán)遍歷時被iter()調用，返回一個迭代器。因為在遍歷的時候，是直接調用的python內置函數(shù)iter()，由iter()通過調用_iter_(self)獲得對象的迭代器。有了迭代器，就可以逐個遍歷元素了。而逐個遍歷的時候，也是使用內置的next(）函數(shù)通過調用對象的_next_(self)方法對迭代器對象進行遍歷。所以要實現(xiàn)_iter_(self)和_next_(self)這兩個方法。

而且因為實現(xiàn)了_next_(self)方法，所以在實現(xiàn)_iter_(self)的時候，直接返回self就可以。

總結一句話就是：

在循環(huán)遍歷自定義容器對象時,會使用python內置函數(shù)iter()調用遍歷對象的_iter_(self)獲得一個迭代器,之后再循環(huán)對這個迭代器使用next()調用迭代器對象的_next_(self)。

注意點：_iter_(self)只會被調用一次,而_next_(self)會被調用 n 次，直到出現(xiàn)StopIteration異常。

Num02–生成器

作用：

延遲操作。也就是在需要的時候才產生結果，不是立即產生結果。12

注意事項：

生成器是只能遍歷一次的。

生成器是一類特殊的迭代器。123

分類：

第一類：生成器函數(shù)：還是使用 def 定義函數(shù)，但是，使用yield而不是return語句返回結果。yield語句一次返回一個結果，在每個結果中間，掛起函數(shù)的狀態(tài)，以便下次從它離開的地方繼續(xù)執(zhí)行。

如下案例加以說明：

# 菲波那切數(shù)列def Fib(max):

n, a, b = 0, 0, 1

while n max: yield b

a, b = b, a + b

n = n + 1

return '親！沒有數(shù)據(jù)了...'# 調用方法，生成出10個數(shù)來f=Fib(10)# 使用一個循環(huán)捕獲最后return 返回的值，保存在異常StopIteration的value中while True: try:

x=next(f)

print("f:",x) except StopIteration as e:

print("生成器最后的返回值是：",e.value) break123456789101112131415161718

第二類：生成器表達式：類似于列表

，只不過是把一對大括號[]變換為一對小括號()。但是，生成器表達式是按需產生一個生成器結果對象，要想拿到每一個元素，就需要循環(huán)遍歷。

如下案例加以說明：

# 一個列表xiaoke=[2,3,4,5]# 生成器generator，類似于list，但是是把[]改為()gen=(a for a in xiaoke)for i in gen:

print(i)#結果是：2345# 為什么要使用生成器？因為效率。# 使用生成器表達式取代列表推導式可以同時節(jié)省 cpu 和 內存(RAM)。# 如果你構造一個列表(list)的目的僅僅是傳遞給別的函數(shù),# 比如 傳遞給tuple()或者set(), 那就用生成器表達式替代吧!# 本案例是直接把列表轉化為元組kk=tuple(a for a in xiaoke)

print(kk)#結果是：(2, 3, 4, 5)# python內置的一些函數(shù)，可以識別這是生成器表達式，外面有一對小括號，就是生成器result1=sum(a for a in range(3))

print(result1)# 列表推導式result2=sum([a for a in range(3)])

print(result2)

分享名稱：python第一類函數(shù) python第一節(jié)
網(wǎng)頁網(wǎng)址：http://muchs.cn/article20/doeehco.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站營銷、網(wǎng)站內鏈、品牌網(wǎng)站建設、品牌網(wǎng)站制作、虛擬主機、網(wǎng)站維護

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)