programming python

Sự kiện trong python

Vòng lặp sự kiện là cốt lõi của mọi ứng dụng asyncio. Các vòng lặp sự kiện chạy các tác vụ và lệnh gọi lại không đồng bộ, thực hiện các hoạt động IO của mạng và chạy các quy trình con

Các nhà phát triển ứng dụng thường nên sử dụng các hàm asyncio cấp cao, chẳng hạn như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

0 và hiếm khi cần tham chiếu đối tượng vòng lặp hoặc gọi các phương thức của nó. Phần này chủ yếu dành cho các tác giả của mã, thư viện và khung cấp thấp hơn, những người cần kiểm soát tốt hơn đối với hành vi của vòng lặp sự kiện

Lấy vòng lặp sự kiện

Các chức năng cấp thấp sau đây có thể được sử dụng để lấy, đặt hoặc tạo một vòng lặp sự kiện

không đồng bộ. get_running_loop[]¶

Trả về vòng lặp sự kiện đang chạy trong chuỗi hệ điều hành hiện tại

Tăng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

1 nếu không có vòng lặp sự kiện nào đang chạy

Hàm này chỉ có thể được gọi từ coroutine hoặc callback

Mới trong phiên bản 3. 7

không đồng bộ. get_event_loop[]¶

Nhận vòng lặp sự kiện hiện tại

Khi được gọi từ coroutine hoặc callback [e. g. được lên lịch với call_soon hoặc API tương tự], chức năng này sẽ luôn trả về vòng lặp sự kiện đang chạy

Nếu không có bộ vòng lặp sự kiện đang chạy, hàm sẽ trả về kết quả của lời gọi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Bởi vì chức năng này có hành vi khá phức tạp [đặc biệt là khi các chính sách vòng lặp sự kiện tùy chỉnh được sử dụng], nên sử dụng chức năng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

3 được ưa thích hơn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

4 trong quy trình coroutine và cuộc gọi lại

Như đã lưu ý ở trên, hãy cân nhắc sử dụng hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

0 cấp cao hơn, thay vì sử dụng các hàm cấp thấp hơn này để tạo và đóng vòng lặp sự kiện theo cách thủ công

Ghi chú

Trong Python phiên bản 3. 10. 0–3. 10. 8 và 3. 11. 0 chức năng này [và các chức năng khác sử dụng nó ngầm định] đã phát ra một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

6 nếu không có vòng lặp sự kiện nào đang chạy, ngay cả khi vòng lặp hiện tại được đặt theo chính sách. Trong Python phiên bản 3. 10. 9, 3. 11. 1 và 3. 12 chúng phát ra một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

6 nếu không có vòng lặp sự kiện nào đang chạy và không có vòng lặp hiện tại nào được đặt. Trong một số bản phát hành Python trong tương lai, điều này sẽ trở thành một lỗi

không đồng bộ. set_event_loop[vòng lặp]¶

Đặt vòng lặp làm vòng lặp sự kiện hiện tại cho chuỗi hệ điều hành hiện tại

không đồng bộ. new_event_loop[]¶

Tạo và trả về một đối tượng vòng lặp sự kiện mới

Lưu ý rằng hành vi của các hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

9 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

00 có thể được thay đổi bằng cách đặt chính sách vòng lặp sự kiện tùy chỉnh .

nội dung

Trang tài liệu này chứa các phần sau

Phần Phương thức vòng lặp sự kiện là tài liệu tham khảo về API vòng lặp sự kiện;

Phần Xử lý gọi lại ghi lại các trường hợp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

01 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

02 được trả về từ các phương pháp lập lịch trình như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

03 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

04;

Phần Đối tượng máy chủ ghi lại các loại tài liệu được trả về từ các phương thức vòng lặp sự kiện như
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
05;

Phần Triển khai vòng lặp sự kiện ghi lại các lớp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07;

Phần Ví dụ giới thiệu cách làm việc với một số API vòng lặp sự kiện

Phương pháp vòng lặp sự kiện¶

Các vòng lặp sự kiện có các API cấp thấp cho các mục sau

Chạy và dừng vòng lặp
Lập lịch gọi lại
Lập kế hoạch gọi lại bị trì hoãn
Tạo tương lai và nhiệm vụ
Mở kết nối mạng
Tạo máy chủ mạng
truyền tập tin
Nâng cấp TLS
Xem mô tả tập tin
Làm việc trực tiếp với các đối tượng ổ cắm
DNS
Làm việc với đường ống
Tín hiệu Unix
Thực thi mã trong nhóm luồng hoặc quy trình
API xử lý lỗi
Kích hoạt chế độ gỡ lỗi
Chạy các quy trình con

Chạy và dừng vòng lặp¶

. run_until_complete[tương lai] ¶

Chạy cho đến khi tương lai [một phiên bản của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

08] hoàn thành

Nếu đối số là một đối tượng coroutine thì nó được lên lịch ngầm để chạy dưới dạng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

09.

Trả lại kết quả của Tương lai hoặc tăng ngoại lệ của nó

. run_forever[] ¶

Chạy vòng lặp sự kiện cho đến khi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

00 được gọi

Nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

00 được gọi trước khi gọi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

02, vòng lặp sẽ thăm dò bộ chọn I/O một lần với thời gian chờ bằng 0, chạy tất cả các lệnh gọi lại đã lên lịch để phản hồi các sự kiện I/O [và những cuộc gọi đã được lên lịch], sau đó thoát

Nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

00 được gọi trong khi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

02 đang chạy, vòng lặp sẽ chạy loạt lệnh gọi lại hiện tại rồi thoát. Lưu ý rằng các cuộc gọi lại mới được lên lịch bởi các cuộc gọi lại sẽ không chạy trong trường hợp này;

. dừng[] ¶

Dừng vòng lặp sự kiện

. is_running[] ¶

Trả lại

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu vòng lặp sự kiện hiện đang chạy

. được_đóng[] ¶

Trả lại

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu vòng lặp sự kiện đã đóng

. đóng[] ¶

Đóng vòng lặp sự kiện

Vòng lặp không được chạy khi chức năng này được gọi. Mọi cuộc gọi lại đang chờ xử lý sẽ bị loại bỏ

Phương pháp này xóa tất cả các hàng đợi và tắt trình thực thi, nhưng không đợi trình thực thi kết thúc

Phương pháp này là idempotent và không thể đảo ngược. Không có phương thức nào khác được gọi sau khi vòng lặp sự kiện được đóng lại

coroutine . shutdown_asyncgens[] ¶

Lên lịch đóng tất cả các đối tượng trình tạo không đồng bộ hiện đang mở bằng lệnh gọi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

09. Sau khi gọi phương thức này, vòng lặp sự kiện sẽ đưa ra cảnh báo nếu một trình tạo không đồng bộ mới được lặp lại. Điều này nên được sử dụng để hoàn thiện một cách đáng tin cậy tất cả các trình tạo không đồng bộ theo lịch trình.

Lưu ý rằng không cần gọi hàm này khi sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Thí dụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Mới trong phiên bản 3. 6

coroutine . shutdown_default_executor[] ¶

Lên lịch đóng trình thực thi mặc định và đợi nó tham gia tất cả các luồng trong

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

21. Sau khi gọi phương thức này, một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

1 sẽ được nâng lên nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 được gọi trong khi sử dụng trình thực thi mặc định

Lưu ý rằng không cần gọi hàm này khi sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Mới trong phiên bản 3. 9

Lên lịch gọi lại¶

