日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Python中的3個“黑魔法”與“騷操作”

【稿件】本文主要介紹Python的高級特性：列表推導式、迭代器和生成器，是面試中經(jīng)常會被問到的特性。因為生成器實現(xiàn)了迭代器協(xié)議，可由列表推導式來生成，所有，這三個概念作為一章來介紹，是最便于大家理解的，現(xiàn)在看不懂沒關系，下面我不僅是會讓大家知其然，重要的更是要知其所以然。

創(chuàng)新互聯(lián)建站于2013年成立，是專業(yè)互聯(lián)網(wǎng)技術服務公司，擁有項目網(wǎng)站設計、成都網(wǎng)站建設網(wǎng)站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元西秀做網(wǎng)站,已為上家服務,為西秀各地企業(yè)和個人服務,聯(lián)系電話:028-86922220

列表推導式

前幾天有個HR讓我談談列表推導式，我說這我經(jīng)常用，就是用舊的列表生成一個新的列表的公式，他直接就把我拒了，讓我回去復習一下，挺受打擊的，所以決定也幫助大家回顧一下。

內容：

  • 列表推導式：舊的列表->新的列表
  • 了解：字典推導式 集合推導式

1.列表推導式：

格式 [表達式 for 變量 in 舊列表]

或 [表達式 for 變量 in 舊列表 if 條件]

例1：生成名字長度大于3且首字母大寫的新列表。

 
 
 
 
    
  
  
  
  
  1. names_old = ['tom', 'amy', 'daming', 'lingling'] 
    2.   
  
  
  
  2. names_new = [name.capitalize() for name in names_old if len(name) > 3] 
    3.   
  
  
  
  3. print(names_new) 
    4.

輸出：

 
 
 
 
    
  
  
  
  
  1. ['Daming', 'Lingling'] 
    2.

例2： (大廠初級筆試題目)生成一個元組列表，要求每個元素為(0-5偶數(shù)，0-10奇數(shù))形式。輸出結果為：

 
 
 
 
    
  
  
  
  
  1. [(0, 1), (0, 3), (0, 5), (0, 7), (0, 9), (2, 1), (2, 3), (2, 5), (2, 7), (2, 9), (4, 1), (4, 3), (4, 5), (4, 7), (4, 9)] 
    2.

for循環(huán)實現(xiàn)代碼：

 
 
 
 
    
  
  
  
  
  1. new_list = list() 
    2.   
  
  
  
  2. for i in range(5):  # 偶數(shù) 
    3.   
  
  
  
  3.     if i % 2 == 0: 
    4.   
  
  
  
  4.         for j in range(10):  # 奇數(shù) 
    5.   
  
  
  
  5.             if j % 2 != 0: 
    6.   
  
  
  
  6.                 new_list.append((i, j)) 
    7.

列表推導式代碼：

 
 
 
 
    
  
  
  
  
  1. new_list = [(i, j) for i in range(5) for j in range(10) if i % 2 == 0 and j % 2 != 0] 
    2.

例3：(大廠初級筆試題目)給出一個員工列表：

 
 
 
 
    
  
  
  
  
  1. employees_old = [{'name': "tmo", "salary": 4800}, 
    2.   
  
  
  
  2.                  {'name': "amy", "salary": 3800}, 
    3.   
  
  
  
  3.                  {'name': "daming", "salary": 7000}, 
    4.   
  
  
  
  4.                  {'name': "lingling", "salary": 5600}]  
    5.

如果員工薪資大于5000則加200，否則加500，輸出新的員工列表。

列表推導式：

 
 
 
 
    
  
  
  
  
  1. employees_new = [employee['salary'] + 200 if employee['salary'] > 5000 else employee['salary'] + 500 for employee in employees_old] 
    2.   
  
  
  
  2. print(employees_new) 
    3.

輸出：

 
 
 
 
    
  
  
  
  
  1. [5300, 4300, 7200, 5800] 
    2.

發(fā)現(xiàn)結果是員工薪資列表，回過頭看一下代碼，確實是把得到的數(shù)字給了列表，那要返回員工列表要怎么實現(xiàn)呢?

