索引

_

_ExceptionInfo（trio.testing._raises_group 中的类）

A

Abort.FAILED()（在 trio.lowlevel 模块中）, [1] Abort.SUCCEEDED()（在 trio.lowlevel 模块中）, [1] Abort（trio.lowlevel 中的类） absolute() （trio.Path 方法） accept() （trio.abc.Listener 方法） accept() （trio.SocketListener 方法） accept() （trio.SSLListener 方法） aclose() （trio.abc.AsyncResource 方法） aclose() （trio.DTLSChannel 方法）, [1] aclose() （trio.MemoryReceiveChannel 方法） aclose() （trio.MemorySendChannel 方法） aclose() （trio.SocketListener 方法） aclose() （trio.SocketStream 方法） aclose() （trio.SSLListener 方法） aclose() （trio.SSLStream 方法） aclose() （trio.StapledStream 方法） aclose() （trio.testing.MemoryReceiveStream 方法） aclose() （trio.testing.MemorySendStream 方法） aclose_forcefully()（在 trio 模块中） acquire() （trio.CapacityLimiter 方法） acquire() （trio.Condition 方法） acquire() （trio.Lock 方法） acquire() （trio.Semaphore 方法）

acquire_nowait() （trio.CapacityLimiter 方法） acquire_nowait() （trio.Condition 方法） acquire_nowait() （trio.Lock 方法） acquire_nowait() （trio.Semaphore 方法） acquire_on_behalf_of() （trio.CapacityLimiter 方法） acquire_on_behalf_of_nowait() （trio.CapacityLimiter 方法） active_thread_count()（在 trio.testing 模块中） add_instrument()（在 trio.lowlevel 模块中） add_parking_lot_breaker()（在 trio.lowlevel 模块中） after_io_wait() （trio.abc.Instrument 方法） after_run() （trio.abc.Instrument 方法） after_task_step() （trio.abc.Instrument 方法） anchor（trio.Path 属性） args（trio.Process 属性） as_posix() （trio.Path 方法） as_uri() （trio.Path 方法） assert_checkpoints()（在 trio.testing 模块中） assert_no_checkpoints()（在 trio.testing 模块中） Asynchronous file interface(异步文件接口) (interface in trio) asynchronous file object AsyncResource（trio.abc 中的类） autojump_threshold（trio.testing.MockClock 属性） available_tokens（trio.CapacityLimiter 属性）

B

before_io_wait() （trio.abc.Instrument 方法） before_run() （trio.abc.Instrument 方法） before_task_step() （trio.abc.Instrument 方法） borrowed_tokens（trio.CapacityLimiter 属性）

break_lot() （trio.lowlevel.ParkingLot 方法） broken_by（trio.lowlevel.ParkingLot 属性） BrokenResourceError BusyResourceError

C

cancel() （trio.CancelScope 方法）, [1] cancel_called（trio.CancelScope 属性）, [1] cancel_scope（trio.Nursery 属性） cancel_shielded_checkpoint()（在 trio.lowlevel 模块中） Cancelled cancelled_caught（trio.CancelScope 属性） CancelScope（trio 中的类） CapacityLimiterStatistics（trio 中的类） CapacityLimiter（trio 中的类） Channel（trio.abc 中的类） check_cancelled()（在 trio.from_thread 模块中） check_half_closeable_stream()（在 trio.testing 模块中） check_one_way_stream()（在 trio.testing 模块中） check_two_way_stream()（在 trio.testing 模块中） checkpoint()（在 trio.lowlevel 模块中） checkpoint_if_cancelled()（在 trio.lowlevel 模块中） child_nurseries（trio.lowlevel.Task 属性） child_tasks（trio.Nursery 属性） chmod() （trio.Path 方法） Clock（trio.abc 中的类） clone() （trio.MemoryReceiveChannel 方法） clone() （trio.MemorySendChannel 方法） close() （trio.DTLSChannel 方法）, [1] close() （trio.DTLSEndpoint 方法）, [1] close() （trio.MemoryReceiveChannel 方法）

