函數簡單說明

# 函數即"變量"
# 高階函數
#     a.把一個函數名當做實參傳給另一個函數(在不修改被裝飾函數的源代碼的情況下，為其添加功能)
#     b.返回值中包含函數名（不修改函數的調用方式）
‘‘‘
import  time
def bar():
    print("in the bar!")
    time.sleep(2)

def foo(func):
    start_time = time.time()
    func()                  #根據內存地址，執行代碼
    stop_time = time.time()
    print("run time %s"  %(stop_time-start_time))
foo(bar)

#函數嵌套，是在一個函數內，用一個def來定義一個新的函數
def foo():
    print("in the foo")
    def bar():
        print("in the bar")
    bar()

#函數調用
def foo():
    print("in the foo")
    bar()

def bar():
    print("in the bar")
 

匿名函數

 1 calc = lambda a,b :a+b
 2 print(calc(1,2))
 3 
 4 calc = lambda n : 3 if n<5 else n*n
 5 print(calc(12))
 6 
 7 res = filter(lambda n:n>5,range(10))
 8 res = map(lambda n:n*n,range(5))
 9 for i in res:
10     print(‘----‘,i)
11 
12 res = [lambda i:i*2 for i in range(10)]

內置函數

  1
 
 # -*- coding:utf-8 -*-
  2 # LC
  3 print(all([1,2,3,0,4]))     #all中的課叠代對象全為真則返回真
  4 print(any([1,2,3,0]))       #any中有一個為真則返回真
  5 print(bin(101))             #把數字轉換成2進制
  6 print(bool({}))             #判斷整數是否為真，列表，元組，字典如果為空，則返回False
  7 
  8 a = bytes("abcde",encoding="utf-8")     #字符串默認是不能夠修改的
  9
 
 b = bytearray("abcde",encoding="utf-8")     #將原有數據變化成一個列表，並且可以改變
 10 b[1] = 100                          #改變列表中的值，但必須要賦值一個整型，為ASCII碼表對應的數字，即d對應ASCII碼中的100
 11 print("----",b)
 12 
 13 callable([])      #判斷是否為可調用對象，函數，類都是可以調用的，即是否有()調用
 14 print(callable([]))
 15 def hel():pass
 16 print(callable(hel))
 17 
 18 chr(100)        #輸入數字，返回數字對應的unicode表中的字符
 19 print("----",chr(97))
 20 
 21 ord("i")       #輸入字符，將字符對應的unicode表的數字返回
 22 print(ord("你"))
 23 
 24 code = "for i in range(10):print(i)"
 25 exec(code)      #exec能夠將字符串轉換成可執行代碼並執行
 26 
 27 print(dir(code))   #查看一點對象具體有什麽方法可以使用
 28 
 29 print(divmod(10.2,2.2)) #查看兩張相除的結果及余數
 30 
 31 #enumerate([])         #將可叠代對象按著序列號排序
 32 list1 = [‘January‘,‘February‘,‘March‘,‘April‘,‘May‘,‘June‘,‘July‘,‘August‘,‘September‘,‘October‘,‘November‘,‘December‘]
 33 print(list(enumerate(list1,start=1)))               #表示從1開始計數，將list1中的對象分配一個序號
 34 for index,i in enumerate(list1,start=1):
 35     print(index,i)
 36 
 37 #filter
 38 res = filter(lambda n:n>5,range(10))        #結合lambda，filter將lambda中為True的返回
 39 for i in res:
 40     print(i)
 41 #map
 42 res = map( lambda n:n*2,range(6))           #map將lambda range中所有的元素進行運算
 43 for i in res:
 44     print(i)
 45 
 46 res = [lambda i:i*2 for i in range(10)]
 47 #reduce
 48 import functools
 49 rese = functools.reduce(lambda x,y:x+y,range(5))       #表示x,y默認從0,1開始，x+y結果傳遞給x，y每次+1，並把結果給x,(即列表中所有數字相加)
 50 print(rese)
 51 
 52 res = functools.reduce(lambda x,y:x*y,range(1,10))      #列表中所有數字相乘
 53 print(‘----‘,res)
 54 
 55 #frozeset
 56 a = frozenset([1,2,3,5,534,4,34,2])         #表示一個不可變集合，即默認集合擁有的方法將無法使用
 57 print(a)
 58 
 59 #globals()          #將整個程序，僅這個文件的變量按著key，value的格式，字典的方式呈現
 60 print(globals())
 61 
 62 #hash
 63 
 64 #hex            #將數字轉換成16進制
 65 #oct(x)         #將數字轉換成8進制
 66 hex(152)
 67 
 68 #id             #返回內存地址
 69 print(‘---‘,id(1))
 70 
 71 #locals()           #尋找局部變量中的變量，僅在局部有效
 72 
 73 #max()              #找出最大的值
 74 #min()
 75 
 76 #pow
 77 print(pow(2,4,5))            #求x的y次方，然後使用z求余
 78 
 79 #round
 80 print(round(1.232122322,5))              #表示保留小數點後幾位
 81 
 82 #sorted
 83 a = {5:2,8:0,1:4,-5:7,99:11}
 84 print(sorted(a.items()))                #將字典a變成列表，並排序，默認按著字典的key排序
 85 # 結果：[(-5, 7), (1, 4), (5, 2), (8, 0), (99, 11)]
 86 print(sorted(a.items(),key=lambda x:x[1]))      #按著字典value排序，使用lambda來指定轉換後的列表中的第二個數字排序
 87 # 結果：[(8, 0), (5, 2), (1, 4), (-5, 7), (99, 11)]
 88 
 89 #zip                #將多個可叠代對象進行相互柔和,以最短的算
 90 a = (1,2,3,4,5,6,7)
 91 b = (‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘)
 92 print(len(b))
 93 c = (‘+‘ for i in range(len(b)))        #使用生成器生成一個元組
 94 print(c)
 95 for i in zip(a,b,c):
 96     print(i)
 97 
 98 #map                #將可叠代對象按著函數執行，即將可叠代對象的值傳遞給函數，並返回結果
 99 def hel(*args):
