Python基礎教程（七） Python中的函數

本節開始介紹Python中的函數
列表、元組和字符串都可以通過索引得到每一個元素
列表、元組和字符串統稱為序列
list()   轉為列表
沒有參數就生成一個空列表
傳參的話可以傳字符串和元組
b="abc"
b=list(b)
print(b) #會將每一個字符變成一個元素
類似的還有
tuple(param)  轉化為元組
str(param)    將對象轉為字符串
如[1,2,3,4]
會轉為
'[1,2,3,4]'
len(param)    返回長度
max(param)    返回序列中的最大值,但是列表或者元組裏面的元素要是同一類型的，又有數字又有字符串是不行的
sum(param)    返回列表和元組元素值的總和，字符串不行
sorted(param) 排序，可以給字符串排序，返回一個列表
reversed(param) 反轉 返回一個迭代器對象，但是可以對其返回值使用list轉為列表
enumerate(param) 返回一個迭代器對象
如：
list1=["a","b","c","d","e"]
list(enumerate(list1))
#得到：
#[(0,"a"),(1,"b"),(2,"c"),(3,"d"),(4,"e")]
zip(param) 返回迭代器 如：
a=[1,2,3,4,5,6,7]
b=["a","b","c"]
print(list(zip(a,b)))
#[(1, 'a'), (2, 'b'), (3, 'c')]
自定義函數：
創建函數 def關鍵字
def 函數名(參數1，參數2，):
代碼塊
有返回值用 return 即可
不return就會返回None
關鍵字參數：
比如說，
def Myfunc(name,age):
print("名字："+name+"年齡+"："+age)
然後你可以
Myfunc("zbp",21)
來調用
如果你記不住參數的順序，可以在調用函數的時候指定關鍵字
Myfunc(age=21,name="zbp")
還有默認參數，就不說了
收集參數：類似於php的func_get_args()
def Myfunc(*params)
print(params)
調用的時候：
Myfunc(1,"aa",[1,2,3])
此時函數會將params解析為一個元組,你傳入Myfunc內也必須傳的是一個元組
print(params)時他也會輸出一個元組
(1,"aa",[1,2,3])
如果函數又有收集參數，又有其他不同參數
def Myfunc(*args,name)
print(args)
print(name)
此時調用的時候
Myfunc(1,2,3,4,5)
他就會報錯
此時應該用關鍵字參數指定一下實參中哪個參數是屬於name的
Myfunc(1,2,3,4,name="zbp")
如果將普通參數放在收集參數之前,也是可以的:
def Myfunc(name,*args)
print(args)
print(name)
Myfunc("zbp",1,2,3)
輸出
(1,2,3)
zbp
下面說一下
*
*args
**
**kargs
這4種情況,其中*args說過了,就是傳入普通的參數,然後函數將這些參數解析為元組
但是對於*args還提多一點:
def Myfunc(*args,name)
print(args)
print(name)
print(*args)
Myfunc("a","b","c",name="zbp")
第3個print會返回什麼:
a b c
我們知道args是一個元組("a","b","c")
*args就會將這個元組拆開,變成普通的3個東西
*的用法:
例如,定義一個含三個位置參數的函數”fun”
def fun(a,b,c):
print a,b,c
fun(1,2,3)
#1 2 3 #輸出
#可以看到出入三個位置參數調用此函數，會打印出三個參數
#現在我們定義一個含三個整數的列表，並使用’*’來將列表作為參數傳入
l = [1,2,3]
fun(*l)
#1 2 3 #輸出
可以看出 fun(1,2,3)和fun(*l)的效果是一樣的,*的作用就是將列表中的元素分拆為多個單獨的參數傳到函數當中
**的用法
舉例說明:
def fun(a, b, c):
print a, b, c
fun(1,5,7)
# 得到1 5 7
fun(a=1,b=5,c=7)
# 得到1 5 7
d={'b':5, 'c':7}
fun(1, **d)
# 得到1 5 7
使用**的時候,傳入的是一個字典,字典的下標是函數的形參名,函數會將字典裏的元素一一填進fun()相對應字典下標的形參中
**kwargs用法
舉例說明:
def fun(a, **kwargs):
print a, kwargs
fun(1, b=4, c=5)
# 輸出 1 {'c': 5, 'b': 4}
fun(45, b=6, c=7, d=8)
# 輸出 45 {'c': 7, 'b': 6, 'd': 8}
fun函數只用一個位置參數，因為常規參數中只有一個變量’a’.但是通過”**kwargs”,可以傳多個鍵值參數。
使用**kwargs時,傳入常規參數(而且這些常規參數必須設置形參名),函數會將多餘的常規參數解析為一個字典
調用的時候 fun(1,2,3,4) 會報錯; fun(1,b=2,c=3,d=4)才對
*args 和**kargs是兩種相似用法,都是傳入普通參數,但前者函數將其解析為元組,後者函數將其解析為字典
二者還可以合作:
def fun(a,*args,**kargs):
print(a)
print(args)
print(kargs)
fun(1,3,5,6,s1="hi",s2="hello")
#結果:
#1
#(3, 5, 6)
#{'s1': 'hi', 's2': 'hello'}
對於*args和**kargs你可以不傳,但是要傳,順序就不能錯
pthyon的函數可以返回多個值
def Myfunc()
return 1,2,3,4,5
其實它返回的只是一個元組而已
作用域：
函數中可以獲取到函數外的全局變量的值(不使用global也行)，但是在函數中無法修改函數外的變量的值，如果修改的話，就會報錯
如果真的想修改，並且影響到函數外的該變量，可以先用global聲明一下
比如：
def Myfunc():
global a
print(a)
a=30
print(a)
a=1
Myfunc()
print(a)
#得到：1 30 30
內嵌函數和閉包：
內嵌函數意思是，允許在函數內定義另一個函數，這個是和js和php不一樣的，js和php不會這麼乾
內嵌函數的縮進就是兩個tab了。
外面的那個函數叫做外函數，內部的叫做內函數
比如：
def func1():
print("func1")
def func2():
print("func2")
func2()
注意：func2在func1中定義的話，就只能在func1中調用，無法在func1外調用
說一下內嵌函數的一個點：
如果在內函數想要改變外函數的變量
def func1():
x=5
def func2():
x*=x
return x
return func2()
此時會報錯說x沒定義
如果加個global
def func1():
x=5
def func2():
global x
x*=x
return x
return func2()
還是會報錯，因為x不是全局變量
此時應該用另外一個關鍵字聲明nonlocal
def func1():
x=5
def func2():
nonlocal x
x*=x
return x
return func2()
func1()
得到25
pthyon的閉包和js的閉包不會一個概念
pthyon的閉包有兩個條件：
在一個外函數中定義了一個內函數，內函數裏運用了外函數的臨時變量，並
且外函數的返回值是內函數的引用。這樣就構成了一個閉包。
如：
def func1(x):
def func2(y):
print(x+y) #調用了外函數的變量
return func2
#調用閉包
a=func1(5) #此時a的類型是一個function
print(a(10))
#得到15
#或者
func1(5)(10)
lambda表達式：
可以使用lambda表達式定義一個匿名函數：
lambda 參數1,參數2, :返回值
比如：
a=lambda x : 2*x+1
print(a(5)) #得到11
兩個BIF：
filter() 過濾器，第一參是個函數，第二參是個迭代器對象，會將第二參中的元素放到第一參的函數中處理，
只會返回處理為TRUE的元素。返回值還是個迭代器對象
比如一個只選出奇數的過濾器
list(filter(lambda x:x%2,[1,2,3,4,5,6,7,8,9,10]))
map()  參數和上面的一樣。但他不是過濾，而是對每個元素加工
list(map(lambda x:x+2,list1))
但是它不會改變list1本身