Python 知识库

1. 静态语言 vs 动态语言

静态语言
- 编译时类型检查
- 执行速度快，但编译时间较长
- 示例语言：C, C++, C#, Java, Kotlin, Scala, Rust, Go 等
动态语言
- 运行时进行类型检查和绑定
- 执行速度较慢，但开发效率高，适用于脚本编写和小型项目
- 动态语言（也称脚本语言）
- 示例语言: Python, Groovy, JavaScript, Ruby, PHP 等

2. 杂项

2.1 None

None 是一个特殊的 Python 值，在没有什么值适合的时候，作为无意义的占位之用

用法1：可选参数

def greet(name=None):
    print(name)

用法2：函数的默认返回值

def no_return():
    pass

result = no_return()
print(result)  # 输出: None

用法3: 初始化变量

value = None

2.2 海象运算符（walrus operator）

海象运算符正式名称为“赋值表达式”，是在 Python 3.8 中引入的一个新特性
语法：name := expression

示例：

numbers = [1, 2, 3, 4, 5]
squares = []
for number in numbers:
    square = number ** 2
    if square > 10:
        squares.append(square)
print(squares)  # 输出: [16, 25]

写法一：列表推导式

numbers = [1, 2, 3, 4, 5]
squares = [number ** 2 for number in numbers if number ** 2 > 10]
print(squares)

写法二：海象运算符

numbers = [1, 2, 3, 4, 5]
squares = [square for number in numbers if (square := number ** 2) > 10]
print(squares)

2.3 多行字符串

template = (
    "..."
    "..."
    "..."
)

注：此()非元组

2.4 延迟类型注解（Forward Reference）

这是一种在定义类或函数时，引用尚未定义的类或类型的方式，特别是在类方法中引用当前类时
语法 'className'

class Node:
    def get_next(self) -> 'Node':
        return self.next

注：Python 3.7 开始，引入 from __future__ import annotations 特性。启用此特性后，所有类型注解都会被自动存储为字符串形式，从而无需手动加引号

2.5 正则

re.compile(r"[^.]*")
r"" 表示原始字符串（raw string），避免转义字符（如 \）被 Python 解释器处理
^ 在字符集中表示取反
[^.] 是一个字符集，匹配除了点号（.）之外的任意字符
*表示零次或多次

2.6 数学函数

import math

print(math.pi)
print(math.e)

3. 推导式

3.1 列表推导式

语法：

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]
or
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

示例：

names = ['Tom', 'Alice', 'Jerry', 'Smith']
new_names = [name.upper() for name in names if len(name) > 3]
print(new_names) # ['ALICE', 'JERRY', 'SMITH']

3.2 字典推导式

{ key_expr: value_expr for value in collection }
or
{ key_expr: value_expr for value in collection if condition }

web_list = ['Google', 'Meta', 'Taobao']
# 字符串值为键，字符串的长度为值
new_dict = {key: len(key) for key in web_list}
print(new_dict)

3.3 元组推导式

(expression for item in Sequence )
or
(expression for item in Sequence if conditional )

numbers = (x for x in range(1, 5))
print(f'type(numbers):{type(numbers)}, numbers:{numbers}') # 返回的是生成器对象
# type(numbers):<class 'generator'>, numbers:<generator object <genexpr> at 0x108911c00>

# 转为元组
print(tuple(numbers)) # (1, 2, 3, 4)

3.4 集合推导式

{ expression for item in Sequence }
or
{ expression for item in Sequence if conditional }

numbers = {i ** 2 for i in (1, 2, 3)}
print(f'type(numbers):{type(numbers)}, numbers:{numbers}')
# type(numbers):<class 'set'>, numbers:{1, 4, 9}

set_chars = {x for x in 'abcdbuddy' if x not in 'abc'}
print(set_chars) # {'y', 'u', 'd'}

3.5 代码分析

embeddings: List[List[float]] = [[] for _ in range(len(texts))]

embeddings: List[List[float]]: 类型注解，表示变量 embeddings 是一个列表的列表
for _ in range(len(texts)): 列表推导式的循环部分，循环 len(texts) 次
[[] ...]：对于每次迭代，都会创建一个新的空列表 [] 并将其添加到外部列表中

3. 内部模块

3.1 typing 模块

typing 模块是在 Python 3.5 版本中引入的，提供类型提示和类型检查的能力

示例：

def __init__(
    self,
    data=None,
    index: Optional[Axes] = None,
    columns: Optional[Axes] = None,
    dtype: Optional[Dtype] = None,
    copy: bool = False,
):

新特性写法

def __init__(
    self,
    data=None,
    index: Axes | None = None,
    columns: Axes | None = None,
    dtype: Dtype | None = None,
    copy: bool | None = None,
) -> None:

| 符号表示联合类型，可以是给定类型中的任意一种

3.2 builtins.py 模块

builtins 模块包含Python内置的所有函数、异常以及其他对象

isinstance() 检查对象是否是特定类的实例
issubclass() 检查一个类是否是另一个类的子类
hasattr() 用于检查对象是否实现了特定的方法或属性

