UU 技术站

Python 基础第一课：你好世界

Fri, 01 May 2026 10:00:00 +0800

Python 基础第一课：你好世界

课程概述

欢迎来到 Python 编程系列课程的第一天！本节课我们将一起踏入 Python 编程的精彩世界。今天的学习内容包括：Python 语言简介、安装与运行环境、print() 函数的标准输出、代码注释的写法，以及现代 Python 中最常用的 f-string（格式化字符串字面量）。本课程内容基于 Python 3.11 编写，涵盖了 Python 3.11 中引入的最新语法特性与最佳实践。无论你是完全没有编程经验的初学者，还是从其他语言转来的开发者，本课程都将帮助你建立扎实的基础。

Python 由荷兰程序员 Guido van Rossum 于 1991 年首次发布，至今已有超过 30 年的发展历史。Python 的设计哲学强调代码的可读性和简洁性，其核心原则之一就是"Readability counts"（可读性很重要）。Python 使用缩进（indentation）来划分代码块，而不是像许多其他语言那样使用大括号 {} 或 begin/end 关键字。这种独特的设计使得 Python 代码在视觉上非常清晰，也强制开发者写出格式良好的代码。Python 的另一条著名的设计原则是"Simple is better than complex"（简单优于复杂），这使得 Python 成为最适合初学者入门的编程语言之一。

Python 3.11 的新特性

在学习基础知识之前，我们有必要了解一下 Python 3.11 相比之前版本带来了哪些重要改进。Python 3.11 于 2022 年 10 月正式发布，被誉为"Python 史上最快的版本"，其解释器启动速度比 Python 3.10 快了 10-15%，而平均执行速度更是提升了 25%。这些性能的提升主要来自于对 Python 虚拟机（Virtual Machine）的深度优化和重构。Python 3.11 还引入了更为精确的错误提示信息（Better Error Messages），当程序出现异常时，Python 3.11 会显示更多上下文信息，帮助开发者更快地定位和修复问题。

Day1 云计算概述

Fri, 13 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记 + 阿里云开发者社区 + 网络资料整理

一、详细讲解

1.1 云计算的定义

云计算（Cloud Computing）是一种通过网络统一管理和调度的计算、存储、软件等资源，形成一个资源池，用户按需使用、按量付费的计算模式。

核心特征：

按需自助服务：用户无需人工干预即可获取资源
泛在网络接入：通过标准网络随时随地访问
资源池化：物理资源被抽象为池化资源池
快速弹性伸缩：资源可快速扩缩容
按使用量付费：用多少付多少，无浪费

1.2 三种服务模型（重点）

模型	全称	用户管理层次	阿里云产品举例
IaaS	Infrastructure as a Service	基础设施（网络/存储/服务器）	云服务器ECS、块存储、vSwitch
PaaS	Platform as a Service	操作系统以上，中间件以上	数据库RDS、对象存储OSS、容器服务ACK
SaaS	Software as a Service	直接使用应用	钉钉、云效、DataV

考试口诀：

IaaS = 你管啥都要管（除了机房硬件）
PaaS = 你只管应用和数据（平台全管）
SaaS = 你只用（啥都不用管）

阿里云各层典型产品：

IaaS： ECS / ECS Bare Metal / 弹性裸金属 PaaS： RDS / OSS / ACK / 函数计算FC / API网关 SaaS：钉钉 / 云效 / 瓴山羊

1.3 四种部署模型

部署模型	说明	适用场景
公有云	第三方提供，多租户共享	中小企业、创业公司
私有云	企业自建，独占资源	金融、政府、大型企业的核心系统
社区云	多个组织共享建设的云	行业联盟、区域联盟
混合云	公有云 + 私有云组合	核心数据留私有云，业务弹性用公有云

1.4 阿里云全球化基础设施

阿里云在全球 28 个地域（Region）运营，拥有 86 个可用区（Zone）。

Python 第二课：变量、数据类型与类型转换

Fri, 01 May 2026 10:00:00 +0800

Python 第二课：变量、数据类型与类型转换

课程概述

本节课我们将深入学习 Python 编程中最核心的概念之一——变量（Variables）。变量是存储数据的容器，是所有程序的基础构建块。我们还将全面介绍 Python 的内置数据类型（Built-in Data Types），包括整数（int）、浮点数（float）、字符串（str）、布尔值（bool）、列表（list）、元组（tuple）、字典（dict）和集合（set）。此外，我们还将学习 Python 中的类型转换（Type Conversion）和 f-string 高级格式化技巧。本课程所有内容基于 Python 3.11 标准，涵盖了 Python 3.11 中关于类型系统的新特性和改进。Python 是一门动态类型语言（dynamically typed language），这意味着变量不需要显式声明类型，Python 解释器会根据赋给变量的值自动推断类型。但与此同时，Python 也是一门强类型语言（strongly typed language），不同类型的数据不能随意进行混合运算，必须通过显式的类型转换来实现。

变量详解

变量的基本概念

在 Python 中，变量是用于存储数据值的容器。你可以形象地将变量想象为一个贴有标签的盒子，盒子里存放着数据，而标签就是变量的名字。每次给变量赋值时，变量就会指向新的数据对象。

# 变量的基本赋值
name = "张三"       # 字符串变量
age = 25            # 整数变量
height = 1.75       # 浮点数变量
is_student = True   # 布尔变量

print(f"姓名：{name}")
print(f"年龄：{age}")
print(f"身高：{height} 米")
print(f"是否学生：{is_student}")

输出：

姓名：张三年龄：25 身高：1.75 米是否学生：True

变量的命名规则

Python 中的变量名必须遵守以下规则：

变量名只能包含字母、数字和下划线（_），不能包含空格或特殊字符。
变量名不能以数字开头。
变量名不能使用 Python 的保留关键字（keywords）。
变量名区分大小写（name 和 Name 是两个不同的变量）。

# 合法的变量名
my_variable = 10
_private_data = "secret"
camelCase = "驼峰命名"
CONSTANT_VALUE = 100  # 常量习惯用全大写

# Python 3.11 中还可以使用 Unicode 字符作为变量名
姓名 = "李四"
π = 3.14159

# 不合法的变量名（会导致 SyntaxError）
# 2nd_value = 20      # 不能以数字开头
# my-var = 30         # 不能使用连字符
# class = "高级"       # 不能使用保留关键字

Python 保留关键字

以下是 Python 3.11 中的所有保留关键字（35个），你不能将它们作为变量名使用：

Day2 计算虚拟化 + CPU内存虚拟化

Fri, 13 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记 + 阿里云开发者社区 + 网络资料整理

一、详细讲解

1.1 虚拟化概述

**虚拟化（Virtualization）**是将物理计算资源（CPU、内存、存储、网络）抽象成虚拟资源池的技术，使得一个物理服务器可以同时运行多个相互隔离的虚拟机。

虚拟化的核心价值：

资源利用率提升：一台物理机跑多个 VM，充分利用 CPU 空闲算力
成本降低：减少物理服务器采购，降低机房空间和电力消耗
隔离性强：每个 VM 独立运行，故障互不影响
快速部署：分钟级创建 VM vs 传统物理机数天交付
弹性伸缩：根据负载动态创建/销毁 VM

1.2 CPU 虚拟化（重点）

CPU 虚拟化的原理

CPU 虚拟化让一个物理 CPU 模拟出多个虚拟 CPU（vCPU），每个 VM 认为自己独占一个完整的 CPU。

两种 CPU 虚拟化架构：

架构	说明	特点
全虚拟化	VM 通过二进制翻译模拟硬件，Guest OS 无需修改	性能损耗较大，但兼容性好
半虚拟化	Guest OS 经过修改，主动配合 Hypervisor	性能好，但需要修改 Guest OS
硬件辅助虚拟化	CPU 提供 VT-x/AMD-V 硬件支持，Guest OS 无需修改	性能接近物理机，主流方案

阿里云 ECS 使用的虚拟化技术：

Python 第三课：运算符、优先级与海象运算符

Fri, 01 May 2026 10:00:00 +0800

Python 第三课：运算符、优先级与海象运算符

课程概述

本节课我们将全面学习 Python 中的运算符（Operators）。运算符是用于执行各种运算操作的符号，Python 提供了丰富的运算符，包括算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符、身份运算符和成员运算符。我们还将深入探讨运算符的优先级（Operator Precedence），理解 Python 如何按照固定的规则计算包含多个运算符的表达式。此外，本课将重点介绍 Python 3.8 引入的海象运算符（Walrus Operator），即赋值表达式（Assignment Expression），它允许在表达式内部进行变量赋值，是一个非常强大且实用的特性。本课程所有内容基于 Python 3.11 编写，涵盖了 Python 3.11 中运算符语法的最新变化和最佳实践。

Python 的运算符系统设计得既强大又优雅。Python 支持运算符重载（Operator Overloading），这意味着同一个运算符在不同数据类型上可能有不同的行为。例如，+ 运算符可以用于数字相加、字符串拼接、列表合并等多种场景，这种设计被称为"魔法方法"（Dunder Methods）或运算符重载。理解运算符的工作原理对于编写高效、简洁的 Python 代码至关重要。

算术运算符

算术运算符是最常用的运算符类型，用于执行基本的数学运算。

基本算术运算符

# 加减乘除
a, b = 15, 4

print(f"a = {a}, b = {b}")
print(f"a + b = {a + b}")    # 19
print(f"a - b = {a - b}")    # 11
print(f"a * b = {a * b}")    # 60
print(f"a / b = {a / b:.4f}")    # 3.7500（浮点除法）

# 整除（向下取整）
print(f"a // b = {a // b}")   # 3

# 取余（模运算）
print(f"a % b = {a % b}")     # 3（15 = 4 * 3 + 3）

# 幂运算（指数运算）
print(f"a ** b = {a ** b}")   # 15^4 = 50625

# 负数运算
print(f"-a = {-a}")           # -15
print(f"+a = {+a}")           # 15（正号，一元运算符）

整数除法的特殊情况

# Python 3.11 中整数除法的行为
print(f"5 / 2 = {5 / 2}")          # 2.5（总是返回浮点数）
print(f"5 // 2 = {5 // 2}")        # 2（向下取整）
print(f"-5 // 2 = {-5 // 2}")      # -3（向下取整，负数向更小的整数取整）
print(f"5 // -2 = {5 // -2}")      # -3
print(f"-5 // -2 = {-5 // -2}")    # 2

# 模运算与整除的关系
print(f"5 % 2 = {5 % 2}")          # 1
print(f"-5 % 2 = {-5 % 2}")        # 1（Python 保证 a % b 的符号与 b 相同）
print(f"5 % -2 = {5 % -2}")        # -1
print(f"-5 % -2 = {-5 % -2}")      # -1

算术运算符的组合赋值

# 组合赋值运算符
x = 10
print(f"初始 x = {x}")

x += 5    # 等价于 x = x + 5
print(f"x += 5 后，x = {x}")

x -= 3    # 等价于 x = x - 3
print(f"x -= 3 后，x = {x}")

x *= 2    # 等价于 x = x * 2
print(f"x *= 2 后，x = {x}")

x /= 4    # 等价于 x = x / 4
print(f"x /= 4 后，x = {x}")

x //= 2   # 等价于 x = x // 2
print(f"x //= 2 后，x = {x}")

x **= 3   # 等价于 x = x ** 3
print(f"x **= 3 后，x = {x}")

x %= 10   # 等价于 x = x % 10
print(f"x %= 10 后，x = {x}")

算术运算符的字符串和序列操作

# 字符串的乘法运算
text = "Python "
print(f"text * 3 = '{text * 3}'")

# 列表的加法和乘法
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(f"list1 + list2 = {list1 + list2}")   # 列表拼接
print(f"list1 * 2 = {list1 * 2}")           # 列表重复

# 元组的加法和乘法
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(f"t1 + t2 = {t1 + t2}")
print(f"t1 * 3 = {t1 * 3}")

比较运算符

比较运算符用于比较两个值的大小或相等性，返回布尔值（True 或 False）。

ACP Day 3 阿里云综述

Sun, 15 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记

ACP Day 3｜阿里云综述

今日主题

Day 3：阿里云综述
对应资料：1-04-阿里云综述.pdf

重点整理

阿里云创立于 2009 年，是全球领先的云计算与人工智能科技公司。
核心定位：通过在线公共服务提供安全、可靠的计算与数据处理能力。
关键发展脉络：成立 → 对外服务 → 海外布局 → 城市大脑 → 数据库与云原生成熟 → 倚天 710 / 一云多芯 → 冬奥全面上云与 CIPU 架构。
能力版图覆盖：计算、存储、数据库、网络、安全、大数据、AI、云原生、物联网。
全球化能力体现为多区域、多可用区和全球 CDN 节点布局。
三条生命线：坚持自主研发之路、与合作伙伴共生共存、坚决不碰客户数据。
整体架构可理解为：基础设施层 + 平台产品层 + 行业解决方案层。

背诵版

阿里云成立于 2009 年。
阿里云提供安全、可靠的计算和数据处理能力。
阿里云既有 IaaS，也有数据库、安全、AI、大数据、云原生等平台能力。
阿里云具备全球化部署能力。
三条生命线：自主研发、合作共赢、不碰客户数据。
整体架构：基础设施层、平台产品层、行业解决方案层。

自测题

阿里云成立于哪一年？
阿里云的三条生命线分别是什么？
阿里云整体架构可以概括为哪三层？
为什么说阿里云不是单一产品，而是完整平台？

口语化背诵版

阿里云成立于 2009 年，它是全球领先的云计算和人工智能科技公司。它的核心作用，就是通过在线公共服务的方式，给客户提供安全、可靠的计算和数据处理能力。

阿里云不是只有一两个产品，它是一整套完整的平台，能力覆盖计算、存储、数据库、网络、安全、大数据、AI、云原生和物联网。所以考试里如果问阿里云是什么，不要只答“卖服务器的”，要答它是完整的云平台和数字化基础设施。

阿里云的发展有几个关键节点：2009 年成立，开始研发飞天；之后具备对外服务能力；再往后开始全球化布局；然后在城市大脑、数据库、云原生、芯片这些方向不断增强；后面又有倚天 710、冬奥全面上云、CIPU 新架构这些代表性成果。这里不用死记所有年份，记住“不断从基础云服务走向全球化、平台化、智能化”就行。

阿里云还有一个特别重要的考点，就是三条生命线：第一，坚持自主研发之路；第二，与合作伙伴共生共存；第三，坚决不碰客户数据。这三条里面，最容易被单独拿出来考的就是“不碰客户数据”，因为它和云上安全、客户信任、责任边界都很相关。

阿里云的整体架构，也可以用一个很简单的方法记：最下面是基础设施层，也就是计算、存储、网络这些基础资源；中间是平台产品层，比如数据库、安全、大数据、AI、云原生这些服务；最上面是行业解决方案层，也就是面向具体业务场景和行业需求的解决方案。所以你可以把它理解成：底层给资源，中间给能力，上层给方案。

另外，阿里云还有很强的全球化能力，有很多区域和可用区，也有全球 CDN 节点。这个点通常不是让你背数字，而是让你理解它代表了全球部署能力、高可用能力、容灾能力和海外业务支撑能力。

Python 第四课：条件语句与结构化模式匹配

Fri, 01 May 2026 10:00:00 +0800

Python 第四课：条件语句与结构化模式匹配

课程概述

本节课我们将学习 Python 中最重要的控制流工具之一——条件语句（Conditional Statements）。条件语句允许程序根据特定条件的真假来选择执行不同的代码路径。我们将详细学习 if、elif（else if 的缩写）和 else 语句的用法，以及条件表达式（三元运算符）的使用。此外，本课还将重点介绍 Python 3.10 引入的革命性新特性——match-case 结构化模式匹配（Structural Pattern Matching）。match-case 是 Python 历史上最重要的语法特性之一，它借鉴自函数式编程语言如 Haskell 和 OCaml，允许开发者以声明式的方式对值、结构和类型进行匹配和解析。本课程所有内容基于 Python 3.11 编写，涵盖了 Python 3.10 和 Python 3.11 中 match-case 的最新改进。

条件语句是编程的基础构建块，几乎所有程序都需要根据不同的条件做出不同的决策。在 Python 中，条件语句不仅支持简单的布尔判断，还支持复杂的表达式、多重条件判断，以及与循环、异常处理等控制流工具的组合使用。Python 的条件语句设计得非常优雅，使用缩进而不是大括号来划分代码块，这使得代码既简洁又具有良好的可读性。

if 语句基础

最基本的 if 语句

if 语句是最简单的条件语句，其基本语法如下：

# 基本语法
if 条件:
    条件为真时执行的代码

# 示例
age = 20

if age >= 18:
    print("你已经成年了！")
    print("可以观看这部电影")

print("程序继续执行...")

在 Python 中，if 语句后的条件表达式不需要使用括号（虽然技术上可以使用括号），条件的真假由 Python 的布尔规则决定。如果条件为真（True），则执行缩进后的代码块；如果为假（False），则跳过该代码块。

ACP Day 4 网络架构 + IP编址

Mon, 16 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记

ACP Day 4｜网络架构 + IP编址

今日主题

Day 4：网络架构 + IP编址
对应资料：2-01-网络架构和网络设备详解 (1).pdf、2-02-IP编址 (1).pdf

重点整理

最简单的网络由两个终端和一条能够承载数据传输的物理介质组成。
数据通信网络由路由器、交换机、防火墙、无线控制器、无线接入点以及主机、服务器等设备组成，最基本功能是实现数据互通。
OSI 七层模型要记住：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。考试常问网络层负责逻辑地址与转发，传输层负责端到端传输。
TCP/IP 参考模型是互联网主流模型，常见协议包括：应用层 HTTP/DNS/DHCP，传输层 TCP/UDP，网络层 IP/ICMP/IGMP，链路层 Ethernet/PPP。
交换机可按网络构成分为接入层、汇聚层、核心层；按 TCP/IP 模型可分为二层交换机和三层交换机。
路由器也可按网络构成分为接入层、汇聚层、核心层；作用是实现不同网络之间的互联。
无线网络常见设备包括 AC（无线控制器）和 AP（无线接入点），其中 AP 分为胖 AP 和瘦 AP。
防火墙的核心作用是控制两个网络之间的安全通信，实现访问控制、身份认证、远程接入、VPN、NAT 等安全功能。
IP 地址由网络部分和主机部分组成，网络掩码用于区分网络部分与主机部分，例如 192.168.10.1/24。
有类编址中：A 类默认 /8，B 类默认 /16，C 类默认 /24；D 类用于组播，E 类用于研究。
私网地址要重点记忆：10.0.0.0/8、172.16.0.0/12、192.168.0.0/16。
特殊 IP 地址要会辨认：255.255.255.255 是有限广播地址，0.0.0.0 是任意地址，127.0.0.0/8 是环回地址，169.254.0.0 段用于本地链路临时通信。
划分子网的目的：减少地址浪费、缩小广播域、让网络规划更合理。
子网划分的本质是向主机位借位，得到更多子网；同时每个子网的可用主机数会减少。
网络工程不仅是设备堆叠，而是按标准、规范和需求完成规划、设计、实施、排错和优化。

背诵版

OSI 七层：物链网传会表应。
网络层管逻辑地址和转发，传输层管端到端传输。
TCP/IP 是互联网主流参考模型。

Python 第五课：逻辑运算符、短路求值与链式比较

Fri, 01 May 2026 10:00:00 +0800

Python 第五课：逻辑运算符、短路求值与链式比较

课程概述

本节课我们将深入探讨 Python 中三个最重要的逻辑运算符——and、or 和 not的工作原理，以及与它们密切相关的短路求值（Short-circuit Evaluation，也称为最小化求值）机制。我们还将详细学习 Python 特有的链式比较（Chained Comparisons）语法，这是 Python 语言中最优雅的特性之一。此外，本课还将涵盖 Python 中所有对象的布尔值规则、真值测试（Truth Value Testing），以及如何利用逻辑运算符的特性编写更加简洁、高效和安全的代码。本课程所有内容基于 Python 3.11 编写，涵盖了 Python 3.11 中关于布尔运算和比较操作的最新实现细节和优化。

逻辑运算符是所有编程语言的基石之一，它们构成了条件判断、循环控制和程序逻辑的核心。Python 的逻辑运算符相比其他语言有一些独特的设计：Python 使用英语单词 and、or、not 而不是 &&、||、! 这样的符号，这使得代码更接近自然语言，可读性更强。更重要的是，Python 的逻辑运算符遵循短路求值原则，这不仅提高了代码效率，还为编写安全的代码提供了独特的手段。

逻辑运算符基础

and（逻辑与）

and 运算符当且仅当两个操作数都为 True 时结果才为 True。在任何其他情况下，结果都是 False。

# and 运算符的真值表
print("=" * 50)
print("and 运算符真值表")
print("=" * 50)
print(f"True  and True  = {True and True}")
print(f"True  and False = {True and False}")
print(f"False and True  = {False and True}")
print(f"False and False = {False and False}")
print()

# and 运算符返回的是最后一个求值的表达式，而不是单纯的 True/False
print("and 返回的值：")
print(f"1 and 2  = {1 and 2}")     # 返回 2
print(f"1 and 0  = {1 and 0}")     # 返回 0
print(f"0 and 1  = {0 and 1}")     # 返回 0
print(f"'a' and 'b' = {'a' and 'b'}")  # 返回 'b'
print(f"'' and 'b' = {'' and 'b'}")    # 返回 ''

or（逻辑或）

or 运算符当任意一个操作数为 True 时结果就为 True。只有两个操作数都为 False 时结果才为 False。

Day 5: VPC专有网络与NAT网关 - ACP云计算工程师认证

Sun, 26 Apr 2026 00:00:00 +0000

Day 5：VPC专有网络与NAT网关

本文基于阿里云ACP云计算工程师认证课程内容整理，涵盖VPC专有网络核心架构、NAT网关原理与实践，以及企业级网络规划最佳实践。

一、VPC专有网络核心概念与逻辑架构

专有网络VPC（Virtual Private Cloud） 是阿里云基于飞天云平台构建的逻辑隔离私有网络，为用户提供完全可控的云上私有网络环境。与传统经典网络相比，VPC允许用户自主规划IP地址范围、配置路由表、部署网关设备，实现与传统数据中心一致的网络体验，同时兼具云端的弹性与高可用优势。

