Python 核心知识点详解
一、变量：给数据 “起个好记的名字”
1. 大白话含义
变量就像 “贴在物品上的标签”—— 比如把 “苹果” 贴标签叫 “我的水果”，后续想拿苹果，直接找 “我的水果” 就行。在 Python 里，变量是给数据起的名字，方便后续调用，不用重复写数据本身。
2. 代码举例
# 给数据“张三”起变量名name，“18”起变量名age
name = "张三"
age = 18
# 调用变量，不用重复写“张三”“18”
print(f"我叫{name}，今年{age}岁") # 输出：我叫张三，今年18岁
# 变量能改值，就像换标签贴
age = 19
print(f"明年我{age}岁") # 输出：明年我19岁
3. 使用场景
- 存需要重复使用的数据（比如用户姓名、年龄）；
- 存计算过程中的中间结果（比如算 BMI 时的身高、体重）。
4. 注意事项
- 变量名不能用数字开头（比如1name报错，得叫name1）；
- 不能用 Python 关键字（比如if“for“print，这些是 Python 的 “专用词”）；
- 区分大小写（Name和name是两个不同变量，新手常踩这个坑）。
二、字符串类型：存 “文字内容” 的容器
1. 大白话含义
字符串就是 “带引号的文字”，不管是单个字、一句话，还是数字（只要带引号），都算字符串，比如 “你好”“123”“Python 真简单”。
2. 代码举例
# 单引号、双引号、三引号都能定义字符串
str1 = '单个字'
str2 = "一句话：今天学Python"
str3 = """多行文字：
第一行
第二行""" # 三引号适合存多行内容
# 字符串常用操作
print(str1 + str2) # 拼接：单个字一句话：今天学Python
print(str2 * 2) # 重复：一句话：今天学Python一句话：今天学Python
print(len(str2)) # 算长度：11（每个字符算1个，包括标点）
3. 使用场景
- 存文本信息（比如用户名、文章内容、提示语）；
- 拼接文字（比如生成用户欢迎语 “欢迎，张三！”）。
4. 注意事项
- 单引号里不能直接放单引号（比如'我叫'张三''报错，可改双引号"我叫'张三'"）；
- 字符串不能和数字直接运算（比如"年龄："+18报错，得转成字符串"年龄："+str(18)）。
三、数字类型：存 “能计算的数值”
1. 大白话含义
数字类型专门存能做加减乘除的数值，分两种：
- 整数（int）：不带小数点的数，比如 1、-5、100；
- 浮点数（float）：带小数点的数，比如 3.14、-0.5、20.8。
2. 代码举例
# 整数
num1 = 10
num2 = -3
# 浮点数
num3 = 3.14
num4 = 5.0 # 5.0是浮点数，不是整数
# 数字运算
print(num1 + num2) # 加法：7
print(num1 * num3) # 乘法：31.4
print(num1 / num2) # 除法：-3.3333333333333335
print(num1 // num2) # 整除：-4（只取整数部分，向下取整）
3. 使用场景
- 存量化数据（比如年龄、身高、价格、分数）；
- 做数学计算（比如算 BMI、算总价、算平均分）。
4. 注意事项
- 整数和浮点数运算，结果是浮点数（比如 10+3.14=13.14）；
- 浮点数运算可能有精度问题（比如 0.1+0.2=0.30000000000000004，可通过round(0.1+0.2,1)取 1 位小数解决）。
四、布尔类型：表示 “对或错”“是或否”
1. 大白话含义
布尔类型只有两个值：True（对、是）和False（错、否），专门用来判断条件是否成立，比如 “10>5” 是对的（True），“2==3” 是错的（False）。
2. 代码举例
# 直接判断条件
is_bigger = 10 > 5
is_equal = 2 == 3
print(is_bigger) # 输出：True
print(is_equal) # 输出：False
# 布尔类型常用在判断里
age = 18
if age >= 18:
print("成年了") # 因为age>=18是True，所以执行这句
else:
print("未成年")
3. 使用场景
- 条件判断（比如判断用户是否成年、密码是否正确）；
- 循环控制（比如判断循环是否继续执行）。
4. 注意事项
- True和False首字母必须大写（比如true报错）；
- 布尔类型可转成数字：True是 1，False是 0（比如True+1=2，False*5=0）。
五、比较运算符：判断 “两个值的关系”
1. 大白话含义
比较运算符就是 “比大小、判相等” 的符号，用它们判断两个值的关系，结果是布尔类型（True或False），比如 “大于”“小于”“等于”。
2. 代码举例（常用 6 种比较运算符）
a = 10
b = 5
print(a > b) # 大于：True
print(a < b) # 小于：False
print(a == b) # 等于：False（注意是两个等号，一个等号是赋值）
print(a != b) # 不等于：True
print(a >= b) # 大于等于：True
print(a <= b) # 小于等于：False
# 也能比较字符串（按字母顺序，a-z对应97-122）
print("apple" < "banana") # True（a的ASCII码比b小）
3. 使用场景
- 条件判断（比如if 分数>=60判断是否及格）；
- 筛选数据（比如if 价格<100筛选低价商品）。
4. 注意事项
- “等于” 是==，不是=（a=5是给 a 赋值，a==5是判断 a 是否等于 5，新手常弄混）；
- 不同类型比较可能报错（比如10 > "5"报错，得先转类型10 > int("5")）。
六、逻辑运算符：组合 “多个判断条件”
1. 大白话含义
逻辑运算符用来把多个比较条件 “串起来”，判断整体是否成立，常用 3 个：
- and（并且）：所有条件都成立，结果才是True；
- or（或者）：只要有一个条件成立，结果就是True；
- not（不是）：把原来的结果反过来（True变False，False变True）。
2. 代码举例
age = 18
score = 85
# and：同时满足“成年”和“分数>=80”
if age >= 18 and score >= 80:
print("成年且成绩良好") # 输出这句（两个条件都成立）
# or：满足“未成年”或“分数<60”
if age < 18 or score < 60:
print("未成年或不及格") # 不输出（两个条件都不成立）
# not：反过来判断“分数不小于60”
if not (score < 60):
print("及格了") # 输出这句（score<60是False，not后变True）
3. 使用场景
- 多条件判断（比如 “年满 18 且有身份证” 才能办卡）；
- 复杂筛选（比如 “价格 < 100 或销量> 1000” 的商品）。
4. 注意事项
- 优先级：not > and > or，不确定时加括号（比如not a and b先算not a，not (a and b)先算a and b）；
- 短路特性：and前面是False，后面不计算（比如False and 1/0不报错，因为 1/0 没执行）；or前面是True，后面不计算。
七、分支结构：让程序 “选路走”
1. 大白话含义
分支结构就是 “如果... 就...，否则... 就...”，让程序根据条件选择不同的代码执行，比如 “如果下雨就带伞，否则就带帽子”。Python 里主要用if“elif“else实现。
2. 代码举例（3 种常见分支）
# 1. 单分支：只有if（满足就执行，不满足就跳过）
score = 85
if score >= 60:
print("及格了") # 输出：及格了
# 2. 双分支：if+else（二选一）
age = 17
if age >= 18:
print("成年")
else:
print("未成年") # 输出：未成年
# 3. 多分支：if+elif+else（多选一）
grade = 88
if grade >= 90:
print("优秀")
elif grade >= 80:
print("良好") # 输出：良好
elif grade >= 60:
print("及格")
else:
print("不及格")
3. 使用场景
- 按条件执行不同操作（比如根据分数给评级、根据用户等级给权限）；
- 处理特殊情况（比如登录时 “密码对就登录，错就提示”）。
4. 注意事项
- if“elif“else后面必须加冒号:；
- 冒号后面的代码要缩进（一般 4 个空格），Python 靠缩进判断 “哪些代码属于这个分支”，缩进错了逻辑会乱。
八、循环结构：让程序 “重复做事”
1. 大白话含义
循环结构就是 “重复做同一件事，直到满足停止条件”，比如 “把列表里的每个元素都打印一遍”“每天背 10 个单词，背够 30 天”。Python 里主要用for和while循环。
2. 代码举例（2 种循环）
（1）for 循环：已知重复次数（遍历可迭代对象）
# 遍历列表（把每个元素都取出来）
fruits = ["苹果", "香蕉", "橘子"]
for fruit in fruits:
print(f"我喜欢吃{fruit}") # 输出3行，分别打印3种水果
# 用range()指定次数（重复5次）
for i in range(5): # range(5)是0-4，共5个数
print(f"第{i+1}次循环") # 输出：第1次...第5次
（2）while 循环：未知重复次数（按条件停止）
# 场景：从1开始加，加到和大于10为止
sum_num = 0
num = 1
while sum_num <= 10: # 条件：和<=10就继续循环
sum_num += num
num += 1
print(f"加到和大于10时，总和是{sum_num}") # 输出：15（1+2+3+4+5=15）
# 循环控制：break（跳出循环）、continue（跳过当前次，继续下一次）
for i in range(5):
if i == 2:
continue # 跳过i=2的这次，不执行下面的print
if i == 4:
break # 当i=4时，直接跳出循环
print(i) # 输出：0、1、3
3. 使用场景
- for循环：遍历数据（列表、字典、字符串等）、已知次数的重复操作；
- while循环：按条件重复（比如 “输入正确密码才停止”“下载进度到 100% 才停止”）。
4. 注意事项
- 避免死循环：while循环的条件必须能在某个时刻变成False（比如while True会一直循环，除非加break）；
- 循环里的变量要更新：while循环里要改条件里的变量（比如上面的sum_num和num），否则条件不变，会一直循环。
九、列表：装 “一堆数据” 的 “大箱子”
1. 大白话含义
列表就像 “家里的收纳箱”，能装各种类型的数据（字符串、数字、甚至其他列表），比如 “购物清单”“学生名单”，用中括号[]定义，元素之间用逗号隔开。
2. 代码举例（定义 + 常用操作）
# 定义列表（装不同类型数据）
shopping_list = ["牛奶", 2, "面包", 5.9, ["鸡蛋", 10]]
# 1. 取值：按索引（从0开始）
print(shopping_list[0]) # 取第1个元素：牛奶
print(shopping_list[-1][1]) # 取最后一个元素（小列表）的第2个值：10
# 2. 改值：按索引改
shopping_list[1] = 3 # 把第2个元素2改成3
print(shopping_list) # 输出：['牛奶', 3, '面包', 5.9, ['鸡蛋', 10]]
# 3. 加元素
shopping_list.append("苹果") # 末尾加：['牛奶', 3, ..., '苹果']
shopping_list.insert(2, "酸奶") # 索引2的位置加：['牛奶', 3, '酸奶', ...]
# 4. 删元素
shopping_list.remove("面包") # 按值删：删掉"面包"
del shopping_list[0] # 按索引删：删掉第1个元素
3. 使用场景
- 存多个同类型或相关的数据（比如班级所有学生的成绩、购物车里的商品）；
- 批量处理数据（比如循环遍历列表，给每个成绩加 5 分）。
4. 注意事项
- 索引不能越界：列表有 n 个元素，索引最大是 n-1（比如 3 个元素的列表，索引 0-2，取索引 3 会报错）；
- 列表是可变的：能直接改里面的元素（和后面的元组不同）。
十、元组：装 “不能改的数据” 的 “固定箱子”
1. 大白话含义
元组和列表很像，也是装一堆数据的 “箱子”，但它是 “固定的”—— 一旦创建，里面的元素不能改（不能加、不能删、不能改值），用小括号()定义。
2. 代码举例
# 定义元组（小括号，元素用逗号隔）
person = ("张三", 18, 1.75) # 存不可变的个人信息
# 1. 取值：和列表一样，按索引
print(person[0]) # 输出：张三
print(person[-1]) # 输出：1.75
# 2. 遍历元组
for info in person:
print(info) # 输出：张三、18、1.75
# 3. 注意：元组不能改元素（下面的代码都会报错）
# person[1] = 19 # 改值报错
# person.append("北京") # 加元素</doubaocanvas>
3. 使用场景
- 存不可变的信息（比如个人身份证号、坐标（x,y）、函数返回的多个固定值）；
- 作为字典的键（列表不能当字典键，元组可以，因为它不可变）；
- 保护数据不被意外修改（比如项目里的配置参数，不想被误改就用元组存）。
4. 注意事项
- 定义单个元素的元组，要加逗号（比如(1)是整数，(1,)才是元组，新手常漏这个逗号）；
- 元组里的 “可变元素” 能改（比如元组里装了列表，列表里的元素能改），例：
t = (1, [2,3])
t[1][0] = 4 # 能改列表里的元素，元组本身的结构没改
print(t) # 输出：(1, [4, 3])
十一、字符串：补充 “进阶处理技巧”
1. 大白话含义（补充）
除了基础的文字存储，字符串还有很多 “整理文字” 的小技巧，比如去空格、替换内容、按规则分割，这些能帮你快速处理文本数据。
2. 代码举例（进阶操作）
text = " Python is easy! It's fun to learn. "
# 1. 去空格：strip()（前后）、lstrip()（左）、rstrip()（右）
print(text.strip()) # 去前后空格："Python is easy! It's fun to learn."
print(text.lstrip()) # 去左空格："Python is easy! It's fun to learn. "
# 2. 替换内容：replace(旧内容, 新内容, 替换次数)
print(text.replace("easy", "simple")) # 把easy换成simple
print(text.replace(" ", "", 2)) # 只删前2个空格："Python is easy! It's fun to learn. "
# 3. 分割字符串：split(分隔符)，返回列表
print(text.split(" ")) # 按空格分割：['', '', 'Python', 'is', 'easy!', ...]
print(text.split(".")[0]) # 按.分割，取第一部分：" Python is easy! It's fun to learn"
# 4. 判断字符串属性（常用）
print("123".isdigit()) # 判断是否全是数字：True
print("Python".isalpha()) # 判断是否全是字母：True
print("Python123".isalnum()) # 判断是否是字母/数字：True
3. 使用场景（补充）
- 处理用户输入（比如去输入内容的前后空格，避免 “张三” 和 “张三” 算两个不同值）；
- 解析文本数据（比如按逗号分割 CSV 文件里的内容，按换行符分割多行日志）；
- 数据校验（比如判断用户输入的手机号是否全是数字）。
4. 注意事项（补充）
- 字符串是 “不可变的”（不能直接改某个字符，比如text[0] = "p"报错，得用replace或切片重新生成）；
- 分割符不存在时，返回只含原字符串的列表（比如"abc".split("d")输出["abc"]，不会报错）。
十二、序列：“可按顺序取数据” 的统称
1. 大白话含义
序列就是 “数据按顺序排列的集合”，你可以按索引（位置）取里面的元素，像排队的人一样，能知道 “第 1 个、第 2 个” 是谁。Python 里常见的序列有：字符串、列表、元组。
2. 代码举例（序列共有的操作）
# 1. 列表（序列）
list_seq = [1,2,3]
# 2. 元组（序列）
tuple_seq = (4,5,6)
# 3. 字符串（序列）
str_seq = "789"
# 序列共有的操作：按索引取值、切片、算长度、判断元素是否存在
# （1）按索引取值
print(list_seq[1]) # 2，列表的第2个元素
print(tuple_seq[2]) # 6，元组的第3个元素
print(str_seq[0]) # 7，字符串的第1个字符
# （2）切片（取一段元素）
print(list_seq[1:3]) # [2,3]，列表的第2-3个元素
print(str_seq[1:]) # "89"，字符串的第2个字符到最后
# （3）算长度（len()）
print(len(list_seq)) # 3，列表有3个元素
print(len(str_seq)) # 3，字符串有3个字符
# （4）判断元素是否存在（in / not in）
print(2 in list_seq) # True，列表里有2
print("a" not in str_seq) # True，字符串里没有a
3. 使用场景
- 只要需要 “按顺序访问数据”，就用序列（比如按顺序遍历学生名单、按位置取配置参数）；
- 根据数据是否需要修改选具体序列：要改就用列表，不改就用元组 / 字符串。
4. 注意事项
- 序列的索引都是从 0 开始（第 1 个元素是索引 0，不是 1，新手必记）；
- 不同序列的 “可变性” 不同：列表可变（能改元素），元组和字符串不可变（不能改元素）。
十三、集合：“去重 + 快速判断” 的工具
1. 大白话含义
集合就像 “没有重复元素的篮子”—— 里面的元素不能重复，而且你能快速判断 “某个元素在不在篮子里”，用大括号{}定义（注意和字典区分，集合里是单个元素，不是键值对）。
2. 代码举例
# 1. 定义集合（自动去重）
s1 = {1,2,2,3} # 重复的2会被自动去掉
print(s1) # 输出：{1,2,3}
# 2. 常用操作：添加、删除、判断、集合运算
# （1）添加元素（add()）
s1.add(4)
print(s1) # {1,2,3,4}
# （2）删除元素（remove()，元素不存在会报错；discard()，不报错）
s1.remove(3)
print(s1) # {1,2,4}
s1.discard(5) # 删不存在的5，不报错
# （3）快速判断元素是否存在（比列表快很多）
print(2 in s1) # True，集合里有2
# （4）集合运算（交集、并集、差集）
s2 = {3,4,5}
print(s1 & s2) # 交集：{4}（两个集合都有的元素）
print(s1 | s2) # 并集：{1,2,3,4,5}（两个集合的所有元素，去重）
print(s1 - s2) # 差集：{1,2}（s1有但s2没有的元素）
3. 使用场景
- 去重（比如处理用户输入的重复手机号、统计列表里的唯一元素）；
- 快速判断（比如判断某个用户是否在 “黑名单” 集合里，比列表的in快 10 倍以上）；
- 数据对比（比如找两个列表的共同元素、不同元素）。
4. 注意事项
- 集合里的元素必须是 “不可变的”（比如整数、字符串、元组，列表不能当集合元素，因为列表可变）；
- 集合是 “无序的”（不能按索引取值，比如print(s1[0])会报错，想按顺序看要转成列表list(s1)）。
十四、字典：“键值对” 存数据，按 “名字” 找内容
1. 大白话含义
字典就像 “带标签的收纳盒”—— 每个盒子（值，value）都有一个唯一的标签（键，key），你不用按顺序找，直接通过标签就能快速拿到盒子里的东西，用大括号{}定义，键和值用:隔开，比如{"标签": "内容"}。
2. 代码举例
# 1. 定义字典（键唯一，值可以重复）
student = {
"name": "张三", # 键"name"，值"张三"
"age": 18, # 键"age"，值18
"scores": {"chinese": 85, "math": 92} # 值可以是字典（嵌套）
}
# 2. 常用操作：取值、改值、添加、删除、遍历
# （1）取值：按键取（推荐用get()，键不存在不报错）
print(student["name"]) # 输出：张三
print(student.get("gender", "男")) # 键不存在，返回默认值"男"
# （2）改值：按键改
student["age"] = 19
print(student["age"]) # 输出：19
# （3）添加键值对（键不存在就是添加）
student["address"] = "北京"
print(student) # 多了"address": "北京"
# （4）删除键值对（del / pop()）
del student["scores"] # 按键删
print(student) # 没了"scores"键值对
# （5）遍历字典（常用3种方式）
# 遍历所有键
for key in student.keys():
print(key) # 输出：name、age、address
# 遍历所有值
for value in student.values():
print(value) # 输出：张三、19、北京
# 遍历键值对（最常用）
for key, value in student.items():
print(f"{key}：{value}") # 输出：name：张三...
3. 使用场景
- 存 “关联型数据”（比如用户信息：姓名 - 年龄 - 地址、商品信息：ID - 名称 - 价格）；
- 快速查询（比如根据用户 ID 找用户信息，不用遍历列表，直接按键取）；
- 配置参数（比如项目里的数据库配置：{"host": "localhost", "port": 3306}）。
4. 注意事项
- 键必须是 “不可变的”（比如字符串、数字、元组，列表不能当键）；
- 键是唯一的（重复定义会覆盖，比如{"a":1, "a":2}最终是{"a":2}）；
- 字典在 Python 3.7 + 是 “有序的”（按插入顺序排列），之前的版本无序（想兼容就用collections.OrderedDict）。
十五、函数：把 “重复代码” 打包成 “工具”
1. 大白话含义
函数就像 “家里的榨汁机”—— 你不用每次榨果汁都重新做一个机器，只要把水果（参数）放进去，按开关（调用函数），就能得到果汁（返回值）。在 Python 里，函数是把一段重复用的代码 “打包”，后续用的时候直接叫名字，不用重复写代码。
2. 代码举例（定义 + 调用 + 进阶）
# 1. 定义基础函数（无参数无返回值）
def say_hello():
print("你好，Python！")
# 调用函数
say_hello() # 输出：你好，Python！
# 2. 定义带参数的函数（有输入）
def calculate_sum(a, b): # a、b是参数（输入）
sum_ab = a + b
print(f"{a}+{b}={sum_ab}")
calculate_sum(3, 5) # 传参数3和5，输出：3+5=8
# 3. 定义带返回值的函数（有输出）
def calculate_bmi(weight, height):
bmi = weight / (height ** 2)
return bmi # 返回计算结果（输出）
# 调用函数，接收返回值
my_bmi = calculate_bmi(62.5, 1.75)
print(f"我的BMI是{my_bmi:.2f}") # 输出：我的BMI是20.41
# 4. 进阶：默认参数（参数有默认值，调用时可省略）
def introduce(name, age=18): # age默认18
print(f"我叫{name}，今年{age}岁")
introduce("张三") # 省略age，用默认值：我叫张三，今年18岁
introduce("李四", 20) # 传age，覆盖默认值：我叫李四，今年20岁
3. 使用场景
- 代码重复使用（比如项目里多次算 BMI，写一个函数调用就行，不用重复写计算代码）；
- 拆分复杂逻辑（把大问题拆成多个小函数，比如 “用户登录” 拆成 “验证账号”“验证密码” 两个函数，代码更清晰）；
- 代码复用（把常用功能写成函数，比如 “读取文件”“发送邮件”，其他项目也能直接用）。
4. 注意事项
- 函数定义要在调用之前（比如先写def say_hello()，再写say_hello()，否则报错）；
- 默认参数要放在普通参数后面（比如def introduce(age=18, name)会报错，得是def introduce(name, age=18)）；
- 函数里的 “局部变量” 不能在外面用（比如calculate_sum里的sum_ab，在函数外打印会报错）。
