【Python从入门到精通】函数详解

标签：function 入门 Python 详解参数 print def 函数

【上图来源于网络图片】

Why do Python programmers prefer dark mode?
Because light attracts bugs.

Python的简洁性和易读性，认为这是吸引Python程序员的原因。

【Python从入门到精通】专栏课程：

1、【Python从入门到精通】认识Python

2、【Python从入门到精通】变量&数据类型

3、【Python从入门到精通】列表&元组&字典&集合

4、【Python从入门到精通】运算符&控制语句

5、【Python从入门到精通】异常详解

一、函数

在Python中，函数是一种用于封装可重复使用的代码块的机制，可以接受参数并返回一个值。函数在程序中起到模块化和代码复用的作用，能让代码更加清晰、简洁和易于维护。

1.1 函数的定义

在Python语法中函数需要通过def关键字来定义。

def function_name(parameters):
    """函数文档字符串"""
    # 函数体（代码块）
    return expression  # 可选

function_name: 函数名，用于调用函数。
parameters: 函数的参数列表，可以是零个或多个，用于传递信息给函数。
文档字符串(docstring): 对函数功能进行描述的字符串，可以通过help()来查看函数的说明。
函数体: 函数执行的具体代码块。
return expression: 用于返回函数的结果，可以有多个return语句，但一旦执行某个return语句，函数即终止并返回相应的值。

1.2 函数调用

定义完函数之后，可以通过函数名加括号()来调用函数，并且可以传递参数给函数。

result = function_name(argument)

1.2.1 有参无返回值函数

def test_f1(name):
    print(name)
    print("方法体")

test_f1("张三")

我们观察上述代码可以发现test_f1函数的定义在调用的前面，这是因为Python是一门解释型语言，在解释器执行代码时，它会逐行解释代码，并且必须在使用一个对象之前先定义它。这种执行模式决定了函数必须在调用之前被定义，以便解释器在进行函数调用时知道如何执行对应的代码。

当解释器遇到一个函数调用时，它会去查找该函数定义的位置，如果该函数没有在调用之前被定义，解释器会抛出一个NameError异常，因为它无法找到对应的函数体。

test_f1("张三")

def test_f1(name):
    print(name)
    print("方法体")

1.2.2 有参有返回值函数

def test_f1(name):
    print(name)
    print("方法体")
    return "我的名字是：" + name

str1 =  test_f1("张三")
print(str1)

1.2.3 无参无返回值

def test_f1():
    print("方法体")

test_f1()

1.2.4 无参有返回值

def test_f1():
    print("方法体")
    return 29

age = test_f1()
print(age)

1.3 参数

1.3.1 位置参数

所谓的位置参数也就是说我们在调用函数时按照函数的参数列表中参数的定义顺序进行传参。

def test_f1(name,age):
    print("我是",name)
    print("今年我",age,"岁！")

test_f1("王五",29)

1.3.2 关键字参数

在调用函数时通过key=value方式传递的参数，不受顺序影响。

def test_f1(name,age):
    print("我是",name)
    print("今年我",age,"岁！")

test_f1(age=29,name="王五")
test_f1(29,"李四")

1.3.3 默认参数

在函数定义时我们可以给参数设置默认值，如果参数有默认值，那么用户在不给该形参传递实参时自定义的默认值就会赋值给对应的参数。

def test_f1(name,age=28):
    print("我是",name)
    print("今年我",age,"岁！")

test_f1("张三")

1.3.4 可变参数

所谓的可变参数就是指参数的数量是不确定的，也就是我们在函数中的形参里面定义了可变参数后，我们再去调用函数时往可变参数中传递的参数个数是动态的。

Python提供了两种类型的可变参数：*args（位置可变参数）和**kwargs（关键字可变参数）。

1、*args

使用*args允许函数接受任意数量的位置参数。*args会将传递给函数的所有位置参数打包成一个元组（tuple）的形式，然后在函数体内部使用。

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

my_function(1, 2, 3) 
my_function('a', 'b', 'c', 'd')

2、**kwargs

使用**kwargs允许函数接受任意数量的关键字参数。**kwargs会将传递给函数的所有关键字参数打包成一个字典（dict），其中关键字是参数名，值是参数值。

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

my_function(name='diamond技术流', age="30")