100 
101     return args
102 for i in map(hel,a,b):
103     print(i)

序列化

 1 #json序列化               #json能夠將內存中的熟悉序列化值硬盤文件中，json只能序列號簡單的，如列表，元組，字典等，函數不行
 2 import  json
 3 info = {
 4     ‘name‘:‘lc‘,
 5     ‘age‘:19
 6 }
 7 f = open("test.txt",‘w‘)
 8 f.write(json.dumps(info))
 9 f.close()
10 
11 #json反序列化               #json返序列化能夠將文件中的數據加載至內存中，保持原格式
12 f = open("test.txt","r")
13 data = json.loads(f.read())     #通過loads來實現
14 print(data["age"])              #可以直接讀取
15 f.close()
16 
17 #pickle序列化              #pickle能夠序列化復雜的對象類型，如函數，pickle僅在python中有效，json是在各種語言中都有效
18 import pickle
19 import json
20 def hello(name):
21     print("hello,",name)
22 info = {
23     ‘name‘:‘lc‘,
24     ‘age‘:‘19‘,
25     ‘func‘:hello                    #函數
26 }
27 f = open("test.txt","wb")               #pickle序列化需要用字節格式
28 pickle.dump(info,f)              #等價於f.write(pickle.dumps(info))
29 f.close()
30 
31 #pickle反序列化
32 f = open("test.txt","rb")
33 data = pickle.load(f)                                #等價於data = pickle.loads(f.read())
34 print(data["func"]("lvcheng"))
35 f.close()

高階函數

轉載：http://www.cnblogs.com/ghgyj/p/3997548.html

要理解“函數本身也可以作為參數傳入”，可以從Python內建的map/reduce函數入手。

如果你讀過Google的那篇大名鼎鼎的論文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。

我們先看map。map()函數接收兩個參數，一個是函數，一個是序列，map將傳入的函數依次作用到序列的每個元素，並把結果作為新的list返回。

舉例說明，比如我們有一個函數f(x)=x2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：

現在，我們用Python代碼實現：

>>> def f(x):
...     return x * x
...
>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

請註意我們定義的函數f。當我們寫f時，指的是函數對象本身，當我們寫f(1)時，指的是調用f函數，並傳入參數1，期待返回結果1。

因此，map()傳入的第一個參數是f，即函數對象本身。

像map()函數這種能夠接收函數作為參數的函數，稱之為高階函數（Higher-order function）。

你可能會想，不需要map()函數，寫一個循環，也可以計算出結果：

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print L

的確可以，但是，從上面的循環代碼，能一眼看明白“把f(x)作用在list的每一個元素並把結果生成一個新的list”嗎？

所以，map()作為高階函數，事實上它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x2，還可以計算任意復雜的函數。

再看reduce的用法。reduce把一個函數作用在一個序列[x1, x2, x3...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素做累積計算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方說對一個序列求和，就可以用reduce實現：

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

當然求和運算可以直接用Python內建函數sum()，沒必要動用reduce。

但是如果要把序列[1, 3, 5, 7, 9]變換成整數13579，reduce就可以派上用場：

>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

這個例子本身沒多大用處，但是，如果考慮到字符串str也是一個序列，對上面的例子稍加改動，配合map()，我們就可以寫出把str轉換為int的函數：

>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     return {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}[s]
...
>>> reduce(fn, map(char2num, ‘13579‘))
13579

整理成一個str2int的函數就是：

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}[s]
    return reduce(fn, map(char2num, s))

還可以用lambda函數進一步簡化成：

def char2num(s):
    return {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}[s]

def str2int(s):
    return reduce(lambda x,y: x*10+y, map(char2num, s))

也就是說，假設Python沒有提供int()函數，你完全可以自己寫一個把字符串轉化為整數的函數，而且只需要幾行代碼！

lambda函數的用法在下一節介紹。

函數-內置函數，匿名函數，嵌套函數，高階函數，序列化