def isinstance(x, A_tuple):
    pass

def issubclass(x, A_tuple):
    pass

def hasattr(*args, **kwargs):
    pass

示例：

class Animal:
    def greet(self):
        return "I am an animal."

class Dog(Animal):
    def greet(self):
        return "I am a Dog."

class Cat(Animal):
    def greet(self):
        return "I am a Cat."

if __name__ == '__main__':
    # 创建实例
    dog = Dog()
    print(isinstance(dog, Animal))

    print(issubclass(Dog, Animal))
    print(issubclass(Dog, (Animal, Cat)))

    print(hasattr(dog, 'greet'))

4. 解包运算符（unpacking operator）

4.1 字典解包 (**)

解包并合并
{**dict1, **dict2} 将两个字典合并成一个新的字典

dict1 = {'param1': 'value1', 'param2': 'value2'}
dict2 = {'param2': 'new_value', 'param3': 'value3'}

combined_params = {**dict1, **dict2}
print(combined_params)

注：若有相同的键，后面的字典中的值会覆盖前面字典中的值

4.2 列表解包 (*)

def sum_number(x, y, z):
    return x + y + z

numbers = [1, 2, 3]
result = sum_number(*numbers)
print(result)  # 输出: 6

解包并合并

list1 = [1, 2, 3]
list2 = [4, 5, 6]

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

4.3 元组解包 (*)

方式一：赋值给多个变量

temp = ("first", "second", "third")
first, second, third = temp
print(first, second, third)

方式二：元组的每个元素作为位置参数

def print_tuple(first, second, third):
    print(first, second, third)

temp = (1, 2, 3)
print(*temp)

4.4 函数参数解包 (*args, **kwargs)

用来接收不定数量的参数

def func(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

func(1, 2, 3, a=4, b=5)

4.5 解包示例

cars_age = [0, 9, 4, 8, 7]
cars_age_desc = sorted(cars_age, reverse=True)
print(cars_age_desc)

# 取最旧的两辆车和其他
oldest_car, second_oldest_car, others = cars_age_desc[0], cars_age_desc[1], cars_age_desc[2:]
print(oldest_car, second_oldest_car, others)

# 解包方式（在把列表拆解成互相不重叠的多个部分时，建议使用 *unpacking）
oldest_car, second_oldest_car, *others = cars_age_desc
print(oldest_car, second_oldest_car, others)

# 带星号(*)的表达式可以出现在任意位置，所以它能够捕获序列中的任何一段元素
oldest, *others, youngest = cars_age_desc
print(oldest, others, youngest)

# 星号(*)只能出现在 多变量赋值 中，不能单独存在
# *others = cars_age # Error
# 改进：直接用赋值 others = cars_age

5. 示例

5.1 方法引用

DataFrame.head() 方法调用
DataFrame.head 方法引用

import pandas as pd

filepath = '../datasets/house.csv'
df = pd.read_csv(filepath)
print(df.head())

df_head = df.head
print(df_head(6))

分析：

def read_csv(
    filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str],
    ...
    dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
) -> DataFrame | TextFileReader:
    ...

class DataFrame(NDFrame, OpsMixin):
    ...

class NDFrame(PandasObject, indexing.IndexingMixin):
    @final
    def head(self: NDFrameT, n: int = 5) -> NDFrameT:
        ...

5.2 类实例作为函数调用

比如：

from transformers import pipeline

classifier = pipeline("text-classification")
outputs = classifier(text)

分析：

def pipeline(
    task: str = None,
    ...
    **kwargs,
) -> Pipeline:
    ...

class Pipeline(_ScikitCompat, PushToHubMixin):
    ...

class TextClassificationPipeline(Pipeline):
    def __call__(self, inputs, **kwargs):
        ...

__call__ 将一个类实例当做函数调用

6. 代码换行

续行字符 \（反斜线），只需把 \ 放在行尾，Python 就会认为后续内容仍在同一行
小窍门：如果位于一对圆括号（也可以是方括号或花括号）内部，也可以直接换行

方式一：反斜杠 \

sum = 1 + 2 \
    + 3

方式二：括号()

sum = (1
       + 2
       + 3)

方式三：块注释 """"""

a = """
*
**
"""

Python 知识库

1. 静态语言 vs 动态语言

2. 杂项

2.1 None

2.2 海象运算符（walrus operator）

2.3 多行字符串

2.4 延迟类型注解（Forward Reference）

2.5 正则

2.6 数学函数

3. 推导式

3.1 列表推导式

3.2 字典推导式

3.3 元组推导式

3.4 集合推导式

3.5 代码分析

3. 内部模块

3.1 typing 模块

3.2 builtins.py 模块

4. 解包运算符（unpacking operator）

4.1 字典解包 (**)

4.2 列表解包 (*)

4.3 元组解包 (*)

4.4 函数参数解包 (*args, **kwargs)

4.5 解包示例

5. 示例

5.1 方法引用

5.2 类实例作为函数调用

6. 代码换行

推荐阅读更多精彩内容