Python学习笔记

什么是Python?
Python它是一种直译式，面向对象，解释式的脚本语言。它和Java,C/C++,Go语言一样都是高级语言，但由于它是解释式语言，所以运行速度会比Java，C/C++等语言慢。Python因为自身携带了许多库（如：OS、TCP、Urllib、Trutle)，语法简单，第三库也有很多。

Python应用范围：

基本全能，例如:系统运维、图形处理、数学处理、文本处理、数据库编程、网络编程、web编程、多媒体应用、pymo引擎、黑客编程、爬虫编写、机器学习、人工智能等。

Python优缺点：

优点：免费开源、无社区限制、可开发应用面广、可跨平台、功能强大、自身携带模块多、第三方模块多、语法简单，代码量少可实现多功能等。

第二章 Python基础

2.1 注释

什么是注释，注释相当于备注的信息，也可以在调试代码的时候隐藏执行代码，但只适合新手。老手的话可以用debug去排查代码bug，这样效率更快。

注释的方法有行注释和块注释。

行注释以 # 开头：

块注释可以用多个 # 、 三单引号或三双引号

# 这是行注释
'''
这
是
块
注
释
'''

2.2 关键字与标识符

关键字：

关键字指的是具有特殊功能的标识符。

关键字有：

False      class      finally    is         return

None       continue   for        lambda     try

True       def        from       nonlocal   while

and        del        global     not        with 

as         elif       if         or         yield

assert     else       import     pass

break      except     in         raise

标识符需要遵循的规则：

第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。

标识符也叫变量名，变量名就是一个变量的名字，例如a和b。

2.3 变量

在Python中，变量是一个核心概念，它是存储数据值的容器。对于变量的学习，通常涵盖以下几个方面：

变量的命名：
- 变量名必须以字母或下划线_开头，后面可以跟字母、数字或下划线。
- 变量名是大小写敏感的。
- 避免使用Python的内置函数或类名作为变量名。
- 使用有意义的变量名可以提高代码的可读性。
变量的类型：
- Python是一种动态类型语言，不需要在声明变量时指定其类型。变量的类型会在赋值时自动确定。
- 常见的类型包括整数（int）、浮点数（float）、字符串（str）、列表（list）、元组（tuple）、字典（dict）、集合（set）等。
变量的赋值：
- 使用=操作符进行赋值。
- 可以将一个值赋给多个变量，但这些变量将共享相同的内存地址（对于不可变类型如整数和字符串，实际上是引用相同的对象）。
- 可以使用链式赋值同时给多个变量赋值。
变量的作用域：
- 局部变量：在函数或方法内部定义的变量，只能在定义它的函数或方法内部访问。
- 全局变量：在函数或方法外部定义的变量，可以在整个程序中访问。
- 需要注意的是，在函数内部修改全局变量需要使用global关键字声明。
变量的生命周期：
- 变量的生命周期从它被定义开始，到它不再被引用（即没有变量名指向它）且内存被垃圾回收器回收时结束。
变量的引用和拷贝：
- 在Python中，赋值操作实际上是对象的引用传递，而不是值的拷贝。
- 对于可变类型（如列表、字典），如果需要复制其值而不是引用，需要使用相应的方法（如list.copy()、dict.copy()）或切片操作（如list[:]）。
常量：
- 常量通常用于存储不会改变的值。在Python中，没有内置的常量类型，但程序员通常会遵循一种约定，即将常量的名称全部大写。
- Python 3.8+ 引入了 typing.Final 类型注解，用于声明一个变量在初始化后不应被重新赋值。
变量的交换：
- 在Python中，可以轻松地交换两个变量的值，无需使用临时变量。
变量的调试和错误处理：
- 使用print()函数可以帮助调试变量的值。
- 在处理可能引发错误的操作时，可以使用try-except语句捕获异常并处理。
变量在函数和模块中的使用：
- 函数参数和返回值都是通过变量来传递的。
- 模块之间可以通过导入（import）来共享变量和函数。

