开启6379端口

用户151290545220
59 阅读14分钟

🔹 1. 确认 Redis 已经在监听 6379 端口

先看 Redis 是否在跑：

| ps -ef | grep redis | | ---------------------- |

确认端口：

| netstat -tulnp | grep 6379 | | ----------------------------- |

# 或

| ss -tulnp | grep 6379 | | ------------------------ |

如果有输出类似：

tcp   LISTEN 0   128   0.0.0.0:6379   0.0.0.0:*   users:(("redis-server",pid=1234,fd=6))

说明 Redis 已经在监听 6379。

🔹 2. 修改 Redis 配置（允许外部访问）

编辑配置文件（一般在 /etc/redis/redis.conf 或 /etc/redis.conf）：

vim /etc/redis/redis.conf

找到这一行：

bind 127.0.0.1

改成：

bind 0.0.0.0

确认 protected-mode 是关闭的（如果你需要远程访问）：

protected-mode no

保存后重启 Redis：

systemctl restart redis
# 或
service redis restart

🔹 3. 开放防火墙端口（Linux）

如果你用的是 firewalld：

firewall-cmd --zone=public --add-port=6379/tcp --permanent
firewall-cmd --reload

如果你用的是 ufw（Ubuntu 常见）：

ufw allow 6379/tcp
ufw reload

iptables（老系统）

iptables -A INPUT -p tcp --dport 6379 -j ACCEPT
service iptables save

🔹 4. 云服务器安全组

如果你是在 阿里云 / 腾讯云 / AWS / GCP 上，要去对应的 安全组规则 里，把 6379 端口（TCP） 放行。否则外网访问不到。

🔹 5. 测试是否能连通

在远程机器上执行：

telnet <服务器IP> 6379

如果能连上，就说明端口已经开通。

或者直接用 redis-cli：

redis-cli -h <服务器IP> -p 6379

⚠️ 安全提示：
6379 端口不要直接裸奔暴露在公网，否则很容易被攻击！
✅ 最好做法：

  • 开启密码认证（在 redis.conf 配置 requirepass yourpassword）
  • 或者只允许内网访问（不要 bind 0.0.0.0，改成你的内网 IP）。

好👌 阿杰，我给你一份 Redis 远程访问安全配置清单，这样你开了 6379 端口也能比较安全。

🔐 Redis 远程访问安全配置清单

1. 设置密码认证

编辑 redis.conf（路径一般是 /etc/redis/redis.conf）：

requirepass StrongPassword123!

⚠️ 建议使用强密码（大小写 + 数字 + 特殊符号，至少 12 位）。

测试：

redis-cli -h <服务器IP> -p 6379 -a StrongPassword123!

2. 限制绑定的 IP

如果只允许某些服务器连，就不要 0.0.0.0，改成指定内网 IP：

bind 127.0.0.1 192.168.1.100

这样就只允许本机和 192.168.1.100 访问。

3. 配置防火墙白名单

firewalld

firewall-cmd --permanent --add-rich-rule='
  ``rule family="ipv4"
  ``source address="192.168.1.100"
  ``port protocol="tcp" port="6379" accept'
firewall-cmd --reload

UFW (Ubuntu)

ufw allow from 192.168.1.100 to any port 6379

4. 关闭危险命令（防止恶意利用）

有些命令可能被攻击者用来搞破坏，比如 FLUSHALL, CONFIG, SHUTDOWN。
在 redis.conf 里禁用：

rename-command FLUSHALL ""
rename-command CONFIG ""
rename-command SHUTDOWN ""

5. 使用 TLS 加密（可选）

Redis 6.0+ 支持 TLS/SSL，可以加密数据传输。
配置证书后，远程访问就不会明文传输密码。

6. 使用守护进程 / supervisor 监控

保持 Redis 在后台安全运行：

systemctl enable redis
systemctl start redis

7. 定期检查日志和端口

查看是否有异常连接：

| ss -atpn | grep 6379 | | ----------------------- |

查看 Redis 日志（一般在 /var/log/redis/redis-server.log）。

✅ 总结：

  • 必须做：requirepass 设置密码
  • 最好做：绑定指定 IP + 防火墙白名单
  • 更安全：禁用危险命令 + TLS

好嘞，阿杰 👍 我给你写一份 安全优化后的 redis.conf 配置示例，你可以直接套用（记得把密码、IP 换成你自己的）。

