1
str1 = "Hello, World!"  # 双引号定义字符串
2
常用的字符串操作方法有：
3
str1.upper()  # 转换为大写
4
str1.lower()  # 转换为小写
5
str1.strip()  # 去除首尾空格
6
str1.split(",")  # 按照逗号分割字符串
7
str1.replace("World", "Python")  # 替换字符串中的内容
8
str1.find("World")  # 查找子字符串的位置，返回索引，如果找不到返回-1
9
str1.isalpha()  # 判断字符串是否只包含字母，返回True或False
10
str1[0]  # 获取字符串的第一个字符
11

12
#字符串切片
13
str1[start:end:step] #切片操作，获取字符串的子串，start表示起始索引，end表示结束索引（左闭右开），step表示步长，默认值为1
14
eg: str1[0:5]  # 获取字符串的前5个字符，结果为 "Hello"
15
    str1[7:]   # 获取字符串从索引7开始到末尾的子串，结果为 "World!"
16
    str1[-1]   # 获取字符串的最后一个字符
17
    str1[-5:]  # 获取字符串的最后5个字符，结果为 "orld!"
18
    str1[0:-1] # 获取从开始到倒数第二个字符的子串，结果为 "Hello, World"
19
    str[1:5:2] # 获取字符串从索引1到索引5（不包含）的字符，步长为2，结果为 "el"
20
    str1[::2]  # 获取字符串的偶数索引字符，结果为 "Hlo ol!"
21
    str1[::-1] # 获取字符串的反转，结果为 "!dlroW ,olleH"
22

23
#字符串输出
24
print(str1 * 2)             # 输出字符串两次
25
print(str1 + '你好')         # 连接字符串
26

27
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
28
输出：hellorunoob
29

30
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
31
输出：hello\nrunoob
32

33
# print默认换行输出，不换行输出需要在变量末尾加上 end=""：
34
print( str1, end=" " )
35
print("这是下一条内容")
36
输出：Hello, World! 这是下一条内容

1
# 创建列表
2
my_list = ['abcd', 786, 2.23, 'runoob', 70.2]  # 避免使用 list 作为变量名，会覆盖内置类型
3
tinylist = [123, 'runoob']
4

5
print(my_list)             # 打印整个列表：['abcd', 786, 2.23, 'runoob', 70.2]
6
print(my_list[0])          # 打印第一个元素（索引 0）：abcd
7
print(my_list[1:3])        # 打印索引 1 和 2 的元素（不含索引 3）：[786, 2.23]
8
print(my_list[2:])         # 打印从索引 2 开始到末尾的所有元素：[2.23, 'runoob', 70.2]
9
print(tinylist * 2)        # 重复打印 tinylist 两次：[123, 'runoob', 123, 'runoob']
10
print(my_list + tinylist)  # 拼接两个列表
11

12

13
#list常用操作
14

15
#1.访问列表元素
16
my_list[0]  # 通过索引访问列表元素，索引从0开始，负数索引表示从末尾开始计数
17

18
#2.修改列表元素
19
my_list[0] = "new_value"  # 通过索引修改列表元素
20
print(my_list)  # 打印修改后的列表  [new_value, 786, 2.23, 'runoob', 70.2]
21

22
#3.添加元素
23
my_list.append("new_element")  # 在列表末尾添加新元素
24

25
#4.删除元素
26
my_list.remove(786)  # 删除列表中第一个匹配的元素
27
my_list.pop(0)  # 删除指定索引的元素，并返回该元素，默认删除最后一个元素
28

29
#5.列表长度
30
my_list_length = len(my_list)  # 获取列表的长度（元素个数）   #len()是python内置函数，返回对象的长度或元素个数
31

32
#6.列表切片
33
#my_list[start:end:step]  # 切片操作，获取列表的子列表，start表示起始索引，end表示结束索引（左闭右开），step表示步长，默认值为1
34

35
#7.列表排序
36
#my_list.sort()  # 对列表进行升序排序
37
#warning  注意列表中的元素必须是可比较的类型，否则会抛出 TypeError 异常
38