2.4 数据类型

python的数据类型有：数字类型、字符串类型、列表、元组、字典、集合等等。数据类型是编程语言必备的属性，只有给数据赋予明确的数据类型，计算机才能对数据进行处理运算。

在Python中，数字数据类型有int、float、bool（布尔型）、complex（复数）

整数类型（int）简称整型，它用于表示整数。
浮点型（float）数学中的小数，用于表示实数。注意：在Python中浮点类型只有单精度float，不要以为保留两位小数的数就是双精度类型(double),在Python中无论你是多少位小数它的数据类型都是float。
布尔型数据只有两个取值：True和False，分别对应整型的1和0。

如果你想判断该数字的数据类型，你可以尝试用type()函数来判定，如以下代码实例：

a6,a5,a3,a2,a1=4 + 7j,47.88 ,47 ,47.8 ,47.88888
a4=False
print(type(a1),type(a2),type(a3),type(a4),type(a5),type(a6))

也可以用isinstance()函数来判定，结果返回True代表你认为的数据类型是正确的，False就代表错误。

不同类型可以相互转换，常见的类型转换函数有：int()、float()、str()、tuple()、list()、set()

2.5 输入与输出

输入函数（input）

num=input("输入数字：")

输出函数（print）

print("Hello, World!")

2.6 算术运算符

在Python中，运算符有：+、-、*、/、%、**、//(加、减、乘、除、取模、次方、整除）
+:加法，两个变量相加求和
-:减法，两个变量相减求差
*：乘法，变量相乘求积
/：除法，变量相除求商
%：取模，得到除法结果第一位余数
**：次方，求变量（a）的n次幂->(a)ⁿ，可以用pow()函数代替
//：整除，取除法后的整数部分

2.7 字符串

如果你想换行转义输出，你可以在要转义的字串符之间加个\n（PS：反斜杠\是特殊转义字符），但在字串符前加个r将会是原字串符输出。

a = 'Hello','world'
b = 'Hello''world'	
#注意字串符a与b的区别，如果有逗号，
#那么输出时将会是两个字串符一起输出，如
#果没有输出将会两个字串符相互结合输出

c,d= 'Hello','world'
print(a)
print(b)
print(c,d)
print(c+d)
print(b[0:-2])
print(c[0:-3])
print(d[0:-1])
print(c*2,d*2)#各输出两次
print((c+d)*2)#结合输出两次
print('Hello,\nworld')
print(r'Hello,world')#加了r后转义字符失效
e='Hello,world'
print(e[0],e[5])#输出指定索引位置的字母
print(e[0],e[-2],e[3])#Python与C语言字串符不同的地方在于Python字串符是不可以被改变的，
                      #如果向一个指定索引赋值，那么将会错误

2.8 if条件判断

条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。程序语言指定任何非0和非空（null）值为true，0 或者 null为false。

if语句

if else语句

if elif else多分支语句

由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

2.9 while循环

while循环是一种控制流语句，它允许代码块基于给定的条件重复执行。
循环体是while循环中需要重复执行的代码块。
循环条件是一个布尔表达式，用于决定循环是否继续执行。
break语句用于在循环内部提前终止循环的执行。
continue语句用于跳过当前循环的剩余部分，直接开始下一次循环。

给出代码示例：

# 示例：打印1到10之间的偶数，但跳过数字6  
  
number = 1  
  
while number <= 10:  
    # 如果当前数字是6，则跳过这次循环，继续下一次  
    if number == 6:  
        number += 1  
        continue  
      
    # 检查数字是否为偶数  
    if number % 2 == 0:  
        print(number)  
      
    # 增加计数器  
    number += 1  
      
# 注意：由于我们在检测到6时直接增加number，并在下一次循环开始前检查条件，  
# 因此当number为6时，循环体会被跳过，不会打印6也不会增加额外的number。

2.10 for循环

