Python零基础核心进阶：四大容器+函数全网超全详解

本文整合Python入门最核心、最高频的知识点：列表、 元组 、字典、集合四大容器 + 函数入门、变量 作用域 、五种函数传参方式。所有内容搭配可运行示例代码、知识点解析，无废话纯干货，适合新手系统学习、面试复盘、期末备考。

所有代码均经过规整修复，可直接复制运行，零基础也能轻松看懂。

一、Python四大容器详解（列表/元组/字典/集合）

1.1 列表 List（可变有序容器，最常用）

列表是Python中最灵活的容器，有序、可变、可重复、支持切片，可以存储任意类型数据。

1.1.1 列表基础运算

# 列表加法：拼接两个列表
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
my_list3 = my_list1 + my_list2
print(my_list3)  # [1, 2, 3, 4, 5, 6]

# 列表乘法：重复复制元素
my_list4 = [1, 2, 3]
my_list5 = my_list4 * 3
print(my_list5)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 列表比较：元素完全一致才为True
my_list6 = [1, 2, 3]
my_list7 = [4, 5, 6]
print(my_list6 == my_list7)  # False

# 索引取值、负索引取值
my_list8 = [1, 2, 3, 4, 5]
print(my_list8[0])   # 第一个元素 1
print(my_list8[-1])  # 最后一个元素 5

# 列表切片 [起始:结束:步长]
print(my_list8[2])       # 3
print(my_list8[1:])     # [2, 3, 4, 5]
print(my_list8[1:3])    # [2, 3]
print(my_list8[:3])     # [1, 2, 3]
print(my_list8[:])      # [1, 2, 3, 4, 5]（拷贝列表）
print(my_list8[1:2:1])  # [2]
print(my_list8[1:4:2])  # [2, 4]
print(my_list8[-1:-4:2])# []
print(my_list8[-1:-4:-2])# [5, 3]
print(my_list8[-4:-1:-2])# []
print(my_list8[::-2])   # [5, 3, 1]

1.1.2 列表常用内置函数

my_list = [1, 2, 3, 4, 5]
print(len(my_list))   # 获取长度 5
print(max(my_list))   # 最大值 5
print(min(my_list))   # 最小值 1
print(sum(my_list))   # 求和 15

# 排序函数（生成新列表，原列表不变）
my_list2 = [5, 3, 1, 4, 2]
print(sorted(my_list2))        # 升序 [1, 2, 3, 4, 5]
print(sorted(my_list2, reverse=True))  # 降序 [5, 4, 3, 2, 1]

# 反转（生成新迭代器）
print(reversed(my_list2))
print(list(reversed(my_list2)))  # [2, 4, 1, 3, 5]

1.1.3 列表常用增删改查方法（原地修改）

# 增
my_list = [1, 2, 3, 4, 5]
my_list.append(6)       # 末尾追加单个元素
print(my_list)  # [1, 2, 3, 4, 5, 6]

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, 6)    # 指定索引插入元素
print(my_list)  # [1, 2, 6, 3, 4, 5]

my_list = [1, 2, 3, 4, 5]
my_list.extend([6, 7, 8]) # 末尾批量追加可迭代对象
print(my_list)  # [1, 2, 3, 4, 5, 6, 7, 8]

# 删
my_list = [1, 2, 3, 4, 5]
my_list.remove(3)       # 删除第一个匹配的指定元素
print(my_list)  # [1, 2, 4, 5]

my_list = [1, 2, 3, 4, 5]
print(my_list.pop(2))   # 删除并返回指定索引元素 3
print(my_list)  # [1, 2, 4, 5]

my_list = [1, 2, 3, 4, 5]
my_list.clear()         # 清空列表
print(my_list)  # []

# 查
my_list = [1, 2, 3, 4, 5, 3, 3]
print(my_list.index(3))  # 返回第一个匹配元素的索引 2
print(my_list.count(3))  # 统计元素出现次数 3

# 排序反转（原地修改）
my_list = [5, 3, 1, 4, 2]
my_list.sort()
print(my_list)  # [1, 2, 3, 4, 5]

