1

print(value1, value2, value3, sep='&', end = '\n', file = None)

1
2
3
4
5
6
7

# 注意需要打开文件，写入，然后关闭文件
fp = open('./note.txt', 'w')
print('hello', file = fp)
fp.close()

# BUG: 不能直接写入到文件路径中
print('hello', file = './note.txt')

1
2
3
4
5

ord('a') # 获取a的Unicode

chr(12345) # 获取12345对应的字符

print(chr(12345), ord('a'), sep = ' & ', end = '\n\n')

1
2

name = input()
print('My name is' + name)

1
2

age = int(input())
print('My age is' + str(age))

1
2
3

# coding=utf-8

# coding=gbk

1
2

# 语法上没问题，但是语义上不建议这样写
true = 1

1
2
3
4

import keyword

print(keyword.kwlist)
print(len(keyword.kwlist))

1
2
3
4
5
6
7
8
9

可以是字符 (英文、中文) 、下划线_, 和数字，并且第一个字符不能是数字

不能使用Python中的保留字

标识符严格区分大小写

以下划线开头的标识符有特殊意义，一般应避免使用相似的标识符

允许使用中文作为标识符，但不建议使用

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

＞ 模块名尽量短小，并且全部使用小写字母，可以使用下划线分隔多个字母。例如：grame_main

＞ 包名尽量短小，并且全部使用小写字母，不推荐使用下划线。例如：com.abpython，不推荐使用com_abpython

> 类名采用单词首字母大写形式（Pascal风格）。例如：MyClass

＞ 模块内部的类采用““+Pascal 风格的类名组成，例如：在MyClass中的内部类_InnerMyClass

＞ 函数、类的属性和方法的命名，全部使用小写字母，多个字母之间使用下划线分隔

> 常量命名时，采用全部大写字母，可以使用下划线

> 使用单下划线“——”开头的模块变量或函数是受保护的，在使用“from xxx import *” 语句从模块中导入时，这些模块变量或函数不能被导入  

> 使用双下划线“__” 开头的实例变量或方法，是类私有的

