python编程基础（待续）【（字符串、列表、字典、元组）操作、运算符、文件读取、os模块、随机数、json、序列化、迭代器】

python编程基础

目录

python编程基础

python编程基础知识

python中的保留字

常用的转义字符及其作用

常用的逻辑运算结果

运算符的优先级

python时间日期格式化符号

随机数应用（random模块）

生成普通的随机数

生成不重复的随机数

随机排列序列元素

特定规则的随机数

初始化随机数生成器

生成器的状态

python正则表达式

常用字符和字符集

常用限定符

常用的选择与分组符号

选择符号

分组符号

零宽断言

非捕获组

选择符

字符串操作

定义、截取、拼接与检索

字符串定义

字符串截取

基本切片

负索引切片

步长切片

字符串的拼接

“+”符号拼接字符串

join（）方法拼接字符串

f_string方式拼接（变量）

用（）拼接

字符串的检索

统计字符串出现的次数

字符串首次出现的索引

分割与验证操作

分割字符串

以指定的字符分割字符串

基本用法

按换行符（\r、\r\n、\n）分割字符串

分割字符串为元组

验证字符串

验证字符串是否为纯字母

方法4：使用 str.isnumeric() 方法（Python 3.4+）

验证字符串是否为字母和数字

验证字符串是否为数字（整数数字，非小数）

验证字符串大小写

验证字符串是否为打印字符串

验证字符串是否有空格组成

替换、对其、编码、大小写、去重

去除字符串中的空格和特殊字符

lstrip() 和 rstrip()

字符串替换

将tab符号（制表符）转换空格

字符串对其填充

字符串前面填充0添加编号

编码与编码字符串

字符串大小写转换

注意事项

字符串去重

字符串格式化处理操作

格式化十进制整数

格式化浮点数

格式化百分数

生成数据编号

格式化科学记数法

格式化金额

进制转换

格式化日期与时间

列表操作

创建、转换、获取、遍历

列表创建与复制

列表转换

列表元素获取

遍历列表

添加、删除、排序及统计

列表的添加

列表的删除

列表的排序

列表的查找统计

元组操作

元组定义

字典操作

创建、转换、遍历、获取、删除

创建字典

注意事项

转换字典

遍历字典

输出

注意事项

获取字典内容

字典的删除

复制及更新

字典的复制

字典的更新

集合的操作

创建、添加、删除、运算

创建集合

创建不可变集合

添加集合元素

删除集合元素

交集、并集、差集运算

集合判断

OS模块应用

读取写入、信息获取与重命名

打开文件描述符

读取文件内容

写入字节类型内容到文件

关闭打开的文件描述符

复制文件描述符

获取文件描述符状态

获取文件信息

获取文件或文件描述符的状态

文件系统路径的编码与解码

重命名文件与目录

目录的创建、删除及遍历

删除文件

创建硬链接

截断文件为指定大小

文件信息设置

目录的创建

目录的删除

目录的遍历操作

获取目录

使用关联的应用程序启动文件

执行系统命令

执行命令、系统信息获取

执行本地命令

执行新程序

系统信息获取

进程相关

获取系统环境变量

系统环境变量

os.path模块

路径获取、拼接、分割及判断

获取路径

路径拼接

路径分割

判断路径

获取路径信息

json模块

读取写入及转换

从json文件中读取文件

将json格式转换成python对象

将python对象转换为json格式字符串后写入到文件

将python对象转换为json字符串

shutil模块

文件的复制、一佛那个、删除及解压缩

复制文件或目录

移动文件或目录

信息获取

压缩与解压缩文件

sys模块

输入输出、解释器及系统版本的获取

标准输入流与输出流

python解释器相关

windows系统相关

路径、编码、线程、递归与异常

虚拟环境与路径

系统编码信息

线程与递归

程序异常

其他系统字段属性或方法

日期时间模块

日期时间对象与星期

获取当前本地日期和时间对象

创建时间对象

获取日期对象

创建日期和时间对象

将data、time对象合为datatime对象

将日期时间字符串转换为日期时间对象

返回指定天数的data、datatime对象

根据指定的字符串返回日期时间对象

返回指定日期的星期码

放回当前日期为星期几

放回包含年份、周数、星期数的元组

放回对应结构化的时间

日期格式化与替换

替换日期时间对象

返回指定格式的日期时间字符串

返回日期时间字符串

时间差、时间戳、时区

获取时间戳

内置函数

数据的转换与计算

整数——》二进制

对象——》布尔型

ascll码——》字符串

整数/字符串——》浮点数

整数——》十六进制数

浮点数/数字字符串——》整数

整数——》八进制

字符——》ascli码

对象——》字符串

求绝对值

求商合余数

求最大值

求最小值

四舍五入

幂运算

求和

输入输出

格式化处理

输入操作

打印输出

查看帮助信息

序列与迭代器

过滤序列

反转序列

排序

可迭代对象长度或个数

函数操作可迭代对象

迭代器的下一个元素

可迭代对象打包成元组

实现切片对象

判断可迭代对象是否包含假值

可迭代对象是否全wield假值

对象/对象属性与编译执行

获取对象类型

执行字符串表达式

执行储存在字符串或文件的python语句

将对象转化为可打印字符串

获取对象内存地址

获取名字、属性或方法列表

创建枚举对象

返回对象字符串

---

python编程基础知识

python中的保留字

常用的转义字符及其作用

\n：换行符。在字符串中插入一个换行符，表示文本在这里换到下一行。

print("Hello,\nWorld!")
# 输出：
# Hello,
# World!

\t：制表符。在字符串中插入一个制表符，通常用于创建表格或增加水平空间。

print("Name\tAge")
# 输出（假设制表符宽度为8个空格）：
# Name    Age

\r：回车符。将光标移动到当前行的开头。

print("Hello\rWorld")
# 输出（光标回到行首并覆盖之前的文本）：
# World

\v：垂直制表符。在某些环境中用于创建垂直分隔线。

\f：换页符。在某些环境中用于分隔页面。

\a：响铃符。在某些终端中会触发响铃。

\b：退格符。将光标向左移动一个位置。

\'：单引号转义符。在字符串中插入单引号。

print('\'Hello\'')
# 输出：'Hello'

\\：反斜杠符。在字符串中插入反斜杠

print("C:\\Users\\User")
# 输出：C:\Users\User

常用的逻辑运算结果

在Python中，逻辑运算符用于根据条件的真假来返回布尔值（True或False）。下面是一些常用的逻辑运算符及其结果：

1. 逻辑与（AND） - and

   • 如果两边的表达式都为True，则结果为True。

   • 否则，结果为False。

   a = True
   b = False
   result = a and b  # 结果为False

2. 逻辑或（OR） - or

   • 如果两边的表达式中至少有一个为True，则结果为True。

   • 否则，结果为False。

   a = True
   b = False
   result = a or b  # 结果为True

3. 逻辑非（NOT） - not

   • 如果表达式为True，则结果为False。

   • 如果表达式为False，则结果为True。

   a = True
   result = not a  # 结果为False

4. 短路运算：

   • 在Python中，and和or运算符支持短路运算。这意味着如果and的第一个操作数是False，或者or的第一个操作数是True，那么第二个操作数将不会被评估。

   a = True
   b = False
   # and短路运算
   result = a and (b or True)  # b or True不会被评估，结果为True
   # or短路运算
   result = a or (b and True)  # b and True不会被评估，结果为True

5. 比较运算符：

   • 比较运算符也可以用来创建逻辑表达式，例如==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。

   a = 5
   b = 10
   result = a < b  # 结果为True
   result = a == b  # 结果为False

6. 成员运算符：

   • in和not in用于检查一个值是否存在于序列（如列表、元组、字符串）中。

   a = [1, 2, 3, 4, 5]
   b = 3
   result = b in a  # 结果为True
   result = b not in a  # 结果为False

7. 身份运算符：

   • is和is not用于比较两个对象的身份（即它们是否为同一个对象）。

   a = [1, 2, 3]
   b = [1, 2, 3]
   result = a is b  # 结果为False，因为a和b指向不同的对象
   result = a is not b  # 结果为True

这些是Python中常用的逻辑运算符和结果。如果你有更具体的问题或需要示例，请随时提问。

运算符的优先级

在Python中，运算符的优先级决定了在表达式中各个运算符的计算顺序。以下是Python中运算符的优先级列表，从最高到最低：

1. 括号 ( )

2. 指数 **

3. 一元运算符 +x, -x, ~x, not x

4. 乘法和除法 *, /, //, %

5. 加法和减法 +, -

6. 比较运算符 <, <=, >, >=, is, is not, in, not in

7. 等于运算符 ==, !=

8. 位运算符 <<, >>, &, ^, |

9. 逻辑非运算符 not

10. 逻辑与运算符 and

11. 逻辑或运算符 or

以下是一些例子来说明这些优先级：

# 指数运算符优先级高于乘法和除法
result = 2 ** 2 * 3  # 16，而不是(2 ** 2) * 3

# 乘法和除法优先级高于加法和减法
result = 3 + 4 * 2  # 11，相当于3 + (4 * 2)

# 括号可以改变优先级
result = (3 + 4) * 2  # 14，先计算括号内的加法

# 比较运算符优先级高于等于运算符
result = 3 < 4 == 5  # False，先比较3 < 4，然后比较True == 5

# 逻辑非运算符优先级高于比较运算符
result = not 3 < 4 and 2 > 1  # True，先计算3 < 4得到True，然后not True得到False，最后False and 2 > 1得到False

# 逻辑与运算符优先级高于逻辑或运算符
result = 1 < 2 and 2 < 3 or 3 < 1  # True，先计算1 < 2 and 2 < 3得到True，然后True or 3 < 1得到True

在编写复杂的表达式时，建议使用括号来明确指定计算顺序，以避免由于优先级引起的错误。

python时间日期格式化符号

在Python中，处理日期和时间时，可以使用datetime模块来格式化和解析日期。以下是一些常用的格式化符号，这些符号可以在strftime()和strptime()方法中使用：

年份:

• %Y - 四位数字表示的年份（例如：2024）

• %y - 两位数字表示的年份（例如：24）

月份:

• %m - 两位数字表示的月份（01到12）

日期:

• %d - 两位数字表示的日期（01到31）

小时（24小时制）:

• %H - 两位数字表示的小时（00到23）

小时（12小时制）:

• %I - 两位数字表示的小时（01到12）

• %p - 上午或下午的标识（AM或PM）

分钟:

• %M - 两位数字表示的分钟（00到59）

秒:

• %S - 两位数字表示的秒（00到59）

微秒:

• %f - 六位数字表示的微秒（000000到999999）

星期:

• %a - 星期的简写（例如：Mon, Tue）

• %A - 星期的全称（例如：Monday, Tuesday）

• %w - 星期的序号（0到6，0表示星期天）

• %u - 星期的序号（1到7，1表示星期一）

月份中的第几天:

• %j - 一年中的第几天（001到366）

时区:

• %Z - 时区的名称

其他:

• %b - 月份的简写（例如：Jan, Feb）

• %B - 月份的全称（例如：January, February）

• %p - 与AM/PM等价

• %x - 适合日期的本地表示（例如：12/31/2024）

• %X - 适合时间的本地表示（例如：23:13:45）

• %c - 适合日期和时间的本地表示（例如：12/31/2024 23:13:45）

• %U - 一年中的第几周，以星期日为一周的开始

• %W - 一年中的第几周，以星期一为一周的开始

• %V - ISO 8601格式的一年中的第几周

• %D - 美国日期格式（%m/%d/%y）

• %n - 换行符

• %t - 水平制表符

• %% - 字面上的百分号（%）

以下是一些使用这些格式化符号的例子：

from datetime import datetime

# 获取当前日期和时间
now = datetime.now()

# 格式化日期和时间
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_date)  # 输出类似于 "2024-05-23 15:21:34"

# 解析日期字符串
parsed_date = datetime.strptime("2024-05-23 15:21:34", "%Y-%m-%d %H:%M:%S")
print(parsed_date)  # 输出 datetime.datetime(2024, 5, 23, 15, 21, 34)

这些格式化符号非常有用，可以帮助你以不同的格式展示日期和时间。

随机数应用（random模块）

生成普通的随机数

1. 生成0到1之间的随机浮点数：

import random

# 生成一个0到1之间的随机浮点数
random_float = random.random()
print(random_float)

1. 生成指定范围内的随机整数：

import random

# 生成一个1到10之间的随机整数（包含1和10）
random_integer = random.randint(1, 10)
print(random_integer)

1. 生成指定范围内的随机浮点数：

import random

# 生成一个1.5到4.5之间的随机浮点数
random_uniform = random.uniform(1.5, 4.5)
print(random_uniform)

1. 生成指定范围内的随机数：

import random

# 生成一个0到1000之间的随机数（包含0，不包含1000）
random_number = random.randrange(0, 1000)
print(random_number)

1. 生成一组随机数：

import random

# 生成一个包含10个0到1之间随机浮点数的列表
random_numbers = [random.random() for _ in range(10)]
print(random_numbers)

1. 生成一个随机布尔值：

import random

# 生成一个随机布尔值（True或False）
random_bool = random.choice([True, False])
print(random_bool)

生成不重复的随机数

1：生成一组不重复的随机整数

假设你想从0到99中随机选择10个不重复的整数：

import random

# 生成10个不重复的随机整数，范围从0到99
unique_random_integers = random.sample(range(100), 10)
print(unique_random_integers)

2：生成不重复的随机浮点数

如果你需要生成一组不重复的随机浮点数，可以先生成一组随机整数，然后转换为浮点数：

import random

# 生成10个不重复的随机整数，范围从0到99，然后转换为浮点数
unique_random_floats = [x / 10 for x in random.sample(range(100), 10)]
print(unique_random_floats)

3：从列表中随机选择不重复的元素

如果你有一个特定的列表，并想从中随机选择几个不重复的元素：

import random

# 定义一个列表
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 随机选择3个不重复的元素
selected_elements = random.sample(my_list, 3)
print(selected_elements)

4：生成不重复的随机数序列

如果你需要生成一个序列的不重复随机数，可以使用循环和random.randint()，但需要确保不重复：

import random

# 生成一个包含5个不重复随机整数的列表，范围从0到99
unique_random_numbers = set()
while len(unique_random_numbers) < 5:
    number = random.randint(0, 99)
    unique_random_numbers.add(number)

print(list(unique_random_numbers))

随机排列序列元素

在Python中，如果你想随机排列一个序列的元素，可以使用random模块中的shuffle()函数。这个函数会就地（in-place）打乱序列的元素，也就是说它会直接修改原序列。

1、使用 random.shuffle()

import random

# 定义一个列表
my_list = [1, 2, 3, 4, 5]

# 使用shuffle随机排列列表元素
random.shuffle(my_list)

# 打印随机排列后的列表
print(my_list)

每次执行这段代码时，my_list 的元素都会被随机重新排列。

示例

import random

# 创建一个列表
fruits = ["apple", "banana", "cherry", "date", "elderberry"]

# 随机排列列表元素
random.shuffle(fruits)

# 输出排列后的列表
print(fruits)  # 输出可能是 ["date", "banana", "cherry", "apple", "elderberry"]

注意事项

• random.shuffle() 会直接修改原列表，不会返回一个新的列表。

• 如果你需要保留原始列表，可以先复制原列表，然后对副本进行随机排列。

2、复制列表并随机排列

如果你不想修改原始列表，可以先复制它，然后对副本进行随机排列：

import random

# 创建一个列表
original_list = [1, 2, 3, 4, 5]
# 复制列表
shuffled_list = original_list[:]

# 随机排列副本
random.shuffle(shuffled_list)

# 输出原始列表和随机排列后的列表
print("Original:", original_list)
print("Shuffled:", shuffled_list)

这样，原始列表 original_list 保持不变，而 shuffled_list 则是随机排列后的新列表。

3、使用 random.sample() 打乱序列

如果你需要从一个序列中随机选择一些元素并打乱，可以使用 random.sample() 函数。这个函数不会就地修改序列，而是返回一个新的列表。

import random

# 创建一个列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 随机选择5个元素并打乱
sample = random.sample(numbers, 5)

# 输出结果
print(sample)  # 输出可能是 [8, 3, 7, 1, 5]

请注意，random.sample() 并不会修改原始序列，它总是返回一个新的列表。

特定规则的随机数

生成符合特定规则的随机数通常需要结合random模块的功能和一些数学逻辑。下面是一些生成特定规则随机数的例子：

1. 生成固定范围内的随机数

生成一个在指定范围内的随机整数：

import random

# 生成一个1到100之间的随机整数
random_integer = random.randint(1, 100)
print(random_integer)

1. 生成符合特定分布的随机数

生成一个符合正态分布的随机数：

import random

# 生成一个均值为0，标准差为1的正态分布随机数
random_gaussian = random.gauss(0, 1)
print(random_gaussian)

1. 生成固定步长的随机数

生成一个在指定范围内，且以固定步长递增的随机数：

import random

# 生成一个1到100之间，步长为5的随机数（即5的倍数）
random_step = random.choice(range(1, 101, 5))
print(random_step)

1. 生成限定数量的不同随机数

生成指定数量的不同随机整数：

import random

# 生成5个不同的1到100之间的随机整数
random_unique = random.sample(range(1, 101), 5)
print(random_unique)

1. 生成符合特定模式的随机数

生成一个随机数，该随机数符合某种模式，比如所有数字之和为特定值：

import random

# 生成一个三位数，其数字之和为6
while True:
    num = random.randint(100, 999)
    if sum(int(digit) for digit in str(num)) == 6:
        print(num)
        break

1. 生成随机数序列

生成一个随机数序列，其中每个数都比前一个大：

import random

# 生成一个包含5个递增随机整数的列表
random_sequence = []
for _ in range(5):
    next_num = random.randint(1, 100)
    if not random_sequence or next_num > random_sequence[-1]:
        random_sequence.append(next_num)
    else:
        next_num = random_sequence[-1] + 1 + random.randint(1, 100)
        random_sequence.append(next_num)
print(random_sequence)

