Python 基础（四）Python函数-CSDN博客

本文链接：https://blog.csdn.net/Darwin_Bossen/article/details/132639025

Python基础文章系列

Python 基础（一）Python基本认识与环境搭建	Python 基础（一）Python基本认识与环境搭建
Python 基础（二）Python变量与基本数据类型	Python 基础（二）Python变量与基本数据类型
Python 基础（三）Python基本语句与基本运算	Python 基础（三）Python基本语句与基本运算
Python 基础（四）Python函数	Python 基础（四）Python函数
Python 基础（五）Python包与模块	Python 基础（五）Python包与模块
Python 基础（六）Python的文件模块	Python 基础（六）Python的文件模块
Python 基础（七）Python的异常处理机制	Python 基础（七）Python的异常处理机制
Python 基础（八）Python的类与对象	Python 基础（八）Python的类与对象
Python 基础（九）Python的内置模块	Python 基础（九）Python的内置模块
Python 基础（十）Python实现简单的图书管理系统	Python 基础（十）Python实现简单的图书管理系统

在这里插入图片描述

4.4 函数

4.4.1 函数的定义

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

4.4.2 格式

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

def 函数名（参数列表）:     函数体

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的，下面的案例：

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:09
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    : 函数定义
# @File    : DefTest.py


# 函数定义
def printme(str):
    print(str)
    return

if __name__ == '__main__':
    printme('Hello World')
    printme('Hello Again')
    printme('Hello Python')

4.4.3 参数传递

可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

**不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
**可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

**不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
**可变类型：**类似 C++ 的引用传递，如列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:14
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    :  函数参数不可变对象
# @File    : NoChangeObject.py


# 函数参数不可变对象
def change(a):
    print(id(a))  # 指向的是同一个对象
    a = 10
    print(id(a))  # 一个新对象


if __name__ == '__main__':
    a = 1
    print(id(a))
    change(a)

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:17
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    : 函数参数可变对象
# @File    : ChangeObject.py

# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return

if __name__ == '__main__':
    # 调用changeme函数
    mylist = [10,20,30]
    changeme( mylist )
    print ("函数外取值: ", mylist)

简单总结：不可变，值传递，可变，引用传递

总结

在Python中，函数参数传递有两种主要方式：传递参数通过值（传值调用）和传递参数通过引用（传引用调用）。

传递参数通过值（Passing Arguments by Value）：
在这种情况下，函数接收到的是参数的副本，而不是原始参数本身。这意味着在函数内部对参数的任何更改都不会影响到原始参数。
在上面的示例中，num的值在函数内部增加了1，但在函数外部没有变化。
传递参数通过引用（Passing Arguments by Reference）：
在Python中，大部分情况下，函数实际上是通过引用传递参数的。这意味着函数接收到的是原始参数的引用，对参数的修改将影响到原始参数。

在这个示例中，my_numbers是一个列表，函数modify_list通过引用访问该列表，并在其末尾添加了一个新元素。
需要注意的是，虽然大多数情况下是通过引用传递参数，但如果在函数内部对参数重新赋值，它将创建一个新的局部变量，不会影响原始参数。这类似于传递参数通过值的行为。

4.4.4 参数

必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:09
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    : 函数定义
# @File    : DefTest.py


# 函数定义
def printme(str):
    print(str)
    return

if __name__ == '__main__':
    printme('Hello World')
    printme('Hello Again')
    printme('Hello Python')

关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
默认参数：调用函数时，如果没有传递参数，则会使用默认参数。

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:09
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    : 函数定义
# @File    : DefTest.py


# 函数定义
def printme(str):
    print(str)
    return

if __name__ == '__main__':
    printme('Hello World')
    printme('Hello Again')
    printme('Hello Python')
    # 关键字参数
    printme(str='Hello Python')
    # 默认参数
    def printinfo(name, age=35):
        print('Name:', name)
        print('Age:', age)
        return

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:09
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    : 函数定义
# @File    : DefTest.py
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

参数

在Python中，函数参数允许您传递信息给函数，以便函数可以执行特定的任务或操作。Python中的参数可以分为以下几种类型：

位置参数（Positional Arguments）：
位置参数是最常见的参数类型。它们按照在函数定义中的顺序传递给函数，需要按照相同的顺序传递给函数调用。例如：

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

result = add(3, 5)

