第一章 - 基础知识

运算符的区分

除法运算符

• **/ (真除法)：**结果将是浮点数。
• // (整除)： 表示整除运算，向下取整。

乘法运算符 (*)

* 运算符具有多重含义：

• 数值运算： 用于数值乘法。

• 序列重复： 当作用于列表、字符串、元组等类型变量与整数进行运算时，表示对内容进行重复，并返回重复后的新对象。

1
2

'a' * 10 # 字符串重复
# 输出：'aaaaaaaaaa'

取余运算符 (%)

% 运算符用于对整数和浮点数计算余数。此外，它也用于字符串格式化。

关系运算符的连续使用

在 Python 中，关系运算符可以连续使用。例如，表达式 3 < 4 < 5 > 2 的值为 True。需要注意的是，Python 3.x 不支持 “<>” 运算符表示不等于。

逻辑运算符 (短路求值)

逻辑运算符 and 和 or 具有短路求值（或称惰性求值）的特点，即程序只计算必须计算的表达式的值：

• and 运算符： 对于表达式 表达式 1 and 表达式 2，如果 表达式 1 的值等价于 False，则整个表达式的值就是 False，此时将不会计算 表达式 2 的值。
• or 运算符： 对于表达式 表达式 1 or 表达式 2，如果 表达式 1 的值等价于 True，则整个表达式的值总是等价于 True，此时不需要再计算 表达式 2 的值。如果 表达式 1 的值等价于 False，则需要计算 表达式 2 的值并将其作为整个表达式的值。

运算符在条件表达式中的应用

在选择和循环结构中，任何单个常量、变量或者任意合法表达式都可以作为条件表达式。

Python 解释器判断条件是否成立的原则如下：

• 条件不成立 (False 等价)： 表达式的值为 False、0（或 0.0、0j 等）、空值 None、空列表 []、空元组 ()、空集合或空字典 {}、空字符串 ""、空 range 对象或其他空迭代对象。
• 条件成立 (True 等价)： 只要值不是上述情况，Python 解释器均认为条件成立。

在条件表达式中，Python 不允许使用赋值运算符 =，这有助于避免将关系运算符 == 误写为赋值运算符 = 而带来的错误。

内置函数介绍

• ord()：返回Unicode编码。
• max(),min(),sum()：最大值、最小值、元素和。
• list(),tuple(),dict(),set()：将元素转换为列表、元组、字典、集合。
• sorted()：对元素进行排序。

1
2

x = [5,4,3,2,1]
sorted(x)

• range()：随机数，start默认0，step默认为1。

1
2
3
4
5
6

>>> list(range(5))
[0,1,2,3,4]
>>> list(range(1,10))
[1,2,3,4,5,6,7,8,9]
>>> list(range(1,10,2))
[1,3,5,7,9]

• input()：接受用户键盘输入。x=input('Please Input:')
• print(value,...,sep=' ',end='\n',file=sys.stdout,flus=False)：输出字符。
  • value,...：输出的多个值。
  • sep=' '：指定分隔符，默认为空格。
  • end='\n'：结束符

__name__属性

每个Python程序在运行时都有一个 __name__ 属性，利用 __name__ 属性的值可以识别和控制Python程序的运行方式：

• 如果程序作为模块被导入，则其 __name__ 属性的值被自动设置为模块文件名；
• 如果作为程序直接运行，则其 __name__ 属性值被自动设置为字符串 '__main__'。

以下划线开头的变量名的特殊含义

• _xxx：这样的对象叫做保护变量，不能用 from module import * 导入，只有类对象和子类对象能访问这些变量；
• __xxx__：系统定义的特殊成员名字；
• __xxx：类中的私有成员，只有类对象自己能访问，子类对象也不能访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。

第二章 - Python可迭代对象

字符串、列表、元组、字典的区分

1. 字符串 (String) 的详细介绍及使用

定义与特性：

