摘要：本文整理了 Python 入门阶段最核心的基础知识：数据类型、逻辑值、字符串、列表与元组、字典，并补充集合、实战案例和速查表。适合零基础学习者快速上手，也适合有基础的同学查漏补缺。
前言
Python 是当下非常流行的编程语言之一，以简洁、易读、上手快著称。
但再简单的语言，基础概念也需要扎实掌握。本文将 Python 入门阶段最常用的数据类型和相关操作整理成一篇复习文章，主要涵盖：
- 📦 数据类型总览
- ✅ 逻辑值与布尔运算
- 📝 字符串操作
- 📋 列表与元组
- 🔢 集合
- 📖 字典
- 🧪 实战小案例
- 🚀 万能速查表
每个知识点都配有 代码示例、解释说明和速查表，方便随时回顾。
适合读者
本文适合：
- 刚开始学习 Python 的零基础同学
- 学过一点 Python，但基础概念不够清晰的同学
- 想快速复习 Python 常用数据类型的同学
- 准备做 Python 入门笔记或面试复习的同学
一、数据类型总览
Python 中一切皆对象，每个对象都有自己的类型。
常用数据类型如下：
| 类型 | 示例 | 可变性 | 典型用途 |
|---|---|---|---|
int | 42 | 不可变 | 整数计算 |
float | 3.14 | 不可变 | 小数计算 |
complex | 3 + 4j | 不可变 | 复数计算 |
bool | True / False | 不可变 | 逻辑判断 |
str | "hello" | 不可变 | 文本处理 |
list | [1, 2, 3] | 可变 | 存储一组有序数据 |
tuple | (1, 2, 3) | 不可变 | 存储固定数据 |
set | {1, 2, 3} | 可变 | 去重与集合运算 |
dict | {"k": "v"} | 可变 | 键值对存储 |
NoneType | None | 不可变 | 表示“空值” |
1.1 可变 vs 不可变
这是 Python 中非常重要的概念。
在 Python 中，变量更像是贴在对象上的“标签”，而不是固定的盒子。
- 不可变类型：修改时通常会创建新对象，例如
int、float、bool、str、tuple - 可变类型：可以在原对象上修改，例如
list、dict、set
示例：
# 不可变类型：修改后会创建新对象
s = "hello"
old_id = id(s)
s = s + " world"
new_id = id(s)
print(old_id == new_id) # False，说明 s 指向了一个新对象# 可变类型：可以在原对象上修改
lst = [1, 2, 3]
old_id = id(lst)
lst.append(4)
new_id = id(lst)
print(old_id == new_id) # True，说明还是同一个列表对象1.2 类型转换
Python 提供了很多常用的类型转换函数。
int("123") # 字符串 → 整数 123
str(123) # 整数 → 字符串 "123"
float("3.14") # 字符串 → 浮点数 3.14
list("abc") # 字符串 → 列表 ['a', 'b', 'c']
tuple([1, 2, 3]) # 列表 → 元组 (1, 2, 3)
set([1, 2, 2, 3]) # 列表 → 集合 {1, 2, 3}
dict([("a", 1)]) # 列表 → 字典 {'a': 1}需要注意的是，并不是所有内容都能转换成功。
int("123") # 正确
int("abc") # 报错：ValueError1.3 类型检查
查看对象类型可以使用 type()，判断对象是否属于某种类型推荐使用 isinstance()。
x = 10
type(x) # <class 'int'>
isinstance(x, int) # True
isinstance(x, (int, float)) # True推荐使用：
isinstance(x, int)而不是直接比较：
type(x) == int因为 isinstance() 更灵活，也能处理继承关系。
1.4 input() 返回的是字符串
初学者经常遇到一个问题：输入的是数字，但程序却不能直接计算。
原因是：input() 得到的内容永远是字符串。
age = input("请输入年龄：")
print(type(age)) # <class 'str'>如果要做数学计算，需要先转换类型：
age = input("请输入年龄：")
age = int(age)
print(age + 1)也可以写成一行：
age = int(input("请输入年龄："))
print(age + 1)1.5 布尔值的陷阱
以下值转换为 bool 时通常是 False：
bool(0) # False 数字零
bool(0.0) # False 浮点数零
bool("") # False 空字符串
bool([]) # False 空列表
bool(()) # False 空元组
bool({}) # False 空字典
bool(set()) # False 空集合
bool(None) # False 空值以下值通常是 True：
bool(-1) # True 非零数字
bool("0") # True 非空字符串
bool("False") # True 非空字符串
bool([0]) # True 非空列表，即使里面是 0口诀：零、空、None 是假的；非零、非空通常是真的。
二、逻辑值：布尔值
布尔值是程序做判断的基础，只有两个值：
True
False注意首字母必须大写：
True # 正确
False # 正确
true # 错误
false # 错误2.1 比较运算符
x = 10
x == 10 # True 等于
x != 5 # True 不等于
x > 5 # True 大于
x < 5 # False 小于
x >= 10 # True 大于等于
x <= 9 # False 小于等于⚠️ 易错点：
=是赋值，==才是比较。
示例：
x = 10 # 把 10 赋值给 x
x == 10 # 判断 x 是否等于 102.2 逻辑运算符
Python 中常用的逻辑运算符有三个：
and
or
notand：并且
and 表示“并且”，要求所有条件都为真，结果才是真。
口诀：
全真才真，一假即假。
True and True # True
True and False # False
False and True # False
False and False # False示例：
age = 20
score = 80
if age >= 18 and score >= 60:
print("通过")or：或者
or 表示“或者”，只要有一个条件为真，结果就是真。
口诀：
一真即真，全假才假。
True or True # True
True or False # True
False or True # True
False or False # False示例：
vip = True
coupon = False
if vip or coupon:
print("可以享受优惠")not：取反
not 表示取反。
not True # False
not False # True示例：
is_login = False
if not is_login:
print("请先登录")2.3 逻辑运算符优先级
逻辑运算符的优先级为：
not > and > or也就是说：
not False and False会先计算：
(not False) and False不确定优先级时，建议直接加括号：
if (age > 18) and (score >= 60):
print("通过")加括号不仅不容易出错，也能让代码更清晰。
2.4 实战：闰年判断
闰年规则：
- 能被 4 整除，并且不能被 100 整除
- 或者能被 400 整除
代码如下：
year = 2024
is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
print(is_leap) # True拆解逻辑：
2024 能被 4 整除吗？ → True
2024 不能被 100 整除吗？ → True
True and True → True
2024 能被 400 整除吗？ → False
True or False → True所以，2024 是闰年。
💡 这里用到了
%取余运算符，2024 % 100的结果是余数24，不是商。
三、字符串：str
字符串是 Python 中处理文本的核心数据类型。
字符串有三个重要特点：
- 用引号包裹
- 有顺序，可以索引和切片
- 不可变
3.1 创建字符串
s1 = 'hello' # 单引号
s2 = "hello" # 双引号
s3 = "I'm OK" # 包含单引号时，可以用双引号
s4 = '他说"你好"' # 包含双引号时，可以用单引号
s5 = '''多行
文本''' # 三引号支持换行
s6 = r"C:newtest" # r 前缀：原始字符串， 不转义单引号和双引号本质上没有区别，主要看哪种写起来更方便。
3.2 转义字符
常见转义字符如下：
| 写法 | 含义 |
|---|---|
n | 换行 |
t | Tab 键 |
\ | 反斜杠 |
' | 单引号 |
" | 双引号 |
示例：
print("hellonworld")输出：
hello
world3.3 索引与切片
字符串就像排队，每个字符都有编号。
H e l l o
0 1 2 3 4
-5 -4 -3 -2 -1示例：
s = "Hello, Python!"
s[0] # 'H'，第一个字符
s[-1] # '!'，最后一个字符
s[0:5] # 'Hello'，索引 0 到 4，不包含 5
s[:5] # 'Hello'，从开头取到索引 4
s[7:] # 'Python!'，从索引 7 取到末尾
s[::-1] # '!nohtyP ,olleH'，反转字符串切片语法：
字符串[开始:结束:步长]切片三规则：
- 包含开始位置
- 不包含结束位置
- 步长默认是
1
3.4 字符串常用操作
拼接
"Hello" + " " + "World" # "Hello World"重复
"哈" * 3 # "哈哈哈"包含判断
"Py" in "Python" # True
"Java" not in "Python" # True长度
len("hello") # 53.5 字符串常用方法
s = " Hello, Python! "大小写
s.upper() # " HELLO, PYTHON! "
s.lower() # " hello, python! "去除两边空白
s.strip() # "Hello, Python!"查找
s.find("Py") # 9，找不到返回 -1
s.count("l") # 2，统计出现次数替换
s.replace("Python", "World") # " Hello, World! "分割与拼接
"apple,banana".split(",") # ['apple', 'banana']
",".join(["apple", "banana"]) # "apple,banana"判断
"123".isdigit() # True，是否全是数字
"abc".isalpha() # True，是否全是字母
"hello.py".endswith(".py") # True，是否以 .py 结尾3.6 字符串格式化：推荐 f-string
在 Python 中，推荐使用 f-string 进行字符串格式化。
name = "张三"
age = 25
print(f"我叫{name}，今年{age}岁")
print(f"明年{age + 1}岁")输出：
我叫张三，今年25岁
明年26岁保留小数位：
pi = 3.14159
print(f"圆周率：{pi:.2f}")输出：
圆周率：3.14四、列表与元组
列表和元组都可以用来存储一组数据。
它们最大的区别是：
- 列表可以修改
- 元组不可以修改
4.1 核心区别
| 对比项 | 列表 list | 元组 tuple |
|---|---|---|
| 符号 | [1, 2, 3] | (1, 2, 3) |
| 可变性 | ✅ 可增删改 | ❌ 不可修改 |
| 速度 | 相对较慢 | 相对较快 |
| 适用场景 | 数据经常变化 | 数据固定不变 |
可以这样理解：
列表 = 购物清单 🛒
可以随时添加、删除、修改。
元组 = 身份证信息 🪪
确定后通常不再修改。4.2 共同点：索引和切片
列表和元组都支持索引、切片、求长度和遍历。
lst = ["苹果", "香蕉", "橘子", "西瓜"]
tup = ("苹果", "香蕉", "橘子", "西瓜")列表操作：
lst[0] # "苹果"
lst[-1] # "西瓜"
lst[1:3] # ["香蕉", "橘子"]
len(lst) # 4元组操作：
tup[0] # "苹果"
tup[-1] # "西瓜"
tup[1:3] # ("香蕉", "橘子")
len(tup) # 4遍历：
for item in lst:
print(item)
for item in tup:
print(item)4.3 列表独有操作
增加元素
lst = [1, 2, 3]
lst.append(4) # [1, 2, 3, 4]
lst.insert(0, 0) # [0, 1, 2, 3, 4]
lst.extend([5, 6]) # [0, 1, 2, 3, 4, 5, 6]说明：
| 方法 | 作用 |
|---|---|
append() | 在末尾追加一个元素 |
insert() | 在指定位置插入元素 |
extend() | 批量追加多个元素 |
删除元素
lst = [1, 2, 3, 4, 5]
lst.remove(3) # 按值删除第一个匹配项
lst.pop() # 删除并返回最后一个元素
lst.pop(0) # 删除并返回指定位置元素
del lst[0] # 删除指定位置元素
lst.clear() # 清空列表示例：
lst = [1, 2, 3, 4, 5]
x = lst.pop()
print(x) # 5
print(lst) # [1, 2, 3, 4]修改元素
lst = [1, 2, 3]
lst[0] = 10
print(lst) # [10, 2, 3]排序
lst = [3, 1, 4, 1, 5]
lst.sort()
print(lst) # [1, 1, 3, 4, 5]降序：
lst.sort(reverse=True)
print(lst) # [5, 4, 3, 1, 1]使用 sorted() 返回新列表，不修改原列表：
lst = [3, 1, 4, 1, 5]
new_lst = sorted(lst)
print(new_lst) # [1, 1, 3, 4, 5]
print(lst) # [3, 1, 4, 1, 5]4.4 列表推导式
列表推导式可以用一行代码生成列表。
传统写法：
squares = []
for x in range(5):
squares.append(x ** 2)
print(squares) # [0, 1, 4, 9, 16]推导式写法：
squares = [x ** 2 for x in range(5)]
print(squares) # [0, 1, 4, 9, 16]带条件筛选：
evens = [x for x in range(10) if x % 2 == 0]
print(evens) # [0, 2, 4, 6, 8]4.5 元组独有操作
元组解包
t = (1, 2, 3)
a, b, c = t
print(a) # 1
print(b) # 2
print(c) # 3交换变量
Python 中可以非常优雅地交换两个变量：
x = 10
y = 20
x, y = y, x
print(x) # 20
print(y) # 10使用 * 收集多余元素
a, *b = (1, 2, 3, 4)
print(a) # 1
print(b) # [2, 3, 4]也可以这样：
a, *b, c = (1, 2, 3, 4, 5)
print(a) # 1
print(b) # [2, 3, 4]
print(c) # 54.6 单元素元组必须加逗号
这是一个非常容易出错的点。
x = (1)
print(type(x)) # <class 'int'>如果想创建单元素元组，必须加逗号：
x = (1,)
print(type(x)) # <class 'tuple'>4.7 元组不可变的一个小陷阱
元组不可变，指的是元组中元素的“引用”不能变。
但如果元组里面放的是可变对象，比如列表，列表内部仍然可以修改。
t = (1, 2, [3, 4])
t[2].append(5)
print(t) # (1, 2, [3, 4, 5])不能这样修改：
t[0] = 100 # 报错：TypeError但可以修改元组内部列表的内容：
t[2].append(5) # 可以4.8 列表和元组互相转换
list((1, 2, 3)) # [1, 2, 3]
tuple([1, 2, 3]) # (1, 2, 3)五、集合：set
集合是一种无序、不重复的数据结构。
它最大的特点是：
自动去重。
5.1 创建集合
s = {1, 2, 3}
print(s) # {1, 2, 3}列表去重：
nums = [1, 2, 2, 3, 3, 3]
unique_nums = set(nums)
print(unique_nums) # {1, 2, 3}注意：空集合不能写 {}。
empty_dict = {} # 空字典
empty_set = set() # 空集合5.2 集合常用操作
s = {1, 2, 3}
s.add(4) # 添加元素
s.remove(2) # 删除元素，元素不存在会报错
s.discard(5) # 删除元素，元素不存在不会报错
print(s)5.3 集合运算
a = {1, 2, 3}
b = {3, 4, 5}并集
a | b # {1, 2, 3, 4, 5}交集
a & b # {3}差集
a - b # {1, 2}对称差集
a ^ b # {1, 2, 4, 5}六、字典：dict
字典是 Python 中非常灵活、非常常用的数据结构。
它通过 键 Key 查找 值 Value。
6.1 基本概念
person = {
"name": "张三",
"age": 25,
"city": "北京"
}可以理解为：
┌──────────┬──────────┐
│ 键 Key │ 值 Value │
├──────────┼──────────┤
│ "name" │ "张三" │
│ "age" │ 25 │
│ "city" │ "北京" │
└──────────┴──────────┘6.2 字典的键有什么要求？
字典的键必须是可哈希对象。
入门阶段可以简单理解为：
- 字符串可以作为键
- 数字可以作为键
- 元组通常可以作为键
- 列表、字典、集合不能作为键
示例：
d = {
"name": "张三",
1: "编号",
(2024, 1): "日期"
}错误示例：
# d[[1, 2]] = "不能用列表当键" # TypeError实际开发中，字典的键最常用的还是字符串。
6.3 创建字典
d1 = {"name": "张三", "age": 25}
d2 = dict(name="张三", age=25)
d3 = {}
d4 = dict.fromkeys(["a", "b"], 0)输出：
print(d4) # {'a': 0, 'b': 0}6.4 取值
d = {"name": "张三", "age": 25}
d["name"] # "张三"
d.get("name") # "张三"
d.get("email") # None
d.get("email", "无") # "无"两种取值方式的区别：
| 写法 | 键不存在时 |
|---|---|
d["key"] | 报错 KeyError |
d.get("key") | 返回 None |
d.get("key", 默认值) | 返回指定默认值 |
判断键是否存在：
"name" in d # True
"email" in d # False6.5 增加和修改
d = {"name": "张三"}
d["age"] = 25
print(d) # {'name': '张三', 'age': 25}如果键已经存在，会覆盖原来的值：
d["age"] = 26
print(d) # {'name': '张三', 'age': 26}批量更新：
d.update({"city": "北京", "age": 27})
print(d) # {'name': '张三', 'age': 27, 'city': '北京'}setdefault()：如果键不存在才设置，存在则不修改。
d = {"name": "张三"}
d.setdefault("name", "李四")
d.setdefault("age", 25)
print(d) # {'name': '张三', 'age': 25}6.6 删除
d = {"name": "张三", "age": 25, "city": "北京"}
del d["city"]
age = d.pop("age")
print(age) # 25
d.clear()
print(d) # {}popitem() 会删除并返回最后一个键值对：
d = {"name": "张三", "age": 25}
item = d.popitem()
print(item)6.7 获取所有键、值、键值对
d = {"name": "张三", "age": 25}
d.keys() # dict_keys(['name', 'age'])
d.values() # dict_values(['张三', 25])
d.items() # dict_items([('name', '张三'), ('age', 25)])6.8 遍历字典
最常用的是遍历键值对：
d = {"name": "张三", "age": 25, "city": "北京"}
for key, value in d.items():
print(f"{key}: {value}")输出：
name: 张三
age: 25
city: 北京只遍历键：
for key in d:
print(key)或者：
for key in d.keys():
print(key)只遍历值：
for value in d.values():
print(value)6.9 字典推导式
squares = {x: x ** 2 for x in range(5)}
print(squares)输出：
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}6.10 嵌套字典
字典的值也可以是另一个字典。
students = {
"001": {"name": "张三", "score": 95},
"002": {"name": "李四", "score": 88},
}逐层取值：
students["001"]["name"] # "张三"
students["002"]["score"] # 886.11 字典排序
d = {"banana": 3, "apple": 1, "cherry": 2}按键排序：
new_d = dict(sorted(d.items()))
print(new_d) # {'apple': 1, 'banana': 3, 'cherry': 2}按值排序：
new_d = dict(sorted(d.items(), key=lambda x: x[1]))
print(new_d) # {'apple': 1, 'cherry': 2, 'banana': 3}按值降序排序：
new_d = dict(sorted(d.items(), key=lambda x: x[1], reverse=True))
print(new_d) # {'banana': 3, 'cherry': 2, 'apple': 1}七、实战小案例
下面用几个简单案例，把前面学过的知识串起来。
案例 1：单词计数器
统计一段文本中每个单词出现的次数。
text = "apple banana apple cherry banana apple"
words = text.split()
count = {}
for word in words:
count[word] = count.get(word, 0) + 1
print(count)输出：
{'apple': 3, 'banana': 2, 'cherry': 1}核心思路：
count.get(word, 0)如果单词存在，取出原来的次数；如果不存在，默认次数为 0。
案例 2：成绩管理系统
计算每个学生的平均分。
students = {
"张三": [90, 85, 92],
"李四": [78, 88, 95],
"王五": [65, 70, 80],
}
for name, scores in students.items():
avg = sum(scores) / len(scores)
print(f"{name}的平均分：{avg:.1f}")输出：
张三的平均分：89.0
李四的平均分：87.0
王五的平均分：71.7案例 3：提取文件名和后缀
filename = "photo_2024.jpg"
name, ext = filename.rsplit(".", 1)
print(f"文件名：{name}")
print(f"后缀：{ext}")输出：
文件名：photo_2024
后缀：jpgrsplit(".", 1) 表示从右边开始，只分割一次。
如果文件名中可能没有后缀，可以这样写：
filename = "photo_2024.jpg"
if "." in filename:
name, ext = filename.rsplit(".", 1)
else:
name, ext = filename, ""
print(f"文件名：{name}")
print(f"后缀：{ext}")案例 4：判断回文
回文是正着读和反着读都一样的字符串。
s = "abcba"
if s == s[::-1]:
print("是回文")
else:
print("不是回文")输出：
是回文中文也可以：
s = "上海自来水来自海上"
if s == s[::-1]:
print("是回文")
else:
print("不是回文")案例 5：找出最高分学生
scores = {
"张三": 90,
"李四": 80,
"王五": 95,
}
top_student = max(scores, key=scores.get)
print(f"最高分学生：{top_student}")
print(f"最高分：{scores[top_student]}")输出：
最高分学生：王五
最高分：95八、练习题
学完之后，可以尝试完成下面几个练习。
练习 1：判断闰年
输入一个年份，判断是否为闰年。
示例：
输入：2024
输出：是闰年提示：
year = int(input("请输入年份："))练习 2：统计单词次数
给定一句英文，统计每个单词出现的次数。
示例：
text = "hello python hello world"期望输出：
{'hello': 2, 'python': 1, 'world': 1}练习 3：筛选偶数
给定列表：
nums = [3, 1, 4, 1, 5, 9, 2, 6]输出其中所有偶数：
[4, 2, 6]练习 4：找出最高分
给定字典：
scores = {
"张三": 90,
"李四": 80,
"王五": 95,
}找出最高分学生和对应分数。
练习 5：判断回文
判断下面字符串是否为回文：
s = "上海自来水来自海上"九、万能速查表
╔════════════════════════════════════════════════════════════╗
║ Python 基础语法速查 ║
╠════════════════════════════════════════════════════════════╣
║ ║
║ 变量 x = 10 ║
║ 输出 print("hello") ║
║ 输入 input("请输入：") ║
║ 类型 type(x) / isinstance(x, int) ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 比较 == != > < >= <= ║
║ 逻辑 and（并且） or（或者） not（取反） ║
║ 布尔 True（真） False（假） ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 运算符 + - * / //（整除） %（取余） **（幂） ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 判断 if ... elif ... else ║
║ 循环 for x in ... / while 条件 ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 字符串 "hello" 不可变 ║
║ 取值 s[0] s[-1] s[1:5] s[::-1] ║
║ 方法 find replace split strip upper lower ║
║ 格式化 f"我叫{name}，今年{age}岁" ║
║ 包含 in / not in ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 列表 [1, 2, 3] 可变 ║
║ 增加 append insert extend ║
║ 删除 remove pop clear del ║
║ 修改 lst[i] = 新值 ║
║ 排序 sort sorted reverse ║
║ 推导式 [x ** 2 for x in range(5)] ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 元组 (1, 2, 3) 不可变 ║
║ 单元素 (1,) ║
║ 解包 a, b, c = (1, 2, 3) ║
║ 交换 a, b = b, a ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 集合 {1, 2, 3} 无序、不重复 ║
║ 空集合 set() ║
║ 添加 s.add(x) ║
║ 删除 s.remove(x) / s.discard(x) ║
║ 运算 | 并集 & 交集 - 差集 ^ 对称差集 ║
║ ║
║ ───────────────────────────────────────── ║
║ ║
║ 字典 {"key": value} ║
║ 取值 d["key"] / d.get("key", 默认值) ║
║ 增改 d["key"] = value / d.update({}) ║
║ 删除 del d["key"] / d.pop("key") ║
║ 遍历 for k, v in d.items() ║
║ 推导式 {k: v for ...} ║
║ ║
╚════════════════════════════════════════════════════════════╝十、总结
本文整理了 Python 入门阶段最常用的数据类型和基础操作。
| 章节 | 一句话总结 |
|---|---|
| 数据类型 | 常见类型包括 int、float、bool、str、list、tuple、set、dict |
| 逻辑值 | True / False、and / or / not，零、空、None 通常为假 |
| 字符串 | 一串文本，不可变，支持索引、切片和常用方法 |
| 列表 | 用 [] 表示，可变，适合存储经常变化的数据 |
| 元组 | 用 () 表示，不可变，适合存储固定数据 |
| 集合 | 用 {} 或 set() 表示，特点是无序、不重复 |
| 字典 | 用键值对存储数据，通过键快速查找值 |
最后用几句话总结：
字符串：处理文本
列表：存一组可变数据
元组：存一组固定数据
集合：去重和集合运算
字典：用键找值
布尔值：控制程序判断编程最好的学习方式就是：
多写、多练、多报错、多总结。
不要怕报错。
每一个错误，都是你真正理解 Python 的机会。
如果这篇文章对你有帮助，欢迎点赞收藏 👍
有问题也可以在评论区留言交流。
微信打赏
Comments | Nothing