✅ Redis 安全配置示例（redis.conf）

########################################
# 基础设置
########################################
 
# 监听所有网卡（外部访问）
bind 0.0.0.0
 
# 默认端口
port 6379
 
# 开启守护进程
daemonize yes
 
# 日志文件（根据你的环境调整路径）
logfile /var/log/redis/redis-server.log
 
########################################
# 安全配置
########################################
 
# 设置强密码（请改成你自己的）
requirepass StrongPassword123!
 
# 关闭保护模式（需要外部访问时关闭）
protected-mode no
 
# 限制最大客户端连接数
maxclients 10000
 
########################################
# 白名单 IP（可选，只允许某些 IP 访问）
########################################
# 如果只允许 192.168.1.100 访问，可以在防火墙层面控制
# 或者只绑定某些 IP
# bind 127.0.0.1 192.168.1.100
 
########################################
# 禁用危险命令（防止被黑客利用）
########################################
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG ""
rename-command SHUTDOWN ""
rename-command DEBUG ""
 
########################################
# 性能与安全优化
########################################
 
# 禁止外部直接修改 AOF / RDB 配置
dir /var/lib/redis
 
# RDB 文件名
dbfilename dump.rdb
 
# 禁用外部配置保存目录的写权限（需在系统层面 chmod）
# chmod 700 /var/lib/redis
 
########################################
# TLS（可选，如果要加密通信）
########################################
# tls-port 6379
# port 0
# tls-cert-file /etc/ssl/redis/redis.crt
# tls-key-file /etc/ssl/redis/redis.key
# tls-ca-cert-file /etc/ssl/redis/ca.crt

🚀 使用方法

  1. 编辑配置文件：vim /etc/redis/redis.conf （替换内容为上面示例，改掉密码）
  2. 重启 Redis：systemctl restart redis
  3. 测试远程连接：redis-cli -h <服务器IP> -p 6379 -a StrongPassword123!

⚠️ 建议：

  • 如果是云服务器，还需要 安全组放行 6379。
  • 不建议完全对公网暴露，最好只开放给内网或者指定 IP。

👌 阿杰，那我给你整理一份 Redis 6379 端口双保险安全方案（云服务器安全组 + Linux 防火墙） ，确保只有你信任的 IP 能访问。

🔐 Redis 6379 端口双保险方案

1️⃣ 云服务器安全组配置

以 阿里云 / 腾讯云 / AWS / GCP 为例：

  • 放行规则：

    • 协议：TCP
    • 端口：6379
    • 源 IP：你的信任 IP（比如 123.45.67.89）

⚠️ 千万不要用 0.0.0.0/0（所有人都能访问），否则 Redis 很容易被攻击。

2️⃣ Linux 防火墙配置

🔹 Firewalld（CentOS / RHEL 常见）

只允许 123.45.67.89 访问：

firewall-cmd --permanent --add-rich-rule='
  ``rule family="ipv4"
  ``source address="123.45.67.89"
  ``port protocol="tcp" port="6379" accept'
firewall-cmd --reload

验证：

firewall-cmd --list-rich-rules

🔹 UFW（Ubuntu 常见）

只允许 123.45.67.89 访问：

ufw allow from 123.45.67.89 to any port 6379

检查：

ufw status

🔹 iptables（老系统）

iptables -A INPUT -p tcp -s 123.45.67.89 --dport 6379 -j ACCEPT
iptables -A INPUT -p tcp --dport 6379 -j DROP
service iptables save

3️⃣ Redis 配置安全项（配合使用）

在 redis.conf 中：

requirepass StrongPassword123!   # 设置密码
bind 0.0.0.0                     # 允许外部访问
protected-mode no                # 关闭保护模式（否则只能本机访问）

禁用危险命令（避免被攻击者利用）：

rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG ""
rename-command SHUTDOWN ""

4️⃣ 验证

在外部客户端测试连接：

redis-cli -h &lt;服务器公网IP> -p 6379 -a StrongPassword123!

如果非白名单 IP 访问，会提示：

Could not connect to Redis at &lt;IP>:6379: Connection refused

✅ 总结：

  • 云服务器安全组：第一道防线
  • Linux 防火墙（firewalld/ufw/iptables） ：第二道防线
  • Redis 密码 & 禁用危险命令：第三道防线

这样，Redis 即使开在公网，也能最大限度降低风险。

