C 语言转python快速入门(一)

C 语言转python快速入门(一)

这份笔记适配有C语言基础的学习者，对比C语言语法差异，整理了Python入门核心知识点

一、基础语法规范

`# 示例1：打印单个元素（字符串、整数、浮点数均可）
print("Hello Python") # 打印字符串，输出：Hello Python
print(100) # 打印整数，输出：100
print(3.14) # 打印浮点数，输出：3.14

示例2：打印多个元素（逗号分隔，自动空格拼接）

name = "张三"
age = 18
print("姓名：", name, "年龄：", age) # 输出：姓名： 张三 年龄： 18

示例3：结合字符串拼接打印（适配C语言学习者的拼接习惯）

`

`print("姓名：" + name + "，年龄：" + str(age)) # 输出：姓名：张三，年龄：18（需转义类型）`

9. 不换行：`print(内容, end='')`，`end`可自定义结尾字符（如逗号、空格），对应C语言printf("%s", str)不换行的需求
`# 示例1：不换行打印，默认end为空字符串
print("Hello", end='')
print(" World") # 输出：Hello World（两句拼接在同一行）

示例2：自定义end为逗号，用于连续打印多个数据

print(10, end=',')
print(20, end=',')
print(30) # 输出：10,20,30

示例3：end为换行符（与默认效果一致）

print("第一行", end='\\n')
` `print("第二行") # 输出：第一行（换行）第二行`

二、字面量与变量

1. 字面量

程序中直接写出来的固定数据，如：10、3.14、"hello"、True

2. 变量

• 定义：无需声明类型，直接赋值即可（Python是动态类型语言，一种变量可接收不同类型的值）

• 命名规则（和C语言一致，即标识符命名规范）：

• 只能由字母、数字、下划线组成

• 不能以数字开头

• 区分大小写，不能用Python关键字（如if、for、import）

3. 数据类型与判断

• 补充：type(数据/变量) 用于查看变量/数据的类型；isinstance(数据, 类型) 查看数据是否属于该类型，是返回布尔值True，否返回False（注意：原笔记中ture拼写错误，正确为True）

• 补充技巧：Ctrl+D 可快速复制当前行（对应原笔记“快速负责”，正确为“快速复制”）

三、字符串（重点）

1. 三种定义方式

# 1. 双引号（支持嵌套单引号，可使用转义字符）
s1 = "hello\\"" # \\ 为转义字符，用于输出特殊符号（如双引号）
# 2. 单引号（支持嵌套双引号）
s2 = 'hello'
# 3. 三引号（支持多行字符串，保留换行和缩进）
s3 = """
hello
world
"""
print(s1)
print(s2)
print(s3)

2. 字符串操作

示例1：两个字符串拼接

s1 = "Hello"
s2 = "Python"
print(s1 + s2) # 输出：HelloPython（无空格拼接）
print(s1 + " " + s2) # 输出：Hello Python（加空格拼接）

示例2：字符串与非字符串拼接（需转换类型，避免报错）

age = 18
# 错误示例：print("年龄：" + age) # 报错：TypeError（int不能和str拼接）
print("年龄：" + str(age)) # 正确：转换为字符串，输出：年龄：18

示例3：多字符串连续拼接

name = "张三"
score = 95
` `print("姓名：" + name + "，分数：" + str(score) + "，等级：优秀") # 输出：姓名：张三，分数：95，等级：优秀`

示例1：非字符串转字符串

num1 = 100 # int类型
num2 = 3.14 # float类型
bool1 = True # bool类型
print(str(num1), type(str(num1))) # 输出：100 <class 'str'>
print(str(num2), type(str(num2))) # 输出：3.14 <class 'str'>
print(str(bool1), type(str(bool1))) # 输出：True <class 'str'>

示例2：字符串转其他类型（常用在输入后转换）

s_num = "100"
s_float = "3.14"
print(int(s_num), type(int(s_num))) # 输出：100 <class 'int'>
print(float(s_float), type(float(s_float))) # 输出：3.14 <class 'float'>

