1.函数基础

1.1 函数定义

        在Python中，函数是一个可以重复使用的代码块，它接受零个或多个输入值（称为参数），并返回一个输出值。定义函数的语法如下：

def function_name(parameters):
    function_body
    return [expression]

        其中，function_name是函数的名称，parameters是函数参数列表，用逗号分隔。function_body是函数的主体，包括一系列语句和操作。return语句可选，用于返回函数的输出值，expression是要返回的表达式。

例如，我们定义了一个计算两个数之和的函数add：

def add(a, b):
    result = a + b
    return result

1.2 函数调用

        定义函数后，我们可以通过函数名称和参数来调用它。调用函数的语法如下

result = function_name(arguments)

        其中，function_name是要调用的函数名称，arguments是传递给函数的参数列表，用逗号分隔。result是函数的返回值。

 例如，我们可以调用add函数：

x = 3
y = 5
z = add(x, y)
print(z)

输出结果为8。

1.3 函数形参和实参

        在Python中，函数的参数分为形式参数和实际参数。形式参数通常是在函数定义时指定的，用于接收参数值，而实际参数是在函数调用时传递的具体数值。

        形式参数分为位置参数、默认参数和可变参数。位置参数是最常见的参数类型，按顺序依次传递给函数。默认参数是指在函数定义时设置默认值，如果没有传递则使用默认值。可变参数又分为两种：*args表示接受任意数量的位置参数，**kwargs表示接受任意数量的关键字参数。

例如，我们可以将add函数改写为支持默认参数和可变参数：

def add(a=0, b=0, *args, **kwargs):
    result = a + b
    for arg in args:
        result += arg
    for key, value in kwargs.items():
        result += value
    return result

        这里，我们将a和b设置为默认值0，同时使用*args接收任意数量的位置参数，**kwargs接收任意数量的关键字参数。例如，我们可以以不同的方式调用add函数：

# 传递位置参数
z1 = add(1, 2, 3, 4, 5)
print(z1)

# 传递关键字参数
z2 = add(a=1, b=2, c=3, d=4, e=5)
print(z2)

# 混合传递参数
z3 = add(1, 2, 3, 4, 5, c=6, d=7, e=8)
print(z3)

输出结果分别为15、18和36。

1.4 函数返回值

        函数可以返回一个或多个值，也可以不返回任何值。如果函数没有显式地使用return语句，则默认返回None值。

例如，我们定义一个计算平均数和方差的函数：

import math

def stats(numbers):
    n = len(numbers)
    mean = sum(numbers)/n
    variance = sum((x - mean)**2 for x in numbers)/n
    std_dev = math.sqrt(variance)
    return mean, variance, std_dev

函数stats接受一个列表作为输入，返回平均数、方差和标准差三个值。我们可以调用该函数：

nums = [1, 2, 3, 4, 5]
avg, var, std = stats(nums)
print("平均数：", avg)
print("方差：", var)
print("标准差：", std)

输出结果为：

平均数： 3.0
方差： 2.0
标准差： 1.4142135623730951

2.函数高级概念

2.1 函数调试

        在编写函数时，经常会出现一些错误和异常情况。Python提供了许多工具和技巧来帮助我们进行函数调试，以便及时发现和解决问题。

        其中，最常见的调试技巧是使用print语句，在代码中插入一些调试信息来帮助定位问题。另外，还可以使用断言（assert）语句，在代码中插入条件判断，用于检查和验证程序的正确性。此外，还可以使用Python自带的pdb调试器，以及其他第三方调试工具。

例如，我们可以使用print语句来调试add函数：

def add(a, b):
    print("参数a：", a)
    print("参数b：", b)
    result = a + b
    print("计算结果：", result)
    return result

x = 3
y = 5
z = add(x, y)
print("最终结果：", z)

输出结果为：

参数a： 3
参数b： 5
计算结果： 8
最终结果： 8

2.2 变量作用域

        在函数中定义的变量有其特定的作用域范围。在Python中，变量作用域分为全局作用域和局部作用域。全局作用域中的变量可以在整个程序中访问，而局部作用域中的变量只能在函数内部访问。

        如果在函数内部要访问全局变量，则需要使用global关键字进行声明。如果在函数内部要修改全局变量，则需要使用global关键字和赋值语句进行修改。

例如，我们定义一个函数，计算一个数的平方和：

total = 0

def square_sum(numbers):
    global total
    for num in numbers:
        total += num**2
    return total

此处，我们使用了全局变量total来记录平方和。在函数内部使用global关键字声明total为全局变量，并进行累加操作。我们可以调用该函数：

nums = [1, 2, 3, 4, 5]
result = square_sum(nums)
print("平方和：", result)

输出结果为：

平方和： 55

2.3 函数类型

        在Python中，函数可以作为变量、参数和返回值使用。这是因为Python将函数视为一种对象，具有类似于其他对象的属性和方法。

例如，我们可以定义一个函数，用于计算两个数之和：

def add(a, b):
    return a + b

 我们还可以定义一个函数，用于计算两个数之差：

def subtract(a, b):
    return a - b

        然后，我们可以定义一个函数，接受一个操作符和两个数作为参数，根据操作符的不同来调用不同的函数：

def do_math(op, a, b):
    if op == "+":
        return add(a, b)
    elif op == "-":
        return subtract(a, b)
    else:
        raise ValueError("无效的操作符")

result = do_math("+", 3, 5)
print(result)

输出结果为8。

 2.4 匿名函数

        Python支持使用lambda表达式创建匿名函数，也称为Lambda函数。Lambda函数通常用于简单的函数操作，可以极大地简化代码逻辑。

Lambda函数的语法如下：

lambda arguments: expression

其中，arguments是参数列表，用逗号分隔。expression是要返回的表达式。

例如，我们可以使用Lambda函数来创建一个计算平方和的函数：

square_sum = lambda numbers: sum(x**2 for x in numbers)
nums = [1, 2, 3, 4, 5]
result = square_sum(nums)
print("平方和：", result)

输出结果为55。

2.5 递归函数

        递归函数指调用自身的函数，通常用于解决问题的分治和归纳。在Python中，递归函数需要注意避免无限循环和栈溢出等问题。

例如，我们可以定义一个递归函数，求解斐波那契数列的第n项：

def fib(n):
    if n == 0 or n == 1:
        return n
    else:
        return fib(n-1) + fib(n-2)

result = fib(10)
print(result)

输出结果为55。

2.6 装饰器

装饰器是Python中的一种高级概念，可以用于动态修改或扩展函数的功能。装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。

装饰器的语法如下：

@decorator
def function_name(parameters):
    function_body
    return [expression]

其中，decorator是装饰器函数，function_name是被装饰的函数。

例如，我们可以定义一个装饰器函数，用于计算函数执行时间：

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print("函数执行时间：", end_time - start_time)
        return result
    return wrapper

然后，我们可以使用装饰器来修饰一个函数：

@timer
def add(a, b):
    time.sleep(1)
    return a + b

result = add(3, 5)
print(result)

输出结果为8，同时打印出函数执行时间：1.000511884689331。

3.常用内置函数

        Python提供了许多常用的内置函数，包括数字处理函数、字符串处理函数、列表处理函数、文件处理函数等。这些内置函数在Python编程中非常实用，也可以根据需要进行扩展和封装。

例如，我们可以使用内置函数map和reduce来对列表中的元素进行处理：

from functools import reduce

nums = [1, 2, 3, 4, 5]
square_nums = list(map(lambda x: x**2, nums))
sum_square_nums = reduce(lambda x, y: x+y, square_nums)
print(sum_square_nums)

输出结果为55。