📝 更新Python文档，优化函数说明与结构

- 在多个文档中调整了函数标题，统一格式，例如将“help() 函数”改为“help函数”。
- 新增了对`locals()`和`globals()`函数的详细说明，增强了对Python命名空间的理解。
- 删除了冗余的内容，简化了文档，确保信息更加清晰易懂。
- 更新了异步编程相关内容，增加了`aiter()`和`anext()`函数的介绍，提升了文档的实用性。

Author: jiangyangcreate

docs/docs/选择编程语言/Python/0基础语法.mdx

@@ -406,6 +406,7 @@ print(keyword.kwlist)
 ## Python内置函数
 
 ### 基本操作
+- help(): 显示帮助信息
 - input(): 用户输入
 - print(): 输出
 - hash(): 哈希值
@@ -502,9 +503,6 @@ print(keyword.kwlist)
 ### 模块操作
 - __ import __(): 动态导入模块
 
-### 其他
-- help(): 显示帮助信息
-
 `} />
 
 

docs/docs/选择编程语言/Python/10函数.mdx

@@ -316,7 +316,7 @@ print(fact(5))  # 120
 
 ## 内置函数
 
-### map 函数
+### map函数
 
 map() 对序列每个元素应用函数，返回映射结果。
 

docs/docs/选择编程语言/Python/25迭代器.mdx

@@ -71,7 +71,7 @@ for num in countdown(5):
 
 Python 提供了多个处理迭代器的内置函数，这些函数让迭代操作更加便捷和强大。
 
-### iter 函数
+### iter函数
 
 `iter()` 函数用于从可迭代对象创建迭代器，或创建一个调用函数直到返回哨兵值的迭代器。
 
@@ -93,7 +93,7 @@ with open('data.txt') as f:
         print(line.strip())
 ```
 
-### next 函数
+### next函数
 
 `next()` 函数用于从迭代器获取下一个元素。
 

docs/docs/选择编程语言/Python/28装饰器与作用域.mdx

@@ -319,19 +319,6 @@ print("函数外的z",z)
 # 函数外的z 30
 ```
 
-### locals
-
-locals 函数返回当前作用域的局部变量的字典。
-
-```python showLineNumbers
-def test():
-    x = 1
-    print(locals())
-test()
-# {'x': 1}
-```
-
-
 ### nonlocal
 
 当一个函数或类的定义嵌套（被包围）在其他函数的定义中时，其非局部作用域就是<Highlight>包围它的函数的局部作用域</Highlight> 。
@@ -417,3 +404,56 @@ print(func()()) # 2
 """
 
 ```
+
+## 内置函数
+
+### locals函数、globals函数
+
+`locals()` 和 `globals()` 都是用来**查看当前命名空间中的变量**的内置函数，本质上都是**返回一个字典对象**。
+
+- **locals()**：返回当前局部作用域中的变量字典
+- **globals()**：返回当前全局作用域（模块级别）中的变量字典
+
+两者都**不需要参数**：
+
+- 函数签名：`locals() -> dict`
+- 函数签名：`globals() -> dict`
+
+```python showLineNumbers
+x = 10
+
+def func(y):
+    z = 20
+    print("函数内部 locals():")
+    print(locals())      # {'y': 5, 'z': 20}
+    print("函数内部 globals() 是否包含 x? ->", "x" in globals())  # True
+
+func(5)
+
+print("模块级别 globals() 中的部分键：")
+print(list(globals().keys())[:8])  # 只看前几个键
+```
+
+> 一般来说：
+>
+> - 在**函数内部**：`locals()` 反映的是当前函数的局部变量，`globals()` 反映的是整个模块的全局变量；
+> - 在**模块顶层**（不在函数里）：`locals()` 和 `globals()` 返回的其实是同一个字典（都是全局命名空间）。
+
+`locals()` 返回的字典在函数内部通常是**只读视图**，直接修改其返回值，不一定会真正改变局部变量；而通过 `globals()` 返回的字典修改全局变量，一般是有效的：
+
+```python showLineNumbers
+a = 1
+
+def demo():
+    b = 2
+    # 尝试修改局部变量
+    locals()["b"] = 100
+    print("b =", b)  # 仍然是 2，大多数实现中修改无效
+
+demo()
+
+# 通过 globals() 修改全局变量
+globals()["a"] = 99
+print("a =", a)  # 99
+```
+