注意：无法将非数值类字符串转为数字（报错）

# print(int(“hello”)) # 报错：ValueError`

name = "张三"
age = 18
score = 95.5
print(f"姓名：{name}，年龄：{age}，分数：{score}") # 输出：姓名：张三，年龄：18，分数：95.5

方式2：format()方法（兼容所有版本，通用）

print("姓名：{}，年龄：{}，分数：{}".format(name, age, score)) # 输出同上

指定占位顺序（避免参数顺序出错）

print("分数：{2}，姓名：{0}，年龄：{1}".format(name, age, score)) # 输出：分数：95.5，姓名：张三，年龄：18

方式3：%格式化（类似C语言printf，适配C语言学习者习惯）

print("姓名：%s，年龄：%d，分数：%.1f" % (name, age, score)) # 输出：姓名：张三，年龄：18，分数：95.5
` `# 说明：%s对应字符串，%d对应整数，%.1f对应保留1位小数的浮点数`

3. 字符串补充特性（新增）

• 特性：不可修改、有序、可迭代，每一个字符都对应一个下标，支持正反向索引（和列表一致）

• 切片：与列表切片规则完全一致，语法 字符串[开始:结束:步长]

• 成员判断：用 in 运算符，判断某个字符是否在字符串中，用法与列表一致

四、输入输出

示例1：基础输入（提示用户输入姓名）

name = input("请输入你的姓名：")
print("你输入的姓名是：", name) # 输入：张三，输出：你输入的姓名是： 张三

示例2：输入后直接打印（无需赋值给变量）

input("请输入任意内容，按回车继续…") # 仅提示，不保存输入内容
` `print("输入完成！")`

示例：输入数字，默认是字符串类型

num = input("请输入一个数字：")
print("你输入的内容：", num) # 输入：100，输出：你输入的内容： 100
print("输入内容的类型：", type(num)) # 输出：<class 'str'>（字符串类型）

# 对比：若直接进行算术运算，会报错（字符串无法参与运算）
` `# print(num + 10) # 报错：TypeError（str和int不能相加）`

示例1：输入整数并运算

num1 = int(input("请输入第一个整数："))
num2 = int(input("请输入第二个整数："))
print("两个数的和：", num1 + num2)
print("两个数的积：", num1 * num2)

运行流程：输入10 → 输入20 → 输出：两个数的和：30，两个数的积：200

示例2：输入浮点数并运算（计算圆的面积）

radius = float(input("请输入圆的半径："))
pi = 3.14
area = pi * radius ** 2
print(f"圆的面积为：{area:.2f}") # 保留2位小数，输入5 → 输出：78.50

示例3：异常处理（避免输入非数字报错，提升代码健壮性）