close() （trio.MemorySendChannel 方法） close() （trio.testing.MemoryReceiveStream 方法） close() （trio.testing.MemorySendStream 方法） close_hook（trio.testing.MemoryReceiveStream 属性） close_hook（trio.testing.MemorySendStream 属性） ClosedResourceError ConditionStatistics（trio 中的类） Condition（trio 中的类） connect() （trio.DTLSEndpoint 方法）, [1] connect() （trio.socket.SocketType 方法） context（trio.lowlevel.Task 属性） coro（trio.lowlevel.Task 属性） current_clock()（在 trio.lowlevel 模块中） current_default_thread_limiter()（在 trio.to_thread 模块中） current_effective_deadline()（在 trio 模块中） current_iocp()（在 trio.lowlevel 模块中） current_kqueue()（在 trio.lowlevel 模块中） current_root_task()（在 trio.lowlevel 模块中） current_statistics()（在 trio.lowlevel 模块中） current_task()（在 trio.lowlevel 模块中） current_time() （trio.abc.Clock 方法） current_time()（在 trio 模块中） current_trio_token()（在 trio.lowlevel 模块中） currently_ki_protected()（在 trio.lowlevel 模块中） custom_sleep_data（trio.lowlevel.Task 属性） cwd()（trio.Path 类方法）

D

deadline_to_sleep_time() （trio.abc.Clock 方法） deadline（trio.CancelScope 属性）, [1] did_shutdown_SHUT_WR（trio.socket.SocketType 属性） disable_ki_protection()（在 trio.lowlevel 模块中） do_handshake() （trio.DTLSChannel 方法）, [1]

do_handshake() （trio.SSLStream 方法） drive（trio.Path 属性） DTLSChannelStatistics（trio 中的类） DTLSChannel（trio 中的类） DTLSEndpoint（trio 中的类）

E

enable_ki_protection()（在 trio.lowlevel 模块中） EndOfChannel endpoint（trio.DTLSChannel 属性）, [1] EventStatistics（trio 中的类）

eventual_parent_nursery（trio.lowlevel.Task 属性） Event（trio 中的类） exists() （trio.Path 方法） expanduser() （trio.Path 方法）

F

fail_after()（在 trio 模块中） fail_at()（在 trio 模块中） FdStream（trio.lowlevel 中的类） fileno() （trio._subprocess.HasFileno 方法）

fill_unfilled() （trio.testing._raises_group._ExceptionInfo 方法） for_later()（trio.testing._raises_group._ExceptionInfo 类方法） from_stdlib_socket()（在 trio.socket 模块中） fromfd()（在 trio.socket 模块中） fromshare()（在 trio.socket 模块中）

G

get() （trio.lowlevel.RunVar 方法） get_cleartext_mtu() （trio.DTLSChannel 方法）, [1] get_data() （trio.testing.MemorySendStream 方法） get_data_nowait() （trio.testing.MemorySendStream 方法） getaddrinfo() （trio.abc.HostnameResolver 方法） getaddrinfo()（在 trio.socket 模块中）

getnameinfo() （trio.abc.HostnameResolver 方法） getnameinfo()（在 trio.socket 模块中） getprotobyname()（在 trio.socket 模块中） getsockopt() （trio.SocketStream 方法） glob() （trio.Path 方法） group() （trio.Path 方法）

H

HalfCloseableStream（trio.abc 中的类） hardlink_to() （trio.Path 方法）

HasFileno（trio._subprocess 中的类） home()（trio.Path 类方法） HostnameResolver（trio.abc 中的类）

I

incoming_packets_buffer（trio.DTLSEndpoint 属性）, [1] Instrument（trio.abc 中的类） is_absolute() （trio.Path 方法） is_block_device() （trio.Path 方法） is_char_device() （trio.Path 方法） is_dir() （trio.Path 方法） is_fifo() （trio.Path 方法） is_file() （trio.Path 方法） is_junction() （trio.Path 方法） is_mount() （trio.Path 方法）

is_readable() （trio.socket.SocketType 方法） is_relative() （trio.CancelScope 方法） is_relative_to() （trio.Path 方法） is_relative（trio.CancelScope 属性） is_reserved() （trio.Path 方法） is_set() （trio.Event 方法） is_socket() （trio.Path 方法） is_symlink() （trio.Path 方法） iter_await_frames() （trio.lowlevel.Task 方法） iterdir() （trio.Path 方法）