讓我們用普通for循環(huán)的方式來進行一下對比：

 
 
 
 
    
  
  
  
  
  1. for employee in employees_old: 
    2.   
  
  
  
  2.     if employee['salary'] > 5000: 
    3.   
  
  
  
  3.         employee['salary'] += 200 
    4.   
  
  
  
  4.     else: 
    5.   
  
  
  
  5.         employee['salary'] += 500 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. print(employees_old) 
    8.

輸出：

 
 
 
 
    
  
  
  
  
  1. [{'name': 'tmo', 'salary': 5300}, {'name': 'amy', 'salary': 4300}, {'name': 'daming', 'salary': 7200}, {'name': 'lingling', 'salary': 5800}] 
    2.

沒錯，我們注意到兩者的差別了，列表推導式我們少了一步賦值(在字典元素上進行賦值)，不能直接返回一個薪資數(shù)值而是一個員工字典給列表。

正確的列表推導式如下：

 
 
 
 
    
  
  
  
  
  1. employees_new = [ 
    2.   
  
  
  
  2.     {'name': employee['name'], 'salary': employee['salary'] + 200} if employee['salary'] > 5000 else 
    3.   
  
  
  
  3.     {'name': employee['name'], 'salary': employee['salary'] + 500} for employee in employees_old] 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. print(employees_new) 
    6.

2.字典推導式：

例1：

 
 
 
 
    
  
  
  
  
  1. dict_old = {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'C'} 
    2.   
  
  
  
  2. dict_new = {value: key for key, value in dict_old.items()} 
    3.   
  
  
  
  3. print(dict_new) 
    4.

輸出：

 
 
 
 
    
  
  
  
  
  1. {'A': 'a', 'B': 'b', 'C': 'd'} 
    2.

3.集合推導式：

類似列表推導式 典型用法：去重

例1：

 
 
 
 
    
  
  
  
  
  1. list_old = [1, 2, 3, 5, 2, 3] 
    2.   
  
  
  
  2. set_new = {x for x in list_old} 
    3.   
  
  
  
  3. print(set_new) 
    4.

輸出：

 
 
 
 
    
  
  
  
  
  1. {1, 2 ,3, 5} 
    2.

小結：到目前為止，列表推導式不就是一個用來創(chuàng)建列表的式子么?除了可以簡化代碼，裝裝X?其實，列表推導式還有另一個優(yōu)點是相比于for循環(huán)更高效，因為列表推導式在執(zhí)行時調用的是Python的底層C代碼，而for循環(huán)則是用Python代碼來執(zhí)行。嗷~面試官最想聽到的，是第二點。

迭代器

由于迭代器協(xié)議對很多人來說，是一個較為抽象的概念，而且生成器自動實現(xiàn)了迭代器協(xié)議，所以我們需要先講解一下迭代器協(xié)議的概念，也是為了更好的理解接下來的生成器。

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

迭代是訪問集合元素的一種方式，迭代器是一個可以記住遍歷位置的對象。迭代器對象從集合的第一個元素開始訪問，直到所有元素被訪問完結束。

迭代器只能往前不能后退。

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

可迭代對象：就是實現(xiàn)了迭代器協(xié)議的對象。

舉個例子，對Python稍微熟悉一點的朋友應該知道，Python的for循環(huán)不但可以用來遍歷list，還可以用來遍歷文件對象，如下所示：

with open('F:/test/test.txt') as f: for line in f: print(line)

為什么在Python中，文件還可以使用for循環(huán)進行遍歷呢?這是因為，在Python中，文件對象實現(xiàn)了迭代器協(xié)議，for循環(huán)并不知道它遍歷的是一個文件對象，它只管使用迭代器協(xié)議訪問對象即可。

正是由于Python的文件對象實現(xiàn)了迭代器協(xié)議，我們才得以使用如此方便的方式訪問文件，如下所示：

 
 
 
 
    
  
  
  
  
  1. with open('F:/test/test.txt') as f: 
    2.   
  
  
  
  2.     for line in f: 
    3.   
  
  
  
  3.         print(line) 
    4.

