Python中的函数
Python中的函数
定义/调用
def sayHi():
print('hello,function in Python')
sayHi()
注意Python中没有JS一样的声明前置，所以定义必须要在调用之前
函数中的参数
def say(str):
print(str)
say('hello, this is argument')
对于Python中的函数参数，定义几个就传几个参，这个很好理解。但是也有一些高级的或者是简化的参数用法：
- 默认参数：
def powerNum(num,pow=2):
res = 1
while pow>0:
pow -= 1
res = res * num
return res
print( powerNum(5) ) # 25 不传第二参数的话，默认使用pow=2来进行计算
# 等价于 print( powerNum(5,2) )
print( powerNum(2,3) ) # 8
默认参数使用的时候，一般放在必选参数后面，如果有多个默认参数，前面的想使用默认值，后面的想自行赋值的话，可以这么写：
def intro(name,age=18,word='hello,nice 2 meet u'):
print('name:%s,age:%d,%s'%(name,age,word))
# 我们现在想使用默认的age，但是想自行赋值word
intro('DeeJay',word='this is DeeJay') # name:DeeJay,age:18,this is DeeJay
# 这么一来就使用了默认的age并且自定义了word
值得注意的是，默认参数必须指向不变的对象,如果是个可变量的话，每次调用，默认函数指向的那个变量的也会改变
def pushEndToList(li = []):
li.append('END')
print(li)
pushEndToList() # ['END']
pushEndToList() # ['END', 'END']
pushEndToList() # ['END', 'END', 'END']
# 可以看到 默认参数li=[] 指向的不是一个不变的对象，
# 调用函数的时候，li指向的对象的值变了，那么再次调用的时候li的值就已经改变了
# 所以，默认参数， 必须要指向一个不变的对象(比如None)
- 可变参数
有时候我们定义函数的时候并不清楚到底需要多少个参数，就可以使用可变参数，使参数的个数不固定
def sum(*num):
print(num)
print( type(num) ) # <class 'tuple'>
res = 0
for number in num:
res += number
return res
sum(1,2,3,4) # (1,2,3,4)
res = sum(1,2,3,4)
print(res) # 10
可变参数的用法已经很清楚了，另外我们可以看到，这个可变参数其实是一个tuple
- 关键词参数
def keywordFunction(name,age,**kw):
print('%s,%s,%s'%(name,age,kw))
keywordFunction('DeeJay',22) # DeeJay,22,{} 可以不传关键词参数
keywordFunction('Yang',23,city='xian') # Yang,23,{'city': 'xian'}
keywordFunction('Wen',23,city='xian',job='frontEnd') # Wen,23,{'city': 'xian', 'job': 'frontEnd'}
关于函数的参数问题，我们来看一个综合的例子：
def fn(a,b,c=100,*args,**kw):
print(a)
print(b)
print(c)
print(args)
print(kw)
fn(1,2,3,4,5) # 1 2 3 (4,5) {}
# 这个很好理解，因为没有传入kw,默认参数c被赋值了3，剩下的被当成args构造出一个元祖
fn(1,2,3,4,5,name='DeeJay',age=21) # 1 2 3 (4,5) {'name': 'DeeJay', 'age': 21}
# 这次传入了kw
# 然后来看一个例子，
A = (4,5)
B = {'name': 'DeeJay', 'age': 21}
# 定义了A和B，然后传给fn()
fn(1,2,3,A,B)
# 输出结果为：
# args == ((4, 5), {'name': 'DeeJay', 'age': 21})
# kw == {}
# 出现上述结果的原因是，没有按照格式来进行传入kw,即按照key=value的形式传入
# 所以A和B都被当成了args,那么如果我们想让A被当成args，B作为kw，可以这样写：
fn(1,2,3,*A,**B) # 此时args == (4,5) kw == {'name': 'DeeJay', 'age': 21}
# 这种方法成为拆包
注意最后的fn(1,2,3,*A,**B)的写法，拆包的作用就是在传参的时候，将变量分解作为参数给函数。
函数的return值
在Python中，函数如果没有显示的写明return值，那么函数默认return None
此外直接写return也等价于return None
对于想返回多个值的函数，可以将多个值组合为一个list或者tuple等返回。
def fn():
a = 10
b = 20
c = 30
return a,b,c
res = fn()
print(res) # (10, 20, 30) 是一个tuple
局部变量和全局变量
Python中的函数中定义的变量为局部变量:
num = 99
def fn():
num = 100
def printNum():
print(num)
fn()
printNum() # 99
上述例子中，已经在全局环境中定义了num,所以在fn()中是在拘捕作用域中定义了一个局部变量num,而不是修改全局中的num,二者仅仅是变量名相同。
如果想要在fn()中修改全局的num，那么需要这么写：
num = 99
def fn():
global num # 表明在内部作用域中没有定义新的局部变量num,这边的num就是全局变量
num = 100
def printNum():
print(num)
fn()
printNum() # 100 此时输出的就是修改过后的全局变量num 为100
上述例子使用global来声明是操作一个全局变量而不是需要重新定义一个局部变量
但是也有例外，对于dict和list，其实可以不写global，程序仍然会去使用全局变量，而不是默认先定义一个局部变量:
# 对于dict和list，如果是全局变量 其实可以不用写global，
# 也会默认使用全局的，而不是先定义一个
di = {'name':'DeeJay'}
li = [1,2,3]
def fn1():
# 这边没有声明global
di['age'] = 21
li.append(4)
def fn2():
print(di)
print(li)
fn1()
fn2() # {'name': 'DeeJay', 'age': 21} [1, 2, 3, 4]
# 直接改变了全局中的di和li
Python中的递归
Py中的递归没什么特别的地方，写个阶乘函数了解一下：
def factorial(n):
if(n == 1):
return 1
return n * factorial(n-1)
res = factorial(4)
print(res)
匿名函数lambda
- 语法
lambda args: expression
lambda x: x*x
上述例子， lambda x:的x是参数，后面的x*x是作为函数return的值。
- 用法
使用匿名函数来进行list.sort()
list.sort()接受一个值为一个函数的key，将这个函数的返回值作为排序的依据，例子：
li = [1,-3,2]
li.sort(key=abs)
print(li) # [1, 2, -3]
# 将abs()的返回值作为排序依据
搭配匿名函数也可以进行排序：
li = [
{'name': 'xiaohong','age': 21},
{'name': 'xiaohong','age': 30},
{'name': 'xiaohong','age': 24},
{'name': 'xiaohong','age': 23},
]
# 现有如上list，想根据其中每个元素的age属性来进行排序：
li.sort(key=lambda person: person['age'])
print(li) # 输出：
# [{'name': 'xiaohong', 'age': 21},
# {'name': 'xiaohong', 'age': 23},
# {'name': 'xiaohong', 'age': 24},
# {'name': 'xiaohong', 'age': 30}]
匿名函数也可以作为参数传入别的函数进行调用：
def fn(a,b,fn):
return fn(a,b)
res = fn(1,2,lambda num1,num2: num1 + num2)
print(res) # 3
以上就是匿名函数的基本用法