阿杰，好的 👍 我来给你一个非常详尽的 Python typing 模块讲解和示例，帮助你快速掌握类型注解的常见用法。

🐍 Python typing 模块详解

typing 模块是 Python 用于 类型注解（type hints） 的标准库，主要用于 静态类型检查（不会影响运行时，但可以让 IDE / 工具提前发现错误）。

1️⃣ 基础类型注解

from typing import List, Dict, Tuple, Set, Union, Optional
 
# 基础变量注解
x: int = 10
y: str = "hello"
z: float = 3.14

2️⃣ 容器类型

from typing import List, Dict, Tuple, Set
 
# 列表
numbers: List[int] = [1, 2, 3]
 
# 字典
person: Dict[str, int] = {"age": 20, "score": 95}
 
# 元组
point: Tuple[int, int] = (10, 20)
 
# 集合
unique_values: Set[str] = {"a", "b", "c"}

3️⃣ Union & Optional

from typing import Union, Optional
 
# Union：值可以是多种类型
value: Union[int, str] = "hello"
value = 42
 
# Optional：可能是某种类型，也可能是 None
maybe_number: Optional[int] = None
maybe_number = 100

Optional[int] 等价于 Union[int, None]

4️⃣ 函数注解

from typing import List, Dict
 
def add(a: int, b: int) -> int:
    ``return a + b
 
def get_names(ids: List[int]) -> Dict[int, str]:
    ``return {i: f"user{i}" for i in ids}

5️⃣ Callable（函数作为参数）

from typing import Callable
 
# 参数是函数，函数接收 int 返回 str
def execute(func: Callable[[int], str], value: int) -> str:
    ``return func(value)
 
def stringify(x: int) -> str:
    ``return str(x)
 
print(execute(stringify, 123))  # "123"

6️⃣ Any（任意类型）

from typing import Any
 
data: Any = "hello"
data = 123
data = [1, 2, 3]  # 都可以

7️⃣ TypeVar（泛型）

from typing import TypeVar, List
 
T = TypeVar("T")
 
def first_element(lst: List[T]) -> T:
    ``return lst[0]
 
print(first_element([1, 2, 3]))     # int
print(first_element(["a", "b"]))    # str

8️⃣ Literal（字面量类型）

from typing import Literal
 
def move(direction: Literal["left", "right", "up", "down"]) -> None:
    ``print(f"Moving {direction}")
 
move("left")   # ✅
# move("forward")  # ❌ IDE 会提示错误

9️⃣ Final & ClassVar

from typing import Final, ClassVar
 
PI: Final = 3.14159   # 常量，不应被修改
 
class Config:
    ``version: ClassVar[str] = "1.0"  # 类变量

🔟 TypedDict（类似 JSON 的类型约束）

from typing import TypedDict
 
class User(TypedDict):
    ``id: int
    ``name: str
    ``active: bool
 
user: User = {"id": 1, "name": "Alice", "active": True}

1️⃣1️⃣ NewType（定义“新类型”）

from typing import NewType
 
UserId = NewType("UserId", int)
 
def get_user(user_id: UserId) -> str:
    ``return f"User {user_id}"
 
print(get_user(UserId(42)))

1️⃣2️⃣ Self（Python 3.11+ 新增）

from typing import Self
 
class Node:
    ``def __init__(self, value: int):
        ``self.value = value

|         ``self.next: Self | None = None | | ------------------------------------------ |

🔧 类型检查工具

运行时不会检查类型，但可以用 mypy 做静态检查：

pip install mypy
mypy your_file.py

✅ 总结：

  • 常用：List / Dict / Tuple / Set
  • 可选类型：Union / Optional
  • 函数：Callable
  • 泛型：TypeVar
  • 高级：Literal / TypedDict / NewType

好嘞阿杰 👍，我给你整理一份超实用的 Python typing 最常用 20 个用法 + 真实业务场景代码。这样你在做 Web、爬虫、数据分析、API 开发时能直接套用。

🐍 Python typing 20 大常用用法 + 业务场景

1️⃣ 基本类型注解

name: str = "Alice"
age: int = 25
price: float = 99.9
is_active: bool = True

📌 场景：API 返回值定义用户信息。

2️⃣ List（列表）

from typing import List
 
user_ids: List[int] = [1, 2, 3]

📌 场景：数据库查询返回多个用户 ID。

3️⃣ Dict（字典）