try:
num = int(input("请输入一个整数："))
print("你输入的整数是：", num)
except:
` ` print("输入错误！请输入有效的整数。")`

五、运算符（对比C语言）

1. 算术运算符

• 优先级：** > * / // % > + –

2. 逻辑运算符（Python专用，替代C语言符号）

• 补充：逻辑运算符的返回值为布尔类型（True/False）

3. 比较/赋值运算符

和C语言完全一致：> < >= <= == !=、= += -= *=等

六、流程控制语句

1. 条件语句

（1）if-elif-else（替代C语言的if-else if-else）

# 基础if语法示例
s1 = 60
if s1 > 100: # if 条件:（末尾必须加冒号）
print("jassh") # 通过Tab缩进表达从属关系
print("jassh")
print("mmn") # 无缩进，不属于if语句块，必执行

# if-elif-else完整示例（elif == else if）
score = int(input("输入分数："))
if score >= 90:
print("优秀")
elif score >= 60:
print("及格")
else:
print("不及格")

（2）match-case（替代C语言的switch）

s2 = int(input())
match s2:
case 1:print("jassh")
case 2:print("jassh")
case 3|4:print("jassh") # | 相当于3或者4
case _:print("jannnsh") # 当以上都不满足的情况下，等价于switch的default
# 特点：当一条case语句执行完之后，其他case语句将不再执行，无需手动加break

2. 循环语句

（1）while循环

# 语法：while 条件: 循环语句 else: 条件不成立时执行的语句（不循环时执行）
i = 0
while i < 5:
print(i)
i += 1
else:
# 循环正常结束（非break中断）时执行
print("循环结束")

（2）for循环（Python特色，可与else结合）

• 基础语法：for 变量 in 可迭代对象:，变量（如a）无需提前定义，每次循环将可迭代对象（如字符串bee）的一个元素赋值给变量，完成一次循环

• 搭配range()生成数字序列（重点）：

3. 循环控制

• break、continue 用法和C语言完全一致，语句末尾无需加;

• break：跳出整个循环；continue：跳过本次循环，执行下一次循环

七、调试方法

八、随机数生成

# 导入随机数模块
import random
# 生成1~100之间的随机整数（包含1和100）
random_num = random.randint(1, 100)
print(random_num)

九、数据容器（重点，等价于C语言的数组，拓展全类型）

Python中数据容器：列表list、字符串str、元组tuple、集合set、字典dict，均用于存储多个数据，各有特性，适配不同场景。

1. 列表list（最常用，增强版数组）

示例2：存储不同类型元素（Python特色，C语言数组不支持）

mix_list = [10, "hello", 3.14, True, [6,7,8]] # 整数、字符串、浮点数、布尔值、嵌套列表
print("同类型列表：", num_list)
` `print("不同类型列表：", mix_list)`

order_list = ["a", "b", "c"]
print("有序列表输出：", order_list) # 输出：['a', 'b', 'c']

可重复性：元素可以重复出现

repeat_list = [1, 2, 2, 3, 3, 3]
print("可重复列表：", repeat_list) # 输出：[1, 2, 2, 3, 3, 3]

可修改性：后续可修改元素值

modify_list = [10, 20, 30]
modify_list[1] = 200 # 修改索引1的元素
` `print("修改后列表：", modify_list) # 输出：[10, 200, 30]`

lst = [1, 2, 3, 4, 5, 6]
# 正向索引：从0开始，依次递增，对应元素的第1个、第2个…第n个
print("正向索引0对应的元素：", lst[0]) # 输出：1（第1个元素）
print("正向索引2对应的元素：", lst[2]) # 输出：3（第3个元素）
# 反向索引：从-1开始，依次递减，-1对应最后一个元素，-2对应倒数第二个元素
print("反向索引-1对应的元素：", lst[–1]) # 输出：6（最后一个元素）
print("反向索引-3对应的元素：", lst[–3]) # 输出：4（倒数第三个元素）

注意：索引不能超出列表范围，否则会报错（和C语言数组下标越界报错类似）

`

`# print(lst[10]) # 报错：IndexError: list index out of range`

# 修改索引1的元素（原元素为2），改为99
lst[1] = 99
print("修改后列表：", lst) # 输出：[1, 99, 3, 4, 5, 6]
# 修改索引4的元素（原元素为5），改为500
lst[4] = 500
print("再次修改后列表：", lst) # 输出：[1, 99, 3, 4, 500, 6]
# 也可以修改不同类型的元素
lst[2] = "python"
` `print("修改为不同类型后：", lst) # 输出：[1, 99, 'python', 4, 500, 6]`

# 方式1：del关键字（按索引删除，彻底删除，无返回值）
del lst[2] # 删除索引2的元素（值为3）
print("del删除后：", lst) # 输出：[1, 2, 4, 5, 6]
# 方式2：remove()方法（按元素值删除，删除第一个匹配的元素）
lst.remove(4) # 删除第一个值为4的元素
print("remove删除后：", lst) # 输出：[1, 2, 5, 6]
# 方式3：pop()方法（按索引删除，默认删除最后一个元素，返回被删除的元素）
del_val1 = lst.pop() # 默认删除最后一个元素（值为6）
print("pop默认删除返回值：", del_val1) # 输出：6
print("pop默认删除后：", lst) # 输出：[1, 2, 5]
del_val2 = lst.pop(1) # 删除索引1的元素（值为2）
print("pop按索引删除返回值：", del_val2) # 输出：2
` `print("pop按索引删除后：", lst) # 输出：[1, 5]`