VPC的三大核心组件

组件	作用	说明
私网网段	定义VPC地址空间	支持10.0.0.0/8、172.16.0.0/12、192.168.0.0/16及其子网
路由器（vRouter）	VPC网络枢纽	连接各交换机，同时作为VPC与外部网络的网关
交换机（vSwitch）	基础连接设备	部署在特定可用区内，连接云资源实例

VPC的逻辑架构

VPC采用数据通路与配置通路分离的设计：

数据通路：交换机（分布式节点）+ 网关组成，所有链路冗余容灾
配置通路：控制器下发转发表到网关和交换机，基于自研协议实现

这种架构确保了控制面与数据面的解耦，使VPC具备电信级的高可用保障。系统路由自动创建，用户可创建自定义路由表与交换机绑定，实现精细化的流量管理。

VPC的显著特点

完全掌控：用户自主选择IP地址范围、配置路由表和网关
灵活互联：通过高速通道、VPN网关、云企业网CEN连接其他VPC或本地IDC
高可用：支持跨可用区部署，单可用区故障不影响整体网络
安全隔离：网络ACL、安全组多层次访问控制

考试要点：VPC是地域级别资源，不支持跨地域部署。一个VPC最多包含10张路由表（含系统路由表），一个交换机只能绑定一张路由表。

二、VPC路由器、交换机与路由表深度解析

交换机（vSwitch）

交换机是组成VPC的基础网络设备，用于连接不同的云资源实例。其关键特性：

可用区绑定：交换机属于特定可用区，不可跨可用区部署
网段约束：交换机网段必须是所属VPC网段的子集，掩码范围16~29位
容灾建议：生产环境至少创建2个跨可用区的交换机

路由表类型

系统路由表 - 创建VPC后自动生成 - 不可删除、不可手动创建 - 可添加自定义路由条目自定义路由表 - 用户自行创建 - 与交换机绑定（一个交换机只能绑定一张） - 多个交换机可绑定同一张自定义路由表网关路由表 - 与IPv4网关绑定，控制公网流量路由

路由条目类型

类型	说明	可修改性
系统路由	VPC内默认路由，管理基础流量	不可修改
自定义路由	用户添加的路由规则	可添加、删除
动态路由	通过CEN/VPN/BGP学习到的路由	自动更新

路由匹配采用最长前缀匹配原则（Longest Prefix Match），这与Internet路由协议标准一致。

Day6 while循环基础

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_01~hm_07 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

while循环是Python编程中的重要知识点，在本课程的第6天我们将系统学习while循环、计数器控制、无限循环、以及while-else结构的完整知识体系。

while循环是一种条件驱动的循环结构，它会在条件为True时反复执行代码块，直到条件变为False为止。这种循环特别适用于迭代次数不确定的场景，比如等待用户输入、读取文件直到结束、或者进行未知次数的搜索操作。

与for循环不同，while循环需要程序员手动管理循环变量，确保循环最终能够终止，否则会产生无限循环。因此，使用while循环时需要格外注意循环条件的设置和计数器变量的更新。

1.2 while循环语法详解

1.2.1 基本语法结构

# while循环的基本语法
while 条件表达式:
    # 循环体 - 当条件为True时执行
    语句块

语法说明：

条件表达式是一个布尔值或可以转换为布尔值的表达式
当条件为True时，执行循环体中的语句
执行完循环体后，会再次评估条件表达式
这个过程重复进行，直到条件变为False

1.2.2 计数循环的实现

# 计数器初始化
counter = 0

# 条件判断
while counter < 5:
    # 循环体
    print(f"计数器当前值: {counter}")
    # 计数器更新 - 这是防止无限循环的关键
    counter += 1

print("循环结束")

运行结果：

计数器当前值: 0 计数器当前值: 1 计数器当前值: 2 计数器当前值: 3 计数器当前值: 4 循环结束

1.3 while循环的执行流程

┌─────────────────┐ │ 初始化计数器 │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ 评估条件表达式 │◄──────────┐ └────────┬────────┘ │ │ │ 条件为True? │ │ │ ┌────┴────┐ │ │ │ │ Yes No │ │ │ │ ▼ ▼ │ ┌─────────┐ ┌─────────┐ │ │ 执行循环体│ │ 退出循环 │ │ │ 更新计数器│ └─────────┘ │ └────┬────┘ │ │ │ └────────────────────────┘

1.4 实用示例

1.4.1 1~100累加求和

# 计算1到100的累加和
i = 1        # 初始化计数器，起始值为1
total = 0    # 初始化求和变量

while i <= 100:      # 条件：i小于等于100
    total += i       # 累加当前i的值
    i += 1            # 计数器递增

print(f"1+2+3+...+100 = {total}")  # 输出: 5050

算法分析：

ACP Day 6 应用交付网络 + 全球化网络

Wed, 18 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记

ACP Day 6｜应用交付网络 + 全球化网络

今日主题

Day 6：应用交付网络 + 全球化网络
对应资料：2-05-阿里云应用交付网络 (1).pdf、2-06-阿里云全球化网络.pdf

重点整理

应用交付网络核心组件包括：负载均衡 SLB、全球加速 GA、弹性公网 IP（EIP）、共享带宽/共享流量包。
负载均衡 SLB 的价值是把流量分发到多台后端服务器，提升吞吐、消除单点故障、提高系统高可用性。
SLB 产品按场景可分为：ALB（7层 HTTP/HTTPS/QUIC，适合复杂七层路由与云原生 Ingress）、NLB（4层 TCP/UDP/TCPSSL，适合超高并发连接）、CLB（传统型，兼顾 4 层和 7 层场景）。
ALB 重点记忆：面向七层应用交付，支持 HTTP/HTTPS/HTTP2/WSS/QUIC/GRPC，单实例可达高规格 QPS。
NLB 重点记忆：面向四层流量，支持 TCP、UDP、TCPSSL，单实例可支持超大规模并发连接。
GA（全球加速）依托阿里云全球传输网络与 BGP 带宽，实现全球就近接入、跨地域部署，优化公网访问质量，减少时延、抖动和丢包。
GA 关键组成包括：加速区域、接入点、加速 IP、CNAME、监听、终端节点组、终端节点、终端节点出公网 IP、基础带宽包。
GA 分为标准型和基础型：标准型支持 4 层/7 层网络加速；基础型主要用于 3 层 IP 协议加速。
EIP 是独立购买和持有的公网 IP 资源，可绑定到 VPC 类型 ECS、私网 SLB、辅助弹性网卡、NAT 网关和高可用虚拟 IP。
EIP 相比 ECS 固定公网 IP，更灵活：可独立持有、可弹性绑定解绑、可灵活调整带宽，还可加入共享带宽以节省成本。

Day7 循环控制break与continue

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_06~hm_07 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

循环控制break与continue是Python编程中用于精确控制循环执行流程的两个重要关键字。在本课程的第7天，我们将深入学习break语句、continue语句、以及它们与循环else子句的配合使用。

在实际的程序开发中，我们经常需要在循环执行过程中根据某些条件提前退出循环（break）或者跳过本次循环的剩余代码（continue）。这两个语句为我们提供了这种精细控制的能力，使得我们可以编写出更加灵活和高效的循环逻辑。

理解break和continue的区别以及它们对循环else子句的影响，是掌握Python循环控制的关键。

1.2 break语句详解

1.2.1 break的基本语法

break语句用于立即终止当前所在的最内层循环，并将控制流转移到循环体之外的下一条语句。

# break语句的语法位置
for 变量 in 序列:
    if 条件:
        break    # 跳出当前循环
    循环体

# while循环中的break
while 条件:
    if 条件:
        break    # 跳出当前循环
    循环体

1.2.2 break在for循环中的使用

# 示例1：查找第一个符合条件的元素
fruits = ["apple", "banana", "cherry", "date", "elderberry"]

for fruit in fruits:
    if len(fruit) > 5:
        print(f"第一个长度大于5的水果: {fruit}")
        break
# 输出: 第一个长度大于5的水果: banana

# 示例2：遍历列表，找到目标后立即停止
numbers = [1, 3, 5, 7, 9, 11, 13, 15]
target = 11

for num in numbers:
    if num == target:
        print(f"找到目标: {target}")
        break
    print(f"检查: {num}")

print("搜索完成")

运行结果：

ACP Day 7 万物上云网络 + Week1复习

Thu, 19 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记

ACP Day 7｜操作数据库 RDS 的参数实验

今日主题

Day 7：操作数据库 RDS 的参数实验
对应资料：07操作数据库RDS的参数实验.pdf

重点整理

RDS（Relational Database Service）是阿里云关系型数据库服务，支持 MySQL、SQL Server、PostgreSQL、OceanBase 等引擎，提供开箱即用的数据库能力，无需自行运维底层基础设施。
RDS 实例创建关键配置：实例规格（CPU/内存配比）、存储类型（ESSD PL0-PL3/普通云盘/高效云盘）、网络类型（专有网络 VPC 推荐）、连接地址（生产环境建议只用内网）。
参数组（Parameter Group）用于批量管理数据库配置参数，确保实例间配置一致。常用参数包括：max_connections（最大连接数）、innodb_buffer_pool_size（InnoDB 缓冲池大小）、character_set_server（字符集，建议 utf8mb4）、wait_timeout（空闲连接超时时间）、long_query_time（慢查询阈值）。
参数修改分为动态生效和需重启生效两类，修改时需注意影响范围。
RDS 高可用架构：主备实例（一主一备，自动数据同步，故障自动切换）用于保障业务连续性；只读实例用于读写分离，分担主实例查询压力。主备建议跨可用区部署。
RDS 备份与恢复：自动备份按策略执行（支持全量备份 + 日志备份），手动备份用于重大变更前。按时间点恢复可恢复到新实例或覆盖原实例。备份保留天数最长 730 天。
RDS 安全配置：白名单控制 IP 访问（默认 0.0.0.0/0 禁止，生产环境应限制具体 IP）；SSL 加密数据传输；TDE 静态数据加密；审计日志记录 SQL 操作。
RDS 监控指标：CPU 使用率、内存使用率、IOPS、连接数、QPS/TPS，配合性能洞察进行 SQL 分析与死锁检测。

背诵版

RDS 核心价值：托管式关系数据库，自带高可用、备份、安全。
参数组作用：批量管理配置，确保实例配置一致；常见参数：连接数、缓冲池、字符集、慢查询时间。
高可用：主备自动切换保障连续性，只读实例分担查询压力。
备份恢复：自动 + 手动两种，按时间点恢复。
安全三剑客：白名单（访问控制）+ SSL（传输加密）+ TDE（静态加密）。

自测题

1. RDS 参数组的主要作用是什么？哪些参数修改需要重启实例？
1. 主备实例和只读实例的区别是什么？
1. RDS 备份分为哪两种？恢复方式有哪些？
1. RDS 白名单的默认策略是什么？生产环境应该如何设置？
1. 什么场景下需要使用 RDS 只读实例？

ACP Day 7｜万物上云网络 + Week1复习（最终整理版）

今日主题

Day 7：万物上云网络 + Week1复习

Day8 for循环与range

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_01~hm_05 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

for循环与range是Python编程中最常用和重要的迭代结构。在本课程的第8天，我们将系统学习for循环的基本语法、range函数的使用、enumerate和zip等内置函数的配合使用，以及序列解包在for循环中的应用。

for循环是一种基于迭代器的循环结构，它依次从可迭代对象中取出每个元素进行处理。与while循环不同，for循环不需要手动管理计数器，Python解释器会自动处理迭代的细节。这使得for循环更加简洁、安全，是处理已知序列或需要遍历元素场景的首选。

1.2 for循环语法详解

1.2.1 基本语法结构

# for循环的基本语法
for 变量 in 可迭代对象:
    # 循环体
    语句块

1.2.2 遍历各种序列类型

# 遍历字符串
print("=== 遍历字符串 ===")
for char in "Python":
    print(char)

# 遍历列表
print("\n=== 遍历列表 ===")
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 遍历元组
print("\n=== 遍历元组 ===")
coordinates = (10, 20, 30)
for coord in coordinates:
    print(f"坐标: {coord}")

# 遍历字典（默认遍历键）
print("\n=== 遍历字典 ===")
person = {"name": "Alice", "age": 30, "city": "Beijing"}
for key in person:
    print(f"{key}: {person[key]}")

运行结果：

Day8 云服务器ECS

Fri, 20 Mar 2026 00:00:00 +0000

Day 8 云服务器 ECS

📅 ACP云计算工程师认证系列 · Day 8
阿里云云服务器 ECS（Elastic Compute Service）是阿里云最基础的计算服务，提供弹性的、可扩展的虚拟计算能力。本篇详细讲解 ECS 的概念、架构、核心组件（实例规格、镜像、磁盘、快照、安全组）、计费方式，以及操作实践与最佳实践。
🎯考试重点：实例规格族分类、镜像类型对比、快照原理、安全组规则与实践建议、计费方式

📖 详细讲解

一、服务器基础知识

1.1 服务器的概念

服务器（Server） 是提供计算服务的硬件设备，通常配置高、性能强、稳定可靠，7×24 小时运行。服务器与普通计算机的核心区别在于：可靠性更高、扩展性更强、长期持续运行能力。

1.2 服务器的发展过程

阶段	形态	特点
传统物理服务器	自购硬件托管	采购周期长、运维成本高、扩展困难
虚拟化服务器	VMware/Hyper-V 虚拟化	资源利用率提升，但仍有物理服务器瓶颈
云服务器	云上虚拟化	按需购买、弹性伸缩、免运维

1.3 云服务器产生的背景

传统硬件服务器存在的不足：

采购周期长：从采购到上线通常需要数周
资源利用率低：平均利用率仅 15%~20%
运维成本高：需要专人维护硬件、网络、空调等
扩展困难：扩容受限于物理服务器数量

云服务器通过虚拟化技术和资源池化，解决了以上问题，实现了即开即用、弹性伸缩、按需付费。

二、阿里云云服务器全景图

2.1 飞天云平台与神龙计算

阿里云的基础设施建立在飞天云操作系统之上。2022 年阿里云发布以 CIPU（Cloud Infrastructure Processing Unit） 为核心的新一代计算架构，配合神龙计算平台，实现了设备虚拟化、网络存储转发和随路加解密的硬件全加速。

神龙架构发展历程：

第一代：基础虚拟化增强
第二代：性能大幅提升
第三代：超大规模支持
第四代（当前）：硬件加速全面集成，飞天+CIPU体系成型

2.2 弹性计算服务定位

阿里云弹性计算服务（ECS）是阿里云最基础、最核心的 IaaS 层服务，为各类云上业务提供计算支撑。

三、云服务器 ECS 概述

3.1 ECS 的概念

云服务器 ECS（Elastic Compute Service） 是一种简单高效、处理能力可弹性伸缩的计算服务。无需提前采购硬件，即可在云上快速创建或释放任意数量的云服务器，降低 IT 运维成本，使您更专注于核心业务创新。

Day9 嵌套循环与图案打印

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_10~hm_12 + 网络资料整理

一、详细讲解

1.1 核心概念

嵌套循环与图案打印是Python编程中用于处理二维结构数据的重要知识点。在本课程的第9天，我们将学习循环嵌套的基础概念、九九乘法表的实现、以及各种图案的打印技巧。

嵌套循环是指一个循环内部包含另一个循环的结构。外层循环控制行或外层维度的变化，内层循环控制列或内层维度的变化。通过合理使用嵌套循环，我们可以打印各种规则或不规则的图案，处理矩阵数据，以及解决需要多层迭代的问题。

1.2 嵌套循环基础

1.2.1 嵌套循环的执行原理

# 嵌套循环的基本结构
for i in range(外层次数):    # 外层循环
    for j in range(内层次数):  # 内层循环
        # 内层循环体
    # 外层循环体（内层循环结束后执行）

1.2.2 执行次数计算

# 嵌套循环总执行次数 = 外层次数 × 内层次数
print("=== 嵌套循环执行次数 ===")
outer_times = 3
inner_times = 4
total_executions = outer_times * inner_times
print(f"外层循环 {outer_times} 次 × 内层循环 {inner_times} 次 = 总执行 {total_executions} 次")

# 演示
count = 0
for i in range(3):
    for j in range(4):
        count += 1
        print(f"i={i}, j={j}", end="  ")
    print()  # 内层循环结束后换行
print(f"\n实际执行次数: {count}")

输出：

ACP Day 9 弹性存储系列

Sat, 21 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记

ACP Day9 学习整理｜弹性存储系列

主资料为《弹性存储系列》，配套实验为《云数据库Redis的操作实践》；本节应按“存储体系概念 + Redis 实验落地”两层来理解。

今日主题

Notion 标题：💾 Day9 弹性存储系列
核心理解：先建立云上存储体系认知，再掌握 Redis 这种高性能数据服务的接入与操作。

重点整理

弹性存储系列的整体框架包括：数据存储基础、块存储、文件存储、对象存储 OSS、日志服务 SLS、混合云存储等。
存储基础要抓住：速度、容量、成本、可靠性，以及快照、备份、故障恢复等概念。
Redis 属于 NoSQL / Key-Value 数据库，常用于缓存与热点数据访问，核心价值是高性能与高并发。
Redis 实验重点是：设置白名单、添加安全组、查看连接地址、通过 ECS 使用 redis-cli 连接实例并完成 AUTH 认证。

高频考点

为什么 Day9 不是只讲 Redis：因为主线是云上存储体系，Redis 只是其中一个具体数据服务实践切口。
为什么 Redis 常用于缓存：因为它基于内存，性能高，能减轻后端数据库压力。
为什么连接 Redis 前要处理白名单和安全组：因为云数据库实例处在受控网络中，访问必须满足网络与安全策略。
为什么通过 ECS 连接 Redis：这更符合云上实际网络模型，也通常是被允许的访问路径。

背诵版

Day9 主题是弹性存储系列，重点是建立云上存储体系认知。
常见存储类型包括：块存储、文件存储、对象存储，以及数据库类数据服务。
Redis 属于 NoSQL / Key-Value 数据库，核心价值是高性能缓存与热点数据承载。
连接 Redis 前要关注白名单、安全组、连接地址与认证信息。
Day9 的本质是：理解存储体系 + 掌握 Redis 操作实践。

Day10 函数定义与调用

Fri, 01 May 2026 10:00:00 +0800

来源：04_函数 hm_01~hm_06 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

函数定义与调用是Python编程中的核心知识点，也是代码模块化、复用和组织的基石。在本课程的第10天，我们将系统学习函数的基本概念、定义语法、参数传递、返回值处理，以及文档字符串的编写。

函数是一段组织好的、可重复使用的、用来实现单一或相关联功能的代码块。在Python中，函数不仅是一种代码复用的手段，更是实现面向过程编程和模块化设计的基础。通过函数，我们可以将复杂的问题分解为多个小问题，使程序结构更加清晰、易于维护。

1.2 函数基础

1.2.1 为什么要使用函数

# 不使用函数：代码重复
print("=== 计算圆的面积 ===")
radius = 5
area = 3.14159 * radius ** 2
print(f"半径{radius}的圆面积: {area}")

radius = 10
area = 3.14159 * radius ** 2
print(f"半径{radius}的圆面积: {area}")

radius = 15
area = 3.14159 * radius ** 2
print(f"半径{radius}的圆面积: {area}")

# 使用函数：代码复用
def calculate_circle_area(radius):
    """计算圆的面积"""
    area = 3.14159 * radius ** 2
    return area

print("\n=== 使用函数 ===")
for r in [5, 10, 15]:
    print(f"半径{r}的圆面积: {calculate_circle_area(r)}")

1.2.2 函数定义的基本语法

# 函数定义的基本结构
def 函数名(参数1, 参数2, ...):
    """文档字符串（可选）"""
    # 函数体
    return 返回值  # 可选

1.3 函数的定义与调用

1.3.1 无参函数

# 无参函数：不需要输入参数
def greet():
    """简单的问候函数"""
    print("Hello, World!")
    print("Welcome to Python!")

# 调用函数
greet()

# 可以多次调用
greet()
greet()

1.3.2 有参函数

# 有参函数：需要输入参数
def greet_person(name):
    """向指定的人打招呼"""
    print(f"Hello, {name}!")
    print(f"Welcome, {name}!")

# 调用函数，传入参数
greet_person("Alice")
print()
greet_person("Bob")

1.3.3 多参数函数

# 多个参数的函数
def calculate_rectangle(length, width):
    """计算矩形的面积和周长"""
    area = length * width
    perimeter = 2 * (length + width)
    return area, perimeter

# 调用函数
result = calculate_rectangle(5, 3)
print(f"面积: {result[0]}, 周长: {result[1]}")

# 使用解包
area, perimeter = calculate_rectangle(5, 3)
print(f"面积: {area}")
print(f"周长: {perimeter}")

1.4 参数详解

1.4.1 位置参数

# 位置参数：按顺序传递
def introduce(name, age, city):
    """自我介绍"""
    print(f"我叫{name}，今年{age}岁，来自{city}。")

# 调用时按位置传递
introduce("张三", 25, "北京")
introduce("李四", 30, "上海")
introduce("王五", 28, "广州")

# 位置参数必须传递，且顺序不能错
# introduce("赵六")  # 错误：缺少参数
# introduce(25, "钱七", "深圳")  # 错误：类型不匹配

1.4.2 关键字参数

# 关键字参数：按名称传递
def introduce(name, age, city):
    """自我介绍"""
    print(f"我叫{name}，今年{age}岁，来自{city}。")

# 使用关键字参数，顺序可以改变
introduce(age=30, name="张三", city="北京")

# 混合使用：位置参数必须在关键字参数前面
introduce("李四", city="上海", age=28)

1.4.3 默认参数

# 默认参数：给参数设置默认值
def greet(name, greeting="Hello"):
    """带默认参数的问候函数"""
    print(f"{greeting}, {name}!")

# 调用时可以不指定默认参数
greet("Alice")  # Hello, Alice!
greet("Bob", "Hi")  # Hi, Bob!

# 默认参数必须在位置参数后面
# def greet(greeting="Hello", name):  # 错误！
# 默认参数可以是有副作用的可变对象（需要注意）

1.4.4 默认参数的最佳实践