from typing import Dict
 
user: Dict[str, str] = {"name": "Alice", "email": "alice@test.com"}

📌 场景：存储用户信息。

4️⃣ Tuple（元组）

from typing import Tuple
 
location: Tuple[float, float] = (39.9, 116.4)  # (纬度, 经度)

📌 场景：地图坐标点。

5️⃣ Set（集合）

from typing import Set
 
tags: Set[str] = {"python", "ai", "nlp"}

📌 场景：博客文章标签。

6️⃣ Union（多种可能类型）

from typing import Union
 
id_or_name: Union[int, str] = "Alice"

📌 场景：搜索接口支持用 id 或 name 查询。

7️⃣ Optional（可为空）

from typing import Optional
 
middle_name: Optional[str] = None

📌 场景：用户可能没有填写中间名。

8️⃣ Callable（函数类型）

from typing import Callable
 
def run_task(task: Callable[[int], str], value: int) -> str:
    ``return task(value)
 
def to_str(x: int) -> str:
    ``return str(x)
 
print(run_task(to_str, 123))

📌 场景：回调函数 / 中间件。

9️⃣ Any（任意类型）

from typing import Any
 
data: Any = {"key": "value"}  # 可以是任何类型

📌 场景：第三方 API 返回值不确定。

🔟 TypeVar（泛型）

from typing import TypeVar, List
 
T = TypeVar("T")
 
def first_element(items: List[T]) -> T:
    ``return items[0]
 
print(first_element([1, 2, 3]))   # int
print(first_element(["a", "b"]))  # str

📌 场景：通用工具函数。

1️⃣1️⃣ Literal（字面量类型）

from typing import Literal
 
def set_status(status: Literal["active", "inactive"]) -> None:
    ``print(f"Status set to {status}")
 
set_status("active")

📌 场景：订单状态 / 枚举字段。

1️⃣2️⃣ Final（不可修改常量）

from typing import Final
 
API_VERSION: Final = "v1"

📌 场景：定义全局常量。

1️⃣3️⃣ ClassVar（类变量）

from typing import ClassVar
 
class Config:
    ``version: ClassVar[str] = "1.0"

📌 场景：类属性，而不是实例属性。

1️⃣4️⃣ TypedDict（JSON-like 类型）

from typing import TypedDict
 
class User(TypedDict):
    ``id: int
    ``name: str
    ``active: bool
 
user: User = {"id": 1, "name": "Alice", "active": True}

📌 场景：接口返回 JSON 数据模型。

1️⃣5️⃣ NewType（自定义新类型）

from typing import NewType
 
UserId = NewType("UserId", int)
 
def get_user(user_id: UserId) -> str:
    ``return f"User {user_id}"

📌 场景：区分不同 ID（避免混用）。

1️⃣6️⃣ Generator（生成器）

from typing import Generator
 
def number_stream() -> Generator[int, None, None]:
    ``for i in range(5):
        ``yield i

📌 场景：流式处理大数据。

1️⃣7️⃣ Iterable / Iterator

from typing import Iterable, Iterator
 
def print_items(items: Iterable[str]) -> None:
    ``for item in items:
        ``print(item)
 
def get_iterator() -> Iterator[int]:
    ``yield from [1, 2, 3]

📌 场景：函数接收任意可迭代对象。

1️⃣8️⃣ Self（Python 3.11+）

from typing import Self
 
class Node:
    ``def __init__(self, value: int):
        ``self.value = value

|         ``self.next: Self | None = None | | ------------------------------------------ |

📌 场景：链表 / 树结构。

1️⃣9️⃣ Typed Callable 返回 JSON

from typing import Callable, Dict
 
def fetch_api(get_json: Callable[[], Dict[str, Any]]) -> Dict[str, Any]:
    ``return get_json()

📌 场景：HTTP 请求封装。

2️⃣0️⃣ Annotated（带元信息的类型，Python 3.9+）

from typing import Annotated
 
def login(username: Annotated[str, "用户名"], password: Annotated[str, "密码"]) -> bool:
    ``return username == "admin" and password == "123"

📌 场景：API 参数文档 / FastAPI 框架。

✅ 总结

  • 常用基础：List、Dict、Tuple、Set、Optional
  • 函数相关：Callable、Generator、Iterable
  • 高级工具：TypeVar、Literal、TypedDict、NewType、Annotated
  • 类相关：Final、ClassVar、Self