. call_soon[gọi lại , *args, context=None]¶

Lên lịch gọi lại gọi lại để được gọi với các đối số args ở lần lặp lại tiếp theo của vòng lặp sự kiện.

Các cuộc gọi lại được gọi theo thứ tự mà chúng được đăng ký. Mỗi cuộc gọi lại sẽ được gọi chính xác một lần

Đối số ngữ cảnh chỉ từ khóa tùy chọn cho phép chỉ định một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

25 tùy chỉnh để gọi lại chạy trong. Ngữ cảnh hiện tại được sử dụng khi không có ngữ cảnh nào được cung cấp

Một phiên bản của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

26 được trả về, có thể được sử dụng sau này để hủy cuộc gọi lại

Phương pháp này không an toàn cho luồng

. call_soon_threadsafe[gọi lại , *args, context=None]¶

Một biến thể thread-safe của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

27. Phải được sử dụng để lên lịch gọi lại từ một luồng khác

Tăng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

1 nếu được gọi trên một vòng lặp đã bị đóng. Điều này có thể xảy ra trên luồng phụ khi ứng dụng chính đang tắt

Xem phần đồng thời và đa luồng của tài liệu.

Đã thay đổi trong phiên bản 3. 7. Đã thêm thông số ngữ cảnh chỉ từ khóa. Xem PEP 567 để biết thêm chi tiết.

Ghi chú

Hầu hết các chức năng lập lịch trình của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

29 không cho phép chuyển đối số từ khóa. Để làm điều đó, hãy sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Sử dụng các đối tượng một phần thường thuận tiện hơn so với sử dụng lambdas, vì asyncio có thể hiển thị các đối tượng một phần tốt hơn trong thông báo lỗi và gỡ lỗi

Lên lịch gọi lại bị trì hoãn¶

Vòng lặp sự kiện cung cấp các cơ chế để lên lịch các chức năng gọi lại sẽ được gọi vào một thời điểm nào đó trong tương lai. Vòng lặp sự kiện sử dụng đồng hồ đơn điệu để theo dõi thời gian

. call_later[trễ , gọi lại, *args, context=None]¶

Lên lịch gọi lại để được gọi sau số giây trì hoãn nhất định [có thể là int hoặc float]

Một phiên bản của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

11 được trả về có thể được sử dụng để hủy cuộc gọi lại

gọi lại sẽ được gọi chính xác một lần. Nếu hai cuộc gọi lại được lên lịch chính xác cùng một lúc, thứ tự mà chúng được gọi là không xác định

Các đối số vị trí tùy chọn sẽ được chuyển đến hàm gọi lại khi nó được gọi. Nếu bạn muốn gọi lại với các đối số từ khóa, hãy sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Đối số ngữ cảnh chỉ từ khóa tùy chọn cho phép chỉ định một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

25 tùy chỉnh để gọi lại chạy trong. Ngữ cảnh hiện tại được sử dụng khi không có ngữ cảnh nào được cung cấp

Đã thay đổi trong phiên bản 3. 7. Đã thêm thông số ngữ cảnh chỉ từ khóa. Xem PEP 567 để biết thêm chi tiết.

Đã thay đổi trong phiên bản 3. 8. Trong Python 3. 7 trở về trước với việc triển khai vòng lặp sự kiện mặc định, độ trễ không thể vượt quá một ngày. Điều này đã được sửa trong Python 3. 8.

. call_at[khi , gọi lại, *args, context=None]¶

Lên lịch gọi lại để được gọi tại dấu thời gian tuyệt đối đã cho khi [một số nguyên hoặc số float], sử dụng cùng tham chiếu thời gian như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Hành vi của phương pháp này giống như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Một phiên bản của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

11 được trả về có thể được sử dụng để hủy cuộc gọi lại

Đã thay đổi trong phiên bản 3. 7. Đã thêm thông số ngữ cảnh chỉ từ khóa. Xem PEP 567 để biết thêm chi tiết.

Đã thay đổi trong phiên bản 3. 8. Trong Python 3. 7 trở về trước với việc triển khai vòng lặp sự kiện mặc định, sự khác biệt giữa thời điểm và thời gian hiện tại không thể vượt quá một ngày. Điều này đã được sửa trong Python 3. 8.

. thời gian[] ¶

Trả về thời gian hiện tại, dưới dạng giá trị

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

17, theo đồng hồ đơn điệu bên trong của vòng lặp sự kiện

Ghi chú

Đã thay đổi trong phiên bản 3. 8. Trong Python 3. 7 và thời gian chờ sớm hơn [độ trễ tương đối hoặc thời điểm tuyệt đối] không được vượt quá một ngày. Điều này đã được sửa trong Python 3. 8.

Xem thêm

Hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Tạo Tương lai và Nhiệm vụ¶

. create_future[] ¶

Tạo một đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

19 được gắn vào vòng lặp sự kiện

Đây là cách ưa thích để tạo Futures trong asyncio. Điều này cho phép các vòng lặp sự kiện của bên thứ ba cung cấp các triển khai thay thế của đối tượng Tương lai [với hiệu suất hoặc thiết bị tốt hơn]

Mới trong phiên bản 3. 5. 2

. create_task[coro , *, name=None, context=None]¶

Lên lịch thực hiện coroutine coro. Trả về một đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

20.

Các vòng lặp sự kiện của bên thứ ba có thể sử dụng lớp con của riêng họ là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

20 để có khả năng tương tác. Trong trường hợp này, loại kết quả là một lớp con của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Nếu đối số tên được cung cấp và không phải là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23, thì nó được đặt làm tên của tác vụ bằng cách sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Đối số ngữ cảnh chỉ từ khóa tùy chọn cho phép chỉ định một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

25 tùy chỉnh để coro chạy trong. Bản sao ngữ cảnh hiện tại được tạo khi không có ngữ cảnh nào được cung cấp

Đã thay đổi trong phiên bản 3. 8. Đã thêm thông số tên.

Đã thay đổi trong phiên bản 3. 11. Đã thêm tham số ngữ cảnh.

. set_task_factory[factory] ¶

Đặt một nhà máy nhiệm vụ sẽ được sử dụng bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Nếu nhà máy là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23, nhà máy tác vụ mặc định sẽ được đặt. Mặt khác, nhà máy phải là một hàm có thể gọi được với chữ ký phù hợp với

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

28, trong đó vòng lặp là một tham chiếu đến vòng lặp sự kiện đang hoạt động và coro là một đối tượng coroutine. Có thể gọi được phải trả về một đối tượng tương thích với

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

. get_task_factory[] ¶

Trả về nhà máy nhiệm vụ hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 nếu nhà máy mặc định đang được sử dụng

Mở kết nối mạng¶

coroutine . create_connection[protocol_factory , máy chủ=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, happy_eyeballs_delay=None, interleave=None]¶

Mở kết nối truyền phát trực tuyến đến một địa chỉ nhất định được chỉ định bởi máy chủ và cổng

Họ ổ cắm có thể là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

32 tùy thuộc vào máy chủ [hoặc đối số họ, nếu được cung cấp]

Loại ổ cắm sẽ là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

protocol_factory phải là một giao thức có thể gọi được trả về giao thức asyncio triển khai.

Phương pháp này sẽ cố gắng thiết lập kết nối trong nền. Khi thành công, nó sẽ trả về một cặp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Bản tóm tắt theo trình tự thời gian của hoạt động cơ bản như sau