輸出：

 
 
 
 
    
  
  
  
  
  1. with open('F:/test/test.txt') as f: 
    2.   
  
  
  
  2.     print(dir(f)) 
    3.

可迭代的是不是肯定就是迭代器?

生成器是可迭代的，也是迭代器。

list是可迭代的，但不是迭代器。list可以借助iter()函數(shù)將可迭代的變成迭代器list->iter(list)->迭代器next()：

舉個栗子：

 
 
 
 
    
  
  
  
  
  1. list1 = iter([x for x in range(10)]) 
    2.   
  
  
  
  2. print(next(list1)) 
    3.   
  
  
  
  3. print(next(list1)) 
    4.

可迭代對象：

  • 生成器
  • 元組 列表 集合 字典 字符串

如何判斷一個對象是否是可迭代?

借助isinstance()函數(shù)：

 
 
 
 
    
  
  
  
  
  1. from collections import Iterable 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. print(isinstance([x for x in range(10)], Iterable))  # 列表 
    4.   
  
  
  
  4. print(isinstance('hello world', Iterable))  # 字符串 
    5.   
  
  
  
  5. print(isinstance(100, Iterable))  # 數(shù)字 
    6.   
  
  
  
  6. print(isinstance((x for x in range(10)), Iterable))  # 迭代器 
    7.

輸出：

 
 
 
 
    
  
  
  
  
  1. True 
    2.   
  
  
  
  2. True 
    3.   
  
  
  
  3. False 
    4.   
  
  
  
  4. True 
    5.

生成器

生成器是Python最有用的特性之一，也是使用的最不廣泛的Python特性之一。究其原因，主要是因為，在其他主流語言里面沒有生成器的概念。

正是由于生成器是一個“新”的東西，所以，它一方面沒有引起廣大工程師的重視，另一方面，也增加了工程師的學習成本，最終導致大家錯過了Python中如此有用的一個特性。

我們已經(jīng)知道，通過列表推導式可以直接創(chuàng)建一個列表，但是，受到內存限制，列表容量肯定是有限的。

而且，創(chuàng)建一個包含100萬個元素的列表，不僅占用很大的存儲空間，如果我們僅僅需要訪問前面那幾個元素，那后面絕大多數(shù)元素占用的空間都白白浪費了。

所以，如果列表元素可以按照某種算法在循環(huán)的過程中不斷推算出后續(xù)的元素，這樣既不必創(chuàng)建完整的list，從而還可以節(jié)省大量的空間。

在Python中，這種一邊循環(huán)一邊計算的機制，稱為生成器:generator。

Python使用生成器對延遲操作提供了支持。所謂延遲操作，是指在需要的時候才產(chǎn)生結果，而不是立即產(chǎn)生結果。這也是生成器的主要好處。

定義生成器

Python有兩種不同的方式提供生成器：

方法一：借助列表推導式

生成器表達式：類似于列表推導(這也就是為什么第一節(jié)我要先介紹列表推導式)，但是，生成器返回按需產(chǎn)生結果的一個對象，而不是一次構建一個結果列表。

例1：

 
 
 
 
    
  
  
  
  
  1. my_generator = (x for x in range(5))  # 注意是()不是[] 
    2.   
  
  
  
  2. print(my_generator)  # 發(fā)現(xiàn)不能打印出元素 
    3.   
  
  
  
  3. print(type(my_generator)) 
    4.   
  
  
  
  4. print(my_generator.__next__())  # 三種得到元素的方法，注意看輸出結果 
    5.   
  
  
  
  5. print(next(my_generator)) 
    6.   
  
  
  
  6. for i in my_generator: 
    7.   
  
  
  
  7.     print(i) 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. # 注意會拋出StopIteration異常 
    10.   
  
  
  
  10. # print(next(my_generator))   
    11.   
  
  
  
  11. print(next(my_generator))   # generator只能遍歷一次 
    12.

