pythopn 函數(內置函數)

內置函數（Py3.5）

重要的內置函數：

1. filter(function, sequence)

# 描述：
    filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。
    該接收兩個參數，第一個爲函數，第二個爲序列，序列的每個元素作爲參數傳遞給函數進行判，
    然後返回 True 或 False，最後將返回 True 的元素放到新列表中。

# 語法：
    以下是 filter() 方法的語法:
    filter(function,sequence)

# 參數：
    function -- 判斷函數。
    sequence -- 可迭代對象。

# 實例    過濾出列表中的所有奇數：
    >>> str = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> def fun1(s):
    >>>    return s % 2 == 1
    >>> ret = filter(fun1, str)             #     filter把不符合的過濾掉
    >>> print(ret)                    #<filter object at 0x000001A8C827B358>   ret是一個迭代器對象
    >>> print(list(ret))                       # ret是一個迭代器對象    轉換成列表   [1, 3, 5, 7, 9]
對sequence中的item依次執行function(item)，將執行結果爲True的item做成一個filter object的迭代器返回。
可以看作是過濾函數。

2. map(function, sequence) 

# 描述：
    map() 會根據提供的函數對指定序列做映射。
    第一個參數 function 以參數序列中的每一個元素調用 function 函數，
    返回包含每次 function 函數返回值的新列表

# 語法：
    map() 函數語法：
    map(function, sequence, ...)

# 參數：
    function -- 函數，有兩個參數
    sequence -- 一個或多個序列

# 實例：   以下實例展示了 map() 的使用方法：
    >>> def square(x):  # 計算平方數
    >>>    num= x ** 2
    >>>    return str(num)+"L"                          
    >>> ret=map(square, [1, 2, 3, 4, 5])          #map  把序列中每個值做處理
    >>> print(ret)                 #  <filter object at 0x000001A8C827B358>   ret是一個迭代器對象
    >>> print(list(ret))             # ret是一個迭代器對象    轉換成列表   ['1L', '4L', '9L', '16L', '25L']

對sequence中的item依次執行function(item)，將執行結果組成一個map object迭代器返回.
map也支持多個sequence，這就要求function也支持相應數量的參數輸入：
    >>> def square(x,y):                        # x*y
    >>>     num= x * y
    >>>     return str(num)+"L"
    >>> a=[1, 2, 3, 4]
    >>> b=[ 7,8, 9, 10]
    >>> s=map(square,a, b)              #這裏square有兩個傳入   a  b  按順序對應  x   y
    >>> print(list(s))                  # ret是一個迭代器對象    轉換成列表   ['7L', '16L', '27L', '40L']

3. reduce(function, sequence, starting_value)　　

# 描述：
    reduce() 函數會對參數序列中元素進行累積。
    函數將一個數據集合（鏈表，元組等）中的所有數據進行下列操作：
    用傳給reduce中的函數 function（有兩個參數）先對集合中的第 1、2 個元素進行操作，
    得到的結果再與第三個數據用 function 函數運算，最後得到一個結果。

# 語法：
    reduce() 函數語法：
    reduce(function, iterable[, initializer])

# 參數：
    function -- 函數，有兩個參數
    iterable -- 可迭代對象
    initializer -- 可選，初始參數

# 實例： 以下實例展示了 reduce() 的使用方法：
    >>> from functools import reduce
    >>> def add(x, y) :                       # 兩數相加
    >>>       return x + y
    >>> ret=reduce(add, [1,2,3,4,5])   # 計算列表和：1+2+3+4+5
    >>> print(ret)                                     #15
對sequence中的item順序迭代調用function，如果有starting_value，還可以作爲初始值調用.
  >>> from functools import reduce          #     ****    reduce  py2可以直接調用   py3必須加這句  ***
  >>> def add(x, y) :                       # 兩數相加
  >>>       return x + y
  >>>       a=10                                            #注意
  >>> ret=reduce(add, [1,2,3,4,5],a)   # 計算列表和：1+2+3+4+5   a爲初始值  10   會在計算完列表和後  加  a
  >>> print(ret)                                     #25

4 lambda
lambda只是一個表達式，函數體比def簡單很多。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda表達式是起到一個函數速寫的作用。允許在代碼內嵌入一個函數的定義。
       普通函數與匿名函數的對比：
#普通函數
  >>> def add(a,b):
  >>>     return a + b
  >>> print(add(2,3))               #5
#匿名函數
  >>> add = lambda a,b : a + b
  >>> print(add(2,3))               #5
 匿名函數的命名規則，用lamdba 關鍵字標識，
 冒號（：）左側表示函數接收的參數（a,b） ,
 冒號（：）右側表示函數的返回值（a+b）。
因爲lamdba在創建時不需要命名，所以，叫匿名函數　　

lambda和普通的函數相比，就是省去了函數名稱而已，同時這樣的匿名函數，又不能共享在別的地方調用。
其實說的沒錯，lambda在Python這種動態的語言中確實沒有起到什麼×××的作用，
因爲有很多別的方法能夠代替lambda。
1. 使用Python寫一些執行腳本時，使用lambda可以省去定義函數的過程，讓代碼更加精簡。
2. 對於一些抽象的，不會別的地方再複用的函數，有時候給函數起個名字也是個難題，
    使用lambda不需要考慮命名的問題。
3. 使用lambda在某些時候讓代碼更容易理解。
lambda語句中，冒號前是參數，可以有多個，用逗號隔開，冒號右邊的返回值。
lambda語句構建的其實是一個函數對象。

# lamdba用在上面幾個函數中
  >>> from functools import reduce
  >>> foo = [1,2, 3, 4, 5, 6, 7, 8, 9, 10]
  >>> f=filter(lambda x: x % 3 == 0, foo)
  >>> m=map(lambda x: x * 2 + 10, foo)
  >>> r=reduce(lambda x, y: x + y, foo)
  >>> print(list(f))          #        [3, 6, 9]
  >>> print(list(m))          #       [12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
  >>> print(r)                #       55