Kết nối được thiết lập và vận chuyển được tạo cho nó.
protocol_factory được gọi mà không có đối số và dự kiến sẽ trả về một phiên bản protocol .
Thể hiện giao thức được kết hợp với phương tiện vận chuyển bằng cách gọi phương thức
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
35 của nó

Một bộ dữ liệu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34 được trả về khi thành công

Vận chuyển được tạo là một luồng hai chiều phụ thuộc vào việc triển khai

lập luận khác

ssl. nếu được cung cấp và không sai, thì truyền tải SSL/TLS được tạo [theo mặc định, truyền tải TCP đơn giản được tạo]. Nếu ssl là một đối tượng
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
37, ngữ cảnh này được sử dụng để tạo phương tiện truyền tải;
Xem thêm
Cân nhắc bảo mật SSL/TLS
server_hostname đặt hoặc ghi đè tên máy chủ mà chứng chỉ của máy chủ đích sẽ được khớp với. Chỉ nên được thông qua nếu ssl không phải là
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
23. Theo mặc định, giá trị của đối số máy chủ được sử dụng. Nếu máy chủ trống, không có giá trị mặc định và bạn phải chuyển một giá trị cho server_hostname. Nếu server_hostname là một chuỗi trống, thì tính năng so khớp tên máy chủ bị vô hiệu hóa [đây là một rủi ro bảo mật nghiêm trọng, cho phép xảy ra các cuộc tấn công trung gian tiềm ẩn]
family, proto, flags là họ địa chỉ, giao thức và cờ tùy chọn được chuyển qua getaddrinfo[] để phân giải máy chủ. Nếu được cung cấp, tất cả những thứ này phải là số nguyên từ các hằng số mô-đun
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
31 tương ứng
happy_eyeballs_delay, nếu được cung cấp, sẽ bật Happy Eyeballs cho kết nối này. Nó phải là một số dấu phẩy động biểu thị lượng thời gian tính bằng giây để chờ một nỗ lực kết nối hoàn tất, trước khi bắt đầu thử song song tiếp theo. Đây là "Trễ thử kết nối" như được định nghĩa trong RFC 8305. Giá trị mặc định hợp lý do RFC đề xuất là
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
32 [250 mili giây]
kiểm soát xen kẽ sắp xếp lại địa chỉ khi tên máy chủ phân giải thành nhiều địa chỉ IP. Nếu
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
33 hoặc không xác định, không thực hiện sắp xếp lại và các địa chỉ được thử theo thứ tự được trả về bởi
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
34. Nếu một số nguyên dương được chỉ định, các địa chỉ sẽ được xen kẽ theo họ địa chỉ và số nguyên đã cho được hiểu là "Số lượng họ địa chỉ đầu tiên" như được định nghĩa trong RFC 8305. Giá trị mặc định là
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
33 nếu happy_eyeballs_delay không được chỉ định và
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
36 nếu có
sock, nếu được cung cấp, phải là một đối tượng
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
37 hiện có, đã được kết nối để phương tiện vận chuyển sử dụng. Nếu sock được cung cấp, không được chỉ định máy chủ, cổng, gia đình, proto, cờ, happy_eyeballs_delay, xen kẽ và local_addr
Ghi chú
Đối số sock chuyển quyền sở hữu ổ cắm sang phương tiện vận chuyển được tạo. Để đóng ổ cắm, hãy gọi phương thức vận chuyển
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
38

local_addr, nếu được cung cấp, là một bộ dữ liệu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

39 được sử dụng để liên kết ổ cắm cục bộ. Local_host và local_port được tra cứu bằng cách sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34, tương tự như máy chủ và cổng

ssl_handshake_timeout là [đối với kết nối TLS] thời gian tính bằng giây để đợi quá trình bắt tay TLS hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

ssl_shutdown_timeout là thời gian tính bằng giây để đợi quá trình tắt SSL hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

33 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

Đã thay đổi trong phiên bản 3. 5. Đã thêm hỗ trợ cho SSL/TLS trong

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07.

Đã thay đổi trong phiên bản 3. 6. Tùy chọn ổ cắm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

36 được đặt theo mặc định cho tất cả các kết nối TCP.

Đã thay đổi trong phiên bản 3. 7. Đã thêm tham số ssl_handshake_timeout.

Đã thay đổi trong phiên bản 3. 8. Đã thêm các tham số happy_eyeballs_delay và xen kẽ.

Thuật toán nhãn cầu hạnh phúc. Thành công với Máy chủ xếp chồng kép. Khi đường dẫn và giao thức IPv4 của máy chủ đang hoạt động, nhưng đường dẫn và giao thức IPv6 của máy chủ không hoạt động, ứng dụng máy khách ngăn xếp kép gặp phải độ trễ kết nối đáng kể so với máy khách chỉ có IPv4. Điều này là không mong muốn vì nó khiến máy khách ngăn xếp kép có trải nghiệm người dùng kém hơn. Tài liệu này chỉ định các yêu cầu đối với các thuật toán giúp giảm độ trễ mà người dùng có thể nhìn thấy này và cung cấp một thuật toán

Để biết thêm thông tin. https. //công cụ. vietf. org/html/rfc6555

Đã thay đổi trong phiên bản 3. 11. Đã thêm thông số ssl_shutdown_timeout.

Xem thêm

Hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

37 là API thay thế cấp cao. Nó trả về một cặp [

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

38,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

39] có thể được sử dụng trực tiếp trong mã không đồng bộ/chờ đợi

coroutine . create_datagram_endpoint[protocol_factory , local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_port=None, allow_broadcast=None, sock=None]¶

Tạo một kết nối datagram

Họ ổ cắm có thể là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

32 hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

02, tùy thuộc vào máy chủ [hoặc đối số họ, nếu được cung cấp]

Loại ổ cắm sẽ là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

protocol_factory phải là một triển khai có thể gọi được trả về giao thức .

Một bộ dữ liệu của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34 được trả về khi thành công

lập luận khác

local_addr, nếu được cung cấp, là một bộ dữ liệu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

39 được sử dụng để liên kết ổ cắm cục bộ. local_host và local_port được tra cứu bằng cách sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

remote_addr, nếu được cung cấp, là một bộ dữ liệu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 được sử dụng để kết nối ổ cắm với một địa chỉ từ xa. remote_host và remote_port được tra cứu bằng cách sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

family, proto, flags là họ địa chỉ, giao thức và cờ tùy chọn được chuyển qua
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
34 để phân giải máy chủ. Nếu được cung cấp, tất cả những thứ này phải là số nguyên từ các hằng số mô-đun
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
31 tương ứng
tái sử dụng_port yêu cầu kernel cho phép điểm cuối này được liên kết với cùng một cổng như các điểm cuối hiện có khác được liên kết, miễn là tất cả chúng đều đặt cờ này khi được tạo. Tùy chọn này không được hỗ trợ trên Windows và một số Unix. Nếu hằng số
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
11 không được xác định thì khả năng này không được hỗ trợ
allow_broadcast yêu cầu kernel cho phép điểm cuối này gửi tin nhắn đến địa chỉ quảng bá
sock có thể được chỉ định tùy chọn để sử dụng một đối tượng
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
37 có sẵn, đã được kết nối, được sử dụng bởi phương tiện vận chuyển. Nếu được chỉ định, nên bỏ qua local_addr và remote_addr [phải là
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
23]
Ghi chú
Đối số sock chuyển quyền sở hữu ổ cắm sang phương tiện vận chuyển được tạo. Để đóng ổ cắm, hãy gọi phương thức vận chuyển
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
38

