Python中的函数
<!--more-->
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
以上就是匿名函数的基本用法