1. 界定符： 字符串是使用单引号、双引号、三单引号或三双引号引起来的一串字符。不同的界定符之间可以互相嵌套。
2. 不可变序列： 字符串属于不可变序列类型，这意味着不能通过下标的方式来修改其中的元素值。对字符串内容进行替换的操作，例如使用 replace() 或 translate() 方法，都会返回一个新的字符串，而不会修改原字符串。
3. 三引号： 三引号 表示的字符串支持换行，常用于表示排版格式复杂的字符串或较长的注释。
4. 有序性与索引： 字符串是有序序列，支持双向索引，第一个元素下标为 0，最后一个元素下标为 -1。

使用方法：

• 创建： 直接使用引号界定即可创建，例如 "Hello"。
• 连接与格式化：
  • 可以使用 + 运算符进行合并以生成新字符串，但效率较低，推荐使用 join() 方法。
  • 可以使用 % 符号进行格式化，但 Python 社区更推荐使用 format() 方法，它支持位置和名称格式化，更加灵活。
• 查找：
  • find() 或 rfind()：查找子字符串首次/最后一次出现的位置，不存在返回 -1。
  • index() 或 rindex()：功能类似，但不存在时抛出异常。
  • count()：返回子字符串出现的次数。
• 分割： split() 或 rsplit() 方法以指定字符为分隔符，将字符串分割成多个字符串，并返回包含结果的列表。如果不指定分隔符，任何空白符号（空格、换行符、制表符等）都将被认为是分隔符。
• 切片： 字符串支持切片操作，用于截取部分元素，生成新的字符串。

2. 列表 (List) 的详细介绍及使用

定义与特性：

1. 可变序列： 列表是 Python 的内置可变序列。
2. 结构： 列表的所有元素放在一对方括号 [] 中，相邻元素使用逗号分隔。
3. 有序性与索引： 列表是有序序列，支持双向索引，第一个元素下标为 0，最后一个为 -1。
4. 元素类型： 同一个列表中的元素类型可以不相同，支持嵌套（例如包含整数、字符串、元组等）。

使用方法：

• 创建： 可以直接赋值创建，或使用 list() 函数将元组、字符串或其他可迭代对象转换为列表。列表推导式也是一种常用的快速生成列表的方式。
• 元素增加（动态增删）：
  • append()： 在列表尾部添加元素，属于原地修改，速度较快，是推荐使用的方法。
  • extend()： 将另一个迭代对象的所有元素添加到列表尾部，属于原地操作。
  • insert(index, value)： 在指定位置插入元素，但由于涉及内存收缩和元素移动，效率较低，除非必要应尽量避免在列表中间位置插入。
• 元素删除：
  • del 命令： 删除整个列表 或删除指定位置上的元素。
  • pop()： 删除并返回指定位置（默认为最后一个）上的元素。
  • remove(value)： 删除首次出现的指定元素，若不存在则抛出异常。
• 访问与判断：
  • 可使用下标直接访问元素。
  • index(value)：获取指定元素首次出现的下标。
  • count()：统计指定元素出现的次数。
  • in 或 not in 关键字用于成员资格判断。
• 排序：
  • sort() 方法： 对列表进行原地排序，没有返回值。
  • sorted() 函数： 返回新列表，不对原列表进行任何修改。
  • reverse() 方法： 将所有元素原地逆序排列。
• 切片操作： 适用于列表，可用于截取部分元素（返回新列表），也可用于原地修改、删除或增加列表中的元素。

3. 元组 (Tuple) 的详细介绍及使用

定义与特性：

1. 不可变序列： 元组属于不可变序列。一旦创建，不能修改其元素值，也无法增加或删除元素。
2. 结构： 元组使用一对圆括号 () 作为定界符，元素之间用逗号分隔。
3. 性能优势： 元组的访问和处理速度通常比列表更快。
4. 作为字典键： 元组可以作为字典的键，而列表不能，因为列表是可变的。

使用方法：

• 创建：
  • 直接赋值创建，例如 t = (1, 2, 3)。
  • 单元素元组： 必须在元素后面加一个逗号，例如 (element,)。
  • tuple() 函数：将其他类型序列转换为元组。