for循环是另一种常见的控制流语句，它允许代码块基于集合中的每个元素重复执行。
for循环通常用于遍历序列（如列表、元组、字符串）或集合（如字典、集合）中的元素。
for循环的基本结构包括迭代变量、迭代对象和循环体。

示例1：打印列表中的元素

# 定义一个列表  
my_list = [1, 2, 3, 4, 5]  
  
# 使用for循环遍历列表并打印元素  
for element in my_list:  
    print(element)

示例2：遍历字典并打印键和值

# 定义一个字典  
my_dict = {"apple": 1, "banana": 2, "cherry": 3}  
  
# 使用for循环遍历字典的键  
for key in my_dict:  
    print(f"Key: {key}, Value: {my_dict[key]}")  
  
# 或者使用items()方法同时遍历键和值  
for key, value in my_dict.items():  
    print(f"Key: {key}, Value: {value}")

示例3：使用for循环和range()函数打印数字序列

# 使用for循环和range()函数打印从1到10的数字  
for i in range(1, 11):  
    print(i)  
  
# 打印从10到1的数字（步长为-1）  
for i in range(10, 0, -1):  
    print(i)

示例4：列表推导式创建新列表

# 使用列表推导式创建一个包含平方数的列表  
numbers = [1, 2, 3, 4, 5]  
squares = [x**2 for x in numbers]  
print(squares)  # 输出: [1, 4, 9, 16, 25]  
  
# 使用列表推导式筛选列表中的偶数  
even_numbers = [x for x in numbers if x % 2 == 0]  
print(even_numbers)  # 输出: [2, 4]

第三章容器

3.1 列表

1. 列表的创建

列表是由一系列元素组成的可变序列，这些元素可以是任何类型（整数、浮点数、字符串、列表等），并且它们之间用逗号分隔，整个列表由方括号[]包围。

# 创建一个包含不同类型元素的列表  
my_list = [1, 2.5, "hello", [4, 5, 6]]  
print(my_list)

2. 访问列表元素

通过索引（下标）可以访问列表中的元素。索引从0开始，负索引可以用来从列表末尾开始访问元素。

# 访问列表中的元素  
print(my_list[0])  # 输出 1  
print(my_list[-1])  # 输出 [4, 5, 6]

3. 列表的切片

通过切片操作可以获取列表的子序列。切片的基本语法是list[start:stop:step]，其中start是起始索引（包含），stop是结束索引（不包含），step是步长。

# 使用切片获取列表的子序列  
sub_list = my_list[1:3]  # 获取索引1到2（不包含2）的元素  
print(sub_list)  # 输出 [2.5, 'hello']

4. 列表的修改

列表是可变的，可以通过索引直接修改列表中的元素。

# 修改列表中的元素  
my_list[0] = 100  
print(my_list)  # 输出 [100, 2.5, 'hello', [4, 5, 6]]

5. 列表的增删操作

使用append()方法在列表末尾添加元素。
使用insert()方法在指定索引处插入元素。
使用remove()方法删除指定元素（第一个匹配的元素）。
使用pop()方法删除并返回指定索引处的元素（默认是最后一个元素）。
使用del语句删除指定索引处的元素或整个切片。
使用extend()方法将另一个列表的元素添加到当前列表的末尾。

# 列表的增删操作示例  
my_list.append("world")  # 添加元素  
my_list.insert(1, "Python")  # 插入元素  
print(my_list)  # 输出 [100, 'Python', 2.5, 'hello', 'world', [4, 5, 6]]  
  
my_list.remove("hello")  # 删除元素  
print(my_list)  # 输出 [100, 'Python', 2.5, 'world', [4, 5, 6]]  
  
last_element = my_list.pop()  # 删除并返回最后一个元素  
print(last_element)  # 输出 [4, 5, 6]  
print(my_list)  # 输出 [100, 'Python', 2.5, 'world']  
  
del my_list[1]  # 删除索引为1的元素  
print(my_list)  # 输出 [100, 2.5, 'world']  
  