# 1. 省略所有参数（默认开始=0，结束=末尾，步长=1）：截取整个列表
print("截取整个列表：", lst[:]) # 输出：[1,2,3,4,5,6,7,8]
# 2. 省略开始和步长（默认开始=0，步长=1）：从开头截取到结束索引5（不包含5）
print("从开头截取到索引5：", lst[:5]) # 输出：[1,2,3,4,5]
# 3. 省略结束和步长（默认结束=末尾，步长=1）：从开始索引2截取到末尾
print("从索引2截取到末尾：", lst[2:]) # 输出：[3,4,5,6,7,8]
# 4. 指定开始和结束，省略步长（默认步长=1）：从索引2截取到索引6（不包含6）
print("从索引2截取到索引6：", lst[2:6]) # 输出：[3,4,5,6]
# 5. 指定步长为2：从开头截取，每隔1个元素取一个（跳过1个元素）
print("步长为2截取：", lst[::2]) # 输出：[1,3,5,7]
# 6. 步长为-1：反向截取（从末尾到开头，相当于倒序）
print("反向截取（倒序）：", lst[::–1]) # 输出：[8,7,6,5,4,3,2,1]
# 7. 反向截取指定范围：从索引6反向截取到索引2（不包含2）
` `print("反向截取指定范围：", lst[6:2:–1]) # 输出：[7,6,5,4]`

`l1 = [1, 2, 3]
l2 = [4, 5, 6]
# 方式1：+号拼接（生成新列表，不修改原列表l1和l2）
l3 = l1 + l2
print("+号拼接新列表：", l3) # 输出：[1,2,3,4,5,6]
print("原列表l1：", l1) # 输出：[1,2,3]（无变化）
print("原列表l2：", l2) # 输出：[4,5,6]（无变化）

# 方式2：extend()方法（将l2的所有元素添加到l1的末尾，修改原列表l1，不修改l2）
l1.extend(l2)
print("extend修改后l1：", l1) # 输出：[1,2,3,4,5,6]
print("原列表l2：", l2) # 输出：[4,5,6]（无变化）

# 方式3：解包拼接（用*解包两个列表的元素，生成新列表，不修改原列表）
l1 = [1,2,3] # 重置l1
l4 = [*l1, *l2] # *l1表示解包l1的元素，*l2表示解包l2的元素
print("解包拼接新列表：", l4) # 输出：[1,2,3,4,5,6]
` `print("原列表l1：", l1) # 输出：[1,2,3]（无变化）`

# 判断元素3是否在列表中
print("3在列表中：", 3 in lst) # 输出：True（存在）
# 判断元素6是否在列表中
print("6在列表中：", 6 in lst) # 输出：False（不存在）
# 判断元素3是否不在列表中（取反）
print("3不在列表中：", 3 not in lst) # 输出：False
# 判断元素6是否不在列表中（取反）
` `print("6不在列表中：", 6 not in lst) # 输出：True`

普通循环方式（繁琐）

lst1 = []
for i in range(1, 11):
lst1.append(i)
print("普通循环生成列表：", lst1) # 输出：[1,2,3,4,5,6,7,8,9,10]

列表推导式方式（简洁）

lst2 = [i for i in range(1, 11)]
print("推导式生成列表：", lst2) # 输出：[1,2,3,4,5,6,7,8,9,10]

# 示例2：有筛选条件，生成1-10的偶数列表（筛选i%2==0的元素）
lst3 = [i for i in range(1, 11) if i % 2 == 0]
print("筛选偶数的推导式列表：", lst3) # 输出：[2,4,6,8,10]

# 示例3：复杂推导式，生成1-10的偶数的平方列表
lst4 = [i**2 for i in range(1, 11) if i % 2 == 0]
` `print("偶数平方的推导式列表：", lst4) # 输出：[4,16,36,64,100]`

