HOME/Articles/

Python中的函数

Article Outline

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


以上就是匿名函数的基本用法