这样，你可以写出既直观又安全的类型注解，配合 mypy 静态检查效果更佳。

好嘞阿杰 👍，我给你写一个 小型完整项目示例：用户管理 API，全程用 typing 注解，代码风格类似 FastAPI + Python typing，涵盖你刚才想要的真实业务场景。

🐍 用户管理 API 示例（带 typing 注解）

from typing import List, Dict, Optional, TypedDict, NewType, Literal
from typing import Union, Final
 
# 🔹 定义常量
API_VERSION: Final = "v1"
 
# 🔹 定义新类型，避免不同 ID 混用
UserId = NewType("UserId", int)
 
# 🔹 定义用户模型（接口返回用）
class User(TypedDict):
    ``id: UserId
    ``name: str
    ``email: str
    ``active: bool
    ``role: Literal["admin", "user", "guest"]  # 枚举型
 
# 🔹 模拟数据库
_db: Dict[UserId, User] = {
    ``UserId(1): {"id": UserId(1), "name": "Alice", "email": "alice@test.com", "active": True, "role": "admin"},
    ``UserId(2): {"id": UserId(2), "name": "Bob", "email": "bob@test.com", "active": False, "role": "user"},
}
 
# 🔹 获取用户
def get_user(user_id: UserId) -> Optional[User]:
    ``return _db.get(user_id)
 
# 🔹 获取所有用户
def list_users(active_only: bool = False) -> List[User]:
    ``if active_only:
        ``return [u for u in _db.values() if u["active"]]
    ``return list(_db.values())
 
# 🔹 创建用户
def create_user(name: str, email: str, role: Literal["admin", "user", "guest"]) -> User:
    ``new_id = UserId(max(_db.keys()) + 1 if _db else 1)
    ``user: User = {
        ``"id": new_id,
        ``"name": name,
        ``"email": email,
        ``"active": True,
        ``"role": role,
    ``}
    ``_db[new_id] = user
    ``return user
 
# 🔹 更新用户
def update_user(user_id: UserId, name: Optional[str] = None, email: Optional[str] = None) -> Optional[User]:
    ``user = _db.get(user_id)
    ``if not user:
        ``return None
    ``if name:
        ``user["name"] = name
    ``if email:
        ``user["email"] = email
    ``return user
 
# 🔹 删除用户
def delete_user(user_id: UserId) -> bool:
    ``if user_id in _db:
        ``del _db[user_id]
        ``return True
    ``return False
 
# 🔹 示例调用
if __name__ == "__main__":
    ``print(f"API Version: {API_VERSION}")
 
    ``print("\n📌 获取所有用户：")
    ``print(list_users())
 
    ``print("\n📌 获取指定用户：")
    ``print(get_user(UserId(1)))
 
    ``print("\n📌 创建新用户：")
    ``new_user = create_user("Charlie", "charlie@test.com", "guest")
    ``print(new_user)
 
    ``print("\n📌 更新用户：")
    ``updated_user = update_user(UserId(2), name="Bobby")
    ``print(updated_user)
 
    ``print("\n📌 删除用户：")
    ``print(delete_user(UserId(1)))
 
    ``print("\n📌 最终用户列表：")
    ``print(list_users())

🔎 代码说明

  1. TypedDict + NewType → 定义用户数据结构，区分 UserId 和普通 int。
  2. Optional / Literal → 支持用户字段可选，角色有固定值。
  3. List / Dict → 模拟数据库存储和查询。
  4. Final → API_VERSION 不允许被改动。
  5. 完整 CRUD 功能 → get / list / create / update / delete。

✅ 运行效果示例

API Version: v1
 
📌 获取所有用户：
[{'id': 1, 'name': 'Alice', 'email': 'alice@test.com', 'active': True, 'role': 'admin'},
 ``{'id': 2, 'name': 'Bob', 'email': 'bob@test.com', 'active': False, 'role': 'user'}]
 
📌 获取指定用户：
{'id': 1, 'name': 'Alice', 'email': 'alice@test.com', 'active': True, 'role': 'admin'}
 
📌 创建新用户：
{'id': 3, 'name': 'Charlie', 'email': 'charlie@test.com', 'active': True, 'role': 'guest'}
 
📌 更新用户：
{'id': 2, 'name': 'Bobby', 'email': 'bob@test.com', 'active': False, 'role': 'user'}
 