> 以双下划线开头和结尾的是Python的专用标识，例如: _init_(表示初始化函数）

1
2
3

name = 'Mike'
name = 20
type(name)

1
2
3
4
5
6

<class 'str'> 字符串
<class 'int'> 整数
<class 'float'> 浮点数
<class 'complex'> 复数
<class 'dict'> {} 字典
<class 'list'> [] 列表

1

a = b = c = 100

1

id(a) == id(b)

1
2
3
4

HELP_LINK = 'https://www.baidu.com'

# 强烈不建议更改常量
HELP_LINK = 123

1

round(0.1 + 0.2, 1)

1
2
3

a = 123 + 456j
a.real
a.imag

1

a = 1.001E5

1
2
3
4
5
6

a = 'test'
b = "test"
c = """
this is test string
this is test2 string
"""

1
2
3
4
5

\n 换行符
\t 制表符
\"
\'
\\

1

a = r"abc\n\n"

1
2
3

a = 'helloBlog'
b = a[0]
c = a[-2]

1
2
3
4
5

a = 'helloBlog'
b = a[0:3] # 前开后闭，结果是 hel
c = a[-9:-6] # 效果类似，通常不会这样使用
d = a[2:] # 缺少参数，选择默认值，从开始或者结尾进行截取
e = a[:3]

1
2
3
4

a + b # combine two string into one
a * 10
10 * a # repeat string a for 10 times
a in b # check a is substring of b, same as JS b.includes(a), return True or False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

bool(False)

bool(None)

bool(0)

bool(0.0)

空序列（空字符串，空元组，空对象，空列表，空集合）

自定义对象的实例，对象的 __bool__() 函数返回 False，或者 __len__() == 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int()
float()
str()

chr(100) # 整数转换成字符串

# 进制转换
hex(100) # 整数转换成十六进制
oct(100) # 整数转换成八进制
bin(100) # 整数转换成二进制

1
2
3

try:
    int('123a')
    int('3.1415')

1

print(eval('3 + 1.5')) # 4.5

1
2

10 / 3 # 3.333
10 // 3 # 3

1

a, b, c = 1, 2, 3  # a = 1, b = 2, c = 3

1

x = y = z = 10  # x, y, z 都赋值为 10

1

a, b, c = [1, 2, 3]  # a = 1, b = 2, c = 3

1
2

x, y = 10, 20
x, y = y, x  # 交换后 x = 20, y = 10

1
2
3
4
5
6
7
8
9

data = [1, 2, 3, 4]
n = len(data)
if n > 2:
    print(n)

# 简化后，在表达式中赋值
data = [1, 2, 3, 4]
if (n := len(data)) > 2:
    print(n)

1

a = 5  # 二进制: 0101

1

a = 5  # 二进制: 0101

1

a = 5  # 二进制: 0101

1

a = 5  # 二进制: 0101

1

a = 5  # 二进制: 0101

1

a = 5  # 二进制: 0101

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

"""
这是一个示例模块，用于演示文档字符串的使用。
该模块包含一个简单的加法函数。
"""

def add_numbers(a, b):
    """
    该函数用于计算两个数的和。

    参数:
    a (int): 第一个加数。
    b (int): 第二个加数。

    返回:
    int: 两个数的和。
    """
    return a + b

1

print(add_numbers.__doc__)

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

import pandas as pd

# 第一步：读取数据
data = pd.read_csv('data.csv')

# 第二步：数据清洗，去除缺失值
data = data.dropna()

# 第三步：数据转换，对某一列数据进行平方运算
data['new_column'] = data['old_column'] ** 2

# 第四步：保存处理后的数据
data.to_csv('processed_data.csv', index=False)

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

age = 25
gender = "female"

# 外层 if 语句判断年龄是否大于等于 18 岁
if age >= 18:
    print("你已经成年了。")
    # 内层 if 语句判断性别
    if gender == "male":
        print("你是成年男性。")
    elif gender == "female":
        print("你是成年女性。")
    else:
        print("未知性别。")
else:
    print("你还未成年。")

1
2
3
4
5
6
7
8

age = 20
is_student = True
has_job = False

if (age >= 18 and is_student) or (not has_job):
    print("你符合特定条件。")
else:
    print("你不符合特定条件。")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

match 表达式:
    case 模式1:
        # 当表达式匹配模式1时执行的代码
        pass
    case 模式2:
        # 当表达式匹配模式2时执行的代码
        pass
    case _:
        # 当表达式不匹配前面任何模式时执行的代码，_ 是通配符
        pass

1
2
3
4
5
6
7
8
9

day = "Monday"

match day:
    case "Monday":
        print("今天是周一，开始新的一周啦！")
    case "Friday":
        print("今天是周五，马上就到周末咯！")
    case _:
        print(f"今天是 {day}，继续加油哦！")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

point = (2, 3)
match point:
    case (0, 0):
        print("该点是原点。")
    case (x, 0):
        print(f"该点在 x 轴上，x 坐标为 {x}。")
    case (0, y):
        print(f"该点在 y 轴上，y 坐标为 {y}。")
    case (x, y):
        print(f"该点的坐标为 ({x}, {y})。")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

numbers = [1, 2, 3]

match numbers:
    case []:
        print("这是一个空列表。")
    case [x]:
        print(f"列表中只有一个元素 {x}。")
    case [x, y]:
        print(f"列表中有两个元素 {x} 和 {y}。")
    case [x, *rest]:
        print(f"列表的第一个元素是 {x}，其余元素是 {rest}。")

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

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

numbers = (1, 2, 3, 4, 5)
for num in numbers:
    print(num * 2)

word = "Hello"
for char in word:
    print(char)

for key, value in person.items():
    print(f"{key}: {value}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 打印 0 到 4 的整数
for i in range(5):
    print(i)

# 打印 2 到 6 的整数
for i in range(2, 7):
    print(i)

# 打印 2 到 10 之间的偶数
for i in range(2, 11, 2):
    print(i)

1
2
3
4

count = 0
while count < 5:
    print(count)
    count = count + 1

1
2
3
4

while True:
    user_input = input("请输入 'q' 退出循环: ")
    if user_input == 'q':
        break

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

# 预设正确的用户名和密码
correct_username = "admin"
correct_password = "123456"

while True:
    # 获取用户输入的用户名和密码
    username = input("请输入用户名: ")
    password = input("请输入密码: ")

    # 检查输入的用户名和密码是否正确
    if username == correct_username and password == correct_password:
        print("登录成功！")
        break
    else:
        print("用户名或密码错误，请重新输入。")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 定义长方形的行数和列数
rows = 5
columns = 10

# 外层循环控制行数
for i in range(rows):
    # 内层循环控制列数
    for j in range(columns):
        print('*', end=' ')
    # 每一行打印完后换行
    print()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 定义三角形的行数
rows = 5

# 外层循环控制行数
for i in range(rows):
    # 内层循环控制每行打印的星号数量
    for j in range(i + 1):
        print('*', end=' ')
    # 每一行打印完后换行
    print()

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

# 菱形的总行数，这里设为 9，可以根据需要调整
n = 9
# 上半部分
for i in range(n // 2 + 1):
    # 打印空格
    for j in range(n // 2 - i):
        print(" ", end="")
    # 打印星号
    for k in range(2 * i + 1):
        print("*", end="")
    print()

# 下半部分
for i in range(n // 2):
    # 打印空格
    for j in range(i + 1):
        print(" ", end="")
    # 打印星号
    for k in range(n - 2 * (i + 1)):
        print("*", end="")
    print()

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

# 菱形的总行数，这里设为 9，可以根据需要调整
n = 9
# 上半部分
for i in range(n // 2 + 1):
    # 打印空格
    for j in range(n // 2 - i):
        print(" ", end="")
    # 打印星号和空格
    for k in range(2 * i + 1):
        if k == 0 or k == 2 * i:
            print("*", end="")
        else:
            print(" ", end="")
    print()

# 下半部分
for i in range(n // 2):
    # 打印空格
    for j in range(i + 1):
        print(" ", end="")
    # 打印星号和空格
    for k in range(n - 2 * (i + 1)):
        if k == 0 or k == n - 2 * (i + 1) - 1:
            print("*", end="")
        else:
            print(" ", end="")
    print()

1
2
3
4
5

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for num in numbers:
    if num == 5:
        break
    print(num)

1
2
3
4
5

for i in range(3):
    for j in range(3):
        if i == 1 and j == 1:
            break
        print(f"i = {i}, j = {j}")

1
2
3
4
5
6

count = 0
while True:
    if count == 5:
        break
    print(count)
    count = count + 1

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

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for num in numbers:
    if num % 2 == 0:
        continue
    print(num)

count = 0
while count < 10:
    count = count + 1
    if count % 3 == 0:
        continue
    print(count)

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

def future_function():
    # 这里的功能还未实现，先用 pass 占位
    pass

class FutureClass:
    def __init__(self):
        # 初始化方法的具体实现稍后完成
        pass

    def some_method(self):
        # 方法的具体逻辑还未编写
        pass

1
2
3
4
5
6
7

num = 10
if num < 5:
    print("数字小于 5")
elif num > 15:
    pass  # 暂时不处理数字大于 15 的情况
else:
    print("数字在 5 到 15 之间")

1
2
3
4
5
6

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        pass  # 当数字为 3 时，不做任何操作
    else:
        print(num)

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

# 字符串示例
string_example = "Hello"
print(string_example[0])  # 输出: H
print(string_example[-1])  # 输出: o

# 列表示例
list_example = [10, 20, 30, 40, 50]
print(list_example[2])  # 输出: 30
print(list_example[-3])  # 输出: 30

# 元组示例
tuple_example = (1, 2, 3, 4, 5)
print(tuple_example[4])  # 输出: 5
print(tuple_example[-2])  # 输出: 4

1
2
3
4
5
6
7

# 字符串切片
string_example = "HelloWorld"
print(string_example[1:5])  # 输出: ello
print(string_example[:5])  # 输出: Hello
print(string_example[6:])  # 输出: World
print(string_example[::2])  # 输出: Hlool，步长为 2，每隔一个字符取一个，得到 Hlool。
print(string_example[::-1])  # 输出: dlroWolleH，步长为 -1，从后往前取元素，实现字符串反转，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

string1 = "Hello"
string2 = " World"
print(string1 + string2)  # 输出: Hello World

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2)  # 输出: [1, 2, 3, 4, 5, 6]

tuple1 = (10, 20)
tuple2 = (30, 40)
print(tuple1 + tuple2)  # 输出: (10, 20, 30, 40)

1
2
3
4
5
6
7
8

string_example = "Hi"
print(string_example * 3)  # 输出: HiHiHi

list_example = [1, 2]
print(list_example * 2)  # 输出: [1, 2, 1, 2]

tuple_example = (10,)
print(tuple_example * 3)  # 输出: (10, 10, 10)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

string_example = "Python"
print('y' in string_example)  # 输出: True
print('z' not in string_example)  # 输出: True

list_example = [10, 20, 30]
print(20 in list_example)  # 输出: True
print(40 not in list_example)  # 输出: True

tuple_example = (1, 2, 3)
print(3 in tuple_example)  # 输出: True
print(4 not in tuple_example)  # 输出: True

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

string_example = "Python"
print(len(string_example))  # 输出: 6
print(max(string_example))  # 输出: y
print(min(string_example))  # 输出: P

list_example = [10, 20, 30, 40, 50]
print(len(list_example))  # 输出: 5
print(max(list_example))  # 输出: 50
print(min(list_example))  # 输出: 10

tuple_example = (1, 2, 3, 4, 5)
print(len(tuple_example))  # 输出: 5
print(max(tuple_example))  # 输出: 5
print(min(tuple_example))  # 输出: 1

1
2
3

fruits = ['apple', 'banana', 'cherry']

print(len(fruits))  # 输出: 3

1
2
3
4

fruits = ['apple', 'banana', 'cherry']

print('banana' in fruits)  # 输出: True
print('grape' not in fruits)  # 输出: True

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

fruits = ['apple', 'banana']

# append() 方法
fruits.append('cherry')
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

# extend() 方法
more_fruits = ['grape', 'kiwi']
fruits.extend(more_fruits)
print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'grape', 'kiwi']

# insert() 方法
fruits.insert(1, 'lemon')
print(fruits)  # 输出: ['apple', 'lemon', 'banana', 'cherry', 'grape', 'kiwi']

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

fruits = ['apple', 'banana', 'cherry', 'grape']
# del 语句
del fruits[1]
print(fruits)  # 输出: ['apple', 'cherry', 'grape']

# remove() 方法
fruits.remove('cherry')
print(fruits)  # 输出: ['apple', 'grape']

# pop() 方法
popped_fruit = fruits.pop()
print(popped_fruit)  # 输出: grape
print(fruits)  # 输出: ['apple']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# sort() 方法
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# sorted() 函数
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
print(numbers)  # 输出: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

1
2
3

numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)  # 输出: [5, 4, 3, 2, 1]

1
2

# 生成一个包含 0 到 9 的平方的列表
squares = [ i**2 for i in range(10) ]

1
2

# 生成一个包含 0 到 9 中偶数的平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]

1
2
3
4
5
6
7
8
9

# 创建一个 3 行 4 列的二维列表，初始值都为 0
rows = 3
cols = 4
matrix = []
for i in range(rows):
    row = []
    for j in range(cols):
        row.append(0)
    matrix.append(row)

1
2
3
4
5

# 创建一个 3 行 4 列的二维列表，初始值都为 0
rows = 3
cols = 4
matrix = [[0 for j in range(cols)] for i in range(rows)]
print(matrix)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 创建一个包含多个元素的元组
fruits = ('apple', 'banana', 'cherry')
print(fruits)

# 创建只包含一个元素的元组，需要在元素后面加逗号
single_element_tuple = ('apple',)
print(single_element_tuple)

# 创建空元组
empty_tuple = ()
print(empty_tuple)

1
2
3
4
5
6
7
8
9

# 将列表转换为元组
list_numbers = [1, 2, 3]
tuple_numbers = tuple(list_numbers)
print(tuple_numbers)

# 将字符串转换为元组
string = "hello"
tuple_from_string = tuple(string)
print(tuple_from_string)

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

# 创建一个元组
animals = ('dog', 'cat', 'bird')
print(animals)

# 删除元组
del animals

# 尝试访问已删除的元组会引发 NameError
try:
    print(animals)
except NameError:
    print("元组已被删除，无法访问。")

1
2
3
4

langs = ('en', 'zh', 'fr')

for lang in range(langs):
    print(lang)

1
2
3
4
5
6
7
8

# 创建一个生成器表达式
generator_expression = (i ** 2 for i in range(5))

# 输出 <generator object <genexpr> at 0x...>
print(generator_expression)

# 将生成器表达式转换为元组
tuple_result = tuple(generator_expression)

1

tuple_result = tuple((i ** 2 for i in range(5)))

1
2
3
4
5
6
7
8
9

# 创建空字典
empty_dict = {}

# 创建包含键值对的字典
student = {
    'name': 'Alice',
    'age': 20,
    'major': 'Computer Science'
}

1
2
3
4
5
6

# 从键值对元组的列表创建字典
pairs = [('name', 'Bob'), ('age', 22), ('major', 'Mathematics')]
student_from_pairs = dict(pairs)

# 使用关键字参数创建字典
student_from_kwargs = dict(name='Charlie', age=21, major='Physics')

1
2

# 创建一个字典，键是 1 到 5 的数字，值是其平方
squares = {i: i ** 2 for i in range(1, 6)}

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

person = {
    'name': 'David',
    'age': 25,
    'city': 'New York'
}

# 使用 del 语句删除键为 'age' 的键值对
del person['age']
print(person)

# 使用 pop() 方法删除键为 'city' 的键值对，并返回该键对应的值
city = person.pop('city')
print(f"被删除的城市是: {city}")
print(person)

1
2
3
4
5
6
7
8
9

book = {
    'title': 'Python Crash Course',
    'author': 'Eric Matthes',
    'year': 2015
}

# 清空字典
book.clear()
print(book)

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

car = {
    'brand': 'Toyota',
    'model': 'Corolla',
    'year': 2020
}

# 删除字典对象
del car

# 尝试访问已删除的字典会引发 NameError
try:
    print(car)
except NameError:
    print("字典已被删除，无法访问。")

1
2
3
4
5
6
7

student = {
    'name': "mike"
}

student['name']

student.get('name', '匿名')

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

student = {
    'name': 'Mike',
    'age': 20
}

for key in student.keys():
    print(key)

for value in student.values():
    print(value)

for key, value in student.items():
    print(key, value)

1
2
3

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)

1
2
3

my_dict = {'name': 'Alice', 'age': 20}
my_dict['age'] = 21  # 修改已有键的值
my_dict['city'] = 'New York'  # 添加新的键值对

1
2
3
4

original_dict = {'name': 'Henry', 'hobbies': ['reading', 'swimming']}
copied_dict = original_dict.copy()

print(copied_dict)  # 输出: {'name': 'Henry', 'hobbies': ['reading', 'swimming']}

1
2
3
4
5
6
7
8

my_dict = {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}
age = my_dict.pop('age')
print(age)  # 输出: 25
print(my_dict)  # 输出: {'name': 'Bob', 'city': 'Los Angeles'}

# 尝试删除不存在的键，提供默认值
result = my_dict.pop('gender', 'unknown')
print(result)  # 输出: unknown

1
2
3
4
5
6
7

my_dict = {'name': 'David', 'age': 35}

# 删除某个键值对
del my_dict['age']

# 删除整个字典
del my_dict

1
2
3

my_dict = {'name': 'Eve', 'age': 40}
my_dict.clear()
print(my_dict)  # 输出: {}

1
2
3

squares_dict = { i: i ** 2 for i in range(1, 6) }

print(squares_dict)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 创建包含多个元素的集合
fruits = {'apple', 'banana', 'cherry'}
print(fruits)

# 创建包含重复元素的集合，重复元素会被自动去除
numbers = {1, 2, 2, 3, 4, 4}
print(numbers)

# 不能使用 {} 创建空集合，因为 {} 会创建一个空字典
empty_dict = {}
print(type(empty_dict))  # 输出 <class 'dict'>

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

# 将列表转换为集合
list_numbers = [1, 2, 3, 3, 4]
set_numbers = set(list_numbers)
print(set_numbers)

# 将字符串转换为集合，字符串中的每个字符会成为集合的一个元素
string = "hello"
set_from_string = set(string)
print(set_from_string)

# 使用 set() 创建空集合
empty_set = set()
print(empty_set)
print(type(empty_set))  # 输出 <class 'set'>

1
2
3
4
5
6
7
8
9

fruits = {'apple', 'banana', 'cherry'}
fruits.remove('banana')
print(fruits)

# 尝试删除不存在的元素，会抛出 KeyError 异常
try:
    fruits.remove('grape')
except KeyError:
    print("指定的元素不存在")

1
2
3
4
5
6
7

fruits = {'apple', 'cherry'}
fruits.discard('cherry')
print(fruits)

# 尝试删除不存在的元素，不会抛出异常
fruits.discard('grape')
print(fruits)

1
2
3

fruits = {'apple', 'banana', 'cherry'}
fruits.clear()
print(fruits)  # 输出 set()

1
2
3
4
5
6
7
8

numbers = {1, 2, 3}
del numbers

# 尝试访问已删除的集合会引发 NameError
try:
    print(numbers)
except NameError:
    print("集合已被删除，无法访问。")

1
2
3
4

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2
print(union_set) 

1
2
3
4

set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1 & set2
print(intersection_set) 

1
2
3
4

set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1 - set2
print(difference_set)  

1
2
3
4

set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)  

1
2
3
4

set1 = {1, 2}
set2 = {1, 2, 3}
print(set1 < set2)  
print(set1 <= set2) 

1
2
3
4

set1 = {1, 2, 3}
set2 = {1, 2}
print(set1 > set2)  
print(set1 >= set2)  

1
2
3
4
5

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}
my_set.add(2)
print(my_set)  # 输出: {1, 2, 3, 4}，因为 2 已存在，集合不会改变

1
2
3
4

my_set = {1, 2, 3}
new_elements = [3, 4, 5]
my_set.update(new_elements)
print(my_set)  # 输出: {1, 2, 3, 4, 5}，重复元素 3 只保留一个

1
2
3
4
5
6
7

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)  # 输出: {1, 3}
try:
    my_set.remove(4)
except KeyError:
    print("指定的元素不存在")

1
2
3
4
5

my_set = {1, 2, 3}
my_set.discard(2)
print(my_set)  # 输出: {1, 3}
my_set.discard(4)
print(my_set)  # 输出: {1, 3}，因为 4 不存在，集合不变

1
2
3

my_set = {'apple', 'banana', 'cherry'}
for element in my_set:
    print(element)

1
2
3
4
5
6
7
8
9

match data:
    case { 'age': 20 }:
        print(1)
    case [1, 2]:
        print(2)
    case (1, 2, 3):
        print(3)
    case _:
        print('相当于通配符，多重条件中的 else')

1
2
3
4
5

a = { 'name': 10, 'age': 20 }
b = { 'add': 'Beijing' }
c = { 'date': '2025' }
print(a | b | c)
# 可以合并多个字典，如果是重复的键名，取后一个的值，类似 Object.assign()

1
2
3
4
5
6
7
8
9

fruits = ['apple', 'orange']
counts = [1, 2]

for f, c in zip(fruits, counts):
    match f, c:
        case 'apple', 1:
            print(1)
        case 'orange', 2:
            print(2)

1
2
3
4
5
6
7
8
9

ages = [89, 92, 00]

# 循环列表，对元素进行判断，不考虑 02，03 这种情况
for i in range(len(ages)):
    if (str(ages[i])) == '0':
        ages[i] = '200' + str(ages[i])
    else:
        ages[i] = '19' + str(ages[i]) # 注意这里是 str，不是 string
print(ages)

1
2
3
4
5
6

for i, value in enumerate(ages):
    if (str(value)) == '0':
        ages[i] = '200' + str(value)
    else:
        ages[i] = '19' + str(value)
print(ages)

1
2
3
4
5
6
7
8

s = set()

for i in range(1, 6):
    info = input(f'请输入{i}好友的信息')
    s.add(info)

for i in s:
    print(i)

1
2

s = "hello"
s.upper()

1
2

s = "WORLD"
s.lower()

1
2
3

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

1
2

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

1
2

s = "HeLlO"
print(s.swapcase())  # 输出: hElLo

1
2

s = "hello world"
print(s.find("world"))  # 输出: 6

1
2

s = "hello world world"
print(s.rfind("world"))  # 输出: 12

1
2
3
4
5

s = "hello world"
try:
    print(s.index("world"))  # 输出: 6
except ValueError:
    print("未找到子字符串")

1
2
3
4
5

s = "hello world world"
try:
    print(s.rindex("world"))  # 输出: 12
except ValueError:
    print("未找到子字符串")

1
2

s = "hello world"
print(s.replace("world", "python"))  # 输出: hello python

1
2
3
4

s = "   hello   "
s.strip()  # 输出: hello
s.lstrip()
s.rstrip()

1
2

s = "hello world"
print(s.split())  # 输出: ['hello', 'world']

1
2

s = "hello\nworld"
print(s.splitlines())  # 输出: ['hello', 'world']

1
2
3

words = ['hello', 'world']
s = " ".join(words)
print(s)  # 输出: hello world

1

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

1

print(s.endswith("world"))  # 输出: True

1
2

s = "Hello, {}! Your age is {}."
print(s.format("Alice", 25))  # 输出: Hello, Alice! Your age is 25.

1

"格式化字符串" % (值1, 值2, ...)

1
2
3
4
5
6
7
8

# 格式化字符串和整数
name = "Alice"
age = 25
print("My name is %s and I'm %d years old." % (name, age))

# 格式化浮点数
pi = 3.1415926
print("The value of pi is approximately %.2f." % pi)

1

"格式化字符串".format(值1, 值2, ...)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 使用位置索引
name = "Bob"
age = 30
print("My name is {} and I'm {} years old.".format(name, age))

# 使用关键字参数
print("My name is {name} and I'm {age} years old.".format(name="Charlie", age=35))

# 格式化浮点数
pi = 3.1415926
print("The value of pi is approximately {:.2f}.".format(pi))

1

f"格式化字符串"

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

name = "David"
age = 40
print(f"My name is {name} and I'm {age} years old.")

# 格式化浮点数
pi = 3.1415926
print(f"The value of pi is approximately {pi:.2f}.")

# 执行表达式
x = 5
y = 3
print(f"The result of {x} + {y} is {x + y}.")

1
2
3
4
5
6
7
8

# 左对齐，填充字符为 *
print("{:*<10}".format("hello"))  # 输出: hello*****

# 右对齐，填充字符为 -
print("{:-<10}".format("hello"))  # 输出: -----hello

# 居中对齐，填充字符为 =
print("{:=^10}".format("hello"))  # 输出: ==hello===

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 显示正负号
print("{:+d}".format(10))  # 输出: +10
print("{:+d}".format(-10))  # 输出: -10

# 只显示负号
print("{:d}".format(10))  # 输出: 10
print("{:d}".format(-10))  # 输出: -10

# 正数前显示空格
print("{: d}".format(10))  # 输出:  10
print("{: d}".format(-10))  # 输出: -10

1
2
3
4
5
6
7
8

# 二进制
print("{:#b}".format(10))  # 输出: 0b1010

# 八进制
print("{:#o}".format(10))  # 输出: 0o12

# 十六进制
print("{:#x}".format(10))  # 输出: 0xa

1
2

# 宽度为 8
print("{:8d}".format(123))  # 输出:     123

1
2

# 添加千位分隔符
print("{:,}".format(1234567))  # 输出: 1,234,567

1
2
3
4

# 浮点数精度
print("{:.2f}".format(3.14159))  # 输出: 3.14
# 字符串最大长度
print("{:.5}".format("abcdefg"))  # 输出: abcde

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 字符串类型
print("{:s}".format("hello"))  # 输出: hello

# 二进制整数
print("{:b}".format(10))  # 输出: 1010

# 浮点数
print("{:f}".format(3.14))  # 输出: 3.140000

# 科学计数法
print("{:e}".format(123456))  # 输出: 1.234560e+05

1

str.encode(encoding='utf-8', errors='strict')

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

# 定义一个字符串
s = "你好，世界！"

# 使用 UTF-8 编码
utf8_bytes = s.encode('utf-8')
print(utf8_bytes)  # 输出类似: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'

# 使用 GBK 编码
gbk_bytes = s.encode('gbk')
print(gbk_bytes)  # 输出类似: b'\xc4\xe3\xba\xc3\xa3\xac\xca\xc0\xbd\xe7\xa3\xa1'

# 处理编码错误
try:
    s.encode('ascii')
except UnicodeEncodeError:
    print("使用 ASCII 编码时出现错误，因为 ASCII 无法编码中文。")

# 忽略无法编码的字符
ascii_bytes_ignore = s.encode('ascii', errors='ignore')
print(ascii_bytes_ignore)  # 输出: b''

# 用 ? 替换无法编码的字符
ascii_bytes_replace = s.encode('ascii', errors='replace')
print(ascii_bytes_replace)  # 输出: b'??????'

1

bytes.decode(encoding='utf-8', errors='strict')

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

# 定义一个 UTF-8 编码的字节序列
utf8_bytes = b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'

# 使用 UTF-8 解码
utf8_string = utf8_bytes.decode('utf-8')
print(utf8_string)  # 输出: 你好，世界！

# 定义一个 GBK 编码的字节序列
gbk_bytes = b'\xc4\xe3\xba\xc3\xa3\xac\xca\xc0\xbd\xe7\xa3\xa1'

# 使用 GBK 解码
gbk_string = gbk_bytes.decode('gbk')
print(gbk_string)  # 输出: 你好，世界！

# 错误的解码方式
try:
    utf8_bytes.decode('gbk')
except UnicodeDecodeError:
    print("使用错误的编码方式解码会出现错误。")

# 忽略无法解码的字节
wrong_bytes = b'\xff'
decoded_ignore = wrong_bytes.decode('utf-8', errors='ignore')
print(decoded_ignore)  # 输出: ''

# 用 � 替换无法解码的字节
decoded_replace = wrong_bytes.decode('utf-8', errors='replace')
print(decoded_replace)  # 输出: �

1
2
3
4
5
6
7
8

num = 123
str3 = "The number is: "
# 正确做法，先将数字转换为字符串
result2 = str3 + str(num)
print(result2)  # 输出: The number is: 123

# 错误示例，会引发 TypeError
# result3 = str3 + num

1
2
3
4

words = ["Hello", "World", "!"]
separator = " "
result = separator.join(words)
print(result)  # 输出: Hello World !

1
2
3
4
5

numbers = [1, 2, 3]
str_numbers = [str(num) for num in numbers]
separator = "-"
result = separator.join(str_numbers)
print(result)  # 输出: 1-2-3

1
2
3

string = "hello world"
unique_chars = ''.join(set(string))
print(unique_chars)

1
2
3
4
5
6

string = "hello world"
result = ""
for char in string:
    if char not in result:
        result += char
print(result)

1
2
3
4
5

from collections import OrderedDict

string = "hello world"
unique_chars = ''.join(OrderedDict.fromkeys(string))
print(unique_chars)

1
2
3
4

string = "hello world"
seen = set()
result = ''.join([char for char in string if not (char in seen or seen.add(char))])
print(result)

1
2
3
4
5
6
7
8
9

import re

pattern = re.compile(r'\d+')

string = 'There are 12 apples and 3 oranges'

result = pattern.findall(string)

print("匹配结果:", result)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import re

pattern = r'hello'
string = 'hello world'

result = re.match(pattern, string)

if result:
    print("匹配成功:", result.group())
else:
    print("匹配失败")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import re

pattern = r'world'
string = 'hello world'

result = re.search(pattern, string)

if result:
    print("匹配成功:", result.group())
else:
    print("匹配失败")

1
2
3
4
5
6
7
8

import re

pattern = r'\d+'  # 匹配一个或多个数字
string = 'There are 12 apples and 3 oranges'

result = re.findall(pattern, string)

print("匹配结果:", result)

1
2
3
4
5
6
7
8

import re

pattern = r'apple'
string = 'I like apple, apple is delicious'

new_string = re.sub(pattern, 'banana', string)

print("替换后的字符串:", new_string)

1
2
3

text = "Hello  World!  Python"
result = text.split()
print(result)