docs/docs/选择编程语言/Python/29文件操作.mdx

@@ -158,8 +158,9 @@ finally:
     fp.close()
 ```
 
+## 内置函数
 
-## memoryview 函数
+### memoryview函数
 
 `memoryview` 函数主要用于需要高性能和低内存开销的场景，特别是在处理大型二进制数据时。它提供了一个“视图”来直接、高效地访问和操作底层对象的内存，而不需要为数据创建昂贵的副本。
 

docs/docs/选择编程语言/Python/2字符串.mdx

@@ -111,7 +111,7 @@ s = s.getvalue()
 ```
 :::
 
-### str 函数
+### str函数
 str() 函数用于将其他类型的数据转换为字符串类型。这在需要将数字、列表或其他对象作为字符串处理时非常有用。
 
 str 函数签名：`str(object='') -> str`

docs/docs/选择编程语言/Python/30异步编程.mdx

@@ -163,7 +163,7 @@ asyncio.run(main())
 
 ## 内置函数
 
-### aiter 函数和 anext 函数
+### aiter函数、anext函数
 
 `aiter()` 和 `anext()` 是异步版本的 `iter()` 和 `next()`，用于处理异步迭代器。
 
@@ -306,135 +306,3 @@ async def process_stream():
 
 asyncio.run(process_stream())
 ```
-
-
-
-## asyncio
-
-### asyncio 常用函数
-
-虽然 asyncio 是标准库，但这里列出一些常用函数：
-
-```python showLineNumbers
-import asyncio
-
-async def demo_asyncio_functions():
-    # 1. asyncio.sleep() - 异步睡眠
-    await asyncio.sleep(1)
-
-    # 2. asyncio.wait_for() - 设置超时
-    try:
-        result = await asyncio.wait_for(
-            asyncio.sleep(5),
-            timeout=2.0
-        )
-    except asyncio.TimeoutError:
-        print("操作超时")
-    
-    # 3. asyncio.as_completed() - 按完成顺序获取结果
-    tasks = [
-        asyncio.create_task(asyncio.sleep(2, result="慢任务")),
-        asyncio.create_task(asyncio.sleep(1, result="快任务"))
-    ]
-    for coro in asyncio.as_completed(tasks):
-        result = await coro
-        print(f"完成: {result}")
-    # 输出顺序: 快任务, 慢任务
-
-asyncio.run(demo_asyncio_functions())
-```
-
-### asyncio.gather()
-
-使用 `asyncio.gather()` 或 `asyncio.create_task()` 可以并发执行多个协程。
-
-函数签名：
-- `asyncio.gather(*coros_or_futures, loop=None, return_exceptions=False) -> List[Any]`
-
-参数说明：
-- `*coros_or_futures`：协程或 future 对象
-- `loop=None`：事件循环，默认使用当前事件循环
-- `return_exceptions=False`：是否返回异常，默认不返回
-
-返回值说明：
-- 返回结果为列表，列表中包含所有协程或 future 对象的返回结果
-- 如果`return_exceptions=True`，则返回结果为列表，列表中包含所有协程或 future 对象的返回结果，包括异常
-
-```python showLineNumbers
-import asyncio
-import time
-
-async def task(name, duration):
-    """模拟一个异步任务"""
-    print(f"任务 {name} 开始")
-    await asyncio.sleep(duration)
-    print(f"任务 {name} 完成")
-    return f"结果-{name}"
-
-async def main():
-    # 方法1: 使用 gather 并发执行
-    start = time.time()
-    results = await asyncio.gather(
-        task("A", 2),
-        task("B", 1),
-        task("C", 3)
-    )
-    print(f"结果: {results}")
-    print(f"总耗时: {time.time() - start:.2f}秒")
-    # 总耗时约3秒（最长任务的时间），而非6秒
-
-asyncio.run(main())
-# 输出:
-# 任务 A 开始
-# 任务 B 开始
-# 任务 C 开始
-# 任务 B 完成
-# 任务 A 完成
-# 任务 C 完成
-# 结果: ['结果-A', '结果-B', '结果-C']
-# 总耗时: 3.00秒
-```
-### asyncio.create_task()
-
-使用 `asyncio.gather()` 或 `asyncio.create_task()` 可以并发执行多个协程。
-
-函数签名：
-- `asyncio.create_task(coro, *, name=None)`
-
-参数说明：
-- `coro`：协程对象
-- `name=None`：任务名称，默认不设置
-
-返回值说明：
-- 返回结果为任务对象
-
-
-```python showLineNumbers
-import asyncio
-import time
-
-async def task(name, duration):
-    """模拟一个异步任务"""
-    print(f"任务 {name} 开始")
-    await asyncio.sleep(duration)
-    print(f"任务 {name} 完成")
-    return f"结果-{name}"
-
-async def main2():
-    start = time.time()
-    
-    # 创建任务，立即开始执行
-    task1 = asyncio.create_task(task("X", 2))
-    task2 = asyncio.create_task(task("Y", 1))
-    task3 = asyncio.create_task(task("Z", 3))
-    
-    # 等待所有任务完成
-    result1 = await task1
-    result2 = await task2
-    result3 = await task3
-    
-    print(f"结果: {result1}, {result2}, {result3}")
-    print(f"总耗时: {time.time() - start:.2f}秒")
-
-asyncio.run(main2())
-```

docs/docs/选择编程语言/Python/39模块.mdx

@@ -703,9 +703,7 @@ python+c/c++混合编程如：
 
 但不论是哪个方法，大致的流程都是：转换数据类型->编译代码->生成编译后的文件（.pyd .pyc .pyo .so .dll 等）
 
-
-
-### 代码编写
+### 代码示例
 
 一个求某个数可以分解为多少个质数之和代码,其中最核心的代码是判断一个数是否为质数。我们使用C语言实现这个被频繁调用的功能。
 

docs/docs/选择编程语言/Python/3序列.mdx

@@ -49,7 +49,7 @@ result = [x**2 for x in range(10) if x % 2 == 0]
 - copy: 返回列表的浅拷贝
 `} />
 