在这个示例中，a和b是位置参数，分别接收值3和5。

关键字参数（Keyword Arguments）：
关键字参数允许您通过参数名指定要传递的值，而不需要按照参数定义的顺序。这提高了函数调用的可读性。例如：

def greet(name, message):
    print(f"{message}, {name}!")

greet(message="Hello", name="Alice")

在这里，我们明确指定了参数的名称，以便更清晰地了解每个参数的含义。

默认参数（Default Arguments）：
默认参数是在函数定义时为参数指定的默认值。如果函数调用没有提供特定参数的值，则将使用默认值。例如：

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Bob")  # 使用默认的message值

在这个示例中，如果未提供message参数，它将默认为"Hello"。

可变长参数：
- **args：这是用于接受可变数量的位置参数的特殊语法。函数将它们作为元组处理。

def add(*args):
    result = 0
    for num in args:
        result += num
    return result

total = add(1, 2, 3, 4)

**kwargs：这是用于接受可变数量的关键字参数的特殊语法。函数将它们作为字典处理。

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

display_info(name="Alice", age=30, city="New York")

这些可变长参数允许函数处理不定数量的参数。

强制关键字参数：
在Python 3.8及更高版本中，您可以使用*来指定参数后必须使用关键字传递。这样可以强制调用者使用关键字，而不是位置传递。

def greet(name, *, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice")  # 报错，必须使用关键字参数
greet(name="Alice")  # 正确的方式

4.4.5 匿名函数

Python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。

语法
lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

# ---encoding:utf-8---
# @Time    : 2023/9/2 15:26
# @Author  : Darwin_Bossen
# @Email   ：3139066125@qq.com
# @Site    : 匿名函数
# @File    : Lambda.py


# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2

if __name__ == '__main__':
    sum(10, 20)

总结

在Python中，匿名函数也被称为lambda函数。它们是一种特殊类型的函数，通常用于定义简单的、一次性的函数。lambda函数的语法非常简洁，通常只包含一个表达式。它们可以在需要函数作为参数的情况下使用，或者在需要一个短小的函数来执行某些操作时很有用。
以下是lambda函数的基本语法和示例：

lambda arguments: expression

lambda关键字用于定义lambda函数。
arguments是函数的参数列表。
expression是函数的返回值表达式。

示例1：一个简单的lambda函数，用于求平方。

square = lambda x: x ** 2
result = square(5)  # 结果为25

示例2：lambda函数作为排序函数的键。

students = [
    {"name": "Alice", "score": 80},
    {"name": "Bob", "score": 75},
    {"name": "Charlie", "score": 90}
]

# 使用lambda函数按照分数对学生列表进行排序
sorted_students = sorted(students, key=lambda student: student["score"], reverse=True)

示例3：lambda函数作为map()函数的参数。

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))  # [1, 4, 9, 16, 25]

4.4.6 总结

当涉及到Python函数时，函数是一种重要的编程概念，用于组织、重用和模块化代码。以下是有关Python函数的详细介绍：

定义函数：
在Python中，可以使用关键字def来定义函数。函数通常包括函数名、参数列表、冒号和函数体。例如：

这个函数名为greet，接受一个参数name，然后在函数体中打印一条问候语。

调用函数：
要使用函数，只需调用它并传递所需的参数（如果有的话）。例如：

greet("Alice")

这将调用greet函数，并将"Alice"作为参数传递给它。

函数参数：
Python函数可以接受零个或多个参数。参数可以是必需的（没有默认值）或可选的（有默认值）。例如：

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

在这个例子中，add函数接受两个参数，a是必需的，而b是可选的，默认为0。

函数返回值：
函数可以使用return语句来返回值。例如：

def multiply(x, y):
    result = x * y
    return result

调用multiply(2, 3)将返回6。

局部变量和作用域：
在函数内部定义的变量是局部变量，只在函数内部可见。这意味着它们在函数外部不可用。函数外部定义的变量是全局变量，在整个程序中可见。
文档字符串（Docstring）：
函数通常包含文档字符串，以描述函数的功能和参数。这些文档字符串可以通过help()函数或文档工具生成文档。
匿名函数（Lambda函数）：
Python支持匿名函数，也称为lambda函数。它们通常用于简单的操作，可以使用lambda关键字创建。

add = lambda x, y: x + y