my_list = [5, 3, 1, 4, 2]
my_list.reverse()
print(my_list)  # [2, 4, 1, 3, 5]

1.2 元组 Tuple（不可变有序容器）

元组有序、不可变、可重复，定义后无法修改元素，安全性更高，适合存储固定数据。

核心特性：单元素元组必须加逗号，否则判定为普通变量。

# 创建元组
my_tuple = (1, 2, 3, 4, 5)
my_tuple2 = ("a", "b", "c")
my_tuple3 = (1, "a", True, 3.14)
my_tuple4 = (1,)  # 单元素元组，必须带逗号

print(my_tuple, type(my_tuple))
print(my_tuple2, type(my_tuple2))
print(my_tuple3, type(my_tuple3))
print(my_tuple4, type(my_tuple4))

# 索引、切片查询（和列表一致）
print(my_tuple[0])
print(my_tuple[-1])
print(my_tuple[1:3])

# 元组不可直接修改，可转列表修改后再转回元组
# my_tuple[0] = 100  # 报错：元组不支持元素赋值
my_list = list(my_tuple)
my_list[0] = 100
my_tuple = tuple(my_list)
print(my_tuple)

1.3 字典 Dict（无序键值对容器）

字典以键值对 存储数据，键不可变、唯一，值任意类型、可重复，查询效率极高。

# 定义字典（重复键会覆盖）
my_dict = {"name": "张三", "age": 18, "gender": "男"}
print(my_dict)

# 新增/修改数据：有键则改，无键则增
my_dict["address"] = "北京市海淀区"
my_dict["name"] = "李四"
my_dict["phone"] = "13800000000"
print(my_dict)

# 删除数据
del my_dict["phone"]
print(my_dict)

# 清空字典
my_dict.clear()
print(my_dict)

# 删除字典对象
del my_dict

# 字典查询
my_dict = {"name": "张三", "age": 18, "gender": "男"}
print(my_dict["name"])   # 直接取值，无键报错
print(my_dict.get("address"))  # 无键返回None（推荐）
print(my_dict.get("address", "北京市海淀区"))  # 无键返回默认值

# 获取键、值、键值对
print(my_dict.keys())
print(my_dict.values())
print(my_dict.items())

# 字典遍历
for key, value in my_dict.items():
    print(key, value)

print("------------------")
for item in my_dict:
    print(f"{item}的值为：{my_dict[item]}")

1.4 集合 Set（无序去重容器）

集合无序、元素唯一、自动去重，元素必须是不可变类型（数字、字符串、元组），不支持列表、字典。主要用于去重、集合运算。

# 定义集合
my_set = {1, 2, 5, 4, 5}
my_set2 = {"a", "c", "c"}
my_set3 = set([1, 2, 5, 4, 5])
print("集合my_set：", my_set, type(my_set))
print("集合my_set2：", my_set2, type(my_set2))
print("集合my_set3：", my_set3, type(my_set3))

# 集合添加数据
my_set.add(3)          # 添加单个元素
print("添加元素3：", my_set)
my_set2 = {"a", "c", "d"}
my_set2.update({"d", "e"})  # 批量添加可迭代对象
print("批量添加元素：", my_set2)

# 元素查询
print(1 in my_set)

# 集合无法索引取值，可转列表
my_list = list(my_set)
print("集合转列表：", my_list)

# 字典转集合：仅保留key
my_dict = {"name": "张三", "age": 18}
my_set4 = set(my_dict)
print("字典转集合：", my_set4)

# 集合运算
s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
print("并集：", s1 | s2, s1.union(s2))
print("交集：", s1 & s2, s1.intersection(s2))
print("差集s1-s2：", s1 - s2, s1.difference(s2))
print("差集s2-s1：", s2 - s1, s2.difference(s1))
print("对称差集：", s1 ^ s2, s1.symmetric_difference(s2))

二、Python函数零基础入门

2.1 函数核心概念

函数是可重复调用的代码块，用于封装逻辑、减少冗余、提升代码复用性。