# 避免使用可变对象作为默认参数
# 错误示例
def add_to_list(item, target_list=[]):  # 危险！
    target_list.append(item)
    return target_list

print(add_to_list(1))  # [1]
print(add_to_list(2))  # [1, 2] - 不是 [2]！

# 正确示例
def add_to_list(item, target_list=None):  # 正确
    if target_list is None:
        target_list = []
    target_list.append(item)
    return target_list

print(add_to_list(1))  # [1]
print(add_to_list(2))  # [2]

1.5 返回值详解

1.5.1 无返回值函数

# 没有return语句的函数，默认返回None
def print_sum(a, b):
    """打印两个数的和，不返回值"""
    print(f"{a} + {b} = {a + b}")

result = print_sum(3, 5)
print(f"返回值: {result}")  # None

# 使用return单独返回None
def check_positive(n):
    """检查是否是正数"""
    if n > 0:
        return True
    else:
        return None

print(check_positive(5))   # True
print(check_positive(-1))  # None

1.5.2 单返回值

# 返回单个值
def square(n):
    """返回n的平方"""
    return n ** 2

result = square(5)
print(f"5的平方: {result}")  # 25

1.5.3 多返回值

# 返回多个值（实际是返回元组）
def calculate(a, b):
    """返回和、差、积"""
    return a + b, a - b, a * b

# 使用元组接收
result = calculate(10, 3)
print(f"结果类型: {type(result)}")
print(f"结果值: {result}")

# 使用解包接收
sum_val, diff, prod = calculate(10, 3)
print(f"和: {sum_val}, 差: {diff}, 积: {prod}")

1.5.4 提前返回

# 使用多个return语句
def absolute_value(n):
    """返回绝对值"""
    if n < 0:
        return -n
    return n

print(absolute_value(-5))  # 5
print(absolute_value(5))   # 5

# 早期返回（Early Return）模式
def process_data(data):
    """处理数据"""
    # 验证输入
    if not data:
        return None
    
    # 主处理逻辑
    result = []
    for item in data:
        if is_valid(item):
            result.append(process(item))
    
    return result

1.6 文档字符串（Docstring）

1.6.1 文档字符串的作用

文档字符串是紧跟在函数定义之后的一个字符串，用于说明函数的功能、参数、返回值、使用示例等信息。

ACP Day 10 云数据库RDS

Sun, 22 Mar 2026 10:00:00 +0800

来源：Notion ACP学习笔记

ACP Day10 学习整理｜云数据库RDS

主资料为《云数据库RDS》，补充资料为《云数据库RDS的操作实践》；本节应按“RDS 产品能力 + DMS / 迁移实践”两层来理解。

今日主题

Notion 标题：🗄️ Day10 云数据库RDS
核心理解：RDS 是关系型数据库的云服务化形态，DMS 负责管理，迁移流程负责把业务数据库接入 RDS。

重点整理

RDS 的核心价值：高可用、自动备份、弹性扩展、安全体系完善、运维成本低。
RDS 支持 MySQL、SQL Server、PostgreSQL、MariaDB TX 等关系型引擎。
RDS 重要维度包括：产品系列、规格族、存储类型、备份恢复、安全体系。
实践主线是：创建账号 -> 通过 DMS 建库 -> 导入本地 MySQL 数据 -> 修改 WordPress 配置 -> 验证应用改连 RDS 成功。

高频考点

为什么企业更愿意用 RDS：因为高可用、备份恢复、安全和扩容等能力被服务化了。
DMS 和 RDS 的关系：RDS 是数据库实例，DMS 是数据库管理平台。
为什么迁移后要改 wp-config.php：因为应用端必须把数据库连接从本地 MySQL 改到 RDS。
为什么备份恢复是重点：数据库场景最关键的是故障后的可恢复性。

背诵版

Day10 核心主题是云数据库 RDS。
RDS 是关系型数据库的云服务化形态。

Python 第十一天：函数返回值与 None

Fri, 01 May 2026 10:00:00 +0800

Python 第十一天：函数返回值与 None

1. 函数返回值基础

什么是返回值

返回值是函数执行完毕后向调用者提供的结果数据。在 Python 中，使用 return 语句来指定函数的返回值。当一个函数没有 return 语句，或者 return 语句后面没有任何表达式时，函数默认返回 None。

# 最简单的返回值示例
def greet():
    return "你好，世界！"

result = greet()
print(result)  # 输出: 你好，世界！

返回值的基本类型

Python 函数可以返回各种类型的数据，包括但不限于：

字符串：返回文本信息
数字：返回计算结果
布尔值：返回判断结果
列表/元组/字典：返回集合数据
对象：返回自定义类的实例
None：表示空或无返回值

# 返回不同类型的示例
def return_types_demo():
    return "Hello"           # 字符串
    return 42                 # 数字
    return [1, 2, 3]          # 列表
    return {"name": "Alice"}  # 字典
    return True               # 布尔值
    return None               # None 值

注意：函数一旦执行到 return 语句就会立即结束，后面的代码不会执行。上面的例子中，只有第一个 return 会生效。

Day11 负载均衡SLB

Fri, 10 Apr 2026 00:00:00 +0000

Day11 负载均衡SLB

一、详细讲解

1.1 负载均衡概述

负载均衡（Load Balancing）是将访问流量根据转发策略分发到多台后端服务器的技术，通过消除单点故障、提升应用系统的吞吐能力和可用性。

负载均衡发展背景

互联网初期：单机部署即可满足需求
业务增长期：访问量增加导致服务器延迟或宕机
集群方案：多台服务器组成集群，通过负载均衡设备统一分发

负载均衡分类

类别	特点
DNS负载均衡	通过DNS服务器配置多个A记录实现
二层负载均衡(MAC)	基于MAC地址分发，对应OSI第二层
三层负载均衡(IP)	基于IP分发，对应OSI网络层
四层负载均衡(TCP/UDP)	基于IP+端口分发，高效率
七层负载均衡(HTTP)	基于URL、语言等应用层信息，灵活

最常用的是四层和七层负载均衡。

负载均衡算法

静态算法（不考虑服务器状态）：

轮询法（RR）：轮流分配请求
加权轮询（WRR）：按权重分配
随机法：随机分配
Hash类：基于关键字Hash分配

动态算法（考虑服务器实时负载）：

最小连接法（LC）：分配给连接数最少的服务器
加权最小连接法（WLC）：综合权重和连接数

1.2 阿里云负载均衡SLB产品家族

阿里云SLB包含三种负载均衡产品：

产品	定位	性能
ALB（应用型负载均衡）	七层，HTTP/HTTPS/QUIC	单实例最大100万QPS
NLB（网络型负载均衡）	四层，TCP/UDP/TCPSSL	单实例最大1亿并发
CLB（传统型负载均衡）	四层+七层，TCP/UDP/HTTP/HTTPS	100万并发、5万QPS

ALB特点

强大七层处理能力与高级路由功能
基于内容的路由、重写、重定向、限速
云原生Ingress网关支持
适用场景：互联网应用七层高性能、音视频、IoT、云原生金丝雀发布

NLB特点

新一代四层负载均衡
超高性能（1亿并发）、自动弹性
支持TCPSSL卸载
适用场景：四层大流量高并发、物联网、车联网

CLB特点

基于物理机架构
四层：LVS + keepalived
七层：Tengine集群
适用场景：网站四层流量分发、同城灾备

1.3 CLB核心概念

实例类型

公网CLB：自动分配公网IP，用于互联网访问
私网CLB：通过私网IP对外提供服务

实例规格

性能共享型：资源共享，不保障性能
性能保障型：可保障性能指标

高可用架构

单实例高可用：支持多可用区，跨机房容灾
多实例高可用：通过云解析DNS调度或全球负载均衡
两地三中心：同城双活 + 异地容灾

会话保持

四层：同一IP持续发往同一服务器
七层：相同Cookie发往同一服务器

健康检查

判断后端ECS业务可用性
TCP健康检查：发送SYN报文
HTTP健康检查：发送HEAD/GET请求，检查2xx状态码
异常服务器自动移除流量

SSL证书管理

证书统一管理在SLB，解密在SLB上进行
降低后端ECS的CPU开销

日志管理

操作日志：ActionTrail集成
健康检查日志：三天内，可存OSS
访问日志：存储SLS日志库

1.4 SLB操作配置流程

准备工作：规划地域、VPC、ECS实例
创建实例：选择网络类型、VPC、可用区、IP模式
创建后端服务器组：添加ECS/ECI/ENI或IP
配置监听：配置协议、端口、转发规则
设置域名解析：CNAME解析到SLB域名

监听配置要点

协议选择：HTTP/HTTPS/QUIC/TCP/UDP
端口配置
转发规则（ALB支持丰富规则）
健康检查配置

HTTP重定向至HTTPS

创建HTTPS监听（443端口）
创建HTTP监听（80端口）
开启监听转发，选择目的HTTPS监听

1.5 SLB最佳实践场景

场景	特点	推荐搭配
公网流量入口	ECS无公网IP，提高可用性	弹性公网IP、NAT网关
音视频/游戏大流量	突发访问、海量流量、QUIC支持	全球加速GA、共享带宽
零售/金融弹性高可靠	弹性伸缩、即开即用	云企业网CEN
云原生应用	ACK/ASK/SAE集成	容器服务ACK、云数据库RDS
跨地域容灾	多地域用户智能调度	云企业网CEN

二、背诵版

2.1 负载均衡基础

负载均衡将流量分发到多台后端服务器，消除单点故障，提升可用性
四层负载均衡：基于IP+端口（TCP/UDP），效率高
七层负载均衡：基于应用层信息（HTTP/URL），灵活
静态算法：轮询、加权轮询、随机、Hash
动态算法：最小连接法、加权最小连接法

2.2 阿里云SLB产品家族

产品	层次	协议	性能指标
ALB	七层	HTTP/HTTPS/QUIC	100万QPS
NLB	四层	TCP/UDP/TCPSSL	1亿并发
CLB	四层+七层	TCP/UDP/HTTP/HTTPS	100万并发/5万QPS

2.3 CLB核心要点

CLB四层：LVS + keepalived；七层：Tengine集群
公网CLB自动分配公网IP；私网CLB使用私网IP
性能保障型可保障性能指标
会话保持：四层基于IP，七层基于Cookie
健康检查：探测后端ECS可用性，异常自动移除
SSL证书在SLB解密，减轻后端ECS压力
支持HTTPS重定向（HTTP→HTTPS）

2.4 SLB操作流程

创建实例 → 创建后端服务器组 → 配置监听 → 设置域名解析

Python 第十二天：*args、**kwargs 与默认参数

Fri, 01 May 2026 10:00:00 +0800

Python 第十二天：*args、**kwargs 与默认参数

1. 函数参数基础回顾

位置参数

位置参数是最基本的参数类型，必须按照定义顺序传递：

def greet(name, age, city):
    """三个位置参数"""
    return f"我是{name}，今年{age}岁，来自{city}"

# 必须按顺序传递
print(greet("张三", 25, "北京"))
# 输出: 我是张三，今年25岁，来自北京

# 错误示例：顺序不对
print(greet("北京", "张三", 25))  # 结果可能不符合预期

关键字参数

使用参数名传递，可以不按顺序：

def greet(name, age, city):
    return f"我是{name}，今年{age}岁，来自{city}"

# 使用关键字参数，顺序可以任意
print(greet(age=25, city="北京", name="张三"))
# 输出: 我是张三，今年25岁，来自北京

# 混合使用：位置参数在前，关键字参数在后
print(greet("张三", city="北京", age=25))
# 输出: 我是张三，今年25岁，来自北京

2. 默认参数详解

基本语法

在函数定义时给参数指定默认值，使其成为可选参数：

def greet(name, greeting="你好", punctuation="!"):
    """默认参数示例"""
    return f"{greeting}，{name}{punctuation}"

# 使用默认 greeting 和 punctuation
print(greet("张三"))              # 你好，张三!
print(greet("李四", "早上好"))    # 早上好，李四!
print(greet("王五", "晚上好", "。")) # 晚上好，王五。

默认参数的重要性

# 没有默认参数：每次都要提供所有参数
def connect_db(host, port, user, password, database):
    """连接数据库（无默认参数）"""
    return f"连接 {host}:{port}/{database} 用户={user}"

# 必须提供所有参数
conn1 = connect_db("localhost", 3306, "root", "123456", "mydb")

# 有默认参数：简化调用
def connect_db_default(host, port=3306, user="root", password="", database="test"):
    """连接数据库（带默认参数）"""
    return f"连接 {host}:{port}/{database} 用户={user}"

# 使用默认值
conn2 = connect_db_default("localhost")
conn3 = connect_db_default("localhost", user="admin")
conn4 = connect_db_default("localhost", database="production")

默认参数的常见陷阱

陷阱1：使用可变对象作为默认值

这是 Python 中最常见的错误之一！

Day 12: 云数据库Redis - ACP云计算工程师认证

Sun, 26 Apr 2026 00:00:00 +0000

Day 12：云数据库Redis

本文基于阿里云ACP云计算工程师认证课程内容整理，涵盖Redis非关系型数据库核心知识、云数据库Redis架构选型、操作配置及性能优化最佳实践。

一、非关系型数据库与Redis核心原理

什么是非关系型数据库（NoSQL）

NoSQL（Not Only SQL） 泛指非关系型数据库，区别于传统关系数据库不保证ACID特性，核心优势在于：

易扩展：无固定表结构，数据模型灵活
大数据量、高性能：支持TB级数据存储，高并发读写
灵活的数据模型：键值、列存储、文档、图形多种类型
高可用：副本集、分片集群自动故障切换

Redis核心特性

Redis（Remote Dictionary Server） 是开源的ANSI C语言编写的内存数据库，支持网络、可基于内存或持久化运行：

特性	说明
持久化	周期性地将内存更新写入磁盘，重启可恢复
数据结构丰富	支持String、List、Set、ZSet、Hash等
主从备份	Master-Slave模式数据复制
原子操作	所有操作原子性，支持事务合并执行
发布/订阅	支持消息通知、Key过期等高级特性

Redis vs 其他数据库

MySQL/PostgreSQL（关系型）→ 复杂查询、事务强一致性 MongoDB（文档型）→ JSON文档存储、半结构化数据 Redis（键值型）→ 高性能缓存、Session存储、实时计算

Redis典型使用场景：缓存层加速

在大并发场景下，直接访问数据库会造成IO压力过大：

用户请求 → 应用服务器 → Redis缓存（先访问） ↓ 未命中数据库服务器

Redis基于内存存储，QPS可达10万以上，远超MySQL等磁盘数据库，是应对高并发访问的核心武器。

考试要点：Redis不仅支持简单的Key-Value，还提供List、Set、ZSet、Hash等复杂数据结构。Redis操作是原子性的，支持事务。

二、云数据库Redis架构选型指南

阿里云Redis产品家族

阿里云提供社区版Redis和企业版Tair两大产品线：

版本	简介	适用场景
社区版	兼容开源Redis协议	小型网站、开发测试、个人学习
企业版Tair	阿里集团自研，增强性能	企业级缓存、高性能并发、低延迟场景

Tair企业版三大存储形态

类型	核心技术	适用场景
性能增强型	多线程模型，性能≈社区版3倍	高性能、低延迟要求
持久内存型	掉电数据不丢失，成本降低30%	温冷数据存储、兼顾性能与成本
容量存储型	基于ESSD，大容量低成本	大容量、低访问频率数据

部署架构选型

标准版-双副本（Master-Replica）

主节点提供日常访问，备节点提供HA高可用
主节点故障后30秒内自动切换到备节点
适用：Redis协议兼容性要求高、作为持久化数据存储、单节点性能压力可控

标准版-单副本

单节点部署，无备用节点
提供数据持久化和备份机制
价格优势明显，适合纯缓存业务

集群版-双副本

代理（Proxy）模式，一个统一连接地址访问集群
数据分片横向扩展，每个分片双副本高可用
适用：数据量大、QPS高、吞吐密集型场景

读写分离版

主备节点 + 只读节点 + 代理节点
链式复制架构，只读节点扩展使整体性能线性增长
适用：读多写少、读取QPS压力大的场景

容灾方案三级对比

灾备级别	架构	说明
★★★☆☆	单可用区双副本	主备部署在不同机器，同一可用区
★★★★☆	双可用区高可用	主备分属同一地域两个可用区，单AZ故障自动切换
★★★★★	全球多活分布式	多子实例跨地域同步，支持异地灾备、就近访问

考试要点：标准版-双副本的主备自动切换时间约为30秒。集群版采用代理模式，通过统一域名访问。读写分离版只读节点采用链式复制架构。

Python Day 13 - 列表增删改查

Fri, 01 May 2026 00:00:00 +0000

深入学习Python列表的创建、访问、添加、删除、修改和查询操作

Day 13: 容器服务ACK - ACP云计算工程师认证

Sun, 26 Apr 2026 00:00:00 +0000

Day 13：容器服务ACK

本文基于阿里云ACP云计算工程师认证课程内容整理，涵盖容器与Docker技术原理、Kubernetes核心概念、容器服务ACK架构与操作配置，以及企业级DevOps最佳实践。

一、容器与Docker技术原理

云计算应用架构演进

单体应用 → SOA架构 → 微服务架构 → 云原生架构 (垂直竖井) (服务化) (轻量容器) (容器+K8s+DevOps)

云原生时代三驾马车：容器、微服务、DevOps

为什么需要容器

容器是一种轻量级、可移植、自包含的软件打包技术，使应用程序可以在几乎任何地方以相同方式运行：

一致性环境：开发、测试、生产环境完全一致
超快速启动：秒级启动，告别分钟级虚拟机
资源隔离：容器间相互隔离，互不影响
高效利用：不需要完整操作系统，容器密度远高于VM

Docker核心特性

特性	说明
标准化	一次构建，到处运行，环境一致
高性能	容器直接运行在宿主机内核，无需硬件虚拟化
轻量级	共享宿主机内核，秒级启动，资源利用率高
隔离性	Linux Namespace实现进程级隔离

Docker vs 虚拟机

对比项	Docker容器	虚拟机
启动时间	秒级	分钟级
资源占用	共享宿主机内核，低	独立操作系统，高
隔离级别	进程级	硬件级
镜像大小	MB级	GB级
交付内容	应用+依赖	完整OS+应用

Docker核心组件

Docker架构 ├── Docker Client（客户端）← 用户交互界面 ├── Docker Daemon（服务端）← 守护进程 ├── Image（镜像）← 只读模板 ├── Container（容器）← 镜像运行实例 └── Registry（镜像仓库）← 镜像存储分发

Build、Ship、Run 流程：

Python Day 14 - 列表推导式 enumerate zip

Fri, 01 May 2026 00:00:00 +0000

深入学习Python列表推导式、enumerate和zip函数的高效用法

Day14 弹性伸缩 + 云架构运维

Thu, 16 Apr 2026 10:00:00 +0800

来源：Notion ACP学习笔记 + 阿里云开发者社区 + 网络资料整理

一、详细讲解

1.1 弹性伸缩概述

弹性伸缩（Auto Scaling）：根据业务负载自动调整计算资源（ECS 实例数量）的功能，实现"用多少扩多少，不用就缩回去"。

为什么需要弹性伸缩：

成本优化：波峰扩容、波谷缩容，避免资源浪费
应对突发流量：大促、活动等场景下自动承接流量
保证可用性：负载高时自动扩容，避免服务崩溃
减少人工干预：规则驱动，7×24 小时无人值守

1.2 阿里云弹性伸缩核心概念（重点）

伸缩组（Scaling Group）

伸缩组是弹性伸缩的核心管理单元，包含以下要素：

要素	说明
最小实例数	伸缩组始终保持的最小实例数量
最大实例数	伸缩组允许扩容到的最大实例数量
期望实例数	伸缩组当前期望维持的实例数量
默认实例数	伸缩组创建时自动创建的实例数量

伸缩配置（Scaling Configuration）

定义创建新 ECS 实例的规格：

实例规格（vCPU / 内存）
镜像（操作系统）
安全组
弹性网卡
实例存储

伸缩规则（Scaling Rule）

规则类型	说明	示例
简单规则	直接指定目标实例数或调整量	+1 台、-2 台、调整到 5 台
步进规则	按负载分层递进调整	CPU > 80% 时 +3 台，> 60% 时 +1 台
目标追踪规则	自动维持目标指标	保持平均 CPU 利用率在 60%

伸缩触发任务

触发方式	说明
定时任务	固定时间触发扩缩容（如每晚高峰期提前扩容）
云监控报警任务	指标阈值触发（CPU、内存、QPS 等）
周期任务	周期性重复触发（每天/每周定时）

⚠️ 重要：云监控报警任务是独立于伸缩组存在的，删除伸缩组不会删除报警任务！

Python Day 15 - 元组 unpacking namedtuple

Fri, 01 May 2026 00:00:00 +0000

深入学习Python元组的基本操作、解包与namedtuple高级用法

Day 15: 企业应用服务（DNS/SSL/CDN）- ACP云计算工程师认证

Sun, 26 Apr 2026 00:00:00 +0000

Day 15：企业应用服务（DNS/SSL/CDN）

本文基于阿里云ACP云计算工程师认证课程内容整理，涵盖企业网站访问全链路：DNS域名解析原理、云解析DNS配置、SSL证书管理，以及CDN内容分发网络原理、配置与最佳实践。

一、企业应用访问全链路：DNS与域名系统

为什么需要域名

人类记忆域名（如www.aliyun.com）比IP地址（如119.75.217.109）容易得多。计算之间通过IP通信，但用户通过域名访问应用——这背后就是DNS（Domain Name System） 域名系统在起作用。

用户浏览器输入域名 ↓ DNS服务器查询域名对应的IP地址 ↓ 返回IP地址 ↓ 浏览器根据IP发起HTTP/HTTPS请求 ↓ 服务器响应内容

域名结构解析

以www.google.com为例：

层级	名称	说明
顶级域名（TLD）	`.com`	由ICANN管理
二级域名	`google`	注册人可自定义
子域名/三级域名	`www`	主机记录，指向Web服务器

常见子域名用途：

mail.google.com → Gmail邮件服务
drive.google.com → Google Drive云存储
map.baidu.com → 百度地图

HTTP vs HTTPS

