函数详解

函数的定义和调用

代码有很多种坏味道，重复是最坏的一种，函数可以解决这个问题

减少代码的冗余，就是代码可以重复的使用

模块化的思想，就是将代码封装起来，需要用到的时候，就使用，不用这个代码的话，就可以不运行

每一个函数就是一个功能，需要自己定义

先定义函数，然后在调用函数

函数怎么定义的，有几个参数，调用函数的时候，就需要传入几个参数进去

如果函数定义的时候有return语句，想要获取都函数的返回值的话，就可以定义一个变量来接收返回值

函数的返回值

返回值则是调用函数后输出给调用方的信息，当然函数也可以只做处理，没有返回值

return返回结果，return操作后，函数结束，后面的语句也就不会执行

跟type方法一样，会返回一个结果出来，想要输出这个结果就需要打印这个结果

return返回的值，可以拿来使用，做一些其他的操作，可以直接使用

没有return的话，打印函数，返回的是一个None

def a():
    return  6*6

result = a()  # 变量赋值给result
print(result)

print(type(result))

返回的类型

函数返回结果同样支持各种对象,包含数字,支付串,列表,元组,也可以是函数和类

return后终止

return后的语句，不会生效，类似与循环中的break，后面的语句不会被生效

def a():
    return  6*6  # 执行到这，函数就结束了
    print("函数终止")  # 不会执行语句

result = a()  # 变量赋值给result
print(result)

return多个数据

返回多个值的话，返回就是一个元组，然后通过索引取到值

def b():
    return 3*3,5+2

print(b()) # 输出为(9, 7)

函数的参数

形参和实参

形参在函数内部使用

实参就是函数调用的时候，

list1 = [1,2,3,4,5,6,7,8,9,10]
list2 = [1,3,5,7,9]

def a(x): # 形参，任意变量即可，变量的类型根据传入的实参决定的，此时x就等于一个列表

    sum = 0
    for i in x:
        sum+=i
    print(sum) 

a(list1)  # 传入的就是一个实参，传入就是一个实际的参数
a(list2)

位置参数

参数按位置依次赋值

def a(x,y):
    print(x+y)

a(1,2)   # x=1,y=2 这样依次赋值才行

关键字参数

可以指定参数传递，不需要按照形参的位置进行传递

def a(x,y):
    print(x+y)

a(y=1,x=2)

# 传参的时候使用=进行传值

缺省参数

默认的参数

缺省参数必须要放在位置参数的后面，否则会报错的

def b(x,y=1):
    print(x+y)
b(1,y=9)

# 缺省参数不传入值的话，使用的就是默认参数
# 传入值话，就会覆盖缺省参数

不定参数

*args 参数，接收一个或者多个参数，合并成一个元组

def a(*args):  # args=(1,2,3) 就是一个元组
    print(args)

a(1)

# 输出为(1,) 

# 也就是说可以接收多个参数，会存入到一个元组中

**kwargs参数 接收一个或者多个参数，存入到字典中

def a(**kwargs):
    print(kwargs)
a(name="123")

# 输出为{"name":"123"}

参数总结

多个参数都使用的话，就是位置参数是在最前面的，缺省参数是在关键字参数的前面，关键字参数优先级最低的

函数的说明文档

函数的注释文档，就是函数里面的注释，能知道这个函数的作用是什么

def a(x,y,z):

# 使用""" 会自动是生成
    """
    # 用来计算数字的功能
    :param x: 第一个数字
    :param y: 第二个数字
    :param z: 第三个数字
    :return:  没有返回值
    """
    print("我是函数a的功能")

# 查询函数的说明文档
help(a)

# 输出为
Help on function a in module __main__:

a(x, y, z)
    # 用来计算数字的功能
    :param x: 第一个数字
    :param y: 第二个数字
    :param z: 第三个数字
    :return:  没有返回值

• 或者 调用函数的时候，鼠标悬浮上面

函数的嵌套调用

函数的嵌套调用，在一个函数中，调用另一个函数

函数的执行顺序就是看谁先调用，不是看谁先创建的

从上到下依次执行

def a():
    print("你好")
    b()

def b():
    print("世界")


a()

# 先从上到下执行，定义了2个函数，然后调用函数a,函数a里面有调用了函数b

# 输出结果为
你好
世界

函数的作用域

看定义的变量在不在函数里面，还是外面

全局作用域

定义在函数外部就是全局变量，都可以直接拿来使用

可以被任何地方访问

a = 10

def p():
    print(a)  # 函数里面也能使用

p()
print(a) # 函数外面也能使用