Xem Giao thức máy khách UDP echo và Giao thức máy chủ echo UDP examples.

Đã thay đổi trong phiên bản 3. 4. 4. Các thông số gia đình, proto, cờ, tái sử dụng_địa chỉ, tái sử dụng_port, allow_broadcast và sock đã được thêm vào.

Đã thay đổi trong phiên bản 3. 8. 1. Tham sốReuse_address không còn được hỗ trợ vì việc sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

15 gây ra mối lo ngại đáng kể về bảo mật cho UDP. Vượt qua rõ ràng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

16 sẽ đưa ra một ngoại lệ.

Khi nhiều quy trình có UID khác nhau gán ổ cắm cho một địa chỉ ổ cắm UDP giống hệt nhau với

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

15, các gói đến có thể được phân phối ngẫu nhiên giữa các ổ cắm

Đối với các nền tảng được hỗ trợ, có thể sử dụnguse_port để thay thế cho chức năng tương tự. Với tái sử dụng_port, thay vào đó,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

11 được sử dụng, điều này đặc biệt ngăn các quy trình có UID khác nhau gán ổ cắm cho cùng một địa chỉ ổ cắm

Đã thay đổi trong phiên bản 3. 8. Đã thêm hỗ trợ cho Windows.

Đã thay đổi trong phiên bản 3. 11. Tham sốReuse_address, bị vô hiệu hóa kể từ Python 3. 9. 0, 3. 8. 1, 3. 7. 6 và 3. 6. 10, đã bị xóa hoàn toàn.

coroutine . create_unix_connection[protocol_factory , đường dẫn=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None]¶

Tạo kết nối Unix

Họ ổ cắm sẽ là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

02;

Một bộ dữ liệu của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34 được trả về khi thành công

đường dẫn là tên của ổ cắm miền Unix và được yêu cầu, trừ khi tham số sock được chỉ định. Ổ cắm Unix trừu tượng, đường dẫn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

22,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

24 được hỗ trợ

Xem tài liệu của phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

25 để biết thông tin về các đối số của phương pháp này

Tính khả dụng . Unix.

Đã thay đổi trong phiên bản 3. 7. Đã thêm tham số ssl_handshake_timeout. Tham số đường dẫn bây giờ có thể là một đối tượng giống như đường dẫn .

Đã thay đổi trong phiên bản 3. 11. Đã thêm thông số ssl_shutdown_timeout.

Tạo máy chủ mạng¶

coroutine . create_server[protocol_factory , máy chủ . AF_UNSPEC=None, port=None, *, family=socket.AF_UNSPEC , cờ=ổ cắm. AI_PASSIVE , tất=Không có, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True]¶

Tạo một máy chủ TCP [loại ổ cắm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

33] lắng nghe trên cổng của địa chỉ máy chủ

Trả về một đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Tranh luận

protocol_factory phải là một triển khai có thể gọi được trả về giao thức .
Tham số máy chủ có thể được đặt thành một số loại xác định nơi máy chủ sẽ lắng nghe
- Nếu máy chủ là một chuỗi, máy chủ TCP được liên kết với một giao diện mạng duy nhất được chỉ định bởi máy chủ
- Nếu máy chủ là một chuỗi các chuỗi, máy chủ TCP được liên kết với tất cả các giao diện mạng được chỉ định bởi chuỗi
- Nếu máy chủ lưu trữ là một chuỗi trống hoặc
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
  23, tất cả các giao diện được giả định và một danh sách nhiều ổ cắm sẽ được trả về [rất có thể là một ổ cắm cho IPv4 và một ổ cắm khác cho IPv6]
Tham số cổng có thể được đặt để chỉ định máy chủ sẽ nghe trên cổng nào. Nếu
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
33 hoặc
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
23 [mặc định], một cổng ngẫu nhiên không sử dụng sẽ được chọn [lưu ý rằng nếu máy chủ phân giải thành nhiều giao diện mạng, một cổng ngẫu nhiên khác sẽ được chọn cho mỗi giao diện]

gia đình có thể được đặt thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

32 để buộc ổ cắm sử dụng IPv4 hoặc IPv6. Nếu không được đặt, họ sẽ được xác định từ tên máy chủ [mặc định là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

33]

cờ là một bitmask cho

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

sock có thể được chỉ định tùy chọn để sử dụng đối tượng ổ cắm có sẵn. Nếu được chỉ định, máy chủ và cổng không được chỉ định
Ghi chú
Đối số sock chuyển quyền sở hữu ổ cắm cho máy chủ được tạo. Để đóng socket, hãy gọi phương thức
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
38 của máy chủ

tồn đọng là số lượng kết nối xếp hàng tối đa được chuyển đến

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

36 [mặc định là 100]

ssl có thể được đặt thành phiên bản

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

37 để bật TLS qua các kết nối được chấp nhận

tái sử dụng_address yêu cầu hạt nhân sử dụng lại một ổ cắm cục bộ ở trạng thái
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
38 mà không cần đợi thời gian chờ tự nhiên của nó hết hạn. Nếu không được chỉ định sẽ tự động được đặt thành
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
07 trên Unix
tái sử dụng_port yêu cầu kernel cho phép điểm cuối này được liên kết với cùng một cổng như các điểm cuối hiện có khác được liên kết, miễn là tất cả chúng đều đặt cờ này khi được tạo. Tùy chọn này không được hỗ trợ trên Windows

ssl_handshake_timeout là [đối với máy chủ TLS] thời gian tính bằng giây để đợi quá trình bắt tay TLS hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

ssl_shutdown_timeout là thời gian tính bằng giây để đợi quá trình tắt SSL hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

33 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

start_serving được đặt thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 [mặc định] khiến máy chủ được tạo bắt đầu chấp nhận kết nối ngay lập tức. Khi được đặt thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

45, người dùng nên đợi trên

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

46 hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

47 để máy chủ bắt đầu chấp nhận kết nối

Đã thay đổi trong phiên bản 3. 5. Đã thêm hỗ trợ cho SSL/TLS trong

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07.

Đã thay đổi trong phiên bản 3. 5. 1. Tham số máy chủ có thể là một chuỗi các chuỗi.

Đã thay đổi trong phiên bản 3. 6. Đã thêm tham số ssl_handshake_timeout và start_serving. Tùy chọn ổ cắm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

36 được đặt theo mặc định cho tất cả các kết nối TCP.

Đã thay đổi trong phiên bản 3. 11. Đã thêm thông số ssl_shutdown_timeout.

Xem thêm

Hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

50 là một API thay thế cấp cao hơn trả về một cặp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

38 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

39 có thể được sử dụng trong mã không đồng bộ/chờ

coroutine . create_unix_server[protocol_factory , đường dẫn=None, *, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True]¶

Tương tự như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

05 nhưng hoạt động với họ ổ cắm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

đường dẫn là tên của ổ cắm tên miền Unix và là bắt buộc, trừ khi cung cấp đối số sock. Ổ cắm Unix trừu tượng, đường dẫn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

22,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

24 được hỗ trợ

Xem tài liệu về phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

05 để biết thông tin về các đối số của phương pháp này

Tính khả dụng . Unix.

Đã thay đổi trong phiên bản 3. 7. Đã thêm thông số ssl_handshake_timeout và start_serving. Tham số đường dẫn bây giờ có thể là một đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

24.

Đã thay đổi trong phiên bản 3. 11. Đã thêm thông số ssl_shutdown_timeout.