协议	端口	加密	安全性
HTTP	80	明文传输	低，存在中间人攻击风险
HTTPS	443	SSL/TLS加密	高，提供身份认证和隐私保护

HTTPS = HTTP + SSL，SSL证书在浏览器和网站之间建立加密通道。

SSL加密原理

SSL（Secure Sockets Layer）采用公钥密码体制：

网站向权威CA机构申请SSL证书（包含公钥和网站身份信息）
浏览器访问网站时，服务器发送证书
浏览器验证证书有效性，获取公钥
浏览器生成对称密钥，用公钥加密后发送
服务器用私钥解密，获取对称密钥
双方使用对称密钥加密通信

企业网站建设五步流程

域名注册认证 → 网站建设备案 → 配置域名解析 → 部署SSL证书 → 网站上线

考试要点：域名由ICANN统一管理，国内由CNNIC负责.cn域名。完整的域名至少包含顶级域名和二级域名两部分。SSL证书提供加密传输和身份认证双重功能。

Python Day 16 - 字典 CRUD get pop update setdefault

Fri, 01 May 2026 00:00:00 +0000

深入学习Python字典的创建、读取、更新、删除等核心操作

Day16 阿里云安全概述

Sun, 26 Apr 2026 03:32:00 +0800

阿里云安全概述

详细讲解

一、信息安全重大事件回顾

2017年勒索病毒大爆发

2017年5月12日，Windows敲诈勒索病毒大规模爆发，在全球大范围蔓延，感染用户主要集中在企业、高校等内网环境。此事件标志着网络攻击从技术炫耀转向利益驱动。

2018年供应链攻击兴起

Memcache DDoS攻击：GitHub遭受1.35TB攻击，随后NETSCOUT确认1.7 Tbps反射放大攻击
GPON路由器漏洞：绕过验证漏洞(CVE-2018-10561)和命令注入漏洞(CVE-2018-10562)，十天内被僵尸网络利用传播
供应链攻击成为主要威胁形式

2019-2021年安全威胁持续升级

2019年"罗宾汉"勒索软件打瘫美国市政府，1万台电脑被入侵
2020年运维面板紧急安全更新，7.4.2版本存在严重漏洞
2021年国内多家银行、医疗机构感染incaseformat蠕虫病毒

二、信息安全基本概念

定义：涉及信息的保密性、完整性、可用性、真实性、可控性的相关技术和理论。

本质：

保护：系统的硬件、软件、数据
防止：系统和数据遭受破坏、更改、泄露
保证：系统连续可靠正常地运行，服务不中断

两个层面：

技术层面：防止外部用户的非法入侵
管理层面：内部员工的教育和管理

三、云计算面临的安全威胁（CSA 12大威胁）

威胁类型	安全威胁	影响
可用性	DDoS攻击、僵尸网络	网站业务不可用
完整性	网站入侵、暴力破解	页面被篡改、植入后门
保密性	网站后门、数据库拖库	用户信息和敏感数据泄露

CSA 12大云计算安全威胁：

数据泄露 2. 身份凭证不足 3. 不安全接口API 4. 系统漏洞 5. 账户劫持 6. 恶意内部人员 7. APT 8. 数据丢失 9. 尽职调查不足 10. 滥用云服务 11. DoS 12. 共享技术漏洞

四、阿里云安全体系

责任分担模型

云平台安全责任：云产品安全、虚拟化安全、硬件安全、物理安全
用户安全责任：用户账户安全、用户业务安全、用户应用安全、用户数据安全、用户基础安全

阿里云安全里程碑

2009年：飞天第一行代码，阿里云成立
2011年：推出"云盾"安全产品与服务
2017年：奥运会全球指定云服务商
2021年：发布108个云产品安全功能，服务超300万企业客户

安全能力

基础安全：DDoS防护、Web应用防火墙、云防火墙
业务安全：内容安全、实人认证、风险识别
数据与身份安全：数据安全中心、密钥管理、加密服务

云产品安全生命周期（SPLC）

安全左移，实现产品默认安全：立项→研发→测试→上线/变更→监控→应急响应

Day17 字典遍历与嵌套

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + Python 3.11官方文档 + 网络资料整理

一、详细讲解

1.1 字典遍历三种方式

Python 字典提供三个核心视图对象，用于遍历键、值或键值对：

person = {"name": "小明", "age": 18, "city": "北京", "job": "工程师"}

# 遍历所有键（最常用）
for key in person:
    print(f"{key}: {person[key]}")

# 遍历所有键（显式）
for key in person.keys():
    print(key)

# 遍历所有值
for value in person.values():
    print(value)

# 遍历键值对（最推荐）
for key, value in person.items():
    print(f"{key}: {value}")

输出：

name: 小明 age: 18 city: 北京 job: 工程师小明 18 北京工程师 name: 小明 age: 18 city: 北京 job: 工程师

1.2 items() 视图对象的高级用法

items() 返回的是视图对象，不是列表，具有内存高效的特点：

Day17 网络安全

Sun, 26 Apr 2026 03:33:00 +0800

网络安全

详细讲解

一、阿里云DDoS防护

DDoS攻击介绍

分布式拒绝服务（Distributed Denial of Service，简称DDoS）将多台计算机联合起来作为攻击平台，通过远程连接利用恶意程序，对一个或多个目标发起DDoS攻击，消耗目标服务器性能或网络带宽，从而造成服务器无法正常地提供服务。

DDoS危害：

重大经济损失
数据泄露
恶意竞争

常见DDoS攻击类型

类型	攻击方式
畸形报文	Frag Flood、Smurf、Stream Flood、Land Flood等
传输层DDoS	Syn Flood、Ack Flood、UDP Flood、ICMP Request Flood等
DNS DDoS	DNS Query Flood、权威服务器攻击、Local服务器攻击等
连接型DDoS	TCP慢速连接、Loic、Hoic、Slowloris等
Web应用层DDoS	HTTP Get Flood、HTTP Post Flood、CC攻击

阿里云DDoS防护产品线

产品	特点	适用场景
DDoS原生防护基础版	免费提供最大5Gbps防护	基础防护
DDoS原生防护企业版	透明防护，一键添加	需要多IP防护
DDoS高防	Tbps级防护，全协议防护	网站、游戏、金融
游戏盾	专防TCP协议CC攻击	游戏行业

DDoS原生防护工作原理

直接为阿里云公网IP资产提升DDoS攻击防御能力
主要提供三层和四层流量型攻击防御
超出清洗阈值后自动触发流量清洗
通过旁路部署方式建设DDoS攻击检测及清洗系统

DDoS高防工作原理

支持DNS解析和IP直接指向两种引流方式
正常访问流量通过端口协议转发返回源站
恶意攻击流量在高防流量清洗中心过滤

二、Web应用防火墙（WAF）

WAF背景

传统WAF痛点：

80%用不上
50%无法应用复杂业务
30%误报机率大
无专人后续运维
产品升级慢、流程复杂

阿里云WAF核心能力

0day漏洞防护：自动防御补丁规则
Web应用防护：防御OWASP常见威胁
CC防护：拦截恶意肉鸡请求
业务风控：防刷、防爬、防撞库

WAF工作原理

浏览器输入域名访问
DNS服务器解析到WAF集群地址
访问流量到达WAF防护集群进行清洗
干净流量根据域名回源到真实服务器
响应内容回到WAF进行双向检测

WAF产品优势

10年以上网络安全经验
集成大数据能力
防御CC攻击和爬虫攻击
5分钟内部署和激活
无需安装软硬件或调整路由

三、云防火墙

云防火墙定位

业界首款Saa化防火墙，云原生的云上边界网络安全防护产品，是业务上云的第一道网络防线。

Day18 字符串全解

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + Python 3.11官方文档 + 网络资料整理

一、详细讲解

1.1 字符串基本特性

Python 字符串是不可变序列（Immutable Sequence），所有修改操作都会返回新字符串：

s = "Hello"
# s[0] = "J"  # TypeError: 'str' object does not support item assignment

# 正确做法：创建新字符串
s2 = "J" + s[1:]
print(s2)  # Jello

# 字符串长度
print(len("Hello"))  # 5

1.2 字符串索引与切片

s = "Python是最流行的编程语言"

# 正向索引（从0开始）
print(s[0])   # P
print(s[7])   # 是

# 反向索引（从-1开始）
print(s[-1])  # 言
print(s[-4])  # 编

# 切片 s[start:end:step]
print(s[0:6])     # Python（不含end）
print(s[7:10])     # 是最流
print(s[:6])       # Python（省略start=0）
print(s[7:])       # 是最流行的编程语言（省略end=len）
print(s[::2])      # Pto无流编言言（步长2）
print(s[::-1])     # 言语言程编的行流最是（逆序）

1.3 常用字符串方法

查找与替换：

Day18 主机安全

Sun, 26 Apr 2026 03:34:00 +0800

主机安全

详细讲解

一、主机安全困境

云环境面临的新安全问题

边界和责任越来越模糊：云的边界/安全责任（共担模型）越来越模糊
资产业务的多元化：用户资产涉及云上云下，类型越来越多元
安全威胁的预谋化：攻击方式从撒网式无差别扫描转向定向攻击

二、云安全中心介绍

云安全中心（态势感知）是集持续监测、深度防御、全面分析、快速响应能力于一体的云上安全管理平台。

产品规格

版本	特点
免费版	基础免费安全防护服务
防病毒版	一键式病毒查杀，避免服务器被入侵
高级版	更轻松满足合规检查要求
企业版	服务器、容器环境的全面安全检测与防护能力
旗舰版	全面建立主机安全防御体系，防勒索防篡改

产品优势

稳定性：百万级服务器装机量，CPU使用率低于10%
统一安全管理：支持线下IDC及其他云平台统一管控
安全闭环能力：主动拦截病毒木马，漏洞扫描，一键修复
病毒云查杀：实时病毒检测和防护服务
全面攻击检测：250+威胁检测模型

产品架构

云安全中心构建涵盖网络层、主机层、应用层的安全纵深防护体系：

网络层：流量镜像检测分析出入云平台的全部网络流量
应用层：扫描Web漏洞、检测Web攻击、分析应用层访问记录
主机层：实时检测主机资产，异常进程/端口/网络连接，漏洞扫描

三、安全预防功能

漏洞扫描与修复

Windows系统漏洞
Linux软件漏洞
Web-CMS漏洞
应用漏洞
应急漏洞

基线检查

检测操作系统和服务的弱口令、账号权限、身份鉴别、密码策略、访问控制、安全审计和入侵防范等安全配置。

云平台配置检查

基于云平台安全实践，联动云产品能力形成安全闭环。

四、主动防御功能

防勒索、防病毒

实时拦截已知勒索病毒、挖矿、蠕虫、DDoS等七类病毒。

应用白名单

防止未经授权的应用异常启动，影响业务正常运行。

防篡改

防止网站被植入涉恐涉政、暗链、后门等，保障网页正常。

云蜜罐

云原生VPC黑洞功能：导流至蜜罐服务
通用主机探针方案：业务主机上部署Agent进行流量转发
丰富蜜罐服务：高低交互蜜罐，覆盖Web、数据库、系统服务等

五、威胁检测功能

安全告警类型

网页防篡改、进程异常行为、网站后门
异常登录、异常事件、敏感文件篡改
恶意进程（病毒云查杀）、异常网络连接
异常账号、应用入侵事件、容器集群异常

病毒云查杀能力

深度学习检测引擎：智能识别未知威胁
云沙箱：真实还原云上环境，监控恶意样本攻击行为
多引擎集成：集成中国及海外主流杀毒引擎
威胁情报检测：多维度检测异常进程和恶意行为

病毒类型：蠕虫病毒、挖矿程序、病毒型感染、勒索病毒、后门程序、木马程序、DDoS木马

查杀优势

轻量：仅占用1% CPU、50MB内存
实时：获取进程启动日志，实时监控
统一管理：云安全中心控制台统一管控

六、容器安全

镜像漏洞扫描

支持深度漏洞扫描，提供漏洞修复方案。

Day19 集合操作全解

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + Python 3.11官方文档 + 网络资料整理

一、详细讲解

1.1 集合的基本特性

Python 集合（Set）是无序、不重复的可变容器：

# 创建集合
s1 = {1, 2, 3, 4, 5}
s2 = set([1, 2, 2, 3, 3, 4, 4])  # set()从列表创建，自动去重
print(s2)  # {1, 2, 3, 4}

# 创建空集合（不能用{}，那是dict）
empty = set()
print(type(empty))  # <class 'set'>

# 集合特点：无序 + 不重复
s = {3, 1, 4, 1, 5, 9, 2, 6}
print(s)  # {1, 2, 3, 4, 5, 6, 9}（顺序不确定）

# 自动去重
nums = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = set(nums)
print(unique)  # {1, 2, 3, 4}

1.2 集合的增删操作

s = {1, 2, 3}

# 添加元素
s.add(4)          # 添加一个元素
print(s)           # {1, 2, 3, 4}
s.add(2)           # 已存在的元素，集合不变
print(s)           # {1, 2, 3, 4}

s.update([5, 6, 7])  # 批量添加（传入可迭代对象）
print(s)              # {1, 2, 3, 4, 5, 6, 7}

# 删除元素
s.remove(3)          # 删除指定元素，不存在则抛KeyError
print(s)              # {1, 2, 4, 5, 6, 7}

s.discard(10)        # 删除指定元素，不存在也不报错
print(s)              # {1, 2, 4, 5, 6, 7}

popped = s.pop()     # 随机删除并返回一个元素
print(popped)        # 1（通常删除第一个）
print(s)              # {2, 4, 5, 6, 7}

s.clear()            # 清空集合
print(s)              # set()

1.3 集合运算（重点）

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# 交集：两个集合都有的元素
print(A & B)               # {4, 5}
print(A.intersection(B))    # {4, 5}

# 并集：所有元素（去重）
print(A | B)               # {1, 2, 3, 4, 5, 6, 7, 8}
print(A.union(B))           # {1, 2, 3, 4, 5, 6, 7, 8}

# 差集：A有B没有的元素
print(A - B)               # {1, 2, 3}
print(A.difference(B))      # {1, 2, 3}

# 对称差集：A和B互相没有的元素
print(A ^ B)               # {1, 2, 3, 6, 7, 8}
print(A.symmetric_difference(B))  # {1, 2, 3, 6, 7, 8}

# 子集与超集
X = {1, 2, 3}
Y = {1, 2, 3, 4, 5}
print(X < Y)   # True（X是Y的真子集）
print(Y > X)   # True（Y是X的真超集）
print(X <= Y)  # True（X是Y的子集，包含相等情况）
print(Y >= X)  # True（Y是X的超集）

# 判断是否相交（无交集返回True）
print(A.isdisjoint(B))  # False（有交集4,5）
C = {10, 20}
print(A.isdisjoint(C))  # True（无交集）

1.4 集合的成员测试

s = {1, 2, 3, 4, 5}

print(3 in s)     # True
print(10 in s)    # False
print(3 not in s) # False

# 集合成员测试比列表快很多（O(1) vs O(n)）

1.5 集合推导式

# 基本集合推导式
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = {x for x in nums if x % 2 == 0}
print(evens)  # {2, 4, 6, 8, 10}

# 带计算的集合推导式
squares = {x**2 for x in range(1, 6)}
print(squares)  # {1, 4, 9, 16, 25}

# 实际应用：从字符串提取不重复字符
text = "hello world"
unique_chars = {c for c in text if c.isalpha()}
print(unique_chars)  # {'h', 'e', 'l', 'o', 'w', 'r', 'd'}

1.6 frozenset（不可变集合）

frozenset 是不可变版本，创建后不能修改：

Day19 数据安全

Sun, 26 Apr 2026 03:35:00 +0800

数据安全

详细讲解

一、数据安全中心（DSC）

数据安全中心（Data Security Center，简称DSC）为客户提供敏感数据自动识别、分级分类、大数据安全审计与数据脱敏等数据安全能力。

产品特点

合规性：满足等保2.0二级"安全审计"与三级"个人信息保护"要求
云原生：依托云原生优势，为云上数据源提供一体化保护
智能化：运用大数据和机器学习能力，智能识别敏感数据
可视化：提供敏感数据识别结果可视化能力

产品功能

免代理一键授权接入：侵入度低，无需登录应用程序
以敏感数据为中心的能力联动：异常行为告警自动关联敏感数据
数据安全态势可视化管理：以资产/用户/事件为中心的审计报表

数据域管理

支持企业管理员基于业务属性、组织架构、数据特征等维度对数据资产进行划分
将具有相同特征的数据资产划分到同一个数据域

数据梳理

敏感数据：客户资料、技术资料、个人信息等高价值数据
支持结构化数据、非结构化数据和大数据产品
内置超过200种文件类型、40+种敏感数据类型

安全审计

原生日志采集：自动建立与对应产品的数据采集链路
Agent采集：通过部署Agent转发日志给DSC审计服务器

数据脱敏

静态脱敏：使用脱敏算法对敏感数据进行遮盖、加密或替换
动态脱敏：直接脱敏指定数据，每次小于2MB
脱敏算法：哈希、洗牌、数据解密、遮盖、替换、加密、变换

数据泄露检测

异常行为识别：及时告警并一键止血
联动威胁情报：封禁恶意IP访问
联动敏感数据识别：从海量告警中快速锁定高危风险
数据明/暗水印：泄露事件溯源

二、密钥管理服务（KMS）

密钥管理服务KMS（Key Management Service）为应用提供符合国密要求的密钥服务及极简应用加解密服务。

功能组件

组件	说明
密钥服务	密钥的全托管和保护，支撑云原生接口的极简数据加密和数字签名
凭据管家	凭据托管加密、定期轮转、安全分发、中心化管理
证书管家	高可用、高安全的密钥和证书托管能力，以及签名验签能力
专属KMS	专属于用户的云上私有密钥管理服务

托管密码机

硬件密码机（HSM）是执行密码运算、安全生成和存储密钥的硬件设备
合规：国密检测认证、FIPS认证
安全：硬件保护、密钥版本管理
易运维：按量计费、自动密钥轮转

密钥轮转

KMS中的CMK支持多个密钥版本
每一个密钥版本是独立生成的密钥
通过生成新密钥版本实现自动轮转

凭据管家

通用凭据：存储账号口令、访问密钥、OAuth密钥、API Key等
动态RDS凭据：应用程序无需配置静态数据库账号口令
动态RAM凭据：全自动定期轮换AccessKey
动态ECS凭据：托管ECS实例登录凭据

三、加密服务

加密服务基于国家密码局认证的硬件加密机，提供了云上数据加解密服务。

加密机类型

类型	说明
通用服务器密码机	满足GM/T 0030要求，提供国际通用密码服务接口
金融数据密码机	满足GM/T 0045要求，用于金融支付领域
签名验签密码机	满足GM/T 0029要求，提供数字签名、验证签名运算

工作原理

通过云密码机产生加密密钥
使用加密密钥对应用数据明文进行加密产生密文
应用系统把密文数据存储到数据库

背诵版

数据安全中心DSC：敏感数据识别 + 分级分类 + 安全审计 + 数据脱敏

Day20 综合练习：名片管理系统

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + 原创项目设计

一、详细讲解

1.1 项目概述

名片管理系统是一个经典的 Python 入门综合项目，涉及：

字典存储名片数据
无限循环 while True 实现菜单
函数封装增删改查操作
if-elif 多重分支处理用户选择

1.2 数据结构设计

# 名片数据结构（字典）
card = {
    "name": "张三",
    "phone": "13800138000",
    "email": "zhangsan@example.com",
    "company": "百度公司"
}

# 名片列表（所有名片存储在列表中）
cards_list = [
    {"name": "张三", "phone": "13800138000", "email": "zhangsan@example.com", "company": "百度"},
    {"name": "李四", "phone": "13900139000", "email": "lisi@example.com", "company": "阿里"},
]

1.3 核心函数实现

# ========== 1. 显示菜单 ==========
def show_menu():
    print("=" * 50)
    print("  名片管理系统 V1.0")
    print("  1. 新增名片")
    print("  2. 显示全部")
    print("  3. 搜索名片")
    print("  4. 修改名片")
    print("  5. 删除名片")
    print("  0. 退出系统")
    print("=" * 50)

# ========== 2. 新增名片 ==========
def add_card(cards):
    name = input("请输入姓名：")
    phone = input("请输入电话：")
    email = input("请输入邮箱：")
    company = input("请输入公司：")
    
    card = {
        "name": name,
        "phone": phone,
        "email": email,
        "company": company
    }
    cards.append(card)
    print(f"√ 名片「{name}」添加成功！")

# ========== 3. 显示全部名片 ==========
def show_all(cards):
    if len(cards) == 0:
        print("当前没有任何名片，请先添加！")
        return
    
    print(f"共找到 {len(cards)} 张名片：")
    print("-" * 60)
    for card in cards:
        print(f"姓名：{card['name']}")
        print(f"电话：{card['phone']}")
        print(f"邮箱：{card['email']}")
        print(f"公司：{card['company']}")
        print("-" * 60)

# ========== 4. 搜索名片 ==========
def search_card(cards):
    if len(cards) == 0:
        print("当前没有任何名片！")
        return None
    
    search_name = input("请输入要搜索的姓名：")
    results = [c for c in cards if c["name"] == search_name]
    
    if results:
        print(f"找到 {len(results)} 张名片：")
        for card in results:
            print(f"  姓名：{card['name']}，电话：{card['phone']}")
        return results
    else:
        print(f"没有找到名为「{search_name}」的名片")
        return None

# ========== 5. 修改名片 ==========
def modify_card(cards):
    if len(cards) == 0:
        print("当前没有任何名片！")
        return
    
    search_name = input("请输入要修改的姓名：")
    for card in cards:
        if card["name"] == search_name:
            print("请输入新的信息（直接回车保留原值）：")
            new_phone = input(f"电话[{card['phone']}]：")
            new_email = input(f"邮箱[{card['email']}]：")
            new_company = input(f"公司[{card['company']}]：")
            
            if new_phone:
                card["phone"] = new_phone
            if new_email:
                card["email"] = new_email
            if new_company:
                card["company"] = new_company
            
            print(f"√ 名片「{search_name}」修改成功！")
            return
    
    print(f"没有找到名为「{search_name}」的名片")

