Python函数和 lambda表达式

Python提供了许多内置函数，比如：print()，len()等。它还支持用户自定义函数。

一、Python函数

1、函数定义使用

（1）函数定义

Python 允许我们将常用的代码以固定的格式封装（包装）成一个独立的模块，只要知道这个模块的名字就可以重复使用它，这个模块就叫做函数（Function）。

定义函数需要使用 def 关键字，一般格式如下：

def 函数名(参数列表):
    函数体
    [return [返回值]]

说明：

• 函数名：就是一个符合 Python 语法的标识符，推荐见名知意。
• 形参列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。
• 函数体：实现特定功能的多行代码
• [return [返回值] ]：可选参数，用于设置该函数的返回值。不带表达式的 return 相当于返回 None，即没有返回值。

（2） 函数使用

函数调用的基本语法格式：

[返回值] = 函数名([形参值])

示例代码如下：

# 自定义函数
'''
定义一个求 2个数之和的函数
'''
def my_sum(a, b):
    '''
        求 2个数之和
    '''
    sum = a + b
    print("my_sum 函数执行了")
    return sum


# 调用函数
res = my_sum(10, 2)
print("my_sum 返回值为：", res)

2、为函数提供说明文档

函数的说明文档通常位于函数内部、所有代码的最前面。

通过调用 Python 的 help() 内置函数或者 __doc__ 属性，可以查看某个函数的使用说明文档。

help(my_sum)
print("-----------")
print(my_sum.__doc__)

3、函数参数传递

python 中一切都是对象，在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

函数参数传递可以传不可变对象和传可变对象。可以理解为值传递还是引用传递，

• 不可变类型：适用于实参类型为不可变类型（字符串、数字、元组）。类似 Java的值传递
• 可变类型：适用于实参类型为可变类型（列表，字典）。类似 Java的引用传递

（1）传不可变对象实例

通过 id() 函数来查看内存地址变化。

def change(a):
    print(id(a))  # 指向的是同一个对象
    a = 10
    print(id(a))  # 一个新对象


a = 1
print(id(a))
print("-----调用函数之前------")
change(a)

（2）传可变对象实例

def changeme(mylist):
    """修改传入的列表"""
    mylist.append([1, 2, 3, 4])
    print("函数内取值: {}，id:{}", mylist, id(mylist))
    return


mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: {}，id:{}", mylist, id(mylist))

4、函数参数类型

4.1 位置参数

位置参数也称必需参数/必备参数，是指必须按照正确的顺序将实际参数传到函数中。

即调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致（传多传少都不行）。

示例代码如下：

def my_sum(a, b):
    sum = a + b
    print("my_sum 函数执行了")
    return sum

# 调用函数时，必须传递 2 个参数，否则会引发错误
res = my_sum(10, 2)
print("my_sum 返回值为：", my_sum(10, 2))

print("my_sum 返回值为：", my_sum(2))  # TypeError: my_sum() missing 1 required positional argument: 'b'

4.1.1 强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参：

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

# 正确调用函数
f(10, 20, 30, d=40, e=50, f=60)

# 错误调用函数
# f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式。 TypeError: f() got some positional-only arguments passed as keyword arguments: 'b'
# f(10, 20, 30, 40, 50, f=60)  # e 必须使用关键字参数的形式。TypeError: f() takes 4 positional arguments but 5 positional arguments (and 1 keyword-only argument) were given

4.2 关键字参数

关键字参数是指使用形式参数的名字来确定输入的参数值。

通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可。因为 Python 解释器能够用参数名匹配参数值。

示例代码如下：

def dis_str(str1, str2):
    print("str1=", str1)
    print("str2=", str2)

# 位置参数调用
dis_str("aaa", "bbb")
print("------1-----")
# 关键字参数调用
dis_str(str2="bbb", str1="aaa")
print("------2-----")
# 混合传参调用
dis_str("aaa", str2="bbb")

注意：位置参数和关键字参数可以混合传参。但是，混合传参时关键字参数必须位于所有的位置参数之后。

4.3 默认参数

Python 允许为参数设置默认值，即在定义函数时，直接给形式参数指定一个默认值。

默认参数是指调用函数时，如果没有传递参数，则会使用默认参数。

Python 定义带有默认值参数的函数，其语法格式如下：

def 函数名(...，形参名，形参名=默认值)：
    代码块

注意：

• 当定义一个有默认值参数的函数时，有默认值的参数必须位于所有没默认值参数的最后，否则会产生语法错误。
• 可以使用“函数名.__defaults__”查看函数的默认值参数的当前值，其返回值是一个元组。

示例代码如下：

# str1没有默认参数，str2有默认参数
def dis_str(str1, str2="str2222"):
    print("str1=", str1)
    print("str2=", str2)


dis_str("aaa")
print("------------")
dis_str("aaa", "bbb")

print("查看函数的默认值参数的当前值:", dis_str.__defaults__)

4.4 不定长参数

不定长参数是指一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数。

基本语法如下：

def functionname([formal_args,] *var_args_tuple|**var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

注意：

• 一种是参数带两个星号 *，表示会以元组(tuple)的形式导入，存放所有未命名的变量参数。
• 一种是参数带两个星号 **，表示参数会以字典(dict)的形式导入，存放所有未命名的变量参数。

示例代码如下：

# sarg1为位置参数，vartuple为可变参数
def printInfo1(arg1, *vartuple):
    print("printInfo1输出: ")
    print("arg1={}，type={}", arg1, type(arg1))
    print("vartuple={}, type={}", vartuple, type(vartuple))


def printInfo2(arg1, **vardict):
    print("printInfo2输出: ")
    print("arg1={}，type={}", arg1, type(arg1))
    print("vardict={}, type={}", vardict, type(vardict))


# 调用函数
printInfo1(70, 'abc', 60, 50, "www")
printInfo2(70, k1='abc', k2=60, k3=50, k4="www")

4、return函数返回值

Python中，用 def 语句创建函数时，可以用 return 语句指定应该返回的值。

• 该返回值可以是任意类型。
• 该返回值参数可以指定，也可以省略不写（不写 return 相当于返回 None）。

示例代码如下：

def changeme(mylist):
    mylist.append([1, 2, 3, 4])
    print("函数内取值: mylist={}，id(mylist){}", mylist, id(mylist))
    return mylist


mylist = [10, 20, 30]
print("调用函数之前: mylist={}，id(mylist){}", mylist, id(mylist))
mylist = changeme(mylist)
print("函数返回值: mylist={}，id(mylist){}", mylist, id(mylist))

二、lambda表达式

lambda 表达式，又称匿名函数，所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。常用来表示内部仅包含 1 行表达式的函数。

如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。

Python 使用 lambda 关键字来创建匿名函数。语法格式如下：

name = lambda [list] : 表达式

其中：

• name 为该 lambda表达式的名称。即调用函数名
• [list] 作为可选参数，等同于定义函数是指定的参数列表；

该语法格式转换成普通函数的形式，如下所示：

def name(list):
    return 表达式
name(list)

示例代码如下：求 2 个数之和的函数

# 使用普通函数的方式
def my_sum(a, b):
    sum = a + b
    return sum

sum = my_sum(10, 2)
print("使用普通函数的方式：sum= ", sum)

# 使用 lambda 表达式方式
sum_fun = lambda x, y: x + y
print("使用 lambda 表达式方式：sum= ", sum_fun(3, 5))

可以理解 lambda 表达式为简单函数（函数体仅是单行的表达式）的简写版本。相比函数，lamba 表达式具有以下 2 个优势：

• 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁；
• 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能。

– 求知若饥，虚心若愚。