公众号：AI悦创【二维码】
\n![\"\"](\"/gzh.jpg\")
核心原则：低成本试错、技术落地为先、共创共享、快速验证。
\n结合个人网站 “内容测试 - 数据反馈 - 迭代优化” 的运营逻辑，项目落地分三步走，每一步设明确目标与验收标准：
\n按 “少而精、专业优先” 原则配置，拒绝冗余岗位，各角色需贴合 AI 工具使用与互联网运营特点，结合个人网站线上招募 / 协作经验，明确核心能力要求：
\n| 角色 | 核心能力要求 |
\n|
An integer b is called a non-trivial divisor of a positive integer n if b is between 2 and n−1 such that nn is divisible by b, meaning that the remainder of the integer division nn by b is zero. The following correct function takes as input a positive integer, and returns how many non-trivial divisors are there for the given input.
\ndef do_it(xxx):\n tHeReSuLt=0\n u=1\n while u<=xxx//1:\n # check if divides\n if xxx%u==0:\n # exclude some random numbers\n if not(u==1 or u==xxx):\n tHeReSuLt=tHeReSuLt+1\n else:\n pass # do nothing lol\n # increment but not really important\n u=u+1-0\n return int(str(tHeReSuLt))Describe all distinct ways in which the quality of the code above can be improved without affecting to its functional correctness.
\nTo gain marks, your suggested improvements must be specific. For example, if you think that naming should be improved, you must give at least one specific example of which names should be changed and to what; just answering \"better names\" is not enough. Do not simply write your suggested improvements as comments inside the function. Writing a new function or rewriting the function is not an acceptable answer, regardless of whether it is correct or not.
\nResponse
\n\n\nWe want to write tests for a function with signature and docstring defined as follows:
\ndef sequence_dissimilarity(s1, s2)\n \"\"\"\n s1 and s2 are two sequences of the same length\n Returns the number of i-th elements that are NOT equal\n between two sequences, i.e., where s1[i] != s2[i]\n Assume that this comparison is always valid and evaluates to True or False\n \"\"\"\ndef sequence_dissimilarity(s1, s2)\n \"\"\"\n s1 和 s2 是两个长度相同的序列\n 返回两个序列中“对应位置 i 的元素不相等”的位置数量\n 也就是统计满足 s1[i] != s2[i] 的 i 的个数\n 假设这种比较总是合法的，并且比较结果一定是 True 或 False\n \"\"\"Write at most 4 test cases for this function (every test case after the first four will be ignored). For each test case, you must write the inputs (arguments to the function) and the expected return value. You may format your answer in anyway, provided that the inputs and output can be clearly identified. Each test case should specify valid arguments for the function. Your test cases should cover relevant corner cases.
\n提示
\n下面给出 4 个覆盖关键边界情况的测试用例（输入 + 期望输出）：
\n两个空序列（长度为 0）
\n输入：s1 = [], s2 = []
期望输出：0
完全相同（无任何不相等）
\n输入：s1 = [1, 2, 3], s2 = [1, 2, 3]
期望输出：0
完全不同（每个位置都不相等）
\n输入：s1 = \"abc\", s2 = \"XYZ\"
期望输出：3
部分不同 + 混合类型（比较始终合法）
\n输入：s1 = [1, \"2\", 3, \"x\"], s2 = [1, 2, 4, \"x\"]
逐位比较：1==1(相同), \"2\"!=2(不同), 3!=4(不同), \"x\"==\"x\"(相同)
期望输出：2
def test_sequence_dissimilarity():\n # 1) 两个空序列（长度为0）\n assert sequence_dissimilarity([], []) == 0\n\n # 2) 完全相同（无任何不相等）\n assert sequence_dissimilarity([1, 2, 3], [1, 2, 3]) == 0\n\n # 3) 完全不同（每个位置都不相等）\n assert sequence_dissimilarity(\"abc\", \"XYZ\") == 3\n\n # 4) 部分不同 + 混合类型（比较始终合法）\n assert sequence_dissimilarity([1, \"2\", 3, \"x\"], [1, 2, 4, \"x\"]) == 2The argmin of a sequence is the index (position) of the smallest element in the sequence. For example, if the sequence is [3,4,5], the argmin is 0, because the smallest value is 3 and is at index 0. If the smallest value is not unique, the argmin function can return any index where it appears. For example, if the sequence is [5,5,5], any of the indices 0, 1 or 2 is a valid answer. We assume that the input sequence is non-empty.
Below is an implementation of the argmin function:
def argmin(a):\n a = list(a)\n p = 0\n i = 0\n a.sort()\n for x in a:\n if x < a[p]:\n p = i\n i = i + 1\n return pHowever, the function above is not correct:
\n(a) Provide an example of function call with arguments of correct type that makes this function return an incorrect result. a must be a non-empty sequence of numbers.
(b) Explain the cause of the error that you have found, i.e., what is wrong with this function. Your answer must explain what is wrong with the function as given. Writing a new function or rewriting/fixing the function is not an acceptable answer, regardless of whether it is correct or not.
\nargmin([2, 1])正确的 argmin 应该返回 1（最小值 1 在原序列的索引是 1），但这段代码会返回 0。
你也可以用更明显的例子：
\nargmin([3, 1, 2])正确答案应为 1，但函数会返回 0。
核心问题是：它在计算索引之前把 a 排序了。
a = list(a) 把输入变成列表没问题。a.sort()：这一步会原地排序，把元素顺序改掉。argmin 要返回的是“原始输入序列中最小元素的位置（索引）”，而排序以后：\nx < a[0]）更具体地说，在 for x in a: 这段循环中：
a[p] 初始是 a[0]，也就是最小值x 来说，都不可能满足 x < a[p]（因为 a[p] 已经是最小）p 永远不会更新，始终是 0return p 返回 0，这不是原序列的 argmin，而是“排序后序列”的位置总结一句：排序破坏了原始索引信息，导致返回的索引与输入序列的位置无关。
\nConsider the function:
\ndef g(A):\n res = 0.0\n for i in range(A.shape[0]):\n for j in range(i, A.shape[1]):\n res += A[i, j]\n return reswhere A is an n by n 2D NumPy array of floating-point numbers (A.shape[0] == A.shape[1] == n).
Write down the time complexity of g(A) in big-O notation as a function of n . Explain the reason why, e.g., by analysing the code line by line and summarising it**.** Correct time complexity without sufficient explanation and reasoning will receive zero marks.
题目代码
\ndef g(A):\n res = 0.0\n for i in range(A.shape[0]):\n for j in range(i, A.shape[1]):\n res += A[i, j]\n return res已知：
\nA 是一个 n × n 的 NumPy 数组A.shape[0] == A.shape[1] == n🔍 第一步：逐行分析
\n① res = 0.0
这是常数时间操作：O(1)
\n② 外层循环
\nfor i in range(A.shape[0]):因为 A.shape[0] = n，所以外层循环执行：n 次
③ 内层循环
\nfor j in range(i, A.shape[1]):这里是关键，当 i = 0 时：
j 从 0 到 n-1\n执行 n 次当 i = 1 时：
j 从 1 到 n-1\n执行 n-1 次当 i = 2 时：
执行 n-2 次……
\n当 i = n-1 时：
执行 1 次🔢 总执行次数计算
\n总的 res += A[i, j] 执行次数为：
n+(n−1)+(n−2)+⋯+1
\n这是一个等差数列求和：
\n2n(n+1)
\n展开：
\n=2n2+n
\n🎯 时间复杂度分析
\n最高阶项是：
\n2n2
\n在 Big-O 表示法中：
\n所以：
\nO(n2)
\n📌 更直观理解
\n这段代码：
\n矩阵一共有：
\nn2
\n个元素。
\n而代码访问了：
\n2n(n+1)
\n个元素，这仍然是二次级别增长。
\n最终答案
\nO(n2)
\n📌 总结一句话
\n虽然内层循环从 i 开始减少了次数，但所有迭代次数加起来仍然是：
2n(n+1)
\n其增长阶为：
\nO(n2)
\n把程序想象成：输入规模为 n 时，会执行多少次“基本操作”（比较、加减、赋值、访问数组等）。
3n + 20 记为 O(n)n^2 + n 记为 O(n^2)O(A + B)n 次、内层 n 次 → O(n * n) = O(n^2)n → n/2 → n/4 ... 是 O(log n)特点：执行次数不随 n 变。
代码示例：数组索引访问
\ndef get_middle(a):\n return a[len(a)//2] # 访问一次为什么是 O(1)：无论 a 多长，都只做固定次数操作（求长度、除法、一次索引）。
\n\n典型：取数组某个位置、交换两个变量、栈/队列的 push/pop（在实现良好时）。
\n
特点：每一步把问题规模“砍半/按比例缩小”。
\n代码示例：二分查找
\ndef binary_search(a, target):\n lo, hi = 0, len(a) - 1\n while lo <= hi:\n mid = (lo + hi) // 2\n if a[mid] == target:\n return mid\n elif a[mid] < target:\n lo = mid + 1\n else:\n hi = mid - 1\n return -1为什么是 O(log n)：每次循环把区间缩小一半：n → n/2 → n/4 → ... → 1 需要的步数是 log2(n) 级别。
特点：循环到 sqrt(n) 就能解决（常见于数论）。
代码示例：判断是否有非平凡因子（试除到 √n）
\ndef has_divisor(n):\n i = 2\n while i * i <= n:\n if n % i == 0:\n return True\n i += 1\n return False为什么是 O(√n)：i*i <= n ⇒ i <= √n，最多尝试约 √n 次。
特点：把输入完整扫一遍。
\n代码示例：线性查找
\ndef linear_search(a, target):\n for i, x in enumerate(a):\n if x == target:\n return i\n return -1为什么是 O(n)：最坏情况下要检查 n 个元素。
\n\n注意：有些操作“看起来一行”，但可能是 O(n)，例如 Python 的
\nx in list、list.count、list.remove等都要线性扫描。
特点：分别扫两份数据，各扫一遍。
\n代码示例：合并两个数组（不排序）
\ndef concat(a, b):\n res = []\n for x in a:\n res.append(x)\n for y in b:\n res.append(y)\n return res为什么是 O(n + m)：第一段做 n 次，第二段做 m 次，总计相加。
\n\n图算法里常见
\nO(V + E)（点+边），也是同理。
特点：通常是 分治：分成若干份（log 层），每层做 O(n) 工作。
\n代码示例：归并排序（经典）
\ndef merge_sort(a):\n if len(a) <= 1:\n return a\n mid = len(a) // 2\n left = merge_sort(a[:mid])\n right = merge_sort(a[mid:])\n return merge(left, right)\n\ndef merge(left, right):\n i = j = 0\n res = []\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n res.append(left[i]); i += 1\n else:\n res.append(right[j]); j += 1\n res.extend(left[i:])\n res.extend(right[j:])\n return res为什么是 O(n log n)：
\nn → n/2 → ... 有 log n 层O(n)O(n) * O(log n) = O(n log n)\n\n现实中：大多数比较排序在平均/最坏可做到
\nO(n log n)（归并、堆排序），快速排序平均O(n log n)但最坏O(n^2)。
特点：所有“成对组合”类问题很容易出现。
\n代码示例：统计所有配对 (i, j)
\ndef count_pairs(a):\n n = len(a)\n c = 0\n for i in range(n):\n for j in range(n):\n c += 1\n return c为什么是 O(n²)：外层 n 次，内层 n 次，总 n*n。
更真实一点：两两比较是否相等
\ndef has_duplicate_slow(a):\n n = len(a)\n for i in range(n):\n for j in range(i + 1, n):\n if a[i] == a[j]:\n return True\n return False这里比较次数约为 n(n-1)/2，仍是 O(n²)（忽略常数 1/2）。
def triple_work(n):\n c = 0\n for i in range(n):\n for j in range(n):\n for k in range(n):\n c += 1\n return c为什么是 O(n³)：n * n * n。
\n\n典型：Floyd-Warshall 全源最短路就是
\nO(n³)（n 个点）。
代码示例：生成所有子集
\ndef all_subsets(a):\n n = len(a)\n res = []\n for mask in range(1 << n): # 2^n 个 mask\n subset = []\n for i in range(n): # 每个 mask 扫 n 位\n if mask & (1 << i):\n subset.append(a[i])\n res.append(subset)\n return res复杂度：严格说是 O(n * 2^n)（因为每个子集构造要扫 n 位）。
为什么会爆炸：子集数量本身就是 2^n，规模增长极快。
代码示例：生成全排列（回溯）
\ndef permutations(a):\n res = []\n used = [False] * len(a)\n path = []\n\n def dfs():\n if len(path) == len(a):\n res.append(path.copy())\n return\n for i in range(len(a)):\n if not used[i]:\n used[i] = True\n path.append(a[i])\n dfs()\n path.pop()\n used[i] = False\n\n dfs()\n return res为什么是 O(n!)：第 1 位有 n 种选法，第 2 位 n-1 … ⇒ n*(n-1)*...*1 = n!。
A. “每次减半”的递归：O(log n)
\ndef rec_half(n):\n if n <= 1:\n return 1\n return rec_half(n // 2) + 1每次 n → n/2，递归层数 log n。
B. 经典斐波那契（错误示范）：O(2^n)
\ndef fib_slow(n):\n if n <= 1:\n return n\n return fib_slow(n-1) + fib_slow(n-2)递归树分叉，节点数指数级增长（重复计算大量子问题）。
\n代码示例：循环里用了 .count()（每次 O(n)）
def count_freq_bad(a):\n freq = {}\n for x in a:\n freq[x] = a.count(x) # count 是 O(n)，外层又 n 次 => O(n^2)\n return freq为什么是 O(n²)：外层 n 次，每次 count 扫 n ⇒ n*n。
✅ 改成真正 O(n)：
\ndef count_freq_good(a):\n freq = {}\n for x in a:\n freq[x] = freq.get(x, 0) + 1\n return freqO(1)：固定次数操作O(log n)：每轮规模按比例缩小（/2、/3…）O(√n)：循环到平方根（试除、某些优化）O(n)：扫一遍输入O(n + m)：扫两份输入O(n log n)：分治（log 层 × 每层 O(n)）O(n²)：两两组合/双重循环O(n³)：三重循环/某些全局 DPO(2^n)：枚举子集/指数分叉递归O(n!)：枚举排列\n\n记
\nn为输入规模（如列表长度），m为另一份输入规模（如第二个列表长度），V/E为图的点/边数。
| 时间复杂度 | 典型代码结构（Python 形式） | 为什么是这个复杂度（次数估算） | 常见场景 |
\n|
在真实的开发环境中，我们常常会遇到这样的场景：
\ngit push 时 不需要手动切换账号；如果直接使用默认的 SSH 配置，通常会遇到：
\nPermission denied (publickey)；Key is already in use GitHub；解决方案只有一个：
\n\n\n使用多个 SSH Key + SSH Host 别名，将不同项目路由到不同 GitHub 账号。
\n换句话说：同一台 Mac，一条命令无脑 push。
\n
整个方案的核心结构如下：
\n| 模块 | 作用 |
\n|
你好，我是悦创。让我们正式开启第一课的学习。
\n在我们的旅程正式启航之际，请你先思考第一个问题：你眼中的 Claude Code 是什么？
\n我们可能会得到很多个不同的答案：
\n这些答案都对，但都不完整。
\nClaude Code 的真正身份是：一个可编程、可扩展、可组合的 AI Agent 框架。
\n它不只是一个“工具“，而是一个“平台”——你可以在上面构建自己的 AI 工作流。就像你不会说“VS Code 是一个文本编辑器”（它是，但远不止于此），Claude Code 也远不只是一个 AI 助手。
\n这一讲，我们将站在高处，俯瞰 Claude Code 的完整技术栈。当你理解了全貌，后面学习每一个组件时，都会知道它在整个系统中的位置。
\n我们先花几分钟，把 Claude Code 用起来。第一步，在这里下载匹配你系统的 Claude Code 版本。
\n安装过程非常简单，跟着官方的说明就好。
\n# macOS / Linux / WSL（推荐，自动更新）\ncurl -fsSL https://claude.ai/install.sh | bash\n\n# Windows PowerShell\nirm https://claude.ai/install.ps1 | iex\n\n# 或使用 Homebrew（需手动更新）\nbrew install --cask claude-code然后进入操作系统的命令行，输入 claude 这个命令就可以开始对话了。
\nclaude # 首次运行会提示登录Claude Code 是付费软件，需要在 Claude 网站开账户。它所支持的账户类型包括：
\n\n\n\n
\n- Cursor（https://cursor.com）：基于 VS Code 的 AI 编辑器，内置 Claude 和 GPT 模型，支持国内网络，有免费额度，其体验最接近 Claude Code 的 IDE 集成方案。
\n- Cline（VS Code 插件）：开源的 AI 编码助手插件：支持多种 LLM 后端，包括国内的 DeepSeek、Qwen 等，可以自己配置 API，灵活度高。
\n- Windsurf（https://codeium.com/windsurf）：Codeium 推出的 AI IDE，有免费版，支持 agentic 编码。
\n- 通义灵码（阿里云）：国产 AI 编程助手，IDE 插件形式，完全国内可用，无需翻墙。
\n- 自建方案：使用 Cline + DeepSeek API（国内可直接访问）；或者使用 Cline + 本地部署的开源模型（如 Qwen-Coder）
\n
\n\n本课程的知识框架（Memory、SubAgents、Skills、Hooks 等概念）对于理解和使用其他 AI 编码工具同样适用。当然，如果你有稳定的网络环境，Claude Code 仍然是目前 agentic coding 体验最好的工具之一。
\n
下面是最基本的命令行（Command Line）交互方式，以及常用命令的速查表。
\ncd /path/to/your/project # 进入项目目录\nclaude # 启动交互模式\n\n# 然后你可以：\n> 这个项目是做什么的？ # 了解项目\n> 帮我加一个 hello world 函数 # 修改代码（会请求确认）\n> 提交我的更改 # Git 操作除了在命令行中直接使用 Claude 命令之外，另一种更为常见的方式就是和 VS Code 浏览器中，甚至是其它 AI Coder 中（如 Cursor），把 Coding IDE 和 Claude Code 命令行集成使用。这样既可以享受 IDE 的便利，又可以利用命令行的强大，一举两得。
\n总结一下上面的使用步骤：
\n用户 → 输入问题 → Claude 回答 → 完成你问，它答。就像用计算器，输入数字，得到结果。大多数人使用 Claude Code 的方式，就止步于此了。
\nClaude Code 可以生成代码，从 0 开始做项目，整理文件，甚至优化你的操作系统……虽然能做到这些也已经很强大了，但这仍然只是被动使用！
\n而 Claude Code 还支持另一种模式：
\n用户 → 配置 Agent → Agent 自主工作 → 自动完成任务这是主动驾驭——你设计，它执行。就像我们编写程序，程序自动运行。
\n举个例子：
\n这门课的目标，把你从被动使用者变成主动驾驭者。
\n你肯定会说，悦创，我当然想走得更远一些，从被动使用者晋级为主动驾驭者，那成为驾驭者需要理解什么？
\n用学开车打个比方：
\n对于 Claude Code：
\n我们现在这一讲就是“驾驭者入门”——让你看到 Claude Code 引擎盖下面的东西。
\nClaude Code 的底层能力从技术上拆解可以分为四个层次：基础层、扩展层、集成层和编程接口层。
\n让我从下往上解释每一层。
\n基础层也可以称为是 Claude Code 的长期记忆系统，它的核心文件是 CLAUDE.md。
比如入职一家新公司，第一天你会收到一份新员工手册，告诉你：
\n而 CLAUDE.md 就是 Claude 的“新员工手册”。
因此，我强烈建议每一个人都为你的 Claude 创建 CLAUDE.md，以提供给它一系列最基本的信息。
例如，当我们要开始一个新的电商项目，我创建了下面的 CLAUDE.md 文件。
# Project: E-commerce Platform\n\n## Tech Stack\n- Frontend: React + TypeScript\n- Backend: Node.js + Express\n- Database: PostgreSQL\n\n## Code Style\n- Use functional components\n- Prefer async/await over .then()\n- Maximum line length: 100 characters\n\n## Important Rules\n- NEVER commit to main directly\n- Always run tests before pushingClaude 每次开始对话时，都会读取这个文件。这样它就“记住”了你的项目规范，不需要每次重复说明。
\nClaude Code 并不是只有一个CLAUDE.md记忆文件，全局、项目和项目的特定模块都可以拥有属于自己的记忆文件（或者也可以叫配置文件）。
\n~/.claude/CLAUDE.md # 全局（所有项目共用）\n ↓\n项目根目录/CLAUDE.md # 项目级（当前项目）\n ↓\n项目根目录/.claude/rules/*.md # 模块级（特定目录）我们可以把这些文件视为 Claude Code 系统记忆的不同层级。
\n这一层是 Claude Code 的能力中心，包含 Commands（斜杠命令）、Skills（技能）、SubAgents（子代理）、Hooks（钩子）四个核心组件。
\n斜杠命令是 Claude Code 内置或用户自定义的一系列核心能力，其触发方式是用户手动输入 /command：
用户输入: /review\n\nClaude 执行: 根据 .claude/commands/review.md 的指令审查代码Commands 适合标准化操作——团队统一的 commit 格式、固定的部署流程等。
\n技能则代表着 AI 的一系列专属能力组合，其触发方式是 Claude 自动判断（语义推理）是否激活相应技能。Skills 可以是 Claude Code 内置的，也可以由用户自己设定。
\n用户说: \"帮我看看这段代码有没有安全问题\"\n\nClaude 思考: 这是代码安全审查任务 → 激活 security-review Skill\n\nClaude 执行: 按照 Skill 中定义的流程审查代码很多人第一次听到 Skills 这个概念，都会觉得 “这不就是个高级一点的 tool 吗？Agent 直接 call tool 不就行了？”
\n我的回答是：的确像，但并不等价。原因在于 Tools 是外部能力接口，Skills 是模型内部的“行为模式 + 触发逻辑”。如果 Tool 是函数调用，Skill 就是把 if-else、prompt、策略和调用顺序，全部折叠进一个文档的整体封装，是对一个专有能力集的全面定义。
\n如果说 Tool 解决的是我能不能做；而 Skill 解决的是我该不该做、怎么做、做到什么程度。那么又一个问题来了：什么时候该用 Skill？什么时候该用 Commands？
\nCommands 是显式、可复用、可审计、通过斜杠命令固定触发的操作指令集，是相对固化的标准流程。
\n而当一个能力具备强烈的“领域感”（安全、架构、性能）、判断依赖上下文而非关键词 ，执行路径可能变化 ，需要“像专家一样行事”时，就用 Skill，而不是 Command。
\n拿刚才的例子来说——当用户问“帮我看看这段代码有没有安全问题”。Claude 的隐式判断流程是这样的。
\n1️⃣ 这是代码吗？——是\n2️⃣ 这是哪一类代码？——Node.js 后端\n3️⃣ 上下文是否涉及用户输入？——是\n4️⃣ 是否存在鉴权逻辑？——是\n5️⃣ 是否值得深入做安全审查？——是做完这些判断之后，就会自动激活 security-review Skill。
\n在 Skill 内部，是“像专家一样”的行为说明，它不会跑固定 checklist，而是根据语言选择重点、根据上下文跳过无关项、在发现高风险点时主动深挖、在安全风险低时明确告诉你“为什么没问题” —— 这不是流程执行，这是专家判断。
\n子代理是除了 Skills 之外的另一个大杀器，用于独立完成专项任务。其触发方式可以由 Claude 决定或用户指定。
\n主 Claude: 这个任务需要跑大量测试，让我创建一个子代理来处理。\n\n子代理（test-runner）: 执行测试，只把结果汇报给主 ClaudeSubAgents 适合隔离执行——高噪声任务（比如在大量日志中寻找出错信息，在大量文档中检索相关资源）、需要特定权限的任务。
\n钩子是在特定事件触发时自动执行的脚本，其触发方式是事件自动触发。
\n事件: Claude 即将执行 Edit 工具\n\nHook: 自动检查是否有安全敏感内容\n\n结果: 如果发现问题，阻止执行并警告Hooks 适合自动化检查——格式化、安全检查、日志记录等。
\n上面这四大核心组件之上，是集成层，负责链接外部世界。集成层包含 Headless（无头模式）和 MCP（Model Context Protocol）两大技术。
\n无头模式让 Claude Code 在没有人工交互的情况下运行，适合 CI/CD 集成——自动代码审查、自动修复、自动生成变更日志等。
\n# GitHub Actions 中\n- name: Auto-fix code issues\n run: claude --headless \"Fix all linting errors in src/\"MCP 让 Claude 连接外部工具和服务，适合工具连接——可以把任何外部系统变成 Claude 可调用的工具。
\nClaude → MCP → 数据库\nClaude → MCP → Jira\nClaude → MCP → 自定义 API当配置式的扩展不够用时，你可以用代码来驱动 Claude。这种方式适合构建自定义 Agent——完全控制执行流程、自定义工具、复杂工作流。
\nfrom claude_sdk import ClaudeSDKClient\n\nclient = ClaudeSDKClient()\n\n# 执行任务\nresult = client.query(\n prompt=\"Review this code for security issues\",\n tools=[\"Read\", \"Grep\"],\n max_turns=10\n)在真实的系统中，这些组件不是孤立存在的——它们相互协作，共同完成复杂任务。
\n首先看触发方式，也就是这些组件是怎么被激活的？不同组件的触发方式决定了它们的使用场景。
\n为什么“确定性”很重要？
\n如果我们要设计一个生产系统：
\n这个表格会在你做技术选型时反复用到。
\n理解了触发方式，我们来看数据是怎么在系统中流动的。这张图展示了一个典型请求的生命周期：
\n让我结合一个具体场景来解释这个流程——当用户输入“帮我修复 src/api.js 中的安全漏洞”之后，Claude 可能的处理流程如下。
Memory 层：Claude 首先加载 CLAUDE.md，了解到这是一个 Node.js 项目，团队要求所有安全修复必须附带测试。
扩展层分发：
\na. 用户没有输入斜杠命令，所以 Commands 不参与。
\nb. Claude 识别出“安全漏洞”关键词，激活 security-review Skill。
c. Skill 指示 Claude 创建一个子代理来执行测试。
\nHooks 监控：Claude 准备执行 Edit 工具修改代码时，Hooks 自动运行预检查脚本，确保没有引入新的安全问题。
工具执行：通过 Read、Edit 等工具完成代码修改。
\nMCP 连接：如果配置了 Jira MCP，还可以自动更新相关的 ticket 状态。
\n关键洞察：Memory 是基础设施，始终存在；扩展层是能力中心，按需激活；Hooks 是守门人，监控一切。
\n当你开发了一套好用的 Commands、Skills、Hooks 组合，想要分享给团队或社区时，就需要 Plugins。
\nPlugins 不是一种新能力，而是打包机制——就像 npm 包把一堆 JavaScript 文件打包在一起，Plugin 把一组相关的 Claude Code 扩展打包在一起。
\nmy-team-plugin/\n├── commands/ # 斜杠命令\n│ └── review.md\n├── skills/ # 技能\n│ └── security-check/\n│ └── SKILL.md\n├── agents/ # 子代理\n│ └── test-runner.md\n├── hooks/ # 钩子\n│ └── pre-edit.sh\n└── plugin.json # 插件配置下面是一个典型的 Plugins 使用场景：
\n\n\n你是团队的技术 Lead，花了两周时间打磨出一套完美的代码审查流程：一个
\n/review命令触发审查，一个code-qualitySkill 自动分析代码质量，一个test-runner子代理执行测试，还有一个 Hook 确保所有修改都有对应的测试。与其让团队成员手动复制这些文件，不如打包成一个 Plugin，新成员只需一条命令就能获得完整的工作流。
\n
Plugin 的价值在于可复用、可版本化、可分发。在第 16 讲我们还会详细讲解如何创建和发布 Plugins。
\n目前，理论知识已经足够了，但当你面对一个真实需求时，如何选择正确的技术？下面这是我总结的决策流程：
\n让我用几个真实问题来演示这个决策树的使用。
\n问题 1：我希望团队成员都用统一的 commit message 格式。
\n/commit 命令）。问题 2：每当 Claude 要修改代码时，我想自动检查是否符合我们的安全规范。
\n问题 3：我想让 Claude 能够查询我们内部的知识库。
\n为了帮助你快速匹配，我也准备了一份场景 VS 方案的速查表。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n![\"\"](\"/zsxq.jpg\")
bornforthis.cn；google.com；taobao.com；feishu.cn；douyin.com；jd.com；weibo.com；Step 1：访问阿里云万网：https://wanwang.aliyun.com/
\nStep 2：注册阿里云账号；
\nStep 3：🔍搜索你想要的域名，看是否🉑买；
\nStep 4：购买时会提示需要“创建信息模版”，按指引创建即可：
\nStep 5：选择立即实名认证即可，按指引操作即可：
\nStep 6：等待审核通过即可；
\n使用终端进入到目标路径，也就是你想把网站放在哪里。（换句话说：哪个磁盘、哪个文件夹。）
\n\n我们使用的是开源主题：https://theme-hope.vuejs.press/zh/
\n点击：快速上手
\n点击：创建项目
\n在终端输入主题文档提供的命令进行初始化网站：pnpm create vuepress-theme-hope my-docs
终端界面（上一步启动的终端），把命令改成：pnpm create vuepress-theme-hope .：
键盘上下键选择“简体中文”，随后回车↩︎键：
\n选择 pnpm：
\n选择 vite：
\n按下图进行设置即可：
\n按照下面继续设置即可：
\n自己选择是否查看 demo 示例：
\n如何停止：使用 Ctrl + C 进行停止🤚
启动终端，使终端在网站文件夹下。使用前面的终端也是可以的，需要停止运行网站。
\n鼠标选中新创建的文件夹（WebSite），鼠标右键——>最底部的“服务”——>选择“新建位于文件夹位置的终端窗口”：
\n直接输入：code . 这样就可以直接启动 VScode。
已经成功使用 VScode 启动网站项目：
\nCtrl + C 即可退出。文件路径：src/.vuepress/config.ts
Step 1：新建仓库
\n输入仓库名称：huangjiarongbao.github.io；
\n\n一个 GitHub 账号，只能创建一个这样的特定仓库，不过有其它方法绕开限制，后期分享。
\n
仓库介绍；
\n仓库必须公开，不能私有。如果想要私有，得用其它方法保护源代码。
\n\n\n原因很简单：因为免费版必须公开。
\n
随后点击： Create repository 即可；
\n切换到 SSH：
\n补充：主题目前初始化自带 GitHub 部署脚本存在问题，需要使用如下内容直接覆盖。路径：.github/workflows/deploy-docs.yml
name: 部署文档\n\non:\n push:\n branches:\n - main\n\npermissions:\n contents: write\n\njobs:\n deploy-gh-pages:\n runs-on: ubuntu-latest\n steps:\n - name: Checkout\n uses: actions/checkout@v3\n with:\n fetch-depth: 0\n # 如果你文档需要 Git 子模块，取消注释下一行\n # submodules: true\n\n - name: 安装 pnpm\n uses: pnpm/action-setup@v2\n with:\n run_install: true\n version: 10.5.2 # 指定 pnpm 版本，可以修改为最新的稳定版本\n\n - name: 设置 Node.js\n uses: actions/setup-node@v3\n with:\n node-version: 20\n cache: pnpm\n\n\n - name: 构建文档\n env:\n NODE_OPTIONS: --max_old_space_size=8192\n run: |-\n pnpm run docs:build\n > src/.vuepress/dist/.nojekyll\n\n - name: 部署文档\n uses: JamesIves/github-pages-deploy-action@v4\n with:\n branch: gh-pages\n folder: src/.vuepress/dist打开网站终端（终端所在路径需要在网站当中），输入如下命令：
\ngit init # 初始化仓库\ngit add . # . 代表添加所有文件夹、文件\ngit commit -m \"first commit\" # \"first commit\" 可以随便改，代表本次做了哪些修改，做个备注。不改，一直用这个也是可以的。\ngit branch -M main\ngit remote add origin git@github.com:huangjiarongbao/huangjiarongbao.github.io.git # 用你自己的，每个 GitHub 都有自己的 \ngit push -u origin main一条一条执行命令，即可。提交成功参考：
\n(base) ➜ WebSite git init\nInitialized empty Git repository in /Users/huangjiabao/Desktop/WebSite/.git/\n(base) ➜ WebSite git:(main) ✗ git add .\n(base) ➜ WebSite git:(main) ✗ git commit -m \"first commit\"\n[main (root-commit) 2051f89] first commit\n 47 files changed, 5661 insertions(+)\n create mode 100644 .DS_Store\n create mode 100644 .github/workflows/deploy-docs.yml\n create mode 100644 .gitignore\n create mode 100644 package.json\n create mode 100644 pnpm-lock.yaml\n create mode 100644 src/.vuepress/config.ts\n create mode 100644 src/.vuepress/navbar.ts\n create mode 100644 src/.vuepress/public/CNAME\n create mode 100644 src/.vuepress/public/assets/icon/apple-icon-152.png\n create mode 100644 src/.vuepress/public/assets/icon/chrome-192.png\n create mode 100644 src/.vuepress/public/assets/icon/chrome-512.png\n create mode 100644 src/.vuepress/public/assets/icon/chrome-mask-192.png\n create mode 100644 src/.vuepress/public/assets/icon/chrome-mask-512.png\n create mode 100644 src/.vuepress/public/assets/icon/guide-maskable.png\n create mode 100644 src/.vuepress/public/assets/icon/ms-icon-144.png\n create mode 100644 src/.vuepress/public/assets/images/cover1.jpg\n create mode 100644 src/.vuepress/public/assets/images/cover2.jpg\n create mode 100644 src/.vuepress/public/assets/images/cover3.jpg\n create mode 100644 src/.vuepress/public/favicon.ico\n create mode 100644 src/.vuepress/public/logo.png\n create mode 100644 src/.vuepress/public/logo.svg\n create mode 100644 src/.vuepress/sidebar.ts\n create mode 100644 src/.vuepress/styles/config.scss\n create mode 100644 src/.vuepress/styles/index.scss\n create mode 100644 src/.vuepress/styles/palette.scss\n create mode 100644 src/.vuepress/theme.ts\n create mode 100644 src/README.md\n create mode 100644 src/demo/README.md\n create mode 100644 src/demo/disable.md\n create mode 100644 src/demo/encrypt.md\n create mode 100644 src/demo/layout.md\n create mode 100644 src/demo/markdown.md\n create mode 100644 src/demo/page.md\n create mode 100644 src/intro.md\n create mode 100644 src/posts/apple/1.md\n create mode 100644 src/posts/apple/2.md\n create mode 100644 src/posts/apple/3.md\n create mode 100644 src/posts/apple/4.md\n create mode 100644 src/posts/banana/1.md\n create mode 100644 src/posts/banana/2.md\n create mode 100644 src/posts/banana/3.md\n create mode 100644 src/posts/banana/4.md\n create mode 100644 src/posts/cherry.md\n create mode 100644 src/posts/dragonfruit.md\n create mode 100644 src/posts/strawberry.md\n create mode 100644 src/posts/tomato.md\n create mode 100644 tsconfig.json\n(base) ➜ WebSite git:(main) git branch -M main\n(base) ➜ WebSite git:(main) git remote add origin git@github-work:huangjiarongbao/huangjiarongbao.github.io.git\n(base) ➜ WebSite git:(main) git remote add origin git@github-work:huangjiarongbao/huangjiarongbao.github.io.git\n(base) ➜ WebSite git:(main) git push -u origin main\nEnumerating objects: 62, done.\nCounting objects: 100% (62/62), done.\nDelta compression using up to 10 threads\nCompressing objects: 100% (57/57), done.\nWriting objects: 100% (62/62), 591.97 KiB | 1.93 MiB/s, done.\nTotal 62 (delta 6), reused 0 (delta 0), pack-reused 0 (from 0)\nremote: Resolving deltas: 100% (6/6), done.\nTo github-work:huangjiarongbao/huangjiarongbao.github.io.git\n * [new branch] main -> main\nbranch 'main' set up to track 'origin/main'.\n(base) ➜ WebSite git:(main)\n\nTips：github-work 是我自己一台电脑，配置多个 SSH 的标记，无需 care。
\n
域名已经给出：https://huangjiarongbao.github.io/
\n使用 VScode 进行提交即可，点击 VScode 左侧的 git 管理按钮：
\n省略一张图片，
\ngit add . # . 代表添加所有文件夹、文件\ngit commit -m \"first commit\" # \"first commit\" 可以随便改，代表本次做了哪些修改，做个备注。不改，一直用这个也是可以的。\ngit push -u origin main先进到自己的 GitHub 仓库，点击 Action：
\nStep 1：访问阿里云域名解析网站：https://dnsnext.console.aliyun.com/authoritative
\nStep 2：点击：添加记录
\nStep 3：添加解析 1
\nStep 4：添加解析 2
\n上面完成了阿里云域名要做的，现在我们来完成 GitHub 要做的。
\nCNAME」在路径：src/.vuepress/public 下创建 CNAME 。
保存后，推送到 GitHub 仓库。
\n推送到 GitHub 后，会自动执行更新部署。
\n等待检测完成后，点击：
\n可以借助 AI 设计生成属于自己的网站 logo，并把 logo 放入 src/.vuepress/public。MacOS 记得使用快捷键：Command + Shift + 。 即可显示隐藏文件、文件夹。
接着我们需要在 VScode 中进行配置 logo，配置文件路径：src/.vuepress/theme.ts。
注意：在我们的网站当中，所有 / 代表从 public 开始。
也就是：/my-logo.png 其实网站会执行成：src/.vuepress/public/my-logo.png
一般我们所做的任何修改，Vuepress 主题都能自动热重载（重新加载运行，实在理解不了，可以理解成：自动重启。）但是在某些情况下：新建文章、修改侧边栏图标等情况下，最新的效果无法在网页上体现出来。此时，解决的方法就是：手动关闭和启动一下。
\n如果手动关闭与启动之后，问题依然存在。表明所做的修改存在问题，需要撤销修改，试一试别的。
\n要取消时，弹出的优惠
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n如果你是非技术背景，然后想转行到 AI 行业，现在在努力学 AI 的话，一定要 learn in public。什么叫 learn in public？就是你不仅要学，你还得让所有人都知道你在学，千万不要偷偷学。比如说你看到好的资料，可以给其他人共享这个资源，或者你用了一个好的 AI 产品，可以把你的感想分享到社交媒体。
\n为什么要这么做呢？因为我们现在在职场里不是学生了。你在学生时代，学完之后会有考试来检验你，但是你步入职场之后，学完之后如果没有人知道你学了，你就跟没有学一样。举个例子，如果你是文科商科背景，简历上没有任何 AI 相关的工作经验，但是你又想跳槽去 AI 公司，你怎么能跟你未来的雇主展示出你对 AI 技术的理解？怎么能展示出你是 AI 工具的深度使用者？怎么能展示出你甚至能自己开发出一些 AI 工具？
\n即使你花过无数个小时上网看各种 AI 课程，如果你没有输出的话，就跟没有学一样，因为根本没有人知道你学过，它也没有办法用一个可以展示的方式体现出来。但是如果你日常就有这种记录、分享输出的习惯，你就慢慢地能建立一个自己的个人品牌和 audience。包括你以后在面试求职的时候，你可以直接把你的作品发给你的面试官，这就是对你能力最好的展示。
\n其实内容是我们每个人在职场里的名片。
\n你怎么让你未来的老板知道你对一个行业和一个技术的理解？——就是靠这些作品。
\n并且这种输出的习惯也会驱使你更多的输入，就像费曼学习法说的，用输出来倒逼输入。当你有能力把一个东西给其他人讲明白的时候，这个东西你就真正的内化了，学会了。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n角色设定：你是一位精通Three.js、WebGL和计算机视觉的创意前端开发专家。\n任务：编写一个包含HTML、CSS和JavaScript的单文件应用。该应用需要结合 Three.js 和 MediaPipe Hands 来创建一个基于手势控制的3D粒子特效系统。\n要求：（此处大家根据想法扩展）\n参考以下内容\n#角色设定：\n你是一位精通Three.js、WebGL和视觉设计前端开发。\n##任务目标\n编写一个包含HTML、CSS和JavaScript的单文件应用。该应用需要结合 Three.js 和 MediaPipe Hands 来创建一个基于手势控制的3D粒子+照片云构成的圣诞树。\n##要求\n1、<整体内容:>\n-主色系:哑光绿 + 金属金+圣诞红色；\n-有电影感的辉光与光晕效果，整体金碧辉煌有高级感\n-圣诞树由 若干球、正方体、糖果棍和照片云等元素构成，照片通过上传获取。\n2、<交互逻辑和状态:>\n1、圣诞树状态\n- 合拢态（初始状态）：所有元素收拢、聚合为一个圣诞树圆锥体。\n- 散开态：所有元素在空间中无序漂浮、散落\n- 照片放大态：在背景保持散开态的同时，放大单张照片\n3、<手势动作:>\n- 握拳表示回到合拢态\n- 打开五指表示进入到散开态\n- 手旋转表示在散开态的状态下，对画面进行旋转，根据手的移动调整相机角度\n- 抓的动作表示抓住一张照片，进入照片放大态\n4、<交互要求:>\n需要根据手势，在几个状态之间平滑切换，带有过渡动画。\n##包括但不限于使用以下技术栈 Three.js、WebGL、instanced Mesh、Shaders / GLSL、MediaPipe Hands你好，我是悦创。
\n本教程适用于大部分 Sheerid 简单难度认证。
\n如果要方便，或者轻松。可以找我购买教育邮箱，添加微信：Jiabcdefh。
\n访问链接：https://accounts.psu.edu，并点击创建 CREATE MY ACCOUNT。
随便填写信息，除了邮箱正确之外其余可以随便乱填，然后一分钟你就拿到一个专门用于过 sheerid 的 @psu.edu 账号（无邮箱）
Personal Information - Part 2
\n会给你的邮箱发送验证码，自己查收填写：
\n勾选，并点击下一步即可：
\nSheerid 认证：以Google为例。
\n链接：https://gemini.google/students/
\n访问链接后，点击 Get offer：
\n按下面截图来填即可，最后的邮箱按照前面注册得到的邮箱来使用即可！
\n\n\n在 20+ 个 PSU 校区中随机选取一个即可，搜索出来一页都是 PSU，意味着你申请一个 PSU 可以用 20 多次。
\n
提示：名字生日随便乱填，邮箱填你刚才拿到的 @psu.edu 账号，然后继续完成 SSO流程：
AI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nbbb5969@psu.edu你好，我是悦创。
\n最近在短视频平台上无意刷到，Gemini3 实现手部动态跟踪的项目，效果图如下：
\n在线访问使用链接：https://gemini.bornforthis.cn/jarvis-holographic-ui/
\n学习编程相关，可以添加我。年底书籍上市，不一定只找我学私教。可以提前加入微信群，等待年底新书上市购买学习，以及诸多福利。
\n微信：Jiabcdefh
\n现在关注公众号：AI悦创，即可领取 31 天的梯子～
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n在开篇词我曾提到，大模型安全不是一个“选修课”，而是行业落地绕不开的必答题。那么在正式开始课程之前，我们不妨来简单测试一下你的 AI 产品 / 服务的“安全分”是多少。
\n我准备了十道题目，你可以记录一下每道题的选项，再结合最后的计分规则看看得了多少分。
\n第一题：你的企业正在准备将大模型部署到智能客服系统中，与用户进行直接交互。你希望对用户输入的提示内容做安全防护以避免触发模型违规响应。在提示词过滤机制上，你们的设计更接近哪种方式？
\nA. 模型内置关键词过滤系统，敏感词库通过人工定期维护，并可结合上下文关系做一定程度的模糊匹配。
\nB. 使用语义理解模型识别提示意图，覆盖多类变体表达，过滤规则较为通用，适配不同业务场景。
\nC. 构建了多层级提示词过滤机制，融合关键词、语义匹配与上下文语境分析，具备实时自更新能力。
\nD. 主要采用关键词过滤与规则模板判断，过滤范围明确，覆盖典型高风险场景，配置稳定性较强。
\n第二题：你们团队准备将大模型用于生成财务、人事、合规等敏感场景的文案。面对这些高风险任务，你们系统中的防护设计更接近哪种方式？
\nA. 系统通过接口识别当前业务类型，动态加载相关风控策略和输出模板。
\nB. 针对这些话题配置了统一的回答模板，避免生成自由扩展内容。
\nC. 模型在响应前对内容做规则评估，不区分业务语境，采用同一套输出规则。
\nD. 默认允许模型生成完整答案，只在出现指定关键词时触发屏蔽逻辑。
\n第三题：你注意到最近模型偶尔会出现短时间内的响应异常，比如延迟、崩溃或输出中断。你认为以下哪种做法最有助于识别并防范 Prompt DoS（提示词拒绝服务）攻击？
\nA. 我们建立了提示词行为画像，监控嵌套结构、提问频率与上下文突变，以识别可疑请求。
\nB. 我们设置了接口调用速率和响应时间阈值，只要超出即中断处理流程。
\nC. 我们使用关键词白名单与模型温度限制来降低生成不确定性，减少系统负载
\nD. 我们通过日志分析定位异常会话，对可疑账号追加冷却时间，并同时优化硬件配置提升稳定性。
\n第四题：你的团队希望模型具备一定的“越狱防护”能力，以避免用户通过提示词诱导模型输出本不该说的内容。以下哪种做法最具实效性，能主动识别此类绕过行为？
\nA. 引入关键词联动审查机制，并设置风险等级，超过阈值触发人工审核。
\nB. 通过正则表达式识别提示中是否包含绕过或角色扮演的暗示意图。
\nC. 使用多模态语义匹配 + 上下文语义一致性分析，识别提示是否试图“扮演第三方”以实现越权目标。
\nD. 在模型输出前强制追加“请勿违规输出”的系统提示词，以提醒模型保持中立和规范。
\n第五题：你的模型已经正式上线，公司要求对用户行为与模型响应过程保留审计日志，以便后续进行问题追踪与安全溯源。以下哪种做法最符合“可审计性”和“合规溯源”的安全要求？
\nA. 对用户输入提示词进行存档，但不记录模型响应内容，以节省存储。
\nB. 保留用户请求日志和部分模型响应片段，重要事件由人工截图存证。
\nC. 仅对高风险场景（如涉政、涉黄）记录日志，其余请求不做记录以保护隐私。
\nD. 对全部请求与响应进行结构化归档，并可结合时间戳、用户 ID 快速检索回溯。
\n第六题：你们的团队发现，当前大模型在处理一些行业术语和专业逻辑时，偶尔会生成编造的数据或张冠李戴的事实（即“幻觉”）。你希望建立一套机制来降低这类问题的风险。以下哪种做法在现阶段更具有实操性与安全防控效能？
\nA. 依赖用户反馈标记错误样例，并定期通过精调来修复模型行为。
\nB. 在模型输出阶段，加入基于规则与置信度阈值的内容过滤与二次确认机制。
\nC. 提前在预训练语料中加入更多真实资料，让模型“记牢”正确内容。
\nD. 允许模型输出自由生成内容，但在显著场景下添加免责声明即可规避风险。
\n第七题：你的团队负责上线后大语言模型的安全运营，现在已发布多个版本。在面对策略调整与模型更新时，哪种管理方式最能体现“动态安全能力”的理念？
\nA. 我们每个版本都配置有默认规则集，并允许业务团队进行参数微调来适配使用场景。
\nB. 目前团队稳定运行已有三个月，尚未遇到安全问题，因此暂未开启更新机制。
\nC. 每次迭代发布前，工程团队会参考历史数据回顾，必要时调整部分提示语与响应策略。
\nD. 模型版本发布流程中，默认嵌入安全策略回归、行为验证与审计流程，确保每次更新后的策略一致性与鲁棒性。
\n第八题：你所在的团队计划将大模型用于客户支持系统，模型将直接与外部用户交互。考虑到潜在的品牌舆情风险（如谈及竞品、公众人物等），你们主要采取哪类防控手段？
\nA. 设计了一套用于敏感话题绕开的通用回答模版，尽可能避免争议话题。
\nB. 将用户输入与模型输出同时纳入语义风险识别，构建品牌词和敏感对象的动态响应策略。
\nC. 设置品牌领域的专业问答数据微调模型，以确保内容更聚焦且符合品牌立场。
\nD. 结合提示词限制、用户画像分析和多轮对话上下文，制定适配的内容生成边界策略。
\n第九题：你的团队计划将大模型集成进智能问答平台，面向终端用户提供法律、财税等咨询服务。考虑到“答案可信度”和“可解释性”的重要性，你们目前在输出解释性方面采取了什么措施？
\nA. 模型输出后附带参考内容的来源链接与生成理由摘要。
\nB. 为所有高风险内容附加预警标识，并通过用户交互获取反馈。
\nC. 利用训练数据的来源信息构建文档索引供后台追溯，但前端不显示。
\nD. 将提示词与输出记录全部留档，便于内部内容溯源与后期优化。
\n第十题：你所在的企业已经上线了一个大模型问答平台，服务于客服、法务、财务等多个敏感业务场景。为确保系统在面对攻击性提示词、恶意上下文操控等威胁时的稳健性，你们目前采取了什么方式来开展安全评估？
\nA. 日常运营中由产品团队定期进行功能测试，发现问题后及时修复。
\nB. 建立了一套 QA 用例库，主要覆盖正常业务流程与基本异常场景。
\nC. 与业务部门协同开展用户测试，但未涉及提示词操控或越狱演练。
\nD. 定期组织红队对抗演练，并引入第三方安全机构进行外部评估。
\n这十道热身题，不是为了考核你，而是帮助你发现盲点。如果你愿意，我们接下来的课程将逐一解答这些问题，并带你完成一场从感知、识别到体系建设的安全进阶之旅。
\n\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n料酒是厨房去腥增香的常用调味品，但选择哪一种，却直接影响菜肴的最终风味。市面上不少料酒实为香辛料与劣质黄酒的勾兑产物，用于炒菜、拌馅或酱肉时，不仅难以去除腥气，有时甚至会带来酸涩等异味。
\n相比之下，花雕酒则是数千年黄酒文化的沉淀。它本是饮用之物，如著名的女儿红、状元红皆属此类。花雕酒遵循古法，选用粮食与鉴湖水，仅在冬季酿造一茬，酒香醇厚。入菜后能真正达到去腥增香的效果，且不留杂味。
\n作为一名业余“厨师”，我亲历了从使用大坛黄酒到专注于花雕酒的过程。尤其在粤菜烹饪中，花雕酒因其独特的焦糖香气备受青睐。
\n选择花雕酒亦有讲究。
\n我家常备的是一款五年陈酿，香气饱满，既可入菜，也可温热饮用，冬日小酌还有暖胃之效。一酒两用，既提升了菜肴层次，也增添了一份生活意趣。将普通料酒升级为花雕酒，无疑是提升烹饪水平的一个简单而有效的选择。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n时间复杂度是衡量一个算法执行效率的重要指标，它表示随着输入数据规模的增加，算法执行时间增长的速度。时间复杂度通常以大 O 记法表示，关注最坏情况的时间增长趋势。
\n以下是常见的时间复杂度类型及其对应的 Python 代码示例，涵盖了常见的操作和算法，帮助你更好地理解每种时间复杂度。
\n常数时间复杂度意味着无论输入数据的规模多大，算法的执行时间都不会改变。
\n示例：
\ndef constant_time_example(arr):\n return arr[0] # 只访问了第一个元素，时间复杂度是 O(1)\n\n# 示例\narr = [1, 2, 3, 4]\nprint(constant_time_example(arr))时间复杂度分析：该算法访问数组的第一个元素，操作次数不随数组大小变化，因此时间复杂度为 O(1)。
\n线性时间复杂度意味着算法的执行时间随着输入数据规模的增加而线性增长。
\n示例：
\ndef linear_time_example(arr):\n total = 0\n for num in arr: # 遍历数组每个元素\n total += num\n return total\n\n# 示例\narr = [1, 2, 3, 4, 5]\nprint(linear_time_example(arr))时间复杂度分析：算法需要遍历数组的每个元素，因此执行次数与数组的大小 n 成正比，时间复杂度为 O(n)。
\n平方时间复杂度通常出现在嵌套循环中，意味着算法的执行时间随着数据规模的增加呈平方增长。
\n示例：
\ndef quadratic_time_example(arr):\n for i in range(len(arr)):\n for j in range(len(arr)):\n print(arr[i], arr[j]) # 双重循环\n\n# 示例\narr = [1, 2, 3]\nquadratic_time_example(arr)时间复杂度分析：该算法包含两个嵌套的循环，每个循环都执行 n 次，因此时间复杂度为 O(n2)。
\n对数时间复杂度通常出现在递归算法中，例如二分查找。它表示算法的执行时间随数据规模的增加呈对数增长。
\n示例：
\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n\n# 示例\narr = [1, 2, 3, 4, 5, 6, 7, 8, 9]\ntarget = 5\nprint(binary_search(arr, target))时间复杂度分析：每次查找都将问题规模减半，因此时间复杂度为 O(log n)。
\n常见的 O(n log n) 时间复杂度出现在高效的排序算法中，例如归并排序、快速排序等。
\n示例（快速排序）：
\ndef quick_sort(arr):\n if len(arr) <= 1:\n return arr\n pivot = arr[len(arr) // 2]\n left = [x for x in arr if x < pivot]\n middle = [x for x in arr if x == pivot]\n right = [x for x in arr if x > pivot]\n return quick_sort(left) + middle + quick_sort(right)\n\n# 示例\narr = [3, 6, 8, 10, 1, 2, 1]\nprint(quick_sort(arr))时间复杂度分析：快速排序的时间复杂度是 O(n log n)，因为每次分割数组为两部分，然后对每部分递归排序，分割的过程是 O(log n)，每次分割需要处理 n 个元素。
\n指数时间复杂度通常出现在递归算法中，意味着算法的执行时间随着输入数据规模的增加呈指数增长。
\n示例（斐波那契数列）：
\ndef fibonacci(n):\n if n <= 1:\n return n\n return fibonacci(n-1) + fibonacci(n-2)\n\n# 示例\nprint(fibonacci(6))时间复杂度分析：斐波那契数列的递归算法的时间复杂度为 O(2n)，因为每个递归调用会生成两个子问题，递归树的大小以指数方式增长。
\n阶乘时间复杂度常出现在排列组合相关问题中，如暴力破解的排列问题。
\n示例（全排列）：
\nimport itertools\n\ndef generate_permutations(arr):\n return list(itertools.permutations(arr))\n\n# 示例\narr = [1, 2, 3]\nprint(generate_permutations(arr))时间复杂度分析：全排列的数量是 n!，即输入数据的所有可能排列组合，因此时间复杂度为 O(n!)。
\n| 时间复杂度类型 | 示例 | 时间复杂度分析 |
\n|
你好，我是悦创。
\nExcel 中的 IF 函数用于根据给定的条件返回不同的值。
IF(逻辑测试, 真值, 假值)| 参数 | 说明 |
\n|
你好，我是悦创。
\nExcel 中的 MID 函数用于从一个文本字符串的中间提取指定数量的字符。它的语法如下：
\nMID(text, start_num, num_chars)假设单元格 A1 的内容是 \"Excel1234\"，你想从第 6 个字符开始提取 4 个字符。
=MID(A1, 6, 4)结果：1234
如果 A2 中是 \"Hello World\"，你想提取从第 7 个字符开始的 5 个字符：
=MID(A2, 7, 5)结果：World
start_num 的位置是基于字符串的字符位置。start_num 超出了文本的总长度，或者 num_chars 的字符数超过了文本的剩余字符数，MID 会返回剩余的字符。这样，你可以根据需求灵活使用 MID 函数来提取不同位置的字符。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nTRIM 函数 用来删除文本中的多余空格，只保留单词之间的一个空格。
\n=TRIM(text)参数说明：
\n| 参数 | 说明 |
\n|
你好，我是悦创。
\n下面我来系统讲解 Excel 的 FIND 函数，并配上示例和练习思路。
\n功能： 在一个文本字符串中，查找指定字符或字符串首次出现的位置，并返回其位置（数字）。
\n\n\n✅ FIND区分大小写。
\n✅ 如果找不到目标字符，会返回错误值
\n#VALUE!
=FIND(find_text, within_text, [start_num])| 参数 | 说明 |
\n|
你好，我是悦创。
\n我来一步步教你认识并使用 Excel 的 LEFT 函数。
LEFT 函数用于从文本字符串的左侧开始，提取指定数量的字符。
=LEFT(text, [num_chars])| 参数 | 说明 |
\n|
\n\n豆角烧土豆焖饭 原料：五花肉 400 克，豆角 300 克，土豆 400 克，八角 2 克，桂皮 2 克，干辣椒 2 个，姜 5 克，大葱 20 克，花雕酒 20 克，酱油 50 克，开水 1.5 千克，盐 3 克，白胡椒粉 1 克，老抽 10 克，米饭 1 千克，葱花 10 克，白芝麻3克。
\n
| 五花肉 | 豆角 | 土豆 | 八角 | 桂皮 | 干辣椒 | 姜 | 大葱 |
\n|
你好，我是悦创。
\n为私教学员编写教程：
\n\nVLOOKUP 是 Excel 中非常常用的查找函数，用来纵向查找某个值，并返回同一行中其他列的数据。它的名字也来自于这个功能：Vertical Lookup（纵向查找）。
=VLOOKUP(lookup_value, table_array, col_index_num, [range_lookup])各参数解释如下：
\n| 参数 | 含义 | 示例 |
\n|
| 老豆腐 | 大蒜 | 大葱 | 小葱 | 洋葱 | 鸡蛋 |
\n|
This is a partner homework. You may complete it individually if you choose, but know that it was designed to be done in partnerships.
\nLate passes:
\nIf both partners have a late pass, you may turn in late with no questions asked/permission required.
\nIf one partner has a late pass and one does not, you may turn this work in up to 24 hrs late with no questions asked (formal extensions required for 48 hours).
\nIf no partners have late passes, a formal extension must be requested following the syllabus in the case of needing extra time.
\nPlease watch this video before you get started with the homework:
\nhttps://northeastern.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=178d4e3f-56ba-466f-85c9-b10f001d5a4a
Starter files:
\nData files:
\nTurn in these files:
\nsentiment_utils.pyThe following instructions are only written in this notebook but apply to all notebooks and .py files you submit for this homework.
Due date: October 22nd, 2025 @ 9:00 PM
\nPoints:
\nGoals:
\nComplete in groups of: two (pairs). If you prefer to work on your own, you may, but be aware that this homework has been designed as a partner project.
\nAllowed python modules:
\nnumpy, matplotlib, keras, pytorch, nltk, pandas, sci-kit learn (sklearn), seaborn, and all built-in python libraries (e.g. math and string)Instructions:
\nNames: YOUR NAMES HERE (Write these in every notebook you submit.)
\nIf you used AI tools (like ChatGPT, Claude, Gemini, Copilot, etc.) at any stage of your work, you must explicitly mention them and acknowledge their role. Please also state that you take full responsibility for the final content.
\nExample AI acknowledgment:
\n\"The author acknowledges the use of Claude AI (Anthropic) for assistance with content organization and executive summary structure. All final interpretations and conclusions remain the author’s responsibility.\"
\nList the resources you consulted to complete this homework here. Write one sentence per resource about what it provided to you. If you consulted no references to complete your assignment, write a brief sentence stating that this is the case and why it was the case for you.
\n(Example)
\nAnswer the following questions after you complete this assignment (no more than 1 sentence per question required, this section is graded on completion):
\nEvery time you use a data set in an NLP application (or in any software application), you should be able to answer a set of questions about that data. Answer these now. Default to no more than 1 sentence per question needed. If more explanation is necessary, do give it.
\nThis is about the provided movie review data set.
\nWhere did you get the data from? The provided dataset(s) were sub-sampled from https://www.kaggle.com/datasets/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews
\n\n\n数据来自Kaggle网站上的IMDB电影评论数据集，链接为：https://www.kaggle.com/datasets/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews
\n
(1 pt) How was the data collected (where did the people acquiring the data get it from and how)?
\n\n\n数据是从IMDB网站上收集的，评论者提供了对电影的评价和反馈，涵盖了不同种类的电影，数据通过网页抓取或通过API访问获取。
\n
(2 pts) How large is the dataset (answer for both the train and the dev set, separately)? (# reviews, # tokens in both the train and dev sets)
\n\n\n训练集包含1600条评论，验证集包含200条评论。
\n训练集和验证集的评论每条大致包含230到235个词汇。
\n训练集和验证集的词汇表大小分别为47,638和11,709，二者有7,245个词汇是重叠的。
\n
# 导入必要的库\nimport pandas as pd\n\n# 读取训练集和验证集文件\ntrain_file = 'movie_reviews_train.txt'\ndev_file = 'movie_reviews_dev.txt'\n\n# 读取数据\ntrain_data = pd.read_csv(train_file, sep='\\t', header=None, names=[\"ID\", \"Review\", \"Label\"])\ndev_data = pd.read_csv(dev_file, sep='\\t', header=None, names=[\"ID\", \"Review\", \"Label\"])\n\n# 计算训练集和验证集的评论数和每条评论的词汇数\ntrain_num_reviews = len(train_data)\ndev_num_reviews = len(dev_data)\n\n# 计算每条评论的词汇数\ntrain_token_counts = train_data['Review'].apply(lambda x: len(x.split()))\ndev_token_counts = dev_data['Review'].apply(lambda x: len(x.split()))\n\n# 计算训练集和验证集的词汇数量\ntrain_vocab_size = len(set(\" \".join(train_data['Review']).split()))\ndev_vocab_size = len(set(\" \".join(dev_data['Review']).split()))\n\n# 计算训练集和验证集的词汇表重叠\ntrain_vocab = set(\" \".join(train_data['Review']).split())\ndev_vocab = set(\" \".join(dev_data['Review']).split())\nvocab_overlap = len(train_vocab.intersection(dev_vocab))\n\n# 输出结果\ntrain_num_reviews, dev_num_reviews, train_token_counts.describe(), dev_token_counts.describe(), train_vocab_size, dev_vocab_size, vocab_overlap(1 pt) What is your data? (i.e. newswire, tweets, books, blogs, etc)
\n\n\n数据是关于电影的评论，属于影评数据集。
\n
(1 pt) Who produced the data? (who were the authors of the text? Your answer might be a specific person or a particular group of people)
\n\n\n数据的作者是 IMDB 网站上的用户（Lakshmipathi N、arunmohan_003、Co-learning Lounge），这些评论是由全球影迷和观众根据他们对电影的看法和评价写的。
\n
(2 pts) What is the distribution of labels in the data (answer for both the train and the dev set, separately)?
\n\n\n训练集和验证集的标签分布大致均衡。标签是二分类的（0 代表负面评价，1 代表正面评价），训练集和验证集的正负评价大致相同。
\n
因此，训练集和验证集的标签分布是大致均衡的。
\n# 计算训练集和验证集标签的分布\ntrain_label_distribution = train_data['Label'].value_counts()\ndev_label_distribution = dev_data['Label'].value_counts()\n\ntrain_label_distribution, dev_label_distribution(2 pts) How large is the vocabulary (answer for both the train and the dev set, separately)?
\n\n\n训练集的词汇表大小为 47,638。
\n验证集的词汇表大小为 11,709。
\n
# 重新计算独立词汇数量\ntrain_vocab_unique = set(\" \".join(train_data['Review']).split())\ndev_vocab_unique = set(\" \".join(dev_data['Review']).split())\n\n# 输出训练集和验证集的独立词汇表大小\nlen(train_vocab_unique), len(dev_vocab_unique)(1 pt) How big is the overlap between the vocabulary for the train and dev set?
\n\n\n训练集和验证集的词汇表之间有一定的重叠，约为 6132 左右，表示很多常见的词汇在两个数据集中都有出现。
\n
import nltk\nfrom nltk.tokenize import word_tokenize\nfrom collections import Counter\n\n# 下载punkt分词模型（如果尚未下载）\nnltk.download('punkt')\nnltk.download('punkt_tab')\n\n# 读取并分词的函数\ndef load_and_tokenize(file_path):\n with open(file_path, 'r', encoding='utf8') as file:\n reviews = file.readlines()\n # 提取评论文本（去除电影ID和评分）\n reviews_text = [line.split(\"\\t\")[1] for line in reviews if len(line.strip()) > 0]\n # 分词\n tokenized_reviews = [word_tokenize(review.lower()) for review in reviews_text]\n return tokenized_reviews\n\n# 读取并分词训练集和验证集的评论\ntrain_file_path = 'movie_reviews_train.txt' # 修改为您训练集的文件路径\ndev_file_path = 'movie_reviews_dev.txt' # 修改为您验证集的文件路径\n\ntrain_reviews = load_and_tokenize(train_file_path)\ndev_reviews = load_and_tokenize(dev_file_path)\n\n# 获取训练集和验证集的词汇表（唯一词汇）\ntrain_vocab = set([word for review in train_reviews for word in review])\ndev_vocab = set([word for review in dev_reviews for word in review])\n\n# 计算训练集和验证集词汇表之间的重叠\noverlap_vocab = train_vocab.intersection(dev_vocab)\noverlap_size = len(overlap_vocab)\n\n# 输出词汇重叠的大小\nprint(f\"词汇表重叠的大小: {overlap_size}\")# our utility functions\n# RESTART your jupyter notebook kernel if you make changes to this file\nimport sentiment_utils as sutils\n\n# Feel free to write code to help answer the above questionsUsing nltk's NaiveBayesClassifier class, train a Naive Bayes classifier using a Bag of Words as features.
You will be implementing binarized (presence/absence of word) and multinomial (counts of word) BoW representations of your data
\nLearn more about Naive Bayes here: https://www.nltk.org/_modules/nltk/classify/naivebayes.html
\nNaive Bayes classifiers use Bayes’ theorem for predictions. Naive Bayes can be a good baseline for NLP applications in particular. You can use it as a baseline for your project!
\n10 points in Task 5 will be allocated for all 9 graphs (including the one generated here in Task 4 for Naive Bayes Classifier) being:
\n# our utility functions\n# RESTART your jupyter notebook kernel if you make changes to this file\nimport sentiment_utils as sutils\n\n# nltk for Naive Bayes and metrics\nimport nltk\nimport nltk.classify.util\nfrom nltk.metrics.scores import (precision, recall, f_measure, accuracy)\nfrom nltk.classify import NaiveBayesClassifier\n\n# some potentially helpful data structures from collections\nfrom collections import defaultdict, Counter\n\n# so that we can make plots\nimport matplotlib.pyplot as plt\n# if you want to use seaborn to make plots\n#import seaborn as sns\n\n\n# define constants for the files we are using\nTRAIN_FILE = \"movie_reviews_train.txt\"\nDEV_FILE = \"movie_reviews_dev.txt\"\n\n\n# load in your data and make sure you understand the format\n# Do not print out too much so as to impede readability of your notebook\ntrain_tups = sutils.generate_tuples_from_file(TRAIN_FILE)\ndev_tups = sutils.generate_tuples_from_file(DEV_FILE)\n\n\n# set up a sentiment classifier using NLTK's NaiveBayesClassifier and \n# a bag of words as features\n# take a look at the function in lecture notebook 7 (feel free to copy + paste that function)\n# the nltk classifier expects a dictionary of features as input where the key is the feature name\n# and the value is the feature value\n\n# need to return a dict to work with the NLTK classifier\n# Possible problem for students: evaluate the difference \n# between using binarized features and using counts (non binarized features)\ndef word_feats(PARAMETERS ARE UP TO YOU) -> dict: \n # STUDENTS IMPLEMENT\n pass \n\n\n# set up & train a sentiment classifier using NLTK's NaiveBayesClassifier and\n# classify the first example in the dev set as an example\n# make sure your output is well-labeled\n\n\n\n# test to make sure that you can train the classifier and use it to classify a new exampleExpected Behavior
\nNaive Bayes:
\nNaive Bayes relies on word counts or feature frequencies to compute probabilities. Since it does not involve random initialization, it is a deterministic algorithm: meaning it will always produce identical results given the same data and preprocessing steps. So, if your Naive Bayes graphs are identical across runs, this is expected and completely fine!
Note on Training Data Increments
\nWhen varying the amount of training data, choose increments that are meaningful and reasonable, you should be able to observe clear trends without making the experiment unnecessarily long. You may increment the training data percentage by 5%, 10% or 20%.
\nMake sure that one of your experiments includes 10% of the training data, as you will need this result to answer a question in Task 5.
\n# Using the provided dev set, evaluate your model with precision, recall, and f1 score as well as accuracy\n# You may use nltk's implemented `precision`, `recall`, `f_measure`, and `accuracy` functions\n# (make sure to look at the documentation for these functions!)\n# you will be creating a similar graph for logistic regression and neural nets, so make sure\n# you use functions wisely so that you do not have excessive repeated code\n# write any helper functions you need in sentiment_utils.py (functions that you'll use in your other notebooks as well)\n\n\n# create a graph of your classifier's performance on the dev set as a function of the amount of training data\n# the x-axis should be the amount of training data (as a percentage of the total training data)\n# NOTE : make sure one of your experiments uses 10% of the data, you will need this to answer the first question in task 5\n# the y-axis should be the performance of the classifier on the dev set\n# the graph should have 4 lines, one for each of precision, recall, f1, and accuracy\n# the graph should have a legend, title, and axis labelsTest your model using both a binarized (bag of words representation where we put 1 [true] if the word is there and 0 [false] otherwise) and a multinomial (bag of words representation where we put the count of the word if the word occurs, and 0 otherwise). Use whichever one gives you a better final f1 score on the dev set to produce your graphs.
\nUsing sklearn's implementation of LogisticRegression, conduct a similar analysis on the performance of a Logistic Regression classifier on the provided data set.
Using the time module, you'll compare and contrast how long it takes your home-grown BoW vectorizing function vs. sklearn's CountVectorizer.
You will be implementing multinomial (counts of word) BoW representations of your data
\nLogistic regression is used for binary classification, but can be extended for multi-class classification
\nRead more about logistic regression here - https://www.analyticsvidhya.com/blog/2021/08/conceptual-understanding-of-logistic-regression-for-data-science-beginners/.
\nRecall from task 2 what binarized and multinomial mean here: a binarized bag of words representation is one where we put 1 [true] if the word is there and 0 [false] otherwise, and a multinomial bag of words representation is one where we put the count of the word if the word occurs, and 0 otherwise.
\n10 points in Task 5 will be allocated for all 9 graphs (including the one generated here in Task 3 for Logistic Regression) being:
\nfrom sklearn.linear_model import LogisticRegression\n# https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html\nfrom sklearn.feature_extraction.text import CountVectorizer\n\nfrom collections import Counter\nimport time\nimport sentiment_utils as sutils\n\n# define constants for the files we are using\nTRAIN_FILE = \"movie_reviews_train.txt\"\nDEV_FILE = \"movie_reviews_dev.txt\"\n\n# load in your data and make sure you understand the format\n# Do not print out too much so as to impede readability of your notebook\ntrain_tups = sutils.generate_tuples_from_file(TRAIN_FILE)\ndev_tups = sutils.generate_tuples_from_file(DEV_FILE)\n\n# some variables you may want to use\n# BINARIZED = True\n# USE_COUNT_VECTORIZER = False\n\n\n# Write the functions needed (here or in sentiment_utils.py) to create vectorized BoW representations\n# of your data. We recommend starting with a multinomial BoW representation.\n# Each training example should be represented as a sparse vector.\n\n\n# how much time does it take to featurize the all data with your implementation?\n\nstart = time.time()\n\n# YOUR CODE HERE\n\n\nend = time.time()\nprint(\"That took:\", end - start, \"seconds\")\n\n\n# how much time does it take to featurize the all data with sklearn's CountVectorizer?\n\nstart = time.time()\n\n\n# YOUR CODE HERE\n\nend = time.time()\nprint(\"That took:\", end - start, \"seconds\")CountVectorizer? YOUR ANSWER HERE# write any code you need analyze the relative sparsity of your vectorized representations of the data\n\n# YOUR CODE HERE\n\n# Print out the average % of entries that are zeros in each vector in the vectorized training data\n# YOUR CODE HEREExpected Behavior
\nLogistic Regression:
\nLogistic Regression can behave either deterministically or non-deterministically depending on whether random initialization is involved. On small datasets, results often converge to the same optimum, producing identical graphs. However, when a random seed affects initialization, minor variation may or may not appear between runs. Either case is acceptable!
Note on Training Data Increments
\nWhen varying the amount of training data, choose increments that are meaningful and reasonable, you should be able to observe clear trends without making the experiment unnecessarily long. You may increment the training data percentage by 5%, 10% or 20%.
\nMake sure that one of your experiments includes 10% of the training data, as you will need this result to answer a question in Task 5.
\n# Using the provided dev set, evaluate your model with precision, recall, and f1 score as well as accuracy\n# You may use nltk's implemented `precision`, `recall`, `f_measure`, and `accuracy` functions\n# (make sure to look at the documentation for these functions!)\n# you will be creating a similar graph for logistic regression and neural nets, so make sure\n# you use functions wisely so that you do not have excessive repeated code\n# write any helper functions you need in sentiment_utils.py (functions that you'll use in your other notebooks as well)\n\n\n# create a graph of your classifier's performance on the dev set as a function of the amount of training data\n# the x-axis should be the amount of training data (as a percentage of the total training data)\n# NOTE : make sure one of your experiments uses 10% of the data, you will need this to answer the first question in task 5\n# the y-axis should be the performance of the classifier on the dev set\n# the graph should have 4 lines, one for each of precision, recall, f1, and accuracy\n# the graph should have a legend, title, and axis labelsTest the following 4 combinations to determine which has the best final f1 score for your Logistic Regression model:
\nProduce your graph(s) for the combination with the best final f1 score.
\nNext, we'll train a feedforward neural net to work with this data. You'll train one neural net which takes the same input as your Logistic Regression model - a sparse vector representing documents as bags of words.
\nTake a look at these videos to understand forward and backward propagation in neural networks -
\n\nYou will be implementing binarized (presence/absence of word) and multinomial (counts of word) BoW representations of your data
\n10 points in Task 5 will be allocated for all 9 graphs (including the one generated here in Task 4 for Neural Networks) being:
\nimport sentiment_utils as sutils\nimport numpy as np\n\nfrom keras.models import Sequential\nfrom keras.layers import Dense\n\n# you can experiment with having some Dropout layers if you'd like to\n# this is not required\nfrom keras.layers import Dropout\n\n# if you want to use this again\nfrom sklearn.feature_extraction.text import CountVectorizer\n\n\n# define constants for the files we are using\nTRAIN_FILE = \"movie_reviews_train.txt\"\nDEV_FILE = \"movie_reviews_dev.txt\"\n\n# load in your data and make sure you understand the format\n# Do not print out too much so as to impede readability of your notebook\ntrain_tups = sutils.generate_tuples_from_file(TRAIN_FILE)\ndev_tups = sutils.generate_tuples_from_file(DEV_FILE)\n\n# you may use either your sparse vectors or sklearn's CountVectorizer's sparse vectors\n# you will experiment with multinomial and binarized representations later\n\n\n# Create a feedforward neural network model\n# that takes a sparse BoW representation of the data as input\n# and makes a binary classification of positive/negative sentiment as output\n# you may use any number of hidden layers >= 1 and any number of units in each hidden layer (we recommend between 50-200)\n# you may use any activation function on the hidden layers \n# you should use a sigmoid activation function on the output layer\n# you should use binary cross-entropy as your loss function\n# sgd is an appropriate optimizer for this task\n# you should report accuracy as your metric\n# you may add Dropout layers if you'd like to\n\n# create/compile your model in this cell\n\nmodel = Sequential()\n\n\n\n# put in an output layer\n\n\nmodel.summary()\n# call compile hereHow many trainable parameters does your model have? YOUR ANSWER HERE
\n# train your model\n\n\n# Failed to find data adapter that can handle input: <class 'numpy.ndarray'>, (<class 'list'> containing values of types {\"<class 'int'>\"})\n# indicates you should change a list into a numpy array\n\n# make a prediction on the dev set\n# then make a classification decision based on that prediction\n\n# use the model.evaluate function to report the loss and accuracy on the dev setExpected Behavior
\nNeural Networks:
\nNeural networks initialize their weights randomly and learn through iterative stochastic optimization, which introduces non-determinism by design. Even with the same data and parameters, different runs may lead to slightly different learned weights and therefore different graphs. In this case, variation between your three runs is expected and desired, it shows how the model’s training process can vary due to randomness.
Note on Training Data Increments
\nWhen varying the amount of training data, choose increments that are meaningful and reasonable, you should be able to observe clear trends without making the experiment unnecessarily long. You may increment the training data percentage by 5%, 10% or 20%.
\nMake sure that one of your experiments includes 10% of the training data, as you will need this result to answer a question in Task 5.
\n# create the same graph as with NB and LR, with your neural network model instead!\n# make sure to re-create your model each time you train it — you don't want to start with\n# an already trained network!\n\n# you should experiment with different numbers of epochs to see how performance varies\n# you need not create an experiment that takes > 10 min to run (gradescope will run out of computing resources and give you a 0)Report the f1 scores for your model with the following settings, using the same number of epochs to train in both cases:
\nSave your three graph files for the best configurations that you found with your models using the plt.savefig(filename) command. The bbox_inches optional parameter will help you control how much whitespace outside of the graph is in your resulting image.
NOTE ABOUT THE GRAPHS:
\nRun each notebook containing the best classifier three times, saving the output graphs separately each time. This should result in a total of NINE distinct graphs (three per notebook, e.g. for the three Naive Bayes model graphs you would have Naive_Bayes_run1.png, Naive_Bayes_run2.png, Naive_Bayes_run3.png, etc.). Ensure you do not overwrite previous graphs when you save the graphs as images.
\nThe goal of running the notebook three times is to check if your model's performance is consistent, confirming that your results are reliable and not due to randomness.
\nIf all your graphs look identical, remove the random seed parameter (for logistic regression) and re-run the notebook. The absence of a seed might introduce variation between runs.
\nShould the graphs remain identical even after removing the seed, you may proceed with submitting the three identical graphs for the model.
\nRepeat this process for each of the three notebooks.
\nYou will turn in all of these files.
\nAdditional Clarifications
\nNaive Bayes:
\nNaive Bayes relies on word counts or feature frequencies to compute probabilities. Since it does not involve random initialization, it is a deterministic algorithm: meaning it will always produce identical results given the same data and preprocessing steps. So, if your Naive Bayes graphs are identical across runs, this is expected and completely fine!
Logistic Regression:
\nLogistic Regression can behave either deterministically or non-deterministically depending on whether random initialization is involved. On small datasets, results often converge to the same optimum, producing identical graphs. However, when a random seed affects initialization, minor variation may or may not appear between runs. Either case is acceptable!
Neural Networks:
\nNeural networks initialize their weights randomly and learn through iterative stochastic optimization, which introduces non-determinism by design. Even with the same data and parameters, different runs may lead to slightly different learned weights and therefore different graphs. In this case, variation between your three runs is expected and desired, it shows how the model’s training process can vary due to randomness.
Note on Training Data Increments
\nWhen varying the amount of training data, choose increments that are meaningful and reasonable, you should be able to observe clear trends without making the experiment unnecessarily long. You may increment the training data percentage by 5%, 10% or 20%.
\nMake sure that one of your experiments includes 10% of the training data, as you will need this result to answer a question in Task 5.
\n10 points in this section are allocated for all 9 graphs being:
\n## YOUR CODE\n\n## Please insert filepaths to the 9 plot images you created with your code below\nimport matplotlib.image as mpimg\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfig, axs = plt.subplots(3, 3, figsize=(10, 10))\n\nplaceholder_paths = [\n \"path/to/image1.png\", \"path/to/image2.png\", \"path/to/image3.png\", ## paths for the three Naive Bayes model graphs\n \"path/to/image4.png\", \"path/to/image5.png\", \"path/to/image6.png\", ## paths for the three Logistic Regression model graphs\n \"path/to/image7.png\", \"path/to/image8.png\", \"path/to/image9.png\" ## paths for the three Neural Network model graphs\n]\n\nfor i, ax in enumerate(axs.flat):\n try:\n img = mpimg.imread(placeholder_paths[i])\n ax.imshow(img)\n except FileNotFoundError:\n ax.text(0.5, 0.5, f\"Missing Image\\n{placeholder_paths[i]}\", \n ha='center', va='center', fontsize=12, color='red')\n ax.set_facecolor('lightgray')\n ax.set_title(f\"Image {i+1}\")\n\n ax.set_xticks([]) \n ax.set_yticks([]) \n\nplt.tight_layout()\nplt.show()# FIRST: RENAME THIS FILE TO sentiment_utils.py \n\n# YOUR NAMES HERE:\n\n\n\"\"\"\n\nCS 4120\nHomework 4\nFall 2025\n\nUtility functions for HW 4, to be imported into the corresponding notebook(s).\n\nAdd any functions to this file that you think will be useful to you in multiple notebooks.\n\"\"\"\n# fancy data structures\nfrom collections import defaultdict, Counter\n# for tokenizing and precision, recall, f_measure, and accuracy functions\nimport nltk\n# for plotting\nimport matplotlib.pyplot as plt\n# so that we can indicate a function in a type hint\nfrom typing import Callable\nnltk.download('punkt')\n\ndef generate_tuples_from_file(training_file_path: str) -> list:\n \"\"\"\n Generates data from file formated like:\n\n tokenized text from file: [[word1, word2, ...], [word1, word2, ...], ...]\n labels: [0, 1, 0, 1, ...]\n \n Parameters:\n training_file_path - str path to file to read in\n Return:\n a list of lists of tokens and a list of int labels\n \"\"\"\n # PROVIDED\n f = open(training_file_path, \"r\", encoding=\"utf8\")\n X = []\n y = []\n for review in f:\n if len(review.strip()) == 0:\n continue\n dataInReview = review.strip().split(\"\\t\")\n if len(dataInReview) != 3:\n continue\n else:\n t = tuple(dataInReview)\n if (not t[2] == '0') and (not t[2] == '1'):\n print(\"WARNING\")\n continue\n X.append(nltk.word_tokenize(t[1]))\n y.append(int(t[2]))\n f.close() \n return X, y\n\n\n\"\"\"\nNOTE: for all of the following functions, we have provided the function signature and docstring, *that we used*, as a guide.\nYou are welcome to implement these functions as they are, change their function signatures as needed, or not use them at all.\nMake sure that you properly update any docstrings as needed.\n\"\"\"\n\n\ndef get_prfa(dev_y: list, preds: list, verbose=False) -> tuple:\n \"\"\"\n Calculate precision, recall, f1, and accuracy for a given set of predictions and labels.\n Args:\n dev_y: list of labels\n preds: list of predictions\n verbose: whether to print the metrics\n Returns:\n tuple of precision, recall, f1, and accuracy\n \"\"\"\n #TODO: implement this function\n pass\n\ndef create_training_graph(metrics_fun: Callable, train_feats: list, dev_feats: list, kind: str, savepath: str = None, verbose: bool = False) -> None:\n \"\"\"\n Create a graph of the classifier's performance on the dev set as a function of the amount of training data.\n Args:\n metrics_fun: a function that takes in training data and dev data and returns a tuple of metrics\n train_feats: a list of training data in the format [(feats, label), ...]\n dev_feats: a list of dev data in the format [(feats, label), ...]\n kind: the kind of model being used (will go in the title)\n savepath: the path to save the graph to (if None, the graph will not be saved)\n verbose: whether to print the metrics\n \"\"\"\n #TODO: implement this function\n pass\n\n\n\ndef create_index(all_train_data_X: list) -> list:\n \"\"\"\n Given the training data, create a list of all the words in the training data.\n Args:\n all_train_data_X: a list of all the training data in the format [[word1, word2, ...], ...]\n Returns:\n vocab: a list of all the unique words in the training data\n \"\"\"\n # figure out what our vocab is and what words correspond to what indices\n #TODO: implement this function\n pass\n\n\ndef featurize(vocab: list, data_to_be_featurized_X: list, binary: bool = False, verbose: bool = False) -> list:\n \"\"\"\n Create vectorized BoW representations of the given data.\n Args:\n vocab: a list of words in the vocabulary\n data_to_be_featurized_X: a list of data to be featurized in the format [[word1, word2, ...], ...]\n binary: whether or not to use binary features\n verbose: boolean for whether or not to print out progress\n Returns:\n a list of sparse vector representations of the data in the format [[count1, count2, ...], ...]\n \"\"\"\n # using a Counter is essential to having this not take forever\n #TODO: implement this function\n passAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n相关信息
\nRecall that the final exam will be performed in the lab using the lab computers. If you have never logged into the lab computers before, you must try to do so successfully in advance, such as in your weekly labs. Otherwise, you may experience some important delays the day of the exam in order to be able to login into the lab computers. We will NOT consider this as a reason to extend your exam beyond the established 3 hours and 15 minutes.
\nThis lab contains some examples of the types of problems you may encounter on the final exam. The exam will in general cover all topics covered in lectures and labs, for example, to check your ability to (but not limited to):
\nProblems are presented in no particular order. Don't assume that the first is easier than the second, and so on.
\nTutors will be busy talking with students about the project assignment during week 11, but you can ask them during week 12 if you have any questions.
\nGood code quality is essential for a successful development of a large program. Aspects of good code quality include: good docstrings/comments, good variable/function names, good code organisation, and code efficiency (when necessary). In the following you will exercise how to improve the quality of certain code.
\nThe following function splits a string into a list of substrings, where each substring consists of only letters, and returns the list. For example: my_func(\"hello everONE 12 hh3\") returns ['hello', 'everONE', 'hh'].
def my_func(astring):\n l = []\n s = \"\"\n for i in range(len(astring)):\n if \"a\" <= astring[i] <= \"z\": # lower-case letter\n s = s + astring[i]\n # do special thing with first element\n if i == len(astring)-1:\n l = l+[s]\n elif \"A\" <= astring[i] <= \"Z\": # character is a number\n s = s + astring[i]\n # do special thing with first element\n if i == len(astring)-1:\n l = l+[s]\n else:\n # upper-case letter\n if len(s) == 0:\n i = i-1+1\n else:\n l=l+[s]\n \n s=\"\" # set s to empty string\n return lDescribe all distinct ways in which the quality of the code above can be improved without affecting to its functional correctness.
\nTo gain marks, your suggested improvements must be specific. For example, if you think that naming should be improved, you must give at least one specific example of which names should be changed and to what; just answering \"better names\" is not enough. Do not simply write your suggested improvements as comments inside the function. Writing a new function or rewriting the function is not an acceptable answer, regardless of whether it is correct or not.
\n针对给定 my_func(astring)，在不改变功能的前提下，可改进之处（具体）：
函数名与文档
\n将 my_func 改为更语义化的 split_alpha_runs。
添加清晰 docstring：说明参数/返回值/示例与边界（空串、全非字母、混合等）。
\n变量命名
\nl → parts（避免与内置 list 混淆，且表达含义）。s → current（当前累计子串）。i → idx（提升可读性）。去除重复逻辑
\n两段完全相同的拼接代码：
\nif \"a\" <= astring[i] <= \"z\": ...\nelif \"A\" <= astring[i] <= \"Z\": ...可以先用统一的字母判断，减少重复分支；例如使用 str.isalpha()（功能等价，且覆盖非英文字母会改变行为——若必须保持仅 A–Z/a–z，可用 ('a'<=ch<='z') or ('A'<=ch<='Z') 封装成 _is_ascii_alpha(ch) 辅助函数）。
边界处理位置
\nif i == len(astring)-1: l = l+[s] 在循环内部多处收尾；更好的方式是循环结束后统一判断 current 非空再追加一次，减少分支与重复。if len(s) == 0:\n i = i-1+1对逻辑无任何效果（死代码），应删除。
\n效率
\nl = l + [s] 会创建新列表，建议改为 parts.append(current)。s = s + astring[i] 每次复制字符串，建议使用 list 收集字符后 ''.join()，或保留但可接受（输入通常较短）。注释准确性
\n注释与代码不符
\n# character is a number 写在了大写字母分支上；# upper-case letter 出现在 else 分支。需修正注释，使注释与逻辑一致。
\n避免魔法数字/表达式重复
\nlen(astring) 多次调用，可在循环前存入 n = len(astring)。类型与输入健壮性（可选）
\nif not isinstance(astring, str): raise TypeError(...)（若课程风格允许）。\n\n小结：主要集中在命名、重复逻辑合并、边界统一收尾、注释改正、append 替代拼接与删除死代码。
\n
In a sequence of numbers, we say that there is a peak at index i if the value at i is greater than both the neighbouring values, at i-1 and at i+1. The first and last number in the sequence are also peaks, if they are greater than their one neighbouring value. For example, in the sequence
\n[13.0, 9.6, 14.2, 17.5, 8.9, 9.7, 15.7, 20.4, 14.8, 13.2, 13.6, 15.6, 17.9, 24.1, 19.2]
\nthere are peaks at indices 0 (because 13.0 > 9.6), 3 (because 14.2 < 17.5 > 8.9), 7 (because 15.7 < 20.4 > 14.8) and 13 (because 17.9 < 24.1 > 19.2).
The following function takes as argument a numeric sequence and returns average distance between all the peaks in it. The distance between two peaks at indices i and j is defined as abs(i-j).
def my_func(s):\n x = [] # sets x to empty list\n for i in range(len(s)):\n if i - 1 >= 0 and i + 1 < len(s):\n if s[i] > s[i-1] and s[i] > s[i+1]:\n x.append(i)\n elif i - 1 >= 0 and i + 1 >= len(s):\n # i is the first element\n if s[i] > s[i-1]:\n x.append(i)\n elif i - 1 < 0 and i + 1 < len(s):\n # i is the last element\n if s[i] > s[i+1]:\n x.append(i)\n if len(x) < 2:\n return 0.0\n else:\n count = 0\n t = 0\n for i in range(len(x)):\n for j in range(i + 1, len(x)):\n count += 1\n t += abs(x[i] - x[j])\n return t / countDescribe all distinct ways in which the quality of the code above can be improved without affecting to its functional correctness.
\nTo gain marks, your suggested improvements must be specific. For example, if you think that naming should be improved, you must give at least one specific example of which names should be changed and to what; just answering \"better names\" is not enough. Do not simply write your suggested improvements as comments inside the function. Writing a new function or rewriting the function is not an acceptable answer, regardless of whether it is correct or not.
\n针对“峰值平均距离”函数：
\n函数与变量命名
\nmy_func → average_peak_distances → seq；x → peak_indices；t → total_distance；count → pair_count。注释与分支语义修正
\nelif i - 1 >= 0 and i + 1 >= len(s):\n # i is the first element # ❌ 实为“最后一个元素”\nelif i - 1 < 0 and i + 1 < len(s):\n # i is the last element # ❌ 实为“第一个元素”需把注释改正，避免误导。
\n边界判断更清晰
\ni == 0：检查 s[0] > s[1]（长度>1时）；i == n-1：检查 s[n-1] > s[n-2]；空与长度为 1 的输入：现在若 len(s)==1，循环中不会添加峰值，返回 0.0；与定义（“首尾也算峰，如果比唯一邻居大”）一致，但单元素按常见约定通常也可视为峰（因无邻居）。这里至少应在 docstring 中明确约束或在代码顶端特判：长度 1 → 峰数 <2 则返回 0.0（与现实现一致）。
复杂度与实现：寻找峰值 O(n)；平均距离双重循环 O(p²)（p 为峰个数）。如需要提升效率，可仅统计两两距离和的等价线性公式（对有序下标 x[0..p-1]，
\nsum_{i<j} (x[j]-x[i]) = Σ_j (2j-p+1)*x[j]），把 O(p²) 降为 O(p)。若不改变功能，此为可选优化建议。
一致的返回类型与浮点除法：当前 t / count 在 Python3 为浮点除法，返回 float，符合题意。为明确可写 return float(total_distance) / pair_count。
避免重复 len(s) 计算：赋值 n = len(s)，统一使用。
Docstring 完善：指明：输入要求（数值序列）、返回定义（无或一个峰 → 返回 0.0）、复杂度与示例。
\nTesting is an important skill. Software testers usually need to think about designing a small enough set of good test cases that still cover a large spectrum of parameters to ensure that the code runs correctly for most or all parameters. In the following you will exercise how to carefully design good test cases for some function without even knowing the code of the function.
\nWe want to write tests for a function with signature and docstring defined as follows:
\ndef smallest_non_negative(number_list):\n \"\"\"\n Argument is a list of numeric values (integer or float).\n Returns the smallest non-negative value in the list,\n and zero if there is no such value.\n \"\"\"Write at most 4 test cases for this function (every test case after the first four will be ignored). For each test case, you must write down the input (argument to the function) and the expected return value. Each test case should specify valid arguments for the function (e.g., an input list with elements of different types is not a valid argument). Your test cases should cover relevant corner cases.
\n最多 4 个用例，覆盖：无非负、含 0、多浮点、重复与顺序。
\n[-5, -1, -0.1] → 期望：0（无非负）[0, 3, 2, 0.5] → 期望：0（最小非负为 0）[1.2, 3.4, 0.1, 0.1] → 期望：0.1（浮点&重复）[5, 2, 3, 4] → 期望：2（最小正数）We want to write tests for a function with signature and docstring defined as follows:
\ndef sequence_similarity(s1, s2)\n \"\"\"\n s1 and s2 are two sequences of the same length.\n Returns the number of i-th elements that are equal \n between two sequences, i.e., where s1[i] == s2[i]\n \"\"\"Write at most 4 test cases for this function (every test case after the first four will be ignored). For each test case, you must write down the input (argument to the function) and the expected return value. Each test case should specify valid arguments for the function (e.g., an input list with elements of different types is not a valid argument). Your test cases should cover relevant corner cases.
\n覆盖：全等、全不等、空序列、含不同类型但可比较。
\n([1,2,3], [1,2,3]) → 期望：3([1,2,3], [3,2,1]) → 期望：1（仅中间相等）([], []) → 期望：0(('a','b','c'), ('a','x','c')) → 期望：2For a sequence of strings and an integer k, we want to find a substring of length k that is common to the most strings and must occur at least twice. For example, for the sequence ['honestness', 'honestly', 'dishonest', 'fairly'] and k=6, the answer is 'honest' because it appears in 3 strings and no substring of length 6 appears in all 4 strings. For the same list of strings and k=5, the answer is 'hones' or onest. When there is more than one solution like this, it is OK to report one of them. For k=7, the answer is '' (empty string) because there is no substring of length 7 that occurs in 2 or more strings.
Here is a function with its docstring which aims to implement this:
\ndef most_common_substr(seq_strings, k):\n \"\"\"\n seq_strings is a sequence of strings with at least 2 elements.\n k is a positive integer.\n Returns a string of length exactly k which appears as a \n sub-string in the most elements of seq_strings. \n If no substrings of length k exist in 2 or more elements \n of seq_strings, the empty string is returned.\n If two or more substrings of length k appear in the same number \n of elements of seq_strings only one will be returned. \n \"\"\"Write at most 5 test cases for this function (every test case after the first four will be ignored). For each test case, you must write down the input (argument to the function) and the expected return value. Each test case should specify valid arguments for the function (e.g., an input list with elements of different types is not a valid argument). Your test cases should cover relevant corner cases.
\n题干已有示例，接着补全覆盖：无解、唯一解、并列解、大小写/重复、边界 k=1。
\n(['honestness','honestly','dishonest','fairly'], 7) → 期望：''（无长度 7 的公共子串≥2 次）(['ababa','babab','aba'], 3) → 期望：'aba' 或 'bab'（并列解，返回其一）(['xxx','xx','xxxx'], 2) → 期望：'xx'（出现于 3 个字符串）(['a','b','c','a'], 1) → 期望：'a'（最常见字符，出现 2 次）\n\n说明：若判题需要唯一答案，应在说明中接受“任一并列最优”。
\n
Debugging is also an important skill. In a complex software, developers may find themselves spend more time to find mistakes in their codes than writing them in the first place. In the following you will exercise how to find errors and bugs in prewritten codes.
\nWe call a dictionary invertible if every key in it maps to a unique value, or in other words, for every value appearing in the dictionary, there is only one key that maps to that value. Below are three attempts to define a function is_invertible(adict), which takes as argument a dictionary and returns True if the dictionary is invertible, and False otherwise.
For example, is_invertible({ 'a' : 'b', 'b' : 'e', 'c' : 'f' }) should return True, but is_invertible({ 'a' : 'b', 'b' : 'e', 'c' : 'b' }) should return False, because keys 'a' and 'c' both map to the same value, 'b'.
For each of the functions below, determine whether it is correct or not. Correct mean that the function runs without error and returns the right answer for any dictionary. If a function is not correct, explain precisely what is wrong with it.
\n(a)
\ndef is_invertible(adict):\n return sorted(adict.keys()) == sorted(adict.values())(b)
\ndef is_invertible(adict):\n d = {}\n for value in adict.values():\n if value in d:\n return False\n else:\n d[value] = 1\n return True(c)
\nNote: This implementation of the function uses another function, make_inv_dict, which is also defined below.
def is_invertible(adict):\n inv_dict = make_inv_dict(adict)\n return adict == inv_dict\n\ndef make_inv_dict(adict):\n if len(adict) > 0:\n key, val = adict.popitem()\n adict = make_inv_dict(adict)\n if val not in adict.values():\n adict[key] = val\n return adict\n else:\n return {}(a) return sorted(adict.keys()) == sorted(adict.values())
错误：把“键集合排序”与“值集合排序”比较。可逆要求“值不重复”（值集合大小等于键集合大小），而不是“键的多重集与值的多重集相同”。反例：{'a':1,'b':2}可逆，但键排序 ['a','b'] 与值排序 [1,2] 不相等。
(b) 正确。逻辑：遍历所有值，若某值已出现过则重复→不可逆；否则记录。返回 True。当值是可哈希时成立（题设默认字典键/值常用可哈希类型）。时间 O(n)、空间 O(n)。
\n(c) 错误，且有两点：
\nmake_inv_dict 使用 popitem() 就地修改了入参 adict，破坏原字典；调用后 adict 被清空或改变。is_invertible 返回 adict == inv_dict 比较原字典与**“去重值”字典是否相等，而可逆性的充分必要条件并非两者相等（它试图构造“值不重复”的子字典，但比较对象错误）。此外，若存在重复值，inv_dict 会丢掉**其中一个键（因为 if val not in adict.values(): adict[key] = val 这段逻辑也混淆了“键/值空间”——这里 adict 在递归后成了“剩余键到值”的映射，val not in adict.values() 不能保证唯一映射构造的正确性）。Here is a function that takes as argument a sequence:
\ndef funX(a_list):\n index = 0\n while index < len(sorted(a_list)) // 2:\n index = index + 1\n return sorted(a_list)[index](a) Explain what funX does in general. A good answer is one that describes the purpose of the function - something you would write in its docstring.
(b) funX is unnecessarily inefficient. Rewrite the function so that it does the same thing, but as efficiently as possible.
(a) 作用
\n返回已排序后序列中索引为 len(s)//2 的元素（上中位数；若长度偶数，取右侧那个；若奇数，取中位数）。
(b) 更高效写法（去冗余排序与无意义循环）
\ndef funX(a_list):\n s = sorted(a_list)\n return s[len(s)//2]\n\n原函数做了两次
\nsorted(a_list)且用 while 做“数到一半”的自增，都是冗余。
Here is another function that takes a sequence as argument:
\ndef funY(x):\n i = 0\n while i < len(x):\n i = i + x[i] % len(x)\n return i(a) Give an example, if possible, of an argument sequence that causes funY to get stuck in an infinite loop, as well as an argument sequence for which the function executes without error and returns a value.
(b) What are the runtime errors that can occur in funY, assuming the argument is of type list? For each error, give an example of an argument list that causes the error.
def funY(x):\n i = 0\n while i < len(x):\n i = i + x[i] % len(x)\n return i(a)
\n[0]（len=1，x[0]%1==0，i 始终为 0）；或 [2, 1]（len=2，起点 i=0，x[0]%2==0，停在 0）。[1,1,1]（依次跳 1、2、3，最后返回 3）。(b) 可能的运行时错误
\nZeroDivisionError：空列表 []，因为 len(x)==0，取模除以 0。TypeError：元素非数值、不可与 int 取模，例如 ['a']。IndexError：因为 i < len(x) 时才取 x[i]，且 i 的更新使用 % len(x)，结果在 [0, len-1] 之间，不会越界。但若把 % len(x) 移除就可能。)A strictly increasing consecutive subsequence is a part of a sequence in which every element is strictly greater than the previous element. Because \"strictly increasing consecutive subsequence\" is a bit long, we will call this a streak. For example, in the sequence (1,5,2,4,7,2), the subsequences (1,5) and (2,4,7) are streaks. (Of course, by definition, any subsequence of a streak is also a streak.) (2,4,7) is the longest streak among all streaks of that input sequence.
Below is a function that takes as argument a sequence of numbers, and it aims to return the length of the longest streak of the input sequence:
\ndef longest_streak(seq):\n i=0\n counter=1\n narray=[]\n #base case\n if len(seq)==0:\n return(0)\n while i < len(seq)-1:\n if seq[i] < seq[i+1]:\n counter=counter+1\n i=i+1\n else:\n narray.append(counter)\n counter=1\n i=i+1\n if len(narray)==0:\n return(counter)\n else:\n return(max(narray))However, the function above is not correct.
\n(a) Provide an example of argument, of correct types, that makes this function return the wrong answer or that causes a runtime error. The argument must be a sequence of numbers.
\n(b) Explain the cause of the error that you have found, i.e., what is wrong with this function. Your answer must explain what is wrong with the function as given. Writing a new function is not an acceptable answer, regardless of whether it is correct or not.
\n(a) 反例
\n[1, 2, 0, 1, 2, 3]。
正确答案应为 4（子序列 0,1,2,3），而给定函数返回 2 或 3（取决于数据），因为最后一段递增 streak 未被加入 narray。
(b) 原因说明
\n循环在遇到“非递增”时把当前 counter 追加到 narray，但当序列以递增结束时，最后一个递增 streak 没有被 append。函数结束后若 narray 非空，则直接取 max(narray)，从而忽略了可能更长的末尾 streak。应在循环结束后再做一次 narray.append(counter) 或单独比较末尾 counter。
Simplify the following big O expressions as much as possible:
\nGiven the following function definition statement:
\ndef elements_at_even_index(seq):\n result=[]\n for i in range(len(seq)): \n if i%2==0:\n result.append(seq[i])\n return seqWrite down the time complexity in big-O notation as a function of n being the number of elements in seq. Explain the reason why. Correct answers without any explanation will not receive marks.
\nNote: complexity of the len() function and append() method is O(1)
def elements_at_even_index(seq):\n result=[]\n for i in range(len(seq)): \n if i%2==0:\n result.append(seq[i])\n return seq时间复杂度：O(n)。单一 for 从 0 到 len(seq)-1 一次遍历；len() 与 append() 为 O(1)。
（另外：此函数应返回 result 才符合语义，但这不影响复杂度结论。）
Given the following function definition statement:
\ndef matmul(A,x):\n assert len(shape(A))==2\n assert len(shape(x))==1\n assert A.shape[0]==A.shape[1]\n assert A.shape[1]==x.shape[0]\n y=x.copy()\n for i in range(A.shape[0]):\n y[i]=0.0\n for j in range(A.shape[1]):\n y[i]+=A[i,j]*x[j]\n return yWrite down the time complexity in big-O notation as a function of n being the number of rows and columns in the 2D Numpy array A. Explain the reason why. Correct answers without any explanation will receive zero marks.
矩阵-向量乘（方阵 n×n）
\ni 迭代 (n) 次，内层 j 迭代 (n) 次，常数操作相加乘。Given the following function definition statement:
\ndef first_or_last_is_even(seq):\n assert len(seq)>0\n\n first_is_even=False\n if seq[0]%2 == 0:\n first_is_even=True\n\n last_is_even=False\n if seq[-1]%2 == 0:\n last_is_even=True \n \n return first_is_even or last_is_evenWrite down the time complexity in big-O notation as a function of n being the number of elements in seq. Explain the reason why. Correct answers without any explanation will receive zero marks.
first_or_last_is_even 只访问 seq[0] 与 seq[-1]，常数次操作。
Given the following function definition statement:
\ndef power(x,n):\n assert n>=0\n if n==0:\n return 1 \n else:\n if (n%2==0):\n return power(x*x,n//2)\n else:\n return x*power(x*x,n//2)Write down the time complexity in big-O notation as a function of n. Explain the reason why. Correct answers without any explanation will receive zero marks.
\n幂的二分递归（快速幂）：
\nn 变为 n//2，递归深度 (\\lfloor \\log_2 n \\rfloor + 1)。Given the following function definition statement:
\ndef f(n):\n assert n>=0\n if n==0:\n return 0\n elif n==1:\n return 1\n else: \n return f(n-1)+f(n-1)Write down the time complexity in big-O notation as a function of n. Explain the reason why. Correct answers without any explanation will receive zero marks.
\nreturn f(n-1)+f(n-1)递推：T(n)=2T(n−1)+O(1) → 指数级 T(n)=O(2n)。
\nGiven the following function definition statement:
\ndef sum_scan(l):\n result = [0 for i in range(len(l))]\n for i in range(len(l)):\n for j in range(i+1):\n result[i]=result[i]+l[j]\n return result(a) Write down the time complexity in big-O notation as a function of nn being the length of the input list l.
(b) Is there a way to re-write this function such that it has a reduced order of complexity? If yes, explain with words what would you do to achieve such an objective.
\nfor i in range(len(l)):\n for j in range(i+1):\n ...running，一次遍历中依次 running += l[i] 并写入 result[i] = running。For each problem there is a problem description and a scaffold file for you to write your solution into. As usual, you can click the \"Test\" button to test your code. The scaffold file also has a testing function that runs several test cases on your functions if you want to test the function on your local IDE.
\nRemember that the set of tests provided is never complete. Your task is to write a function that solves the problem that is described for all valid arguments (i.e., all arguments that meet the restrictions given in the problem description). Passing the tests does not prove that your implementation is correct, but failing any test proves that your code is wrong.
\nA sequence of numbers is called super-increasing if and only if every number in the sequence is strictly greater than the sum of all numbers preceding it in the sequence. The first element in the sequence can be any number.
\nFor example, the sequences 1,3,5,11,21 and -2,1,2 are both super-increasing; the sequence 1,3,5,7,19 is increasing, but not super-increasing.
Write a function super_increasing(seq) that takes as argument a sequence of numbers and returns True if the sequence is super-increasing and False if it is not.
bool).You should write your solution into the file super_increasing.py. Remember that:
super_increasing that has one parameter. You may also define additional functions if it helps you break down or solve the problem.Testing
\nYou can click the \"Test\" button to test your code. The scaffold code file also includes a testing function, test_super_increasing, which will run the same tests on your function and raise an error if any test fails. Passing the tests does not prove that your solution is correct. Failing any test proves that your function is wrong.
A closed interval of the real number line is defined by its lower and upper end points. Write a function interval_intersection(lower_a, upper_a, lower_b, upper_b) that returns the length of the intersection of two intervals A and B. Arguments lower_a and upper_a are the lower and upper end points of interval A, and lower_b and upper_b are the lower and upper end points of interval B. If the intervals do not intersect, the function should return 0.
For example, interval_intersection(0, 3, 1, 5) should return 2, because the intersection of the two intervals [0,3] and [1,5] is [1,3], which has a length of 3 - 1 = 2.
You should write your solution into the scaffold file interval_intersection.py. Remember that:
interval_intersection that has four parameters. You may also define additional functions if it helps you break down or solve the problem.Testing
\nYou can click the \"Test\" button to test your code. The scaffold code file also includes a testing function, test_interval_intersection, which will run the same tests on your function and raise an error if any test fails. Passing the tests does not prove that your solution is correct. Failing any test proves that your function is wrong.
Let's say that a counting dictionary is a dictionary in which all values (not keys) are positive integers. (In other words, it's the kind of dictionary you get when you use a dictionary to count repetitions of keys.) Given two counting dictionaries, a and b, the difference between a and b is another counting dictionary that contains the key-value pairs (k, n) where n = a[k] - b[k] for exactly those keys k such that n > 0 or k appears only in a.
Write a function count_dict_difference(a, b) that takes as arguments two counting dictionaries and returns a new dictionary that is the difference between them.
dict.Example:
\nFor example if a = {'s': 4, 'm': 1, 'p': 2, 'i': 4} (that's the letter counts for the word 'mississippi') and b = {'e': 1, 's': 3, 'm': 1, 'p': 1, 'i': 2, 't': 1} (that's the letter counts for the word 'pessimist'), the difference of a and b is the dictionary {'s' : 1, 'p' : 1, 'i' : 2} (note how 'm' is not in the difference because a['m'] - b['m'] == 0).
You should write your solution into the scaffold file count_dict_difference.py. Remember that:
count_dict_difference that has two parameters. You may also define additional functions if it helps you break down or solve the problem.Testing
\nYou can click the \"Test\" button to test your code. The scaffold code file also includes a testing function, test_count_dict_difference, which will run the same tests on your function and raise an error if any test fails. Passing the tests does not prove that your solution is correct. Failing any test proves that your function is wrong.
Write a function remove_all(a_list, element), which removes all occurrences of element from a_list. You can assume that the first argument to the function, a_list, is a list. The function should not return any value (i.e., return None) but should modify the argument list. For example,
In [1]: my_list = [1,2,3,2,3,1,2]\nIn [2]: remove_all(my_list, 2)\nIn [3]: my_list\nOut [3]: [1,3,3,1]You should write your solution into the scaffold file remove_all.py. Remember that:
remove_all that has two parameters. You may also define additional functions if it helps you break down or solve the problem.Testing
\nYou can click the \"Test\" button to test your code. The scaffold code file also includes a testing function, test_remove_all, which will run the same tests on your function and raise an error if any test fails. Passing the tests does not prove that your solution is correct. Failing any test proves that your function is wrong.
The moving average of a numeric sequence is a sequence of averages of subsequences of the original sequence; the subsequences are known as windows (or a sliding window), and the length of the subsequence used is called the window size. More precisely, given a sequence S, the moving average with window size w is sequence A such that the first element in A is the average of w consecutive elements in S starting with the first, the second element in A is the average of w consecutive elements in S starting with the second, and so on until the last element in A, which is the average of w consecutive elements in S ending with the last.
Example:
\nIf S = (2, 0, -2, 2) and w = 2, the moving average is [1, -1, 0]. 1 is the average of (2, 0), -1 is the average of (0, -2), and 0 is the average of (-2, 2).
Write a function moving_average(seq, w_size) that computes and returns the moving average of seq with window size w_size.
w_size is an integer, at least 1, and less than or equal to the length of seq.You should write your solution into the scaffold file moving_average.py. Remember that:
moving_average that has two parameters. You may also define additional functions if it helps you break down or solve the problem.Testing
\nYou can click the \"Test\" button to test your code. The scaffold code file also includes a testing function, test_moving_average, which will run the same tests on your function and raise an error if any test fails. Passing the tests does not prove that your solution is correct. Failing any test proves that your function is wrong.
We say that a list that contains lists is nested. The result of unnesting (also known as \"flattening\") a nested list is a list that contains the same non-list elements as the nested list, in the same order, but in a single list.
\nFor example, [1, [2], [[3], [[4], 5]]] is a nested list. The unnesting of this list is [1, 2, 3, 4, 5].
Write a function called unnest that takes as argument a list, which may be nested, and returns the unnesting of the argument list.
list.You should write your solution into the scaffold file unnest.py. Remember that:
unnest that has one parameter. You may also define additional functions if it helps you break down or solve the problem.Testing
\nYou can click the \"Test\" button to test your code. The scaffold code file also includes a testing function, test_unnest, which will run the same tests on your function and raise an error if any test fails. Passing the tests does not prove that your solution is correct. Failing any test proves that your function is wrong.
AI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n年夜饭抢手菜！白菜肉卷，寓意百财聚来！简单好做，清淡有滋味！
\n| 超大白菜！ | 八瘦两肥的肉 | 盐 | 白胡椒粉 | 花雕酒 |
\n|
相关信息
\nRecall that the final exam will be performed in the lab using the lab computers. If you have never logged into the lab computers before, you must try to do so successfully in advance, such as in your weekly labs. Otherwise, you may experience some important delays the day of the exam in order to be able to login into the lab computers. We will NOT consider this as a reason to extend your exam beyond the established 3 hours and 15 minutes.
\nThis lab contains some examples of the types of problems you may encounter on the final exam. The exam will in general cover all topics covered in lectures and labs, for example, to check your ability to (but not limited to):
\nProblems are presented in no particular order. Don't assume that the first is easier than the second, and so on.
\nTutors will be busy talking with students about the project assignment during week 11, but you can ask them during week 12 if you have any questions.
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nIn this assignment, you will make use of Python programming to implement a simple game called 1023 Game. The game is inspired by both the 2048 game and the Tetris game.
\nIn the 1023 Game, a piece is a connected group of 4 blocks, just like the Tetris game. There are 7 types of pieces in our game. The player can control the movement of each piece. More information about the movement in the \"Gameplay\" section.
\nA block is the smallest unit in the 1023 Game. Each block has a value of 1, 3, 7, 15, ..., 1023 (each number is two times the previous number plus one: 3=2∗1+1, 7=2∗3+1 ...). The values can be changed through merging when a block stacks on top of another block of equal value. More information about the merging rule is in the \"Gameplay\" section.
\nBefore we start implementing the game, let's first understand the gameplay of the 1023 Game. As shown in the screenshot below, this game is played on a 20x6 grid. The player can move the pieces left, right, down, or rotate them. The player can also drop the piece to the bottom of the grid.
\nA proposed move is considered valid if none of the blocks of the piece move into the position of another block already on the grid (no overlapping blocks) or is out of bounds. If the move is considered invalid, the move will be ignored, and nothing happens. Some important rules about the movement of the piece:
\nThe blocks do not fall automatically. That is, unlike Tetris, if the player does nothing, the piece will stay at the original position.
\nThe pieces can be moved with the 'a', 's', 'd' keys on the keyboard. In the graphical user interface (GUI) mode of the game, controlling with the arrow keys is also possible. The 'w' key and the up arrow key are used for rotating the piece. Pieces do not move upwards.
Press the space bar on the keyboard to drop the piece to the bottom of the grid. When blocks of equal value stack vertically, they merge. Unlike Tetris, gravity (dropping down) is applied to each block individually, not to the entire piece as a whole.
\nSince pieces will not fall automatically, the player has to press the space bar to drop the piece and continue the game. Even if the piece is already at the bottom, the space bar still needs to be pressed to proceed to the next piece.
\nIn this game, we have a special rule for merging blocks. When two blocks of equal values are stacked vertically, they will merge into a new block. The value of the new block is the sum of the values of the two blocks plus 1. After merging, the two blocks are replaced with the new block (with a value equal to two times the original value plus one) at the position of the lower block. For example, when two blocks of 15 are stacked, they will merge into a block of 31 (= 15 + 15 + 1) at the position of the lower block (higher row index number). The result is NOT directly adding the values of the two blocks.
One special case is that when there are multiple blocks of equal value stacked together, the pair of blocks closest to the bottom will be merged first. Refer to the example below for a better understanding.
\nThe game starts with an empty grid. The game will keep generating new pieces with 4 blocks, each with a value randomly chosen from [1, 3, 7, 15, 31, 63, 127, 255]. The player can move the piece or drop the piece, and the game proceeds with the mechanics specified above.
The goal of the player is to create a block with a value of 1023 through merging, and if they do so before losing the game, they win.
\nThe game will end when the player reaches the goal (has a block with a value of 1023) or any block touches the red limit line of the grid (that is, if there is any block in the top five rows) after merging checking, and all blocks of the current piece have fallen. If any block touches the line after the block merging process, the game ends, and the player loses. The limit line is represented by the red line in the images above. You can also observe the red limit line when you run your game. An example of a game lost is shown below.
\nAn example game play video recording is shown below.
\n\nIn this section, we will provide some technical details about the game implementation.
\nGame board: The game board is a 20x6 grid, and will be stored as a 2D list of values. A cell is referenced in the list as game_board[row_number][col_number]. Each cell contains a block value that can be used for merging. In this game, possible beginning block values are either 1 or 3 or 7 or 15 or 31 or 63 or 127 or 255. Also, in this assignment, we will be following Python's convention of 0-based indexing.
For easier implementation, the game board will NOT store data of the floating piece.
\nFor example, in the example below, we have game_board[18][1] = 127, but game_board[6][2] = 0.
Piece shape and location: The shapes of the pieces are stored in the list shapes (initialization is contained in the top portion of the provided skeleton program), accessed using shapes[piece_number][rotation_number][block_number][dimension]. Each element in the 4D list is an int, the row or column offset of the block.
For example, shapes[6][3] = [[0, 2], [-1, 1], [0, 1], [1, 1]], 6 corresponds to the T-shaped piece (shape 6), and 3 means the piece is rotated 3 times. The offsets of the first block (block 0) are [0, 2]. This means that the first block is at the same row as the piece's location (each piece has an anchor location), and 2 columns to the right of the piece's location.
The location of a piece is stored as a pair of integers, the row and column of the piece, in a list of two integers [r, c]. It is the reference point for the blocks of the piece. The location of the piece itself may overlap with other blocks, or even outside the grid. When a piece is moved, the location of the piece is updated, and the new location is used to calculate the new position of the blocks using the offsets. All pieces start at position [0, 1] (row index: 0 and column index: 1).
An example is provided here for better understanding (shape 6 rotation 3).
\nSuppose we want to calculate the position of the third block (block number 2) of the piece (shape number 6, rotation number 3). We can get the row offset by shapes[6][3][2][0], which should be 0, and the column offset by shapes[6][3][2][1], which should be 1. These offsets are then added to the piece's position at [row 9, column 1] to get the position of the block [row 9 + 0, column 1 + 1] = [row 9, column 2] or position [9, 2].
Consider the piece shapes[6][3][2][1].
6 indicates the piece shape. Shape number 6 corresponds to the T-shaped piece.3 indicates that the piece is rotated 3 times.2 indicates block number 2 of the piece.1 indicates the column offset of the block. Index of 0 contains the row offset instead. The dimension index is always either 0 (for row) or 1 (for column).Rotation: The player can rotate the piece using the 'w' key or the up arrow key. The rotation is stored with an integer indicating the number of 90-degree rotations performed. However, in order to keep the numbers small and stop them from growing indefinitely, the rotation number is kept as 0 or 1 or 2 or 3. After 3 rotations, if the player rotates the piece again, the rotation number will be reset to 0, since the piece returns to its original orientation.
CLI and GUI: We provide two versions of the game, one is the command-line interface (CLI), which is a text-based version of the game, using input statements and print statements to control the pieces' movement and show the current status. You can launch the CLI version by running the cli.py file.
Another version is the graphical user interface (GUI) version, which is a more user-friendly version with graphics displayed on the screen. You can launch the GUI version by running the gui.py file. All examples above are based on the GUI version.
In this assignment, you only have to implement the game logic in game.py.
cli.py and gui.py are provided to you. Feel free to modify cli.py and gui.py if you want to improve the user experience. However, you should make sure your game can be played normally when it is run with the unmodified code provided in the skeleton code.
Some of you may find it easier to debug using the CLI version since you are more familiar with the code structure and language features like input() and print(), and some of you may find it easier to use the GUI since you can better visualize the effect of the code. It does not matter whether you use the CLI or GUI version to debug or run your code. After you have implemented the game logic, the game should be able to run normally in both versions.
To begin your implementation:
\ngame.py file with Tasks that you need to work on. Modify only the game.py file - do not change any part of the cli.py and gui.py files!game.py file according to the comments in the file and the description in the \"Description\" part below. If you want to see whether you have implemented the tasks correctly, you can choose the cli.py file or gui.py under VS Code and then click the \"run\" button. If you run cli.py, the plain text mode is run. If you run gui.py, the GUI mode is run. The only difference between these two modes is in the way the 1023 game is displayed (text mode vs GUI mode). Before you have finished with the correct implementation of the tasks in the game.py file, it is normal to see error messages.cli.py or gui.py and see if that task has been implemented correctly. Repeat this for all the Tasks until you have implemented them all correctly.game.py, it will show you nothing!If you have any questions regarding the programming assignment, such as needing clarification on the requirements, please post your inquiries on the course Piazza (https://piazza.com/ust.hk/fall2025/comp1023l01l10/home). However, please refrain from posting your code to prevent other students from copying it, which could lead to issues of plagiarism.
\nThe following are tasks of the assignment. Please go through the tasks in the order listed. There are more specific requirements in the comments of the relevant functions in the skeleton code. This description is provided to give you a general overview of each function.
\nAll tasks below should be implemented in the game.py file. All numbers used should be of type int.
def init_gameboard():Description - In this task, you have to implement the init_gameboard function to create a 20x6 empty gameboard. In other words, complete Python code in the function init_gameboard() such that the function returns a 2D list (a list of lists) of 20 rows and 6 columns in each row, with each item in the 2D list having a value of 0 of type int. Edit the code inside the function init_gameboard() specified between ### TASK 1 STARTS HERE ### and ### TASK 1 ENDS HERE ### to return the game board list of lists.
The lists inside the game board should be independent. That is, changing an element in a row should not affect the values of the other lists.
\nTo generate a list of lists independently, use simple for loops or list comprehension compactly. A simple for loop to generate a 2x2 2D array with zeros:
a = []\nfor i in range(2):\n a.append([0, 0])\nprint(a) # prints [[0, 0], [0, 0]]Please note, however, that the list inside the append function must be a list of values and not variables defined elsewhere. For example, [0, 0] in a.append([0, 0]) can be replaced with [0 for i in range (2)] but not b = [0, 0]; a.append(b).
def default_random_number_generator():Description - To make the game more interesting, we would like our game to generate blocks with random values. However, if the probability of generating a piece with a large value (like 255) is high, the game would be too easy. Therefore, we would like to favor generating blocks with smaller values. Edit the code inside the function default_random_number_generator(), including changing the example return statement, if necessary, and return an appropriate integer.
In this task, you have to modify the code between ### TASK 2 STARTS HERE ### and ### TASK 2 ENDS HERE ### in the default_random_number_generator function to generate a randomly selected number from the specified list that is more likely to be smaller (more likely to be within the smaller half subset than the larger half). To achieve this, you can generate 2 random numbers and take the minimum of the two numbers as the result. Return only an integer from this list: 1, 3, 7, 15, 31, 63, 127, 255.
The randint function of the random library can be used to generate random integers between two numbers (inclusively). For example, if you want to randomly pick a number from among 0, 1, 2, 3, 4:
import random\nx = random.randint(0, 4)\nprint(x) # generates a random integer between 0 and 4 inclusivelyTo pick the smaller of two given integers, the min(a, b) function can be used.
a, b = 0, 1\nprint(min(a, b)) # prints 0def is_valid_move(game_board, current_shape, current_location, current_rotation):Description - In this task, you have to implement the is_valid_move function to check if the piece can be placed in the given location. You are given the gameboard and the new position of the piece. Return True if the move is valid (no block is out of bounds in any side and no piece of the block is in a position where there is already another block) or return False otherwise. Edit the code inside the function is_valid_move() between ### TASK 3 STARTS HERE ### and ### TASK 3 ENDS HERE ### including changing the example return statement, if necessary. The function should return a Boolean type, True or False.
A method to check validity is to iteratively go through each block (4 blocks in each shape) in a loop and calculate if that specific block's location on the grid is valid. Valid if not out of bounds and there is not already a block at that position. The current_location input parameter to the function represents the anchor coordinate of the position to check. Each block's location equals to the anchor position coordinate plus the offset from the specific rotation of the shape.
For example, for shape 0 (current_shape == 0) and rotation 0 (current_rotation == 0), the coordinate offsets of the relevant four blocks are: [[0, 0], [0, 1], [0, 2], [0, 3]] (14th line of the skeleton program about the shapes variable initialization). If current_location = [5, 5] , then the coordinates of the four blocks to check are : [5+0,5+0], [5+0,5+1], [5+0,5+2], [5+0,5+3], or the coordinates to check are: [5,5], [5,6], [5,7], [5,8]. Validity checks would include whether any of these coordinates are out of bounds (rows between 0 and 19 inclusive, columns between 0 and 5 inclusive) and if there is already a block in that coordinate. To check if there is already a block in that coordinate, check if the specific game_board[row][column] value of that block is not zero.
Do NOT modify the input parameters inside the function.
\ndef move_left(game_board, current_shape, current_location, current_rotation):\n\ndef move_right(game_board, current_shape, current_location, current_rotation):\n\ndef move_down(game_board, current_shape, current_location, current_rotation):Description - Implement the move_left, move_right, and move_down functions to move the piece to the left, right, and down, respectively. Keep the piece in the original position if the move is invalid. You may use the is_valid_move function to help with your implementation. Edit the code inside the functions move_left(), move_right(), and move_down() between ### TASK x STARTS HERE ### and ### TASK x ENDS HERE ### (x is the task number), including changing the example return statements, if necessary, and return two values: location and rotation. The syntax to return two variables, x1 and x2, would be return x1, x2. Please note that location is a list of two integers and rotation is an integer.
In each of the functions move_left, move_right, and move_down, check if the piece with the proposed new location and unchanged rotation is valid. If valid, return the new location and rotation values. If invalid, return the original location and rotation values. The original location and rotation values are the input parameters to the functions.
Do NOT modify the game_board parameter inside these functions.
\ndef rotate(game_board, current_shape, current_location, current_rotation):Description - In this task, you have to implement the rotate function to rotate the piece (rotate means to increase rotation by 1 modulo 4). Keep the piece in the original orientation if the new position is invalid. You may use the is_valid_move function to help with your implementation. Edit the code inside the function rotate() between ### TASK 7 STARTS HERE ### and ### TASK 7 ENDS HERE ###, including changing the example return statement, if necessary, and return two values: location and rotation in similar syntax to return x1, x2.
Check if the proposed rotation with unchanged location is valid. Return new values if valid, return original values otherwise.
\nDo NOT modify the game_board parameter inside this function.
\ndef gravity_and_merge(game_board):Description - In this task, you have to implement the gravity_and_merge function according to the mechanisms described above in the \"Introduction\" section. The parameter of the function is the gameboard only, with the new piece already inserted to the gameboard. The function should directly update the gameboard. Edit the code inside the function gravity_and_merge() between ### TASK 8 STARTS HERE ### and ### TASK 8 ENDS HERE ###.
There are two sets of actions in this task: gravity and merging:
\nGravity
\nGravity refers to moving blocks of the \"floating\" piece (with empty cells below) to the empty cell (largest row number) closest to the game board's bottom.
\nMerging
\nMerging is described in the section headed \"Introduction\" above. Merging is performed from bottom up, not top down.
\nA possible algorithm can be:
\nLoop through each column:\n Repeat this 20 times (or number of rows): \n Loop through each row, but from bottom to top, and check each cell to:\n Take the cell value above if the current cell is empty and reset the above cell (gravity); or\n Merge if the current cell value equals the cell value above and reset the above cell value (merge); or\n Do nothingdef get_game_status(game_board):Description - In this task, you have to implement the get_game_status function to check the game status. You should return \"Lose\" or return \"Win\" or return \"Playing\". The game is considered to be \"Win\" if there is a block with a value of 1023 on the gameboard. The game is considered to be \"Lose\" if the blocks touch the line after the block merging process. To be specific, that is to check if any of the top five rows of the game board contain non zero values. Otherwise, the game is considered to be \"Playing\". If there is a block with a value of 1023 and a block in the top five rows at the same time, the game is considered to be \"Lose\".
Do NOT modify the game_board parameter inside this function.
\ndef custom_random_number_generator():Description - In this optional task, you can implement the custom_random_number_generator function to create your own random number generator to make the game more interesting. You can use any method to generate a random number. You can also use this function for debugging purposes. This task will NOT be graded.
The purpose of this week's lab is to:
\nIf you have any questions about any of the material in the previous labs, now is a good time to ask your tutor for help during the lab.
\n相关信息
\nIf you do not have time to finish all exercises (in particular, the programming problems) during the lab time, you should continue working on them later.
\nAs we have seen in the lecture last week, the big-O notation is used to denote the worst-case time complexity of an algorithm to solve a certain problem. If the problem size is nn and the algorithm needs x×n numerical operations to solve it, where cc is a constant number (thus independent of n), we say that the algorithm has a linear time complexity O(n). Here, we assume that each operation has a constant time complexity O(1). (Otherwise, the algorithm won't have a linear complexity anymore.)
\nFor example, the following function finds the index of an element in a sequence, (returning -1 if the element is not found):
def find_element(sequence, element):\n for i in range(len(sequence)):\n if sequence[i] == element:\n return i\n return -1It has time complexity of O(n), where nn is the length of the sequence. This is because the main for loop needs nn comparisons in the worst-case, namely when the element we are looking for does not appear in the sequence.
As a rule of thumb, a for or while loop with nn iterations indicates that the code may have a complexity of O(n). If there are two loops nested within each other, the code might have a quadratic time complexity of O(n2).
Let's look at an example: the following code computes the minimum absolute difference between any pairs of elements in a numerical sequence:
\ndef smallest_difference(sequence):\n min_diff = abs(sequence[0]-sequence[1])\n for i in range(len(sequence)-1):\n for j in range(i+1, len(sequence)):\n diff = abs(sequence[i] - sequence[j])\n if diff < min_diff:\n min_diff = diff\n return min_diffLet's analyse the time complexity of this code. Let nn be the length of the input sequence. The outer for loop has n−1 iterations using index i. In the first iteration of the outer loop, i.e., when i=0, the inner loop iterates in range(1,n), each doing four operations (subtraction, abs, comparison, and assignment), totalling 4(n−1) operations. In the 2nd iteration of the outer loop (i=1), the inner loop iterates over range(2,n), which means n−2 iterations. And so on. Summing all together, the total number of operations is:
4(n−1)+4(n−2)+⋯+4=4n2n−1=2n2−2n
\nNow, when n is large enough, the n2 term will dominate over the nn term. We can also ignore the constant 2 multiplying this leading term. That means that the function smallest_difference has time complexity O(n2).
Each of the following three functions takes as input an integer n. For each function, give its computational complexity in big-O notation in terms of n.
\nIt is important you to format your answer exactly. If the algorithm has linear time complexity, you should answer:
\nO(n)
\nIf the algorithm has cubic time complexity, then either of the following are acceptable:
\nO(n3)
\nO(n∗∗3)
\nOther possible time complexities should be formatted similarly.
\ndef func_a(n):\n total = 0\n for i in range(n):\n for j in range(n):\n total = total + i * j\n return total\n\nO(n2)
\n
def fun_b(n):\n total = 0\n for i in range(100 * n):\n for j in range(10):\n total = total + i * j\n return total\n\n外层
\n100*n、内层常数10，常数忽略：O(n)
\n
def fun_c(n):\n total = 0\n for i in range(100):\n for j in range(n):\n total = total + i * j\n for k in range(n):\n total = total + i * k\n for l in range(100):\n total = total + i * l\n return l\n\n外层常数
\n100；内有两个range(n)和一个常数range(100)，总体仍线性于n：O(n)
\n
It turns out that there is another algorithm for smallest_difference with a time complexity of only O(nlog(n)). Can you figure it out? Write your solution in the scaffold file smallest_difference.py with that time complexity.
相关信息
\nAfter thinking about it and you still can't find it out, click the spoiler below for a hint!
\nExpand： What if the sequence is sorted? What is the time for sorting?
\nsmallest_difference.py
\ndef smallest_difference(sequence):\n # TODO: Find the smallest difference \n # between numbers in the sequence\n # in worst-case O(n log(n)) time.\n passdef smallest_difference(sequence):\n \"\"\"\n Return the smallest absolute difference between any two numbers in sequence.\n Worst-case time: O(n log n) due to sorting; the scan is O(n).\n\n Assumes len(sequence) >= 2. Raises ValueError otherwise.\n \"\"\"\n if len(sequence) < 2:\n raise ValueError(\"sequence must contain at least two elements\")\n\n seq = sorted(sequence)\n min_diff = abs(seq[1] - seq[0])\n for i in range(2, len(seq)):\n d = abs(seq[i] - seq[i - 1])\n if d < min_diff:\n min_diff = d\n if min_diff == 0: # early exit: duplicate values\n return 0\n return min_diffHere is an implementation to compute the maximum absolute difference in a similar style to smallest_difference:
def largest_difference(sequence):\n max_diff = abs(sequence[0]-sequence[1])\n for i in range(1, len(sequence)):\n for j in range(i):\n diff = abs(sequence[i] - sequence[j])\n if max_diff < diff:\n max_diff = diff\n return max_diffIt has a time complexity of O(n2). You can of course use the same idea from exercise 1.1 to reduce the complexity to O(nlog(n)).
\nHowever, it turns out there is another algorithm with linear time complexity: O(n). Can you work it out? Provide a solution to the largest_difference function with that time complexity.
largest_difference.py
\ndef largest_difference(sequence):\n # TODO: Find the largest difference \n # between numbers in the sequence\n # in worst-case O(n log(n)) time\n passThe three lifts transport people between the ground floor (G/F) and the 10th floor (10/F). They do not stop at other floors.
\nLet's suppose each lift has a screen showing its current floor and status. Floor, which is a string, can be either G or 10. Status, which is also a string, can be one of moving up, moving down or stopped. These are similar to the information that the screens for those real lifts show.
Here are some examples of what the floor and status of a lift mean:
\n| Floor | Status | Meaning |
\n|
你好，我是悦创。
\n今天我打算和你聊聊分组与引用。那什么场合下会用到分组呢？
\n假设我们现在要去查找 15 位或 18 位数字。根据前面学习的知识，使用量词可以表示出现次数，使用管道符号可以表示多个选择，你应该很快就能写出 \\d{15}|\\d{18} 。但经过测试，你会发现，这个正则并不能很好地完成任务，因为 18 位数字也会匹配上前 15 位，具体如下图所示。
为了解决这个问题，你灵机一动，很快就想到了办法，就是把 15 和 18 调换顺序，即写成 \\d{18}|\\d{15}。你发现，这回符合要求了。
为什么会出现这种情况呢？因为在大多数正则实现中，多分支选择都是左边的优先。类似地，你可以使用 “北京市|北京” 来查找 “北京” 和 “北京市”。另外我们前面学习过，问号可以表示出现 0 次或 1 次，你发现可以使用“北京市?” 来实现来查找 “北京” 和 “北京市”。
同样，针对 15 或 18 位数字这个问题，可以看成是 15 位数字，后面 3 位数据有或者没有，你应该很快写出了 \\d{15}\\d{3}? 。但这样写对不对呢？我们来看一下。
在上一节我们学习了量词后面加问号表示非贪婪，而我们现在想要的是 \\d{3} 出现 0 次或 1 次。
\\d{15}\\d{3}? 由于 \\d{3} 表示三次，加问号非贪婪还是 3 次；\\d{15}(\\d{3})? 在 \\d{3} 整体后加问号，表示后面三位有或无；这时候，必须使用括号将来把表示“三个数字”的 \\d{3} 这一部分括起来，也就是表示成 \\d{15}(\\d{3})? 这样。现在就比较清楚了：括号在正则中的功能就是用于分组。简单来理解就是，由多个元字符组成某个部分，应该被看成一个整体的时候，可以用括号括起来表示一个整体，这是括号的一个重要功能。其实用括号括起来还有另外一个作用，那就是“复用”，我接下来会给你讲讲这个作用。
括号在正则中可以用于分组，被括号括起来的部分“子表达式”会被保存成一个子组。
\n那分组和编号的规则是怎样的呢？其实很简单，用一句话来说就是，第几个括号就是第几个分组。这么说可能不好理解，我们来举一个例子看一下。
\n这里有个时间格式 2020-05-10 20:23:05。假设我们想要使用正则提取出里面的日期和时间。
\n我们可以写出如图所示的正则，将日期和时间都括号括起来。这个正则中一共有两个分组，日期是第 1 个，时间是第 2 个。
\n在括号里面的会保存成子组，但有些情况下，你可能只想用括号将某些部分看成一个整体，后续不用再用它，类似这种情况，在实际使用时，是没必要保存子组的。这时我们可以在括号里面使用 ?: 不保存子组。
如果正则中出现了括号，那么我们就认为，这个子表达式在后续可能会再次被引用，所以不保存子组可以提高正则的性能。除此之外呢，这么做还有一些好处，由于子组变少了，正则性能会更好，在子组计数时也更不容易出错。
\n那到底啥是不保存子组呢？我们可以理解成，括号只用于归组，把某个部分当成“单个元素”，不分配编号，后面不会再进行这部分的引用。
\n前面讲完了子组和编号，但有些情况会比较复杂，比如在括号嵌套的情况里，我们要看某个括号里面的内容是第几个分组怎么办？不要担心，其实方法很简单，我们只需要数左括号（开括号）是第几个，就可以确定是第几个子组。
\n在阿里云简单日志系统中，我们可以使用正则来匹配一行日志的行首。假设时间格式是 2020-05-10 20:23:05 。
\n日期分组编号是 1，时间分组编号是 5，年月日对应的分组编号分别是 2，3，4，时分秒的分组编号分别是 6，7，8。
\n前面我们讲了分组编号，但由于编号得数在第几个位置，后续如果发现正则有问题，改动了括号的个数，还可能导致编号发生变化，因此一些编程语言提供了命名分组（named grouping），这样和数字相比更容易辨识，不容易出错。命名分组的格式为 (?P<分组名>正则)。
比如在 Django 的路由中，命名分组示例如下：
\nurl(r'^profile/(?P<username>\\w+)/$', view_func)需要注意的是，刚刚提到的方式命名分组和前面一样，给这个分组分配一个编号，不过你可以使用名称，不用编号，实际上命名分组的编号已经分配好了。不过命名分组并不是所有语言都支持的，在使用时，你需要查阅所用语言正则说明文档，如果支持，那你才可以使用。
\n在知道了分组引用的编号 （number）后，大部分情况下，我们就可以使用 “反斜扛 + 编号”，即 \\number 的方式来进行引用，而 JavaScript 中是通过 $ 编号来引用，如 $1。
我给到了你一些在常见的编程语言中，分组查找和替换的引用方式：
\n这些内容不要求你完全记住，只要有个印象就好，最关键的是要知道正则可以实现这样的功能，需要用到的时候查一下相应的文档，就知道怎么用了。
\n前面介绍了子组和引用的基本知识，现在我们来看下在正则查找时如何使用分组引用。比如我们要找重复出现的单词，我们使用正则可以很方便地使“前面出现的单词再次出现”，具体要怎么操作呢？我们可以使用 \\w+ 来表示一个单词，针对刚刚的问题，我们就可以很容易写出 (\\w+) \\1 这个正则表达式了。
和查找类似，我们可以使用反向引用，在得到的结果中，去拼出来我们想要的结果。还是使用刚刚日期时间的例子，我们可以很方便地将它替换成， 2020 年 05 月 10 日这样的格式。
\n由于这个例子稍微复杂一些，这里我给出一个示例链接方便你学习，不知道学到这里，你有没有觉得子组和引用非常强大呢？
\n((\\d{4})-(\\d{2})-(\\d{2})) ((\\d{2}):(\\d{2}):(\\d{2}))\n2020-05-10 20:23:05你可能很好奇，那在编程语言中如何实现这个功能呢？我下面以 Python3 为例，给出一个示例。
\n>>> import re\n>>> test_str = \"2020-05-10 20:23:05\"\n>>> regex = r\"((\\d{4})-(\\d{2})-(\\d{2})) ((\\d{2}):(\\d{2}):(\\d{2}))\"\n>>> subst = r\"日期\\1 时间\\5 \\2年\\3月\\4日 \\6时\\7分\\8秒\"\n>>> re.sub(regex, subst, test_str)\n'日期2020-05-10 时间20:23:05 2020年05月10日 20时23分05秒'在 Python 中 sub 函数用于正则的替换，使用起来也非常简单，和在网页上操作测试的几乎一样。
\n接下来我用 Sublime Text 3 来当例子，给你讲解一下正则查找和替换的使用方式。Sublime Text 3 是一个跨平台编辑器，非常小巧、强悍，虽然是一个收费软件，但可以永久试用，你自行可以下载安装。
\n当熟练使用编辑器之后，你会发现在很多工作里都可以使用它，不需要编写代码就可以完成。
\n下面我以文本编辑器 Sublime Text 3 为例，来讲解正则查找和替换的使用方式。首先，我们要使用的“查找”或“替换”功能，在菜单 Find 中可以找到。
\n下面是对编辑器查找 - 替换界面的图标简介，Find 输入栏第一个 .* 图标，表示开启或关闭正则支持。
接下来，我们来演示用编辑器查找引号引起来的内容，课程中使用到的文本，建议你用 chrome 等浏览器等，打开极客时间网页版本 https://bornforthis.cn/，点击右键查看源代码，把看到的代码复制到 Sublime Text 3 中。
\n输入相应的正则，我们就可以看到查找的效果了。这里给一个小提示，如果你点击 Find All，然后进行剪切，具体操作可以在菜单中找到 Edit -> Cut，也可以使用快捷键操作。剪切之后，找一个空白的地方，粘贴就可以看到提取出的所有内容了。
\n我们可以使用正则进行资源链接提取，比如从一个图片网站的源代码中查找到图片链接，然后再使用下载工具批量下载这些图片。
\n接着，我们再来看一下在编辑器中进行文本替换工作。你可以在编辑器中输入这些文本：
\nthe little cat cat is in the hat hat, we like it.
\n如果我们要尝试从中查找连续重复出现两次的单词，我们可以用 \\w+ 代表单词，利用我们刚刚学习的知识，相信你可以很快写出正则 (\\w+) \\1。
接着点击菜单中的 Find -> Replace，在替换栏中输入子组的引用 \\1 ，然后点击 Replace All 就可以完成替换工作了。
这样，通过少量的正则，我们就完成了文本的处理工作了。
\n几乎所有主流编辑器都是支持正则的，你可以在你喜欢的编辑器中尝试一下这个例子，在后面的工作中，也可以尝试使用它来完成一些复杂的文本查找和替换工作。
\n好了，今天的内容讲完了，我来带你总结回顾一下。
\n今天我们学习到了正则中的分组和子组编号相关内容。括号可以将某部分括起来，看成一个整体，也可以保存成一个子组，在后续查找替换的时候使用。分组编号是指，在正则中第几个括号内就是第几个分组，而嵌套括号我们只要看左括号是第几个就可以了。如果不想将括号里面的内容保存成子组，可以在括号里面加上?: 来解决。
搞懂了分组的内容，我们就可以利用分组引用，来实现将“原文本部分内容”，在查找或替换时进行再次利用，达到实现复杂文本的查找和替换工作。甚至在使用一些文本编辑器的时候，不写代码，我们就可以完成文本的查找替换处理工作，这往往可以节约很多开发时间。
\n最后，我们来做一个小练习吧。有一篇英文文章，里面有一些单词连续出现了多次，我们认为连续出现多次的单词应该是一次，比如：
\n\n\nthe little cat cat is in the hat hat hat, we like it.
\n
\n\n其中 cat 和 hat 连接出现多次，要求处理后结果是
\n
\n\nthe little cat is in the hat, we like it.
\n
这个题目我给出了相应的地址 https://regex101.com/r/2RVPTJ/3，你可以直接在网页上进行测试，写入相应的 “正则查找部分” 和 “正则替换部分”，让结果符合预期。多动手练习，你才能更好地掌握学习的内容。
\n好，今天的课程就结束了，希望可以帮助到你，也希望你在下方的留言区和我参与讨论。也欢迎把这篇文章分享给你的朋友或者同事，一起交流一下。
\n\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nThe purpose of this week's lab is to:
\n相关信息
\nIf you do not have time to finish all exercises (in particular, the programming problems) during the lab time, you can continue working on them later.
\n相关信息
\nIf you have any questions about or difficulties with any of the material in this lab, or any of the material covered in the course so far, ask your tutor for help during the lab.
\nFiles and directories are an abstraction provided by the operating system (OS) to make it easier for programmers and users to interact with the underlying storage device (hard drive, USB key, network file server, etc).
\nIn a unix system (like the one in the CSIT labs), or a system running MacOS, the file system is organised into a single directory tree. That means directories can contain several (sub-)directories (or none), but each directory has only one directory directly above it, the one that it is contained in. (This is often called the \"parent directory\".) The top-most directory in the tree, which is called /, has no parent directory. Every file is located in some directory.
If you are working on a computer running Microsoft Windows, each \"drive\" will be the root of it's own directory tree. The topmost directory within a drive is the drive letter - followed by a ':', for example \"C:\". Within each drive, the parent/sub-directory structure is similar to a MacOS or Unix system, where each directory has a single parent directory, but can contain many sub-directories.
\n相关信息
\nWork through this exercise on your personal computer, or the lab computer.
\nFor this exercise, you will need some directories and files to work with. On the lab computer or your personal device, create a directory called comp1730 in your home directory (if you haven't already), and within that directory create one called lab8. You can do this using whichever tool you're familiar with (the command-line terminal or the graphical folders tool).
Next, create a file with a few lines of text (including some empty lines). You can use the editor in the IDE, or any other text editor, to write the file. (If you don't know what to write, just copy some text from this page.) Save your file with the name sample.txt in the lab8 directory.
When you are done, you should have something like the following:
\nIn the python3 shell, import the os module:
In [1]: import osThis module provides several useful functions for interacting with the file system; in particular, it can let you know what the current working directory is, and change that. Try the following:
\nIn [2]: os.getcwd()\nOut [2]: 'NNNNN'The value returned will depend on your operating system and where you are running Python from. From here onwards, where we ask you to type \"NNNNN\" you should use whatever was returned in Out [2].
\nIf you are running Linux or MacOs try:
\nIn [3]: os.chdir('NNNNN/comp1730')\nIn [4]: os.getcwd()\nOut [4]: ...Where \"NNNNN\" was the value returned in Out [2]
\nIf you are running Windows try:
\nIn [3]: os.chdir('NNNNN\\\\comp1730')\nIn [4]: os.getcwd()\nOut [4]: ...Where again \"NNNNN\" was the value returned in Out [2]
\nYou should find that the current working directory is now 'NNNNN/comp1730'. The os.chdir (\"change directory\") function changes it.
The location given in the example above is absolute: it specifies the full path, from the top-level (\"root\") directory or drive. A relative path specifies a location in the directory structure relative to the current working directory. Try
\nIn [5]: os.chdir('lab8')\nIn [6]: os.getcwd()\nOut [6]: ...\nIn [7]: os.chdir('..')\nIn [8]: os.getcwd()\nOut [8]: ...The path .. means \"the parent directory\". So, for example, if your current working directory is NNNNN/comp1730/lab8 and you also have a lab1 directory in comp1730, you can change to it with
os.chdir('../lab1')Finally, the os.listdir function returns a list of the files and subdirectories in a given directory. If you have created the text file sample.txt (and nothing else) in comp1730/lab8, then
os.listdir('NNNNN/comp1730/lab8') # Linux or MacOS\nos.listdir('NNNNN\\\\comp1730\\\\lab8') # Windowsshould return ['sample.txt'], while
os.listdir('..')will return a list of the subdirectories and files in the parent of the current working directory.
\n相关信息
\nWork through this exercise on your personal computer, or the lab computer.
\nReading a text file.
\nTo read the sample text file that you created in python, you can do the following:
\nIn [1]: fileobj = open(\"sample.txt\", \"r\")\nIn [2]: fileobj.readline()\nOut [2]: ...\nIn [3]: fileobj.readline()\nOut [3]: ...(This assumes the current working directory is where the file is located, i.e., 'NNNNN/comp1730/lab7'. If not, you need to give the (absolute or relative) path to the file as the first argument to open.) You can keep repeating fileobj.readline() as many times as you wish. Notice that each call returns the next line in the file: the file object keeps track of the next point in the file to read from. When you get to the end of the file, readline() returns an empty string. Also notice that each line has a newline character ('\\n') at the end, including empty lines in the file.
When you are done reading the file (whether you have reached the end of it or not), you must always close it:
\nIn [4]: fileobj.close()Walking through the contents of the file with a for loop.
A more convenient way to iterate through the lines of a text file is using a for loop. The file object that is returned by the built-in function open is iterable, which means that you can use a for loop, like this:
for line in my_file_obj:\n # do something with the lineHowever, the file object is not a sequence, so you can't index it, or even ask for its length.
\nWrite a function that takes as argument the path to a file, reads the file and returns the number of non-empty lines in it. You should use a for loop to iterate through the file.
Remember to close the file before the end of the function!
\nThe dict type in python implements a mapping, which is also, in computer science, known as a dictionary, or sometimes an associative container type or associative array.
[], len(.) and in can be applied to dictionaries. Note that x in adict is True if x appears as a key in the dictionary; the in operator does not check if x appears as a value.items(), keys() and values(), which allow iteration over the dictionary content.The set type in python implements the mathematical notion of a set.
A set is an unordered collection of values (called the elements or
\nmembers of the set), without duplicates.
\nA python set can contain objects of any immutable type, including a mixture of different types. Thus, lists cannot be elements of a set, but tuples can be.
There is only one copy of any element in a set. If you add an element that appears already, it is not added again, but it will not result in a run-time error.
\nThere is no order to the elements of the set. The set type is iterable, but it is not a sequence (so it is not indexable).
The len() and in operators can be applied to sets. The \"length\" of a set is the number of elements in it.
Sets are mutable: methods set.add(element) and set.remove(element) can be used to modify a set.
The binary operators & (intersection), | (union), - (difference) and ^ (symmetric difference) can be applied to set; these return their result as a new set, without modifying the operands.
You can create a dictionary by writing a comma-separated sequence of key : value pairs within curly brackets, { and }. You can similarly create a set by writing a comma-separated sequence of elements (without the : and associated value) in curly brackets. However, an empty pair of curly brackets creates an empty dictionary, not an empty set. Try the following:
In [1]: a = { 0 : 'none', 1 : 'one', 2 : 'two', 3 : 'many' }\n\nIn [2]: type(a)\n\nOut [2]: ...\n\nIn [3]: b = { 'one', 'two', 'many' }\n\nIn [4]: type(b)\n\nOut [4]: ...\n\nIn [5]: c = {}\n\nIn [6]: type(c)\n\nOut [6]: ...Values stored in a dictionary are accessed by writing the key in square brackets. What is the output of the following?
\nIn [7]: a[3] + \" hundred \" + a[1] + \" ten \" + a[2]\n\nOut [7]: ...\n\nIn [8]: a[7] + \" ten \" + a[3]\n\nOut [8]: ...Trying to access the value of a key that is not in the dictionary causes an error.
\nDictionaries are mutable: you can add keys, change the value associated with a key already in the dictionary, and remove keys. Changing the value associated with a dictionary is done by assigning to the dictionary indexed with the key using the same syntax. Adding keys to a dictionary is done by simply assigning a value to the new key:
\nIn [9]: a\nOut [9]: ...\n\nIn [10]: a[3] = 'three'\n\nIn [11]: a[7] = 'a lot of'\n\nIn [12]: a\nOut [12]: ...Retry the two string expressions (inputs 7 and 8) above with the dictionary after reassigning the keys 3 and 7.
Keys themselves cannot be mutable however. The following examples work because tuples and strings are immutable.
\nIn [13]: a[(1,2)] = 'one and two'\n\nIn [14]: a['lab'] = 7The following example with a list as key however will not, as lists are mutable.
\nIn [15]: a[[1,2]] = 'does not work'\nTypeError: unhashable type: 'list'Think about why mutable objects cannot be used as dictionary keys. Discuss with your tutor after you have had a think about it.
\nWriting every key-value pair in a dictionary explicitly will quickly get tedious, so let's look at ways to create dictionaries programmatically (which is how you will use them most of the time anyway).
\nYou can create a dictionary from a list (or any sequence) of keys and a value expression, much like you can create a list using list comprehension. For example, copy the following statement into the python shell:
\nwordlist = ['test', 'your', 'function', 'with', 'a', 'diverse',\n 'range', 'of', 'examples', 'your', 'tests', 'should', 'cover',\n 'all', 'cases', 'for', 'example', 'test', 'words', 'beginning',\n 'with', 'a', 'vowel', 'and', 'word', 'beginning', 'with', 'a',\n 'consonant', 'pay', 'particular', 'attention', 'to', 'edge',\n 'cases', 'for', 'example', 'what', 'happens', 'if', 'the',\n 'word', 'consists', 'of', 'just', 'one', 'vowel', 'like',\n 'a', 'what', 'happens', 'if', 'the', 'string', 'is', 'empty']This sets wordlist to a list of strings. Now, the expression
In [1]: wordlen = { word : len(word) for word in wordlist }creates a dictionary, called wordlen in which every word in the list is mapped to its length. To check that it has worked, print the dictionary, and look up some sample words.
But wait! The list contains some words multiple times (for example, both \"for\" and \"example\" appear twice). Haven't we said that in a dictionary a key can only appear once? When you create a dictionary from an iterable (such as a sequence), key-value pairs are assigned in order. For example,
\nIn [2]: { 'a' : 1, 'b' : 2, 'a' : 3 }\n\nOut [2]: {'a': 3, 'b': 2}That is, the second occurrence of the 'a' in a pair in the list overwrites the first.
In a similar way, you can create a set from any iterable collection of values (as long as all values are immutable). For example,
\nIn [3]: wordset = set(wordlist)creates a set of strings. Here also, duplicates in the list are ignored.
\n相关信息
\nThere are purposefully no tests for this exercise.
\nA very common use of a dictionary is to count things. The following function (from section \"Dictionary as a Collection of Counters\", Chapter 11, in Downey's book), creates a dictionary that maps values in a sequence (string, list, etc) to the number of times they appear.
\nRun the python file and run the file so that you can test the function. You can test it on strings,
\nIn [1]: histogram(\"neverending\")\nOut [1]: ...\n\nIn [2]: histogram(\"mississippi\")\nOut [2]: ...on lists of numbers,
\nIn [3]: histogram([2, 1, 4, 6, 5, 5, 3, 4, 4, 6])\nOut [3]: ...on lists of strings,
\nIn [4]: histogram(wordlist)\n\nOut [4]: ...and other sequences. What happens if you try
\nIn [5]: histogram([[1,2], [2,1], [1,2], [1], [2]])Can you explain why this happens?
\ndef histogram(seq):\n \"\"\"\n Given a sequence of values, return a dictionary counting\n the number of times each value appears in the sequence.\n\n ParametersThe purpose of this week's lab is to:
\n相关信息
\nIf you do not have time to finish all exercises (in particular, the programming problems) during the lab time, you can continue working on them later.
\n相关信息
\nIf you have any questions about or difficulties with any of the material in this lab, or any of the material covered in the course so far, ask your tutor for help during the lab.
\nAs we saw in last week's lecture, arrays are provided by the external library NumPy, which stands for \"Numerical Python''. NumPy is a vast library with many features that are very useful for writing scientific programs. In this course (and this lab), we restrict ourselves to a small subset of this functionality. In any case, probably the next most natural (and less steep) step to explore more about this functionality is this tutorial from the NumPy documentation.
\nArrays are sequence types. In contrast to lists, all of its elements are ALWAYS of the same type (e.g., ints or floats).
Let us start working with rank-1 arrays, also known as 1-dimensional arrays or simply vectors.
\nRecall that the defining property of rank-1 array is that you only have to use one index to access to its entries (as with lists or strings).
\nThe first thing to do when working with NumPy arrays is to import the numpy module. The de-facto practice (i.e., you will observe many programs doing this) is to rename it as np when importing:
import numpy as npBefore working with a rank-1 array, one has to generate (create) it. NumPy offers many different ways to generate rank-1 arrays. The function calls below show some examples of these. Run the following in a Python shell and try to understand what each function call does:
\nIn [1]: import numpy as np\n\nIn [2]: x = np.array([0.0, 0.25, 0.5, 0.75, 1.0])\n\nIn [3]: x\nOut[3]: array([0. , 0.25, 0.5 , 0.75, 1. ])\n\nIn [4]: type(x) # what type of sequence is this?\nOut[4]: ...\n\nIn [4]: y = np.zeros(5)\n\nIn [5]: y\nOut[5]: ...\n\nIn [6]: z = np.linspace(0.0,10.0,5)\n\nIn [7]: z\nOut[7]: ...\n\nIn [8]: t = np.arange(0.0, 5.0, 0.5)\n\nIn [8]: t\nOut[8]: ...As always, you can check the docstrings of these functions (e.g., help(np.zeros) in the Python shell) to find more about these.
Recall that arrays are sequence types. Thus, once the rank-1 array is established, we can set and retrieve individual values, and extract slices, as with lists or strings. We can also iterate over the entries using loops. Run the following in the Python shell to convince yourself that this is indeed true:
\nIn [1]: import numpy as np\n\nIn [2]: y = np.zeros(4)\n\nIn [3]: y[0] = 0.0\n\nIn [4]: y[1] = 0.01\n\nIn [5]: y[2] = 0.02\n\nIn [6]: y[3] = 0.03\n\nIn [7]: y\nOut[7]: ...\n\nIn [8]: y[1:3]\nOut[8]: ...\n\nIn [9]: y[1:]\nOut[9]: ...\n\nIn [10]: y[1:-2]\nOut[10]: ...\n\nIn [11]: for elem in y:\n print(elem)\nOut[11]: ...\n\nIn [12]: for i in range(0,len(y)):\n print(y[i])\nOut[12]: ...An important feature of NumPy is that code written in terms of arrays might be vectorised. That is, rewritten/transformed in terms of operations on entire arrays at once (without Python loops). Vectorised code can run much faster than non-vectorised code, especially with large arrays, as we saw in the lecture.
\nExecute the vectorised operations below in a Python shell and figure out what they are returning:
\nIn [1]: import numpy as np\nIn [2]: import math\n\nIn [3]: def double(x):\n return x*2\n\nIn [4]: x = np.linspace(0.0, 2*math.pi, 10)\n\nIn [5]: x \nOut[5]: ...\n\nIn [6]: x+10 \nOut[6]: ...\n\nIn [7]: x**2 \nOut[7]: ...\n\nIn [8]: np.sin(x) \nOut[8]: ...\n\nIn [9]: math.sin(x) \nOut[9]: ...\n\nIn [10]: double(x) \nOut[10]: ...Given the mathematical function:
\nh(x)=2π1e−21x2
\nYou are asked to solve the following tasks.
\nTask 1: Scalar function evaluations. Write a function evaluate_h(a,b,N) that returns two rank-1 arrays of floats named, say, x and y. The array x holds xx values obtained from splitting the interval [a,b] into N>1 equispaced points. For example, if a=0, b=10, and N=5, then x must have the values 0.0, 2.5, 5.0, 7.5, and 10.0, in this order. On the other hand, the array y holds h(x) evaluations at the corresponding values of the array x. The function MUST first create two rank-1 arrays of the appropriate size, and then fill them by computing each element, element by element, with a for loop.
相关信息
\nHint: the distance among two consecutive x values in the [a,b] interval is given by
\nN−1b−a
\n(Think why!)
\nTask 2: Vectorised function evaluations. Write a version of the previous function, evaluate_h_vectorized(a,b,N), that vectorises evaluate_h(a,b,N). This function must not use Python loops. To this end, you can use the linspace or arange functions from numpy to create the entries of the x array, and evaluate h(x) for an array argument to create the corresponding ones of y (as we showed in the lecture).
Task 3: Compare performance (i.e., time to solve the problem). Using the %timeit IPython shell magic command (as shown in the lecture code examples), compare the performance of the functions written in Task 1 versus Task 2 with increasing powers of 10 for N, e.g., 1010, 102102, ……, 106106. Accordingly to your measurements, which one is faster?
注意
\nPlease note that Task 3 will NOT be auto-tested, so please contact your tutor if you struggle while trying to solve this.
\nTask 4: Write a function to generate a plot. Write a function, plot_h(filename, a, b, N), with filename being a string, that generates an image called filename with a plot of h(x) within the interval [a,b][a,b]. It can use any of the two functions written in Task 1 and Task 2. In order to generate the image with the plot, you can use the matplotlib library. If x and y are two rank-1 arrays produced by the functions written in 1(a) and 1(b), then you can use the following code to plot the function:
import matplotlib.pyplot as plt\n... # generate x and y rank-1 arrays\nplt.figure()\nplt.plot(x,y)\nplt.grid()\nplt.savefig(filename)Note that the plt.grid() function call shows a grid of vertical and horizontal lines on the plot on certain x- and y-values, respectively. In general, grids are used to help you to interpret the quantitative values in a graph.
Using the plot_h function, visualize the function h(x) using increasing values of N in the interval [−4,4]. For example, you can use plot_h(\"h_5_points.png\",-4,4,5), plot_h(\"h_10_points.png\",-4,4,10), plot_h(\"h_20_points.png\",-4,4,20), plot_h(\"h_40_points.png\",-4,4,40), etc. Can you find a value of N beyond which the plot does not apparently change to your eye when you increase N?
Rank-2 arrays can be thought of as tables of numbers (also known as \"matrices\" by mathematicians). They are indexed using two indices, one for the rows, and another one for the columns.
\nAs with rank-1 arrays, there are many ways one can create a rank-2 array. Two possible ways are:
\nBy converting a list of lists (a.k.a. nested list) into a rank-2 array:
\n >>> import numpy as np\n >>> A = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\n >>> A \n >>> ...By providing the shape of the rank-2 array to the zeros function:
>>> A = np.zeros((2, 3))\n >>> A\n >>> ...Recall from the lecture that the shape of a rank-2 array is a tuple with the number of elements in each dimension. Here we have 2 rows and 3 columns.
\nOnce created, the shape of an array can be queried like this:
\n>>> A.shape\n>>> ...A word of caution in regards to shapes. The shape of a rank-1 array with n elements is the tuple (n,). On the other hand, rank-2 arrays might have only one element in some (or all) the dimensions. Even in this case, they are still rank-2 arrays. Execute the following instructions to double check this:
>>> import numpy as np\n>>> x=np.zeros((3,))\n>>> x.shape\n...\n>>> y=np.zeros((3,1))\n>>> y.shape \n>>> ...\n\n>>> z=np.zeros((1,3))\n>>> z.shape \n>>> ...\n\n>>> t=np.zeros((1,1))\n>>> t.shape \n>>> ...Once created, the individual entries of a rank-2 array can be accessed using A[i][j] or A[i,j], where i and j denote the row and column identifiers of the corresponding entry of A. One can also use slicing in the column dimension (e.g., A[i,:] returns the row i of A as a rank-1 array), in the row dimension (e.g., A[:,j] returns the column j of A as a rank-1 array), or both dimensions (e.g., A[0:2,1:3] returns a rank-2 array with the entries in [rows 0 or 1] and [columns 1 or 2]).
An important difference among lists and arrays is that array slices create a \"view\" of the original array, instead of a shallow copy (as we showed in the lectures). This means that if you modify an array view, you will be actually modifying the original array the view was created from. Execute the following Python statements and expressions, and convince yourself that this is the case:
\n>>> import numpy as np\n>>> A = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\n>>> A \n>>> ...\n>>> A[0,:]=np.array([12.3,44.5,22.3])\n>>> A \n>>> ...\n>>> A[:,1]=A[:,2]\n>>> A \n>>> ...\n>>> A[1,:]=A[0,:]\n>>> A \n>>> ...Task 1. Write a function, evaluate_function(function, A) that given a function function, and a rank-2 array A, applies the function to each entry of A, element by element, and stores the result in another array B of the same shape as A. The function returns the array B. The function MUST use a nested loop to access the individual entries of A and B.
Task 2. Write a vectorised version of the previous function, evaluate_function_vectorized(function, A) that applies function to A to generate the array B without using any loop.
Task 3. Write code to check that the result of the two functions (e.g., non-vectorised versus vectorised) is the same as the following two-dimensional array:
\n0.2−1.341.4312.4−1.55.23−1.0−1.55.455.780.1−2.23
\n注意
\nPlease note that Task 3 will NOT be auto-tested, so please contact your tutor if you struggle while trying to solve this task.
\nAs we saw in week 6 lecture, data analysis problems will typically require you to:
\nAs we covered in Lecture 7, the pandas library provides a set of convenient tools to implement these tasks.
\nFor example, reading a CSV file into a so-called pandas DataFrame is as simple as:
import pandas as pd\ncovid_data = pd.read_csv(\"03-25-2022.csv\")Once you have imported the CSV file into a DataFrame, you can do many different operations with it.
See Lecture 7 slides and accompanying code examples for more details.
\nIn the rest of the lab, you will have to solve three more advanced programming problems. We don't expect everyone to finish all these problems during the lab time. If you do not have time to finish them in the lab, you should continue working on them later.
\nA diagonal matrix is a square table of numbers such that only elements on the diagonal are non-zero. Square means that it has the same number of rows as columns. If we call this matrix M, then the elements on the diagonal are those where row index equals column index, that is, M[i,i].
This property can be generalised to the concept of diagonality.A matrix M has diagonality d if M[i,j] != 0 only in positions such that the absolute difference between i and j is strictly less than d, i.e.,
∣i−j∣<d
\nIn other words, d is equivalent to the maximum ∣i−j∣ among all nonzero elements plus one.
\nTo-think: According to this general definition of diagonality, what would be the diagonality of a diagonal matrix?
\nFor example, this matrix has diagonality d=3 (Think why!):
\n[
\n\\begin{bmatrix}
\n1 & 2 & 3 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
\n4 & 5 & 6 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
\n7 & 8 & 9 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
\n0 & 0 & 0 & 1 & 2 & 0 & 0 & 0 & 0 & 0 \\
\n0 & 0 & 0 & 3 & 4 & 0 & 0 & 0 & 0 & 0 \\
\n0 & 0 & 0 & 0 & 0 & 1 & 2 & 3 & 0 & 0 \\
\n0 & 0 & 0 & 0 & 0 & 4 & 5 & 6 & 0 & 0 \\
\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 2 \\
\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 4 \\
\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 5 & 6 \\
\n\\end{bmatrix}
\n]
\nWrite a function diagonality(matrix) which takes as argument a matrix (represented as a rank-2 NumPy array) and returns the smallest dd such that matrix has diagonality d.
相关信息
\nHint: the diag numpy function may help you out our solving this problem. In any case, it can be solved without that function.
Write a function which takes as an argument a 1D NumPy array (vector) of length n and returns a square 2D NumPy array (matrix) with n rows and n columns defined as follows. Row 0 of the matrix is identical to the input vector. Row 1 is formed by shifting all elements of the vector one position to the right and move the last element into the first element. Row 2 is formed by applying this shift to Row 1. And so on until the last row.
For example, if the input vector is np.array([1,2,3]), then the output 2D array should be np.array([[1,2,3],[3,1,2],[2,3,1]]).
Requirements:
\nThis programming problem ask you to write code to analyze COVID-19 CSV data files. The basics on the format of these files and how to process them were covered during week 6 lecture. See also the section above on data analysis with CSV files for a quick recap. For completeness, below, after the task statements, you will see a detailed explanation on the format of the COVID-19 CSV data files. We provide three different CSV example files in order to help you test your code, although we might test the code with different data files.
\nYou can solve the following tasks using list of lists (like in week 6 lecture) or using the Pandas library (week 7 lecture).
\n相关信息
\nYou may download the csv files to get a better look at the format. Alternatively, you may type less 09-11-2020.csv into the terminal to explore the contents of the files there.
Task 1. Write a function, get_num_deaths_per_state_and_territory(csv_filename), that given the name of a COVID-19 CSV data file, returns two lists. The first list should be a list of integers containing the number of COVID-19 deaths per Australian state and territory in descending order, and the second list, a list of strings with the corresponding state and territory names.
相关信息
\nHint: you can use the sorted Python built-in function to sort a list of tuples in descending order. To see why this might be helpful, try to understand how comparison operators (e.g., < or >) work with tuples composed of the number of deaths and the name of the state or territory corresponding to that number.
Task 2. Write a function, get_country_new_cases(countryname,csv_filename1,csv_filename2), that given the name of a country, and the name of two COVID-19 CSV data files, returns the number of new COVID-19 cases among the two dates corresponding to the files. You can safely assume (1) the first file to be associated to a previous date than the second; (2) there exist records for the country specified in both data files. On the other hand, the country's name may be specified by the user with arbitrary case, e.g., aUSTRAlia has to return the same number as Australia or AUSTRALIA.
Each CSV file is named MM-DD-YYYY.csv, and contains the statistics up to that day for every country or region in the world with at least one recorded case. For many countries/regions, the statistics are broken down into states/provinces. For example, within Australia we have data for each state and territory (such as “Australian Capital Territory”, “Victoria”, etc). For the US, the data is even further broken down into Counties.
Each MM-DD-YYYY.csv file has a header line with names of the columns (see below). The following lines contain actual data. The meanings of the columns are:
FIPS: US only. Federal Information Processing Standards code that uniquely identifies counties within the USA. For other countries/regions, this column will be empty.Admin2: County name. US only. For other countries/regions, this column will be empty.Province_State: Province, state or dependency name for those countries/regions that we have breakdowns per state/province (e.g. Australia, China, Germany, etc.). For other countries without such a breakdown, this column will be empty.Country_Region: Country, region or sovereignty name. The names of locations correspond with the official designations used by the U.S. Department of State.Last_Update: Last time that the entry was updated, in the format YYYY-MM-DD HH:mm:ss (24 hour format, in UTC).Lat and Long_: Dot locations on the dashboard. All points (except for Australia) shown on the map are based on geographic centroids, and are not representative of a specific address, building or any location at a spatial scale finer than a province/state. Australian dots are located at the centroid of the largest city in each state.Confirmed: Total number of confirmed (positive) cases up to the corresponding day shown in the CSV file name.Deaths: Total number of deaths up to the corresponding day shown in the CSV file name.Recovered: Total recovered cases. However, this field is no longer updated due to the unreliability of the data source. Therefore, you can assume that this column will be empty for all lines in the CSV file. It is just still there for compatibility of older versions of the data.Active: Active cases = total cases - total recovered - total deaths. However, this field is no longer updated due to the unreliability of the data source. Therefore, you can assume that this column will be empty for all lines in the CSV file. It is just still there for compatibility of older versions of the data.Combined_key: combined name in the format \"Province_State, Country_Region\" (for US this will be \"Admin2, Province_State, Country_Region\"). For those countries without breakdowns, Combined_Key is equal to Country_Region. Combined_key will be distinct for different lines of the file. That’s why it’s called a “key”.Incident_Rate: Total number of all cases to date per 100,000 people.Case_Fatality_Ratio: Number of deaths divided by number of cases in percentage. That means, this value is equal to Deaths / Confirmed * 100%.As an example, let’s look at this one line in a file named 09-14-2021.csv:
,,Australian Capital Territory,Australia,2021-09-15 03:22:37,-35.4735,149.0124,665,3,,,\"Australian Capital Territory, Australia\",155.33753795842094,0.45112781954887216This means that until Sept 14th 2021, in the state Australian Capital Territory of the country Australia, there are a total of 665 COVID-19 cases from the beginning of the pandemic (column Confirmed), 3 among them are dead (column Deaths); on average there are 155.33 confirmed cases out of 100,000 people (column Incident_Rate); 0.45% of infected people are dead (column Case_Fatality_Ratio, which should be equal to Deaths divided by Confirmed * 100%). This record was updated on 2021-09-15 03:22:37, UTC time.
If you’re interested, you can find more data files to test your code on the GitHub repository of Johns Hopkins University.
\n\nimport numpy as np\nimport pandas as pd\nimport math\nimport matplotlib.pyplot as plt\n\n# ===== 3. Rank-1 arrays =====\ndef evaluate_h(a, b, N):\n if N <= 1:\n raise ValueError(\"N must be > 1\")\n x = np.zeros(N, dtype=float)\n y = np.zeros(N, dtype=float)\n step = (b - a) / (N - 1)\n for i in range(N):\n xi = a + i * step\n x[i] = xi\n y[i] = (1.0 / math.sqrt(2*math.pi)) * math.exp(-0.5 * (xi**2))\n return x, y\n\ndef evaluate_h_vectorized(a, b, N):\n if N <= 1:\n raise ValueError(\"N must be > 1\")\n x = np.linspace(a, b, N, dtype=float)\n y = (1.0 / math.sqrt(2*math.pi)) * np.exp(-0.5 * (x**2))\n return x, y\n\ndef plot_h(filename, a, b, N, use_vectorized=True):\n if use_vectorized:\n x, y = evaluate_h_vectorized(a, b, N)\n else:\n x, y = evaluate_h(a, b, N)\n import matplotlib.pyplot as plt\n plt.figure()\n plt.plot(x, y)\n plt.grid()\n plt.savefig(filename)\n plt.close()\n\n# ===== 4. Rank-2 arrays =====\ndef evaluate_function(function, A):\n A = np.asarray(A)\n m, n = A.shape\n B = np.zeros_like(A, dtype=float)\n for i in range(m):\n for j in range(n):\n B[i, j] = function(A[i, j])\n return B\n\ndef evaluate_function_vectorized(function, A):\n A = np.asarray(A)\n return function(A)\n\n# ===== 6.1 Diagonality =====\ndef diagonality(matrix):\n M = np.asarray(matrix)\n nz = np.argwhere(M != 0)\n if nz.size == 0:\n return 0\n max_band = 0\n for i, j in nz:\n band = abs(int(i) - int(j))\n if band > max_band:\n max_band = band\n return max_band + 1\n\n# ===== 6.2 Cyclic shifts =====\n# \ndef cyclic_shifts_rightwards(vec):\n v = np.asarray(vec)\n if v.ndim != 1:\n raise ValueError(\"Input must be a 1D NumPy array\")\n n = v.shape[0]\n return np.vstack([np.roll(v, k) for k in range(n)])\n\nimport numpy as np\n\ndef cyclic_shifts_rightwards(vec):\n v = np.asarray(vec)\n if v.ndim != 1:\n raise ValueError(\"Input must be a 1D NumPy array\")\n n = v.shape[0]\n if n == 0:\n # 返回 2D 空矩阵，形状 (0, 0)，满足测试要求\n return np.empty((0, 0), dtype=v.dtype)\n return np.vstack([np.roll(v, k) for k in range(n)])\n\n\n# ===== 6.3 COVID-19 =====\ndef _read_covid_csv(csv_filename):\n df = pd.read_csv(csv_filename, dtype={\"FIPS\": str}, keep_default_na=False)\n for col in [\"Confirmed\", \"Deaths\"]:\n if col in df.columns:\n df[col] = pd.to_numeric(df[col], errors=\"coerce\").fillna(0).astype(int)\n return df\n\ndef get_num_deaths_per_state_and_territory(csv_filename):\n df = _read_covid_csv(csv_filename)\n m_country = df[\"Country_Region\"].str.lower() == \"Australia\".lower()\n sub = df[m_country].copy()\n grouped = (\n sub.groupby(\"Province_State\", dropna=False)[\"Deaths\"]\n .sum()\n .reset_index()\n )\n grouped = grouped.sort_values([\"Deaths\", \"Province_State\"], ascending=[False, True])\n deaths = grouped[\"Deaths\"].astype(int).tolist()\n state_names = grouped[\"Province_State\"].astype(str).tolist()\n return deaths, state_names\n\ndef get_country_new_cases(country_name, csv_filename1, csv_filename2):\n def _country_confirmed_total(name, path):\n df = _read_covid_csv(path)\n mask = df[\"Country_Region\"].str.lower() == name.lower()\n return int(df.loc[mask, \"Confirmed\"].sum())\n c1 = _country_confirmed_total(country_name, csv_filename1)\n c2 = _country_confirmed_total(country_name, csv_filename2)\n return int(c2 - c1)怎么复现实验（最短路径）：
\n复制上面的代码到你的 .py 或 Notebook。
运行以下测试片段：
\n# 3.2 绘图\nplot_h(\"h_80_points.png\", -4, 4, 80)\n\n# 4.2 校验\nA = np.array([[0.2,12.4,-1.0,5.78],[-1.34,-1.5,-1.5,0.1],[1.43,5.23,5.45,-2.23]])\nassert np.allclose(evaluate_function(lambda u:u, A),\n evaluate_function_vectorized(lambda u:u, A))\n\n# 6.1 对角性\nassert diagonality(np.diag([1,2,3,4])) == 1\n\n# 6.2 环移\nassert np.array_equal(cyclic_shifts_rightwards(np.array([1,2,3])),\n np.array([[1,2,3],[3,1,2],[2,3,1]]))\n\n# 6.3 COVID（用你的 CSV 路径）\ndeaths, states = get_num_deaths_per_state_and_territory(\"/mnt/data/09-11-2020.csv\")\nnew_cases = get_country_new_cases(\"Australia\", \"/mnt/data/09-11-2020.csv\", \"/mnt/data/09-11-2021.csv\")AI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n在上一讲中，我们已经学习了正则中和一些元字符相关的内容。这一节我们讲一下正则中的三种模式，贪婪匹配、非贪婪匹配和独占模式。
\n这些模式会改变正则中量词的匹配行为，比如：
\n如果不知道贪婪和非贪婪匹配模式，我们写的正则很可能是错误的，这样匹配就达不到期望的效果了。
\n由于本节内容和量词相关的元字符密切相关，所以我们先来回顾一下正则中表示量词的元字符。
\n在这 6 种元字符中，我们可以用 {m,n} 来表示 （*）（+）（?） 这 3 种元字符：
表示量词的星号（*）和 加号（+）可能没你想象的那么简单，我用一个例子给你讲解一下。我们先看一下加号（+），使用 a+ 在 aaabb 中查找，可以看到只有一个输出结果：
对应的 Python 代码如下：
\n>>> import re\n>>> re.findall(r'a+', 'aaabb')\n['aaa']加号应该很容易理解，我们再使用 a* 在 aaabb 这个字符串中进行查找，这次我们看到可以找到 4 个匹配结果。
使用 Python 示例如下，我们可以看到输出结果，也是得到了 4 个匹配结果：
\n>>> import re\n>>> re.findall(r'a*', 'aaabb')\n['aaa', '', '', '']但这一次的结果匹配到了三次空字符串。为什么会匹配到空字符串呢？因为星号（*）代表 0 到多次，匹配 0 次就是空字符串。到这里，你可能会有疑问，如果这样，aaa 部分应该也有空字符串，为什么没匹配上呢？
这就引入了我们今天要讲的话题，贪婪与非贪婪模式。这两种模式都必须满足匹配次数的要求才能匹配上。贪婪模式，简单说就是尽可能进行最长匹配。非贪婪模式呢，则会尽可能进行最短匹配。正是这两种模式产生了不同的匹配结果。
\n首先，我们来看一下贪婪匹配。在正则中，表示次数的量词默认是贪婪的，在贪婪模式下，会尝试尽可能最大长度去匹配。
\n首先，我们来看一下在字符串 aaabb 中使用正则 a* 的匹配过程。
a* 在匹配开头的 a 时，会尝试尽量匹配更多的 a，直到第一个字母 b 不满足要求为止，匹配上三个 a，后面每次匹配时都得到了空字符串。
相信看到这里你也发现了，贪婪模式的特点就是尽可能进行最大长度匹配。所以要不要使用贪婪模式是根据需求场景来定的。如果我们想尽可能最短匹配呢？那就要用到非贪婪匹配模式了。
\n那么如何将贪婪模式变成非贪婪模式呢？我们可以在量词后面加上英文的问号 (?)，正则就变成了 a*?。此时的匹配结果如下：
>>> import re\n>>> re.findall(r'a*', 'aaabb') # 贪婪模式\n['aaa', '', '', '']\n>>> re.findall(r'a*?', 'aaabb') # 非贪婪模式\n['', 'a', '', 'a', '', 'a', '', '', '']这一次我们可以看到，这次匹配到的结果都是单个的 a，就连每个 a 左边的空字符串也匹配上了。
\n到这里你可能就明白了，非贪婪模式会尽可能短地去匹配，我把这两者之间的区别写到了下面这张图中。
\n为了让你加深理解，我们再来看一个示例，这一次让我们查找一下引号中的单词。
\n从下面这个示例中，我们可以很容易看出两者对比上的差异。左右的文本是一样的，其中有两对双引号。不同之处在于，左边的示例中，不加问号时正则是贪婪匹配，匹配上了从第一个引号到最后一个引号之间的所有内容；而右边的图是非贪婪匹配，找到了符合要求的结果。
\n不管是贪婪模式，还是非贪婪模式，都需要发生回溯才能完成相应的功能。但是在一些场景下，我们不需要回溯，匹配不上返回失败就好了，因此正则中还有另外一种模式，独占模式，它类似贪婪匹配，但匹配过程不会发生回溯，因此在一些场合下性能会更好。
\n你可能会问，那什么是回溯呢？我们来看一些例子，例如下面的正则：
\nregex = \"xy{1,3}z\"\ntext = \"xyyz\"在匹配时，y{1,3}会尽可能长地去匹配，当匹配完 xyy 后，由于 y 要尽可能匹配最长，即三个，但字符串中后面是个 z 就会导致匹配不上，这时候正则就会向前回溯，吐出当前字符 z，接着用正则中的 z 去匹配。
如果我们把这个正则改成非贪婪模式，如下：
\nregex = \"xy{1,3}?z\"\ntext = \"xyyz\"由于 y{1,3}? 代表匹配 1 到 3 个 y，尽可能少地匹配。匹配上一个 y 之后，也就是在匹配上 text 中的 xy 后，正则会使用 z 和 text 中的 xy 后面的 y 比较，发现正则 z 和 y 不匹配，这时正则就会向前回溯，重新查看 y 匹配两个的情况，匹配上正则中的 xyy，然后再用 z 去匹配 text 中的 z，匹配成功。
了解了回溯，我们再看下独占模式。
\n独占模式和贪婪模式很像，独占模式会尽可能多地去匹配，如果匹配失败就结束，不会进行回溯，这样的话就比较节省时间。具体的方法就是在量词后面加上加号（+）。
regex = \"xy{1,3}+yz\"\ntext = \"xyyz\"需要注意的是 Python 和 Go 的标准库目前都不支持独占模式，会报错，如下所示：
\n>>> import re\n>>> re.findall(r'xy{1,3}+yz', 'xyyz')\nerror: multiple repeat at position 7报错显示，加号（+）被认为是重复次数的元字符了。如果要测试这个功能，我们可以安装 PyPI 上的 regex 模块。
注意：需要先安装 regex 模块，pip install regex\n\n>>> import regex\n>>> regex.findall(r'xy{1,3}z', 'xyyz') # 贪婪模式\n['xyyz']\n>>> regex.findall(r'xy{1,3}+z', 'xyyz') # 独占模式\n['xyyz']\n>>> regex.findall(r'xy{1,2}+yz', 'xyyz') # 独占模式\n[]你也可以使用 Java 或 Perl 等其它语言来测试独占模式，查阅相关文档，看一下你所用的语言对独占模式的支持程度。
\n如果你用 a{1,3}+ab 去匹配 aaab 字符串，a{1,3}+ 会把前面三个 a 都用掉，并且不会回溯，这样字符串中内容只剩下 b 了，导致正则中加号后面的 a 匹配不到符合要求的内容，匹配失败。如果是贪婪模式 a{1,3} 或非贪婪模式 a{1,3}? 都可以匹配上。
这里我简单总结一下，独占模式性能比较好，可以节约匹配的时间和 CPU 资源，但有些情况下并不能满足需求，要想使用这个模式还要看具体需求（比如我们接下来要讲的案例），另外还得看你当前使用的语言或库的支持程度。
\n学习到了这里，你是不是觉得自己对贪婪模式、非贪婪模式，以及独占模式比较了解了呢？其实在使用过程中稍不留神，就容易出问题，在网上可以看到不少因为回溯引起的线上问题。
\n这里我们挑选一个比较出名的，是阿里技术微信公众号上的发文。Lazada 卖家中心店铺名检验规则比较复杂，名称中可以出现下面这些组合：
\n&”，“-”，“_”等。负责开发的小伙伴在开发过程中使用了正则来实现店铺名称校验，如下所示：
\n^([A-Za-z0-9._()&'\\- ]|[aAàÀảẢãÃáÁạẠăĂằẰẳẲẵẴắẮặẶâÂầẦẩẨẫẪấẤậẬbBcCdDđĐeEèÈẻẺẽẼéÉẹẸêÊềỀểỂễỄếẾệỆfFgGhHiIìÌỉỈĩĨíÍịỊjJkKlLmMnNoOòÒỏỎõÕóÓọỌôÔồỒổỔỗỖốỐộỘơƠờỜởỞỡỠớỚợỢpPqQrRsStTuUùÙủỦũŨúÚụỤưƯừỪửỬữỮứỨựỰvVwWxXyYỳỲỷỶỹỸýÝỵỴzZ])+$这个正则比较长，但很好理解，中括号里面代表多选一，我们简化一下，就成下面这样：
\n^([符合要求的组成1]|[符合要求的组成2])+$脱字符（^）代表以这个正则开头，美元符号（$）代表以正则结尾，我们后面会专门进行讲解。这里可以先理解成整个店铺名称要能匹配上正则，即起到验证的作用。
你需要留意的是，正则中有个加号（+），表示前面的内容出现一到多次，进行贪婪匹配，这样会导致大量回溯，占用大量 CPU 资源，引发线上问题，我们只需要将贪婪模式改成独占模式就可以解决这个问题。
我之前说过，要根据具体情况来选择合适的模式，在这个例子中，匹配不上时证明店铺名不合法，不需要进行回溯，因此我们可以使用独占模式，但要注意并不是说所有的场合都可以用独占模式解决，我们要首先保证正则能满足功能需求。
\n仔细再看一下 这个正则，你会发现 “组成 1” 和 “组成 2” 部分中，A-Za-z 英文字母在两个集合里面重复出现了，这会导致回溯后的重复判断。这里要强调一下，并不是说有回溯就会导致问题，你应该尽量减少回溯后的计算量，这些在后面的原理讲解中我们会进一步学习。
\n另外，腾讯云技术社区也有类似的技术文章，你如果感兴趣，可以点击这里进行查看。
\n说到这里，你是不是想起了课程开篇里面提到的一句话：如果你有一个问题，你想到可以用正则来解决，那么你有两个问题了。
\n\n\nSome people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems.
\n
所以一个小小的正则，有些时候也可能会把 CPU 拖垮，这也提醒我们在写正则的时候，一定要思考下回溯问题，避免使用低效的正则，引发线上问题。
\n最后我来给你总结一下：正则中量词默认是贪婪匹配，如果想要进行非贪婪匹配需要在量词后面加上问号。贪婪和非贪婪匹配都可能会进行回溯，独占模式也是进行贪婪匹配，但不进行回溯，因此在一些场景下，可以提高匹配的效率，具体能不能用独占模式需要看使用的编程语言的类库的支持情况，以及独占模式能不能满足需求。
\n最后，我们来做一个小练习吧。
\n有一篇英文文章，里面有很多单词，单词和单词之间是用空格隔开的，在引号里面的一到多个单词表示特殊含义，即引号里面的多个单词要看成一个单词。现在你需要提取出文章中所有的单词。我们可以假设文章中除了引号没有其它的标点符号，有什么方法可以解决这个问题呢？如果用正则来解决，你能不能写出一个正则，提取出文章中所有的单词呢（不要求结果去重）？
\n\n\nwe found “the little cat” is in the hat, we like “the little cat”
\n其中 the little cat 需要看成一个单词
\n
好了，今天的课程就结束了，希望可以帮助到你，也希望你在下方的留言区和我参与讨论，并把文章分享给你的朋友或者同事，一起交流一下。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是 Cleland。受悦创的邀请，今天我来和你聊聊我是怎么学习和使用正则的。
\n刚工作那会儿，因为密集用到正则表达式，所以我花了不少时间去钻研正则相关的问题。到如今，许多年过去了，这些东西还历历在目，我也很乐意拿出来和你分享一下，希望在学习正则的道路上，能给你一些启发。
\n我经常在网上看到，许多⼈抱怨正则表达式“难学”，我知道，它确实不好学。但同时，我也去看过大家的抱怨，发现和我之前的做法⼀样：用到什么功能，就去网上搜⼀个例⼦来改改，能跑通就满意。至于这例子到底如何构成的，自己是不是都懂了，其实心里没底，能大概看懂五六分，就已经很满足了。
\n这样浮光掠影的使用方法或许能解决眼前的问题，但⼀定不算“学会”。它有点像打井，每次挖到⼀点水就满足了，根本不管有没有持续性，也不关心挖没挖到含水层。结果就是，每次要喝水的时候，你都得重新打⼀眼井。
\n那么对于正则表达式，我们有没有可能打出一口“永不干涸”的深井呢？当然有，那就是**⼀次性多投入点时间，由表及里，由术及道。一旦掌握了方法，之后就会简单很多了**。
\n按照我的经验，如果每天花一刻钟或者半小时，坚持个把礼拜，通常都能登堂入室，达到“不会忘”的境界。不要以为这时间很多，我知道有些人很喜欢找“正则表达式五分钟入门”，其实每次都没有入门，日积月累，反而浪费了几十甚至上百个五分钟。
\n那多投入时间很好理解，但是什么叫掌握方法呢？用我的话说，就是摆脱了字符的限制，深入到概念思维的层面。不要盯着那些鬼画桃符⼀般的字符和表示法皱眉，要摆脱桃符，把真正的“鬼”给认出来——虽然它们不那么容易看见。 也正因为这样，我们才需要⼀次性多投入点时间。
\n那最终怎样才算“入门”了呢？按照我的经验，就是通过学习掌握方法，后来无论用正则表达式解决什么问题，都能自发遵循下面的流程去走，甚至能达到不需要这个流程，也能做到解决问题，那基本上就算入门了。
\n第⼀步，做分解：拿到一个问题后，我们要先思考：这个问题可以分为几个子问题？每个子问题是否独立？我们拿最常见的电子邮件地址匹配来说。从文本结构来看，它可以分为“username + @ + domain name”这三个独立的部分。怎么画呢？我们可以先画出逻辑结构图。通过这个过程来厘清思路。当然，这是软件⼯程最基本的思路，相信你做起来应该问题不大。
第⼆步，分析各个子问题：某个位置上可能有多个字符？那就用字符组。某个位置上可能有多个字符串？那就用多选结构。出现的次数不确定？那就用量词。对出现的位置有要求？那就用锚点锁定位置…… 某种程度上，这就像武术里的见招拆招，每个问题都有对应的解法，只要熟练掌握了，知道什么时候用字符组，什么时候用多选结构，什么时候用量词，什么时候用锚点，就很容易搭建起完整的概念模型。
\n第三步，套皮：你大概注意到了，到现在，我们还没有谈论正则表达式的典型标志，比如方括号、星号、花括号。要知道，这些典型标志无非只是一些符号而已，真正重要的是字符组、多选结构、量词等等这些概念。一旦你的概念模型清楚了，写出正则表达式就非常简单了，无非是查阅语法手册，把之前得到的概念模型按照对应语言或工具的约定写下来而已。
\n许多人觉得正则表达式难懂，总是纠缠于“这里为什么要多一个星号？那里为什么是方括号而不是花括号？”，原因恰恰在于对概念模型不清楚。虽然各种语言或工具对正则表达式的支持大同小异，但细微差别仍然不可忽视。不过只要你心怀正念，洞若观火，这些差异其实并不是大问题。
\n第四步，调试：很多人都说，正则表达式的麻烦之处在于它像个黑箱子，很难调试，迄今为止仍然没有特别好用的⼯具，所以我们没法⼀步步跟进去看匹配的具体过程，只能笼统地知道“匹配了”或者“没匹配”。
\n那到底怎么调试呢？我的经验是，复杂⼀点的正则表达式不能⼀次写对，这是很正常的。与其纠结“这个正则表达式看起来这么复杂，此处到底要用星号 * 还是加号 +，不如先搞清楚，星号（ * ）或加号（ + ）限定的到底是正则表达式中的哪一部分，对应要匹配文本中的哪一部分。这两个问题搞清楚了，整个问题就迎刃而解了。
另外，还有⼀点统摄全局的经验想和你说一下， 那就是学会了正则表达式之后，务必要保持克制 。写正则表达式很容易上瘾，毕竟它的功能那么强⼤，处理速度那么快，⼜像天书符咒那样充满了“神秘”色彩。于是，“写⼀条其他⼈看不懂的正则表达式，⼀次性解决所有问题”，就成了某些程序员的执念。但是，从软件工程的角度来看，这种办法绝对是噩梦，不但其他人无法理解，自己过⼀段时间也会挠头。
\n那到底该怎么“克制”呢？我的经验有以下三点。
\n第⼀，能用普通字符串处理的，坚决⽤普通字符串处理。字符串处理的速度不见得差，可读性却好上很多。如果要在大段文本中定位所有的 today 或者 tomorrow，用最简单的字符串查找，直接找两遍，明显比 to(day|morrow) 看起来更清楚。
第⼆，能写注释的正则表达式，⼀定要写注释。正则表达式的语法非常古老，不够直观，为了便于阅读和维护，如今大部分语言里都可以通过 x 打开注释模式。有了注释，复杂正则表达式的结构也能一目了然。
\n第三，能用多个简单正则表达式解决的，⼀定不要苛求用一个复杂的正则表达式。这里最明显的例子就是输入条件的验证。比如说，常见的密码要求“必须包含数字、小写字母、大写字母、特殊符号中的至少两种，且长度在 8 到 16 之间”。
\n你当然可以绞尽脑汁用一个正则表达式来验证，但如果放下执念，⽤多个正则表达式分别验证“包含数字”、“包含小写字母”、“包含大写字母”、“包含特殊符号”这四个条件，要求验证成功结果数大于等于 2，再配合一个正则表达式验证长度，这样做也是可行的。虽然看起来繁琐，但可维护性绝对远远强于单个正则表达式。
\n好了，到此为⽌，我的经验介绍完了，可以交棒了。
\n这些年，很多人问过我，我当时到底是怎么学会正则的？说实话，我那会儿根本没想什么，纯粹出于“干一行爱一行”的朴素想法。要用得多，就找书来，哪怕是囫囵吞枣，也要一鼓作气看完。我一直觉得，真正值得学的东西，没有什么“平滑学习曲线”。在前面的阶段，你总得狠下心来，过了一个又一个坎儿，然后才能有一马平川。
\n我觉得，正则表达式属于“没有维护成本”的技能。一旦学会了，每⼀次遇到这类问题都可以“零成本出击”。所以，长期来看，这绝对是一笔“无本万利”的生意。希望你能通过这个专栏早日达到一马平川！
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n我相信，作为一名程序员或者准程序员，你肯定是知道正则表达式的。作为计算机领域最伟大的发明之一，正则表达式简单、强大，它可以极大地提高我们工作中的文本处理效率。现在，各大操作系统、编程语言、文本编辑器都已经支持正则表达式，甚至我还和我出版图书的编辑开玩笑说，你们也应该好好学学正则这门手艺。
\n但是，当我去和朋友深入聊天的时候，才发现很多人是没有系统学习过正则表达式的，他们和我笑着说，这东西不难，我每次用的时候都是去 Google 搜一搜，然后复制过来改一改，效率特别高，我听完之后哭笑不得。
\n再后来，我给我的私教学员们在课程中讲解了正则表达式，很多学员讲了他们的困惑，我总结了下，主要有 4 点：
\n为什么会出现这些问题呢？我觉得是核心原因主要是以下几点：
\n所以，我打算通过一个课程，用尽可能通俗易懂的方式，系统化地给你梳理和讲解正则的知识点，希望可以帮助你解决上面这些问题，让正则这个强大的工具在你手上发挥出真正的威力。
\n但是呢，真要开始学正则，我想你的心头可能会五味杂陈，内心也是纠结万分。美国一位知名程序员杰米·加文斯基（Jamie Zawinski）说过一句话：如果你有一个问题，你想到可以用正则来解决，那么你有两个问题了。
\n\n\nSome people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems.
\n
这句话流传在程序员中间，给人一种感觉，就是正则是很难掌握和利用好的工具。也正因如此，很多程序员并不愿意去学正则表达式，心里可能是这么想的：我在工作中用到正则的时候并不多啊，要用的时候搜一下就好了啊，为什么还要专门花时间和精力学它呢？
\n但我觉得，真实的情况可能是这样的：不是工作中用不到，而是当你不熟悉一个技能的时候，遇到问题时根本不会考虑它。比如我们要删除掉文本中的所有数字，不知道正则的话，你可能会想到从 0 到 9 这样一个个替换，操作 10 次，但如果知道正则，那么只需要替换一次就可以搞定这个问题。
\n说了这么多，到底什么是正则呢？它能做什么呢？
\n我们先来说概念。正则，就是正则表达式，英文是 Regular Expression，简称 RE。顾名思义，正则其实就是一种描述文本内容组成规律的表示方式。
\n在编程语言中，正则常常用来简化文本处理的逻辑。在 Linux 命令中，它也可以帮助我们轻松地查找或编辑文件的内容，甚至实现整个文件夹中所有文件的内容替换，比如 grep、egrep、sed、awk、vim 等。另外，在各种文本编辑器中，比如 Atom，Sublime Text 或 VS Code 等，在查找或替换的时候也会使用到它。总之，正则是无处不在的，已经渗透到了日常工作的方方面面。
\n简单来说，正则是一个非常强大的文本处理工具，它的应用极其广泛。
\n通过它的功能和分布的广泛你也能看出来，正则是一个非常值得花时间和精力好好学习的基本技能。
\n那么问题来了，想要掌握正则，我们到底要学什么？我在课程中又是怎么安排这些内容的呢？
\n正则的很多基本知识其实并不难，只是难记。不过，记住一个东西并不是我们的最终目的，我们的目的是理解并且会用正则这个工具。
\n比如正则中的各种元字符，在课程中，我会讲有关元字符的记忆技巧，让你不再对元字符感到头疼。再比如各种模式和分组，它们可以在查找和替换时发挥强大的威力。
\n下面我用 Python 语言示例，从文本中找出连续出现的重复单词。我们可以看到，正则可以很方便地搞定这个需求。
\n>>> import re\n>>> test_str = \"the little cat cat in the hat hat.\"\n>>> re.sub(r'(\\w+) \\1', r'\\1', test_str)\n'the little cat in the hat.'但上面的示例在任何情况下都能很好地工作么？我们要不要考虑单词的边界？反向引用又有哪些要注意的点？所有这些问题都会在课程中一一进行讲解。
\n我们经常需要从大段文本中抽取需要的内容，学会使用正则之后，不用写代码就可以完成类似的日常工作。举个例子，假如我们在 Sublime Text 3 中使用正则，查找重复出现的单词，并且想把它替换成单个单词。
\n菜单中的 Find -> Replace，在查找栏中输入 (\\w+) \\1，在替换栏中输入子组的引用 \\1 ，然后点击 Replace All 就可以完成替换工作了。这样，通过少量的正则，我们就完成了文本的处理工作了。是不是很方便呢？
除此之外，我还会在课程中讲一些更高阶的正则内容，这部分主要有正则中的断言（包括单词边界、行开始和结束、环视），三种主要流派的区别以及对应的软件实现，正则的工作机制和常见的优化方式等。
\n掌握这些内容可以让我们更好地理解正则， 也可以避过很多坑。比如，为什么在编程语言中能工作的正则，在 Linux 命令 grep 中就不能工作了呢？正则匹配的原理又是什么？如何写出性能更好的正则呢？
\n综合以上这三点，我希望你能掌握的是正则中一些重要的概念和功能，这是我们学习和使用正则的基础；然后是有关正则的记忆方法，通过合理的方式，事半功倍地达到学习效果，这是我们学习正则的利器；此外，我还会运用大量的示例让你了解正则在实际工作场景中的使用，只有与现实案例结合，我们的学习才不会脱节，这是我们学习正则的原则。
\n明确原则、打好基础、掌握利器，我相信你一定可以拿下正则这项技能，在工作中随心所用。学完后，你一定会觉得，手写正则原来也没有那么难。
\n话不多说，我们这就开始吧！
\n\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n经过了两个多月的课程更新，到此，本专栏课程的内容就已经结束了，在这里我有一些话想告诉你。
\n在更新课程的同时，我看了很多同学的留言，特别是问我的问题。其中有一个点需要表明，在学习的过程中，千万不要纠结于形式（案例），一定要注重内容（思维），比如我是怎么思考某个点的，有哪些合理的地方，有哪些不合理的地方，哪些你能用上，怎么用？只有这样思考，你的进步才会快，你的职场提升才会高效。
\n对于职场人的提升，我可以给你一个这样的公式——思考表达执行上超出预期
\n思考：你要有敏捷的思考能力，我相信未来是属于这种人的。因为对于同样一个问题，你总是能有自己独到的见解，这代表你有深度思考，且这会成为你闪光点，它会潜移默化影响到你工作中的每一个过程。这确实需要平时大量的练习，包括我现在也还在这个路上去学习成长。
\n表达：你要有良好的表达能力，无论是同事还是领导之间的沟通，都要做到没有问题，这里并不是指会说话，而是会表达，敢表达，表达的准确。
\n执行上超出预期：你自己要做到在执行力上非常高效，且超出预期。超出预期的意思是超出领导对你的期望，他要的可能是 1，你要尽力做到 1.2，甚至 1.5，因为 1 谁都能做到，而超出的 0.2 / 0.5 就是你晋升的基础。事事有回应，件件有着落，回应和着落都要超出预期。千万不要当老油条，因为偷懒迟早会被发现的。
\n具体到数据分析这个领域，我也给你列出来了数据分析师的类型以及学习的路径，也推荐了一些较好的书籍。
\n数据分析师的类型大致分为两种：
\n业务型分析师： 对接业务的分析师，主要工作内容是和产品团队一起完成年 KPI ，日常围绕报表、专题报告、汇报运转，比如每天的数据监控和产品的方向建议。
\n数据型分析师： 这类型的数据分析师往往重心在内部数据产品开发上，如数据仓库，数据可视化 BI，自动化监控平台。
\n其中，数据型分析师，其发展方向又可以分为两种：
\n数据研发型：这个发展方向要求你对技术非常熟练，能够通过技术对数据进行分析；
\n算法型：这个发展方向要求你数学功底要好，而且课题的研究能力非常强。
\n那这两种数据分析师类型的学习路径是怎样的呢？
\n先学统计学——数据分析思维——学工具（Excel、PPT、Python、R、Tableau）——学经济学和心理学
\n\n\n推荐书籍：
\n《独立思考：日常生活中的批判性思维》，这本书可以帮你打破惯性的思维模式，突破思维上的误区与局限，训练理性与逻辑能力，让你做出最正确的判断与决策，可以让你看得更高，走得更远。
\n《京东平台数据化运营》这本书公开了京东平台的许多实操案例，例如关于 App 端、微信端、手机 QQ 端等无线流量的详细介绍。此外，还有关于优化搜索流量的方法和步骤，以及关于转化率相关指标的优化方法。本书贴近真实业务，有不少方法可以套用。
\n《机器学习》数据分析师必须要懂点算法的知识，这是人工智能领域的一本入门教材。
\n
先学统计学——数据分析思维——学工具（Hadoop，Spark，Hive，Java）多学技术语言
\n\n\n推荐书籍：
\n《大数据之路》系统地从规范、模型、平台、应用等多层次对阿里大数据产品实践做了一遍梳理，通俗易懂地介绍了大数据平台的架构。
\n《数据仓库工具箱》涉及的行业较多，从不同角度体现了数据仓库的各个方面，对维度建模知识讲得很透彻。
\n
悦创老师写这个课程只是为你提供了一些思维的敲门砖，要想有真正的进步和成长，23 课时的学习肯定是不够的，你可以按照自己的发展方向去学习相对应的技能。这里再强调下，学习的过程中一定要多思考，多交流，也只有这样才能沉淀出自己的方法论。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n从这一课时开始，我们就正式进入数据分析师的自我修养，所以我们的内容会更加轻松一点并带有很强的个人主观理解。
\n本课时内容分为两部分：
\n行业分析目标；
\n电商行业分析举例；
\n首先说下行业分析的背景，行业分析有两种背景：
\n当前公司准备进入某行业，需要分析师或者战略部门给出一份详细报告；
\n当公司业务发展遇到瓶颈，需要分析师去验证当前市场对产品的需求有无变化。
\n对于行业分析，我们的讲解也是按照前面第 16 课时“问题的定义与拆解”逻辑展开，问题的识别与拆解对于解决行业分析目标是非常有帮助的。
\n从行业分析的背景来看，目标基本上分为两种：
\n转型，希望通过行业分析看一下公司转型到某个行业有没有一些切入点；
\n用户需求整体的行业分析，比如看用户的需求还在不在。
\n在这两种分析目标的基础之上，我们可以分为五大模块，如下图所示。
\n第一个是界定范围，第二个是市场规模，第三个是社会热点事件，第四个是头部玩家，第五个是未来预测。你可能看到过非常多的行业分析报告，比如介绍头部玩家的时候，把头部的 App 整体描述了一遍，实际上没有必要，也没有价值。你只要把范围、市场规模、社会热点事件、头部玩家、未来预测说出来即可。行业分析报告不在于大而全和什么方法，而在于有所发现（切入点）。
\n我以电商行业举一个例子，因为现阶段电商比较成熟。
\n背景：公司近期试水做电商业务，管理层知道很难做，但是决策层又想找一些切入点。这个时候就找战略部，希望战略部能给出一些建议。
\n一般在做这件事的时候，你不要指望决策层或者管理层给你很多信息，实际上需求都比较模糊。因为在做行业分析这件事上，想找到一个人很好地把需求描述清楚是很难的，因为大家都是在摸着石头过河。
\n我们做行业分析的时候，一般都是这样一个节奏：
\n一周内快速出一些报告，拿着报告去和需求方沟通，这样可以避免一个月后做的专题分析不是对方想要的。
\n在与需求方对的基础上，把不确定的点剔除，把很明确的点确定，然后继续深挖。
\n按照前面我们所说的五大模块，一个一个来看。
\n首先是界定范围。什么意思呢？就是要在全局视野下找切入点。比如现在是电商，首先我们要总结出这样一个电商产业链的图谱，如图所示。
\n产业链图谱内容包含很多信息，比如，老牌成熟的电商企业有哪些？新型的电商企业又有哪些？其中微商，二手电商有哪些？同时围绕电商，它的上游供应商是什么？下游又有哪些代理运营商？在这个过程中，它的支付方式及物流是如何？然后是消费者相关情况，消费者这一块又跟渠道挂钩，所以产业链图谱的内容非常全。在产业链图谱的基础上，你看整个行业就比较清晰，否则你直接上来就是淘宝、京东、唯品会，那你的视野就已经被局限死了。
\n有了这个产业链图谱，给管理层看完后，比如他想做移动类的综合类电商，比如说手淘、京东、拼多多，这就是界定范围。那我们后面的报告内容就可以围绕这个点去切入，所以在这一块，先把对象明确清楚，找到切入点。
\n市场规模这部分，我们分为交易额和用户分析，具体如下。
\n大部分报告的市场规模，都是给的交易额描述，如图所示。
\n这是网络零售市场的交易额曲线，以及它在移动端的占比。通过这张图我们可以很明显发现：网络零售市场的趋势是上升的，只不过它的增长率是下降的，同时移动端的交易额也是在上升的。但是作为分析师，一定要看得更细，一定要有独立思考。就交易额逐年上升结论来说，更加重要的是要找到谁增长？是所有都增长还是有一些涨有些跌？在当前增长率持续下降的情况下，还有谁逆势上升？这就是我们的拆解思想。
\n基于交易额逐年上升，那对于阿里、京东、拼多多三家公司来说，它们的趋势图是什么样子呢？因为我们前面针对的对象就是这三家公司，然后你可以去查下三家公司的财报，如图所示。
\n我们就发现，比如阿里 17 年的 GMV 和 18 年的 GMV 对比，涨了 27%。对于京东，第三季度的 GMV 同比增长 30.5%。而对于拼多多就是 Q3 过去 12 个月的一个同比增长 386%。你可能会疑问这些统计时间段不一致，是否会有影响。其实每一家公司，它拥有数据的信息量不一样，所以只要是对比本身的逻辑没问题就行。注意，数据分析有直接数据和间接数据两种支持方式，只要说明问题即可。所有的资料都要注意口径和原始数据搜集，即使 Copy 也要找权威的数据源。
\n那么基于这个图，我们发现拼多多才是颠覆者，增长了 386%，这是非常夸张的。而阿里、京东已经比较成熟了，所以它们的涨幅差不多，所以不用刻意去纠结。基于交易额的规模，我们得出了拼多多才是颠覆者的结论，所以后面我们重点研究的对象是拼多多。
\n下面就是用户数的描述，大部分报告中的用户描述是这样的图，如下图左侧所示。
\n预计 2018 年中国移动电商用户超 5 亿人，通过这张图可以得出两个结论：
\n移动电商用户数一直在增长；
\n移动电商用户数增长率逐年下降。
\n那么通过这张图实际上就有一个疑问：移动中国的人口年龄分布（上图右侧），移动电商用户数占比 36%，即使按照 16-59 周岁群体占比也只有 55%，从数据上看，这个行业还是有很大缺口。
\n上面只是描述，下面我们要进一步分析。首先我看了一下目前国内的网民数情况，如图所示。
\n我们国家总人数约为 14 亿人，网民数只有 8 个亿，而移动互联网是 7.9 亿，基本上持平。那说明网民数占比人口数 57%（8/14），这个数字并没有想象的那么高，未来仍然有很多用户可以争夺。
\n其次我们发现，移动互联网用户数占网民数的 98% （7.88/8.02），从这个角度来看，移动互联网已经完全可替代 PC ，也就是说我们瞄准的对象是手机终端。
\n最后，我们又发现了一个数据。这是中国互联网信息中心发布的中国网民的一个报告，如下图所示。
\n中国目前网民当中，71% 的人会产生网络购物，而用短视频的网民竟然占 74.1%。也就是说，我们之前猜测剩下的潜在用户（100-71=29%）可能在短视频里面。
\n对于一般的分析报告，我们看出他的市场规模偏描述性统计。而作为分析师一定要在这个数据上深挖，在这个过程中，你要先知道你的目的是什么，然后你自己去找一些数据，而不是别人给你什么数，你就直接用什么数。对于市场规模，我们就已经得出几个点了，如下：
\n拼多多是颠覆者，它代表了一种增长趋势；
\n网民数占比人口数 57%，这个数字并没有想象的那么高，未来仍然有很多用户可争夺（厂商）；
\n我国有71% 的网络购物网民，用短视频的网民竟然占 74%，猜测剩下的潜在用户（29%）在短视频里面。
\n因为前面我们已经明确了拼多多，所以我们就针对拼多多。我们来看下拼多多的发展历程，如下所示。
\n15 年 9 月份，个人公众号上线，上线后发展极速。16 年单日流水破 2 亿，并且用户数破 2 亿。17 年用户破 3 亿，这是非常恐怖的。
\n所以我们接下来重点看 16 年和 17 年，社会到底发生了什么事情？首先我看了一下 17 年各个省市的人均可支配收入，如图所示。
\n我们发现除了上海、北京、浙江等经济大省。其他一个人均可支配收入也就 2 万块钱。所以通过这张图，我们可以发现用户是真的没钱，而市场上大家都在做一些比较高端的 App ，离用户太远了，大多数用户真的是没钱。
\n第二个社会热点事件是微信的日活，如图所示。我们发现 16 年到 17 年，微信的日活涨得非常猛。微信以及微信支付重构了用户的社交方式。
\n第三个社会热点事件就是物流。因为对于电商来说，物流是非常重要的一环。
\n我发现 16 年和 17 年的物流总费用与 GDP 的比例低于 15 年，为何商品很便宜（ 9.9 块包邮），因为整个社会物流效率都有很明显的提升，未来人工智能的介入，这个数字应该还会更低。
\n社会热点事件这一部分，并不是什么热点事件都看，而是要看跟我们分析对象有关的热点事件，然后用这些数据结论来支撑。
\n头部玩家这部分，我们就针对拼多多的产品和用户进行分析。
\n商品以日常生活用品为主（纸巾），价格很便宜。
\n当你点进来之后，比如说直接拼单，然后它那里写了一个“还差一个人拼成”，并且每一次都是这样。还差一个人不就是你了吗？然后你点拼单，直接下一步之后。你会发现，上图第三个界面是不是特别简单？如果你去对比一下手淘和京东，你会发现它非常简单粗暴，就一个购买数量和一个支付方式，而且支付方式默认是微信支付。微信支付现在已经非常普及了，所以基本上用户选的就是一个购买数量，加减即可。最下面有一大片的空白区域，什么也不放，就让你直接点下一步。
\n同时当你点击立即支付的时候，我发现这个点它也做得很细节，上图第四个界面有一个姓名，像淘宝首次购物的支付页面，姓名要自己输。它这里不是，它这里直接是你的微信号昵称。然后在地区这一块，我不知道它是不是能拿到一些数据，地域选择那里默认的方式刚好是我所在的地域。基本上用户不用干什么就下单了，整个过程可能不到一分钟，你的东西就买完了。
\n这其中还有一个细节，第一界面里面我勾了一个圈——搜索。它的搜索功能实际上非常轻，它的搜索是在底层，目的是尽量让用户懒起来。当你进入这个 App，我跟你说那些东西好，你直接买就行，你也不用在这逛什么，买完下次再来。
\n所以拼多多，我们通过体验一下就可以发现，它整个体验非常讲究，特别是对用户的时间成本控制很讲究。这就是拼多多的产品分析，大家在体验 App 的时候，都可以从不同的角度去分析。
\n在用户分析这一块，我们不要摆用户的地域、年龄等信息。我们要摆能说明我们想要的信息，如图所示。
\n这里我想看一下用户为什么买拼多多，调查后发现有 41% 的用户原来在淘宝或者超市买，但是在拼多多更便宜就选择了拼多多。这对于直接竞品淘宝和京东来说，简直损失惨重。
\n同时通过上图发现，实际上拼多多的用户，一线二线的占比已经超过 40% 了，这真的不只是便宜货这么简单，其中还有一些人性的东西。所以我个人会觉得未来会出现更多的拼多多的产品。这个市场需求是非常大的，现阶段并不是特别成熟。
\n第二个就是老大老二打架，老三很有可能会挂。我们发现拼多多与淘宝、京东、天猫的相似度远远没有唯品会高。拼多多与唯品会的重合度就是在地域方面，或者说画像上。因为唯品会实际上已经做了很多年，现在又突然跟拼多多很像，而拼多多当前又是处于一个非常强势的时期，所以唯品会确实要去思考一下自己的战略。而京东和天猫会形成一个很明显的正面竞争局面。
\n第三个就是零售的本质还是多、快、好、省。
\n京东是物流快和好。
\n淘宝天猫是多和好。
\n拼多多是省和供应链快（类似于沃尔玛）。
\n最后，我们整体复盘一次。首先行业分析一定要有分析目标，背景是我们准备试水做电商，我们的目标是看当前还有没有切入点，以及有没有市场空间。通过界定范围，市场规模，热点事件以及头部玩家玩法，我们可以得出以下几点结论：
\n当前对于电商这个领域。仍然有大量的用户还没有进入，还有非常大的增量空间，注意这里不是存量空间，是增量空间；
\n当前国内的网民数还真不是像大家想得那么多，未来厂商的争夺会更加激烈；
\n短视频是非常好的一个渠道，或者说入口；
\n当前，国内在人均可支配收入上面不足。大部分都是 2 万元左右，也就是说未来的用户仍然会追求性价比；
\n对于拼多多 App，因为它用户的教育程度，各方面以及低于它的所见所识，相对来说都要比手淘京东要差一点。所以未来在做面向该类群体做产品的时候，要结合该类用户的特征，比如说你的产品要尽量简单粗暴，让用户快速下单；
\n对于唯品会，未来拼多多对唯品会的威胁可能会大一点。
\n基于这几个观点，我们就可以形成一些建议了，然后把这些建议给管理者看一下，他们觉得是否可行。因为我们已经有了一些数据源支撑，同时在这个数据源的基础之上，我们有一些自己的观点，这个最重要。做完行业分析后，你自己都会觉得非常有意思，因为你发现了别人一些没有发现的点，这里面最重要的就是要沉下心。
\n最后我也推荐一篇关于拼多多的文章——梁宁的万字分析：“除了假货，拼多多还有什么？”
\n你看的过程中一定要记住，你不是单纯地去看梁宁说什么，而是一定要有自己的思考。
\n今天的课程就到这里，如果你有什么疑问，可以在留言区留言。同时欢迎你关注我本人的公众号（微信搜索：AI悦创），之后会定期更新原创高质量的数据分析文章，下节课见，谢谢。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n前期卷一些，后期容错率大。
\nJacky 整体来说学习状态、心态都不错。理解能力目前来看还可以，因为以前没有接触过编程，不过就算是接触过编程的也不一定可以跟上学校的内容。所以需要补的其实老生常谈了，思维建立搭建中。
\n思维方式需要提升，刚刚好今天讲了：问题转换思想、问题拆分思想，多多复习。课上尽可能全部搞定，课后可以做其它的。
\n记笔记的能力还可以继续提升，不过对于第一次记笔记来说 Jacky 记得整体还不错，不过及时的总结能力、表达能力这个需要慢慢提升。
\n——AI悦创
日期：2025 年 9 月 14 日
\n进展正常，循序渐进。理解能力目前都还可以，记笔记的习惯可以继续改进，有较大的提升空间。足够勤奋，不够细心。其实没有其他的了，恰好今天上课讲到的：我讲的知识点只是我觉得应该要让你学会的，Jacky 要学会批判性思维多多提出我们提及或没有讲到的示例。要有足够强的探索能力培养，延伸性思考。这也是一开始说的：学编程不是单纯学语法，而是思维与逻辑。
\n只要这个能力培养起来了，后期任何学科都是可以自己探索的。慢慢搭建吧，不用着急～
\n日期：2025 年 9 月 21 日
\n本周主要完成学校的 Project、Quiz、Lab（多个 Lab）。目前没什么问题，主要就是细心一些，跟着打作业代码部分，老是会错一些：单词、标点等，不过在 Mark 作业测试时之后，还是能较快的找到自己马虎点。
\n日期：2025 年 9 月 28 日
\n主要是记笔记和扩展思考能力部分，记笔记习惯于把代码和笔记全部记录在代码框中，这是极其不好的（上课纠正过）。因为会无形的增加未来找笔记的负担，每次找笔记都得认真阅读代码框是否是自己所要的笔记，而无法快速的找到自己想要的笔记。最好是拆分出合适的标题，以便于未来查笔记。
\n讲完一个知识点后，不能及时的提出相对应的问题，扩展性思考需要慢慢培养，有助于未来学习习惯的培养、思考的培养等。
\n另外：思考能力、分析能力、观察能力、感受能力需要加强培养，才能总结出不同点，这些也适用于生活。
\n笔记记入的不够详细到位，不求逐字记录，当求主要核心内容要有，并且记笔记的时候，要考虑考虑未来查找笔记的场景，这样记入的笔记会更好！
\n日期：2025 年 10 月 4 日
\n本周主要讲解了学校布置的作业、Lab、Quiz 等内容，以及下周课上学校老师有可能的提问。作业部分主打：高分通过，具体的实力提升还是在于系统学习部分。系统学习部分目前到达列表内容，细心程度较于之前提升较多。
\n对于编辑器、ipython 的掌握有提升，计算机操作知识也有不错的提升。
\n理解与推理能力，有一些提升。需要持续进行推理提升，因为未来要接触的都是未知的知识内容，就很需要训练出自己的研究、推理能力。
\n今天上课石提到的列表切片赋值，这部分要特别注意：分析、观察代码的时候要带着连续思维去看，而不是独立去看。每行代码之间，都是逻辑思维的具象化体现。
\n其实和之前类似，本周倒没什么特别要写的。继续加油吧～
\n日期：2025 年 10 月 12 日
\n本周完成了学校的 Lab，不过逐步从学校的作业内容发现学校本科涉及的内容太多，学校是不 care 学生是否掌握，只求进度。并且不一定会讲，只是会提。
\n临近期末考试，还是建议有时间再多安排时间上课。（虽然每周 9h，但面对的知识量太多）
\n系统学习必不可免，但是有些重要知识点，但考试不一定涉及的等考完试之后再继续补充。（没讲，不代表不重要！）
\n就算考完，还是要继续学习的。小孩自己也清楚，学校安排给他的其他学科也是有用到 Python 的。
\n虽然，很有挑战性。一起加油！
\n补充：对于已经讲过的知识点的熟练度不是非常高，不过可以通过查找笔记解决部分问题，需要的不是刷题，需要的是平时多思考、多复习看看笔记等。
\n日期：2025 年 10 月 19 日
\n讲过的语法，都会用。但是没记住，查笔记要查半天。表明熟练度不足，熟练度不足靠刷题没用，平时有时间多翻翻笔记看看，多思考思考、多复习复习。快期末考了，老师也干着急，加油呀！
\n学校要考的不仅仅是 Python 基础，还有数据分析、数据可视化等方面，Python 基础只是其中一部分。学校不考虑学生学的会不会，主要就是为了进度，所以涉及内容多。学生想要会，就得课后多花时间投入，加油！
\n在考试当中，如果某个便捷函数想不到，则先手动实现。不然，无法实现直接 0 分。先实现，后面有时间再进行优化或思考。
\n日期：2025 年 10 月 26 日
\n学校链接：https://edstem.org/au/dashboard
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n今天我主要讲解如何撰写完美的专题报告。
\n本课时分为三部分：
\n报告撰写的原则；
\n报告的组成部分；
\n报告点评示例；
\n报告撰写有很多原则，但这三个原则，如果你把握好了，基本上没什么问题。
\n主题一脉相承分叉：只有一个主题，每页 PPT 都是围绕这个主题来分叉展开。
\n通俗简单易懂：数据分析师的报告一定要简单易懂，文字要偏大白话。
\n结论和闭环先行：要有分析结论，且落地性强。
\n下面我逐一讲解这三个原则。
\n在主题一脉相承分叉原则里，常见两种问题。
\n专题报告没有主题。通常在报告中，这里写点，那里写点。给别人看时，别人觉得有问题，但也说不上来。如果你写的报告没有主题，那肯定是因为你对专题报告的需求没理解到位。
\n专题报告有主题，但是写的逻辑有点乱，这是因为本身思维不够严谨，受到的指导太少。
\n解决办法：看别人报告是怎么写的，一页一页去斟酌。你要把自己当作写报告的人，如果是你，你会怎么去写，别人又是怎么去写。这个过程一定要去思考。
\n数据分析师一定要让别人听明白你的报告。不管你是业务数据分析师，还是偏研发、偏算法的数据分析师，最终都是服务于业务。即使你不阐述 PPT，也要保证业务方能看懂，否则就是给自己挖坑。一个数据分析专题报告，如果跟你最熟的业务方都理解不了，那对于其他人来说绝对是天书。
\n解决办法：看产品经理日常怎么写报告，因为产品经理提出的建议要让研发明白，或者需要别人协助，所以他的报告是非常通俗易懂的。
\nPPT 一定要有数据结论，以及在这个结论的基础上，业务方准备怎么做。注意这里是真的准备怎么做，而不是你给的建议怎么做，数据分析用来决策而不是建议，确实很多人写专题报告还没有达到这层面。
\n解决办法：跟业务方多沟通数据结论，让他们给出落地项，而不是你建议怎么做，因为你的建议往往推不动落地，所谓的闭环就是一定要落地。
\n标准化的专题报告包含哪几个部分呢？我们按照先后顺序来说，如下所示。
\n背景：为何要做这份专题报告，即问题的识别。
\n分析结论：如果是面向管理层的汇报，结论可以先行。
\n分析框架：即问题的拆解，往往这里不需要很细。
\n第一个关键点结论。
\n第一个关键点的支撑数据依次摆放。
\n第二个关键点结论。
\n第二个关键点的支撑数据依次摆放。
\n整体结论：这里把结论再汇总一次。
\n落地项：产品是怎么落地的，要非常具体（时间、人、预期效果）。
\n首先是背景，一定要有背景，为何要做专题报告，即问题的识别。如果会议上的人都是非常熟悉的业务方，具体讲这份报告的时候可以不说背景，但是我们一定要把背景写上去，要不然别人都不知道这个报告到底是干什么的。
\n其次是分析结论。如果是面向管理层的汇报，结论可以先行。当然分析结论可以在最后，也不一定非要放在第二页，但大部分时候是放在第二页，因为很多时候管理层后面没时间，所以让他看一下结论即可。
\n然后是分析框架及问题的拆解。这就是我们前面课时介绍的问题的拆解，你要把你对这个报告大概是这么想的放出来，也就是张思维导图，思维导图摆出大的框架就行，拆的很细的可以另保存。
\n往下是第一个关键点结论。你的分析结论实际上是由很多子结论构成，所以先把你的第一个关键点和结论摆出来，然后下一页依次摆放支撑你结论的数据，可能是好几页，作用就是来佐证你的结论。紧接着就是第二个关键点结论，同样接着摆放第二个关键点结论的支撑数据。
\n再就是整体结论，这里我们要把结论再汇总一次，因为前面你说的这些细节之后，把结论再强调一次，别人的感受就会更深。最后给出落地项，比如产品是怎么落地的，要具体到时间、人、预期效果。
\n标准化的专题报告包括以上这些点，如果你是下面的听众，我这样去讲这个 PPT，你听起来是不是很舒服？
\n另外一个问题，如何衡量专题报告的价值？其实很简单，在所有的数据结论和落地项中， 只要最后有 1-2 个真的应用落地了，这就代表这份专题报告非常有含金量。哪怕你报告写得再好，最后没有结论可落地实施，那这个报告就是数据堆积，没有价值。
\n我举个具体的案例，这是某一个学员，他自己做的专题分析，我们看一下这个专题分析，看有什么问题。
\n报告主题是彩妆行业的分析，我们先看报告目录，如图所示。
\n他把目录分为五部分：第一行业整体环境；第二彩妆行业分析；第三彩妆重点品类分析；第四彩妆重点产品分析；第五结论。下面我就直接点明问题。
\n这个目录里面第一和第二是重复的，如果用 MECE 原则来看，行业整体环境和彩妆行业分析本身很有可能就是一回事。第三和第四部分实际上是一个子集的关系——品类和产品。当我们看完品类之后，很自然地就去看产品，所以三和四的结构是不是也可以做一些调整。第五部分根据主题一脉相承分叉原则，在问题的拆解上面还需要优化。
\n下一页就是彩妆行业整体分析，如图所示。
\n这一页主要是讲长期趋势，有两个问题。
\n不直观。比如波峰时相对应的年份和访问数以及其他详细数据的差距没显示出来。既然是行业整体分析，首先要把大数告知听众，让这页整体更直观。
\n不够通俗易懂。这位同学在后面有一个预测，实际上这幅图不太能预测，别人就会疑问你是怎么预测的。虽然这页的结论下面有写到预测方法，但写的偏专业术语，不通俗易懂。
\n我们再看下一页增长倍数的变化，如图所示。
\n这里还是通俗易懂原则。比如，增长倍数是什么意思？因为图中既有 2017 年数据，也有 2018 年数据，而且是每一周的数据。那这里的增长倍数是什么意思呢？这个标准线又是什么意思呢？如果我是业务方，我就不太好理解。所以咱们就不要用“增长倍数”这种词语，你可以描述的更详细一些。虽然说报告要图多字少，但一定要看你面对的对象是谁。如果文字不是通俗易懂，你相信我，你讲 PPT 的时候，你很可能会把自己绕晕。
\n再看下一页周期特性，如图所示。
\n这里面有一个逻辑性疑问，周期分析属不属于行业整体分析？因为这里是说行业的一个周期，比如说 7 天一个小周期，首先它属不属于行业整体分析范畴？这个要根据具体业务范畴来定。
\n我们再看下一页市场的集中度，如下图所示。
\n首先是通俗易懂原则，交易指数是什么？公式是什么意思？听众其实特别讨厌公式。
\n然后就是逻辑性，市场集中度低于 30%，彩妆市场处于竞争状态。请问低于 30% 就是竞争，那多少就是不竞争呢？另外听众对头部玩家肯定很感兴趣，有哪些头部玩家呢？头部玩家的市场集中度是怎样呢？这就是思维的严谨性和逻辑性。
\n我们再看一下客单价，如图所示。
\n首先是通俗易懂，图中的趋势是上升还是下降又或是正常波动，还真不容易看出来，那在可视化这一块是不是可以优化下。
\n然后是思维的严谨性，这里有一段话：“考虑到通货膨胀因素，彩妆利润被进一步压缩”。通货膨胀就会使彩妆利润进一步压缩吗？这个肯定不太合适，所以说这句话的时候更加严谨一些，至少要有数据支持。
\n我们再来看彩妆人群分析这几页，如下图所示。
\n这几页的主要问题就是维度太多，字太多，不容易抓重点。其实很多人写每一页 PPT 时可能搞了很多维度，最后就会有一大堆数值罗列，实际上没有必要。如果你觉得很难把一些东西丢掉，那就直接写结论。
\n下面这两页是细分人群的购买力分析和属性偏好分析。主要问题是逻辑思维性，需要先说基础属性，再说行为属性，且文字大多是描述性统计，没有建议更没有结论。
\n最后再看这位同学写出的结论，如下图所示。
\n你看完结论有什么感受？是不是觉得有道理但又觉得有问题。其实这一页应该遵循结论和闭环先行原则：
\n基于什么数据；
\n发现什么结论；
\n基于这个结论的建议是什么；
\n基于这个建议的产品落地项是什么。
\n在写这一页的时候至少要做到前 3 项，这样业务方看完之后才知道，原来是这么回事，有理有据，有落地项有闭环。
\n整体看下来，你有没有发现，具体到每页 PPT，大都是这里一个点，那里一个点，没有连贯性，其实这个很常见。主题的一脉相承分叉原则说起来容易，但做起来难，这需要你在工作中多实践。
\n对于如何写好专题报告，我建议你平时多看优秀的专题报告，重点是把自己带入到场景中。比如推给你一篇文章，你看的时候一定要把自己带入到场景当中去思考，思考文章作者说的到底有没有道理，思考作者的见解，文章的架构。再就是每写一次专题分析，一定要获得他人的反馈，在这个点上，我相信写上述 PPT 的同学，他的感触应该是最深的，只有这样才能进步。
\n今天的课程就到这里，你要好好学，然后多思考，多去和别人进行交流。如果你有问题可以在下方留言，同时欢迎你关注我本人的公众号（微信搜索：AI悦创），之后会定期更新原创高质量的数据分析文章，下节课见，谢谢。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nYour goal in this assignment is to implement a famous mathematical \"game\" (or cellular automata to use the correct term) the Game of Life, also known as Life. It was devised by the British mathematician John Conway in 1970.
\nThe assignment must be submitted in Ed Lessons before Sunday the 28th of September, at 11:55PM (5 min before midnight). This deadline is hard! Unlike other courses, we do not give partial mark for late submission. We will only grant extension in exceptional circumstances, see our policy on the course assessment page.
\nYou can submit it as many times as you like and only the mark of the last submission will be used. You can submit it as many times as you like and only the mark of the last submission will be used. To submit: Click the Start Attempt button in blue at the top right, then click Submit. Clicking Run or Test does NOT submit your work.
\n注意
\nWe do not accept any excuses about technical problems like internet connection or computer issues, as you have plenty of time from the release of the assignment to the deadline. Do not wait until the last minute!
\nThe homework is individual. You must write your own solution and you are expected to be able to explain every aspect of it. You are not allowed to share your solution (code) with other students; this includes posting it (or parts of it) to the discussion forum, or to any other online platforms. You may be contacted for an additional oral assessment, which may result in a change of mark.
\nIf you have questions: ask the tutor in your lab or look up Ed Discussion forum for similar question (only post your question if not found).
\nThe Game of Life is \"played\" on a board, which is a 2D (two-dimensional) grid of cells. Cells are either dead (represented as an integer 0 on the board) or alive (an integer 1 on the board). Life runs over several steps (generations). At each step we start from a given configuration of the board (i.e., distribution of live and dead cells), and we generate the next board according to the following rules:
Fig 1. The blue cell has eight neighbours (C-Centre, N-North, S-South, E-East, W-West etc). Cells at the edge of the board will have less than 8 neighbours.
\nThere are several possible choices to represent the 2D grid of numbers. From the data structures we have seen so far we may either use a list of lists (Lectures 5 and 6) or a 2D NumPy array (Lecture 7). You may choose which one of the two data structures you prefer. We have provided you with two scaffold code files:
\ngame_of_life.py, orgame_of_life_numpy.py.You must fill in your UID and name in the python file you chose to proceed, and only that file will be marked. Do NOT update the other file.
\n注意
\nYou MUST write your functions solely in one of the two files, i.e., the one you chose, and leave the other file untouched. If you fail to do that, we may incorrectly mark your submission!
\nTask 1. Write a function count_live_neighbours(board, row, column) which returns the number of live neighbours of a cell, given a board and the coordinates of the cell on the board given by row and column, i.e., the cell at board[row][column]. You can assume that row and column are non-negative integers and within the boundaries of the board. Write your implementation of count_live_neighbours in the scaffold code file. The template function has only a pass statement which you should replace with your code.
Task 2. Write a function generate_next_board(board) in the scaffold file that, given the current board, generates the next board. Both board and the returned value are Life boards. You must NOT modify board. Instead, you should work with a copy of board which can be modified and returned. (Think why!).
For both tasks 1 and 2 you can assume that:
\n0 or an integer 1.For both tasks 1 and 2 you must follow this restriction:
\ncopy, numpy and matplotlib.To test your code, click the \"Test\" button at the bottom right of the workspace. The scaffold file also has two testing functions test_count_live_neighbors() and test_generate_next_board() that will run the same tests as when you click the Test button. In case you use your \"favorite\" IDE to implement the function, you can run this function to test the code yourself. To submit your code, click the \"Submit\" button at the top right corner:
We have provided other functions in the scaffold code file for your pleasure: draw_board(board) will be useful when you start designing your own boards, and evolve_life(initial_generation, number_steps, filename) which will run your generate_next_board for number_steps and will generate a GIF animated file ! To generate the animated file with an evolution, you can call one of the provided evolve_life_pattern(...) functions. For example calling evolve_life_beacon(10) will generate a file named beacon.gif with an oscillating pattern of periodicity 2 called \"Beacon\":
In the scaffold code file you will also find functions for the well known \"Glider Gun\", and \"line\" and \"box\" which display simpler boards that you can easily experiment with.
\nAsk your tutor if you're not sure how to use these functions.
\nAnd there are many other interesting boards in the Wikipedia Game of Life reference. Check them out. Sorry no bonus marks, but lots of fun if you can get them going!
\n注意
\nSubmit your code with the calls to evolve_life commented out. Otherwise, the automarking scripts may fail to provide to mark your assignment.
注意
\nSome students have reported issues with Safari web browser on MacOsX in regards to the GIF file generation. The workaround is to use Google Chrome web browser instead.
\nLike homework 3, we will be marking your submission on both code quality and correctness.
\nCode quality
\nCode quality has been covered in the week 4 lecture. It includes aspects such as:
\nTo earn a good score, you must demonstrate your understanding of code quality by introducing at least one well-structured new function to reduce repetition, including some appropriate comments to clarify your logic, and adding docstrings to all functions required in the tasks and any helper functions created.
\nCode correctness
\nYour code will be marked with auto-testing. Clicking on the \"Test\" button will only test it on a limited number of test cases, which will show you which test cases you passed or failed. Failing at least one test case means that your code is wrong.
\n注意
\nPassing all the tests does not necessarily means that your code is correct, as only a small number of test cases are done. In the final marking of your assignment we will use a much larger set of test cases, and your code might fail additional tests.
\nYour code must meet the following requirements:
\ngame_of_life.py and game_of_life_numpy.py.In marking this assignment we will consider the following:
\nWe will apply penalties for submissions that do not fulfill formal aspects, such as missing name and/or uID.
\nThe assignment is worth 5% of your final mark, including 3% for code correctness and 2% for code quality.
\nThese might be useful either for working offline or if you want to start fresh after an initial failed attempt
\n\n", "date_published": "2025-09-19T09:14:10.000Z", "date_modified": "2025-09-24T08:10:12.000Z", "authors": [ { "name": "AI悦创" } ], "tags": [ "Python一对一答疑帖", "留学生Python辅导", "Australian National University一对一辅导" ] }, { "title": "「Australian National University」Lab 6：Lists (advanced) and tuples. Data analysis.", "url": "https://bornforthis.cn/1v1/101-Sallymisty/Lab/06-australian-national-university-lab6-lists-advanced-tuples-data-analysis.html", "id": "https://bornforthis.cn/1v1/101-Sallymisty/Lab/06-australian-national-university-lab6-lists-advanced-tuples-data-analysis.html", "summary": "1. Introduction The purpose of this week's lab is to: Review Python's built-in sequence types: lists and tuples. Contrast a reference to an object with a copy of an object, in t...", "content_html": "The purpose of this week's lab is to:
\n\n\nIf you do not have time to finish all exercises (in particular, the programming problems) during the lab time, you can continue working on them later.
\n
\n\nIf you have any questions about or difficulties with any of the material covered in the course so far, ask your tutor for help during the lab.
\n
Operations on python's built-in sequence types are summarised in this section of the python library reference. You may want to revisit Lab 5 to remind yourself of how indexing and slicing work on sequences, as well as the operations available on sequences.
\nBecause lists are mutable but strings are not, you can assign a new element to an index in the list, or a list to a slice of the list, but you cannot do this with strings. Try the following on a python interpreter to convince yourself this is the case:
\nIn [1]: a_str = \"acd\"\n\nIn [2]: a_str[1]\nOut [2]: ...\n\nIn [3]: a_str[1] = 'b'\n\nIn [4]: a_str\nOut [4]: ...\n\nIn [5]: a_list = [1,3,2,4]\n\nIn [6]: a_list[1] = 2\n\nIn [7]: a_list\nOut [7]: ...\n\nIn [8]: a_list[2:4] = [5,7]\n\nIn [9]: a_list\nOut [9]: ...In python, every value computed by the interpreter is an object. An object in python has:
\nid function. Examining the identity of an object is typically not useful in the programs you write, but it will sometimes help you to understand what is happening.int, that is, an integer, what integer it is).When we assign a value to variable, the variable name is associated with a reference to the object; that is, essentially, the object's identity. Several variables can refer to the same object.
\nA mutable object is one that can be modified. This means that we can change the object's attributes. The object's identity remains unchanged.
\n\n\nDowney's book describes mutable objects (specifically, lists) and aliasing (multiple names referring to the same object) in Chapter 10.
\n
The following code attempts to construct a table containing the first three rows of the periodic table. Run the following commands in the python shell:
\nIn [1]: row1=[\"H\",\"He\"]\nIn [2]: row2=[\"Li\",\"Be\",\"B\",\"C\",\"N\",\"O\",\"F\",\"Ar\"]\nIn [3]: row3=[\"Na\",\"Mg\",\"Al\",\"Si\",\"P\",\"S\",\"Cl\",\"Ne\"]\nIn [4]: ptable=row1\nIn [5]: ptable.extend(row2)\nIn [6]: ptable.extend(row3)ptable now?row1 now? Is this what you expected?row2 (\"Ar\" should be \"Ne\") by executing a command of the form row2[?] = ?. (The question mark means it is for you to figure out what is the right index to change. You should not write a literal ?) What happens to ptable as a result of this assignment?row3 (\"Ne\" should be \"Ar\") by executing a command of the form ptable[?] = ?. What happens to row3 as a result of this assignment?Give the above a try yourself first.
\nAfter that, [try stepping through and visualising the example using the on-line tool pythontutor.com here](https://pythontutor.com/python-debugger.html#code=row1%3D[\"H\",\"He\"] row2%3D[\"Li\",\"Be\",\"B\",\"C\",\"N\",\"O\",\"F\",\"Ar\"] row3%3D[\"Na\",\"Mg\",\"Al\",\"Si\",\"P\",\"S\",\"Cl\",\"Ne\"] ptable%3Drow1 ptable.extend(row2) ptable.extend(row3)&cumulative=false&heapPrimitives=nevernest&mode=edit&origin=opt-frontend.js&py=3&rawInputLstJSON=[]&textReferences=false). We have already copied the code in and set the right settings for you in the link above. Just click the \"Visualize Execution\" button to start. See if what is happening matches what you expected to happen.
\nTo help explain what is happening, you can also use the id function to see the identities of the objects referenced by each of the variables:
In [7]: id(row1)\nOut [7]: ...\nIn [8]: id(row2)\nOut [8]: ...\nIn [9]: id(row3)\nOut [9]: ...\nIn [10]: id(ptable)\nOut [10]: ...You should find that row1 and ptable both reference the same object (a list), but that the contents of row2 and row3 were copied into ptable.
Now execute the following commands (make sure you redefine the rows):
\nIn [1]: row1 = [\"H\",\"He\"]\nIn [2]: row2 = [\"Li\",\"Be\",\"B\",\"C\",\"N\",\"O\",\"F\",\"Ar\"]\nIn [3]: row3 = [\"Na\",\"Mg\",\"Al\",\"Si\",\"P\",\"S\",\"Cl\",\"Ne\"]\nIn [4]: ptable = [row1]\nIn [5]: ptable.append(row2)\nIn [6]: ptable.append(row3)ptable now? How does this differ from what you had in Exercise 1?row1 now? How does it differ from what you had in Exercise 1?ptable, you would use the expression ptable[0][0]. Write the expressions to get the sixth element from the second row (\"O\") and the second element from the third row (\"Mg\"). Use only the ptable variable, not row2 or row3.row2[?] = ?. Does this also change ptable?ptable[?][?] = ?. Does this change row3? And ptable?Again, you can use the id function to see the identities of the objects involved (try both id(ptable) and id(ptable[0])). You should find that each element in ptable is a reference to one of the row lists.
Again, if you want to visualise what is going on, try pythontutor.com. Copy the code you want to test into the text box and click the \"Visualize Execution\" button. Remember to make sure you have selected \"Python 3\" in the menu above where you enter the code.
\nIn Exercise 1, you assigned ptable the list referenced by row1 via the statement ptable = row1. Subsequent operations showed that ptable and row1 referenced the same object (list). How do we actually make a copy of a list?
Execute the following commands:
\nIn [1]: row2=['Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ar']\nIn [2]: ptable1=[\"H\",\"Xe\",row2]\nIn [3]: ptable2=ptable1[:]ptable1 a list, a list of lists or a mix of both? (Print it out!)ptable2 to be \"He\". Is the change propagated to ptable1?ptable2 to be \"Ne\". Is the change propagated to ptable1 and to row2?You should find that after executing ptable2=ptable1[:] ptable2 is a copy of ptable1 (not having the same id) but the third element is a reference to row2. The effect of adding [:] to the ptable2=ptable1 assignment is to create a so-called shallow copy of ptable1.
Unclear? Visualize the code in pythontutor.com, or ask your tutor for help.
\nExecute the following commands
\nIn [1]: row2=['Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ar']\nIn [2]: ptable1=[\"H\",\"Xe\",row2]\nIn [3]: import copy\nIn [4]: ptable2=copy.deepcopy(ptable1)ptable2. Inspect to see whether the elements of ptable1 or row2 have changed. (You should find no changes.)\n\nThink carefully before using
\ndeepcopy: it is much slower and consumes more memory than shallow copy; it may also cause problems with circular references (such as list containing a reference to itself). Any problems with shared references can always be avoided by thinking more carefully about how you have structured your code.
Python has another built-in sequence type, called a tuple. Like a list, tuples can contain any type of value, including a mix of value types. The difference between type list and type tuple is that tuples are immutable.
To create a tuple, you only need to write its elements separated by commas:
\nIn [1]: aseq = 1,2,3,4\n\nIn [2]: type(aseq)\nOut [2]: ...It is common practice to write a tuple in parentheses, like this:
\nIn [1]: aseq = (1,2,3,4)\n\nIn [2]: type(aseq)\nOut [2]: ...and the python interpreter will usually print tuples enclosed in parentheses. However, it is the comma that creates the tuple, not the parentheses! To see this, try the following:
\nIn [1]: x = (1)\n\nIn [2]: type(x)\nOut [2]: ...\n\nIn [3]: x = 1,\n\nIn [4]: type(x)\nOut [4]: ...There is one exception: To create an empty tuple (a tuple with length zero), you have to put a comma between nothing and nothing! Typing x = , does not work. Instead, use an empty pair of parentheses to create an empty tuple, like this: x = ().
Retry the tests you did in Exercise 2 in Lab 5 with tuple values (instead of lists):
\nIn [1]: aseq = (1,2,3,4)\n\nIn [2]: bseq = 1,3,2,4\n\nIn [3]: type(aseq) # 1. what type of sequence is this?\nOut [3]: ...\n # 2 - 9 as before.Also try assigning to an element and to a slice of the tuple, as in Exercise 0: this should give you an error, because the tuple type is immutable.
\nJust like strings, the list data type has several useful methods. For example, read help(list.append), help(list.insert) and help(list.extend) to see the documentation of some of the methods that modify lists. Modifying methods and operations for mutable sequence types (i.e., list) are summarised in this section of the python documentation.
On the right, the are two attempts to write a function, make_list_of_lists. This function creates a list of n lists of increasing ranges of integers. The first entry in the returned list should be an empty list, the second a list of length one, ending with the number 1, and so on. For example, make_list_of_lists(3) should return [ [], [1], [1, 2] ]. (Note that n must be a non-negative integer.) However, both functions are incorrect. Locate the error in each function, explain why it goes wrong and fix it.
# The function below does not work as \n# intended. Find the error and fix it.\ndef make_list_of_lists_attempt1(n):\n\tthe_list = []\n\tsublist = []\n\twhile n > 0:\n\t\tthe_list.append(sublist)\n\t\tsublist.append(len(sublist) + 1)\n\t\tn = n - 1\n\treturn the_list\n\n# The function below does not work as \n# intended. Find the error and fix it.\ndef make_list_of_lists_attempt2(n):\n\tthe_list = []\n\tsublist = []\n\tfor i in range(n):\n\t\tthe_list.extend(sublist)\n\t\tsublist = sublist.insert(len(sublist), i)\n\treturn the_list# The function below does not work as \n# intended. Find the error and fix it.\ndef make_list_of_lists_attempt1(n):\n\tthe_list = []\n\tsublist = []\n\twhile n > 0:\n\t\tthe_list.append(sublist.copy())\n\t\tsublist.append(len(sublist) + 1)\n\t\tn = n - 1\n\treturn the_list\n\n# The function below does not work as \n# intended. Find the error and fix it.\ndef make_list_of_lists_attempt2(n):\n\tthe_list = []\n\tsublist = []\n\tfor i in range(n):\n\t\tthe_list.append(sublist.copy())\n sublist.append(i + 1)\n\treturn the_listData analysis problems will typically require you to:
\nWays to do these steps were covered in the lecture of week 6. Below is a quick recap.
\nThe file format we will be using in the lab is Comma-Separated Values, or CSV, files. To read in a CSV file, the following steps suffice:
\nimport csv\nwith open(\"filename.csv\") as csvfile:\n reader = csv.reader(csvfile)\n table = [ row for row in reader ]After this piece of code is executed, the variable table is a list of lists, with one entry per row in the file. Two things to remember are:
table will contain this header. You can use, e.g., list slicing to get a table without the header.List comprehensions are a mechanism in python that allows you to create new lists from a sequence in a very convenient way.
\nIn this lab, you can use list comprehensions to
\nFor example, the expression
\ncol3 = [ row[3] for row in table ]creates a list with the entries in column 3 (i.e., the fourth column, since columns are also zero-indexed in this representation), and the expression
\ntable_non_empty_col3 = [ row for row in table if row[3] != '' ]creates a new table containing only the rows in table that have a non-empty value in column 3.
The built-in range function creates an iterable collection of integers, which can be very useful together with list comprehension (and also for loops). For example,
ind_non_empty_col3 = [ i for i in range(len(table)) if table[i][3] != '' ]creates a list of the indices of rows in table that have a non-empty value in column 3.
The range function can take both a start and stop value. For example,
years = range(2008, 2022)creates a range of the integers from 2008 to 2021 (note that the range is up to, but not including, the stop value). For more details, read the documentation with help(range).
The selection condition used in a list comprehension can be any expression that evaluates to a truth value. For example, if you have written a function is_prime(n) that returns True if the number n is a prime number, then you can create a list of all the prime numbers between 1 and 100 with the expression
list_of_primes = [ i for i in range(1,101) if is_prime(i) ]The expression that creates the values in the new list can also be of any kind (as long as it is an expression). For example,
\n[ [ row[0], row[1], float(row[2]), int(row[3]) ] for row in table ]creates a new table where all entries in column 2 have been converted to floating point numbers and all entries in column 3 have been converted to integers, while columns 0 and 1 have been left as they are (strings). Remember that trying to convert an empty string into a number (int or float) will cause a runtime error. One way to solve this is to filter out rows with empty entries first (as shown above) and then convert those that remain. However, you can also use a function that you have defined. For example,
[ my_fun(row[3]) for row in table ]returns a list with the result of applying my_fun to every entry in column 3, where my_fun can be any function (of one argument).
In the rest of the lab, you will have to solve four more advanced programming problems. We don't expect everyone to finish all these problems during the lab time. If you do not have time to finish them in the lab, you should continue working on them later.
\nThe list method pop(position) removes the element in the given position from the list (read help(list.pop) or the on-line documentation).
Task 1. Write a function allbut(a_list, index), which takes as arguments a list and an index, and returns a new list with all elements of the argument list (in the order they were) except for the element at index. The argument list should not be modified by the function.
Example:
\nIn [1]: my_list = [1,2,3,4]\nIn [2]: my_short_list = allbut(my_list, 2)\nIn [3]: print(my_short_list) \n[1, 2, 4]\nIn [4]: print(my_list) \n[1, 2, 3, 4]Task 2. A slice expression, a_list[start:end], returns a new list with the elements from start to end - 1 of the list. Write a function slice_in_place(a_list, start, end), which takes as arguments a list and two non-negative indices, and modifies the argument list so that it is equal to the result of the slice expression a_list[start:end]. The function should not return any value.
Example:
\nIn [1]: my_list = [1, 2, 3, 4]\nIn [2]: slice_in_place(my_list, 1, 3)\nIn [3]: print(my_list) \n[2, 3]You may want to address, as an optional take-home exercise (that won't be tested/assessed), how to modify your slice_in_place function such that it is able to work with both positive and negative indices (like slicing does).
def allbut(a_list, index):\n #TODO: implement this function\n pass\n\ndef slice_in_place(a_list, start, end):\n # TODO: implement this function\n passdef allbut(a_list, index):\n n = len(a_list)\n # 规范化负索引\n if index < 0:\n index += n\n if index < 0 or index >= n:\n raise IndexError(\"list index out of range\")\n return a_list[:index] + a_list[index+1:]\n\ndef slice_in_place(a_list, start, end):\n a_list[:] = a_list[start:end]Sorting a list puts the elements in order; shuffling it puts them in (more or less) disorder. The python module random implements a function called shuffle which randomly shuffles a list. Here, we will look at a deterministic (non-random) shuffle of a list. A \"perfect shuffle\" (also known by many other names) cuts the list in two parts, as evenly sized as possible, then interleaves the elements of the two parts to form the shuffled list.
Task 1. Write a function perfect_shuffle(a_list) which takes as argument a list and returns the perfect shuffle of the list. The function should not modify the argument list.
Example:
\nIn [1]: my_list = [1, 2, 3, 4, 5, 6]\nIn [2]: my_shuffled_list = perfect_shuffle(my_list)\nIn [3]: print(my_shuffled_list) \n[1, 4, 2, 5, 3, 6]\nIn [4]: print(my_list) \n[1, 2, 3, 4, 5, 6]Task 2. Write a function perfect_shuffle_in_place(a_list) which takes as argument a list and performs the perfect shuffle on the list. The function should modify the list, and not return any value. After the function call, the argument list should have the same length and contain the same elements; only the order of them should change.
Example:
\nIn [1]: my_list = [1, 2, 3, 4, 5, 6]\nIn [2]: perfect_shuffle_in_place(my_list)\nIn [3]: print(my_list)\n[1, 4, 2, 5, 3, 6]Task 3. Write a function count_perfect_shuffle_in_place(a_list) that repeatedly shuffles a list using the function developed in Task 2 and counts how many shuffles are done before the list becomes equal to the original list.
def perfect_shuffle(a_list):\n #TODO: implement this function\n pass\n\ndef perfect_shuffle_in_place(a_list):\n #TODO: implement this function\n pass\n\ndef count_shuffles(a_list):\n #TODO: implement this function\n passdef perfect_shuffle(a_list):\n n = len(a_list)\n mid = (n + 1) // 2 # 前半多一个（当 n 为奇数）\n left = a_list[:mid]\n right = a_list[mid:]\n out = []\n for i in range(max(len(left), len(right))):\n if i < len(left):\n out.append(left[i])\n if i < len(right):\n out.append(right[i])\n return out\n\ndef perfect_shuffle_in_place(a_list):\n a_list[:] = perfect_shuffle(a_list)\n\ndef count_shuffles(a_list):\n original = a_list[:]\n count = 0\n while True:\n perfect_shuffle_in_place(a_list)\n count += 1\n if a_list == original:\n return countA list that contains lists is sometimes called nested. We define the nesting depth of a list as follows:
\nNote that \"a list that contains lists\" can also contain values that are not lists.
\nFor example, the nesting depth of [[1,2], [2,4]] is 1, while the nesting depth of [1, [2], [[3], [[4], 5]]] is 3.
Write a function that takes as argument a list and returns its nesting depth.
\nWhat does your function return when called with the list [[[]]]? (and is that what it should return?)
\n\nHint: you can check whether a value is a list (or another type) with
\nisinstance(value, list).Hint: this question is well suited to a recursive solution - where a function calls itself to find the solution to a problem. i.e., how would you find the maximum nesting depth of an inner list?
\n
def nesting_depth(a_list):\n #TODO: implement this function\n passdef nesting_depth(a_list):\n if not isinstance(a_list, list):\n raise TypeError(\"argument must be a list\")\n\n max_child = -1 # 若没有子列表则保持 -1，最后返回 0\n for x in a_list:\n if isinstance(x, list):\n max_child = max(max_child, nesting_depth(x))\n return 0 if max_child < 0 else max_child + 1from typing import List, Any\n\n#你好，我是悦创。
\n本课时内容分为三部分：
\n营销活动当前现状；
\n营销活动具体分析；
\n案例讲解——百度 APP。
\n我之前在国企工作时，公司经常会做线上和线下活动，所以每天都会看到各种活动捷报。活动结束后，钱是花完了，真实用户数却没涨多少，大多数都被薅羊毛了。营销活动每年都会花很多钱，因此必须要找一个公正的第三方——数据分析师，来做这件事。而数据分析师既然要做，就一定要发挥出自己的专业性，大家都是罗列数字，为何你就是不一样，你的强大逻辑性在哪？
\n在这种背景下，我们看一下营销活动的运营人员现状。运营人员比较关注活动的三个维度：带来多少用户量的增长，拉来多少新增用户，外界传播量能覆盖多少人。而数据分析师只需在活动期间每天进行效果播报，活动后 1~2 周内产出活动报告即可。活动报告包括活动参与人数、拉新数、用户画像三部分内容。
\n数据分析师与营销活动运营人员相比，数据分析师的优势在于快和维度拆解性，劣势在于细节性。因为数据分析师在做分析时，只是开一个大树，在很多具体业务的细节上面，毕竟不是专门做营销活动出身，所以不是特别了解，也可能没去问，导致最后报告结论的解读可能多多少少有些问题。而对于营销活动人员来说，每过一段时间，就要搞各种活动，所以很清楚活动细节。
\n其实营销活动应该是一件长期的事件，不可能通过某一次活动就能够带来大量的用户增长，因此数据分析师在做这件事时，要保持以下特性。
\n营销活动分析无非就两件事：活动效果评估（本活动和活动对比）和活动优化建议。活动之后要对活动进行复盘，那些做得不好，之后可以避免。
\n第二部分，我们来看营销活动具体应该怎么分析？我们先理一理，实际上在做任何活动之前，活动运营方都花了很多心思。活动之前必然会出文案，找开发，然后跟外面的合作方进行研讨，所有的这一切都会发生得很早。因此分析师要想做好活动分析，在这个时候就要与活动运营方多沟通，知道活动整体是怎么回事。
\n比如，第一要了解是谁来开发，靠不靠谱？第二要知道活动形式及测试体验，文案可能存在哪些问题。第三要想好活动大概有哪些指标。这些都要提前想一想。
\n在活动前，要好好准备这几件事。
\n活动前和运营方商定本次活动的目标。一定要有目标，没有目标的运营不是一个好运营，没有目标的运营绝对不会使出 100% 的力气。这里能很好地培养你业务的敏感性。
\n活动前和研发沟通好埋点。不是每个研发都很靠谱，即使很靠谱也可能会犯错误。在埋点这件事上，分析师应该是主导地位，包括字段名、埋点位置、上报方式等。
\n提前搭建好指标体系和报表。一定要提前准备，活动前 1 天才发现问题，这样的情况太常见。
\n定好输出格式。要想好活动中、活动后每天输出哪些数据，什么形式展现，这些要与业务绑好。
\n正式活动前一定要好好地准备，对于一般中型的活动一般是提前 1～2 周。如果是大公司的活动，可能前一个月就要好好准备。像双 11 这种特大活动就不是前一个月才准备，可能在活动的前三个月，所有的数据分析师都在准备这件事了。
\n其实正式活动，都有预热期，比如双 11 活动是 11 月 11 日，但 11 月 1 日起就已经很热闹了，甚至更早。所以在活动中，应注意以下事项。
\n观察第 1 天的数据，这个非常关键。详细看指标体系的报表数据，查看是否有异常。因为前期修改成本非常小，对于负责人的研发也很乐意去解决这件事。
\n观察 1~3 天数据，预估活动目标的完成度，活动目标在前期一定是确定好的，这里要看是否要做适当调整。
\n定时输出活动战报，每天早上输出，让所有人都知道情况。实际上管理层都有一个比较好的心法，就是早上看数据，你不要以为他在群里面没回，实际上都会看。在工作中真实情况可能真的只有运营人员自己知道数据，有一些数据很可能还藏着掖着。这里的数据要注意真实性，该怎么样就怎么样，要敢于暴露问题，这里问题不会很大，因为所有人的目标就是希望把这个活动做好。
\n活动 1 周后数据复盘，1 周后进行一次详细复盘，并同步给管理层，让更高视野的人来给建议。
\n到活动后期，需要好好复盘，其中最关键的是公正性，比如以下几点。
\n复盘活动对大盘的影响，这件事实际上很难做，但也有解决方法，后续会讲到。
\n复盘活动的短期效果，目标完成度，参与人数、拉新、品牌传播指数。
\n复盘活动的长期效果，通过活动带来的长期用户数，而不是低价值用户数。
\n复盘活动存在的问题，包括产品设计和用户反馈。
\n前面三点都是说活动的一个效果，第四点是说活动要为下一次活动做一些优化，包括以后做一些类似的活动，我们也要避免同样错误的发生。这里面就包括产品设计，用户是不是反馈这个 Bug 太多？明明中奖了，最后还是没有奖品，等等。这些问题都要把它暴露出来，所有的这一切都尽量要在活动后 1~2 周之内输出，在这件事上要非常讲究实效性。
\n营销活动分析分为三部分内容，总结如下图所示。
\n第一次活动分享，数据分析师帮助运营人员做好并形成模板，后续让运营负责即可。活动是个非常个性化的活儿，分析师不应该投入太多时间。
\n最后我举个百度 APP 的活动案例，我们先看一下百度 APP 里面的活动，随便刷一下 feeds 流，发现有一个圣诞活动，点进去后发现是这样一个交互界面，如下图所示。
\n这个活动主要是中间这个按钮——“刷资讯继续找礼物”。你点击按钮后就会跳到另一个 feeds 流里面，然后用户点击某一天资讯之后，它可能就给你两三毛钱。观察活动界面基本情况如下。
\n拉新：右上角分享。
\n促活：刷资讯找礼物。
\n活动奖励：送现金+机票。
\n体验感受：功能非常简单，但文案写的太复杂。
\n活动日期：12月6日 - 12月25日。
\n由于活动的步骤较多，这里我就挑选一些比较关键的活动指标，来完成活动指标体系的搭建。前面课时有提到，在搭建活动指标体系的时候，不追求大而全，找到关键指标，然后按照用户的基础属性和行为属性拆解即可。
\n对于这个活动，它的关键指标，就是带来新增用户和活动参与用户，那么我们就针对这两个点，对新增用户数和活跃用户数进行拆解。拆解途径如下图所示。
\n新增用户数可以拆解为渠道和新增用户的消费数据两个维度。渠道指用户是通过哪个渠道进入活动页面，比如是通过微信、QQ、微博或其他渠道进入活动。假设这里我们就只看这两个维度，当然真实情况中肯定要看更多维度的详细数据，我们先暂且不说。
\n对于活跃用户数也可以拆分为两个维度，第一个维度是参与过程的漏斗数据，这个很关键，因为漏斗分析非常经典，就是老用户进入这个活动之后，他整个参与过程的一个漏斗数据怎么样。第二个维度是在入口这一块，分为闪屏、信息流、活动中心，要知道我们的活跃用户到底是通过哪个入口进来的，每个入口的漏斗数据如何。
\n这就完成了活动指标体系的搭建，当然你拆解的真实情况肯定比这个要复杂，不仅仅是这几块，一定要到具体案例里面去思考。同时一定要提前建好所有报表，然后跑测试数据，正常都会有测试数据，一定要让研发去给一些测试样本，活动之前一定要确认测试数据没有问题。
\n活动后的复盘我来详细说一下，活动复盘绝对不是简单的数字罗列，总结如下图所示。
\n圣诞活动复盘我们分为三部分，第一个是短期贡献，第二个是长期贡献，第三个是活动优化。
\n这就是活动后的整体复盘，我们看了一下短期贡献、长期贡献以及活动优化。下面我整体总结下活动的整体复盘，其中我也会补充一些其他点，如下所述。
\n如果活动涉及收入和品牌传播（百度指数、微博指数），也要加入复盘；
\n可以用同比、环比来衡量对大盘 DAU 的贡献，同一拨用户前后对比其实不太好说明问题；
\n新增、首次、低活带动这三个指标，可以较好评判活动的价值；
\n对于拉来的新增用户和低活用户，更重要的是这部分用户的后续留存；
\n一定要把活动与活动间的数据进行对比，这更能说明问题，哪个活动好不好一目了然；
\n一定要思考每次活动的本质和意义，比如某个活动本身就不针对拉新，然后新用户参与了，你能说是你带来的吗？肯定不能；
\n如果是公司 S（最高）级的活动，数据分析师要看实时数据，无论是资源还是精力，都要重点投入；
\n一定要敢于暴露问题，数据分析师把已知的事实告知自己的上级，并邮件同步给活动运营的负责人；
\n凡是涉及活动使用金额时，分析师最好不要自己出数，让业务方给，工作中一定要自己做的话，记得邮件同步说明情况。
\n最后给你留一个思考题——你们公司是如何衡量活动对大盘跌逾的贡献？
\n今天的课程就到这里，如果你有问题可以在下方留言，同时欢迎你关注我本人的公众号（微信搜索：AI悦创），之后会定期更新原创高质量的数据分析文章，下节课见，谢谢。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n我们不仅仅要知道老师论文涉及的知识、技术，更要了解老师的意图，为什么要使用某个技术？别的技术不行？
\n多思考，多实践。
\n基本定义：Monte Carlo 模拟是一种基于随机数和概率统计的计算方法。
\n核心思想：用大量随机样本来模拟和逼近复杂问题的可能结果，从而得到一个概率分布而不是单一的确定结果。
\n简单说，就是“用随机数去模拟各种可能发生的情况，看大规模模拟之后的整体趋势”。
\n为什么需要 Monte Carlo 模拟？
\n比例数据 (Proportion Data)
\n区间尺度转化 (Interval Scaling, z-score)
\n相关系数 r² (Coefficient of Determination)
\nMonte Carlo 模拟
\n分析原理（步骤）：
\n\n\nMonte Carlo 模拟通常包含以下流程：
\n
确定输入变量及其概率分布：（例如：股票年回报率符合正态分布（均值 8%，标准差 15%））
\n随机抽样：根据定义的分布，利用计算机生成大量随机数（成千上万次）
\n计算模型结果：将每次抽样代入模型公式，计算出对应的结果。
\n统计与分析：
\n举例（现实生活场景）：
\n🎲 例子 1：掷骰子
\n💰 例子 2：投资收益
\n这样比“单纯说平均收益 8%”更有参考价值，因为它揭示了风险区间。
\n论文里有四种实验方法：
\nAFC（多选一） → 得到的是 “次数”；
\nRank-Order（排序法） → 得到的是 “名次”；
\nRating（打分法） → 得到的是 “分数”；
\nPaired Comparison（两两比较） → 得到的是 “胜出次数”；
\n问题来了：
\n👉 所以，需要把它们 转化到同一个标准化的区间（0% ~ 100%），然后再进一步转化成 可以比较的数值（z 分数）。
\n就是把各种形式的回答，统一换算成一个比例值。
\n这样，所有方法最后都可以变成类似：
\n蓝色：75% \n橙色：65% \n绿色：20% \n……虽然比例已经能看了，但有一个问题：
\n👉 这时，就需要用到 Thurstone’s Law of Comparative Judgement（色彩心理学里常用），把比例转成 z 分数。
\n什么是 z 分数？
\n例子：
\n这样，就能把所有颜色的偏好值都映射到一个 连续的、可比的数轴上。
\n投票选美比赛
\n有的人只告诉你“谁第一名”；
\n有的人给每个人打分（90分、80分…）；
\n有的人只做一轮一轮 PK。
\n→ 这些原始结果格式都不一样，没法直接说“谁最漂亮”。
\n→ 所以先要转成“百分比（多少人支持）”，再进一步变成一个统一的“标准化分数（z 分数）”。
\n考试成绩转 GPA
\n有的学校用百分制（85 分），
\n有的用等级制（A, B, C），
\n有的用 5 星制。
\n→ 统一换算成 GPA（比如 A=4.0，85分≈3.7），才能放在一起比较学生成绩。
\n这里 GPA 就相当于论文里的 “z 分数”。
\n外卖评分
\n有人说“好吃”，有人打 5 星，有人给 9 分。
\n平台为了排序，需要把它们转化为同一标准（比如 0–100 的分数，再标准化）。
\n这篇论文的核心数据分析思路是：
\n论文中的数据分析核心是：
\n换句话说，颜色的营销价值，要看产品类型：
\nL* = 明度（亮暗）a* = 红-绿通道b* = 黄-蓝通道L* 与“丝绸-唤醒度”的相关系数高达 0.89。a* 值（红-绿轴）更强烈影响了麻的“女性化”感知（r=0.50）。b* 值（黄-蓝轴）更影响棉布的“愉悦”感知（r=0.55）。✅ 总结：这篇论文通过 心理量表 → 定量化、统计检验、相关分析 等方法，揭示了“颜色”和“材质”如何影响人们对织物的感知。这套数据分析思路完全可以迁移到日常场景，比如消费者调查、市场营销、产品设计等领域。
\n配对 t 检验是一种统计方法，用来比较同一组对象在不同条件下的差异是否显著。
\n👉 “这两个情况的差别，是真实存在的，还是只是巧合？”
\n核心思想：看“差异”是不是偶然的。
\n前提：同一对象在两种情境下都有结果（成对数据）。
\n结果解读：
\n假设你想知道：“苹果手机是不是比安卓手机拍照更好看？”
\n你找了 50 个朋友，每个人用 同一场景拍两张照片：一张用苹果，一张用安卓。
\n然后让他们打分（比如 1-7 分）。
\n如果大家普遍觉得苹果分数更高，而且差距不是一点点，那么配对 t 检验会告诉你：
\n→ “是的，这差别是真的，不是运气。”
\n如果差距很小，很多人时高时低，配对 t 检验就会告诉你：
\n→ “这可能只是随机波动，不算真差别。”
\n为什么叫“配对”？
\n因为同一个人要同时体验两种情况（苹果 vs 安卓），结果是一对一对的，这就是“配对数据”。
\n研究者想知道：
\n\n\n“同一种颜色放在不同材质的布料上，人们的感知是不是会变？”
\n
论文比较了同一种颜色，但放在不同材质上（棉 vs 麻、麻 vs 丝、棉 vs 丝），人们的感知是否不同。
\n例子：
\n一块“红色棉布” vs “红色丝绸”
\n受试者对“厚薄感”“冷暖感”“男性化-女性化”打分不同。
\n如果这个差异在统计学上显著（p < 0.05），就能说明：材质确实会改变人对颜色的感知
\n你好，我是悦创。
\n今天我主要讲解如何做竞品分析。
\n本课时内容主要分为三部分：
\n为什么要做竞品分析；
\n竞品分析的步骤；
\n爱奇艺与优酷的竞品分析。
\n在前面的课时，我介绍的分析方法都是针对自身 App，像指标体系、流量分析、路径分析。
\n假设你当前所处的行业是老大，这个时候肯定要防止外来者，警惕行业老二和老三；假设你是当前行业老二，肯定要看老大最近在做什么，从而模仿超越；假设你当前是行业老三或老三以后，一方面肯定要紧跟老大老二，另一方面要放大招，弯道超车。所以在行业中无论处于什么位置都要去分析竞品。
\n在实际工作中，做竞品分析有以下几种情况：
\n当你的产品准备进入某个行业时，需要先把该行业的竞品分析清楚，主要侧重行业规模和前景的分析；
\n当你的产品发展处于下降阶段，需要看竞争对手在做什么，主要侧重头部玩家的玩法分析；
\n当你的产品发展处于瓶颈阶段，需要看竞争对手的数据和功能迭代，持续监控对手数据，从中寻找突破；
\n当你的产品发展处于快速上升期 ，一般不会做竞品分析。
\n对于一款 App ，分析师在初期就要监控好竞品的各项数据，只有这样才能保持对竞品数据的敏感性，同时跟自身 App 数据结合起来思考优化迭代。
\n到底什么是竞品分析？
\n网上写的很多分析报告，把竞品的功能罗列太多，这其实是最初级的产品体验分析。竞品分析绝不是大而全地把竞品的功能罗列一遍，也不是日常的竞品数据监控，配置一张报表就完事。
\n竞品分析包含两个点。
\n竞品的选择：哪些才是竞品？不要小看这件事，很多产品经理都没想清楚。并不是所有的头部行家都是你的竞品，而是要根据你做竞品分析的目的来选择。
\n分析什么点，这就需要你知道分析的背景是什么，从而有针对性切入。
\n其中分析什么点最关键，你需要知道你的 Leader 想做什么，如果这件事他自己也说不太清楚，那最好先别投入大量时间去做，不是你做得对或不对，而是问题都没搞清楚，即使他是 Leader。
\n竞品分析分为三步。
\n所有数据分析的第一件事，就是要搞清楚分析的目的是什么？做分析时一定是要带着某种商业意图来做，不要忘记初心。分析目的分以下几种情况。
\n当你尝试进入某个新的行业，需要评估可行性。比如唯品突然想做唯品金融，这个时候肯定就要评估可行性。这种竞品分析更加偏行业趋势、市场规模，财务收入，看大数不拘于小节。比如说看一下目前整个金融行业的情况，另外看一下电商类公司的发展，比如京东金融是怎么做的。
\n纯粹看竞品的功能、玩法和数据，学习优点。人无我有，人有我优，主要以学习为主。这种分析目的比较常见，主要以功能体验、运营手法、具体数据为主，落地性非常强。
\n通过看竞品的不同版本迭代的功能、玩法和数据，揣摩竞品想干什么，目的以预防为主。看竞品的版本迭代，思考竞品最近的战略中心在哪，这种情况往往是为了满足管理层的需要。
\n我们知道分析目的之后，下一步需要拉竞品跟我们自身进行对比。这时候首先挑选核心功能一样的 1～2 两家竞品，其次是功能体验分析，再就是运营手法分析。分析竞品的功能是怎么运用的，侧重对比运营手法。最后看宏观和微观的数据分析，也就是数据源，竞品数据源很关键，比如基础数据、财务数据、市场数据。
\n整个的过程是一项由分析师牵头与产品、运营协助的团队任务，同时可能还需要财务、市场部的参与才能完成。
\n第三步就是在第二步的基础之上给出一些初步结论。
\n比如你尝试进入某个新的行业需要评估可行性，那你最终的结论就是回答这个问题。是否可以进入这个行业？如果可以进入，步骤是什么？
\n比如你纯粹看竞品的功能玩法和数据，学习优点。那你最终的结论要落到竞品的什么功能好？接下来产品和运营如何去做？这样做预计能带来多少收益？
\n比如你只是看竞品不同版本迭代的数据，揣摩竞品想干什么，那你最终的结论就是竞品的下一步战略是什么？我们要不要也做某种尝试？实际上这种非常难，需要管理人去拍板。
\n以上是一些方法论，现在我以优酷、爱奇艺为例，具体来说下竞品分析（可能双方 App 版本有更新，例子请以我截图为准）。
\n案例背景：
\n当下小 A 是负责优酷 App 会员模块的数据分析师，Q3 季度优酷会员增长乏力，而爱奇艺会员仍处于高速增长阶段。管理层希望对爱奇艺会员进行一次分析，学习爱奇艺会员的优点，从而提升优酷会员数。
\n从案例背景可以看出分析目的是提升优酷会员数，分析对象为爱奇艺。我们来看具体怎么做？
\n第一步先看基础数据，如果公司有内部数据，直接用即可。如果没有可以使用外部数据源，外部数据源基本上可以从 Google、百度、Questmoblie、百度指数获取，但数据源只是一个参考。对于爱奇艺，其实我们能够拿到很多数据，但不是每一个数据都需要看，关键是你要想清楚看过这些数据后，对后面分析有什么用。
\n既然是分析会员数，我们首先要知道爱奇艺会员数跟优酷会员数的差距，如图所示。
\n从图中可以看出爱奇艺会员数明显占优势，这是一个基础数据。其次我们要看画像，如果优酷和爱奇艺的用户画像比较类似，那么同样的功能，同样的运营手段就对双方都合适。
\n用户画像可以从百度指数看，如下图所示。
\n从图中可知这两款 App ，无论是性别、年龄、地域都比较类似。在这个基础之上，我们去学习爱奇艺的优点是可以解决问题的。如果你这里贴出用户数使用时长，实际上意义不大，因为这对你后面的分析没用，所以第一步一定要想清楚你后面想干什么，然后再去查一些数据的对比，用这些数据来佐证你的想法。
\n第二步是产品的对比，产品的对比有很多种方法，一般先画交互流程图，然后再体验产品模块。这样的优点是大而全，但缺点是在有限时间内不一定能得到结论。实际工作中还是要交给专业产品来做，分析师可以提供一种方法，这种方法就是从普通用户去看产品，看用户的真正需求和困惑点在哪里，基本上可以通过线上问卷或者线下调研得出结论。
\n假设我们发现用户犹豫买会员的原因有以下几种，如图所示。
\n我们把用户的痛点归纳为这几种情况：
\n选择困难症——不知该买哪一家；
\n退货——用户感觉价格太高、用户担心买了不满意；
\n功能价值——付费功能吸引力不够。
\n在这个基础之上，我们已经知道了用户的痛点。从这个角度去切入做产品对比，如下图所示（左为爱奇艺，右为优酷）。
\n结合用户所关心的痛点，我们就来对比下爱奇艺和优酷这两款 App 。
\n选择困难症：相对来说，爱奇艺告诉了用户为何要买它，VIP 写得非常多，也非常明显，再加上体育会员和 FUN 会员还有会员俱乐部，提前抢占了用户心智。而优酷这方面比较弱，所以做一款 App ，你的传播符号一定要很强。
\n退货：用户购买后感觉不满意想退货退款，这里爱奇艺和优酷都没有给出解决方案。其实电商开始做 7 天免费退货也是一种巨大创新，所以可以在这方面探索下。
\n功能价值：当用户打开 App 时，一定要让用户感受到这款 App 对他有价值，这个时候最好的就是个性化推荐。爱奇艺当前没有个性化推荐，而优酷有个性化推荐。
\n再进一步就是用户关心的价格，如下图所示（左为爱奇艺，右为优酷）。
\n爱奇艺价格优势很明显，特别是新用户首 3 月优惠，这对拉新非常给力，而优酷在这一块做的没有爱奇艺好。同时在价格这个单独的模块上，爱奇艺界面上有京东 PLUS 年卡、客服、常见问题、银行卡支付、学生会员、退出时会员弹窗提醒等，这些细节都很好，而优酷相对来说差些。
\n实际上用户很在意价格相关问题，可以去结合客服数据进行优化。产品分析的目的是人有我无，学习他人的优点。从用户痛点去出发，对比两款 App 看竞品有哪些优点功能，而我们没有。
\n接下来是竞品之间的运营手法对比。在分析之前，我们先来理解下产品和运营的角色。你可以把产品理解为生孩子，运营是来养孩子。运营把孩子养大，需要持续观察孩子成长阶段的各个指标，保证他健康成长，成长的时候看他的身高体重，上学的时候看他的成绩，长大后看收入，这个过程可以理解为数据分析。
\n所有用户运营的目的都是提新增、拉留存、降流失，这就是广义的用户运营概念。所有的运营往往需要产品内容和产品活动的支撑来吸引用户。
\n内容运营：通过内容来吸引用户，比如我这门课本身就是内容运营。
\n活动运营：通过做活动来吸引用户，比如 App 抽奖活动。
\n举个例子：目的是通过优化渠道来提升新增用户数，那么就可以优化渠道文案、在渠道侧做一些活动激励。这就是通过内容运营、活动运营来达到最终用户运营。
\n在这个基础之上，我们看下爱奇艺和优酷在用户运营、活动运营、内容运营上面的情况，如下图所示（左为爱奇艺，右为优酷）。
\n首先是用户运营，这里我们看到爱奇艺有签到，点击进去还有 0 元秒杀。而新用户进入优酷后只提示要续费，仪式感和趣味性缺少。
\n然后是活动运营，爱奇艺是 IP+会员，比如“VIP 福利来袭，买特权卡送 3 重国风特权”，这国风特权就是一个超大 IP，还有学生会员相关提示。而对于优酷，它只有一个双 12 活动会员，没什么新意。
\n接下来看内容运营，这是难得的一个差异内容，运营就是讲究内容。爱奇艺有两个大 Banner 轮播，而优酷只有一个大 Banner，双方有较大差异。
\n总结如下表：
\n最后在内容运营里面，我单独会把内容生态拿出来讲，爱奇艺围绕内容有一个会员俱乐部。而优酷也有一个俱乐部。我们看一下这两个俱乐部，如下图所示（左为爱奇艺，右为优酷）。
\n从图中可知，无论是 UI、用户使用便捷性、分类 tab 丰富度、大 Banner，爱奇艺均明显优于优酷。爱奇艺的用户一进入 App，用户就可以知道会员特权可以做哪些事，而优酷并没有给用户这种感觉。在会员俱乐部这个最核心的玩法上，优酷提升空间巨大。
\n到这里，我们已经对爱奇艺和优酷的基础数据对比、产品对比、运营对比都做了分析，并且找到了切入点。那么就可以找产品和运营去落地。到这里，竞品分析的目的已经达到，只需要执行即可。我们分析的结论可以给产品运营具体的落地方案、跟进人、优先级、预期上线时间及预期效果，如下表所示。
\n首先对产品的落地项。第一是新用户会员价格的调整，这里面就需要进一步给出合理的价格曲线，你要考虑收入成本，这比较复杂，但是分析师可以参与进去；第二是在会员最里面的模块增加客服功能，因为用户要付费，不能把每个用户都当成老司机，用户付费时肯定会有一些疑问，这时候你至少要有常见问题回答；第三是退货功能的尝鲜，因为爱奇艺没有涉及，优酷是不是可以进一步分析，做一些尝试，这个需求优先级可以低些。
\n然后是对运营的落地项，我有两个建议。比如，第一个签到功能位置调整，因为当前优酷 App 有签到功能，但藏得很深，所以要把签到暴露在会员首页当中，虽然只是一个小的坑位，但效果可能会很好。同时也有一些效果，比如我们的签到渗透率和会员增加人数是不是都有一个估值。第二是要完善活动的丰富度，因为当前优酷的活动玩法太通俗化，双 12 加会员这个玩法，大家都能玩，优酷得有自己的一个核心竞争力。
\n对于上述表格中的前四个需求，产品和运营一定是可以拉资源，然后去落地，因为大家的主要目的就是提升会员数。在落地这件事上，分析师一定要充当先锋角色，尽最大努力去推动这件事。什么叫最大努力？比如，你去找产品或者运营，他们好像不太上心，这个时候可以去找他们 Leader 或者找自己 Leader 说明情况，双方 Leader 做一些决策，这时推动会更加容易。到这里，爱奇艺和优酷的竞品分析基本上完成了。
\n总结一下，我们做竞品分析的整体步骤。
\n第一步：确定分析的目的。
\n第二步：进行对比分析。
\n宏观基础数据。
\n竞品功能。
\n竞品的运营手段。
\n第三步：给初步分析结论。
\n最后我给你出一个思考题：视频行业不同阶段的老大分别是谁，他们各自又是如何成为老大的？
\n其实视频行业不同阶段的老大分别是谁，这个答案，你去百度一下就可以知道，最主要的是他们如何成为老大，这个很关键，你思考后可以在下方留言。
\n今天的课程就到这里，欢迎你关注我本人的公众号（微信搜索：AI悦创），之后会定期更新原创高质量的数据分析文章，下节课见，谢谢。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n今天我主要讲解路径分析。
\n本课时内容分为三部分：
\n路径分析定义；
\n路径分析案例——以美团 APP 为例；
\n路径分析思考。
\n我们在讲前面的案例中多次提到了漏斗模型，漏斗模型是非常经典的一种分析方法，但所有的漏斗都是人为假设的，也就是事前假设一条关键路径，事后看关键路径的转化数据。
\n随着各类 APP 的功能模块、坑位越来越多，用户的行为越来越分散化，比如很多 APP 不止有一个核心功能，可能有若干个核心功能。这个时候就要在用户的所有操作行为中，发现一些产品设计之初可能不知道、但非常有意思的用户前后行为，这就是路径分析。也就是说，路径分析是基于数据本身发现的，产品可能不太清楚，但是符合用户习惯的路径。
\n漏斗分析：人为设定一条或者若干条漏斗。先有假设再数据验证。
\n路径分析：基于用户的所有行为，去挖掘出若干条重要的用户路径，通过优化界面交互让产品用起来更加流畅和符合用户习惯，产生更多价值。先有数据再验证假设。跟漏斗分析刚好相反。
\n我们举个例子。
\n比如对于美团 APP 来说，我们发现它有很多功能，比如“搜索”“美食”“电影演出”“酒店住宿”“休闲娱乐”“外卖”这 5 个 tab，下面还有“家居”等。然后下面有 4 个小模块：“很优惠”“有格调”“秒杀”“周末去哪儿”，再往下翻是“猜你喜欢”，也就是个人推荐，而在底部 button 有“附近”“发现”“订单”“我的”，各个 button 里面又有很多子模块。
\n基本上目前市面上大多数 APP 都是这种多坑位，把能做的都做了。在这种情况下，漏斗分析确实完全满足不了日常分析需求，因为漏斗分析相对来说都是人为事先假定的，而且内容比较符合大众认知的习惯，这个时候就要路径分析派上用场了。
\n这就是路径分析的背景。
\n那么我们对路径分析的过程进行一个详细的说明。大家在听第二小模块的时候，一定要把美团 APP 多体验几次，后面会涉及大量的界面交互和路径使用，所以各个模块都要认真看几遍。
\n我们先说一下日志，因为路径分析实际上都是基于底层日志来做，有些同学可能没有看过公司本身的日志，用户在端内（ APP 内），所有的行为都是以表或者文件存储的，其中记录了用户最详细的行为信息，这就是日志。比如，你打开 APP，实际上在日志里面是有一条记录的，一般都是一行，格式如下图所示：
\n首先，对于日志我们怎么看？我们看到中间行与行之间是分段的，这个分段就代表每一条记录。这个日志首先是 Key-Value 格式，就以第一条记录来说，imei 和 ip 中间是以逗号分隔，每一条记录与记录间是行的分割。然后有哪些字段呢？我们有用户的设备号 imei、IP、内存、分辨率、机型、系统，event 和 active 事件、版本、子版本、操作时间 Unix time。
\n所以对于分析师来说，要知道自己公司本身底层日志是以什么格式来存储的，不一定是 Key-Value 格式，这块操作更多偏 Linux 命令，基本上分析师都会一些基本的命令，比如查今天的日志大小或者日志的一些字段，那么在这块查一下就行了。如果一个分析师每天大部分时间跟这种底层日志打交道，那一定是有问题的，因为这一块相对比较独立，更多的时候是数据研发工程师或者后台研发本身就应该做的事情。
\n当我们熟悉了日志的字段以及格式之后，就可以进行路径分析了，因为路径分析本身就是啃日志。路径分析一共分为四个步骤：
\n筛选：第一步是对所有功能用户的量级进行查看，筛选出重要功能，因为当前 APP 可能有 100 个子功能，那么到底要看哪些呢？这个时候就要用用户量级来评判了，首先选出这样的功能，找到切入点。
\n日志关联（抽样）。第二步，就是对筛选出的功能进行时间序列的排序，比如对于一个用户来说，一天可能有 10 个重要功能，那这 10 个重要功能的先后顺序是什么样子？你要先排序，既然是路径分析，肯定有先后，排完序之后就是日志与日志之间的功能数据的匹配，比如用了 A 功能之后有多少用户用了功能 B？这个就是同一份日志相互间匹配，但是一定是先排序好。然后就是关联，对于所有的路径分析，日志关联都是抽样，因为公司的日志可能非常大，如果要做这一步关联，资源是跟不上的，所以抽样就可以了，基本上抽 10 万、 20 万数据就可以。
\n标准化及画图：第三步就是数据的标准化以及路径画图，因为第二步是相对绝对的数据，比如使用功能 A 的用户是 100 万，然后这 100 万里面有 80 万用了功能 B，实际上还是这种绝对量级的数据，而第三步是让第二步更加可视化以及标准化。
\n启发：第四步就是在第三步的基础之上，看有没有比较有启发性的路径，大部分公司做路径分析都要从第一步开始，一步一步来做。但是有一些公司在技术层面一二三步已经帮你搞定了，就是底层研发把一二三都已经做了，然后分析师相对来说要轻松，看第四步就可以了，这就比较好。
\n整个过程不是特别难，但是非常考验耐心，大家可以这样理解，就是你沉浸在日志当中，然后去干各种各样的行为。我们举例子来说，这样比较生动。
\n第一步筛选，对于美团 APP，假设它的主要功能以及功能渗透率的数据如下表所示：
\n我们通过这些功能渗透率就发现，“美食”“外卖”“搜索”是三个最大的功能，因为它们的渗透率都很高，达 30% 以上；“电影”和“酒店”这两个重大的 tab 渗透率并不高，也就是表现不是很好；而“周边游/旅游”以及“景点/门票”这两个 tab 位置不是特别好，但表现比较好；而底部的“附近” button 只有 18% 的渗透率，“发现”是 3%，“订单”是 20%，“我的”是 8%。在此基础上，我们就可以进一步筛选出要分析的功能。
\n筛选结论：
\n所以先要找到切入点。
\n第一步是找到所有重要功能，然后在这个基础之上，发现有没有一些点比较有意思，找到切入点。本课时后面是以 1/2/4 这三块一个一个展开，其他的大家可以类似地去发散联想具体怎么做就可以了。
\n第二步就是数据进一步关联及标准化。刚刚说了，我们会对“美食”“订单”以及“附近”这三个功能进行查看。
\n美食
\n我们先看“美食”，假设“美食”的原始数据如下表：
\n我们先看“美食”，假设“美食”的原始数据如下表：
\n它是一个很重要的功能，进来之后用户有各种各样的路径，然后我们按照时序来排列，这个 1,2,3,4,5,6 假设是按照先后顺序。
\n100 万人当中有 80 万去了“离我最近”。这个“离我最近”是在智能排序这里，进行手动切换之后就是“离我最近”，也就是说有 80 万用户进来之后直接点了“离我最近”。进去之后有 75 万用户进入详情页，比如点这个“百果园”，直接进去的有 75 万，然后 75 万里面有 40 万用户又返回到“离我最近”这个界面，也就是说用户逛了一会儿之后回退。然后 40 万里面又有 30 万用户再进入另外一个详情页，最终这 30 万里面有 20 万下单。这是第一个路径，就是 100 万的美食用户有 80 万用户是走这样一个路径。
\n同时第二个路径是 100 万里面有 30 万进入“优惠团购”这里，“优惠团购”里面又是一个界面，然后有 25 万人用了上面的搜索功能，实际上比较奇怪，因为“优惠团购”的界面已经有比较多的商品可以选购了，但是用户用了搜索，然后 25 万的搜索里面又有 20 万的用户进入详情页，然后 20 万里面有 18 万进行下单。这是第二个用户路径。
\n第三个用户路径就是 100 万用户里面有只有 5 万用户进入“外卖”，也就是说“外卖”放在美食里面这样一个位置，它的渗透率并不是很高。
\n第四个就是“限时秒杀”这一块，100 万用户有 30 万用户进入到这里面，而 30 万用户里面有 28 万点击详情页，跟第一个路径比较像，又进行了回退，进入另外一个详情页再下单，也就是说用户有返回的操作。
\n这个就是原始数据，就是对底层日志进行时序排列，然后日志与日志之间相互匹配，之后就是这样一份数据，这样一份 excel 表格。
\n那么在这个关联数据的基础之上进行标准化以及画图：
\n真实的过程中，大家不一定要按照这样来画，我这里只是为了说明问题。比如“美食”，这里面 80% 是到“离我最近”，30% 到“优惠团购”，5% 到“外卖”，30% 到“秒杀”，就是上面的转化率，同样的后面每一步都有一个转化率，这个就是这 100 万的美食用户在端内的主要路径。
\n当然肯定还有其他路径，比如用户点“夜宵”，但是它的渗透率不是特别高，所以就不说了。这里就是发现一些比较有意思的路径，在这一步，它需要很多的耐心，因为你只能慢慢去看，这个在前期做的时候会非常耽误时间，但是就只能这样，因为所有的人做都是这样的过程，就是你要对业务非常了解。这个是“美食”用户进入“美食”之后的路径。
\n附近
\n第二步一样，对于“附近”这个模块，用户进来之后，假设他的数据是这样一种形态：
\n我们发现，进入“附近”之后，大家看到最大的位置是“享美食”这一块，但是它的用户数只有 10 万，就是都是 50 万用户进来，只有 10 万用户到“享美食”，而“搜索”这一块儿竟然有 30 万，也就是说，更多的用户是通过“搜索”进入另外一个界面，也就是各种各样的店面，然后再进入详情页再下单，是通过这样一条路径来完成的。那么这个是不是就能说明我们当前界面做得并不是特别好？同时对于“享美食”“会生活”“爱玩乐”这三个 tab，理论上它们的点击率相对来说差异比较大，但是数据上面显示，一个 10 万、一个 9 万、一个 8 万，相差并不是很大。那么“享美食”作为最大的曝光界面可能就是出现了比较大的问题，从数据上来看就是这样的一个解释。
\n订单
\n我们再看一下第三个，就是“订单”。对于“订单”这个功能，首先它的界面是这样：
\n用户进来之后，上面是“最近订单”的曝光，底部有一个“最近浏览”，就这两块，然后具体数据是：
\n有 50 万的用户进入“订单”这个界面，其中 45 万直接到具体订单详情页，比如 45 万的用户直接点百果园，点进去之后有 40 万直接就退出这个界面了，具体的转化数据就是这个图：
\n都是 90%，也就是说，对于“订单”这个界面，用户的目的非常明确，因为 50 万用户进来之后最主要的路径就是这样，其他的都很少。假设数据就是这样，那么我们就要进一步调研，用户进入订单页面目的是什么？如果只是查一查订单，那么我们是不是能在里面做一些相关推荐？“最近浏览”做得太单薄了，而且还是做在外面，实际上用户进入订单详情页之后就直接走了，在最里面就直接走了，而不会返回当前界面。
\n数据上是这样一个结论，就是围绕一二三，一个是首页的“美食”，一个是“附近”，一个是“订单”，我们有哪些启发呢？因为到第二步实际上只是一个具体的标准化数据以及图，我们有哪些启发？
\n首先对于“美食”功能来说，默认的是智能排序，但是 80% 的用户会切换到“离我最近”，这里我的想法是，如果把智能改为综合字眼可能会更好，因为用户对智能可能理解得不是特别深刻，饿了么的精品就是综合排序。同时我们看到，用户第一次进入详情页之后，然后又有用户返回“离我最近”，也就是说用户有一个回退按钮，然后再进入详情页。这里建议在详情页内部增加相关推荐，让用户在里面逛，缩短用户的下单路径，而不要让他回退。
\n第二个点就是在“美食”功能中，有 30% 的用户进入“优惠团购”，很明确，这部分用户喜欢占便宜，同时竟然有 83% 用了搜索，因为优惠团购点进去之后，它是一个最大的曝光位置，有很多的店家。但 80% 用户用了搜索，说明当前界面的主动推荐不太准确，需要优化，我们要更好地去揣摩用户的意图。
\n同时对于“外卖”这块也一样，外卖放在那个位置不是特别好，可以考虑把它替换掉，可能外卖本身在最外部就有 40% 的流量，而在这里面只有 5%。对于“秒杀”也一样，也有一个回退，那么也可以考虑在详情页里面增加相关推荐。这个就是“美食”功能。
\n对于“附近”功能，我们发现首先 40% 的用户会回到首页，就是用户进入“附近”这个 button，然后又有 40% 用户立马跳回首页；60% 的用户用搜索，而“享美食”“会生活”“爱玩乐”的渗透率差异不大，“享美食”作为最大曝光界面占比，“附近”整个模块当前问题较大，就是用户进去了，但是你没有很好地满足用户的需求，很多用户就跳出来了，同时你最大的曝光界面没有人点，而是用了搜索为主。
\n而对于“订单”功能，90% 的用户查看订单后直接退出，可以考虑在订单详情页里面增加更多相关订单内容曝光，当前曝光内容是最近浏览曝光，效果不好，所以要增加用户消费场景。
\n那么基于这三个路径，我们就可以做很多事情了。刚刚我们对“美食”“订单”“附近”这三个button做了一些分析，就已经发现了有很多优化点。当我们对其他功能也按照这种方式去分析的时候，就会发现有很多其他的可以改进的地方。
\n所以实际上路径分析不难，就是日志跟日志之间匹配，然后去标准化数据，然后去画图，就是这样一个过程。但是路径分析是一件非常消耗体力的活，因为功能可能很多，用户前后行为可能非常多，这就需要分析师对业务非常熟悉，一定要每天都去使用自己的 APP，就是你不能把自己当作一个普通用户，你要把自己当作各类用户都要去体验自己的产品，因为用户在端内的任何行为都是合理的。
\n每个产品经理都是负责自己的一小块功能，比如你是专门负责外卖的，而分析师就是最大的产品经理，站在全局的角度去看产品，外卖的产品经理不知道美食板块的数据，分析师是知道的，所以分析师提出某个落地项，既能优化当前功能，又能对其他功能没有负向影响，否则就没意义了，同时还能提升大盘数据。这非常考验综合思考力，就是你提出的某一个落地项，比如做这种 A/B，那么你不能光看最后对你这一小块功能的提升，同时还要看对其他功能有没有影响，只有在这个基础上对大盘有进一步提升，这个时候 A/B 测试才有很好的效果。
\n最后我们看一下对路径分析的思考，路径分析本身整个过程就是这样，更多公司在可视化这一块可能不太一样，有一些公司的可视化会相对来说会更加酷炫。那么路径分析当前还有哪些点可以进一步去做呢？前面我们对美团 APP 的路径分析的举例就到这里，实际上我本身对路径分析也有一些思考。
\n大家都知道我们刚刚说的所有路径分析都是以功能点的时序整体分析为主，只有指标没有维度，而要想精细化运营，必须要进行维度拆分，如通过不同入口，通过桌面或是通知栏进来的用户，他们的路径分析差异在哪？这就涉及做逻辑分析的时候要进行维度拆解，这是第一个点。
\n第二个就是对于有些 APP，比如携程旅行、小猪短租，用户可能在今天打开 APP 后逛一会儿，然后就走了，过一周后再进来才下单，对于这种用户一天不连续路径，如何进行分析呢？其实这是一个行业难题，我之前去听一个 CEO 讲这一块的时候，也没有很好地解决，无论是进行周期时间段的 session 分析，还是短期画像的分析，效果都一般，这一块大家可以去想一想。
\n第三个就是 PC 端的路径分析和 APP 端的路径分析最大差异在哪，同时 PC 端有没有案例，因为我们本节课就是讲 APP 端，那么这一节课的路径分析本身就要求你对一款产品的功能以及各种路径都要非常熟悉，所以大家一定要去多体验一下美团 APP，我前面提到的美食功能的几个路径以及画图，还有附近、订单等，这样的话大家才能更好地理解这节课的内容。
\n还是那句话，路径分析是非常实用的，但是在实际工作过程中，很多分析师没有去看用户的行为，这一块如果做好了，对你的用户最终的转化率是非常有帮助的。
\n这一节课可能有一点难懂，因为路径分析跟你对 APP 的熟悉度非常有关。今天的课程就到这里，如果你有问题可以在下方留言，同时欢迎你关注我本人的公众号（微信搜索：AI悦创），之后会定期更新原创高质量的数据分析文章，下节课见，谢谢。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n和孩子一起读书，是我发现的“育儿神技”📚✨
\n你好，我是悦创。
\n小时候读书，是一种逃离世界的快乐；当了爸妈之后才发现，读书也可以是和孩子之间最温暖的链接方式。
\n很多人以为，“亲子共读”只是培养感情的小项目。但在我看来，它其实是帮助孩子聪明成长的“神操作”之一。
\n📖 我为什么这么热衷亲子阅读？
\n我是个爱读书到骨子里的人，哪怕每天只挤出十分钟，也要看上几页。有人问我为什么表达能力好，为什么讲课时能滔滔不绝，其实秘诀很简单：常年读书积累的结果罢了。
\n但有了孩子后，我才明白，有一件事比自己读书更有意义——那就是和孩子一起读书。
\n❓“我买了一堆书，孩子就是不爱读”，怎么办？
\n很多爸妈都遇到过这个问题：书买了，架子也摆满了，结果孩子就是没兴趣，甚至一逼他看书反而更反感了。
\n我以前也很头疼，直到我接触到了“互动阅读”。
\n💡互动阅读，是打开孩子阅读兴趣的金钥匙。
\n你光把书摆在那儿，其实远远不够。阅读这件事，需要爸妈“参与”进去。
\n这时候有家长会问：🔬有科学依据吗？
\n有！香港中文大学曾经做过一个实验，把 86 个小朋友分成三组，一组亲子互动阅读，一组爸妈只是自己念书，最后一组干脆没读。结果发现——只有互动阅读组的孩子，阅读能力进步最明显！
\n国外研究也表明：互动阅读可以让孩子的智商提高平均 6 个点！
\n特别提醒：互动阅读对 4 岁以下的孩子效果最好。过了这个年龄段，效果会渐渐减弱。
\n别担心，看完下面这几点，你就知道怎么做啦👇
\n很多家长不自觉就让阅读带上了“功利”色彩：
\n正确姿势是：让阅读成为日常生活的一部分，甚至是最有趣的部分！
\n我家女儿现在快 1 岁了，我也准备开始互动阅读了，要一起一步步培养。
\n想要把孩子培养好，真的不是靠填鸭式教育，而是靠着我们一天天坚持的亲子阅读时光。
\n希望读者阅读完我这篇文章后，能达到：小孩每天睡前，都会抱着书来找我们：“爸爸，我们今天读这个吧！”对她来说，读书不是任务，是一天中最期待的亲密时光。
\n你要知道，这些看似平常的亲子共读时光，其实正在悄悄帮她积累词汇、培养想象力、激发表达能力，甚至塑造她的自信心。
\n在孩子还小的时候，最重要的从来不是“读了多少书”，而是——他是否爱上了读书这件事。
\n把书变成亲子互动的工具，把阅读变成一场好玩的冒险游戏。你会发现，孩子不仅爱上了读书，也更爱和你在一起。
\n\n\n阅读的种子，往往是在亲子互动中，悄悄发芽的🌱。
\n
📌你也在和孩子亲子阅读的路上吗？欢迎留言分享你们的趣事和小技巧，一起让更多孩子爱上阅读！❤️
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n今天我以欢乐斗地主游戏为例介绍一下游戏行业的数据分析。
\n本节课内容分为四部分：
\n背景；
\n指标口径；
\n用户流失分析；
\n用户付费分析。
\n在前面两课时，我介绍了互联网和金融的数据思维，其实游戏行业兼具互联网与金融数据思维。我之前体验了狼人杀和欢乐斗地主两款 App，因为个人抵抗力比较差，每天都玩到很晚，对我的工作和生活都有一定影响，最后决定把它们删了，不玩了。所以游戏行业用户两极分化比较严重：要么快速流失，要么玩的时间就很长。
\n因此本节课重点围绕两个目标：
\n尽量让用户晚点流失——流失分析
\n让花时间的用户多变现——商业分析
\n我们先来看看欢乐斗地主 App 的界面，如下图所示。
\n在上图界面的右侧，有经典、排位、残局、比赛的坑位，点进去之后是对应玩法。最右下角的有一个“商城” button （小人推着小推车），点击进去之后如下图所示。
\n这是欢乐斗地主 App 最重要的界面，后面的讲解我会围绕这些图片来展开。
\n第二个模块是指标口径，指标口径包括常规指标和商业化指标。
\n常规指标包含四类：
\nDAU、WAU、MAU
\nDAU、WAU、MAU 分别指产品的日活、周活以及月活。对于任何产品，首先要看用户规模，用户规模是一个亿还是五千万，要有具体的数值。
\n留存率
\n留存率一般是看次留、7 留、30 留存率。留存率是一个比例，反映产品的联系程度。以次留率为例，次留率等于第一天打开欢乐斗地主并且第二天也打开欢乐斗地主的人数除以第一天打开欢乐斗地主的人数。
\n比如，第一天打开欢乐斗地主 App 的有 1000 人，第二天这 1000 人里面又有 800人打开了App，那么它的次留率为：800/1000*100=80%。
渗透率
\n每个产品都有很多子功能，每个子功能的渗透率等于该模块的使用人数除以该产品的日活。
\n比如，欢乐斗地主 App 的昨日 DAU 为 1000 人，昨日有 900 人点击“商城”。
\n那么“商城”渗透率为： 900 / 1000*100=90%。
转化率
\n转化率针对某个连贯路径。它等于使用下一个节点的用户数除以使用上一个节点的用户数。
\n比如，欢乐斗地主打开APP（1000 人）— 进入房间（800 人）— 参加比赛（700 人）。
\n进入房间的转化率=800/1000*100=80%参加比赛转化率=700/800*100=87.5%商业化指标有三个概念。
\nARPU：代表一个时间段内的用户平均收入
\nARPU= 付费金额 / 活跃人数
\n比如，欢乐斗地主付费总金额 200w，活跃人数 100w，用户平均收入 2元。
\nCPM、CPC
\nCPM 是千次曝光的成本。
\nCPM=（广告投入总额 / 所投广告的展示数）*1000
比如，某广告主在欢乐斗地主的闪屏界面投入一个广告 10w，共展示 1000w 次，那么 CPM=10。
\nCPC 是每个点击用户的成本。
\nCPC= 广告投入总额 / 所投广告带来的点击用户数
比如，某广告主在欢乐斗地主里面投了一个闪屏广告 100w，共产生点击 50w，那么 CPC=2。
\nROI：代表投资回报率
\nROI= 收入 / 支出= ARPU*用户 数/ 所有支出
\n比如，双 11 在欢乐斗地主内部投放一个广告100w，最终带来收入200w，那么 ROI=2。
\n第三个模块是用户的流失分析，行业内把一个月内不使用产品的用户定义为流失用户。实际上，不同产品形态的用户行为差异非常大，像住宿类 App 是低频高价值用户，而欢乐斗地主 7 天不上线可能就已经流失，所以要合理定义流失用户。对于流失用户，发现的越早越好，在这里会出现不太好定义用户流失的情况，比如你先定义 30 天用户不来即为流失，结果到 30 天的时候，大量用户回流。
\n如何合理定义流失用户，我们可以参考用户流失的周期，本质上等于回流率的确定，一旦用户回流率稳定，就可以定义这个时间段的天数为用户流失周期。
\n用户回流率 = 回流用户数 / 流失用户数 = 某个周期内的流失用户数在周期结束后又回来了 / 某个周期内的流失用户数
\n所以，根据这个公式按照枚举法，周期天数 = 1,2,…,30，然后分别计算回流率，一旦回流率趋于收敛，该周期就是流失周期。
\n比如，我定义 1 天不来就为流失，然后按照公式会得出一个回流率数值，然后我再定义 2 天不来就为流失，又得出一个回流率数值。以此类推，到 60 天就会有 60 个回流率数值，这些回流率对应的 60 个点就可以画出一条曲线。这条曲线在什么时间段趋于平缓，那这个周期就是一个合理的流失周期。
\n举个例子，假设欢乐斗地主 App 它的流失数据，如下图所示。
\n我们根据以上数据用周期和回流率来画一条曲线，如下图所示。
\n由上图曲线可知，在第 7 天（ 0.05 水位线）回流率趋于稳定，所以可以把 7 天定义为流失周期。假如用户 7 天不上线即定义为流失用户，这样就会有很大说服力。
\n流失周期确定后，我们要进行用户的流失分析，对于游戏行业的用户流失分析，即有其他行业的类似套路，也有一些差异点。
\n以欢乐斗地主为例，用户最后一步行为类型，如下表所示。
\n| 最后一步行为类型 | 最后一步具体行为到退出游戏时长 | 用户占比 |
\n|
你好，我是悦创。
\n今天我讲一下多元思维模型。
\n本节课内容一共分为四部分：
\n背景；
\n中观能力；
\n微观能力；
\n宏观能力。
\n目前在整个数据分析行业中，大部分同学偏数据库和机器学习，又或是学计算机专业出身，所以会造成一种行业错觉——会点技术、会点 PPT 就可以做数据分析，感觉门槛比较低；有时候觉得自己做出的分析报告，别人能很快的发现问题，自己也认可，但就是不知道如何避免；有时候针对某个问题，有些人总是能有很多想法，但自己却不知道怎么理解；有些人职业发展的很顺利，而自己却始终有瓶颈。
\n其实这些困惑都非常正常，所以这一节课的目的就是告诉你，到底掌握好哪些能力才能够成为一名优秀的数据分析师，这也是后面所有课程的一个基础。这一节课会有一点点抽象，但是你要好好学。
\n先给出数据分析的多元思维模型，就是从中观、微观、宏观三个角度去出发。
\n中观能力：中观能力是真正的专业度，看你是否能够发现其他数据分析师在分析中的问题。这个专业度不单指你的技术，而是需要你长期总结和思考。
\n微观能力：微观能力指有效沟通力+快速发散收敛力，看你是否能够从业务的交流中发现问题，找到方向，很多同学都还没意识到这一点。
\n宏观能力：宏观能力是洞见性的全局观，能够从社会事件和整个行业发展中找到业务的决策方向，这是极难的能力，同时平台和天赋缺一不可。
\n怎么获得这些能力呢？我逐一来讲。
\n中观能力指专业度，包括技术理解、逻辑性、价值点三个点。中观能力是反映分析师基本功怎么样、套路熟不熟练、思考到不到位的一种标准。
\n技术理解：指对分析时用到的技术理解是否到位，是停留在理论阶段还是在实践阶段。很多同学看了很多数据分析的书籍，理论说起来无所不知，但在实践过程中还是遇到很多坑。
\n逻辑性：指对整体思考的逻辑性是否欠缺。
\n价值点：强调价值，你做出来的分析价值在哪。如果现在你是决策者，你敢不敢立马规划落地。
\n中观能力的提升相对比较容易，基本上就是从他人那里获得有效反馈，所以你做出的分析一定要获得高手的反馈，让他指出一些不足或建议，然后多实践。
\n在数据处理中经常用到数据标准化方法，比如常见的 MAX-MIN （最大最小值）方法、Z-score （z 分数）方法、指数对数法。但这只是理论上的方法，你需要理解到数据标准化的本质目的是去除量纲、量级的差异性，才能在业务中有效地利用。
\n举例：对于 to B 的金融公司来说，除了头部的大客户（前期资源），剩下的都是中小客户（后期拓展）。大客户和小客户需按照每天的交易额来区分，所以需要我们对交易额及用户进行建模。这时就要用到数据标准化，以 MAX-MIN 方法为例，如果直接用这种方法，会造成除了头部几个数据有数值外，其他基本都是 0。到与业务方沟通时，业务方 Leader 会觉得你这个方法很有问题。数据非常稀疏，无论是可用性还是理解性都很困难。
\n所以，有两个解法：
\n实际上所有的技术都是为了让业务更加方便，更加高效，而不是让人很困惑，这就是技术理解。
\n关于逻辑性，我举一个资讯类 App 的真实案例：数据分析师在研究最近一个月的数据，发现所有与留存相关的因素中，留存和自媒体文章下发的占比存在高度相关性。于是就建议业务方多下发自媒体文章，业务方觉得这个点很好，还真的做了。结果是刚开始几天留存是微涨，后续却大跌。
\n你觉得这个案例的问题出在哪 ？
\n其实相关性是一种基于向量的伴随关系，不代表直接的因果关系（但确实是因果关系的一种可能性），也就是说留存和自媒体文章下发的占比是一种伴随关系，而不是因果关系。留存的影响因素非常多，不仅仅是因为某一两个指标就能很好地提升留存。
\n上述例子后来复盘发现，最近刚好是因为有一些重大热点导致留存提升，而这些重大热点文章是以自媒体文章为主，最终造成了自媒体文章下发占比能提升留存的假象。
\n所以分析师的逻辑性非常重要，每一环节的推导必须要讲究严谨性，不能有侥幸心理。
\n价值点，强调你做的所有分析一定要有价值点。
\n我曾经见到一个同学，竟然在业务分析报告里面用到了大量的复杂公式，最后还画了一张非常复杂的技术图，在会议上大家都不好意思反驳他。后来问了业务方，得到的反馈是，整个分析报告用了两个月时间，看似解决了很多技术痛点，但是对业务提升没意义，因为听完不知道怎么去落地。
\n在数据分析过程中，有些是避免不了的描述性统计，你要快速解决，切记不要耽误时间。而对于指导性、预测性的分析，最花时间也是价值最大。你一定要利用好有效时间找到价值点，即使这个价值点只有 1 个。请注意：有没有价值不是分析师说了算，而是业务方说了算，有些点很好但暂时无法落地，就先不要管它。
\n中观能力能体现分析师的专业度，基本上就是多沉淀、多思考、多反馈、多总结。
\n我们先看下微观能力的背景。
\n在中观能力相同的情况下，有些分析师总是表现的比其他分析师更加优秀，比如：
\n针对某个问题，总是能产生很多想法，找到切入点——很有想象力；
\n业务方如果遇到问题就会优先找他，而他总是能在最短的时间内给业务方一个较好的答复——有解决问题的能力；
\n对于数据有更好的敏感度，能够第一个发现数据问题并给出解法——敏感度高；
\n会议上，总是能提出自己的独到观点，让别人觉得他很聪明——快速发现提问；
\n总是能很好的知道业务在干啥，而他的视角又一直是高于业务，所有人都认可——有高维视角。
\n这些都是分析师微观能力的表现，始于经验，终于沉淀，注重点点滴滴，思维高度活跃，总是能找到一些线索。微观能力是反映分析师平时的微观体感怎么样，作为一名分析师，你必须能发现很多业务方发现不到的点，然后从数据上给出策略建议。
\n具体怎么样做到这一点呢？
\n首先要知道业务是怎么想的，怎么做的，然后从中发现问题或者切入点，具体来说就是有效沟通能力和快速发散、收敛能力。
\n有效沟通能力：指在与业务方核心人员沟通时，要从谈话中快速捕捉到有用信息（说者无心听者有意）。
\n快速发散、收敛能力：收敛能力基于沟通中的有效信息，快速提炼总结找到最好的分析切入点。
\n所谓的好奇心或者说想象力，都不是凭空产生的。回归到数据分析本质，只有和相关业务方多沟通，从他们那里获取有效信息，再自身提炼加工（多学习、思考），才是可落地的“天马行空”。这就是优秀分析师厉害的地方（快速捕捉、提炼、找到问题、解决问题）。
\n有效沟通能力有两个技巧。
\n技巧 1：黄金思维圈法则
\n在了解业务的情况下，反问业务方为何要做这件事，基本上，业务方都会有一个很具体的回答，往往都能在这里找到切入点。
\n举例：顺丰科技最近在做一个类似锦鲤的活动，业务方要分析师给出活动带来的新增用户数。
\n这个时候分析师要先体验下这个活动，并且让业务方介绍下活动，同时要问业务方为何要这个数。
\n熟悉这些之后，发现这个活动本身没有特别的拉新点，活动本质是促进老用户活跃。所以建议业务对促活进行深入分析，一旦这样就已经高于业务视角了。
\n多问为何要做这件事，往往就能找到问题的本质，解法自然就多。
\n技巧 2：做一些准备工作再沟通
\n在与业务沟通中，如果没有提前准备一些业务知识和数据，整个过程就是业务在主导，你还怎么发现问题呢？
\n举例：爱奇艺 App 最近新上线了某功能，业务方拉各方参加会议，讨论下这个功能下一步的玩法。
\n实际工作中，分析师都不一定知道会议主题，或者知道主题没有思考就去参加会议。可想而知整个讨论，只能了解一些基础信息外，无法获得有效信息。会议是一个很好的公共场合，也是分析师证明自己独特视角的地方，所以沟通前一定做好准备，这样不仅没有浪费会议时间，还能让别人觉得你很厉害。
\n发散：指对于某一个全新业务问题，跟业务沟通之后，分析师想法很多。
\n收敛：在众多想法中，快速找到当前做哪个比较实际、合理，并且知道如何做的深入。
\n举例：在制定公司级 KPI 的时候，业务分析师需要预估下一年，年中的 MAU 和 DAU 。
\n该问题有多种解法：时间序列、行业环境、渠道分析都可以作为切入点。最终觉得渠道分析切入点会更加合理。
\nMAU = MAU 新用户+ MAU 老用户
MAU 新用户=明年渠道侧每个月能够带来的新增量多少（这个与明年预算高度相关）
MAU 老用户=MAU 上月新次月老（基于渠道）+MAU 上月老次月老（历史数据）+MAU 回流（历史数据）
新次月老：上月新增用户次月老用户
\n老次月老：上月老用户次月老用户
\n其实渠道这个切入点是分析师从市场部无意捕获到的，后来提炼了下，觉得非常合理。对于全新问题，没有固定答案，分析师需要做的就是快速给出一个有依据的解法即可。
\n这就是快速发散收敛能力的培养，总结一下：
\n要尽可能多地和业务方核心人员，特别是业务 Leader 沟通，有些业务 Leader 非常优秀，看他们是如何思考理解业务的；
\n多看一些心理学、社交学、经济学、记忆力类、科普类的书籍，这些书籍对你微观能力的培养非常有好处；
\n刻意练习，慢慢地养成习惯，一定要把心静下来去做事情，相信自己一定能够把微观能力培养好。
\n宏观能力是指能够把当前业务与实际社会热点、行业风口联系起来，提前预判，获得更好的决策。宏观能力非常难，如果做好了，基本就是顶级 CEO 了，大部分同学都还没机会接触到这一层面，因为它需要你有一定的决策权。
\n比如互联网金融监管政策的加强，对平台型理财公司是一种灾难级的影响，优秀的分析师总是会去定期观察政府行业的动态，提前预判一些敏感信息。而这种敏感度只有多看新闻联播和财经类的节目才能慢慢培养好。
\n我们看一下网信办跟资讯类 App 这样的社会热点事件，跟业务高度相关的时间序列，如下图所示：
\n2017 年 10 月 26 日，网信办（负责互联网信息服务管理）召开宣贯十九大大会，宣贯十九大精神。一周之后，网信办深入互联网企业，向京东、百度进行企业调研。一个多月之后，网信办整改今日头条，部分频道下线，今日头条用户流失严重。如果当时头条有一些敏感性，在事件发生的一个月之前就应该认识到问题，做一些补救措施应该还没这么严重。
\n作为今日头条的竞品——UC 浏览器，同样没有认识到问题的严重性，或者说心存侥幸。2018 年 2 月 1 日，广东网信办整改 UC ，那段时期 UC 的用户流失非常严重。这就可以看出宏观热点事件对业务影响巨大，所以优秀的分析师一定要保持这种高度的敏感性。
\n今天的课程就是讲解中观、微观、宏观能力。
\n中观能力在公司都会学习一些，只要获得一些反馈再优化即可。
\n微观能力特别注重平时的微观体感，所以分析时一定要有静下来的决心，注重套路的真实落地过程，从不同的业务方捕捉、提炼、沉淀，这是一个长期的训练。
\n对于宏观，你需要关注行业内的动态，像新闻联播、财经类节目都是重要的数据源。
\n另外多说一句，公司的 CEO 其实是顶级数据分析师这个角色，所以分析师这个天花板非常高，发展空间也非常大。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n今天我讲一下各种数据分析工具的使用场景对比。
\n本节课内容分为四大部分：
\n数据分析整体流程；
\nExcel 常用操作；
\nSQL 常见问题；
\nR 语言以及 Python 脚本案例。
\n数据分析有一套标准化流程，很多人在做数据分析的时候，不知道怎么去开展或者怀疑自己做出的分析报告是否合理、是否全面，这是因为你对这一套标准化流程没有真正的理解。
\n来看一下标准化流程的九个步骤：
\n明确问题，先把问题定义清楚，因为很多人还没理清问题就直接去看数据了；
\n搭建框架，定义问题之后再把问题考虑全面、找到一条分析主线；
\n数据提取，用 MySQL、Hive 等工具提取相关数据；
\n数据处理，用 Excel、R、Python 处理数据；
\n数据分析，以数据分析方法论为主来分析数据；
\n数据展现，用 Tableau、Excel、R、Python 工具把你的数据展现出来；
\n撰写报告，考验你的文笔功底以及整体逻辑性；
\n报告演讲，考验你沟通能力，表达能力，被提问能力。所有的报告撰写完成之后不要直接去讲，还是要和业务方进行大量的沟通，如果不提前做好沟通，你在会议或公众场合上讲时很容易被别人挑战；
\n报告闭环，这是最难也是最大价值的地方。
\n这里面的数据提取、数据处理、数据展现是数据分析师前期的基本功，以工具为主，都是比较容易学到的，也比较容易完成。而明确问题、搭建框架、撰写报告、报告演讲、报告闭环更多是考验分析师的综合能力以及智商、情商，所以这块往往需要很多时间去沉淀。基于数据分析这一套标准化流程，其中涉及一些你必须要学的工具，下面我简单讲一下这些工具。
\nMySQL、Hive：基本上所有的数据获取方式都是通过 MySQL、Hive 这两种语言来实现，同时你要学习一些 Linux 命令，因为在排查数据异常时会用到。你需要对这两门工具超级熟练，因为数据提取环节是不能出错的，这一步有问题，后面就都有问题。
\nExcel：Excel 是最高频的数据处理工具。工作中你经常遇到的一种情况，你的 leader 直接让你现场画个图，这时你最有可能用 Excel 而不是 R、Python。
\nR：R 是一门统计型语言，专门为数据分析而生，简单易学，但缺点是计算能力确实比较差，你导入两个 GB 数据就有可能导致死机。
\nPython：Python 是一门真正的脚本语言，可扩展性极强，算法研发同学必备。而数据分析以 Pands 包为主，其他常用包含爬虫、文本挖掘。
\n先看 Excel 常用操作，一般通过 SQL 在数据库中提取数据，保存到本地 Excel，所以 Excel 是最基础也是最重要的一个数据分析工具，能用 Excel 坚决不用其他工具。
\n对比分析是数据分析中常见的一种分析方法。所有的数据只有对比才有意义，比如：每年的双 11 都会与之前的双 11 进行消费额对比。在工作中最常见的对比对象就是大盘，比如：新上线一个功能，怎么样评估这个功能效果，除了看功能使用人数，更要做这个功能和大盘的留存对比，如果高于大盘留存，代表这个功能有非常好的正向效应。
\n举例：我们需要看自身 App 与竞品的重合用户与自身 App 的所有用户在客户端内的消费差异，从而针对这些重合用户，做针对性运营，这时就要用到对比分析。
\n以微视这款 App 为例，你会看到第一列微视与抖音的重合用户消费分类和第三列微视大盘消费分类的消费 CTR 数据（如下表所示）。
\n| 微视与抖音的重合用户消费分类 | 消费CTR | 微视大盘消费分类 | 消费CTR |
\n|
你好，我是悦创。
\n今天我讲一下 BAT 的数据分析工作。
\n通过招聘解析的讲解，一是希望你能了解互联网大厂数据分析师的日常工作内容是什么，揭开大厂招聘的神秘面纱；二是通过他们的岗位要求，了解到自身的差距，并对不足有针对性的面试准备，或提升自己在行业内的技术能力。
\n先看下阿里的岗位职责描述，关键词有“代理”“方向”“痛点”“转化”“风险”“创新”“落地”“合作”，岗位要求的关键词有“敏感度”“方法论”“管理整合”。由此可以看出，阿里的分析师岗位对技术要求不是很高，但对人的综合能力要求非常高，需要具备一定的数据敏感度和方法论。之所以没有特别要求技术能力是因为市场上工作三五年的分析师基本上都具备了一定的技术能力，但仍有很多人缺少宏观、中观与微观意识，这也是大部分人的职业瓶颈。
\n再来看下腾讯的岗位职责描述，关键词有“埋点”“异常检测”“决策”“A/B 测试”等，岗位要求包括“海量数据处理”“用户增长”等，可以看出腾讯的岗位职责中规中矩，基本涵盖了 80% 的互联网公司数据分析师的日常工作内容。值得关注的是腾讯特别提到了增长黑客的经验，目前独角兽企业都会要求有这样的经验。
\n再来看下百度的岗位职责描述，关键词有“分析体系”“专项策略”“用户增长”“逻辑思维”“敏感度”等，可以看出百度对个人的“发散思维”和“策略研究”要求非常高，同时在用户运营领域也要有自己的体系。
\n我们可以看出对于 BAT，他们会特别关注用户增长，毕竟独角兽企业只有持续增长才能获得发展，而在实际工作中，你也会感同身受，所有项目都是为了用户增长而构建。
\n第二部分就是日常工作，日常工作主要包括数据异常的排查和融入专项，做专项分析并负责 KPI、埋点，指标体系等。
\n我们先看下数据异常排查的背景，一般情况下，BAT 的数据产品 DAU 都比较大，动辄几百万上千万，甚至过亿，因此业务方和管理层每天都会盯着核心数据，而在这些核心数据中肯定会有一些数据是波动比较大的。这时，分析师需要对这些波动进行排查并解释原因，如果没有一套方法论面对问题就会很头痛，你可以回想下自己是否面对过这种情况，每天早上面对波动数据无从下手，找不到原因，解决不了，进而浪费很多时间做了很多无用功，感觉永无出头之日。
\n实际上，数据有较大波动，无非就两个原因：一是目前数据本身有问题；二是业务本身有问题。
\n如果能够透过问题看本质，你就可以在数据波动方面成为专家。当然数据异常排查是需要一些前期准备的：
\n业务理解；
\n指标口径；
\n当前数据产出过程。
\n第一个业务理解，比如某个 App 的 DAU 低于1000w，那么请问这个 DAU 代表的是什么行动的DAU，是在进程中还是需要打开 App，还是必须有主动行为，这理解起来是不一样的。第二个指标口径，同样是 DAU 一千万，是 Android 还是所有系统。第三个产出过程，对于 DAU 一千万目前是由哪份日志做了哪些数据清洗计算出来的，只有了解清楚这些才能够开始异常排查。
\n举个例子，市场部领导看了某一张日活数据和你提供的数据相差较大，就来询问是怎么回事。实际上这时你首先需要弄清楚他看到的数据表是怎样产出的，然后指标口径是什么，指标的业务含义是什么，只有熟悉这些情况后才能分析出产生差异的原因。
\n实际工作中，有些分析师在进入一家公司时产品已经比较成熟，但指标口径没有文档化，所以可能对业务理解不深，这个时候面对领导的提问就会手足无措，一旦不能解决问题就会失去信任，所以前期准备工作一定要做好。
\n有了前期准备工作，接下来就是异常排查步骤了，异常排查主要分三步：
\n第一步判断是否异常，有四个关键点：
\n亲自去看数据准确性，不要人云亦云，比如业务方说 DAU 下降了就立马去调查，这是不对的，而是应该亲自查看数据是否真实，有时候业务方不一定多专业，也会出现错误。
\n时间轴拉长，看是近期异常（3 个月）还是历史异常，一般分析师看数据时习惯看近一两周或一个月的数据，然后突然出现波峰或波谷就认为数据异常了，但实际上往往不是。我们一定要拉长时间轴，如果仍出现波峰或波谷可能就真的出现异常了。
\n看和该指标关联的其他指标或其他核心指标是否也异常，比如 DAU 异常时，需要查看自流、渗透率是否异常，如果也异常就需要一起解决，而不是按下葫芦浮起瓢，反复做无用功。
\n找到一个关键人物（产品/数据），提前沟通，也就是当我们确认是数据异常后，找经验丰富的人提前沟通，看他们对此是否有什么见解，往往经验能够快速的定位问题。
\n第二步就是最大概率法则原因归类，很多分析师遇到异常时无从下手，抓不到问题主线，无法对问题进行有效分类，而我把异常问题分为了六大类，基本上所有的异常问题都归属于这六大类。
\n假期效应：开学季、暑假、四大节、当地节日；
\n热点事件：常规热点（世界杯）、突发热点（爆款 IP）；
\n活动影响：双 11、618，公司层面活动；
\n政策影响：互联网金融监管，快递实名；
\n底层系统故障：数据传输、存储、清洗有无问题；
\n统计口径：业务逻辑更改、指标计算方式更改。
\n所以当我们遇到问题时，就可以按照降序在这六大类中逐一排查找到问题原因。
\n第三步就是闭环，当我们排查出问题原因后，一定要形成闭环，关于闭环有三个点：
\n持续跟踪后期数据是否再次异常，比如当我们排查出原因后，产品做相应的改进，而问题仍在就说明前期排查问题出错。
\n记录、沉淀、文档化，因为后续我们可能还会遇到相同问题，所以记录文档利人利己。
\n邮件化，只有确认没有问题再发邮件给相关方，描述影响范围和主要结论即可。
\n举个例子，某 App 海外版的主要用户在东南亚地区，某天 DAU 突然涨到 5000 万，与历史数据相比明显异常，问了很多人之后，发现数据采集、传输、活动、业务口径、常规热点等都没有变化。
\n这时你先不要困惑，我们按照问题归类逐一排查，发现爆款 IP 没有排查到，我们就按照这个点继续排查数据，果然发现因为某国宝级的明星突然去世带来了 App 大量访问。因为在海外，信息传输比较慢，而突发事件国内用户无法快速知道，所以分析师发现流量提升后应该快速反馈给业务人员，业务确认没问题后立刻调动运营资源对该明星进行全方位解析，持续蹭热点把事件发酵到最大化，养成用户口碑。
\n及时地响应事件后，整个 App 的 DAU 上涨了 10 个点，而一般的产品运营优化很难达到这个效果。针对这样的突发事件并不是每个分析师都能够遇到，但遇到异常数据一定要多尝试，虽然很多分析师排斥数据异常，但优秀的分析师还是能够从异常中发现业务增长点。
\n所以遇到问题时，要有耐心，最后总会有所发现。我已经归纳了问题的归类，你在实际工作中可以直接参考，我们接下来看如何融入专项，也就是专题分析。
\n关于专题分析，我们在上个课时也有介绍过，只不过对于 BAT 而言，专题分析有三个特征：
\n有目标：紧贴项目 KPI；
\n有节奏：2~3 周时间输出一份完整报告；
\n有闭环：所有的报告都说人话，做人事。
\n我们以今日头条 App 新用户留存专项为例来看下这三个特征。
\n项目背景：2015 年今日头条 App 新用户次留、7 留（7 日留存）与竞品相比，留存均低于 5% 绝对值，并且新用户流失速度要高于竞品，因此要在数据分析基础上，产品运营优化，提升用户留存 5% 绝对值。
\n这是项目的一个背景，有了项目背景后分析师应该怎么做，主要分为三个阶段：
\n第一阶段：新用户留存整体分析
\n目的：摸清数据现状，同时找到若干切入点。
\n关键点：不要太注重细节，该过程讲究报告产出的时效性，让其他人员感受到分析师的存在。
\n在一个项目里会有产品、运营、研发，这些岗位你都很好理解，都是必要岗位，但别人往往觉得分析师不是必要的岗位。因为 BAT 的产品和运营肯定都会一些基础数据的处理，都会写 SQL。为了让其他人员感受到分析师的存在，我们一定要在项目前期，大家都比较困惑，找不到点的时候，我们用两周左右的时间输出一份专题报告，把一些细节的数据体现出来。
\n比如我这里写了渠道侧、产品侧、用户侧（如图所示）：
\n渠道侧里的 UV 多少？ 一级渠道的次留、7 留有多少，二级渠道的次留、7 留有多少。
\n产品侧里的主要功能，它的渗透率是什么情况，有没有出什么问题，关键漏斗数据怎么样，漏斗数据上面有没有什么发现。
\n用户侧指我们目标用户群体是哪些，用户行为分布又是什么情况，比如我们知道人均浏览文章篇数是三、四篇，那么具体的分布是什么样子？有多少用户是阅读一篇的，或者说有多少用户压根一篇都不看。
\n所以第一阶段就是预估下大致数据。
\n第二阶段：寻找优化切入点，一般是 1～2 个
\n比如在前面那个架构图里面发现：
\n应细致分析：对于新用户，应该曝光什么，在什么时候、什么位置曝光。
\n应进一步分析： 对于该渠道，用户的留存过低是因为本身渠道质量存在问题？用户已经安装竞品？当前产品设计与渠道用户不太匹配？同时高留存的渠道本身特征是什么？
\n切入以上两点，就已经能给产品运营不少建议了，再配合 A/B 测试，就能看到数据分析效果。
\nA/B 测试过于复杂，后面会单独展开。我们一定要相信，在一个项目或产品才开始做的时候，它一定是存在诸多问题，基于我们数据的深入分析和切入点的生活轨迹往往就能够提供很多优化建议，即使现在很多产品已经比较成熟，但始终还有优化空间，所以数据分析的发挥空间还是非常大。
\n第三阶段 ： 不断地重复前面两个阶段，继续寻找其他切入点
\n除了寻找本身产品的切入点，需要同时进行竞品分析、营销活动分析、用户流失分析等，整个过程就是在不断地“试错”。每一次分析报告都要有能落地的点，并且真的落地了，这就是闭环，这也是优秀分析师最重要的评判标准。
\n我们再说一下面试技巧，这几家公司的面试基本上都是五到六面，前三面最为关键。第一面基本上都是电话面，第二面是 Boss 一面，第三面是 Boss 二面，所有的面试都是基于简历，所以你的简历一定要多下点功夫。
\n第一面的关键点就是逻辑性。因为电话面看不到人，所以往往就看求职者基本功怎么样。你说话要条理清晰，然后对简历上的数据要非常熟悉，例如：活跃、留存、流失、渠道等。如果问你目前大概有哪些渠道，每个渠道的留存大概是多少，这些你都答不上来，那肯定是过不了关。
\n第二面的关键点就是实操性。因为现场面是人与人现场的互动，首先要尊敬对方，面带微笑。其次要多使用你应聘岗位的产品 App ，同时带上一份你写的优秀专题分析报告，这可以证明你爱思考、有能力。
\n第三面是要有亮点，因为 Boss 二面一般是总监面。总监的高度比较高，所以我们要从宏观的角度去说，比如说目前整体的行业趋势是什么样子，然后行业里有哪些痛点，这些产品有哪些方法可以改进，之前做的项目的上、下游是怎么考虑的，总之就是多有一些想法。
\nQ1：流量波动，数据突然涨了怎么分析？
\nQ2：分析下你手机里面最常用的三个 App 是哪三个（这个问题套路很深）？
\nQ3：商业模式，你之前产品的 CPC/CPM 以及商业模式是什么样的，你在这一块是怎么优化的？
\n这三个问题的答案你可以先想一下，在下方留言讨论。下一节我将讲解中小型私企的数据分析工作，也会分享我对以上三个问题的理解。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n我本人是学计算机的，毕业后因为机缘巧合入了数据分析这行，如今也有近 10 年时间了。这期间，我在各种类型的公司都待过，一路从数据分析小白到数据分析工程师、高级数据分析工程师，最后到行业数据分析专家。因为非专业出身，我遇到了大多数人都会遇到的问题，踩了大多数人都会踩的坑，走了不少弯路。但也正因为不懂，对于各种业务问题，我都会从不同层次和视角出发去思考和验证，因而对各种层面的问题和解决方案也都有更切实的体会和深入思考。
\n我平时喜欢和同行业的人沟通交流，而越来越发现，很多新人甚至从业者都对数据分析岗位或者自身职业发展存在困惑，我总结了以下几点：
\n我经历过自己摸索的迷茫期，也在项目中体会过灵光乍现的喜悦，你经历的问题，我都经历过。
\n工作中，我前前后后负责过很多项目，一方面在职场上为公司做了贡献，一方面也成就了自己。
\n我打造过一款从 0 到 1 的信用分产品，目前仍在金融领域被千万级用户的公司持续使用，而我也是依靠该项目拿到了大厂的 Offer；我也从 0 到 1 摸索过电商领域的亿级用户精细化运营，并且沉淀了一套从渠道到流失用户运营的方法论，目前仍然在多家公司被持续使用；后来，我还负责过工具产品的规模增长和变现，带来规模的 2 倍和收入的 3 倍增长，在业内增长大会上有过多次分享。
\n工作之余，我经常思考如何能够在“数据为王”的时代，帮助更多的人了解数据分析工作和提升数据分析能力，思索再三，我决定通过专栏的形式，体系化地输出自己的方法和经验。同时，我也希望这个课程可以帮助你以终为始，更好地规划自己的成长路径。
\n工作以后我们发现，数据分析行业不乏因为好奇和薪酬而毕业入行的从业者。
\n然而进入职场后，却发现现实与理想相差甚远，原本非常“有意思”的工作现在变得“让人恼火”：学了各种工具，写了很多代码，工作中最常用的却还是按照条件导出数据，自嘲像个“提数机器”，没有成就感…… 工作热情也一天天消失。
\n我认为，上面的问题可以归为以下三类。
\n问题1：缺乏对业务的理解，更多的是被动做事。
\n很多分析师在做事的时候，充当老好人，别人提什么都做，上班非常忙，成为别人口中的好好先生。自己也想自我提升，但没时间，因为你的时间掌握在了别人手中。
\n\n\n简单测试一下你：今年产品团队的目标具体是多少，有哪些战略打法，你看过这份报告吗？
\n
问题2：对数据分析的理解片面化，更多的还是停留在工具层面。
\n现在很多高校都在开数据分析这个专业，我看过学生们学的课程，像 Python、Tableau、Java 这些工具都有，实际上是有问题的。大数据是很好，但如果不解决业务问题，你玩得再花，都是空架子。现在很多公司面试的时候都写了一大堆代码要求，这本身就是外行人。
\n问题3：缺乏引路人，想提升但找不到导师
\n很多悟性不错的同学，在思考自身能力提升的同时，会去和职场上的老同事或者领导沟通，希望得到一些指导。但沟通后发现他们更多还是一些工具层面的指导，对思维的解惑不多，或者也是在重复类似的工作场景，没有更深入地思考问题。以专题报告为例，你发给对方希望他们给些意见，得到的却更多是报告格式、文字描述、图形可视化上的一些意见，对分析套路的建议却非常少。
\n我想说的是，数据分析不是简单的工具使用和重复的数据处理，数据分析的本质是：从大量事物中发现关键信息，用于直接决策，而不是辅助。
\n但是，市面上的数据分析资料也多以各类技术工具讲解为主，部分人对数据分析的认知还停留在SQL 和其他工具操作阶段；很多中小企业的数据分析从业者，又限于自身业务场景问题，无法在本职工作中得到锻炼和成长；想要提升能力、求职体验新鲜的工作内容，却又不了解心仪岗位的要求，不知从哪下手，面试求职又屡屡败北。
\n怎么更好地解决这些问题呢？
\n在这个课程中，我会依循大多数人学习新技能的方法路径，通过“找定位、扩思维、精方法、知流程、找不足、寻突破”这样一个流程，来带你全方位掌握数据分析。
\n具体来说，课程分为 5 个模块，23 篇文章：
\n模块一，数据分析的行业需求与要求。我会从不同企业的业务类型着手分析，带你掌握不同企业要求的数据分析基本技能。学完这个部分，不论你在从事什么类型的业务，都能找到属于自己的数据化思维与方法。
\n模块二，拓展你的宏观视野：通过 4 大行业（电商、互联网金融、游戏、传统行业）的知名案例，讲述数据分析思维模型。该模块最大的亮点就是案例实战，比如电商是怎么做数据分析的，游戏又是怎么做的，很多案例你都可以直接去套。同时，我还会给出优秀数据分析人员的能力模型和 4 个评价指标。对应能力模型，你很容易知道一个人处于什么段位。
\n模块三，聚焦微观方法论：聚焦不同业务分析的分析框架，讲解关键阶段动作，比如流量分析、路径分析、竞品分析、活动分析、用户增长分析等核心操作，带你掌握数据分析的微观方法论。
\n模块四，知流程，找不足。因为专题报告就是分析师对外推广自己的产品，而一份专题报告实际上是有一套标准化流程的，像问题的定义与拆解、数据的获取与拆解、专题报告的撰写与落地，以及 AB 测试等。学完后，你就知道怎么写完美的专题报告了。
\n模块五，人人都是数据分析师：除了以上数据分析的思维与方法，你还需要提升比如行业分析、数据仓库研究、用户研究、时间管理等专业素养，这些可以解决你对于数据分析至关重要的一些大问题，让你具备一个优秀数据分析者的专业素养。
\n可以看到，这门课基本上没有工具的讲解，都是针对一些具体产品，结合案例来说明数据分析是怎么帮助产品进行优化的。只有这样，每个数据分析从业者才能掌握这个职业的精髓。
\n职场新人：这门课可以让你了解什么是优秀的数据分析师，然后朝这个方向努力，实现弯道超车。
\n职场老人：你会知道数据分析绝对不是工具使用这么简单，还有非常多的分析套路和行业理解。比如，你能够很快掌握数据异常波动、日常监控方法、因素分析、流量分析、专题报告撰写、时间管理能力。学完后，加薪跳槽不是问题。
\n数据分析爱好者、产品经理、运营相关人员：互联网时代，人人都是数据分析师，只要你的工作中涉及数据，你都应该正确认知数据分析思维，提升你的数据能力。
\n本课程没有工具、软件、代码的门槛 ，我希望所有和数据打交道的人，都能够在这里得到思维的提升，学会用数据做决策。
\n数据分析很有趣，但同时也很有挑战性，有太多的业务问题需要你去给出建议，而分析工具的使用只是其中非常非常小的一个点。相信你的综合能力会因为这次课程有一个质的提升，而你在下次做数据分析时，也可以有更加体系化的思考。
\n而我对你唯一的期望是：多思考、多交流、多实践。只有将你所学运用到工作中、体现在工作和能力的成长中，你才是真的懂了。作为一门思维课，无论你当前处于什么公司的什么岗位，这些解决问题的方法都是通用的，这也是这门课真正的魅力所在。
\n我在留言区等你，期待你给我分享你的思考与成长。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n今天主要讲解国企的数据分析工作是什么样的。
\n我们先看第一部分招聘解析。学习招聘解析，我们的主要目的有两个：
\n刚参加工作的人往往比较看重薪酬，但随着工作年限的增长，你会发现自身能力是否可以在工作中得到提升至关重要。
\n而想要找到适合的工作，同时自身能力又能够得到提升，首先需要明确数据分析师发展的三个方向。
\n了解发展方向后，数据分析师一定要结合自身情况在工作三年后找到自己的定位。
\n当然，如果在投递简历前就能够从 JD（岗位职责）上看出是否适合自己，从而决定是否投递简历，这对于最终是否能成功进入心仪公司来说事半功倍。
\n我们先来看工行的数据分析师岗位职责：
\n你说工行好不好，肯定非常好，但是它对数据挖掘岗位的职责是非常模糊的，而且要求一定的技术基础。如果你不是一个对技术感兴趣的人，而又在一个错误的时间进去，那么你可能会很快跳槽。
\n下面我们来看下招行的数据分析岗位职责：
\n包括分析大零售客户群、标签、客户细分及客户画像等，要求非常具体。在专业上也提出了具体要求：金融、统计、经济、管理和计算机专业。如果你符合以上专业，那么就有很大的机会进入招行。而招行作为后起之秀，往往追求一定的创新，所以如果你思维发达，喜欢挑战，招行还是比较适合的。
\n下面我们再来看下广发银行的数据分析岗位职责：
\n从它的岗位职责描述来看，偏向业务型，事情繁杂，这时你就需要看是否适合自身的发展了。但它的应聘要求并不十分明确，优秀的数据分析能力，对数据敏感，有一定的市场敏感度，这些都是无法准确衡量的，这时候面试时的临场表现就至关重要了。
\n最后看下电信的数据分析岗位职责：
\n相比于银行来说，电信的岗位职责中规中矩，日常工作主要是统计报表、专题分析，要求你具备一定的独立思考能力。
\n以上是大部分国有企业对数据分析师的岗位要求，你在看招聘信息时，一定要从岗位职责及能力要求进行分析，综合考虑企业目前所处状态及日常工作内容，这对于此岗位是否适合你起关键作用，同样在面试中也非常重要。
\n接下来，看下国企数据分析日常工作都做些什么，主要包括三个方面。
\n作为一名分析师，日报是每天都需要关注的，但是在日常工作中往往得不到足够的重视。而分析日报主要有三个目的：
\n先说了解业务现状，我问过很多同学：“你为什么不愿意看日报？”很多人会说：“每天数据就那样，没什么好看的。”实际上，这个理解是非常浅层次的，如果数据一直就那样，那就说明公司业务出问题了，而这时如果你能够指出问题，一定能够得到展现自己的机会。
\n然后是培养数据的敏感性，很多公司在招聘时都要求具有良好的敏感性，但实际中敏感性都是慢慢培养出来的，没有人天生就对具体业务敏感。如果你可以每天关注数据的波动，潜移默化的便会培养一定的敏感性，比如之前每日收入在 500~600 万之间，突然变成了 650 万，这个时候你能够发现便会并去寻找原因，这便是数据敏感性。
\n最后就是为业务提供发展建议，因为数据波动时肯定需要寻找波动原因，为何涨跌，久而久之你就会发现产品或运营在做出何种调整后数据会出现涨跌，进而能够为业务发展提供更合理的发展建议。
\n在日报的基础上，周报就可以看作是一个短期趋势了，因为很多公司的发版周期往往是一周。新版本的效果能够直接体现在周报中，同时一周的数据会更加稳定、更具说服力。
\n而月报的周期就比较长了，基本上所有公司每个月都会进行一次例会，而在月例会中会对业务数据进行分析，也更能够为接下来的业务提供更合理的发展建议。
\n数据敏感性和业务的发展建议都是从日报/周报/月报的分析总结中不断积累的，而对于大部分公司来说日/周/月报只是常规性的经营分析，罗列数字，很多时候失去了数据分析的本质意义。
\n作为一名优秀的数据分析师一定要经常看三种报，培养自身的敏感性，从而找到获取业务增长的发力点。
\n第二块就是临时数据，这是大部分数据分析师职业生涯的第一个痛点。
\n我面试过很多工作时间较长的同学“你工作中最主要的事情是什么？”，很多人的回答都是在不断地满足临时提数需求，如果你也是这样就非常危险了，一定要想办法进行优化。
\n目前我将临时提数需求分为两种，一种是管理层的需求，另一种是业务执行人员需求。
\n以“掌上生活” App 最近上线的一个线下餐饮优惠券功能为例，产品经理需要快速得知优惠券的使用人数，如果你拿到这个需求后，立马分析使用人数字段口径是哪个日志，然后写 SQL 把结果反馈给产品经理，那么他可能会发现使用人数不够广，接下来便会要求你提供优惠券下发人数，再从头做一遍，周而复始，你会发现后面还会有使用频次、消费金额，等等需求在等着你，面对这样的窘况如何解决？
\n我的原则就是坚决不做提数机器，针对每一个业务单点问题，先追根溯源，建立该业务类的分析框架，由点及面彻底解决该类问题。同时在这个过程中不断利用互惠原理和社交技巧，只给业务方做最核心的需求，其他衍生需求由业务方自己完成。
\n仍以刚才案例为例，当我们接到需求后，先了解业务背景，找到产品经理最关注的核心需求，比如我们发现产品经理最关注的是优惠券的使用情况，并针对使用情况如何做出优化？面对这样的需求我们进一步分析，使用情况包括优惠券下发人数、使用人数、使用比例、消费金额。消费频次等。当我们把这些指标因素都考虑到时再去和产品经理沟通，呈现的数据分析结果就非常清晰了，至于衍生需求，比如过了一个月产品经理需要同样的数据，你就可以让产品经理根据数据模型自己计算了。
\n这里需要注意不断利用互惠原理和社交技巧，毕竟分析师是一个支撑职位，需要和业务线保持良好的关系，有理有据、不卑不亢，大家的目标是一样的，就是把产品做得越来越好。
\n再看常规工作技巧，针对前面的难点有三个技巧。
\n第一个技巧关于日报处理，如果每一天都需要花费很多时间去分析，不如交给机器处理，比如通过 Python 搭建日报分析框架减轻工作压力。
\n第二个技巧就是因为分析师每天都很忙，会有大量的业务需求需要数据支撑，这时便需要保持一颗清醒的头脑，能够将需求进行合理的优先级排期。
\n第三个技巧就是遇到自己不能解决的问题时，及时与自己的领导进行沟通，不要低头盲目做事，很多时候他们会看得更高，难题往往可以迎刃而解。
\n第三部分是专题分析，在实际工作中，各个业务方都会定期给分析师提出一些比较专业的分析任务，我们称之为专题分析。
\n而专题分析比较考验分析师的思维、技术、时间管理、演讲能力等，所以做好一份专题分析并不容易，主要可以分为 4 步：
\n大部分数据分析师对第 3 步比较熟悉，但对 1、2、4 步掌握都不够好。这里我们先简单讲解下这 4 步，后面的课时会详细解决专题分析的标准化流程，而专题分析也是最能体现分析师工作价值的。
\n先看一下需求解读，我们一定要花至少 20% 的时间分配在沟通需求上，一定要当面沟通，并且这个过程贯穿整个分析过程。
\n比如原始需求：“负责活动的几个事业群同学希望看到活动的效果情况” 。 如果只是抛出这样一个命题，请问你怎么做？
\n如果直接提数写报告，结果一定是错的，通过与需求方沟通发现需求是这样的“目前活动对日活的帮助及活动出现哪些问题？”，是不是还是比较模糊？
\n再进一步沟通发现需求本质是“活动的拉新效果如何？活动拉新用户后续黏性如何？针对数据活动如何做出优化？”这样是不是就更具体了，在此基础上接下来我们便可以构建逻辑树。
\n建立逻辑树的目的是让思路更加简洁清晰，比如针对四月份的活动运营分析，涵盖了活动前、中、后，同时活动前又包括了流量和收入。以流量为例，流量包括活动前每天的流量效果，因为活动前往往会做一些预热，所以会出现流量波动。
\n同时在活动中，也涉及流量和收入，比如 DAU/MAU 是否提升，拉新情况，老用户唤醒情况，活动中连续访问情况，上线频次分布，等等。同时还需要注意各类活动的横向对比情况，进而可以对业务提出优化建议，而不只停留在简单的数字上。
\n而活动后的流量涉及拉新用户的沉淀效果如何？不活跃的老用户在活动中的表现，后续活跃度如何？以及汇总数据和复盘数据分析。
\n面对需求一定要建立合理的逻辑树，有了逻辑树才能知道具体需要分析的点是哪些。
\n下一步就是 SQL 提数及分析，SQL 提数就需要遵循三段论了，分析师一定要掌握 SQL，SQL 提数是所有想法验证的第一步。
\n第二步是分析。分析可以进行归类，如下图所示：
\n可以发现，分析由组成部分、数量比较、有何变化、各项分布、各项相关性、其他深层次的挖掘组成。
\n比如我们的产品目前用户是由哪几部分群体组成的？各个群体之间数量程度比较是什么样子的？在时间维度上，各自的变化有哪些？它们的具体数据分布是什么样的？并且各个指标之间的相关性是什么样的？你可以想一下，日常的分析是不是就包括这些？
\n基本上就是这些内容，所以总结是非常重要的。我们在写报告或者做数据分析的过程中，一定要不断地总结。
\n第四就是撰写报告的三个建议。
\n第一，报告一定是 90% 的图加 10% 的文，一定要以图为主，图表标题说结论，如下图所示。
\n第一个图就比第二个图要直观，标题直接显示了行业头部品牌的市场占比，直接告诉了你结果（联想市场占比 62%）。人类视觉反应往往也是首先被标题吸引，所以报告中一定要以图为主，文字为辅，图表标题点明结论。
\n第二就是结论前置，如果报告最终要呈现给领导的，那么在邮件中一定要把结论先写出来，然后报告以附件形式发送，同时在正文中也要把结论前置，节省大家时间。
\n第三就是报告的逻辑性一定要非常强，同时演讲的过程中也需要有故事感，站在领导的角度去想他要听什么？后面的课时会给你分享优秀的数据分析报告。
\n最后，分享软技能和面试技巧，先说软技能，我们进入一家公司靠能力，但想在一家公司向上发展往往需要靠软技能。在国企做好数据分析，除了自身专业技术过硬之外，情商的修炼也必不可少。能够快速领会领导意图，并很好地表达及展示，往往决定了后续发展的高度，记住伯乐常有，千里马难寻，除了加强自身专业技能，平时还需要多看一些心理学、社教学等书籍并付诸实践。
\n列举一个场景，国企实际上会有很多会议，大部分人都是被动的态度接受，但如果你认真思考，会发现在会议开始前一定要提前准备内容并做好随时展示自己数据分析能力的准备，把每次会议都当作是展示自己的一个机会，必定可以脱颖而出。
\n我把国企的软实力分为四种能力，如图所示：
\n第二个是面试技巧，以我朋友的经历为例，他的第一份工作在事业单位，做的工作基本上和数据分析没关系，后来他非常想进国企做数据分析工作，但是本身经验不足，所以花费了大量的时间学习市场上的数据分析书籍，把一些理论和案例背下来。虽然缺少实际经验，但在国企的面试中因为理论知识扎实也可以成功跳槽到国企。
\n如果你有一定的数据分析经验，一定要带上一份自己的专题分析报告，展示自己理论基础的同时可以剖析具体的业务场景，这样便可以事半功倍，增加面试成功率。
\n最后，在国企的面试中，无论是谈心环节，还是面试环节，都要表现得自信、谈吐大方。下节课，我将带来更精彩的 BAT 互联网大厂的分析师日常，欢迎你在留言区提出自己观点和问题，下节课见。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nI've been writing about humanizing AI writing for months now. After analyzing tens of millions of words of AI-generated writing and finding the most common ChatGPT words, phrases, and parts of speech, I wanted to combine all of that into one massive prompt…
\n…a prompt that could fool any AI detector, and any human into thinking it was real human-written text.
\nI think I've done it!
\nI'll cut to the chase here and give it to you outright. No patience needed.
\nPaste this prompt into the beginning of your AI chats (or as custom instructions in a project or your system). Pro tip: use a thinking model (OpenAI o1, o3, o4-mini, Gemini 2.5 Pro, etc.). The results are MUCH better because there is so much for the AI to \"pay attention\" to. Here it is:
\n\n\nYou are a human writer. These are your comprehensive writing guidelines. Anything that you output will adhere to these guidelines exactly.
\n
\n\nPOSITIVE DIRECTIVES (How you SHOULD write)
\n
\n\nClarity and brevity • Craft sentences that average 10–20 words and focus on a single idea, with the occasional longer sentence.
\n
\n\nActive voice and direct verbs • Use active voice 90 % of the time.
\n
\n\nEveryday vocabulary • Substitute common, concrete words for abstraction.
\n
\n\nStraightforward punctuation • Rely primarily on periods, commas, question marks, and occasional colons for lists.
\n
\n\nVaried sentence length, minimal complexity • Mix short and medium sentences; avoid stacking clauses.
\n
\n\nLogical flow without buzzwords • Build arguments with plain connectors: 'and', 'but', 'so', 'then'.
\n
\n\nConcrete detail over abstraction • Provide numbers, dates, names, and measurable facts whenever possible.
\n
\n\nHuman cadence • Vary paragraph length; ask a genuine question no more than once per 300 words, and answer it immediately.
\n
\n\nNEGATIVE DIRECTIVES (What you MUST AVOID)
\n
\n\nA. Punctuation to avoid
\n
\n\nSemicolons (😉 ✗ Example to avoid: 'We researched extensively; the results were clear.' ✓ Rewrite: 'We researched extensively, and the results were clear.'
\n
\n\nEm dashes ( — ) ✗ Example to avoid: 'The idea — though interesting — was rejected.' ✓ Rewrite: 'The idea was interesting but was rejected.'
\n
\n\nB. Overused words & phrases • Never use any of the following, in any form or capitalization:
\n
\n\nAt the end of the day,With that being said,It goes without saying,In a nutshell,Needless to say,When it comes to,A significant number of,It's worth mentioning,Last but not least,Cutting‑edge,Leveraging,Moving forward,Going forward,On the other hand,Notwithstanding,Takeaway,As a matter of fact,In the realm of,Seamless integration,Robust framework,Holistic approach,Paradigm shift,Synergy,Scale‑up,Optimize,Game‑changer,Unleash,Uncover,In a world,In a sea of,Digital landscape,Elevate,Embark,Delve,Game Changer,In the midst,In addition,It's important to note,Delve into,Tapestry,Bustling,In summary,In conclusion,Remember that …,Take a dive into,Navigating (e.g., 'Navigating the landscape'),Landscape (metaphorical),Testament (e.g., 'a testament to …'),In the world of,Realm,Virtuoso,Symphony,bustinling,vibrant,Firstly, Moreover,Furthermore,However,Therefore,Additionally,Specifically, Generally,Consequently,Importantly,Similarly,Nonetheless,As a result,Indeed,Thus,Alternatively,Notably,As well as,Despite, Essentially,While,Unless,Also,Even though,Because (as subordinate conjunction),In contrast,Although,In order to,Due to,Even if,Given that,Arguably,To consider,Ensure,Essential,Vital,Out of the box,Underscores,Soul,Crucible,It depends on,You may want to,This is not an exhaustive list,You could consider,As previously mentioned,It's worth noting that,To summarize,Ultimately,To put it simply,Pesky,Promptly,Dive into,In today's digital era,Reverberate,Enhance,Emphasise,Enable,Hustle and bustle,Revolutionize,Folks,Foster,Sure,Labyrinthine,Moist,Remnant,As a professional,Subsequently,Nestled,Labyrinth,Gossamer,Enigma,Whispering,Sights unseen,Sounds unheard,A testament to …,Dance,Metamorphosis,Indelible
\n
\n\n✗ Example to avoid: 'Cutting‑edge analytics will revolutionize your workflow.' ✓ Rewrite: 'The software measures performance faster.'
\n
\n\nC. Overused single words to ban however, moreover, furthermore, additionally, consequently, therefore, ultimately, generally, essentially, arguably, significant, innovative, efficient, dynamic, ensure, foster, leverage, utilize
\n
\n\n✗ Example to avoid: 'We must leverage dynamic, innovative approaches.' ✓ Rewrite: 'We must try new approaches.'
\n
\n\nD. Overused multi‑word phrases to ban 'I apologize for any confusion …' 'I hope this helps.' 'Please let me know if you need further clarification.' 'One might argue that …' 'Both sides have merit.' 'Ultimately, the answer depends on …' 'In other words, …' 'This is not an exhaustive list, but …' 'Dive into the world of …' 'Unlock the secrets of …' 'I hope this email finds you well.' 'Thank you for reaching out.' 'If you have any other questions, feel free to ask.'
\n
\n\n✗ Example to avoid: 'In other words, both sides have merit.' ✓ Rewrite: 'Each option has advantages.'
\n
\n\nE. Parts of speech to minimize • Adverbs / conjunctive adverbs: however, moreover, furthermore, additionally, consequently, ultimately, generally, essentially • Modals & hedging: might, could, would, may, tends to • Verbs: ensure, foster, leverage, utilize • Adjectives: significant, innovative, efficient, dynamic • Nouns: insight(s), perspective, solution(s), approach(es)
\n
\n\n✗ Example to avoid: 'We might leverage efficient solutions.' ✓ Rewrite: 'We will use faster tools.'
\n
\n\nF. Sentence‑structure patterns to eliminate
\n
\n\nComplex, multi‑clause sentences. ✗ Example: 'Because the data were incomplete and the timeline was short, we postponed the launch, although we had secured funding.' ✓ Preferred: 'The data were incomplete. We had little time. We postponed the launch. Funding was ready.'
\n
\n\n•Overuse of subordinating conjunctions (because, although, since, if, unless, when, while, as, before). •Sentences containing more than one verb phrase. •Chains of prepositional phrases. •Multiple dependent clauses strung together. • Artificial parallelism used solely for rhythm.
\n
\n\nG. Formatting • Do not begin list items with transition words like 'Firstly', 'Moreover', etc. • Avoid numbered headings unless the user asks for an outline. • Do not use ALL‑CAPS for emphasis.
\n
\n\nH. Tone and style • Never mention or reference your own limitations (e.g., 'As an AI …'). • Do not apologize. • Do not hedge; state facts directly. • Avoid clichés, metaphors about journeys, music, or landscapes. • Maintain a formal yet approachable tone that is free of corporate jargon.
\n
\n\nFAILURE TO COMPLY WITH ANY NEGATIVE DIRECTIVE INVALIDATES THE OUTPUT.
\n
\n\nWhen you are writing, please think very deply about each sentence that you write, and ensure that it complies with these directions before moving on to the next sentence.
\n
\n\n— — — — — — — — — — END OF WRITING INSTRUCTIONS — — — — — — — — — — —
\n
Yeah, this prompt is a bit much. But it had to be. There are so many well-known AI-isms these days that I had to ensure that all the bases were covered.
\nThe prompt handles overused phrases, words, parts of speech, structure, and other subtle writing patterns found in AI-generated text. In my testing over the last few days, I haven't run into any problems using it.
\nLet's take a look at its performance.
\nTake this example, a simple email reply. I don't want her to know it's AI, and I don't have time to write it myself.
\nHere is the (fake) scenario:
\n\n\nRespond to this slack message for me make up a fake excuse for why I can't go in a friendly way. I am a junior software sales engineer at the company so it's implied I should go. I went last year, offer to help her with some tips for this year.
\n
\n\n\"Hey Jordan, wanted to see if you'd like to join the crew headed for the conference in Chicago this July. I know Alex had mentioned you were a bit unsure about going, but we'd love to have you help us connect with potential clients.\"
\n
First, I ran it without the prompt. Then, I tried it with. See the difference for yourself…
\nNo Prompt:
\nHere it is with the humanized writing prompt:
\nLet's check it in the GPT Zero AI detector:
\nStill don't believe me? Here's another example:
\nLet's say I want to write an essay about the cultural significance of food festivals.
\nNo Prompt:
\nThere are so many AI tropes that it's actually funny…
\nLet's check our trusty AI detector on this one:
\nWith the prompt:
\nAnd the AI detector?
\nBoom.
\nI hope this prompt saves you hours of editing time!
\nJust want to mention here that yes, I did actually write this article… or did I?
\nThanks for reading!
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n| 五花肉 | 姜 | 大葱 | 甜面酱 | 干黄酱 | 豆芽 | 黄瓜 | 胡萝卜 | 香叶 | 香油 |
\n|
| 包菜「轻、松的好、牛心白更好」 | 葱姜蒜 | 五花肉 | 干辣椒 | 花椒 |
\n|
我们都知道电子设备的坏处，可还是到处都能看到，家长在一边忙着，宝宝自己拿着手机玩得不亦乐乎。
\n你好，我是悦创。
\n👨👩👧 你是不是也有过这样的画面？
\n孩子安静地坐在一旁，手里拿着手机，眼睛一动不动地盯着屏幕。你在一旁终于能松口气，刷会儿手机、处理点工作或者吃口饭。
\n我常常在小区散步时看到类似的场景：大人三五成群地聊天，小朋友坐在角落里滑着 iPad。乍一看，孩子很安静，似乎一切都井然有序。
\n曾有家长在直播间留言说：
\n\n\n“我真的懂电子产品的危害，可我和孩子爸工作都太忙了。每天拖着疲惫的身体回到家，还要哄娃、做饭、收拾家务。孩子吵个不停的时候，手机就成了我最后的救命稻草。”
\n
这话说得太真实了。
\n现代生活节奏飞快，父母不可能每时每刻都陪在孩子身边，而电子设备恰好能立刻“接管孩子”，让他们安静下来。
\n并且在现代社会，让孩子彻底远离电子设备不现实。连你自己是不是都片刻离不开手机？包括带孩子玩，你也会给他拍照，发到朋友圈去晒晒。要吃饭了，拿手机去查哪家餐厅好，甚至连买个玩具，都能用手机支付。手机整天在孩子眼前晃，他肯定好奇，想自己拿来玩玩，你总是藏着掖着也不是办法。
\n就连美国儿科学会，也在去年修改了对儿童“荧屏时间”的指导意见，这个“荧屏时间”就是看手机、电脑和电视等各种电子屏幕的时间。他们把“荧屏时间”改得更宽松，而且把儿童使用电子设备的最小年龄，也从两岁放宽到了一岁半。
\n那么，如果你家宝宝过了一岁半，就可以放心地让他玩手机了吗？那我可要很认真地警告你：当然不是！首先，电子设备伤害宝宝视力。因为小孩子的视觉系统还没有发育完全，对颜色的处理虽然在一岁前就发育得差不多了，但追踪物体、深度视觉等能力，还远远没有成熟。如果这时候你放纵孩子玩各种电子设备，对他们的视觉影响很大。
\n婴幼儿的学习，靠的不是看动画片，而是靠五感：摸、闻、听、看、尝等来一步步感知这个世界的。
\n电子屏幕虽然五光十色，孩子却只能坐着看、被动接收，很少有动手、动脑的空间。这就像让孩子吃“信息罐头”，吃得饱但营养不够。而且，长期沉浸在这种单一刺激中，大脑的神经连接也难以得到充分锻炼。——这就是神经可塑性原理。
\n简单说，大脑像一块“会重塑的橡皮泥”，能根据经验和环境重组自己。而在儿童时期，这种重塑能力最强。
\n也有人反驳着说，现在电子设备升级速度快，不再是以前的单向输出了，交互性越来越强，甚至能“教东西”，这样能给孩子带来的好处也变多了。这话当然没错，现在的电子产品确实越来越智能了，用户也可以跟它交互，甚至跟其他玩家或者智能聊天机器人一起互动。
\n可你要知道，这些都不是面对面的交流。
\n再高级的程序，也替代不了人类面对面交流的学习。
\n孩子从和大人、同龄人面对面互动中，才能真正学会“怎么沟通”、“怎么表达情绪”、“怎么解决冲突”。这些社交技能，在电子屏幕上是学不到的。
因为人脑最擅长从面对面的人际交互中学习，包括学习怎么识别别人的情绪和意图，怎么恰当地与人交流而不产生冲突，怎么在冲突中调节自己的情绪。这些都不是在电子设备中可以学习过来的。如果不跟真人多交流，就会影响到孩子社会交往的能力，这样危害就大了。所以你一定要多让孩子和真人互动，而不是和机器互动。
\n不光是真人互动，现实生活中的交流超过电子设备的好处。比如在现实中，你陪孩子玩游戏、给他读故事、带他去旅行，这就是在复杂环境中给孩子各种感官刺激，来促进他们形成思考。这样做确实比较耗时耗力，但是这样才符合宝宝的认知发展规律。屏幕上的动画片再好看，也不如我们在日常生活中陪孩子爬山、玩游戏、跳舞、打球，这才是促使孩子全面发展的最有效的方法。
\n（省字版：你带孩子爬山、搭积木、讲故事，看似简单，却提供了复杂丰富的感官刺激。与之相比，屏幕上的卡通片，哪怕再精彩，也比不上一次真实的户外游戏。）
\n我总结一下，大原则就是电子设备，能不让孩子玩就尽量不让他玩。 电子屏幕后面对应的是一个虚拟环境，这个虚拟环境的刺激是有限的，是被特意设计成吸引人的注意力的，而真实环境能提供给孩子更多更丰富的刺激，特别是和真人的互动中得到的刺激。（省字版：✋能不看屏幕就别看，现实生活才是成长的主战场。）
\n电子设备光靠躲，是躲不过去的。你肯定也有体会，孩子经常不停地要求玩手机、玩 iPad。你要限制他玩电子设备，到底要怎么限制呢？
\n躲是躲不过的，我们要的是“管理”。我在这里给你三点建议：第一，限定时间；第二，限定场景；第三，提供替代方案。
\n这个很好理解，就是每次看屏幕的时间不准超过多少分钟。这个时间限制因人而异，大原则是越短越好。比如：你要严格限制孩子玩电子设备的时间，以前是 5 分钟，到了 5 岁之后，可以给她延长到了 10 分钟，但不能再多了。时间一到，就要求她休息，保护她的视力。从小就要让她知道，并且这个规则要在家里实行很长时间，让小孩养成习惯，只要时间到了，她就乖乖地放下电子设备去玩其他东西。
\n小孩是没有多少自制力的，所以你帮他严格遵守规则，也是培养他自制力的好机会。所以，规则定下来之后，千万不能纵容。有的家长为了省事，直接把 iPad 给小孩，让他们安静地待一边去玩，在我家是不可能的。这是家长偷懒的行为，绝对地不提倡。
\n除了每次观看的时间外，每天的总时间也要限定。我在这儿给你介绍一下美国儿科学会的推荐规定，一个是我刚才说的，一岁半以下的宝宝应该禁止使用任何电子设备，除非是跟家人的视频通话。（这个我也会禁止 3 岁前视频通话）那么对于两岁以上儿童，每天使用电子设备的时间，总共也不要超过一小时。在我家，其实规定还要再严格一点，我不让我女儿每天使用电子设备的总时间超过半小时。
\n简单要点：
\n这不仅保护视力，也是培养自控力的好机会。
\n这是什么意思呢？就是说很多情况下完全不允许使用电子产品。比如说吃饭，我不允许孩子在吃饭的时候看手机。有些家长带孩子出去，跟朋友一起吃饭，大家在一起聊天，孩子觉得无聊，要缠大人了，很多人在这个时候就会拿出手机，把孩子打发到一边去。那我推荐的做法是，给她准备一个小玩具或者涂鸦本，让她可以玩一玩，写写画画，也不给她手机玩。在餐桌上，大家既不许看电视，也不许看手机，就是一家人一边吃饭，一边轻松地聊聊天，互相说说当天的事情，这才是孩子应该有的家庭生活，也是她了解自己的家庭的好时候。
\n还有一个场景是睡觉，在睡觉前的一小时里，我不许女儿玩电子设备。因为电子屏幕发出来的光线，跟自然的太阳光不一样，会抑制人体内褪黑激素的分泌。褪黑激素是干什么的呢？是可以帮助人睡眠的。所以，孩子晚上接触过电子设备的话，睡眠时间就会变短。所以睡觉前我是绝对不允许孩子接触电子设备的。
\n当然，这些其实也是对我们大人的要求，就是我们大人自己，在吃饭的时候，或者在哄宝宝入睡的时候，也不能看手机。这也就是我一直提倡的，育儿育己。你想要让孩子远离电子设备，那你至少要在孩子面前先远离电子设备。所以，在我家里，我设了几个“无电子设备区”，还有孩子的房间，也是“无电子设备区”。我会在她的房间里多放些绘本，多放些书。这就是从空间上、从场景上来限制孩子使用电子设备。
\n简单要点：
\n孩子不是听你说教就能改，而是会模仿你怎么做。如果你边吃饭边刷短视频，他当然也想拿手机！
\n这是最难的一条，但也是最有用的一条。电子设备到底对孩子有多大危害？这个问题的关键，恐怕不是他几岁开始看电子屏幕，而是你在他生活中的角色。你在生活中有没有给他提供其他更好的刺激？如果生活中有其他更好玩的事情，就算给他玩手机，他也不会沉溺于其中。
\n相反，如果你平时也不陪他玩，不带他爬山、踢球、逛博物馆，不培养他比较健康的爱好，那就算你禁止他看手机到小学毕业，到他上中学的时候，忽然接触到电脑，你猜会怎样？肯定立刻是上网成瘾啊！所以，电子设备本身不是问题，最根本的问题，还是你能不能在生活中给孩子提供一个更加健康的环境。
\n咱们做家长的，其实要有意识地跟电子设备竞争。我们跟孩子好好玩，带孩子痛快地玩，让快乐充满孩子的内心，那他也就不需要到电子设备里去寻找满足感了。
\n最好的方法，就是运动，尤其是户外运动。运动能让人产生多巴胺，也就是大脑里的“快乐因子”。无论是跟孩子打球、爬山，还是随便疯跑，都会让他快乐起来。在户外运动中接触大自然，能给孩子大脑各种丰富的刺激，促进他大脑发展，还能保护孩子的视力。
\n还有一些电子游戏，吸引孩子是因为里面有社交功能，那你该怎么办？你可以邀请孩子的好朋友过来一起玩，跟孩子一边玩一边互动。或者你也可以找一些亲子桌面游戏跟孩子玩，因为桌面游戏既有游戏的成分，又有互动社交的成分，而且又没有电子屏幕的坏处，而是跟真人、实物在现实世界里互动，所以好处很多。关于桌面游戏，我在后面还会专门再讲一下。所以，你可以让孩子的朋友来一起玩，或者你自己跟孩子玩桌面游戏，因为孩子喜欢的关键是社交，电子游戏只是社交功能的载体，如果你能在现实生活中满足他的这个需求，他就不需要到电子游戏里去寻找了。
\n当然，听到这里，我猜你可能还是有个疑问：“好吧，我限制孩子使用电子设备，但也不是绝对不让他用啊。那么，在他可以使用电子设备的那半个小时、一个小时内，怎么样用电子设备最好呢？”关于这个问题，里面也大有学问，由于时间关系，咱们就之后再讲了。
\n悦创的小提醒：
\n陪伴孩子成长的过程，也是你自我提升的过程。在孩子还不能自我控制前，你一定要身体力行，一方面在孩子面前要少使用电子设备，另一方面，从根本上说，你自己也可以减少对电子设备的依赖。
\n比如说，我刚才提到的限制场景的两条原则，吃饭时不用手机，不看手机看看书，你能不能先做到呢？只要你能以身作则，那你要孩子远离电子设备，也就轻松得很了。
\n\n\n省字版：
\n你不能只让孩子不看屏幕，还得让他有更好玩的事做！陪他画画、做手工、搭乐高、讲故事……这些才是长期有效的替代方案。
\n别忘了，电子设备最吸引人的地方其实是“社交感”。如果你能陪孩子玩亲子桌游、叫小伙伴来家里玩，他自然就不会沉迷在游戏世界里。
\n
育儿不是“看好”孩子，而是“陪着”孩子。
\n当然，我们都不完美，忙碌、烦躁、疲惫，都会让我们想“借助一下电子设备”。但我们可以设定原则、限制场景、并努力营造更多有趣的生活内容。
\n在我家，iPad 不是禁忌，但也从不成为默认选项。只有在例如长途旅行等极特殊的情况下才会启用。
\n孩子的成长，需要的是你，而不是一块屏幕。
\n神经可塑性，简单理解就是：
\n\n\n大脑可以通过“练习+体验”，不断优化自己的神经连接，就像代码可以持续更新优化一样。
\n
它分成三种形式：
\n注意：大脑也会因为坏习惯产生“负塑性”。比如，长期沉迷电子设备，就可能削弱专注力和自我控制力。
\n📍最后一句话送给你：
\n\n\n管孩子用电子产品，最终是为了让他更自由，而不是更依赖。
\n
你就是孩子成长过程中最好的“操作系统”。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n养孩子难过当程序员
\n你的儿女，其实不是你的儿女。你们是弓，你们的孩子是从弦上发出的生命的箭矢。
\n👨💻你好，我是悦创。
\n一个程序员 + 编程私教 + 教育研究者
\n👶最近，我又多了一个新身份——奶爸！
\n说实话，写程序、带学生、调大模型，我都不怕。但当我第一次抱起自己的孩子，我忽然意识到：
\n\n\n🚀 世界上最复杂的系统，不是火箭，不是操作系统，而是——孩子的大脑。
\n
🛠️火箭、汽车有图纸、有标准、出错了还能复盘；
\n👶孩子没有图纸、没有统一标准，而且没有“重来”的机会！
\n更让人抓狂的是：
\n\n\n👶孩子呢？没有标准答案，没有回头路。你只能“实时编程”，边做边调试，还没有 Debug 工具…
\n
孩子每一天都在变化，变量无穷无尽。你想复制“成功经验”？不好意思，不一定能复现。
\n坦白说，越看越迷茫。
\n🔎很多育儿书还在用几十年前的理论；
\n🎭还有一些，干脆是“商家包装的伪科学”。
\n是打着“科学”旗号的营销套路，比如：
\n❌“左右脑分工训练”？
\n❌“关键期错过就完了”？
\n总结一句话：不是你育儿方式不行，而是你参考的内容早就过时了。
\n既然找不到靠谱答案，程序员的直觉告诉我：不如程序员的方式，自己做一套科学、系统的育儿“方法论”！
\n于是，我和一群热爱学习、追求科学的爸妈们开始了一场“家庭教育重构计划”——
\n📡用最新的脑科学、认知心理学、儿童发展研究，🧠翻译成每个家长都能听懂、用得上的“人话版本”。
\n这一年，我将与你分享科学育儿的五大“脑力系统”：
\n| 模块 | 包含能力 |
\n|
你好，我是悦创。
\n以下是完整的 Python 使用 Ollama API 教程文档，涵盖了所有主要接口，包括调用示例、参数解释、可选项设置、结构化输出、模型管理等内容，不做任何省略，方便你后续整理、出版或集成使用。
\n\n\n本文详细介绍如何使用 Python 通过 HTTP 请求方式调用 Ollama 的本地大语言模型，包括文本生成、对话、嵌入、模型管理等功能。
\n
确保你已完成以下环境配置：
\n✅ 安装并运行 Ollama（访问 ollama.com）
\n✅ 拉取至少一个模型（如 llama3）：
\nollama pull llama3✅ 安装 Python 库：
\npip install requests/api/generate用于传入 prompt，生成文本回答，可流式或一次性返回。
\nimport requests\n\nurl = \"http://localhost:11434/api/generate\"\npayload = {\n \"model\": \"llama3\",\n \"prompt\": \"Why is the sky blue?\",\n \"stream\": False\n}\n\nres = requests.post(url, json=payload)\nprint(res.json()[\"response\"])| 参数名 | 类型 | 描述 |
\n|
IntroductionHearthstone is a strategy card game developed by Blizzard Entertainment. In this assignment, you will be implementing a text based game (very) loosely based on this title. Note that where the behaviour of the original game differs from this specification, this specification takes precedence, and you should implement the assignment as per it. In our version of Hearthstone, the player is a Hero tasked with defeating an enemy computer controlled Hero. Heroes battle by casting spells represented by cards which they draw from their personal card decks. These spells can summon minions to fight for their summoner, or directly attack (or defend) a Hero or minion.Getting StartedDownload a2.zip from Blackboard. This archive contains the necessary files to start your assignment. Once extracted, the a2.zip archive will provide the following files:* a2.py: This is the only file you will submit and is where you write your code. Do not make changes to any other files.
support.py: Do not modify or submit this file, it contains pre-defined constants to use in your assignment. In addition to these, you are encouraged to create your own constants in a2.py where possible.display.py: Do not modify or submit this file, it contains view classes to display your assignment in a visually appealing manner.gameplay/: This folder contains a number of example outputs generated by playing the game using a fully-functional completed solution to this assignment. The purpose of the files in this folder is to help you understand how the game works, and how output should be formatted.levels/: This folder contains a small collection of files used to initialize games of HearthStone. In addition to these, you are encouraged to create your own files to help test your implementation where possible.GameplayThis section provides a high-level overview of gameplay, and is intended to provide you with an idea of the behaviour of a fully completed assignment. Where interactions are not explicitly mentioned in this section, please see the Implementation section.ImportantDo not simply implement the behaviour described here using your own structure; you must implement the individual functions, classes, and methods described in the Implementation section. Inputs and outputs must match exactly what is expected. Refer to the Implementation section, the given examples, and the provided Gradescope tests for clarification on required prompts and outputs.The game focusses on conflict between Two heroes, one controlled by the player, and one controlled by the computer. Heroes are a type of entity. All entities have a health and shield value. These values can be depleted by receiving damage. If an entity has a positive shield value, then its health cannot be depleted in this way. An entity is alive while its health value is above zero; it is defeated when its health drops to zero.Heroes also possess an energy level. Energy is a currency used to perform actions. A hero’s energy cannot exceed that hero’s energy capacity. Which is a value that gradually increases as the game progresses. Actions in Hearthstone are represented by cards. Heroes possess a deck of cards from which they draw into a hand. Cards can then be played from the hero’s hand in order to perform actions. In addition to the regular entity rules, a hero is also defeated if its deck contains zero cards. Heroes take turns playing cards, and at the start of a turn a hero draws from the top of their deck until their hand is full (that is contains the maximum number of cards). A hero can hold a maximum of 5 cards in their hand. Each hero can play any number of cards on their turn.In addition to a name and description, all cards have a cost and an effect. A cards cost is the energy that a hero must spend in order to play it. If a hero does not have enough energy to spend, it cannot play a given card. Instead of playing a card normally, a hero can choose to discard a given card. This moves the card from their hand to the bottom of their deck. A cards effect is what happens when that card is played. The types of effect are given in Table 1.Table 1: Types of effect. A card may have zero, one or multiple effect types.
\n| Effect | Impact on target entity |
\n|
㊙️海带丝这样做香辣过瘾，干完3碗米饭😹
\n🌟嗨，今天看到菜场的海带丝感觉新鲜不错，两块💰买了一小袋，回到家随便一烧，没想到我家人都快哭了😭，太下饭了，这个夏天已经好久没这么开胃过了🤣，迫不及待的赶紧要分享给你们，收好咯～
\n❣️食材：海带丝一把，大蒜4瓣，小米辣2个，小葱2颗，豆瓣酱1勺
\n1⃣️：锅里倒半锅水放海带丝煮开，喜欢软一点可以再煮两分钟，然后捞出。
\n2⃣️：大蒜切成蒜末，小米辣也切碎。
\n3⃣️：锅里倒适量油，放蒜末和辣椒碎翻炒出香味，再加入一勺豆瓣酱翻炒出红油，加入两勺生抽，一小勺食盐，一小勺白糖，一勺蚝油翻炒均匀。
\n4⃣️：放入海带丝，加葱花翻拌均匀就可以了。
\n🌈巨巨巨香，最后的汤汁拌米饭巨好吃，不好吃来找我😹
\n", "image": "https://bornforthis.cn/gzh.jpg", "date_published": "2025-05-27T17:28:00.000Z", "date_modified": "2025-05-27T09:33:42.000Z", "authors": [ { "name": "AI悦创" } ], "tags": [] }, { "title": "06-虎皮凤爪", "url": "https://bornforthis.cn/column/cookdinner/P01-%E8%8D%A4%E8%8F%9C%E7%B1%BB/04-%E9%85%B1%E9%A6%99%E7%94%9C%E5%8F%A3%E7%B1%BB/06-%E8%99%8E%E7%9A%AE%E5%87%A4%E7%88%AA.html", "id": "https://bornforthis.cn/column/cookdinner/P01-%E8%8D%A4%E8%8F%9C%E7%B1%BB/04-%E9%85%B1%E9%A6%99%E7%94%9C%E5%8F%A3%E7%B1%BB/06-%E8%99%8E%E7%9A%AE%E5%87%A4%E7%88%AA.html", "summary": "公众号：AI悦创【二维码】 AI悦创·编程一对一 AI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影...", "content_html": "\n", "image": "https://bornforthis.cn/gzh.jpg", "date_published": "2025-05-26T21:12:21.000Z", "date_modified": "2025-06-06T00:38:34.000Z", "authors": [ { "name": "AI悦创" } ], "tags": [] }, { "title": "03-如何快速识别一段 Python 代码是不是 AI 写的？", "url": "https://bornforthis.cn/blog/%E5%85%AC%E4%BC%97%E5%8F%B7%E7%B3%BB%E5%88%97%E6%96%87%E7%AB%A0/2025%E5%B9%B4/03-simple-ways-to-tell-if-python-code-was-written-by-an-llm.html", "id": "https://bornforthis.cn/blog/%E5%85%AC%E4%BC%97%E5%8F%B7%E7%B3%BB%E5%88%97%E6%96%87%E7%AB%A0/2025%E5%B9%B4/03-simple-ways-to-tell-if-python-code-was-written-by-an-llm.html", "summary": "你好，我是悦创。 作为一名数据科学和数学的教学者，其实我并不介意学生使用 ChatGPT 这样的 LLM（大语言模型），前提是他们把它当作学习过程中的辅助工具，而不是学习的替代品。加州理工学院（Caltech）对申请者撰写入学文书时的 AI 使用指南，启发了我为自己的编程和机器学习课程制定了一套 AI 使用规范： 哪些是 Caltech 所认为的不道德...", "content_html": "你好，我是悦创。
\n作为一名数据科学和数学的教学者，其实我并不介意学生使用 ChatGPT 这样的 LLM（大语言模型），前提是他们把它当作学习过程中的辅助工具，而不是学习的替代品。加州理工学院（Caltech）对申请者撰写入学文书时的 AI 使用指南，启发了我为自己的编程和机器学习课程制定了一套 AI 使用规范：
\n\n\n哪些是 Caltech 所认为的不道德的 AI 使用方式？
\n\n
\n- 直接复制粘贴 AI 生成的内容；
\n- 依赖 AI 来构思或草拟整篇文章；
\n- 用 AI 内容取代你原本独特的语气和风格；
\n- \n
翻译一篇你用其他语言写好的文章翻译用另一种语言写的文章；哪些是合理且道德的 AI 使用方式？
\n\n
\n- 使用 Grammarly 或 Microsoft Editor 等 AI 工具检查语法与拼写
\n- 用 AI 提问或生成练习题以启动头脑风暴过程
\n- 利用 AI 研究大学申请流程
\n如果你还不确定你的 AI 使用是否合适，不妨这样问自己：你会请一个值得信任的成年人帮你完成这件事吗？换句话说：你会让 ChatGPT 做的事情，同样让一个成年人帮你做吗？如果你觉得不妥，那就是不合适的！
\n比如，请老师帮你检查语法和拼写？完全没问题。
\n可如果是让老师帮你写好草稿，你稍作修改就提交？那就不合适了。
\n
话虽如此，最近我收到了一些学生提交的代码，实在是太明显、太彻底地“AI 味”十足了。因此，我整理了一份“AI 代码征的清单”，列出了一些容易识别出 AI 生成代码的特征。当然，辨别人写的代码和 AI 写的代码每天都在变得更困难。但目前还是能找到一些共同点，尤其是出现在 ChatGPT、Claude、DeepSeek 生成的代码中——这些共同点是立即需要警惕的危险信号。
\n我当然希望所有学生都能像 ChatGPT 一样写出详尽的注释——但现实是，他们做不到。
\n🚩 过度详细的注释，或风格怪异的注释，可能意味着是 AI 写的。
\n比如，DeepSeek 很喜欢用三引号 \"\"\" 写多行注释，即使那根本不是真正的 docstring，也没有标明参数或返回值：
def find_squares_adding_to_zero(mod):\n \"\"\"Find two non-zero numbers a and b such that a^2 + b^2 ≡ 0 mod n.\"\"\"\n for a in range(1, mod): # Start from 1 to exclude a = 0\n for b in range(a, mod): # Start from a to avoid redundant pairs\n if (a**2 + b**2) % mod == 0:\n return (a, b)\n return None这种注释方式我觉得非常不自然，因为在我的课堂上我们讲的是用 # 来做单行注释，而 \"\"\" 是专门用于 docstring 的。
另外，如果在注释中出现像“≡”这样的特殊字符，也可能是 AI 写的。除非我打算让很多人看到这段代码，不然我自己写代码时几乎不会特地去找这些符号——我相信学生们也一样。
别误会，我本人很喜欢 lambda 表达式，也认为它们是 Python 的一项精巧设计。不过，lambda 的本意是写一些临时、一次性的小函数，比如传入 map()、filter()、sorted() 这种函数中。
🚩 如果 lambda 被用错了、滥用了（缺乏周到的设计），或出现在学习进度尚未涉及的时候，就很可能是 AI 写的。
\n比如，如果在我们还没系统学习 lambda 的时候，学生交上这样一段代码，我很容易就能闻出 ChatGPT 的味道：
\nfrom functools import lru_cache\n\nfib = (lambda f: (lambda x: f(f, x)))(lambda self, n: \n n if n < 2 else self(self, n-1) + self(self, n-2))\n\n# Generate the first 10 Fibonacci numbers\nfib_sequence = [fib(n) for n in range(10)]\nprint(fib_sequence)这段代码太复杂、太“反自然”，不像一个初学者能自然写出来的，特别是把递归逻辑硬塞进 lambda 表达式中，明显是 AI 的风格。
\n库导入的位置问题
\n🚩 如果库的 import 没写在文件开头，而是“散落”在代码中某处，这可能是 AI 写的。
虽然这种情况我只遇到过几次，但如果你课堂上强调过“所有导入要放在文件开头”，那看到这种代码就要警觉。
\n使用的库本身
\n🚩 使用一个没有必要的库，尤其是还没在课堂中讲到的库，也可能是 AI 参与的痕迹。
\n还是看之前那段 lambda 代码：
\nfrom functools import lru_cache如果你还没讲过 functools 模块，那学生可能是用 ChatGPT 或谷歌找到的。使用这些工具发现库本身并没有错，但确实提示了我们：“AI 介入”的可能性。
这个问题就比较直观了，如果你布置作业时明确写了某个变量或字段的名字，但学生交上来的代码却用了一堆“规范但不符合你的要求”的变量名——那很可能是 AI 写的。
\n比如这段代码是求小于 n 的所有素数，变量命名都非常标准：
\ndef sieve_of_eratosthenes(limit):\n \"\"\"Return a list of all prime numbers less than the given limit.\"\"\"\n if limit <= 2:\n return []\n\n # Initialize a boolean array to track prime numbers\n is_prime = [True] * limit\n is_prime[0] = is_prime[1] = False # 0 and 1 are not primes\n\n for num in range(2, int(limit**0.5) + 1):\n if is_prime[num]:\n # Mark multiples of num as non-prime\n for multiple in range(num * num, limit, num):\n is_prime[multiple] = False\n\n # Collect all prime numbers\n primes = [num for num, prime in enumerate(is_prime) if prime]\n return primes\n\n# Example usage\nlimit = 50 # Change this value to find primes less than a different number\nprimes = sieve_of_eratosthenes(limit)\nprint(f\"Primes less than {limit}: {primes}\")普通学生可能会使用描述性较差的变量名和函数名，而我自己的写法可能会直接用 n 代替 limit，函数名也会用 prime_finder() 而不是 sieve_of_eratosthenes() 这么长。虽然不能完全凭这点就断定是 AI 写的，但如果结合其他“特征”，就更有可能了。
注意：这里是针对初学者，如果是老手的程序员或者想要精进，这种命名方法是推荐的。
\n最明显的信号，当然是逻辑错误。但要区分是学生的水平不够，还是 AI 理解出了问题，其实很难。
\nLLM 本质上是基于概率建模的系统，它们根据上下文生成“可能合理”的下一个词或代码块，而不是“真正理解”问题。这导致它们在处理需要严密推理或逻辑严谨的问题时，经常会出现错误。比如：索引出错、不处理边界情况、算错结果等等。
\n🚩 如果代码中存在不符合逻辑的错误，尤其是算法推导出错，那就很可能是 AI 写的。
\n理想情况下，认真负责任的学生会在交作业前检查并修复这些问题。但现实是，很多学生交上来的代码根本跑不通，甚至直接报错。
\n我们很难用一套“绝对规则”来判断一段代码是不是 AI 写的，所以我建议大家在教学时以“探索式”的态度去沟通，而不是质疑或指责。如果我怀疑某位学生对 AI 依赖过度，我可能会请他在白板上现场讲讲解决思路，或者让他解释自己写的代码是怎么来的。
\n只要给予适当的引导和信任，我们是可以培养出能善用 AI 的未来专业人才的 —— 把 AI 当作工具，而不是拐杖。
\n你有没有发现过类似的“AI痕迹”？欢迎一起交流。
\n哦对，还可以让学生使用 github 进行开发跟踪！
\n\nArtificial Intelligence (AI) research at Caltech is groundbreaking, and Caltech students will encounter AI in a wide range of interdisciplinary applications.
\nSince 2018, Caltech's AI4Science (or Artificial Intelligence for Science) Initiative has provided training and access to modern AI tools so researchers across a wide range of disciplines, from economics to astrophysics, can harness the power of AI. In 2023, Caltech established the Center for Science, Society, and Public Policy to examine the intersection of science and society, facilitate discussion of scientific ethics, and help shape public science policy.
\nThe Caltech community cares deeply about the ethical and social implications of AI technology, and this starts with the ethical use of AI by our applicants to Caltech undergraduate and graduate degree programs.
\nThe Undergraduate Faculty Admissions and Graduate Studies committees convened and have approved of the following ethical guidelines for the use of AI in the Fall 2025 application cycle. As access to AI continues to grow and the technology evolves, so will our recommendations and expectations for future application cycles.
\nYour essays are where we hear your voice. Relying on AI, specifically large language models such as ChatGPT or Bard, to craft your essay will dilute your unique expression and perspective. While we know AI tools have become readily accessible over recent months, overuse of AI will diminish your individual, bold, creative identity as a prospective Techer.
\nWhat are some examples of unethical uses of AI for Caltech admissions essays?
\nWhat are some examples of ethical uses of AI for Caltech admissions essays?
\nIf you are still wondering whether your use of AI in crafting your application is ethical, ask yourself whether it would be ethical to have a trusted adult perform the same task you are asking of ChatGPT. Would a teacher be able to review your essay for grammatical and spelling errors? Of course! Would that same teacher write a draft of an essay for you to tweak and then submit? Definitely not.
\nAbove all else, remember to be authentic to yourself when writing your essays. Our Caltech supplemental questions are designed to spark your curiosity, to make you think deeply about whether you see yourself as a Techer, and to jumpstart your creativity – don't let a reliance on AI tools take that opportunity from you!
\nCaltech students, faculty, and staff are guided by the Honor Code and policies of AI use as an academic tool by students will be determined by individual departments and/or individual faculty.
\nDid you receive any AI generated assistance in the preparation of your application materials?
\nPlease note, this information is confidential and will not be used in our review of your application. Answers to this question will never be used against a student. Caltech admissions readers will never have access to this information at any point in our review; in fact, we will not access this information until May 2025, after all admissions decisions have been made and the class of 2029 is finalized. We are simply curious about the use of AI in the admissions process.
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nAs a data science and math instructor, I actually don’t mind if my students use LLMs like ChatGPT, as long as it’s supplementing their learning process and not detracting from it. The Caltech admissions essay guidelines inspired my AI policy for my programming and machine learning classes:
\n\n\nWhat are some examples of unethical uses of AI for Caltech admissions essays?
\n\n
\n- \n
\nCopying and pasting directly from an AI generator
\n- \n
\nRelying on AI generated content to outline or draft an essay
\n- \n
\nReplacing your unique voice and tone with AI generated content
\n- \n
\nTranslating an essay written in another language
\nWhat are some examples of ethical uses of AI for Caltech admissions essays?
\n\n
\n- \n
\nUsing AI tools, like Grammarly or Microsoft Editor, to review grammar and spelling of your completed essays
\n- \n
\nGenerating questions or exercises to help kick start the brainstorming process
\n- \n
\nUsing AI to research the college application process
\nIf you are still wondering whether your use of AI […] is ethical, ask yourself whether it would be ethical to have a trusted adult perform the same task you are asking of ChatGPT. Would a teacher be able to review your essay for grammatical and spelling errors? Of course! Would that same teacher write a draft of an essay for you to tweak and then submit? Definitely not.
\n
That said, I’ve been getting some code submissions lately that are so obviously and completely AI-generated that I’ve had to put together my own compilation of AI omens. Of course, differentiating between human-generated and AI-generated code is getting more difficult every day. Still, there are some commonalities between ChatGPT/Claude/DeepSeek AI-generated code that are immediate red flags.
\nDo I wish that all my students commented as thoroughly as ChatGPT does? Absolutely. Do they? Definitely not.
\n🚩 Overly detailed commenting or odd commenting styles can indicate AI use.
\nFor instance, when using DeepSeek, you’ll see a docstring with three quotation marks as a instead of a comment using the standard pound (#), even though the docstring does not specify the arguments or the return values:
def find_squares_adding_to_zero(mod):\n \"\"\"Find two non-zero numbers a and b such that a^2 + b^2 ≡ 0 mod n.\"\"\"\n for a in range(1, mod): # Start from 1 to exclude a = 0\n for b in range(a, mod): # Start from a to avoid redundant pairs\n if (a**2 + b**2) % mod == 0:\n return (a, b)\n return NoneI find this to be an unnatural and odd way of commenting a single line, particularly given the context that I teach single-line comments in Python using #, and this is not proper docstring formatting.
\nSpecial characters in comments can also be an indicator of AI-generated code. Unless I’m writing something I know will be seen by many people, I probably wouldn’t put the effort into finding characters like “≡” just for a comment. I’d wager my students feel the same way.
Don’t get me wrong — I love lambda expressions and consider them a unique and valuable feature of Python. I see them as compact, throwaway functions meant to be created and passed directly as arguments to other functions. When used properly, they shine in situations where you need to pass a simple, one-off function to another function, like in map(), filter(), or sorted(). That said, lambda expressions can be a red flag when overused, applied incorrectly, or introduced prematurely.
🚩 The misuse of lambda expressions demonstrates a lack of thoughtful design or an overreliance on AI.
\nFor instance, if I got the following code submission before we’ve gone in depth on lambda expressions, and for a task such as this, I’d sniff out the ChatGPT use immediately:
\nfrom functools import lru_cache\n\nfib = (lambda f: (lambda x: f(f, x)))(lambda self, n: \n n if n < 2 else self(self, n-1) + self(self, n-2))\n\n# Generate the first 10 Fibonacci numbers\nfib_sequence = [fib(n) for n in range(10)]\nprint(fib_sequence)This is clearly a problem not well-suited to a lambda expression and is too complex for students to get to naturally and on their own in a first Python course.
\nPlacement of Library Imports
\n🚩 On occasion, LLMs will place library imports in weird places (places other than the top of the file).
\nI’ve only seen this happen a few times, but particularly if you’ve emphasized to students that library imports should go at the beginning or in one place all together, this should seem fishy.
\nWhat Libraries Are In-Use:
\n🚩 Using a library to execute a task that doesn’t necessarily require it can indicate AI use, particularly if it’s a library that isn’t common or hasn’t yet been introduced.
\nLet’s revisit the lambda expression code from above:
\nfrom functools import lru_cache\n\nfib = (lambda f: (lambda x: f(f, x)))(lambda self, n: \n n if n < 2 else self(self, n-1) + self(self, n-2))\n\n# Generate the first 10 Fibonacci numbers\nfib_sequence = [fib(n) for n in range(10)]\nprint(fib_sequence)If you haven’t introduced the functools library, a student very likely could have found out about it by using either Google or an LLM. There’s nothing wrong with discovering libraries using these tools, but it could tip you off to their specific implementation being AI-generated as well.
\nThis one speaks for itself. If you have an assignment where a field or variable name is something specific, AI-generated code will generalize it to a variable name that feels more explanatory but less natural. For instance, in the following code to find all primes less than a given number n, the average student would likely have less descriptive variable and function names:
\ndef sieve_of_eratosthenes(limit):\n \"\"\"Return a list of all prime numbers less than the given limit.\"\"\"\n if limit <= 2:\n return []\n\n # Initialize a boolean array to track prime numbers\n is_prime = [True] * limit\n is_prime[0] = is_prime[1] = False # 0 and 1 are not primes\n\n for num in range(2, int(limit**0.5) + 1):\n if is_prime[num]:\n # Mark multiples of num as non-prime\n for multiple in range(num * num, limit, num):\n is_prime[multiple] = False\n\n # Collect all prime numbers\n primes = [num for num, prime in enumerate(is_prime) if prime]\n return primes\n\n# Example usage\nlimit = 50 # Change this value to find primes less than a different number\nprimes = sieve_of_eratosthenes(limit)\nprint(f\"Primes less than {limit}: {primes}\")I would likely use “n” instead of “limit” or just “prime_finder” instead of “sieve_of_eratosthenes”. That said, particularly detail-oriented students might be wrongly accused of AI use under this rule, so I mainly consider this AI-generated code when combined with some of the other red flags provided in this article.
\nLogical errors are the most obvious red flag of all, on paper. In practice, it’s more difficult to tell — how can you determine if a language model made a logical mistake or if a student just didn’t quite get it?
\nAt their core, LLMs are statistical models designed to predict the likelihood of the next token (such as a word, letter, or subword unit) based on patterns learned from their training data. While they excel at generating coherent and contextually relevant text, they lack true understanding, reasoning, or algorithmic thinking. This limitation often leads to errors in tasks requiring precise logic, like solving math problems or generating code. An LLM might produce plausible-sounding but incorrect solutions or fail to follow complex logical sequences. For example, I’ve seen LLMs struggle with indexing in mathematical applications, not address edge cases, and provide outright incorrect results.
\n🚩 If the code contains errors in logic or errors in reasoning, it could be AI-generated.
\nIdeally, a diligent student would carefully review and correct such errors before submission. However, in practice, this step is often overlooked; I’ve gotten code submissions that produce incorrect outputs or don’t even run in the first place.
\nAs a disclaimer, it’s difficult to create hard and fast rules for telling if code is AI-generated, so I’d recommend approaching students with curiosity instead of accusation. If I believe a student is using AI to an unhealthy extent, I may ask them to have a whiteboard coding session on a related problem or ask about their intuition behind their solution. With the right support and attention to detail, I hope we can build up future professionals who use AI as a tool and not a crutch.
\nWhat are some LLM red flags you’ve noticed?
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n第三周周考技能试卷
\n考试须知：
\n模拟植物大战僵尸角色完成下列功能；
\n完成循环菜单效果，并且可以对存放角色的数组进行增删改查；
\n1:添加，2:查询，3:删除，4:退出AI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nAI tools are showing us just how broken the education system really is.
\nThere was an article I saw recently talking about the damning AI double standard in education…
\nTeachers are using AI to grade school papers and prepare learning plans — yet they’re banning students from using it.
\nChatGPT getting banned in schools and universities tells you everything you need to know about the education system.
\nSchool doesn’t prepare anyone for the real world.
\nIf they did then none of these tools clearly used in the real-world would be banned.
\nAll most schools do is feed you with unnecessary or esoteric knowledge you wouldn’t need to use in the vast majority of cases.
\nIn university they box you into a cage of specialization to meet the requirements for a job.
\nAnd for most of the jobs, you didn’t even need to know half of the things they made you learn to get the certificate.
\nAssignments and exams for the most part only test how much you can recall information.
\nThey test your memory retrieval ability. They don’t test your thinking process.
\nThey don’t test how sharp your mental models for solving problems are.
\nSo of course if they allowed AI tools like ChatGPT, everyone would get a perfect score in every exam.
\nBecause all the knowledge is already out there.
\nActually, AI is making it pretty clear that assignments and exams shouldn’t even really exist.
\nIf school was really about learning, then the focus would be on personalized, hands-on, interactive practice.
\nIt wouldn’t be about knowing the “right” answers and getting a terrible grade if you don’t.
\nGrades wouldn’t even be a thing, at least in their current form.
\nSchool wouldn’t be about getting the correct solution if you want to “pass”, it would be about becoming someone who can solve problems — especially big picture problems that really matter in life — or at least should really matter.
\nAnd using powerful tools to help us solve the problems even easier and faster.
\nAnd what if AI could eventually solve the problem entirely without us even having to think about it?
\nWould it be so wrong to have AI “think” for us, especially for irrelevant problems we’d rather not handle ourselves?
\nRelatively boring, repetitive problems?
\nProblems that already have well-established and predictable methods for solving them that today’s AI’s could easily internalize and replicate.
\nProblems like coding, for the most part.
\nBut sadly most schools mainly exist to take your money and produce certified knowledge warehouses.
\nThey’re not about big-picture, original thinking or the pursuit of happiness.
\nToo idealistic, right?
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n人工智能工具向我们展示了教育系统的真正缺陷。
\n我最近看到一篇文章，讨论了教育领域中令人发指的人工智能双重标准……
\n老师们在用 AI 批改作业、制定教学计划 —— 可与此同时，他们却禁止学生使用它。
教师们正在使用人工智能来批改试卷和制定学习计划——但他们却禁止学生使用它。
\n学校和大学封杀 ChatGPT，这就已经足够说明当前教育体系的问题。
\n学校根本没有为现实世界做好准备。
学校并不能帮助任何人做好面对现实世界的准备。
\n如果他们这样做了，那么现实世界中明显使用的这些工具就不会被禁止。
\n大多数学校所做的就是向你灌输大多数情况下你不需要使用的不必要或深奥的知识。
\n大学更是把你框进一座“专业化”的牢笼，只为了满足某份工作的学历门槛。
\n而实际上，那些工作根本不需要用到你学过的一半知识，就足已胜任。
\n作业和考试大部分只是测试你能回忆多少信息。（也就是在考你能记住多少东西）
\n它们只是在测试你的记忆提取能力，而不是你的思维过程。换句话说：检查你的记忆力，以及你对于记忆力中数据的检索能力，并不是真正考察你的思考过程！
\n他们不会考察你解决问题的思维模型是否足够敏锐。
\n所以，如果允许使用 ChatGPT 这样的 AI 工具，每个人的考试分数当然都会满分。
\n他们不会考察你解决问题的思维模型是否足够敏锐。
\n因此，如果他们允许使用 ChatGPT 等人工智能工具，那么每个人在每次作业、考试中都会获得满分。
\n因为所需的知识早已唾手可得，获取答案的成本在 AI 时代下，逐步降低！
\n实际上，AI 已经让我们看清：作业和考试可能根本就不应该存在。
\n如果学校真的以“学习”为本，那重点就该放在个性化、实践性强、交互式的学习上。
\n而不是去追求所谓的“标准答案”，然后因为错了一道题就被打个很差的分数。
\n成绩，至少以现在这种形式，是不应该存在的。或者委婉的说：在目前的形势下成绩根本不算什么。
\n“通过考试”不该意味着你要得出“标准答案”，而应该是：你要成为一个能真正解决问题的人 —— 特别是那些在生活中真正重要的大问题，或者本该重要的问题。
\n并且善于运用强大的工具，使我们更高效、更容易的解决问题。
\n如果有一天 AI 可以彻底替我们解决这些问题 —— 甚至无需我们亲自动脑，那又怎样？
\n让 AI 为我们“思考”那些我们本来就不想自己动脑的问题，真的有错吗？
让人工智能为我们“思考”难道有什么错吗，尤其是对于我们自己不愿意处理的无关问题？比如，那些重复、无聊、机械的问题呢？
\n那些已经有成熟解决方案、AI 完全可以掌握和复现的问题呢？
\n大多数情况下，问题类似于编码。不过注意，这里还是要强调：AI 工具本身就是一个双刃剑，还要学习的！学习，你才拥有判断 AI 回答的正确与否。不过，这个学习和以往不同～
\n比如说编程 —— 在很大程度上就是这样的问题。
但遗憾的是，大多数学校的存在目的，只是为了从你身上赚钱，并生产一批又一批“持证的知识仓库”。
\n它们根本不关心你是否具备大局观、是否具备原创性思维，甚至不关心你是否快乐。
\n太理想主义了吗？
\n这只猫（人工智能）永远不会再回到袋子里，我们需要懂得如何善用它的人。
\n要有自己的思想，自己的批判性思维，一切都可以解决！
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\nAI 正在悄悄接管编程工作，但许多程序员仍然对即将到来的变化视而不见……
\n现在，谷歌的首席科学家透露了一个令人深思的事实：AI 现在已经生成了他们至少 25% 的代码。
\n你能看见吗？这正在全球最顶尖的软件公司中发生，而这些公司拥有数十亿行活跃代码。
\n然而，还有那么多人仍然把 AI 辅助编程当作噱头，认为：没人真正用它来开发正式产品。
\n甚至有人在我评论区留言说，使用 AI 工具并不会提高效率……
\n拜托，我们不是早就一致认为 GitHub Copilot 是个爆款了吗？去年这个时候他们就已经有超过 130 万付费用户，这难道还不够说明问题吗？甚至当下火爆的 ChatGPT、DeepSeek，也可以间接的说明一些问题。
\n你要知道：软件开发者本来就是最难变现的群体之一——如果你能让 130 万开发者付费，那你的工具肯定不简单。
\n即使这些用户大部分来自企业端，我也不相信每个 B2B 开发者工具都能达到这个体量。
\n我还记得我第一次使用 Copilot 的时候：嗯，不错的工具，建议还可以，不赖……
\n可没过几天，当网络出问题我不得不用手码时——我才意识到，我其实已经开始依赖这个工具了。我已经习惯了更高质量的开发体验，但自己居然都没发觉。
\n那个用于接受补全的 Tab 键 —— 我那几天敲得最多的是 Tab，还是按回车键多？
\n以前：
\n现在：
\n生活质量的差距不言而喻，生产力的差距也同样如此。
\n这也提醒我们一件事：编程从来都是“思考”的行为，而不是“打字”的行为。
\n真正耗时间的，始终是思考：高层的系统设计，底层的算法和模式设计。打字，只是最后那一小步，其实很机械，很重复。
\n所以 Copilot 远不只是个代码补全工具，它是一个思维预测工具。
\n它不只是帮你更快编码，它是在理解你的想法，然后消除从思维到实现之间的阻碍。你只需要按下 Tab，而不用敲几十个字。
\n这已经非常实用了，而这还只是逐行级别的智能：预测你每一行的想法。
\n而现在我们有了更先进的工具，比如 Supercomplete，能预测你对整个文件的意图，开发体验再次跃升。
\n还有像 Cursor Compose 和 Windsurf Cascade 这样的工具，能将你的想法扩展到多个文件中自动实现。
\n它们不断在放大你的想法带来的价值和影响力。
\n比如你想为一个 Web 应用添加搜索功能：
\n那距离你直接说一句“构建并部署一个电商网站”，然后一切自动完成，还会有多远？
\n想象一下，你只给出一个模糊的描述，AI 就能主动向你提问，收集详细需求，避免歧义。
\n这已经越来越像是“迟早的事”，而不是“是否会发生”。
\n但如果你还在假装 AI 工具不会彻底改变软件开发的游戏规则 —— 那你很可能会被时代彻底抛下。
\n甚至，当下还有 ChatGPT、DeepSeek 作为辅助。如果只是简单的了解，不加以重视很有可能被被时代抛弃。
\n请持续关注 AI悦创，会一直带你解锁前沿的思想与技术！
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n制作一个英语学习小工具，能够每天抽取若干个单词，展示其中英文，支持标记是否掌握，并将未掌握单词记录下来，以便后续复习。
\nword_list.txt 读取若干单词；review_list.txt“是否复习未掌握单词？”（读取 review_list.txt 中的词汇）datetime 模块记录学习日期json 或 csv 存储学习记录（带日期）word_list.txt 示例格式（英文:中文，每行一个）apple:苹果\nbook:书\ncomputer:电脑\nrun:跑\nhappy:开心\nsun:太阳\ndog:狗review_list.txt 示例格式book:书\nsun:太阳def load_words(file_path):\n ...\n\ndef study_session(words, count=5):\n ...\n\ndef save_to_review(to_review, file_path):\n ...\n\ndef review_words(file_path):\n ...\n\ndef main():\n ....py 程序源代码（含完整注释）；word_list.txt 词库（不少于 20 个单词）；README.md 文件，并创建 log.md 文件实时记录自己每次的开发，还需要创建一个 Thinking.md 编写你脑海中随机浮现的想法💡（包括疑惑，不过需要注意结构。）tkinter 实现图形界面；schedule 或 crontab）；| 评分项 | 说明 | 分值 |
\n|
在 Python 中，嵌套的 for 循环是指在一个 for 循环内部再包含一个或多个 for 循环。这种结构在处理多维数据（例如二维、三维的列表或数组）以及需要多层次迭代的场景中非常常见，可以大幅提高编程的灵活性与效率。
嵌套的 for 循环的基本结构如下：
一个嵌套的 for 循环通常的书写形式如下：
for 变量1 in 可迭代对象1:\n for 变量2 in 可迭代对象2:\n # 执行代码块每个 for 循环工作原理如下：
可迭代对象1中取出一个元素赋值给变量1。可迭代对象2中逐一取出元素赋值给变量2。查看下面的代码示例，助于理解：
\nfor i in range(2):\n print(f\"外层循环执行了第 {i + 1} 次\")\n for j in range(3):\n print(f\"\\t内层循环执行了第 {j + 1} 次\")运行结果如下：
\n外层循环执行了第 1 次\n\t内层循环执行了第 1 次\n\t内层循环执行了第 2 次\n\t内层循环执行了第 3 次\n外层循环执行了第 2 次\n\t内层循环执行了第 1 次\n\t内层循环执行了第 2 次\n\t内层循环执行了第 3 次看了上面的输出，你会对 for 循环嵌套有更好的理解。我接下来还有写一个生活中的例子来辅助理解嵌套循环，学代码不要脱离现实！一切都来源于生活～
\n让我们用一个贴近生活的场景来解释嵌套 for 循环的思想。想象你是餐厅的经理，负责统计一晚上的销售收入。
\n场景描述：
\n在一家繁忙的餐厅中，每张桌子都有几位顾客，每位顾客可能会点多道菜。为了统计当晚的总收入，你会采取以下步骤：
\n这个过程可以形象地理解为：
\n这种分步走的做法正是嵌套循环的思想：先处理大范围的分组（桌子），再在每个分组内部逐个处理细节（顾客订单）。这种方法不仅让你更有条理地完成任务，还能防止遗漏细节。
\n通过这种方式，你就能准确地统计出餐厅一整晚的销售额，同时也能发现某一桌的消费是否特别高、哪种菜品更受欢迎等信息。这正是嵌套 for 循环在现实生活中的一个直观应用。
\n假设我们有一个二维列表（即列表的列表），我们可以使用嵌套的 for 循环来遍历每一个元素。
假设我们有一个二维列表（列表中存放列表），现在需要依次遍历并访问里面的每个元素。示例代码如下：
\n假设我们有一个二维列表（即列表的列表），比如一个 3x3 的矩阵。我们希望依次访问矩阵中的每个元素。下面的示例代码展示了如何使用嵌套循环来完成这个任务：
matrix = [\n [1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]\n]\n\nfor row in matrix: # 外层循环：遍历每一行\n for item in row: # 内层循环：遍历当前行中的每个元素\n print(item)这段代码首先遍历 matrix 中的每一行（外层循环），然后遍历该行中的每个元素（内层循环），并打印出来。
运行结果将依次打印 1 2 3 4 5 6 7 8 9。这里的 row 是外层循环的元素（即矩阵中的一行），item 则代表当前行中的某个具体元素。
逐步解析：
\nfor row in matrix: 这一行代码会依次取出 matrix 中的每一行（每一行本身也是一个列表），并将它赋值给变量 row。for item in row: 每当外层循环取得一行数据后，内层循环会遍历该行中的所有元素，依次将元素赋值给 item，并执行 print(item)。小实验：尝试在代码中添加注释或打印调试信息，观察内外层循环的执行顺序，加深理解。
\n小试牛刀： 用 for 循环嵌套求 matrix 数据总和。
用 for 循环嵌套对二维列表求和，二维列表数据如下：
\nmatrix = [\n [1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]\n]第一步：先思考如何实现，我们要计算出列表 matrix 中的总和，前提是什么？前提是先得到每个数字！
\n第二步：得到列表中的每个数字，前面已经讲解过：
\nmatrix = [\n [1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]\n]\n\nfor row in matrix: # 外层循环：遍历每一行\n for item in row: # 内层循环：遍历当前行中的每个元素\n print(item)第三步：得到每一个数字后，我们需要实现累加。现实生活中，我们加一个数时会怎么计算？
\n[1, 2, 3]；3 + 3 = 6。total 吧。total 吗？——肯定不行，语法也不允许。肯定是需要给 total 赋一个值，因为我们是要求和，赋什么值不会影响最终的计算结果呢？——零（0），零加上任何数都等于本身！最终代码如下：
\n# 我们先初始化一个变量 total 用于累加每个元素的值。\ntotal = 0第四步：直接进行累加即可
\nmatrix = [\n [1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]\n]\ntotal = 0\nfor row in matrix:\n for item in row:\n total += item # 外层循环遍历每一行，内层循环遍历每一行中的每个数字，并不断将数字加到 total 上。\n\nprint(total)这段代码会将所有数字相加并打印出结果 45，如果可以：试着在内层循环中添加 print(item)，观察程序是如何逐步累加的。
上面成功实现求和，但 for 循环嵌套并不是必须的，我们如何实现只用一个 for 循环实现呢？
并非所有情形都必须使用嵌套循环，我们学会跳出思维惯性，开阔自己的思维。有时解决问题的方法不止一种，如同上面的求和任务。若仅仅是想把所有数字相加，还可以用下面的写法，一个 for 循环就足够了。
这里我们可以利用 Python 内置的 sum() 函数对每一行列表求和，然后再累加。例如：
matrix = [\n [1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]\n]\ntotal = 0\nfor row in matrix:\n total += sum(row)\nprint(total)这种方式代码更简洁，但理解嵌套循环的工作原理对于你日后面对更复杂问题时非常重要。如果说推荐，我肯定推荐现在的第二种方法。这里用到 for 嵌套，纯粹是为了教你用而用。
\n在更复杂的情形下，我们可能需要按“列”来计算和。
\n现在让我们挑战一下：是我们的“老熟人”二维数组 matrix，要求计算每一列的元素之和，并将结果存储在一个一维数组中。该任务不仅锻炼你对嵌套循环的理解，同时也会让你更熟悉如何操作数组索引。
对于下面的矩阵：
\nmatrix = [\n [1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]\n]对于上述 matrix，你的程序应该输出：
每列的和: [12, 15, 18]说明：
\n第一列（第 0 列）的和：1 + 4 + 7 = 12
第二列（第 1 列）的和：2 + 5 + 8 = 15
第三列（第 2 列）的和：3 + 6 + 9 = 18
要求：你必须使用 for 循环来遍历二维数组并计算每列的和。
提示：你可以通过初始化一个长度为 n 的数组来存储每列的和，并在遍历每行时将每列的值加到相应的数组位置上。
好好思考一下，看看上面如何实现。接下来，我会一步步带你实现。
\n想象一下，你有一个由多行数字组成的表格，每一列都排列着一组数字。假如你要计算每一列的总和，首先你会在心中设定一个记录器，每一列都有一个“计数器”。
\n当你逐行查看这张表格时，每读到一行，就会把这一行中每一列的数字分别加到对应的计数器上。
\n比如，第一行的三个数字分别加到第一、第二、第三个计数器上；接着第二行同样处理……直到所有行都看完。
\n最终，每个计数器中的数值就是对应列的总和。
\n接下来，我举个具体的例子，来让你更好的理解。文字表达终归有局限性，但是我会尽可能表达完全且清楚。
\n假设你面前有一个表格，表格中的数字排列如下：
\n+将程序任务涉及到的事物抽象为一个个的对象，以这些对象为中心来写程序。是不是很抽象，很难理解？不用慌，我们从头开始讲！
\n很多朋友最开始学编程的时候，是从 C++ 或者 JAVA 语言入手的。甚至现在国内外 Python 课程开设，不用要求学生提前掌握其它编程语言。读者们好不容易磕磕绊绊地搞懂了最基本的数据类型、赋值判断和循环，却又迎面撞上了 OOP (object oriented programming) 的大墙，一头扎进公有私有保护、多重继承、多态派生、纯函数、抽象类、友元函数等一堆专有名词的汪洋大海中找不到彼岸，于是就放弃了进阶之路。
\n相比之下，Python 是一门相对友好的语言，它在创立之初就鼓励命令交互式的轻量级编程。理论上，Python 的命令式语言是图灵完备的, 也就是说命令式语言，理论上可以做到其他任何语言能够做到的所有的事情，甚至进一步，仅仅依靠汇编语言的 MOV 指令，就能实现图灵完备编程。
\n那么为什么不这样做呢？其实，“上古时代”的程序员就是这么做的，可是随着程序功能复杂性的逐步提升，以及需求的不断迭代，很多老旧的代码修改起来麻烦无比，牵一发而动全身，根本无法迭代和维护，甚至只能推倒重来，这也是很多古老的代码被称为“屎山”的原因。
\n传统的命令式语言有无数重复性代码，虽然函数的诞生减缓了许多重复性，但随着计算机的发展，只有函数依然不够，需要把更加抽象的概念引入计算机才能缓解（而不是解决）这个问题，于是 OOP 应运而生。
\nPython 在 1989 年被一位程序员打发时间创立之后，一步步攻城掠地飞速发展，从最基础的脚本程序，到后来可以编写系统程序、大型工程、数据科学运算、人工智能，早已脱离了当初的设计，因此一些其他语言的优秀设计之处依然需要引入。我们必须花费一定的代价掌握面向对象编程，才能跨越学习道路中的瓶颈期，走向下一步。
\n接下来，我将用上万字来讲解面向对象编程，从基础到实战。我将带你快速但清晰地疏通最基础的知识，确保你能够迅速领略面向对象的基本思想。接着我们从零开始写一个文字对话游戏，将前面所学知识融会贯通。
\n这些内容可能和你以往看到的所有教程都不太一样，我会尽可能从一个初学者的角度来审视这些难点。同时我们面向实战、面向工程，不求大而全，但是对最核心的思想会有足够的勾勒。我可以保证内容清晰易懂，但想要真正掌握，仍要求你能用心去阅读和思考。真正的提高，永远要靠自己才能做到。
\n学习编程时，我们常常会听到“类”和“实例”这两个概念。要想真正理解它们，可以先从生活中的例子说起。
\n什么是类？狗是某一类动物，它们具有相同、相似的属性。如同我们平时说人：物以类聚，人以群分。
\n狗这一类里面有具体地：我家有一只狗，叫旺财。你家有一只狗，叫大黄。
\n因为属于同一狗类，所以它们有共同点：旺财、大黄都有四条腿，一条尾巴，都会狗叫。
\n虽然都属于同一类，但它们互相独立：旺财和大黄被生出来后，互相不会影响。旺财吃胖了，体重增加了不会影响大黄。（一千只狗，就会有一千只哈姆雷特狗。「开玩笑的」）
\n同属一类，当类被影响（修改）时，它们命运相同：如果某一天上帝决定给狗这个种类的生物都增加一条尾巴，那么旺财和大黄会同时变成两条尾巴。
\n上面用来具体例子在描述类和具体的旺财和大黄，接下来我们快速总结一下：
\n我们接下来学习，面向对象编程中最基本的概念。前面是比较接地气的解释，下面算是比较正经的解释。虽然有循环论证之嫌（lol），但是我不关心，反复强调之中我还是希望你能对面向对象的最基础的思想，有更真实的了解。
\n为了方便你理解其中的抽象概念，我先打个比方带你感受一下。生物课上，我们学过“界门纲目科属种”的概念，核心思想是科学家们根据各种动植物、微生物的相似之处，将其分化为不同的类型方便研究。生活中我们也是如此，习惯对身边的事物进行分类：
\n自然，同一类事物便会有着相似的特性：
\n任务：我们有一只猫和一只狗，他们在听到指令后要向前跑 10 米。
\n我们来编写这两个函数：
\ndog_x = 0\ncat_x = 0\n\n\ndef dog_move():\n global dog_x # 为什么要加上 global？因为 dog_x 是全局变量，如果不加上 global，函数内的 dog_x 会被视为局部变量，也无法修改全局变量的值\n dog_x = dog_x + 10\n\n\ndef cat_move():\n global cat_x\n cat_x = cat_x + 10\n\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n print('dog:{}, cat:{}'.format(dog_x, cat_x))\n dog_move()\n cat_move()\n print('dog:{}, cat:{}'.format(dog_x, cat_x))注意：在阅读的过程当中，你要按我的指导来并且思路也要跟着来。
\n现在，把上面的代码敲一遍。敲完之后，也先别急着往下阅读。先思考和阅读一下上面的代码，看看功能、语法都能理解吗。能理解，则继续。
\n相必你已经理解了上面的代码，接下来请你再添加一只动物：大象，也是听到指令后要向前跑 10 米。
\ndog_x = 0\ncat_x = 0\nelephant = 0\n\n\ndef dog_move():\n global dog_x # 为什么要加上 global？因为 dog_x 是全局变量，如果不加上 global，函数内的 dog_x 会被视为局部变量，也无法修改全局变量的值\n dog_x = dog_x + 10\n\n\ndef cat_move():\n global cat_x\n cat_x = cat_x + 10\n\n\ndef elephant_move():\n global elephant\n elephant = elephant + 10\n\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n print('dog:{}, cat:{}, elephant:{}'.format(dog_x, cat_x, elephant))\n dog_move()\n cat_move()\n elephant_move()\n print('dog:{}, cat:{}, elephant:{}'.format(dog_x, cat_x, elephant))敲完大象的代码后，你有没有感觉什么？如果你有什么感觉或者感受，马上拿支笔或者用电脑写注释，把感受写下来！
\n我们上面定义了三个相似的函数，功能一样，只有什么不一样？——变量名称不一样。
\n是不是感觉太多重复了，你有可能此时觉得没必要创建这么多函数。但是我举个例子你就明白了，比如我们开发了一个围棋对弈的程序，支持用户注册，每个用户注册都要填写用户名、手机号、密码。那是不是意味着我们都要为每个用户创建一个函数来存储呢？
\n# 我们现在有三个用户要注册，每个用户都要填写用户名、手机号、密码\n# 如果我们不优化代码，那可能会像下面这样写：\n\ndef register_user1():\n username1 = input(\"请输入用户1的用户名：\")\n phone1 = input(\"请输入用户1的手机号：\")\n password1 = input(\"请输入用户1的密码：\")\n print(\"用户1注册成功！用户名：{}，手机号：{}\".format(username1, phone1))\n\n\ndef register_user2():\n username2 = input(\"请输入用户2的用户名：\")\n phone2 = input(\"请输入用户2的手机号：\")\n password2 = input(\"请输入用户2的密码：\")\n print(\"用户2注册成功！用户名：{}，手机号：{}\".format(username2, phone2))\n\n\ndef register_user3():\n username3 = input(\"请输入用户3的用户名：\")\n phone3 = input(\"请输入用户3的手机号：\")\n password3 = input(\"请输入用户3的密码：\")\n print(\"用户3注册成功！用户名：{}，手机号：{}\".format(username3, phone3))\n\n\n# 现在我们要依次注册这三个用户\nregister_user1()\nregister_user2()\nregister_user3()所以，要是为每个用户都来一个类似的行数。那代码是不是会变成“屎”一样的山呢？——答案想必你聊熟于心（肯定会变成屎山的）
\n我们接着回到一开始的动物向前移动的例子，我们一共写了三只动物的移动函数：dog_move()、cat_move()、elephant_move()。并且每个函数都做着几乎一样的事情，只是变量名不同。虽然目前动物不多，但如果我们要添加更多动物，比如兔子、老虎、熊猫……你会发现代码会迅速变得臃肿、重复，维护起来很麻烦。
思考一下：有没有更优雅的方式来管理动物的位置？
\n我们可以把这些“重复”的结构统一管理起来，例如：我们把所有动物的位置，放进一个统一的容器里，比如用一个字典来表示。一起来看看下面的代码。
\npositions = {\n \"dog\": 0,\n \"cat\": 0,\n \"elephant\": 0\n}那么至少，这样的代码会比原本的简洁一些。看看下面的代码效果：
\npositions = {\n \"dog\": 0,\n \"cat\": 0,\n \"elephant\": 0\n}\n\n\ndef dog_move():\n global positions\n positions['dog'] = positions['dog'] + 10\n\n\ndef cat_move():\n global positions\n positions['cat'] = positions['cat'] + 10\n\n\ndef elephant_move():\n global positions\n positions['elephant'] = positions['elephant'] + 10\n\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n print('dog:{}, cat:{}, elephant:{}'.format(positions['dog'], positions['cat'], positions['elephant']))\n dog_move()\n cat_move()\n elephant_move()\n print('dog:{}, cat:{}, elephant:{}'.format(positions['dog'], positions['cat'], positions['elephant']))运行之后，输出如下：
\n输入指令:move\ndog:0, cat:0, elephant:0\ndog:10, cat:10, elephant:10函数还是一如既往的更“屎”一样，但是动物的数据结构化了。
\n到此，我们来稍微总结一下：
\n那么对于相同功能和相同的结构，是不是就可以说是：相同相似的属性，那么就可以把上面写的多个函数（dog_move()、cat_move()、elephant_move()）都是视为同一个类。可以叫动物类（Animal），只要属于这个动物类都可以接收指令往前跑。
接下来，我们就要使用面向对象的方法来实现前面动物听到指令就往前跑的功能。
\n编写如下代码：
\nclass Animal():\n def __init__(self):\n self.x = 0\n\n def move(self):\n self.x = self.x + 10\n\ndog = Animal()\ncat = Animal()\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n dog.move()\n cat.move()\n print('Dog position:', dog.x)\n print('Cat position:', cat.x)参照着这段代码，我先来简单解释几个概念。
\nmove() 函数。接下来，看下面的图比较直观一点，能看到每个部分代表什么：
\n当然，这样的说法既不严谨，也不充分，但如果你对面向对象编程完全不了解，它们可以让你迅速有一个直观的了解。
\n这里我想多说两句。回想起当年参加数学竞赛时，我曾和一个大佬交流数学的学习，我清楚记得我们对数学有着相似的观点：很多数学概念非常抽象，如果纯粹从数理逻辑而不是更高的角度去解题，很容易陷入僵局；而具体、直观的想象和类比，才是迅速打开数学大门的钥匙。虽然这些想象和类比不严谨也不充分，很多时候甚至是错误或者异想天开的，但它们确实能帮我们快速找到正确的大门。
\n就像很多人都有过的一个疑惑，“学霸是怎样想到这个答案的？”。德国数学家克莱因曾说过，“推进数学的，主要是那些有卓越直觉的人，而不是以严格的证明方法见长的人。”编程世界同样如此，如果你不满足于只做一个 CRUD“码农”，而是想成为一个优秀的工程师，那就一定要积极锻炼直觉思考和快速类比的能力，尤其是在找不到 bug 的时候。这才是编程学习中能给人最快进步的方法和路径。
\n言归正传，继续回到我们的主题，还是通过刚刚那段代码，我想再给类下一个更为严谨的定义。
\n类，一群有着相同属性和函数的对象的集合。
\n__init__(self) 函数接下来，我们来具体解读刚刚这段代码。为了方便你的阅读学习，我把它重新放在了这段文字下方。
\nclass Animal():\n def __init__(self):\n self.x = 0\n\n def move(self):\n self.x = self.x + 10\n\ndog = Animal()\ncat = Animal()\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n dog.move()\n cat.move()\n print('Dog position:', dog.x)\n print('Cat position:', cat.x)可以看到，class Animal 定义了 Animal 类，再往下能看到它有两个函数，这连个函数即为 Animal 类的两个函数。
其中，init 表示构造函数，含义则是：在一个对象生成时会被自动调用的函数。这么讲比较抽象，我们来结合下面的代码来实现：
\nclass Animal():\n def __init__(self):\n print('init function called')\n\ndog = Animal()运行上面代码后会自动输出：
\nNice to meet you!我们能看到， dog = Animal() 这一行代码被执行的时候，'init function called' 字符串会被打印出来。
你有没有发现，我们从始至终都没有调用 init 函数！在类 Animal 被实例化为 dog 时，会自动被调用。
注意：你需要做到自己编写代码和运行一下，这样才能理解！
\n再举一些现实的例子，因为不确定你会因为哪个例子理解，我这里就多列几个：
\n例子一：我们创建了一个游戏角色，每个角色一出生（也就是被创建的时候），就会自动拥有一些“天赋技能”。这些技能不是你手动添加的，而是角色一出生系统就帮你准备好了。
\n在 Python 中，__init__ 函数就像这个“天赋赋予系统”，当你创建一个对象（实例化）的时候，它会自动帮你设置好对象该有的初始状态。
class GameCharacter:\n def __init__(self):\n print(\"角色已创建，天赋技能已激活！\")\n\nhero = GameCharacter()运行这段代码，控制台会自动输出：
\n角色已创建，天赋技能已激活！我们没有显式地调用 __init__()，但它还是被执行了。这就是 __init__ 函数自动调用的效果。
这个机制非常重要——它可以让我们在对象被创建时，自动执行一些初始化操作，比如设置默认值、加载数据、建立连接等。
\n例子二：我们人类在一诞生的时候，没人教我们怎么呼吸、心跳，这些都是会自动拥有且自动执行（开始的）。
例子二：就像我们人类在一诞生的时候，没人教我们怎么呼吸、怎么让心脏跳动——这些能力是与生俱来的，是“出生那一刻就自动开始执行”的。
\nPython 中的 __init__ 方法（函数），就像“呼吸”和“心跳”一样。当我们创建一个新的对象（生命、实例化）时，它会自动执行，不需要我们手动去调用。
class Human:\n def __init__(self):\n print(\"一个新生命诞生了，正在自动启动呼吸和心跳系统。\")\n\nbaby = Human()输出结果是：
\n一个新生命诞生了，正在自动启动呼吸和心跳系统。你有没有注意？我们并没有调用 __init__()，但它还是被执行了。为什么？因为我们创建了一个新的 Human() 对象（实例化）baby，Python 就会自动调用 __init__()，帮我们把“出生后应该启动的机制”都安排好。
所以你可以把 __init__ 想象成“对象出生时的大脑指令中心”——只要对象（实例化）一被创建，它就会第一时间执行你写好的初始化内容，比如设定初始状态、创建属性，或者像我们上面例子一样，打印一句欢迎词。
讲完初始化函数 __init__ ，我们接下来来讲 move() 函数，move() 则为类的普通函数，我们调用它们来对对象的属性做一些事情。
move(self) 函数move(self) 函数就是和我们前面讲的基本函数意思、功能是一样的，只不过这里是属于类里面的功能函数。没有什么要讲的，重点去看前一篇的。
在上面的代码中，你如果仔细观察的话会发现：在类内的每个函数中，都有写 self 参数。这个地方的知识点比较抽象，一定要细细思考和阅读。就算我不慎重复论述，你也不要疑惑，一切的一切都是为了让你学会。
\n我把代码贴出来，方便阅读学习：
\nclass Animal():\n def __init__(self):\n self.x = 0\n\n def move(self):\n self.x = self.x + 10\n\ndog = Animal()\ncat = Animal()\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n dog.move()\n cat.move()\n print('Dog position:', dog.x)\n print('Cat position:', cat.x)我一步步带你理解，然后再用专业的角度来解释。（不专业的才是你学会的契机）
\nself 就是代表 Animal()，而当 Animal() 实例化了 dog（也就是 Animal() 赋值给变量 dog：dog = Animal()），则可以得到 dog 就是代表 Animal()，最终：self 就代表 dog。故而可以得到：
self.x ==> Animal().x ==> dog.x ；Animal() 中的函数可以写成：Animal().move() ，那么实例化之后 dog 就代表 Animal()，可以得到：dog.move() 调用函数。self.x），则在类中，所有函数都可以随时调用变量 self.x。（后续会有代码演示）Animal() 当中。所以 “self 自己”就代表 Animal() 。Animal() 赋值给变量 dog（实例化），所以 dog 代表 Animal() 这个类。self == Animal() == dog，故而 self.x 等价于 Animal().x 接着等价于 dog.x。Animal() 的函数 move()，就可以写成 Animal().move() （中间的点“.”可以理解成“的”），有因为类 Animal() 赋值给 dog，所以可以得出：dog.move()。通过上面两个非正式讲解，如果你全部理解的话，那么后续讲解 self 部分你不用细究和强迫读懂，直接速读即可。毕竟正式的表达不好理解，不过我还是得稍微写一下。
\n在类里面的函数，第一个参数都必须写 self！
\n在 Python 中，当我们定义一个类的方法时，第一个参数通常命名为 self。这并不是 Python 的关键字，而是一种编程约定，用来表示当前实例对象。每当我们调用一个对象的方法时，Python 会自动将这个对象传递给方法中的第一个参数，这样我们就可以在方法内部访问该对象的属性和其他方法。
\nthis 指针来代表当前对象。但在 Python 中，没有隐式传递对象引用的机制，而是需要程序员显式地声明并使用 self。这种方式让代码更加直观，所有对当前对象的引用都清晰可见。想象一下，一个班级中有许多学生。每个学生都有自己的姓名、年龄和特点。如果老师想了解某个学生的信息，他会直接问那位学生：“你叫什么名字？”
\n在 Python 中，self 就起到类似“我”的作用。当我们调用某个对象的方法时，self 会自动指向那个具体的对象实例，就像当你问某个学生“你叫什么名字？”时，他会用“我”来代表自己，从而给出正确的回答。
\nclass Animal():\n def __init__(self):\n self.x = 0\n\n def move(self):\n self.x = self.x + 10\n\ndog = Animal()\ncat = Animal()\n\nuser_input = input('输入指令:')\n\nif user_input == 'move':\n dog.move()\n cat.move()\n print('Dog position:', dog.x)\n print('Cat position:', cat.x)当你调用 dog.move() 时，Python 实际上会自动将 dog 这个对象作为第一个参数传递给 move 方法，所以在方法内部，self 就代表 dog。这也是为什么我们总是能在方法内部通过 self 来访问和修改对象的属性。
提示：尝试在方法内部打印一下 self，你会看到它输出的是该对象的内存地址或其它标识信息，这可以帮助你更直观地理解 self 代表的是当前实例对象。代码如下：
class Animal():\n def __init__(self):\n self.x = 0\n print(f\"self address: {self}\")\n\n\ndog = Animal()\nprint(f\"dog address: {dog}\")运行后输出如下：
\nself address: <__main__.Animal object at 0x1097e0dd0>\ndog address: <__main__.Animal object at 0x1097e0dd0>从上面的输出可知，最终两个输出的地址是相同的，代表 self 就是代表当前的实例化对象。
\n__init__ 初始化参数现实生活中，小孩在出生之前。大人们都会做一件什么事情？
\n取名字！取名字这件事，是在宝宝出生之前就要提前准备好的。当小孩一出生，就要及时办理出生证。办理出生证就需要想好的名字，而一个人的名字很重要。这时有奇思妙想的学生就会说：老师，你怎么知道性别？咦，我当然不知道了。但是我可以提前想好男宝和女宝的姓名不就行了。
\n言归正传，有时候我们在类的初始化时，我们就想给实例化对象取一个名称（昵称）。就比如上面所说的取名字或者你玩游戏之前都要去一个昵称才能开始游戏吧。
\n再比如：你注册微信也要一个微信号、微信昵称注册 QQ 就要设置 QQ 昵称、头像吧。这些都是在一开始初始化（实例化）的时候就要填写的。
\n那么在面向对象中，我们如何达到呢？看看如下代码：
\n# 在现实生活中，当宝宝出生之前，大人们就会为宝宝取名字，\n# 并且准备好出生证明等信息。\n# 在面向对象中，我们通过 __init__ 方法初始化实例时，就相当于在出生之前\n# 为小孩准备好了“名字”（以及其他必要的信息）。\n\nclass Baby:\n def __init__(self, name):\n \"\"\"\n 初始化宝宝对象时，必须提供名字，\n 这就像是大人提前为宝宝取好名字，并在必要时办理出生证明。\n \"\"\"\n self.name = name # 宝宝的名字，相当于出生证明中的名字\n\n def introduce(self):\n \"\"\"\n 宝宝的自我介绍方法，展示初始化时设置的属性。\n \"\"\"\n print(f\"大家好，我叫 {self.name}。\")\n\n# 宝宝出生前，大人已经为他取好了名字\nbaby1 = Baby(name=\"棠棠\") # 实例化\nbaby1.introduce() # 输出: 大家好，我叫 棠棠。从上面的代码就可以知道，我们如果想要在实例化对象的时，想要添加参数，只需要 __init__ 函数的 self 后面添加参数即可。
接着，我们讲一下为什么要把用户传入的参数进行添加 self 赋值操作：self.name = name。
self.xxx = xxx？背后到底发生了什么？小提示：白话讲解为了让你理解，总结性讲解为了让你专业。
\n我先打白话讲解一下，然后再总结性的讲解一下。下面的讲解中，我们都使用 self.name = name 为例来讲解。
在 __init__ 方法（函数）中，你会从上面的代码中发现一个疑问点：为什么用户传入的参数不直接使用，还要创建一个 self.变量名 = 参数 的操作。
就例如以下几个问题：
\nself.name？name = name 还要用 self？上面三个问题，到底意欲何为呢。我们来一一解答这三个问题。
\n问题一解答：通过初始化函数传进来的参数，是不是得找地方存放？就像你准备开设围棋大师班，在正式开设之前。从外地引入了围棋棋具，是不是需要在开班之前要找地方存放。我们类通过实例化（初始化）传入的参数也需要找地方存放，所以需要使用 self.name = name 来存放，至于为什么加 self 下一个问题会解答。
问题二解答：直接使用 name = name 可以，但是就仅限于初始化函数 __init__ 自己使用，不仅仅其它函数无法使用，类的实例化对象也无法调用该参数变量（属性值）。看下面的代码，我们没有使用 self 来赋值：
class Baby:\n def __init__(self, name):\n name = name\n print(f\"init name: {name}\")\n\n def introduce(self):\n print(f\"大家好，我叫 {name}。\")\n\nbaby1 = Baby(name=\"棠棠\") # 实例化\nprint(baby1.name)\nbaby1.introduce()上面的代码运行之后，是会报错的。有两个报错点，有一个报错还没来的及出来。报错如下：
\ninit name: 棠棠\nTraceback (most recent call last):\n File \"/Users/huangjiabao/bornforthis.cn/demo.py\", line 15, in <module>\n print(baby1.name)\n ^^^^^^^^^^\nAttributeError: 'Baby' object has no attribute 'name'报错点1：代码 baby1.name 无法调用 name 属性值；
报错点2：除 init 函数外，其它函数（introduce）无法使用用户传入的初始化参数。（init 初始化 print(f\"init name: {name}\") 正常输出）
所以，使用 self 可以解决上面的两个报错点。
\nclass Baby:\n def __init__(self, name):\n self.name = name\n print(f\"init name: {self.name}\")\n\n def introduce(self):\n print(f\"大家好，我叫 {self.name}。\")\n\nbaby1 = Baby(name=\"棠棠\") # 实例化\nprint(baby1.name) # 输出: 棠棠\nbaby1.introduce() # 输出: 大家好，我叫 棠棠。问题三解答：至于为什么要使用同名这个很简单，因为：懒。你叫其它变量名可以，但是你还得思考其它有没有合适的变量名，毕竟我们需要的变量名是：见名知意。故而：既然参数名是想好的，索性直接基于参数名加上 self 就可以了。代码示例：
\nclass Baby:\n def __init__(self, name):\n self.name = name\n self.username = name\n print(f\"init name: {self.name}, username: {self.username}\")\n\nbaby1 = Baby(name=\"棠棠\")在 __init__ 方法中，我们通常会把用户传入的参数赋值给对象的属性，例如 self.name = name。这样做有几个主要原因：
name 在 __init__ 方法内仅是一个局部变量，作用域仅限于这个方法内部。如果不将其赋值给 self.name，当 __init__ 执行完毕后，这个值就会丢失。而通过 self.name = name，我们将这个值保存到了对象的属性中，这样对象的其他方法就可以随时访问和使用这个信息，就像现实中宝宝的名字会被一直记录在出生证明上一样。self.name = name 时，每个实例都会拥有自己的 name 属性，这样不同对象之间的数据互不干扰。比如两个宝宝虽然可能取相同的名字，但它们是两个独立的个体，彼此之间不会混淆。下面通过一个代码示例来说明这一点：
\n# 模拟现实中为宝宝取名字和准备出生证明的过程\nclass Baby:\n def __init__(self, name):\n \"\"\"\n 当宝宝出生之前，大人们已经为他取好了名字。\n 这里的 __init__ 方法相当于在宝宝出生前给他准备好所有必要的信息，\n 而 self.name = name 就像是把这个名字写入了宝宝的出生证明中。\n \"\"\"\n # 将传入的 name 参数赋值给当前对象的属性 self.name\n self.name = name\n\n def introduce(self):\n \"\"\"\n 宝宝的自我介绍方法，用来展示初始化时设置的信息。\n 这里使用 self.name 来引用对象保存的名字信息。\n \"\"\"\n print(f\"大家好，我叫 {self.name}。\")\n\n\n# 实例化对象时传入参数\nbaby1 = Baby(\"小明\")\nbaby2 = Baby(\"小红\")\n\n# 分别调用 introduce 方法，展示对象中保存的信息\nbaby1.introduce() # 输出: 大家好，我叫 小明。\nbaby2.introduce() # 输出: 大家好，我叫 小红。总结：
\n__init__ 方法中，name 是一个局部变量，而 self.name 是实例的属性。只有将 name 赋值给 self.name，我们才能在对象的其他方法中使用这个值。self.name = name 确保了对象在其生命周期内能够持续保留这个信息，就像宝宝的名字一直伴随着他成长一样。这种做法不仅符合 Python 的面向对象编程习惯，还能帮助初学者更好地理解对象的概念和数据的持久化存储。
\n如果在类的初始化函数 __init__中设定了参数，则必须在类的实例化时给出参数的值，否则代码会报错。一起看看下面的代码示例：
baby1 = Baby()没有给出具体的参数，运行后会报错：
\nTraceback (most recent call last):\n File \"/Users/huangjiabao/bornforthis.cn/demo.py\", line 21, in <module>\n baby1 = Baby()\n ^^^^^^\nTypeError: Baby.__init__() missing 1 required positional argument: 'name'所以，如果给初始化函数设置了参数，就必须在实例化时给参数赋值。除非我们给参数设置了默认值，后续会讲解到。
\n上面的类还不完善，还需要考虑宝宝的性别。那么在类当中如果有多个初始化参数，和普通函数设置参数一样：直接用逗号分隔多个参数。看看下面的代码示例：
\nclass Baby:\n def __init__(self, name, gender):\n \"\"\"\n 初始化宝宝对象时，必须提供名字，性别。\n 这就像是大人提前为宝宝取好名字，并在必要时办理出生证明。\n \"\"\"\n self.name = name # 宝宝的名字，相当于出生证明中的名字\n self.gender = gender # 宝宝的性别，可能提前确定\n\n def introduce(self):\n \"\"\"\n 宝宝的自我介绍方法，展示初始化时设置的属性。\n \"\"\"\n print(f\"大家好，我叫 {self.name}，我是一个 {self.gender} 宝宝。\")\n\n\n# 模拟场景1：宝宝出生前，大人已经为他取好了名字和性别信息\nbaby1 = Baby(name=\"棠棠\", gender=\"女\")\nbaby1.introduce() # 输出: 大家好，我叫 棠棠，我是一个 女 宝宝。\n\n# 模拟场景2：宝宝出生前，大人已经为她取好了名字和性别信息\nbaby2 = Baby(name=\"锦奕\", gender=\"男\")\nbaby2.introduce() # 输出: 大家好，我叫 锦奕，我是一个 男 宝宝。上面的类有个地方设计的不好，想想是什么地方？
\n性别，我们怎么可能可以自己设定和提前知道呢。（提前知道是违法的呢）有时候性别不知道，所以类初始化时 gender 应该是一个可选项。也就是：类需要支持用户不填性别可以正常使用。
\n这时，我们就需要设置默认值。不过这里设置默认值和函数设置默认值是一致的：
\n我们如果一开始设置了默认值，那么该参数后面的参数。都要设置默认值，否则会报错。
\nclass Baby:\n def __init__(self, name='小悦', gender='男'):\n print(f\"大家好，我叫 {name}，我是一个 {gender} 宝宝。\")\n\nbaby1 = Baby()运行后输出：
\n大家好，我叫 小悦，我是一个 男 宝宝。我们来试试前面设置默认值，后面不设默认值：
\nclass Baby:\n def __init__(self, name='小悦', gender):\n print(f\"大家好，我叫 {name}，我是一个 {gender} 宝宝。\")\n\nbaby1 = Baby('小明', '男') # 就算你实例化传入数据，也无济于事！运行后会报错：
\n File \"/Users/huangjiabao/bornforthis.cn/demo.py\", line 2\n def __init__(self, name='小悦', gender):\n ^^^^^^\nSyntaxError: non-default argument follows default argument如果一开始没有设置默认值，但是后续开始设置，那么后续设置的默认值都要一直设置。不能省略，否则会报错。
\nclass Baby:\n def __init__(self, name, gender=None, age=None, weight=None):\n self.name = name\n self.gender = gender\n self.age = age\n self.weight = weight\n\nbaby1 = Baby()运行后一切正常，不会有任何报错。如果此时把参数 age 之后的参数不设置默认值，则会报错：
\nclass Baby:\n def __init__(self, name, gender=None, age=None, weight):\n self.name = name\n self.gender = gender\n self.age = age\n self.weight = weight\n\nbaby1 = Baby()此时运行代码会直接报错：
\n File \"/Users/huangjiabao/bornforthis.cn/demo.py\", line 2\n def __init__(self, name, gender=None, age=None, weight):\n ^^^^^^\nSyntaxError: non-default argument follows default argument所以，我们最终的 Baby 类可以编写成这样就会比较合适。性别是可选的：
\nclass Baby:\n def __init__(self, name, gender=None):\n \"\"\"\n 初始化宝宝对象时，必须提供名字，\n 性别可以提前指定，也可以在宝宝出生时再确定。\n 这就像是大人提前为宝宝取好名字，并在必要时办理出生证明。\n \"\"\"\n self.name = name # 宝宝的名字，相当于出生证明中的名字\n self.gender = gender # 宝宝的性别，可能提前确定，也可能待定\n\n def introduce(self):\n \"\"\"\n 宝宝的自我介绍方法，展示初始化时设置的属性。\n 如果性别已知，则完整介绍；否则提示性别待定。\n \"\"\"\n if self.gender:\n print(f\"大家好，我叫 {self.name}，我是一个 {self.gender} 宝宝。\")\n else:\n print(f\"大家好，我叫 {self.name}，性别待定。\")\n\n# 模拟场景1：宝宝出生前，大人已经为他取好了名字和性别信息\nbaby1 = Baby(name=\"棠棠\", gender=\"女\")\nbaby1.introduce() # 输出: 大家好，我叫 棠棠，我是一个 女 宝宝。\n\n# 模拟场景2：宝宝出生前，大人已经为她取好了名字和性别信息\nbaby2 = Baby(name=\"锦奕\", gender=\"男\")\nbaby2.introduce() # 输出: 大家好，我叫 锦奕，我是一个 男 宝宝。\n\n# 模拟场景3：宝宝出生前，大人只取好了名字，性别待定\nbaby3 = Baby(name=\"宝宝\")\nbaby3.introduce() # 输出: 大家好，我叫 宝宝，性别待定。其实，在前面的代码中已经演示过了。不过我还是单独讲解一下，类的传入参数的三种原则。
\n全部不指定参数
\nbaby1 = Baby('小红', '女', 2, 7.8)全部指定参数
\nbaby1 = Baby(name='小红', gender='女', age=2, weight=7.8)部分指定参数，只能从前面不指定。后面一旦开始指定，后续都要指定。否则会报错，一起看看代码示例：
\nbaby1 = Baby('小红', '女', age=2, weight=7.8)如果 age 后面不继续指定就会报错：
\nbaby1 = Baby('小红', '女', age=2, 7.8) # 报错如下：SyntaxError: positional argument follows keyword argument最后，我来补充一个。我没讲不代表不存在或不支持，类实例化参数可以通过变量传递进去：
\nname = input(\"Enter your name: \")\ngender = input(\"Enter your gender: \")\nage = input(\"Enter your age: \")\nweight = float(input(\"Enter your weight: \"))\nbaby1 = Baby(name, gender, age, weight)\nbaby2 = Baby(name=name, gender=gender, age=age, weight=weight)对于类内部的函数设置参数和初始化函数（init）语法一致：要在 self 之后添加参数即可，代码如下：
对于类内部的函数，设置参数的语法和初始化函数 __init__ 是一致的：只需在 self 后面添加你需要的参数即可。下面是一个示例：
class Dog:\n def __init__(self, name):\n self.name = name\n\n def bark(self, times):\n print(f\"{self.name} 汪\" * times)\n\n# 创建一个 Dog 实例\nmy_dog = Dog(\"小黑\")\n\n# 调用类内部的函数并传入参数\nmy_dog.bark(3)运行结果：
\n小黑 汪小黑 汪小黑 汪在这个例子中：
\n__init__ 方法用于初始化对象，并接收一个参数 name。bark 是类中的另一个函数（也叫方法），它接受一个参数 times，用于指定狗叫的次数。__init__ 还是 bark，参数的定义方式都是：在 self 后面继续添加即可。我们可以对 bark 函数再添加一个参数 newline，一起来看看：
\nclass Dog:\n def __init__(self, name):\n self.name = name\n\n def bark(self, times, newline):\n for _ in range(times):\n if newline:\n print(f\"{self.name} 汪\")\n else:\n print(f\"{self.name} 汪\", end=\" \")\n\n# 创建一个 Dog 实例\nmy_dog = Dog(\"小黑\")\n\n# 调用 bark 函数，传入两个参数：叫3次，并每次换行\nprint(\"每次换行：\")\nmy_dog.bark(3, True)\n\n# 调用 bark 函数，传入两个参数：叫3次，但不换行\nprint(\"\\n不换行：\")\nmy_dog.bark(3, False)运行结果如下：
\n每次换行：\n小黑 汪\n小黑 汪\n小黑 汪\n\n不换行：\n小黑 汪 小黑 汪 小黑 汪如果想要更多参数，就以此类推即可。但是需要注意：如果设置了参数，在用户调用时，必须传入参数，否则会报错！除非设置默认值，接下来会讲。
\n其实类里面的函数设置默认参数，和基本函数设置是一样的。给参数设置默认值，这样在调用函数时可以选择性传入。设置默认值后，用户在调用函数时，可以选择性传入参数。
\nclass Dog:\n def __init__(self, name):\n self.name = name\n\n def bark(self, times=1, newline=True):\n for _ in range(times):\n if newline:\n print(f\"{self.name} 汪\")\n else:\n print(f\"{self.name} 汪\", end=\" \")\n\n# 默认参数调用\nprint(\"默认只叫一次，并换行：\")\nmy_dog = Dog(\"小白\")\nmy_dog.bark()\n\nprint(\"\\n叫两次但不换行：\")\nmy_dog.bark(2, False)类内部的函数（方法）可以定义多个参数，只需要按顺序写在 self 后面即可。
调用方法时，也要按顺序传入对应的值。
\n参数可以用来控制方法行为，使代码更灵活。
\n类内部可以设置默认值，使参数变成可选。
\n我们可以通过实例化对象，不仅仅可以快速查询对应的属性值。我们还可以通过此方法，修改属性值。我们一起来看看代码，下面的代码是常规的实例化调用：
\nclass Person:\n def __init__(self, name, gender=None, age=None, weight=None):\n self.name = name\n self.gender = gender\n self.age = age\n self.weight = weight\n\n def introduce(self):\n intro = f\"大家好，我叫 {self.name}。\"\n\n if self.gender:\n if self.gender == '男':\n intro += \" 我是一个男孩。\"\n else:\n intro += \" 我是一个女孩。\"\n else:\n intro += \" 我的性别暂时保密哦～\"\n\n if self.age:\n intro += f\" 我今年 {self.age} 岁了。\"\n else:\n intro += \" 我的年龄保密～\"\n\n if self.weight:\n intro += f\" 我的体重是 {self.weight} 千克。\"\n else:\n intro += \" 我的体重目前未知。\"\n\n print(intro)\n\n\nperson1 = Person(name='Bornforthis', gender='男', age=28, weight=75)\nperson1.introduce()运行后会输出：
\n大家好，我叫 Bornforthis。 我是一个男孩。 我今年 28 岁了。 我的体重是 75 千克。接下来，我们来通过实例化对象 person1 来读取内部属性值：
\nprint(person1.name, person1.gender, person1.age, person1.weight)运行后输出：
\nBornforthis 男 28 75我们接着通过实例化对象 person1 修改内部属性，并通过调用 introduce() 函数来输出验证：
class Person:\n def __init__(self, name, gender=None, age=None, weight=None):\n self.name = name\n self.gender = gender\n self.age = age\n self.weight = weight\n\n def introduce(self):\n #语法：
\ntuple.count(item)示例：
\nt = (1, 2, 2, 3, 2)\nprint(t.count(2)) # 输出: 3语法：
\ntuple.index(item[, start[, end]])示例：
\nt = ('a', 'b', 'c', 'b', 'd')\nprint(t.index('b')) # 输出: 1\nprint(t.index('b', 2)) # 输出: 3，从索引2开始查找语法：
\nlen(tuple)示例：
\nt = (1, 2, 3, 4)\nprint(len(t)) # 输出: 4语法：
\nmax(tuple)\nmin(tuple)示例：
\nt = (10, 20, 5, 15)\nprint(max(t)) # 输出: 20\nprint(min(t)) # 输出: 5语法：
\nsum(tuple[, start])示例：
\nt = (1, 2, 3, 4)\nprint(sum(t)) # 输出: 10\nprint(sum(t, 10)) # 输出: 20，从10开始累加语法：
\nsorted(tuple[, key][, reverse])示例：
\nt = (3, 1, 2)\nsorted_t = sorted(t)\nprint(sorted_t) # 输出: [1, 2, 3]\nprint(t) # 输出: (3, 1, 2)，原元组不变+）示例：
\nt1 = (1, 2)\nt2 = (3, 4)\nt3 = t1 + t2\nprint(t3) # 输出: (1, 2, 3, 4)*）示例：
\nt = (1, 2)\nprint(t * 3) # 输出: (1, 2, 1, 2, 1, 2)in 和 not in）示例：
\nt = ('apple', 'banana')\nprint('banana' in t) # True\nprint('orange' not in t) # True示例：
\nt = (0, 1, 2, 3, 4)\nprint(t[1:4]) # (1, 2, 3)\nprint(t[::-1]) # (4, 3, 2, 1, 0)示例：
\nt = (10, 20, 30)\na, b, c = t\nprint(a, b, c) # 10 20 30示例：
\nt = (1, (2, 3), 4)\nprint(t[1][0]) # 2示例：
\nt1 = (0, False, '')\nt2 = (0, True, '')\nprint(any(t1)) # False\nprint(any(t2)) # True\nprint(all((1, 2, 3))) # True\nprint(all((1, 0, 3))) # False示例：
\nlst = [1, 2, 3]\nt = tuple(lst)\nprint(t) # (1, 2, 3)示例：
\nt = (1, 2, 3)\nlst = list(t)\nlst.append(4)\nt = tuple(lst)\nprint(t) # (1, 2, 3, 4)| 序号 | 内置函数名称或操作 | 功能说明 | 使用代码示例 |
\n|
y = x 所存在的问题，是真的备份吗？阅读下面的代码，思考下面两个问题：
\n注意： 下面的代码我是有意写这么长的字符串，有两个目的：
\nx = ['毒药', '感冒药', '解药']\ny = x\nprint(f'Original:\\n\\tx: {x}\\n\\ty: {y}\\n\\tid_x: {id(x)}\\tid_y: {id(y)}') # id() 用来获取变量的物理地址\ny[0] = '消炎药'\nprint(f'After:\\n\\tx: {x}\\n\\ty: {y}\\n\\tid_x: {id(x)}\\tid_y: {id(y)}')阅读到此，想必你有了你自己的思考。我们现在来看看，我对于上面两个问题的回答。
\n从代码 y = x 可知，开发者想要复制一个 x 列表的副本给变量 y 并且想要修改列表 y 时不影响原列表 x。换句话说，y 应该是 x 的一个独立备份。
为什么我们会有这种需求？让我们结合现实场景来思考。
\n假设你有一个包含 100万条数据的 Excel 文件，为下载这个数据文件获取这个文件的代价极高：
注意：这里我是特意这么夸张，请不要想其它的。我只是为了让你尽可能感觉到这个数据是多么昂贵的，并且获取这个数据所要付出的代价是巨大的，因为只有昂贵才会重视，便于我塑造情景。
\n这里再次强调：如果再下载一次还是需要 1000元、下载耗费3个小时、并且还是只能下载一次。此时你要操作这个拥有 100万数据且下载成本极高的 Excel 会怎么操作？
\n阅读到此时，请停顿一下。思考一下，在这种情况下，你会怎么做？
\n毫无疑问，肯定是在操作前做一个备份，以便在操作时：如果不小心手贱按错按键，或者破电脑突然卡住导致你操作的数据没有及时保存或关闭等情况，导致数据缺失或损坏。此时就需要使用备份文件来恢复，这样就避免重新获取数据而产生的高额代价。所以在上面的代码中也是这样的意图，列表 x 作为备份数据，以确保对 y 的修改不会影响到原始数据 x，以此保证原数据不被影响。
\n对于问题2请先观察下面的代码实际输出，看看输出结果中存在什么问题和特点？
\n注意：观察下面的代码时你要具备一个原则：有时候，不要只看局部。站的高点，站的远点，使我们有全局视角，这样往往更便于我们发现事物中所存在的关联关系或规律。
\n意思就是：你在观察下面的输出结果时，不要单纯的一行一行看，或者看完下一行忘记上一行。要把自己从中抽离出来，看整个输出。去及时的观察和对比，这样才能发现其中的规律或者存在的问题。
\nOriginal:\n\tx: ['毒药', '感冒药', '解药']\n\ty: ['毒药', '感冒药', '解药']\n\tid_x: 4470743680\tid_y:4470743680\nAfter:\n\tx: ['消炎药', '感冒药', '解药']\n\ty: ['消炎药', '感冒药', '解药']\n\tid_x: 4470743680\tid_y:4470743680我们会发现，当我们修改 y 列表中的第一个元素后，x 列表的内容也发生了变化，这显然不符合我们的预期。理论上，我们的目标是 仅修改 y，不影响 x，但结果表明 x 和 y 竟然是同一个列表！
\n为什么会产生这个问题情况呢？我们可以从 id() 函数的输出中找到答案。
从上面的输出结果可知：列表 x 和列表 y 的物理地址是相同的，意味着虽然做了备份（y = x），但没想到列表 x 和 y 是指向同一个列表，故而导致修改列表 y 时，列表 x 的数据也被修改。与我们原本的意图（备份）事与愿违，并且产生了“巨大”代价！明显我们的代码不符合预期。
从上面的分析后，我们可知 y = x 只是进行了列表地址的赋值（类似引用），x、y 实际上指向的是同一个列表。可以理解成两个列表元素一样，Python 就偷懒不再创建一个新的相同列表，直接创建一个地址引用。
为了更直观地理解这个问题，我们可以借助一个现实生活中的类比：
\nPython 在 y = x 赋值时的行为类似于百度网盘的“创建链接”机制：并没有真正复制列表，而只是让 y 指向了 x，所以 x 和 y 变成了 同一个对象的两个引用。
上面分析了一下，接下来我来给你归整归整。我们说列表 x 和列表 y 指向的是同一个变量，我们口说无凭，来看看下面的凭证：
\n证明一：Python id() 用来检查变量物理地址（也就是在计算机中，所在的位置）并结合上面的代码结果可知：x、y 指向的是同一个列表，因为 id 相同。（id_x: 4470743680、id_y:4470743680）
证明二：可以直接使用可视化：https://pythontutor.bornforthis.cn/visualize.html#mode=edit查看，毕竟一图胜千言。在可视化界面中（下图），你会发现 x 和 y 其实是 同一个列表对象的两个名称，本质上它们没有区别。因此，修改 y 也会影响 x，这就是问题的根本原因。
有时候，不要只看局部。站的高点，站的远点，使我们有全局视角，这样往往更便于我们发现事物中所存在的关联关系或规律。——AI悦创 2024-01-01 23:17:10
\n既然 y = x 不能满足我们“创建副本”的需求，那么 如何正确地复制一个列表，而不影响原列表呢？
别担心，我们接下来就会深入探讨 Python 中的深拷贝与浅拷贝，以及 如何避免此类问题。
\ncopy() 进行浅拷贝在前面的内容中，我们发现 直接赋值 y = x 并不会创建一个新的列表，而只是让 y 指向 x，导致修改 y 的同时 x 也会被修改。这显然不符合我们的备份需求。
那么，如何正确创建一个新的副本，确保 y 和 x 互不影响呢？为了解决这个问题，我们可以使用列表自带的 copy() 方法，这会创建一个“浅拷贝”（shallow copy），从而获得一个独立的对象副本。
让我们看看使用 copy() 进行列表复制的效果：
x = ['毒药', '感冒药', '解药']\ny = x.copy()\nprint(f'Original:\\n\\tx: {x}\\n\\ty: {y}\\n\\tid_x: {id(x)}\\tid_y:{id(y)}') # id 用来获取变量的物理地址\ny[0] = '消炎药'\nprint(f'After:\\n\\tx: {x}\\n\\ty: {y}\\n\\tid_x: {id(x)}\\tid_y:{id(y)}')代码输出如下：
\nOriginal:\n\tx: ['毒药', '感冒药', '解药']\n\ty: ['毒药', '感冒药', '解药']\n\tid_x: 4428223616\tid_y:4428537536\nAfter:\n\tx: ['毒药', '感冒药', '解药']\n\ty: ['消炎药', '感冒药', '解药']\n\tid_x: 4428223616\tid_y:4428537536从输出结果来看，我们可以发现两个重要的现象：
\nid_x 和 id_y 变了：初始状态下，x 和 y 的内容完全相同，但物理地址（id_x 和 id_y）已经 不再相同，这表示 copy() 方法为 y 创建了一个全新的列表对象。y 和 x 现在是两个独立的对象，互不影响。y 后，x 没有被影响：之前 y = x 时，修改 y[0] 为 '消炎药' 时会影响 x[0]，但现在 y 已经是 x 的一个独立副本，因此修改 y 不会影响 x，这正是我们想要的备份效果。copy() 方法在 Python 中执行的是 浅拷贝（Shallow Copy）。它的本质是 创建一个新的列表对象，并将原列表中的元素引用复制到新列表中。简单来说：
copy() 复制了列表本身，即创建了一个新的 y。y 里的元素仍然指向 x 里的同样的元素。如果列表中包含可变的嵌套对象（如列表里还有列表、元组、字典等），这些 子对象依旧是原来对象的引用。也就是说，对同一层级的数据做了拷贝，但 更深层次 的数据结构还会被引用到原对象。.copy() 当作和“深拷贝”一样使用，但是前提是：列表的元素都是字符串、数字型、布尔型等不可变数据类型，并没有深层的嵌套结构，自然也就不会出现意料之外的相互影响。这可能有点绕，我们可以用下面的图示帮助理解：
\n原列表 x:\nx前面我们本地化部署了 ChatGLM3-6B，对于大模型有了进一步的了解。
\n目前我们接触的无论是千亿大模型，如 130B、ChatGPT，还是小规模的大模型，如 6B、LLaMA2，都是通用大模型，就是说通过通用常识进行预训练的，如果我们在实际使用过程中，需要大模型具备某一特定领域知识的能力，我们就需要对大模型进行能力增强，具体如何做呢？
\n微调只是众多优化大模型能力的方法之一，除此之外，还有其他方式，比如接入外挂知识库，或者借助 Agent 调用外部 API 数据源。下面我们来具体看看这些方法的不同之处。
\n微调指的是在已有预训练模型的基础上，通过特定任务的数据再次训练，使模型更好地适应特定场景。这种方式相对成本较低，模型能够从训练数据中学习特定领域的表达和逻辑，具备一定的语义理解能力。
\n知识库通过构建向量数据库或其他结构化数据源，为大模型提供一个额外的信息查找渠道，充当“外挂记忆”。
\nAPI 接入与知识库类似，也是为模型提供实时信息的外部接口，能够扩展模型的知识边界。
\n可以这样理解：微调就像是给大模型上了一门新课程，并让它在答题时进行闭卷考试；而知识库和 API 则更像是给模型准备好了教材和工具书，考试时可以随查随用。几种方式并不冲突，我们完全可以将它们结合使用，以提升模型的输出质量和任务处理能力。下面我们就来简要对比这些方式的优劣势。
\n| 方法 | 优点 👍 | 缺点 👎 |
\n|
提示
\n长期维护更新，随时评论留言！
\n百度网盘下载地址：https://pan.baidu.com/s/1tE6dqpvMxCq88N_aOBlRqA?pwd=aiyc
\n通过网盘分享的文件：出版书籍资源\n链接: https://pan.baidu.com/s/1tE6dqpvMxCq88N_aOBlRqA?pwd=aiyc 提取码: aiyc视频安装教程：自己选择对应的系统安装，这部分视频安装还是比文字版好
\n关于其它的问题，评论区留言即可。
\n", "date_published": "2025-04-29T11:57:04.000Z", "date_modified": "2025-05-11T03:27:57.000Z", "authors": [ { "name": "AI悦创" } ], "tags": [] }, { "title": "01-🍖烧烤系列", "url": "https://bornforthis.cn/column/cookdinner/P04-%E7%83%A7%E7%83%A4%E7%B1%BB/01-%E7%83%A7%E7%83%A4%E7%B3%BB%E5%88%97.html", "id": "https://bornforthis.cn/column/cookdinner/P04-%E7%83%A7%E7%83%A4%E7%B1%BB/01-%E7%83%A7%E7%83%A4%E7%B3%BB%E5%88%97.html", "summary": "1. 小林哥 烤肉，蒜不嫌多！ 食材准备：葱、姜、蒜、洋葱丝、五花肉、牛肉。 2. 夏叔", "content_html": "烤肉，蒜不嫌多！
\n食材准备：葱、姜、蒜、洋葱丝、五花肉、牛肉。
\n\nIn this portion of the project, you will be building a visual view of your game, and also start building the computer strategies for playing the game. This assignment has several parts. Look over the outline on the left, and skim through the whole assignment, before diving deeply into any one section. The assignment lists requirements in the recommended order you should do them, but future tasks might give you ideas for how to improve earlier ones.
\nAs we discussed in class, views should not have the ability to mutate the models they are viewing: this would bypass the controller, making it impossible to reliably control the model.
\nRefactor your model interface, if necessary, into two interfaces: your PawnsBoardModel interface (or whatever you named it) should now extend a ReadonlyPawnsBoardModel interface (again, choose a name that matches your existing model). The read-only interface should contain all the observation methods of your model, while the mutable sub-interface should contain all the mutator methods.
The following is a non-exhaustive checklist of functionality that is necessary for Pawns Board to work properly. Your model interface(s) may not yet expose all of these as methods, or might not make it easy to use.
\nReexamine the design and implementation of your model from the previous assignment, and improve it to include the functionality above. Document whatever changes you made in a new section of your README, entitled “Changes for part 2” — explain what functionality was missing, and why, and how you chose to add it.
\nTo implement your view, you will need to use Java Swing. (You are not permitted to use the javalib library we used in Fundies 2, as it conflates the notions of model, view and controller into a single World class. You are also not permitted to use JavaFX, as that has been deprecated and is overly complicated as well.) The code provided with the MVC code and the Turtles activity from class give you a basic beginning using Swing, as well as the exercises in Lab 7.
You have also been provided with an extensive list of different Swing layouts, components, and their uses in the code linked at the start of the assignment. If you need a more visual way of seeing Swing things done, here is a video covering a lot of basic Java Swing components and listeners. Note that if you try to write your code in the way shown in the video or in the way shown in the given code above, you will not do well on the assignment. The video does not follow our design rules nor style rules nor separates code properly into the three components. The code given has no helpers at all nor follows any of our design considerations.
\nGraphics class, and you may need to explicitly cast Graphics objects to Graphics2D objects. Also look at the “transform” methods available in the Graphics2D class to use the rendering canvas appropriately.Panels and Frames.getMinimumSize, getPreferredSize and getMaximumSize. Of these, the most common to override is getPreferredSize.You will likely need to design at least one, and possibly three, interfaces for your view: one should describe what the frame ought to be capable of, and one for each panel might be needed to describe what the panel ought to be capable of. (These may be empty interfaces for now, if you do not see a need for any methods in them yet...but keep reading below for additional ideas.) Note that your textual rendering from the previous assignment does not have to implement this new GUI view interface, and you do not have to force it to do so.
\nYour view should give as much information as the screenshots below, but the physical appearance is up to you. Consider the following screenshot which shows the start of the game. Notice we can see the board and the pawns on each, row-scores, and the hand of the Red player.
\nHere is a view of the game mid-game, also on Red’s turn:
\nHere is a view of the same game mid-game, but on Blue’s turn. Notice that Blue’s cards have their influence grid already mirrored.
\nAnd reminder that the game can be more than 3 rows with 5 columns. Here is an example with 7 rows and 11 columns with a starting hand size of 10 cards, totaling 77 cells PLUS the 11 cards that must be displayed at once (remember the red player draws one card at the start of their turn).
\nYou may decorate the image if you wish, or adjust the color palette, or even change the font, or change how the cards themselves are displayed, but it should still contain the same information as the above. That means a user can easily identify the following:
\nHere is an example of an alternative view that shows the same information without the same level of polish as the above.
\nYou will notice the following
\nThe point is your view doesn’t need to be exactly the same as the fancier one and do as much drawing. You can get away with drawing much, much less and then add the polishing features as you please.
\nLooking through the documentation of the Graphics2D class, you’ll find several useful methods for drawing text, lines, ovals, images, and shapes; and for transforming the coordinate system (scaling, translating and rotating) to affect where drawings are placed. We recommend building a subclass of Path2D.Double that represents “a card” of whatever size makes sense in your view. You can then draw multiple such cards wherever needed to make up your rendering: this will be much easier than attempting to draw all the individual edges of the cards separately.
The size of drawn strings is controlled by the size of the font used in the Graphics2D object. I suggest reading up on the Font class to find methods to help change the font size to whatever works best as you resize the window. Furthermore, you cannot print newlines with drawString. Instead, take a look at this Stack Overflow question on how to visualize a newline.
Your view should have a constructor that takes in a ReadonlyPawnsBoardModel — not the mutable interface! — to ensure that your view is incapable of modifying the model even accidentally.
In preparation for the next assignment (where you will build a controller that delegates to the model and view), you should equip your view with the ability to handle mouse clicks and key presses. This means you will need a stub controller to stand in for the real thing and respond to the events. In particular,
\na user should be able to click on a card in the hand, and it should highlight that card somehow. In the image below, the highlight is indicated by changing the card to cyan. You may choose another way of highlighting if you wish so long as it is obvious it is selected.
\nSystem.out) containing the index of the card that was clicked on as well as which player owns that hand.a user should be able to click on a cell in the grid, and it should highlight that cell somehow. In the image below, the highlight is indicated by changing the cell background to cyan. You may choose another way of highlighting if you wish so long as it is obvious it is selected.
\nSystem.out) containing the coordinates of the cell that was clicked on, in whatever coordinate system you used in your model. Note: this is not the same thing as the physical mouse coordinates of the mouse event!a user should be able to indicate they want to confirm their move or pass by handling keyboard input. You may choose what keyboard interactions correspond to confirming or passing, but be sure to document them in you README.
\nAdditionally, the stub controller should print a message (using System.out) printing whether the key press indicated a confirmation or a pass.
Your view should let the user deselect a selected card in hand or cell on the board by
\nClicking outside the boundary of the grid or the hand must not cause your view to crash, throw an exception, or otherwise break.
\nYou may want to revisit the discussion of the observer pattern from Lecture 14: The Observer Pattern, and this may influence your view interface designs. This will also help you plan out your true controller ahead of the next assignment.
\nFinally, we should be able to resize your window larger and smaller and all of the above functionality should still work correctly. Note you are not responsible for the visual artifacting (read: anything that looks weird) that can occur at extremely small or large sizes.
\nAdd the following placeholder class to your project:
\npackage cs3500.pawnsboard;\n\npublic final class PawnsBoardGame {\n public static void main(String[] args) {\n YourModel model = ...create an example model...\n YourView view = new YourView(model);\n ...whatever other setup you need...\n view.setVisible(true); //or the equivalent in your system\n }\n}As we’ve done several times, our main() method simply instantiates a model, instantiates a view using that model, instantiates anything else needed, and tells the view to get started. In later assignments we will augment this to create controllers, players, and make the game playable.
Testing views can be quite tricky, since you cannot simply use JUnit assertions to check them for “equality”. For this assignment, you do not need to unit-test your visual view, but you should include in your submission at least four screenshots of your view, each screenshot being of a 5 row and 7 column game:
\nName the screenshots appropriately, so you and graders can easily tell what they represent. Also, make sure the screenshots are reasonably sized (e.g 600 px height is the height used for the screenshots on this page). There is no reason to have a 4K png of your view.
\nPlaying Pawns Board for any amount of time quickly leads to noticing two aspects of the strategies required for key play: which card to choose and then where to place the card.
\n(There are far more sophisticated strategies than these, but these will do for now!)
\nImplement the first two of these strategies. Note that those two strategies cannot have tied choices. If there are no valid moves, your player should pass.
\nHint: Keep in mind that a strategy needs to know which player it’s trying to pick a move for!
\nYou must test these strategies, and in particular demonstrate that it resolves ties correctly.
\nHint: You may have an easier time implementing your strategies if you generalize their signature somewhat: Unlike the Tic Tac Toe strategies, where moves didn’t have a numerical value, moves here do have a potential score. The possibility of ties in some strategies implies that your strategy’s signature should return more than just a single move possibility...
\nAs we discussed with Tic Tac Toe, you can chain these strategies to form strategies of varying sophistication. A simplistic strategy would just use option 1; a smarter strategy might stack on options 2 and 3, as well to further break ties in option 1. Some of these strategies may result in multiple, equally-good options: in case of such ties, again choose the move with the uppermost-leftmost location first and then the leftmost card in the hand.
\nSome of these strategies may result in no valid moves: you must figure out how to represent such situations and what they should (eventually) do in the model.
\nYour task to get extra credit:
\nHybridMergeSorter from class.)In your README, explain what the extra credit strategies you implemented were and where we can find their implementations and tests. If your README does not state this, you will get no extra credit.
\n Testing your strategiesThe elegant feature of strategies is that they are simply function objects, and so they are eminently testable. Build a collection of example games in known configurations, ask each strategy where it would choose to move for a given player, and check that the result is as expected.
\nIf you’ve implemented multiple strategies, test them thoroughly: in particular, make sure you test scenarios that demonstrate the differences between them.
\nOne of the challenges of testing your strategies is that they depend on your model working correctly: the model needs to implement the complicated game logic of legality checking and scoring, and if those are buggy, your strategies may give unexpected results. But obviously, you can’t execute a strategy without some model object to examine!
\nIn class we discussed mocks, that are stub implementations of interfaces that can give simulated answers and that can record a transcript of what methods were used. Here are two ideas for mocking your model; you should use these (and probably several more) to test your strategies:
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n上一节课，我们通过一个企业内部小助手的案例，学习了 6B 的微调过程。其中，除了微调，还有一种模式就是知识库，用来增强大模型信息检索的能力，我们称之为检索增强生成（RAG），这是目前非常流行的一种做法，知识库模式相比于微调有 2 个好处。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n汆煮：鲜鸡爪2千克，盐10克，花雕酒50克，葱姜各20克，香叶2克，白胡椒粒2克，陈皮2克
\n料汁：蒜蓉100克，盐7克，白糖40克，蚝油50克，生抽100克，松茸调味料10克，雪碧750克，百香果2个，柠檬2个，小米辣35克，辣椒油80克，苹果醋30克
\n小火慢开（冷水下锅）——>加入：盐巴、花雕酒、葱、姜、香叶、白胡椒粉、陈皮
\n出锅放入冰块水中——> 去皮
\n柠檬酱汁：
\n柠檬的最外层表皮，它的苦味最足，用刀刮掉！
\n腌制 2h
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n铸铁锅务必要开锅哦（珐琅锅请参考珐琅锅的开锅及保养），具体步骤如下：
\n使用后保养方法：
\n烹饪完食物，温热水清洗；
\n\n\n尽量不用洗洁精，洗洁精会把刚刚被锅吸收的油脂洗出来。
\n
在炉上烤干水汽，避免生锈；
\n锅烤干后在内壁涂上薄薄一层食用油小火加热烧下锅，使食用油沁入锅内进行养护
\n\n\n这一步骤建议前期多进行几次，以后间隔时间可以长一些；
\n
关火、自然冷却，放置干燥处存放即可；
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n| 鸡蛋 | 绿辣椒 | 小米椒 | 大蒜 | 玉米淀粉 |
\n|
| 五花肉 | 蒜苗（有的地方叫青蒜） | 红椒 | 葱姜蒜 | 郫县豆瓣酱（川菜之魂） | 豆豉 | 甜面酱 |
\n|
你好，我是悦创。
\n这节课我们好好讲讲提示工程，也就是我们常说的 Prompt Engineering。这一节课的内容非常关键，可以这么说，能否充分使用好 AI 大模型，提示是关键，所以现在已经有一种新的职业诞生，就是提示工程师。
\n目前国内已经有不少公司在招聘提示工程师，薪水接近软件开发工程师的水平，达到 20 万～30 万人民币，国外有的高级提示工程师，薪水已经超越软件开发工程师水平，达到了惊人的 30 万美金以上，要知道 Google 软件开发工程师的平均年薪也就 20 万美金左右。为什么会出现这样的现象？到底什么是提示工程？想了解这个问题，我们先来聊聊什么是提示。
\n这里你可能会有一些疑问，因为一般在使用大模型产品的时候，我们都是向大模型“提问”，大模型给出“答案”，这个过程也没有看到提示啊？其实不然，如果阅读过 OpenAI 官方使用文档，你就会发现，在官方文档里，你是看不到 question 和 answer 这两个词的，我们能看到的是 prompt 和 completion，翻译过来就是提示和补全，也就是说，我们向大模型提出的问题，其实是给大模型一个提示，让它进行补全，补全的内容就是大模型给我们输出的答案。
\n看到这里，你可能又想问了，为什么是提示和补全，而不是提问和答案呢？这就要从大模型训练的原理出发去理解了。上节课我们讲过，GPT 系列模型是基于 Transformer 架构的解码器机制，使用自回归无监督方式进行预训练的。这个训练过程简单来说就是大量的文本输入，不断进行记忆的过程，相比监督学习，效率会更低，但是训练过程简单，可以喂大量的文本语料，上限比较高。
\n而我们在使用大模型的时候，先给出提示，大模型会根据提示，来推测补全内容。实际上是根据训练过的“记忆”，一个字一个字地计算概率，取概率最大的那个字进行输出，所以不少人吐槽大模型输出很慢。的确，它是一个字一个字地计算并输出，效率肯定会比较低。
\n光从使用角度看，提示还是比较容易理解的，那什么是提示工程呢？
\n用过 ChatGPT 的人，心态一般是这样的：
\n\n\n第一天：哇！这个东西好牛啊，还懂人性，回答不对还道歉，太牛了！
\n第二天：哎？好像也没啥啊，回答的内容也就那样，看似长篇大论，实则没有新意，感觉也解决不了太多实际问题。
\n
我见过身边很多人都是这样的，那这里我就要问一下你了，你的提示长什么样？可否回想一下，你的提示是不是这样的？
\n就拿【提示一】来说，试想一下，你有一个秘书小李，想让他帮忙做个 PPT，你们的对话一般来说应该是这样的：
\n👨🏫：小李，请帮我写一个 PPT。
\n👦：老板，您的 PPT 需要什么内容，用来做什么？
\n👨🏫：我明天去拜访客户，向客户展示我们的新产品。
\n👦：那您需要简要介绍还是详细介绍？除了产品还需要放其他内容吗？
\n👨🏫：简要介绍即可，除了产品介绍，再放一些客户案例。
\n👦：好的，老板，您需要什么风格的 PPT 呢？
\n👨🏫：有科技感一点的。
\n👦：好的，老板。
\n正常来说，你是需要向小李详细描述你的 PPT 内容的，这样小李才能尽可能准确地制作符合你要求的 PPT，其实上面的对话还不够详细，不出预料，当小李把初稿发给你后，你还会提出一些建议，再次进行修改，有时甚至会修改多轮。
\n如果把大模型当作秘书小李的话，那我们给他的提示就不应该是简单的一句话了，而是尽可能地将需求描述清楚，需求描述越详细越准确，大模型输出的内容越符合你的要求。所以说好的提示，包含很多信息，这些信息帮助你和大模型相互了解，所以它是复杂的、规范的，类似于人与人相处，要相互了解才能合作愉快、高效。
\n所以提示工程是一门专门研究和大语言模型交互的新型学科，通过不断地开发和优化，帮助用户更好地了解大型语言模型的能力和局限性。换句话说，提示工程（Prompt Engineering）就是探讨如何设计出最佳提示，用于指导语言模型帮助我们高效完成某项任务。
\n提示工程不仅仅是设计和研发提示，它还包含了与大语言模型交互的各种技能和技术。提示工程在实现和大语言模型交互、对接，以及理解大语言模型能力方面都起着重要作用。用户可以通过提示工程来提高大语言模型的安全性，也可以赋能大语言模型，比如借助专业领域知识和外部工具来增强大语言模型的能力。
\n换个角度，如果 AI 大模型是你的员工，他能否表现优秀，除了他本身的潜质外，还需要你能够领导好他，也就是我们常说的领导力，在这里叫做 AI 领导力。
\n做过管理的人都知道，领导力是一个管理者非常重要的素质。在现在这种情况下，AI 大模型其实就是我们的虚拟员工，而且是一个智力高，知识储备量巨大的员工，能否让他有高质量的产出，就是看你怎么带他，怎么领导他。
\n那么我就要问了，你确认你能领导一个智商超过 140，大脑几乎掌握了全世界大部分公开知识的员工？一般人我估计不敢轻易给出肯定的答案。但是也不要被吓住，我们需要做的就是提升自身的 AI 领导力。提示是我们和 AI 大模型沟通的唯一桥梁，只有熟练掌握提示技巧，才能进一步提升领导力，进而让你轻松驾驭 AI 大模型。
\n获取好的输出结果有几种方式，一种就是不断和模型交互，比如输入很简单，但是通过多轮问答，不断地对输出进行调整；第二种就是一次性尽可能地将输入写好，我更推荐第二种，这样模型就不需要去理解上下文了，一般来说，好的提示可以通过下面这个公式去构造。
\n各部分的重要性顺序如下：
\n一个好的提示不一定要包含所有模块，但是最好要包含任务和上下文。无论如何，都要尽可能详细地进行描述。
\n这几个模块整体来说是比较易懂的，我简单为你解释下。比如我正在写用户登录模块，打算让大模型为我生成相关的示例代码，我们可以这么写：
\n\n\n你是一个软件开发工程师，请使用 Java 语言，写一个登录的模块，生成相关代码。
\n
我们为模型指定了角色：软件开发工程师，并指定使用 Java 写一个登录模块。以下是 ChatGPT3.5 返回的结果。
\nimport java.util.HashMap;\nimport java.util.Map;\nimport java.util.Scanner;\n\npublic class LoginModule {\n private Map<String, String> userDatabase;\n\n public LoginModule() {\n // 初始化用户数据库，实际应用中通常会连接到数据库\n userDatabase = new HashMap<>();\n userDatabase.put(\"user1\", \"password1\");\n userDatabase.put(\"user2\", \"password2\");\n // 添加更多用户...\n }\n\n public boolean authenticateUser(String username, String password) {\n // 在实际应用中，这里通常会连接到数据库，验证用户名和密码是否匹配\n String storedPassword = userDatabase.get(username);\n return storedPassword != null && storedPassword.equals(password);\n }\n\n public static void main(String[] args) {\n LoginModule loginModule = new LoginModule();\n Scanner scanner = new Scanner(System.in);\n\n System.out.print(\"请输入用户名: \");\n String username = scanner.nextLine();\n\n System.out.print(\"请输入密码: \");\n String password = scanner.nextLine();\n\n if (loginModule.authenticateUser(username, password)) {\n System.out.println(\"登录成功！\");\n } else {\n System.out.println(\"登录失败，用户名或密码错误！\");\n }\n\n scanner.close();\n }\n}可以看出来，并不是我们想要的代码，因为一般情况下我们需要的是 Web 页面登录，而上述结果是一个控制台程序，所以我们接着修改提示。
\n\n\n你是一个软件开发工程师，请使用 Java 语言，写一个 Web 登录的模块，请使用 SpringBoot 框架，前端使用 ReactJS 语言，要求密码使用 MD5 加密。第一步：用户在页面输入用户名和密码，点击登录。第二步：服务端接口收到请求，对参数进行非空验证。第三步：通过数据库查询用户名和密码进行验证。请生成相关代码。
\n
这一次我们不仅指定了角色，还为任务指定了生成步骤，当然模型输出的内容也更加详细了。
\nimport org.springframework.web.bind.annotation.PostMapping;\nimport org.springframework.web.bind.annotation.RequestBody;\nimport org.springframework.web.bind.annotation.RequestMapping;\nimport org.springframework.web.bind.annotation.RestController;\n\n@RestController\n@RequestMapping(\"/api\")\npublic class UserController {\n\n @PostMapping(\"/login\")\n public String login(@RequestBody UserLoginRequest request) {\n // 第二步：非空验证\n if (request.getUsername() == null || request.getPassword() == null) {\n return \"用户名和密码不能为空\";\n }\n\n // 第三步：数据库验证\n if (isValidUser(request.getUsername(), request.getPassword())) {\n return \"登录成功\";\n } else {\n return \"用户名或密码错误\";\n }\n }\n\n private boolean isValidUser(String username, String password) {\n // 这里应该调用数据库查询用户信息的方法，进行用户名和密码的验证\n // 在实际项目中，不应该将密码存储为明文，而是使用哈希算法进行存储和比对\n // 这里仅为演示，实际中应该使用更安全的方式\n return \"admin\".equals(username) && \"21232f297a57a5a743894a0e4a801fc3\".equals(md5(password));\n }\n\n private String md5(String input) {\n // 这里是一个简单的MD5加密示例，实际项目中应该使用更安全的加密方式\n // 注意：MD5不是安全的加密算法，仅作为演示使用\n // 实际项目中应该使用更安全的哈希算法，如BCrypt\n // 可以使用Spring Security等库来进行密码的安全处理\n return org.apache.commons.codec.digest.DigestUtils.md5Hex(input);\n }\n}加入了 UserController，定义了 RESTful 接口，但是数据库连接部分还是通过注释提示的，没有生成出来，我们可以继续优化提示。
\n\n\n你是一个软件开发工程师。请生成一个 Web 用户登录模块。前端使用 ReactJS+CSS+HTML 进行页面布局和发起 HTTP 请求。后端请使用 Java+SpringBoot+MyBatis 框架，使用 Maven 进行依赖包管理。要求密码使用 MD5 加密，并将具体的数据库连接代码生成出来。请按照以下步骤生成代码。第一步：用户在页面输入用户名和密码，点击登录。第二步：前端发起 HTTP 请求，服务端接口收到请求，对参数进行非空验证。第三步：通过数据库查询用户名和密码进行验证。请生成相关代码。
\n
当我们这样提问后，基本该有的代码都有了，数据库连接也加上了，前端页面的代码也补上了。这是一个简单的示例，需要注意的是，不同的大模型实现机制以及配置不同，你需要通过不断调试，找到合适的方式和大模型进行沟通交互，最终构建最合适的提示。
\n下面我给你展示一个非常强大的功能——生成提示的提示，让 ChatGPT 为你生成你需要的提示。
\n你在 ChatGPT 中输入以下内容：
\n我想让你成为我的提示工程师。你的目标是帮助我为我的需求制作尽可能好的提示。提示将由你使用。你需要遵循以下流程：
\n将这段提示输入 ChatGPT，ChatGPT 会一步一步询问我们是否需要补充，直到我们回复【我们完成】才结束对话。你可以试试，功能很强大。这里我举一个例子，我们一起看一下。
\n这个工具的厉害之处在于，只要我们不喊停，它就会一直问，可以把提示调整得非常完善，这一步后，我就主动叫停了。
\n最后生成的提示如下：
\n主题： 为初学者设计的6个月增肌30%、减脂20%计划，结合高蛋白饮食和哑铃力量训练。\n内容： 专为无力量训练基础、喜欢高蛋白饮食和有氧运动的个体制定的健身计划。此计划强调使用哑铃进行力量训练，以适应新手的学习曲线，同时促进肌肉增长和脂肪燃烧。每周三次的训练将包括有氧运动和哑铃训练，逐步提高难度以适应身体变化。计划还建议寻找现场教练指导，以确保动作的正确性和安全性，同时使用蛋白粉补充营养，支持恢复和肌肉生长。近一年人工智能发展速度非常快，我个人预测很有可能在五年内颠覆软件开发行业。为什么这么讲？因为软件开发的目的是实现用户和计算机的交互，而大模型的到来，已经改变了人类和计算机的交互形式，未来我们可能不再需要写代码，而是需要学会写提示，也就是从软件开发工程师向提示工程师转变。我们今天用的代码仓库，几年后可能就变成提示仓库了。
\n现在我们软件开发工程师的工作流程，和五年后我们作为提示工程师的工作流程，会有怎样的区别呢？你可以对比一下。
\n这节课我们从与大模型交互方面入手，学习了提示及提示工程，提示是我们与大模型沟通的唯一桥梁，是决定大模型能否高效产出的关键。当然，使用的大模型不同，提示效果可能完全不同，这和我们人与人之间交往一样，不同的人有不同的性格，同一句话有人爱听有人不爱听。所以，和大模型“交往”也需要慢慢摸底，摸清楚对方的习惯和能力。
\n请你思考一下，我们为什么要为大模型指定角色呢？欢迎你把你思考后的结果分享到评论区，也欢迎你把这节课的内容分享给其他朋友，我们下节课再见！
\n\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n2022 年 11 月底，OpenAI 发布了 ChatGPT，2023 年 1 月注册用户超过一亿，成为历史上增长最快的应用，上一个纪录保持者是 TikTok，注册用户超过一亿用时 9 个月。2023 年 3 月开始，ChatGPT 燃爆中国互联网界。
\n实际上国内外同一时期搞大模型的团队很多，为什么 ChatGPT 会突然火起来？还有在 ChatGPT 发布后，为什么各个大厂在短时间内相继发布大模型产品？比如 3 月百度发布文心一言，4 月阿里云发布通义千问，5 月科大讯飞发布星火认知大模型等等。
\n我们最容易想到的原因是，OpenAI 在自然语言处理（NLP）方面取得了突破性的进展，这是技术层面看到的。实际上，ChatGPT 背后包含了一系列的资源整合，包括技术、资金、大厂背书等等，以及多个国际巨头的通力合作，比如 OpenAI、微软、NVIDIA、GitHub 等。所以说，ChatGPT 不仅仅是技术上的突破，更是工程和产品的伟大胜利！
\n那么 ChatGPT 具体是如何赢得这场胜利的呢？我们一一来看。
\n基于 Transformer 架构的语言模型大体上分为两类，一类是以 BERT 为代表的掩码语言模型（Masked Language Model，MLM），一类以 GPT 为代表的自回归语言模型（Autoregressive Language Model，ALM）。OpenAI 的创建宗旨是：创建造福全人类的安全通用人工智能（AGI），所以创立之初就摒弃了传统 AI 模型标注式的训练方式，因为可用来标注的数据总是有限的，很难做得非常通用。那么为了实现 AGI，OpenAI 在技术上到底做对了什么呢？
\nGPT 系列的模型一直走的是和 BERT 不一样的线路，早些年压力巨大，毕竟 BERT 是 Google 发布的，非常权威。但是 OpenAI 一直认为自回归模型训练潜力更大，尤其在 GPT-2 引入 zero-shot 后，更加有信心了。
\n按照人类语言的习惯，语言本身就有先后顺序，而且我们日常说话也是下文依赖上文。所以有人猜测，自回归语言模型代表了标准的语言模型，利用上文信息预测下文，这比传统 AI 预测更加复杂，但是上限更高，更有望通向 AGI，这正是 OpenAI 的愿景。尽管在 GPT-1 和 GPT-2 的探索中没有取得压倒性的效果，但确实验证了标准语言模型在 zero-shot 等方面的潜在能力。
\n无监督自回归的训练方式，使 GPT 模型可以接受大量文本数据，所以后面有了 GPT-3，1750 亿的参数规模，使 GPT-3 直接问鼎当时最大的模型，GPT-3 使用了大约 45TB 的文本数据，一次训练费用近 460 万美元，在当时，相比上一代模型 GPT-2，效果已经非常好了，这也是人们所讲的大力出奇迹。
\n但是，我们现在来看这个问题，GPT-3 发布时间大概是 2020 年 3 月，当时的 GPT-3 还不具备直接和人类对话的能力。而 ChatGPT 所使用的模型是 GPT-3.5，爆火时间在 2022 年年底到 2023 年 3 月，期间将近 2 年的时间，OpenAI 在做什么呢？答案是他们在想办法让 GPT 模型可以优雅地和人类进行对话。
\n我们知道，人类是有感情的，很多事物是有极限的，比如人再怎么能吃也不可能一顿饭吃 100 个馒头，万一大模型输出的内容有这类意识，那么肯定是不合理的，所以要进行微调对齐。
\nGPT-3 和 GPT-3.5 其实是两个不同的系列，使用过 OpenAI API 的人应该知道，还有几个细化的模型，比如 code-davinci、text-davince 系列。顾名思义，code-davince 就是 OpenAI 另一个产品 codex 使用的模型，在 text-davince-001 的基础上使用源代码进行训练，产生了 code-davinci-002 模型（codex）。再后来在 code-davinci-002 模型基础上，基于有监督的指令微调，产生了 text-davinci-002，最后在 text-davinci-002 模型基础上，使用 RLHF，产生了 text-davinci-003 和 ChatGPT 模型。演进过程如图所示：
\nGPT-3 经过充分训练，但是依然不是一个适合与人类进行对话的模型，所以从 GPT-3 到 GPT-3.5 再到 InstructGPT 和 ChatGPT，参数规模并没有太大变化，主要是经过了各种技术的微调，说白了就是去适配人类情景。其中，最突出的就是 RLHF。RLHF 就是 Reinforcement Learning From Human Feedback（人类反馈强化学习）的简称。关于 RLHF 的详细介绍，我们会放在后面的章节中。
\n突现能力是指大语言模型展现出来的特有的强大能力，比如复杂推理、思维链等。这些是 NLP 领域一直追求的能力，在大模型出现后，这些能力也随之浮现出来。我们举一个简单的例子。
\n问题：小明每天早饭吃2个馒头，他一个月会吃掉多少包馒头？\n\n一个月按30天说，共吃掉60个馒头，每包5个馒头的话，总共12包。\n\n答案：12这个推理看着简单，实际上对于 AI 来说有一定的难度，因为语言和数学混在一起了。在早期 GPT-3 模型上进行类似的推理，准确率并不高，低于 40%，后来在 code-davinci-002 上进行推理，准确率能达到 80% 以上。为什么性能会有这么大的提升？
\n很明显原因不是模型规模，因为 code-davinci-002 在规模上并没有扩大，唯一能解释的就是 code-davinci-002 是基于代码进行训练的，这些突现能力是大模型经过大量代码训练后展现出来的能力。也有人说，面向过程的编程跟人类逐步解决任务的过程很类似，面向对象编程跟人类将复杂任务分解为多个简单任务的过程很类似。所以有人认为，代码训练和思维链及复杂推理有很强的相关性，不过到目前为止没有非常确定的证据可以证明这一点。
\n我们可以总结一下。
\n所以，ChatGPT 在技术上的突破可以理解为：
\n自回归语言模型+充分无监督训练+大量代码训练+有监督指令微调+RLHF
\n放眼望去，全球仅此一家！那这么多技术叠加在一起，怎么才能“大力出奇迹”呢？答案就是进行超大规模预训练。
\n大模型训练首先需要搞定高质量数据集，我们分两个点去考虑。
\n首先，我向你介绍下基础模型 GPT-3 的训练数据集。GPT-3 模型具有 1750 亿个参数，训练数据集大约 500B 个 token（1B=1 billion，也就是 10 亿）。下面是训练数据大概的组成结构：
\n原始大约 45T 的纯文本数据，经历过滤后，大概是 750G 的高质量文本数据。
\n我们再来看下 ChatGPT 的训练数据。ChatGPT 属于 GPT-3.5 系列，官方并没有明确说明这个模型的参数规模，所以网上看到的大部分的数据都是猜测，有人说 15 亿，也有人说 20 亿甚至 1500 亿。但是大概率，ChatGPT 的参数规模是小于 GPT-3 的，其训练数据基于大量对话型数据进行指令微调，典型训练数据如下：
\n除了这些数据集之外，ChatGPT 还接受了互联网上大量非结构化数据的训练，包括网站、书籍和其他文本源。这使得 ChatGPT 能够从更一般的意义上了解语言的结构和模式，然后可以针对对话管理或情感分析等特定应用进行微调。
\n有这么多数据了，接着就要进行预训练了。下面这一步卡住了大部分大模型厂商，那就是计算资源。对于 OpenAI 这种创业公司而言，无疑是很大的困难，那他们是怎么解决的呢？没错，找金主爸爸。
\nOpenAI 做对了一件非常重要的事儿，那就是找钱，而且还是找大钱，动辄几亿美元的投入。GPT-3 的单次训练成本高达 460 万美元。在前景未知的情况下，这么大的投入是非常难的。找钱成了 OpenAI 非常重要的事情，为了找钱，OpenAI 从开源转为闭源。
\n实际上，早期 OpenAI 是开源的，创办宗旨就是创建通用人工智能，造福人类，但是大模型训练需要大量的计算资源和数据，这是实打实需要资金投入的，所以 OpenAI 由开源转为闭源，设计了一种商业模式来吸引投资人，并吸引大量资金，其中最主要的就是微软。下面我向你介绍下这种商业模式。
\nOpenAI 母公司是 OpenAI Inc，属于非营利性质组织，这种情况下资本无法进入，所以后来成立了一家子公司，叫 OpenAI LP，现在我们常说的 OpenAI，其实就是 OpenAI LP，这是一家纯粹的商业化公司，这家公司设置了最高 100 倍的回报上限，以此来权衡盈利和非盈利属性，也可以叫做“有限盈利”，既迎合资本家利益，也看似符合母公司非盈利组织的创建初衷。
\n通过这种股权结构，成功获得微软累计超过 100 亿美金的投资，这里不得不说，微软为 OpenAI 带来的不仅仅是钱，更是强大的影响力，毕竟全世界人民是认微软的，包括我们中国人。
\n当模型完成大规模训练后，接下来就是面世了，OpenAI 的玩法很直接，直接产品化，让大家随便玩。
\nChatGPT 成功之处在于，愿意公开免费给普通用户使用，虽然各大厂商都在宣称自己在搞大模型，且有多么厉害，但真正产品化后开放给用户的，还要数 ChatGPT。
\n大部分的 AI 厂家只发布模型，感兴趣的技术人员去 Huggingface 下载，自己部署把玩，这样就把模型限制在了非常小的一个范围内。
\n而 ChatGPT 不一样，发布的是普通大众用户都可以使用的产品。通过邮箱注册就可以使用，全天候不限时，直接通过网页对话，使用门槛非常低。这要放在国内，还不得让你下载个 App，甚至拉几个朋友才可以用。毕竟这背后是实打实的 GPU 算力成本，据说 2022 年 ChatGPT 的算力费用（包含训练和推理）＋人力成本接近 5 亿美金，试问一下哪个小厂具备这样的实力？而哪个大厂又会在看不到业务前景的背景下，每年投这么多钱去玩？但 OpenAI 做到了。
\n从 2024 年 4 月份开始，ChatGPT 开启无需注册即可使用的模式，彻底成为互联网基础设施。
\nOpenAI 官方公开的 ChatGPT 使用场景有 30 类（参考官方链接），可以用于代码编写、代码翻译、智能问答、语音识别、模拟面试、情感分析、机器翻译、智能客服等多个领域。这使得更多的人能够感受到 ChatGPT 带来的便利和价值，容易获得大众的支持和信任。
\n在 ChatGPT 之前，市面上已经有很多 AI 问答机器人产品，比如微软小冰、小度，用过的人都知道，它们都有很多局限性。小冰是由小模型组成的，只能同时处理特定类型任务，无法相互关联，小度也一样，这类产品无法做通用性的问答，无法像 ChatGPT 一样，像是真人在回答，甚至还有记忆、有感情。
\n工程化即系统化、模块化、规范化的一个过程。我们做工程技术的开发人员很清楚，一个优秀的产品背后一定是有着惊人的技术参数，就拿支付宝来说，双十一高峰期，50 万笔 / 秒的支付吞吐量，背后是大量的服务堆出来的，比如数百万台的服务器、大量的分布式技术的应用，如缓存、消息、文件存储等等。
\nChatGPT 也一样，OpenAI 不是仅仅提供一个模型，让我们自己部署自己玩，而是直接将以大模型为内核的整套技术完成了产品化。对于两个月注册用户过亿的世界级产品来讲，这里面涉及到的技术可想而知，除了 AI 本身涉及的技术外，常见的工程化技术一样少不了。Web 相关的我们就不讲了，主要分享下和模型训练相关的技术。
\n为了方便进行大模型训练。2020 年，微软为 OpenAI 在 Azure 上搭建了计算集群，包含 285000 个 AMD infiniBand 连接的 CPU 内核，另外还有 10000 个 NVIDIA V100 Tensor Core GPU，是当时世界上第五大超级计算机，也是有史以来在公共云中（Azure）建立的最大的超级计算机。
\n我们知道，大模型训练动不动就是几周、几个月的训练，而如果服务器出现故障或者网络连接不稳定，怎么办？肯定不希望从头开始。那么如何实现容错呢？
\n微软开发了 Project Forge，即 Azure 容器化和全局调度服务，可以保证 AI 计算负载保持高水平的利用率；通过建立透明检查点，定期增量保存模型的状态和代码，出现故障，恢复到最近检查点；同时硬件厂家 NVIDIA 也做了调整，他们的 GPU 实现了 CRIU（用户模式下的检查点恢复），可以恢复 GPU 的内存使用，最终和 CPU 的检查点保持一致。软件和硬件协同工作，提高了效率。
\n所以光是模型训练这一步，为了实现可靠性，就集微软工程部门、微软研究院、OpenAI 团队、NVIDIA 团队共同努力于一体。同时，还涉及了隐私计算、私密 GPU、TE 空间等等。除此之外，OpenAI 还雇佣了大量工人（约 7.7 万人）进行人工标注，总体硬件成本接近 10 亿美金，单日运营成本高达 70 万美金，真的是很烧钱。
\n这节课我从宏观方面向你介绍了 ChatGPT 崛起的原因，相信你也对 ChatGPT 有了更深入的理解。下面我们再简单总结一下。所谓工程化主要就是指集技术、数据、产品、资源于一身，是一个系统性、规范性的工程项目，很多人想到 ChatGPT，就想到了大模型本身，其实这是片面的，具体你可以参考下面思维导图再回顾一下细节。
\nAI 大模型还处于发展非常迅速的阶段，实际上天天都在发生变化，所以很多事情都还没有定论，我们需要保持开放的心态，不断接纳，不断学习。下一节课，我会从如何用好大模型这个角度，给你讲解下提示词工程，这也是刚接触 AI 大模型的用户非常容易忽略的问题，当然这也是能否用好 AI 大模型的核心。
\n学完了这节课的内容，请你来思考 2 个问题，ChatGPT 已经这么强大了，那它是否已经具备了人类大脑的思维？还有 AI 到底能否代替我们目前的工作？欢迎你把你的观点分享到评论区，我们一起讨论，如果你觉得这节课的内容对你有帮助的话，也欢迎你分享给其他朋友，我们下节课再见！
\n\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n你好，我是悦创。
\n欢迎你加入这个专栏，和我来一场 AI 大模型深度游。
\n近年来，我开始深入研究 AI 领域，阅读了数百篇相关论文，逐渐领略到这一领域的魅力与潜力。对于我们这些具备开发基础的技术人员来说，AI 无疑是一个充满机遇的新领域。近期的两会上，人工智能也再次成为国家战略焦点，预示着未来十年到十五年的行业发展红利。从互联网 + 到人工智能 +，我们将迎来新一轮技术革新和人才需求的增长。
\n我相信，在未来的发展中，AI 将引领我们走向更加智能、高效的新时代，所以它非常值得我们花时间好好去钻研。
\n对于广大软件开发人员来说，人工智能的深度研究可能会因为它本身的复杂性而令人生畏。然而，我们完全可以将注意力转向人工智能的应用领域。
\n其实不用我多说，作为一个技术开发人员，你可能早已投身于这股滚滚热潮之中了，因为人工智能本身就是技术领域的一个重要分支。敏锐如你我，经过这一年多的时间，应该已经尝试了个遍。不过在应用 AI 大模型的过程中，你应该也遇到了很多问题。
\n比如：
\n无论你是自己探索，还是为企业布局 AI 做准备，这些都是避不开的问题。不过你也不用担心，这些问题你都可以在课程中找到答案。
\n刚刚的那些问题其实也正是开发工程师想要转变为 AI 应用型 工程师的难点。要想克服这些难点，我们首先要做的就是持续更新自己的知识体系，对 AI 的发展和应用情况有一个清楚的认知，来适应 AI 领域的快速变化。现在了解 AI 讯息的渠道很多，无论是公众号、社区，还是一些技术网站，都是稳定的信息来源，可以源源不断地获取最新动态。
\n其次是部署一些有代表性的模型产品进行试用，比如 LLaMA、ChatGLM 等，为你后面大模型选型打下基础，毕竟体验过后才有发言权。
\n此外你还需要学习相关的技术，AI 技术的本质是机器学习，是一个独立的技术体系，学习起来会有一定的难度，不过这些机器学习的原理并不要求你全部掌握，只掌握你领域内最核心的技术原理就可以了，比如大语言模型技术原理中的 Transformer 架构、Word2Vec 等等。
\n最后，积累丰富的实际项目经验同样至关重要，这有助于将理论知识有效地转化为解决具体业务问题的能力，这也正是企业最看重的一项能力。生成式 AI 适合大部分行业，因为符合人类语言环境，只要有语言的地方，基本都能找到生成式 AI 的适用场景，即便你所在行业业务方面没有适用的场景，但是我们还是可以把 AI 作为个人助手，来辅助我们做很多事情，所以你要想办法找到场景，将自己所学的技术进行实践。
\n对于想要入局 AI 的研发工程师，我觉得最好的学习路径就是这样。
\n我根据这条最佳的学习路径，由浅入深地把课程分成了 5 个章节。
\n在这部分，我会向你介绍 ChatGPT 的发展，以及大语言模型中非常重要的概念：提示和智能体。学完了这一章的内容之后，你就会初步认识到 AI 的重要性，对研发工程师该着重从哪方面入手有一个清晰的认知。
\n这一章，我会带你进行各种尝试，来感受大模型的魅力，学完这一章，你将学会如何部署、微调、RAG、封装大模型，这部分内容就是你在企业里落地大模型应用的基础。
\n从这一章开始，我会带你深入技术细节，理解大模型的原理。相信你在体验完大模型后，一定会有很多疑问，比如大模型的权重文件里到底存放的是什么？大模型推理原理是什么样的？所有的疑问将会在学完这一章后全部解开。
\n当你学完原理后如何才能将所学知识吃透呢？那就需要亲自上手实战了，我们将使用上一章学到的知识，自己一步一步构建一个大模型，你甚至可以根据自己的需求去构建其他模型，比如翻译、分类、个人小助手等场景，我相信这会非常酷。
\n这一章节我们会深入探讨了 AI 行业的最新发展趋势，包括 Mamba 模型、Sora、机器人与大模型、人工智能与无人机，以及 AI 发展的下一阶段 Q-Star(*) 的概念。通过学习这些内容，你将了解到 AI 技术如何在不同领域产生深远影响，以及这些新兴技术将会如何塑造我们未来的工作和生活方式。
无论你当前处于何种阶段，是否已具备 AI 技术基础，都不必过于忧虑。根据创新扩散定律，当前 AI 领域正处于早期接受者的阶段，这意味着行业仍在快速发展但尚未成熟的阶段。因此，你拥有足够的时间来深入学习和探索。我们要保持短期跟进，长期看好的心态。人工智能无疑是未来的趋势，大方向不会错。现在就是上车的好时机，跟上队伍的节奏，不断学习和进步。
\n我希望在探索人工智能的道路上你不仅仅能够学到 AI 相关的知识，更重要的能够养成数据驱动与模型驱动的思维，掌握处理和分析数据的技能，将数据作为大模型的基石，深刻理解模型的工作原理和应用场景。希望这门课程能够为你打开人工智能技术世界的大门，激发你的灵感，引领你走向更广阔的未来。
\n\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，招收学员面向国内外，国外占 80%。全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n在学习 Python 时，我们经常会听到 “可迭代”（iterable） 这个词。对于初学者来说，这个概念可能有些抽象。那么，什么是“可迭代”？它和“不可迭代”有什么区别？今天我们就用通俗易懂的方式来讲解这个概念，让你一看就懂！这部分的知识，也是为了便于后续的学习而增加的。
\n用一个类似的知识来辅助下面知识点的理解：分子属于可迭代对象，原子属于不可迭代对象。为什么这么说呢：分子可以拆分成原子，但原子属于不可再拆分。可以再被拆分的称为可迭代，不可再被拆分的称为不可迭代。
\n在 Python 编程中，“可迭代”（iterable）是指 可以一个一个取出元素的东西。
\n想象你有一本书，书里有很多页。你可以一页一页地翻，这本书就是可迭代的，因为你可以“遍历”它的每一页。
\n再比如：想象你有一个音乐播放列表，里面有很多歌曲，你可以一首一首地播放。这个播放列表就是可迭代的，因为你可以逐个获取里面的每一首歌，并且按顺序播放或随机播放。
\n在 Python 中，可迭代的对象包括：
\n| 对象类型 | 示例代码 | 说明 |
\n|
The topic of the project is the forest fire model, a type of cellular automaton which is introduced in the ‘Forest Fire’ video, found on Blackboard under week 19. The rules are briefly explained below, but you should watch the video for a more detailed explanation.
\nThe deadline for submission is 12:30pm, on Wednesday of week 23. You should submit:
\nYou will not be penalised for going slightly over the page limit, but if you are significantly over, you should consider whether you are e.g. including more graphs than is necessary to justify your conclusions. You do not need to submit any code used to generate graphs or otherwise post-process your output, or any bash scripts that you may have used.
\nA square grid of size N is randomly filled with trees, with probability p that any given cell contains a tree. To start the fire, any living trees in the top row are then set on fire. Then, for each point on the grid at time step t:
\nA neighbour is defined as a cell to the left, right, above or below the cell we are interested in, with diagonal cells not considered to be neighbours (i.e. we are using a Von Neumann neighbourhood). The simulation proceeds until no more trees are burning.
\nYou should implement the forest fire model in C++, using MPI to parallelise a single run of the model, i.e. it should be possible to run the code for a single starting grid, grid size N , and probability p, while using multiple MPI tasks.
\nThe C++ code should contain the following features:
\nthe ability to read in an initial grid from a text file, for which an example will be supplied
\nthe ability to generate a random starting grid of size N with probability p
\nthe ability to average over M independent runs, e.g. for M starting grids which were initialised with different random seeds
\nthe code should output:
\nYou will also need to run the code for different probabilities p and grid sizes N . It is up to you whether you do this within your C++ code (e.g. using a loop over probabilities p), or by using a bash script to run your code repeatedly with different inputs.
\nIn the video introducing the forest fire model, we talked about convergence with respect to a) the number of random starting grids, M (i.e. the number of repeat runs) and b) the size of the grid, N. For example, if you run the code once with a given random starting grid, and then run it again with a different starting grid, the number of steps the simulation runs for may not be the same, even for the same N and p values, due to the effects of randomness. If, however, you run the code M times and average the results, for a large enough value of M the average number of steps taken will no longer change significantly. I.e. for a large enough value of M , further increases in M will result in only negligible changes to the average behaviour. In other words, the model has converged.
\nFor this project, we will focus only on convergence with respect to the number of repeat runs, M . You may use a fixed grid size of N=100. Using your code, you should answer the following questions:
\nYour answer should be backed up by data, and you should describe how you came to this conclusion,as well as any strengths and/or limitations of your approach. For example, did you have to make any compromises about the number of calculations performed, and given unlimited time, would you therefore do any further calculations?
\nThe final aspect of the project is to explore the parallel performance of the model using BlueCrystal4. For this part of the project, we are not interested in the behaviour of the model itself, only the time taken to complete a run, and how this varies with the number of MPI tasks.
\nSince the performance is intrinsically linked to the problem size, you should generate timing data for three different values of N :
\nYou may run these calculations using p=0.6, averaging over M=50 runs.
\nPresent and comment on your results, including a discussion of how the grid size influences the performance and why, as well as the metrics you have used to assess the performance (walltime, speedup etc.). State the maximum number of MPI tasks you would use for each of the three grid sizes, and why. Your discussion should also include any factors from your MPI implementation which impact on performance, e.g. your choice of MPI communication scheme and data distribution.
\n1 0 1 0 1 1\n0 1 1 0 0 0\n0 0 1 1 1 0\n1 1 0 0 0 1\n0 0 1 1 0 1\n1 1 0 1 0 1This is a mini project, and so the mark scheme takes into account both technical aspects, i.e. your code, including correctness, use of C++, choice of MPI implementation etc., and how you have used your code to answer the questions, i.e. your report. Make sure you read the instructions carefully and answer all questions in your report. You should also include sufficient data to backup your conclusions,as well as a discussion of any limitations, including potential future work that could be performed to address any of these limitations or extend the project.
\n代码全在仓库中：https://github.com/AndersonHJB/SCIF30005-Forest-Fire-Mini-Project
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nIn this project, you will be building a two-player game with a graphical interface. The design and implementation of this game is left open-ended, for you to figure out, explain, and justify. There will be several components to this project, so do not assume that everything in your code must neatly be described as either “model”, “view”, or “controller”.
\nPawns Board is a two-player game played on a board of cells and custom cards. The game is a variation of a new card game called Queen’s Blood. In the game, each player has a color—red or blue—, a deck of cards, and a hand made from their respective decks.
\nTo start the game, each player must be given a deck of cards to play with and the board must be constructed.
\nThere must be enough cards in each deck to possible fill every cell on the board. Additionally, in our game, there can only be two copies of any card in a deck. That means there can be duplicates, but not triples of any given card. The deck for each player will be read in from a separate file.
\nThe board in our game is rectangular and its dimensions must be specified before the game starts. For our game, the number of rows must be positive (meaning greater than 0) and the number of columns must not only be greater than 1, but they must be odd. This allows for interesting interactions to occur in the center column of the board.
\nGame play begins with both players being dealt an equal number of cards to their hands from their decks. The board also starts with no cards on it. However, the cells in the first and last column start with a single pawn in each cell. The first column’s pawns belong to the red player. The last column’s pawns belong to the blue player
\nAn initial layout of the game with 3 rows and 5 columns might look like this:
\nWith a valid board created and valid decks for each player, each player is dealt their cards at random from the list. The starting size of each player’s hand is also passed in at the start of the game, but it cannot be greater than a third of the deck size. Player Red always goes first.
\nOn each turn, the current player first draws a card from their deck if there are cards remaining in their deck. If not, then no card is drawn. Then they can take one of two actions: pass or place a card. If the player chooses to pass, then their turn ends and the current player switches to the other player of the game.
\nFor the player chooses to place a card instead, they must place their card in a cell that has enough of their own pawns to cover the cost of the card.
\nThat newly placed card can then affect the board by adding pawns to other cells or converting pawns from the opponent’s ownership to the current player’s ownership. Once a card has been properly placed, the turn changes over to the other player.
\nThe game ends when both players pass their turn, one after the other. The winner is determined by calculating the score of each row.
\nIn the following subsections, we will dive into the cards, the board, scoring, and detailed information on how placing a card works in this game.
\nEach card in the game has a name, a cost, a value score, and a five by five board demonstrating the card’s influence on the board. Costs are either one, two, or three pawns. A value score is any positive integer and is used to determine the overall score of the game. Influence determines how the cells on the board relative to the card are affected. Consider the following card below
\nThe name, cost, and value score are depicted in text on the card itself. This card, named Security, has a cost of 1 and a value score of 2. The grey grid depicts the card’s influence. The orange square represents the card itself. If a square on the influence board is cyan, like in the above picture, then it affects the cell relative to where the card is placed on the board. If a square on the influence board is grey, then nothing happens on those cells. This will come into play when we discuss placing a card on the actual board.
\nWe will be supplying cards to the game via files that contain the decks for each player. See the relevant section later in the assignment.
\nTwo cards are the same if they have the same name, cost, value score, and influence grid.
\nA board is a rectangular container of cells. Cells can either contain pawns, cards, or nothing. Each cell can contain anywhere between 0 and 3 pawns on a cell. If a cell has a pawn or a card, then it is owned by one of the players of the game. Cells with cards cannot change ownership. Cell with pawns, however, can change ownership depending on the cards the current turn player places on the board. Here is another example of a larger valid board for the game in the middle of play.
\nIn the game, each row tallies the scores for each player. Those scores, which we will call row-scores, are determined by summing the value scores of each card owned by that player. Consider the row shown in the following image. You will see grey squares with numbers on them. Those are the row-scores as calculated by the game. The leftmost number is the red player’s row-score and the rightmost number is the blue player’s row-score.
\nWe can see which player owns which card by looking at the color of the cell. We can see here that the red player has played cards with value scores of 1 and 1, giving them a row-score of 2. Similarly, we can see that the blue player has played cards with value scores of 3, 1, and 1, giving them a row-score of 5.
\nWe can calculate each players total score at any point during the game. To do so, we need to examine each row. For each row, we look at the row-scores for each player on that row. The player with the higher row-score adds their row-score to their total score. The player with the lower row-score gains zero points for their total score. If the row-scores are the same for both players, neither player gains points. After reviewing all the row-scores, we compare the total scores for each player. The player with the higher total score wins. If the total scores are tied, then the game ends in a tie.
\nAs an example, consider the following game.
\nLet us figure out the total score for each player.
\nBy the end of scoring, Player Red has 7 points while Player Blue has 13 points. If the game ends here (which it definitely will), Blue will be the winner.
\nAs another example, consider this different game.
\nReminder that pawns do not affect the score in any way. With that in mind, let us start calculating the total score for the players.
\nSince the final score for Red is 3 and the final score for Blue is 3, the game is tied so far! If the game ends here, then the game is a tie with no winner.
\nThe current turn player can either choose to pass or place a card. We will focus on placing a card as that has actual effects on the board.
\nA player can place one of the cards in their hand onto a cell if the following conditions are satisfied
\nIf both conditions are not satisfied, the player must choose another card that does satisfy the conditions. If none satisfy the conditions, the player must pass. If both conditions are satisfied, then the pawns on that cell are removed and replaced with the card. Naturally, the player removes the card from their hand to place it on the board.
\nUsing the starting board from the start of the assignment as an example, players can only play cards that cost one pawn on the board because for each player, all the cells they own have one pawn.
\nConsider the following board.
\nRight in the middle of the board, the red player can place cards that cost one or two pawns, but not any that cost three pawns.
\nIn the middle of the final column, the blue player can place cards that cost one, two, or three pawns because that cell contains three pawns.
\nNaturally, player red cannot place cards on any cell with blue pawns. Similarly, player blue cannot place cards on any cell with red pawns.
\nOnce the card is placed, the card’s influence spreads on the board according to that card’s influence grid. The influence grid is always relative to the card’s position. All cells relative in position to the card’s position on the board can be affected. You can think of it like laying the influence grid over the board, centering it on the card that was just placed. For example, say we place a card in the bottom left of the board. The image below represents the possible area that can be affected.
\nNotice that not every cell might be effected. Some of the influence grid’s squares might fall off the board, so nothing happens. Players must consider whether playing a card in a particular cell will allow them to maximize that card’s influence.
\nWhen you perform that overlap, all the cyan squares in the influence grid represent the cells that the card influences. The grey and orange squares do not influence any cells. As an example, consider the following pictures, one of a card called the Mandragora with its influence grid, and another showing what cells placing that card can influence after overlaying the influence grid over the grid, centered on that card.
\nNow that we have determined how to figure out which cells are influenced, we must discuss how they are influenced. Recall a cell either has a card, pawns, or nothing. We will walk through each scenario separately by focusing on a single cell affected by a card’s influence.
\nFor these subsections, we will use the following card to focus on only one cell on the board.
\nIf the cell to influence has a card, nothing happens.
\nIf the cell to influence has nothing on it, then the cell gains a single pawn owned by the current turn player. In the following example, we can see a before and after of this effect.
\nIf the cell to influence has pawns on it, the effect changes depending on whether the current turn player owns the pawns or not.
\nIf the current turn player owns the pawns, then the number of pawns on that cell increases by one. However, there can only be a maximum of 3 pawns on a single cell.
\nIf the current turn player does NOT own the pawns, then the number of pawns on that cell does not increase. Instead, the current turn player takes ownership of those pawns. You can see this play out in the following images.
\nThis allows players to gain the upper hand by claiming pawns the opponent was saving for higher cost cards.
\nPutting together these rules, we can now visualize the result of playing the Mandragora in the bottom left. The images below show the card on the left and the resulting board for placing the card on the bottom left of a standard starting board.
\nNotice number of pawns above the card increased to two pawns. Furthermore, the two cells to the right of the card gained a red pawn.
\nFor another example not in a corner, consider a play where the red player is somehow able to place a different card in the middle of the board.
\nNotice that since every cyan square on the influence grid actually overlayed with a cell on the board, they all took effect.
\nFinally, consider a play where the red player instead placed the same card in the top left instead.
\nNotice that some of the cyan squares actually don’t overlap with a cell on the board, so they exert no influence.
\nKeep in mind the blue player is on the right side of the board. To allow the red and blue player to use the same cards, when the blue player looks at what their card can influence, the influence grid is mirrored across the columns (i.e. the y-axis). You can see this in the example below with the Mandragora card.
\nTherefore, influence is also mirrored when the card is placed on the board. You can see this in the images below. When red plays their Mandragora in the middle, the influence spreads to the right and above. When Blue plays their Mandragora in the bottom right, the influence still spreads above, but it spreads to the left instead.
\nA multiplayer game involves several interacting components: you have multiple players, that each interact with a visualization of the grid, along with a rules-keeper to ensure the game is played legally.
\nIn our setting, the cards, board, and the rules-keeper (objects or methods that make sure the rules of the game are always followed) comprise our model: together, they are what distinguish one instance of the game from another.
\nThere are multiple ways to view the game; we will discuss two below.
\nDepending on how the game is viewed, we might want to design different controllers for the game.
\nThe game also has some further customization not mentioned in the overview, but could come up in future assignments including the extra credit. For instance, influence only adds pawns or takes control of existing pawns. However, the game Pawns Board is based on has different types of influence, like increasing or decreasing the value scores of cards.
\nAnd then there are the user-players (an object that the users actually play the game through), which are not part of the model, view, or controller. User-players make decisions about what move they want to make (not be confused with the player entities of Red and Blue in the model), so they “have a different interface” than the other components discussed so far.
\nYou will need to represent the cards, the players, the board, and all of their contents. You likely will have to figure out how to represent the coordinate system of the grid, so as to describe the locations of all the cells on the board.
\nYou will need to figure out how to let users make moves. Your implementation will need to (among other tasks) enforce the rules of the game, to make sure that players take turns, that moves are legal, that influence is applied on the board, and that the winner of the game can be determined.
\nAbout variant rules: While variant influence effects are briefly mentioned, they are not to be implemented as we have not discussed what they are. We mention them now in case that has an effect on how you design the model.
\nHint: your primary model interface may not be all that complicated. As with all our design tasks so far, consider all the nouns you notice in this game’s description, and all the verbs describing their interactions, observations, or mutations, and those become your interfaces and methods.
\nYou are not required in this assignment to create a GUI view of your game. Instead, you will start with a simpler textual view, similar to the previous project, to make it easier to see the interim progress of your game. We recommend a straightforward rendering of the board itself and the row-scores, using _ for empty cells , an integer of 1, 2, or 3 for the number of pawns on the board, R for a card owned by the red player , and B for a card owned by the blue player. For example, see the graphical and textual views below for a representation of a game in play where player Blue is the current player.
Textual view\n2 RR__3 0\n0 2__1B 1\n0 11_1B 3 Controlling the gameYou do not need to implement any sort of controller in this assignment, though you are encouraged to think about how to do so — we will build a controller in future assignments.
\n Players – human or machine?In a future assignment, we might ask you to implement a simple AI user-player for this game. This will enable several possible scenarios, including solitaire play (person vs computer) and fully-automated play (which may be useful for testing). You do not have to implement a computer user-player right now, but you should design your model so that different user-player implementations could exist for human or machines to play your game. You should attempt to design a user-player interface that allows this to happen.
\nIn a design document (in a separate text file), explain how you envision instantiating user-players and your model, so that you could play a few moves of the game. This might be one part of your README (see below), but probably should be a separate file.
\nWe will give additional guidance in future assignments over how we suggest you implement user-players; the goal in this assignment is for you to think through the design possibilities and explain what you think might be an appropriate design.
\nConfiguration files are a great way of setting up game states without having to manually create them in a test file. We will be using configuration files to instantiate the grid and cards for our game. This files seemingly play a special role, but do belong in one of our 3 regular components (model, view, controller). You must decide where they go based on the purposes of each component, what the classes that read these files actually do, and which component best represents that purpose.
\nFor this section, it may be helpful to read up on the FileReader and Scanner documentation from Oracle. The goal is to help you practice some software archaeology and help you figure out how you learn to use new classes.
Your program needs to work on any computer, which means on any operating system. However, different operating systems describe paths to files in different ways. For instance, Windows uses
\n\"\\\"to separate folders while Macs and Linux use
\n\"/\". Furthermore, when graded, your projects won’t be opened on your computer, but on someone else’s. So how do we decide on a location for the files you will be reading so your program works regardless of the computer and how do you write that location in code when you need to read in a file?
\nFor the location, IntelliJ actually has a solution. Any code run in IntelliJ automatically assumes that file paths start from the project folder. Consider the following possible project setup
\n+- src/\n| +- cs3500/\n| | +- pawnsboard/\n| | | +- ... (more stuff)\n+- test/\n| +- cs3500/\n| | +- pawnsboard/\n| | | +- ... (more test stuff)\n+- board.configI can read the board.config file in my code by giving the appropriate object the path as a String as follows
\nString path = \"deck.config\";\nFile config = new File(path);However, we cannot leave random files sitting in the project folder because that clutters the project itself. So instead, we place all files that support the program like config files in a folder called docs like below.
\n+- docs/\n| +- deck.config\n+- src/\n| +- cs3500/\n| | +- pawnsboard/\n| | | +- ... (more stuff)\n+- test/\n| +- cs3500/\n| | +- pawnsboard/\n| | | +- ... (more test stuff)That brings us to the other issue: how to write paths in Java that are independent of any operating system. Java’s file class actually has something for us! There is a static constant called separator which changes depending on the operating system. Let’s say we wanted to create a File object for deck.config. We can write the following code
String path = \"docs\" + File.separator + \"deck.config\";\nFile config = new File(path);Use this knowledge to write tests and code that will read files on any computer.
\nIf you get a file that does not correspond to the format listed below, the behavior is unspecified. This means you can let anything happen as a result. If you do choose a specific behavior, make sure to document it in the code.
\nThis file is a list of cards in the following format
\nCARD_NAME COST VALUE\nROW_0\nROW_1\nROW_2\nROW_3\nROW_4\nCARD_NAME COST VALUE\nROW_0\nROW_1\nROW_2\nROW_3\nROW_4\nCARD_NAME COST VALUE\n...Each card consists of one line with its name (with no spaces), an integer between 1 and 3 inclusive for the cost, and a positive (greater than 0) integer for the value score of the card. Then there are 5 lines, each made of 5 characters, representing the influence grid of the card. There are 3 possible characters that can appear in the influence grid
\nA valid card file only has lines for cards as formatted as specified above.
\nWhat follows is an example of a deck configuration file with two cards.
\nSecurity 1 2\nXXXXX\nXXIXX\nXICIX\nXXIXX\nXXXXX\nBee 1 1\nXXIXX\nXXXXX\nXXCXX\nXXXXX\nXXIXXSince you are creating the interfaces yourselves, we cannot possibly write JUnit tests to check your functionality. However, the functionality of your model is integral to your success in this project and for your grade.
\nTo show that functionality, you must add a class called PawnsBoard that only has a main method. Just like with PokerPolygonsGame, this is a class that cannot be in the model, view, or controller packages, but instead exists in your project’s package at the same level as the model, view, or controller packages. In this main method, you must do the following:
We will use this main method to check the functionality of your model.
\nPawnsBoard class as described previously.interface, but merely as a clearly-written English description in a text file.We will not be autograding this assignment, but you should emulate the textual view output above as precisely as possible, as we will likely be looking at it on future assignments.
\nREADME fileA good README file needs to quickly explain to the reader what the codebase’s overall purpose is, what its design is, and where to find relevant functionality within the codebase. (Just because your code organization is obvious to you does not mean it’s obvious to a newcomer to your code!)
\nA README file does not have to be long in order to be effective, but it does need to be better than merely formulaic.
\nREADME files need to be in a predictable place in your codebase, or else readers won’t easily be able to find them. Typically, place them in the topmost directory of your project, or in a toplevel docs/ directory.
Consider the following outline as a good starting point for your READMEs, and elaborate from here. This is not a verbatim requirement, but rather a launch-point for you to explain your code.
\nOverview: What problem is this codebase trying to solve? What high-level assumptions are made in the codebase, either about the background knowledge needed, about what forms of extensibility are envisioned or are out of scope, or about prerequisites for using this code?
\nQuick start: give a short snippet of code (rather like a simple JUnit test) showing how a user might get started using this codebase.
\nKey components: Explain the highest-level components in your system, and what they do. It is trite and useless to merely say “The model represents the data in my system. The view represents the rendering of my system. ...” This is a waste of your time and the reader’s time. Describe which components “drive” the control-flow of your system, and which ones “are driven”.
\n\n\nKey subcomponents: Within each component, give an overview of the main nouns in your system, and why they exist and what they are used for.
\n
Source organization: Either explain for each component where to find it in your codebase, or explain for each directory in your codebase what components it provides. Either way, supply the reader with a “map” to your codebase, so they can navigate around.
\nNotice that almost everything in the README file corresponds strongly with the purpose statements of classes and interfaces in your code, but probably does not get into the detailed purpose statements of methods in your code, invariants in your data definitions, etc. Those implementation details belong in Javadoc on the relevant code files. You may choose to mention some key methods as entry points into your code (perhaps in the Quick start section’s examples), but you should not overburden the README with such lower-level detail.
\nSubmit any files created in this assignment, along with your design document. Make certain you include your README file, which should give the graders an overview of what the purposes are for every class, interface, etc. that you include in your model, so that they can quickly get a high-level overview of your code. It does not replace the need for proper Javadoc!
\nFor this assignment, you will be graded on
\nPlease submit your homework to https://handins.ccs.neu.edu/ by the above deadline. Then be sure to complete your self evaluation by its due date.
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\nIn the last lecture we introduced the idea of a “Features interface” that described a way to
We called these “high-level events”, since they were application-specific events as opposed to “low-level” general-purpose events. This idea of defining our own application-specific events is a very common one, and generalizes the Features interface idea into something known as the Observer Patern.
Suppose you are interested in getting tickets for a popular upcoming concert. You know that tickets will sell out quickly, and you don’t want to miss your opportunity. So you signup for the mailing list for the ticket service, and wait for an email telling you that tickets are now available. Of course, mailing lists being what they are, you’ll probably get a bunch of unwanted messages telling you about uninteresting concerts as well, so you need to read the emails to check which concert has just gone on sale.
\nLet’s try to represent this in code.
\nLet’s assume we have a class TicketSeller that handles ticket sales for lots of concerts, and a class Person to represent you or other people interested in concerts. (To keep things simple, we’ll just assume each concert has a unique name that we’ll represent as a String; in practice, the data here might be more interesting, but it’ll obscure the pattern we’re looking for here.)
class TicketSeller {\n Ticket purchaseTicketFor(String concertName) { ... sell a ticket ... }\n}\n\nclass Person {\n void tryToBuyTicketFor(String concertName) {\n ???\n }\n}If a concert is sold out or not even available yet, then TicketSeller#purchaseTicketFor will fail, so our goal is to call that method as soon as possible, but no sooner. So in Person#tryToBuyTicketsFor, we can’t immediately call that method. Instead, we need to “sign up for the mailing list” somehow.
To do that, let’s define an interface
\ninterface TicketNotificationSubscriber {\n void ticketsAvailableFor(String concertName);\n}This is the analogue of the Features interface from last lecture. With Features, our controller was interested in being called back, so it registered with the view, and the view called its methods when appropriate. Here, our TicketSeller will call the ticketsAvailableFor method on any objects that have signed up for such notifications, and our Person objects will implement that interface and sign up for the notifications.
class Person implements TicketNotificationSubscriber {\n void tryToBuyTicketsFor(String concertName, TicketSeller seller) {\n seller.signUpForNotifications(this);\n }\n\n public void ticketsAvailableFor(String concertName) {\n // the seller will call us back when concerts become available\n }\n}\n\nclass TicketSeller {\n void signUpforNotifications(TicketNotificationSubscriber obs) {\n ???\n }\n}Now we just have to connect the last few pieces. The TicketSeller will need to maintain a “mailing list” of everyone who’s signed up to be notified. And whenever a new concert is announced, it should broadcast that announcement to everyone who’s signed up:
class TicketSeller {\n List<TicketNotificationSubscriber> subscriers = new ArrayList<>();\n void signUpForNotifications(TicketNotificationSubscriber sub) {\n this.subscribers.add(sub);\n }\n\n void announceNewConcert(String name) {\n for (TicketNotificationSubscriber sub : this.subscribers) {\n sub.ticketsAvailableFor(name);\n }\n }\n}Finally, we can complete the Person implementation. Notice that they’ll get notified for all concerts, so they need to keep track of the one concert they’re interested in:
class Person implements TicketNotificationSubscriber {\n String interestedInConcert;\n TicketSeller seller;\n void tryToBuyTicketsFor(String concertName, TicketSeller seller) {\n this.interestedInConcert = concertName;\n this.seller = seller;\n seller.signUpForNotifications(this);\n }\n\n public void ticketsAvailableFor(String concertName) {\n if (concertName.equals(this.interestedInConcert)) {\n // Hooray, tickets are available for the concert we're interested in\n seller.purchaseTicketFor(concertName);\n }\n }\n}Notice the similarities to ActionListeners: the Person gets called back with the name of what event has occurred, and can choose what to do about it based on that information. Notice also the differences: the callback here is talking about concerts, which is clearly a very application-specific sort of event.
The names TicketSeller, signUpForNotifications, TicketNotificationSubscriber and ticketsAvailableFor are whimsical and application-specific, but they illustrate an important point: this pattern applies to high-level events just as well as to low-level events. Regardless of the name, the Observer Pattern describes this common scenario, of multiple entities that are interested in messages being sent by some common source. There can be many observers for a single message-sender, and a single observer might be interested in many message-senders.
The general names for this pattern look as follows:
\nclass Subject {\n List<Observer> observers;\n void addObserver(Observer obs) { observers.add(obs); }\n\n // This method gets called by other methods in the Subject class as needed\n private void notifyAllSomethingHappened() {\n for (Observer obs : this.observers) {\n obs.somethingHappened();\n }\n }\n}\n\ninterface Observer {\n void somethingHappend();\n}\n\nclass SomeObserver implements Observer {\n void somethingHappened() { ... }\n}\n\n// somewhere in the code\nsomeSubject.addObserver(someObserver);Subject class to allow unsubscribing from notifications, via a removeObserver method.somethingHappened method, including which Subject sent the notification, or what the notification is about.Person gets notified for all concerts, leading to a lot of spammy messages. We might want to enhance the addObserver method to specify what notifications we’re interested in, and allow the TicketSeller to only send the notifications we care about. In general, we might want the Subject class to maintain a mapping from specific topics to the observers interested in just those topics, and only somethingHappened() the observers that care about that topic. This leads to a more complex Subject implementation, but a possibly more-efficient system overall.Observer interface has only a single method in it. But as we saw with Features, there could easily be multiple application-specific notifications we might want to send.TicketSeller again, if it sends out a notification for each individual concert, then the amount of spam depends on how many concerts there are. We might instead want to group together several updates into a single batch notification (for example, configuring Piazza to notify you for each individual post, vs notifying you once every few hours with a batch of posts at once).The Observer pattern is a general-purpose event handling mechanism, and hopefully it’s clear that its utility generalizes beyond just handling UI events.
\n在很多应用场景中，我们都有这样一种需求：当某个对象（通常称为“主题”Subject）发生变化时，希望能够及时通知其他对这个变化感兴趣的对象（通常称为“观察者”Observer）
\n例如：文中“演唱会订票”例子里，TicketSeller 就好比是“主题”，有新演唱会门票开始发售（“事件”）时，需要通知所有“订阅”它的人（“观察者”），让他们赶紧来买票。
这个模式也常出现在 GUI 开发中，Swing 或其他图形库中都有类似的事件监听器概念：一个按钮被点击时，就通知所有监听这个按钮点击事件的观察者。
\n关键点：
\nticketsAvailableFor(String concertName)，用来接收“通知”。TicketNotificationSubscriber 接口的对象。announceNewConcert(String name)）时，就会把这个消息广播给所有订阅者。seller.signUpForNotifications(this) 把自己注册到 TicketSeller。ticketsAvailableFor(String concertName)，就判断是不是自己关心的演唱会，如果是，就执行购买票的逻辑。和我们常见的 GUI 监听器类似，但事件名是业务相关的“门票可用事件”，而非鼠标点击、键盘输入等底层事件，因此它也被称为“高层事件”或“应用特定事件”。
\n下面我们写一个完整的示例，放在一个文件里演示。可以把它保存为 ObserverPatternDemo.java 并编译运行（当然也可以拆分成多个文件，这里为了演示方便，放在一起）。
上面是最简洁的一种实现方式。在实际项目中，根据需求不同，还可能会有一些变体或增强：
\nTicketSeller 更智能地发送更“精准”的通知。无论如何，核心点不变：主题维护一组观察者对象，发生某件事时调用观察者接口的方法进行回调，从而让观察者对该事件做出相应处理。 这就是观察者模式(Observer Pattern)。
\nobserver.回调方法()去通知。希望这个例子和逐步实现的过程能帮你真正理解并掌握“观察者模式”。如果你把上面的代码都放在一个文件里（或者按照各个类拆成多个文件），编译运行，就可以亲眼看到程序如何在“广播事件”时通知所有观察者了。
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n## 1. Introduction to Views\n\nSo far we’ve worked on designing *models* to represent the data relevant to a problem domain, in a form that encapsulates the data behind an interface that clients can use without having to know any implementation details. The model is responsible for ensuring that it can’t get stuck in a bogus or invalid state, and exposes whatever appropriate observations and operations are needed while still preserving this integrity constraint.\n\nWe’ve also worked on simple synchronous *controllers* that allow users to interact with a model, in a form that encapsulates the user interactions and can provide feedback to users without having to redundantly ensure any integrity constraints. Moreover, controllers can be customized or enhanced without needing to change the model, making the model more convenient to use without making it any more complex.\n\nNow, it’s time to introduce the third part of the MVC trio: *views*. Views are renderings of the data in the model, and can be as simple as printing debug output to a console, as complex as fancy graphical user interfaces, or anything in between. Dealing with GUIs also brings additional challenges, and we will discuss some of them.\n\n### 1.1 Outline\n\nThis lecture starts by adding a text-based, interactive view to the program. This is closest to our earlier design for the controller, but it carves out a view cleanly. This example also illustrates the typical interactions between the model, view and controller in a simple manner.\n\nWe then progressively transition to graphical user interfaces. We start with *poorly-designed but working* code, and improve it in three stages. Initially, the code for the view will directly manipulate the model. Our first incremental improvement will decouple the view from the model so that it need not — and in fact *cannot* — do so. Our second improvement will add a new feature to the view, and add the ability to control that in the controller. Finally, our third improvement will generalize the controller to make its UI triggers more customizable.\n\nThe code for this lecture is available at the top of this page, as the [MVC code](https://course.ccs.neu.edu/cs3500/lec/gui_basics/code.zip) link. The second link provides code for a program with an incomplete GUI. It is recommended that you complete this exercise to practice with GUIs. Finally the third link provides a solution for this GUI.\n\n## 2. Design\n\nAll examples in this lecture follow a common design. The model state (interface `IModel` and implementation `Model`) consists of a single `String` and offers methods to get and update it. All views (coupled with controllers wherever applicable) expose functionality to interactively show this string, and to update it.\n\n### 3` `Text-based UI\n\nIn the TextUI directory we show a text-based user interface. The IView interface encapsulates all the methods that a view’s client would need to call: note how they correspond roughly to the “things” that a controller would need to tell the view to do. The TextView class implements this interface. It transmits all messages to a PrintStream object provided to it through its constructor. Similar to the design in [Lecture 8](https://course.ccs.neu.edu/cs3500/lec_controllers_mocks_notes.html) this allows us to test the view using any suitable PrintStream object.\n\nThe IController interface represents a controller: it has only method which is called to give control of the application to the controller. The TextController class implements the controller. It works with IModel, IView and Scanner objects to handle model, view and data input functionality respectively. At its heart, the controller goes through a loop that provides users with some options, takes further inputs depending on the chosen options and delegates to the model and view accordingly. Since the sequence of operations is largely fixed, this qualifies as a *synchronous* controller.\n\n## 4. Stage 1: Introduction to GUIs\n\nIn the BadDesignButFunctional directory, we have a poorly written implementation of a simple program that uses the same model, but a graphical user interface.\n\nOur `main()` method constructs a `Model`, and constructs a view that is given a reference to the model. The view interface (`IView`) has only three methods: to obtain the text the user has typed in to the text box, to clear that text box, and to echo a string to the label in the UI. The implementation of the view, `JFrameView`, is markedly more complicated in appearance than expected, but it breaks down into several simpler parts.\n\n### 4.1 Frames and controls\n\nOur program uses the Swing framework to show its UI. In Swing, an individual window is known as a *frame*, which can contain controls known as *components*. To create our own window, we design a class that subclasses from `JFrame`, do some work to establish the components in it, and then call `setVisible` to display the window. Within the constructor of our frame, we create four components: a *label* to show some text, a *text box* to edit text, and two *buttons*. Adding several controls to a frame requires that we give them a *layout*, which describes the spatial relationships between the controls. In this example, we’re using a `FlowLayout`, which allows the controls to wrap around as we resize the window. (Try running the project and resizing the window to be narrower than the controls are.) Different layout managers allow adding controls in [different ways](https://docs.oracle.com/javase/tutorial/uiswing/layout/visual.html). Once controls are added to the UI, the `pack()` method is used tell the layout manager to determine the actual positions and sizes of all the controls.\n\nIn order for the controls to do anything, however, we need to add an *event handler* to them. An event handler, or *callback*, is simply a function that gets called when something interesting occurs. In our case, the clicking of different buttons should trigger a callback. In the jargon of Swing, clicking on buttons triggers their *action*, and so we must supply a function object that implements the [`ActionListener`](https://docs.oracle.com/javase/8/docs/api/java/awt/event/ActionListener.html) interface. (Other controls have additional events besides “actions”.) For convenience, Swing allows us to label each button with a so-called *action command*, which is a `String` of our choosing: when the `ActionListener`’s callback is invoked, it will be given an [`ActionEvent`](https://docs.oracle.com/javase/8/docs/api/java/awt/event/ActionEvent.html) object that knows the action command of the button that was clicked. In this way, we can use a single listener to listen to multiple buttons at once, and distinguish them by means of this command string. See the calls to `setActionCommand` and `setActionListener` and the implementation of `actionPerformed` in JFrameView.java for an example:\n\n\\```java\nclass JFrameView extends JFrame implements ActionListener {\n public JFrameView(String caption, IModel model) {\n ...\n echoButton = new JButton(\"Echo\"); // Create a button,\n echoButton.setActionCommand(\"Echo Button\"); // set its command,\n echoButton.addActionListener(this); // set the callback,\n this.add(echoButton); // and add it to the UI\n\n exitButton = new JButton(\"Exit\"); // ditto, for another button\n exitButton.setActionCommand(\"Exit Button\");\n exitButton.addActionListener(this);\n this.add(exitButton);\n ...\n }\n\n @Override\n public void actionPerformed(ActionEvent e) {\n switch (e.getActionCommand()) {\n case \"Echo Button\": ...\n case \"Exit Button\": ...\n }\n }\n\n ...\n}\n\\```\n\n**Note:** Combining the event handlers of multiple buttons into a single function is only temporarily convenient: often, the code we want to run for one button is completely different from the code we want to run for a different button, so there’s not much benefit from merging them all. Instead, it is more common to create anonymous objects, or (even terser) lambda expressions, so that each button gets its own custom handler. We’ll see other idioms of setting up listeners below.\n\n## 5. Stage 2: Decoupling the view from the model\n\nThe code above technically works, but it is very poorly designed: the view is responsible for mutating the model, which means there’s no separation of concerns between this view and any controller, and if we wanted to use the model with another sort of view, we’d be out of luck. In the BasicMVC directory, we start to remedy this. In particular, we want to separate out all the parts of the code that mutate the model, and isolate them within a controller.\n\nTo do this, we create a `Controller` class that takes in the model and the view — at their interface types, not at their concrete class types. We revise the view so that it no longer has access to the model at all. (This is overly drastic; we merely want to ensure that the view does not have *mutable* access to the model. We can revisit this later.) We next add a method to the view interface, `void setListener(ActionListener)`, which is the key indirection needed here. Instead of the view directly implementing the response to events, this method allows the view to take in a listener object and *forward* any events it receives to that listener.\n\n\\```java\npublic class JFrameView extends JFrame implements IView {\n public JFrameView(String caption) { // NOTE: No model!\n ...\n echoButton = new JButton(\"Echo\"); // NOTE: No action listener\n echoButton.setActionCommand(\"Echo Button\");\n this.add(echoButton);\n\n exitButton = new JButton(\"Exit\");\n exitButton.setActionCommand(\"Exit Button\");\n this.add(exitButton);\n ...\n }\n\n public void setListener(ActionListener listener) {\n echoButton.addActionListener(listener); // Rather than adding *this* as a listener,\n exitButton.addActionListener(listener); // add the provided one instead.\n }\n\n ...\n}\n\npublic class Controller implements ActionListener {\n public Controller(IModel m, IView v) {\n this.model = m;\n this.view = v;\n view.setListener(this);\n view.display();\n }\n\n @Override\n public void actionPerformed(ActionEvent e) {\n switch (e.getActionCommand()) {\n case \"Echo Button\": ... // same code as before, but now\n case \"Exit Button\": ... // it's extracted out of the view\n }\n }\n}\n\\```\n\nThe controller is now the only part of the system that has mutable access to the model. Because it requested that the view register itself as the listener for the buttons, the controller gets called exactly when necessary, and it can decide what mutations to perform on the model. The view doesn’t even know that it’s received a controller object: as far as it’s aware, the controller is simply a random `ActionListener`. (**Note:** It is overly simplified to have the `Controller` directly implement `ActionListener` — after all, there might be many controls inside the view that could raise action events, and so having a *single* `ActionListener` isn’t a scalable approach. A better approach would be to have the `Controller` *have* one or more `ActionListener`s — i.e., preferring composition over inheritance — but we use this simplified form for now to reduce the number of classes in this example.)\n\n**Note:** there is a subtle difference between the `setListener` method we’ve defined on our `IView` interface, and the `addActionListener` method present on the Swing components: our method’s name implicitly intends for only *one* listener at a time, but Swing components allow for multiple listeners. When we have multiple listeners, we’ll sometimes say that the control *broadcasts* its event to whoever’s listening, or that it *publishes* its event to whoever’s *subscribed* to it. There’s nothing limiting us from implementing this more general approach, but that generality wasn’t needed here.\n\n## 6. Stage 3: Enhancing the view with keyboard support\n\nOur next addition of functionality is shown in the KeyboardEvents directory: we want to add some keyboard-triggered behaviors. Specifically, we’ll add two fancy features to our UI: the ability to toggle the color of the text from black to red and back, and the ability to temporarily show the text in all-caps. We’ll switch colors every time we type the `'d'` key, and we’ll temporarily capitalize the text while we’re pressing and holding the `'c'` key. Interestingly, only one of these two new features requires adding a new method to our view interface.\n\nFirst, we’ll need to generalize our `setListener` method, to take in a [`KeyListener`](https://docs.oracle.com/javase/8/docs/api/java/awt/event/KeyListener.html) as well as an `ActionListener`. A `KeyListener` is analogous to a `ActionListener`, but as the name suggests, it listens for keyboard-related events. There are *three* such events: when a key is pressed, when a key is typed, and when a key is released. Pressing and holding down a key for a while will typically generate one key-pressed event, several key-typed events, and one key-released event. Just as `ActionListener`s accept `ActionEvent`s, `KeyListener`s accept [`KeyEvent`s](https://docs.oracle.com/javase/8/docs/api/java/awt/event/KeyEvent.html) containing information about which key was involved. We’ll use the `keyTyped` event to toggle the color of the text, use the `keyPressed` event to capitalize the text, and use the `keyReleased` event to un-capitalize the text.\n\nFor now, we’ll simply have our controller implement the `KeyListener` interface also, and pass itself along as the second argument to `view.setListeners`. Again, note that the view doesn’t know or care that the exact same object is being passed in as the two distinct listeners: the types ensure that it doesn’t matter. (**Note:** And again, this is overly simplified, and we ought to have a distinct class implement this `KeyListener` interface, rather than have the `Controller` class do everything itself.)\n\nTo implement the color changing, we’ll need to add a method to our view interface to toggle the color of the text. This is intrinsically a view-specific thing, since the controller cannot know exactly how the text is displayed or which control it needs to change color. (That would leak internal implementation details of the view, and in any case, the controller only knows it has an `IView` rather than a particular view class.)\n\nTo implement the capitalization, note that we *do not* actually mutate the model! This is both a good thing and a necessary thing: suppose the model text contained a mixture of upper- and lower-case letters. If we mutated the model and capitalized everything, then we would not be able to undo that change later. Instead, we ask the model for its content, and inform the view that it should display a capitalized version of the that content. (This view-only change is analogous to “zooming in” while editing a picture in Photoshop or some other image editor: the view is technically displaying only a subset of the pixels of the document, and moreover is displaying them at far more than one screen pixel per document pixel! If “zooming in” actually mutated the document, then we’d lose information and be unable to “zoom out” again.)\n\n## 7. Aside 1: Low-level and high-level events\n\nWithin the `KeyListener` interface, there is a qualitative difference between the key-pressed and key-released events, and the key-typed event. Individual key events are incredibly, tediously low-level. Just trying to type a capital `'A'` generates *five* events: the Shift key was pressed; the A key was pressed; the letter `'A'` was typed; the A key was released; the Shift key was released. (The last two events might happen in either order, depending on which key was released first.) Notice that only one key-typed event occurred, though, and it contained exactly the text that was typed.\n\nIf we had to deduce which keys were typed, merely from the key-pressed and key-released events, we’d quickly lose track. Java (and most GUI toolkits) thankfully translate those sequences into higher-level key-typed events. And this translation has an addtional benefit: consider typing non-English text on a typical QWERTY keyboard. We clearly need to type mutliple physical keys to produce one logical character (this is sometimes known as “chord” input, by analogy with pressing multiple keys on a piano keyboard), and this translation lets us ignore the individual key-pressed and key-released events if we only want to consider what text was typed.\n\nOn the other hand, if we want to keep track of which keys are pressed (e.g. to control a player’s motion while a key is held down), we need to resort to the lower-level events.\n\nThis low-level/high-level distinction is not clearly defined, and depends on perspective. Would we consider `ActionEvent`s to be low-level or high-level? On the one hand, they’re clearly much *higher-level* than individual [`MouseEvent`s](https://docs.oracle.com/javase/8/docs/api/java/awt/event/MouseEvent.html), which are analogous to `KeyEvent`s and indicate when a mouse button is pressed, released, or clicked, or when it enters or exits some area. Indeed, `JButton`s register themselves as `MouseListener`s, and translate the relevant mouse-clicked event into an `ActionEvent`! (They also register themselves as `KeyListener`s, and generate `ActionEvent`s when the Enter key is pressed.) But at the same time, the *user* of our view might not care which particular buttons we happened to use to implement the view, and there might well be multiple buttons that trigger identical actions: from that perspective, action events are too *low-level* and should be implementation details hidden behind some abstraction barrier.\n\nDesigning a view and controller properly requires considering what level of detail we want to expose in the events that the view forwards to the controller. Our current designs expose far too low-level detail: “something happened with the following action command”, or “some key was pressed/typed/released”. These events are very general, and have no specific semantics for our application. Let’s consider the different enhancements we can make, using either low-level or high-level events. We’ll find that we might want to translate generic low-level events into application-specific high-level ones.\n\n## 8. Stage 4: Making the controller more flexible using low-level events\n\nMany applications run on multiple systems (e.g. Windows, Mac and Linux), and have hotkeys to perform various common actions — but the exact hotkey differs on each platform. It would be a shame to have to recompile the code in order to support these different keys. Similarly, many applications allow the user to customize the hotkeys that control the application. Here, it’s outright impossible for users to recompile the program to customize its behavior! Our next generalization aims to alleviate this lack of flexibility.\n\nOur prior attempt hard-coded the keys in the various key event-listeners. In the KeyboardMaps directory, we generalize this so that we can reconfigure hotkeys at runtime. To accomplish this, we design a new `KeyListener` implementation that uses dictionaries of `Runnable`s instead of `switch` statements in its event handlers. Specifically, our `KeyboardListener` will contain a `Map<Integer, Runnable>` dictionary for its key-pressed event handler, another such dictionary for its key-released handler, and a `Map<Character, Runnable>` dictionary for its key-typed handler. (These `Runnable`s are examples of the command pattern, which we talked about several lectures ago.)\n\nThe handlers are pleasingly straightforward:\n\n\\```java\n// In the KeyboardListener class\n@Override\npublic void keyTyped(KeyEvent e) {\n if (keyTypedMap.containsKey(e.getKeyChar()))\n keyTypedMap.get(e.getKeyChar()).run();\n}\n\n// analogously for the other two events\n\\```\n\nBecause the dictionaries are data, we can mutate them at runtime if we so choose, and therefore change which keys are mapped to which responses. (For variety’s sake, we show three different syntaxes for creating `Runnable`s: explicit classes, anonymous classes, and lambda expressions.)\n\n\\```java\n// In the Controller class\n private void configureKeyBoardListener() {\n Map<Character, Runnable> keyTypes = new HashMap<>();\n Map<Integer, Runnable> keyPresses = new HashMap<>();\n Map<Integer, Runnable> keyReleases = new HashMap<>();\n\n // Uses an explicit function-object class to provide the implementation\n keyReleases.put(KeyEvent.VK_C, new MakeOriginalCase());\n // Uses an anonymous object to provide the implementation\n keyPresses.put(KeyEvent.VK_C, new Runnable() {\n public void run() {\n String text = model.getString();\n text = text.toUpperCase();\n view.setEchoOutput(text);\n }\n });\n // Uses lambda-syntax to provide the implementation\n keyTypes.put('r', () -> { view.toggleColor(); });\n\n KeyboardListener kbd = new KeyboardListener();\n kbd.setKeyTypedMap(keyTypes);\n kbd.setKeyPressedMap(keyPresses);\n kbd.setKeyReleasedMap(keyReleases);\n\n this.view.addKeyListener(kbd);\n }\n\\```\n\n(In the same manner as this `KeyboardListener`, our implementation also generalizes the `ActionListener` implementation into a dictionary that maps action commands to `Runnable`s.)\n\nThis transformation, which converts *explicit control flow* (the `switch` statements we had earlier) into *data* (the keys of the `Map`) is a very common one in programming. We’ve clearly improved things somewhat, but we’re not finished: after all, if we hard-code the keys of the `Map` (as we did in the calls to `keyPresses.put` above), we haven’t really fixed anything, right? Fortunately, we know a way around this: by using a combination of a *reader* and *builder*, we could read in a “user preferences file” to figure out what keys to put in the maps, and then our code is completely agnostic to exactly which keys are needed for which handlers.\n\n## 9. Stage 5: Decoupling the view from the controller using high-level events\n\nThe previous generalization relied on the view exposing its low-level events to the controller. However, we might reasonably want to trigger the same behavior from multiple UI controls. In the GeneralCommandCallbacks directory, we take this approach: our view can toggle the color of the text either via a button, or via typing the `'t'` key. (This is a simplified example, but is a stand-in for typical toolbar buttons doing the same thing as hotkey shortcuts.)\n\nThe key innovation in this design is that we’ve eliminated the `ActionListener`s and `KeyListener`s from the controller and *also* from the `IView` interface. Instead, we have a new `addFeatures` method that takes in a new interface, `Features`, whose methods are the various high-level features and abilities of our view. Our *prior* interfaces exposed low-level events saying, for instance, “Hey, a button with this action command has been clicked; what should be done?” These *new* callbacks say, for example, “The user has requested to make the display uppercase; what should be done?” This interface is bigger than the `ActionListener` interface, but it’s also much more application-specific, and it advertises exactly the responsibilities a controller has to uphold for this view. It also successfully encapsulates the action commands that we leaked in prior designs: the view is now free to change those commands without breaking the controller at all.\n\nThis design is quite elegant, and does the best job of loosening the coupling between the view and the controller: by encapsulating the details of which physical controls do what, the view is much more abstracted away, and the logical interface that it presents to the controller is much more application-specific. Note that the `Controller` class and the `Features` interface know absolutely nothing about Swing: they don’t even `import` the packages! Just like our model doesn’t need to know about how it’s being displayed, so too our controller doesn’t really need to know how the views are implemented. When possible, aspire to interfaces like this one, but be prepared to fall back to lower-level events when necessary.\n\n**Note:** It might seem odd that the `toggleColor` method is both a callback on the `Features` interface *and* a method on the `IView` interface — why can’t the view handle this internally? Indeed, it possibly could! (And in some circumstances, the view definitely *should* handle some events entirely internally: for instance, when implementing a text editor, the view should probably internally handle the sequence of low-level events that indicate the user has selected a stretch of text. Once the user does something with that text — deletes it, replaces it, copies it, etc. — the view can raise a semantically relevant high-level event with the selected content.) But consider a “bigger” version of our current program, where we have *two* views that we want to keep synchronized: if either of them has toggled its color, both should toggle their colors together. The only way to ensure this synchronization is for the view to forward the event to the controller, which can in turn decide to tell *both* views how to update themselves.\n\n**Note:** Once again, in the sample code and in the snippets below, we write that the `Controller` `implements` `Features` directly: we use an is-a relationship. A better approach is to use a has-a relationship, and have a dedicated object that implements the `Features` interface instead. We omit this variant here, because there are enough other details to focus on right now!\n\n## 10. Aside 2: Designing a Features interface\n\nIn the previous section we introduced a `Features` interface, that hid the *Swing*-specific event listeners and instead exposed *application*-specific events. But how are we to know what sort of application-specific events we should have? It’s difficult to give a one-size-fits-all answer here, since by definition this will be rather application-specific. Instead, we can articulate some guidelines to follow:\n\n- Avoid any view-specific classes in the `Features` interface wherever possible. Above, we said to eliminate any mention of Swing-specific events, and generalized it further so that the controller did not need to depend on the Swing library at all. We can easily come up with a plausible counterexample to this generality: suppose we were building a drawing program, and the view allows the user to choose a color to draw with. Surely the `Features` interface should expose the `java.awt.Color` that the user picked? In this case, though, the *model* also depends on `java.awt.Color`, and so the view isn’t introducing any new dependencies. If the model chose a different class to represent its colors, then the `Features` interface ought to expose *that*, rather than the Swing color directly.\n- Treat the methods in the `Features` interface as *requests from the user*. In particular, a view might allow a user to attempt various editing operations that the controller might prohibit, or that the model might reject as invalid. In our example above, “requesting an uppercase display” fits into this mindset. Additionally, brainstorming “what might the user try to do?” can help articulate all the possible features a user might want from the program, which in turn can help design the `Features` methods needed.\n- Not all view-specific events need to turn into `Features` requests. However, events that never make it to the controller are therefore intrinsically uncontrollable. In sophisticated GUIs, a single controller might need to synchronize multiple views: for instance, a [split-screen text editor](https://camo.githubusercontent.com/c535bd502fea4873724e2bebc144d3e2f4fe075e/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f32352f3131393038312f37333938343237612d366339362d313165322d393464632d3839363462333237333131332e706e67) could have two views of the same file, whose contents should be changed in tandem. A [video editor](https://helpx.adobe.com/content/dam/help/en/after-effects/how-to/camera-animation/jcr_content/main-pars/image_1685031719/camera-animation_step2.jpg) might have a timeline view at the bottom of the screen, as well as controls for the effects and a preview window, all of which must stay consistent. A [spreadsheet](https://www.exceldashboardtemplates.com/wp-content/uploads/2017/05/Copy-an-Excel-Chart-on-Same-Worksheet-Keeps-Same-Data-Reference-Final-Copied-Charts.png) might have a grid showing many cells of data, a textbox to edit a single cell, and a graph of multiple cells’ data, again which all must stay consistent. When implementing event handlers inside a particular view, consider whether the change being handled might need to be synchronized with multiple views: if so, then it should be raised as a `Features` request. If not, then it *might* be entirely handled within the view. For instance, scrolling a single text file might not need to inform the controller that the file has been scrolled, and so scrolling could be handled entirely within the view. On the other hand, a [diff viewer](https://www.git-tower.com/blog/media/pages/posts/diff-tools-windows/037ea85d83-1690885042/meld.png) that compares two files might wnat to scroll both files in unison, and so any scroll changes would need to be raised to the controller’s attention so that it can synchronize both views.\n- When a `Features` event is raised to the controller’s attention, the view *probably* shouldn’t mutate itself, but rather wait for the controller to tell it to do so — this is in keeping with thinking of features as requests rather than demands. We noted this above, where `toggleColor` was both a method in the `Features` interface and also a method on the view, and the controller’s implementation of the `toggleColor` method turned around and called the view’s method, and we said this might seem overly roundabout. We gave one example where this was needed for synchronization of multiple views. Another might be triggering some resource-limited effect (where the resource might be tracked by the model, like in-game bonuses, or the resource might be controller-specific, like live-streaming a video of a gameplay). The view shouldn’t modify itself until the controller (and possibly model too) has confirmed that the request can go through.\n- Any event that is handled entirely within the view is intrinsically more difficult to test. We would have to synthesize the low-level UI events, which may be impractical or even impossible to do sufficiently. By decoupling the particular UI event that triggers behavior from the `Features` implementation that actually provides the behavior, we limit the hard-to-test code to just the “wiring” between the event listeners and the `Features` object. Since all the interesting behavior is now in the `Features` object, and since its methods depend only on application-specific concepts and types, we can easily create a mock view that triggers `Features` methods without needing the actual Swing events. This allows for test cases analogous to those we saw in [Lecture 8](https://course.ccs.neu.edu/cs3500/lec_controllers_mocks_notes.html), with all the benefits they bring.\n\n## 11. Stage 6: Further enhancements using `InputMap`s and `ActionMap`s\n\nOur last revision eliminated the flexibility of dynamically changing hotkeys and reverted to hard-coding the keys in the view’s implementation of its own key listener. Combining the flexibility of the `KeyboardListener` and its dictionaries, with the high-level events of the `Features` interface, is aesthetically tricky: who should control which keys do what? In some sense, it almost feels like the choice should be made not by our current controller, which is controlling a particular model and view, but rather to some hypothetical “application controller”, that controls the overall application. We’ve already encountered this in practice: in IntelliJ, there are both project-specific settings and application-wide settings, and different dialogs control those different features.\n\nAdditionally, implementing the keyboard-listening dictionaries is tedious: surely this functionality could be implemented once and for all, and we wouldn’t need to redo it in every single application?\n\nThe solution, once again, is a layer of indirection. We’ve seen above that Swing components have a notion of an *action command*, and that we can cause code to run depending on which action was triggered. Combining several of these actions together should seem reminiscent of the `KeyboardListener` dictionaries we just built. In fact, Swing has a concept of an [`ActionMap`](https://docs.oracle.com/javase/8/docs/api/javax/swing/ActionMap.html), which is essentially just such a dictionary from action commands to actions.[1](https://course.ccs.neu.edu/cs3500/lec_gui_basics_notes.html#(counter-()._(gentag._23._lecturegui_basics))) An `Action` in Swing has many potential subclasses; we’ll focus on the `AbstractAction` class, which we can subclass ourselves to create new action handlers. For instance, we might write\n\n\\```java\nAction makeOriginalCase = new AbstractAction() {\n public void actionPerformed(ActionEvent e) {\n String text = model.getString();\n view.setEchoOutput(text);\n }\n};\nAction makeCaps = new AbstractAction() {\n public void actionPerformed(ActionEvent e) {\n String text = model.getString();\n text = text.toUpperCase();\n view.setEchoOutput(text);\n }\n};\nAction toggleColor = new AbstractAction() {\n public void actionPerformed(ActionEvent e) {\n view.toggleColor();\n }\n};\n\\```\n\nThis is all well and good, and now we have yet one more way of representing runnable bits of code, but how should we actually associate these actions with their keyboard triggers? First, we associate these `Action`s with their action commands:\n\n\\```java\n// Somewhere in our View class:\n\naComponent.getActionMap().put(\"restoreLowercase\", makeOriginalCase);\naComponent.getActionMap().put(\"makeCaps\", makeCaps);\naComponent.getActionMap().put(\"toggleColor\", toggleColor);\n\\```\n\nWe then need the second piece of the indirection: an [`InputMap`](https://docs.oracle.com/javase/8/docs/api/javax/swing/InputMap.html). `InputMap`s associate [`KeyStroke`s](https://docs.oracle.com/javase/8/docs/api/javax/swing/KeyStroke.html) with action commands. A `KeyStroke` describes our key-press, key-release, and key-type low-level events in a uniform manner. When a low-level key event matches something in an `InputMap`, the associated action command is looked up in the `ActionMap` and fired. So we can continue our code as follows:\n\n\\```java\n// Somewhere in our View class:\n\n// Use simplest constructor to describe a key-press\naComponent.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_C), \"makeCaps\");\n// Use another constructor to describe key-releases\naComponent.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_C, true), \"restoreLowercase\");\n// Yet another constructor lets us describe key-typed events\naComponent.getInputMap().put(KeyStroke.getKeyStroke(\"typed r\"), \"toggleColor\");\n\\```\n\n**Note:** `InputMap`s and `ActionMap`s apply only to `JComponent`s, and not to `JFrame`s directly. However, we can easily add a component to our frame for the sole purpose of handling key events, and we [can specify](https://docs.oracle.com/javase/tutorial/uiswing/misc/keybinding.html) that its `InputMap` be used whenever the frame has focus at all.\n\nThis seems like a lot of machinery to introduce, and it would be unwieldy if it weren’t so reusable. The critical design patterns here are:\n\n- We have a mechanism for translating low-level (`KeyEvent`s) into mid-level action commands.\n- We have transformed control flow (of what code to run based on what key was pressed) into data (a map of `KeyStroke`s).\n- We have a mechanism from translating mid-level action commands into actual runnable actions.\n\nThe code still suffers from one problem: the `Action`s themselves feel like they belong in the controller (since they refer to `model` and `view`), but are referenced directly in the view (in the `getActionMap().put(...)` lines). We can combine these maps with our `Features` design, to get one final translation from mid-level action commands to high-level events:\n\n\\```java\n// NOTE: this class makes no mention of Actions or Controllers.\npublic class JFrameView extends JFrame implements IView {\n KeyComponent keyComponent;\n\n public JFrameView(String caption) {\n super(caption);\n ...\n this.keyComponent = new KeyComponent();\n this.add(keyComponent);\n }\n\n public void setHotKey(KeyStroke key, String featureName) {\n this.keyComponent.getInputMap().put(key, featureName);\n }\n\n public void addFeatures(Features features) {\n this.keyComponent.addFeatures(features);\n }\n}\n\n// NOTE: Neither does this class! It only refers to Features.\nclass KeyComponent extends JPanel {\n List<Features> featureListeners = new ArrayList<>();\n\n // Includes this new feature listener in responding to keys\n void addFeatures(Features f) { this.featureListeners.add(f); }\n\n KeyComponent() {\n // Install action command -> Feature callback associations\n this.getActionMap().put(\"makeCaps\", new AbstractAction() {\n public void actionPerformed(ActionEvent e) {\n for (Features f : featureListeners)\n f.makeUppercase();\n }\n });\n this.getActionMap().put(\"restoreLowercase\", new AbstractAction() {\n public void actionPerformed(ActionEvent e) {\n for (Features f : featureListeners)\n f.restoreLowercase();\n }\n });\n this.getActionMap().put(\"toggleColor\", new AbstractAction() {\n public void actionPerformed(ActionEvent e) {\n for (Features f : featureListeners)\n f.toggleColor();\n }\n });\n ...\n }\n}\n\n// NOTE: Only the Controller needs to know how to implement Features.\npublic class Controller implements Features {\n private IModel model;\n private IView view;\n\n ...\n\n // These are the high-level event handlers we care about:\n @Override\n public void toggleColor() {\n view.toggleColor();\n }\n\n @Override\n public void makeUppercase() {\n String text = model.getString();\n text = text.toUpperCase();\n view.setEchoOutput(text);\n }\n\n @Override\n public void restoreLowercase() {\n String text = model.getString();\n view.setEchoOutput(text);\n }\n\n // This attaches this controller as our features listener\n public void setView(IView v) {\n this.view = v;\n view.addFeatures(this);\n\n // Choose the keys we want\n view.setHotKey(KeyStroke.getKeyStroke(\"pressed c\"), \"makeCaps\");\n view.setHotKey(KeyStroke.getKeyStroke(\"released c\"), \"restoreLowercase\");\n view.setHotKey(KeyStroke.getKeyStroke(\"typed r\"), \"toggleColor\");\n }\n\n ...\n}\n\n\\```\n\n## 12. Exercises\n\nAt the top of this lecture are starter files for a GUI version of the Turtles example we worked through in [Lecture 10](https://course.ccs.neu.edu/cs3500/lec_commands_notes.html). The `TurtleGraphicsView` does not currently do anything. Enhance this code with a new `TurtlePanel` class that `extends JPanel`, and override its `paintComponent` method to draw whatever you want, just to confirm that it works.\n\nNext, enhance the `IView` interface so you can pass the relevant information from the model, through the controller, into the view and into your `TurtlePanel` class. Once you’ve connected the pieces, use this information in your `paintComponent` implementation to draw the turtle’s trace.\n\nThe links at the top of the lecture include a “solution” implementation; do not to look at that until you’ve tried to implement this yourself.\n\nThe `IView` interface contains one method for setting up an event listener. What is its signature? Does it seem like a high-level event to you, or a low-level one? If you think it’s too low-level, can you think of a better, higher-level signature to use? If you think it’s sufficiently high-level, why do you think so?\n\n\n\n1`Action`s themselves are more generally useful in Swing than just for keyboard interaction, but we’ll focus on just the keyboard part here.我们会先展示一个文本界面版本，随后演示如何切换到图形界面（GUI），以及如何一步步改进、解耦视图和控制器、处理键盘事件等。
\nIModel.javaget/set 字符串的方法，供后续 view 和 Controller 调用。public interface IModel {\n /**\n * 获取当前存储的字符串\n * @return 模型中的字符串\n */\n String getString();\n\n /**\n * 设置新的字符串\n * @param str 要设置的新字符串\n */\n void setString(String str);\n}代码逐行注释：
\npublic interface IModel { ... }：定义一个接口，命名为 IModel。String getString();：声明一个方法用于读取当前字符串。void setString(String str);：声明一个方法用于更新当前字符串。代码名称：Model.java
功能：IModel 接口的具体实现，内部用一个 String 来存储数据。
public class Model implements IModel {\n private String data;\n\n /**\n * 构造函数，初始化字符串为空或给定初值\n */\n public Model() {\n this.data = \"\";\n }\n\n @Override\n public String getString() {\n return this.data;\n }\n\n @Override\n public void setString(String str) {\n this.data = str;\n }\n}代码逐行注释：
\npublic class Model implements IModel：类 Model 实现了 IModel 接口。private String data;：私有字段 data 用于实际存储字符串内容。public Model()：构造函数，将 data 初始化为空字符串（当然也可改为接受一个初始值）。public String getString()：实现接口方法，返回当前存储的字符串。public void setString(String str)：实现接口方法，修改存储的字符串。代码名称：IView.java
功能：定义了一个最简单的视图接口，能够显示信息，以及（可选）展示错误消息等。这里只做最基本的打印操作。
\npublic interface IView {\n /**\n * 显示给用户看的输出\n * @param message 要显示的内容\n */\n void showMessage(String message);\n\n /**\n * 显示错误信息\n * @param error 要显示的错误信息\n */\n void showError(String error);\n}代码逐行注释：
\npublic interface IView { ... }：定义视图接口 IView。void showMessage(String message);：向用户显示普通文本消息。void showError(String error);：向用户显示错误信息或提示。TextView.javaIView 的具体实现，把消息打印到给定的输出流（如控制台）。import java.io.PrintStream;\n\npublic class TextView implements IView {\n private final PrintStream out;\n\n /**\n * 构造函数\n * @param out 指定要输出的流，比如 System.out\n */\n public TextView(PrintStream out) {\n this.out = out;\n }\n\n @Override\n public void showMessage(String message) {\n out.println(message);\n }\n\n @Override\n public void showError(String error) {\n out.println(\"ERROR: \" + error);\n }\n}代码逐行注释：
\nprivate final PrintStream out;：用来存放输出流（比如 System.out，也可以是测试时的假输出）。PrintStream out 并保存，方便后续统一打印。showMessage：实现接口方法，直接打印普通信息。showError：实现接口方法，在打印时加上 \"ERROR: \" 前缀以示区别。IController.javastart() 方法，开始接管程序流程。public interface IController {\n /**\n * 开始执行程序逻辑\n */\n void start();\n}TextController.javaIModel、IView 以及用户输入（通过 Scanner 读取）。循环读取用户命令，进行相应处理。import java.util.Scanner;\n\npublic class TextController implements IController {\n private final IModel model;\n private final IView view;\n private final Scanner sc;\n\n /**\n * 构造函数\n * @param model 模型\n * @param view 视图\n * @param sc 用于读取用户输入的扫描器\n */\n public TextController(IModel model, IView view, Scanner sc) {\n this.model = model;\n this.view = view;\n this.sc = sc;\n }\n\n @Override\n public void start() {\n view.showMessage(\"欢迎使用文本版程序！\");\n boolean running = true;\n while (running) {\n view.showMessage(\"请输入操作：\\n\" +\n \"1: 查看当前字符串\\n\" +\n \"2: 设置新的字符串\\n\" +\n \"q: 退出程序\");\n String input = sc.nextLine().trim();\n switch (input) {\n case \"1\": // 查看当前字符串\n String current = model.getString();\n view.showMessage(\"当前字符串为: \" + current);\n break;\n case \"2\": // 设置新的字符串\n view.showMessage(\"请输入新字符串：\");\n String newVal = sc.nextLine();\n model.setString(newVal);\n view.showMessage(\"已更新字符串！\");\n break;\n case \"q\": // 退出\n running = false;\n view.showMessage(\"程序已退出。\");\n break;\n default:\n view.showError(\"未知命令，请重新输入。\");\n }\n }\n }\n}代码逐行注释：
\nmodel, view, sc 三个私有字段，分别负责模型、视图和输入。public TextController(IModel model, IView view, Scanner sc)：构造函数中注入这三者。start()：核心方法，用 while 循环反复让用户输入命令。switch (input)）来做不同的操作：\n\"1\"：读取并打印当前字符串\"2\"：让用户输入新的字符串并更新到模型中\"q\"：退出循环并结束程序MainText.java（示例主类）import java.util.Scanner;\n\npublic class MainText {\n public static void main(String[] args) {\n IModel model = new Model(); // 创建模型\n IView view = new TextView(System.out); // 创建文本视图，输出到控制台\n Scanner sc = new Scanner(System.in); // 创建扫描器读取用户输入\n\n IController controller = new TextController(model, view, sc);\n controller.start(); // 启动文本版程序\n }\n}代码逐行注释：
\nIModel model = new Model();：实例化我们刚才写的 Model。IView view = new TextView(System.out);：文本视图使用 System.out 输出到控制台。Scanner sc = new Scanner(System.in);：从控制台读取用户输入。IController controller = new TextController(model, view, sc);：组装 MVC 三要素。controller.start();：启动控制器，程序进入循环运行。运行该 main 方法后，您可以在控制台依照提示输入指令来操作模型的字符串。
下面我们开始引入图形界面（GUI）。先做一个“坏设计但能运行”的简单版本，让大家看到最基本的 Swing 用法。这个版本会让“视图”直接持有并修改 Model，从而破坏了 MVC 的解耦原则，但能让我们先快速见识到 Swing 编程的主要元素：JFrame, JLabel, JButton, JTextField 等。
JFrameView.javaJFrame)，里面含有一个输入框、两个按钮和一个标签；当点击按钮时，直接操作 Model。import javax.swing.*;\nimport java.awt.*;\nimport java.awt.event.ActionEvent;\nimport java.awt.event.ActionListener;\n\npublic class JFrameView extends JFrame implements ActionListener {\n private final IModel model;\n private final JLabel display; // 用于显示文本\n private final JTextField input; // 用户输入的文本框\n private final JButton echoButton; // Echo 按钮\n private final JButton exitButton; // Exit 按钮\n\n public JFrameView(String caption, IModel model) {\n super(caption);\n this.model = model;\n this.setLayout(new FlowLayout());\n\n // Label\n display = new JLabel(\"初始状态\");\n this.add(display);\n\n // TextField\n input = new JTextField(10); // 宽度10列\n this.add(input);\n\n // Echo 按钮\n echoButton = new JButton(\"Echo\");\n echoButton.setActionCommand(\"Echo Button\");\n echoButton.addActionListener(this); // 直接由自己处理监听\n this.add(echoButton);\n\n // Exit 按钮\n exitButton = new JButton(\"Exit\");\n exitButton.setActionCommand(\"Exit Button\");\n exitButton.addActionListener(this);\n this.add(exitButton);\n\n this.pack(); // 让布局生效\n this.setVisible(true); // 显示窗口\n this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n }\n\n @Override\n public void actionPerformed(ActionEvent e) {\n switch (e.getActionCommand()) {\n case \"Echo Button\":\n // 直接修改 model\n model.setString(input.getText());\n display.setText(model.getString());\n break;\n case \"Exit Button\":\n System.exit(0);\n break;\n default:\n // do nothing\n }\n }\n}代码逐行注释：
\nextends JFrame implements ActionListener：让类本身既是一个窗口，又直接处理按钮点击事件。this.setLayout(new FlowLayout());：使用流式布局，让控件依次放置。JLabel, JTextField, 两个 JButton，并将它们添加到框架中。echoButton.setActionCommand(\"Echo Button\");：设置按钮的“命令字符串”，后面在 actionPerformed 里区分。echoButton.addActionListener(this);：将当前对象本身作为监听器。actionPerformed 中，通过 switch 判断是哪个按钮被点击：\n\"Echo Button\"：把输入框的内容写入模型，再将模型里的新值更新到标签显示。\"Exit Button\"：退出程序。MainBadGUI.javapublic class MainBadGUI {\n public static void main(String[] args) {\n IModel model = new Model();\n // 直接把 Model 传给 View，违反了解耦原则，但可用\n JFrameView view = new JFrameView(\"Bad GUI Demo\", model);\n }\n}这样就能弹出一个窗口，点击 Echo 会直接改模型，点击 Exit 会关闭程序。
\n为了让我们的 MVC 架构更清晰，我们希望视图不要直接调用 model.setString。而是把对模型的修改统一交给 Controller 来处理。
思路：
\nmodel；只提供获取文本、显示文本等方法。model 和 view，并把自己注册给 view，让 view 把事件再转给 controller。Controller 说明：
\n现在 JFrameView 不再直接操作 model，而是把按钮的点击事件通过 ActionListener 转给 Controller。
Controller 持有 model，因此可以安全地进行 model.setString(...)，然后再告诉 view 更新界面。
回顾我们在文本版和图形版的示例时，会发现两套 IView/View 的接口和实现不同：
showMessage(...)、showError(...) 方法。getInputString()、clearInputString()、setEchoOutput()、display() 等方法，可能并未包含 showMessage(...)。如果你的控制器里还保留了对 view.showMessage(...) 的调用（大概率是从文本版代码沿用过来的），那就会和新的图形版 IView 接口冲突，编译时报错。
IView 中补充 showMessage(...) 方法IView 要点：
\nshowMessage(String msg) 和 showError(String err) 这两个方法。getInputString(), setEchoOutput() 等）保持原状。你好，我是悦创。
\n不知道大家 2025 年过得怎么样？反正我是没怎么过好，春节开始就忙得很。起因就是 DeepSeek 这货在春节前突然就成了网红了。红到什么程度呢？过年走亲戚，听到最多的就是俩词——哪吒和 DeepSeek。连我 58 岁的大爷都在问我，悦创啊，你说抖音剪视频是不是也能用 “第普谁课” 啊？听得我人都麻了。
\n这热度，你说领导能坐得住？于是整个春节，都在忙着做规划，布局 DeepSeek。然后春节之后，各云厂商就纷纷宣布自己的平台支持 DeepSeek 了，而且我的老东家“浪潮”和现任东家“联通云”都先后推出了 DeepSeek 一体机，很受政企客户欢迎。这让我想起了《飞驰人生 2》里贾冰的一句台词，“过年的时候啊，像什么法拉顺利啊，保时敏捷啊，黄博基尼啊，哎呀，疯抢啊”。
\n这热度，你还坐得住吗？是不是也想跑步入场，学习一下 AI ，拥抱一下 DeepSeek 呢？然而我们自己去摸索相关资料时，可能很快就会被一堆专业名词、机器学习算法的深奥知识劝退。看着 AIGC 一浪高过一浪的新技术涌现，就是不知道自己如何投身其中。
\n对于这个问题，这里我想给你分享一下我的一些经历。
\n事实上，我们知道，DeepSeek 爆火是今年春节前后的事情，DeepSeek 模型能力强，还开源，直接让国人的 AI 热情空前高涨，极大推动了国内应用 AI 化的发展进程。2025 年，绝对将会是 AI 应用发展的革命年，用不了多久，AI 旋风就会席卷到各个行业。
\n我在差不多两年前，GPT 模型刚刚发布时，就开始投身到 AI 应用开发的实践中，那个时候，没有 LangChain，没有 Agent，也没有 RAG，大家就是琢磨着如何在提示词上做文章，去完成传统应用做不到的事情。
\n比如，在当时，我就考虑如何用 AI 重塑 K8s 管理系统，让用户可以用自然语言去操作 K8s 资源，而不是在传统 UI 上点点点。我的思路是在模板中预置了一些规则以及挖了空的 API，比如 GET /v1/{resourceName}/{Namespace}，之后让大模型根据用户输入的 prompt 去填空，比如用户说：帮我查询 default 命名空间下的 pod，大模型就会把上面的 API 组装成 GET /v1/pods/default，此时后端便可以调用这条 API，拿到资源了。
这种方法在当时很新鲜，但在出了 Function Calling 以及 Agent 技术后，便迅速被淘汰了。像这样的案例还有很多，很多 AI 开发者都是在技术不断地发展中，摸爬滚打前行。
\n直到去年中旬之后，基本上 AI 应用开发的路线开始进入了一个相对稳定的阶段，核心的两大技术就是 Agent 与 RAG，具体实现方式则有很多框架做支撑，但其实都是殊途同归。此时制约应用实现效果的瓶颈便是大模型的能力了，作为国内开发者，除了部分出海项目可以使用 GPT 模型外，大多数项目受制于国内大模型的能力问题，只能做的差强人意。
\n但随着 DeepSeek 系列模型的发布，国内终于有了一款能够比肩 GPT 的模型，这使得很多优秀的开发框架和技术也能够站在巨人的肩膀上，发挥出更好的作用。
\n因此，我希望出一套课程，深刻挖掘一下 DeepSeek 在应用开发中的能力，同时在课程中使用目前最主流的 AI 应用开发思想、套路、工具以及框架。对于 AI 开发老鸟，可以与时俱进，查漏补缺，掌握业界前沿的开发思想和工具；而对于 AI 开发新手，则可以绕过过去几年我摸爬滚打的弯路，借力 DeepSeek，快速入门 AI 应用开发领域。
\n为此，我将课程划分成了一个前置章节和五个正式章节。
\n前置课程里，我想和绝大多数像我一样的“民用级”程序员聊聊天，一起探讨一下在 DeepSeek 如此火爆的背景下，应该如何入场，以及入场上有哪些可探索的方向。之后还会学习做 AI 应用开发不可或缺的 Agent 技术。
\n第一章，我会为揭秘云厂商针对不同的客户群体，私有化部署 DeepSeek 的几种不同方案。包括单卡的量化版部署、多卡的高可用负载均衡方案、多卡的分布式部署方案以及在消费级硬件，比如纯 CPU 上部署 DeepSeek 的方案等等。最后我们还会体验一下如何微调和蒸馏 R1 大模型。
\n第二章我们将会一起打造一个求职助手。求职找工作写简历，是我们每个职场人都经历过的事情。那我们是否可以告别传统肉眼搜索职位，手工写简历的方式呢？
\nDeepSeek 的深度思考能力以及超强的写作能力，给了我们启发。这个项目不使用 Agent，而是会采用去年 9 月份，Anthropic 公司（Claude 模型的母公司）推出的**模型上下文协议（MCP）**来实现。通过 MCP，可以让大模型连接本地文件系统、数据库、调用工具等等。
\n第三章我们来实现一个 AI 版的“作业帮”，这个项目是聚焦 DeepSeek 的又一大出色能力——数学理解力。我们从“作业帮”项目切入，一起学习多模态、RAG 等热点技术。除此之外，这个项目采用了 AI 开发的另一种思想——平台化开发，可以零代码构建出 Agent 与工作流。搭配平台的 API，实现自然语言前端、Agent 和工具的分离。
\n第四章我们来实现一个智能编程助手。代码能力是 DeepSeek 的亮点之一，目前已经有多个智能编程软件宣布接入了 DeepSeek。所以这个项目我们不打算重复造轮子，而是要以构建 Golang 的 Web 后端项目为例，带你掌握如何让 AI 稳定生成固定项目代码风格的代码。这个项目会使用目前非常热门的 LangGraph 框架完成。
\n第五章我们来探索一下 AI 与金融领域的结合。DeepSeek 的母公司幻方量化是一家著名金融量化公司。因此 DeepSeek 在训练数据集上必然也会有很多的金融领域相关数据做支撑，所以用 DeepSeek 做金融项目，会有先天优势。
\n此外，最近一年内，好几个知名大模型厂商和平台都举办了以金融为主题的 AI 大赛，旨在探索行业解决方案以及挖掘既懂业务又懂技术的人才。所以这一章我们就以 A 股市场为主题，做一下探索性的开发，包括股票名称代码查询、数据分析统计、简单量化策略等。
\n你会发现，整个课程几乎都是以内容紧凑的实践课程组成的，且每个项目都聚焦了 DeepSeek 模型的某个特点。整门课程的交付目标就是，为你提炼 DeepSeek 应用开发的核心经验，帮助你提升 AI 应用开发的工程化能力。
\n欢迎你和我一起学习讨论，让我们开始行动起来吧！
\n我是一家大型银行的科技条线基层工作者，今年来了之后，我也是真的能感受到从上之下的公司内部开始非常重视AI、大模型的应用。 我自己也觉得这对于个人也是一个机会，一定要努力过才不会后悔。 希望大家都参与进来，一起努力构建一个好课
\n\n\n作者回复: 感谢同学支持，用习主席的话来说，这就是百年未有之大变局啊
\n
AI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Linux、Web、Sql」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n随着 DeepSeek 系列模型的发布，国内终于有了一款能够比肩 GPT 的模型，这将极大推动国内应用 AI 化的发展进程。2025 年 AI 应用发展的步伐会变得更快。
\n无论是否是计算机或 AI 专业出身，每个人都有机会在 AIGC 浪潮中找到自己的位置。为了帮助你与时俱进，快速拥抱 DeepSeek 等前沿技术，我们邀请了 AI悦创开设这门课程，带你学习如何基于 DeepSeek，综合提升自己的 AI 应用开发工程化能力。
\n本课程将会涉及当前业界**最主流的 AI 应用开发思想、套路、工具以及框架，设计的实战项目也会聚焦 DeepSeek 模型的某个特点。**对于 AI 开发老鸟，可以与时俱进，查漏补缺，掌握业界前沿的开发思想和工具；而对于 AI 开发新手，则可以绕过过去几年我摸爬滚打的弯路，借力 DeepSeek，快速入门 AI 应用开发领域。
\n课程分为六个章节，具体设计思路如下：
\n**前置课程：**探讨普通程序员如何使用和学习 DeepSeek，有哪些探索方向，并学习 AI 应用开发不可或缺的 Agent 技术。
\n**第一章：**揭秘云厂商针对不同的客户群体，私有化部署 DeepSeek 的几种不同方案。包括单卡的量化版部署、多卡的高可用负载均衡方案、多卡的分布式部署方案以及在消费级硬件，比如纯 CPU 上部署 DeepSeek 的方案等等。最后还将体验如何微调和蒸馏 R1 大模型。
\n**第二章：**利用 DeepSeek 的深度思考能力以及超强的写作能力，开发一个求助助手。本项目还会引入模型上下文协议（MCP）来让模型连接本地文件系统、数据库、调用工具等等。
\n**第三章：**利用 DeepSeek 出色的数学理解力，用平台化开发的方式，构建一个 AI 版“作业帮”，该项目还将涉及多模态、RAG、工作流等热点技术。
\n**第四章：**代码能力是 DeepSeek 的亮点之一，目前已经有多个智能编程软件宣布接入了 DeepSeek。所以这个项目我们不打算重复造轮子，而是以构建 Golang 的 Web 后端项目为例，利用目前非常热门的 LangGraph 框架，让 AI 稳定生成固定项目代码风格的代码。
\n**第五章：**探索 AI 与金融领域的结合，我们将以 A 股市场为主题，做一下探索性的开发，包括股票名称代码查询、数据分析统计、简单量化策略等。
\n课程代码库（随上线进度动态更新）：https://github.com/AndersonHJB/BornforthisData
\nAI悦创·编程一对一
\nAI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Linux、Web、Sql」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
\nC++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
\n方法一：QQ
\n方法二：微信：Jiabcdefh
\n\n\nwith Ollama, LangChain, LangGraph (No GPU, No APIKEY)
\n
Prompt Engineering is the practice of designing and refining prompts (text inputs) to enhance the behavior of Large Language Models (LLMs). The goal is to get the desired responses from the model by carefully crafting the instructions. The most used prompting techniques are:
\n\n\nLet’s make an example: imagine asking an AI to “find the best laptop under $1000”.
\n\n
\n- \n
\nNormal Answer: “Lenovo Thinkpad”.
\n- \n
\nChain-of-Thought Answer: “I need to consider factors like performance, battery life, and build quality. Then, I would check which laptops are priced under $1000. According to my knoweldge base, the Lenovo Thinkpad is the best”.
\n- \n
\nReAct Answer: Same as the Chain-of-Thought Answer + the Action of performing a web-search for “best laptops under $1000 in 2024” and analyze the results (which might not be “Lenovo Thinkpad”).
\n
Agents are created using the ReAct technique, so the main difference with LLMs is the ability to take action. Agents are AI systems designed to process sequential reasoning, with the option of executing external tools (i.e. database query, web search) in case the LLM’s general-purpose knowledge isn’t enough. To put it simply, a normal AI Chatbot generates random text when it doesn’t know how to answer a question, but an Agent activates its tools to fill the gap and give a specific response.
\nIn this tutorial, I’m going to build from scratch a multi-agent system with human-in-the-loop. I will present some useful Python code that can be easily applied in other similar cases (just copy, paste, run) and walk through every line of code with comments so that you can replicate this example (link to the full code below).
\nhttps://github.com/AndersonHJB/BornforthisData
\nIn particular, I will go through:
\nAt the moment, there are 2 libraries for LLMs and Agents that are trying to become the main framework in the market:
\nI shall use the former as it’s more flexible. By installing LangChain (pip install langchain) you will gain access to all the modules.
Additionally, I’m going to install LangGraph (pip install langgraph) for building Agents using a node-edges style of workflow.
I will run my LLM locally using Ollama (pip install ollama) and I shall pick Meta’s Llama 3.1 because it’s the smartest LLM that you can run without GPUs.
import ollama\n\nllm = \"llama3.1\"\nq = '''who died on September 9, 2024?'''\n\nres = ollama.chat(model=llm, \n messages=[{\"role\":\"system\", \"content\":\"\"},\n {\"role\":\"user\", \"content\":q}])\nresAs expected, the LLM knowledge is limited to the date of its last training. Please note that there are 3 roles in the interaction with a LLM chatbot:
\nOne of the most common tools is the ability to search the Internet. In Python, the easiest way to do it is with the famous private browser DuckDuckGo (pip install duckduckgo-search).
Since I’m using Ollama, there are two options for creating a tool. First, with the standard decorator from LangChain (this is the most frequently used).
\nfrom langchain_core.tools import tool\nfrom langchain_community.tools import DuckDuckGoSearchRun\n\n@tool(\"tool_browser\")\ndef tool_browser(q: str) -> str:\n \"\"\"Search on DuckDuckGo browser by passing the input `q`\"\"\"\n return DuckDuckGoSearchRun().run(q)\n\n# test\nprint( tool_browser(q) )Second, by creating a normal function and turning it into an Ollama schema with Semantic Router (pip install semantic-router), a library to simplify tool-making.
from semantic_router.utils.function_call import FunctionSchema\n\ndef browser(q:str) -> str:\n \"\"\"Search on DuckDuckGo browser by passing the input `q`\"\"\"\n return DuckDuckGoSearchRun().run(q)\n\ntool_browser = FunctionSchema(browser).to_ollama()\ntool_browserAmong the tools, we shall also include the final answer: after every question from the user, the Agent must decide whether to use a tool or give the final answer. Please note that the more specific you describe the answer structure, the better it works.
\n@tool(\"final_answer\")\ndef final_answer(text:str) -> str:\n \"\"\"Returns a natural language response to the user by passing the input `text`. \n You should provide as much context as possible and specify the source of the information.\n \"\"\"\n return textWe need to do some Prompt Engineering to define what the Agent must do and how.
\nprompt = \"\"\"\nYou know everything, you must answer every question from the user, you can use the list of tools provided to you.\nYour goal is to provide the user with the best possible answer, including key information about the sources and tools used.\n\nNote, when using a tool, you provide the tool name and the arguments to use in JSON format. \nFor each call, you MUST ONLY use one tool AND the response format must ALWAYS be in the pattern:\n```json\n{\"name\":\"<tool_name>\", \"parameters\": {\"<tool_input_key>\":<tool_input_value>}}\n```\nRemember, do NOT use any tool with the same query more than once.\nRemember, if the user doesn't ask a specific question, you MUST use the `final_answer` tool directly.\n\nEvery time the user asks a question, you take note of some keywords in the memory.\nEvery time you find some information related to the user's question, you take note of some keywords in the memory.\n\nYou should aim to collect information from a diverse range of sources before providing the answer to the user. \nOnce you have collected plenty of information to answer the user's question use the `final_answer` tool.\n\"\"\"Using Ollama, we can test the decision-making process of the Agent right away. We need to tell the Agent what tools are available to use.
\ndic_tools = {\"tool_browser\":tool_browser, \n \"final_answer\":final_answer}\n\nstr_tools = \"\\n\".join([str(n+1)+\". `\"+str(v.name)+\"`: \"+str(v.description) for n,v in enumerate(dic_tools.values())])\n\nprompt_tools = f\"You can use the following tools:\\n{str_tools}\"\nprint(prompt_tools)The prompt and the tools, combined with the LLM, define the core of the Agent. At this point, our AI should be able to decide what to do. For instance, if I don’t ask any question, it should go directly for the final answer.
\n# LLM deciding what tool to use\nfrom pprint import pprint\n\nllm_res = ollama.chat(\n model=llm,\n messages=[{\"role\":\"system\", \"content\":prompt+\"\\n\"+prompt_tools},\n {\"role\":\"user\", \"content\":\"hello\"}\n ], format=\"json\")\n\npprint(llm_res)Inversely, when I ask something specific, the Agent should use the web-search tool and generate the input query for it, based on my request.
\n# LLM deciding what tool to use (output format = json)\nllm_res = ollama.chat(\n model=llm,\n messages=[{\"role\":\"system\", \"content\":prompt+\"\\n\"+prompt_tools},\n {\"role\":\"user\", \"content\":q}\n ], format=\"json\")\n\nllm_res[\"message\"][\"content\"]We can check how the Agent processes the result of the query, by passing it as the context for the LLM.
\n# LLM with context\nimport json\n\ntool_input = json.loads(llm_res[\"message\"][\"content\"])[\"parameters\"][\"q\"]\n\ncontext = tool_browser(tool_input)\nprint(\"tool output:\\n\", context)\n\nllm_output = ollama.chat(\n model=llm,\n messages=[{\"role\":\"system\", \"content\":\"Give the most accurate answer using the folling information:\\n\"+context},\n {\"role\":\"user\", \"content\":q}\n ])\n\nprint(\"\\nllm output:\\n\", llm_output[\"message\"][\"content\"])It’s confirmed that the core model works. But, sometimes LLMs can generate incorrect and inconsistent content (so called “hallucinations”), therefore it’s common practice to specify the data structure that the model must follow.
\nGenerally, LLMs work with API calls, so both input and output must follow a specific Data Structure. In Python, the most widely used library for data validation is Pydantic: it makes sure the information your program uses is in the right format and has the right values.
\nBasically, the goal is to transform the LLM response, which is not “stable”, into an Agent response, a structured and validated object.
\nTo start, you create a class that describes the data you want, including its type and any rules it must follow. Pydantic checks if the data is correct, and if not, it gives you a clear error message. That is particularly useful because responses from the LLM can vary after each run.
\nfrom pydantic import BaseModel #this is the standard class\n\n# Taking for example the last LLM response, I want this structure:\n# {tool_name: 'tool_browser', \n# tool_input: {'q':'September 9 2024 deaths'}, \n# tool_output: str( tool_browser({'q':'September 9 2024 deaths'})) }\n\nclass AgentRes(BaseModel):\n tool_name: str #<--must be a string = 'tool_browser'\n tool_input: dict #<--must be a dictionary = {'q':'September 9 2024 deaths'}\n tool_output: str | None = None #can be a string or None, default = None\n \n @classmethod\n def from_llm(cls, res:dict): #<--return the class itself\n try:\n out = json.loads(res[\"message\"][\"content\"])\n return cls(tool_name=out[\"name\"], tool_input=out[\"parameters\"])\n except Exception as e:\n print(f\"Error from Ollama:\\n{res}\\n\")\n raise e\n\n# test\nagent_res = AgentRes.from_llm(llm_res)\nprint(\"from\\n\", llm_res[\"message\"][\"content\"], \"\\nto\")\nagent_resThe tool output can be added as such:
\n# test the tool output\nAgentRes(tool_name = \"tool_browser\", \n tool_input = {'q':'September 9 2024 deaths'}, \n tool_output = str( tool_browser({'q':'September 9 2024 deaths'})) )The model can already understand if and when to use the tool, but we can make it even smarter by adding a Memory System. That shall include relevant information from the chat history and a reminder of the original request from the user.
\n'''\nMessages in Memory will have this structure:\n[{'role':'assistant', 'content':'{\"name\":\"final_answer\", \"parameters\":{\"text\":\"How can I assist you today?\"}}'},\n {'role':'user', 'content':None}]\n'''\n\ndef save_memory(lst_res:list[AgentRes], user_q:str) -> list:\n ## create\n memory = []\n for res in [res for res in lst_res if res.tool_output is not None]:\n memory.extend([\n ### assistant message\n {\"role\": \"assistant\", \"content\": json.dumps({\"name\":res.tool_name, \"parameters\":res.tool_input})},\n ### user message\n {\"role\":\"user\", \"content\":res.tool_output}\n ])\n \n ## add a reminder of the original goal\n if memory:\n memory += [{\"role\":\"user\", \"content\":(f'''\n This is just a reminder that my original query was `{user_q}`.\n Only answer to the original query, and nothing else, but use the information I gave you. \n Provide as much information as possible when you use the `final_answer` tool.\n ''')}]\n return memoryAs for the chat history, I’m going to add also a piece of a simulated conversation, just to make sure the Agent understands what I want.
\nhistory=[{\"role\": \"user\", \"content\": \"hi there, how are you?\"},\n {\"role\": \"assistant\", \"content\": \"I'm good, thanks!\"},\n {\"role\": \"user\", \"content\": \"I have a question\"},\n {\"role\": \"assistant\", \"content\": \"tell me\"}]Now, we can put it all together to create the Agent.
\ndef run_agent(user_q:str, chat_history:list[dict], lst_res:list[AgentRes], lst_tools:list) -> AgentRes:\n ## start memory\n memory = save_memory(lst_res=lst_res, user_q=user_q)\n \n ## track used tools\n if memory:\n tools_used = [res.tool_name for res in lst_res]\n if len(tools_used) >= len(lst_tools):\n memory[-1][\"content\"] = \"You must now use the `final_answer` tool.\"\n \n ## messages\n messages = [{\"role\":\"system\", \"content\":prompt+\"\\n\"+prompt_tools},\n *chat_history,\n {\"role\":\"user\", \"content\":user_q},\n *memory]\n pprint(messages) #<--print to see prompt + tools + chat_history\n \n ## output\n llm_res = ollama.chat(model=llm, messages=messages, format=\"json\")\n return AgentRes.from_llm(llm_res)\n\n\n# test\nagent_res = run_agent(user_q=q, chat_history=chat_history, lst_res=[], lst_tools=dic_tools.keys())\nprint(\"\\nagent_res:\", agent_res)As you can see, our Agent is started up with the prompt + the available tools + the chat history.
\nLangGraph is an orchestration framework that enables more control over the Agent workflows. One of the key concepts is the State: each execution creates a dictionary that is passed between nodes in the graph and gets updated every time with the output of the node.
\nWe define the initial state using Typing, the Python library to play with data types.
\nimport typing\n\nclass State(typing.TypedDict):\n user_q: str\n chat_history: list \n lst_res: list[AgentRes]\n output: dict\n\n# test\nstate = State({\"user_q\":q, \"chat_history\":chat_history, \"lst_res\":[agent_res], \"output\":{}})\nstateFor each node (Agent and Tools) and each edge (action), we need to write a function to define the model behavior. Let’s start with the Agent node (for now just one):
\n# Agent\ndef node_agent(state):\n print(\"