# ========== 6. 删除名片 ==========
def delete_card(cards):
    if len(cards) == 0:
        print("当前没有任何名片！")
        return
    
    search_name = input("请输入要删除的姓名：")
    for i, card in enumerate(cards):
        if card["name"] == search_name:
            confirm = input(f"确定删除名片「{search_name}」？(y/n)：")
            if confirm.lower() == "y":
                cards.pop(i)
                print(f"√ 名片「{search_name}」已删除！")
            return
    
    print(f"没有找到名为「{search_name}」的名片")

1.4 主程序循环

def main():
    cards = []  # 存储所有名片的列表
    
    while True:
        show_menu()
        user_choice = input("请选择操作（0-5）：")
        
        if user_choice == "1":
            add_card(cards)
        elif user_choice == "2":
            show_all(cards)
        elif user_choice == "3":
            search_card(cards)
        elif user_choice == "4":
            modify_card(cards)
        elif user_choice == "5":
            delete_card(cards)
        elif user_choice == "0":
            print("感谢使用，再见！")
            break
        else:
            print("无效选择，请输入 0-5 之间的数字")

if __name__ == "__main__":
    main()

1.5 运行效果示例

================================================== 名片管理系统 V1.0 1. 新增名片 2. 显示全部 3. 搜索名片 4. 修改名片 5. 删除名片 0. 退出系统 ================================================== 请选择操作（0-5）：1 请输入姓名：张三请输入电话：13800138000 请输入邮箱：zhangsan@example.com 请输入公司：百度公司 √ 名片「张三」添加成功！请选择操作（0-5）：2 共找到 1 张名片： ------------------------------------------------------------ 姓名：张三电话：13800138000 邮箱：zhangsan@example.com 公司：百度公司 ------------------------------------------------------------ 请选择操作（0-5）：0 感谢使用，再见！

1.6 模块化改进（进阶）

将代码拆分为多个文件：

Day20 业务安全

Sun, 26 Apr 2026 03:36:00 +0800

业务安全

详细讲解

一、内容安全

内容安全基于深度学习技术，提供图片、视频、语音、文字、网页等多媒体的内容风险智能识别和审核服务。

产品功能

内容检测API：提供图片、视频、文本、语音、网页等形式内容违规检测API
OSS违规检测：检测OSS中图片、视频、音频文件中的违规风险
自定义机审标准：基于业务场景配置审核标准

核心能力

海量数据样本：基于阿里巴巴多年积累的海量互联网数据训练AI模型
弹性服务扩容：服务秒级弹性扩容
性价比高：毫秒级结果返回，99%以上准确率
个性化定制：一对一运营，支持个性化识别策略调整

检测能力覆盖

暴恐、涉政、涉黄、广告、辱骂、不良场景等风险检测

人工审核服务

人机审核：机器识别基础上选择性人工审核
纯人工审核：对全量内容数据进行人工审核

二、实人认证

实人认证是对用户身份信息真实性核验的服务，验证用户为真人且为本人。

产品优势

精准身份认证技术：基于深度学习生物识别算法
全局信息安全保障：从终端设备、网络传输、服务器、数据管理各环节保障
多样产品能力输出：PC、APP、H5、小程序全场景覆盖
安全对抗丰富经验：源自阿里巴巴多年风险对抗实战经验

金融级实人认证方案

方案	说明
金融级多因子意愿认证方案	人脸与声纹双模态活体检测
金融级活体人脸验证方案	活体检测+人脸比对
金融级活体检测方案	纯活体检测
金融级人脸比对方案	人脸比对

认证场景

有源认证：权威渠道验证
自定义比对源认证：自定义比对源
真人检测：验证真人为本人

三、风险识别

风险识别（Fraud Detection）是一套实时分析、精准识别、全场景覆盖的业务风险管理产品。

核心能力

资深专家团队：多行业资深风控专家
全链路防控：从端到云全链路分析与动态攻防
智能算法策略：上千套策略模型即开即用
超强性能：毫秒级、超高并发能力

功能概述

功能	说明
决策引擎平台	可视化、交互友好的风险管理运营平台
场景化风控方案	面向注册、登录、营销、信贷等通用场景
设备安全能力	基于端上安全组件对设备风险进行识别

场景风控类型

注册风险识别：发现批量注册行为
登录风险识别：发现账户被盗行为
营销风险识别：发现作弊、薅羊毛、套利等风险
设备风险识别：对移动APP上的恶意设备行为进行识别
业务风险情报：对企业平台的账户或用户进行风险检测

版本对比

功能	基础版	增强版
实时分析	支持	支持
服务返回值	量化评分	量化评分+风险特征标签
设备风险监测	不支持	支持
设备指纹	不支持	支持
团伙分析	不支持	支持
日志服务投递	不支持	支持

背诵版

内容安全：深度学习 + 图片/视频/语音/文字/网页检测 + 毫秒级返回 + 99%准确率

Day 21 - 面向对象编程：类与对象基础

Fri, 01 May 2026 10:00:00 +0800

Day 21 - 面向对象编程：类与对象基础

什么是面向对象编程（OOP）？

面向对象编程（Object-Oriented Programming，简称OOP）是一种程序设计范式，它使用"对象"来描述现实世界中的事物。Python 是一种多范式编程语言，完全支持面向对象编程。在 Python 中，一切皆为对象——数字、字符串、列表、字典，甚至函数都是对象。理解类和对象的概念是掌握 Python 编程的关键一步。

面向对象编程的核心思想是将数据和操作数据的方法封装在一起，形成一个独立的单元——类（Class）。类就像是一张蓝图或者模板，定义了某种类型对象所具有的属性（特征）和方法（行为）。而对象（Object）则是根据类这张蓝图创建出来的具体实例。打个比方，“汽车"是一个类，而一辆具体的红色 BMW 汽车就是一个对象；“学生"是一个类，而"张三"这位具体的学生就是一个对象。

类的定义与语法

在 Python 中，使用 class 关键字来定义一个类。类名通常采用 PascalCase 命名法（每个单词首字母大写），例如 Student、Person、BankAccount 等。类的定义体包含属性（数据）和方法（函数）。让我们从一个最简单的例子开始：

class Person:
    """一个人类的简单表示"""
    
    def say_hello(self):
        """打招呼的方法"""
        print("你好！")

# 创建对象
p = Person()
p.say_hello()

在这个例子中，我们定义了一个名为 Person 的类。类中有一个 say_hello 方法。注意方法定义中的第一个参数 self，这是面向对象编程中最重要的概念之一。

self 参数详解

self 参数是类方法（除了类方法和静态方法之外）的第一个参数，它指向对象本身。当我们调用 p.say_hello() 时，Python 内部会将这个调用转换为 Person.say_hello(p)，也就是说，self 接收到了调用该方法的对象 p 本身。

self 这个名字并不是关键字，你可以用其他名字来代替它，但按照 Python 的惯例，始终使用 self 是一个良好的编程习惯。使用其他名字虽然不会报错，但会让你的代码难以被其他程序员理解，因为 Python 社区已经形成了使用 self 的共识。

self 的主要作用体现在以下几个方面：

访问对象的属性（实例变量）
调用对象的其他方法
在方法之间传递对象本身
判断两个对象是否是同一个对象（使用 is 运算符）

class Dog:
    def __init__(self, name, age):
        self.name = name      # 将name存储在当前对象中
        self.age = age        # 将age存储在当前对象中
    
    def bark(self):
        print(f"{self.name} 在叫：汪汪汪！")
    
    def info(self):
        print(f"名字：{self.name}，年龄：{self.age}岁")

dog1 = Dog("旺财", 3)
dog2 = Dog("小白", 5)

dog1.bark()    # 输出：旺财 在叫：汪汪汪！
dog2.bark()    # 输出：小白 在叫：汪汪汪！

dog1.info()    # 输出：名字：旺财，年龄：3岁
dog2.info()    # 输出：名字：小白，年龄：5岁

类与对象的关系

类和对象之间的关系是"模板"与"实例"的关系。类定义了创建对象的蓝图，描述了一类对象共同的特征和行为；对象是类的具体实现，每个对象都有自己独立的属性值，但共享类中定义的方法。

Day21 其他安全产品

Sun, 26 Apr 2026 03:37:00 +0800

其他安全产品

详细讲解

一、身份安全 - IDaaS

应用身份服务IDaaS介绍

IDaaS（Identity as a Service）是阿里云原生企业身份管理服务：

EIAM：用于保护企业内部身份
CIAM：提供面向外部会员的身份管理
安全认证：集成多种无密码认证方式

IDaaS设计理念

默认安全：可用性和安全性难以两全时，优先保障安全性
开发友好：API在线调试、SDK与样例代码、代码开源

EIAM使用流程

免费开通实例 → 创建账户 → 登录门户 → 创建应用

CIAM版本

版本	说明
专属版	独立环境部署，支持功能定制，适合中大型公司
标准版（未开放）	共享集群，按月活用户计费
免费版（未开放）	MAU限制100以内

安全认证

号码认证：整合三大运营商网关认证能力
IFAA：金融级移动端生物识别产品
WebAuthn：PC端浏览器免密登录
短信认证、OTP

二、安全管理服务

安全管家服务

阿里云安全专家提供的全方位安全技术和咨询服务。

产品功能

安全体系咨询：建设完善的安全运营体系
安全风险评估：评估企业信息系统安全风险
安全事件应急响应：7*24远程紧急响应处理
应用安全评估：评估应用层安全风险
安全监测与巡检：每日安全巡检
安全加固服务：指导安全加固

双层服务形态

类型	说明
企业版	安全常态化防护，风险评估+每日巡检+安全加固+事件提醒+应急响应
护航版	应急突发保障，量身定制防护方案+全面安全体检+全天候值守

应急响应服务

参照国家信息安全事件响应处理标准，提供预防、情报收集、遏制、根除、恢复流程的7*24远程紧急响应处理。

等保咨询服务

等级保护整改方案咨询
安全产品选型及部署指导
系统安全整改工作
安全管理咨询

威胁狩猎服务

基于欺骗伪装技术，通过部署诱饵和陷阱，诱导攻击者进入蜜网，完整记录攻击者行为，捕获高级未知攻击。

三、通用安全解决方案

等保合规解决方案

覆盖等保定级、备案、建设整改及测评阶段：

系统定级
系统备案
建设整改
等级测评
监督检查

等保合规2.0架构（等保三级）

安全物理环境：阿里云平台自带
安全通信网络：网络架构、通信传输、可信验证
安全区域边界：边界防护、访问控制、入侵防范、恶意代码防护、安全审计
安全计算环境：身份鉴别、访问控制、安全审计、入侵防范等
安全管理中心：系统管理、审计管理、安全管理、集中管控

四、云监控

云监控概念

云监控（CloudMonitor）是针对阿里云资源和互联网应用进行监控的服务，用于收集监控指标、探测可用性、设置警报。

Day 22 - 构造函数 init 详解

Fri, 01 May 2026 10:00:00 +0800

Day 22 - 构造函数 init 详解

什么是 init 方法？

__init__ 是 Python 类中的一个特殊方法，也被称为"构造函数"或"初始化方法"。当我们使用 类名() 创建对象时，__init__ 方法会被自动调用。它的主要作用是对新创建的对象进行初始化设置，比如给对象的属性赋初值、建立对象之间的关联关系等。

__init__ 这个名字来源于 “initialize”（初始化）这个词。在 Python 中，以双下划线 __ 开头和结尾的方法称为"魔术方法"（Magic Methods）或"特殊方法"（Special Methods），它们有特殊的用途，会在特定情况下被 Python 自动调用。

init 的基本语法

class 类名:
    def __init__(self, 参数1, 参数2, ...):
        # 初始化代码
        self.属性1 = 参数1
        self.属性2 = 参数2

__init__ 方法的第一个参数永远是 self（指向正在创建的对象），后面的参数是你在创建对象时需要传入的值。

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print(f"新对象创建：{self.name}")

# 创建对象时传入参数
person1 = Person("张三", 25, "男")
person2 = Person("李四", 30, "女")

print(f"{person1.name} 是 {person1.age} 岁的 {person1.gender}生")
print(f"{person2.name} 是 {person2.age} 岁的 {person2.gender}生")

输出：

Day 23 - 字符串表示 str 与 del

Fri, 01 May 2026 10:00:00 +0800

Day 23 - 字符串表示 str 与 del

对象的字符串表示概述

在 Python 中，每个对象都可以被转换为字符串。当你使用 print() 函数打印一个对象，或者在某些需要字符串的地方使用对象时，Python 需要将对象转换为字符串。默认的实现通常显示的是类似 <__main__.ClassName object at 0x7f8a9c123456> 这样的信息，虽然包含了对象的内存地址，但对于人类阅读来说并不友好。

为了提供更有意义的字符串表示，Python 提供了两个魔术方法：__str__ 和 __repr__。通过在类中重写这两个方法，你可以自定义对象的字符串表现形式，使输出更加友好和有意义。

这两个方法的区别在于：__str__ 是面向用户的字符串表示，用于给终端用户查看；而 __repr__ 是面向开发者的字符串表示，应该尽可能提供详细的信息，以便开发者调试。

str 方法详解

__str__ 方法在以下情况会被调用：

使用 print() 函数打印对象时
使用 str() 函数转换对象时
在需要字符串的地方使用 f-string 格式化对象时
用户友好的错误消息中

__str__ 方法应该返回一个字符串。如果没有定义 __str__，Python 会使用 __repr__ 作为备选。

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages
    
    def __str__(self):
        """返回用户友好的字符串表示"""
        return f"《{self.title}》 - {self.author}"

book = Book("活着", "余华", 500)

print(book)           # 《活着》 - 余华
print(str(book))      # 《活着》 - 余华
print(f"我正在读{book}")  # 我正在读《活着》 - 余华

repr 方法详解

__repr__ 方法在以下情况会被调用：

Day 24 - 私有属性与封装

Fri, 01 May 2026 10:00:00 +0800

Day 24 - 私有属性与封装

什么是封装？

封装（Encapsulation）是面向对象编程的三大基本特性之一（另外两个是继承和多态）。封装的核心理念是将数据（属性）和操作数据的方法（行为）打包在一起，对外隐藏内部实现细节，只暴露必要的接口。这样做的好处是：提高代码的可维护性、降低模块间的耦合度、保护数据不被意外或恶意修改。

在 Python 中，封装并不是像 Java 或 C++ 那样通过严格的访问控制关键字（public、private、protected）来实现的。Python 采用了一种"约定优于配置"的方式，通过命名规范来标识成员的访问级别。

Python 的命名规范

Python 中以下划线的前缀和数量来表示属性的访问级别：

_name（单下划线）：受保护的属性，按照约定，外部代码不应该直接访问，但 Python 不会阻止这种访问。这是一种"软私有"的约定。
__name（双下划线开头）：名称改写（Name Mangling）机制，会将属性名改写为 _类名__name 的形式。这提供了一定程度的"硬私有"保护，但通过改写后的名称仍然可以访问。
__name__（双下划线开头和结尾）：这是魔术方法/属性的保留命名空间，如 __init__、__str__、__dict__ 等。普通属性不应该使用这种命名方式。

class BankAccount:
    def __init__(self, account_id, initial_balance):
        self.account_id = account_id      # 公开属性
        self._transactions = []            # 受保护属性（约定不直接访问）
        self.__balance = initial_balance   # 私有属性（名称改写）
    
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须为正数")
        self.__balance += amount
        self._transactions.append(("存款", amount))
    
    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("取款金额必须为正数")
        if amount > self.__balance:
            raise ValueError("余额不足")
        self.__balance -= amount
        self._transactions.append(("取款", -amount))
    
    def get_balance(self):
        """获取余额（受控访问）"""
        return self.__balance
    
    def get_transactions(self):
        """获取交易记录"""
        return self._transactions.copy()

# 创建账户
account = BankAccount("ACC001", 1000)

# 公开属性可以直接访问
print(f"账号：{account.account_id}")

# 受保护属性（可以访问，但不推荐）
print(f"交易记录：{account._transactions}")

# 私有属性（访问会报错）
# print(account.__balance)  # AttributeError

# 但可以通过改写后的名称访问（不推荐）
print(account._BankAccount__balance)  # 1000

# 通过方法访问私有属性（推荐方式）
print(f"余额：{account.get_balance()}")

# 存款和取款
account.deposit(500)
account.withdraw(200)
print(f"交易记录：{account.get_transactions()}")
# [('存款', 500), ('取款', -200)]

为什么要使用私有属性？

假设我们有一个 BankAccount 类，余额是一个私有属性。如果允许外部代码直接访问和修改余额，那么可能会出现以下问题：

Day 25 - 继承与 super 函数

Fri, 01 May 2026 10:00:00 +0800

Day 25 - 继承与 super 函数

什么是继承？

继承（Inheritance）是面向对象编程中最核心的概念之一，它允许我们定义一个类（子类）作为另一个类（父类或基类）的扩展。子类继承了父类的属性和方法，同时可以添加自己特有的属性和方法，或者重写（override）父类的方法来改变行为。

继承的主要好处是代码复用：公共的属性和方法只需要在父类中定义一次，子类自动拥有这些特性。此外，继承还体现了"是一个"（is-a）的关系，例如：狗是一种动物，学生是一个人，苹果是一种水果。

在 Python 中，使用圆括号 () 在类名后指定父类来实现继承。

继承的基本语法

class 父类:
    # 父类的定义

class 子类(父类):
    # 子类的定义

class Animal:
    """动物基类"""
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def speak(self):
        raise NotImplementedError("子类必须实现 speak 方法")
    
    def info(self):
        print(f"名字：{self.name}，年龄：{self.age}")

class Dog(Animal):
    """狗类，继承自动物类"""
    
    def speak(self):
        print(f"{self.name} 在叫：汪汪汪！")

class Cat(Animal):
    """猫类，继承自动物类"""
    
    def speak(self):
        print(f"{self.name} 在叫：喵喵喵！")

# 创建子类对象
dog = Dog("旺财", 3)
cat = Cat("小白", 2)

dog.info()   # 名字：旺财，年龄：3
dog.speak()  # 旺财 在叫：汪汪汪！

cat.info()   # 名字：小白，年龄：2
cat.speak()  # 小白 在叫：喵喵喵！

单继承与多继承

Python 支持两种继承方式：单继承（一个类只继承一个父类）和多继承（一个类继承多个父类）。虽然多继承功能强大，但容易导致代码复杂度增加和菱形继承问题，因此在使用时需要特别小心。

Day 26 - 多重继承与方法解析顺序（MRO）

Fri, 01 May 2026 10:00:00 +0800

Day 26 - 多重继承与方法解析顺序（MRO）

多重继承的概念

多重继承（Multiple Inheritance）是指一个类可以直接继承多个父类。Python 完整地支持多重继承，这使得类可以从多个不相关的类中继承功能。然而，多重继承也带来了复杂性，特别是在方法解析顺序（Method Resolution Order，MRO）和菱形继承问题上。

class Flyer:
    def fly(self):
        print("我可以飞翔")

class Swimmer:
    def swim(self):
        print("我可以游泳")

class Walker:
    def walk(self):
        print("我可以行走")

class Duck(Flyer, Swimmer, Walker):
    """鸭子继承三种能力"""
    pass

duck = Duck()
duck.fly()   # 我可以飞翔
duck.swim()  # 我可以游泳
duck.walk()  # 我可以行走

菱形继承问题

菱形继承（Diamond Inheritance）是指两个类继承自同一个基类，然后又有一个类同时继承这两个类，形成菱形结构。这种结构在多重继承中容易引发问题：如果基类有实例属性或方法，在子类中应该如何访问？

class A:
    def greet(self):
        print("A 的 greet 方法")

class B(A):
    def greet(self):
        print("B 的 greet 方法")
        super().greet()

class C(A):
    def greet(self):
        print("C 的 greet 方法")
        super().greet()

class D(B, C):
    def greet(self):
        print("D 的 greet 方法")
        super().greet()

# 创建 D 的实例并调用 greet
d = D()
d.greet()

输出：

Day 27 - 多态与鸭子类型

Fri, 01 May 2026 10:00:00 +0800

Day 27 - 多态与鸭子类型

什么是多态？

多态（Polymorphism）是面向对象编程的三大基本特性之一，意思是"多种形态"。在 Python 中，多态指的是同一种操作（如调用同一个方法）在不同类型的对象上会产生不同的行为。

多态的核心思想是：关注对象的"行为"而非"类型"。当我们调用一个对象的方法时，不需要关心这个对象是什么类型的具体类，只需要知道它支持这个方法即可。这大大增强了代码的灵活性和可扩展性。

class Dog:
    def speak(self):
        return "汪汪汪"

class Cat:
    def speak(self):
        return "喵喵喵"

class Duck:
    def speak(self):
        return "嘎嘎嘎"

# 多态：同一个方法调用，不同对象产生不同行为
animals = [Dog(), Cat(), Duck()]

for animal in animals:
    print(f"{animal.__class__.__name__} 说：{animal.speak()}")

# 输出：
# Dog 说：汪汪汪
# Cat 说：喵喵喵
# Duck 说：嘎嘎嘎

Python 中的多态实现

Python 是动态类型语言，天生支持多态。在静态类型语言（如 Java、C++）中，多态需要通过继承和接口来实现。但在 Python 中，任何定义了 speak() 方法的对象都可以被调用，而不需要继承关系。

class People:
    def speak(self):
        return "你好！"

class Bird:
    def speak(self):
        return "叽叽喳喳"

def make_speak(obj):
    """多态函数：接收任何有 speak 方法的对象"""
    print(obj.speak())

person = People()
bird = Bird()

make_speak(person)  # 你好！
make_speak(bird)    # 叽叽喳喳

抽象基类与多态

虽然 Python 不强制使用抽象基类，但抽象基类（ABC）提供了一种方式来定义接口规范，确保子类实现了必要的方法。这在大型项目中很有用。

Day 28 - @classmethod 装饰器详解

Fri, 01 May 2026 10:00:00 +0800

Day 28 - @classmethod 装饰器详解

什么是类方法？

类方法（Class Method）是绑定到类而不是实例的方法。类方法使用 @classmethod 装饰器装饰，第一个参数是类本身（通常命名为 cls），而不是实例（self）。

类方法的主要用途包括：

工厂方法：创建类的实例的不同方式
访问或修改类属性
不依赖于特定实例的功能