J

joinpath() （trio.Path 方法）

jump() （trio.testing.MockClock 方法）

K

kill() （trio.Process 方法）, [1]

L

lchmod() （trio.Path 方法） Listener（trio.abc 中的类） locked() （trio.Condition 方法） locked() （trio.Lock 方法）

LockStatistics（trio 中的类） lockstep_stream_one_way_pair()（在 trio.testing 模块中） lockstep_stream_pair()（在 trio.testing 模块中） Lock（trio 中的类） lstat() （trio.Path 方法）

M

match() （trio.Path 方法） Matcher（trio.testing 中的类） matches() （trio.testing.Matcher 方法） matches() （trio.testing.RaisesGroup 方法） max_value（trio.Semaphore 属性） memory_stream_one_way_pair()（在 trio.testing 模块中） memory_stream_pair()（在 trio.testing 模块中） memory_stream_pump()（在 trio.testing 模块中） MemoryChannelStatistics（trio 中的类） MemoryReceiveChannel（trio 中的类） MemoryReceiveStream（trio.testing 中的类） MemorySendChannel（trio 中的类） MemorySendStream（trio.testing 中的类）

mkdir() （trio.Path 方法） MockClock（trio.testing 中的类） module trio, [1], [2], [3], [4], [5], [6], [7], [8], [9] trio.from_thread trio.lowlevel trio.socket trio.testing trio.to_thread monitor_completion_key()（在 trio.lowlevel 模块中） monitor_kevent()（在 trio.lowlevel 模块中） move_on_after()（在 trio 模块中） move_on_at()（在 trio 模块中）

N

name（trio.lowlevel.Task 属性） name（trio.Path 属性） NeedHandshakeError

notify() （trio.Condition 方法） notify_all() （trio.Condition 方法） notify_closing()（在 trio.lowlevel 模块中） Nursery（trio 中的类）

O

open() （trio.Path 方法） open_file()（在 trio 模块中） open_memory_channel()（在 trio 模块中） open_nursery()（在 trio 模块中） open_process()（在 trio.lowlevel 模块中） open_signal_receiver()（在 trio 模块中）

open_ssl_over_tcp_listeners()（在 trio 模块中） open_ssl_over_tcp_stream()（在 trio 模块中） open_stream_to_socket_listener()（在 trio.testing 模块中） open_tcp_listeners()（在 trio 模块中） open_tcp_stream()（在 trio 模块中） open_unix_socket()（在 trio 模块中） owner() （trio.Path 方法）

P

parent_nursery（trio.lowlevel.Task 属性） parent_task（trio.Nursery 属性） parents（trio.Path 属性） parent（trio.Path 属性） park() （trio.lowlevel.ParkingLot 方法） ParkingLotStatistics（trio.lowlevel 中的类） ParkingLot（trio.lowlevel 中的类） parts（trio.Path 属性） Path（trio 中的类） peer_address（trio.DTLSChannel 属性）, [1]

permanently_detach_coroutine_object()（在 trio.lowlevel 模块中） pid（trio.Process 属性） poll() （trio.Process 方法）, [1] PosixPath（trio 中的类） Process（trio 中的类） put_data() （trio.testing.MemoryReceiveStream 方法） put_eof() （trio.testing.MemoryReceiveStream 方法） Python 增强建议；PEP 525, [1] Python 增强建议；PEP 621 Python 增强建议；PEP 654, [1], [2]

R

