二、机器学习中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")  # 缩进属于if
    print("执行代码块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 = {"[email protected]", "[email protected]", "[email protected]"}
email = "[email protected]"

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] = 99

print(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] = score
        print(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"])