coroutine . connect_accepted_socket[protocol_factory , sock, *, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None]¶

Bọc một kết nối đã được chấp nhận thành một cặp giao thức/truyền tải

Phương pháp này có thể được sử dụng bởi các máy chủ chấp nhận các kết nối bên ngoài asyncio nhưng sử dụng asyncio để xử lý chúng

Thông số

protocol_factory phải là một triển khai có thể gọi được trả về giao thức .
sock là một đối tượng ổ cắm có sẵn được trả về từ
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
60
Ghi chú
Đối số sock chuyển quyền sở hữu ổ cắm sang phương tiện vận chuyển được tạo. Để đóng ổ cắm, hãy gọi phương thức vận chuyển
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
38

ssl có thể được đặt thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

37 để bật SSL qua các kết nối được chấp nhận

ssl_handshake_timeout là [đối với kết nối SSL] thời gian tính bằng giây để đợi quá trình bắt tay SSL hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

ssl_shutdown_timeout là thời gian tính bằng giây để đợi quá trình tắt SSL hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

33 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

Trả về một cặp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Mới trong phiên bản 3. 5. 3

Đã thay đổi trong phiên bản 3. 7. Đã thêm tham số ssl_handshake_timeout.

Đã thay đổi trong phiên bản 3. 11. Đã thêm thông số ssl_shutdown_timeout.

Truyền tệp¶

coroutine . gửi tệp[vận chuyển , tệp, offset=0, count=None, *, fallback=True]¶

Gửi tệp qua phương tiện giao thông. Trả về tổng số byte đã gửi

Phương pháp sử dụng hiệu suất cao

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

68 nếu có

tệp phải là đối tượng tệp thông thường được mở ở chế độ nhị phân

offset cho biết bắt đầu đọc tệp từ đâu. Nếu được chỉ định, số đếm là tổng số byte cần truyền thay vì gửi tệp cho đến khi đạt đến EOF. Vị trí tệp luôn được cập nhật, ngay cả khi phương pháp này phát sinh lỗi và có thể sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

69 để lấy số byte thực tế đã gửi

dự phòng được đặt thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 khiến asyncio đọc và gửi tệp theo cách thủ công khi nền tảng không hỗ trợ lệnh gọi hệ thống gửi tệp [e. g. Ổ cắm Windows hoặc SSL trên Unix]

Tăng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

71 nếu hệ thống không hỗ trợ tòa nhà tòa nhà sendfile và dự phòng là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Mới trong phiên bản 3. 7

Nâng cấp TLS¶

coroutine . start_tls[vận chuyển , giao thức, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None]¶

Nâng cấp kết nối dựa trên giao thông hiện có lên TLS

Tạo một phiên bản bộ mã hóa/giải mã TLS và chèn nó vào giữa phương tiện truyền tải và giao thức. Bộ mã hóa/giải mã thực hiện cả giao thức truyền tải và truyền tải theo giao thức

Trả về phiên bản hai giao diện đã tạo. Sau khi chờ đợi, giao thức phải ngừng sử dụng truyền tải ban đầu và chỉ giao tiếp với đối tượng được trả về vì bộ mã hóa lưu trữ dữ liệu phía giao thức và trao đổi không thường xuyên các gói phiên TLS bổ sung với truyền tải

Thông số

các trường hợp giao thức và vận chuyển mà các phương thức như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

73 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

74 trả về

sslcontext. một phiên bản được định cấu hình của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

server_side vượt qua

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 khi kết nối phía máy chủ đang được nâng cấp [như kết nối được tạo bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

73]

máy chủ_hostname. đặt hoặc ghi đè tên máy chủ mà chứng chỉ của máy chủ đích sẽ được khớp với

ssl_handshake_timeout là [đối với kết nối TLS] thời gian tính bằng giây để đợi quá trình bắt tay TLS hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

ssl_shutdown_timeout là thời gian tính bằng giây để đợi quá trình tắt SSL hoàn tất trước khi hủy kết nối.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

33 giây nếu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 [mặc định]

Mới trong phiên bản 3. 7

Đã thay đổi trong phiên bản 3. 11. Đã thêm thông số ssl_shutdown_timeout.

Xem mô tả tập tin¶

. add_reader[fd , gọi lại, *args]¶

Bắt đầu theo dõi bộ mô tả tệp fd để biết khả năng đọc và gọi lại cuộc gọi với các đối số được chỉ định sau khi fd khả dụng để đọc

. remove_reader[fd] ¶

Dừng theo dõi bộ mô tả tệp fd để biết tính sẵn sàng đọc. Trả về

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu fd trước đó đã được theo dõi để đọc

. add_writer[fd , gọi lại, *args]¶

Bắt đầu theo dõi bộ mô tả tệp fd để biết khả năng ghi và gọi hàm gọi lại với các đối số đã chỉ định khi fd sẵn sàng để ghi

Sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

10 để chuyển đối số từ khóa để gọi lại.

. remove_writer[fd] ¶

Dừng theo dõi bộ mô tả tệp fd để ghi tính khả dụng. Trả về

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu trước đó fd được theo dõi để ghi

Xem thêm phần Hỗ trợ nền tảng để biết một số hạn chế của các phương pháp này.

Làm việc trực tiếp với các đối tượng socket¶

Nói chung, việc triển khai giao thức sử dụng API dựa trên vận chuyển như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

25 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

05 nhanh hơn so với việc triển khai hoạt động trực tiếp với ổ cắm. Tuy nhiên, có một số trường hợp sử dụng khi hiệu suất không quan trọng và làm việc trực tiếp với các đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

31 sẽ thuận tiện hơn

coroutine . sock_recv[sock , nbyte]¶

Nhận tới nbyte từ sock. Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Trả lại dữ liệu đã nhận dưới dạng đối tượng byte

sock phải là ổ cắm non-blocking

Đã thay đổi trong phiên bản 3. 7. Mặc dù phương thức này luôn được ghi lại dưới dạng phương thức coroutine, nhưng vẫn phát hành trước Python 3. 7 đã trả lại một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

08. Kể từ Python 3. 7 đây là một phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

90.

coroutine . sock_recv_into[sock , buf]¶

Nhận dữ liệu từ sock vào bộ đệm buf. Được mô phỏng theo phương pháp chặn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Trả về số byte được ghi vào bộ đệm

sock phải là ổ cắm non-blocking

Mới trong phiên bản 3. 7

coroutine . sock_recvfrom[sock , bufsize]¶

Nhận một datagram có kích thước tối đa từ sock. Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Trả về một bộ dữ liệu [dữ liệu đã nhận, địa chỉ từ xa]

sock phải là ổ cắm non-blocking

Mới trong phiên bản 3. 11

coroutine . sock_recvfrom_into[sock , buf, nbytes=0]¶

Nhận một datagram lên đến nbyte từ sock vào buf. Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Trả về một bộ [số byte nhận được, địa chỉ từ xa]

sock phải là ổ cắm non-blocking

Mới trong phiên bản 3. 11

coroutine . sock_sendall[sock , dữ liệu]¶

Gửi dữ liệu đến ổ cắm sock. Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Phương pháp này tiếp tục gửi đến ổ cắm cho đến khi tất cả dữ liệu trong dữ liệu đã được gửi hoặc xảy ra lỗi.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 được trả lại khi thành công. Khi có lỗi, một ngoại lệ được đưa ra. Ngoài ra, không có cách nào để xác định lượng dữ liệu, nếu có, đã được xử lý thành công bởi đầu nhận của kết nối

