日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

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

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
5個小技巧，讓你的for循環(huán)瞬間高大上！

本文轉(zhuǎn)載自公眾號“讀芯術(shù)”(ID：AI_Discovery)

讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術(shù)通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領(lǐng)域值得信任、有價值的長期合作伙伴，公司提供的服務(wù)項目有：域名與空間、網(wǎng)頁空間、營銷軟件、網(wǎng)站建設(shè)、興山網(wǎng)站維護、網(wǎng)站推廣。

或許每個初學(xué)Python的程序員最早接觸的概念中都有For循環(huán)，這一點理所當然， for循環(huán)可以在不費吹灰之力的情況下對數(shù)據(jù)執(zhí)行很多操作。

然而，大量的使用for循環(huán)也可能會讓使用者的思維拘泥于簡單的迭代中，而忽略了一些更加高效且簡潔的迭代方法。

如何讓你的for循環(huán)告別繁復(fù)擁抱簡潔，如何重啟探索Python循環(huán)迭代的大門，希望以下幾個小技巧能夠給你啟發(fā)。

Zip：同時在兩個列表中循環(huán)

筆者在實踐中發(fā)現(xiàn)代碼可以同時在兩個數(shù)組中進行循環(huán)。要想在其他的編程語言中做到這一點相對來說難度大很多，這也體現(xiàn)出了Python的簡易性。要達到同時在兩個數(shù)組中進行循環(huán)這一目的，只需使用zip()函數(shù)。

 
 
 
 
    
  
  
  
  
  1. for first,second in zip(array1,array2): 
    2. 
  
  
  
  
  2.     print(first) 
    3. 
  
  
  
  
  3.     print(second) 
    4.

在一個偶整數(shù)序列和一個奇整數(shù)序列中使用這一方法就能體現(xiàn)出這一函數(shù)的功效。

 
 
 
 
    
  
  
  
  
  1. odds = [1,3,5,7,9] 
    2. 
  
  
  
  
  2. evens = [2,4,6,8,10] 
    3. 
  
  
  
  
  3. for oddnum, evennum in zip(odds,evens): 
    4. 
  
  
  
  
  4.     print(oddnum) 
    5. 
  
  
  
  
  5.     print(evennum) 
    6.

以上函數(shù)輸出的結(jié)果便是：

 
 
 
 
    
  
  
  
  
  1. 1 
    2. 
  
  
  
  
  2. 2 
    3. 
  
  
  
  
  3. 3 
    4. 
  
  
  
  
  4. 4 
    5. 
  
  
  
  
  5. 5 
    6. 
  
  
  
  
  6. 6 
    7. 
  
  
  
  
  7. 7 
    8. 
  
  
  
  
  8. 8 
    9. 
  
  
  
  
  9. 9 
    10. 
  
  
  
  
  10. 10 
    11.

In Range函數(shù)：編寫C-Style循環(huán)

C-Style似乎看起來有點兒平凡，但它能在循環(huán)中煥發(fā)光彩。

 
 
 
 
    
  
  
  
  
  1. for i in range(10): 
    2. 
  
  
  
  
  2.     print(i) 
    3. 
  
  
  
  
  3.     if i == 3: 
    4. 
  
  
  
  
  4.         i.update(7) 
    5.

C語言愛好者可能覺得以上的代碼并不是C-Style循環(huán)，但如果不想自己動手編寫迭代函數(shù)，以上內(nèi)容已經(jīng)是最完美的形式了。

不過筆者熱衷于“浪費時間”，因此決定編寫一個新的迭代程序來寫出盡可能完美的C-Style循環(huán)。

 
 
 
 
    
  
  
  
  
  1. class forrange: 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     def __init__(self, startOrStop,stop=None, step=1): 
    4. 
  
  
  
  
  4.         if step == 0: 
    5. 
  
  
  
  
  5.             raise ValueError('forrangestep argument must not be zero') 
    6. 
  
  
  
  
  6.         if not isinstance(startOrStop,int): 
    7. 
  
  
  
  
  7.             raise TypeError('forrangestartOrStop argument must be an int') 
    8. 
  
  
  
  
  8.         if stop is not None and notisinstance(stop, int): 
    9. 
  
  
  
  
  9.             raise TypeError('forrangestop argument must be an int') 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.         if stop is None: 
    12. 
  
  
  
  
  12.             self.start = 0 
    13. 
  
  
  
  
  13.             self.stop = startOrStop 
    14. 
  
  
  
  
  14.             self.step = step 
    15. 
  
  
  
  
  15.         else: 
    16. 
  
  
  
  
  16.             self.start = startOrStop 
    17. 
  
  
  
  
  17.             self.stop = stop 
    18. 
  
  
  
  
  18.             self.step = step 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.     def __iter__(self): 
    21. 
  
  
  
  
  21.         returnself.foriterator(self.start, self.stop, self.step) 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     class foriterator: 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.         def __init__(self, start, stop,step): 
    26. 
  
  
  
  
  26.             self.currentValue = None 
    27. 
  
  
  
  
  27.             self.nextValue = start 
    28. 
  
  
  
  
  28.             self.stop = stop 
    29. 
  
  
  
  
  29.             self.step = step 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.         def __iter__(self): return self 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.         def next(self): 
    34. 
  
  
  
  
  34.             if self.step > 0 andself.nextValue >= self.stop: 
    35. 
  
  
  
  
  35.                 raise StopIteration 
    36. 
  
  
  
  
  36.             if self.step < 0 andself.nextValue <= self.stop: 
    37. 
  
  
  
  
  37.                 raise StopIteration 
    38. 
  
  
  
  
  38.             self.currentValue =forrange.forvalue(self.nextValue, self) 
    39. 
  
  
  
  
  39.             self.nextValue += self.step 
    40. 
  
  
  
  
  40.             return self.currentValue 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42.     class forvalue(int): 
    43. 
  
  
  
  
  43.         def __new__(cls, value,iterator): 
    44. 
  
  
  
  
  44.             value =super(forrange.forvalue, cls).__new__(cls, value) 
    45. 
  
  
  
  
  45.             value.iterator = iterator 
    46. 
  
  
  
  
  46.             return value 
    47. 
  
  
  
  
  47.  
    48. 
  
  
  
  
  48.         def update(self, value): 
    49. 
  
  
  
  
  49.             if not isinstance(self, int): 
    50. 
  
  
  
  
  50.                 raiseTypeError('forvalue.update value must be an int') 
    51. 
  
  
  
  
  51.             if self ==self.iterator.currentValue: 
    52. 
  
  
  
  
  52.                 self.iterator.nextValue =value + self.iterator.step 
    53.

