多个返回值

如果一个函数要有多个返回值，该如何书写代码？

1
2
3
4
5
def test_return():
 return 1,2
x,y = test_return()
print(x)  #结果1
print(y)  #结果2

按照返回值的顺序写对应顺序的多个变量接收即可

变量之间用逗号隔开

支持不同类型的数据return

1
2
3
4
5
6
7
8
9
10
11
"""
演示函数的多返回值示例
"""
#演示使用多个变量，接收多个返回值
def test_return():
    return 1,2,3

x,y,z = test_return()
print(x)
print(y)
print(z)

其中 1，2，3 的类型不受限，需要注意顺序问题，第一个数值对应第一个类型，依次类推

1
2
3
4
5
6
7
8
9
10
11
"""
演示函数的多返回值示例
"""
#演示使用多个变量，接收多个返回值
def test_return():
    return 1,"hello",True

x,y,z = test_return()
print(x)
print(y)
print(z)

位置参数

调用函数时根据函数定义的参数位置来传递参数

1
2
3
4
5
def user_info(name,age,gender):
 print(f'您的名字时{name},年龄是{age},性别是{gender}')


     user_info('TOM',20,'男')

注意：

传递的参数和定义的参数的顺序及个数必须一致

关键字参数

函数调用时通过”键=值“形式传递参数

可让函数更加清晰，容易使用，同时也清除了参数的顺序需求

1
2
3
4
5
6
7
8
def user_info(name,age,gender):
    print(f"您的名字是：{name}，年龄是：{age}，性别是：{gender}")
#关键字传参
user_info(name="小明",age=20,gender="男")
#可以不按照固定顺序
user_info(age=20,gender="男",name="小明")
#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明",age=20,gender="男")

注意：

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def user_info(name,age,gender):
    print(f"您的名字是：{name}，年龄是：{age}，性别是：{gender}")
#位置参数 - 默认使用形式
user_info('小明',20,'男')
#关键字传参
user_info(name="小王",age=11,gender="女")
#可以不按照固定顺序
user_info(age=10,gender="女",name="小文")
#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("敏婕",age=9,gender="女")

#缺省参数（默认值）

#不定长 - 位置不定长，*号

#不定长 - 关键字不定长，**号

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值

1
2
3
4
5
6
def user_info(name,age,gender='男'):
    print(f'您的名字是：{name}，年龄是：{age}，性别是：{gender}')


user_info('TOM',20)
user_info('Rose',18,'女')

注意：

函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值

不定长参数

也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景

当调用函数时不确定参数个数时，可以使用不定长参数

类型：

位置传递

1
2
3
4
5
6
7
8
def user_info(*args):
    print(args)


#('TOM',)
user_info('TOM')    
#('TOM',18)
user_info('TOM',18)

注意：

传进的所有参数都会被 args 变量收集，它会根据传进参数的位置合并为一个元组（tuple），args 是元组类型，这就是位置传递

位置不定长传递以*号标记一个形式参数，以元组的形式接受参数，形式参数一般命名为 args

1
2
3
4
5
6
7
#不定长 - 位置不定长，*号
#不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
print(f"args参数的类型是：{type(args)},内容是:{args}")

    user_info(1,2,3,'小明','男孩')
    #不定长 - 关键字不定长，**号

关键字传递

1
2
3
4
5
6
def user_info(**kwargs):
    print(kwargs)


#('name': 'TOM', 'age': 18, 'id': 110)
user_info(name='TOM', age=18, id=110)

注意：

参数是”键=值“形式的形式的情况下，所有的”键=值“都会被 kwargs 接受，同时会根据”键=值“组成字典。

关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为 kwargs

1
2
3
4
5
#不定长 - 关键字不定长，**号
def user_info(**kwargs):
    print(f"args参数的类型是：{type(kwargs)},内容是:{kwargs}")

user_info(name="小王", age=11, gender="女")

匿名函数

函数作为参数传递

如下代码：

1
2
3
4
5
6
7
8
def test_func(compute):
    result = compute(1,2)
    print(result)

def compute(x,y):
  return x + y

test_func(compute)     #结果：3

函数 compute 作为参数，传入了 test_func 函数中使用

  • test_func 需要一个函数作为参数传入，这个函数需要接收 2 个数字进行计算，计算逻辑由这个被传入函数决定
  • compute 函数接收 2 个数字对其进行计算，compute 函数作为参数，传递了 test_func 函数使用
  • 最终，在 test_func 函数内部，由传入的 compute 函数，完成了对数字的计算操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
演示函数作为参数传递
"""

#定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1,2)  #确定compute是函数
    print(f"compute参数的类型是：{type(compute)}")
    print(f"计算结果：{result}")
#定义一个函数，准备作为参数传入另一个函数
def compute(x,y):
    return x + y
#调用，并传入函数
test_func(compute)

将函数传入的作用在于：传入计算逻辑，而非传入数据

lambda 匿名函数

函数的定义中

  • def 关键字，可以定义带有名称的函数
  • lambda 关键字，可以定义匿名函数（无名称）

有名称的函数可以基于名称重复使用

无名称的匿名函数只可临时使用一次

匿名函数定义语法

**lambda **传入参数：函数体（一行代码）

  • lambda 是关键字，表示定义匿名函数
  • 传入参数表示匿名函数的形式参数，如：x，y 表示接收 2 个形式参数
  • 函数体，就是函数的执行逻辑，要注意：只能写一行，无法书写多行代码
1
2
3
4
5
6
7
8
9
10
"""
演示lambda匿名函数
"""

#定义一个函数，接受其他函数输入
def test_func(compute):
    result = compute(1,2)
    print(f"结果：{result}")
#通过lambda匿名函数的形式，将匿名函数作为参数传入
test_func(lambda x,y: x + y)

注意：

  • 匿名函数用于临时构建一个函数，只能用一次的场景
  • 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用 lambda 匿名函数，应使用 def 定义带名函数

map 函数

map（）函数是一个内置的高阶函数

参数 1：传入一个函数，这个函数可以是内置的，也可以是自己定义，也可以是匿名函数

参数 2：是可迭代对象，如列表，字符串等等

该函数返回一个 map 对象，是个迭代器

注意不是列表不能直接输出，可以通过 for 循环或 list（）来显示

map 函数将 iterable 中的每一个元素执行一遍 function，结果以 map 对象的形式返回

注意，iterable 后还有省略号，即可以传多个 iterable，如果有额外的 iterable 参数，并行的从这些参数中取元素，并调用 function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def square(x):
    return X*X
a = map(square,[1,2,3])
print(a)
print(list(a))
#map返回的实际上是一个map对象
#也可以通过for循环来取出内容
def square(x):
    return X*X
a = map(square,[1,2,3])
ls = []
for i in a:
    ls.append(i)
print(ls)
#也可以使用推导式
def square(x):
    return X*X
a = map(square,[1,2,3])
ls = [item for item in a] 
print(ls)