函数

函数

函数_介绍

\(在程序中需要反复执行的代码，通常被封装为“函数”。\)

\(在python中的函数很灵活。\)

在类之外定义	函数
在类之内定义	方法

函数_创建

\(自定义函数的语法格式如下：\)

def 函数名(形参列表):
  函数体
  return 返回值 # 如果不返回数据，可以省略return语句

函数_调用

使用位置参数调用函数

def rect_area(width,height):
    area = width * height
    return area
r_area = rect_area(369.57,410) # 实参顺序受形参顺序限制，第一个形参是width，第二个形参是height；实参与此对应：369.57是width，410是height
print("{0} × {1} 长方形的面积：{2:.2f}".format(369.57,410,r_area))
# 输出：
# 369.57 × 410 长方形的面积：151523.70

使用关键字参数调用函数

• \(关键字的名称就是定义函数时形参的名称\)
• \(如此这般，实参顺序不再受形参顺序限制\)

def rect_area(width,height):
    area = width * height
    return area
r_area = rect_area(width=369.57,height=410)
print("{0} × {1} 长方形的面积：{2:.2f}".format(369.57,410,r_area))

r_area = rect_area(height=410,width=369.57) # 实参顺序不受限制
print("{0} × {1} 长方形的面积：{2:.2f}".format(369.57,410,r_area))
# 输出：
# 369.57 × 410 长方形的面积：151523.70
# 369.57 × 410 长方形的面积：151523.70

使用关键字参数调用函数的好处

• \(调用者能清晰地看出所传参数的含义，提高函数调用的可读性\)

函数_参数的默认值

Python函数的默认值是指在定义函数时，为参数提供的预设值。如果调用函数时没有传递相应参数的值，则会使用默认值作为参数的值。在函数定义中，可以通过在参数名后加上等号和默认值来指定参数的默认值。例如：

def make_coffee(name="卡布奇诺"):
    return "制作一杯{0}咖啡".format(name)
coffee1 = make_coffee("拿铁")  # 提供参数
coffee2 = make_coffee()  # 不提供参数，使用默认值
print(coffee1)
print(coffee2)
# 输出：
# 制作一杯拿铁咖啡
# 制作一杯卡布奇诺咖啡

---

函数_可变参数

■ 基于元组的可变参数（\(*args\)）

  基于元组的可变参数指的是使用"\(*args\)"语法定义函数参数，在函数调用时可以传入任意数量的位置参数，这些参数将被自动打包成一个元组(args)并传递给函数。在函数内部，可以通过对args元组进行索引操作来获取对应的参数值。

def my_func(*args):
    for arg in args:
        print(arg)

my_func(1, 2, 3)  # 输出：1 2 3

■ 基于字典的可变参数（\(**kwargs\)）

  基于字典的可变参数指的是使用"\(**kwargs\)"语法定义函数参数，在函数调用时可以传入任意数量的关键字参数，这些参数将被自动打包成一个字典(kwargs)并传递给函数。在函数内部，可以通过对kwargs字典进行键值对的操作来获取对应的参数值。

def my_func(**kwargs):
    for key, value in kwargs.items():
        print(key, "=", value)

my_func(name="Alice", age=20)  # 输出：name = Alice, age = 20

需要注意的是，"*args"和"**kwargs"只是一种约定俗成的写法，实际上可以使用任意名称来表示可变参数。但是建议保持这个约定以提高代码的可读性和可维护性。

---

函数_变量的作用域

Python中全局变量和局部变量的作用域规则与C++有所不同。

在Python中，如果在函数内部声明一个变量并将其设置为一个值，该变量默认是局部变量。如果要在函数内部使用全局变量，则必须使用global关键字显式声明该变量。

在C++中，变量可以被定义为全局变量或局部变量。全局变量可以在整个程序中访问，而局部变量只能在它们被定义的代码块中访问。C++还允许通过使用关键字extern来声明全局变量，从而使得在多个文件中都可以使用同一全局变量。

x=20
def print_value():
    x=10
    print("函数中x = {p1}".format(p1=x))

print_value()
print("全局变量x = {p1}".format(p1=x))
# 输出：
# 函数中x = 10
# 全局变量x = 20

若在模块和函数中定义两个同名变量，因为会发生命名冲突，函数中的同名变量会屏蔽“在函数外、模块中”的同名变量（如上例的 x=20）。如果要在函数内部使用全局变量，则必须使用global关键字显式声明该变量。

x=20
def print_value():
    global x  # 将x变量提升为全局变量
    x=10  # 全局变量被修改为10
    print("函数中x = {p1}".format(p1=x))

print_value()
print("全局变量x = {p1}".format(p1=x))

# 输出：
# 函数中x = 10
# 全局变量x = 10

函数类型

在Python中，函数是一种对象，因此也有自己的类型，称为函数类型。可以使用内置函数type()来获取一个函数的类型，它将返回<class 'function'>。

函数类型使得函数成为一等公民，可以像其他对象一样被处理和传递，例如可以将函数作为参数传递给另一个函数，或者将函数作为另一个函数的返回值。这种能力使得Python非常适合用于函数式编程和其他高级编程技术。

# 定义加法函数
def add(a,b):
    return a+b

# 定义减法函数
def sub(a,b):
    return a-b