2. 元组tuple（不可修改版列表）

• 核心特性：元组（tuple）与列表（list）的用法高度相似，但最核心的区别是元素不可修改，相当于C语言中用const修饰的数组（const数组不可修改元素值）。除此之外，元组同样具备“有序、可重复、可迭代”的特性，有序指元素排列顺序固定，可重复指同一个元素可多次出现，可迭代指可以通过循环遍历元组中的元素。

• 定义：元组的语法格式为 元组名称 = (元素1, 元素2, …, 元素n)，与列表的区别是用圆括号()包裹元素（列表用方括号[]）。需要特别注意的是，定义单元素元组时，必须在元素末尾加逗号,，否则Python会将其识别为普通数据类型（而非元组），这是元组定义的高频易错点。

# 示例1：多元素元组（正常定义，用圆括号包裹）
t1 = (1, 2, 3, 4, 5) # 存储5个整数的元组
print("多元素元组：", t1) # 输出：(1, 2, 3, 4, 5)
print("元组类型：", type(t1)) # 输出：<class 'tuple'>

# 示例2：空元组（两种定义方式，均可用）
t2 = () # 方式1：直接用空圆括号
t3 = tuple() # 方式2：用tuple()函数
print("空元组t2：", t2) # 输出：()
print("空元组t3：", t3) # 输出：()

# 示例3：单元素元组（重点！必须加逗号）
t4 = (10,) # 正确定义：元素末尾加逗号，是元组类型
t5 = (10) # 错误定义：无逗号，被识别为整数int类型
print("单元素元组t4：", t4) # 输出：(10,)
print("t4类型：", type(t4)) # 输出：<class 'tuple'>
print("错误定义t5：", t5) # 输出：10
print("t5类型：", type(t5)) # 输出：<class 'int'>

# 示例4：省略圆括号的元组（允许省略，但建议加上，提升可读性）
t6 = 5, 7, 9 # 省略圆括号，本质也是元组
print("省略括号的元组：", t6) # 输出：(5, 7, 9)
` `print("t6类型：", type(t6)) # 输出：<class 'tuple'>`

• 常用方法：由于元组元素不可修改，因此元组的方法比列表少，核心常用方法只有2个，均用于元素查询，无法像列表那样添加、删除、修改元素。

• count(元素)：用于统计某个指定元素在元组中出现的次数，语法格式为 元组名.count(要统计的元素)，返回值为整数（出现的次数），若元素不存在，返回0。

`t = (1, 2, 3, 2, 4, 2, 5)
# 统计元素2在元组中出现的次数
count_2 = t.count(2)
print("元素2出现的次数：", count_2) # 输出：3（元素2共出现3次）
# 统计元素6在元组中出现的次数（元素不存在）
count_6 = t.count(6)
` `print("元素6出现的次数：", count_6) # 输出：0`

– **index(元素)**：用于查找某个指定元素在元组中**第一次出现**的索引位置，语法格式为 `元组名.index(要查找的元素)`，返回值为整数（索引值），若元素不存在，会直接报错（和列表的index()方法用法一致）。
`t = (1, 2, 3, 2, 4, 2, 5)
# 查找元素4第一次出现的索引
index_4 = t.index(4)
print("元素4第一次出现的索引：", index_4) # 输出：4（元素4在索引4位置）
# 查找元素2第一次出现的索引
index_2 = t.index(2)
print("元素2第一次出现的索引：", index_2) # 输出：1（元素2在索引1位置）
# 查找不存在的元素（会报错）
` `# index_6 = t.index(6) # 报错：ValueError: tuple.index(x): x not in tuple`

组包与解包（特色用法）

# 组包：将多个数据自动封装为元组（可省略括号）
t1 = (1,2,3,4,5,6)
t6 = 5,7,9 # 省略括号，本质也是元组（建议加上括号，更规范）
# 解包：将元组的元素依次赋值给多个变量
a,b,c,d,e,f = t1 # a对应1，b对应2，…，f对应6
print(a) # 输出：1

