New translations handlers.md (Chinese Simplified)

guide/content/zh/guide/basics/handlers.md

@@ -28,52 +28,52 @@ async def i_am_ALSO_a_handler(request):
 
 还有另外两个点需要注意一下：
 
-1. 你可以不用直接使用 :class:`sanic.response.HTTPresponse` 实例去返回数据 使用一些内置封装好的[返回函数](./response#methods)将会变的更加简单。
+1. 你可以不用直接使用 :class:`sanic.response.HTTPresponse` 实例去返回数据 使用一些内置封装好的[便捷方法](./response#methods)，将会变的更加简单。
 
    - `from sanic import json`
    - `from sanic import html`
    - `from sanic import redirect`
    - _etc_
-2. 我们会在[流媒体部分](../advanced/streaming#response-streaming)中看到的，您并不总是需要返回一个对象。 如果您使用此较低级别的 API，您可以控制处理器内响应的流量，并且返回对象未被使用。
+2. 我们会在[流媒体部分](../advanced/streaming#response-streaming)中看到的，您并不总是需要返回一个对象。 如果您使用这个底层的 API，您可以在处理程序内部控制响应的流程，并且不需要使用返回对象。
 
-.. 提示：浮动通知
+.. tip:: 提示
 
 ```
-如果你想了解更多关于封装你的逻辑的信息，结帐[基于类的视图](../advanced/class-based-views.md)。现在，我们将继续只是基于函数的视图。
+如果你想了解更多关于封装逻辑的内容，可以查阅[基于类的视图](../advanced/class-based-views.md)。现在，我们将继续仅基于函数的视图讲解。
 ```
 
-### 一个简单的基于功能的处理程序
+### 一个简单的基于函数的处理器
 
-创建路由处理程序的最常见方式是装饰函数。 它为路线定义建立简单的视觉标识。 我们将了解更多关于[路由](./routing.md)
+创建路由处理程序的最常见方式是装饰函数。 它为路由定义创建了一个视觉上简洁的标识。 我们稍后将了解更多关于[路由](./routing.md)
 
-.. 列:
+.. column::
 
 ```
-Let's look at a practical example.
+让我们来看一个实际的例子。
 
-- We use a convenience decorator on our app instance: `@app.get()`
-- And a handy convenience method for generating out response object: `text()`
+- 我们在应用实例上使用了一个便捷装饰器：`@app.get()`
+- 以及一个用于生成响应对象的便捷方法：`text()`
 
-Mission accomplished 💪
+任务完成💪
 ```
 
-.. 列:
+.. column::
 
 ````
 ```python
 from sanic import text
 
 @app.get("/foo")
 async def foo_handler(request):
-    return text("我说了！")
+    return text("I said foo!")
 ```
 ````
 
 ---
 
 ## 关于 _async_...
 
-.. 列:
+.. column::
 
 ```
 完全可以写入同步处理程序。
@@ -86,65 +86,65 @@ async def foo_handler(request):
 - 或大约**31.76** 请求/秒
 ```
 
-.. 列:
+.. column::
 
 ````
 ```python
 @app.get("/sync")
 def sync_handler(request):
     time.sleep(0.1)
-    return text("完成")
+    return text("Done.")
 ```
 ````
 
-.. 列:
+.. column::
 
 ```
-Just by changing to the asynchronous alternative `asyncio.sleep()`, we see an incredible change in performance. 🚀
+只需将 `time.sleep()` 更改为异步替代方案 `asyncio.sleep()`，我们就能看到性能有了显著提升。 🚀
 
-Using the same four (4) worker processes:
+同样使用四个（4）工作进程：
 
-- **115,590** requests in 30.08s
-- Or, about **3,843.17** requests/second
+- 在30.08秒内处理了 **115,590** 个请求
+- 或者说，大约每秒处理 **3,843.17** 个请求
 
 .. attrs::
     :class: is-size-2
 
     🤯
 ```
 
-.. 列:
+.. column::
 
 ````
 ```python
 @app.get("/async")
 async def async_handler(request):
-    等待asyncio.sleep(0.1)
-    return text("完成")
+    await asyncio.sleep(0.1)
+    return text("Done.")
 ```
 ````
 
-好的... 这是一个荒谬的过于戏剧性的结果。 你们所看到的任何基准都本质上是非常偏颇的。 这个示例是为了在网上显示`async/await`的好处。 结果肯定会有所不同。 诸如Sanic和其他异步Python图书馆之类的工具不是使事情变得更快的神奇子弹。 它们使它们更有效率。
+好的... 这是一个夸张得离谱的结果。 你们所看到的任何基准都本质上是非常偏颇的。 这个例子旨在极度展示`async/await`在web开发领域的优势。 结果肯定会有所不同。 像Sanic和其他异步Python库并非神奇的解决方案，能自动让程序运行更快。 它们使程序执行更加高效。
 
-在我们的例子中，异步版本要好得多，因为当一个请求正在睡觉时， 它能够开始另一个和另一个，以及另一个...
+在我们的示例中，异步版本之所以表现优秀，是因为当一个请求在“睡眠”（等待）时，它可以开始处理另一个请求，然后再处理下一个、下一个、下一个……以此类推，实现并行处理多个请求，从而大大提高服务器的吞吐量。
 
-但这是要点！ 沙漠之所以迅速，是因为它需要现有的资源，并挤压了可用资源的业绩。 它可以同时处理许多请求，这意味着每秒要有更多的请求。
+但是，这就是关键所在！ Sanic之所以快，是因为它充分利用可用资源并榨取其性能潜力。 它可以同时处理大量请求，这就意味着每秒能够处理更多的请求。
 
-.. 提示：常见错误！
+.. 提示：一个常见的误区！
 
 ```
-Don't do this! You need to ping a website. What do you use? `pip install your-fav-request-library` 🙈
+当你你需要对一个网站进行ping操作。你会用什么工具？`pip install 你最爱的请求库 `，我劝你不要这样做🙈
 
-Instead, try using a client that is `async/await` capable. Your server will thank you. Avoid using blocking tools, and favor those that play well in the asynchronous ecosystem. If you need recommendations, check out [Awesome Sanic](https://github.com/mekicha/awesome-sanic).
+而应该尝试使用支持`async/await`功能的客户端。你的服务器会因此说`谢谢你`，避免使用阻塞型工具，尽量选择能良好适应异步生态系统中的工具。如果你需要推荐，可以查看[Awesome Sanic](https://github.com/mekicha/awesome-sanic).。
 
-Sanic uses [httpx](https://www.python-httpx.org/) inside of its testing package (sanic-testing) 😉.
+Sanic在其测试包（sanic-testing）中使用了[httpx](https://www.python-httpx.org/) 😜。
 ```
 
 ---
 
-## 一个完整注释的处理程序
+## 一个带完整注解的处理器
 
-对于那些使用类型注释的人...
+对于那些使用类型注解的人...
 
 ```python
 from sanic.response import HTTPResponse, text
@@ -155,63 +155,63 @@ async def typed_handler(request: Request) -> HTTPResponse:
     return text("Done.")
 ```
 
-## 命名您的处理程序
+## 为您的处理器命名
 
-所有处理程序都是自动命名的。 这对调试和生成模板中的 URL非常有用。 未指定时，将使用的名称是函数的名称。
+所有处理器都会自动命名。 这对于调试和在模板中生成URL非常有用。 如果不特别指定，将使用的名称就是函数的名
 
-.. 列:
+.. column::
 
 ```
 例如，这个处理程序将被命名为“foo_handler”。
 ```
 
-.. 列:
+.. column::
 
 ````
 ```python
-# Handler 名称将是“foo_handler”
+# Handler name will be "foo_handler"
 @app.get("/foo")
 async def foo_handler(request):
-    return text("我说了！")
+    return text("I said foo!")
 ```
 ````
 
-.. 列:
+.. column::
 
 ```
-然而，你可以把`name`的参数传递给装饰师来覆盖这个问题。
+同样，您可以通过向装饰器传递`name`参数来指定名称。
 ```
 
-.. 列:
+.. column::
 
 ````
 ```python
-# Handler 名称将是“foo”
+# Handler name will be "foo"
 @app.get("/foo", name="foo")
 async def foo_handler(request):
-    return text("我说了！")
+    return text("I said foo!")
 ```
 ````
 
-.. 列:
+.. column::
 
 ```
 事实上，正如你将要做的那样，可能有时候你**MUST** 提供一个名称。 例如，如果你在同一函数上使用两个装饰器，你需要为其中至少一个提供一个名称。
 
 如果您不这样做，您将会遇到一个错误，您的应用程序将不会启动。名称**必须** 在您的应用程序中是唯一的。
 ```
 
-.. 列:
+.. column::
 
 ````
 ```python
-# 两个处理器，相同的函数，
-# 不同的名字：
+# Two handlers, same function,
+# different names:
 # - "foo_arg"
 # - "foo"
-@app。 et("/foo/<arg>", name="foo_arg")
+@app.get("/foo/<arg>", name="foo_arg")
 @app.get("/foo")
-异步脚(请求，arg=Non):
-    return text("我说了！")
+async def foo(request, arg=None):
+    return text("I said foo!")
 ```
 ````