MetaGPT中的教程助手：TutorialAssistant

1. 提示词

1. COMMON_PROMPT = """
2. You are now a seasoned technical professional in the field of the internet.
3. We need you to write a technical tutorial with the topic "{topic}".
4. """
6. DIRECTORY_PROMPT = (
7.     COMMON_PROMPT
8.     + """
9. Please provide the specific table of contents for this tutorial, strictly following the following requirements:
10. 1. The output must be strictly in the specified language, {language}.
11. 2. Answer strictly in the dictionary format like {{"title": "xxx", "directory": [{{"dir 1": ["sub dir 1", "sub dir 2"]}}, {{"dir 2": ["sub dir 3", "sub dir 4"]}}]}}.
12. 3. The directory should be as specific and sufficient as possible, with a primary and secondary directory.The secondary directory is in the array.
13. 4. Do not have extra spaces or line breaks.
14. 5. Each directory title has practical significance.
15. """
16. )
17. CONTENT_PROMPT = (
18.     COMMON_PROMPT
19.     + """
20. Now I will give you the module directory titles for the topic.
21. Please output the detailed principle content of this title in detail.
22. If there are code examples, please provide them according to standard code specifications.
23. Without a code example, it is not necessary.
25. The module directory titles for the topic is as follows:
26. {directory}
28. Strictly limit output according to the following requirements:
29. 1. Follow the Markdown syntax format for layout.
30. 2. If there are code examples, they must follow standard syntax specifications, have document annotations, and be displayed in code blocks.
31. 3. The output must be strictly in the specified language, {language}.
32. 4. Do not have redundant output, including concluding remarks.
33. 5. Strict requirement not to output the topic "{topic}".
34. """
35. )

复制代码

2. 两个动作： 写文档大纲 (WriteDirectory) 和文档内容 (WriteContent)

1. from typing import Dict
3. from metagpt.actions import Action
4. from metagpt.utils.common import OutputParser
7. class WriteDirectory(Action):
8.     """Action class for writing tutorial directories.
10.     Args:
11.         name: The name of the action.
12.         language: The language to output, default is "Chinese".
13.     """
15.     name: str = "WriteDirectory"
16.     language: str = "Chinese"
18.     async def run(self, topic: str, *args, **kwargs) -> Dict:
19.         """Execute the action to generate a tutorial directory according to the topic.
21.         Args:
22.             topic: The tutorial topic.
24.         Returns:
25.             the tutorial directory information, including {"title": "xxx", "directory": [{"dir 1": ["sub dir 1", "sub dir 2"]}]}.
26.         """
27.         prompt = DIRECTORY_PROMPT.format(topic=topic, language=self.language)
28.         resp = await self._aask(prompt=prompt)
29.         return OutputParser.extract_struct(resp, dict)
32. class WriteContent(Action):
33.     """Action class for writing tutorial content.
35.     Args:
36.         name: The name of the action.
37.         directory: The content to write.
38.         language: The language to output, default is "Chinese".
39.     """
41.     name: str = "WriteContent"
42.     directory: dict = dict()
43.     language: str = "Chinese"
45.     async def run(self, topic: str, *args, **kwargs) -> str:
46.         """Execute the action to write document content according to the directory and topic.
48.         Args:
49.             topic: The tutorial topic.
51.         Returns:
52.             The written tutorial content.
53.         """
54.         prompt = CONTENT_PROMPT.format(topic=topic, language=self.language, directory=self.directory)
55.         return await self._aask(prompt=prompt)

复制代码

3. 教程助手定义

详细逻辑：第一步写文档目次，第二步，根据文档目次写每一章的内容，第三步，将内容写入markdown文件中

1. from datetime import datetime
2. from typing import Dict
3. from metagpt.const import get_metagpt_root
4. from metagpt.logs import logger
5. from metagpt.roles.role import Role
6. from metagpt.schema import Message
7. from metagpt.utils.file import File
9. TUTORIAL_PATH = get_metagpt_root()/"data"/"tutorial_docx"
11. class TutorialAssistant(Role):
12.     """Tutorial assistant, input one sentence to generate a tutorial document in markup format.
14.     Args:
15.         name: The name of the role.
16.         profile: The role profile description.
17.         goal: The goal of the role.
18.         constraints: Constraints or requirements for the role.
19.         language: The language in which the tutorial documents will be generated.
20.     """
22.     name: str = "Stitch"
23.     profile: str = "Tutorial Assistant"
24.     goal: str = "Generate tutorial documents"
25.     constraints: str = "Strictly follow Markdown's syntax, with neat and standardized layout"
26.     language: str = "Chinese"
28.     topic: str = ""
29.     main_title: str = ""
30.     total_content: str = ""
32.     def __init__(self, **kwargs):
33.         super().__init__(**kwargs)
34.         self.set_actions([WriteDirectory(language=self.language)])
35.         self._set_react_mode(react_mode="by_order")
37.     async def _handle_directory(self, titles: Dict) -> Message:
38.         """Handle the directories for the tutorial document.
40.         Args:
41.             titles: A dictionary containing the titles and directory structure,
42.                     such as {"title": "xxx", "directory": [{"dir 1": ["sub dir 1", "sub dir 2"]}]}
44.         Returns:
45.             A message containing information about the directory.
46.         """
47.         self.main_title = titles.get("title")
48.         directory = f"{self.main_title}\n"
49.         self.total_content += f"# {self.main_title}"
50.         actions = list(self.actions)
51.         for first_dir in titles.get("directory"):
52.             actions.append(WriteContent(language=self.language, directory=first_dir))
53.             key = list(first_dir.keys())[0]
54.             directory += f"- {key}\n"
55.             for second_dir in first_dir[key]:
56.                 directory += f"  - {second_dir}\n"
57.         self.set_actions(actions)
58.         self.rc.max_react_loop = len(self.actions)
59.         return Message()
61.     async def _act(self) -> Message:
62.         """Perform an action as determined by the role.
64.         Returns:
65.             A message containing the result of the action.
66.         """
67.         todo = self.rc.todo
68.         if type(todo) is WriteDirectory:
69.             msg = self.rc.memory.get(k=1)[0]
70.             self.topic = msg.content
71.             resp = await todo.run(topic=self.topic)
72.             logger.info(resp)
73.             return await self._handle_directory(resp)
74.         resp = await todo.run(topic=self.topic)
75.         logger.info(resp)
76.         if self.total_content != "":
77.             self.total_content += "\n\n\n"
78.         self.total_content += resp
79.         return Message(content=resp, role=self.profile)
81.     async def react(self) -> Message:
82.         msg = await super().react()
83.         root_path = TUTORIAL_PATH / datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
84.         await File.write(root_path, f"{self.main_title}.md", self.total_content.encode("utf-8"))
85.         msg.content = str(root_path / f"{self.main_title}.md")
86.         return msg