39
#my_list.sort(reverse=True)  # 对列表进行降序排序
40
#my_list_sorted = sorted(my_list)  # 返回一个新的升序排序的列表，不改变原列表        #sorted()是python内置函数，返回一个新的排序后的列表
41

42
#8.列表反转
43
my_list.reverse()  # 反转列表中的元素顺序
44
my_list_reversed =reversed(my_list)  # 返回一个反转后的迭代器，不改变原列表        #reversed()是python内置函数，返回一个反转后的迭代器
45
print(str(list(my_list_reversed)))  # 将迭代器转换为列表并打印
46

47
#9.元素计数
48
count = my_list.count('runoob')  # 统计列表中某个元素的出现次数

1
my_tuple = ('abcd', 786, 2.23, 'runoob', 70.2)  # 避免使用 tuple 作为变量名
2
tinytuple = (123, 'runoob')
3

4
print(my_tuple)               # 输出完整元组
5
print(my_tuple[0])            # 输出第一个元素：abcd
6
print(my_tuple[1:3])          # 输出索引 1 和 2 的元素：(786, 2.23)
7
print(my_tuple[2:])           # 输出从索引 2 开始的所有元素
8
print(tinytuple * 2)          # 输出两次 tinytuple
9
print(my_tuple + tinytuple)   # 连接两个元组
10

11

12
#warning 元组虽然是不可变的，但如果元组中包含可变对象（如列表），则这些可变对象仍然可以被修改。
13
my_tuple_with_list = (1, 2, [3, 4])
14
my_tuple_with_list[2][0] = 99  # 修改元组中的列表元素
15

16
#同时元组支持切片操作，类似于列表，但元组的切片操作会返回一个新的元组，而不是列表。
17
#元组没有append()、remove()等方法，因为它们是不可变的，但可以使用 + 运算符连接元组，或者使用 * 运算符重复元组。

1
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'} #使用的是字面量语法（大括号 {}）。这是直接定义一个包含多个字符串元素的集合。
2

3
print(sites)   # 输出集合（无序，重复元素会被自动去掉）
4

5
# 成员测试
6
if 'Runoob' in sites:
7
    print('Runoob 在集合中')
8
else:
9
    print('Runoob 不在集合中')
10

11
# set 可以进行集合运算
12
a = set('abracadabra')  #set() 接收一个字符串时，它会将字符串打散，把里面的每一个字符当作独立的元素放入集合中。
13
b = set('alacazam')
14

15
print(a)           # a 中的唯一字符
16

17
print(a - b)       # a 和 b 的差集（在 a 中但不在 b 中）
18
print(a | b)       # a 和 b 的并集（在 a 或 b 中）
19
print(a & b)       # a 和 b 的交集（同时在 a 和 b 中）
20
print(a ^ b)       # a 和 b 的对称差集（在 a 或 b 中，但不同时存在）
21

22
#常用操作
23
1.添加元素
24
sites.add('Twitter')  # 添加元素
25

26
2.删除元素
27
sites.remove('Baidu')  # 删除元素，如果元素不存在会抛出 KeyError 异常
28

29
3.清空集合
30
sites.clear()  # 清空集合
31

32
4.集合长度
33
len(sites)  # 获取集合的长度（元素个数）
34

35
5.集合遍历
36
for site in sites:
37
    print(site)  # 遍历集合中的元素
38

39
6.元素是否存在
40
if 'Google' in sites:
41
    print('Google 在集合中')
42
else:
43
    print('Google 不在集合中')

1
my_dict = {}
2
my_dict['one'] = "1 - 菜鸟教程"
3
my_dict[2]     = "2 - 菜鸟工具"
4

