二、机器学习中Python变量基础

二、Python变量基础

像C语言和Matlab一样，变量名由字母、数字、下划线组成（但不能以数字开头，字母区分大小写）变量名不能与内置的函数同名。

根据变量是否可以充当容器，将变量类型分为基本类型和高级类型。

基本变量类型：字符串、数字。布尔型

高级变量类型：集合、元组。列表、字典。

2.1 常见变量类型

七种变量类型

# 字符串（str）
str_v = "a real man"# 数字（int或float）
num_v = 415411#布尔型（bool）
bool_v = True# 集合（set）
set_v = {1,2,3,1}# 元组（tuple）
tuple_v = (1,2,3)#列表（list）
list_v = [1,2,3]# 字典(dict)
dict_v = {'a':1,'b':2,'c':3}

Python语言的标准输出方法是：print(变量名)

2.2 常用运算符

数字有两种数据类型，分别是整数（int）和浮点数（float）

常见的数字运算符

运算符	含义	输入	输出
+、-、*、/	加、减、乘、除	1*2+3/4	2.75
**	幂	2**4	16
()	修正运算次序	1*（2+3）/4	1.25
//	取整	28//5	5
%	取余	28%5	3

2.3 基于基本变量类型生成

对字符串作比较，使用等于号==与不等号!=；

对数字作比较，使用大于>、大于等于>=、等于==、小于<、小于等于<=。

# 字符串——检查某字符串的值  
str_v = 'cxk'  
print(str_v == 'chicken')  
print(str_v != 'chicken') #False
#True

# 数字——检查某数字是否在某范围  
num_v = 3
print(num_v > 5)
print(num_v == 5)
print(num_v < 5)#False
#False
#True

2.4 基于高级变量类型生成

# 集合——检查某变量是否在该集合中
set_v = {1, 2, 3}
print(2 in set_v)
print(2 not in set_v) 

 

# 元组——检查某变量是否在该元组中  
tuple_v = (1, 2, 3)
print(2 in tuple_v)
print(2 not in tuple_v) 

2.5 同时检查多个条件

and 的规则是，两边全为True则为True，其它情况均为False；

or 的规则是，两边有一个是True则为True，其他情况为False。

2.6 判断语句

bool 值通常作为if判断的条件，if判断的语法规则为

核心语句

if 条件1:# 条件1为 True 时执行的代码
elif 条件2:# 条件1为 False，但条件2为 True 时执行的代码
else:# 所有条件均为 False 时执行的代码

"""1.条件表达式必须返回布尔值（True 或 False）"""
# 比较运算（返回布尔值）
age = 18
if age >= 18:print("成年人")# 逻辑运算（返回布尔值）
x = 5
if x > 0 and x < 10:print("x在0到10之间")"""2.缩进定义代码块：Python 通过缩进（通常4个空格）标识代码归属。"""
if True:print("执行代码块1")  # 缩进属于ifprint("执行代码块2")  # 缩进属于if
print("始终执行")        # 无缩进，不属于if"""3.简单判断"""
num = 10
if num > 0:print("正数")
elif num < 0:print("负数")
else:print("零")# 输出: 正数"""4.多条件组合"""
username = "admin"
password = "123456"if username == "admin" and password == "123456":print("登录成功")
else:print("用户名或密码错误")# 输出: 登录成功"""5.嵌套判断"""
score = 85
if score >= 60:if score >= 90:print("优秀")elif score >= 80:print("良好")else:print("及格")
else:print("不及格")# 输出: 良好"""6.检查数据存在性"""
names = ["Alice", "Bob", "Charlie"]
name = "Bob"if name in names:print(f"{name} 在名单中")
else:print(f"{name} 不在名单中")# 输出: Bob 在名单中# 比较运算：==, !=, >, <, >=, <=
print(3 > 5)  # False# 逻辑运算：and, or, not
print(not (False or True))  # False# 成员检测：in, not in
print("a" in ["a", "b"])  # True# 对象存在性：空对象（如空列表、空字符串）视为 False，非空视为 True
if []:print("非空")  # 不会执行
else:print("空列表")  # 输出: 空列表

输出结果

2.7 基本变量间的转换

字符串、整数、浮点数、布尔型四者之间可以无缝切换。

转换为字符串使用str函数；

转换为整数型数字使用int函数；