class MyClass:
    class_attr = "类属性值"
    
    def __init__(self, value):
        self.instance_attr = value
    
    @classmethod
    def class_method(cls):
        """类方法"""
        print(f"类方法被调用")
        print(f"cls 是：{cls}")
        print(f"cls.class_attr = {cls.class_attr}")
        return cls("通过类方法创建")  # 可以使用 cls 创建实例

# 通过类调用类方法
MyClass.class_method()
# 类方法被调用
# cls 是：<class '__main__.MyClass'>
# cls.class_attr = 类属性值

# 通过实例调用类方法（不推荐，但可以）
obj = MyClass("实例值")
obj.class_method()  # cls 仍然是 MyClass，不是 obj 的类

实例方法 vs 类方法 vs 静态方法

Python 中有三种类型的方法：

Day 29 - @staticmethod 装饰器与单例模式

Fri, 01 May 2026 10:00:00 +0800

Day 29 - @staticmethod 装饰器与单例模式

什么是静态方法？

静态方法（Static Method）是使用 @staticmethod 装饰器装饰的方法。它不需要 self 或 cls 参数，可以像普通函数一样定义，但在类内部定义，属于类的命名空间。

静态方法的主要用途：

将一些与类相关的功能封装在类内部，使代码更组织化
不需要访问类属性或实例属性的功能
可以被子类继承（但不能通过 super() 调用父类的静态方法）

class MathUtils:
    """数学工具类"""
    
    @staticmethod
    def add(a, b):
        """加法"""
        return a + b
    
    @staticmethod
    def multiply(a, b):
        """乘法"""
        return a * b
    
    @staticmethod
    def is_prime(n):
        """判断素数"""
        if n < 2:
            return False
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

# 调用静态方法
print(MathUtils.add(3, 5))      # 8
print(MathUtils.multiply(4, 7)) # 28
print(MathUtils.is_prime(17))   # True
print(MathUtils.is_prime(15))   # False

# 也可以通过实例调用
utils = MathUtils()
print(utils.add(2, 3))  # 5

三种方法的对比

class Example:
    class_attr = "类属性"
    
    def __init__(self, value):
        self.value = value
    
    def instance_method(self):
        """实例方法：需要 self"""
        return f"实例方法，value={self.value}"
    
    @classmethod
    def class_method(cls):
        """类方法：需要 cls"""
        return f"类方法，class_attr={cls.class_attr}"
    
    @staticmethod
    def static_method():
        """静态方法：不需要 self 或 cls"""
        return "静态方法，不依赖类或实例"

# 对比
obj = Example("test")

# 实例方法：需要实例调用
print(obj.instance_method())
# Example.instance_method(obj)  # 需要显式传递实例

# 类方法：类或实例都可以调用
print(Example.class_method())
print(obj.class_method())

# 静态方法：类或实例都可以调用
print(Example.static_method())
print(obj.static_method())

静态方法与命名空间

静态方法的一个重要作用是将相关的函数组织在类的命名空间中，避免污染全局命名空间。

Day 30 - 异常处理：try-except-else-finally

Fri, 01 May 2026 10:00:00 +0800

Day 30 - 异常处理：try-except-else-finally

什么是异常？

异常（Exception）是 Python 程序在运行过程中发生的错误。当异常发生时，程序会停止执行，并创建一个异常对象。如果异常没有被捕获和处理，程序会打印一个回溯（traceback）并终止。

Python 的异常处理机制允许我们捕获异常并自定义处理方式，而不是让程序直接崩溃。这对于编写健壮的程序至关重要。

# 常见的异常类型
print(10 / 0)  # ZeroDivisionError: division by zero
print(int("abc"))  # ValueError: invalid literal for int()
print([1, 2, 3][10])  # IndexError: list index out of range
print({}["key"])  # KeyError: 'key'

try-except 基本语法

try:
    # 可能发生异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理 ZeroDivisionError 异常
    print("不能除以零！")

完整的异常处理结构

try:
    # 可能发生异常的代码
    num = int(input("请输入一个数字："))
    result = 10 / num
except ValueError:
    # 处理值错误（输入不是数字）
    print("输入无效，请输入数字！")
except ZeroDivisionError:
    # 处理除以零错误
    print("不能除以零！")
else:
    # 只有在没有异常时才会执行
    print(f"结果：{result}")
finally:
    # 无论是否有异常都会执行
    print("程序结束")

except 的多种写法

捕获特定异常

try:
    value = int("abc")
except ValueError:
    print("ValueError 被捕获")

try:
    lst = [1, 2, 3]
    value = lst[10]
except IndexError:
    print("IndexError 被捕获")

捕获多种异常（方式1）

try:
    value = int("abc")
except (ValueError, TypeError):
    print("ValueError 或 TypeError 被捕获")

捕获多种异常（方式2）

try:
    value = int("abc")
except ValueError:
    print("ValueError 被捕获")
except TypeError:
    print("TypeError 被捕获")

获取异常信息

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"异常信息：{e}")
    print(f"异常类型：{type(e).__name__}")

完整的 try-except-else-finally

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("错误：除数不能为零")
        return None
    except TypeError:
        print("错误：参数类型错误")
        return None
    else:
        # 只有在没有异常时执行
        print(f"计算成功：{a} / {b} = {result}")
        return result
    finally:
        # 无论是否有异常都会执行
        print("divide 函数执行完毕")

print("测试 10 / 2：")
divide(10, 2)

print("\n测试 10 / 0：")
divide(10, 0)

print("\n测试 '10' / 2：")
divide('10', 2)

异常对象的属性和方法

异常对象是 Python 的内置异常类的实例，具有以下常用属性：

Day 31 - raise 语句与自定义异常

Fri, 01 May 2026 10:00:00 +0800

Day 31 - raise 语句与自定义异常

raise 语句基础

raise 语句用于显式地抛出异常。在 Python 中，你可以抛出任何继承自 BaseException 的对象，但通常我们应该抛出 Exception 的子类。

# 基本语法
raise Exception("错误信息")

# 重新抛出当前捕获的异常
try:
    raise ValueError("原始错误")
except ValueError:
    print("处理异常")
    raise  # 重新抛出

# 使用 raise from 链接异常
try:
    raise ValueError("原始错误")
except ValueError as e:
    raise RuntimeError("新错误") from e

常见的内置异常

Python 提供了一系列内置异常，按层次结构组织：

BaseException ├── SystemExit ├── KeyboardInterrupt ├── GeneratorExit └── Exception ├── StopIteration ├── ArithmeticError │ ├── FloatingPointError │ ├── OverflowError │ └── ZeroDivisionError ├── LookupError │ ├── IndexError │ └── KeyError ├── OSError (IOError) │ ├── FileNotFoundError │ ├── PermissionError │ └── TimeoutError ├── TypeError ├── ValueError ├── RuntimeError └── ...

# 触发各种内置异常
print(10 / 0)  # ZeroDivisionError
print(int("abc"))  # ValueError
print([1,2][10])  # IndexError
print({}["key"])  # KeyError
open("nonexistent.txt")  # FileNotFoundError

自定义异常类

自定义异常应该继承自 Exception 或其子类。通常，自定义异常类比较简单，只需要定义构造函数和异常消息。

Day32 - 模块与导入系统详解

Fri, 01 May 2026 10:00:00 +0800

Day32 - 模块与导入系统详解

详细讲解

1. 模块基础概念

模块（Module） 是 Python 中组织代码的基本单位。一个 .py 文件就是一个模块，模块中可以包含函数、类、变量以及可执行代码。

# mymodule.py
def greet(name):
    return f"你好，{name}！"

class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b

PI = 3.14159

2. import 语句详解

2.1 基本导入

import mymodule

# 调用函数
result = mymodule.greet("张三")
print(result)  # 输出: 你好，张三！

# 使用类
calc = mymodule.Calculator()
print(calc.add(10, 5))  # 输出: 15

# 访问变量
print(mymodule.PI)  # 输出: 3.14159

2.2 from…import 语句

# 导入特定成员
from mymodule import greet, PI

# 直接使用（无需模块名前缀）
print(greet("李四"))  # 输出: 你好，李四！
print(PI)  # 输出: 3.14159

# 导入所有成员（不推荐）
from mymodule import *

2.3 as 别名使用

import mymodule as m

# 使用简短别名
print(m.greet("王五"))  # 输出: 你好，王五！

# 部分导入起别名
from mymodule import Calculator as Calc, PI as PI_VALUE

calc = Calc()
print(calc.add(100, 200))  # 输出: 300

3. sys.path 与模块搜索路径

Python 导入模块时，会按照以下顺序搜索：

Day33 - 包与命名空间详解

Fri, 01 May 2026 10:00:00 +0800

Day33 - 包与命名空间详解

详细讲解

1. 包的基本概念

包（Package） 是包含 __init__.py 文件的目录，用于组织多个模块。包可以嵌套，形成层次结构。

mypackage/ ├── __init__.py # 包初始化文件（必需） ├── module1.py ├── module2.py └── subpackage/ ├── __init__.py └── module3.py

2. `init.py` 文件详解

2.1 作用

__init__.py 是 Python 包的标识文件，有以下作用：

标识该目录是一个包
在包被导入时执行初始化代码
控制包的导出内容

# mypackage/__init__.py

# 1. 初始化代码（包导入时执行）
print("mypackage 已被导入")

# 2. 定义包的版本
__version__ = "1.0.0"

# 3. 简化包的导入接口
from .module1 import Class1
from .module2 import function1

# 4. 定义 __all__ 控制 from package import *
__all__ = ['Class1', 'function1', 'subpackage']

2.2 包的多级初始化

# mypackage/subpackage/__init__.py
"""子包初始化"""

print("mypackage.subpackage 已加载")

# 从模块导入到包级别
from .module3 import ServiceClass

__all__ = ['ServiceClass']

2.3 `init.py` 常见用法

# 方式1：全部导入（不推荐）
import mypackage.module1
import mypackage.module2

# 方式2：使用 __init__.py 暴露接口
# 在 __init__.py 中：
# from .module1 import useful_function
# 使用时：
from mypackage import useful_function

# 方式3：导入所有公开接口
# 在 __init__.py 中设置 __all__

3. `name` 属性详解

__name__ 是 Python 的内置变量，其值取决于代码的执行方式。

Day34 - 文件读写与JSON处理

Fri, 01 May 2026 10:00:00 +0800

Day34 - 文件读写与JSON处理

详细讲解

1. 文件打开与关闭

1.1 基本语法

# 传统方式 - 需要手动关闭
file = open('example.txt', 'r', encoding='utf-8')
content = file.read()
file.close()  # 忘记关闭会导致资源泄漏

# 推荐方式 - 使用 with 语句（自动关闭）
with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    # 文件在 with 块结束后自动关闭

1.2 文件打开模式

模式	说明	文件指针位置	如果文件存在	如果文件不存在
`'r'`	读取（默认）	开头	读取	报错
`'w'`	写入	开头	覆盖	创建
`'x'`	创建并写入	开头	报错	创建
`'a'`	追加	末尾	追加	创建
`'r+'`	读取+写入	开头	读取	报错
`'w+'`	读取+写入	开头	覆盖	创建
`'a+'`	读取+追加	末尾	追加	创建

1.3 编码问题

# 推荐使用 UTF-8 编码
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()

# 处理不同编码
with open('file.txt', 'r', encoding='gbk') as f:
    content = f.read()

# 遇到编码错误时的处理
with open('file.txt', 'r', encoding='utf-8', errors='ignore') as f:
    content = f.read()

with open('file.txt', 'r', encoding='utf-8', errors='replace') as f:
    content = f.read()  # 替换为 ?

2. 文件读取操作

2.1 读取全部内容

# 读取整个文件
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()  # 返回字符串

# 读取前 N 个字符
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read(100)  # 读取前100个字符

2.2 按行读取

# 读取单行（包含换行符）
with open('example.txt', 'r', encoding='utf-8') as f:
    line1 = f.readline()
    line2 = f.readline()