sock phải là ổ cắm non-blocking

Đã thay đổi trong phiên bản 3. 7. Mặc dù phương thức này luôn được ghi lại dưới dạng phương thức coroutine, trước Python 3. 7 nó trả về một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

08. Kể từ Python 3. 7, đây là một phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

90.

coroutine . sock_sendto[sock , dữ liệu, address]¶

Gửi một datagram từ vớ đến địa chỉ. Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Trả về số byte đã gửi

sock phải là ổ cắm non-blocking

Mới trong phiên bản 3. 11

coroutine . sock_connect[sock , địa chỉ]¶

Kết nối tất với ổ cắm từ xa tại địa chỉ

Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

sock phải là ổ cắm non-blocking

Đã thay đổi trong phiên bản 3. 5. 2. ______1000 không cần giải quyết nữa.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

001 sẽ cố gắng kiểm tra xem địa chỉ đã được giải quyết chưa bằng cách gọi cho

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

002. Nếu không,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

003 sẽ được sử dụng để giải quyết địa chỉ.

Xem thêm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

25 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

005

coroutine . sock_accept[sock] ¶

Chấp nhận kết nối. Được mô phỏng theo phương pháp chặn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

006

Ổ cắm phải được liên kết với một địa chỉ và lắng nghe các kết nối. Giá trị trả về là một cặp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

007 trong đó conn là một đối tượng ổ cắm mới có thể sử dụng để gửi và nhận dữ liệu trên kết nối và địa chỉ là địa chỉ được liên kết với ổ cắm ở đầu kia của kết nối

sock phải là ổ cắm non-blocking

Đã thay đổi trong phiên bản 3. 7. Mặc dù phương thức này luôn được ghi lại dưới dạng phương thức coroutine, trước Python 3. 7 nó trả về một

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

08. Kể từ Python 3. 7, đây là một phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

90.

Xem thêm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

05 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

coroutine . sock_sendfile[sock , file, offset=0, count=None, *, fallback=True]¶

Gửi tệp bằng cách sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

012 hiệu suất cao nếu có thể. Trả về tổng số byte đã gửi

Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

013

tất phải là loại không chặn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

014

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

tệp phải là đối tượng tệp thông thường mở ở chế độ nhị phân

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

69 để lấy số byte thực tế đã gửi

dự phòng, khi được đặt thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07, làm cho asyncio đọc và gửi tệp theo cách thủ công khi nền tảng không hỗ trợ tòa nhà tòa nhà sendfile [e. g. Ổ cắm Windows hoặc SSL trên Unix]

Nâng cao

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

71 nếu hệ thống không hỗ trợ syscall sendfile và dự phòng là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

sock phải là ổ cắm non-blocking

Mới trong phiên bản 3. 7

DNS¶

coroutine . getaddrinfo[máy chủ , cổng, *, family=0, type=0, proto=0, flags=0]¶

Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

020

coroutine . getnameinfo[sockaddr , cờ=0]¶

Phiên bản không đồng bộ của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

021

Đã thay đổi trong phiên bản 3. 7. Cả hai phương thức getaddrinfo và getnameinfo luôn được ghi lại để trả về một coroutine, nhưng trước Python 3. 7 trên thực tế, họ đã trả lại các đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

19. Bắt đầu với Python 3. 7 cả hai phương thức đều là coroutines.

Làm việc với đường ống¶

coroutine . connect_read_pipe[protocol_factory , pipe]¶

Đăng ký đầu đọc của đường ống trong vòng lặp sự kiện

protocol_factory phải là một giao thức có thể gọi được trả về giao thức asyncio triển khai.

pipe là một đối tượng dạng tệp .

Cặp trả về

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34, trong đó vận chuyển hỗ trợ giao diện và giao thức

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

024 là một đối tượng được khởi tạo bởi giao thức_factory

Với vòng lặp sự kiện

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06, đường ống được đặt ở chế độ không chặn

coroutine . connect_write_pipe[protocol_factory , pipe]¶

Đăng ký ghi cuối đường ống trong vòng lặp sự kiện

protocol_factory phải là một giao thức có thể gọi được trả về giao thức asyncio triển khai.

pipe là đối tượng dạng tệp .

Cặp trả về

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34, trong đó vận chuyển hỗ trợ giao diện và giao thức

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

027 là một đối tượng được khởi tạo bởi giao thức_factory

Với vòng lặp sự kiện

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06, đường ống được đặt ở chế độ không chặn

Ghi chú

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06 không hỗ trợ các phương pháp trên trên Windows. Sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 thay thế cho Windows

Xem thêm

Phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

031 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

032

Tín hiệu Unix¶

. add_signal_handler[signum , gọi lại, *args]¶

Đặt gọi lại làm trình xử lý cho tín hiệu signum

Cuộc gọi lại sẽ được gọi theo vòng lặp, cùng với các cuộc gọi lại được xếp hàng đợi khác và các coroutine có thể chạy được của vòng lặp sự kiện đó. Không giống như các trình xử lý tín hiệu đã đăng ký bằng cách sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

033, một cuộc gọi lại đã đăng ký với chức năng này được phép tương tác với vòng lặp sự kiện

Tăng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

034 nếu số tín hiệu không hợp lệ hoặc không bắt được. Tăng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

1 nếu có sự cố khi thiết lập trình xử lý

Sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

10 để chuyển đối số từ khóa để gọi lại.

Giống như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

033, chức năng này phải được gọi trong luồng chính

. remove_signal_handler[sig] ¶

Xóa trình xử lý cho tín hiệu sig

Trả về

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu bộ xử lý tín hiệu đã bị xóa hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

45 nếu không có bộ xử lý nào được đặt cho tín hiệu đã cho

Tính khả dụng . Unix.

Xem thêm

Mô-đun

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

040

Thực thi mã trong chuỗi hoặc nhóm quy trình¶

awaitable . run_in_executor[executor , func, *args]¶

Sắp xếp để func được gọi trong trình thực thi được chỉ định

Đối số thực thi phải là một phiên bản

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

041. Người thi hành mặc định được sử dụng nếu người thi hành là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Thí dụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Lưu ý rằng bộ phận bảo vệ điểm vào [

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

043] là bắt buộc đối với tùy chọn 3 do đặc thù của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

044, được sử dụng bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

045. Xem Nhập mô-đun chính an toàn .

Phương thức này trả về một đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

10 để chuyển đối số từ khóa cho func.

Đã thay đổi trong phiên bản 3. 5. 3. ______323 không còn định cấu hình

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

049 của bộ thực thi nhóm luồng mà nó tạo ra, thay vào đó, hãy để bộ thực thi nhóm luồng [

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

21] đặt mặc định.

. set_default_executor[executor] ¶

Đặt người thi hành làm người thi hành mặc định được sử dụng bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

051. người thi hành phải là một thể hiện của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Đã thay đổi trong phiên bản 3. 11. executor phải là một thể hiện của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

21.

API xử lý lỗi¶

Cho phép tùy chỉnh cách xử lý ngoại lệ trong vòng lặp sự kiện

. set_exception_handler[trình xử lý] ¶

Đặt trình xử lý làm trình xử lý ngoại lệ vòng lặp sự kiện mới

Nếu trình xử lý là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23, thì trình xử lý ngoại lệ mặc định sẽ được đặt. Mặt khác, trình xử lý phải có thể gọi được với chữ ký khớp với

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

055, trong đó

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