1. 生成随机加权概率分布的随机数

生成一个随机数，其生成概率与权重相关：

import random

# 定义权重
weights = [10, 20, 30, 40]

# 根据权重生成随机数
random_weighted = random.choices([1, 2, 3, 4], weights=weights, k=1)[0]
print(random_weighted)

1. 生成随机二进制数

生成一个具有特定位数的随机二进制数：

import random

# 生成一个8位的随机二进制数
random_binary = ''.join(random.choice('01') for _ in range(8))
print(random_binary)

这些例子展示了如何使用Python的random模块来生成符合特定规则的随机数。你可以根据实际需求调整这些规则。

初始化随机数生成器

在Python中，初始化随机数生成器通常意味着设置一个种子值，以便每次运行代码时都能得到可重复的随机数序列。这在调试和测试中非常有用，因为它确保了随机数生成的一致性。

1、使用 random.seed()

random.seed() 函数用于初始化随机数生成器。你可以传递任何可哈希的类型作为种子，但通常传递一个整数。

import random

# 设置随机数生成器的种子
random.seed(42)

# 生成一些随机数
print(random.random())  # 每次运行时，这个值都将是相同的
print(random.randint(1, 10))  # 也是相同的

如果你不传递任何参数给 random.seed()，它将使用系统时钟作为种子，从而每次运行时生成不同的随机数序列。

2、使用 random.getstate() 和 random.setstate()

除了设置种子，Python的 random 模块还允许你获取和设置随机数生成器的内部状态。这可以用来保存当前的随机数生成状态，并在以后恢复到该状态。

import random

# 获取当前状态
state = random.getstate()

# 生成一些随机数
print(random.random())
print(random.randint(1, 10))

# 设置状态，随机数生成器将回到获取状态时的状态
random.setstate(state)

# 生成的随机数将与之前相同
print(random.random())
print(random.randint(1, 10))

使用种子确保随机数的一致性

import random

# 设置种子
random.seed(10)

# 生成随机数
print(random.randint(1, 100))  # 输出将总是相同的，例如：92
print(random.random())         # 输出也将总是相同的，例如：0.6388838698347835

每次你运行这段代码时，只要种子值相同，生成的随机数序列也将相同。

注意事项

• 使用相同的种子值初始化随机数生成器可以确保随机数的可重复性，这对于调试和测试非常有用。

• 如果不设置种子，每次程序运行时生成的随机数序列将不同，因为默认情况下种子是系统时间。

• random.seed() 可以被用来生成伪随机数序列，但不适合用于加密目的。

生成器的状态

在Python中，random模块的生成器状态指的是其内部维护的随机数生成算法的当前状态。Python的random模块使用的是梅森旋转算法（Mersenne Twister），它是一个伪随机数生成器（PRNG），可以生成高质量的伪随机数序列。

1、获取和设置随机生成器的状态

Python允许你获取和设置random模块的当前状态。这可以用来恢复生成器到某个特定的状态，或者在不同的程序运行之间复制生成器的状态。

获取状态

使用random.getstate()可以获取当前的随机生成器状态：

import random

# 获取当前状态
state = random.getstate()

# 做一些随机数生成
random.random()
random.random()

# 再次获取状态
new_state = random.getstate()

# 检查状态是否改变
print(state == new_state)  # False，因为已经生成了新的随机数

2、设置状态

使用random.setstate()可以设置随机生成器的状态：

import random

# 获取当前状态
state = random.getstate()

# 做一些随机数生成
random.random()
random.random()

# 设置回之前的状态
random.setstate(state)

# 现在生成的随机数将与设置状态之前相同
print(random.random())  # 与设置状态前最后一次生成的随机数相同

3、保存和恢复状态

你可以将生成器的状态保存到一个变量中，然后在需要的时候恢复它：

import random

# 保存当前状态
state = random.getstate()

# 生成一些随机数
print(random.random())
print(random.randint(1, 100))

# 恢复之前的状态
random.setstate(state)

# 现在生成的随机数将与之前相同
print(random.random())
print(random.randint(1, 100))

注意事项

• 设置随机生成器的状态可以用来重现随机数序列，这在调试和测试中非常有用。

• 状态是一个包含多个元素的元组，通常你不需要了解其内部结构，只需要知道如何获取和设置即可。

• 如果你尝试设置一个无效的状态，random.setstate()将抛出ValueError异常。

通过这种方式，你可以控制随机数生成器的行为，确保随机数的可重复性。

python正则表达式

常用字符和字符集

在Python中，正则表达式（Regular Expressions，简称regex）是一种强大的文本匹配工具。它使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。以下是一些常用的字符和字符集：

1、常用字符

• .：匹配任意单个字符（换行符除外）。

• ^：匹配字符串的开始。

• $：匹配字符串的结束。

• *：匹配前面的子表达式零次或多次。

• +：匹配前面的子表达式一次或多次。

• ?：匹配前面的子表达式零次或一次。

• {m,n}：匹配确定的 m 到 n 次。

• []：匹配括号内的任意一个字符。

• |：匹配两个或多个表达式中的一个。

• \d：匹配任意数字，等同于 [0-9]。

• \D：匹配任意非数字字符，等同于 [^0-9]。

• \w：匹配任意字母数字字符，包括下划线，等同于 [a-zA-Z0-9_]。

• \W：匹配任意非字母数字字符，等同于 [^a-zA-Z0-9_]。

• \s：匹配任意的空白符（包括空格、制表符、换行符等）。

• \S：匹配任意非空白符。

2、特殊字符的转义

• \：转义特殊字符，使其被视为普通字符。

以下是一些使用Python re 模块的正则表达式示例：

import re

# 匹配包含任意字符的字符串
pattern = r".*"
result = re.match(pattern, "hello world")
print(result)  # <re.Match object; span=(0, 11), match='hello world'>

# 匹配字符串开头
pattern = r"^hello"
result = re.match(pattern, "hello world")
print(result)  # <re.Match object; span=(0, 5), match='hello'>
result = re.match(pattern, "hello123 world")
print(result)  # None, 不匹配

# 匹配字符串结尾
pattern = r"world$"
result = re.match(pattern, "hello world")
print(result)  # None, 不匹配
result = re.match(pattern, "hello world ")
print(result)  # None, 字符串末尾有空格

# 匹配任意数字
pattern = r"\d"
result = re.match(pattern, "123")
print(result)  # <re.Match object; span=(0, 1), match='1'>

# 匹配一个或多个空格
pattern = r"\s+"
result = re.match(pattern, "   hello")
print(result)  # <re.Match object; span=(0, 3), match='   '>

3、常用字符集

• [abc]：匹配方括号内的任意一个字符（a、b或c）。

• [a-z]：匹配任意一个小写字母。

• [A-Z]：匹配任意一个大写字母。

• [0-9]：匹配任意一个数字。

4、反义字符集

• [^abc]：匹配除了方括号内的任意一个字符。

• [^a-z]：匹配除了小写字母之外的任意字符。

• [^A-Z]：匹配除了大写字母之外的任意字符。

• [^0-9]：匹配除了数字之外的任意字符。

5、组合字符集

• [a-zA-Z]：匹配任意一个字母数字字符。

• [a-zA-Z0-9]：匹配任意一个字母数字字符或数字。

注意事项

• 当使用正则表达式时，特殊字符需要使用反斜杠 \ 进行转义。

• 正则表达式模式中的字符集（character sets）可以使用连字符 - 来指定一个范围。

• 正则表达式中的特殊字符和字符集可以组合使用，以匹配复杂的模式。

通过这些基本的字符和字符集，你可以构建复杂的正则表达式来匹配几乎任何文本模式。

常用限定符

在Python的正则表达式中，限定符用于指定前面元素的出现次数，从而增加模式的灵活性。以下是一些常用的限定符：

1. * - 星号（Asterisk）：匹配前面的元素零次或多次。

   • 例如：a* 匹配零个或多个 "a"。

2. + - 加号（Plus）：匹配前面的元素一次或多次。

   • 例如：a+ 匹配一个或多个 "a"。

3. ? - 问号（Question Mark）：匹配前面的元素零次或一次。

   • 例如：a? 匹配零个或一个 "a"。

4. {m} - 精确限定符：匹配确定的 m 次。

   • 例如：a{3} 匹配正好三个 "a"。

5. {m,} - 最小限定符：匹配至少 m 次。

   • 例如：a{2,} 匹配至少两个 "a"。

6. {m,n} - 范围限定符：匹配 m 到 n 次。

   • 例如：a{2,3} 匹配两个或三个 "a"。

7. *? - 非贪婪限定符：非贪婪版本的 *。

   • 例如：a*? 匹配尽可能少的 "a"。

8. +? - 非贪婪限定符：非贪婪版本的 +。

   • 例如：a+? 匹配尽可能少的 "a"。

9. ?? - 非贪婪限定符：非贪婪版本的 ?。

   • 例如：a?? 匹配尽可能少的 "a"。

10. {m}? - 非贪婪限定符：非贪婪版本的 {m}。

    • 例如：a{2}? 匹配正好两个 "a"，但尽可能少。

11. {m,}? - 非贪婪限定符：非贪婪版本的 {m,}。

    • 例如：a{2,}? 匹配至少两个 "a"，但尽可能少。

12. {m,n}? - 非贪婪限定符：非贪婪版本的 {m,n}。

    • 例如：a{2,3}? 匹配两个或三个 "a"，但尽可能少。

示例

以下是一些使用限定符的正则表达式示例：

import re

# 匹配零个或多个 'a'
text = 'aaaaa'
match = re.search('a*', text)
print(match.group())  # 输出: aaaaa

# 匹配至少两个 'a'
match = re.search('a{2,}', text)
print(match.group())  # 输出: aaaaa

# 匹配两个或三个 'a'，但尽可能少
match = re.search('a{2,3}?', text)
print(match.group())  # 输出: aa

# 匹配字符串 "abc" 后面跟着零个或一个 "x"
match = re.search('abcx?', 'abc')
print(match.group())  # 输出: abc

# 匹配字符串 "abc" 后面跟着一个或多个 "x"，但尽可能少
match = re.search('abcx+?', 'abcxxx')
print(match.group())  # 输出: abcx

注意事项

• 默认情况下，限定符是贪婪的，它们会尽可能多地匹配字符。

• 通过在限定符后面添加 ? 可以使限定符变为非贪婪模式，即尽可能少地匹配字符。

• 正确使用限定符可以提高正则表达式的灵活性和匹配效率。

常用的选择与分组符号

在Python的正则表达式中，选择和分组符号是构建复杂模式的关键元素。以下是一些常用的选择与分组符号及其用法：

选择符号

• |：逻辑或运算符，用于匹配多个选项中的一个。

  示例：

  import re
  pattern = r"red|blue|green"
  result = re.match(pattern, "I have a red ball")
  print(result.group())  # red

分组符号

• (...)：捕获括号，用于将多个元素组合成一个组，并捕获匹配的文本。

  示例：

  import re
  pattern = r"(\w+)\s(\w+)"
  result = re.match(pattern, "John Doe")
  print(result.group(1), result.group(2))  # John Doe

• (?:...)：非捕获括号，用于将多个元素组合成一个组，但不捕获匹配的文本。

  示例：

  import re
  pattern = r"(?:\w+)\s(\w+)"
  result = re.match(pattern, "John Doe")
  print(result.group(1))  # Doe

• (?P<name>...)：命名捕获，使用名称来标记捕获组，使后续的引用更加清晰。

  示例：

  import re
  pattern = r"(?P<first_name>\w+)\s(?P<last_name>\w+)"
  result = re.match(pattern, "John Doe")
  print(result.group("first_name"), result.group("last_name"))  # John Doe

零宽断言

• (?=...)：正向前瞻断言，表示匹配...前面的位置。

  示例：

  import re
  pattern = r"John(?= Doe)"
  result = re.match(pattern, "John Doe")
  print(result.group())  # John

• (?!...)：负向前瞻断言，表示匹配除了...外前面的位置。

  示例：

  import re
  pattern = r"John(?! Doe)"
  result = re.match(pattern, "John Smith")
  print(result.group())  # John

• (?<=...)：正向后瞻断言，表示匹配...后面的位置。

  示例：

  import re
  pattern = r"(?<=John )Doe"
  result = re.match(pattern, "John Doe")
  print(result.group())  # Doe

• (?<!...)：负向后瞻断言，表示匹配除了...外后面的位置。

  示例：

  import re
  pattern = r"(?<!John )Doe"
  result = re.match(pattern, "Jane Doe")
  print(result.group())  # Doe

注释