转换为浮点型数字使用float函数；

转换为布尔型使用bool函数。

# 定义变量 
str_v = '123' 
int_v = 123 
float_v = 123.0 
bool_v = True
# 转化为字符串
print(str(int_v))
print(str(float_v))
print(str(bool_v))# 转化为整数型变量
print(int(str_v))
print(int(float_v))
print(int(bool_v))# 转化为浮点型变量
print(float(str_v))
print(float(float_v))
print(float(bool_v))# 转化为布尔型变量
print(bool(str_v))
print(bool(int_v))
print(bool(float_v)) 

2.8 高级变量类型（集合、元组、列表和字典）

高级变量类型，主要是集合、元组、列表和字典，它们具有随意容纳任意变量特点

（1）集合

集合是无序的、不可重复的元素的组合。集合内元素存储没有顺序，不支持索引访问，元素不可重复，自动去重；可动态增删元素（但元素本身必须是不可变类型，如数字、字符串、元组）。

集合运算：支持并集（|）、交集（&）、差集（-）等数学运算。

创建方式：使用大括号 {1, 2, 3} 或 set() 函数（空集合必须用 set()）

# 元组拆分法——只要前两个答案 
values = 98, 99, 94, 94, 90, 92 
a, b, *rest = values
print(a,b,rest)