• 删除： 只能使用 del 命令删除整个元组对象，不能删除部分元素。
• 访问： 支持切片操作，但只能用于访问元素，不支持修改或删除。
• 序列解包 (Unpacking)： 元组是序列解包的常用场景，可以简洁地为多个变量同时赋值。
• 限制： 元组不支持 append()、extend()、insert()、remove()、pop() 等修改方法。

4. 字典 (Dictionary) 的详细介绍及使用

定义与特性：

1. 映射类型： 字典是 Python 中唯一的映射类型，是 “键-值对”的无序可变序列。
2. 结构： 元素放在一对大括号 {} 中，键和值用冒号分隔，相邻元素用逗号分隔。
3. 键 (Key)： 键必须是 Python 中任意不可变数据（如整数、字符串、元组），且键不允许重复。
4. 值 (Value)： 可以是任意类型的数据，值可以重复。

使用方法：

• 创建：
  • 直接赋值创建，例如 d = {'key': 'value'}。
  • dict() 函数：通过已有数据创建字典。
  • 字典推导式：快速生成字典。
• 读取元素：
  • 使用下标（键）访问：dict[key]。若键不存在会抛出异常。
  • get(key) 方法： 推荐且更安全，若键不存在可以返回指定值（默认 None）。
• 添加与修改：
  • 通过下标赋值：如果键已存在则修改其值；如果键不存在，则添加一个新的键值对。
  • update() 方法：将另一个字典的键值对一次性添加到当前字典，若键相同则更新值。
• 删除：
  • del 命令：删除指定键对应的元素。
  • clear()：清空字典。
  • pop()：删除并返回指定键的元素。
• 获取键/值/项：
  • keys()： 返回字典的“键”列表。
  • values()： 返回字典的“值”列表。
  • items()： 返回字典的“键-值对”列表。
• 序列解包： 对字典进行序列解包时，默认是对字典的键进行操作。若需对“键-值对”操作，需要使用 items() 方法。

第三章 - 选择与循环

选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 单分支选择结构
if a>b:
  print("yes")
# 双分支选择结构
if a>b:
  print("yes")
else:
  print("no")
# 嵌套
if score>100:
  return 'error 100'
elif score>=90:
  return 'A'
elif score>=80:
  return 'B'
else:
  return 'error 101'

循环结构

1. for 循环 vs while 循环

场景： 能够体现两者适用范围的区别。

A. for 循环（适合已知次数/遍历序列）

任务： 计算列表是一个由数字组成的序列，我们需要计算总和。

1
2
3
4
5
6
7
8

numbers = [1, 2, 3, 4, 5]
total = 0

# 推荐做法：直接遍历元素
for num in numbers: # 每次从numbers(数组)里面提取出一个数字，赋值给num这个变量。
    total += num

print(f"总和是: {total}")

1
2

for i in range(1,101): # 从1循环到100，i=1 .... i=100
  ans=ans+i

B. while 循环（适合未知次数/条件控制）

任务： 模拟一个存钱罐，直到存够 100 元才停止。

1
2
3
4
5
6
7
8
9
10
11

balance = 0
target = 100
day = 0

# 我们不知道具体要存几天，只知道停止条件
while balance < target:
    day += 1
    balance += 15  # 每天存15元
    print(f"第 {day} 天，当前余额: {balance}")

print(f"终于存够了！用了 {day} 天。")

2. break 与 continue 的使用

场景： 在筛选数据时控制流程。

任务： 在一组数据中，我们想打印所有偶数，但如果遇到数字 0，则认为数据出错，立即停止整个处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

data = [1, 3, 4, 7, 8, 0, 10, 12]

print("开始处理数据...")

for x in data:
    if x == 0:
        print(">> 错误：发现非法数据 0，程序终止！")
        break  # 直接跳出整个循环，后面的 10 和 12 不会被处理
    
    if x % 2 != 0:
        continue # 跳过本次循环剩余语句，直接进入下一次循环（不打印奇数）
        
    print(f"处理偶数: {x}")