• (?#...)：注释，用于在正则表达式中添加注释。

  示例：

  import re
  pattern = r"(?# This is a comment)\w+"
  result = re.match(pattern, "Hello world")
  print(result.group())  # Hello

非捕获组

• (?>...)：原子括号，用于创建一个非捕获组，一旦开始匹配就不能回溯。

  示例：

  import re
  pattern = r"(?>abc|ab)c"
  result = re.match(pattern, "abc")
  print(result.group())  # abc

选择符

• (?(...))：条件表达式，用于基于捕获组的值进行选择。

  示例：

  import re
  pattern = r"(?(1)a|b)"
  result = re.match(pattern, "a")
  print(result.group())  # a

这些符号和结构使得正则表达式非常灵活和强大，能够匹配复杂的文本模式。

字符串操作

定义、截取、拼接与检索

字符串定义

在Python中，字符串是一系列Unicode字符的有序集合，用于表示文本数据。Python中的字符串可以用单引号 ''、双引号 "" 或三引号 ''' 或 """ 来定义。三引号通常用于定义多行字符串或文档字符串（docstrings）。

1、单行字符串

s1 = 'hello'
s2 = "world"

2、多行字符串

使用三引号可以定义多行字符串：

s = """
hello
world
"""
print(s)  # 输出: hello\nworld\n

3、文档字符串（docstrings）

三引号也常用于定义函数、类或模块的文档字符串：

def my_function():
    """这是一个函数的文档字符串。"""
    pass

字符串是不可变的

在Python中，字符串是不可变的数据类型，这意味着一旦创建了字符串，你就不能更改它的单个字符。

字符串的一些基本操作

• 连接：使用 + 操作符连接字符串。

  s = 'hello' + ' ' + 'world'

• 重复：使用 * 操作符重复字符串。

  s = 'hello' * 3  # 'hellohellohello'

• 切片：使用切片操作访问字符串的一部分。

  s = 'hello'
  print(s[1:4])  # 'ell'

• 成员检查：使用 in 和 not in 检查子字符串。

  s = 'hello'
  print('l' in s)  # True
  print('x' not in s)  # True

• 长度：使用 len() 函数获取字符串长度。

  s = 'hello'
  print(len(s))  # 5

• 格式化：使用 % 操作符或 str.format() 方法或f-string进行格式化。

  name = 'Alice'
  age = 30
  s1 = 'My name is %s, and I am %d years old.' % (name, age)
  s2 = 'My name is {}, and I am {} years old.'.format(name, age)
  s3 = f'My name is {name}, and I am {age} years old.'

• 查找和替换：使用 find()、index() 或 replace() 方法。

  s = 'hello'
  index = s.find('l')  # 2
  new_s = s.replace('l', 'x')  # 'hexxo'

• 大小写转换：使用 upper()、lower()、title()、capitalize() 等方法。

  s = 'hello'
  print(s.upper())  # 'HELLO'
  print(s.lower())  # 'hello'

• 字符串方法：Python提供了大量的字符串方法，如 split()、join()、strip()、startswith()、endswith() 等。

  s = '  hello world  '
  words = s.split()  # ['hello', 'world']
  new_s = ' '.join(words)  # 'hello world'
  print(s.strip())  # 'hello world'
  print(s.startswith('hello'))  # True

字符串截取

在Python中，字符串截取通常通过切片（slicing）操作来实现。切片操作允许你获取字符串的一部分，其语法为 字符串[start:stop:step]，其中 start 是切片开始的位置，stop 是切片结束的位置（不包括该位置的字符），而 step 是步长，即选择特定索引的字符。

基本切片

• 从头开始截取：

  s = 'hello'
  print(s[:3])  # 'hel'，从索引0开始，到索引3（不包括索引3）结束

• 从尾部开始截取：

  s = 'hello'
  print(s[2:])  # 'llo'，从索引2开始，到字符串末尾

• 截取整个字符串：

  s = 'hello'
  print(s[:])  # 'hello'，从头到尾

• 不指定开始和结束：

  s = 'hello'
  print(s[:: ])  # 'hello'，等同于s[:]

负索引切片

• 从尾部开始计数：

  s = 'hello'
  print(s[-3:-1])  # 'll'，从倒数第三个字符开始，到倒数第二个字符结束（不包括）

步长切片

• 步长为2：

  s = 'hello'
  print(s[::2])  # 'hlo'，从索引0开始，每隔一个字符取一个字符

• 反向切片：

  s = 'hello'
  print(s[::-1])  # 'olleh'，从末尾到开头反向读取字符串

注意事项

• 切片操作不会修改原始字符串，它返回一个新的字符串。

• 如果 start 大于 stop，切片结果是一个空字符串。

• 负索引允许你从字符串的末尾开始计数。

• 步长可以是任何整数，包括负数。

通过这些方法，你可以灵活地截取和操作字符串。

字符串的拼接

“+”符号拼接字符串

在Python中，+ 符号用于字符串拼接，即将两个或多个字符串连接成一个字符串。这是一种非常直观和常用的方法。

1、 基本用法

# 拼接两个字符串
s1 = "Hello"
s2 = "World"
result = s1 + " " + s2  # 使用空格作为分隔符
print(result)  # 输出: HelloWorld

2、拼接多个字符串

# 拼接多个字符串
s1 = "Hello"
s2 = ", "
s3 = "World"
s4 = "!"
result = s1 + s2 + s3 + s4
print(result)  # 输出: Hello, World!

3、拼接字符串和变量

# 拼接字符串和变量
name = "Alice"
greeting = "Hello, " + name + "!"
print(greeting)  # 输出: Hello, Alice!

4、使用循环拼接字符串

虽然可以使用循环和 + 符号来拼接多个字符串，但这种方法效率不高，特别是在循环中。对于更复杂的拼接任务，建议使用 join() 方法。

# 使用循环拼接字符串
words = ["Hello", "World", "!"]
result = ""
for word in words:
    result += word + " "
print(result.strip())  # 输出: Hello World !

注意事项

• 当使用 + 符号拼接字符串时，如果字符串是不可变的（如字符串字面量），Python会在内存中创建一个新的字符串对象，然后将两个字符串的内容复制到新对象中。

• 在循环中使用 + 符号拼接字符串会导致性能问题，因为每次循环都会创建一个新的字符串对象。在这种情况下，使用 join() 方法或字符串列表的 extend() 方法更为合适。

使用 + 符号拼接字符串是一种简单直观的方法，适用于简单的场景或少量的字符串拼接。对于更复杂的需求，考虑使用 join() 方法以提高性能和可读性。

join（）方法拼接字符串

在Python中，join() 是一个字符串方法，用于将序列中的元素连接成一个新的字符串。此方法将序列中的元素按照指定的顺序连接起来，并可以插入指定的分隔符。

1、基本用法

join() 方法的基本语法如下：

"分隔符".join(序列)

这里的“分隔符”是字符串方法的调用者，而“序列”是一个可迭代的元素集合，如列表、元组等。

# 列表中的字符串元素
words = ["Hello", "World", "from", "Python"]
# 使用空格作为分隔符
result = " ".join(words)
print(result)  # 输出: Hello World from Python

2、拼接非字符串序列

如果序列中的元素不是字符串，join() 方法会尝试将每个元素转换为字符串。这使得 join() 方法非常灵活。

# 列表中的整数
numbers = [1, 2, 3, 4]
# 将整数转换为字符串并用逗号分隔
result = ", ".join(map(str, numbers))
print(result)  # 输出: 1, 2, 3, 4

在这个例子中，我们使用了 map(str, numbers) 来确保列表中的每个整数都转换为字符串。

3、多行字符串

join() 方法也可以用于创建多行字符串。

# 列表中的多行文本
lines = ["Hello", "World", "!"]
# 使用换行符作为分隔符
result = "\n".join(lines)
print(result)
# 输出:
# Hello
# World
# !

4、空字符串作为分隔符

如果需要无分隔符合并字符串，可以使用空字符串作为 join() 方法的参数。

# 列表中的字符串
words = ["Hello", "World"]
# 无分隔符合并
result = "".join(words)
print(result)  # 输出: HelloWorld

注意事项

• join() 方法不会修改原始序列，它返回一个新的字符串。

• 如果序列中的元素是不可变的（如字符串字面量），join() 方法在连接时会创建一个新的字符串对象。

• 确保序列中的每个元素都是字符串，或者可以被转换为字符串，否则会引发异常。

使用 join() 方法拼接字符串比使用 + 操作符更高效，特别是在处理大量数据时。这是因为 join() 方法在内存中只创建了一个新的字符串对象，而使用 + 操作符会在每次连接时创建新的字符串对象。

f_string方式拼接（变量）

在Python 3.6及以上版本中，f-string（格式化字符串字面量）提供了一种非常便捷和易读的方式来格式化字符串。使用f-string，你可以直接在字符串中嵌入表达式，包括变量、函数调用等，并进行拼接。

1、基本用法

f-string 以 f 或 F 为前缀，后面跟着一个被花括号 {} 包围的表达式。表达式可以是变量、函数调用、算术运算等。

# 定义变量
name = "Alice"
age = 30

# 使用f-string拼接字符串
greeting = f"Hello, {name}. You are {age} years old."
print(greeting)  # 输出: Hello, Alice. You are 30 years old.

2、多行f-string

f-string支持多行字符串，每行的表达式都会自动对齐。

# 定义变量
name = "Alice"
age = 30

# 使用f-string生成多行字符串
multi_line_greeting = f"""
Hello, {name}.
You are {age} years old.
"""

print(multi_line_greeting)
# 输出:
# Hello, Alice.
# You are 30 years old.

3、表达式内计算

f-string允许在花括号内进行简单的计算。

# 定义变量
price = 19.99
tax_rate = 0.08

# 计算总价
total_price = price * (1 + tax_rate)

# 使用f-string显示总价
print(f"The total price is: ${total_price:.2f}")
# 输出: The total price is: $21.19

4、 调用函数

f-string内也可以调用函数。

# 定义函数
def get_greeting(name):
    return f"Hello, {name}!"

# 使用f-string调用函数
name = "Bob"
print(f"{get_greeting(name)}")
# 输出: Hello, Bob!

5、处理非字符串变量

f-string会自动调用str()方法将非字符串变量转换为字符串。

# 定义变量
age = 25

# 使用f-string
print(f"Age: {age}")
# 输出: Age: 25

注意事项

• f-string是不可变的，这意味着你不能在f-string中修改变量的值。

• f-string不支持转义字符，花括号 {} 内的表达式将被直接计算并转换为字符串。

• 使用f-string时，如果涉及到用户输入，需要注意避免注入攻击，确保输入内容的安全性。

f-string是Python中非常强大和灵活的字符串格式化工具，它使得字符串拼接和变量插入变得非常简单和直观。

用（）拼接

在Python中，使用圆括号 () 拼接字符串通常指的是在不使用字符串连接操作符 + 的情况下，通过将字符串放在同一个表达式中来实现拼接。这种方法并不常用，因为它的可读性不如使用 + 或 join() 方法，但它是技术上可行的。

示例

# 使用圆括号拼接字符串
s1 = "Hello"
s2 = "World"
result = s1 + " " + s2  # 这是常规的拼接方式
result_with_parentheses = (s1) + (" ") + (s2)  # 使用圆括号
print(result)  # 输出: HelloWorld
print(result_with_parentheses)  # 输出: HelloWorld

在这个例子中，result_with_parentheses 的计算方式与 result 相同，只是通过添加额外的圆括号来强调每个字符串元素。然而，这种写法并不增加任何实际的功能或好处，只是视觉上的不同。

更实用的应用

虽然直接使用圆括号来拼接字符串并不常见，但圆括号在Python中有多种用途，包括但不限于：

1. 分组表达式：在进行算术运算时，使用圆括号来明确运算顺序。

   result = (1 + 2) * 3

2. 调用函数：圆括号用于函数调用。

   message = print("Hello, World!")

3. 创建元组：使用圆括号定义元组。

   my_tuple = (1, 2, 3)

4. 解包操作：在处理数据结构如列表或元组时，圆括号用于解包元素。

   a, b, c = (1, 2, 3)

5. 条件表达式：在某些情况下，圆括号用于确保条件表达式的正确性。

   if (a == b) and (c != d):
       print("Conditions are met")

结论

虽然使用圆括号 () 拼接字符串在技术上是可能的，但它并不提供比直接使用 + 或 join() 方法更多的优势。在实际编程中，选择更清晰和直观的方法（如 + 或 join()）来拼接字符串通常是更好的做法。圆括号在Python中有广泛的用途，但拼接字符串不是其中之一。

字符串的检索

统计字符串出现的次数

在Python中，统计一个字符串在另一个字符串中出现的次数可以通过几种不同的方法实现。以下是一些常用的方法：

1：使用count()方法

字符串对象有一个内置的count()方法，可以统计子字符串在字符串中出现的次数。

s = "hello world, hello Python"
sub = "hello"
count = s.count(sub)
print(count)  # 输出: 2

2：使用find()方法

通过循环和find()方法，你可以找到每个子字符串的索引位置，并统计出现次数。注意，这个方法需要手动更新搜索的起始位置。

s = "hello world, hello Python"
sub = "hello"
count = 0
start = 0

while True:
    start = s.find(sub, start)
    if start == -1:
        break
    count += 1
    start += 1  # 增加起始位置，避免重复计数
print(count)  # 输出: 2

3：使用正则表达式

使用re模块的findall()方法可以找到所有匹配的子字符串，并计算它们的数量。

import re

s = "hello world, hello Python"
sub = "hello"
matches = re.findall(sub, s)
count = len(matches)
print(count)  # 输出: 2

4：使用collections模块的Counter类

你也可以使用Counter类来统计子字符串出现的次数。

from collections import Counter

s = "hello world, hello Python"
sub = "hello"
count = Counter(s.split())[sub]
print(count)  # 输出: 2

注意事项

• count()方法在子字符串为空字符串时会返回1，因为它在字符串的每个位置都找到了空字符串。

• find()方法在找不到子字符串时返回-1。

• 使用正则表达式时，要注意特殊字符可能需要转义，尤其是当子字符串包含正则表达式元字符时。

• Counter类在统计时会将原始字符串拆分成单词，默认以空白字符作为分隔符。

选择哪种方法取决于你的具体需求和场景。对于大多数情况，count()方法是最简单直接的选择。

字符串首次出现的索引

在Python中，要找到字符串首次出现的索引，可以使用字符串对象的 find() 方法或 index() 方法。

1、使用 find() 方法

find() 方法返回子字符串首次出现的最低索引。如果找不到子字符串，则返回 -1。

s = "hello world, hello Python"
sub = "hello"
index = s.find(sub)
print(index)  # 输出: 0

2、 使用 index() 方法

index() 方法也返回子字符串首次出现的最低索引，但如果找不到子字符串，它会抛出一个 ValueError 异常。

s = "hello world, hello Python"
sub = "hello"
try:
    index = s.index(sub)
    print(index)  # 输出: 0
except ValueError:
    print("Substring not found")

注意事项

• find() 和 index() 在功能上相似，但 find() 在子字符串不存在时返回 -1，而 index() 会抛出异常。

• 如果有可能找不到子字符串，使用 find() 可以避免异常处理，而 index() 则提供了一种通过异常处理来确认找到子字符串的方法。

通常情况下，如果你确信子字符串一定存在于父字符串中，或者你希望在子字符串不存在时收到一个明确的信号，使用 index() 方法会更合适。如果你需要处理子字符串不存在的情况，find() 方法提供了一种更灵活的方式。

分割与验证操作

分割字符串

以指定的字符分割字符串

在Python中，可以使用字符串的 split() 方法以指定的字符分割字符串。该方法会根据提供的分隔符将字符串分割成多个子字符串，并返回一个列表。

基本用法

s = "one,two,three,four"
# 使用逗号分割字符串
parts = s.split(",")
print(parts)  # 输出: ['one', 'two', 'three', 'four']

分割字符串时忽略空格

默认情况下，split() 方法会保留分隔符之间的空格。如果你想要忽略空格，可以使用 split() 方法的第二个参数 maxsplit。

s = "one, two, three, four"
# 分割字符串，最多分割3次
parts = s.split(",", maxsplit=3)
print(parts)  # 输出: ['one', 'two', 'three', 'four']

分割字符串时去除空字符串

如果你想要去除结果中的空字符串，可以在使用 split() 方法后使用列表推导式。

s = "one,,two,,three"
# 分割字符串并去除空字符串
parts = [part for part in s.split(",") if part]
print(parts)  # 输出: ['one', 'two', 'three']

使用正则表达式分割字符串

对于更复杂的分割规则，可以使用 re.split() 方法。

import re

s = "one,two;three:four"
# 使用正则表达式分割字符串
parts = re.split(r"[,;:]", s)
print(parts)  # 输出: ['one', 'two', 'three', 'four']

注意事项

• split() 方法不会修改原始字符串；它返回一个新的列表。

• 如果不需要指定分隔符，可以省略参数，这将分割字符串中的所有空白字符。

• split() 方法通常对分隔符是单个字符的情况工作得很好。如果需要使用多个字符或者更复杂的分隔模式，考虑使用 re.split()。

使用 split() 方法是处理字符串分割的标准方式，它简单、高效，并且适用于大多数基本需求。对于更高级的用例，re.split() 提供了强大的正则表达式支持。

按换行符（\r、\r\n、\n）分割字符串

在Python中，可以使用字符串的 splitlines() 方法按换行符分割字符串。splitlines() 方法会根据一个或多个换行符字符（\n、\r、\r\n）来分割字符串，并返回一个列表。

基本用法

s = "first line\r\nsecond line\nthird line\rlast line"
lines = s.splitlines()
print(lines)
# 输出:
# ['first line', 'second line', 'third line', 'last line']

自定义行为

splitlines() 方法可以接受一个名为 keepends 的可选参数。如果设置为 True，则方法返回的列表中的每个元素都会包含其原始的换行符。

s = "first line\r\nsecond line\nthird line\rlast line"
lines = s.splitlines(True)
print(lines)
# 输出:
# ['first line\r\n', 'second line\n', 'third line\r', 'last line']

使用 split() 方法

如果你想要使用 split() 方法来按换行符分割字符串，可以利用换行符作为分隔符：

s = "first line\nsecond line\r\nthird line\rlast line"
lines = s.split('\n')
print(lines)
# 输出: ['first line', 'second line\r\nthird line\rlast line']

lines = s.split('\r')
print(lines)
# 输出: ['first line\nsecond line\nthird line\rlast line']

注意，使用 split() 方法时，你可能需要检查字符串中的换行符是 \n、\r 还是 \r\n，并相应地调整代码。

注意事项

• splitlines() 是处理多平台文本（Windows、Unix、Mac）的一个很好的选择，因为它能够理解不同的换行符。

• 如果你想要确保能够处理所有可能的换行符情况，可能需要结合使用 split() 方法和一些条件逻辑。

• splitlines() 是Python 3中的特性，Python 2中使用 split() 方法是常见的做法。

通常情况下，splitlines() 方法是处理换行符分割字符串的首选方法，因为它简单、直观，并且能够处理多种换行符情况。

分割字符串为元组

在Python中，将字符串分割成元组可以通过使用字符串的 split() 方法来实现，然后将分割后的列表转换为元组。这种方法适用于任何需要将字符串分割成多个部分并存储为元组的场景。

基本用法

假设你有一个字符串并希望将其分割成多个子字符串，然后将这些子字符串存储在一个元组中：

s = "one,two,three"
# 使用逗号分割字符串
parts = s.split(",")
# 将列表转换为元组
tuple_parts = tuple(parts)
print(tuple_parts)  # 输出: ('one', 'two', 'three')

示例：分割并转换为元组

以下示例展示了如何将一个包含多个子字符串的字符串分割并转换为元组：

s = "hello,world,from,Python"
# 使用逗号分割字符串
parts = s.split(",")
# 转换为元组
greeting = tuple(parts)
print(greeting)  # 输出: ('hello', 'world', 'from', 'Python')

处理空格分割的字符串

如果你想分割一个由空格分隔的字符串，可以按照类似的方法操作：

s = "This is a sample string"
# 使用空格分割字符串
parts = s.split()
# 转换为元组
words = tuple(parts)
print(words)  # 输出: ('This', 'is', 'a', 'sample', 'string')

使用正则表达式分割字符串

对于更复杂的分割规则，可以使用 re.split() 方法，然后将结果转换为元组：

import re

s = "one,two;three:four"
# 使用正则表达式分割字符串
parts = re.split(r"[,;:]", s)
# 转换为元组
tuple_parts = tuple(parts)
print(tuple_parts)  # 输出: ('one', 'two', 'three', 'four')

注意事项

1. 分割后的空字符串：如果原始字符串中包含连续的分隔符，split() 方法会生成空字符串。例如，"one,,two".split(",") 会生成 ['one', '', 'two']。如果需要过滤这些空字符串，可以使用列表推导式：

   s = "one,,two"
   parts = [part for part in s.split(",") if part]
   tuple_parts = tuple(parts)
   print(tuple_parts)  # 输出: ('one', 'two')

2. 分割后的元组不可变：一旦将列表转换为元组，元组就是不可变的。这意味着你不能修改元组中的元素。

3. 性能考虑：对于大量数据的处理，使用 split() 方法和列表推导式通常足够高效。如果使用正则表达式，确保正则表达式的性能是可接受的。

通过这些方法，你可以轻松地将字符串分割成多个部分并存储为元组，这在处理数据和配置信息时非常有用。

验证字符串

验证字符串是否为纯字母

要验证一个字符串是否只包含字母字符，可以使用Python的内置方法或正则表达式。以下是一些常用的方法：

方法1：使用 isalpha() 方法

isalpha() 方法检查字符串是否只由字母组成，这意味着它不包含数字、符号、空格或任何非字母字符。

s = "HelloWorld"
is_alpha = s.isalpha()
print(is_alpha)  # 输出: True

s = "Hello123"
is_alpha = s.isalpha()
print(is_alpha)  # 输出: False

注意：isalpha() 会考虑字母字符的Unicode表示，因此它适用于多种语言。

方法2：使用正则表达式

使用正则表达式可以提供更灵活的字母验证方式，包括处理字符串开头或结尾可能有的空白字符。

import re

s = "HelloWorld"
match = re.fullmatch(r'[A-Za-z]+', s)
is_alpha = bool(match)
print(is_alpha)  # 输出: True

s = "Hello123"
match = re.fullmatch(r'[A-Za-z]+', s)
is_alpha = bool(match)
print(is_alpha)  # 输出: False

re.fullmatch 确保整个字符串符合正则表达式，[A-Za-z]+ 表示一个或多个字母字符。

方法3： ：使用 str.isnumeric() 方法（Python 3.4+）

isnumeric() 方法检查字符串是否只包含数字字符，但它也支持数字字符的Unicode表示。

s = "𝟣𝟢𝟣𝟤𝟥"
is_numeric = s.isnumeric()
print(is_numeric)  # 输出: True

验证字符串是否为字母和数字

要验证一个字符串是否仅由字母和数字组成，可以使用Python的内置字符串方法或正则表达式。以下是几种常用的方法：

方法1：使用 isalnum() 方法

isalnum() 方法检查字符串是否只包含字母和数字，这意味着它不包含空格、符号或其他非字母数字字符。

s = "Hello123"
is_alnum = s.isalnum()
print(is_alnum)  # 输出: True

s = "Hello 123"
is_alnum = s.isalnum()
print(is_alnum)  # 输出: False

方法2：使用正则表达式

使用正则表达式可以提供更灵活的验证方式，包括处理字符串开头或结尾可能有的空白字符。

import re

s = "Hello123"
match = re.fullmatch(r'[A-Za-z0-9]+', s)
is_alnum = bool(match)
print(is_alnum)  # 输出: True

s = "Hello123!"
match = re.fullmatch(r'[A-Za-z0-9]+', s)
is_alnum = bool(match)
print(is_alnum)  # 输出: False

re.fullmatch 确保整个字符串符合正则表达式，[A-Za-z0-9]+ 表示一个或多个字母或数字字符。

方法3：组合 isalpha() 和 isdigit()

如果你需要更细致的控制，可以组合使用 isalpha() 和 isdigit() 方法，检查字符串是否包含除字母和数字之外的字符。

def is_alphanumeric(s):
    return all(c.isalpha() or c.isdigit() for c in s)

s = "Hello123"
print(is_alphanumeric(s))  # 输出: True

s = "Hello123!"
print(is_alphanumeric(s))  # 输出: False

方法4：使用 str.isnumeric() 方法（Python 3.4+）

虽然 isnumeric() 主要用于数字字符，但也可以用于检查字母数字字符。

s = "𝟣𝟢𝟣𝟤𝟥"
is_numeric = s.isnumeric()
print(is_numeric)  # 输出: True

以下是一个完整的示例，展示了如何使用这些方法验证字符串是否仅由字母和数字组成：

import re

def is_alphanumeric(s):
    return all(c.isalpha() or c.isdigit() for c in s)

# 方法1：使用 isalnum()
s1 = "Hello123"
print(s1.isalnum())  # 输出: True

# 方法2：使用正则表达式
s2 = "Hello123!"
match = re.fullmatch(r'[A-Za-z0-9]+', s2)
print(bool(match))  # 输出: False

# 方法3：组合 isalpha() 和 isdigit()
s3 = "Hello123"
print(is_alphanumeric(s3))  # 输出: True

# 方法4：使用 isnumeric()（适用于 Unicode 字符）
s4 = "𝟣𝟢𝟣𝟤𝟥"
print(s4.isnumeric())  # 输出: True

注意事项

1. isalnum()：是最简单直接的方法，但它只适用于ASCII字符集。

2. 正则表达式：提供了最大的灵活性，可以定制以适应各种字母数字格式。

3. 组合方法：提供了更细致的控制，适用于需要处理特定字符集的情况。

4. isnumeric()：适用于Unicode字符集，但主要用于数字字符。

根据你的具体需求选择合适的方法。对于大多数基本需求，isalnum() 方法通常是最简单和最直接的选择。

验证字符串是否为数字（整数数字，非小数）

要验证一个字符串是否表示一个整数，可以使用以下几种方法：

方法1：使用 .isdigit() 方法

isdigit() 方法检查字符串是否只包含数字，并且是非空的。

s = "12345"
is_digit = s.isdigit()
print(is_digit)  # 输出: True

s = "123.45"
is_digit = s.isdigit()
print(is_digit)  # 输出: False

注意：isdigit() 只能检查正整数，不能用于负数或小数。

方法2：使用 str.isnumeric() 方法（Python 3.4+）

isnumeric() 方法检查字符串是否只包含数字字符，但它也支持数字字符的Unicode表示。

s = "𝟣𝟢𝟣𝟤𝟥"
is_numeric = s.isnumeric()
print(is_numeric)  # 输出: True

同样，这个方法只能检查正整数。

方法3：尝试转换为 int

尝试将字符串转换为整数。如果转换成功，则字符串是一个整数。

def is_integer(s):
    try:
        int(s)
        return True
    except ValueError:
        return False

# 示例
s = "12345"
print(is_integer(s))  # 输出: True

s = "-12345"
print(is_integer(s))  # 输出: True

s = "123.45"
print(is_integer(s))  # 输出: False

s = "abc123"
print(is_integer(s))  # 输出: False

这个方法可以处理正整数、负整数和整数部分。

方法4：使用正则表达式

使用正则表达式可以更灵活地定义整数的格式，包括正负号。

import re

def is_integer(s):
    return bool(re.match(r'^[-+]?\d+$', s))

# 示例
s = "12345"
print(is_integer(s))  # 输出: True

s = "-12345"
print(is_integer(s))  # 输出: True

s = "+12345"
print(is_integer(s))  # 输出: True

s = "123.45"
print(is_integer(s))  # 输出: False

s = "abc123"
print(is_integer(s))  # 输出: False

正则表达式 r'^[-+]?\d+$' 可以匹配包括正负号的整数。

注意事项

1. isdigit()：只适用于非负整数。

2. isnumeric()：适用于Unicode数字字符，但同样只适用于非负整数。

3. 尝试转换：可以处理正整数、负整数，是最常用的方法。

4. 正则表达式：提供了最大的灵活性，可以定制以适应各种数字格式。

根据你的具体需求选择合适的方法。如果需要验证包括负整数的情况，尝试转换为 int 或使用正则表达式是更好的选择。

验证字符串大小写

要验证字符串的大小写情况，可以使用Python的内置字符串方法：

1. isupper()：验证字符串是否全部大写

如果字符串中的所有字母都是大写，则返回 True，否则返回 False。

s = "HELLO"
print(s.isupper())  # 输出: True

s = "Hello"
print(s.isupper())  # 输出: False

1. islower()：验证字符串是否全部小写

如果字符串中的所有字母都是小写，则返回 True，否则返回 False。

s = "hello"
print(s.islower())  # 输出: True

s = "Hello"
print(s.islower())  # 输出: False

1. istitle()：验证字符串是否遵循标题大小写

如果字符串遵循了每个单词的首字母大写的规则，则返回 True，否则返回 False。

s = "Hello World"
print(s.istitle())  # 输出: True

s = "hELLO wORLD"
print(s.istitle())  # 输出: False

1. 组合检查是否含有大小写字母

如果你想检查字符串是否同时包含大小写字母，可以自定义一个函数：

def contains_upper_lower(s):
    return any(char.isupper() for char in s) and any(char.islower() for char in s)

s = "Hello World"
print(contains_upper_lower(s))  # 输出: True

s = "HELLO WORLD"
print(contains_upper_lower(s))  # 输出: False

s = "hello world"
print(contains_upper_lower(s))  # 输出: False

注意事项

• 如果字符串为空或没有字母，则 isupper() 和 islower() 都会返回 False。

• istitle() 对于非英语单词或包含专有名词的字符串可能不适用。

• 这些方法只考虑字母字符的大小写，会忽略数字、符号和空格等非字母字符。

使用这些方法，你可以根据需要验证字符串的大小写情况。

验证字符串是否为打印字符串

在编程中，"打印字符串"（Printable string）通常指的是只包含可打印字符的字符串。这包括字母、数字和一些标点符号及特殊字符，但不包括空格、制表符、换行符等空白字符，以及控制字符。

要验证一个字符串是否为打印字符串，可以使用Python标准库中的 string 模块，它定义了各种字符串常量，包括 printable，它是一个包含所有可打印ASCII字符的字符串。

使用 string.printable

import string

def is_printable(s):
    return all(char in string.printable for char in s)

s = "Hello, World!"
print(is_printable(s))  # 输出: True

s = "Hello,\nWorld!"
print(is_printable(s))  # 输出: False

在这个例子中，is_printable 函数检查字符串 s 中的每个字符是否都在 string.printable 中定义的可打印字符集合内。

使用正则表达式

另一种方法是使用正则表达式来检查字符串是否只包含可打印字符：

import re

def is_printable(s):
    return bool(re.fullmatch('[ -~]+', s))
    
s = "Hello, World!"
print(is_printable(s))  # 输出: True

s = "Hello,\nWorld!"
print(is_printable(s))  # 输出: False

在这个例子中，正则表达式 '[ -~]+' 匹配所有可打印的ASCII字符。字符集 [ -~] 包含了从空格 () 到 ~ 的所有可打印ASCII字符。

注意事项

• 可打印字符通常不包括任何非打印字符，如控制字符（如换行符 \n、回车符 \r、制表符 \t 等）。

• ASCII字符集定义了128个字符，包括95个可打印字符和33个控制字符（非打印字符）。

• 如果需要考虑Unicode字符（非ASCII字符），则需要相应地调整验证逻辑。

根据你的具体需求，你可以选择使用 string.printable 或正则表达式来验证字符串是否为打印字符串。

验证字符串是否有空格组成

要验证一个字符串是否由空格组成，包括只包含空格的字符串，可以使用Python的内置字符串方法 isspace()。此方法检查字符串是否只包含空白字符（如空格、制表符、换行符等）。

使用 isspace() 方法

def is_space(s):
    return s.isspace() and bool(s)

s = "     "
print(is_space(s))  # 输出: True

s = "Hello World"
print(is_space(s))  # 输出: False

s = ""  # 空字符串
print(is_space(s))  # 输出: False

在这个例子中，is_space 函数首先检查字符串 s 是否非空，然后使用 isspace() 方法检查字符串中的每个字符是否都是空白字符。

注意事项

• isspace() 方法如果应用于空字符串，将返回 False，因为它要求字符串至少有一个空白字符。

• 如果你的需求是检查字符串是否只包含普通空格字符（而不是所有类型的空白字符，如制表符或换行符），则需要使用不同的方法。

检查只包含普通空格

如果你需要检查字符串是否只包含普通空格（即字符 ' '），可以直接使用 all() 函数和条件表达式：

def is_only_spaces(s):
    return all(char == ' ' for char in s) and bool(s)

s = "     "
print(is_only_spaces(s))  # 输出: True

s = " \t   \n"
print(is_only_spaces(s))  # 输出: False

s = ""  # 空字符串
print(is_only_spaces(s))  # 输出: False

使用正则表达式

对于更复杂的空白字符检查，或者需要明确指定哪些字符被视为空白，可以使用正则表达式：

import re

def is_space(s):
    return bool(re.fullmatch(r'\s*', s))

def is_only_spaces(s):
    return bool(re.fullmatch(r' +', s))

s = "     "
print(is_space(s))  # 输出: True
print(is_only_spaces(s))  # 输出: True

s = " \t   \n"
print(is_space(s))  # 输出: True
print(is_only_spaces(s))  # 输出: False

s = ""  # 空字符串
print(is_space(s))  # 输出: False
print(is_only_spaces(s))  # 输出: False

在这个例子中，\s* 匹配任何空白字符（包括零个或多个），而 + 匹配一个或多个普通空格字符。

替换、对其、编码、大小写、去重

去除字符串中的空格和特殊字符

strip() 函数是一个非常有用的字符串方法，它用于移除字符串开始和结尾的特定字符。默认情况下，如果没有指定任何参数，strip() 会移除空白字符，这包括空格、制表符、换行符等。

s = "  Hello World!  "
clean_s = s.strip()
print(clean_s)  # 输出: "Hello World!"

自定义字符

strip() 方法可以接受一个参数，用于指定需要移除的字符集合。

s = "----Hello World!----"
clean_s = s.strip("-")
print(clean_s)  # 输出: "Hello World!"

在这个例子中，strip() 移除了字符串两端的所有破折号。

移除两端的特定字符

如果你想要移除字符串两端的特定字符，可以指定这些字符作为参数。

s = "abcHello World!cba"
clean_s = s.strip("abc")
print(clean_s)  # 输出: "Hello World!"

组合字符

可以组合多个字符进行移除。

s = "abcHello World!cba123"
clean_s = s.strip("abc123")
print(clean_s)  # 输出: "Hello World!"

注意事项

• strip() 只能移除字符串开始和结尾的字符。如果需要移除字符串中间的字符，需要使用其他方法，如 replace() 或正则表达式。

• 如果需要移除字符串一侧（开始或结尾）的字符，可以使用 lstrip() 或 rstrip()。

• strip() 不改变原始字符串，它返回一个新的字符串。

lstrip() 和 rstrip()

• lstrip() 用于移除字符串开始的字符。

• rstrip() 用于移除字符串结尾的字符。

s = "  Hello World!  "
clean_s_left = s.lstrip()  # 移除左侧空白
clean_s_right = s.rstrip()  # 移除右侧空白
print(clean_s_left)  # 输出: "Hello World!  "
print(clean_s_right)  # 输出: "  Hello World!"

字符串替换

字符串的替换可以通过内置的 replace() 方法来实现。此方法会返回一个新的字符串，在其中指定的旧字符串被替换为新字符串。

基本用法

s = "Hello World"
# 替换字符串
new_s = s.replace("World", "Python")
print(new_s)  # 输出: Hello Python

指定最大替换次数

replace() 方法还接受一个可选参数 count，用于指定最大的替换次数。

s = "Hello World, World!"
# 替换不超过两个"World"
new_s = s.replace("World", "Python", 2)
print(new_s)  # 输出: Hello Python, Python!

在这个例子中，只有前两个出现的 "World" 被替换为 "Python"。

使用正则表达式

对于更复杂的替换规则，可以使用 re.sub() 函数，它提供了使用正则表达式进行模式匹配和替换的功能。

python

import re

s = "Hello World, World!"
# 使用正则表达式替换
new_s = re.sub(r"World", "Python", s)
print(new_s)  # 输出: Hello Python, Python!

替换所有匹配的模式

如果你想替换所有匹配的模式，可以使用正则表达式中的 re.sub() 函数而不设置最大次数。

import re

s = "Hello World, World! Welcome to the World of Python."
# 替换所有"World"为"Python"
new_s = re.sub(r"World", "Python", s)
print(new_s)  # 输出: Hello Python, Python! Welcome to the Python of Python.

注意事项

• replace() 方法不会修改原始字符串，它返回一个新的字符串。

• replace() 方法适用于简单的替换任务，对于需要条件判断或更复杂模式匹配的替换，应该使用 re.sub()。

• re.sub() 可以处理复杂的模式替换，包括使用捕获组进行更精细的文本操作。

将tab符号（制表符）转换空格

在Python中，将制表符（Tab，通常表示为 \t）转换为空格可以通过字符串的 replace() 方法或正则表达式来实现。以下是两种常见的方法：

方法1：使用 replace() 方法

如果你知道文本中制表符的精确模式，或者你只是想替换所有的制表符为一个空格，可以直接使用 replace() 方法：

s = "Hello\tWorld!\tThis is a test."
# 将每个制表符替换为一个空格
new_s = s.replace("\t", " ")
print(new_s)  # 输出: Hello World! This is a test.

方法2：使用正则表达式

如果你需要将制表符替换为多个空格（例如，将每个制表符视为4个空格），可以使用 re.sub() 函数：

import re

s = "Hello\tWorld!\tThis is a test."
# 将每个制表符替换为四个空格
new_s = re.sub(r"\t", "    ", s)  # 注意四个空格
print(new_s)  # 输出: Hello    World!    This is a test.

将制表符转换为多个空格以保持对齐

有时候，保持文本的对齐是重要的，这时你可以计算制表符的宽度：

import re

def expand_tabs(s, tab_width=4):
    return re.sub(r"\t", " " * tab_width, s)

s = "Hello\tWorld!\tThis\tIs a\tTest."
# 将每个制表符替换为四个空格
new_s = expand_tabs(s)
print(new_s)
# 输出:
# Hello    World!    This        Is a       Test.

注意事项

• replace() 方法直接替换字符，适用于已知每个制表符应该被替换为单个空格的情况。

• 使用正则表达式 re.sub() 可以更灵活地处理制表符的替换，特别是当你需要将制表符替换为多个空格以保持文本对齐时。

• tab_width 参数可以根据需要调整，通常设置为4或8，这是文本编辑器中常见的制表符宽度。

字符串对其填充

在Python中，对字符串进行对齐填充通常是为了美观或者为了满足特定的格式要求。Python提供了几种方法来实现字符串的对齐填充：

使用字符串的 ljust()、rjust() 和 center() 方法

这些方法可以用于对字符串进行左对齐、右对齐和居中对齐，并使用指定的字符（默认为空格）填充至特定的宽度。

s = "Hello"

# 左对齐，总共10个字符宽度
left_justified = s.ljust(10)
print(left_justified)  # 输出: 'Hello     '

# 右对齐，总共10个字符宽度
right_justified = s.rjust(10)
print(right_justified)  # 输出: '     Hello'

# 居中对齐，总共10个字符宽度
centered = s.center(10)
print(centered)  # 输出: '   Hello   '

使用格式化字符串（f-string）

格式化字符串提供了一种更灵活的方式来对齐文本。

s = "Hello"

# 左对齐
left_justified = f"{s:<10}"
print(left_justified)  # 输出: 'Hello     '

# 右对齐
right_justified = f"{s:>10}"
print(right_justified)  # 输出: '     Hello'

# 居中对齐
centered = f"{s:^10}"
print(centered)  # 输出: '   Hello   '

使用 str.format() 方法

str.format() 方法同样提供了对齐的选项。

s = "Hello"

# 左对齐
left_justified = "{:<10}".format(s)
print(left_justified)  # 输出: 'Hello     '

# 右对齐
right_justified = "{:>10}".format(s)
print(right_justified)  # 输出: '     Hello'

# 居中对齐
centered = "{:^10}".format(s)
print(centered)  # 输出: '   Hello   '

使用 textwrap 模块

对于更复杂的对齐需求，比如多行文本的对齐，可以使用 textwrap 模块。

import textwrap

text = "Hello World\nThis is a test\nAligned text"
wrapped_text = textwrap.fill(text, width=20)
print(wrapped_text)

这会将每行文本折行，使得每行不超过20个字符宽度。

注意事项

• 默认情况下，ljust()、rjust()、center()、f-string和str.format()方法使用空格进行填充。你可以指定其他字符作为填充字符。

• 对于多行文本，使用空格进行居中对齐可能无法达到完美的居中效果，因为它不会考虑单词的边界。

• textwrap 模块提供了更多用于文本对齐和折行的高级功能。

根据你的具体需求，可以选择最适合的方法来进行字符串的对齐填充。

字符串前面填充0添加编号

在Python中，经常需要在字符串前面填充0以添加编号，例如生成格式化的编号或文件名。这可以通过字符串的 zfill() 方法或使用格式化字符串来实现。

方法1：使用 zfill() 方法

zfill() 方法可以为字符串填充0，直到达到指定的宽度。

s = "5"
# 填充0直到字符串长度为3
padded_s = s.zfill(3)
print(padded_s)  # 输出: "005"

方法2：使用字符串格式化

可以使用 str.format() 方法或f-string来实现相同的效果。

使用 str.format() 方法

s = "5"
# 填充0直到字符串长度为3
padded_s = "{:03}".format(s)
print(padded_s)  # 输出: "005"

使用 f-string

s = "5"
# 填充0直到字符串长度为3
padded_s = f"{s:03}"
print(padded_s)  # 输出: "005"

方法3：使用 rjust() 方法

rjust() 方法也可以实现类似的效果，它通过在左侧填充字符来确保字符串达到指定的宽度。

s = "5"
# 填充0直到字符串长度为3
padded_s = s.rjust(3, '0')
print(padded_s)  # 输出: "005"

示例：为一系列编号添加前导0

假设你有一个编号列表，需要为每个编号前面填充0以达到固定的宽度。

使用 zfill()

numbers = [1, 5, 12, 34, 78]
padded_numbers = [str(num).zfill(3) for num in numbers]
print(padded_numbers)  # 输出: ['001', '005', '012', '034', '078']

使用 str.format()

numbers = [1, 5, 12, 34, 78]
padded_numbers = ["{:03}".format(num) for num in numbers]
print(padded_numbers)  # 输出: ['001', '005', '012', '034', '078']

使用 f-string

numbers = [1, 5, 12, 34, 78]
padded_numbers = [f"{num:03}" for num in numbers]
print(padded_numbers)  # 输出: ['001', '005', '012', '034', '078']

注意事项

1. zfill()：只能填充0，并且从字符串的左侧开始填充。

2. str.format() 和 f-string：可以指定填充的字符，并且可以更灵活地控制格式。

3. rjust()：可以指定任意字符进行填充，并且也可以控制填充的位置。

选择哪种方法取决于你的具体需求和场景。对于简单的前导0填充，zfill() 是一个直观的选择。对于更灵活的填充需求，str.format() 或 f-string 更加强大。

编码与编码字符串

字符串大小写转换

在Python中，可以使用字符串的内置方法来转换字符串的大小写：

1. upper() — 转换为大写

将字符串中的所有小写字母转换为大写字母。

s = "Hello World"
upper_s = s.upper()
print(upper_s)  # 输出: "HELLO WORLD"

1. lower() — 转换为小写

将字符串中的所有大写字母转换为小写字母。

s = "HELLO WORLD"
lower_s = s.lower()
print(lower_s)  # 输出: "hello world"

1. capitalize() — 首字母大写

将字符串的第一个字母转换为大写，其余字母转换为小写。

s = "hello world"
capitalized_s = s.capitalize()
print(capitalized_s)  # 输出: "Hello world"

1. title() — 标题式大小写

将字符串中每个单词的首字母转换为大写。

s = "hello world"
title_s = s.title()
print(title_s)  # 输出: "Hello World"

1. swapcase() — 大小写转换

将字符串中的大写字母转换为小写字母，小写字母转换为大写字母。

s = "Hello World"
swapcase_s = s.swapcase()
print(swapcase_s)  # 输出: "hELLO wORLD"

示例

s = "Hello World"

# 转换为大写
upper_s = s.upper()
print(upper_s)  # HELLO WORLD

# 转换为小写
lower_s = s.lower()
print(lower_s)  # hello world

# 首字母大写
capitalized_s = s.capitalize()
print(capitalized_s)  # Hello world

# 每个单词首字母大写
title_s = s.title()
print(title_s)  # Hello World

# 交换大小写
swapcase_s = s.swapcase()
print(swapcase_s)  # hELLO wORLD

注意事项

• 字符串是不可变的，所以这些方法都会返回一个新的字符串。

• capitalize() 只能用于将字符串的第一个字母大写，其余小写，如果需要每个单词首字母大写，请使用 title()。

• title() 会将每个单词的首字母大写，但要注意它可能会误将某些非字母字符后的字母也作为单词首字母来处理。

这些方法可以满足大多数大小写转换的需求。

字符串去重

在Python中，对字符串去重通常指的是去除字符串中重复的字符，使每个字符只出现一次。这可以通过使用集合（set）来实现，因为集合不允许元素重复。以下是几种常见的方法：

方法1：使用集合

将字符串转换为集合可以去除重复的字符，然后再转换回字符串。

s = "hello world"
# 转换为集合去重，然后转换回字符串
unique_chars = ''.join(set(s))
print(unique_chars)  # 输出: 'helloworld'

注意：这种方法会丢失原始字符串中字符的顺序。

方法2：使用有序的数据结构

如果你需要保留字符的原始顺序，可以使用一个辅助的数据结构来跟踪已经看到的字符。

s = "hello world"
seen = set()
unique_chars = ''
for char in s:
    if char not in seen:
        seen.add(char)
        unique_chars += char
print(unique_chars)  # 输出: 'helowrd'

方法3：使用 dict.fromkeys()

从Python 3.7开始，字典保持插入顺序，所以可以使用 dict.fromkeys() 来去重并保留顺序。

s = "hello world"
unique_chars = ''.join(dict.fromkeys(s))
print(unique_chars)  # 输出: 'helowrd'

方法4：使用 OrderedDict

在Python 3.6之前的版本中，可以使用 collections.OrderedDict 来去重并保留顺序。

from collections import OrderedDict

s = "hello world"
unique_chars = ''.join(OrderedDict.fromkeys(s))
print(unique_chars)  # 输出: 'helowrd'

注意事项

• 使用集合去重的方法会丢失原始字符串中字符的顺序。

• 如果需要保留顺序，可以使用有序的数据结构（如列表和集合的组合，或 dict.fromkeys()）。

• dict.fromkeys() 和 OrderedDict.fromkeys() 不仅可以去重，还可以保持元素的第一次出现的顺序。

根据你的具体需求（是否需要保留顺序），选择合适的方法进行字符串去重。

字符串格式化处理操作

格式化十进制整数

格式化浮点数

格式化百分数

生成数据编号

格式化科学记数法

格式化金额

进制转换

格式化日期与时间

列表操作

创建、转换、获取、遍历

列表创建与复制

在Python中，创建列表（list）是一种基本且灵活的数据结构操作。列表可以包含不同类型的元素，并且可以进行动态地增长和收缩。以下是一些创建列表的常见方式：

1. 直接定义

直接定义是创建列表最直观的方法。

# 创建一个数字列表
numbers = [1, 2, 3, 4, 5]

# 创建一个包含各种类型元素的列表
mixed_list = [1, "hello", 3.14, True]

# 创建一个空列表
empty_list = []

1. 使用列表推导式

列表推导式提供了一种优雅的方式来创建列表，特别是基于另一个列表或任何可迭代对象。

# 使用列表推导式创建一个平方列表
squares = [x**2 for x in range(10)]

# 创建一个包含特定条件元素的列表
even_numbers = [x for x in range(20) if x % 2 == 0]

1. 使用 list() 构造函数

list() 可以用来将其他可迭代对象转换成列表。

# 从字符串创建列表
list_from_string = list("hello")
print(list_from_string)  # 输出: ['h', 'e', 'l', 'l', 'o']

# 从范围创建列表
numbers = list(range(5))
print(numbers)  # 输出: [0, 1, 2, 3, 4]

1. 使用 range() 和列表推导式

当需要创建数字列表时，range() 结合列表推导式非常有用。

# 创建一个包含0到9的列表
numbers = [x for x in range(10)]

# 创建一个步长为2的数字列表
evens = [x for x in range(0, 20, 2)]

1. 复制列表

当需要基于现有列表创建一个新列表时，可以通过复制来实现。

# 创建一个新列表，基于现有列表
original_list = [1, 2, 3]
new_list = original_list.copy()

# 使用切片复制
new_list_slice = original_list[:]

1. 复合列表字面量

创建包含多个子列表的列表。

# 创建一个二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

注意事项

• 列表是可变的，这意味着你可以在列表中添加、删除或更改元素。

• 列表可以包含不同类型的元素，这使得它们非常灵活。

• 使用列表推导式时，应注意其可能对性能的影响，特别是在处理大型数据集时。

通过这些方法，你可以根据不同的需求和场景灵活地创建列表。

列表转换

在Python中，不同类型的数据结构可以很容易地转换成列表：

1、字符串转换成列表

可以使用 list() 函数将字符串转换成列表。

s = "hello"
s_list = list(s)
print(s_list)  # 输出: ['h', 'e', 'l', 'l', 'o']

2、元组转换成列表

同样地，使用 list() 函数可以将元组转换成列表。

t = (1, 2, 3)
t_list = list(t)
print(t_list)  # 输出: [1, 2, 3]

3、range对象转换成列表

使用 list() 函数也可以将 range 对象转换成列表。

r = range(5)
r_list = list(r)
print(r_list)  # 输出: [0, 1, 2, 3, 4]

4、字典转换成列表

字典是一个包含键值对的数据结构，但列表是单一元素的数据结构。因此，你需要决定将字典的哪部分转换成列表：键、值还是键值对。

• 转换成包含所有键的列表：

  d = {'a': 1, 'b': 2, 'c': 3}
  d_keys = list(d.keys())
  print(d_keys)  # 输出: ['a', 'b', 'c']

• 转换成包含所有值的列表：

  d_values = list(d.values())
  print(d_values)  # 输出: [1, 2, 3]

• 转换成包含所有键值对的列表：

  d_items = list(d.items())
  print(d_items)  # 输出: [('a', 1), ('b', 2), ('c', 3)]

或者，如果你想要将字典转换成包含字典的列表（例如，列表中的每个元素都是一个字典）：

list_of_dicts = [d]
print(list_of_dicts)  # 输出: [{'a': 1, 'b': 2, 'c': 3}]

注意事项

• 使用 list() 函数是最常用和最直接的转换方法。

• 当从字典转换时，需要考虑是转换键、值还是键值对。

• 列表是可变的，所以转换成列表后，你可以添加、删除或更改元素。

• 列表推导式提供了一种更灵活的方式来创建列表，允许在转换过程中应用条件和表达式。

根据你的具体需求选择合适的转换方法。

列表元素获取

在Python中，获取列表中的元素可以通过索引（下标）来实现。列表的索引从0开始计数。以下是一些基本的方法来获取列表中的元素：

1. 通过索引获取元素

你可以通过具体的索引位置来访问列表中的元素。

# 定义一个列表
my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# 获取列表中的第一个元素
first_fruit = my_list[0]
print(first_fruit)  # 输出: 'apple'

# 获取第三个元素
third_fruit = my_list[2]
print(third_fruit)  # 输出: 'cherry'

1. 通过负索引获取元素

使用负索引可以倒序访问列表元素，其中 -1 是最后一个元素的索引。

# 获取列表中的最后一个元素
last_fruit = my_list[-1]
print(last_fruit)  # 输出: 'elderberry'

# 获取倒数第二个元素
second_last_fruit = my_list[-2]
print(second_last_fruit)  # 输出: 'date'

1. 通过切片获取多个元素

切片可以获取列表的一部分。

# 获取从第二个元素到第三个元素（不包括第四个元素）
part_list = my_list[1:3]
print(part_list)  # 输出: ['banana', 'cherry']

# 获取从第一个元素到第三个元素
another_part_list = my_list[:3]
print(another_part_list)  # 输出: ['apple', 'banana', 'cherry']

# 获取从第三个元素到列表末尾
last_two_fruit = my_list[2:]
print(last_two_fruit)  # 输出: ['cherry', 'date', 'elderberry']

1. 通过循环遍历列表

如果你想获取列表中的每个元素，可以使用循环。

# 遍历列表中的每个元素
for fruit in my_list:
    print(fruit)

1. 通过列表的 index() 方法获取元素索引

如果需要获取某个元素在列表中的索引，可以使用 index() 方法。

# 获取 'cherry' 的索引
cherry_index = my_list.index('cherry')
print(cherry_index)  # 输出: 2

1. 使用 enumerate 同时获取索引和元素

enumerate 函数可以同时获取列表中元素的索引和值。

# 使用 enumerate 获取索引和元素
for index, fruit in enumerate(my_list):
    print(index, fruit)

注意事项

• 索引是从0开始的，切片是从1开始的。

• 切片操作不会修改原始列表，它返回一个新的列表。

• 尝试访问不存在的索引会导致 IndexError 错误。

• 负索引和切片可以非常方便地进行列表的倒序和部分元素访问。

通过这些方法，你可以灵活地获取列表中的元素。

遍历列表

在Python中，遍历列表是一个常见的操作，可以使用几种不同的方法来实现。以下是一些常用的遍历列表的方法：

1. 使用 for 循环

最基本的遍历列表的方法是使用 for 循环，它将逐个元素地遍历列表。

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用 for 循环遍历列表
for fruit in fruits:
    print(fruit)

1. 使用 while 循环和索引

你也可以使用 while 循环和索引来遍历列表。

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用 while 循环和索引遍历列表
index = 0
while index < len(fruits):
    print(fruits[index])
    index += 1

1. 使用 enumerate 函数

enumerate 函数可以在遍历列表时同时获取元素的索引和值。

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用 enumerate 遍历列表
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")

1. 使用 iter() 函数和生成器

可以使用 iter() 函数和生成器来遍历列表。

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用 iter() 函数和生成器遍历列表
iterator = iter(fruits)
for fruit in iterator:
    print(fruit)

1. 使用列表推导式

列表推导式通常用于生成新的列表，但也可以用于遍历列表。

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用列表推导式遍历列表
[print(fruit) for fruit in fruits]

1. 使用 next() 函数和生成器

可以结合使用 next() 函数和生成器来遍历列表。

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用 next() 函数和生成器遍历列表
iterator = iter(fruits)
while True:
    try:
        print(next(iterator))
    except StopIteration:
        break

注意事项

• for 循环是遍历列表最简单和最直观的方法。

• 使用 while 循环和索引可以更灵活地控制遍历过程，例如在满足特定条件时跳过某些元素。

• enumerate 函数在需要索引和值的情况下非常有用。

• 列表推导式主要用于生成新的列表，但也可以用来执行简单的遍历操作。

• 使用 iter() 和 next() 函数可以更灵活地控制遍历过程，特别是在处理大型数据集时。

根据你的具体需求和场景，选择合适的方法来遍历列表。

添加、删除、排序及统计

列表的添加

在Python中，向列表中添加元素可以通过多种方法实现。以下是一些常用的方法：

1. 使用 append() 方法

append() 方法将一个元素添加到列表的末尾。

# 定义一个列表
my_list = [1, 2, 3]
# 使用 append() 添加元素
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

1. 使用 insert() 方法

insert() 方法可以在指定位置插入一个元素。

# 定义一个列表
my_list = [1, 2, 4]
# 使用 insert() 在指定位置添加元素
my_list.insert(2, 3)  # 在索引2的位置插入元素3
print(my_list)  # 输出: [1, 2, 3, 4]

1. 使用 extend() 方法

extend() 方法用于将一个列表中的所有元素添加到另一个列表的末尾。

# 定义两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 extend() 合并列表
list1.extend(list2)
print(list1)  # 输出: [1, 2, 3, 4, 5, 6]

也可以使用 extend() 来添加多个元素：

# 定义一个列表
my_list = [1, 2, 3]
# 使用 extend() 添加多个元素
my_list.extend([4, 5])
print(my_list)  # 输出: [1, 2, 3, 4, 5]

1. 使用 + 操作符

可以使用 + 操作符将两个列表合并。

# 定义两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 + 操作符合并列表
new_list = list1 + list2
print(new_list)  # 输出: [1, 2, 3, 4, 5, 6]

1. 使用 * 操作符（扩展列表元素）

虽然不是添加元素，但是 * 操作符可以用来重复列表中的元素。

# 定义一个列表
my_list = [1, 2, 3]
# 使用 * 操作符重复列表元素
new_list = my_list * 2
print(new_list)  # 输出: [1, 2, 3, 1, 2, 3]

示例代码

以下是一些示例代码：

# 定义一个列表
my_list = [1, 2, 3]

# 使用 append() 添加元素
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

# 使用 insert() 在指定位置添加元素
my_list.insert(2, 'inserted')
print(my_list)  # 输出: [1, 2, 'inserted', 3, 4]

# 使用 extend() 添加多个元素
my_list.extend([5, 6])
print(my_list)  # 输出: [1, 2, 'inserted', 3, 4, 5, 6]

# 使用 + 操作符合并列表
new_list = my_list + [7, 8, 9]
print(new_list)  # 输出: [1, 2, 'inserted', 3, 4, 5, 6, 7, 8, 9]

# 使用 * 操作符重复列表元素
repeated_list = [0] * 3
print(repeated_list)  # 输出: [0, 0, 0]

注意事项

1. append()：用于在列表末尾添加一个元素。

2. insert()：用于在指定位置插入一个元素。

3. extend()：用于将一个列表中的所有元素添加到另一个列表的末尾。

4. + 操作符：用于合并两个列表。

5. * 操作符：用于重复列表中的元素。

选择哪种方法取决于你的具体需求和场景。对于大多数基本需求，append() 和 extend() 是最常用的方法。

列表的删除

在Python中，删除列表中的元素可以通过多种方法实现。以下是一些常用的方法：

1. 使用 remove() 方法

remove() 方法用于删除列表中第一个匹配的指定值。如果该值不存在，会引发 ValueError。

my_list = [1, 2, 3, 4, 2]
my_list.remove(2)  # 删除第一个出现的2
print(my_list)  # 输出: [1, 3, 4, 2]

1. 使用 pop() 方法

pop() 方法用于删除指定索引位置的元素，并返回该元素。如果不指定索引，默认删除并返回最后一个元素。

my_list = [1, 2, 3, 4]
last_element = my_list.pop()  # 删除并返回最后一个元素
print(last_element)  # 输出: 4
print(my_list)  # 输出: [1, 2, 3]

# 删除并返回索引为1的元素
second_element = my_list.pop(1)
print(second_element)  # 输出: 2
print(my_list)  # 输出: [1, 3]

1. 使用 del 语句

del 语句可以删除指定索引的元素，或者删除整个列表。

my_list = [1, 2, 3, 4]
del my_list[1]  # 删除索引为1的元素
print(my_list)  # 输出: [1, 3, 4]

# 删除整个列表
del my_list
# print(my_list)  # 会引发 NameError，因为 my_list 不再存在

1. 使用 clear() 方法

clear() 方法用于删除列表中的所有元素。

my_list = [1, 2, 3, 4]
my_list.clear()
print(my_list)  # 输出: []

1. 使用列表推导式

如果你想根据某些条件删除多个元素，可以使用列表推导式创建一个新列表。

my_list = [1, 2, 3, 4, 5]
# 删除所有偶数
filtered_list = [x for x in my_list if x % 2 != 0]
print(filtered_list)  # 输出: [1, 3, 5]

示例代码

以下是一些示例代码，展示了如何使用这些方法删除列表中的元素：

# 定义一个列表
my_list = [1, 2, 3, 4, 2]

# 使用 remove() 删除元素
my_list.remove(2)
print(my_list)  # 输出: [1, 3, 4, 2]

# 使用 pop() 删除最后一个元素
last_element = my_list.pop()
print(last_element)  # 输出: 2
print(my_list)  # 输出: [1, 3, 4]

# 使用 del 删除指定索引的元素
del my_list[1]
print(my_list)  # 输出: [1, 4]

# 使用 clear() 删除所有元素
my_list.clear()
print(my_list)  # 输出: []

# 使用列表推导式删除特定元素
my_list = [1, 2, 3, 4, 5]
filtered_list = [x for x in my_list if x % 2 != 0]
print(filtered_list)  # 输出: [1, 3, 5]

注意事项

• remove() 方法只会删除第一个匹配的元素，如果需要删除所有匹配的元素，可以使用循环。

• pop() 方法会返回被删除的元素，适合在需要使用被删除元素的情况下使用。

• del 可以删除特定索引的元素或整个列表。

• clear() 方法用于清空列表。

• 列表推导式是一种优雅的方式来创建新列表，同时过滤掉不需要的元素。

列表的排序

在Python中，可以使用列表的 sort() 方法或者内置函数 sorted() 来对列表进行排序。

1. 使用列表的 sort() 方法

sort() 方法会就地修改列表，对列表中的元素进行排序。

# 定义一个数字列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# 使用 sort() 方法对列表进行排序
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9]

sort() 方法还可以接受参数来控制排序行为：

• key 参数：指定一个函数，用于在比较元素前先对元素进行转换。

• reverse 参数：布尔值，控制排序是升序还是降序。

# 定义一个字符串列表
fruits = ['banana', 'apple', 'cherry']
# 使用 sort() 方法按字母顺序排序
fruits.sort(key=str.lower)
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 6, 5, 5, 4, 3, 2, 1, 1]

1. 使用 sorted() 函数

sorted() 函数会返回一个新的列表，原列表不会被修改。

# 定义一个数字列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# 使用 sorted() 函数对列表进行排序
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9]

和 sort() 方法一样，sorted() 函数也接受 key 和 reverse 参数。

# 定义一个字符串列表
fruits = ['banana', 'apple', 'cherry']
# 使用 sorted() 函数按字母顺序排序
sorted_fruits = sorted(fruits, key=str.lower)
print(sorted_fruits)  # 输出: ['apple', 'banana', 'cherry']

1. 对复杂数据结构排序

当列表中包含复杂数据结构，如元组或字典时，可以通过 key 参数指定排序的依据。

# 定义一个包含元组的列表
pairs = [(1, 'one'), (3, 'three'), (2, 'two')]
# 按元组的第一个元素排序
pairs.sort(key=lambda x: x[0])
print(pairs)  # 输出: [(1, 'one'), (2, 'two'), (3, 'three')]

# 定义一个包含字典的列表
dict_list = [{'name': 'John', 'age': 45}, {'name': 'Diana', 'age': 32}]
# 按字典的 'age' 键排序
dict_list.sort(key=lambda x: x['age'])
print(dict_list)  # 输出: [{'name': 'Diana', 'age': 32}, {'name': 'John', 'age': 45}]

反转列表

1. 使用 reverse() 方法

reverse() 方法会就地修改列表，将列表中的元素顺序反转。

# 定义一个列表
my_list = [1, 2, 3, 4, 5]
# 使用 reverse() 方法反转列表
my_list.reverse()
print(my_list)  # 输出: [5, 4, 3, 2, 1]

1. 使用切片

切片可以用来创建一个反向的列表副本。

# 定义一个列表
my_list = [1, 2, 3, 4, 5]
# 使用切片反转列表
reversed_list = my_list[::-1]
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

这种方法不会修改原始列表，而是返回一个新的反转后的列表。

1. 使用 reversed() 函数

reversed() 函数返回一个反转的迭代器，你可以用它来创建一个反转的列表副本。

# 定义一个列表
my_list = [1, 2, 3, 4, 5]
# 使用 reversed() 函数反转列表
reversed_list = list(reversed(my_list))
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

同样地，这种方法也不会修改原始列表。

1. 使用 for 循环

虽然不是最优雅的方法，但可以使用 for 循环来手动反转列表。

# 定义一个列表
my_list = [1, 2, 3, 4, 5]
# 创建一个空列表来存储反转后的元素
reversed_list = []
for item in my_list:
    reversed_list.insert(0, item)
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

1. 使用递归

虽然通常不推荐使用递归来反转列表（因为列表可能会很大，导致递归深度过大），但这是一种理论上的方法。

# 定义一个列表
my_list = [1, 2, 3, 4, 5]

def reverse_list_recursive(L):
    if len(L) == 0:
        return L
    return reverse_list_recursive(L[1:]) + [L[0]]

reversed_list = reverse_list_recursive(my_list)
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

注意事项

• sort() 方法会就地修改列表，而 sorted() 函数会返回一个新的列表。

• 可以通过 key 参数指定排序的依据，例如，可以用于实现自定义对象的排序。

• reverse=True 可用于实现降序排序。

• 排序默认是稳定的，相同元素的相对顺序会被保持。

根据你的具体需求选择合适的方法进行列表排序。

列表的查找统计

在Python中，对列表进行查找和统计元素出现的次数有几种常用的方法：

1. 使用 count() 方法

列表的 count() 方法可以统计某个元素在列表中出现的次数。

# 定义一个列表
my_list = [1, 2, 2, 3, 3, 3, 4]
# 统计元素2出现的次数
count_of_2 = my_list.count(2)
print(count_of_2)  # 输出: 2

1. 使用 index() 方法与循环

如果你需要找到某个元素第一次或所有出现的位置，可以使用 index() 方法结合循环。

# 定义一个列表
my_list = ['apple', 'banana', 'cherry', 'apple', 'banana']
# 查找元素'apple'第一次出现的位置
index_of_apple = my_list.index('apple')
print(index_of_apple)  # 输出: 0

# 查找元素'apple'所有出现的位置
indexes_of_apple = [index for index, element in enumerate(my_list) if element == 'apple']
print(indexes_of_apple)  # 输出: [0, 3]

1. 使用 in 关键字

要检查列表中是否包含某个元素，可以使用 in 关键字。

# 定义一个列表
my_list = [1, 2, 3, 4, 5]
# 检查元素3是否在列表中
contains_three = 3 in my_list
print(contains_three)  # 输出: True

1. 使用列表推导式

列表推导式可以用来查找满足特定条件的元素。

# 定义一个列表
my_list = [1, 2, 2, 3, 3, 3, 4]
# 查找所有等于2的元素
twos = [element for element in my_list if element == 2]
print(twos)  # 输出: [2, 2]

1. 使用 collections.Counter

如果你需要统计列表中所有元素的出现次数，可以使用 collections 模块的 Counter 类。

from collections import Counter

# 定义一个列表
my_list = ['apple', 'banana', 'cherry', 'apple', 'banana']
# 使用 Counter 统计每个元素的出现次数
count = Counter(my_list)
print(count)  # 输出: Counter({'apple': 2, 'banana': 2, 'cherry': 1})

示例代码

以下是一些示例代码：

# 定义一个列表
my_list = [1, 2, 2, 3, 3, 3, 4]

# 使用 count() 方法统计元素出现的次数
count_of_2 = my_list.count(2)
print(count_of_2)  # 输出: 2

# 使用 index() 方法查找元素第一次出现的位置
index_of_1 = my_list.index(1)
print(index_of_1)  # 输出: 0

# 使用 in 关键字检查元素是否存在于列表中
contains_4 = 4 in my_list
print(contains_4)  # 输出: True

# 使用列表推导式查找满足条件的元素
evens = [element for element in my_list if element % 2 == 0]
print(evens)  # 输出: [2, 2, 4]

# 使用 collections.Counter 统计所有元素的出现次数
from collections import Counter
counter = Counter(my_list)
print(counter)  # 输出: Counter({2: 2, 3: 3, 1: 1, 4: 1})

注意事项

• count() 方法只能统计一个元素的出现次数。

• index() 方法只能找到元素第一次出现的位置，如果要找到所有位置，需要使用列表推导式结合 enumerate。

• in 关键字可以用来检查元素是否存在于列表中。

• 列表推导式可以用来查找满足特定条件的元素。

• collections.Counter 是一个方便的工具，可以快速统计列表中所有元素的出现次数。

根据你的具体需求选择合适的方法进行列表的查找和统计。

元组操作

元组定义

在Python中，元组（tuple）是一个不可变的序列类型，用于存储不同的值。元组一旦创建，其内容就不能被修改，这意味着元组中的元素是只读的。以下是定义元组的一些常见方式：

1. 使用圆括号 ()

定义元组时，可以使用圆括号 ()，这是最常见的方式。

# 定义一个元组
my_tuple = (1, 2, 3, 4)
print(my_tuple)  # 输出: (1, 2, 3, 4)

# 定义一个单元素元组
single_element_tuple = (1,)
print(single_element_tuple)  # 输出: (1,)

注意：如果元组中只有一个元素，需要在该元素后面加上逗号 ,，以避免语法上的歧义。

1. 使用逗号 ,

也可以在没有圆括号的情况下，仅通过逗号 , 来定义元组。

# 定义一个元组
my_tuple = 1, 2, 3, 4
print(my_tuple)  # 输出: (1, 2, 3, 4)

1. 使用 tuple() 函数

tuple() 函数可以将其他可迭代对象转换为元组。

# 使用 tuple() 函数定义一个元组
my_tuple = tuple([1, 2, 3, 4])
print(my_tuple)  # 输出: (1, 2, 3, 4)

# 从字符串创建元组
my_tuple_from_string = tuple('hello')
print(my_tuple_from_string)  # 输出: ('h', 'e', 'l', 'l', 'o')

1. 创建空元组

可以定义一个空元组，用于后续添加元素或作为函数的返回值。

# 定义一个空元组
empty_tuple = ()
print(empty_tuple)  # 输出: ()

# 或者使用 tuple() 函数创建空元组
empty_tuple = tuple()
print(empty_tuple)  # 输出: ()

示例代码

以下是一些示例代码，展示了如何定义元组：

# 使用圆括号定义元组
my_tuple = (1, 2, 3, 4)
print(my_tuple)  # 输出: (1, 2, 3, 4)

# 定义一个单元素元组
single_element_tuple = (1,)
print(single_element_tuple)  # 输出: (1,)

# 使用逗号定义元组
my_tuple = 1, 2, 3, 4
print(my_tuple)  # 输出: (1, 2, 3, 4)

# 使用 tuple() 函数定义元组
my_tuple = tuple([1, 2, 3, 4])
print(my_tuple)  # 输出: (1, 2, 3, 4)

# 从字符串创建元组
my_tuple_from_string = tuple('hello')
print(my_tuple_from_string)  # 输出: ('h', 'e', 'l', 'l', 'o')

# 定义一个空元组
empty_tuple = ()
print(empty_tuple)  # 输出: ()

注意事项

• 元组是不可变的，所以一旦创建就不能修改其内容。

• 元组可以用来存储不同类型的元素，但通常用于存储同类型的元素。

• 元组可以作为字典的键，因为它们是不可变的。

• 元组可以使用索引和切片操作来访问其元素，类似于列表。

元组是一种常用的数据结构，适用于需要确保数据不被修改的场景。

元组的切片、查找、获取元素、删除等操作与列表类似

字典操作

创建、转换、遍历、获取、删除

创建字典

在Python中，字典（dictionary）是一种内置的数据结构，用于存储关联唯一的键（key）和值（value）的数据。字典是可变的，这意味着可以在创建后修改其内容。

以下是一些创建字典的常见方式：

1. 使用花括号 {}

字典可以使用花括号 {} 定义，其中键值对以逗号分隔。

# 使用花括号定义一个字典
my_dict = {'key1': 'value1', 'key2': 'value2'}
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

1. 使用 dict() 函数

dict() 函数可以将其他可迭代的键值对序列转换成字典。

# 使用 dict() 函数定义一个字典
my_dict = dict(key1='value1', key2='value2')
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 从列表的元组创建字典
list_of_tuples = [('key1', 'value1'), ('key2', 'value2')]
my_dict = dict(list_of_tuples)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

1. 使用字典推导式

字典推导式提供了一种优雅的方式来创建字典，特别是基于另一个字典或任何可迭代对象。

# 使用字典推导式
keys = ['key1', 'key2']
values = ['value1', 'value2']
my_dict = {k: v for k, v in zip(keys, values)}
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

1. 复制现有字典

可以使用 copy() 方法复制现有字典。

# 复制一个字典
original_dict = {'key1': 'value1', 'key2': 'value2'}
my_dict = original_dict.copy()
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

1. 创建空字典

可以定义一个空字典，用于后续添加键值对。

# 定义一个空字典
empty_dict = {}
print(empty_dict)  # 输出: {}

# 或者使用 dict() 函数创建空字典
empty_dict = dict()
print(empty_dict)  # 输出: {}

示例代码

以下是一些示例代码，展示了如何定义字典：

# 使用花括号定义字典
my_dict = {'key1': 'value1', 'key2': 'value2'}
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 使用 dict() 函数定义字典
my_dict = dict(key1='value1', key2='value2')
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 从列表的元组创建字典
list_of_tuples = [('key1', 'value1'), ('key2', 'value2')]
my_dict = dict(list_of_tuples)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 使用字典推导式
keys = ['key1', 'key2']
values = ['value1', 'value2']
my_dict = {k: v for k, v in zip(keys, values)}
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 复制一个字典
original_dict = {'key1': 'value1', 'key2': 'value2'}
my_dict = original_dict.copy()
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 定义一个空字典
empty_dict = {}
print(empty_dict)  # 输出: {}

注意事项

• 字典中的键必须是不可变类型，如字符串、整数或元组。

• 字典的键是唯一的，不能有重复的键。

• 字典是无序的，直到Python 3.7版，字典保持插入顺序。从Python 3.7开始，字典是有序的。

• 字典是可变的，可以在创建后修改其内容。

转换字典

在Python中，将元组、列表和字符串转换成字典是常见需求。以下是一些方法：

1. 将元组转换成字典

元组列表通常包含键值对，可以使用 dict() 函数将它们转换成字典。

# 定义一个元组列表
tuple_list = (('key1', 'value1'), ('key2', 'value2'))

# 使用 dict() 函数将元组列表转换成字典
my_dict = dict(tuple_list)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

1. 将列表转换成字典

列表可以转换成字典，尤其是当列表元素为键值对时。

# 定义一个列表，其中每个元素都是一个元组
list_of_tuples = [('key1', 'value1'), ('key2', 'value2')]

# 使用 dict() 函数将列表转换成字典
my_dict = dict(list_of_tuples)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

如果列表的元素是单一的键，并且你希望将这些键与它们自己或其他值关联起来，可以这样做：

# 定义一个键的列表
keys = ['key1', 'key2']

# 使用字典推导式将列表转换成字典
my_dict = {key: key for key in keys}
print(my_dict)  # 输出: {'key1': 'key1', 'key2': 'key2'}

1. 将字符串转换成字典

将字符串转换成字典稍微复杂一些，因为需要定义键值对的结构。一种方法是使用JSON格式的字符串。

import json

# 定义一个JSON格式的字符串
json_str = '{"key1": "value1", "key2": "value2"}'

# 使用 json.loads() 函数将字符串转换成字典
my_dict = json.loads(json_str)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

如果字符串是以特定分隔符分隔的键值对，可以使用字符串的方法和 dict() 函数进行转换：

# 定义一个以逗号和冒号分隔的键值对字符串
str_key_value = "key1:value1,key2:value2"

# 使用字符串方法和 dict() 函数将字符串转换成字典
my_dict = dict(pair.split(":") for pair in str_key_value.split(","))
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

示例代码

以下是一些示例代码，展示了如何进行转换：

# 将元组转换成字典
tuple_list = (('key1', 'value1'), ('key2', 'value2'))
my_dict = dict(tuple_list)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 将列表转换成字典
list_of_tuples = [('key1', 'value1'), ('key2', 'value2')]
my_dict = dict(list_of_tuples)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

keys = ['key1', 'key2']
my_dict = {key: key for key in keys}
print(my_dict)  # 输出: {'key1': 'key1', 'key2': 'key2'}

# 将字符串转换成字典
json_str = '{"key1": "value1", "key2": "value2"}'
my_dict = json.loads(json_str)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

str_key_value = "key1:value1,key2:value2"
my_dict = dict(pair.split(":") for pair in str_key_value.split(","))
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

注意事项

• 确保元组或列表中的每个元素都是键值对。

• 使用 json.loads() 需要导入 json 模块，并且字符串必须是有效的JSON格式。

• 如果字符串不是JSON格式，确保定义好键值对的分隔符，并正确地分割和转换它们。

遍历字典

在Python中，遍历字典以获取所有键值对、所有键或所有值，可以通过几种简单的方法实现。以下是详细的步骤和代码示例：

1. 获取所有键值对

要获取字典中的所有键值对，可以使用字典的 items() 方法，它会返回一个包含所有键值对的视图。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 遍历字典的键值对
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

1. 获取所有键

要获取字典中的所有键，可以使用字典的 keys() 方法，它会返回一个包含所有键的视图。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 遍历字典的键
for key in my_dict.keys():
    print(key)

或者，你可以直接在字典对象上进行迭代：

# 遍历字典的键
for key in my_dict:
    print(key)

1. 获取所有值

要获取字典中的所有值，可以使用字典的 values() 方法，它会返回一个包含所有值的视图。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 遍历字典的值
for value in my_dict.values():
    print(value)

示例代码

以下是一些示例代码，展示了如何遍历字典以获取所有键值对、所有键和所有值：

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 获取所有键值对
print("遍历所有键值对:")
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

# 获取所有键
print("\n遍历所有键:")
for key in my_dict.keys():
    print(key)

# 获取所有值
print("\n遍历所有值:")
for value in my_dict.values():
    print(value)

输出

遍历所有键值对:
Key: a, Value: 1
Key: b, Value: 2
Key: c, Value: 3

遍历所有键:
a
b
c

遍历所有值:
1
2
3

注意事项

• 字典是无序的，直到Python 3.7版，字典保持插入顺序。从Python 3.7开始，字典是有序的，这意味着键、值和键值对的顺序将按照插入顺序进行遍历。

• 在遍历字典时，你可以修改字典的值，但不建议在遍历时添加或删除键，因为这可能导致运行时错误。

• 如果需要对键、值或键值对进行进一步处理，可以使用列表推导式或字典推导式。

获取字典内容

在Python中，获取字典中指定键的值以及在键不存在时添加键值对是常见的操作。以下是如何实现这些操作的方法：

获取指定键的值

你可以直接通过键来访问字典中的值。如果键存在，将返回对应的值；如果键不存在，将引发 KeyError。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 获取指定键的值
try:
    value = my_dict['a']
    print(value)  # 输出: 1
except KeyError:
    print("Key does not exist.")

为了更安全地访问字典中的值，你可以使用 get() 方法，它允许你指定一个默认值，如果键不存在，将返回这个默认值而不是引发异常。

# 使用 get() 方法获取指定键的值
value = my_dict.get('a', None)  # 第二个参数是默认值
print(value)  # 输出: 1

value = my_dict.get('d', None)  # 'd' 不存在，返回 None
print(value)  # 输出: None

获取指定键的值，如果不存在则添加键值

你可以使用 setdefault() 方法来实现这个需求。如果键不存在于字典中，这个方法会添加键并将值设为你提供的默认值。

# 使用 setdefault() 方法获取值，如果键不存在则添加键值对
value = my_dict.setdefault('d', 4)
print(value)  # 输出: 4
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 再次获取 'd' 的值，此时不会添加新的键值对
value = my_dict.setdefault('d', 5)
print(value)  # 输出: 4
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

示例代码

以下是一些示例代码：

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 获取指定键的值
try:
    value = my_dict['a']
    print(f"Value for 'a': {value}")  # 输出: Value for 'a': 1
except KeyError:
    print("Key 'a' does not exist.")

# 使用 get() 方法获取指定键的值
value = my_dict.get('a')
print(f"Value for 'a' using get(): {value}")  # 输出: Value for 'a' using get(): 1
value = my_dict.get('d', None)
print(f"Value for 'd' using get(): {value}")  # 输出: Value for 'd' using get(): None

# 使用 setdefault() 方法获取值，如果键不存在则添加键值对
value = my_dict.setdefault('d', 4)
print(f"Value for 'd' using setdefault(): {value}")  # 输出: Value for 'd' using setdefault(): 4
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

注意事项

• 使用 get() 方法可以避免因键不存在而导致的 KeyError。

• setdefault() 方法在键不存在时添加键值对，并返回值；如果键已存在，它不会更改字典，只返回对应的值。

• 这些方法提供了灵活的方式来访问和修改字典。

根据你的具体需求选择合适的方法来获取字典中的值或添加键值对。

字典的删除

在Python中，从字典中删除条目可以通过几种不同的方法实现。以下是如何删除字典中的指定键、键值对，以及删除所有元素：

1. 删除指定键的值

使用 del 语句可以删除字典中的指定键及其对应的值。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除指定键 'b' 及其对应的值
del my_dict['b']
print(my_dict)  # 输出: {'a': 1, 'c': 3}

如果尝试删除不存在的键，将会引发 KeyError。

1. 删除字典中的一个键值对

使用 pop() 方法可以删除字典中的一个键值对，并返回该键对应的值。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除 'b' 键值对，并获取其值
removed_value = my_dict.pop('b', None)
print(removed_value)  # 输出: 2
print(my_dict)  # 输出: {'a': 1, 'c': 3}

pop() 方法接受一个默认值作为第二个参数，如果键不存在，则返回默认值而不会引发异常。

1. 删除字典中的所有元素

使用 clear() 方法可以删除字典中的所有元素。

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除所有元素
my_dict.clear()
print(my_dict)  # 输出: {}

示例代码

以下是一些示例代码，展示了如何删除字典中的元素：

# 定义一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除指定键 'b' 及其对应的值
del my_dict['b']
print(my_dict)  # 输出: {'a': 1, 'c': 3}

# 删除 'a' 键值对，并获取其值
removed_value = my_dict.pop('a')
print(removed_value)  # 输出: 1
print(my_dict)  # 输出: {'c': 3}

# 删除所有元素
my_dict.clear()
print(my_dict)  # 输出: {}

注意事项

• 使用 del 删除字典中的键时，如果键不存在，会引发 KeyError。

• 使用 pop() 方法删除键值对时，可以通过提供默认值参数来避免 KeyError。

• 使用 clear() 方法会清空整个字典，使其变为空字典。

• 字典是可变的，所以删除操作会直接影响原字典。

根据你的具体需求选择合适的方法来删除字典中的元素。

复制及更新

字典的复制

在Python中，复制字典是一个常见的操作，尤其是在你需要修改字典内容而不影响原始字典的情况下。以下是几种复制字典的方法：

1. 使用 dict() 函数

使用 dict() 函数可以创建一个新字典，它是原始字典的浅拷贝。

# 定义一个字典
original_dict = {'a': 1, 'b': 2, 'c': 3}

# 使用 dict() 函数复制字典
copied_dict = dict(original_dict)
print(copied_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

1. 使用字典的 copy() 方法

字典对象的 copy() 方法可以创建一个新字典，它是原始字典的浅拷贝。

# 定义一个字典
original_dict = {'a': 1, 'b': 2, 'c': 3}

# 使用 copy() 方法复制字典
copied_dict = original_dict.copy()
print(copied_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

1. 使用字典推导式

字典推导式可以基于原始字典快速创建一个新的字典。

# 定义一个字典
original_dict = {'a': 1, 'b': 2, 'c': 3}

# 使用字典推导式复制字典
copied_dict = {key: value for key, value in original_dict.items()}
print(copied_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

1. 使用 copy.deepcopy() 方法

如果字典中包含其他可变对象（如列表或字典），你可能需要进行深拷贝以确保复制的字典不会影响到原始字典。

import copy

# 定义一个包含可变对象的字典
original_dict = {'a': 1, 'b': [2, 3], 'c': {'d': 4}}

# 使用 deepcopy() 方法进行深拷贝
deep_copied_dict = copy.deepcopy(original_dict)
print(deep_copied_dict)  # 输出: {'a': 1, 'b': [2, 3], 'c': {'d': 4}}

示例代码

以下是一些示例代码，展示了如何复制字典：

# 使用 dict() 函数复制字典
original_dict = {'a': 1, 'b': 2, 'c': 3}
copied_dict = dict(original_dict)
print(copied_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用 copy() 方法复制字典
copied_dict = original_dict.copy()
print(copied_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用字典推导式复制字典
copied_dict = {key: value for key, value in original_dict.items()}
print(copied_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用 deepcopy() 方法进行深拷贝
import copy
original_dict = {'a': 1, 'b': [2, 3], 'c': {'d': 4}}
deep_copied_dict = copy.deepcopy(original_dict)
print(deep_copied_dict)  # 输出: {'a': 1, 'b': [2, 3], 'c': {'d': 4}}

注意事项

• 浅拷贝（dict() 和 copy()）只复制字典本身，而不复制字典中的可变对象。

• 深拷贝（deepcopy()）复制字典及其中的可变对象。

• 字典推导式适用于简单的字典复制，并且可以添加条件或修改键值对。

根据你的具体需求选择合适的复制方法。

字典的更新

在Python中，更新字典的内容可以通过多种方法实现，包括使用 update() 方法、直接赋值、解包字典以及其他一些技术。以下是一些常用的字典更新方法：

1. 使用 update() 方法

update() 方法是更新字典内容的标准方式，它可以将一个字典的键值对添加到另一个字典中。

# 定义两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# 使用 update() 方法更新字典
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

update() 方法可以接受任何可迭代的键值对序列，如元组列表或另一个字典。

1. 直接赋值

直接赋值是更新字典中特定键的值的最简单方法。

# 定义一个字典
my_dict = {'a': 1, 'b': 2}

# 直接赋值更新键 'a' 的值
my_dict['a'] = 10
print(my_dict)  # 输出: {'a': 10, 'b': 2}

如果键不存在，这种方法会添加新的键值对。

1. 使用解包字典

从Python 3.5开始，可以使用解包来合并两个字典。

# 定义两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# 使用解包更新字典
my_dict = {**dict1, **dict2}
print(my_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

这种方法会创建一个新的字典，其中包含两个字典的键值对。

1. 使用 merge() 方法（在Python 3.9及以上版本中）

从Python 3.9开始，字典有一个 merge() 方法，它类似于 update()，但只能用于字典对象。

# 定义两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# 使用 merge() 方法更新字典
dict1 |= {}
dict1.merge(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

1. 使用 | 运算符（在Python 3.9及以上版本中）

Python 3.9引入了一个新的合并运算符 |，可以用来更新字典。

# 定义两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# 使用 | 运算符更新字典
dict1 |= dict2
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

示例代码

以下是一些示例代码，展示了如何更新字典：

# 使用 update() 方法更新字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

# 直接赋值更新字典
my_dict = {'a': 1, 'b': 2}
my_dict['a'] = 10
print(my_dict)  # 输出: {'a': 10, 'b': 2}

# 使用解包更新字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
my_dict = {**dict1, **dict2}
print(my_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

# 使用 merge() 方法更新字典 (Python 3.9+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1 |= {}
dict1.merge(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

# 使用 | 运算符更新字典 (Python 3.9+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1 |= dict2
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

注意事项

• update() 方法就地修改字典，不返回任何值。

• 直接赋值可以添加新的键值对或更新现有键的值。

• 解包和 | 运算符创建一个新的字典。

• merge() 方法和 | 运算符在Python 3.9及以上版本中可用。

根据你的具体需求选择合适的方法来更新字典。

集合的操作

创建、添加、删除、运算

创建集合

创建不可变集合

添加集合元素

删除集合元素

交集、并集、差集运算

集合判断

OS模块应用

读取写入、信息获取与重命名

打开文件描述符

在Python中，os 模块提供了丰富的方法来处理文件和目录，但直接打开文件描述符通常不是通过 os 模块完成的，而是通过内置的 open() 函数。不过，os 模块确实提供了一些与文件描述符操作相关的函数，比如 os.open、os.read、os.write 和 os.close，这些函数可以用来执行底层的文件操作。

使用内置 open() 函数

这是打开文件的最常见方式，它返回一个文件对象。

# 使用内置 open() 函数打开文件
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

使用 os.open 函数

os.open 函数可以用于底层的文件描述符操作。

import os

# 使用 os.open 打开文件并获取文件描述符
fd = os.open('example.txt', os.O_RDONLY)

# 使用 os.read 读取文件内容
with os.fdopen(fd) as file:
    content = file.read()
    print(content)

# 关闭文件描述符
os.close(fd)

示例：使用文件描述符

以下是使用 os.open 来打开文件并读取内容的示例：

import os

# 打开文件获取文件描述符
fd = os.open('example.txt', os.O_RDONLY)

try:
    # 使用文件描述符读取数据
    buffer = os.read(fd, 1024)  # 读取1024字节
    print(buffer.decode('utf-8'))
finally:
    # 关闭文件描述符
    os.close(fd)

注意事项

• os.open 函数提供了更多的控制，比如可以指定文件的打开模式（只读、写入等）。

• 使用 os.open 时，你需要手动关闭文件描述符以避免资源泄露。

• os.read 和 os.write 函数提供了底层的文件读取和写入操作。

• 在大多数情况下，推荐使用内置的 open() 函数，因为它更简单、更安全，并且提供了异常处理和上下文管理器支持。

如果你需要进行更复杂的文件操作，或者需要与操作系统底层进行交互，可以使用 os 模块提供的这些函数。

读取文件内容

在Python中，os 模块通常用于处理文件和目录，而不是直接用于读取文件内容。读取文件内容通常使用内置的 open() 函数。不过，os 模块确实提供了一些函数，如 os.read()，可以用来读取文件内容，但这种方式不如使用 open() 函数常见。

以下是如何使用 os 模块读取文件内容的方法：

使用 os.open() 和 os.read()

这种方法使用底层的系统调用，通常不推荐，除非你需要进行更细粒度的控制。

import os

# 打开文件获取文件描述符
fd = os.open('example.txt', os.O_RDONLY)

# 读取文件内容
try:
    # 读取全部内容
    content = os.read(fd, os.fstat(fd).st_size)
    print(content.decode('utf-8'))
finally:
    # 关闭文件描述符
    os.close(fd)

使用内置的 open() 函数

这是读取文件内容的最常见和推荐的方法。

# 使用内置 open() 函数打开文件
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

使用 os 模块和文件对象

如果你已经使用了 os 模块的其他功能，可以使用 os.open() 获取文件描述符，然后使用 os.fdopen() 将文件描述符转换为文件对象。

import os

# 打开文件获取文件描述符
fd = os.open('example.txt', os.O_RDONLY)

# 将文件描述符转换为文件对象
with os.fdopen(fd) as file:
    content = file.read()
    print(content)

示例代码

以下是一些示例代码，展示了如何使用不同的方法读取文件内容：

# 方法1: 使用内置 open() 函数
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

# 方法2: 使用 os.open() 和 os.read()
import os
fd = os.open('example.txt', os.O_RDONLY)
try:
    content = os.read(fd, os.fstat(fd).st_size)
    print(content.decode('utf-8'))
finally:
    os.close(fd)

# 方法3: 使用 os.open() 和 os.fdopen()
import os
fd = os.open('example.txt', os.O_RDONLY)
with os.fdopen(fd) as file:
    content = file.read()
    print(content)

注意事项

• 使用内置的 open() 函数是最简单和最常见的方法，它提供了异常处理和上下文管理器支持。

• os.read() 和 os.write() 等函数提供了底层的文件操作，通常不推荐使用，除非你需要更细粒度的控制。

• 使用 os.open() 和 os.fdopen() 可以在已经使用 os 模块的其他功能时保持一致性。

根据你的具体需求选择合适的方法来读取文件内容。对于大多数情况，使用内置的 open() 函数是最佳选择。

写入字节类型内容到文件

在Python中，使用 os 模块写入字节类型内容到文件可以通过 os.open() 函数结合 os.write() 函数来完成。这种方式允许你直接与文件描述符交互，进行底层的文件写入操作。

使用 os.open() 和 os.write()

以下是一个示例，展示了如何使用 os 模块将字节类型的内容写入文件：

import os

# 定义要写入的字节内容
byte_content = b"Hello, world!"

# 使用 os.open() 打开文件获取文件描述符，模式为写入
fd = os.open('example.bin', os.O_WRONLY | os.O_CREAT)

# 使用 os.write() 写入字节内容
os.write(fd, byte_content)

# 关闭文件描述符
os.close(fd)

在这个示例中：

1. os.O_WRONLY 表示只写模式。

2. os.O_CREAT 表示如果文件不存在，则创建文件。

使用 open() 函数以二进制模式写入

虽然 os 模块可以用于底层的文件操作，但在大多数情况下，使用内置的 open() 函数以二进制模式写入字节内容更为简单和直观：

# 定义要写入的字节内容
byte_content = b"Hello, world!"

# 使用 open() 函数以二进制写入模式打开文件
with open('example.bin', 'wb') as file:
    file.write(byte_content)

在这个示例中，'wb' 模式表示以二进制格式打开文件进行写入操作。

示例代码

以下是一些示例代码，展示了如何使用不同的方法将字节类型的内容写入文件：

# 方法1: 使用 os.open() 和 os.write()
import os
byte_content = b"Hello, world!"
fd = os.open('example.bin', os.O_WRONLY | os.O_CREAT)
os.write(fd, byte_content)
os.close(fd)

# 方法2: 使用 open() 函数以二进制写入模式
byte_content = b"Hello, world!"
with open('example.bin', 'wb') as file:
    file.write(byte_content)

注意事项

• 使用 os.write() 时，你需要手动关闭文件描述符以避免资源泄露。

• 使用内置的 open() 函数以二进制模式写入通常是更简单和更安全的方法，因为它提供了异常处理和上下文管理器支持。

• 在处理二进制数据时，确保使用 'wb' 模式打开文件，这样可以避免对字节内容的不必要解码。

根据你的具体需求选择合适的方法来写入字节类型的内容到文件。对于大多数情况，使用内置的 open() 函数是最佳选择。

关闭打开的文件描述符

复制文件描述符

获取文件描述符状态

获取文件信息

获取文件或文件描述符的状态

文件系统路径的编码与解码

重命名文件与目录

目录的创建、删除及遍历

删除文件

创建硬链接

截断文件为指定大小

文件信息设置

目录的创建

目录的删除

目录的遍历操作

获取目录

使用关联的应用程序启动文件

执行系统命令

执行命令、系统信息获取

执行本地命令

执行新程序

系统信息获取

进程相关

获取系统环境变量

系统环境变量

os.path模块

路径获取、拼接、分割及判断

获取路径

路径拼接

路径分割

判断路径

获取路径信息

json模块

读取写入及转换

从json文件中读取文件

在Python中，从JSON文件中读取数据通常使用 json 模块，这是处理JSON数据的标准方式。以下是如何使用 json 模块从JSON文件中读取数据的步骤：

1. 使用 json.load() 函数

json.load() 函数可以直接从文件对象中读取JSON数据，并将其转换为Python的字典或列表。

import json

# 打开JSON文件
with open('data.json', 'r') as file:
    data = json.load(file)
    print(data)

在这个示例中，data.json 是包含JSON数据的文件。使用 with open() 语句打开文件，确保文件在读取后会被正确关闭。

1. 使用 json.loads() 函数

如果你已经读取了JSON数据到一个字符串中，可以使用 json.loads() 函数将字符串转换为Python对象。

import json

# 假设你已经有了一个JSON格式的字符串
json_str = '{"name": "John", "age": 30, "city": "New York"}'

# 使用 json.loads() 将字符串转换为字典
data = json.loads(json_str)
print(data)

示例：从JSON文件中读取数据

假设你有一个名为 data.json 的文件，其内容如下：

{
    "name": "John",
    "age": 30,
    "city": "New York"
}

你可以使用以下代码读取这个文件：

import json

# 打开JSON文件并读取数据
with open('data.json', 'r') as file:
    data = json.load(file)

# 打印读取的数据
print(data)

# 访问特定的数据
print(f"Name: {data['name']}, Age: {data['age']}, City: {data['city']}")

注意事项

• 确保文件路径正确，且文件确实存在，否则会引发 FileNotFoundError。

• JSON文件必须是一个有效的JSON格式，否则会引发 json.JSONDecodeError。

• 使用 with open() 语句可以确保文件在读取后会被正确关闭，即使在读取过程中发生了异常。

这些方法提供了灵活的方式来从JSON文件中读取数据，并将其转换为Python的数据结构，便于后续处理。

将json格式转换成python对象

在Python中，将JSON格式的字符串或文件内容转换成Python对象，通常使用 json 模块提供的 loads() 和 load() 函数。

使用 json.loads() 函数

如果你有一个JSON格式的字符串，可以使用 json.loads() 函数将其转换成Python的数据结构，如字典或列表。

import json

# JSON格式的字符串
json_str = '{"name": "John", "age": 30, "city": "New York"}'

# 使用 json.loads() 将字符串转换为字典
data = json.loads(json_str)

print(data)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York'}
print(type(data))  # 输出: <class 'dict'>

使用 json.load() 函数

如果你有一个存储JSON数据的文件，可以使用 json.load() 函数从文件中读取并转换成Python的数据结构。

import json

# 打开包含JSON数据的文件
with open('data.json', 'r') as file:
    data = json.load(file)

print(data)  # 输出取决于文件内容，通常为字典或列表
print(type(data))  # 输出: <class 'dict'> 或 <class 'list'>

示例代码

以下是一些示例代码，展示了如何将JSON格式的字符串和文件内容转换成Python对象：

import json

# JSON格式的字符串
json_str = '["apple", {"name": "John", "age": 30}, 3.14]'

# 使用 json.loads() 将字符串转换为Python对象
data = json.loads(json_str)
print(data)  # 输出: ['apple', {'name': 'John', 'age': 30}, 3.14]
print(type(data))  # 输出: <class 'list'>

# 假设有一个名为 data.json 的文件，包含以下内容：
# ["apple", {"name": "John", "age": 30}, 3.14]

# 使用 json.load() 从文件转换为Python对象
with open('data.json', 'r') as file:
    data = json.load(file)
print(data)  # 输出: ['apple', {'name': 'John', 'age': 30}, 3.14]
print(type(data))  # 输出: <class 'list'>

注意事项

• JSON标准的数据类型包括对象（转换为Python字典）、数组（转换为Python列表）、字符串、数字（整数或浮点数）、布尔值（转换为Python的 True 或 False）以及 null（转换为Python的 None）。

• json.loads() 函数用于处理字符串，而 json.load() 函数用于从文件对象读取。

• 确保JSON数据格式正确，否则可能会引发 json.JSONDecodeError。

这些方法允许你轻松地将JSON格式的数据转换为Python可以处理的对象。

将python对象转换为json格式字符串后写入到文件

在Python中，要将Python对象（如字典或列表）转换为JSON格式字符串并写入文件，可以使用 json 模块提供的 dump() 或 dumps() 函数。

使用 json.dumps() 函数

json.dumps() 函数可以将Python对象转换成一个JSON格式的字符串。

import json

# 定义一个Python字典
data = {'name': 'John', 'age': 30, 'city': 'New York'}

# 使用 json.dumps() 将字典转换为JSON格式的字符串
json_str = json.dumps(data, indent=4)
print(json_str)

写入文件

要将JSON字符串写入文件，你可以使用 with open() 语句，并结合文件的写入模式 'w'。

import json

# 定义一个Python字典
data = {'name': 'John', 'age': 30, 'city': 'New York'}

# 打开文件以写入
with open('data.json', 'w') as file:
    # 使用 json.dump() 将字典转换并写入文件
    json.dump(data, file, indent=4)

在这个示例中，indent=4 参数用于格式化输出，使JSON字符串更易于阅读。

示例代码

以下是将Python对象转换为JSON格式字符串并写入文件的完整示例：

import json

# 定义一个Python列表
data = ['apple', {'name': 'John', 'age': 30}, 3.14]

# 打开文件以写入
with open('data.json', 'w') as file:
    # 使用 json.dump() 将列表转换并写入文件
    json.dump(data, file, indent=4)

文件 data.json 将包含以下内容：

[
    "apple",
    {
        "name": "John",
        "age": 30
    },
    3.14
]

注意事项

• 使用 'w' 模式写入文件会覆盖文件内容。如果文件已存在，原有内容将被新内容替换。

• json.dump() 函数接受一个文件对象作为第一个参数，因此它可以直接写入文件。

• indent 参数用于美化输出，设置为 None 或者省略则输出压缩格式的JSON字符串。

• 如果要写入的数据包含非ASCII字符，可能需要考虑 ensure_ascii 参数。

这些方法允许你轻松地将Python对象转换为JSON格式，并将其持久化到文件中。

将python对象转换为json字符串

将Python对象转换成JSON字符串，可以使用Python标准库中的 json 模块。以下是一些常见的转换方法：

使用 json.dumps() 方法

此方法将Python对象序列化为JSON格式的字符串。

import json

# 假设我们有以下Python字典
python_obj = {
    'name': 'John',
    'age': 30,
    'is_student': False,
    'scores': [88, 92, 77],
    'address': None
}

# 转换为JSON字符串
json_str = json.dumps(python_obj, indent=4)
print(json_str)

输出将是：

{
    "name": "John",
    "age": 30,
    "is_student": false,
    "scores": [
        88,
        92,
        77
    ],
    "address": null
}

参数说明

• indent=4：美化输出，使JSON字符串易于阅读。如果不希望美化输出，可以省略该参数或者使用indent=None。

• ensure_ascii=False：默认情况下，json.dumps()会将非ASCII字符转义。设置此参数为False可以输出实际的Unicode字符。

• sort_keys=True：设置为True时，字典的键将在转换为JSON对象时进行排序。

• separators：默认为 (', ', ': ')，可以通过提供一个包含两个字符串的元组来定制，例如使用(',', ':')来生成没有空格的压缩格式JSON字符串。

处理日期时间对象

如果Python对象中包含日期时间对象，需要先将其转换为字符串，因为JSON格式不支持日期时间对象。

from datetime import datetime
import json

# 假设我们有以下包含日期时间对象的Python字典
python_obj = {
    'name': 'John',
    'birthday': datetime(1990, 1, 1)
}

# 定义一个函数来处理日期时间对象
def default_converter(o):
    if isinstance(o, datetime):
        return o.__str__()

# 转换为JSON字符串
json_str = json.dumps(python_obj, default=default_converter, indent=4)
print(json_str)

输出将是：

{
    "name": "John",
    "birthday": "1990-01-01 00:00:00"
}

注意事项

• JSON格式支持的数据类型包括对象（字典）、数组（列表）、字符串、数值、布尔值和 null。

• 如果Python对象中包含复杂的自定义对象，需要使用 default 参数来指定一个函数，该函数知道如何将这些对象转换为JSON支持的类型。

• json.dumps() 方法用于生成字符串，如果要直接写入文件，可以使用 json.dump() 方法。

这些方法允许你轻松地将Python对象转换为JSON格式的字符串，便于存储或传输。

shutil模块

文件的复制、一佛那个、删除及解压缩

复制文件或目录

移动文件或目录

信息获取

压缩与解压缩文件

sys模块

输入输出、解释器及系统版本的获取

标准输入流与输出流

python解释器相关

windows系统相关

路径、编码、线程、递归与异常

虚拟环境与路径

系统编码信息

线程与递归

程序异常

其他系统字段属性或方法

日期时间模块

日期时间对象与星期

获取当前本地日期和时间对象

创建时间对象

获取日期对象

创建日期和时间对象

将data、time对象合为datatime对象

将日期时间字符串转换为日期时间对象

返回指定天数的data、datatime对象

根据指定的字符串返回日期时间对象

返回指定日期的星期码

放回当前日期为星期几

放回包含年份、周数、星期数的元组

放回对应结构化的时间

日期格式化与替换

替换日期时间对象

返回指定格式的日期时间字符串

返回日期时间字符串

时间差、时间戳、时区

获取时间戳

内置函数

数据的转换与计算

整数——》二进制

对象——》布尔型

ascll码——》字符串

整数/字符串——》浮点数

整数——》十六进制数

浮点数/数字字符串——》整数

整数——》八进制

字符——》ascli码

对象——》字符串

求绝对值

求商合余数

求最大值

求最小值

四舍五入

幂运算

求和

输入输出

格式化处理

输入操作

打印输出

查看帮助信息

序列与迭代器

过滤序列

在Python中，过滤序列通常是指从一个序列中选择满足特定条件的元素。这个过程可以通过多种方法实现，包括使用列表推导式、filter() 函数以及循环等。以下是一些常用的方法：

1. 使用列表推导式

列表推导式是Python中快速生成列表的一种方式，它允许你指定一个条件表达式来过滤元素。

# 定义一个数字列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 使用列表推导式过滤出所有偶数
evens = [x for x in numbers if x % 2 == 0]
print(evens)  # 输出: [2, 4, 6, 8, 10]

1. 使用 filter() 函数

filter() 函数可以对序列进行过滤，它接受一个函数和一个序列，返回一个迭代器，该迭代器包含所有使得函数返回值为 True 的元素。

# 定义一个数字列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 定义一个过滤函数，返回偶数
def is_even(num):
    return num % 2 == 0

# 使用 filter() 函数过滤出所有偶数
evens = list(filter(is_even, numbers))
print(evens)  # 输出: [2, 4, 6, 8, 10]

1. 使用循环

虽然不是最简洁的方法，但使用循环可以给你更多的控制权，以实现更复杂的过滤逻辑。

# 定义一个数字列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 使用循环过滤出所有偶数
evens = []
for num in numbers:
    if num % 2 == 0:
        evens.append(num)
print(evens)  # 输出: [2, 4, 6, 8, 10]

示例代码

以下是一些示例代码，展示了如何过滤不同类型的序列：

# 使用列表推导式过滤字符串列表中的空字符串
strings = ["apple", "", "banana", "cherry", " ", "date"]
non_empty_strings = [s for s in strings if s.strip()]
print(non_empty_strings)  # 输出: ['apple', 'banana', 'cherry', 'date']

# 使用 filter() 函数过滤出列表中的正数
numbers = [-10, -3, 0, 5, 9, 12]
positive_numbers = list(filter(lambda x: x > 0, numbers))
print(positive_numbers)  # 输出: [-10, -3, 5, 9, 12]

# 使用循环过滤元组中的非重复元素
my_tuple = (1, 2, 2, 3, 4, 5, 5, 6)
unique_elements = []
for elem in my_tuple:
    if elem not in unique_elements:
        unique_elements.append(elem)
print(unique_elements)  # 输出: [1, 2, 3, 4, 5, 6]

注意事项

• 列表推导式提供了一种快速、简洁的方式来过滤列表。

• filter() 函数适用于简单的过滤条件，并且返回一个迭代器，如果需要列表形式，需要使用 list() 函数转换。

• 使用循环可以提供最大的灵活性，但代码可能不如列表推导式和 filter() 函数简洁。

根据你的具体需求选择合适的方法来过滤序列。

反转序列

在Python中，反转序列是一个常见的操作，可以应用于字符串、列表、元组等。以下是一些常用的方法来反转各种类型的序列：

1. 反转列表

使用切片

最简单的方法是使用切片来反转列表。

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

使用 reverse() 方法

列表的 reverse() 方法会就地反转列表中的元素。

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  # 输出: [5, 4, 3, 2, 1]

1. 反转字符串

使用切片

字符串也可以使用切片来反转。

my_string = "hello"
reversed_string = my_string[::-1]
print(reversed_string)  # 输出: "olleh"

使用 reversed() 函数

reversed() 函数可以返回一个反转的迭代器。

my_string = "hello"
reversed_string = ''.join(reversed(my_string))
print(reversed_string)  # 输出: "olleh"

1. 反转元组

使用切片

元组和列表类似，也可以使用切片来反转。

my_tuple = (1, 3, 5, 7, 9)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple)  # 输出: (9, 7, 5, 3, 1)

示例代码

以下是一些示例代码，展示了如何反转不同类型的序列：

# 反转列表
my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

# 反转字符串
my_string = "hello"
reversed_string = my_string[::-1]
print(reversed_string)  # 输出: "olleh"

# 反转元组
my_tuple = (1, 3, 5, 7, 9)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple)  # 输出: (9, 7, 5, 3, 1)

注意事项

• 切片方法是最简洁和常用的反转序列的方法。

• reverse() 方法会就地修改列表，不返回新列表。

• reversed() 函数返回一个迭代器，需要将其转换为列表或字符串来查看反转后的结果。

排序

1. sorted()：

   • 这个函数返回一个新的列表，包含所有输入项，按升序排列。

   • 语法：sorted(iterable, key=None, reverse=False)

   • iterable 是要排序的可迭代对象。

   • key 是一个函数，它会被用来在比较时获取每个元素的比较键。

   • reverse 是一个布尔值，如果为 True，则列表将被降序排列。

   示例：

   numbers = [5, 2, 9, 1, 5, 6]
   sorted_numbers = sorted(numbers)
   print(sorted_numbers)  # 输出: [1, 2, 5, 5, 6, 9]

可迭代对象长度或个数

len(s)

s:要获取长度的或项目个数的对象

函数操作可迭代对象

迭代器的下一个元素

可迭代对象打包成元组

实现切片对象

判断可迭代对象是否包含假值

可迭代对象是否全wield假值

对象/对象属性与编译执行

获取对象类型

执行字符串表达式

执行储存在字符串或文件的python语句

将对象转化为可打印字符串

获取对象内存地址

获取名字、属性或方法列表

创建枚举对象

返回对象字符串

1. Fizz Buzz问题：编写一个程序，打印从1到100的数字，但当数字能被3整除时，打印"Fizz"；能被5整除时，打印"Buzz"；同时能被3和5整除时，打印"FizzBuzz"。

2. 反转字符串：编写一个函数，实现字符串的反转。

3. 检查回文字符串：编写一个函数，检查一个字符串是否是回文。

4. 罗马数字转换：将罗马数字转换为整数。

5. 列表推导式：使用列表推导式生成一个列表，包含前n个正奇数的平方。

6. 合并两个有序列表：给定两个有序整数列表，合并它们并使新列表中的元素仍然有序。

7. 找出列表中的重复项：编写一个函数，找出列表中的所有重复项。

8. 计算字符串中字符的频率：编写一个函数，计算并返回字符串中每个字符的出现次数。

9. 实现一个简单的计算器：实现一个可以接受两个数字和运算符（加、减、乘、除）并返回结果的计算器。

10. 搜索和排序：编写一个函数，对列表进行排序，并找出列表中第二大的数。

11. 动态规划问题：例如，斐波那契数列、0/1背包问题、最长公共子序列等。

12. 正则表达式：使用正则表达式验证字符串是否符合特定的模式。

13. 递归函数：编写一个递归函数来计算阶乘或者解决其他递归问题。

14. 装饰器：编写一个装饰器，用于计算函数执行时间。

15. 闭包：编写一个闭包，实现私有变量的效果。

16. 迭代器和生成器：实现一个迭代器或生成器，用于处理数据流。

17. 异常处理：编写一个程序，处理可能出现的异常，并给出相应的错误信息。

18. 对象和类：设计一个类，实现特定的功能，例如一个简单的银行账户类。

19. 多线程和多进程：编写一个程序，使用多线程或多进程来解决并发问题。

20. 算法问题：实现排序算法（如快速排序、归并排序）、搜索算法（如二分查找）等。

21. 二分法排序

22. 请写一个函数，在不转换为字符串的情况下验证这个数字是否为回文。即正序和倒序数值相同？

23. 给定一个整数数组nums和一个目标值m，请在该数组中找出和为目标值的那个两个整数，并返回他们的数据下标。数据中通一个元素不能出现两遍

24. 统计在一个队列中的数字，有多少个正数，多少个负数

25. 水仙花：指一个三位数，它的每个位上的数字的3次幂指和等于它本身

26. 求出1000以内的完全数

27. 用python写一个冒泡排序

28. 计算n的阶乘

29. 在算法中，什么是时间复杂度和空间复杂度？他们的重要性是什么？

30. s=1+2-3+4-5+6-7+8-9.....n写一个编写一个函数，传入参数n返回s的值

31. 列表推导式是什么

32. 如何将数字转换wield字符串？

33. pytest单元框架里亲炙条件怎么处理？

34. pytest里如何进行case组装

35. pytest如何进行参数化实现