"""(1)数据去重（唯一性）集合自动去除重复元素，适用于快速清理重复数据。"""
# 从列表去重
names = ["Alice", "Bob", "Alice", "Charlie", "Bob"]
unique_names = set(names)
print("去重后的名字:", unique_names)  # 输出: {'Alice', 'Bob', 'Charlie'}# 统计唯一IP访问量
ip_list = ["192.168.1.1", "10.0.0.1", "192.168.1.1", "10.0.0.2"]
unique_ips = set(ip_list)
print("唯一IP数量:", len(unique_ips))  # 输出: 3"""(2)集合运算（并集、交集、差集）集合支持数学运算，适合处理分组数据的关系分析。"""# 定义两组用户的爱好
hobbies_a = {"reading", "music", "travel"}
hobbies_b = {"travel", "sports", "cooking"}# 共同爱好（交集）
common_hobbies = hobbies_a & hobbies_b
print("共同爱好:", common_hobbies)  # 输出: {'travel'}# 所有爱好（并集）
all_hobbies = hobbies_a | hobbies_b
print("所有爱好:", all_hobbies)  # 输出: {'reading', 'music', 'travel', 'sports', 'cooking'}# A有但B没有的爱好（差集）
unique_to_a = hobbies_a - hobbies_b
print("A独有的爱好:", unique_to_a)  # 输出: {'reading', 'music'}"""(3)成员快速检测（高效查找）集合的成员检测时间复杂度为 O(1)，适合高频查询。"""# 黑名单过滤（快速判断是否在集合中）
blacklist = {"spam@example.com", "phishing@bad.com", "malware@virus.org"}
email = "spam@example.com"if email in blacklist:print("拦截垃圾邮件!")  # 输出: 拦截垃圾邮件!
else:print("允许通过")# 白名单验证
valid_users = {"admin", "user1", "guest"}
username = "hacker"
print("用户是否有效:", username in valid_users)  # 输出: False"""(4)动态增删元素（可变性）
集合支持动态添加或删除元素，但元素本身必须是不可变类型。"""# 初始化一个空集合
tags = set()# 添加标签
tags.add("Python")
tags.add("编程")
tags.add("Python")  # 重复添加会被忽略
print("当前标签:", tags)  # 输出: {'Python', '编程'}# 删除标签
tags.discard("编程")  # 安全删除（元素不存在时不报错）
tags.remove("Python")  # 强制删除（元素不存在时报错）
print("删除后标签:", tags)  # 输出: set()"""(5)集合推导式（Set Comprehension）
类似列表推导式，生成集合时自动去重。"""
# 生成1~10中偶数的平方的集合
squares = {x**2 for x in range(1, 11) if x % 2 == 0}
print("偶数的平方:", squares)  # 输出: {64, 4, 36, 16, 100}# 统计句子中不同单词的长度
sentence = "Python is simple but powerful"
word_lengths = {len(word) for word in sentence.split()}
print("单词长度集合:", word_lengths)  # 输出: {2, 4, 6, 8}"""(6)不可变集合（frozenset）
使用 frozenset 创建不可变集合，可作为字典的键。"""
# 创建不可变集合
allowed_operations = frozenset(["read", "execute"])# 作为字典的键
permissions = {allowed_operations: "基础权限",frozenset(["read", "write", "execute"]): "高级权限"
}print(permissions[allowed_operations])  # 输出: 基础权限

输出结果

常应用于数据去重、成员快速检测、数字集合运算等。

（2）元组

元组具有有序性和不可变型。元组内插入顺序存储，可通过索引（如 t[0]）访问；一旦创建，元素不可修改、增删。元组可以包含任意元素类型（如混合数字、字符串、列表等）。若元素均为不可变类型，元组可作为字典的键。

创建方式：

使用圆括号 (1, 'a') 或 tuple() 函数。

应用场景：存储不可变数据（如配置项）、作为字典的键、保证数据不被修改。

案例 1：存储不可变数据（如坐标、配置项）

元组常用于存储不可修改的固定数据，例如坐标点、配置参数等。

# 定义坐标点 (x, y)
point = (3, 5)
print(f"坐标点: {point}")  # 输出: (3, 5)# 定义应用配置项 (host, port, debug_mode)
config = ("localhost", 8080, False)
print(f"服务器配置: {config}")  # 输出: ('localhost', 8080, False)# 尝试修改元组（会报错）
try:point[0] = 10  # 触发 TypeError
except TypeError as e:print(f"错误: {e}")  # 输出: 'tuple' object does not support item assignment

案例 2：作为字典的键（键必须不可变）

元组可以作为字典的键（而列表不行），因为它不可变。

# 定义坐标到颜色的映射
color_map = {(255, 0, 0): "红色",(0, 255, 0): "绿色",(0, 0, 255): "蓝色"
}# 查询颜色
rgb = (255, 0, 0)
print(f"{rgb} 对应的颜色是: {color_map[rgb]}")  # 输出: 红色# 尝试用列表作为键（会报错）
try:bad_key = [1, 2, 3]color_map[bad_key] = "黑色"
except TypeError as e:print(f"错误: {e}")  # 输出: unhashable type: 'list'

输出结果

案例 3：函数返回多个值

元组常用于函数返回多个值，避免使用临时对象。

def calculate_stats(numbers):"""返回总和和平均值"""total = sum(numbers)average = total / len(numbers)return (total, average)  # 返回元组# 调用函数并解包结果
data = [10, 20, 30, 40]
sum_result, avg_result = calculate_stats(data)
print(f"总和: {sum_result}, 平均值: {avg_result}")  # 输出: 总和: 100, 平均值: 25.0

案例 4：保护数据不被修改

当需要传递数据并防止被意外修改时，使用元组替代列表。

# 敏感数据（如权限列表）
read_only_permissions = ("read", "execute")  # 使用元组确保不可变def check_permission(permission):if permission in read_only_permissions:print(f"权限 {permission} 有效")else:print(f"权限 {permission} 无效")check_permission("write")  # 输出: 权限 write 无效
check_permission("read")  # 输出: 权限 read 有效

输出结果

案例 5：结合解包操作

元组支持解包（Unpacking），简化代码逻辑。

# 元组解包
dimensions = (1920, 1080)
width, height = dimensions
print(f"分辨率: {width}x{height}")  # 输出: 分辨率: 1920x1080# 交换变量值
a, b = 5, 10
a, b = b, a  # 通过元组解包交换
print(f"交换后: a={a}, b={b}")  # 输出: 交换后: a=10, b=5

案例 6：命名元组（增强可读性）

使用 collections.namedtuple 创建带字段名的元组（类似轻量级类）。

from collections import namedtuple# 定义命名元组类型 "Person"
Person = namedtuple("Person", ["name", "age", "gender"])# 创建实例
alice = Person("Alice", 25, "Female")
print(alice)          # 输出: Person(name='Alice', age=25, gender='Female')
print(alice.name)     # 输出: Alice
print(alice[1])       # 输出: 25（仍支持索引访问）

输出结果

（3）列表

列表具有有序性和可变性，元素按插入顺序存储，支持索引和切片操作。可动态增删改元素（如append()、pop() 等方法），还提供排序sort()、反转 reverse() 等。

元素类型支持任意类型元素，包括嵌套列表

创建方式：

使用方括号 [1, 2, 3] 或 list() 函数。

应用场景：需要频繁修改的动态数据集合（如日志记录、数据批量处理）。

"""(1)创建列表"""
# a. 全是字符串的列表
names = ["Alice", "Bob", "Charlie", "Diana"]
print(names)  # 输出: ['Alice', 'Bob', 'Charlie', 'Diana']# b. 全是数字的列表
numbers = [1, 3, 5, 7, 9]
print(numbers)  # 输出: [1, 3, 5, 7, 9]# c. 混合类型的“释放自我”列表，允许包含任意数据类型（甚至嵌套列表、字典等）：
mixed = [10, "Python", True, 3.14, ["嵌套列表"], {"key": "value"}]
print(mixed)  # 输出: [10, 'Python', True, 3.14, ['嵌套列表'], {'key': 'value'}]"""（2）访问与修改元素"""
# a. 访问元素（索引从 0 开始）
names = ["Alice", "Bob", "Charlie"]
print(names[0])   # 输出第一个元素: Alice
print(names[-1])  # 输出倒数第一个元素: Charlie
print(names[-2])  # 输出倒数第二个元素: Bob# b. 修改元素
names[1] = "Bill"  # 修改索引1的元素
print(names)  # 输出: ['Alice', 'Bill', 'Charlie']"""（3）切片——访问部分元素"""
# 切片语法：list[start:end:step]（含头不含尾，step 为步长）
# 切片后生成新列表，与原列表独立。
# a. 从第 x 个元素切到第 y 个元素
numbers = [0, 1, 2, 3, 4, 5]
subset = numbers[1:4]  # 索引1到3（元素1, 2, 3）
print(subset)  # 输出: [1, 2, 3]# b. 切除开头或结尾
# 切除前2个元素
print(numbers[2:])   # 输出: [2, 3, 4, 5]# 切除后2个元素
print(numbers[:-2])  # 输出: [0, 1, 2, 3]# c. 每隔 n 个元素采样一次
# 每隔2个元素取一次（步长=2）
print(numbers[::2])  # 输出: [0, 2, 4]# 从索引1开始，每隔1个取到末尾
print(numbers[1::2])  # 输出: [1, 3, 5]# d. 切片与原列表独立
original = [10, 20, 30]
sliced = original[1:]  # 切片得到新列表 [20, 30]
sliced[0] = 99print(original)  # 原列表不变: [10, 20, 30]
print(sliced)    # 切片后的列表: [99, 30]"""（4）列表元素的添加（+ 和 * 操作）"""
# a. + 合并列表（生成新列表）
list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2
print(combined)  # 输出: [1, 2, 3, 4]# b. * 重复列表元素（生成新列表）
repeated = list1 * 3
print(repeated)  # 输出: [1, 2, 1, 2, 1, 2]# c. 注意：+ 和 * 不修改原列表
print(list1)  # 原列表不变: [1, 2]
print(list2)  # 原列表不变: [3, 4]

输出结果

（4）字典

字典具有键值对结构、无序性、高效查找和可变性

存储 {键: 值} 对，键唯一且必须为不可变类型（如字符串、数字、元组），值可为任意类型。Python 3.7+ 后按插入顺序保存，但设计上仍视为“无序”。基于哈希表实现，键的查找速度极快（时间复杂度接近 O(1)）。可动态增删改键值对。

创建方式：

使用大括号 {'name': 'Alice', 'age': 25} 或 dict() 函数。

"""以下是关于 Python字典（Dict） 的案例详解，涵盖创建、修改、添加和删除操作"""
"""（1）创建字典
a. 字典与列表的对比,字典可以理解为“升级版的列表”——列表的索引是固定数字（0,1,2...），
而字典的索引（键）可以自定义为字符串、数字等不可变类型，且键值对结构更灵活。"""
"""b. 创建与列表等效的特殊字典
用数字作为键模拟列表索引："""
# 列表方式
list_data = ["数学", "物理", "化学"]# 字典方式（等效）
dict_data = {0: "数学", 1: "物理", 2: "化学"}print(dict_data[1])  # 输出: 物理（等效于 list_data[1]）"""c. 常规字典（键为字符串）
以学科名称为键，学科实力为值："""
# 键为学科名称（字符串），值为学科实力（任意类型）
subjects = {"数学": 95,          # 值可以是数字"物理": "A+",        # 值可以是字符串"化学": ["实验强", "理论弱"],  # 值可以是列表"计算机": {"排名": 1, "实验室": "国家级"}  # 值可以是字典
}print(subjects["化学"])  # 输出: ['实验强', '理论弱']"""（2）字典元素的修改、添加与删除
以学科名称为键，学科实力为值，演示动态操作：a. 修改元素
直接通过键修改对应的值："""
# 修改数学的学科实力
subjects["数学"] = 98
print(subjects["数学"])  # 输出: 98"""b. 添加新元素
通过新键赋值即可添加新键值对："""
# 添加新学科 "生物"
subjects["生物"] = "B+"
print(subjects["生物"])  # 输出: B+"""c. 删除元素
使用 del 或 pop() 删除键值对："""
# 删除 "化学" 学科
del subjects["化学"]
print(subjects)  # 输出中不再包含 "化学"# 使用 pop() 删除并返回被删值
physics_rank = subjects.pop("物理")
print(physics_rank)  # 输出: A+
print(subjects)      # 输出中不再包含 "物理"

应用场景

存储关联数据（如JSON结构）、快速键值查询、配置映射。

特性	集合（Set）	元组（Tuple）	列表（List）	字典（Dict）
有序性	无序	有序	有序	无序（Python3.7+ 按插入顺序）
可变性	可变（元素不可变）	不可变	可变	可变
元素唯一性	唯一	允许重复	允许重复	键唯一，值可重复
元素类型	不可变元素	任意类型	任意类型	键不可变，值任意
典型操作	集合运算	索引访问	增删改、切片	键值查询与更新
内存效率	较高（去重优化）	较高（不可变）	较低（动态扩展）	中等（哈希表开销）

# ------------------------------
# 功能：管理学生信息、课程和成绩
# 使用四种数据结构：
#   - 列表（动态操作学生信息）
#   - 元组（存储不可变课程信息）
#   - 集合（去重选修课程）
#   - 字典（存储学生成绩，快速查询）
# ------------------------------# 1. 元组（Tuple）: 存储固定课程信息（课程名, 学分）
courses = (("Math", 4),("Python", 3),("Physics", 4),("Chemistry", 3)
)# 2. 列表（List）: 动态管理学生姓名（可增删改）
students = ["Alice", "Bob", "Charlie"]# 3. 集合（Set）: 存储学生选修的课程（自动去重）
selected_courses = {"Math", "Python", "Physics"}# 4. 字典（Dict）: 存储学生成绩 {学生: {课程: 分数}}
scores = {"Alice": {"Math": 90, "Python": 85},"Bob": {"Math": 78, "Physics": 92},"Charlie": {"Python": 88, "Chemistry": 76}
}# ------------------------------
# 功能函数实现
# ------------------------------def add_student(name: str):"""添加学生（列表的增操作）"""students.append(name)print(f"添加学生: {name}")def remove_course(course: str):"""删除选修课程（集合的删操作）"""if course in selected_courses:selected_courses.remove(course)print(f"移除课程: {course}")else:print(f"课程 {course} 不存在")def update_score(student: str, course: str, score: int):"""更新成绩（字典的改操作）"""if student in scores and course in scores[student]:scores[student][course] = scoreprint(f"更新 {student} 的 {course} 成绩为 {score}")else:print("学生或课程不存在")def check_course_credit(course_name: str):"""通过课程名查询学分（元组的查操作）"""for course in courses:if course[0] == course_name:return course[1]return None# ------------------------------
# 演示操作
# ------------------------------if __name__ == "__main__":# 初始状态print("\n----- 初始数据 -----")print("学生名单:", students)print("选修课程:", selected_courses)print("Alice的成绩:", scores["Alice"])# 动态操作数据add_student("David")          # 列表追加remove_course("Physics")      # 集合删除update_score("Bob", "Math", 85)  # 字典修改# 查询操作credit = check_course_credit("Python")print(f"\nPython课程的学分: {credit}")# 最终状态print("\n----- 更新后数据 -----")print("学生名单:", students)print("选修课程:", selected_courses)print("Bob的成绩:", scores["Bob"])