# 定义计算函数
def calc(opr):
    if opr=='+':
        return add
    else:
        return sub
f1=calc('+') # f1实际上是add()函数
f2=calc('-') # f2实际上是sub()函数
print("10 + 5 = {0}".format(f1(10,5)))
print("10 - 5 = {0}".format(f2(10,5)))

# 输出：
# 10 + 5 = 15
# 10 - 5 = 5

# 定义加法函数
def add(a,b):
    return a+b

# 定义减法函数
def sub(a,b):
    return a-b

# 定义平方函数
def square(a):
    return a*a

# 定义计算函数
def calc(opr):
    if opr=='+':
        return add
    elif opr=='-':
        return sub
    elif opr=='self':
        return square

f1=calc('+') # f1实际上是add()函数
f2=calc('-') # f2实际上是sub()函数
f3=calc('self') # f3实际上是square()函数

print("10 + 5 = {0}".format(f1(10,5)))
print("10 - 5 = {0}".format(f2(10,5)))
print("10 * 10 = {0}".format(f3(10)))
# 输出：
# 10 + 5 = 15
# 10 - 5 = 5
# 10 * 10 = 100

注意，有两个参数的函数和有一个参数的函数是不同的函数类型。

解释来说，在Python中，函数的类型基于其参数数量和返回值类型来定义。有两个参数的函数和有一个参数的函数是不同的函数类型，因为它们的参数数量不同。所以即使两个函数的名称相同，但如果它们的参数数量不同，它们仍然被认为是不同的函数类型。这是因为Python使用参数数量和类型来解析函数调用，从而决定如何处理传递给函数的参数。

---

内置函数_过滤函数filter()

■ 函数原型

filter(function, iterable)

参数function是一个提供过滤条件的函数，返回布尔值。
参数iterable是容器类型的数据

■ 函数详解

filter()函数是一个内置函数，用于筛选序列（如列表、元组、集合等）中符合特定条件的元素，并返回一个新的迭代器对象。它接受两个参数，第一个参数是一个函数或lambda表达式，用于对序列中每个元素进行判断；第二个参数是待筛选的序列。该函数会将序列中的每个元素依次传入第一个参数中进行判断，如果判断结果为True，则保留该元素，否则过滤掉该元素。最终，filter()函数返回一个包含所有未被过滤的元素的迭代器对象。

# 设置过滤条件函数
def f1(x):
    return x>50

data_1=[66,15,91,28,98,50,7,80,99]
filtered=filter(f1,data_1)
data_2=list(filtered) # 将迭代器对象转换为列表以便打印输出
print(data_2)
print(filtered) # 返回一个迭代器对象

# 输出：
# [66, 91, 98, 80, 99]
# <filter object at 0x000002627CEB4A30>

■ 注意

filter()函数的返回值并非列表，若需要返回列表类型的数据，还需要通过list()函数进行转换。

内置函数_映射函数map()

map()函数是Python内置的高阶函数之一，用于对可迭代对象中的每个元素应用给定函数，并返回一个包含结果的迭代器。

■ 基本语法

map(function, iterable, ...)

其中 function是要应用于每个元素的函数，iterable是需要进行映射操作的可迭代对象。可以提供多个可迭代对象，map()函数将以并行方式处理它们。返回值是一个迭代器对象，可以使用list()函数将其转换为列表形式。

■示例

以下代码将列表[1, 2, 3]中的每个元素乘以2并生成一个新的列表：

result = map(lambda x: x * 2, [1, 2, 3])
print(list(result)) # Output: [2, 4, 6]

当map函数的参数表包含多个可迭代对象时，它将并行迭代这些可迭代对象，并将每个元素作为参数传递给一个函数。下面是一个示例，演示如何使用map函数对两个列表进行相加：

a = [1, 2, 3]
b = [4, 5, 6]

result = map(lambda x, y: x + y, a, b)

print(list(result))

输出：

[5, 7, 9]

在上面的代码中，我们定义了两个列表a和b，然后使用map函数对它们进行相加操作。在map函数中，我们传递了一个lambda函数来将两个参数相加，然后将a和b作为迭代器的输入。

由于map返回一个迭代器对象，所以我们最终将其转换为一个列表并打印结果。运行代码后，我们可以看到列表[5, 7, 9]，表示将a和b中的相应元素相加所得到的结果。

■ 原理解释

在调用map()函数时，iterable会被遍历，它的元素会逐一传入function()函数中，在function()函数中对元素进行变换。

---

内置函数_匿名函数lambda()

■ 介绍

lambda函数是匿名函数，即没有函数名的函数。

■ 语法

lambda 参数列表:lambda体
# lambda的参数列表与普通函数的参数列表一样，只不过不需要用小括号括起来

需要注意的是：lambda体部分不能是一个代码块，不能包含多条语句，只有一条语句。语句会计算一个结果并作为返回值。与有名函数不同的是，lambda不需要return语句进行返回。

■ 示例

data_1=[66,15,91,28,98,50,7,80,99]
filtered=filter(lambda x: (x>50),data_1)
data_2=list(filtered)
print(data_2)

# 输出：
# [66, 91, 98, 80, 99]

■ 理解

lambda()函数是一种匿名函数，可以在创建时定义并使用。它通常用于需要一个简单函数的地方，这些函数不需要定义一个完整的函数来使用。

---