复制代码

1. 2024-12-12 15:39:46.005 | INFO     | metagpt.const:get_metagpt_package_root:21 - Package root set to d:\llm\metagpt

复制代码

4. 示例

1. async def main():
2.     topic = "Write a tutorial about python asyncio"
3.     role = TutorialAssistant(language="Chinese")
4.     await role.run(topic)
6. await main()

复制代码

输出：

1. {
2. "title": "Python Asyncio 异步编程教程",
3. "directory": [
4.     {
5.         "一、异步编程基础": [
6.             "1.1 异步编程概念",
7.             "1.2 Python中的异步历史",
8.             "1.3 异步编程的优势"
9.         ]
10.     },
11.     {
12.         "二、Asyncio入门": [
13.             "2.1 安装与配置",
14.             "2.2 Event Loop事件循环",
15.             "2.3 coroutine协程",
16.             "2.4 Future对象",
17.             "2.5 使用async和await"
18.         ]
19.     },
20.     {
21.         "三、Asyncio高级应用": [
22.             "3.1 并发执行与同步",
23.             "3.2 异步网络请求",
24.             "3.3 异步文件操作",
25.             "3.4 异步数据库操作",
26.             "3.5 异步队列"
27.         ]
28.     },
29.     {
30.         "四、常见问题与解决方案": [
31.             "4.1 协程间通信",
32.             "4.2 异步异常处理",
33.             "4.3 性能优化",
34.             "4.4 兼容性问题"
35.         ]
36.     },
37.     {
38.         "五、实战案例": [
39.             "5.1 异步爬虫",
40.             "5.2 异步Web服务",
41.             "5.3 异步数据处理"
42.         ]
43.     },
44.     {
45.         "六、附录": [
46.             "6.1 常用库与资源",
47.             "6.2 最佳实践",
48.             "6.3 进一步学习"
49.         ]
50.     }
51. ]
52. }
54. 2024-12-12 15:39:57.769 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
55. 2024-12-12 15:39:57.770 | INFO     | __main__:_act:72 - {'title': 'Python Asyncio 异步编程教程', 'directory': [{'一、异步编程基础': ['1.1 异步编程概念', '1.2 Python中的异步历史', '1.3 异步编程的优势']}, {'二、Asyncio入门': ['2.1 安装与配置', '2.2 Event Loop事件循环', '2.3 coroutine协程', '2.4 Future对象', '2.5 使用async和await']}, {'三、Asyncio高级应用': ['3.1 并发执行与同步', '3.2 异步网络请求', '3.3 异步文件操作', '3.4 异步数据库操作', '3.5 异步队列']}, {'四、常见问题与解决方案': ['4.1 协程间通信', '4.2 异步异常处理', '4.3 性能优化', '4.4 兼容性问题']}, {'五、实战案例': ['5.1 异步爬虫', '5.2 异步Web服务', '5.3 异步数据处理']}, {'六、附录': ['6.1 常用库与资源', '6.2 最佳实践', '6.3 进一步学习']}]}
58. # 一、异步编程基础
60. ## 1.1 异步编程概念
62. 异步编程是一种编程范式，允许程序在等待某些操作完成（如I/O操作）时继续执行其他任务。与传统的同步编程不同，同步编程在等待操作完成时会阻塞当前任务的执行。异步编程可以提高程序的效率和响应性。
64. ## 1.2 Python中的异步历史
66. Python的异步编程经历了几个阶段的发展：
68. - Python 2.x时代：主要通过`threading`和`multiprocessing`模块实现并发。
69. - Python 3.0至3.3：引入了`yield`关键字和`generators`，可以通过生成器实现简单的协同程序。
70. - Python 3.4：引入了`asyncio`库，提供了编写单线程并发代码的框架。
71. - Python 3.5：引入了`async`和`await`关键字，使得异步编程更加直观和易于编写。
73. ## 1.3 异步编程的优势
75. 异步编程具有以下优势：
77. 1. 提高I/O密集型应用的性能：在等待I/O操作完成时，CPU可以切换到其他任务，从而提高资源利用率。
78. 2. 更好的资源利用：异步编程允许使用单线程管理多个并发任务，减少了线程或进程的开销。
79. 3. 提升用户体验：在Web应用和用户界面中，异步编程可以避免因长时间操作导致的界面冻结。
81. 以下是一个简单的使用`asyncio`的例子：
83. ```python
84. import asyncio
86. async def hello_world():
87.     print("Hello")
88.     await asyncio.sleep(1)  # 模拟I/O操作
89.     print("World")
91. # 运行异步函数
92. asyncio.run(hello_world())
93. ```
95. 请注意，上述代码应在Python 3.7及以上版本运行，因为`asyncio.run()`函数是在Python 3.7中引入的。在之前的版本中，需要使用`asyncio.get_event_loop().run_until_complete(hello_world())`来运行异步函数
97. 2024-12-12 15:40:15.460 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
98. 2024-12-12 15:40:15.462 | INFO     | __main__:_act:75 - # 一、异步编程基础
100. ## 1.1 异步编程概念
102. 异步编程是一种编程范式，允许程序在等待某些操作完成（如I/O操作）时继续执行其他任务。与传统的同步编程不同，同步编程在等待操作完成时会阻塞当前任务的执行。异步编程可以提高程序的效率和响应性。
104. ## 1.2 Python中的异步历史
106. Python的异步编程经历了几个阶段的发展：
108. - Python 2.x时代：主要通过`threading`和`multiprocessing`模块实现并发。
109. - Python 3.0至3.3：引入了`yield`关键字和`generators`，可以通过生成器实现简单的协同程序。
110. - Python 3.4：引入了`asyncio`库，提供了编写单线程并发代码的框架。
111. - Python 3.5：引入了`async`和`await`关键字，使得异步编程更加直观和易于编写。
113. ## 1.3 异步编程的优势
115. 异步编程具有以下优势：
117. 1. 提高I/O密集型应用的性能：在等待I/O操作完成时，CPU可以切换到其他任务，从而提高资源利用率。
118. 2. 更好的资源利用：异步编程允许使用单线程管理多个并发任务，减少了线程或进程的开销。
119. 3. 提升用户体验：在Web应用和用户界面中，异步编程可以避免因长时间操作导致的界面冻结。
121. 以下是一个简单的使用`asyncio`的例子：
123. ```python
124. import asyncio
126. async def hello_world():
127.     print("Hello")
128.     await asyncio.sleep(1)  # 模拟I/O操作
129.     print("World")
131. # 运行异步函数
132. asyncio.run(hello_world())
133. ```
135. 请注意，上述代码应在Python 3.7及以上版本运行，因为`asyncio.run()`函数是在Python 3.7中引入的。在之前的版本中，需要使用`asyncio.get_event_loop().run_until_complete(hello_world())`来运行异步函数。
138. 。
139. # 二、Asyncio入门
141. ## 2.1 安装与配置
143. Asyncio 是 Python 的一个库，用于编写单线程并发代码，通过异步/等待语法。要在 Python 中使用 asyncio，你需要 Python 3.5 或更高版本。
145. ### 安装
147. Asyncio 随 Python 3.4+ 一起安装，无需额外安装。
149. ### 配置
151. 无需特别的配置，直接在 Python 脚本中导入即可使用。
153. ```python
154. import asyncio
155. ```
157. ## 2.2 Event Loop事件循环
159. 事件循环是 asyncio 程序的核心，它用来调度和执行任务。
161. ```python
162. # 示例：创建事件循环
163. loop = asyncio.get_event_loop()
164. try:
165.     loop.run_forever()
166. finally:
167.     loop.close()
168. ```
170. ## 2.3 coroutine协程
172. 协程是使用 `async def` 定义的函数，它是异步编程的核心。
174. ```python
175. # 示例：定义协程
176. async def main():
177.     print('Hello')
178.     await asyncio.sleep(1)
179.     print('World')
181. # 运行协程
182. loop = asyncio.get_event_loop()
183. loop.run_until_complete(main())
184. loop.close()
185. ```
187. ## 2.4 Future对象
189. Future 对象表示尚未完成的计算，它用来与异步执行的结果进行交互。
191. ```python
192. # 示例：创建 Future 对象
193. async def main():
194.     # 获取当前事件循环
195.     loop = asyncio.get_event_loop()
196.     # 创建一个 Future 对象
197.     future = loop.create_future()
199.     # 模拟异步操作，并在一段时间后设置结果
200.     async def set_future():
201.         await asyncio.sleep(1)
202.         future.set_result('Future is done!')
204.     # 启动任务
205.     loop.create_task(set_future())
207.     # 等待 Future 完成
208.     result = await future
209.     print(result)
211. loop = asyncio.get_event_loop()
212. loop.run_until_complete(main())
213. loop.close()
214. ```
216. ## 2.5 使用async和await
218. `async` 和 `await` 关键字用于编写异步代码。
220. ```python
221. # 示例：使用 async 和 await
222. async def say_after(delay, what):
223.     await asyncio.sleep(delay)
224.     print(what)
226. async def main():
227.     print(f"started at {time.strftime('%X')}")
229.     await say_after(1, 'hello')
230.     await say_after(2, 'world')
232.     print(f"finished at {time.strftime('%X')}")
234. asyncio.run(main())
235. ```
237. 请注意，上面的示例中使用了 `asyncio.run(main())`，这是 Python 3.7+ 推荐的运行协程的方式，代替了手动获取事件循环和关闭事件循环的做法。`asyncio.run()` 应该只被调用一次，通常在主程序入口处。
239. 2024-12-12 15:40:36.272 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
240. 2024-12-12 15:40:36.274 | INFO     | __main__:_act:75 - # 二、Asyncio入门
242. ## 2.1 安装与配置
244. Asyncio 是 Python 的一个库，用于编写单线程并发代码，通过异步/等待语法。要在 Python 中使用 asyncio，你需要 Python 3.5 或更高版本。
246. ### 安装
248. Asyncio 随 Python 3.4+ 一起安装，无需额外安装。
250. ### 配置
252. 无需特别的配置，直接在 Python 脚本中导入即可使用。
254. ```python
255. import asyncio
256. ```
258. ## 2.2 Event Loop事件循环
260. 事件循环是 asyncio 程序的核心，它用来调度和执行任务。
262. ```python
263. # 示例：创建事件循环
264. loop = asyncio.get_event_loop()
265. try:
266.     loop.run_forever()
267. finally:
268.     loop.close()
269. ```
271. ## 2.3 coroutine协程
273. 协程是使用 `async def` 定义的函数，它是异步编程的核心。
275. ```python
276. # 示例：定义协程
277. async def main():
278.     print('Hello')
279.     await asyncio.sleep(1)
280.     print('World')
282. # 运行协程
283. loop = asyncio.get_event_loop()
284. loop.run_until_complete(main())
285. loop.close()
286. ```
288. ## 2.4 Future对象
290. Future 对象表示尚未完成的计算，它用来与异步执行的结果进行交互。
292. ```python
293. # 示例：创建 Future 对象
294. async def main():
295.     # 获取当前事件循环
296.     loop = asyncio.get_event_loop()
297.     # 创建一个 Future 对象
298.     future = loop.create_future()
300.     # 模拟异步操作，并在一段时间后设置结果
301.     async def set_future():
302.         await asyncio.sleep(1)
303.         future.set_result('Future is done!')
305.     # 启动任务
306.     loop.create_task(set_future())
308.     # 等待 Future 完成
309.     result = await future
310.     print(result)
312. loop = asyncio.get_event_loop()
313. loop.run_until_complete(main())
314. loop.close()
315. ```
317. ## 2.5 使用async和await
319. `async` 和 `await` 关键字用于编写异步代码。
321. ```python
322. # 示例：使用 async 和 await
323. async def say_after(delay, what):
324.     await asyncio.sleep(delay)
325.     print(what)
327. async def main():
328.     print(f"started at {time.strftime('%X')}")
330.     await say_after(1, 'hello')
331.     await say_after(2, 'world')
333.     print(f"finished at {time.strftime('%X')}")
335. asyncio.run(main())
336. ```
338. 请注意，上面的示例中使用了 `asyncio.run(main())`，这是 Python 3.7+ 推荐的运行协程的方式，代替了手动获取事件循环和关闭事件循环的做法。`asyncio.run()` 应该只被调用一次，通常在主程序入口处。
342. # 三、Asyncio高级应用
344. ## 3.1 并发执行与同步
346. `asyncio` 是 Python 的一个异步I/O框架，用于编写单线程并发代码，通过异步/等待语法。
348. ### 并发执行
350. `asyncio` 允许我们并发地运行多个协程。以下是一个简单的并发执行示例：
352. ```python
353. import asyncio
355. async def say_after(delay, what):
356.     await asyncio.sleep(delay)
357.     print(what)
359. async def main():
360.     print(f"started at {time.strftime('%X')}")
362.     # 创建两个协程对象，不立即运行
363.     coroutine1 = say_after(1, 'hello')
364.     coroutine2 = say_after(2, 'world')
366.     # 等待两个协程并发执行
367.     await asyncio.gather(coroutine1, coroutine2)
369.     print(f"finished at {time.strftime('%X')}")
371. # 运行主协程
372. asyncio.run(main())
373. ```
375. ### 同步
377. 在并发编程中，同步是确保多个任务按预期执行的机制。`asyncio` 提供了 `asyncio.Lock()` 和 `asyncio.Event()` 等同步原语。
379. 以下是一个使用 `asyncio.Lock()` 的示例：
381. ```python
382. import asyncio
384. async def worker(lock, worker_id):
385.     print(f"Worker {worker_id} waiting for the lock")
386.     async with lock:
387.         print(f"Worker {worker_id} has the lock")
388.         await asyncio.sleep(1)
389.     print(f"Worker {worker_id} released the lock")
391. async def main():
392.     # 创建一个锁
393.     lock = asyncio.Lock()
395.     # 创建并运行三个工作协程
396.     tasks = [asyncio.create_task(worker(lock, i)) for i in range(3)]
397.     await asyncio.gather(*tasks)
399. # 运行主协程
400. asyncio.run(main())
401. ```
403. ## 3.2 异步网络请求
405. `aiohttp` 是一个支持 `asyncio` 的异步HTTP网络库。
407. ```python
408. import aiohttp
409. import asyncio
411. async def fetch(session, url):
412.     async with session.get(url) as response:
413.         return await response.text()
415. async def main():
416.     async with aiohttp.ClientSession() as session:
417.         html = await fetch(session, 'http://python.org')
418.         print(html)
420. # 运行主协程
421. asyncio.run(main())
422. ```
424. ## 3.3 异步文件操作
426. `asyncio` 允许你以异步方式执行文件操作。
428. ```python
429. import asyncio
430. import aiofiles
432. async def write_to_file(filename, content):
433.     async with aiofiles.open(filename, 'w') as f:
434.         await f.write(content)
436. async def main():
437.     await write_to_file('example.txt', 'Hello, world!')
439. # 运行主协程
440. asyncio.run(main())
441. ```
443. ## 3.4 异步数据库操作
445. 对于数据库操作，可以使用像 `aiomysql` 或 `aiopg` 这样的异步驱动。
447. 以下是使用 `aiomysql` 的简单示例：
449. ```python
450. import asyncio
451. import aiomysql
453. async def query_db(loop, dbname, user, password):
454.     async with aiomysql.create_pool(host='127.0.0.1', port=3306,
455.                                     user=user, password=password,
456.                                     db=dbname, loop=loop) as pool:
457.         async with pool.acquire() as conn:
458.             async with conn.cursor() as cur:
459.                 await cur.execute("SELECT 1")
460.                 result = await cur.fetchone()
461.                 print(result)
463. loop = asyncio.get_event_loop()
464. loop.run_until_complete(query_db(loop, 'test', 'user', 'password'))
465. ```
467. ## 3.5 异步队列
469. `asyncio` 提供了 `asyncio.Queue`，这是一个异步的先进先出（FIFO）队列。
471. ```python
472. import asyncio
474. async def worker(q):
475.     while True:
476.         item = await q.get()
477.         print(f'Worker got item: {item}')
478.         # 模拟处理项目
479.         await asyncio.sleep(1)
480.         q.task_done()
482. async def main():
483.     q = asyncio.Queue(maxsize=3)
485.     # 启动三个工作协程
486.     tasks = []
487.     for i in range(3):
488.         task = asyncio.create_task(worker(q))
489.         tasks.append(task)
491.     # 生产项目
492.     for item in range(10):
493.         await q.put(item)
495.     # 等待队列清空
496.     await q.join()
498.     # 取消工作协程
499.     for task in tasks:
500.         task.cancel()
501.     await asyncio.gather(*tasks, return_exceptions=True)
503. # 运行主协程
504. asyncio.run(main())
505. ```
507. 请注意，以上示例代码遵循了代码规范，并包含了必要的注释，以方便理解。
509. 2024-12-12 15:41:09.514 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
510. 2024-12-12 15:41:09.515 | INFO     | __main__:_act:75 - # 三、Asyncio高级应用
512. ## 3.1 并发执行与同步
514. `asyncio` 是 Python 的一个异步I/O框架，用于编写单线程并发代码，通过异步/等待语法。
516. ### 并发执行
518. `asyncio` 允许我们并发地运行多个协程。以下是一个简单的并发执行示例：
520. ```python
521. import asyncio
523. async def say_after(delay, what):
524.     await asyncio.sleep(delay)
525.     print(what)
527. async def main():
528.     print(f"started at {time.strftime('%X')}")
530.     # 创建两个协程对象，不立即运行
531.     coroutine1 = say_after(1, 'hello')
532.     coroutine2 = say_after(2, 'world')
534.     # 等待两个协程并发执行
535.     await asyncio.gather(coroutine1, coroutine2)
537.     print(f"finished at {time.strftime('%X')}")
539. # 运行主协程
540. asyncio.run(main())
541. ```
543. ### 同步
545. 在并发编程中，同步是确保多个任务按预期执行的机制。`asyncio` 提供了 `asyncio.Lock()` 和 `asyncio.Event()` 等同步原语。
547. 以下是一个使用 `asyncio.Lock()` 的示例：
549. ```python
550. import asyncio
552. async def worker(lock, worker_id):
553.     print(f"Worker {worker_id} waiting for the lock")
554.     async with lock:
555.         print(f"Worker {worker_id} has the lock")
556.         await asyncio.sleep(1)
557.     print(f"Worker {worker_id} released the lock")
559. async def main():
560.     # 创建一个锁
561.     lock = asyncio.Lock()
563.     # 创建并运行三个工作协程
564.     tasks = [asyncio.create_task(worker(lock, i)) for i in range(3)]
565.     await asyncio.gather(*tasks)
567. # 运行主协程
568. asyncio.run(main())
569. ```
571. ## 3.2 异步网络请求
573. `aiohttp` 是一个支持 `asyncio` 的异步HTTP网络库。
575. ```python
576. import aiohttp
577. import asyncio
579. async def fetch(session, url):
580.     async with session.get(url) as response:
581.         return await response.text()
583. async def main():
584.     async with aiohttp.ClientSession() as session:
585.         html = await fetch(session, 'http://python.org')
586.         print(html)
588. # 运行主协程
589. asyncio.run(main())
590. ```
592. ## 3.3 异步文件操作
594. `asyncio` 允许你以异步方式执行文件操作。
596. ```python
597. import asyncio
598. import aiofiles
600. async def write_to_file(filename, content):
601.     async with aiofiles.open(filename, 'w') as f:
602.         await f.write(content)
604. async def main():
605.     await write_to_file('example.txt', 'Hello, world!')
607. # 运行主协程
608. asyncio.run(main())
609. ```
611. ## 3.4 异步数据库操作
613. 对于数据库操作，可以使用像 `aiomysql` 或 `aiopg` 这样的异步驱动。
615. 以下是使用 `aiomysql` 的简单示例：
617. ```python
618. import asyncio
619. import aiomysql
621. async def query_db(loop, dbname, user, password):
622.     async with aiomysql.create_pool(host='127.0.0.1', port=3306,
623.                                     user=user, password=password,
624.                                     db=dbname, loop=loop) as pool:
625.         async with pool.acquire() as conn:
626.             async with conn.cursor() as cur:
627.                 await cur.execute("SELECT 1")
628.                 result = await cur.fetchone()
629.                 print(result)
631. loop = asyncio.get_event_loop()
632. loop.run_until_complete(query_db(loop, 'test', 'user', 'password'))
633. ```
635. ## 3.5 异步队列
637. `asyncio` 提供了 `asyncio.Queue`，这是一个异步的先进先出（FIFO）队列。
639. ```python
640. import asyncio
642. async def worker(q):
643.     while True:
644.         item = await q.get()
645.         print(f'Worker got item: {item}')
646.         # 模拟处理项目
647.         await asyncio.sleep(1)
648.         q.task_done()
650. async def main():
651.     q = asyncio.Queue(maxsize=3)
653.     # 启动三个工作协程
654.     tasks = []
655.     for i in range(3):
656.         task = asyncio.create_task(worker(q))
657.         tasks.append(task)
659.     # 生产项目
660.     for item in range(10):
661.         await q.put(item)
663.     # 等待队列清空
664.     await q.join()
666.     # 取消工作协程
667.     for task in tasks:
668.         task.cancel()
669.     await asyncio.gather(*tasks, return_exceptions=True)
671. # 运行主协程
672. asyncio.run(main())
673. ```
675. 请注意，以上示例代码遵循了代码规范，并包含了必要的注释，以方便理解。
679. # 四、常见问题与解决方案
681. ## 4.1 协程间通信
683. 在Python的`asyncio`中，协程之间的通信通常使用`asyncio.Queue`或者`asyncio.Event`来实现。
685. ### 示例：使用`asyncio.Queue`
687. ```python
688. import asyncio
690. async def producer(queue):
691.     for i in range(5):
692.         print(f"Producing item {i}")
693.         await queue.put(i)
694.     await queue.put(None)  # 用来标记生产结束
696. async def consumer(queue):
697.     while True:
698.         item = await queue.get()
699.         if item is None:
700.             break
701.         print(f"Consuming item {item}")
702.         await asyncio.sleep(1)  # 模拟消费时间
703.         queue.task_done()
705. queue = asyncio.Queue()
706. producer_coro = producer(queue)
707. consumer_coro = consumer(queue)
709. loop = asyncio.get_event_loop()
710. loop.run_until_complete(asyncio.gather(producer_coro, consumer_coro))
711. loop.close()
712. ```
714. ## 4.2 异步异常处理
716. 在异步编程中，异常处理非常重要。可以使用`try-except`块来捕获和处理异常。
718. ### 示例：异步异常处理
720. ```python
721. import asyncio
723. async def async_function_with_error():
724.     raise ValueError("An error occurred")
726. async def main():
727.     try:
728.         await async_function_with_error()
729.     except ValueError as e:
730.         print(f"Caught an exception: {e}")
732. loop = asyncio.get_event_loop()
733. loop.run_until_complete(main())
734. loop.close()
735. ```
737. ## 4.3 性能优化
739. 性能优化通常涉及减少协程之间的等待时间，以及减少不必要的上下文切换。
741. - 使用`asyncio.gather`来并发运行多个协程。
742. - 使用`await`关键字仅在你确实需要等待某个操作完成时。
744. ### 示例：并发运行多个协程
746. ```python
747. import asyncio
749. async def fast_function():
750.     await asyncio.sleep(1)
752. async def main():
753.     await asyncio.gather(
754.         fast_function(),
755.         fast_function(),
756.         fast_function()
757.     )
759. loop = asyncio.get_event_loop()
760. loop.run_until_complete(main())
761. loop.close()
762. ```
764. ## 4.4 兼容性问题
766. 由于`asyncio`是Python 3.4+的一部分，如果你需要支持更早的Python版本，可能会遇到兼容性问题。
768. - 使用`asyncio`之前，检查Python版本。
769. - 使用`pip`安装`asyncio`的第三方包，如`aiolib`，来支持旧版本的Python。
771. 确保你的代码在支持的版本范围内运行良好，并且遵循最佳实践来减少兼容性问题。
773. ---
775. 请注意，以上内容遵循了Markdown的语法规范，并提供了相应的代码示例。代码示例遵循了标准的Python代码规范，并包含了必要的
777. 2024-12-12 15:41:28.223 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
780. 注释。
783. 2024-12-12 15:41:28.226 | INFO     | __main__:_act:75 - # 四、常见问题与解决方案
785. ## 4.1 协程间通信
787. 在Python的`asyncio`中，协程之间的通信通常使用`asyncio.Queue`或者`asyncio.Event`来实现。
789. ### 示例：使用`asyncio.Queue`
791. ```python
792. import asyncio
794. async def producer(queue):
795.     for i in range(5):
796.         print(f"Producing item {i}")
797.         await queue.put(i)
798.     await queue.put(None)  # 用来标记生产结束
800. async def consumer(queue):
801.     while True:
802.         item = await queue.get()
803.         if item is None:
804.             break
805.         print(f"Consuming item {item}")
806.         await asyncio.sleep(1)  # 模拟消费时间
807.         queue.task_done()
809. queue = asyncio.Queue()
810. producer_coro = producer(queue)
811. consumer_coro = consumer(queue)
813. loop = asyncio.get_event_loop()
814. loop.run_until_complete(asyncio.gather(producer_coro, consumer_coro))
815. loop.close()
816. ```
818. ## 4.2 异步异常处理
820. 在异步编程中，异常处理非常重要。可以使用`try-except`块来捕获和处理异常。
822. ### 示例：异步异常处理
824. ```python
825. import asyncio
827. async def async_function_with_error():
828.     raise ValueError("An error occurred")
830. async def main():
831.     try:
832.         await async_function_with_error()
833.     except ValueError as e:
834.         print(f"Caught an exception: {e}")
836. loop = asyncio.get_event_loop()
837. loop.run_until_complete(main())
838. loop.close()
839. ```
841. ## 4.3 性能优化
843. 性能优化通常涉及减少协程之间的等待时间，以及减少不必要的上下文切换。
845. - 使用`asyncio.gather`来并发运行多个协程。
846. - 使用`await`关键字仅在你确实需要等待某个操作完成时。
848. ### 示例：并发运行多个协程
850. ```python
851. import asyncio
853. async def fast_function():
854.     await asyncio.sleep(1)
856. async def main():
857.     await asyncio.gather(
858.         fast_function(),
859.         fast_function(),
860.         fast_function()
861.     )
863. loop = asyncio.get_event_loop()
864. loop.run_until_complete(main())
865. loop.close()
866. ```
868. ## 4.4 兼容性问题
870. 由于`asyncio`是Python 3.4+的一部分，如果你需要支持更早的Python版本，可能会遇到兼容性问题。
872. - 使用`asyncio`之前，检查Python版本。
873. - 使用`pip`安装`asyncio`的第三方包，如`aiolib`，来支持旧版本的Python。
875. 确保你的代码在支持的版本范围内运行良好，并且遵循最佳实践来减少兼容性问题。
877. ---
879. 请注意，以上内容遵循了Markdown的语法规范，并提供了相应的代码示例。代码示例遵循了标准的Python代码规范，并包含了必要的注释。
882. # 五、实战案例
884. ## 5.1 异步爬虫
886. 异步IO在爬虫领域有广泛的应用，因为它可以显著提高爬取效率，特别是在处理网络请求时。以下是一个使用`asyncio`和`aiohttp`的异步爬虫示例。
888. ```python
889. import asyncio
890. import aiohttp
892. async def fetch(session, url):
893.     async with session.get(url) as response:
894.         return await response.text()
896. async def main():
897.     async with aiohttp.ClientSession() as session:
898.         url = 'http://example.com'
899.         html = await fetch(session, url)
900.         print(html)
902. if __name__ == '__main__':
903.     asyncio.run(main())
904. ```
906. 在这个示例中，`fetch` 函数是一个异步的HTTP请求处理函数，它使用了`aiohttp`库来异步获取网页内容。`main` 函数初始化了一个`aiohttp.ClientSession`，然后调用`fetch`函数，并打印出获取的HTML内容。
908. ## 5.2 异步Web服务
910. `asyncio`也可以用于创建异步的Web服务。下面是一个使用`aiohttp`创建的简单异步Web服务示例。
912. ```python
913. from aiohttp import web
915. async def handle(request):
916.     name = request.match_info.get('name', "Anonymous")
917.     text = f"Hello, {name}!"
918.     return web.Response(text=text)
920. app = web.Application()
921. app.add_routes([
922.     web.get('/', handle),
923.     web.get('/{name}', handle)
924. ])
926. web.run_app(app)
927. ```
929. 在这个例子中，我们创建了一个简单的Web应用程序，它响应根URL和带名字的路径。`handle` 函数是一个异步处理函数，它根据URL路径中的名字返回响应。
931. ## 5.3 异步数据处理
933. 在数据处理任务中，如果任务可以并行处理，`asyncio`也能提供帮助。以下是一个使用`asyncio`进行异步文件读写的例子。
935. ```python
936. import asyncio
937. import aiofiles
939. async def write_data(file_path, data):
940.     async with aiofiles.open(file_path, 'w') as f:
941.         await f.write(data)
943. async def read_data(file_path):
944.     async with aiofiles.open(file_path, 'r') as f:
945.         data = await f.read()
946.         print(data)
948. async def main():
949.     file_path = 'example.txt'
950.     data_to_write = '异步文件写入示例'
951.    
952.     # 写入数据
953.     await write_data(file_path, data_to_write)
954.    
955.     # 读取数据
956.     await read_data(file_path)
958. if __name__ == '__main__':
959.     asyncio.run(main())
960. ```
962. 在这个例子中，`write_data` 函数异步地将数据写入文件，而`read_data` 函数从文件异步读取数据。通过这种方式，可以在处理I/O密集型任务时提高效率。
964. 2024-12-12 15:41:46.964 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
965. 2024-12-12 15:41:46.965 | INFO     | __main__:_act:75 - # 五、实战案例
967. ## 5.1 异步爬虫
969. 异步IO在爬虫领域有广泛的应用，因为它可以显著提高爬取效率，特别是在处理网络请求时。以下是一个使用`asyncio`和`aiohttp`的异步爬虫示例。
971. ```python
972. import asyncio
973. import aiohttp
975. async def fetch(session, url):
976.     async with session.get(url) as response:
977.         return await response.text()
979. async def main():
980.     async with aiohttp.ClientSession() as session:
981.         url = 'http://example.com'
982.         html = await fetch(session, url)
983.         print(html)
985. if __name__ == '__main__':
986.     asyncio.run(main())
987. ```
989. 在这个示例中，`fetch` 函数是一个异步的HTTP请求处理函数，它使用了`aiohttp`库来异步获取网页内容。`main` 函数初始化了一个`aiohttp.ClientSession`，然后调用`fetch`函数，并打印出获取的HTML内容。
991. ## 5.2 异步Web服务
993. `asyncio`也可以用于创建异步的Web服务。下面是一个使用`aiohttp`创建的简单异步Web服务示例。
995. ```python
996. from aiohttp import web
998. async def handle(request):
999.     name = request.match_info.get('name', "Anonymous")
1000.     text = f"Hello, {name}!"
1001.     return web.Response(text=text)
1003. app = web.Application()
1004. app.add_routes([
1005.     web.get('/', handle),
1006.     web.get('/{name}', handle)
1007. ])
1009. web.run_app(app)
1010. ```
1012. 在这个例子中，我们创建了一个简单的Web应用程序，它响应根URL和带名字的路径。`handle` 函数是一个异步处理函数，它根据URL路径中的名字返回响应。
1014. ## 5.3 异步数据处理
1016. 在数据处理任务中，如果任务可以并行处理，`asyncio`也能提供帮助。以下是一个使用`asyncio`进行异步文件读写的例子。
1018. ```python
1019. import asyncio
1020. import aiofiles
1022. async def write_data(file_path, data):
1023.     async with aiofiles.open(file_path, 'w') as f:
1024.         await f.write(data)
1026. async def read_data(file_path):
1027.     async with aiofiles.open(file_path, 'r') as f:
1028.         data = await f.read()
1029.         print(data)
1031. async def main():
1032.     file_path = 'example.txt'
1033.     data_to_write = '异步文件写入示例'
1034.    
1035.     # 写入数据
1036.     await write_data(file_path, data_to_write)
1037.    
1038.     # 读取数据
1039.     await read_data(file_path)
1041. if __name__ == '__main__':
1042.     asyncio.run(main())
1043. ```
1045. 在这个例子中，`write_data` 函数异步地将数据写入文件，而`read_data` 函数从文件异步读取数据。通过这种方式，可以在处理I/O密集型任务时提高效率。
1049. # 六、附录
1051. ## 6.1 常用库与资源
1053. Python 的 `asyncio` 是一个用于编写并发代码的库，使用async/await语法。以下是一些常用的库和资源，可以帮助你更好地理解和应用 `asyncio`。
1055. ### 常用库
1057. - `aiohttp`：用于异步HTTP网络请求。
1058. - `aiomysql` / `aiopg`：用于异步操作MySQL和PostgreSQL数据库。
1059. - `aioredis`：用于异步操作Redis。
1060. - `aiofiles`：用于异步文件操作。
1062. ### 资源
1064. - [官方文档](https://docs.python.org/3/library/asyncio.html)：提供了最权威的 `asyncio` 使用指南。
1065. - [Asyncio GitHub 仓库](https://github.com/python/asyncio)：可以找到最新的信息和一些示例。
1067. ## 6.2 最佳实践
1069. 在使用 `asyncio` 进行编程时，以下是一些最佳实践：
1071. 1. **避免阻塞操作**：确保你的异步函数不会进行阻塞操作，如长时间的计算或等待输入/输出。
1072. 2. **合理使用并发**：不要盲目地创建大量协程，合理地管理和调度它们可以避免资源浪费和提高效率。
1073. 3. **错误处理**：使用 `try-except` 块来处理可能出现的异常，确保程序的健壮性。
1075. ### 代码示例
1077. ```python
1078. import asyncio
1080. async def fetch_data(url):
1081.     async with aiohttp.ClientSession() as session:
1082.         async with session.get(url) as response:
1083.             return await response.text()
1085. async def main():
1086.     urls = ['http://example.com', 'http://example.org']
1087.     tasks = [fetch_data(url) for url in urls]
1088.     results = await asyncio.gather(*tasks)
1089.     for result in results:
1090.         print(result)
1092. if __name__ == '__main__':
1093.     asyncio.run(main())
1094. ```
1096. ## 6.3 进一步学习
1098. 想要进一步学习 `asyncio`，以下是一些建议：
1100. - **理解事件循环**：深入了解 `asyncio` 的事件循环是如何工作的，这是 `asyncio` 的核心概念。
1101. - **并发模型**：研究 `asyncio` 的并发模型，包括协程、任务和未来。
1102. - **性能调优**：学习如何对基于 `asyncio` 的应用进行性能分析和调优。
1104. 通过这些资源的帮助，你可以更深入地掌握 `asyncio`，并在实践中更有效地
1106. 2024-12-12 15:42:04.027 | WARNING  | metagpt.utils.cost_manager:update_cost:49 - Model GLM-4 not found in TOKEN_COSTS.
1109. 使用它。
1112. 2024-12-12 15:42:04.030 | INFO     | __main__:_act:75 - # 六、附录
1114. ## 6.1 常用库与资源
1116. Python 的 `asyncio` 是一个用于编写并发代码的库，使用async/await语法。以下是一些常用的库和资源，可以帮助你更好地理解和应用 `asyncio`。
1118. ### 常用库
1120. - `aiohttp`：用于异步HTTP网络请求。
1121. - `aiomysql` / `aiopg`：用于异步操作MySQL和PostgreSQL数据库。
1122. - `aioredis`：用于异步操作Redis。
1123. - `aiofiles`：用于异步文件操作。
1125. ### 资源
1127. - [官方文档](https://docs.python.org/3/library/asyncio.html)：提供了最权威的 `asyncio` 使用指南。
1128. - [Asyncio GitHub 仓库](https://github.com/python/asyncio)：可以找到最新的信息和一些示例。
1130. ## 6.2 最佳实践
1132. 在使用 `asyncio` 进行编程时，以下是一些最佳实践：
1134. 1. **避免阻塞操作**：确保你的异步函数不会进行阻塞操作，如长时间的计算或等待输入/输出。
1135. 2. **合理使用并发**：不要盲目地创建大量协程，合理地管理和调度它们可以避免资源浪费和提高效率。
1136. 3. **错误处理**：使用 `try-except` 块来处理可能出现的异常，确保程序的健壮性。
1138. ### 代码示例
1140. ```python
1141. import asyncio
1143. async def fetch_data(url):
1144.     async with aiohttp.ClientSession() as session:
1145.         async with session.get(url) as response:
1146.             return await response.text()
1148. async def main():
1149.     urls = ['http://example.com', 'http://example.org']
1150.     tasks = [fetch_data(url) for url in urls]
1151.     results = await asyncio.gather(*tasks)
1152.     for result in results:
1153.         print(result)
1155. if __name__ == '__main__':
1156.     asyncio.run(main())
1157. ```
1159. ## 6.3 进一步学习
1161. 想要进一步学习 `asyncio`，以下是一些建议：
1163. - **理解事件循环**：深入了解 `asyncio` 的事件循环是如何工作的，这是 `asyncio` 的核心概念。
1164. - **并发模型**：研究 `asyncio` 的并发模型，包括协程、任务和未来。
1165. - **性能调优**：学习如何对基于 `asyncio` 的应用进行性能分析和调优。
1167. 通过这些资源的帮助，你可以更深入地掌握 `asyncio`，并在实践中更有效地使用它。

复制代码

参考链接：https://github.com/geekan/MetaGPT
如果有任何问题，欢迎在评论区提问。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。