生成器和迭代器

list的一個問題是，如果使用range生成一個較大的list，而在使用的時候只使用1個或前幾個，就會造成大量的浪費。（python2）

生成器

是一種可以對其進行迭代的程序（通常是for循環），但是它的值只需要延遲產生（lazily).

• method one：

def lazy_range(n):
    i = 0
    while i < n:
        yield i
        i += 1

for i in lazy_range(10):
    print(i)# dosomethingwith(i)

在python3中range本身就是lazily的。
?延遲的缺點是，你只能通過生成器迭代一次，如果需要多次迭代某個對象，你就需要每次都重新創建一個生成器，或者使用list。

• method two：
  使用包含在圓括號中的for語句解析：

lazy_evens_below_20 = (i for i in range(20) if i%2== 0)
print(lazy_evens_below_20)

隨機性

import random

 random.random()#生成0-1之間均勻分布的隨機數，是最常用的隨機函數
 
 random.seed(x)#設置隨機數種子
 random.random()#兩次設置相同的隨機數種子得到的結果一致
 
 random.randrange(n)#返回從range(n)中[0:n-1]中隨機選取
 random.randrange(x,y)#返回從range(x,y)中[x,y-1]中隨機選取

up_to_tem = list(range(10))#注意這里直接使用range(10)不可以一定要強制list()才行
random.shuffle(up_to_tem)#shuffle對list中的元素隨機重新排列

random.choice(up_to_tem)#注意只能隨機選取一個元素
#不重復選取
random.sample(list,num)#list：待選取list num:想要選取的元素個數
#重復選取
#多次調用choice即可
four_with_replacement = [random.choice(list(range(10))) for _ in range(4)]
#使用_占位，沒有實際意義

正則表達式

import re
#正則的package
re.match("a","cat")#cat是以a為開頭嗎？
re.search("c"."dog")#dog中是否有一個字符是c？
re.split("[ab]","carbs")#分割掉a，b剩余的字符
re,sub("[0-9]","-","R2D2")#將用虛線進行位的替換

枚舉

有時候，想在一個list上進行迭代，并且同時使用它的元素和索引
在一個已知的list上面進行迭代

for i,document in enumerate(documents):
    do_something(i,document)
# i:index,document:element

for i,_ in enumerate(documents):
    do_something(i,documents)
# only index

壓縮與參數拆分

如果想要把兩個或者多個list壓縮在一起，可以使用zip同時把多個list轉換為一個對應元素的tuple 的single list：

list1 = [1,2,3]
list2 = ['a','b']
list=zip(list1,list2)
print(tuple(list))

list1 = [1,2,3]
list2 = ['a','b']
list3 = [4,5,6]
list=zip(list1,list2,list3)
print(tuple(list))

if the length of these lists aren’t same, zip will end at the shortest list
(最短截止）

解壓

pairs = [(1,2),(3,4),(5,6)]
letters,numbers= zip(*pairs)
print(letters,numbers)

*（星號）執行參數拆分argument unpacking
?可以在任何函數上進行參數拆分

def add(a,b):
    return a+b

ans = add(1,2)
print(ans)

ans = add(*[1,2])
print(ans)

args 和 kwargs

如果想要創建一個更高階的函數，把某個函數f作為input，并返回一個對任意輸入都返回f值兩倍的函數：

def doubler(f):
    def g(x):
        return 2*f(x)
    return g

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

g = doubler(f2(1,2))
print(g(1,2))

對于有多個參數的函數就不適用
需要一個可以取任意參數的函數的method，利用參數拆分可以做到：

def magic(*args,**kwargs):
    print("unnamed args:",args)
    print("keyword args:",kwargs)

magic(1,2,key='word',key2='word2')

輸出的未命名的args和關鍵字kwargs如下：

也就是說當定義了這樣一個function時，args是它的一個未命名參數的tuple，kwargs是它的一個已命名參數的dict
反過來也適用，可以使用一個list/tuple和dict來給函數提供參數

def other_way_magic(x,y,z):
    return x+y+z
x_y_list = [1,2]
z_dict = {"z":3}
print(other_way_magic(*x_y_list,**z_dict))

用它可以將任意參數作為輸入的高階函數

def doubler_correct(f):
    def g(*args,**kwargs):
        return 2*f(*args,**kwargs)
    return g

def f2(x,y):
    return x+y
g = doubler_correct(f2)
print(g(1,2))

因為傳入函數的參數具有不確定性，所以像最開始那樣直接固定參數個數不行，所以才用這種參數隨便的method。