other_list = [7, 8, 9]  
my_list.extend(other_list)  # 将other_list的元素添加到my_list的末尾  
print(my_list)  # 输出 [100, 2.5, 'world', 7, 8, 9]

6. 列表的排序和反转

使用sort()方法对列表进行原地排序（列表本身会改变）。
使用sorted()函数对列表进行排序并返回新列表（原列表不会改变）。
使用reverse()方法对列表进行原地反转（列表本身会改变）。

# 列表的排序和反转示例  
my_list = [5, 2, 9, 1, 5]  
my_list.sort()  # 原地排序  
print(my_list)  # 输出 [1, 2, 5, 5, 9]  
  
sorted_list = sorted(my_list)  # 返回新列表  
print(sorted_list)  # 输出 [1, 2, 5, 5, 9]  
  
my_list.reverse()  # 原地反转

3.2 元组

元组是Python中的不可变序列类型，用于存储一组有序的元素。元组使用小括号()来定义，元素之间用逗号,分隔。

1. 创建元组

# 直接构造元组  
tup1 = (1, 2, 3)  
print(tup1)  # 输出: (1, 2, 3)  
  
# 单个元素的元组需要逗号  
tup2 = (4,)  
print(tup2)  # 输出: (4,)  
  
# 从列表转换为元组  
list1 = [5, 6, 7]  
tup3 = tuple(list1)  
print(tup3)  # 输出: (5, 6, 7)

2. 访问元组元素

# 索引访问  
tup = (1, 2, 3, 4, 5)  
print(tup[0])  # 输出: 1  
print(tup[-1])  # 输出: 5  
  
# 切片访问  
print(tup[1:4])  # 输出: (2, 3, 4)

3. 元组的方法

# count方法  
tup = (1, 2, 2, 3, 2)  
print(tup.count(2))  # 输出: 3  
  
# index方法  
print(tup.index(2))  # 输出: 1（第一个2的索引）

4. 嵌套元组

# 嵌套元组  
nested_tup = (1, (2, 3), 4, (5, 6, (7, 8, 9)))  
  
# 访问嵌套元组中的元素  
print(nested_tup[1])  # 输出: (2, 3)  
print(nested_tup[1][0])  # 输出: 2  
print(nested_tup[3][2][1])  # 输出: 8

3.3 字典

字典是Python中的可变容器模型，它可存储任意类型对象，如字符串、数字、元组等，并且每个对象都有一个唯一的键与之关联。字典使用大括号{}来表示，键值对之间用冒号:分隔，不同的键值对之间用逗号,分隔。

1. 创建字典

# 直接构造字典  
person = {'name': 'Alice', 'age': 25, 'job': 'Engineer'}  
print(person)  # 输出: {'name': 'Alice', 'age': 25, 'job': 'Engineer'}  
  
# 使用dict()函数从元组列表创建字典  
items = [('name', 'Bob'), ('age', 30), ('job', 'Doctor')]  
person_dict = dict(items)  
print(person_dict)  # 输出: {'name': 'Bob', 'age': 30, 'job': 'Doctor'}

2. 访问字典元素

# 通过键访问值  
print(person['name'])  # 输出: Alice  
  
# 使用get()方法访问值，如果键不存在则返回None或指定默认值  
print(person.get('city'))  # 输出: None  
print(person.get('city', 'No city provided'))  # 输出: No city provided

3. 修改和添加键值对

# 修改键值对  
person['age'] = 26  
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'job': 'Engineer'}  
  
# 添加新的键值对  
person['city'] = 'New York'  
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'job': 'Engineer', 'city': 'New York'}

4. 删除键值对

# 使用del语句删除键值对  
del person['city']  
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'job': 'Engineer'}  
  
# 使用pop()方法删除键值对，并返回被删除的值  
city = person.pop('city')  # 这里会抛出KeyError，因为'city'键已经被删除了  
# 如果键不存在，pop()方法会抛出KeyError，但可以提供一个默认值来避免这种情况  
city = person.pop('city', 'No city found')  
print(city)  # 输出: No city found

5. 遍历字典

# 遍历键  
for key in person.keys():  
    print(key)  
# 输出:  
# name  
# age  
# job  
  
# 遍历值  
for value in person.values():  
    print(value)  
# 输出:  
# Alice  
# 26  
# Engineer  
  
# 遍历键值对  
for key, value in person.items():  
    print(f'{key}: {value}')  
# 输出:  
# name: Alice  
# age: 26  
# job: Engineer

6. 嵌套字典

# 嵌套字典表示用户信息  
users = {  
    'Alice': {  
        'age': 26,  
        'job': 'Engineer',  
        'city': 'New York'  
    },  
    'Bob': {  
        'age': 30,  
        'job': 'Doctor',  
        'city': 'Los Angeles'  
    }  
}  
  
# 访问嵌套字典中的值  
print(users['Alice']['age'])  # 输出: 26  
print(users['Bob']['city'])  # 输出: Los Angeles

3.4 集合

在Python等编程语言中，集合通常作为内置数据类型提供，具有快速查找、添加和删除元素的能力。集合的实现通常基于哈希表或类似的数据结构，以确保高效的元素查找和添加操作。

注意：

集合中的元素必须是不可变类型，如整数、浮点数、字符串、元组等。列表、字典等可变类型不能直接作为集合的元素。
集合本身也是不可变的，即集合一旦创建就不能修改其元素（但可以通过添加、删除元素来间接修改集合）。
集合是无序的，即集合中元素的顺序是不确定的。如果需要保持元素的顺序，可以使用列表或其他有序数据结构。

1. 创建集合

# 使用大括号创建集合  
set1 = {1, 2, 3, 4}  
print(set1)  # 输出: {1, 2, 3, 4}  
  
# 使用set()函数创建集合  
set2 = set([1, 2, 2, 3, 4, 4])  # 重复元素会被自动去重  
print(set2)  # 输出: {1, 2, 3, 4}  
  
# 创建一个空集合（注意不能直接使用{}，因为{}会被解释为一个空字典）  
set3 = set()  
print(set3)  # 输出: set()

2. 集合的添加和删除

# 添加元素  
set1.add(5)  
print(set1)  # 输出: {1, 2, 3, 4, 5}  
  
# 添加多个元素  
set1.update([6, 7])  
print(set1)  # 输出: {1, 2, 3, 4, 5, 6, 7}  
  
# 删除元素  
set1.remove(2)  # 如果元素不存在，会抛出KeyError  
print(set1)  # 输出: {1, 3, 4, 5, 6, 7}  
  
# 丢弃元素（如果元素不存在，不会抛出异常）  
set1.discard(8)  
print(set1)  # 输出仍然是: {1, 3, 4, 5, 6, 7}  
  
# 清除集合中的所有元素  
set1.clear()  
print(set1)  # 输出: set()

3. 集合的运算

# 创建两个集合  
set_a = {1, 2, 3, 4}  
set_b = {3, 4, 5, 6}  
  
# 并集  
union_set = set_a | set_b  # 或使用 union() 方法：union_set = set_a.union(set_b)  
print(union_set)  # 输出: {1, 2, 3, 4, 5, 6}  
  
# 交集  
intersection_set = set_a & set_b  # 或使用 intersection() 方法：intersection_set = set_a.intersection(set_b)  
print(intersection_set)  # 输出: {3, 4}  
  
# 差集  
difference_set = set_a - set_b  # 或使用 difference() 方法：difference_set = set_a.difference(set_b)  
print(difference_set)  # 输出: {1, 2}  
  
# 对称差集（只存在于一个集合中的元素）  
symmetric_difference_set = set_a ^ set_b  # 或使用 symmetric_difference() 方法：symmetric_difference_set = set_a.symmetric_difference(set_b)  
print(symmetric_difference_set)  # 输出: {1, 2, 5, 6}  
  
# 判断一个集合是否是另一个集合的子集  
print(set_b.issubset(set_a))  # 输出: False  
print(set_a.issuperset(set_b))  # 输出: False  
print({3, 4}.issubset(set_a))  # 输出: True

第四章函数

4.1 函数定义与调用

在编程中，函数是一段可以被多次重复使用的代码块，它执行特定的任务并可能返回结果。函数定义描述了函数如何工作，而函数调用则是实际执行函数的过程。

函数定义通常包括以下几个部分：

函数名：用于标识函数的名称。
参数列表：传递给函数的值或变量列表，用括号 () 包围，参数之间用逗号 , 分隔。如果函数没有参数，则参数列表为空。
冒号：在函数名和参数列表之后使用冒号 : 表示函数定义的开始。
函数体：包含执行特定任务的代码块，用缩进来表示（在Python中）。
返回值：函数执行完成后返回的结果，使用 return 语句来指定。如果函数没有返回值，则默认返回 None。

def greet(name):  
    """这个函数接受一个名字作为参数，并返回问候语"""  
    return "Hello, " + name + "!"

在这个例子中，greet 是函数名，name 是参数，函数体中的代码将名字与问候语拼接起来，并使用 return 语句返回结果。

函数调用是执行函数的过程。要调用一个函数，你需要使用函数名并传递任何必要的参数（如果函数需要参数的话）。调用函数后，Python将执行函数体中的代码，并返回任何指定的结果。

以下是如何调用上面定义的 greet 函数的例子：

message = greet("Alice")  # 调用函数，并将"Alice"作为参数传递  
print(message)  # 输出：Hello, Alice!

4.2 函数参数

函数参数是函数定义中用于接收传递进来的值或变量的部分。它们允许函数根据不同的输入执行不同的操作，从而增加了函数的灵活性和重用性。

1. 位置参数

位置参数是最常见的参数类型，它们按照在函数定义中出现的顺序进行传递。在调用函数时，必须按照定义中的顺序为位置参数提供值。

def greet(name, age):  
    print(f"Hello, {name}! You are {age} years old.")  
  
# 调用函数，按照顺序传递参数  
greet("Alice", 30)  # 输出：Hello, Alice! You are 30 years old.

2. 关键字参数

关键字参数允许在调用函数时通过参数名来指定参数值，这样可以不必按照定义中的顺序传递参数。

def greet(name, age):  
    print(f"Hello, {name}! You are {age} years old.")  
  
# 调用函数，使用关键字参数  
greet(age=30, name="Alice")  # 输出：Hello, Alice! You are 30 years old.

3. 默认参数

在函数定义中，可以为参数指定默认值。如果在调用函数时没有为这些参数提供值，那么将使用默认值。

def greet(name, age=None):  
    if age is None:  
        print(f"Hello, {name}!")  
    else:  
        print(f"Hello, {name}! You are {age} years old.")  
  
# 调用函数，不传递age参数，使用默认值  
greet("Alice")  # 输出：Hello, Alice!  
  
# 调用函数，传递age参数  
greet("Bob", 25)  # 输出：Hello, Bob! You are 25 years old.

4. 可变位置参数

在函数定义中，可以使用 *args 语法来接收任意数量的位置参数，并将它们作为一个元组处理。

def sum_numbers(*args):  
    return sum(args)  
  
# 调用函数，传递任意数量的位置参数  
result = sum_numbers(1, 2, 3, 4, 5)  # 输出：15

5. 可变关键字参数

在函数定义中，可以使用 **kwargs 语法来接收任意数量的关键字参数，并将它们作为一个字典处理。

def print_info(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key}: {value}")  
  
# 调用函数，传递任意数量的关键字参数  
print_info(name="Alice", age=30, city="New York")  
# 输出：  
# name: Alice  
# age: 30  
# city: New York

6. 参数解包

在调用函数时，可以使用 * 和 ** 来解包序列和字典，将它们的元素作为位置参数和关键字参数传递给函数。

