python使用函数的优点是什么_【小白必看】python函数是什么？python函数的定义？ python函数怎么使用？...

先上目录1、函数是什么

2、定义函数

3、空函数

4、多个返回值

5、函数的参数

6、递归函数

7、函数的作用域

8、函数式编程

9、函数作为返回值返回

10、函数的闭包

11、匿名函数 lambda

函数是什么？

定义：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

作用：函数能提高应用的模块性，和代码的重复利用率。

函数是 python 的一等公民，函数也是对象。

使用函数有两个步骤：

1、定义函数 def 函数名(): 函数体

2、调用函数 函数名()

定义函数

用 def关键字来定义对象。

# 无参无返回值

def foo():

语句

# 有参无返回值

def foo(x, y):

z = x + y

# 无参有返回值

def foo():

x =1

return x + 1

# 有参有返回值

def foo(x, y):

return x + y

空函数

暂时还没有想好怎么去定义函数，可以用 pass 占个坑。

def emptyfunc():

pass

多个返回值

return多个值，其实是返回一个元组。

def foo():

x, y, z = 1, 2, 3

return x,y,z

# 返回一个元组

tup = foo()

# 元组拆包

x1, y1, z1 = foo()

函数的参数

必选参数

def foo(x, y, z):

pass

默认参数

假如不传 x 参数的话，x 默认是等于 1

def foo(x=1):

pass

可变参数（*）

定义：​​​​​​​

def foo(*args):

pass

调用：

（1）不定长传参

foo(1,2,3,4,5)

（2）元组和列表的压包​​​​​​​

foo(*(1,2,3,4,5))

# or

foo(*[1,2,3,4,5])

关键字参数（**）

定义：​​​​​​​

def foo(**kwargs):

pass

其中kwargs是一个字典。

调用：

（1）传入键值对

foo(k1=v1, k2=v2)

（2）传入字典变量（d是一个字典变量）

foo(**d)

命名关键字参数（ * ）

定义：​​​​​​​

def foo(a, b, *, k1, k2, k3):

passa, b是普通参数，k1, k2, k3 是命名关键字参数

命名关键字参数需要一个特殊分隔符 *，后面的参数被视为命名关键字参数

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符 * 了

调用：

foo(a, b, k1=v1, k2=v2, k3=v3)

参数组合

定义：​​​​​​​

def fun(parameter, *args, keyparameter, **kwargs):

pass

参数定义顺序：

​

函数的递归​​​​​​​

# 典型案例：斐波那契数列

def fib_recursion(idx):

if idx <= 2:

return 1

else:

return fib_recursion(idx-1) + fib_recursion(idx-2)

注意：必须设置函数终止条件

使用递归优点是逻辑简单清晰，缺点是过深调用导致栈溢出

函数的作用域外部不能访问函数内部变量

函数内部能够访问外部变量

函数内部不能修改外部变量，强行修改需要加 global 外部变量 = 新值

函数内部和函数外部变量名可以相同，但需要注意访问优先级

# 例子一，内部访问同名变量，不要在内部变量定义之前去访问

g = 1

def foo():

print(g) # 报错 UnboundLocalError: local variable 'g' referenced before assignment

g = 2

print(g) # 2

foo()

print(g) # 1

# -------------------- #

# 例子二，采用global关键字，会把内部变量g声明成全局变量，从而在函数内部可以改变全局变量

g =1

def foo():

global g

print(g) # 1

g =2

print(g) # 2

foo()

print(g) # 2

函数式编程

高阶函数

map

用法：map(函数名，列表/元组/集合/字符串)

说明：把传入的函数依次作用于每个元素，处理完后返回的是生成器类型，需要用list生成数据

li =[1, 2, 3, 4, 5]

def add1(x):

return x +1

add_li =list(map(add1, li)) # [2, 3, 4, 5, 6]

filter

用法：filter(函数名, 列表/元组/集合/字符串)

说明：filter()把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素，处理完后返回的是生成器类型，需要用list生成数据​​​​​​​​​​​​​​

li =[1, 2, 3, 4, 5, 6]

def ven_num(n):

if n%2==0:

return n

even_li =list(filter(even_num, li)) # [2,4,6]

​​​

reduce()

用法：reduce(函数名，列表/元组/集合/字符串)

说明：reduce() 用于对参数序列中元素进行累积。python3 中，reduce 已经被从全局名字空间里移除了，它被放置在functools模块里

from functools importreduce

li =[1, 2, 3, 4, 5]

m =reduce(lambda x, y : x+y, li) # m=15

返回函数（函数名作为返回值返回）​​​​​​​

def outer_foo(*args):

def inner_foo():

for i in args:

print(i)

return inner_foo

​​​​​​​f = outer_foo(1, 2, 3, 4, 5)

f() # 1 2 3 4 5

函数的闭包​​​​​​​

# 典型案例1:

# 外部函数只是返回了函数名的列表，但并没有调用。等到内部函数被调用的时候，外部函数已经迭代完毕，最终的i变成3，所以f1()、f2()、f3()相当于执行了三次f(),返回3*3=9

​​​​​​​def count():

fs =[]

for i inrange(1, 4):

def f():

return i*i

fs.append(f)

return fs

f1, f2, f3 = count()

print(f1()) # 9

print(f2()) # 9

print(f3()) # 9

# 典型案例2:

# 外部函数返回的是内部函数名的调用，所以结果和案例1不相同

def count():

def f(j):

def g():

return j*j

return g

fs =[]

for i inrange(1, 4):

fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()

return fs

​​​​​​​f1,f2,f3 = count()

print(f1()) # 1

print(f2()) # 4

print(f3()) # 9

匿名函数

语法：lambda 形参:含形参的表达式​​​​​​​

f = lambda x:x+1

print(f(1)) # 2

lambda 返回的是函数名（函数地址）

lambda 常常与map、filter、reduce、sorted等联合使用