ln函数怎么看奇偶性_【小白必看】python函数是什么？python函数的定义？ python函数怎么使用？...-CSDN博客

本文链接：https://blog.csdn.net/weixin_39852491/article/details/111642671

先上目录

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):
    pass

a, 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 形参:含形参的表达式