5
tinydict = {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
6

7
print(my_dict['one'])       # 输出键为 'one' 的值
8
print(my_dict[2])           # 输出键为 2 的值
9
print(tinydict)             # 输出完整的字典
10
print(tinydict.keys())      # 输出所有键
11
print(tinydict.values())    # 输出所有值
12

13
#元组作为字典的键
14
my_dict_with_tuple = {('a', 'b'): 1, ('c', 'd'): 2}  # 使用元组作为字典的键
15
print(my_dict_with_tuple[('a', 'b')])  # 输出键为 ('a', 'b') 的值：1
16

17
#元组常用操作
18
1.访问元素
19
my_dict_with_tuple[('a', 'b')] = 3  # 修改键为 ('a', 'b') 的值为 3
20

21
2.删除元素
22
del my_dict_with_tuple[('c', 'd')]  # 删除键为 ('c', 'd') 的键值对
23

24
3.遍历字典
25
for key, value in my_dict_with_tuple.items():
26
    print(f"键: {key}, 值: {value}")  # 遍历字典中的键值对
27

28
4.字典长度
29
len(my_dict_with_tuple)  # 获取字典的长度（键值对的数量）
30

31
5.检查键是否存在
32
if ('a', 'b') in my_dict_with_tuple.keys():
33
    print("键 ('a', 'b') 存在")
34
else:
35
    print("键 ('a', 'b') 不存在")
36

37
6.检查值是否存在
38
if 3 in my_dict_with_tuple.values():
39
    print("值 3 存在")
40
else:
41
    print("值 3 不存在")

1
1.常见 bytes 操作
2
# ========== 1. 创建 bytes ==========
3
b1 = b'hello'              # 字面量
4
b2 = bytes('你好', 'utf-8') # 字符串编码
5
b3 = bytes([72, 101, 108]) # 从整数列表创建 → b'Hel'
6
b4 = bytes(5)              # 5个零字节 → b'\x00\x00\x00\x00\x00'
7

8
# ========== 2. 索引与切片（与 str 类似）==========
9
b = b'Hello, World!'
10
b[0]          # 72（返回整数，不是 bytes！）
11
b[0:5]        # b'Hello'
12
b[-1]         # 33（'!' 的 ASCII 值）
13

14
# ========== 3. 常用方法 ==========
15
b = b'  Hello, World!  '
16
b.strip()             # b'Hello, World!'
17
b.lower()             # b'  hello, world!  '
18
b.split(b',')         # [b'  Hello', b' World!  ']
19
b.replace(b'World', b'Python')  # b'  Hello, Python!  '
20
b.startswith(b'  He') # True
21

22
# ========== 4. 编码与解码 ==========
23
text = '你好世界'
24
encoded = text.encode('utf-8')     # str → bytes
25
decoded = encoded.decode('utf-8')  # bytes → str → '你好世界'
26

27
# ========== 5. 拼接与重复 ==========
28
b1 = b'Hello'
29
b2 = b' World'
30
b1 + b2       # b'Hello World'
31
b'Ha' * 3     # b'HaHaHa'
32

33
# ========== 6. 判断与查找 ==========
34
b = b'abcdef'
35
b'cd' in b    # True
36
b.index(b'd') # 3
37
b.count(b'a') # 1
38

39
# ========== 7. 与整数互转 ==========
40
b = b'\x00\x01\x02\x03'
41
list(b)                    # [0, 1, 2, 3]
42
bytes([255, 128, 0])       # b'\xff\x80\x00'
43

44
# ========== 8. hex / fromhex ==========
45
b = b'\xde\xad\xbe\xef'
46
b.hex()                    # 'deadbeef'
47
bytes.fromhex('deadbeef')  # b'\xde\xad\xbe\xef'
48

49
#bytearray 的可变操作
50
ba = bytearray(b'Hello')
51

52
2. ✅ 可变操作（bytes 不支持）
53
ba[0] = 72            # 按索引修改（赋值整数）
54
ba[1:3] = b'EL'       # 切片赋值
55
ba.append(33)          # 追加字节 → bytearray(b'HELLO!')
56
ba.extend(b' World')   # 扩展
57
ba.insert(5, 44)       # 插入
58
ba.pop()               # 弹出最后一个字节
59
del ba[5]              # 删除指定位置
60

61
# ⚠️ 注意：ba[i] = 整数，ba[i:j] = bytes/bytearray
62
ba[0] = ord('h')       # ✅ 正确
63
# ba[0] = b'h'         # ❌ TypeError!
64

65
3. 典型应用场景
66
# 📡 网络通信：读取 socket 数据
67
data = sock.recv(1024)          # 返回 bytes
68
header = data[:4]               # 解析头部
69

70
# 📁 文件读写（二进制模式）
71
with open('image.png', 'rb') as f:
72
    content = f.read()           # bytes
73

74
# 🔧 协议解析/修改（需要可变）
75
buf = bytearray(header + payload)
76
buf[2] = 0x01                    # 修改标志位
77
buf[4:8] = length.to_bytes(4, 'big')  # 更新长度字段
78
sock.sendall(buf)

1
range(stop)   #此处 stop 表示生成的整数序列的结束值（不包含 stop），默认从 0 开始，步长为 1。

1
for i in range(5):
2
    print(i)

1
0 1 2 3 4

1
range(start, stop)

1
for i in range(2, 6):
2
    print(i)

1
2 3 4 5

1
range(start, stop, step) #开始，截至，步数

1
for i in range(0, 10, 2):
2
    print(i)

1
0 2 4 6 8

1
names = ["Tom", "Alice", "Bob"]
2

3
for name in names:
4
    print(name)

1
Tom
2
Alice
3
Bob

1
for i in range(10):
2
    if i == 5:
3
        break
4
    print(i)

1
0
2
1
3
2
4
3
5
4

1
for i in range(5):
2
    if i == 2:
3
        continue
4
    print(i)

1
0
2
1
3
3
4
4

1
lambda arguments: expression

1
square = lambda x: x ** 2
2
print(square(5))  # 25

1
numbers = [1, 2, 3, 4]
2
squares = list(map(lambda x: x ** 2, numbers))  #  map() 函数会将 lambda 函数应用到 numbers 列表的每个元素上，并返回一个迭代器，最后使用 list() 将其转换为列表。
3
print(squares)  # [1, 4, 9, 16]

1
numbers = [1, 2, 3, 4, 5, 6]
2
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3
print(even_numbers)  # [2, 4, 6]

1
from functools import reduce
2

3
numbers = [1, 2, 3, 4]
4
total = reduce(lambda x, y: x + y, numbers)
5
print(total)  # 10

1
from functools import reduce
2

3
students = [
4
    {"name": "小明", "score": 85},
5
    {"name": "小红", "score": 92},
6
    {"name": "小刚", "score": 58},
7
    {"name": "小丽", "score": 76},
8
]
9

10
# filter()：筛选出及格的学生
11
#students是一个列表，filter()函数会将lambda函数应用到students列表的每个元素上，并返回一个迭代器，最后使用list()将其转换为列表。
12
#lambda student: student["score"] >= 60是一个匿名函数，接收一个学生字典作为参数，返回该学生的成绩是否大于等于60。
13
passed = list(filter(lambda student: student["score"] >= 60, students))
14

15

16

17
# sorted()：按成绩从高到低排序
18
ranked = sorted(passed, key=lambda student: student["score"], reverse=True) #reverse=True表示降序排列
19

20
# map()：提取排序后的学生姓名
21
names = list(map(lambda student: student["name"], ranked))
22

23
# reduce()：计算及格学生的总分
24
total_score = reduce(
25
    lambda total, student: total + student["score"],
26
    passed,
27
    0,
28
) # reduce()三个参数，第一个参数是函数，第二个参数是可迭代对象，第三个参数是初始值，这里初始值为0，表示从0开始累加。
29

30
print(names)  # ['小红', '小明', '小丽']
31
print(total_score)  # 253

1
[表达式 for 变量 in 可迭代对象]

1
[表达式 for 变量 in 可迭代对象 if 条件]

1
class 类名:
2
    类属性 = 属性值
3

4
    def __init__(self, 参数1, 参数2):
5
        self.实例属性1 = 参数1
6
        self.实例属性2 = 参数2
7

8
    def 方法名(self, 参数):
9
        # 方法体
10
        return 结果
11

12

13
对象 = 类名(参数1, 参数2)
14
对象.方法名(参数)

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
    def introduce(self):
7
        return f"我叫{self.name}，今年{self.age}岁"
8

9

10
# 实例化对象并调用方法
11
person = Person("小明", 18)
12
print(person.name)          # 小明
13
print(person.introduce())   # 我叫小明，今年18岁

1
class Dog:
2
    species = "犬科"  # 类属性
3

4
    def __init__(self, name):
5
        self.name = name  # 实例属性
6

7
    def bark(self):
8
        print(f"{self.name}：汪汪！")
9

10

11
dog = Dog("旺财")
12
print(Dog.species)  # 犬科
13
dog.bark()          # 旺财：汪汪！

1
python3 -m venv .venv
2
source .venv/bin/activate
3
python -c "import sys; print(sys.executable)"

1
from timeit import repeat
2

3
processed = list(range(10_000))
4
incoming = list(range(9_000, 11_000))
5

6

7
def filter_with_list():
8
    return [item for item in incoming if item not in processed]
9

10

11
def filter_with_set():
12
    processed_set = set(processed)
13
    return [item for item in incoming if item not in processed_set]
14

15

16
assert filter_with_list() == filter_with_set()
17
for func in (filter_with_list, filter_with_set):
18
    samples = repeat(func, number=3, repeat=3)
19
    print(func.__name__, f"{min(samples) / 3:.6f} 秒/次")

1
from pathlib import Path
2
from tempfile import TemporaryDirectory
3

4

5
def iter_errors(path):
6
    with path.open(encoding="utf-8") as file:
7
        for number, line in enumerate(file, start=1):
8
            if "ERROR" in line:
9
                yield number, line.rstrip("\n")
10

11

12
with TemporaryDirectory() as directory:
13
    path = Path(directory) / "app.log"
14
    path.write_text("INFO start\nERROR timeout\nINFO done\n", encoding="utf-8")
15
    for number, message in iter_errors(path):
16
        print(number, message)  # 2 ERROR timeout

1
from concurrent.futures import ThreadPoolExecutor, as_completed
2
from time import sleep
3

4

5
def read_record(record_id):
6
    sleep(0.02)
7
    if record_id == 2:
8
        raise ValueError("记录格式无效")
9
    return {"id": record_id, "status": "ok"}
10

11

12
with ThreadPoolExecutor(max_workers=3) as pool:
13
    futures = {pool.submit(read_record, number): number for number in range(3)}
14
    for future in as_completed(futures):
15
        record_id = futures[future]
16
        try:
17
            print("成功", future.result())
18
        except ValueError as exc:
19
            print("失败", record_id, str(exc))

1
import asyncio
2

3

4
async def fetch_record(record_id, semaphore):
5
    async with semaphore:
6
        try:
7
            async with asyncio.timeout(0.08):
8
                delay = 0.15 if record_id == 3 else 0.01
9
                await asyncio.sleep(delay)
10
                return {"id": record_id, "status": "ok"}
11
        except TimeoutError:
12
            return {"id": record_id, "status": "timeout"}
13

14

15
async def main():
16
    semaphore = asyncio.Semaphore(2)
17
    async with asyncio.TaskGroup() as group:
18
        tasks = [
19
            group.create_task(fetch_record(number, semaphore))
20
            for number in range(4)
21
        ]
22
    print([task.result() for task in tasks])
23

24

25
if __name__ == "__main__":
26
    asyncio.run(main())

1
from concurrent.futures import ProcessPoolExecutor
2

3

4
def sum_squares(limit):
5
    return sum(number * number for number in range(limit))
6

7

8
if __name__ == "__main__":
9
    with ProcessPoolExecutor(max_workers=2) as pool:
10
        results = list(pool.map(sum_squares, [10_000, 20_000]))
11
    print(results)  # [333283335000, 2666466670000]

1
@decorator
2
def work():
3
    ...

1
from functools import wraps
2
from time import perf_counter
3

4

5
def timed(func):
6
    @wraps(func)
7
    def wrapper(*args, **kwargs):
8
        started = perf_counter()
9
        try:
10
            return func(*args, **kwargs)
11
        finally:
12
            elapsed = perf_counter() - started
13
            print(f"{func.__name__}: {elapsed:.6f}s")
14
    return wrapper
15

16

17
@timed
18
def total_price(prices, discount=1.0):
19
    """计算折扣后的总价。"""
20
    return sum(prices) * discount
21

22

23
print(total_price([10, 20], discount=0.9))  # 先输出耗时，再输出 27.0
24
print(total_price.__name__)               # total_price