# 拓展解包：用*收集多余元素（封装为列表）
x,*y,z = t1 # x接收第一个元素1，z接收最后一个元素6，其余元素由y接收（y是列表[2,3,4,5]）
# *表示收集所有剩余元素，封装到列表中，可处理数量不确定的元素

3. 集合set（自动去重容器）

• 核心特性：集合（set）是Python中一种特殊的数据容器，核心特性有三个，与列表、元组差异较大，需要重点区分：
  无序性：集合中的元素没有固定的排列顺序，每次打印集合，元素的输出顺序可能不同（与列表、元组的有序性完全相反），因此集合不支持索引访问（无下标概念）；

• 不可重复性：集合会自动去除重复的元素，无论定义时输入多少个重复元素，最终集合中只会保留一个（这是集合最常用的特性之一，用于去重）；

• 可修改性：集合可以添加、删除元素，但由于其无序性，无法像列表那样通过索引修改元素（只能先删除旧元素，再添加新元素）。

• 定义：集合的语法格式为 集合名称 = {元素1, 元素2, …, 元素n}，用大括号{}包裹元素，但需要特别注意：{} 空集合不能用定义（{}用于定义空字典），空集合必须用 set() 函数定义，这是集合定义的高频易错点。此外，也可以用 set(可迭代对象) 函数，将列表、元组等可迭代对象转换为集合（自动去重）。

# 示例1：正常集合（自动去重）
s1 = {1, 2, 3, 2, 4} # 定义时包含重复元素2
print("自动去重后的集合：", s1) # 输出：{1,2,3,4}（重复元素2被自动去除）
print("集合类型：", type(s1)) # 输出：<class 'set'>
# 示例2：空集合（重点！必须用set()定义）
s2 = set() # 正确：空集合
s3 = {} # 错误：定义的是空字典，不是集合
print("空集合s2：", s2) # 输出：set()
print("s2类型：", type(s2)) # 输出：<class 'set'>
print("错误定义s3：", s3) # 输出：{}
print("s3类型：", type(s3)) # 输出：<class 'dict'>

# 示例3：用列表转换为集合（自动去重）
lst = [1, 2, 3, 3, 4, 5]
s4 = set(lst) # 将列表转换为集合，自动去重
print("列表转换的集合：", s4) # 输出：{1,2,3,4,5}

# 示例4：用元组转换为集合（自动去重）
t = (1, 1, 2, 3, 3, 3)
s5 = set(t)
` `print("元组转换的集合：", s5) # 输出：{1,2,3}`

• 常见操作：集合的常见操作分为“元素操作”和“集合运算”两类，元素操作包括添加、删除、清空，集合运算包括交集、并集、差集（类似数学中的集合运算），具体用法如下：

一、元素操作（添加、删除、清空）

s = {1, 2, 3, 4, 5}

1. 添加元素：add()方法（只能添加单个元素，元素已存在则不操作）

s.add(6) # 添加元素6（不存在，添加成功）
print("添加元素6后：", s) # 输出：{1,2,3,4,5,6}
s.add(3) # 添加元素3（已存在，不操作）
print("添加已存在元素3后：", s) # 输出：{1,2,3,4,5,6}（无变化）

2. 删除元素：两种常用方法（remove()和discard()）

# 方法1：remove()方法（删除指定元素，元素不存在会报错）
s.remove(3) # 删除元素3（存在，删除成功）
print("remove删除元素3后：", s) # 输出：{1,2,4,5,6}
# s.remove(7) # 删除元素7（不存在，报错：KeyError）

# 方法2：discard()方法（删除指定元素，元素不存在不报错，推荐使用）
s.discard(4) # 删除元素4（存在，删除成功）
print("discard删除元素4后：", s) # 输出：{1,2,5,6}
s.discard(7) # 删除元素7（不存在，不报错，无变化）
print("discard删除不存在元素7后：", s) # 输出：{1,2,5,6}

3. 清空集合：clear()方法（清空所有元素，变为空集合）