056 là tham chiếu đến vòng lặp sự kiện đang hoạt động và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

057 là đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

058 chứa thông tin chi tiết về ngoại lệ [xem tài liệu

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

059 để biết chi tiết về ngữ cảnh]

. get_Exception_handler[] ¶

Trả về trình xử lý ngoại lệ hiện tại hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 nếu không có trình xử lý ngoại lệ tùy chỉnh nào được đặt

Mới trong phiên bản 3. 5. 2

. default_exception_handler[bối cảnh] ¶

Trình xử lý ngoại lệ mặc định

Điều này được gọi khi một ngoại lệ xảy ra và không có trình xử lý ngoại lệ nào được đặt. Điều này có thể được gọi bởi trình xử lý ngoại lệ tùy chỉnh muốn trì hoãn hành vi xử lý mặc định

tham số ngữ cảnh có cùng ý nghĩa như trong

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

059

. call_exception_handler[bối cảnh] ¶

Gọi trình xử lý ngoại lệ vòng lặp sự kiện hiện tại

bối cảnh là một đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

058 chứa các khóa sau [các khóa mới có thể được giới thiệu trong các phiên bản Python trong tương lai]

'thông điệp'. Thông báo lỗi;
'ngoại lệ' [tùy chọn]. đối tượng ngoại lệ;

'tương lai' [tùy chọn]. trường hợp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

19;

'nhiệm vụ' [không bắt buộc]. trường hợp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

09;

'xử lý' [tùy chọn]. ví dụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

26;

'giao thức' [tùy chọn]. Phiên bản giao thức ;
‘vận chuyển’ [tùy chọn]. Phiên bản Vận tải ;

'ổ cắm' [tùy chọn]. Ví dụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

37;

'không đồng bộ' [tùy chọn]. Máy phát điện không đồng bộ gây ra
sự ngoại lệ

Ghi chú

Phương thức này không nên bị quá tải trong các vòng lặp sự kiện được phân lớp. Để xử lý ngoại lệ tùy chỉnh, hãy sử dụng phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

067

Bật chế độ gỡ lỗi¶

. get_debug[] ¶

Nhận chế độ gỡ lỗi [

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

068] của vòng lặp sự kiện

Giá trị mặc định là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu biến môi trường

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

070 được đặt thành một chuỗi không trống, nếu không thì là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

. set_debug[đã bật. bool] ¶

Đặt chế độ gỡ lỗi của vòng lặp sự kiện

Đã thay đổi trong phiên bản 3. 7. Giờ đây, Chế độ phát triển Python mới cũng có thể được sử dụng để bật chế độ gỡ lỗi.

Xem thêm

Chế độ gỡ lỗi của asyncio .

Chạy các quy trình con¶

Các phương pháp được mô tả trong tiểu mục này ở mức độ thấp. Thay vào đó, trong mã async/await thông thường, hãy cân nhắc sử dụng các chức năng tiện lợi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

072 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

073 cấp cao

Ghi chú

Trên Windows, vòng lặp sự kiện mặc định

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 hỗ trợ các quy trình con, trong khi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06 thì không. Xem Hỗ trợ quy trình con trên Windows để biết chi tiết.

coroutine . sub process_exec[protocol_factory , * . PIPEargs, stdin=subprocess.PIPE , stdout=quy trình con. PIPE , stderr=quy trình con. ỐNG , **kwargs]¶

Tạo một quy trình con từ một hoặc nhiều đối số chuỗi được chỉ định bởi args

args phải là một danh sách các chuỗi được đại diện bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

22;

hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23, được mã hóa thành mã hóa hệ thống tệp .

Chuỗi đầu tiên chỉ định chương trình có thể thực thi được và các chuỗi còn lại chỉ định các đối số. Cùng với nhau, các đối số chuỗi tạo thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

078 của chương trình

Điều này tương tự với lớp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

079 của thư viện tiêu chuẩn được gọi với

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

080 và danh sách các chuỗi được truyền dưới dạng đối số đầu tiên;

protocol_factory phải có thể gọi được trả về một lớp con của lớp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

082

thông số khác

stdin có thể là bất kỳ trong số này

một đối tượng giống như tệp đại diện cho một đường ống được kết nối với luồng đầu vào tiêu chuẩn của quy trình con bằng cách sử dụng
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
083

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

084 [mặc định] sẽ tạo một đường ống mới và kết nối nó,

giá trị

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 sẽ làm cho quy trình con kế thừa bộ mô tả tệp từ quy trình này

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

086 cho biết rằng tệp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

087 đặc biệt sẽ được sử dụng

thiết bị xuất chuẩn có thể là bất kỳ trong số này

một đối tượng giống như tệp đại diện cho một đường ống được kết nối với luồng đầu ra tiêu chuẩn của quy trình con bằng cách sử dụng
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
083

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

084 [mặc định] sẽ tạo một đường ống mới và kết nối nó,

giá trị

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 sẽ làm cho quy trình con kế thừa bộ mô tả tệp từ quy trình này

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

086 cho biết rằng tệp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

087 đặc biệt sẽ được sử dụng

stderr có thể là bất kỳ trong số này

một đối tượng giống như tệp đại diện cho một đường ống được kết nối với luồng lỗi tiêu chuẩn của quy trình con bằng cách sử dụng
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
083

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

084 [mặc định] sẽ tạo một đường ống mới và kết nối nó,

giá trị

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 sẽ làm cho quy trình con kế thừa bộ mô tả tệp từ quy trình này

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

086 cho biết rằng tệp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

087 đặc biệt sẽ được sử dụng

hằng số

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

098 sẽ kết nối luồng lỗi tiêu chuẩn với luồng đầu ra tiêu chuẩn của quy trình

Tất cả các đối số từ khóa khác được chuyển đến
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
079 mà không cần diễn giải, ngoại trừ bufsize, universal_newlines, shell, văn bản, mã hóa và các lỗi hoàn toàn không được chỉ định
API quy trình con
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
29 không hỗ trợ giải mã luồng dưới dạng văn bản.
```
# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]
```
001 có thể được sử dụng để chuyển đổi các byte được trả về từ luồng thành văn bản

Xem hàm tạo của lớp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

079 để biết tài liệu về các đối số khác

Trả về một cặp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34, trong đó vận chuyển phù hợp với lớp cơ sở

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

004 và giao thức là một đối tượng được khởi tạo bởi giao thức_factory

coroutine . sub process_shell[protocol_factory , cmd . PIPE, *, stdin=subprocess.PIPE , stdout=quy trình con. PIPE , stderr=quy trình con. ỐNG , **kwargs]¶

Tạo một quy trình con từ cmd, có thể là một chuỗi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

22 hoặc một chuỗi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

23 được mã hóa thành mã hóa hệ thống tệp , sử dụng “shell” của nền tảng .

Điều này tương tự với lớp thư viện tiêu chuẩn

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

079 được gọi với

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

008

protocol_factory phải là một callable trả về một lớp con của lớp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

009

Xem

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

010 để biết thêm chi tiết về các đối số còn lại

Trả về một cặp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

34, trong đó truyền tải tuân theo lớp cơ sở

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

012 và giao thức là một đối tượng được khởi tạo bởi giao thức_factory

Ghi chú

Ứng dụng có trách nhiệm đảm bảo rằng tất cả các khoảng trắng và ký tự đặc biệt được trích dẫn một cách thích hợp để tránh các lỗ hổng shell injection. Hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