局部作用域

定义在函数内部的就是局部变量，在全局是无法访问的

a = 10
b = 100
def p():
    b = 20  # 局部变量
    # print(a)
    print(b)  # 使用的局部变量，如果函数里面有，就使用函数里面定义的变量，没有的话，就使用全局变量定义的

p()
print(b)  # 使用的是全局变量

global关键字

就是将局部变量变成全局变量,从而实现修改了全局变量

在函数里面声明全局变量

用的比较的少

修改全局变量a

a = 200
def b():
    global a  # 将a变成了全局变量
    a = 100
    print(a)

b()
print(a)


# 输出为
100
100

闭包

一般开发中不用，但是需要了解写法和作用

外部函数，内部函数，内部函数使用外部函数的局部变量，外部函数返回了内部函数

def a():
    x = 10
    def b():
        print(x)
    return  b  # 返回的是内部函数的地址

m = a()
m()  # 调用内部函数

递归函数

是一种编程的思想

但是开发一般中不会经常使用

函数内部自己调用自己，必须要有出口，就是一直调用后，函数自己停止下来

def a(num):
    if num == 1:
        return 1
    else:
        return num + a(num-1)

res = a(3)
print(res)

• 代码的逻辑是什么呢？

# 第一种思路
a(3) = 3+a(2) = 3+2+a(1) = 3+2+1=6


# 第二种思路
a(3) num = 3  return 3+a(2)

a(2)  num = 2 return 2+a(1)

a(1)  num = 1 return 1 

然后依次往回推

a(1) = 1
a(2) = 2+1
a(3) = 3+2+1=6

匿名函数

也是做一个了解

当我们需要临时使用一个操作比较简单的函数时，可以使用匿名函数：lambda表达式，格式如下。

lambda 参数: 返回值


add = lamda x,y: x+y

a = lambda x,y:x+y

print(a(1,2))

# a = 等于这个匿名函数名

# 通过调用a来实现匿名函数的调用(),还是需要传入参数的

高阶函数

高阶函数的定义

函数的参数可以数字，字符串，列表，字典，也可以使用函数对象

已函数为参数的函数称为高阶函数

# 定义函数用于显示一个函数的信息

def info(func):
    print("函数的名称:",func.__name__)
    print("函数的描述:",func.__doc__)
    print(func(1,2))  # func形参接收的是一个函数地址，那么可以通过这个地址来调用函数

def add(x,y):
    """ 加法函数 """
    return  x+y

info(add)

# 输出为
函数名称: add
函数描述: 加法函数

装饰器

就是一种典型的以函数为参数的函数，装饰器目的就是通过包装，来为函数增加响应的功能

装饰器，一个能够批量给函数前后添加代码的工具

前置的条件就是：是嵌套函数，且外部函数的返回值为内部函数

def tool(old_func): # 里面传入的是函数
    def new_func():
        print("执行前")
        old_func()  #原来的函数调用
        print("执行后")

    return new_func  # 返回的是内部函数的地址

@tool   # 等价于 hello = tool(hello)  等价于 hello = 内部函数的地址
def hello():  # 原函数
    print("大家好!")

hello()  # 拿到了内部函数的地址，通过这个地址来调用内部函数

函数名 = tool(原函数)

常用的高阶函数

map,filter,reduce

其他

函数地址

调用函数的本质就是函数地址()直接调用

直接打印函数名

def a():
    print("nihao")

print(a)

# 输出的是函数的地址 <function a at 0x00000290EE34F240>

# 地址() 地址添加一个括号，就相当于调用
a()

那我们是不是可以将这个地址赋值给一个变量，通过定义的这个变量来调用函数呢？

def a():
    print("nihao")

b = a  # 将地址赋值给这个变量，那么可以通过这个变量()实现调用函数

b()

函数返回值作为其他函数的实参

添加购物车的时候，会先判断你是否登录了

登录一个函数，有一个返回值，作为添加购物车传入的实参，这样做的话，必须要有一个return语句返回才行

添加购物车一个函数

def login():
    if "登陆了":
        return 1
    else:
        return 0

r = login()

def add(x):
    if x == 1:
        print("添加成功")
    else:
        print("请先登录")

add(r)

global关键字

对于不可变的数据，字符串，元组，整数，浮点数，布尔， 想要在函数里面进行修改，必须使用global声明

对于可变的数据，列表，集合，字典，这些不需要声明，可以直接在函数里面进行修改

函数最大的作用

• 就是实现了函数的个性化调用，函数定义一个功能

• 调用不同的参数实现不同的功能