Filter()函數(shù)：只對需要的數(shù)據(jù)進行循環(huán)

在處理大量的數(shù)據(jù)時，使用filter函數(shù)能夠使得數(shù)據(jù)在使用時效果更佳。Filter函數(shù)正如其名，其功效是在對數(shù)據(jù)進行迭代前進行過濾。當只需要使用某一范圍內(nèi)的數(shù)據(jù)而且不想再添加一個條件時，filter十分實用。

 
 
 
 
    
  
  
  
  
  1. people = [{"name": "John","id": 1}, {"name": "Mike", "id": 4},{"name": "Sandra", "id": 2}, {"name":"Jennifer", "id": 3}]for person in filter(lambda i:i["id"] % 2 == 0, people): 
    2. 
  
  
  
  
  2. ...     print(person) 
    3. 
  
  
  
  
  3. ... 
    4. 
  
  
  
  
  4. {'name': 'Mike', 'id': 4} 
    5. 
  
  
  
  
  5. {'name': 'Sandra', 'id': 2} 
    6.

Enumerate()函數(shù)：對維度進行索引

在Python中使用枚舉函數(shù)可以讓Python將從數(shù)組中輸出的列表索引進行編號。筆者制作了一個包含三個元素的列表對這一功能進行展示：

 
 
 
 
    
  
  
  
  
  1. l = [5,10,15] 
    2.

現(xiàn)在可以利用以下方法來訪問數(shù)組索引：

 
 
 
 
    
  
  
  
  
  1. l[1] 
    2. 
  
  
  
  
  2. 10 
    3. 
  
  
  
  
  3. l[0] 
    4. 
  
  
  
  
  4. 5 
    5. 
  
  
  
  
  5. l[2] 
    6. 
  
  
  
  
  6. 15 
    7.

在這些列表中進行枚舉時，維度的索引位置和維度會結(jié)合產(chǎn)生一個新的變量。請注意這一新變量的類型。

Python會自動將這些索引置入一個元組之中，這一點十分奇怪。筆者還是傾向于從只有一個元素的Python庫中獲得這些結(jié)果。還好，我們可以把這些枚舉函數(shù)置入到一個Python庫中。

 
 
 
 
    
  
  
  
  
  1. data = dict(enumerate(l)) 
    2.

輸入以上代碼之后就會得出：

 
 
 
 
    
  
  
  
  
  1. >>> data 
    2. 
  
  
  
  
  2. {0: 5, 1: 10, 2: 15} 
    3.

圖源：unsplash

Sorted()函數(shù)：使用數(shù)據(jù)中進行排序，而非使用前

Sort函數(shù)對于常常需要處理大量數(shù)據(jù)的人來說至關(guān)重要，它將字符串根據(jù)首字母A到B進行排列，將整數(shù)和倍數(shù)自負無窮起由小至大排列。需要注意的是，這一函數(shù)無法用于帶有字符串和整數(shù)或浮點數(shù)的列表。

 
 
 
 
    
  
  
  
  
  1. l = [15,6,1,8] 
    2. 
  
  
  
  
  2. for i in sorted(l): 
    3. 
  
  
  
  
  3.     print(i) 
    4. 
  
  
  
  
  4. 1 
    5. 
  
  
  
  
  5. 6 
    6. 
  
  
  
  
  6. 8 
    7. 
  
  
  
  
  7. 15 
    8.

也可以將相反的參數(shù)設(shè)為False來進行逆運算。

 
 
 
 
    
  
  
  
  
  1. for i in sorted(l,reverse = True): 
    2. 
  
  
  
  
  2.     print(i) 
    3. 
  
  
  
  
  3. 15 
    4. 
  
  
  
  
  4. 8 
    5. 
  
  
  
  
  5. 6 
    6. 
  
  
  
  
  6. 1 
    7.

對于可用的最后一個參數(shù)，可以使用key函數(shù)。Key是一個應(yīng)用于已知循環(huán)中的每個維度的函數(shù)。而筆者偏向于使用lambda，Lambda會創(chuàng)造一個匿名但仍可調(diào)用的函數(shù)。

 
 
 
 
    
  
  
  
  
  1. l.sort(key=lambda s: s[::-1]) 
    2.

寫代碼時，遇到大量的帶有迭代的數(shù)據(jù)在所難免。簡潔成就卓越，這些方法能夠使代碼簡潔明了并且運行起來更快。循環(huán)的世界值得你繼續(xù)探索!


新聞名稱：5個小技巧，讓你的for循環(huán)瞬間高大上！
文章轉(zhuǎn)載：http://www.dlmjj.cn/article/cddsiij.html