013 có thể được sử dụng để thoát đúng khoảng trắng và các ký tự đặc biệt trong các chuỗi sẽ được sử dụng để tạo các lệnh trình bao

Xử lý gọi lại¶

lớp không đồng bộ. Xử lý ¶

Một đối tượng trình bao bọc gọi lại được trả về bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

03,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

015

hủy[] ¶

Hủy cuộc gọi lại. Nếu cuộc gọi lại đã bị hủy hoặc được thực thi, phương pháp này không có hiệu lực

đã hủy[] ¶

Trả lại

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu cuộc gọi lại bị hủy

Mới trong phiên bản 3. 7

lớp không đồng bộ. Xử lý hẹn giờ ¶

Một đối tượng trình bao bọc gọi lại được trả về bởi

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

04 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

018

Lớp này là lớp con của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

khi nào[] ¶

Trả lại thời gian gọi lại theo lịch trình là

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

17 giây

Thời gian là dấu thời gian tuyệt đối, sử dụng cùng tham chiếu thời gian như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Mới trong phiên bản 3. 7

Đối tượng máy chủ¶

Các đối tượng máy chủ được tạo bởi các hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

05,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

023,

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

50 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

025

Không khởi tạo lớp trực tiếp

lớp không đồng bộ. Máy chủ ¶

Đối tượng máy chủ là trình quản lý bối cảnh không đồng bộ. Khi được sử dụng trong câu lệnh

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

026, đảm bảo rằng đối tượng Máy chủ đã đóng và không chấp nhận các kết nối mới khi câu lệnh

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

026 được hoàn thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Đã thay đổi trong phiên bản 3. 7. Đối tượng máy chủ là trình quản lý bối cảnh không đồng bộ kể từ Python 3. 7.

đóng[] ¶

Ngừng phục vụ. đóng ổ cắm nghe và đặt thuộc tính

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

028 thành

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Các ổ cắm đại diện cho các kết nối máy khách đến hiện có được để mở

Máy chủ được đóng không đồng bộ, hãy sử dụng quy trình đăng ký

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

030 để đợi cho đến khi máy chủ được đóng

get_loop[] ¶

Trả về vòng lặp sự kiện được liên kết với đối tượng máy chủ

Mới trong phiên bản 3. 7

coroutine start_serving[] ¶

Bắt đầu chấp nhận kết nối

Phương thức này là idempotent, vì vậy nó có thể được gọi khi máy chủ đang phục vụ

Tham số chỉ từ khóa start_serving cho

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

05 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

032 cho phép tạo đối tượng Máy chủ không chấp nhận kết nối ban đầu. Trong trường hợp này, có thể sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

46 hoặc

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

47 để làm cho Máy chủ bắt đầu chấp nhận kết nối

Mới trong phiên bản 3. 7

coroutine serve_forever[] ¶

Bắt đầu chấp nhận kết nối cho đến khi quy trình đăng ký bị hủy. Việc hủy nhiệm vụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

035 khiến máy chủ bị đóng

Phương thức này có thể được gọi nếu máy chủ đã chấp nhận kết nối. Chỉ có thể tồn tại một tác vụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

035 trên một đối tượng Máy chủ

Thí dụ

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Mới trong phiên bản 3. 7

is_serving[] ¶

Trả lại

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 nếu máy chủ chấp nhận kết nối mới

Mới trong phiên bản 3. 7

coroutine wait_closed[] ¶

Đợi cho đến khi phương thức

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

38 hoàn thành

ổ cắm ¶

Danh sách các đối tượng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

37 mà máy chủ đang lắng nghe

Đã thay đổi trong phiên bản 3. 7. Trước Python 3. 7

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

040 được sử dụng để trả về trực tiếp danh sách ổ cắm máy chủ nội bộ. Trong 3. 7 một bản sao của danh sách đó được trả về.

Triển khai vòng lặp sự kiện¶

asyncio vận chuyển với hai triển khai vòng lặp sự kiện khác nhau.

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Theo mặc định, asyncio được định cấu hình để sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

06 trên Unix và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

07 trên Windows

lớp không đồng bộ. SelectorEventLoop ¶

Vòng lặp sự kiện dựa trên mô-đun

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

045

Sử dụng bộ chọn hiệu quả nhất có sẵn cho nền tảng nhất định. Cũng có thể định cấu hình thủ công việc triển khai bộ chọn chính xác sẽ được sử dụng

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Tính khả dụng . Hệ điều hành Unix, Windows.

lớp không đồng bộ. ProactorEventLoop ¶

Vòng lặp sự kiện dành cho Windows sử dụng “Cổng hoàn thành I/O” [IOCP]

Tính khả dụng . các cửa sổ.

Xem thêm

Tài liệu MSDN về Cổng hoàn thành I/O

lớp không đồng bộ. Vòng lặp sự kiện trừu tượng ¶

Lớp cơ sở trừu tượng cho các vòng lặp sự kiện tuân thủ không đồng bộ

Phần Phương pháp vòng lặp sự kiện liệt kê tất cả các phương pháp mà một triển khai thay thế của

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

046 nên xác định.

Ví dụ¶

Lưu ý rằng tất cả các ví dụ trong phần này đều có mục đích hiển thị cách sử dụng API vòng lặp sự kiện cấp thấp, chẳng hạn như

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

047 và

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

03. Các ứng dụng asyncio hiện đại hiếm khi cần phải viết theo cách này;

Xin chào thế giới với call_soon[]¶

Một ví dụ sử dụng phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

03 để lên lịch gọi lại. Cuộc gọi lại hiển thị

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

051 và sau đó dừng vòng lặp sự kiện

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Xem thêm

Một ví dụ tương tự Xin chào thế giới được tạo bằng một coroutine và hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

052.

Hiển thị ngày hiện tại với call_later[]¶

Một ví dụ về cuộc gọi lại hiển thị ngày hiện tại mỗi giây. Cuộc gọi lại sử dụng phương thức

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

04 để tự lên lịch lại sau 5 giây và sau đó dừng vòng lặp sự kiện

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

Xem thêm

Một ví dụ tương tự ngày hiện tại được tạo bằng một coroutine và hàm

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

052.

Xem một bộ mô tả tập tin cho các sự kiện đọc¶

Đợi cho đến khi bộ mô tả tệp nhận được một số dữ liệu bằng phương pháp

# will schedule "print["Hello", flush=True]"
loop.call_soon[
    functools.partial[print, "Hello", flush=True]]

055 rồi đóng vòng lặp sự kiện

Phương pháp vòng lặp sự kiện¶

Chạy và dừng vòng lặp¶

Lên lịch gọi lại¶

Lên lịch gọi lại bị trì hoãn¶

Tạo Tương lai và Nhiệm vụ¶

Mở kết nối mạng¶

Tạo máy chủ mạng¶

Truyền tệp¶

Nâng cấp TLS¶

Xem mô tả tập tin¶

Làm việc trực tiếp với các đối tượng socket¶

DNS¶

Làm việc với đường ống¶

Tín hiệu Unix¶

Thực thi mã trong chuỗi hoặc nhóm quy trình¶

API xử lý lỗi¶

Bật chế độ gỡ lỗi¶

Chạy các quy trình con¶

Xử lý gọi lại¶

Đối tượng máy chủ¶

Triển khai vòng lặp sự kiện¶

Ví dụ¶

Xin chào thế giới với call_soon[]¶

Hiển thị ngày hiện tại với call_later[]¶

Xem một bộ mô tả tập tin cho các sự kiện đọc¶

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề