前言

在 Python 的世界里，函数是代码复用和逻辑封装的基石，而数据容器（如列表、元组、字典、集合）则是组织和操作信息的利器。无论是初学者还是有一定经验的开发者，掌握函数的定义、参数传递、返回值以及闭包、装饰器等高级特性，同时熟练使用各种数据容器的增删改查、遍历方式和性能特点，都是写出简洁、高效、可维护代码的关键。本文将从函数的基本语法出发，逐步深入到函数式编程思想；随后系统梳理 Python 内置的四大数据容器及其常用方法，并通过真实案例展示它们在实际项目中的协同使用。希望读者在阅读完本文后，不仅能够快速上手，还能举一反三，在日常开发中灵活运用这些核心概念。

---

Python函数

函数介绍

函数:是组织好的，可重复使用的，用来实现特定功能的代码段。

def my_length(str):
    length = 0;
    for i in str:
        length += 1;

    return length;

name = "itheima"
print(f"{name}的长度是: {my_length(name)}")

运行结果：

函数的定义:
def 函数名 (传入参数):
 函数体
 return 返回值

函数的调用:
函数名(参数)

函数的传入参数

传入参数的功能是:在函数进行计算的时候，接受外部(调用时)提供的数据
可以有如下函数定义：

def add(x, y):
    result = x + y
    print(f"{x}+{y}的结果是：{result}")

函数定义中，提供的x和y，称之为：形式参数（形参），表示函数声明将要使用2个参数

• 参数之间使用逗号进行分隔

函数调用中，提供的5和6，称之为：实际参数（实参），表示函数执行时真正使用的参数值

• 传入的时候，按照顺序传入数据，使用逗号分隔

传入参数的数量是不受限制的。

• 可以不使用参数
• 也可以仅使用任意N个参数

函数的返回值

def add(x, y):
    result = x + y
    return result

r = add(1, 2)
print(r)

定义两数相加的函数功能。完成功能后，会将相加的结果返回给函数调用者,所以，变量r接收到了函数的执行结果。

综上所述：
所谓“返回值”，就是程序中函数完成事情后，最后给调用者的结果

语法就是：通过return关键字，就能向调用者返回数据
Python中有一个特殊的字面量：None，其类型是：<class ‘NoneType’>
无返回值的函数，实际上就是返回了：None这个字面量

None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。
也就是返回了空的意思。
None可以主动使用return返回，效果等同于不写return语句：

None作为一个特殊的字面量，用于表示：空、无意义，其有非常多的应用场景。

• 用在函数无返回值上

• 用在if判断上

  • 在if判断中，None等同于False
  • 一般用于在函数中主动返回None，配合if判断做相关处理

• 用于声明无内容的变量上

  • 定义变量，但暂时不需要变量有具体值，可以用None来代替

#暂不赋予变量具体值
name = None

函数的说明文档

函数是纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低。

我们可以给函数添加说明文档，辅助理解函数的作用。
语法如下：

通过多行注释的形式，对函数进行说明解释

• 内容应写在函数体之前

在PyCharm编写代码时，可以通过鼠标悬停，查看调用函数的说明文档

变量的作用域

局部变量

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

变量num是定义在test函数内部的变量，在函数外部访问则立即报错.

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

全局变量

num = 1000
def testOne():
    print(num)

def testTwo():
    num = 10
    print(num)

testOne()
testTwo()
print(f"全局变量num={num}")

使用 global关键字 可以在函数内部声明变量为全局变量, 如下所示

num = 1000
def testOne():
    print(num)

def testTwo():
    #声明num是全局变量
    global num
    num = 100000
    print(num)

testOne()
testTwo()
print(f"全局变量num={num}")

Python数据容器

Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为5类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

数据容器list

基本语法：

列表内的每一个数据，称之为元素

• 以 [] 作为标识
• 列表内每一个元素之间用, 逗号隔开

my_list = [6, 'hello_itheima', True]
print(my_list)
print(type(my_list))

my_list = [
    [1, 2, 3],
    [2, 4, 9],
]
print(my_list)
print(type(my_list))

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

my_list = ['itheima', 'hello_world', 'hei_man']
print(my_list[0])
print(my_list[1])
print(my_list[2])

或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）

my_list = ['itheima', 'hello_world', 'hei_man']
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

如果列表是嵌套的列表，同样支持下标索引

my_list = [
    [1, 2, 3],
    [4, 5, 6],
]
print(my_list[0])
print(my_list[0][0])

列表也提供了一系列功能：

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

查找某元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)

my_list = ['itheima', 'hello_world', 'hei_man']
print(my_list.index('hei_man'))

修改特定位置（索引）的元素值：
语法：列表[下标] = 值
可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

my_list = ['itheima', 'hello_world', 'hei_man']
print(my_list[0])
my_list[0] = 'gril'
print(my_list[0])
print(my_list[-1])
my_list[-1] = 'please'
print(my_list[-1])

插入元素：
语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

my_list = ['itheima', 'hello_world', 'hei_man']
my_list.insert(1,'please')
print(my_list)

追加元素：
语法：列表.append(元素)，将指定元素，追加到列表的尾部

my_list = ['itheima', 'hello_world', 'hei_man']
my_list.append('hei_gril')
print(my_list)
print(my_list.append([1,2,3]))
print(my_list)

追加元素方式2：
语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

my_list = ['itheima', 'hello_world', 'hei_man']
my_list.extend([1,2,3])
print(my_list)

删除元素：
语法1： del 列表[下标]
语法2：列表.pop(下标)

my_list = ['itheima', 'hello_world', 'hei_man']
del my_list[0]
print(my_list)
my_list.pop(0)
print(my_list)

删除某元素在列表中的第一个匹配项
语法：列表.remove(元素)

my_list = ['itheima','hei_man', 'hello_world', 'hei_man']
my_list.remove('hei_man')
print(my_list)

清空列表内容，语法：列表.clear()

my_list = ['itheima','hei_man', 'hello_world', 'hei_man']
my_list.clear()
print(my_list)

统计某元素在列表内的数量
语法：列表.count(元素)

 my_list = ['itheima','hei_man', 'hello_world', 'hei_man']
print(my_list.count('hei_man'))

统计列表内，有多少元素
语法：len(列表)

my_list = ['itheima','hei_man', 'hello_world', 'hei_man']
print(len(my_list))

列表有如下特点：

• 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

数据容器tuple（元组）

元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
元组也支持嵌套：

mt_tuple = ((1,2,3), (2,4,6))
print(mt_tuple[1][1])

注意事项

tupleOne = (1, 2, 3)
#定义一个元素的元组
tupleTwo = (4,) #注意：必须带有逗号，否则不是元组类型

元组由于不可修改的特性，所以其操作方法非常少

tupleOne = (1, 2, 3,'hello_world',3)
print(tupleOne[1])
print(tupleOne.index('hello_world'))
print(tupleOne.count(3))
print(len(tupleOne))

不可以修改元组的内容，否则会直接报错


可以修改元组内的list的内容（修改元素、增加、删除、反转等）

tupleOne = (1, 2, 3,['hello_world',3])
tupleOne[3][0] = "hello"
print(tupleOne)

不可以替换list为其它list或其它类型

tupleOne = (1, 2, 3,['hello_world',3])
tupleOne[3] = [1,2,3]

元组有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）
• 支持for循环

数据容器str（字符串）

字符串是字符的容器，一个字符串可以存放任意数量的字符。
如，字符串：“itheima”
字符串也可以通过下标进行访问

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

同元组一样，字符串是一个：无法修改的数据容器。
所以：

• 修改指定下标的字符 （如：字符串[0] = “a”）
• 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
• 追加字符等 （如：字符串.append()）

均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

查找特定字符串的下标索引值
语法：字符串.index(字符串)

strOne = "my name is itheima"
print(strOne.index("is"))

字符串的替换
语法：字符串.replace(字符串1，字符串2）
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串

strOne = "my name is itheima"
strTwo = strOne.replace("itheima", "hello world")
print(strOne)
print(strTwo)

字符串的分割
语法：字符串.split(分隔符字符串）
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列注意：字符串本身不变，而是得到了一个列表对象

strOne = "my name is itheima"
strOne_list = strOne.split(" ")
print(strOne)
print(strOne_list)

字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中
字符串的规整操作（去前后空格）
语法：字符串.strip()

strOne = " my name is itheima "
print(strOne.strip())

字符串的规整操作（去前后指定字符串）
语法：字符串.strip(字符串)

 strOne = "78my name is itheima87"
print(strOne.strip("78"))

注意，传入的是“78” 其实就是：”7”和”8”都会移除，是按照单个字符。

统计字符串中某字符串的出现次数
语法：字符串.count(字符串)

strOne = "my name is myheimyheMyheim"
print(strOne.count("my"))

统计字符串的长度
语法：len(字符串)

strOne = "my name is myheimyheMyheim"
print(len(strOne))

字符串有如下特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

数据容器（序列）的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。

序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

my_list = [1, 2, 3, 4, 5]
new_list = my_list[0:3]
print(new_list)

my_tuple = (1, 4, 6, 9)
new_tuple = my_tuple[:]
print(new_tuple)

my_list = [1, 3, 5, 6 ,8 ,10]
new_list = my_list[::3]
print(new_list)

数据容器set（集合）

集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
基本语法：

my_set = {'itheima', 1, 'hello', 'world'}
print(my_set)

添加新元素
语法：集合.add(元素)。将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素

my_set = {'itheima', 1, 'hello', 'world'}
my_set.add('hei_man')
print(my_set)

my_set = {'itheima', 1, 'hello', 'world'}
my_set.remove(1)
print(my_set)

从集合中随机取出元素
语法：集合.pop()，功能，从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

my_set = {'itheima', 1, 'hello', 'world'}
element = my_set.pop()
print(element)
print(my_set)

取出2个集合的差集
语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变

setOne = {'itheima', 1, 'hello', 'world'}
setTwo = {1, 2, 3, 4}
setThree = setOne.difference(setTwo)
print(setThree)
print(setOne)
print(setTwo)

消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
结果：集合1被修改，集合2不变

setOne = {'itheima', 1, 'hello', 'world'}
setTwo = {1, 2, 3, 4}
setOne.difference_update(setTwo)
print(setOne)
print(setTwo)

2个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

setOne = {'itheima', 1, 'hello', 'world'}
setTwo = {1, 2, 3, 4}
setThree = setOne.union(setTwo)
print(setThree)
print(setOne)
print(setTwo)

查看集合的元素数量
语法：len(集合)
功能：统计集合内有多少元素
结果：得到一个整数结果

setOne = {'itheima', 1, 'hello', 'world'}
print(len(setOne))

注意：集合不支持下标索引，所以也就不支持使用while循环。

集合有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环

数据容器dict（字典、映射）

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

• 使用{}存储原始，每一个元素是一个键值对
• 每一个键值对包含Key和Value（用冒号分隔）
• 键值对之间使用逗号分隔
• Key和Value可以是任意类型的数据（key不可为字典）
• Key不可重复，重复会对原有数据覆盖

字典同集合一样，不可以使用下标索引
但是字典可以通过Key值来取得对应的Value

drictOne = {"name":"hgq", "age":28, "sex":"male"}
print(drictOne)
print(drictOne["name"])
print(drictOne["age"])
print(drictOne["sex"])

字典的注意事项

• 键值对的Key和Value可以是任意类型（Key不可为字典）
• 字典内Key不允许重复，重复添加等同于覆盖原有数据
• 字典不可用下标索引，而是通过Key检索Value

新增元素
语法：字典[Key] = Value，结果：字典被修改，新增了元素

drictOne = {"name":"hgq", "age":28, "sex":"male"}
drictOne["address"] = 'henan'
print(drictOne)

更新元素
语法：字典[Key] = Value，结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

drictOne = {"name":"hgq", "age":28, "sex":"male"}
drictOne["name"] = 'itheima'
print(drictOne)

删除元素
语法：字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

drictOne = {"name":"hgq", "age":28, "sex":"male"}
drictOne.pop("name")
print(drictOne)

清空字典
语法：字典.clear()，结果：字典被修改，元素被清空

drictOne = {"name":"hgq", "age":28, "sex":"male"}
drictOne.clear()
print(drictOne)

获取全部的key
语法：字典.keys()，结果：得到字典中的全部Key

drictOne = {"name":"hgq", "age":28, "sex":"male"}
print(drictOne.keys())

遍历字典
语法：for key in 字典.keys()

drictOne = {"name":"hgq", "age":28, "sex":"male"}
for key in drictOne.keys():
    print(drictOne[key])

计算字典内的全部元素（键值对）数量
语法：len(字典)
结果：得到一个整数，表示字典内元素（键值对）的数量

drictOne = {"name":"hgq", "age":28, "sex":"male"}
print(len(drictOne))

字典有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对
• 可以通过Key获取到Value，Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加或删除更新元素等）
• 支持for循环，不支持while循环

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

5类数据容器都支持for循环遍历
列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

len(容器)
统计容器的元素个数
max(容器)
统计容器的最大元素
min(容器)
统计容器的最小元素
list(容器)
将给定容器转换为列表
str(容器)
将给定容器转换为字符串
tuple(容器)
将给定容器转换为元组
set(容器)
将给定容器转换为集合
sorted(容器, [reverse=True])
将给定容器进行排序

注意，排序后都会得到列表（list）对象

字符串大小比较

字符串所用的所有字符如：

• 大小写英文单词
• 数字
• 特殊符号(!、\、|、@、#、空格等）

都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值
字符串进行比较就是基于数字的码值大小进行比较的。

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

---

总结

希望本文的讲解能为你的学习和项目提供实用的参考，祝你编程愉快！