print("循环结束。")

3. 带有 else 子句的循环

这是一个 Python 特有的有趣特性，常用于搜索场景。

任务： 检查一个列表中是否包含“危险品”。如果找到了，就报警；如果检查完整个列表都没找到（循环自然结束），则报告安全。

1
2
3
4
5
6
7
8
9
10
11

items = ["apple", "banana", "book", "pen"] # 尝试把这里改成包含 "bomb" 看看效果

search_target = "bomb"

for item in items:
    if item == search_target:
        print(f"警报：发现了 {search_target}！")
        break # 因为break退出，所以不会执行 else
else:
    # 只有当循环没有被 break 打断，自然执行完毕时才运行这里
    print("检查完毕：未发现危险品，安全。")

4. 逻辑运算符的“短路”特性

场景： 利用 and 的短路特性避免报错。

任务： 计算 100 / n，但在计算前必须确保 n 不为 0。

1
2
3
4
5
6
7
8

n = 0 

# 如果 n != 0 为 False，Python 就不会去计算后面的 (100/n > 5)
# 从而避免了 "ZeroDivisionError" 除以零错误
if n != 0 and (100 / n > 5): 
    print("结果大于 5")
else:
    print("无法计算或结果不满足条件")

第四章 - 字符串与正则表达式

正则表达式

元字符

量词

定位符

习题

代码分析题

1. 请写出下列程序的输出结果：

1
2
3
4
5
6

num = 0
for i in range(1, 7):
    if i % 4 == 0:
        break
    num += i
print(num)

输出结果： 6

2. 请写出下列程序的输出结果：

1
2
3
4
5
6

def multiply(a, b=5):
    return a * b

result1 = multiply(3)
result2 = multiply(3, 6)
print(result1, result2)

输出结果： 15 18

3. 以下代码输出结果是：

1
2
3

tuple1 = (4, 5, 6)
tuple2 = tuple1 * 2
print(tuple2)

输出结果： (4, 5, 6, 4, 5, 6)

4. 以下代码输出结果是：

1
2

dict1 = {"city": "Beijing", "area": 16410}
print(dict1.get("city"), dict1.get("population", "Unknown"))

输出结果： Beijing Unknown

5. 以下代码输出结果是：

1
2

s = "I like coding"
print(s[:6], s[-6:])

输出结果： I like coding

简述题

1. 简述Python程序在运行时的 __name__ 属性

每个Python程序在运行时都有一个 __name__ 属性，利用 __name__ 属性的值可以识别和控制Python程序的运行方式：
1）如果程序作为模块被导入，则其 __name__ 属性的值被自动设置为模块文件名；
2）如果作为程序直接运行，则其 __name__ 属性值被自动设置为字符串 '__main__'。

2. 分析逻辑运算符 “or” 的短路求值特性

假设有表达式“表达式1 or 表达式2”，如果表达式1的值等价于True，那么无论表达式2的值是什么，整个表达式的值总是等价于True。此时不需要再计算表达式2的值，直接以表达式1的值作为整个表达式的值。
如果表达式1的值等价于False，这时无法确定整个表达式等价于True还是False，所以需要继续计算表达式2的值并将其作为整个表达式的值。

3. 介绍一下字符串、列表、元组、字典几种数据类型，并说说如何使用

• 字符串：就是使用单引号、双引号、三引号作为定界符引起来的一串字符，字符串属于不可变类型。
• 列表：是Python中最常用的数据类型之一，列表使用 [] 作定界符，使用中可以通过列表对数据实现存储、修改、删除等操作。
• 元组：与列表类似，不同之处在于元组中的元素不可以修改和删除，元组使用 () 作为定界符。
• 字典：是Python中唯一的映射类型，采用键值对的形式进行数据存储。

4. 简述在Python中以下划线开头的变量名的特殊含义