RaisesGroup（trio.testing 中的类） rate（trio.testing.MockClock 属性） read_bytes() （trio.Path 方法） read_text() （trio.Path 方法） readinto_overlapped()（在 trio.lowlevel 模块中） readlink() （trio.Path 方法） reattach_detached_coroutine_object()（在 trio.lowlevel 模块中） receive() （trio.abc.ReceiveChannel 方法） receive() （trio.DTLSChannel 方法）, [1] receive() （trio.MemoryReceiveChannel 方法） receive_nowait() （trio.MemoryReceiveChannel 方法） receive_some() （trio.abc.ReceiveStream 方法） receive_some() （trio.SocketStream 方法） receive_some() （trio.SSLStream 方法） receive_some() （trio.StapledStream 方法） receive_some() （trio.testing.MemoryReceiveStream 方法） receive_some_hook（trio.testing.MemoryReceiveStream 属性） receive_stream（trio.StapledStream 属性）, [1] ReceiveChannel（trio.abc 中的类） ReceiveStream（trio.abc 中的类） register_with_iocp()（在 trio.lowlevel 模块中） relative_deadline（trio.CancelScope 属性） relative_to() （trio.Path 方法） release() （trio.CapacityLimiter 方法） release() （trio.Condition 方法）

release() （trio.Lock 方法） release() （trio.Semaphore 方法） release_on_behalf_of() （trio.CapacityLimiter 方法） remove_instrument()（在 trio.lowlevel 模块中） remove_parking_lot_breaker()（在 trio.lowlevel 模块中） rename() （trio.Path 方法） repark() （trio.lowlevel.ParkingLot 方法） repark_all() （trio.lowlevel.ParkingLot 方法） replace() （trio.Path 方法） reschedule()（在 trio.lowlevel 模块中） reset() （trio.lowlevel.RunVar 方法） resolve() （trio.Path 方法） returncode（trio.Process 属性）, [1] rglob() （trio.Path 方法） rmdir() （trio.Path 方法） root（trio.Path 属性） run()（在 trio 模块中） run()（在 trio.from_thread 模块中） run_process()（在 trio 模块中） run_sync()（在 trio.from_thread 模块中） run_sync()（在 trio.to_thread 模块中） run_sync_soon() （trio.lowlevel.TrioToken 方法） RunFinishedError RunStatistics（trio.lowlevel 中的类） RunVar（trio.lowlevel 中的类）

S

samefile() （trio.Path 方法） Semaphore（trio 中的类） send() （trio.abc.SendChannel 方法） send() （trio.DTLSChannel 方法）, [1] send() （trio.MemorySendChannel 方法） send_all() （trio.abc.SendStream 方法） send_all() （trio.SocketStream 方法） send_all() （trio.SSLStream 方法） send_all() （trio.StapledStream 方法） send_all() （trio.testing.MemorySendStream 方法） send_all_hook（trio.testing.MemorySendStream 属性） send_eof() （trio.abc.HalfCloseableStream 方法） send_eof() （trio.SocketStream 方法） send_eof() （trio.StapledStream 方法） send_nowait() （trio.MemorySendChannel 方法） send_signal() （trio.Process 方法）, [1] send_stream（trio.StapledStream 属性）, [1] SendChannel（trio.abc 中的类） sendfile() （trio.socket.SocketType 方法） SendStream（trio.abc 中的类） Sequencer（trio.testing 中的类） serve() （trio.DTLSEndpoint 方法）, [1] serve_listeners()（在 trio 模块中） serve_ssl_over_tcp()（在 trio 模块中） serve_tcp()（在 trio 模块中） set() （trio.Event 方法） set() （trio.lowlevel.RunVar 方法） set_ciphertext_mtu() （trio.DTLSChannel 方法）, [1] set_custom_hostname_resolver()（在 trio.socket 模块中） set_custom_socket_factory()（在 trio.socket 模块中） setsockopt() （trio.SocketStream 方法） shield（trio.CancelScope 属性）, [1] sleep()（在 trio 模块中） sleep_forever()（在 trio 模块中） sleep_until()（在 trio 模块中） socket() （trio.abc.SocketFactory 方法） socket()（在 trio.socket 模块中） SocketFactory（trio.abc 中的类）