s.clear()
print("清空后的集合：", s) # 输出：set()

二、集合运算（交集、并集、差集，类似数学集合）

s1 = {1, 2, 3, 4} # 集合1
s2 = {3, 4, 5, 6} # 集合2
# 1. 交集：& 符号，获取两个集合共有的元素（既在s1中，也在s2中）
intersection = s1 & s2
print("s1和s2的交集：", intersection) # 输出：{3,4}

# 2. 并集：| 符号，获取两个集合的所有元素（去重）
union = s1 | s2
print("s1和s2的并集：", union) # 输出：{1,2,3,4,5,6}

# 3. 差集：- 符号，获取“前一个集合有、后一个集合没有”的元素
diff1 = s1 – s2 # s1有、s2没有的元素
diff2 = s2 – s1 # s2有、s1没有的元素
print("s1 – s2（差集）：", diff1) # 输出：{1,2}
print("s2 – s1（差集）：", diff2) # 输出：{5,6}

三、集合推导式（简化集合创建，自动去重）

语法：新集合名 = {要插入的元素 for 变量 in 可迭代对象 if 条件判断}

# 示例：生成1-10的奇数集合
s3 = {i for i in range(1, 11) if i % 2 == 1}
print("1-10的奇数集合：", s3) # 输出：{1,3,5,7,9}

# 示例：生成列表中不重复的偶数集合
lst = [2, 4, 2, 6, 4, 8]
s4 = {i for i in lst if i % 2 == 0}
` `print("列表去重后的偶数集合：", s4) # 输出：{2,4,6,8}`

4. 字典dict（键值对容器，C语言无对应类型）

• 核心特性：字典（dict）是Python中最灵活、最常用的数据容器之一，C语言中没有对应的类型，其核心特性与列表、元组、集合差异较大，重点关注以下4点：
  键值对存储：字典不存储单个元素，而是以“键值对（key:value）”的形式存储数据，每个键值对由“键（key）”和“值（value）”组成，key用于定位value，类似C语言中的“键值对数组”（但更灵活）；

• key唯一性：字典中的key必须是唯一的，不能重复，若定义时出现重复key，后面的key会覆盖前面的key；value可以重复，且可以是任意数据类型；

• 有序性：Python 3.7版本及以上，字典是有序的（元素顺序与定义顺序一致）；Python 3.7版本以下，字典是无序的，日常开发中无需刻意关注版本，按有序使用即可；

• 可修改性：字典可以添加、删除、修改键值对，操作灵活，可根据key快速定位并修改对应的value。

• 定义：字典的语法格式为 字典名称 = {key1:value1, key2:value2, …, keyn:valuen}，用大括号{}包裹键值对，每个键值对用冒号:分隔，多个键值对用逗号,分隔。空字典有两种定义方式：字典名 = {} 或 字典名 = dict()，也可以用 dict(键值对参数) 或 dict(可迭代对象) 函数创建字典。

# 示例1：正常字典（key为字符串，value为不同类型）
dict1 = {
"name": "张三", # key: "name"，value: 字符串
"age": 18, # key: "age"，value: 整数
"score": 90.5, # key: "score"，value: 浮点数
"is_pass": True, # key: "is_pass"，value: 布尔值
"hobbies": ["篮球", "游戏"] # key: "hobbies"，value: 列表
}
print("正常字典：", dict1)
print("字典类型：", type(dict1)) # 输出：<class 'dict'>

# 示例2：空字典（两种定义方式）
dict2 = {} # 方式1：用空大括号
dict3 = dict() # 方式2：用dict()函数
print("空字典dict2：", dict2) # 输出：{}
print("空字典dict3：", dict3) # 输出：{}

# 示例3：重复key的情况（后面的key覆盖前面的）
dict4 = {"name": "张三", "name": "李四", "age": 19}
print("重复key的字典：", dict4) # 输出：{'name': '李四', 'age': 19}（前面的name被覆盖）

