Python基础

一、基础语法

1、注释

1.1、单行注释

单行注释以"#"开头，直到行尾都会被注释。

# 这是一行注释

1.2、多行注释

多行注释以"""或’''开始，指导下一个相同符号结束。

"""
这是多行注释
这是多行注释
"""

2、标识符和关键字

2.1、标识符

标识符指变量、函数、类等的名称。

规则：必须以字母和下划线开头，并且只能包含下划线、数字和字母，区分大小写。

2.2、关键字

Python中关键字不可作为标识符。

常见关键字有：if、else、for、while、def、class、import等

# 查看所有 Python 关键字
import keyword
print(keyword.kwlist)

3、输入输出

Python通过==input()==函数获取用户输入，通过==print()==函数显示输出。

注意：input()获取的数据类型是字符串类型

# input()
# 输入数字并进行计算
num1 = input("请输入第一个数字：")
num2 = input("请输入第二个数字：")

# 错误的做法
# result = num1 + num2  # 这会进行字符串拼接，不是数学运算

# 正确的做法
result = int(num1) + int(num2)
print(f"两数之和为：{result}")

# print() 函数的高级用法
print("第一行")
print("第二行")  # 默认会换行

print("同一行", end=" ")
print("输出", end=" ")
print("内容")  # 使用 end 参数控制结尾

print("苹果", "香蕉", "橙子", sep="-")  # 使用 sep 参数控制分隔符

4、变量的定义与使用

在Python中，不需要提前声明变量，可以直接赋值使。

# 单独赋值
x = 1

# 多重赋值
x,y,z = 1,2,3

5、内存管理和垃圾回收机制

在Python中，创建变量时，会在内存中创建一个对象，并将这个变量指向这个对象。而当这个对象没有变量指向时，就会被自动清理。

二、数据类型和运算符

1、数字类型

1.1、整数

整数类型可以表示任意大小的整数。

# 整数类型示例
age = 25
population = 1400000000  # 14亿
small_number = -100
big_number = 999999999999999999999999999999

1.2、浮点数

浮点数指带小数点的数字。

# 浮点数类型示例
temperature = 36.5
pi = 3.14159
scientific_notation = 1.23e-4  # 科学计数法，等于0.000123


# 浮点数的精度问题
result = 0.1 + 0.2
print(f"0.1 + 0.2 = {result}")  # 可能不是你期望的0.3
print(f"结果是否等于0.3：{result == 0.3}")

1.3、复数

# 复数类型示例
complex_num1 = 3 + 4j
complex_num2 = complex(5, 6)  # 另一种创建方式

print(f"复数1：{complex_num1}")
print(f"复数2：{complex_num2}")
print(f"复数1的实部：{complex_num1.real}")
print(f"复数1的虚部：{complex_num1.imag}")

2、字符串类型

字符串类型常用于处理文本信息。可以用单、双、三引号创建。

# 字符串创建的不同方式
name = 'Alice'
message = "Hello, World!"
long_text = """这是一个
多行字符串
可以包含换行"""

print(name)
print(message)
print(long_text)

# 字符串的常用操作
text = "  Python Programming  "

print(f"原始字符串：'{text}'")
print(f"去掉空格：'{text.strip()}'")
print(f"转大写：'{text.upper()}'")
print(f"转小写：'{text.lower()}'")
print(f"替换内容：'{text.replace('Python', 'Java')}'")
print(f"字符串长度：{len(text)}")
print(f"是否包含Python：{'Python' in text}")

# 字符串索引和切片
greeting = "Hello, Python!"

print(f"第一个字符：{greeting[0]}")
print(f"最后一个字符：{greeting[-1]}")
print(f"前5个字符：{greeting[:5]}")
print(f"后7个字符：{greeting[-7:]}")
print(f"中间部分：{greeting[7:13]}")
print(f"反转字符串：{greeting[::-1]}")

3、布尔类型

布尔类型用于表示真或假。即true或false。

# 布尔类型的基本使用
is_student = True
is_working = False
has_license = True

print(f"是学生：{is_student}")
print(f"在工作：{is_working}")
print(f"有驾照：{has_license}")

# 布尔值的产生
age = 20
print(f"是否成年：{age >= 18}")
print(f"是否未成年：{age < 18}")

# 空值的布尔转换
empty_string = ""
empty_list = []
zero = 0

print(f"空字符串的布尔值：{bool(empty_string)}")
print(f"空列表的布尔值：{bool(empty_list)}")
print(f"零的布尔值：{bool(zero)}")

4、数据类型转换

# 数据类型转换示例
# 字符串转数字
str_num = "123"
int_num = int(str_num)
float_num = float(str_num)

print(f"字符串：{str_num} (类型：{type(str_num)})")
print(f"整数：{int_num} (类型：{type(int_num)})")
print(f"浮点数：{float_num} (类型：{type(float_num)})")

# 数字转字符串
number = 456
str_number = str(number)
print(f"数字转字符串：{str_number} (类型：{type(str_number)})")

5、算数运算符

# 基本算术运算
a = 10
b = 3

print(f"加法：{a} + {b} = {a + b}")
print(f"减法：{a} - {b} = {a - b}")
print(f"乘法：{a} * {b} = {a * b}")
print(f"除法：{a} / {b} = {a / b}")
print(f"整除：{a} // {b} = {a // b}")
print(f"取模：{a} % {b} = {a % b}")
print(f"幂运算：{a} ** {b} = {a ** b}")

6、比较运算符

# 比较运算符示例
x = 10
y = 5

print(f"{x} > {y}: {x > y}")
print(f"{x} < {y}: {x < y}")
print(f"{x} >= {y}: {x >= y}")
print(f"{x} <= {y}: {x <= y}")
print(f"{x} == {y}: {x == y}")
print(f"{x} != {y}: {x != y}")

# 字符串比较
name1 = "Alice"
name2 = "Bob"
print(f"字符串比较：{name1} < {name2} = {name1 < name2}")  # 按字典序比较

7、逻辑运算符

# 逻辑运算符示例
age = 25
has_job = True
has_car = False

# and运算符：所有条件都为True时结果才为True
can_rent_car = age >= 21 and has_job
print(f"可以租车：{can_rent_car}")

# or运算符：任意一个条件为True时结果就为True
can_travel = has_car or age >= 18
print(f"可以旅行：{can_travel}")

# not运算符：取反
is_minor = not (age >= 18)
print(f"是未成年人：{is_minor}")

# 复杂逻辑判断
username = "admin"
password = "123456"
is_admin = username == "admin" and password == "123456"
print(f"是管理员：{is_admin}")

8、赋值运算符

# 基本赋值和复合赋值
count = 10
print(f"初始值：{count}")

count += 5  # 等同于 count = count + 5
print(f"加5后：{count}")

count -= 3  # 等同于 count = count - 3
print(f"减3后：{count}")

count *= 2  # 等同于 count = count * 2
print(f"乘2后：{count}")

count //= 4  # 等同于 count = count // 4
print(f"整除4后：{count}")

9、位运算符

# 位运算符示例
a = 12  # 二进制：1100
b = 5   # 二进制：0101

print(f"a = {a} (二进制：{bin(a)})")
print(f"b = {b} (二进制：{bin(b)})")
print(f"a & b = {a & b} (按位与)")
print(f"a | b = {a | b} (按位或)")
print(f"a ^ b = {a ^ b} (按位异或)")
print(f"~a = {~a} (按位取反)")
print(f"a << 1 = {a << 1} (左移1位)")
print(f"a >> 1 = {a >> 1} (右移1位)")

10、成员运算符和身份运算符

成员运算符用于判断某个元素是否在某个序列中。
身份运算符用于判断两个对象是否是引用同一个对象。

# 成员运算符
fruits = ["apple", "banana", "orange"]
print(f"apple在列表中：{'apple' in fruits}")
print(f"grape不在列表中：{'grape' not in fruits}")

# 字符串中的成员运算
text = "Hello, Python!"
print(f"Python在字符串中：{'Python' in text}")

# 身份运算符
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"list1 is list2: {list1 is list2}")  # False，不同对象
print(f"list1 is list3: {list1 is list3}")  # True，同一对象
print(f"list1 == list2: {list1 == list2}")  # True，内容相同

# 小整数对象的特殊情况
x = 100
y = 100
print(f"x is y: {x is y}")  # True，小整数有缓存

三、字符串详解

1、索引与切片

索引和切片用于访问字符串中的字符。索引从0开始，负数表示从字符串末尾开始数。切片用于获取字符串的子串。

# 算法导航的题目编号分析
problem_code = "ALG001_ARRAY_EASY"

# 索引操作
print(f"第一个字符: {problem_code[0]}")        # 输出: A
print(f"最后一个字符: {problem_code[-1]}")      # 输出: Y
print(f"第7个字符: {problem_code[6]}")          # 输出: _

# 切片操作
problem_id = problem_code[0:6]              # ALG001
problem_type = problem_code[7:12]           # ARRAY
problem_level = problem_code[13:]           # EASY

print(f"题目ID: {problem_id}")
print(f"题目类型: {problem_type}")
print(f"难度等级: {problem_level}")

# 文件名处理
filename = "video_2024_01_15_final.mp4"

# 使用步长提取信息
year = filename[6:10]                       # 2024
month = filename[11:13]                     # 01
day = filename[14:16]                       # 15

# 反向切片
reversed_name = filename[::-1]              # 反转整个文件名
extension = filename[-4:]                   # .mp4

print(f"年份: {year}")
print(f"月份: {month}")
print(f"日期: {day}")
print(f"反转文件名: {reversed_name}")
print(f"文件扩展名: {extension}")

2、拼接与重复

拼接用于将多个字符串连接成一个新的字符串。重复用于将字符串重复指定次数。

# 编程导航用户信息拼接
username = "程序员"
platform = "开发"
role = "应用"

# 使用 + 运算符拼接
user_info = username + " 正在 " + platform + " Hello World " + role
print(user_info)

# 使用 join() 方法拼接
info_parts = [username, "是", platform, "的", role]
user_info_joined = " ".join(info_parts)
print(user_info_joined)

# 字符串重复
separator = "=" * 50
print(separator)
print("公告".center(50))
print(separator)

3、常用方法

# 用户输入处理
user_input = "  Hello Algorithm Navigation!  "

# 大小写转换
print(f"转大写: {user_input.upper()}")
print(f"转小写: {user_input.lower()}")
print(f"首字母大写: {user_input.capitalize()}")
print(f"标题格式: {user_input.title()}")

# 去除空白字符
print(f"去除两端空白: '{user_input.strip()}'")
print(f"去除左侧空白: '{user_input.lstrip()}'")
print(f"去除右侧空白: '{user_input.rstrip()}'")

# 字符串查找和替换
content = "Python教程，Java教程，JavaScript教程"
print(f"查找'Python': {content.find('Python')}")
print(f"替换教程: {content.replace('教程', '课程')}")
print(f"统计'教程'出现次数: {content.count('教程')}")

4、字符串的格式化

1、%格式化

# 剪切助手的处理进度报告
video_name = "教学视频.mp4"
progress = 75.5
total_size = 1024

# % 格式化
progress_msg = "正在处理 %s，进度：%.1f%%，文件大小：%d MB" % (video_name, progress, total_size)
print(progress_msg)

# 用户统计
user_count = 50000
active_rate = 0.85
stats_msg = "用户总数：%d，活跃率：%.2f%%" % (user_count, active_rate * 100)
print(stats_msg)

3、format()

# 老鱼简历的信息展示
name = "程序员"
age = 27
skills = ["Python", "Java", "JavaScript"]
experience = 5

# 位置参数
info1 = "姓名：{}，年龄：{}，经验：{}年".format(name, age, experience)
print(info1)

# 关键字参数
info2 = "姓名：{name}，年龄：{age}，经验：{exp}年".format(name=name, age=age, exp=experience)
print(info2)

# 数字格式化
salary = 25000.5
formatted_salary = "期望薪资：{:.2f} 元".format(salary)
print(formatted_salary)

# 成绩单格式化
score = 0.856
percentage = "{:.2%}".format(score)
print(f"面试通过率：{percentage}")

4、f-string

# 信息展示
problem_id = "ALG001"
problem_title = "两数之和"
difficulty = "简单"
solved_count = 1250
total_count = 5000

# f-string 基本用法
problem_info = f"题目 {problem_id}：{problem_title}（难度：{difficulty}）"
print(problem_info)

# 表达式计算
solve_rate = solved_count / total_count
progress_info = f"解决进度：{solved_count}/{total_count} ({solve_rate:.1%})"
print(progress_info)

# 格式化数字
large_number = 1234567
formatted_number = f"用户总数：{large_number:,}"
print(formatted_number)

# 对齐和填充
header = f"{'题目ID':<10} {'标题':<20} {'难度':<10} {'通过率':<10}"
print(header)
print("-" * 60)
print(f"{problem_id:<10} {problem_title:<20} {difficulty:<10} {solve_rate:<10.1%}")

5、正则表达式

import re

# 的用户数据清洗
def clean_user_data():
    # 邮箱验证
    emails = ["123@yuyuanweb.com", "invalid-email", "user@domain.cn"]
    email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

    print("=== 邮箱验证 ===")
    for email in emails:
        if re.match(email_pattern, email):
            print(f"✓ {email} 格式正确")
        else:
            print(f"✗ {email} 格式错误")

    # 手机号提取
    text = "联系程序员：手机 13800138000，微信同号。备用联系方式：15900159000"
    phone_pattern = r'1[3-9]\d{9}'
    phones = re.findall(phone_pattern, text)
    print(f"\n提取到的手机号：{phones}")

    # 密码强度检查
    passwords = ["123456", "abc123", "MyPassword123!", "weakpwd"]
    # 至少8位，包含大小写字母、数字和特殊字符
    strong_pattern = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$'

    print("\n=== 密码强度检查 ===")
    for pwd in passwords:
        if re.match(strong_pattern, pwd):
            print(f"✓ {pwd} 强度足够")
        else:
            print(f"✗ {pwd} 强度不足")

clean_user_data()

四、列表与元组

1、列表的创建于基本操作

列表可以存储任意类型的数据，可以动态的添加、删除、修改元素。

特性：有序、可重复

# 1、创建
popular_courses = ["Python 基础", "数据结构与算法", "Web 开发", "机器学习", "项目实战"]
hh_skills = ["Python", "Java", "JavaScript", "MySQL", "Redis"]
# 混合类型列表
mixed_data = ["程序员", 2024, 3.14, True, None]

# 2、修改
study_plan = ["数组", "链表", "栈", "队列", "树"]

# 修改
study_plan[2] = "栈和队列"
print(f"更新后的计划: {study_plan}")

# 修改多个元素
study_plan[3:5] = ["二叉树", "平衡树", "图论"]
print(f"扩展后的计划: {study_plan}")

2、列表的索引与切片

Python 使用从0开始的索引系统，支持负数索引从尾开始访问元素。

支持步长参数，可以以特定的间隔提取元素。

# 用户等级
user_levels = ["新手", "初级", "中级", "高级", "专家"]

# 正向索引
print(f"第一个等级: {user_levels[0]}")    # 输出: 新手
print(f"第三个等级: {user_levels[2]}")    # 输出: 中级

# 负向索引
print(f"最高等级: {user_levels[-1]}")     # 输出: 专家
print(f"倒数第二个等级: {user_levels[-2]}")  # 输出: 高级

# 切片操作
print(f"前三个等级: {user_levels[0:3]}")   # 输出: ['新手', '初级', '中级']
print(f"从中级开始: {user_levels[2:]}")    # 输出: ['中级', '高级', '专家']
print(f"最后两个等级: {user_levels[-2:]}")  # 输出: ['高级', '专家']

# 编号
question_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 使用步长
print(f"奇数题目: {question_numbers[::2]}")      # 输出: [1, 3, 5, 7, 9]
print(f"偶数题目: {question_numbers[1::2]}")     # 输出: [2, 4, 6, 8, 10]
print(f"逆序排列: {question_numbers[::-1]}")     # 输出: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 复杂切片
print(f"每隔2个取一个: {question_numbers[1:9:2]}")  # 输出: [2, 4, 6, 8]

3、列表的常用方法

# 1、添加
# 剪切助手的待处理任务列表
tasks = ["视频转码", "音频提取"]

# append() 在末尾添加单个元素
tasks.append("添加字幕")
print(f"添加任务后: {tasks}")

# insert() 在指定位置插入元素
tasks.insert(1, "质量检查")
print(f"插入任务后: {tasks}")

# extend() 添加多个元素
new_tasks = ["生成缩略图", "上传到服务器"]
tasks.extend(new_tasks)
print(f"扩展任务后: {tasks}")

# 使用 + 运算符连接列表
urgent_tasks = ["紧急修复", "客户支持"]
all_tasks = tasks + urgent_tasks
print(f"所有任务: {all_tasks}")

# 2、删除
# 题目标签
tags = ["数组", "链表", "栈", "队列", "数组"]  # 注意有重复

# remove() 删除第一个匹配的元素
tags.remove("数组")  # 只删除第一个"数组"
print(f"删除后: {tags}")

# pop() 删除并返回指定位置的元素
removed_tag = tags.pop(1)  # 删除索引为1的元素
print(f"删除的标签: {removed_tag}")
print(f"删除后的标签: {tags}")

# del 关键字删除元素或切片
del tags[0]  # 删除第一个元素
print(f"删除第一个元素后: {tags}")

# clear() 清空整个列表
backup_tags = tags.copy()  # 先备份
tags.clear()
print(f"清空后: {tags}")
print(f"备份: {backup_tags}")

# 3、查找和统计
# 用户的学习时长记录（分钟）
study_minutes = [45, 60, 30, 60, 90, 45, 120]

# 查找元素
print(f"60分钟学习的位置: {study_minutes.index(60)}")     # 输出: 1
print(f"45分钟学习的次数: {study_minutes.count(45)}")    # 输出: 2

# 排序操作
study_minutes_copy = study_minutes.copy()
study_minutes_copy.sort()  # 原地排序
print(f"升序排序: {study_minutes_copy}")

study_minutes_copy.sort(reverse=True)  # 降序排序
print(f"降序排序: {study_minutes_copy}")

# 使用 sorted() 函数（不修改原列表）
sorted_minutes = sorted(study_minutes)
print(f"原列表: {study_minutes}")
print(f"排序后的新列表: {sorted_minutes}")

4、列表推导式

列表推导式是Python的一个强大特性，它允许你用简洁的语法创建列表。

基本语法：[ expression for item in iterable ]。

# 筛选高分
source = [90,80,20,98,92,10,49,93];
height_source = [ item for item in source if item >= 90 ]

# 嵌套循环
video_batches = [
    ["video1.mp4", "video2.avi"],
    ["video3.mov", "video4.mkv"],
    ["video5.wmv"]
]

video = [video.split('.')[-1] for batch in video_batches for video in batch if video.endswith('.mkv')]

5、元组的创建于基本操作

元组一旦创建不可改变。

支持索引和切片操作。

# 创建单元素元组（注意逗号不能省略）
single_element = ("Python",)  # 或者 "Python",
print(f"单元素元组: {single_element}")
print(f"类型: {type(single_element)}")

# 不用括号也可以创建元组
coordinates = 10, 20
print(f"坐标: {coordinates}")
print(f"类型: {type(coordinates)}")

# 空元组
empty_tuple = ()
print(f"空元组: {empty_tuple}")

6、序列通用操作

# 课程信息
course_list = ["Python", "Java", "JavaScript", "Go", "Rust"]
course_tuple = ("Python", "Java", "JavaScript", "Go", "Rust")

# 长度操作
print(f"列表长度: {len(course_list)}")
print(f"元组长度: {len(course_tuple)}")

# 成员检测
print(f"'Python' 在列表中: {'Python' in course_list}")
print(f"'C++' 在元组中: {'C++' in course_tuple}")

# 最大最小值
numbers_list = [85, 92, 78, 95, 88]
numbers_tuple = (85, 92, 78, 95, 88)

print(f"列表最大值: {max(numbers_list)}")
print(f"元组最小值: {min(numbers_tuple)}")
print(f"列表总和: {sum(numbers_list)}")

# 剪切助手的版本比较
version_a = (1, 2, 3)
version_b = (1, 2, 4)
version_c = (1, 3, 0)

print(f"版本A < 版本B: {version_a < version_b}")  # True
print(f"版本B < 版本C: {version_b < version_c}")  # True

# 列表比较
scores_a = [85, 90, 78]
scores_b = [85, 90, 80]
print(f"分数A < 分数B: {scores_a < scores_b}")  # True

# 字符串序列比较
names_a = ["Alice", "Bob"]
names_b = ["Alice", "Charlie"]
print(f"名单A < 名单B: {names_a < names_b}")  # True

# 3x4矩阵
rows, cols = 3, 4

# 错误的初始化方式
wrong_matrix = [[0] * cols] * rows  # 这会创建相同引用的行

# 正确的初始化方式
correct_matrix = [[0 for _ in range(cols)] for _ in range(rows)]

# 或者使用这种方式
score_matrix = [
    [0, 0, 0, 0],
    [0, 0, 0, 0],
    [0, 0, 0, 0]
]

# 填充一些数据
score_matrix[0] = [85, 90, 78, 92]
score_matrix[1] = [88, 85, 95, 87]
score_matrix[2] = [90, 92, 88, 94]

print("矩阵:")
for i, row in enumerate(score_matrix):
    print(f"用户{i+1}: {row}")

五、字典与集合

1、字典的创建与基本操作

字典是Python中最灵活的数据结构之一,以键值对形式存在,查询高效

# 大括号创建
interview_question = {
    "id": "Q001",
    "title": "Python 中的装饰器原理",
    "difficulty": "中等",
    "tags": ["Python", "装饰器", "高级特性"],
    "solved_count": 1245
}

# dictc创建一个字典
algorithm_stats = dict([
    ("数组", 156),
    ("链表", 89),
    ("二叉树", 124),
    ("图论", 67)
])

# 项目配置
project_config = {
    "project_name": "项目",
    "video_format": "mp4",
    "resolution": "1080p",
    "fps": 30
}

# 访问值
print(f"项目名称: {project_config['project_name']}")
print(f"视频格式: {project_config['video_format']}")

# 修改值
project_config["resolution"] = "4K"
project_config["fps"] = 60

# 添加新键值对
project_config["duration"] = 120  # 视频时长（秒）
project_config["audio_quality"] = "高品质"

# 删除键值对
del project_config["fps"]

print(project_config)

2、字典的常用方法

get(key)：根据key获取值

keys()：获取所有键

values()：获取所有值

items()：获取键值对

update(字典)：合并字典

setdefault(key,value)：添加键值对

# 编程导航课程信息
course_info = {
    "course_name": "Python",
    "instructor": "程序员",
    "duration": 120,
    "students": 5680
}

# 安全获取值
instructor = course_info.get("instructor")
price = course_info.get("price", "免费")  # 如果没有价格信息，默认为免费
category = course_info.get("category")

print(f"讲师: {instructor}")
print(f"价格: {price}")
print(f"分类: {category}")  # 输出: None

# 检查键是否存在
if "students" in course_info:
    print(f"学生数量: {course_info['students']}")

# 获取键列表
for key in course_info.keys():
    print(f"• {key}")

# 获取值列表
for value in course_info.values():
    print(f"• {value}")

# 获取键值对
for key,value in course_info.items():
    print(f"• {key}:{value}")

3、字典推导式

字典推导式是创建字典的一种简洁而强大的方式，它允许你用简洁的语法创建字典。

基本语法：{ key: value for item in iterable }。

# 面试鸭题目统计
interview_data = [
    {"category": "Python", "difficulty": "简单", "count": 45},
    {"category": "Python", "difficulty": "中等", "count": 32},
    {"category": "Java", "difficulty": "简单", "count": 38},
    {"category": "Java", "difficulty": "困难", "count": 15},
    {"category": "算法", "difficulty": "中等", "count": 67}
]

# 按分类统计题目总数
category_totals = {}
for item in interview_data:
    category = item["category"]
    count = item["count"]
    category_totals[category] = category_totals.get(category, 0) + count

print("各分类题目统计:")
for category, total in category_totals.items():
    print(f"{category}: {total}题")

# 使用字典推导式创建难度标签
difficulty_tags = {
    f"{item['category']}-{item['difficulty']}": f"【{item['difficulty']}】{item['category']}类题目"
    for item in interview_data
}

print("\n题目标签:")
for tag, desc in difficulty_tags.items():
    print(f"{tag}: {desc}")

4、集合的创建与操作

集合是无序且不重复的元素集合。

特点：自动去重、快速成员检测

# 技术栈
popular_technologies = {"Python", "Java", "JavaScript", "Go", "Python"}  # 重复的Python会被去除
print(f"热门技术栈: {popular_technologies}")

# 从列表创建集合
programming_languages = ["Python", "Java", "C++", "Python", "JavaScript", "Java"]
unique_languages = set(programming_languages)
print(f"去重后的语言: {unique_languages}")

# 剪切助手支持的输入格式
input_formats = set(["mp4", "avi", "mov", "mkv", "flv"])
print(f"支持的输入格式: {input_formats}")

# 创建空集合
empty_set = set()  # 注意：{} 创建的是空字典，不是空集合
print(f"空集合: {empty_set}")

# 数据结构
user_skills = {"数组", "链表", "栈"}

# 添加新技能
user_skills.add("队列")
user_skills.add("二叉树")
print(f"学习新技能后: {user_skills}")

# 添加多个技能
advanced_skills = {"红黑树", "B树", "跳跃表"}
user_skills.update(advanced_skills)
print(f"进阶学习后: {user_skills}")

# 删除技能
user_skills.remove("跳跃表")  # 如果元素不存在会抛出异常
user_skills.discard("哈希表")  # 如果元素不存在不会抛出异常

# 检查技能是否掌握
if "二叉树" in user_skills:
    print("✅ 已掌握二叉树")
else:
    print("❌ 尚未掌握二叉树")

print(f"最终技能集合: {user_skills}")

5.集合的数学运算

交集：两个集合共有的元素

并集：两个集合全部的元素

差集：一个集合有另一个集合没有的元素

对称差集：只在其中一个集合的元素

# 技能匹配
frontend_skills = {"HTML", "CSS", "JavaScript", "React", "Vue", "TypeScript"}
backend_skills = {"Python", "Java", "JavaScript", "MySQL", "Redis", "Docker"}

# 找出前后端共同需要的技能
common_skills = frontend_skills & backend_skills
print(f"前后端共同技能: {common_skills}")

# 也可以使用 intersection() 方法
common_skills_2 = frontend_skills.intersection(backend_skills)
print(f"使用方法获取: {common_skills_2}")

# 全栈开发者应该掌握的技能交集
fullstack_essential = frontend_skills & backend_skills
if fullstack_essential:
    print(f"全栈开发者必备技能: {', '.join(fullstack_essential)}")

# 技能的并集
all_course_skills = frontend_skills | backend_skills
print(f"涵盖的技能数量: {len(all_course_skills)}")
print(f"技能列表: {sorted(all_course_skills)}")

# 计算技能覆盖率
total_market_skills = {"Python", "Java", "JavaScript", "Go", "C++", "Django", "Spring", "React", "Vue", "MySQL", "Redis", "Docker", "Kubernetes"}
coverage_rate = len(all_course_skills & total_market_skills) / len(total_market_skills) * 100
print(f"市场技能覆盖率: {coverage_rate:.1f}%")

# 差集
# 还需要学习
need_to_learn = frontend_skills - backend_skills
print(f"推荐学习: {need_to_learn}")

# 额外掌握的技能
extra_skills = frontend_skills - backend_skills
if extra_skills:
    print(f"额外掌握的技能: {extra_skills}")
else:
    print("学习内容完全符合推荐路径")

# 学习进度计算
progress = len(frontend_skills & backend_skills) / len(backend_skills) * 100
print(f"学习进度: {progress:.1f}%")

#对称差集
# 找出技能的差异
format_differences = frontend_skills ^ backend_skills
print(f"技能差异: {format_differences}")

# 分别找出独有的技能
input_only = frontend_skills - backend_skills
output_only = backend_skills - frontend_skills

print(f" {input_only}")
print(f" {output_only}")

# 都有的技能
universal_formats = frontend_skills & backend_skills
print(f"都有的技能: {universal_formats}")

6、集合推导式

类似列表推导式，但是集合推导式结果自动去重

article_titles = [
    "Python数据结构详解",
    "Java算法实战指南",
    "JavaScript前端开发",
    "Python爬虫技术",
    "数据结构与算法",
    "Java设计模式",
    "Python机器学习"
]

# 提取编程语言
programming_languages = {
    word for title in article_titles
    for word in title.split()
    if word in ["Python", "Java", "JavaScript", "C++", "Go"]
}
print(f"涉及的编程语言: {programming_languages}")

# 提取技术关键词（长度大于3的词）
tech_keywords = {
    word for title in article_titles
    for word in title.split()
    if len(word) > 3 and word not in ["详解", "指南", "技术"]
}
print(f"技术关键词: {tech_keywords}")

7、可变类型和不可变类型

不可变类型包括数字、字符串、元组和冻结集合：

# 剪切助手的配置信息（不可变）
DEFAULT_CONFIG = {
    "max_file_size": 1024 * 1024 * 100,  # 100MB
    "supported_formats": ("mp4", "avi", "mov", "mkv"),  # 元组不可变
    "quality_levels": frozenset(["低", "中", "高", "超高"])  # 冻结集合不可变
}

# 尝试修改元组会报错
# DEFAULT_CONFIG["supported_formats"][0] = "webm"  # TypeError

# 字符串不可变性演示
project_name = "编程导航"
original_id = id(project_name)
project_name += "平台"  # 这实际上创建了新的字符串对象
print(f"原始ID: {original_id}")
print(f"修改后ID: {id(project_name)}")
print(f"是同一个对象: {original_id == id(project_name)}")  # False

可变类型包括列表、字典、集合：

# 用户数据（可变）
user_profile = {
    "username": "程序员",
    "skills": ["Python", "Java"],  # 列表可变
    "completed_questions": {1, 2, 3},  # 集合可变
    "preferences": {"theme": "dark"}  # 字典可变
}

original_id = id(user_profile)

# 修改可变对象
user_profile["skills"].append("JavaScript")  # 原地修改列表
user_profile["completed_questions"].add(4)  # 原地修改集合
user_profile["preferences"]["language"] = "中文"  # 原地修改字典

print(f"修改后ID: {id(user_profile)}")
print(f"是同一个对象: {original_id == id(user_profile)}")  # True
print(f"用户资料: {user_profile}")

六、流程控制

1、条件语句

# 文件大小检查
file_size = 1024 * 1024 * 10  # 10MB

# 传统写法
if file_size > 1024 * 1024 * 5:
    status = "大文件"
else:
    status = "普通文件"

# 使用条件表达式
status = "大文件" if file_size > 1024 * 1024 * 5 else "普通文件"
print(f"文件状态：{status}")

2.循环语句

# 课程列表展示
courses = ["Python 基础", "数据结构", "算法设计", "Web 开发", "机器学习"]

for course in courses:
    print(f"📚 {course}")

for index, task in enumerate(courses, 1):
    print(f"{index}. {task}")


#文件处理队列
file_queue = ["video1.mp4", "video2.avi", "video3.mov", "video4.mkv"]
processed_files = []

print("=== 处理队列 ===")
while file_queue:
    current_file = file_queue.pop(0)
    print(f"正在处理：{current_file}")
    processed_files.append(current_file)

    # 模拟处理过程
    if len(processed_files) >= 3:
        print("批量处理完成，暂停处理")
        break

print(f"已处理文件：{processed_files}")
print(f"待处理文件：{file_queue}")

3、循环控制语句

循环控制语句让我们能够更精确地控制循环的执行流程。 break 用于提前
终止循环， continue 用于跳过当前迭代， 而 pass 则作为占位符使用。

4、range()函数详解

# 基本用法
# 批量文件处理
print("=== 批量处理演示 ===")

# range(stop) - 从0开始到stop-1
print("处理前5个文件:")
for i in range(5):
    print(f"  处理文件 {i + 1}: video_{i + 1}.mp4")

# range(start, stop) - 从start开始到stop-1
print("\n处理文件3到文件7:")
for i in range(3, 8):
    print(f"  处理文件 {i}: video_{i}.mp4")

# range(start, stop, step) - 指定步长
print("\n每隔2个文件处理一次:")
for i in range(1, 11, 2):
    print(f"  处理文件 {i}: video_{i}.mp4")



# 倒叙和负步长的使用
# 版本回退功能
resume_versions = [
    "v1.0 - 基础版本",
    "v1.1 - 添加项目经验",
    "v1.2 - 优化布局",
    "v1.3 - 添加技能标签",
    "v1.4 - 最新版本"
]

print("=== 版本历史 ===")
print("正序显示:")
for i in range(len(resume_versions)):
    print(f"  {resume_versions[i]}")

print("\n倒序显示:")
for i in range(len(resume_versions) - 1, -1, -1):
    print(f"  {resume_versions[i]}")

# 使用负步长更简洁的写法
print("\n最近3个版本:")
for i in range(len(resume_versions) - 1, len(resume_versions) - 4, -1):
    if i >= 0:
        print(f"  {resume_versions[i]}")

5、enumerate()和zip()函数

enumerate()在遍历序列时同时获取索引和值

interview_topics = [
    "Python基础语法",
    "数据结构与算法",
    "数据库设计",
    "系统架构",
    "项目经验"
]

print("\n=== 题目清单 ===")
for index, topic in enumerate(interview_topics):
    question_id = f"Q{index + 1:03d}"  # 生成Q001, Q002格式
    print(f"{question_id}: {topic}")

zip()可以同时遍历多个序列

# 课程评分统计
course_names = ["Python基础", "数据结构", "算法设计", "Web开发", "机器学习"]
course_ratings = [4.8, 4.6, 4.7, 4.5, 4.9]
course_students = [1250, 980, 760, 1100, 650]

print("=== 编程导航课程统计 ===")
for name, rating, students in zip(course_names, course_ratings, course_students):
    print(f"{name:<12} 评分: {rating}/5.0  学员: {students}人")

同时使用处理复杂数据

# 任务进度跟踪
task_names = ["视频转码", "音频提取", "字幕生成", "封面制作"]
task_progress = [85, 60, 30, 10]
task_status = ["进行中", "进行中", "排队中", "未开始"]

print("=== 任务进度 ===")
for index, (name, progress, status) in enumerate(zip(task_names, task_progress, task_status)):
    task_id = f"T{index + 1:02d}"
    progress_bar = "█" * (progress // 10) + "░" * (10 - progress // 10)
    print(f"{task_id} {name:<12} [{progress_bar}] {progress}% - {status}")