Python의 코루틴에서는 정확히 무슨 일이 일어나고 있나요?
1. 기존 동기화 구문 요청 예시
는 여전히 동일합니다. 비동기 구문 구현을 이해하기 전에 먼저 동기화 구문 예시부터 시작하겠습니다. 이 프로그램은 해당 응답 콘텐츠를 얻습니다.
import socket
def request(host: str) -> None:
"""模拟请求并打印响应体"""
url: str = f"http://{host}"
sock: socket.SocketType = socket.socket()
sock.connect((host, 80))
sock.send(f"GET {url} HTTP/1.0rnHost: {host}rnrn".encode("ascii"))
response_bytes: bytes = b""
chunk: bytes = sock.recv(4096)
while chunk:
response_bytes += chunk
chunk = sock.recv(4096)
print("n".join([i for i in response_bytes.decode().split("rn")]))
if __name__ == "__main__":
request("so1n.me")프로그램을 실행하면 프로그램이 정상적으로 출력되고 상단에는 해당 HTTP 응답 헤더가 인쇄되고 하단에는 HTTP 응답 본문이 인쇄되며 서버가 호출하는 것을 볼 수 있습니다. us https 형식으로 다시 요청하면 출력 결과는 다음과 같습니다.
HTTP/1.1 301 Moved Permanently Server: GitHub.com Content-Type: text/html Location: https://so1n.me/ X-GitHub-Request-Id: A744:3871:4136AF:48BD9F:6188DB50 Content-Length: 162 Accept-Ranges: bytes Date: Mon, 08 Nov 2021 08:11:37 GMT Via: 1.1 varnish Age: 104 Connection: close X-Served-By: cache-qpg1272-QPG X-Cache: HIT X-Cache-Hits: 2 X-Timer: S1636359097.026094,VS0,VE0 Vary: Accept-Encoding X-Fastly-Request-ID: 22fa337f777553d33503cee5282598c6a293fb5e <html> <head><title>301 Moved Permanently</title></head> <body> <center><h1 id="Moved-Permanently">301 Moved Permanently</h1></center> <hr><center>nginx</center> </body> </html>
그러나 이는 HTTP 요청이 어떻게 구현되는지를 말하는 것이 아닙니다. 이 코드에서 기본 호출은 자세히 알 수 없습니다. 스레드가 connect 또는 recv를 호출하면(Send는 기다릴 필요가 없지만 동시성이 높으면 보내기 전에 배수를 기다려야 합니다. 소규모 데모에서는 배수 방법을 사용할 필요가 없습니다) 프로그램이 작업이 완료될 때까지 일시 중지합니다. 한 번에 많은 웹페이지를 다운로드하게 되면 앞선 글에서 언급한 것과 같게 되며 대부분의 대기 시간은 IO에 소비되고 CPU는 항상 유휴 상태가 됩니다. 매우 높으며 동시에 운영 체제는 프로세스, 사용자 또는 시스템이 사용할 수 있는 스레드 수를 제한하는 경우가 많지만 코루틴은 그러한 제한이 없고 리소스를 덜 차지하며 시스템 병목 현상이 없습니다.
2. 비동기식 요청
비동기식은 별도의 스레드가 동시 작업을 처리하도록 허용합니다. 그러나 위에서 언급한 것처럼 소켓은 기본적으로 차단되므로 소켓은 setblocking 메서드를 제공합니다. 개발자가 차단 여부를 선택할 수 있도록 하기 위해 Non-Blocking을 설정한 후 연결 및 수신 방법도 변경해야 합니다.
차단이 없기 때문에 프로그램은 연결을 호출한 후 즉시 반환됩니다. 그러나 Python의 최하위 계층은 C입니다. 이 코드는 C에서 비차단 소켓.connect를 호출한 후 예외를 발생시킵니다. 이를 잡아야 합니다.
import socket
sock: socket.SocketType = socket.socket()
sock.setblocking(Flase)
try:
sock.connect(("so1n.me", 80))
except BlockingIOError:
pass작업 후 연결 설정을 신청하기 시작했지만 연결이 설정되지 않은 경우 send를 호출하면 오류가 보고되므로 연결이 언제 완료될지 알 수 없습니다. 오류가 보고되면 성공으로 간주됩니다(실제 코드에서는 시간 제한을 추가해야 함).
while True: try: sock.send(request) break except OSError as e: pass
하지만 CPU를 유휴 상태로 두는 것은 성능 낭비입니다. 그 동안은 다른 일을 할 수 없습니다. 테이크아웃을 주문하고 계속 전화해서 식사가 준비됐는지 물어보는 것처럼요. 아니, 식사가 끝난 후 전화하면 비용만 발생합니다. 이는 매우 경제적입니다(일반적인 상황에서도 마찬가지입니다). 이때 이벤트 루프가 작동하게 됩니다. UNIX 계열 시스템에는 리스닝 함수를 호출하기 전에 이벤트가 발생할 때까지 기다릴 수 있는 select라는 함수가 있습니다. 그러나 초기 구현 성능이 좋지 않아 교체되었습니다. 그러나 인터페이스는 유사합니다. 그 이유는 이러한 다양한 이벤트 루프가 Python의 선택기 라이브러리에 캡슐화되어 있기 때문입니다. 동시에 DefaultSelector를 통해 시스템에서 가장 유사한 선택 기능을 선택할 수 있습니다. 지금은 이벤트 루프의 원리에 대해 이야기하지 않겠습니다. 이벤트 루프에서 가장 중요한 것은 이름의 두 부분입니다. 하나는 이벤트이고 다른 하나는 이벤트에 이벤트를 등록할 수 있습니다.
def demo(): pass selector.register(fd, EVENT_WRITE, demo)
이 방법으로 이 이벤트 루프는 해당 파일 설명자 fd를 수신합니다. 이 파일 설명자가 쓰기 이벤트(EVENT_WRITE)를 트리거하면 이벤트 루프는 등록된 함수 데모를 호출할 수 있음을 알려줍니다. 그런데 위의 코드를 이 메소드로 변경하여 실행하게 되면 프로그램이 실행되지 않고 종료되는 것처럼 보이지만 실제로는 프로그램이 실행되지만 등록을 완료한 후 개발자가 이벤트를 받기를 기다립니다. 루프 이벤트는 다음 작업을 수행하므로 코드 끝에 다음 코드만 작성하면 됩니다.
while True: for key, mask in selector.select(): key.data()
이러한 방식으로 프로그램은 계속 실행되며 이벤트가 캡처되면 for를 통해 알려줍니다. 여기서 key .data는 우리가 등록한 콜백 함수입니다. 이벤트가 발생하면 알림을 받게 됩니다. 콜백 함수를 가져와서 실행할 수 있으면 Simple Small을 구현하는 첫 번째 동시 프로그램을 작성할 수 있습니다. I/O 멀티플렉싱 로직에 대한 코드와 설명은 다음과 같습니다.
import socket
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE
# 选择事件循环
selector: DefaultSelector = DefaultSelector()
# 用于判断是否有事件在运行
running_cnt: int = 0
def request(host: str) -> None:
"""模拟请求并打印响应体"""
# 告诉主函数， 自己的事件还在运行
global running_cnt
running_cnt += 1
# 初始化socket
url: str = f"http://{host}"
sock: socket.SocketType = socket.socket()
sock.setblocking(False)
try:
sock.connect((host, 80))
except BlockingIOError:
pass
response_bytes: bytes = b""
def read_response() -> None:
"""接收响应参数， 并判断请求是否结束"""
nonlocal response_bytes
chunk: bytes = sock.recv(4096)
print(f"recv {host} body success")
if chunk:
response_bytes += chunk
else:
# 没有数据代表请求结束了， 注销监听
selector.unregister(sock.fileno())
global running_cnt
running_cnt -= 1
def connected() -> None:
"""socket建立连接时的回调"""
# 取消监听
selector.unregister(sock.fileno())
print(f"{host} connect success")
# 发送请求， 并监听读事件， 以及注册对应的接收响应函数
sock.send(f"GET {url} HTTP/1.0rnHost: {host}rnrn".encode("ascii"))
selector.register(sock.fileno(), EVENT_READ, read_response)
selector.register(sock.fileno(), EVENT_WRITE, connected)
if __name__ == "__main__":
# 同时多个请求
request("so1n.me")
request("github.com")
request("google.com")
request("baidu.com")
# 监听是否有事件在运行
while running_cnt > 0:
# 等待事件循环通知事件是否已经完成
for key, mask in selector.select():
key.data()이 코드는 거의 동시에 4개의 요청을 등록하고 연결 콜백을 등록한 다음 이벤트 루프 로직, 즉 이벤트에 대한 제어권을 입력합니다. 이벤트 루프가 프로그램에 소켓 설정 알림을 받았다고 알릴 때까지 반복하면 프로그램은 등록된 콜백을 취소한 다음 요청을 보내고 읽기 이벤트 콜백을 등록한 다음 응답 결과가 수신될 때까지 이벤트 루프에 제어를 전달합니다. 그래야만 응답 결과 처리 기능으로 들어가고 모든 응답 결과가 수집될 때까지 프로그램은 종료되지 않습니다. 다음은 내 처형 중 하나의 결과입니다.
so1n.me connect success github.com connect success google.com connect success recv google.com body success recv google.com body success baidu.com connect success recv github.com body success recv github.com body success recv baidu.com body success recv baidu.com body success recv so1n.me body success recv so1n.me body success
可以看到他们的执行顺序是随机的， 不是严格的按照so1n.me, github.com, google.com, baidu.com顺序执行， 同时他们执行速度很快， 这个程序的耗时约等于响应时长最长的函数耗时。但是可以看出， 这个程序里面出现了两个回调， 回调会让代码变得非常的奇怪, 降低可读性， 也容易造成回调地狱， 而且当回调发生报错的时候， 我们是很难知道这是由于什么导致的错误， 因为它的上下文丢失了， 这样子排查问题十分的困惑。作为程序员， 一般都不止满足于速度快的代码， 真正想要的是又快， 又能像Sync的代码一样简单, 可读性强, 也能容易排查问题的代码, 这种组合形式的代码的设计模式就叫协程。
协程出现得很早， 它不像线程一样， 被系统调度， 而是能自主的暂停， 并等待事件循环通知恢复。由于协程是软件层面实现的， 所以它的实现方式有很多种， 这里要说的是基于生成器的协程， 因为生成器跟协程一样， 都有暂停让步和恢复的方法(还可以通过throw来抛错）， 同时它跟Async语法的协程很像， 通过了解基于生成器的协程， 可以了解Async的协程是如何实现的。
三.基于生成器的协程
3.1生成器
在了解基于生成器的协程之前， 需要先了解下生成器， Python的生成器函数与普通的函数会有一些不同, 只有普通函数中带有关键字yield， 那么它就是生成器函数， 具体有什么不同可以通过他们的字节码来了解：
In [1]: import dis # 普通函数 In [2]: def aaa(): pass In [3]: dis.dis(aaa) 1 0 LOAD_CONST 0 (None) 2 RETURN_VALUE # 普通函数调用函数 In [4]: def bbb(): ...: aaa() ...: In [5]: dis.dis(bbb) 2 0 LOAD_GLOBAL0 (aaa) 2 CALL_FUNCTION0 4 POP_TOP 6 LOAD_CONST 0 (None) 8 RETURN_VALUE # 普通生成器函数 In [6]: def ccc(): yield In [7]: dis.dis(ccc) 1 0 LOAD_CONST 0 (None) 2 YIELD_VALUE 4 POP_TOP 6 LOAD_CONST 0 (None) 8 RETURN_VALUE
上面分别是普通函数， 普通函数调用函数和普通生成器函数的字节码， 从字节码可以看出来， 最简单的函数只需要LOAD_CONST来加载变量None压入自己的栈， 然后通过RETURN_VALUE来返回值， 而有函数调用的普通函数则先加载变量， 把全局变量的函数aaa加载到自己的栈里面， 然后通过CALL_FUNCTION来调用函数， 最后通过POP_TOP把函数的返回值从栈里抛出来， 再把通过LOAD_CONST把None压入自己的栈， 最后返回值。而生成器函数则不一样， 它会先通过LOAD_CONST来加载变量None压入自己的栈， 然后通过YIELD_VALUE返回值， 接着通过POP_TOP弹出刚才的栈并重新把变量None压入自己的栈， 最后通过RETURN_VALUE来返回值。从字节码来分析可以很清楚的看到， 生成器能够在yield区分两个栈帧, 一个函数调用可以分为多次返回， 很符合协程多次等待的特点。
接着来看看生成器的一个使用, 这个生成器会有两次yield调用, 并在最后返回字符串'None'， 代码如下：
In [8]: def demo():
...: a = 1
...: b = 2
...: print('aaa', locals())
...: yield 1
...: print('bbb', locals())
...: yield 2
...: return 'None'
...:
In [9]: demo_gen = demo()
In [10]: demo_gen.send(None)
aaa {'a': 1, 'b': 2}
Out[10]: 1
In [11]: demo_gen.send(None)
bbb {'a': 1, 'b': 2}
Out[11]: 2
In [12]: demo_gen.send(None)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-12-8f8cb075d6af> in <module>
----> 1 demo_gen.send(None)
StopIteration: None这段代码首先通过函数调用生成一个demo_gen的生成器对象, 然后第一次send调用时返回值1， 第二次send调用时返回值2， 第三次send调用则抛出StopIteration异常， 异常提示为None, 同时可以看到第一次打印aaa和第二次打印bbb时， 他们都能打印到当前的函数局部变量， 可以发现在即使在不同的栈帧中， 他们读取到当前的局部函数内的局部变量是一致的， 这意味着如果使用生成器来模拟协程时， 它还是会一直读取到当前上下文的， 非常的完美。
此外， Python还支持通过yield from语法来返回一个生成器, 代码如下:
In [1]: def demo_gen_1(): ...: for i in range(3): ...: yield i ...: In [2]: def demo_gen_2(): ...: yield from demo_gen_1() ...: In [3]: demo_gen_obj = demo_gen_2() In [4]: demo_gen_obj.send(None) Out[4]: 0 In [5]: demo_gen_obj.send(None) Out[5]: 1 In [6]: demo_gen_obj.send(None) Out[6]: 2 In [7]: demo_gen_obj.send(None) --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-7-f9922a2f64c9> in <module> ----> 1 demo_gen_obj.send(None) StopIteration:
通过yield from就可以很方便的支持生成器调用， 假如把每个生成器函数都当做一个协程， 那通过yield from就可以很方便的实现协程间的调用， 此外生成器的抛出异常后的提醒非常人性化， 也支持throw来抛出异常， 这样我们就可以实现在协程运行时设置异常， 比如Cancel，演示代码如下:
In [1]: def demo_exc(): ...: yield 1 ...: raise RuntimeError() ...: In [2]: def demo_exc_1(): ...: for i in range(3): ...: yield i ...: In [3]: demo_exc_gen = demo_exc() In [4]: demo_exc_gen.send(None) Out[4]: 1 In [5]: demo_exc_gen.send(None) --------------------------------------------------------------------------- RuntimeErrorTraceback (most recent call last) <ipython-input-5-09fbb75fdf7d> in <module> ----> 1 demo_exc_gen.send(None) <ipython-input-1-69afbc1f9c19> in demo_exc() 1 def demo_exc(): 2 yield 1 ----> 3 raise RuntimeError() 4 RuntimeError: In [6]: demo_exc_gen_1 = demo_exc_1() In [7]: demo_exc_gen_1.send(None)Out[7]: 0 n [8]: demo_exc_gen_1.send(None) Out[8]: 1 In [9]: demo_exc_gen_1.throw(RuntimeError) --------------------------------------------------------------------------- RuntimeErrorTraceback (most recent call last) <ipython-input-9-1a1cc55d71f4> in <module> ----> 1 demo_exc_gen_1.throw(RuntimeError) <ipython-input-2-2617b2366dce> in demo_exc_1() 1 def demo_exc_1(): 2 for i in range(3): ----> 3 yield i 4 RuntimeError:
从中可以看到在运行中抛出异常时， 会有一个非常清楚的抛错， 可以明显看出错误堆栈， 同时throw指定异常后， 会在下一处yield抛出异常(所以协程调用Cancel后不会马上取消， 而是下一次调用的时候才被取消)。
3.2用生成器实现协程
我们已经简单的了解到了生成器是非常的贴合协程的编程模型， 同时也知道哪些生成器API是我们需要的API， 接下来可以模仿Asyncio的接口来实现一个简单的协程。
首先是在Asyncio中有一个封装叫Feature, 它用来表示协程正在等待将来时的结果, 以下是我根据asyncio.Feature封装的一个简单的Feature, 它的API没有asyncio.Feature全, 代码和注释如下:
class Status:
"""用于判断Future状态"""
pending: int = 1
finished: int = 2
cancelled: int = 3
class Future(object):
def __init__(self) -> None:
"""初始化时， Feature处理pending状态， 等待set result"""
self.status: int = Status.pending
self._result: Any = None
self._exception: Optional[Exception] = None
self._callbacks: List[Callable[['Future'], None]] = []
def add_done_callback(self, fn: [['Future'], None]Callable) -> None:
"""添加完成时的回调"""
self._callbacks.append(fn)def cancel(self):
"""取消当前的Feature"""
if self.status != Status.pending:
return False
self.status = Status.cancelled
for fn in self._callbacks:
fn(self)
return True
def set_exception(self, exc: Exception) -> None:
"""设置异常"""
if self.status != Status.pending:
raise RuntimeError("Can not set exc")
self._exception = exc
self.status = Status.finished
def set_result(self, result: Any) -> None:
"""设置结果"""
if self.status != Status.pending:
raise RuntimeError("Can not set result")
self.status = Status.finished
self._result = result
for fn in self._callbacks:
fn(self)
def result(self):
"""获取结果"""
if self.status == Status.cancelled:
raise asyncio.CancelledError
elif self.status != Status.finished:
raise RuntimeError("Result is not read")
elif self._exception is not None:
raise self._exception
return self._result
def __iter__(self):
"""通过生成器来模拟协程， 当收到结果通知时， 会返回结果"""
if self.status == Status.pending:
yield self
return self.result()在理解Future时， 可以把它假想为一个状态机， 在启动初始化的时候是peding状态， 在运行的时候我们可以切换它的状态, 并且通过__iter__方法来支持调用者使用yield from Future()来等待Future本身， 直到收到了事件通知时， 可以得到结果。
但是可以发现这个Future是无法自我驱动, 调用了__iter__的程序不知道何时被调用了set_result， 在Asyncio中是通过一个叫Task的类来驱动Future, 它将一个协程的执行过程安排好， 并负责在事件循环中执行该协程。它主要有两个方法:
1.初始化时， 会先通过send方法激活生成器
2.后续被调度后马上安排下一次等待， 除非抛出StopIteration异常
还有一个支持取消运行托管协程的方法(在原代码中， Task是继承于Future, 所以Future有的它都有), 经过简化后的代码如下：
class Task: def __init__(self, coro: Generator) -> None: # 初始化状态 self.cancelled: bool = False self.coro: Generator = coro # 预激一个普通的future f: Future = Future() f.set_result(None) self.step(f) def cancel(self) -> None: """用于取消托管的coro""" self.coro.throw(asyncio.CancelledError) def step(self, f: Future) -> None: """用于调用coro的下一步, 从第一次激活开始， 每次都添加完成时的回调， 直到遇到取消或者StopIteration异常""" try: _future = self.coro.send(f.result()) except asyncio.CancelledError: self.cancelled = True return except StopIteration: return _future.add_done_callback(self.step)
这样Future和Task就封装好了， 可以简单的试一试效果如何:
In [2]:def wait_future(f: Future, flag_int: int) -> Generator[Future, None, None]:
...:result = yield from f
...:print(flag_int, result)
...:
...:future: Future = Future()
...:for i in range(3):
...:coro = wait_future(future, i)
...:# 托管wait_future这个协程， 里面的Future也会通过yield from被托管
...:Task(coro)
...:
...:print('ready')
...:future.set_result('ok')
...:
...:future = Future()
...:Task(wait_future(future, 3)).cancel()
...:ready
0 ok
1 ok
2 ok
---------------------------------------------------------------------------
CancelledErrorTraceback (most recent call last)
<ipython-input-2-2d1b04db2604> in <module>
12
13 future = Future()
---> 14 Task(wait_future(future, 3)).cancel()
<ipython-input-1-ec3831082a88> in cancel(self)
81
82 def cancel(self) -> None:
---> 83 self.coro.throw(asyncio.CancelledError)
84
85 def step(self, f: Future) -> None:
<ipython-input-2-2d1b04db2604> in wait_future(f, flag_int)
1 def wait_future(f: Future, flag_int: int) -> Generator[Future, None, None]:
----> 2 result = yield from f
3 print(flag_int, result)
4
5 future: Future = Future()
<ipython-input-1-ec3831082a88> in __iter__(self)
68 """通过生成器来模拟协程， 当收到结果通知时， 会返回结果"""
69 if self.status == Status.pending:
---> 70 yield self
71 return self.result()
72
CancelledError:这段程序会先初始化Future, 并把Future传给wait_future并生成生成器, 再交由给Task托管， 预激, 由于Future是在生成器函数wait_future中通过yield from与函数绑定的， 真正被预激的其实是Future的__iter__方法中的yield self, 此时代码逻辑会暂停在yield self并返回。在全部预激后， 通过调用Future的set_result方法， 使Future变为结束状态， 由于set_result会执行注册的回调， 这时它就会执行托管它的Task的step方法中的send方法, 代码逻辑回到Future的__iter__方法中的yield self， 并继续往下走， 然后遇到return返回结果, 并继续走下去, 从输出可以发现程序封装完成且打印了ready后， 会依次打印对应的返回结果， 而在最后一个的测试cancel方法中可以看到，Future抛出异常了， 同时这些异常很容易看懂， 能够追随到调用的地方。
现在Future和Task正常运行了， 可以跟我们一开始执行的程序进行整合, 代码如下：
class HttpRequest(object):
def __init__(self, host: str):
"""初始化变量和sock"""
self._host: str = host
global running_cnt
running_cnt += 1
self.url: str = f"http://{host}"
self.sock: socket.SocketType = socket.socket()
self.sock.setblocking(False)
try:
self.sock.connect((host, 80))
except BlockingIOError:
pass
def read(self) -> Generator[Future, None, bytes]:
"""从socket获取响应数据， 并set到Future中， 并通过Future.__iter__方法或得到数据并通过变量chunk_future返回"""
f: Future = Future()
selector.register(self.sock.fileno(), EVENT_READ, lambda: f.set_result(self.sock.recv(4096)))
chunk_future = yield from f
selector.unregister(self.sock.fileno())
return chunk_future# type: ignore
def read_response(self) -> Generator[Future, None, bytes]:
"""接收响应参数， 并判断请求是否结束"""
response_bytes: bytes = b""
chunk = yield from self.read()
while chunk:
response_bytes += chunk
chunk = yield from self.read()
return response_bytes
def connected(self) -> Generator[Future, None, None]:
"""socket建立连接时的回调"""
# 取消监听
f: Future = Future()
selector.register(self.sock.fileno(), EVENT_WRITE, lambda: f.set_result(None))
yield f
selector.unregister(self.sock.fileno())
print(f"{self._host} connect success")
def request(self) -> Generator[Future, None, None]:
# 发送请求， 并监听读事件， 以及注册对应的接收响应函数
yield from self.connected()
self.sock.send(f"GET {self.url} HTTP/1.0rnHost: {self._host}rnrn".encode("ascii"))
response = yield from self.read_response()
print(f"request {self._host} success, length:{len(response)}")
global running_cnt
running_cnt -= 1
if __name__ == "__main__":
# 同时多个请求
Task(HttpRequest("so1n.me").request())
Task(HttpRequest("github.com").request())
Task(HttpRequest("google.com").request())
Task(HttpRequest("baidu.com").request())
# 监听是否有事件在运行
while running_cnt > 0:
# 等待事件循环通知事件是否已经完成
for key, mask in selector.select():
key.data()这段代码通过Future和生成器方法尽量的解耦回调函数， 如果忽略了HttpRequest中的connected和read方法则可以发现整段代码跟同步的代码基本上是一样的, 只是通过yield和yield from交出控制权和通过事件循环恢复控制权。同时通过上面的异常例子可以发现异常排查非常的方便， 这样一来就没有了回调的各种糟糕的事情， 开发者只需要按照同步的思路进行开发即可， 不过我们的事件循环是一个非常简单的事件循环例子， 同时对于socket相关都没有进行封装， 也缺失一些常用的API， 而这些都会被Python官方封装到Asyncio这个库中， 通过该库， 我们可以近乎完美的编写Async语法的代码。
위 내용은 Python의 코루틴에서는 정확히 무슨 일이 일어나고 있나요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
핫 AI 도구
Undresser.AI Undress
사실적인 누드 사진을 만들기 위한 AI 기반 앱
AI Clothes Remover
사진에서 옷을 제거하는 온라인 AI 도구입니다.
Undress AI Tool
무료로 이미지를 벗다
Clothoff.io
AI 옷 제거제
AI Hentai Generator
AI Hentai를 무료로 생성하십시오.
인기 기사
뜨거운 도구
메모장++7.3.1
사용하기 쉬운 무료 코드 편집기
SublimeText3 중국어 버전
중국어 버전, 사용하기 매우 쉽습니다.
스튜디오 13.0.1 보내기
강력한 PHP 통합 개발 환경
드림위버 CS6
시각적 웹 개발 도구
SublimeText3 Mac 버전
신 수준의 코드 편집 소프트웨어(SublimeText3)
뜨거운 주제
7522
15
1378
52
81
11
54
19
21
74
파이썬 : 게임, Guis 등
Apr 13, 2025 am 12:14 AM
Python은 게임 및 GUI 개발에서 탁월합니다. 1) 게임 개발은 Pygame을 사용하여 드로잉, 오디오 및 기타 기능을 제공하며 2D 게임을 만드는 데 적합합니다. 2) GUI 개발은 Tkinter 또는 PYQT를 선택할 수 있습니다. Tkinter는 간단하고 사용하기 쉽고 PYQT는 풍부한 기능을 가지고 있으며 전문 개발에 적합합니다.
PHP 및 Python : 두 가지 인기있는 프로그래밍 언어를 비교합니다
Apr 14, 2025 am 12:13 AM
PHP와 Python은 각각 고유 한 장점이 있으며 프로젝트 요구 사항에 따라 선택합니다. 1.PHP는 웹 개발, 특히 웹 사이트의 빠른 개발 및 유지 보수에 적합합니다. 2. Python은 간결한 구문을 가진 데이터 과학, 기계 학습 및 인공 지능에 적합하며 초보자에게 적합합니다.
Debian Readdir가 다른 도구와 통합하는 방법
Apr 13, 2025 am 09:42 AM
데비안 시스템의 readdir 함수는 디렉토리 컨텐츠를 읽는 데 사용되는 시스템 호출이며 종종 C 프로그래밍에 사용됩니다. 이 기사에서는 ReadDir를 다른 도구와 통합하여 기능을 향상시키는 방법을 설명합니다. 방법 1 : C 언어 프로그램을 파이프 라인과 결합하고 먼저 C 프로그램을 작성하여 readDir 함수를 호출하고 결과를 출력하십시오.#포함#포함#포함#포함#includinTmain (intargc, char*argv []) {dir*dir; structdirent*entry; if (argc! = 2) {
파이썬과 시간 : 공부 시간을 최대한 활용
Apr 14, 2025 am 12:02 AM
제한된 시간에 Python 학습 효율을 극대화하려면 Python의 DateTime, Time 및 Schedule 모듈을 사용할 수 있습니다. 1. DateTime 모듈은 학습 시간을 기록하고 계획하는 데 사용됩니다. 2. 시간 모듈은 학습과 휴식 시간을 설정하는 데 도움이됩니다. 3. 일정 모듈은 주간 학습 작업을 자동으로 배열합니다.
NGINX SSL 인증서 업데이트 Debian Tutorial
Apr 13, 2025 am 07:21 AM
이 기사에서는 Debian 시스템에서 NginxSSL 인증서를 업데이트하는 방법에 대해 안내합니다. 1 단계 : CertBot을 먼저 설치하십시오. 시스템에 CERTBOT 및 PYTHON3-CERTBOT-NGINX 패키지가 설치되어 있는지 확인하십시오. 설치되지 않은 경우 다음 명령을 실행하십시오. sudoapt-getupdatesudoapt-getinstallcertbotpython3-certbot-nginx 2 단계 : 인증서 획득 및 구성 rectbot 명령을 사용하여 nginx를 획득하고 nginx를 구성하십시오.
Debian OpenSSL에서 HTTPS 서버를 구성하는 방법
Apr 13, 2025 am 11:03 AM
데비안 시스템에서 HTTPS 서버를 구성하려면 필요한 소프트웨어 설치, SSL 인증서 생성 및 SSL 인증서를 사용하기 위해 웹 서버 (예 : Apache 또는 Nginx)를 구성하는 등 여러 단계가 포함됩니다. 다음은 Apacheweb 서버를 사용하고 있다고 가정하는 기본 안내서입니다. 1. 필요한 소프트웨어를 먼저 설치하고 시스템이 최신 상태인지 확인하고 Apache 및 OpenSSL을 설치하십시오 : Sudoaptupdatesudoaptupgradesudoaptinsta
데비안에 대한 Gitlab의 플러그인 개발 안내서
Apr 13, 2025 am 08:24 AM
데비안에서 gitlab 플러그인을 개발하려면 몇 가지 특정 단계와 지식이 필요합니다. 다음은이 과정을 시작하는 데 도움이되는 기본 안내서입니다. Gitlab을 먼저 설치하려면 Debian 시스템에 Gitlab을 설치해야합니다. Gitlab의 공식 설치 매뉴얼을 참조 할 수 있습니다. API 액세스 토큰을 얻으십시오 API 통합을 수행하기 전에 Gitlab의 API 액세스 토큰을 먼저 가져와야합니다. Gitlab 대시 보드를 열고 사용자 설정에서 "AccessTokens"옵션을 찾은 다음 새 액세스 토큰을 생성하십시오. 생성됩니다
Apache는 어떤 서비스입니까?
Apr 13, 2025 pm 12:06 PM
아파치는 인터넷 뒤의 영웅입니다. 웹 서버 일뿐 만 아니라 큰 트래픽을 지원하고 동적 콘텐츠를 제공하는 강력한 플랫폼이기도합니다. 모듈 식 설계를 통해 매우 높은 유연성을 제공하여 필요에 따라 다양한 기능을 확장 할 수 있습니다. 그러나 Modularity는 또한 신중한 관리가 필요한 구성 및 성능 문제를 제시합니다. Apache는 사용자 정의가 필요한 서버 시나리오에 적합하고 복잡한 요구를 충족시킵니다.