# 示例4：用dict()函数创建字典
dict5 = dict(name="王五", age=20, score=88) # 键值对参数
dict6 = dict([("name", "赵六"), ("age", 21)]) # 可迭代对象（元组组成的列表）
print("dict()参数创建：", dict5) # 输出：{'name': '王五', 'age': 20, 'score': 88}
` `print("dict()可迭代对象创建：", dict6) # 输出：{'name': '赵六', 'age': 21}`

• 常用操作：字典的常用操作围绕“键值对”展开，包括访问value、修改value、添加键值对、删除键值对、遍历字典、字典推导式等，具体用法如下，重点掌握“通过key操作value”：
  `dict1 = {“name”: “张三”, “age”: 18, “score”: 90}

一、访问value（核心：通过key访问，不可用索引）

# 方式1：字典名[key]（直接访问，key不存在会报错）
print("通过key访问name：", dict1["name"]) # 输出：张三
print("通过key访问age：", dict1["age"]) # 输出：18
# print(dict1["gender"]) # key不存在，报错：KeyError: 'gender'

# 方式2：get()方法（安全访问，key不存在返回None或指定默认值，推荐使用）
print("get()访问gender（无默认值）：", dict1.get("gender")) # 输出：None
print("get()访问gender（有默认值）：", dict1.get("gender", "男")) # 输出：男（指定默认值）

二、修改value（通过key赋值，key存在则修改，不存在则添加）

dict1["age"] = 19 # key"age"存在，修改其value
print("修改age后：", dict1) # 输出：{'name': '张三', 'age': 19, 'score': 90}

三、添加键值对（key不存在时，直接赋值即可添加）

dict1["gender"] = "男" # key"gender"不存在，添加键值对
dict1["hobbies"] = ["篮球", "编程"] # 添加value为列表的键值对
print("添加键值对后：", dict1) # 输出：{'name': '张三', 'age': 19, 'score': 90, 'gender': '男', 'hobbies': ['篮球', '编程']}

四、删除键值对（通过key删除，常用del关键字和pop()方法）

# 方式1：del关键字（删除指定key对应的键值对，key不存在报错）
del dict1["score"] # 删除key"score"对应的键值对
print("del删除score后：", dict1) # 输出：{'name': '张三', 'age': 19, 'gender': '男', 'hobbies': ['篮球', '编程']}

# 方式2：pop()方法（删除指定key对应的键值对，返回被删除的value，key不存在可指定默认值）
del_val = dict1.pop("hobbies") # 删除key"hobbies"，返回其value
print("pop删除返回值：", del_val) # 输出：['篮球', '编程']
print("pop删除hobbies后：", dict1) # 输出：{'name': '张三', 'age': 19, 'gender': '男'}
# key不存在时，指定默认值（不报错）
del_val2 = dict1.pop("score", "无此key")
print("pop删除不存在key的返回值：", del_val2) # 输出：无此key

五、遍历字典（三种常用方式，重点掌握遍历键值对）

方式1：遍历所有key（用keys()方法）

print("遍历所有key：")
for key in dict1.keys():
print(key) # 输出：name、age、gender

方式2：遍历所有value（用values()方法）

print("遍历所有value：")
for value in dict1.values():
print(value) # 输出：张三、19、男

方式3：遍历所有键值对（用items()方法，最常用）

print("遍历所有键值对：")
for key, value in dict1.items():
print(f"{key}: {value}") # 输出：name: 张三、age: 19、gender: 男

六、字典推导式（简化字典创建，类似列表推导式）

语法：新字典名 = {key: value for 变量 in 可迭代对象 if 条件判断}

# 示例1：生成key为1-5，value为对应平方的字典
dict7 = {i: i**2 for i in range(1, 6)}
print("1-5平方的字典：", dict7) # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 示例2：筛选key为偶数的字典
dict8 = {i: i*2 for i in range(1, 11) if i % 2 == 0}
` `print("key为偶数的字典：", dict8) # 输出：{2:4, 4:8, 6:12, 8:16, 10:20}`

十、补充：列表常用方法（拓展必备）