輸出：

 
 
 
 
    
  
  
  
  
  1. Traceback (most recent call last): 
    2.   
  
  
  
  2.   File "E:/pycharm/Leetcode/RL_Learning/printdata.py", line 11, in  
    3.   
  
  
  
  3.     print(next(my_generator)) 
    4.   
  
  
  
  4. StopIteration 
    5.   
  
  
  
  5.  at 0x0000000000513660> 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. 0 
    8.   
  
  
  
  8. 1 
    9.   
  
  
  
  9. 2 
    10.   
  
  
  
  10. 3 
    11.   
  
  
  
  11. 4 
    12.

方法二：借助函數(shù)

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

步驟：

  • 定義函數(shù)，函數(shù)返回使用yield關鍵字;
  • 調用函數(shù)，接收函數(shù)返回值;
  • 得到的返回結果就是生成器;
  • 借助next()或__nest__()得到想要的元素。

例2：你的函數(shù)里面只要出現(xiàn)了yield關鍵字，你的函數(shù)就不再是函數(shù)了，就變成生成器了：

 
 
 
 
    
  
  
  
  
  1. # 斐波那契數(shù)列： 
    2.   
  
  
  
  2. def fib(length):    # 1. 定義函數(shù) 
    3.   
  
  
  
  3.     a, b = 0, 1 
    4.   
  
  
  
  4.     n = 0 
    5.   
  
  
  
  5.     while n < length: 
    6.   
  
  
  
  6.         n += 1 
    7.   
  
  
  
  7.         yield b         # return b + 暫停 
    8.   
  
  
  
  8.         a, b = b, a + b 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. g = fib(5)     # 2. 調用函數(shù) 
    12.   
  
  
  
  12. print(g)     # 3. 返回的就是生成器 
    13.   
  
  
  
  13. print(next(g))     # 4. 借助`next()`或`__nest__()`得到想要的元素 
    14.   
  
  
  
  14. print(next(g))    # 每調用一次產(chǎn)生一個值 
    15.   
  
  
  
  15. print(next(g)) 
    16.   
  
  
  
  16. print(g.__next__()) 
    17.   
  
  
  
  17. print(g.__next__()) 
    18.

輸出：

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2. 1 
    3.   
  
  
  
  3. 1 
    4.   
  
  
  
  4. 2 
    5.   
  
  
  
  5. 3 
    6.   
  
  
  
  6. 5 
    7.

注意：生成器只能遍歷一次。

當調用函數(shù)的時候，并沒有進函數(shù)進行執(zhí)行，而是直接生成一個生成器，當調用next的時候，才進入函數(shù)真正開始執(zhí)行，除了第一次調用next()方法是從函數(shù)頭開始執(zhí)行，其余每次都是接著從上次執(zhí)行到y(tǒng)ield的地方接著執(zhí)行的。

小結：

使用生成器以后，代碼行數(shù)更少。大家要記住，如果想把代碼寫的Pythonic，在保證代碼可讀性的前提下，代碼行數(shù)越少越好。

合理使用生成器，能夠有效提高代碼可讀性。只要大家完全接受了生成器的概念，理解了yield語句和return語句一樣，也是返回一個值。那么，就能夠理解為什么使用生成器比不使用生成器要好，能夠理解使用生成器真的可以讓代碼變得清晰易懂。

在實際工作中，充分利用Python生成器，不但能夠減少內存使用，還能夠提高代碼可讀性。掌握生成器也是Python高手的標配。如果本文對你有幫助，不要忘記關注點贊或收藏支持一下~

作者：臧遠慧

簡介：就職于中科星圖股份有限公司(北京)，研發(fā)部后端技術組。個人擅長 Python/Java 開發(fā)，了解前端基礎;熟練掌握 MySQL，MongoDB，了解 Redis;熟悉 Linux 開發(fā)環(huán)境，掌握 Shell 編程，有良好的 Git 源碼管理習慣;精通 Nginx ，F(xiàn)lask、Swagger 開發(fā)框架;有 Docker+Kubernetes 云服務開發(fā)經(jīng)驗。對人工智能、云原生技術有較大的興趣。

【原創(chuàng)稿件，合作站點轉載請注明原文作者和出處為.com】


新聞名稱：Python中的3個“黑魔法”與“騷操作”
網(wǎng)頁URL：http://www.5511xx.com/article/ccegodc.html