-### list() 函数
+### list函数
 
 `list()` 函数用于创建一个新的列表，或者将一个可迭代对象转换为列表。
 
@@ -476,7 +476,7 @@ squares = {x: x**2 for x in range(5)}
 - fromkeys: 用指定的键和值创建一个新字典
 `} />
 
-### dict() 函数
+### dict函数
 
 `dict()` 函数用于创建一个新的字典。
 
@@ -916,7 +916,7 @@ squares = {x**2 for x in range(5)}
 `} />
 
 
-### frozenset() 函数
+### frozenset函数
 
 `frozenset` 是 `set` 的不可变版本。一旦创建，`frozenset` 的元素就不能被修改。这使得 `frozenset` 可以作为字典的键或集合中的元素。
 
@@ -948,7 +948,7 @@ print(frozen.difference(other_set)) # frozenset({1, 2, 3})
 由于 `frozenset` 是不可变的，它不支持 `add`, `remove`, `pop`, `update` 等会修改集合内容的方法。
 :::
 
-### set() 函数
+### set函数
 
 `set()` 函数用于创建一个新的集合。
 
@@ -1232,7 +1232,7 @@ result = func(**kwargs)  # 等同于 func(a=1, b=2, c=3)
 - index: 返回元素首次出现的索引
 `} />
 
-### tuple() 函数
+### tuple函数
 
 `tuple()` 函数用于创建一个新的元组。
 
@@ -1507,7 +1507,7 @@ print(b)  # <list_reverseiterator object at 0x...>
 print(list(b))  # [3, 2, 1]
 ```
 
-### filter 函数
+### filter函数
 
 filter 函数用于过滤序列，返回一个迭代器对象。