注意：若一个函数的形参列表中即存在可变参数又存在非可变参数，那么可变参数要放在末尾。

1.4 Lambda函数

Lambda函数是一种匿名函数，也称为内联函数或函数字面量，在Python中用于创建简单的函数。Lambda函数是一种快速创建小型函数的方式，通常用于一次性的函数需求。

lambda arguments: expression

lambda: 定义Lambda函数的关键字。
arguments: Lambda函数的参数，可以是零个或多个。
expression: Lambda函数的返回值表达式。

Lambda函数的特点如下所示：

匿名性：Lambda函数是匿名的，没有函数名。
简洁性：Lambda函数通常用于简单的函数，可以将函数定义压缩在一行代码中。
一次性使用：Lambda函数通常用于一次性的功能需求，不会存储以供将来使用。
函数对象：Lambda函数返回一个函数对象，可以将其赋给变量，并像普通函数一样调用。

1.4.1 单个参数形式

x = lambda a:a+10
print(x(10))

1.4.2 多个参数

x = lambda a,b:a+b
print(x(10,20))

1.4.3 没有参数

x = lambda :100
print(x())

1.4.4 作为参数传递

Lambda函数常用在高阶函数（接受函数作为参数的函数）中，比如map()、filter()、sorted()等内置函数。

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)
print(list(squared))

1.5 作用域

Python中函数内部有一个本地作用域，外部有一个全局作用域，函数可以在局部作用域访问全局作用域的变量。

1.6 函数递归

函数递归是指在函数定义中调用自身的过程。在Python中，递归是一种强大的编程技术，允许函数解决复杂的问题并使代码更加优雅。递归函数通常包括两个部分：基本情况（Base Case）和递归情况（Recursive Case），其中基本情况用于结束递归过程，递归情况则是通过调用自身来解决更小规模的问题。

递归的特点：

自相似性：递归函数会将大问题分解成更小规模的相似子问题。
函数调用自身：在函数内部调用自身，形成递归调用链。

递归的优点：

代码简洁优雅：递归可以使代码更加简洁易懂。
问题表达优势：递归可以更自然地表达一些问题，如树形数据结构遍历等。

递归的缺点：

性能开销：递归调用会增加函数调用栈的开销，可能引起性能问题。
栈溢出风险：递归调用过深会导致栈溢出错误。

注意：在递归中必须要有基本情况用于结束递归，否则可能会引发栈溢出错误。

下面我们通过递归来实现数学中的阶乘。

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

result = factorial(5)
print(result)

1.7 函数重载

Python中并未提供函数重载机制。

1.8 函数嵌套

在Python中，函数嵌套是指在一个函数的内部定义另一个函数。通过函数嵌套，我们可以在一个函数内部创建其局部函数，这样可以提高代码的模块化、封装性和可读性。在函数嵌套中，内部函数可以访问外部函数的变量，但外部函数无法访问内部函数的变量。

def outer_function():
    
    # 外部函数
    def inner_function():
        # 内部函数
        pass

    # 外部函数内的操作
    inner_function()  # 调用内部函数

# 调用外部函数
outer_function()

def outer_function():
    x = 10  # 外部函数的变量

    def inner_function():
        print(x)  # 内部函数可以访问外部函数的变量

    inner_function()  # 调用内部函数

outer_function()

注意：函数嵌套还可以用来创建闭包。

闭包是一个包含自由变量的函数对象，即便在函数返回后这些自由变量依然可以被访问。闭包通常用于保持函数状态。

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))
print(closure(6))

在上面的示例中，inner_function()被作为一个闭包返回，保留了x的值，即使outer_function()已经执行完毕。

通过函数嵌套，Python代码可以更加模块化，函数更加灵活，可以灵活地利用作用域和变量共享的特性。函数嵌套也使得代码更加易读，利于实现复杂逻辑。

本期教程就到这里，通过本期教程我们学习了Python中的函数，是不是很简单，下期教程我们将学习Python中的面向对象知识点。

关于Python更多的内容可以关注《Python从入门到精通》专栏，该专栏主要用于分享Python学习教程，该系列教程只有干货没有花里胡哨，欢迎大家一起来学习探讨一起进步。

标签：function,入门,Python,详解,参数,print,def,函数
From： https://blog.csdn.net/diamond_5446/article/details/136653000