SocketListener（trio 中的类） socketpair()（在 trio.socket 模块中） SocketStream（trio 中的类） SocketType（trio.socket 中的类） socket（trio.DTLSEndpoint 属性）, [1] socket（trio.SocketListener 属性）, [1] socket（trio.SocketStream 属性）, [1] spawn_system_task()（在 trio.lowlevel 模块中） SSLListener（trio 中的类） SSLStream（trio 中的类） StapledStream（trio 中的类） start() （trio.Nursery 方法）, [1] start_clock() （trio.abc.Clock 方法） start_guest_run()（在 trio.lowlevel 模块中） start_soon() （trio.Nursery 方法）, [1] start_thread_soon()（在 trio.lowlevel 模块中） started() （trio.TaskStatus 方法） stat() （trio.Path 方法） statistics() （trio.CapacityLimiter 方法） statistics() （trio.Condition 方法） statistics() （trio.DTLSChannel 方法）, [1] statistics() （trio.Event 方法） statistics() （trio.Lock 方法） statistics() （trio.lowlevel.ParkingLot 方法） statistics() （trio.MemoryReceiveChannel 方法） statistics() （trio.MemorySendChannel 方法） statistics() （trio.Semaphore 方法） stderr（trio.Process 属性） stdin（trio.Process 属性） stdio（trio.Process 属性） stdout（trio.Process 属性） stem（trio.Path 属性） Stream（trio.abc 中的类） StrictFIFOLock（trio 中的类） StrOrBytesPath()（在 trio._subprocess 模块中） suffixes（trio.Path 属性） suffix（trio.Path 属性） symlink_to() （trio.Path 方法）

T

task_exited() （trio.abc.Instrument 方法） task_scheduled() （trio.abc.Instrument 方法） task_spawned() （trio.abc.Instrument 方法） TASK_STATUS_IGNORED（trio.trio 属性） TaskStatus（trio 中的类） Task（trio.lowlevel 中的类） tb（trio.testing._raises_group._ExceptionInfo 属性） temporarily_detach_coroutine_object()（在 trio.lowlevel 模块中） terminate() （trio.Process 方法）, [1] TooSlowError total_tokens（trio.CapacityLimiter 属性） touch() （trio.Path 方法） transport_listener（trio.SSLListener 属性） transport_stream（trio.SSLStream 属性） trio module, [1], [2], [3], [4], [5], [6], [7], [8], [9]

trio.from_thread module trio.lowlevel module trio.socket module trio.testing module trio.to_thread module trio_test()（在 trio.testing 模块中） TrioDeprecationWarning TrioInternalError TrioToken（trio.lowlevel 中的类） type（trio.testing._raises_group._ExceptionInfo 属性）

U

unlink() （trio.Path 方法） unpark() （trio.lowlevel.ParkingLot 方法）

unpark_all() （trio.lowlevel.ParkingLot 方法） unwrap() （trio.SSLStream 方法）

V

value（trio.Semaphore 属性）

value（trio.testing._raises_group._ExceptionInfo 属性）

W

wait() （trio.Condition 方法） wait() （trio.Event 方法） wait() （trio.Process 方法）, [1] wait_all_tasks_blocked()（在 trio.testing 模块中） wait_all_threads_completed()（在 trio.testing 模块中） wait_kevent()（在 trio.lowlevel 模块中） wait_overlapped()（在 trio.lowlevel 模块中） wait_readable()（在 trio.lowlevel 模块中） wait_send_all_might_not_block() （trio.abc.SendStream 方法） wait_send_all_might_not_block() （trio.SocketStream 方法） wait_send_all_might_not_block() （trio.SSLStream 方法） wait_send_all_might_not_block() （trio.StapledStream 方法） wait_send_all_might_not_block() （trio.testing.MemorySendStream 方法） wait_send_all_might_not_block_hook（trio.testing.MemorySendStream 属性）

wait_task_rescheduled()（在 trio.lowlevel 模块中） wait_writable()（在 trio.lowlevel 模块中） WaitForSingleObject()（在 trio.lowlevel 模块中） WindowsPath（trio 中的类） with_name() （trio.Path 方法） with_segments() （trio.Path 方法） with_stem() （trio.Path 方法） with_suffix() （trio.Path 方法） WouldBlock wrap_file()（在 trio 模块中） wrapped（trio.Asynchronous file interface(异步文件接口) 属性） write_bytes() （trio.Path 方法） write_overlapped()（在 trio.lowlevel 模块中） write_text() （trio.Path 方法）