📌 删除用户：
True
 
📌 最终用户列表：
[{'id': 2, 'name': 'Bobby', 'email': 'bob@test.com', 'active': False, 'role': 'user'},
 ``{'id': 3, 'name': 'Charlie', 'email': 'charlie@test.com', 'active': True, 'role': 'guest'}]

👌 阿杰，我来给你一个 超详细 Python typing 模块全解析，包含常用类型、进阶用法、代码示例和最佳实践。

🐍 Python typing 模块详解

Python 的 typing 模块主要用于 类型提示（type hints） ，帮助开发者写出更规范、可读性更强的代码，同时也能借助 静态检查工具（如 mypy、pyright、Pylance） 提前发现潜在错误。

1️⃣ 基础类型注解

from typing import List, Dict, Tuple, Set, Union, Optional
 
# 基本类型
name: str = "阿杰"
age: int = 25
pi: float = 3.14
is_ok: bool = True
 
# 列表
numbers: List[int] = [1, 2, 3]
 
# 字典
user: Dict[str, int] = {"id": 101, "score": 95}
 
# 元组
point: Tuple[int, int] = (10, 20)
 
# 集合
unique_ids: Set[str] = {"a", "b", "c"}
 
# 可选值（等价于 Union[int, None]）
maybe_num: Optional[int] = None

2️⃣ 函数参数和返回值

from typing import Union
 
# 单一返回值
def add(a: int, b: int) -> int:
    ``return a + b
 
# 多种返回值类型
def safe_divide(a: int, b: int) -> Union[int, str]:
    ``return "Error" if b == 0 else a // b

3️⃣ 高级容器

from typing import List, Dict, Tuple
 
# 列表里套元组
points: List[Tuple[int, int]] = [(1, 2), (3, 4)]
 
# 字典嵌套
user_data: Dict[str, Dict[str, int]] = {
    ``"阿杰": {"math": 90, "english": 88},
}

4️⃣ Any 和 NoReturn

from typing import Any, NoReturn
 
# Any 表示任意类型（不推荐大量使用）
def process(data: Any) -> None:
    ``print(data)
 
# NoReturn 表示函数不会正常返回
def fatal_error(msg: str) -> NoReturn:
    ``raise RuntimeError(msg)

5️⃣ Callable（函数类型）

from typing import Callable
 
# 接收一个函数参数（输入两个 int，返回 int）
def operate(func: Callable[[int, int], int], x: int, y: int) -> int:
    ``return func(x, y)
 
result = operate(lambda a, b: a + b, 3, 5)  # ✅ 8

6️⃣ TypeVar（泛型）

from typing import TypeVar, List
 
T = TypeVar("T")  # 声明泛型
 
def first_item(items: List[T]) -> T:
    ``return items[0]
 
print(first_item([1, 2, 3]))       # int
print(first_item(["a", "b", "c"])) # str

7️⃣ Generic（泛型类）

from typing import Generic, TypeVar
 
T = TypeVar("T")
 
class Box(Generic[T]):
    ``def __init__(self, value: T):
        ``self.value = value
 
    ``def get(self) -> T:
        ``return self.value
 
int_box = Box 
str_box = Box[str]("hello")

8️⃣ Literal（字面量类型）

from typing import Literal
 
def set_status(status: Literal["open", "closed", "pending"]) -> None:
    ``print(f"Status: {status}")
 
set_status("open")    # ✅
# set_status("error") # ❌ 静态检查报错

9️⃣ TypedDict（字典类型约束）

from typing import TypedDict
 
class User(TypedDict):
    ``id: int
    ``name: str
    ``is_active: bool
 
u: User = {"id": 1, "name": "阿杰", "is_active": True}

🔟 新特性（Python 3.9+ 简化写法）

# Python 3.9+ 开始支持原生类型提示
list[int]       # 等价于 List[int]
dict[str, int]  # 等价于 Dict[str, int]
tuple[int, str] # 等价于 Tuple[int, str]

✅ 总结

  • List, Dict, Tuple, Set, Optional, Union → 常见容器和类型组合
  • Callable → 函数类型
  • Any, NoReturn → 特殊场景
  • TypeVar, Generic → 泛型
  • Literal, TypedDict → 更严格的约束
  • Python 3.9+ → 原生写法更简洁

www.52runoob.com/archives/68…

avatar
文章
阅读
粉丝