• _xxx：这样的对象叫做保护变量，不能用 from module import * 导入，只有类对象和子类对象能访问这些变量；
• __xxx__：系统定义的特殊成员名字；
• __xxx：类中的私有成员，只有类对象自己能访问，子类对象也不能访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。

编程题

题目 1

给定列表 [8, 2, 6, 2, 4, 8, 1]，将元素按从大到小排序，并去除重复元素。

1
2
3
4

original_list = [8, 2, 6, 2, 4, 8, 1]
result_list = sorted(list(set(original_list)), reverse=True)
print(result_list)
# 示例输出：[8, 6, 4, 2, 1]

题目 2

生成12个范围在15到60之间的随机整数，存储到列表中，计算所有偶数的和，并输出列表与偶数和。

1
2
3
4
5
6
7
8
9
10
11

import random

random_list = [random.randint(15, 60) for _ in range(12)]
even_sum = 0
for num in random_list:
    if num % 2 == 0:
        even_sum += num

# 输出结果
print("随机列表：", random_list)
print("列表中偶数的和：", even_sum)

题目 3

编写函数 my_min()，接收一个包含数字的可迭代对象（如列表、元组）作为参数，模拟内置函数 min() 的功能：

• 若可迭代对象为空，返回 None；
• 若可迭代对象非空，返回其中的最小值（要求通过遍历实现，禁止直接调用 min()）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def my_min(iterable):
    # 判断可迭代对象是否为空（先转换为列表判断，避免生成器等特殊情况）
    iter_list = list(iterable)
    if not iter_list:
        return None
    
    # 假设第一个元素为最小值
    min_num = iter_list[0]
    
    # 遍历剩余元素更新最小值
    for num in iter_list[1:]:
        if num < min_num:
            min_num = num
    
    return min_num

# 测试
print(my_min([5, 2, 8, 1]))     # 输出：1
print(my_min((9, 3, 6)))        # 输出：3
print(my_min([]))               # 输出：None

题目 4

编写函数 count_even_odd()，接收任意多个整数作为参数，统计并返回其中偶数的个数和奇数的个数。

1
2
3
4
5
6
7
8
9
10
11
12
13

def count_even_odd(*args):
    even_count = 0  # 偶数个数
    odd_count = 0   # 奇数个数
    for num in args:
        if num % 2 == 0:
            even_count += 1
        else:
            odd_count += 1
    return even_count, odd_count

# 测试
even, odd = count_even_odd(1, 2, 4, 5)
print(f"偶数个数：{even}，奇数个数：{odd}")

题目 5

输入一段包含身份证号（18 位，最后一位可能为 X/x）、固定电话（格式如“0431-1234567”“010-12345678”）的混合字符串，完成以下操作：

1. 使用正则表达式提取所有 18 位身份证号和符合格式的固定电话；
2. 统计提取到的身份证号数量和固定电话数量；
3. 对提取的身份证号，输出其出生日期（身份证号第 7-14 位，格式如“2000-01-01”）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import re

input_str = input("请输入包含18位身份证号和固定电话的混合字符串：")

# 正则模式
id_card_pattern = r'\d{17}[\dXx]'          # 18位身份证号，末位可为X/x
tel_pattern = r'\d{3,4}-\d{7,8}'           # 固定电话：区号3-4位，号码7-8位

# 提取
id_cards = re.findall(id_card_pattern, input_str)
tels = re.findall(tel_pattern, input_str)

# 统计
print(f"提取到的18位身份证号数量：{len(id_cards)}")
print(f"提取到的固定电话数量：{len(tels)}")
print(f"提取的身份证号列表：{id_cards}")
print(f"提取的固定电话列表：{tels}")

# 出生日期解析
print("身份证号出生日期解析结果：")
for id_card in id_cards:
    birth_str = id_card[6:14]
    birth_date = f"{birth_str[:4]}-{birth_str[4:6]}-{birth_str[6:8]}"
    print(f"身份证号：{id_card}，出生日期：{birth_date}")