语法：def 函数名(参数): 函数体 [return 返回值]

• 无return：默认返回None
• 函数定义不执行，调用才执行
• 不加括号是函数对象，加括号才是调用

2.2 三类基础函数示例

# 无参无返回值函数
def calculate_sum1():
    a = 100
    b = 200
    print(a + b)

# 有参无返回值函数
def calculate_sum2(a, b):
    """
    计算两个数的和
    :param a: 第一个数
    :param b: 第二个数
    :return: 无
    """
    print(a + b)

# 有参有返回值函数（推荐）
def calculate_sum3(a, b):
    """
    计算两个数的和并返回结果
    :param a: 第一个数
    :param b: 第二个数
    :return: 两数之和
    """
    return a + b

if __name__ == '__main__':
    calculate_sum1()
    calculate_sum2(a=100, b=200)
    res = calculate_sum3(100, 200)
    if res >= 300:
        print("两个数的和大于等于300")
    else:
        print("两个数的和小于300")

三、变量作用域（Python&JS核心差异）

3.1 作用域分类

• 全局变量：函数外定义，全局可访问
• 局部变量：函数内定义，仅函数内生效，执行结束销毁

3.2 核心规则与global关键字

Python核心规则：函数内直接赋值同名变量，默认创建 局部变量 ，不修改全局 ；如需修改全局变量，必须声明 global。

g_number = 100

# 读取全局变量
def print_number():
    g_number2 = 200
    print("函数内全局变量：", g_number)
    print("函数内局部变量：", g_number2)

# 新建同名局部变量，不修改全局
def print_number2():
    g_number = 200
    print("函数内局部变量：", g_number)

# global修改全局变量
def print_number3():
    global g_number
    g_number = 300
    print("函数内修改后全局变量：", g_number)

if __name__ == '__main__':
    print_number()
    print("全局变量原值：", g_number)
    print("------------------------------")
    print_number2()
    print("全局变量未改变：", g_number)
    print("------------------------------")
    print_number3()
    print("全局变量已修改：", g_number)

3.3 Python与JS作用域关键区别

• Python：函数内赋值即局部变量，改全局必须global
• JS (let/const) ：规则和Python一致，声明即局部，不声明改全局
• JS (var) ：函数作用域，无块级作用域，易污染全局

四、函数五大传参方式（面试高频）

4.1 位置参数

按定义顺序传参，顺序不可乱，一一对应。

4.2 关键字参数

通过参数名=值传参，顺序随意，可读性更强。

4.3 默认参数

定义时设置默认值，不传参则使用默认值，默认参数必须后置。

4.4 可变位置参数 *args

接收任意数量位置参数，打包为元组。

4.5 可变关键字参数 **kwargs

接收任意数量关键字参数，打包为字典。

# 位置参数
def print_info(name, age):
    print("姓名：", name)
    print("年龄：", age)

# 关键字参数
def print_info2(name, age):
    print("姓名：", name)
    print("年龄：", age)

# 默认参数
def print_info3(name, age=18):
    print("姓名：", name)
    print("年龄：", age)

# 可变位置参数
def print_info4(*args):
    for arg in args:
        print(arg)

# 可变关键字参数
def print_info5(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

if __name__ == '__main__':
    # 位置参数调用
    print_info("张三", 18)
    
    # 关键字参数调用
    print_info2(name="张三", age=18)
    print_info2(age=18, name="张三")
    
    # 默认参数调用
    print_info3("张三")
    print_info3("张三", 20)
    
    # 可变参数调用
    print_info4("张三", 18, "李四", 20)
    print_info5(name="张三", age=18, sex="男")

五、全文核心总结

1. 四大容器核心差异：列表可变有序、元组不可变有序、字典键值对查询快、集合无序自动去重；
2. 函数核心：封装复用、定义不执行、调用才生效，return用于返回结果；
3. 作用域 核心：Python函数内赋值默认局部，修改全局必须global，和JS let表现一致；
4. 传参顺序铁律：位置参数 > 默认参数 > *args > **kwargs。