def greet(name, age):  
    print(f"Hello, {name}! You are {age} years old.")  
  
args = ("Bob", 20)  
greet(*args)  # 输出：Hello, Bob! You are 20 years old.  
  
kwargs = {"name": "Charlie", "age": 35}  
greet(**kwargs)  # 输出：Hello, Charlie! You are 35 years old.

注意事项：

位置参数必须在关键字参数之前。
在函数定义中，可变位置参数 *args 必须位于关键字参数和可变关键字参数 **kwargs 之前。
在调用函数时，解包序列作为位置参数和解包字典作为关键字参数通常用于将函数参数与列表、元组或字典等数据结构结合起来使用。

4.3 函数返回值

函数返回值是函数执行完毕后返回给调用者的结果。函数返回值可以是一个值、一个对象、一个列表、一个字典，或者是任何可以被赋值给变量的数据类型。函数通过使用 return 语句来指定其返回值。

return 语句：在函数体中，使用 return 语句可以立即结束函数的执行，并将控制权返回给调用者。return 语句后面的表达式（如果有的话）将被计算，并作为函数的返回值。
返回值类型：函数可以返回任何类型的值，包括整数、浮点数、字符串、列表、元组、字典、自定义对象等。
没有返回值：如果函数没有 return 语句，或者 return 语句后面没有跟任何表达式，那么函数默认返回 None。

返回多个值（使用元组）

在 Python 中，虽然函数只能返回一个值，但这个值可以是元组，从而可以“返回”多个值。

def get_person_info():  
    return "Alice", 30, "New York"  # 返回一个包含三个元素的元组  
  
name, age, city = get_person_info()  # 解包元组到单独的变量中  
print(name, age, city)  # 输出：Alice 30 New York

4.4 变量作用域

1. 局部作用域

在函数或代码块内部定义的变量具有局部作用域。这些变量只能在其被定义的函数或代码块内部访问。一旦函数或代码块执行完毕，这些变量就会被销毁，不再存在。

def my_function():  
    local_var = "I am local"  # 局部变量  
    print(local_var)  
  
my_function()  # 输出: I am local  
# 在函数外部无法访问 local_var  
# print(local_var)  # 这会引发错误

2. 全局作用域

在函数或代码块外部定义的变量具有全局作用域。这些变量在整个程序中都是可见和可访问的。

global_var = "I am global"  # 全局变量  
  
def my_function():  
    print(global_var)  # 可以在函数内部访问全局变量  
  
my_function()  # 输出: I am global  
print(global_var)  # 也可以在函数外部访问全局变量

3. 嵌套作用域

在嵌套函数（一个函数内部定义的另一个函数）中，内部函数可以访问其外部函数定义的变量，这种变量具有嵌套作用域。但是，外部函数不能直接访问内部函数的变量，除非这些变量被明确地返回或作为某种形式的输出。

def outer_function():  
    outer_var = "I am outer"  # 嵌套作用域中的变量  
  
    def inner_function():  
        print(outer_var)  # 内部函数可以访问外部函数的变量  
        inner_var = "I am inner"  
        print(inner_var)  
  
    inner_function()  
  
outer_function()  # 输出: I am outer 和 I am inner  
# 在 outer_function 外部无法访问 inner_var 或 outer_var

4.5 递归函数

递归函数是一种在函数定义中直接或间接调用自身的函数。递归函数通常用于解决可以分解为更小、更简单的相同问题的子问题的情况。递归函数有两个基本组件：基准情况和递归步骤。

基准情况（Base Case）：这是递归函数停止递归并返回值的条件。没有基准情况，递归函数将会无限循环下去，导致栈溢出错误。
递归步骤（Recursive Step）：这是函数将问题分解为更小、更简单的子问题的步骤。递归步骤通常包括一个或多个对函数自身的调用，但每次调用时，参数会更接近基准情况。

递归函数的示例

阶乘函数