# 读取所有行（返回列表）
with open('example.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()

# 直接迭代文件对象（推荐，内存高效）
with open('example.txt', 'r', encoding='utf-8') as f:
    for line in f:
        print(line.strip())  # strip() 去除换行符

2.3 逐字符读取

with open('example.txt', 'r', encoding='utf-8') as f:
    while True:
        char = f.read(1)  # 读取单个字符
        if not char:
            break
        print(char, end='')

3. 文件写入操作

3.1 写入字符串

# 写入单行（不自动添加换行符）
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write('第一行')
    f.write('第二行')  # 不会换行

# 写入多行
with open('output.txt', 'w', encoding='utf-8') as f:
    lines = ['第一行\n', '第二行\n', '第三行\n']
    f.writelines(lines)

# 使用 print 函数写入（自动添加换行符）
with open('output.txt', 'w', encoding='utf-8') as f:
    print('第一行', file=f)
    print('第二行', file=f)

3.2 追加模式

# 在文件末尾追加
with open('log.txt', 'a', encoding='utf-8') as f:
    f.write('新的日志条目\n')

3.3 二进制文件

# 写入二进制数据
with open('data.bin', 'wb') as f:
    f.write(b'\x00\x01\x02\x03')

# 读取二进制数据
with open('data.bin', 'rb') as f:
    data = f.read()
    print(data)  # b'\x00\x01\x02\x03'

4. 文件指针操作

with open('example.txt', 'r', encoding='utf-8') as f:
    # 获取文件指针位置
    print(f.tell())  # 0
    
    # 读取一些内容
    content = f.read(10)
    print(f.tell())  # 10
    
    # 移动文件指针
    f.seek(0)        # 移到开头
    print(f.tell())  # 0
    
    f.seek(5)        # 移到第5个字节
    print(f.tell())  # 5
    
    # 从末尾往前移动（需要使用二进制模式）
    # f.seek(-10, 2)  # 从文件末尾往前10字节

5. JSON 数据处理

5.1 JSON 模块概述

JSON（JavaScript Object Notation）是一种轻量级数据交换格式。

Day35 - 文件处理综合 (CSV/shutil/os/pathlib)

Fri, 01 May 2026 10:00:00 +0800

Day35 - 文件处理综合 (CSV/shutil/os/pathlib)

详细讲解

1. CSV 文件处理

1.1 CSV 模块基础

import csv

# 准备数据
data = [
    ['姓名', '年龄', '城市'],
    ['张三', '25', '北京'],
    ['李四', '30', '上海'],
    ['王五', '28', '广州']
]

# 写入 CSV 文件
with open('output.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerows(data)  # 写入多行

# 读取 CSV 文件
with open('output.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

注意：newline='' 在写入 CSV 时必须使用，否则在 Windows 上可能导致行距加倍。

1.2 字典方式操作 CSV

import csv

# 写入字典格式
fieldnames = ['name', 'age', 'city']
data = [
    {'name': '张三', 'age': 25, 'city': '北京'},
    {'name': '李四', 'age': 30, 'city': '上海'}
]

with open('dict_data.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()  # 写入表头
    writer.writerows(data)

# 读取字典格式
with open('dict_data.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']} - {row['age']} - {row['city']}")

1.3 CSV 高级选项

import csv

# 自定义分隔符
with open('tab_data.tsv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f, delimiter='\t')
    writer.writerows(data)

# 引用处理
with open('quoted.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f, quoting=csv.QUOTE_ALL)  # 所有字段加引号
    writer.writerows(data)

# quoting 选项：
# QUOTE_ALL      - 所有字段加引号
# QUOTE_MINIMAL  - 特殊字符字段加引号（默认）
# QUOTE_NONNUMERIC - 非数字字段加引号
# QUOTE_NONE     - 不加引号

1.4 处理大 CSV 文件

import csv

# 使用生成器处理大文件
def read_csv_chunked(filepath, chunk_size=1000):
    """分块读取大 CSV 文件"""
    with open(filepath, 'r', encoding='utf-8') as f:
        reader = csv.reader(f)
        header = next(reader)  # 读取表头
        
        chunk = []
        for row in reader:
            chunk.append(row)
            if len(chunk) >= chunk_size:
                yield header, chunk
                chunk = []
        
        if chunk:  # 处理最后一块
            yield header, chunk

# 使用
for header, chunk in read_csv_chunked('large_file.csv'):
    print(f"处理 {len(chunk)} 条记录")
    # 处理每块数据

2. shutil 模块 - 高级文件操作

2.1 复制操作

import shutil

# 复制文件
shutil.copy('source.txt', 'dest.txt')      # 复制文件内容
shutil.copy2('source.txt', 'dest.txt')    # 复制文件并保留元数据

# 复制目录
shutil.copytree('source_dir', 'dest_dir')  # 递归复制整个目录

# 复制到文件夹
shutil.copy('file.txt', 'target_dir/')     # 目标可以是目录

2.2 移动和重命名

import shutil

# 移动文件
shutil.move('source.txt', 'dest.txt')

# 移动目录
shutil.move('source_dir', 'dest_dir')

# 重命名（同一目录下移动即重命名）
shutil.move('old_name.txt', 'new_name.txt')

2.3 删除操作

import shutil

# 删除目录（必须是空目录）
import os
os.rmdir('empty_dir')

# 删除目录树（递归删除）
shutil.rmtree('dir_to_remove')

# 安全删除（移动到回收站，可安装 send2trash 库）
# pip install send2trash
try:
    import send2trash
    send2trash.send2trash('file_to_delete.txt')
except ImportError:
    print("请安装: pip install send2trash")

2.4 归档和压缩

import shutil

# 创建归档（zip, tar, gztar, bztar, xztar）
shutil.make_archive('backup', 'zip', 'directory_to_backup')

# 解压归档
shutil.unpack_archive('backup.zip', 'extract_here')

# 列出支持的格式
print(shutil.get_archive_formats())
print(shutil.get_unpack_formats())

2.5 其他有用功能

import shutil

# 获取磁盘使用情况
total, used, free = shutil.disk_usage('/')
print(f"总容量: {total // (2**30)} GB")
print(f"已使用: {used // (2**30)} GB")
print(f"剩余: {free // (2**30)} GB")

# 复制权限（仅 Unix）
# shutil.copystat(src, dst)

# 获取临时目录
print(shutil.gettempdir())

# 命令行工具包装
# shutil.which('python')  # 查找命令路径

3. os 模块 - 系统交互

3.1 路径操作

import os

# 获取当前工作目录
print(os.getcwd())

# 改变当前目录
os.chdir('/path/to/directory')

# 返回绝对路径
os.path.abspath('relative/path')

# 判断路径类型
os.path.isfile('file.txt')     # 是否为文件
os.path.isdir('directory')     # 是否为目录
os.path.islink('link')         # 是否为符号链接
os.path.exists('path')         # 路径是否存在

# 路径连接
path = os.path.join('dir', 'subdir', 'file.txt')
# 输出: dir/subdir/file.txt (Unix) 或 dir\subdir\file.txt (Windows)

# 分割路径
dirname, basename = os.path.split('/path/to/file.txt')
# dirname: /path/to, basename: file.txt

# 分割扩展名
name, ext = os.path.splitext('file.txt')
# name: file, ext: .txt

3.2 目录操作

import os

# 创建目录
os.mkdir('new_dir')           # 创建单级目录（父目录必须存在）
os.makedirs('path/to/new/dir')  # 递归创建目录

# 列出目录内容
os.listdir('.')               # 返回列表

# 遍历目录树
for dirpath, dirnames, filenames in os.walk('.'):
    print(f"目录: {dirpath}")
    print(f"子目录: {dirnames}")
    print(f"文件: {filenames}")

# 删除
os.remove('file.txt')         # 删除文件
os.rmdir('empty_dir')         # 删除空目录

3.3 文件信息

import os
import datetime

# 获取文件大小（字节）
size = os.path.getsize('file.txt')

# 获取文件修改时间
mtime = os.path.getmtime('file.txt')
print(datetime.datetime.fromtimestamp(mtime))

# 获取创建时间
ctime = os.path.getctime('file.txt')

# 获取文件详细信息
stat_info = os.stat('file.txt')
print(f"大小: {stat_info.st_size} 字节")
print(f"修改: {datetime.datetime.fromtimestamp(stat_info.st_mtime)}")

3.4 环境变量

import os

# 获取环境变量
home = os.environ.get('HOME')           # Unix
# home = os.environ.get('USERPROFILE') # Windows
path = os.environ.get('PATH', '')

# 设置环境变量
os.environ['MY_VAR'] = 'value'

# 获取所有环境变量
for key, value in os.environ.items():
    print(f"{key}={value}")

4. pathlib 模块 - 面向对象路径操作

Python 3.4+ 推荐使用 pathlib，比 os.path 更直观。

Day36 - 浅拷贝与深拷贝详解

Fri, 01 May 2026 10:00:00 +0800

Day36 - 浅拷贝与深拷贝详解

详细讲解

1. 对象赋值与引用

在 Python 中，一切皆对象。赋值语句（如 a = b）并不复制对象，而是创建了对同一对象的引用。

# 赋值 - 同一个对象的不同引用
a = [1, 2, 3]
b = a

print(f"a: {a}")   # [1, 2, 3]
print(f"b: {b}")   # [1, 2, 3]
print(f"a is b: {a is b}")  # True - 同一对象

# 修改 a，b 也会变化
a.append(4)
print(f"修改后 a: {a}")   # [1, 2, 3, 4]
print(f"修改后 b: {b}")   # [1, 2, 3, 4] - b 也变了！

# id() 显示对象身份
print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")  # 相同

2. 浅拷贝（Shallow Copy）

浅拷贝创建一个新对象，但只复制原对象中的第一层引用。对于嵌套对象，只复制其引用，不复制嵌套对象本身。

Day37 - 迭代器与生成器详解

Fri, 01 May 2026 10:00:00 +0800

Day37 - 迭代器与生成器详解

详细讲解

1. 迭代器基础

1.1 可迭代对象与迭代器

可迭代对象（Iterable）：可以使用 for 循环遍历的对象，如 list, dict, str, file 等。

迭代器（Iterator）：实现了 __iter__() 和 __next__() 方法的对象。

# 可迭代对象
numbers = [1, 2, 3]  # list 是可迭代对象

# 获取迭代器
iterator = iter(numbers)
print(f"迭代器: {iterator}")

# 手动迭代
print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
print(next(iterator))  # StopIteration 异常

1.2 迭代器协议

# 迭代器必须实现的两个方法
class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0
    
    def __iter__(self):
        """返回迭代器本身"""
        return self
    
    def __next__(self):
        """返回下一个元素"""
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

# 使用
it = MyIterator([10, 20, 30])
for item in it:
    print(item)

1.3 iter() 和 next() 内置函数

# iter() 可以接受两个参数：可迭代对象 + 哨兵值
# 这样会在每次 next() 时调用可迭代对象，直到返回值等于哨兵值

# 示例：读取行直到空行
with open('lines.txt', 'r') as f:
    for line in iter(f.readline, ''):
        print(line.strip())

# next() 可以指定默认值
numbers = [1, 2, 3]
it = iter(numbers)
print(next(it, '默认值'))  # 1
print(next(it, '默认值'))  # 2
print(next(it, '默认值'))  # 3
print(next(it, '默认值'))  # 默认值（不会抛出 StopIteration）

2. 生成器基础

生成器是一种特殊的迭代器，使用 yield 关键字来产生值，而不是 return。

Day38 装饰器详解

Fri, 01 May 2026 10:00:00 +0800

Day38 - 装饰器详解 (@decorator/wraps/闭包)

详细讲解

1. 闭包基础

1.1 什么是闭包

闭包是指一个函数记住其创建时所处的环境（外部作用域的变量）的机制。

def outer():
    x = 10  # 外部变量
    
    def inner():
        print(x)  # 引用外部变量
    
    return inner

# 创建闭包
closure = outer()
closure()  # 输出 10

# 验证闭包
print(f"closure.__closure__: {closure.__closure__}")  # 闭包变量
print(f"closure.__code__.co_freevars: {closure.__code__.co_freevars}")  # 自由变量名

1.2 闭包的经典应用

def make_multiplier(factor):
    """创建乘数函数（闭包）"""
    def multiply(x):
        return x * factor
    return multiply

# 创建两个不同的乘数
times_2 = make_multiplier(2)
times_3 = make_multiplier(3)
times_5 = make_multiplier(5)

print(times_2(10))  # 20
print(times_3(10))  # 30
print(times_5(10))  # 50

# 闭包会记住创建时的 factor 值
print(f"times_2 的闭包: {times_2.__closure__[0].cell_contents}")  # 2

1.3 闭包的常见陷阱

# 陷阱：循环中的闭包
def create_funcs():
    funcs = []
    for i in range(3):
        # 错误！所有函数都会引用同一个 i
        def func():
            return i
        funcs.append(func)
    return funcs

funcs = create_funcs()
print([f() for f in funcs])  # [2, 2, 2] - 不是 [0, 1, 2]！

# 正确做法：使用默认参数捕获当前值
def create_funcs_fixed():
    funcs = []
    for i in range(3):
        def func(i=i):  # 默认参数在定义时绑定
            return i
        funcs.append(func)
    return funcs

funcs = create_funcs_fixed()
print([f() for f in funcs])  # [0, 1, 2]

2. 装饰器基础

装饰器是一个返回函数的高阶函数，用于在不修改原函数的情况下扩展功能。

Day39 - 正则表达式基础

Fri, 01 May 2026 10:00:00 +0800

Day39 - 正则表达式基础

详细讲解

1. 正则表达式简介

正则表达式是一种用于匹配字符串的模式表达式，在文本处理、数据提取、验证等场景中广泛应用。

import re

# 最简单的匹配
pattern = r'hello'
text = 'hello world'

if re.search(pattern, text):
    print("找到匹配！")

# 常用场景
# 1. 验证邮箱格式
# 2. 提取网页中的链接
# 3. 处理日志文件
# 4. 数据清洗和转换

2. re 模块主要函数

2.1 `re.match()` - 从开头匹配

import re

# match() 从字符串开头匹配
result = re.match(r'hello', 'hello world')
print(result)  # <re.Match object>
print(result.group())  # 'hello'
print(result.span())   # (0, 5)

# 如果开头不匹配，返回 None
result = re.match(r'world', 'hello world')
print(result)  # None

# 使用分组
result = re.match(r'(\w+), (\w+)', 'hello, world')
if result:
    print(result.group(1))  # 'hello'
    print(result.group(2))  # 'world'
    print(result.groups())  # ('hello', 'world')

2.2 `re.search()` - 搜索匹配

# search() 在字符串任意位置查找第一个匹配
result = re.search(r'world', 'hello world')
print(result.group())  # 'world'
print(result.span())   # (6, 11)

# 搜索邮箱
text = "联系邮箱: test@example.com 或 admin@test.org"
result = re.search(r'\w+@\w+\.\w+', text)
print(result.group())  # 'test@example.com'

# 找不到返回 None
result = re.search(r'notfound', 'hello')
print(result)  # None

2.3 `re.findall()` - 查找所有匹配

# findall() 返回所有匹配的列表
text = "我的邮箱是 test@example.com，副邮箱是 backup@example.org"

# 查找所有邮箱
emails = re.findall(r'\w+@\w+\.\w+', text)
print(emails)  # ['test@example.com', 'backup@example.org']

# 查找所有数字
numbers = re.findall(r'\d+', '我有 3 个苹果，5 个橙子，共 8 个水果')
print(numbers)  # ['3', '5', '8']

# 使用分组 - 返回分组内容的列表
text = "红色: #FF0000, 绿色: #00FF00, 蓝色: #0000FF"
colors = re.findall(r'#([0-9A-Fa-f]{6})', text)
print(colors)  # ['FF0000', '00FF00', '0000FF']

2.4 `re.finditer()` - 迭代器版本

# finditer() 返回迭代器，比 findall() 内存效率高
text = "邮箱: a@test.com, b@test.com, c@test.com"

for match in re.finditer(r'\w+@\w+\.\w+', text):
    print(f"位置 {match.span()}: {match.group()}")

3. 字符类（Character Classes）

# [] - 匹配方括号内的任意一个字符

# 匹配元音字母
vowels = re.findall(r'[aeiouAEIOU]', 'Hello World')
print(vowels)  # ['e', 'o', 'o']

# 匹配数字或字母
alphanum = re.findall(r'[a-zA-Z0-9]', 'Hello123!')
print(alphanum)  # ['H', 'e', 'l', 'l', 'o', '1', '2', '3']

# [^] - 否定，匹配不在方括号内的字符
non_vowels = re.findall(r'[^aeiouAEIOU]', 'Hello')
print(non_vowels)  # ['H', 'l', 'l']

# 常用简写
# \d  = [0-9]        数字
# \D  = [^0-9]       非数字
# \w  = [a-zA-Z0-9_] 单词字符
# \W  = [^a-zA-Z0-9_] 非单词字符
# \s  = [ \t\n\r\f\v] 空白字符
# \S  = [^ \t\n\r\f\v] 非空白字符
# .   = 任意字符（除换行符）

# 示例
text = "用户: ZhangSan, 年龄: 25, 电话: 138-0000-8888"

ages = re.findall(r'\d+', text)
print(ages)  # ['25', '138', '0000', '8888']

words = re.findall(r'\w+', text)
print(words)  # ['用户', 'ZhangSan', '年龄', '25', '电话', '138', '0000', '8888']

4. 量词（Quantifiers）

# *    - 0 次或多次
# +    - 1 次或多次
# ?    - 0 次或 1 次
# {n}  - 恰好 n 次
# {n,} - 至少 n 次
# {n,m} - n 到 m 次

# * 示例：匹配任意数量字符
pattern = r'ab*c'  # ac, abc, abbc, abbbc, ...
print(re.findall(r'ab*c', 'ac abc abbc abbbc'))  # ['ac', 'abc', 'abbc', 'abbbc']

# + 示例：至少一个
pattern = r'ab+c'  # abc, abbc, abbbc, ... (不包括 ac)
print(re.findall(r'ab+c', 'ac abc abbc'))  # ['abc', 'abbc']

# ? 示例：可选
pattern = r'colou?r'  # color, colour
print(re.findall(r'colou?r', 'color colour'))  # ['color', 'colour']

# {n} 示例：精确次数
pattern = r'\d{4}'  # 4 位数字
print(re.findall(r'\d{4}', '2024年 12345月'))  # ['2024', '1234']

# {n,m} 示例：范围次数
pattern = r'\d{2,4}'  # 2-4 位数字
print(re.findall(r'\d{2,4}', '1 12 123 1234 12345'))
# ['12', '123', '1234', '1234', '5'] - 注意贪婪匹配

# 贪婪 vs 非贪婪（最小匹配）
text = '<div>content</div>'

# 贪婪：尽可能多匹配
print(re.findall(r'<div>.*</div>', text))  # ['<div>content</div>']

# 非贪婪：尽可能少匹配
print(re.findall(r'<div>.*?</div>', text))  # ['<div>content</div>']

# 非贪婪添加 ?
text = '<div>div1</div><div>div2</div>'
print(re.findall(r'<div>.*?</div>', text))  # ['<div>div1</div>', '<div>div2</div>']

5. 边界匹配

# ^  - 字符串开头
# $  - 字符串结尾
# \b - 单词边界
# \B - 非单词边界

# 匹配以数字开头的行
text = "123abc\nhello\n456xyz"
lines = re.findall(r'^\d+', text, re.MULTILINE)
print(lines)  # ['123', '456']

# 匹配以.com结尾的域名
domains = re.findall(r'\w+\.com$', 'test.com\nexample.org\nmail.com')
print(domains)  # ['test.com', 'mail.com']

# \b 边界示例
text = "a cat a the in cat"

# 匹配完整的单词 'cat'
cats = re.findall(r'\bcat\b', text)
print(cats)  # ['cat', 'cat'] - 两个独立的 cat

# 不使用边界
cats_all = re.findall(r'cat', text)
print(cats_all)  # ['cat', 'cat', 'cat'] - 包括 a[cat] 中的 cat

# \B 非边界示例
text = "abc abc"
print(re.findall(r'ab\B', text))  # ['ab'] - abc 中的 ab
print(re.findall(r'\Bab\B', text))  # [] - 开头和结尾的 ab 都不匹配

6. 分组（Groups）

# () - 创建分组

# 提取邮箱用户名和域名
text = "邮箱: john@example.com 和 jane@test.org"
matches = re.findall(r'(\w+)@(\w+)\.(\w+)', text)
print(matches)  # [('john', 'example', 'com'), ('jane', 'test', 'org')]

# 嵌套分组
text = "2024-05-01"
match = re.search(r'(\d{4})-(\d{2})-(\d{2})', text)
if match:
    print(match.groups())  # ('2024', '05', '01')
    print(match.group(1))  # '2024' 年
    print(match.group(2))  # '05' 月
    print(match.group(3))  # '01' 日

# 命名分组
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
match = re.search(pattern, '2024-05-01')
if match:
    print(match.group('year'))   # '2024'
    print(match.group('month'))  # '05'
    print(match.group('day'))     # '01'
    print(match.groupdict())     # {'year': '2024', 'month': '05', 'day': '01'}

# 非捕获分组 (?:)
text = "abc123def"
# 捕获分组会作为 groups 返回
match = re.search(r'(?:abc)(\d+)', text)
print(match.groups())  # ('123',)

# 分组在替换中的应用
text = "2024-05-01"
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', text)
print(result)  # 05/01/2024

7. re.compile() 编译正则

# 编译正则表达式，提高匹配效率
pattern = re.compile(r'\d{4}-\d{2}-\d{2}')

# 使用编译后的 pattern
text = "今天是 2024-05-01，明天是 2024-05-02"

print(pattern.findall(text))  # ['2024-05-01', '2024-05-02']
print(pattern.search(text).group())  # '2024-05-01'

# 编译时指定 flags
pattern = re.compile(r'hello', re.IGNORECASE)
print(pattern.findall('Hello HELLO hello'))  # ['Hello', 'HELLO', 'hello']

8. re 模块的 flags

# re.IGNORECASE / re.I - 忽略大小写
print(re.findall(r'hello', 'Hello HELLO', re.I))

# re.MULTILINE / re.M - 多行模式
text = "line1\nline2\nline3"
print(re.findall(r'^line\d', text, re.M))  # ['line1', 'line2', 'line3']

# re.DOTALL / re.S - 点号匹配所有字符（包括换行）
text = "hello\nworld"
print(re.findall(r'hello.*world', text))    # [] - 默认不匹配换行
print(re.findall(r'hello.*world', text, re.S))  # ['hello\nworld']

# re.VERBOSE / re.X - 详细模式（忽略空白和注释）
pattern = re.compile(r'''
    \d{3}  # 区号
    -      # 分隔符
    \d{4}  # 号码
''', re.VERBOSE)

# 可以组合使用
pattern = re.compile(r'hello', re.I | re.M)

背诵版

核心速查

┌─────────────────────────────────────────────────────────────┐ │ re 模块主要函数 │ ├─────────────────────────────────────────────────────────────┤ │ re.match() │ 从字符串开头匹配 │ │ re.search() │ 搜索第一个匹配 │ │ re.findall() │ 返回所有匹配的列表 │ │ re.finditer() │ 返回匹配的迭代器 │ │ re.sub() │ 替换匹配项 │ │ re.split() │ 按匹配分割 │ │ re.compile() │ 编译正则表达式 │ └─────────────────────────────────────────────────────────────┘

字符类速查

模式	说明	等价
`\d`	数字	`[0-9]`
`\D`	非数字	`[^0-9]`
`\w`	单词字符	`[a-zA-Z0-9_]`
`\W`	非单词字符	`[^a-zA-Z0-9_]`
`\s`	空白字符	`[ \t\n\r\f\v]`
`\S`	非空白字符	`[^ \t\n\r\f\v]`
`.`	任意字符	-

量词速查

量词	说明
`*`	0 次或多次
`+`	1 次或多次
`?`	0 次或 1 次
`{n}`	恰好 n 次
`{n,}`	至少 n 次
`{n,m}`	n 到 m 次

考前记忆

面试重点

match vs search

Day40 - 正则表达式高级与综合项目

Fri, 01 May 2026 10:00:00 +0800

Day40 - 正则表达式高级与综合项目

详细讲解

1. 分组高级用法

1.1 捕获分组与非捕获分组

import re

# 捕获分组 - 会保存到 groups() 中
text = "2024-05-01"
match = re.search(r'(\d{4})-(\d{2})-(\d{2})', text)
print(match.groups())  # ('2024', '05', '01')

# 非捕获分组 (?:...) - 不保存到 groups()
match = re.search(r'(\d{4})-(?:\d{2})-(\d{2})', text)
print(match.groups())  # ('2024', '01')

# 使用场景：提高效率（不需要的分组不用保存）
# 当分组多时，非捕获分组性能更好

1.2 命名分组

# (?P<name>pattern) - 命名分组
text = "John Doe <john@example.com>"

match = re.search(r'(?P<name>\w+) (?P<surname>\w+) <(?P<email>\w+@\w+\.\w+)>', text)
if match:
    print(match.groupdict())
    # {'name': 'John', 'surname': 'Doe', 'email': 'john@example.com'}

    # 按名称访问
    print(match.group('name'))   # 'John'
    print(match.group('email'))  # 'john@example.com'

# 命名分组在替换中也很方便
text = "2024-05-01"
result = re.sub(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
                 r'\g<month>/\g<day>/\g<year>', text)
print(result)  # 05/01/2024

1.3 反向引用

# \1, \2 等 - 引用前面的分组

# 匹配重复的单词
text = "the the cat cat dog"
pattern = r'(\w+) \1'  # \1 引用第一个分组
print(re.findall(pattern, text))  # ['the', 'cat']

# 匹配 HTML 标签
text = "<div>content</div> <span>text</span>"
pattern = r'<(\w+)>.*?</\1>'  # \1 引用前面的标签名
print(re.findall(pattern, text))  # ['div', 'span']

# 匹配引号
pattern = r'(["\'])(.*?)\1'  # \1 引用开头的引号
print(re.findall(pattern, "'hello' and \"world\""))  # ["'", 'hello', '"', 'world']

1.4 条件匹配

# (?(id)yes_pattern|no_pattern) - 如果 id 存在则匹配 yes_pattern，否则匹配 no_pattern

# 匹配带引号或不带引号的单词
text = '"hello" world "python"'

# 如果有引号，则匹配引号内的内容；否则匹配单词
pattern = r'(["\'])?(?(1)(.*?)\1|(\w+))'
matches = re.findall(pattern, text)
print(matches)  # [('"', 'hello', ''), ('', '', 'world'), ('"', 'python', '')]

2. `re.sub()` 高级用法

2.1 基本替换

import re

# 基本替换
text = "Hello World"
result = re.sub(r'World', 'Python', text)
print(result)  # Hello Python

# 使用分组引用
text = "2024-05-01"
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', text)
print(result)  # 05/01/2024

# 命名分组引用
result = re.sub(r'(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})',
                 r'\g<d>-\g<m>-\g<y>', text)
print(result)  # 01-05-2024

2.2 替换函数

# 传入函数作为替换参数

def expand_date(match):
    """日期转换函数"""
    year, month, day = match.groups()
    
    months = {
        '01': 'January', '02': 'February', '03': 'March',
        '04': 'April',   '05': 'May',      '06': 'June',
        '07': 'July',    '08': 'August',   '09': 'September',
        '10': 'October', '11': 'November', '12': 'December'
    }
    
    return f"{months[month]} {day}, {year}"

text = "Date: 2024-05-01"
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', expand_date, text)
print(result)  # Date: May 01, 2024

# 数字格式化
def format_number(match):
    num = int(match.group())
    return f"{num:,}"  # 添加千分位

text = "金额: 1234567"
result = re.sub(r'\d+', format_number, text)
print(result)  # 金额: 1,234,567

2.3 `re.subn()` - 返回替换次数

# subn() 返回 (新字符串, 替换次数)
text = "aaa bbb aaa ccc aaa"
result, count = re.subn(r'aaa', 'XXX', text)
print(f"替换后: {result}, 替换次数: {count}")
# 替换后: XXX bbb XXX ccc XXX, 替换次数: 3

3. `re.split()` 高级用法

import re

# 基本分割
text = "apple,banana,cherry"
parts = re.split(r',', text)
print(parts)  # ['apple', 'banana', 'cherry']

# 使用分组分割 - 分组会保留在结果中
text = "apple1banana2cherry"
parts = re.split(r'(\d)', text)
print(parts)  # ['apple', '1', 'banana', '2', 'cherry']

# 限制分割次数
text = "a:b:c:d:e"
parts = re.split(r':', text, maxsplit=2)
print(parts)  # ['a', 'b', 'c:d:e']

# 按多种分隔符分割
text = "apple,bana;na|cherry"
parts = re.split(r'[,;|]', text)
print(parts)  # ['apple', 'bana', 'na', 'cherry']

4. 零宽断言（Lookaround）

4.1 正向先行断言 `(?=...)`

# 匹配后面跟着特定内容的前缀
text = "Windows10 Windows11 Windows12"

# 匹配前面是 Windows，后面是数字的 Windows
result = re.findall(r'Windows(?=\d)', text)
print(result)  # ['Windows', 'Windows', 'Windows']

# 更实用的例子：获取价格（数字前的货币符号）
text = "价格: $100, €50, ¥200"
result = re.findall(r'[$€¥]\d+', text)
print(result)  # ['$100', '€50', '¥200']

# 匹配后面是 .com 的域名部分
text = "example.com test.org hello.com"
result = re.findall(r'\w+(?=\.com)', text)
print(result)  # ['example', 'hello']

4.2 负向先行断言 `(?!...)`

# 匹配后面不跟着特定内容的前缀
text = "Windows10 WindowsMac Windows11"

# 匹配后面不是数字的 Windows
result = re.findall(r'Windows(?!\d)', text)
print(result)  # ['WindowsMac']

# 排除特定结尾
text = ["file.txt", "file.log", "file.txt.bak", "data.csv"]
txt_files = [f for f in text if re.match(r'.*\.txt(?!\.)', f)]
print(txt_files)  # ['file.txt']

4.3 正向后行断言 `(?<=...)`

# 匹配前面跟着特定内容的后缀
text = "价格: 100元, 200元, 300美元"

# 匹配"元"前面的数字
result = re.findall(r'(?<=[元])\d+', text)
print(result)  # ['100', '200']

# 提取 HTML 中的文本内容
html = "<div>Hello</div><span>World</span>"
result = re.findall(r'(?<=<[a-z]+>)[^<]+', html)
print(result)  # ['Hello', 'World']

# 提取域名后的路径
text = "https://example.com/path1 http://test.org/path2"
result = re.findall(r'(?<=//[^/]+/).+', text)
print(result)  # ['/path1', '/path2']

4.4 负向后行断言 `(?<!...)`

# 匹配前面不跟着特定内容的后缀
text = "100元 200美元 300元 400日元"

# 匹配前面不是"元"的数字
result = re.findall(r'(?<![元])\d+', text)
print(result)  # ['200', '400']

# 更实用的例子：提取不是来自某个前缀的内容
text = "abc123 abc456 xyz789"
result = re.findall(r'(?<!abc)\d+', text)
print(result)  # ['3456', '789'] - abc123 中的 1 被排除

5. 综合项目实践

5.1 日志分析器

import re
from collections import Counter
from datetime import datetime

class LogAnalyzer:
    """日志分析器"""
    
    # 日志格式正则（示例：Apache 访问日志）
    LOG_PATTERN = re.compile(
        r'(?P<ip>[\d.]+) '  # IP 地址
        r'- - '
        r'\[(?P<timestamp>[^\]]+)\] '  # 时间戳
        r'"(?P<method>\w+) (?P<path>[^\s]+) [^"]+" '  # 请求方法和路径
        r'(?P<status>\d{3}) '  # 状态码
        r'(?P<size>\d+)'
    )
    
    # 错误日志正则
    ERROR_PATTERN = re.compile(
        r'\[(?P<timestamp>[^\]]+)\] '
        r'\[(?P<level>\w+)\] '
        r'(?P<message>.+)'
    )
    
    @classmethod
    def parse_access_log(cls, log_text):
        """解析访问日志"""
        results = []
        for line in log_text.strip().split('\n'):
            match = cls.LOG_PATTERN.search(line)
            if match:
                results.append(match.groupdict())
        return results
    
    @classmethod
    def analyze_traffic(cls, log_text):
        """流量分析"""
        entries = cls.parse_access_log(log_text)
        
        # 统计各状态码数量
        status_counts = Counter(e['status'] for e in entries)
        
        # 统计各路径访问量
        path_counts = Counter(e['path'] for e in entries)
        
        # 统计各 IP 访问量
        ip_counts = Counter(e['ip'] for e in entries)
        
        # 计算总流量
        total_bytes = sum(int(e['size']) for e in entries)
        
        return {
            'total_requests': len(entries),
            'status_codes': dict(status_counts),
            'top_paths': path_counts.most_common(10),
            'top_ips': ip_counts.most_common(10),
            'total_bytes': total_bytes
        }
    
    @classmethod
    def extract_errors(cls, log_text):
        """提取错误信息"""
        errors = []
        for line in log_text.strip().split('\n'):
            match = cls.ERROR_PATTERN.search(line)
            if match:
                errors.append(match.groupdict())
        return errors

# 使用示例
sample_log = '''
127.0.0.1 - - [01/May/2024:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234
127.0.0.1 - - [01/May/2024:10:00:01 +0000] "GET /style.css HTTP/1.1" 200 5678
127.0.0.2 - - [01/May/2024:10:00:02 +0000] "GET /api/users HTTP/1.1" 404 0
192.168.1.1 - - [01/May/2024:10:00:03 +0000] "POST /login HTTP/1.1" 200 89
192.168.1.1 - - [01/May/2024:10:00:04 +0000] "POST /login HTTP/1.1" 401 23
'''

analyzer = LogAnalyzer()
result = analyzer.analyze_traffic(sample_log)

print(f"总请求数: {result['total_requests']}")
print(f"状态码统计: {result['status_codes']}")
print(f"Top 路径: {result['top_paths']}")
print(f"Top IPs: {result['top_ips']}")

5.2 文本数据清洗工具

import re

class TextCleaner:
    """文本数据清洗工具"""
    
    @staticmethod
    def clean_html(text):
        """移除 HTML 标签"""
        # 移除 script 和 style 内容
        text = re.sub(r'<script[^>]*>.*?</script>', '', text, flags=re.DOTALL | re.IGNORECASE)
        text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL | re.IGNORECASE)
        # 移除所有 HTML 标签
        text = re.sub(r'<[^>]+>', '', text)
        # 解码 HTML 实体
        text = TextCleaner._decode_html_entities(text)
        return text.strip()
    
    @staticmethod
    def _decode_html_entities(text):
        """解码 HTML 实体"""
        entities = {
            '&nbsp;': ' ', '&amp;': '&', '&lt;': '<', '&gt;': '>',
            '&quot;': '"', '&#39;': "'", '&apos;': "'"
        }
        for entity, char in entities.items():
            text = text.replace(entity, char)
        # 处理数字形式的实体
        text = re.sub(r'&#(\d+);', lambda m: chr(int(m.group(1))), text)
        return text
    
    @staticmethod
    def normalize_whitespace(text):
        """规范化空白字符"""
        # 将所有连续空白替换为单个空格
        text = re.sub(r'\s+', ' ', text)
        # 移除首尾空白
        return text.strip()
    
    @staticmethod
    def remove_special_chars(text, keep_pattern=''):
        """移除特殊字符"""
        if keep_pattern:
            pattern = f'[^a-zA-Z0-9{re.escape(keep_pattern)}]'
        else:
            pattern = r'[^a-zA-Z0-9\u4e00-\u9fff]'  # 保留中文
        return re.sub(pattern, '', text)
    
    @staticmethod
    def extract_phones(text):
        """提取电话号码"""
        patterns = [
            r'1[3-9]\d{9}',           # 手机号
            r'\d{3,4}-\d{7,8}',       # 固话
            r'\+\d{1,3}-\d{3,4}-\d{7,8}'  # 国际电话
        ]
        phones = []
        for pattern in patterns:
            phones.extend(re.findall(pattern, text))
        return list(set(phones))  # 去重
    
    @staticmethod
    def extract_emails(text):
        """提取邮箱地址"""
        pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
        return re.findall(pattern, text)
    
    @staticmethod
    def mask_sensitive(text, mask_type='phone'):
        """脱敏处理"""
        if mask_type == 'phone':
            return re.sub(r'(1[3-9]\d{9})', 
                         lambda m: m.group(1)[:3] + '****' + m.group(1)[7:], text)
        elif mask_type == 'email':
            return re.sub(r'([a-zA-Z0-9]{2})[a-zA-Z0-9]*@',
                         r'\1***@', text)
        return text

# 使用示例
html_text = '''
<div class="content">
    <script>alert("bad");</script>
    <p>联系我们: 010-12345678 或 13812345678</p>
    <p>邮箱: contact@example.com</p>
    <p>地址: 北京市海淀区中关村大街1号</p>
</div>
'''

cleaner = TextCleaner()
text = cleaner.clean_html(html_text)
print(f"清洗后: {text}")

print(f"提取电话: {cleaner.extract_phones(text)}")
print(f"提取邮箱: {cleaner.extract_emails(text)}")
print(f"脱敏电话: {cleaner.mask_sensitive(text, 'phone')}")

5.3 URL 解析器

import re
from urllib.parse import urlparse, parse_qs

class URLParser:
    """URL 解析器"""
    
    # 更完整的 URL 正则
    URL_PATTERN = re.compile(
        r'^(?P<scheme>https?)://'  # 协议
        r'(?P<domain>[^/:]+)'       # 域名
        r'(?::(?P<port>\d+))?'      # 端口（可选）
        r'(?P<path>/[^?#]*)?'       # 路径
        r'(?:\?(?P<query>[^#]+))?'  # 查询字符串
        r'(?:#(?P<fragment>.+))?'   # 锚点
    )
    
    @classmethod
    def parse(cls, url):
        """解析 URL"""
        # 尝试用正则解析
        match = cls.URL_PATTERN.match(url)
        if match:
            return match.groupdict()
        
        # 回退到 urllib
        parsed = urlparse(url)
        return {
            'scheme': parsed.scheme,
            'domain': parsed.netloc,
            'port': parsed.port,
            'path': parsed.path,
            'query': parsed.query,
            'fragment': parsed.fragment
        }
    
    @classmethod
    def extract_params(cls, url):
        """提取 URL 参数"""
        parsed = urlparse(url)
        params = parse_qs(parsed.query)
        # 转换为简单字典（值列表转单值）
        return {k: v[0] if len(v) == 1 else v for k, v in params.items()}
    
    @classmethod
    def build_url(cls, scheme='https', domain='', path='/', params=None, fragment=''):
        """构建 URL"""
        url = f"{scheme}://{domain}{path}"
        if params:
            query = '&'.join(f"{k}={v}" for k, v in params.items())
            url += f"?{query}"
        if fragment:
            url += f"#{fragment}"
        return url
    
    @classmethod
    def extract_domain_info(cls, domain):
        """提取域名信息"""
        # 提取子域名
        parts = domain.split('.')
        if len(parts) >= 3:
            subdomain = parts[0]
            main_domain = '.'.join(parts[1:])
        else:
            subdomain = None
            main_domain = domain
        
        # 提取顶级域
        tld = parts[-1] if parts else ''
        
        return {
            'original': domain,
            'subdomain': subdomain,
            'domain': main_domain,
            'tld': tld
        }

# 使用示例
urls = [
    'https://example.com:8080/path/to/page?id=123&name=test#section',
    'http://sub.domain.co.uk/api/v1/users?page=1',
    'https://www.test.org'
]

parser = URLParser()
for url in urls:
    print(f"\n解析: {url}")
    info = parser.parse(url)
    print(f"  域名: {info['domain']}")
    print(f"  路径: {info.get('path', '/')}")
    print(f"  参数: {parser.extract_params(url)}")
    
    if info.get('domain'):
        domain_info = parser.extract_domain_info(info['domain'])
        print(f"  域名信息: {domain_info}")

5.4 数据验证器

import re

class Validator:
    """常用数据验证器"""
    
    @staticmethod
    def is_valid_email(email):
        """验证邮箱"""
        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        return re.match(pattern, email) is not None
    
    @staticmethod
    def is_valid_phone(phone, region='CN'):
        """验证手机号"""
        if region == 'CN':
            # 中国手机号（11位，以1开头，第2位3-9）
            pattern = r'^1[3-9]\d{9}$'
        elif region == 'US':
            # 美国电话（10位）
            pattern = r'^\d{10}$'
        else:
            pattern = r'^\+?\d{6,15}$'
        return re.match(pattern, phone) is not None
    
    @staticmethod
    def is_valid_url(url):
        """验证 URL"""
        pattern = r'^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/.*)?$'
        return re.match(pattern, url) is not None
    
    @staticmethod
    def is_valid_ip(ip):
        """验证 IPv4 地址"""
        pattern = r'^(\d{1,3}\.){3}\d{1,3}$'
        if not re.match(pattern, ip):
            return False
        # 检查每段是否在 0-255
        return all(0 <= int(octet) <= 255 for octet in ip.split('.'))
    
    @staticmethod
    def is_valid_date(date_str, format='%Y-%m-%d'):
        """验证日期格式"""
        from datetime import datetime
        try:
            datetime.strptime(date_str, format)
            return True
        except ValueError:
            return False
    
    @staticmethod
    def is_strong_password(password):
        """验证密码强度"""
        if len(password) < 8:
            return False, "密码长度至少8位"
        
        has_upper = bool(re.search(r'[A-Z]', password))
        has_lower = bool(re.search(r'[a-z]', password))
        has_digit = bool(re.search(r'\d', password))
        has_special = bool(re.search(r'[!@#$%^&*(),.?":{}|<>]', password))
        
        if not has_upper:
            return False, "需要包含大写字母"
        if not has_lower:
            return False, "需要包含小写字母"
        if not has_digit:
            return False, "需要包含数字"
        if not has_special:
            return False, "需要包含特殊字符"
        
        return True, "密码强度合格"

# 使用示例
validator = Validator()

test_cases = [
    ('email', 'test@example.com'),
    ('phone', '13812345678'),
    ('url', 'https://www.example.com'),
    ('ip', '192.168.1.1'),
    ('date', '2024-05-01'),
]

for type_name, value in test_cases:
    method = getattr(validator, f'is_valid_{type_name}')
    result = method(value)
    status = "✓" if result else "✗"
    print(f"{status} {type_name}: {value}")

# 密码强度验证
password = "Test@1234"
valid, msg = validator.is_strong_password(password)
print(f"\n密码 '{password}': {msg}")

背诵版

高级正则速查

┌─────────────────────────────────────────────────────────────┐ │ 零宽断言（Lookaround） │ ├─────────────────────────────────────────────────────────────┤ │ (?=...) 正向先行 │ 后面跟着... │ │ (?!...) 负向先行 │ 后面不跟... │ │ (?<=...) 正向后行 │ 前面是... │ │ (?<!...) 负向后行 │ 前面不是... │ ├─────────────────────────────────────────────────────────────┤ │ (?P<name>...) 命名分组 │ │ (?:...) 非捕获分组 │ │ \1, \2 反向引用 │ └─────────────────────────────────────────────────────────────┘

re.sub 替换函数

# 基本替换
re.sub(pattern, replacement, string)

# 替换函数
def replace_func(match):
    return ...  # 返回替换文本

re.sub(pattern, replace_func, string)

# 返回替换次数
re.subn(pattern, replacement, string)  # 返回 (结果, 次数)

考前记忆

面试重点

零宽断言的区别

博客首页排版修复：Hero 区域高度与快捷链接间距优化

Thu, 30 Apr 2026 20:30:00 +0800

问题现象

博客首页打开后，搜索框下方留出了大片空白，快捷链接卡片被推到了屏幕下半部分。用户需要滚动才能看到"专栏"入口，访问路径变长了。

目标效果：搜索框 → 少量间距 → 快捷链接 → 专栏卡片，首页一屏内尽量展示所有核心入口。

排查过程

第一层：min-height 冲突

打开浏览器开发者工具，定位到 .home-hero 元素，发现 computed style 显示 min-height: 80vh。这个规则来自主题源文件，但自定义 CSS 里已经加了一条覆盖规则：

.home-hero {
  min-height: auto !important;
  padding: 2rem 0 0.75rem !important;
}

curl 确认线上 CSS 已经包含这条规则，但刷新页面视觉上没有任何变化——说明有其他规则优先级更高，或者被注释掉的原始规则依然在解析。

第二层：多处冲突的 min-height

用 grep -n "min-height" /var/www/blog/static/css/tech.css 找到了三处相关规则：

/* Line 128 */
.home-hero { min-height: 80vh; padding: 80px 20px; }

/* Line 393-396 (media query) */
@media (max-width: 768px) {
  .home-hero { min-height: 60vh !important; padding: 50px 20px !important; }
}

/* Line 614 (media query) */
@media (min-width: 769px) {
  .home-hero { min-height: 65vh; padding: 60px 40px; }
}

这三处都设置了具体的高度值，而且注释掉不等于删除——CSS 解析器依然会处理注释内的内容在某些构建流程中。更关键的是：自定义 CSS 的覆盖规则写在 line 128 之后，但主题的 media query 规则在 line 393 和 614，相同选择器的后来者优先级更高，且 !important 在 media query 内层会覆盖外层普通规则。

工具箱

Sun, 26 Apr 2026 00:00:00 +0000

安装包下载

文件	版本	大小	说明
hugo-0.146.0-extended-linux-amd64.tar.gz	0.146.0	18 MB	Hugo 静态博客引擎 extended 版（含 PostCSS/SCSS）
PaperMod-master.zip	master	281 KB	PaperMod 主题源码
tailscale_1.96.4_amd64.tar.gz	1.96.4	35 MB	Tailscale 客户端（tailscaled + tailscale CLI）
derper_v1.96.5_linux_amd64.tar.gz	1.96.5	13 MB	Tailscale DERP relay 二进制
lucky_2.26.2_Linux_x86_64.tar.gz	2.26.2	11 MB	Lucky ACME 客户端（自动化 SSL 证书）
lucky.tar.gz	旧版	11 MB	Lucky 旧版本
nginx-1.20.1_almalinux9_x86_64.tar.gz	1.20.1	575 KB	Nginx 二进制（仅主程序）

软件安装

Hugo

tar -xzf hugo-0.146.0-extended-linux-amd64.tar.gz
mv hugo /usr/local/bin/
hugo version

Tailscale

tar -xzf tailscale_1.96.4_amd64.tar.gz
cd tailscale_1.96.4_amd64
./tailscaled install-systemd

DERP relay

tar -xzf derper_v1.96.5_linux_amd64.tar.gz
./derper -c /var/lib/derper/derper.conf

Lucky（ACME 客户端）

tar -xzf lucky_2.26.2_Linux_x86_64.tar.gz
cd lucky
./lucky

Nginx（AlmaLinux 9）

# AlmaLinux 9 用 dnf 安装
dnf install -y nginx

# 或下载本包后手动部署
tar -xzf nginx-1.20.1_almalinux9_x86_64.tar.gz
mv nginx /usr/sbin/nginx
nginx -v

其他工具

工具	用途
Cloudflare	CDN / DNS / 安全
Let’s Encrypt	免费 SSL 证书
GitHub	代码托管
Hugo	静态博客引擎
Tailscale	内网穿透 / VPN
MobaXterm	Windows SSH 客户端

工具在精不在多，够用就好。

关于

Sun, 26 Apr 2026 00:00:00 +0000

关于本站

踩过的坑，都是经验。

我是谁

热爱折腾的开发者，主要方向：

网络与安全 — Tailscale、WireGuard、DERP 部署
DevOps — Linux 服务器运维、CI/CD
博客折腾 — Hugo、Hexo 等静态博客

技术栈

分类	技术
编程	Go / Python / Shell / JavaScript
容器	Docker / K8s
网络	Tailscale / WireGuard / Nginx
云服务	阿里云 ECS / 腾讯云 / Cloudflare

博客说明

本站基于 Hugo + PaperMod，部署在 阿里云 ECS。

保持折腾，持续记录。

博客手机端渲染优化：从 CSS 排查到 Hugo goat SVG 根因定位

Sun, 26 Apr 2026 06:30:00 +0800

问题现象

博客在手机端打开 Day 5 这类文章时，中文文字出现了逐字分行的问题：

创建 N A T 网关

明明一行能显示的文字，被拆成了一个个单字，视觉上完全无法阅读。

第一反应：CSS 问题

以为是 word-break 或 white-space 的锅。用 MobaXterm 连上服务器，先把 CSS 文件拉下来看：

scp root@***.uuworld.cn:/var/www/blog/static/css/tech.css .

找到好几处 word-break: break-word，这个属性在手机端会让浏览器在任意字符之间断行——而中文没有空格，浏览器就把每个字都当成了合法断点，自然就逐字分行显示。

修改方案：把涉及中文内容的 word-break: break-word 全部改成 word-break: normal，让中文按自然语意换行。

同步回服务器，重建 Hugo：

scp tech.css root@***.uuworld.cn:/var/www/blog/static/css/tech.css
ssh root@***.uuworld.cn "cd /var/www/blog && hugo"

验证 CSS 是否更新：

curl https://***.uuworld.cn/css/tech.css | grep 'word-break'

结果：CSS 已生效。但刷新手机端，问题依旧。

深入：HTML 里藏了什么

CSS 修改了但没效果，怀疑 HTML 本身就有问题。用 curl 抓页面看：

curl http://***.uuworld.cn/acp/acp-day-05-acp-day-5-vpc-nat/ | grep -A5 '典型实验流程'

输出里发现了这个：

<div class="goat svg-container ">
  <svg xmlns="http://www.w3.org/2000/svg" font-family="Menlo,Lucida Console,monospace" viewBox="0 0 192 201">
    <g transform='translate(8,16)'>
      <text text-anchor='middle' x='0' y='4' fill='currentColor' style='font-size:1em'>系</text>
      <text text-anchor='middle' x='0' y='20' fill='currentColor' style='font-size:1em'>├</text>
      <text text-anchor='middle' x='0' y='36' fill='currentColor' style='font-size:1em'>├</text>

问题找到了！Hugo 生成的 HTML 里，代码块被转成了 SVG 图形，每个字符都是独立的 <text> 元素。手机端 SVG 无法正确缩放，浏览器就把每个字符当成独立行来渲染。

安装包落地自动化流程

Sun, 26 Apr 2026 02:10:00 +0800

背景

每次在服务器上下载、安装、配置软件后，安装包散落在 /tmp 或下载目录，没有统一管理。下次要用时找不到，或者重复下载。

博客搭建完成后，决定把「安装包落地」这件事系统化。

流程设计

下载安装包（本地或代理） ↓ 安装、配置、验证 ↓ 移动到 /var/www/blog/static/downloads/ ↓ 更新 tools/index.md 的下载链接 ↓ Hugo 自动构建发布

实际操作

1. 下载安装包

能直接从互联网下载（代理/VPS 可达）：本地 curl/wget 后 scp 上传

# 本地下载 Hugo
curl -sL 'https://github.com/gohugoio/hugo/releases/download/v0.146.0/...tar.gz' -o hugo.tar.gz

# scp 到服务器 downloads 目录
scp hugo.tar.gz root@***.uuworld.cn:/var/www/blog/static/downloads/

服务器本地已有：直接 cp 到 downloads

cp /root/go/bin/derper /var/www/blog/static/downloads/
cd /var/www/blog/static/downloads/
tar -czf derper_v1.96.5_linux_amd64.tar.gz derper

2. 更新 tools 页面

在 content/tools/index.md 添加下载链接：

| [derper_v1.96.5_linux_amd64.tar.gz](/downloads/derper_v1.96.5_linux_amd64.tar.gz) | 1.96.5 | 13 MB | Tailscale DERP relay 二进制 |

3. 构建发布

cd /var/www/blog
/usr/local/bin/hugo --quiet

即可通过 https://***.uuworld.cn/tools/ 下载。

Hugo + PaperMod 博客搭建全记录

Sun, 26 Apr 2026 00:30:00 +0800

背景

想用一个简洁的技术博客记录折腾过的项目，选型要求：静态站点、主题好看、部署简单、定制灵活。

最终技术栈：Hugo 0.146 + PaperMod + nginx + 自定义赛博朋克样式。

目标

静态博客，Markdown 写文章
PaperMod 主题，简洁好看
自定义科技感 UI：粒子背景 + 霓虹光效
通过 nginx 直接托管 /var/www/blog/public/
支持 /about/ 和 /tools/ 页面

踩坑记录

Hugo 版本与主题兼容

下载 Hugo 0.139.0 配合 PaperMod 时报错：

ERROR 2026/04/25 错过了GaTracker的site.config.googleAnalytics

解决：升级到 Hugo 0.146.0 extended 版本，问题消失。

wget https://github.com/gohugoio/hugo/releases/download/v0.146.0/hugo_extended_0.146.0_linux-amd64.tar.gz
tar -xzf hugo_extended_0.146.0_linux-amd64.tar.gz hugo
mv hugo /usr/local/bin/

安装包下载

文件	下载
hugo-0.146.0-extended-linux-amd64.tar.gz	Hugo 0.146.0 extended
PaperMod-master.zip	PaperMod 主题最新源码

about 页面不渲染

content/about.md 放在根目录，访问 /about/ 始终 404。

ali-ecs DERP 部署全记录

Sat, 25 Apr 2026 22:59:00 +0800

背景

需要在阿里云 ECS 上部署 Tailscale DERP relay，让 Windows 客户端能通过 DERP 连接到节点。

目标

域名：derp.***.cn
泛域名证书：.**.cn
derper 运行在 443 端口
STUN 运行在 3478 UDP

踩坑记录

1. DNSPod Token 格式

问题：API 返回 401，原因是 SecretId 是腾讯云 CAM 的，不是 DNSPod 的。

解决：DNSPod Token 格式是 ID,Token（两部分用逗号连接），腾讯云控制台生成的 SecretId/SecretKey 是 CAM 的，不通用。

2. lucky 安装失败

问题：jsdelivr CDN 在阿里云 ECS 上无法访问，导致 lucky 安装脚本无法下载二进制文件。

解决：从 GitHub 直接下载 release 包，传到 ECS 再解压安装。

3. derper 证书参数

问题：新版 derper 参数变了，不再是 -c cert -k key，改为 -certmode manual -certdir。