阶乘函数是一个很好的递归函数示例。n 的阶乘（n!）定义为从 1 乘到 n 的所有整数的乘积。

def factorial(n):  
    # 基准情况：0 的阶乘是 1  
    if n == 0:  
        return 1  
    # 递归步骤：n 的阶乘是 n 乘以 (n-1) 的阶乘  
    else:  
        return n * factorial(n - 1)  
  
print(factorial(5))  # 输出：120

斐波那契数列

斐波那契数列是另一个常见的递归函数示例。斐波那契数列是这样一个数列：0、1、1、2、3、5、8、13、21、…，其中每个数字是前两个数字的和。

def fibonacci(n):  
    # 基准情况：斐波那契数列的前两个数是 0 和 1  
    if n == 0:  
        return 0  
    elif n == 1:  
        return 1  
    # 递归步骤：第 n 个斐波那契数是前两个斐波那契数的和  
    else:  
        return fibonacci(n - 1) + fibonacci(n - 2)  
  
print(fibonacci(10))  # 输出：55

4.6 匿名函数

定义：匿名函数是没有正式名称的函数，它们通常在需要时定义，并在单个语句中完成其功能。
特点：
- 不以文件形式存在，通常只在需要时创建。
- 简短，主要用于一次性或临时任务。
- 可以在函数体内或代码块中直接定义和使用。

在Python中，匿名函数使用lambda关键字定义，其基本语法如下：

lambda arguments: expression

arguments：函数参数，可以有一个或多个，用逗号分隔。
expression：函数体，可以是一个简单的表达式或一个函数调用。

示例1：计算两个数的和

add = lambda x, y: x + y  
print(add(3, 4))  # 输出：7

示例2：作为map()函数的参数

lst = [1, 2, 3, 4]  
squared = map(lambda x: x ** 2, lst)  
print(list(squared))  # 输出：[1, 4, 9, 16]

4.7 闭包

在Python中，闭包是一个常见的概念，它通常与嵌套函数（nested functions）和内部函数（inner functions）一起出现。当一个内部函数引用了其外部函数（包含它的函数）的变量（非全局变量）时，就形成了一个闭包。即使外部函数执行完成后，这些变量仍然会被内部函数所记住，这就是闭包的作用。

下面是一个Python中闭包的简单示例：

def outer_function(outer_variable):  
    def inner_function(inner_variable):  
        # 访问外部函数的变量  
        print(f'Outer Variable: {outer_variable}')  
        print(f'Inner Variable: {inner_variable}')  
        return outer_variable + inner_variable  
      
    # 返回内部函数（此时，内部函数就是一个闭包）  
    return inner_function  
  
# 创建一个闭包实例  
my_closure = outer_function('Hello')  
  
# 调用闭包  
result = my_closure('World')  # 输出: Outer Variable: Hello, Inner Variable: World  
print(result)  # 输出: 12（'Hello'和'World'的字符串长度之和）

4.8 装饰器

装饰器本质上是一个Python函数，它接受一个函数作为参数，并返回一个新的函数对象。这个新的函数对象在功能上是对原函数的增强或修改。

特点：
- 不修改源代码：使用装饰器，你可以在不修改原函数代码的情况下，为其添加新的功能。
- 可重用性：一旦定义了一个装饰器，你就可以在多个地方重复使用它，为不同的函数或类添加相同的功能。
- 语法简洁：使用@符号可以轻松地将装饰器应用于函数或类。

以下是一个简单的装饰器示例，用于计算函数的执行时间：

import time  
  
def timer_decorator(func):  
    def wrapper(*args, **kwargs):  
        start_time = time.time()  
        result = func(*args, **kwargs)  
        end_time = time.time()  
        print(f"Function {func.__name__} took {end_time - start_time} seconds to execute.")  
        return result  
    return wrapper  
  
@timer_decorator  
def example_function(n):  
    sum = 0  
    for i in range(n):  
        sum += i  
    return sum  
  
# 调用函数  
result = example_function(1000000)  
print(result)