Python 3.5 官方文档

Runtime

  • abc
  • abc.ABC
  • abc.ABCMeta
  • abc.ABCMeta.register()
  • abc.ABCMeta.__subclasshook__()
  • abc.abstractclassmethod()
  • abc.abstractmethod()
  • abc.abstractproperty()
  • abc.abstractstaticmethod()
  • abc.get_cache_token()
  • atexit
  • atexit.register()
  • atexit.unregister()
  • builtins
  • contextlib
  • contextlib.closing()
  • contextlib.ContextDecorator
  • contextlib.contextmanager()
  • contextlib.ExitStack
  • contextlib.ExitStack.callback()
  • contextlib.ExitStack.close()
  • contextlib.ExitStack.enter_context()
  • contextlib.ExitStack.pop_all()
  • contextlib.ExitStack.push()
  • contextlib.redirect_stderr()
  • contextlib.redirect_stdout()
  • contextlib.suppress()
  • fpectl
  • fpectl.FloatingPointError
  • fpectl.turnoff_sigfpe()
  • fpectl.turnon_sigfpe()
  • gc
  • gc.callbacks
  • gc.collect()
  • gc.disable()
  • gc.enable()
  • gc.garbage
  • gc.get_count()
  • gc.get_debug()
  • gc.get_objects()
  • gc.get_referents()
  • gc.get_referrers()
  • gc.get_stats()
  • gc.get_threshold()
  • gc.isenabled()
  • gc.is_tracked()
  • gc.set_debug()
  • gc.set_threshold()
  • inspect
  • inspect.BoundArguments
  • inspect.BoundArguments.apply_defaults()
  • inspect.BoundArguments.args
  • inspect.BoundArguments.arguments
  • inspect.BoundArguments.kwargs
  • inspect.BoundArguments.signature
  • inspect.cleandoc()
  • inspect.currentframe()
  • inspect.formatargspec()
  • inspect.formatargvalues()
  • inspect.getargspec()
  • inspect.getargvalues()
  • inspect.getattr_static()
  • inspect.getcallargs()
  • inspect.getclasstree()
  • inspect.getclosurevars()
  • inspect.getcomments()
  • inspect.getcoroutinelocals()
  • inspect.getcoroutinestate()
  • inspect.getdoc()
  • inspect.getfile()
  • inspect.getframeinfo()
  • inspect.getfullargspec()
  • inspect.getgeneratorlocals()
  • inspect.getgeneratorstate()
  • inspect.getinnerframes()
  • inspect.getmembers()
  • inspect.getmodule()
  • inspect.getmoduleinfo()
  • inspect.getmodulename()
  • inspect.getmro()
  • inspect.getouterframes()
  • inspect.getsource()
  • inspect.getsourcefile()
  • inspect.getsourcelines()
  • inspect.isabstract()
  • inspect.isawaitable()
  • inspect.isbuiltin()
  • inspect.isclass()
  • inspect.iscode()
  • inspect.iscoroutine()
  • inspect.iscoroutinefunction()
  • inspect.isdatadescriptor()
  • inspect.isframe()
  • inspect.isfunction()
  • inspect.isgenerator()
  • inspect.isgeneratorfunction()
  • inspect.isgetsetdescriptor()
  • inspect.ismemberdescriptor()
  • inspect.ismethod()
  • inspect.ismethoddescriptor()
  • inspect.ismodule()
  • inspect.isroutine()
  • inspect.istraceback()
  • inspect.Parameter
  • inspect.Parameter.annotation
  • inspect.Parameter.default
  • inspect.Parameter.empty
  • inspect.Parameter.kind
  • inspect.Parameter.name
  • inspect.Parameter.replace()
  • inspect.Signature
  • inspect.Signature.bind()
  • inspect.Signature.bind_partial()
  • inspect.Signature.empty
  • inspect.Signature.from_callable()
  • inspect.Signature.parameters
  • inspect.Signature.replace()
  • inspect.Signature.return_annotation
  • inspect.stack()
  • inspect.trace()
  • inspect.unwrap()
  • site
  • site.addsitedir()
  • site.getsitepackages()
  • site.getuserbase()
  • site.getusersitepackages()
  • site.main()
  • sys
  • sys.abiflags
  • sys.api_version
  • sys.argv
  • sys.base_exec_prefix
  • sys.base_prefix
  • sys.builtin_module_names
  • sys.byteorder
  • sys.call_tracing()
  • sys.copyright
  • sys.displayhook()
  • sys.dllhandle
  • sys.dont_write_bytecode
  • sys.excepthook()
  • sys.exc_info()
  • sys.executable
  • sys.exec_prefix
  • sys.exit()
  • sys.flags
  • sys.float_info
  • sys.float_repr_style
  • sys.getallocatedblocks()
  • sys.getcheckinterval()
  • sys.getdefaultencoding()
  • sys.getdlopenflags()
  • sys.getfilesystemencoding()
  • sys.getprofile()
  • sys.getrecursionlimit()
  • sys.getrefcount()
  • sys.getsizeof()
  • sys.getswitchinterval()
  • sys.gettrace()
  • sys.getwindowsversion()
  • sys.get_coroutine_wrapper()
  • sys.hash_info
  • sys.hexversion
  • sys.implementation
  • sys.intern()
  • sys.int_info
  • sys.is_finalizing()
  • sys.last_traceback
  • sys.last_type
  • sys.last_value
  • sys.maxsize
  • sys.maxunicode
  • sys.meta_path
  • sys.modules
  • sys.path
  • sys.path_hooks
  • sys.path_importer_cache
  • sys.platform
  • sys.prefix
  • sys.ps1
  • sys.ps2
  • sys.setcheckinterval()
  • sys.setdlopenflags()
  • sys.setprofile()
  • sys.setrecursionlimit()
  • sys.setswitchinterval()
  • sys.settrace()
  • sys.settscdump()
  • sys.set_coroutine_wrapper()
  • sys.stderr
  • sys.stdin
  • sys.stdout
  • sys.thread_info
  • sys.tracebacklimit
  • sys.version
  • sys.version_info
  • sys.warnoptions
  • sys.winver
  • sys._clear_type_cache()
  • sys._current_frames()
  • sys._debugmallocstats()
  • sys._getframe()
  • sys._xoptions
  • sys.__displayhook__
  • sys.__excepthook__
  • sys.__interactivehook__
  • sys.__stderr__
  • sys.__stdin__
  • sys.__stdout__
  • sysconfig
  • sysconfig.get_config_h_filename()
  • sysconfig.get_config_var()
  • sysconfig.get_config_vars()
  • sysconfig.get_makefile_filename()
  • sysconfig.get_path()
  • sysconfig.get_paths()
  • sysconfig.get_path_names()
  • sysconfig.get_platform()
  • sysconfig.get_python_version()
  • sysconfig.get_scheme_names()
  • sysconfig.is_python_build()
  • sysconfig.parse_config_h()
  • traceback
  • traceback.clear_frames()
  • traceback.extract_stack()
  • traceback.extract_tb()
  • traceback.format_exc()
  • traceback.format_exception()
  • traceback.format_exception_only()
  • traceback.format_list()
  • traceback.format_stack()
  • traceback.format_tb()
  • traceback.FrameSummary
  • traceback.print_exc()
  • traceback.print_exception()
  • traceback.print_last()
  • traceback.print_stack()
  • traceback.print_tb()
  • traceback.StackSummary
  • traceback.StackSummary.extract()
  • traceback.StackSummary.from_list()
  • traceback.TracebackException
  • traceback.TracebackException.exc_type
  • traceback.TracebackException.filename
  • traceback.TracebackException.format()
  • traceback.TracebackException.format_exception_only()
  • traceback.TracebackException.from_exception()
  • traceback.TracebackException.lineno
  • traceback.TracebackException.msg
  • traceback.TracebackException.offset
  • traceback.TracebackException.stack
  • traceback.TracebackException.text
  • traceback.TracebackException.__cause__
  • traceback.TracebackException.__context__
  • traceback.TracebackException.__suppress_context__
  • traceback.walk_stack()
  • traceback.walk_tb()
  • warnings
  • warnings.catch_warnings
  • warnings.filterwarnings()
  • warnings.formatwarning()
  • warnings.resetwarnings()
  • warnings.showwarning()
  • warnings.simplefilter()
  • warnings.warn()
  • warnings.warn_explicit()
  • __future__
  • __main__
  • Multimedia

  • aifc
  • aifc.aifc.aifc()
  • aifc.aifc.aiff()
  • aifc.aifc.close()
  • aifc.aifc.getcompname()
  • aifc.aifc.getcomptype()
  • aifc.aifc.getframerate()
  • aifc.aifc.getmark()
  • aifc.aifc.getmarkers()
  • aifc.aifc.getnchannels()
  • aifc.aifc.getnframes()
  • aifc.aifc.getparams()
  • aifc.aifc.getsampwidth()
  • aifc.aifc.readframes()
  • aifc.aifc.rewind()
  • aifc.aifc.setcomptype()
  • aifc.aifc.setframerate()
  • aifc.aifc.setmark()
  • aifc.aifc.setnchannels()
  • aifc.aifc.setnframes()
  • aifc.aifc.setparams()
  • aifc.aifc.setpos()
  • aifc.aifc.setsampwidth()
  • aifc.aifc.tell()
  • aifc.aifc.writeframes()
  • aifc.aifc.writeframesraw()
  • aifc.open()
  • audioop
  • audioop.add()
  • audioop.adpcm2lin()
  • audioop.alaw2lin()
  • audioop.avg()
  • audioop.avgpp()
  • audioop.bias()
  • audioop.byteswap()
  • audioop.cross()
  • audioop.error
  • audioop.findfactor()
  • audioop.findfit()
  • audioop.findmax()
  • audioop.getsample()
  • audioop.lin2adpcm()
  • audioop.lin2alaw()
  • audioop.lin2lin()
  • audioop.lin2ulaw()
  • audioop.max()
  • audioop.maxpp()
  • audioop.minmax()
  • audioop.mul()
  • audioop.ratecv()
  • audioop.reverse()
  • audioop.rms()
  • audioop.tomono()
  • audioop.tostereo()
  • audioop.ulaw2lin()
  • chunk
  • chunk.Chunk
  • chunk.Chunk.close()
  • chunk.Chunk.getname()
  • chunk.Chunk.getsize()
  • chunk.Chunk.isatty()
  • chunk.Chunk.read()
  • chunk.Chunk.seek()
  • chunk.Chunk.skip()
  • chunk.Chunk.tell()
  • colorsys
  • colorsys.hls_to_rgb()
  • colorsys.hsv_to_rgb()
  • colorsys.rgb_to_hls()
  • colorsys.rgb_to_hsv()
  • colorsys.rgb_to_yiq()
  • colorsys.yiq_to_rgb()
  • imghdr
  • imghdr.tests
  • imghdr.what()
  • ossaudiodev
  • ossaudiodev.open()
  • ossaudiodev.openmixer()
  • ossaudiodev.OSSAudioError
  • ossaudiodev.oss_audio_device.bufsize()
  • ossaudiodev.oss_audio_device.channels()
  • ossaudiodev.oss_audio_device.close()
  • ossaudiodev.oss_audio_device.closed
  • ossaudiodev.oss_audio_device.fileno()
  • ossaudiodev.oss_audio_device.getfmts()
  • ossaudiodev.oss_audio_device.mode
  • ossaudiodev.oss_audio_device.name
  • ossaudiodev.oss_audio_device.nonblock()
  • ossaudiodev.oss_audio_device.obufcount()
  • ossaudiodev.oss_audio_device.obuffree()
  • ossaudiodev.oss_audio_device.post()
  • ossaudiodev.oss_audio_device.read()
  • ossaudiodev.oss_audio_device.reset()
  • ossaudiodev.oss_audio_device.setfmt()
  • ossaudiodev.oss_audio_device.setparameters()
  • ossaudiodev.oss_audio_device.speed()
  • ossaudiodev.oss_audio_device.sync()
  • ossaudiodev.oss_audio_device.write()
  • ossaudiodev.oss_audio_device.writeall()
  • ossaudiodev.oss_mixer_device.close()
  • ossaudiodev.oss_mixer_device.controls()
  • ossaudiodev.oss_mixer_device.fileno()
  • ossaudiodev.oss_mixer_device.get()
  • ossaudiodev.oss_mixer_device.get_recsrc()
  • ossaudiodev.oss_mixer_device.reccontrols()
  • ossaudiodev.oss_mixer_device.set()
  • ossaudiodev.oss_mixer_device.set_recsrc()
  • ossaudiodev.oss_mixer_device.stereocontrols()
  • sndhdr
  • sndhdr.what()
  • sndhdr.whathdr()
  • wave
  • wave.Error
  • wave.open()
  • wave.openfp()
  • wave.Wave_read.close()
  • wave.Wave_read.getcompname()
  • wave.Wave_read.getcomptype()
  • wave.Wave_read.getframerate()
  • wave.Wave_read.getmark()
  • wave.Wave_read.getmarkers()
  • wave.Wave_read.getnchannels()
  • wave.Wave_read.getnframes()
  • wave.Wave_read.getparams()
  • wave.Wave_read.getsampwidth()
  • wave.Wave_read.readframes()
  • wave.Wave_read.rewind()
  • wave.Wave_read.setpos()
  • wave.Wave_read.tell()
  • wave.Wave_write.close()
  • wave.Wave_write.setcomptype()
  • wave.Wave_write.setframerate()
  • wave.Wave_write.setnchannels()
  • wave.Wave_write.setnframes()
  • wave.Wave_write.setparams()
  • wave.Wave_write.setsampwidth()
  • wave.Wave_write.tell()
  • wave.Wave_write.writeframes()
  • wave.Wave_write.writeframesraw()
  • Operating System

  • argparse
  • argparse.Action
  • argparse.ArgumentDefaultsHelpFormatter
  • argparse.ArgumentParser
  • argparse.ArgumentParser.add_argument()
  • argparse.ArgumentParser.add_argument_group()
  • argparse.ArgumentParser.add_mutually_exclusive_group()
  • argparse.ArgumentParser.add_subparsers()
  • argparse.ArgumentParser.convert_arg_line_to_args()
  • argparse.ArgumentParser.error()
  • argparse.ArgumentParser.exit()
  • argparse.ArgumentParser.format_help()
  • argparse.ArgumentParser.format_usage()
  • argparse.ArgumentParser.get_default()
  • argparse.ArgumentParser.parse_args()
  • argparse.ArgumentParser.parse_known_args()
  • argparse.ArgumentParser.print_help()
  • argparse.ArgumentParser.print_usage()
  • argparse.ArgumentParser.set_defaults()
  • argparse.FileType
  • argparse.MetavarTypeHelpFormatter
  • argparse.Namespace
  • argparse.RawDescriptionHelpFormatter
  • argparse.RawTextHelpFormatter
  • ctypes
  • ctypes.addressof()
  • ctypes.alignment()
  • ctypes.ArgumentError
  • ctypes.Array
  • ctypes.Array._length_
  • ctypes.Array._type_
  • ctypes.BigEndianStructure
  • ctypes.byref()
  • ctypes.cast()
  • ctypes.CDLL
  • ctypes.CFUNCTYPE()
  • ctypes.create_string_buffer()
  • ctypes.create_unicode_buffer()
  • ctypes.c_bool
  • ctypes.c_byte
  • ctypes.c_char
  • ctypes.c_char_p
  • ctypes.c_double
  • ctypes.c_float
  • ctypes.c_int
  • ctypes.c_int16
  • ctypes.c_int32
  • ctypes.c_int64
  • ctypes.c_int8
  • ctypes.c_long
  • ctypes.c_longdouble
  • ctypes.c_longlong
  • ctypes.c_short
  • ctypes.c_size_t
  • ctypes.c_ssize_t
  • ctypes.c_ubyte
  • ctypes.c_uint
  • ctypes.c_uint16
  • ctypes.c_uint32
  • ctypes.c_uint64
  • ctypes.c_uint8
  • ctypes.c_ulong
  • ctypes.c_ulonglong
  • ctypes.c_ushort
  • ctypes.c_void_p
  • ctypes.c_wchar
  • ctypes.c_wchar_p
  • ctypes.DllCanUnloadNow()
  • ctypes.DllGetClassObject()
  • ctypes.FormatError()
  • ctypes.GetLastError()
  • ctypes.get_errno()
  • ctypes.get_last_error()
  • ctypes.HRESULT
  • ctypes.LibraryLoader
  • ctypes.LibraryLoader.LoadLibrary()
  • ctypes.LittleEndianStructure
  • ctypes.memmove()
  • ctypes.memset()
  • ctypes.OleDLL
  • ctypes.POINTER()
  • ctypes.PyDLL
  • ctypes.PyDLL._handle
  • ctypes.PyDLL._name
  • ctypes.PYFUNCTYPE()
  • ctypes.py_object
  • ctypes.resize()
  • ctypes.set_errno()
  • ctypes.set_last_error()
  • ctypes.sizeof()
  • ctypes.string_at()
  • ctypes.Structure
  • ctypes.Structure._anonymous_
  • ctypes.Structure._fields_
  • ctypes.Structure._pack_
  • ctypes.Union
  • ctypes.util.find_library()
  • ctypes.util.find_msvcrt()
  • ctypes.WinDLL
  • ctypes.WinError()
  • ctypes.WINFUNCTYPE()
  • ctypes.wstring_at()
  • ctypes._CData
  • ctypes._CData.from_address()
  • ctypes._CData.from_buffer()
  • ctypes._CData.from_buffer_copy()
  • ctypes._CData.from_param()
  • ctypes._CData.in_dll()
  • ctypes._CData._b_base_
  • ctypes._CData._b_needsfree_
  • ctypes._CData._objects
  • ctypes._FuncPtr
  • ctypes._FuncPtr.argtypes
  • ctypes._FuncPtr.errcheck
  • ctypes._FuncPtr.restype
  • ctypes._Pointer
  • ctypes._Pointer.contents
  • ctypes._Pointer._type_
  • ctypes._SimpleCData
  • ctypes._SimpleCData.value
  • curses
  • curses.ascii
  • curses.ascii.alt()
  • curses.ascii.ascii()
  • curses.ascii.controlnames
  • curses.ascii.ctrl()
  • curses.ascii.isalnum()
  • curses.ascii.isalpha()
  • curses.ascii.isascii()
  • curses.ascii.isblank()
  • curses.ascii.iscntrl()
  • curses.ascii.isctrl()
  • curses.ascii.isdigit()
  • curses.ascii.isgraph()
  • curses.ascii.islower()
  • curses.ascii.ismeta()
  • curses.ascii.isprint()
  • curses.ascii.ispunct()
  • curses.ascii.isspace()
  • curses.ascii.isupper()
  • curses.ascii.isxdigit()
  • curses.ascii.unctrl()
  • curses.baudrate()
  • curses.beep()
  • curses.can_change_color()
  • curses.cbreak()
  • curses.color_content()
  • curses.color_pair()
  • curses.curs_set()
  • curses.def_prog_mode()
  • curses.def_shell_mode()
  • curses.delay_output()
  • curses.doupdate()
  • curses.echo()
  • curses.endwin()
  • curses.erasechar()
  • curses.error
  • curses.filter()
  • curses.flash()
  • curses.flushinp()
  • curses.getmouse()
  • curses.getsyx()
  • curses.getwin()
  • curses.halfdelay()
  • curses.has_colors()
  • curses.has_ic()
  • curses.has_il()
  • curses.has_key()
  • curses.initscr()
  • curses.init_color()
  • curses.init_pair()
  • curses.isendwin()
  • curses.is_term_resized()
  • curses.keyname()
  • curses.killchar()
  • curses.longname()
  • curses.meta()
  • curses.mouseinterval()
  • curses.mousemask()
  • curses.napms()
  • curses.newpad()
  • curses.newwin()
  • curses.nl()
  • curses.nocbreak()
  • curses.noecho()
  • curses.nonl()
  • curses.noqiflush()
  • curses.noraw()
  • curses.pair_content()
  • curses.pair_number()
  • curses.panel
  • curses.panel.bottom_panel()
  • curses.panel.new_panel()
  • curses.panel.Panel.above()
  • curses.panel.Panel.below()
  • curses.panel.Panel.bottom()
  • curses.panel.Panel.hidden()
  • curses.panel.Panel.hide()
  • curses.panel.Panel.move()
  • curses.panel.Panel.replace()
  • curses.panel.Panel.set_userptr()
  • curses.panel.Panel.show()
  • curses.panel.Panel.top()
  • curses.panel.Panel.userptr()
  • curses.panel.Panel.window()
  • curses.panel.top_panel()
  • curses.panel.update_panels()
  • curses.putp()
  • curses.qiflush()
  • curses.raw()
  • curses.resetty()
  • curses.reset_prog_mode()
  • curses.reset_shell_mode()
  • curses.resizeterm()
  • curses.resize_term()
  • curses.savetty()
  • curses.setsyx()
  • curses.setupterm()
  • curses.start_color()
  • curses.termattrs()
  • curses.termname()
  • curses.textpad.rectangle()
  • curses.textpad.Textbox
  • curses.textpad.Textbox.do_command()
  • curses.textpad.Textbox.edit()
  • curses.textpad.Textbox.gather()
  • curses.textpad.Textbox.stripspaces
  • curses.tigetflag()
  • curses.tigetnum()
  • curses.tigetstr()
  • curses.tparm()
  • curses.typeahead()
  • curses.unctrl()
  • curses.ungetch()
  • curses.ungetmouse()
  • curses.unget_wch()
  • curses.update_lines_cols()
  • curses.use_default_colors()
  • curses.use_env()
  • curses.version
  • curses.window.addch()
  • curses.window.addnstr()
  • curses.window.addstr()
  • curses.window.attroff()
  • curses.window.attron()
  • curses.window.attrset()
  • curses.window.bkgd()
  • curses.window.bkgdset()
  • curses.window.border()
  • curses.window.box()
  • curses.window.chgat()
  • curses.window.clear()
  • curses.window.clearok()
  • curses.window.clrtobot()
  • curses.window.clrtoeol()
  • curses.window.cursyncup()
  • curses.window.delch()
  • curses.window.deleteln()
  • curses.window.derwin()
  • curses.window.echochar()
  • curses.window.enclose()
  • curses.window.encoding
  • curses.window.erase()
  • curses.window.getbegyx()
  • curses.window.getbkgd()
  • curses.window.getch()
  • curses.window.getkey()
  • curses.window.getmaxyx()
  • curses.window.getparyx()
  • curses.window.getstr()
  • curses.window.getyx()
  • curses.window.get_wch()
  • curses.window.hline()
  • curses.window.idcok()
  • curses.window.idlok()
  • curses.window.immedok()
  • curses.window.inch()
  • curses.window.insch()
  • curses.window.insdelln()
  • curses.window.insertln()
  • curses.window.insnstr()
  • curses.window.insstr()
  • curses.window.instr()
  • curses.window.is_linetouched()
  • curses.window.is_wintouched()
  • curses.window.keypad()
  • curses.window.leaveok()
  • curses.window.move()
  • curses.window.mvderwin()
  • curses.window.mvwin()
  • curses.window.nodelay()
  • curses.window.notimeout()
  • curses.window.noutrefresh()
  • curses.window.overlay()
  • curses.window.overwrite()
  • curses.window.putwin()
  • curses.window.redrawln()
  • curses.window.redrawwin()
  • curses.window.refresh()
  • curses.window.resize()
  • curses.window.scroll()
  • curses.window.scrollok()
  • curses.window.setscrreg()
  • curses.window.standend()
  • curses.window.standout()
  • curses.window.subpad()
  • curses.window.subwin()
  • curses.window.syncdown()
  • curses.window.syncok()
  • curses.window.syncup()
  • curses.window.timeout()
  • curses.window.touchline()
  • curses.window.touchwin()
  • curses.window.untouchwin()
  • curses.window.vline()
  • curses.wrapper()
  • errno
  • getopt
  • getopt.error
  • getopt.getopt()
  • getopt.GetoptError
  • getopt.gnu_getopt()
  • getpass
  • getpass.getpass()
  • getpass.GetPassWarning
  • getpass.getuser()
  • io
  • io.BlockingIOError
  • io.BufferedIOBase
  • io.BufferedIOBase.detach()
  • io.BufferedIOBase.raw
  • io.BufferedIOBase.read()
  • io.BufferedIOBase.read1()
  • io.BufferedIOBase.readinto()
  • io.BufferedIOBase.readinto1()
  • io.BufferedIOBase.write()
  • io.BufferedRandom
  • io.BufferedReader
  • io.BufferedReader.peek()
  • io.BufferedReader.read()
  • io.BufferedReader.read1()
  • io.BufferedRWPair
  • io.BufferedWriter
  • io.BufferedWriter.flush()
  • io.BufferedWriter.write()
  • io.BytesIO
  • io.BytesIO.getbuffer()
  • io.BytesIO.getvalue()
  • io.BytesIO.read1()
  • io.BytesIO.readinto1()
  • io.FileIO
  • io.FileIO.mode
  • io.FileIO.name
  • io.IncrementalNewlineDecoder
  • io.IOBase
  • io.IOBase.close()
  • io.IOBase.closed
  • io.IOBase.fileno()
  • io.IOBase.flush()
  • io.IOBase.isatty()
  • io.IOBase.readable()
  • io.IOBase.readline()
  • io.IOBase.readlines()
  • io.IOBase.seek()
  • io.IOBase.seekable()
  • io.IOBase.tell()
  • io.IOBase.truncate()
  • io.IOBase.writable()
  • io.IOBase.writelines()
  • io.IOBase.__del__()
  • io.open()
  • io.RawIOBase
  • io.RawIOBase.read()
  • io.RawIOBase.readall()
  • io.RawIOBase.readinto()
  • io.RawIOBase.write()
  • io.StringIO
  • io.StringIO.getvalue()
  • io.TextIOBase
  • io.TextIOBase.buffer
  • io.TextIOBase.detach()
  • io.TextIOBase.encoding
  • io.TextIOBase.errors
  • io.TextIOBase.newlines
  • io.TextIOBase.read()
  • io.TextIOBase.readline()
  • io.TextIOBase.seek()
  • io.TextIOBase.tell()
  • io.TextIOBase.write()
  • io.TextIOWrapper
  • io.TextIOWrapper.line_buffering
  • io.UnsupportedOperation
  • os
  • os.abort()
  • os.access()
  • os.altsep
  • os.chdir()
  • os.chflags()
  • os.chmod()
  • os.chown()
  • os.chroot()
  • os.close()
  • os.closerange()
  • os.confstr()
  • os.confstr_names
  • os.cpu_count()
  • os.ctermid()
  • os.curdir
  • os.defpath
  • os.device_encoding()
  • os.devnull
  • os.DirEntry
  • os.DirEntry.inode()
  • os.DirEntry.is_dir()
  • os.DirEntry.is_file()
  • os.DirEntry.is_symlink()
  • os.DirEntry.name
  • os.DirEntry.path
  • os.DirEntry.stat()
  • os.dup()
  • os.dup2()
  • os.environ
  • os.environb
  • os.error
  • os.execl()
  • os.execle()
  • os.execlp()
  • os.execlpe()
  • os.execv()
  • os.execve()
  • os.execvp()
  • os.execvpe()
  • os.extsep
  • os.fchdir()
  • os.fchmod()
  • os.fchown()
  • os.fdatasync()
  • os.fdopen()
  • os.fork()
  • os.forkpty()
  • os.fpathconf()
  • os.fsdecode()
  • os.fsencode()
  • os.fstat()
  • os.fstatvfs()
  • os.fsync()
  • os.ftruncate()
  • os.fwalk()
  • os.getcwd()
  • os.getcwdb()
  • os.getegid()
  • os.getenv()
  • os.getenvb()
  • os.geteuid()
  • os.getgid()
  • os.getgrouplist()
  • os.getgroups()
  • os.getloadavg()
  • os.getlogin()
  • os.getpgid()
  • os.getpgrp()
  • os.getpid()
  • os.getppid()
  • os.getpriority()
  • os.getresgid()
  • os.getresuid()
  • os.getsid()
  • os.getuid()
  • os.getxattr()
  • os.get_blocking()
  • os.get_exec_path()
  • os.get_handle_inheritable()
  • os.get_inheritable()
  • os.get_terminal_size()
  • os.initgroups()
  • os.isatty()
  • os.kill()
  • os.killpg()
  • os.lchflags()
  • os.lchmod()
  • os.lchown()
  • os.linesep
  • os.link()
  • os.listdir()
  • os.listxattr()
  • os.lockf()
  • os.lseek()
  • os.lstat()
  • os.major()
  • os.makedev()
  • os.makedirs()
  • os.minor()
  • os.mkdir()
  • os.mkfifo()
  • os.mknod()
  • os.name
  • os.nice()
  • os.open()
  • os.openpty()
  • os.pardir
  • os.pathconf()
  • os.pathconf_names
  • os.pathsep
  • os.pipe()
  • os.pipe2()
  • os.plock()
  • os.popen()
  • os.posix_fadvise()
  • os.posix_fallocate()
  • os.pread()
  • os.putenv()
  • os.pwrite()
  • os.read()
  • os.readlink()
  • os.readv()
  • os.remove()
  • os.removedirs()
  • os.removexattr()
  • os.rename()
  • os.renames()
  • os.replace()
  • os.rmdir()
  • os.scandir()
  • os.sched_getaffinity()
  • os.sched_getparam()
  • os.sched_getscheduler()
  • os.sched_get_priority_max()
  • os.sched_get_priority_min()
  • os.sched_param
  • os.sched_param.sched_priority
  • os.sched_rr_get_interval()
  • os.sched_setaffinity()
  • os.sched_setparam()
  • os.sched_setscheduler()
  • os.sched_yield()
  • os.sendfile()
  • os.sep
  • os.setegid()
  • os.seteuid()
  • os.setgid()
  • os.setgroups()
  • os.setpgid()
  • os.setpgrp()
  • os.setpriority()
  • os.setregid()
  • os.setresgid()
  • os.setresuid()
  • os.setreuid()
  • os.setsid()
  • os.setuid()
  • os.setxattr()
  • os.set_blocking()
  • os.set_handle_inheritable()
  • os.set_inheritable()
  • os.spawnl()
  • os.spawnle()
  • os.spawnlp()
  • os.spawnlpe()
  • os.spawnv()
  • os.spawnve()
  • os.spawnvp()
  • os.spawnvpe()
  • os.startfile()
  • os.stat()
  • os.statvfs()
  • os.stat_float_times()
  • os.stat_result
  • os.stat_result.st_atime
  • os.stat_result.st_atime_ns
  • os.stat_result.st_birthtime
  • os.stat_result.st_blksize
  • os.stat_result.st_blocks
  • os.stat_result.st_creator
  • os.stat_result.st_ctime
  • os.stat_result.st_ctime_ns
  • os.stat_result.st_dev
  • os.stat_result.st_file_attributes
  • os.stat_result.st_flags
  • os.stat_result.st_gen
  • os.stat_result.st_gid
  • os.stat_result.st_ino
  • os.stat_result.st_mode
  • os.stat_result.st_mtime
  • os.stat_result.st_mtime_ns
  • os.stat_result.st_nlink
  • os.stat_result.st_rdev
  • os.stat_result.st_rsize
  • os.stat_result.st_size
  • os.stat_result.st_type
  • os.stat_result.st_uid
  • os.strerror()
  • os.supports_bytes_environ
  • os.supports_dir_fd
  • os.supports_effective_ids
  • os.supports_fd
  • os.supports_follow_symlinks
  • os.symlink()
  • os.sync()
  • os.sysconf()
  • os.sysconf_names
  • os.system()
  • os.tcgetpgrp()
  • os.tcsetpgrp()
  • os.terminal_size
  • os.terminal_size.columns
  • os.terminal_size.lines
  • os.times()
  • os.truncate()
  • os.ttyname()
  • os.umask()
  • os.uname()
  • os.unlink()
  • os.unsetenv()
  • os.urandom()
  • os.utime()
  • os.wait()
  • os.wait3()
  • os.wait4()
  • os.waitid()
  • os.waitpid()
  • os.walk()
  • os.WCOREDUMP()
  • os.WEXITSTATUS()
  • os.WIFCONTINUED()
  • os.WIFEXITED()
  • os.WIFSIGNALED()
  • os.WIFSTOPPED()
  • os.write()
  • os.writev()
  • os.WSTOPSIG()
  • os.WTERMSIG()
  • os._exit()
  • platform
  • platform.architecture()
  • platform.dist()
  • platform.java_ver()
  • platform.libc_ver()
  • platform.linux_distribution()
  • platform.machine()
  • platform.mac_ver()
  • platform.node()
  • platform.platform()
  • platform.popen()
  • platform.processor()
  • platform.python_branch()
  • platform.python_build()
  • platform.python_compiler()
  • platform.python_implementation()
  • platform.python_revision()
  • platform.python_version()
  • platform.python_version_tuple()
  • platform.release()
  • platform.system()
  • platform.system_alias()
  • platform.uname()
  • platform.version()
  • platform.win32_ver()
  • time
  • time.altzone
  • time.asctime()
  • time.clock()
  • time.clock_getres()
  • time.clock_gettime()
  • time.clock_settime()
  • time.ctime()
  • time.daylight
  • time.get_clock_info()
  • time.gmtime()
  • time.localtime()
  • time.mktime()
  • time.monotonic()
  • time.perf_counter()
  • time.process_time()
  • time.sleep()
  • time.strftime()
  • time.strptime()
  • time.struct_time
  • time.time()
  • time.timezone
  • time.tzname
  • time.tzset()
  • Data Types

  • array
  • array.array
  • array.array.append()
  • array.array.buffer_info()
  • array.array.byteswap()
  • array.array.count()
  • array.array.extend()
  • array.array.frombytes()
  • array.array.fromfile()
  • array.array.fromlist()
  • array.array.fromstring()
  • array.array.fromunicode()
  • array.array.index()
  • array.array.insert()
  • array.array.itemsize
  • array.array.pop()
  • array.array.remove()
  • array.array.reverse()
  • array.array.tobytes()
  • array.array.tofile()
  • array.array.tolist()
  • array.array.tostring()
  • array.array.tounicode()
  • array.array.typecode
  • array.typecodes
  • bisect
  • bisect.bisect()
  • bisect.bisect_left()
  • bisect.bisect_right()
  • bisect.insort()
  • bisect.insort_left()
  • bisect.insort_right()
  • calendar
  • calendar.Calendar
  • calendar.Calendar.itermonthdates()
  • calendar.Calendar.itermonthdays()
  • calendar.Calendar.itermonthdays2()
  • calendar.Calendar.iterweekdays()
  • calendar.Calendar.monthdatescalendar()
  • calendar.Calendar.monthdays2calendar()
  • calendar.Calendar.monthdayscalendar()
  • calendar.Calendar.yeardatescalendar()
  • calendar.Calendar.yeardays2calendar()
  • calendar.Calendar.yeardayscalendar()
  • calendar.day_abbr
  • calendar.day_name
  • calendar.firstweekday()
  • calendar.HTMLCalendar
  • calendar.HTMLCalendar.formatmonth()
  • calendar.HTMLCalendar.formatyear()
  • calendar.HTMLCalendar.formatyearpage()
  • calendar.isleap()
  • calendar.leapdays()
  • calendar.LocaleHTMLCalendar
  • calendar.LocaleTextCalendar
  • calendar.month()
  • calendar.monthcalendar()
  • calendar.monthrange()
  • calendar.month_abbr
  • calendar.month_name
  • calendar.prcal()
  • calendar.prmonth()
  • calendar.setfirstweekday()
  • calendar.TextCalendar
  • calendar.TextCalendar.formatmonth()
  • calendar.TextCalendar.formatyear()
  • calendar.TextCalendar.prmonth()
  • calendar.TextCalendar.pryear()
  • calendar.timegm()
  • calendar.weekday()
  • calendar.weekheader()
  • collections
  • collections.abc
  • collections.abc.AsyncIterable
  • collections.abc.AsyncIterator
  • collections.abc.Awaitable
  • collections.abc.ByteString
  • collections.abc.Callable
  • collections.abc.Container
  • collections.abc.Coroutine
  • collections.abc.Generator
  • collections.abc.Hashable
  • collections.abc.ItemsView
  • collections.abc.Iterable
  • collections.abc.Iterator
  • collections.abc.KeysView
  • collections.abc.Mapping
  • collections.abc.MappingView
  • collections.abc.MutableMapping
  • collections.abc.MutableSequence
  • collections.abc.MutableSet
  • collections.abc.Sequence
  • collections.abc.Set
  • collections.abc.Sized
  • collections.abc.ValuesView
  • collections.ChainMap
  • collections.ChainMap.maps
  • collections.ChainMap.new_child()
  • collections.ChainMap.parents
  • collections.Counter
  • collections.Counter.elements()
  • collections.Counter.fromkeys()
  • collections.Counter.most_common()
  • collections.Counter.subtract()
  • collections.Counter.update()
  • collections.defaultdict
  • collections.defaultdict.default_factory
  • collections.defaultdict.__missing__()
  • collections.deque
  • collections.deque.append()
  • collections.deque.appendleft()
  • collections.deque.clear()
  • collections.deque.copy()
  • collections.deque.count()
  • collections.deque.extend()
  • collections.deque.extendleft()
  • collections.deque.index()
  • collections.deque.insert()
  • collections.deque.maxlen
  • collections.deque.pop()
  • collections.deque.popleft()
  • collections.deque.remove()
  • collections.deque.reverse()
  • collections.deque.rotate()
  • collections.namedtuple()
  • collections.OrderedDict
  • collections.OrderedDict.move_to_end()
  • collections.OrderedDict.popitem()
  • collections.somenamedtuple._asdict()
  • collections.somenamedtuple._fields
  • collections.somenamedtuple._make()
  • collections.somenamedtuple._replace()
  • collections.somenamedtuple._source
  • collections.UserDict
  • collections.UserDict.data
  • collections.UserList
  • collections.UserList.data
  • collections.UserString
  • copy
  • copy.copy()
  • copy.deepcopy()
  • copy.error
  • datetime
  • datetime.date
  • datetime.date.ctime()
  • datetime.date.day
  • datetime.date.fromordinal()
  • datetime.date.fromtimestamp()
  • datetime.date.isocalendar()
  • datetime.date.isoformat()
  • datetime.date.isoweekday()
  • datetime.date.max
  • datetime.date.min
  • datetime.date.month
  • datetime.date.replace()
  • datetime.date.resolution
  • datetime.date.strftime()
  • datetime.date.timetuple()
  • datetime.date.today()
  • datetime.date.toordinal()
  • datetime.date.weekday()
  • datetime.date.year
  • datetime.date.__format__()
  • datetime.date.__str__()
  • datetime.datetime
  • datetime.datetime.astimezone()
  • datetime.datetime.combine()
  • datetime.datetime.ctime()
  • datetime.datetime.date()
  • datetime.datetime.day
  • datetime.datetime.dst()
  • datetime.datetime.fromordinal()
  • datetime.datetime.fromtimestamp()
  • datetime.datetime.hour
  • datetime.datetime.isocalendar()
  • datetime.datetime.isoformat()
  • datetime.datetime.isoweekday()
  • datetime.datetime.max
  • datetime.datetime.microsecond
  • datetime.datetime.min
  • datetime.datetime.minute
  • datetime.datetime.month
  • datetime.datetime.now()
  • datetime.datetime.replace()
  • datetime.datetime.resolution
  • datetime.datetime.second
  • datetime.datetime.strftime()
  • datetime.datetime.strptime()
  • datetime.datetime.time()
  • datetime.datetime.timestamp()
  • datetime.datetime.timetuple()
  • datetime.datetime.timetz()
  • datetime.datetime.today()
  • datetime.datetime.toordinal()
  • datetime.datetime.tzinfo
  • datetime.datetime.tzname()
  • datetime.datetime.utcfromtimestamp()
  • datetime.datetime.utcnow()
  • datetime.datetime.utcoffset()
  • datetime.datetime.utctimetuple()
  • datetime.datetime.weekday()
  • datetime.datetime.year
  • datetime.datetime.__format__()
  • datetime.datetime.__str__()
  • datetime.time
  • datetime.time.dst()
  • datetime.time.hour
  • datetime.time.isoformat()
  • datetime.time.max
  • datetime.time.microsecond
  • datetime.time.min
  • datetime.time.minute
  • datetime.time.replace()
  • datetime.time.resolution
  • datetime.time.second
  • datetime.time.strftime()
  • datetime.time.tzinfo
  • datetime.time.tzname()
  • datetime.time.utcoffset()
  • datetime.time.__format__()
  • datetime.time.__str__()
  • datetime.timedelta
  • datetime.timedelta.max
  • datetime.timedelta.min
  • datetime.timedelta.resolution
  • datetime.timedelta.total_seconds()
  • datetime.timezone
  • datetime.timezone.dst()
  • datetime.timezone.fromutc()
  • datetime.timezone.tzname()
  • datetime.timezone.utc
  • datetime.timezone.utcoffset()
  • datetime.tzinfo
  • datetime.tzinfo.dst()
  • datetime.tzinfo.fromutc()
  • datetime.tzinfo.tzname()
  • datetime.tzinfo.utcoffset()
  • enum
  • enum.Enum
  • enum.IntEnum
  • enum.unique()
  • heapq
  • heapq.heapify()
  • heapq.heappop()
  • heapq.heappush()
  • heapq.heappushpop()
  • heapq.heapreplace()
  • heapq.merge()
  • heapq.nlargest()
  • heapq.nsmallest()
  • pprint
  • pprint.isreadable()
  • pprint.isrecursive()
  • pprint.pformat()
  • pprint.pprint()
  • pprint.PrettyPrinter
  • pprint.PrettyPrinter.format()
  • pprint.PrettyPrinter.isreadable()
  • pprint.PrettyPrinter.isrecursive()
  • pprint.PrettyPrinter.pformat()
  • pprint.PrettyPrinter.pprint()
  • pprint.saferepr()
  • reprlib
  • reprlib.aRepr
  • reprlib.recursive_repr()
  • reprlib.Repr
  • reprlib.Repr.maxarray
  • reprlib.Repr.maxdeque
  • reprlib.Repr.maxdict
  • reprlib.Repr.maxfrozenset
  • reprlib.Repr.maxlevel
  • reprlib.Repr.maxlist
  • reprlib.Repr.maxlong
  • reprlib.Repr.maxother
  • reprlib.Repr.maxset
  • reprlib.Repr.maxstring
  • reprlib.Repr.maxtuple
  • reprlib.Repr.repr()
  • reprlib.Repr.repr1()
  • types
  • types.BuiltinFunctionType
  • types.BuiltinMethodType
  • types.CodeType
  • types.coroutine()
  • types.CoroutineType
  • types.DynamicClassAttribute()
  • types.FrameType
  • types.FunctionType
  • types.GeneratorType
  • types.GetSetDescriptorType
  • types.LambdaType
  • types.MappingProxyType
  • types.MappingProxyType.copy()
  • types.MappingProxyType.get()
  • types.MappingProxyType.items()
  • types.MappingProxyType.keys()
  • types.MappingProxyType.values()
  • types.MemberDescriptorType
  • types.MethodType
  • types.ModuleType
  • types.ModuleType.__doc__
  • types.ModuleType.__loader__
  • types.ModuleType.__name__
  • types.ModuleType.__package__
  • types.new_class()
  • types.prepare_class()
  • types.SimpleNamespace
  • types.TracebackType
  • weakref
  • weakref.CallableProxyType
  • weakref.finalize
  • weakref.finalize.alive
  • weakref.finalize.atexit
  • weakref.finalize.detach()
  • weakref.finalize.peek()
  • weakref.finalize.__call__()
  • weakref.getweakrefcount()
  • weakref.getweakrefs()
  • weakref.proxy()
  • weakref.ProxyType
  • weakref.ProxyTypes
  • weakref.ref
  • weakref.ref.__callback__
  • weakref.ReferenceError
  • weakref.ReferenceType
  • weakref.WeakKeyDictionary
  • weakref.WeakKeyDictionary.keyrefs()
  • weakref.WeakMethod
  • weakref.WeakSet
  • weakref.WeakValueDictionary
  • weakref.WeakValueDictionary.valuerefs()
  • Language

  • ast
  • ast.AST
  • ast.AST.col_offset
  • ast.AST.lineno
  • ast.AST._fields
  • ast.copy_location()
  • ast.dump()
  • ast.fix_missing_locations()
  • ast.get_docstring()
  • ast.increment_lineno()
  • ast.iter_child_nodes()
  • ast.iter_fields()
  • ast.literal_eval()
  • ast.NodeTransformer
  • ast.NodeVisitor
  • ast.NodeVisitor.generic_visit()
  • ast.NodeVisitor.visit()
  • ast.parse()
  • ast.walk()
  • compileall
  • compileall.compile_dir()
  • compileall.compile_file()
  • compileall.compile_path()
  • dis
  • dis.Bytecode
  • dis.Bytecode.codeobj
  • dis.Bytecode.dis()
  • dis.Bytecode.first_line
  • dis.Bytecode.from_traceback()
  • dis.Bytecode.info()
  • dis.cmp_op
  • dis.code_info()
  • dis.dis()
  • dis.disassemble()
  • dis.disco()
  • dis.distb()
  • dis.findlabels()
  • dis.findlinestarts()
  • dis.get_instructions()
  • dis.hascompare
  • dis.hasconst
  • dis.hasfree
  • dis.hasjabs
  • dis.hasjrel
  • dis.haslocal
  • dis.hasname
  • dis.Instruction
  • dis.Instruction.arg
  • dis.Instruction.argrepr
  • dis.Instruction.argval
  • dis.Instruction.is_jump_target
  • dis.Instruction.offset
  • dis.Instruction.opcode
  • dis.Instruction.opname
  • dis.Instruction.starts_line
  • dis.opmap
  • dis.opname
  • dis.show_code()
  • dis.stack_effect()
  • keyword
  • keyword.iskeyword()
  • keyword.kwlist
  • parser
  • parser.compilest()
  • parser.expr()
  • parser.isexpr()
  • parser.issuite()
  • parser.ParserError
  • parser.sequence2st()
  • parser.ST.compile()
  • parser.ST.isexpr()
  • parser.ST.issuite()
  • parser.ST.tolist()
  • parser.ST.totuple()
  • parser.st2list()
  • parser.st2tuple()
  • parser.STType
  • parser.suite()
  • parser.tuple2st()
  • pickletools
  • pickletools.dis()
  • pickletools.genops()
  • pickletools.optimize()
  • pyclbr
  • pyclbr.Class.file
  • pyclbr.Class.lineno
  • pyclbr.Class.methods
  • pyclbr.Class.module
  • pyclbr.Class.name
  • pyclbr.Class.super
  • pyclbr.Function.file
  • pyclbr.Function.lineno
  • pyclbr.Function.module
  • pyclbr.Function.name
  • pyclbr.readmodule()
  • pyclbr.readmodule_ex()
  • py_compile
  • py_compile.compile()
  • py_compile.main()
  • py_compile.PyCompileError
  • symbol
  • symbol.sym_name
  • symtable
  • symtable.Class
  • symtable.Class.get_methods()
  • symtable.Function
  • symtable.Function.get_frees()
  • symtable.Function.get_globals()
  • symtable.Function.get_locals()
  • symtable.Function.get_parameters()
  • symtable.Symbol
  • symtable.Symbol.get_name()
  • symtable.Symbol.get_namespace()
  • symtable.Symbol.get_namespaces()
  • symtable.Symbol.is_assigned()
  • symtable.Symbol.is_declared_global()
  • symtable.Symbol.is_free()
  • symtable.Symbol.is_global()
  • symtable.Symbol.is_imported()
  • symtable.Symbol.is_local()
  • symtable.Symbol.is_namespace()
  • symtable.Symbol.is_parameter()
  • symtable.Symbol.is_referenced()
  • symtable.SymbolTable
  • symtable.SymbolTable.get_children()
  • symtable.SymbolTable.get_id()
  • symtable.SymbolTable.get_identifiers()
  • symtable.SymbolTable.get_lineno()
  • symtable.SymbolTable.get_name()
  • symtable.SymbolTable.get_symbols()
  • symtable.SymbolTable.get_type()
  • symtable.SymbolTable.has_children()
  • symtable.SymbolTable.has_exec()
  • symtable.SymbolTable.is_nested()
  • symtable.SymbolTable.is_optimized()
  • symtable.SymbolTable.lookup()
  • symtable.symtable()
  • tabnanny
  • tabnanny.check()
  • tabnanny.filename_only
  • tabnanny.NannyNag
  • tabnanny.process_tokens()
  • tabnanny.verbose
  • token
  • token.ISEOF()
  • token.ISNONTERMINAL()
  • token.ISTERMINAL()
  • token.tok_name
  • tokenize
  • tokenize.detect_encoding()
  • tokenize.open()
  • tokenize.TokenError
  • tokenize.tokenize()
  • tokenize.untokenize()
  • Networking

  • asynchat
  • asynchat.async_chat
  • asynchat.async_chat.ac_in_buffer_size
  • asynchat.async_chat.ac_out_buffer_size
  • asynchat.async_chat.close_when_done()
  • asynchat.async_chat.collect_incoming_data()
  • asynchat.async_chat.discard_buffers()
  • asynchat.async_chat.found_terminator()
  • asynchat.async_chat.get_terminator()
  • asynchat.async_chat.push()
  • asynchat.async_chat.push_with_producer()
  • asynchat.async_chat.set_terminator()
  • asyncio
  • asyncore
  • asyncore.dispatcher
  • asyncore.dispatcher.accept()
  • asyncore.dispatcher.bind()
  • asyncore.dispatcher.close()
  • asyncore.dispatcher.connect()
  • asyncore.dispatcher.create_socket()
  • asyncore.dispatcher.handle_accept()
  • asyncore.dispatcher.handle_accepted()
  • asyncore.dispatcher.handle_close()
  • asyncore.dispatcher.handle_connect()
  • asyncore.dispatcher.handle_error()
  • asyncore.dispatcher.handle_expt()
  • asyncore.dispatcher.handle_read()
  • asyncore.dispatcher.handle_write()
  • asyncore.dispatcher.listen()
  • asyncore.dispatcher.readable()
  • asyncore.dispatcher.recv()
  • asyncore.dispatcher.send()
  • asyncore.dispatcher.writable()
  • asyncore.dispatcher_with_send
  • asyncore.file_dispatcher
  • asyncore.file_wrapper
  • asyncore.loop()
  • mmap
  • mmap.mmap
  • mmap.mmap.close()
  • mmap.mmap.closed
  • mmap.mmap.find()
  • mmap.mmap.flush()
  • mmap.mmap.move()
  • mmap.mmap.read()
  • mmap.mmap.readline()
  • mmap.mmap.read_byte()
  • mmap.mmap.resize()
  • mmap.mmap.rfind()
  • mmap.mmap.seek()
  • mmap.mmap.size()
  • mmap.mmap.tell()
  • mmap.mmap.write()
  • mmap.mmap.write_byte()
  • signal
  • signal.alarm()
  • signal.getitimer()
  • signal.getsignal()
  • signal.ItimerError
  • signal.pause()
  • signal.pthread_kill()
  • signal.pthread_sigmask()
  • signal.setitimer()
  • signal.set_wakeup_fd()
  • signal.siginterrupt()
  • signal.signal()
  • signal.sigpending()
  • signal.sigtimedwait()
  • signal.sigwait()
  • signal.sigwaitinfo()
  • socket
  • socket.CMSG_LEN()
  • socket.CMSG_SPACE()
  • socket.create_connection()
  • socket.error
  • socket.fromfd()
  • socket.fromshare()
  • socket.gaierror
  • socket.getaddrinfo()
  • socket.getdefaulttimeout()
  • socket.getfqdn()
  • socket.gethostbyaddr()
  • socket.gethostbyname()
  • socket.gethostbyname_ex()
  • socket.gethostname()
  • socket.getnameinfo()
  • socket.getprotobyname()
  • socket.getservbyname()
  • socket.getservbyport()
  • socket.has_ipv6
  • socket.herror
  • socket.htonl()
  • socket.htons()
  • socket.if_indextoname()
  • socket.if_nameindex()
  • socket.if_nametoindex()
  • socket.inet_aton()
  • socket.inet_ntoa()
  • socket.inet_ntop()
  • socket.inet_pton()
  • socket.ntohl()
  • socket.ntohs()
  • socket.setdefaulttimeout()
  • socket.sethostname()
  • socket.socket()
  • socket.socket.accept()
  • socket.socket.bind()
  • socket.socket.close()
  • socket.socket.connect()
  • socket.socket.connect_ex()
  • socket.socket.detach()
  • socket.socket.dup()
  • socket.socket.family
  • socket.socket.fileno()
  • socket.socket.getpeername()
  • socket.socket.getsockname()
  • socket.socket.getsockopt()
  • socket.socket.gettimeout()
  • socket.socket.get_inheritable()
  • socket.socket.ioctl()
  • socket.socket.listen()
  • socket.socket.makefile()
  • socket.socket.proto
  • socket.socket.recv()
  • socket.socket.recvfrom()
  • socket.socket.recvfrom_into()
  • socket.socket.recvmsg()
  • socket.socket.recvmsg_into()
  • socket.socket.recv_into()
  • socket.socket.send()
  • socket.socket.sendall()
  • socket.socket.sendfile()
  • socket.socket.sendmsg()
  • socket.socket.sendto()
  • socket.socket.setblocking()
  • socket.socket.setsockopt()
  • socket.socket.settimeout()
  • socket.socket.set_inheritable()
  • socket.socket.share()
  • socket.socket.shutdown()
  • socket.socket.type
  • socket.socketpair()
  • socket.SocketType
  • socket.timeout
  • ssl
  • ssl.CertificateError
  • ssl.cert_time_to_seconds()
  • ssl.create_default_context()
  • ssl.DER_cert_to_PEM_cert()
  • ssl.enum_certificates()
  • ssl.enum_crls()
  • ssl.get_default_verify_paths()
  • ssl.get_server_certificate()
  • ssl.match_hostname()
  • ssl.MemoryBIO
  • ssl.MemoryBIO.eof
  • ssl.MemoryBIO.pending
  • ssl.MemoryBIO.read()
  • ssl.MemoryBIO.write()
  • ssl.MemoryBIO.write_eof()
  • ssl.OP_NO_SSLv2
  • ssl.OP_NO_SSLv3
  • ssl.OP_NO_TLSv1
  • ssl.OP_NO_TLSv1_1
  • ssl.OP_NO_TLSv1_2
  • ssl.PEM_cert_to_DER_cert()
  • ssl.PROTOCOL_SSLv2
  • ssl.PROTOCOL_SSLv23
  • ssl.PROTOCOL_SSLv3
  • ssl.PROTOCOL_TLSv1
  • ssl.PROTOCOL_TLSv1_1
  • ssl.PROTOCOL_TLSv1_2
  • ssl.RAND_add()
  • ssl.RAND_bytes()
  • ssl.RAND_egd()
  • ssl.RAND_pseudo_bytes()
  • ssl.RAND_status()
  • ssl.SSLContext
  • ssl.SSLContext.cert_store_stats()
  • ssl.SSLContext.check_hostname
  • ssl.SSLContext.get_ca_certs()
  • ssl.SSLContext.load_cert_chain()
  • ssl.SSLContext.load_default_certs()
  • ssl.SSLContext.load_dh_params()
  • ssl.SSLContext.load_verify_locations()
  • ssl.SSLContext.options
  • ssl.SSLContext.protocol
  • ssl.SSLContext.session_stats()
  • ssl.SSLContext.set_alpn_protocols()
  • ssl.SSLContext.set_ciphers()
  • ssl.SSLContext.set_default_verify_paths()
  • ssl.SSLContext.set_ecdh_curve()
  • ssl.SSLContext.set_npn_protocols()
  • ssl.SSLContext.set_servername_callback()
  • ssl.SSLContext.verify_flags
  • ssl.SSLContext.verify_mode
  • ssl.SSLContext.wrap_bio()
  • ssl.SSLContext.wrap_socket()
  • ssl.SSLEOFError
  • ssl.SSLError
  • ssl.SSLError.library
  • ssl.SSLError.reason
  • ssl.SSLObject
  • ssl.SSLSocket
  • ssl.SSLSocket.cipher()
  • ssl.SSLSocket.compression()
  • ssl.SSLSocket.context
  • ssl.SSLSocket.do_handshake()
  • ssl.SSLSocket.getpeercert()
  • ssl.SSLSocket.get_channel_binding()
  • ssl.SSLSocket.pending()
  • ssl.SSLSocket.read()
  • ssl.SSLSocket.selected_alpn_protocol()
  • ssl.SSLSocket.selected_npn_protocol()
  • ssl.SSLSocket.server_hostname
  • ssl.SSLSocket.server_side
  • ssl.SSLSocket.shared_ciphers()
  • ssl.SSLSocket.unwrap()
  • ssl.SSLSocket.version()
  • ssl.SSLSocket.write()
  • ssl.SSLSyscallError
  • ssl.SSLWantReadError
  • ssl.SSLWantWriteError
  • ssl.SSLZeroReturnError
  • ssl.wrap_socket()
  • Input/ouput

  • asyncio.AbstractEventLoop
  • asyncio.AbstractEventLoop.add_reader()
  • asyncio.AbstractEventLoop.add_signal_handler()
  • asyncio.AbstractEventLoop.add_writer()
  • asyncio.AbstractEventLoop.call_at()
  • asyncio.AbstractEventLoop.call_exception_handler()
  • asyncio.AbstractEventLoop.call_later()
  • asyncio.AbstractEventLoop.call_soon()
  • asyncio.AbstractEventLoop.call_soon_threadsafe()
  • asyncio.AbstractEventLoop.close()
  • asyncio.AbstractEventLoop.connect_read_pipe()
  • asyncio.AbstractEventLoop.connect_write_pipe()
  • asyncio.AbstractEventLoop.create_connection()
  • asyncio.AbstractEventLoop.create_datagram_endpoint()
  • asyncio.AbstractEventLoop.create_future()
  • asyncio.AbstractEventLoop.create_server()
  • asyncio.AbstractEventLoop.create_task()
  • asyncio.AbstractEventLoop.create_unix_connection()
  • asyncio.AbstractEventLoop.create_unix_server()
  • asyncio.AbstractEventLoop.default_exception_handler()
  • asyncio.AbstractEventLoop.getaddrinfo()
  • asyncio.AbstractEventLoop.getnameinfo()
  • asyncio.AbstractEventLoop.get_debug()
  • asyncio.AbstractEventLoop.get_exception_handler()
  • asyncio.AbstractEventLoop.get_task_factory()
  • asyncio.AbstractEventLoop.is_closed()
  • asyncio.AbstractEventLoop.is_running()
  • asyncio.AbstractEventLoop.remove_reader()
  • asyncio.AbstractEventLoop.remove_signal_handler()
  • asyncio.AbstractEventLoop.remove_writer()
  • asyncio.AbstractEventLoop.run_forever()
  • asyncio.AbstractEventLoop.run_in_executor()
  • asyncio.AbstractEventLoop.run_until_complete()
  • asyncio.AbstractEventLoop.set_debug()
  • asyncio.AbstractEventLoop.set_default_executor()
  • asyncio.AbstractEventLoop.set_exception_handler()
  • asyncio.AbstractEventLoop.set_task_factory()
  • asyncio.AbstractEventLoop.sock_accept()
  • asyncio.AbstractEventLoop.sock_connect()
  • asyncio.AbstractEventLoop.sock_recv()
  • asyncio.AbstractEventLoop.sock_sendall()
  • asyncio.AbstractEventLoop.stop()
  • asyncio.AbstractEventLoop.subprocess_exec()
  • asyncio.AbstractEventLoop.subprocess_shell()
  • asyncio.AbstractEventLoop.time()
  • asyncio.AbstractEventLoopPolicy
  • asyncio.AbstractEventLoopPolicy.get_event_loop()
  • asyncio.AbstractEventLoopPolicy.new_event_loop()
  • asyncio.AbstractEventLoopPolicy.set_event_loop()
  • asyncio.async()
  • asyncio.asyncio.subprocess.Process
  • asyncio.asyncio.subprocess.Process.communicate()
  • asyncio.asyncio.subprocess.Process.kill()
  • asyncio.asyncio.subprocess.Process.pid
  • asyncio.asyncio.subprocess.Process.returncode
  • asyncio.asyncio.subprocess.Process.send_signal()
  • asyncio.asyncio.subprocess.Process.stderr
  • asyncio.asyncio.subprocess.Process.stdin
  • asyncio.asyncio.subprocess.Process.stdout
  • asyncio.asyncio.subprocess.Process.terminate()
  • asyncio.asyncio.subprocess.Process.wait()
  • asyncio.as_completed()
  • asyncio.BaseEventLoop
  • asyncio.BaseEventLoop.connect_accepted_socket()
  • asyncio.BaseProtocol.connection_lost()
  • asyncio.BaseProtocol.connection_made()
  • asyncio.BaseProtocol.pause_writing()
  • asyncio.BaseProtocol.resume_writing()
  • asyncio.BaseSubprocessTransport
  • asyncio.BaseSubprocessTransport.close()
  • asyncio.BaseSubprocessTransport.get_pid()
  • asyncio.BaseSubprocessTransport.get_pipe_transport()
  • asyncio.BaseSubprocessTransport.get_returncode()
  • asyncio.BaseSubprocessTransport.kill()
  • asyncio.BaseSubprocessTransport.send_signal()
  • asyncio.BaseSubprocessTransport.terminate()
  • asyncio.BaseTransport
  • asyncio.BaseTransport.close()
  • asyncio.BaseTransport.get_extra_info()
  • asyncio.BaseTransport.get_protocol()
  • asyncio.BaseTransport.is_closing()
  • asyncio.BaseTransport.set_protocol()
  • asyncio.BoundedSemaphore
  • asyncio.Condition
  • asyncio.Condition.acquire()
  • asyncio.Condition.locked()
  • asyncio.Condition.notify()
  • asyncio.Condition.notify_all()
  • asyncio.Condition.release()
  • asyncio.Condition.wait()
  • asyncio.Condition.wait_for()
  • asyncio.coroutine()
  • asyncio.create_subprocess_exec()
  • asyncio.create_subprocess_shell()
  • asyncio.DatagramProtocol
  • asyncio.DatagramProtocol.datagram_received()
  • asyncio.DatagramProtocol.error_received()
  • asyncio.DatagramTransport.abort()
  • asyncio.DatagramTransport.sendto()
  • asyncio.ensure_future()
  • asyncio.Event
  • asyncio.Event.clear()
  • asyncio.Event.is_set()
  • asyncio.Event.set()
  • asyncio.Event.wait()
  • asyncio.Future
  • asyncio.Future.add_done_callback()
  • asyncio.Future.cancel()
  • asyncio.Future.cancelled()
  • asyncio.Future.done()
  • asyncio.Future.exception()
  • asyncio.Future.remove_done_callback()
  • asyncio.Future.result()
  • asyncio.Future.set_exception()
  • asyncio.Future.set_result()
  • asyncio.gather()
  • asyncio.get_event_loop()
  • asyncio.get_event_loop_policy()
  • asyncio.Handle
  • asyncio.Handle.cancel()
  • asyncio.IncompleteReadError
  • asyncio.IncompleteReadError.expected
  • asyncio.IncompleteReadError.partial
  • asyncio.InvalidStateError
  • asyncio.iscoroutine()
  • asyncio.iscoroutinefunction()
  • asyncio.LifoQueue
  • asyncio.LimitOverrunError
  • asyncio.LimitOverrunError.consumed
  • asyncio.Lock
  • asyncio.Lock.acquire()
  • asyncio.Lock.locked()
  • asyncio.Lock.release()
  • asyncio.new_event_loop()
  • asyncio.open_connection()
  • asyncio.open_unix_connection()
  • asyncio.PriorityQueue
  • asyncio.ProactorEventLoop
  • asyncio.Protocol
  • asyncio.Protocol.data_received()
  • asyncio.Protocol.eof_received()
  • asyncio.Queue
  • asyncio.Queue.empty()
  • asyncio.Queue.full()
  • asyncio.Queue.get()
  • asyncio.Queue.get_nowait()
  • asyncio.Queue.join()
  • asyncio.Queue.maxsize
  • asyncio.Queue.put()
  • asyncio.Queue.put_nowait()
  • asyncio.Queue.qsize()
  • asyncio.Queue.task_done()
  • asyncio.QueueEmpty
  • asyncio.QueueFull
  • asyncio.ReadTransport
  • asyncio.ReadTransport.pause_reading()
  • asyncio.ReadTransport.resume_reading()
  • asyncio.run_coroutine_threadsafe()
  • asyncio.SelectorEventLoop
  • asyncio.Semaphore
  • asyncio.Semaphore.acquire()
  • asyncio.Semaphore.locked()
  • asyncio.Semaphore.release()
  • asyncio.Server
  • asyncio.Server.close()
  • asyncio.Server.sockets
  • asyncio.Server.wait_closed()
  • asyncio.set_event_loop()
  • asyncio.set_event_loop_policy()
  • asyncio.shield()
  • asyncio.sleep()
  • asyncio.start_server()
  • asyncio.start_unix_server()
  • asyncio.StreamReader
  • asyncio.StreamReader.at_eof()
  • asyncio.StreamReader.exception()
  • asyncio.StreamReader.feed_data()
  • asyncio.StreamReader.feed_eof()
  • asyncio.StreamReader.read()
  • asyncio.StreamReader.readexactly()
  • asyncio.StreamReader.readline()
  • asyncio.StreamReader.readuntil()
  • asyncio.StreamReader.set_exception()
  • asyncio.StreamReader.set_transport()
  • asyncio.StreamReaderProtocol
  • asyncio.StreamWriter
  • asyncio.StreamWriter.can_write_eof()
  • asyncio.StreamWriter.close()
  • asyncio.StreamWriter.drain()
  • asyncio.StreamWriter.get_extra_info()
  • asyncio.StreamWriter.transport
  • asyncio.StreamWriter.write()
  • asyncio.StreamWriter.writelines()
  • asyncio.StreamWriter.write_eof()
  • asyncio.SubprocessProtocol
  • asyncio.SubprocessProtocol.pipe_connection_lost()
  • asyncio.SubprocessProtocol.pipe_data_received()
  • asyncio.SubprocessProtocol.process_exited()
  • asyncio.Task
  • asyncio.Task.all_tasks()
  • asyncio.Task.cancel()
  • asyncio.Task.current_task()
  • asyncio.Task.get_stack()
  • asyncio.Task.print_stack()
  • asyncio.TimeoutError
  • asyncio.wait()
  • asyncio.wait_for()
  • asyncio.WriteTransport
  • asyncio.WriteTransport.abort()
  • asyncio.WriteTransport.can_write_eof()
  • asyncio.WriteTransport.get_write_buffer_limits()
  • asyncio.WriteTransport.get_write_buffer_size()
  • asyncio.WriteTransport.set_write_buffer_limits()
  • asyncio.WriteTransport.write()
  • asyncio.WriteTransport.writelines()
  • asyncio.WriteTransport.write_eof()
  • Base Event Loop
  • Develop with asyncio
  • Event loops
  • Queues
  • select
  • select.devpoll()
  • select.devpoll.close()
  • select.devpoll.closed
  • select.devpoll.fileno()
  • select.devpoll.modify()
  • select.devpoll.poll()
  • select.devpoll.register()
  • select.devpoll.unregister()
  • select.epoll()
  • select.epoll.close()
  • select.epoll.closed
  • select.epoll.fileno()
  • select.epoll.fromfd()
  • select.epoll.modify()
  • select.epoll.poll()
  • select.epoll.register()
  • select.epoll.unregister()
  • select.error
  • select.kevent()
  • select.kevent.data
  • select.kevent.fflags
  • select.kevent.filter
  • select.kevent.flags
  • select.kevent.ident
  • select.kevent.udata
  • select.kqueue()
  • select.kqueue.close()
  • select.kqueue.closed
  • select.kqueue.control()
  • select.kqueue.fileno()
  • select.kqueue.fromfd()
  • select.PIPE_BUF
  • select.poll()
  • select.poll.modify()
  • select.poll.poll()
  • select.poll.register()
  • select.poll.unregister()
  • select.select()
  • selectors
  • selectors.BaseSelector
  • selectors.BaseSelector.close()
  • selectors.BaseSelector.get_key()
  • selectors.BaseSelector.get_map()
  • selectors.BaseSelector.modify()
  • selectors.BaseSelector.register()
  • selectors.BaseSelector.select()
  • selectors.BaseSelector.unregister()
  • selectors.DefaultSelector
  • selectors.DevpollSelector
  • selectors.DevpollSelector.fileno()
  • selectors.EpollSelector
  • selectors.EpollSelector.fileno()
  • selectors.KqueueSelector
  • selectors.KqueueSelector.fileno()
  • selectors.PollSelector
  • selectors.SelectorKey
  • selectors.SelectorKey.data
  • selectors.SelectorKey.events
  • selectors.SelectorKey.fd
  • selectors.SelectorKey.fileobj
  • selectors.SelectSelector
  • Streams (coroutine based API)
  • Subprocess
  • Synchronization primitives
  • Tasks and coroutines
  • Transports and protocols (callback based API)
  • Internet Data

  • base64
  • base64.a85decode()
  • base64.a85encode()
  • base64.b16decode()
  • base64.b16encode()
  • base64.b32decode()
  • base64.b32encode()
  • base64.b64decode()
  • base64.b64encode()
  • base64.b85decode()
  • base64.b85encode()
  • base64.decode()
  • base64.decodebytes()
  • base64.decodestring()
  • base64.encode()
  • base64.encodebytes()
  • base64.encodestring()
  • base64.standard_b64decode()
  • base64.standard_b64encode()
  • base64.urlsafe_b64decode()
  • base64.urlsafe_b64encode()
  • binascii
  • binascii.a2b_base64()
  • binascii.a2b_hex()
  • binascii.a2b_hqx()
  • binascii.a2b_qp()
  • binascii.a2b_uu()
  • binascii.b2a_base64()
  • binascii.b2a_hex()
  • binascii.b2a_hqx()
  • binascii.b2a_qp()
  • binascii.b2a_uu()
  • binascii.crc32()
  • binascii.crc_hqx()
  • binascii.Error
  • binascii.hexlify()
  • binascii.Incomplete
  • binascii.rlecode_hqx()
  • binascii.rledecode_hqx()
  • binascii.unhexlify()
  • binhex
  • binhex.binhex()
  • binhex.Error
  • binhex.hexbin()
  • email
  • email.charset.add_alias()
  • email.charset.add_charset()
  • email.charset.add_codec()
  • email.charset.Charset
  • email.charset.Charset.body_encode()
  • email.charset.Charset.body_encoding
  • email.charset.Charset.get_body_encoding()
  • email.charset.Charset.get_output_charset()
  • email.charset.Charset.header_encode()
  • email.charset.Charset.header_encode_lines()
  • email.charset.Charset.header_encoding
  • email.charset.Charset.input_charset
  • email.charset.Charset.input_codec
  • email.charset.Charset.output_charset
  • email.charset.Charset.output_codec
  • email.charset.Charset.__eq__()
  • email.charset.Charset.__ne__()
  • email.charset.Charset.__str__()
  • email.charset: Representing character sets
  • email.contentmanager.ContentManager
  • email.contentmanager.ContentManager.add_get_handler()
  • email.contentmanager.ContentManager.add_set_handler()
  • email.contentmanager.ContentManager.get_content()
  • email.contentmanager.ContentManager.set_content()
  • email.contentmanager.get_content()
  • email.contentmanager.raw_data_manager
  • email.contentmanager.set_content()
  • email.contentmanager: Managing MIME Content
  • email.encoders.encode_7or8bit()
  • email.encoders.encode_base64()
  • email.encoders.encode_noop()
  • email.encoders.encode_quopri()
  • email.encoders: Encoders
  • email.errors.BoundaryError
  • email.errors.HeaderParseError
  • email.errors.MessageError
  • email.errors.MessageParseError
  • email.errors.MultipartConversionError
  • email.errors: Exception and Defect classes
  • email.generator.BytesGenerator
  • email.generator.BytesGenerator.clone()
  • email.generator.BytesGenerator.flatten()
  • email.generator.BytesGenerator.write()
  • email.generator.DecodedGenerator
  • email.generator.Generator
  • email.generator.Generator.clone()
  • email.generator.Generator.flatten()
  • email.generator.Generator.write()
  • email.generator: Generating MIME documents
  • email.header.decode_header()
  • email.header.Header
  • email.header.Header.append()
  • email.header.Header.encode()
  • email.header.Header.__eq__()
  • email.header.Header.__ne__()
  • email.header.Header.__str__()
  • email.header.make_header()
  • email.header: Internationalized headers
  • email.headerregistry.Address
  • email.headerregistry.Address.addr_spec
  • email.headerregistry.Address.display_name
  • email.headerregistry.Address.domain
  • email.headerregistry.Address.username
  • email.headerregistry.Address.__str__()
  • email.headerregistry.AddressHeader
  • email.headerregistry.AddressHeader.addresses
  • email.headerregistry.AddressHeader.groups
  • email.headerregistry.BaseHeader
  • email.headerregistry.BaseHeader.defects
  • email.headerregistry.BaseHeader.fold()
  • email.headerregistry.BaseHeader.max_count
  • email.headerregistry.BaseHeader.name
  • email.headerregistry.ContentDispositionHeader
  • email.headerregistry.ContentTransferEncoding
  • email.headerregistry.ContentTransferEncoding.cte
  • email.headerregistry.ContentTypeHeader
  • email.headerregistry.ContentTypeHeader.content_type
  • email.headerregistry.ContentTypeHeader.maintype
  • email.headerregistry.ContentTypeHeader.subtype
  • email.headerregistry.DateHeader
  • email.headerregistry.DateHeader.datetime
  • email.headerregistry.Group
  • email.headerregistry.Group.addresses
  • email.headerregistry.Group.display_name
  • email.headerregistry.Group.__str__()
  • email.headerregistry.HeaderRegistry
  • email.headerregistry.HeaderRegistry.map_to_type()
  • email.headerregistry.HeaderRegistry.__call__()
  • email.headerregistry.HeaderRegistry.__getitem__()
  • email.headerregistry.MIMEVersionHeader
  • email.headerregistry.MIMEVersionHeader.major
  • email.headerregistry.MIMEVersionHeader.minor
  • email.headerregistry.MIMEVersionHeader.version
  • email.headerregistry.ParameterizedMIMEHeader
  • email.headerregistry.ParameterizedMIMEHeader.params
  • email.headerregistry.SingleAddressHeader
  • email.headerregistry.SingleAddressHeader.address
  • email.headerregistry.UnstructuredHeader
  • email.headerregistry: Custom Header Objects
  • email.iterators.body_line_iterator()
  • email.iterators.typed_subpart_iterator()
  • email.iterators._structure()
  • email.iterators: Iterators
  • email.message.EmailMessage
  • email.message.EmailMessage.add_alternative()
  • email.message.EmailMessage.add_attachment()
  • email.message.EmailMessage.add_related()
  • email.message.EmailMessage.clear()
  • email.message.EmailMessage.clear_content()
  • email.message.EmailMessage.get_body()
  • email.message.EmailMessage.get_content()
  • email.message.EmailMessage.is_attachment()
  • email.message.EmailMessage.iter_attachments()
  • email.message.EmailMessage.iter_parts()
  • email.message.EmailMessage.make_alternative()
  • email.message.EmailMessage.make_mixed()
  • email.message.EmailMessage.make_related()
  • email.message.EmailMessage.set_content()
  • email.message.Message
  • email.message.Message.add_header()
  • email.message.Message.as_bytes()
  • email.message.Message.as_string()
  • email.message.Message.attach()
  • email.message.Message.defects
  • email.message.Message.del_param()
  • email.message.Message.epilogue
  • email.message.Message.get()
  • email.message.Message.get_all()
  • email.message.Message.get_boundary()
  • email.message.Message.get_charset()
  • email.message.Message.get_charsets()
  • email.message.Message.get_content_charset()
  • email.message.Message.get_content_disposition()
  • email.message.Message.get_content_maintype()
  • email.message.Message.get_content_subtype()
  • email.message.Message.get_content_type()
  • email.message.Message.get_default_type()
  • email.message.Message.get_filename()
  • email.message.Message.get_param()
  • email.message.Message.get_params()
  • email.message.Message.get_payload()
  • email.message.Message.get_unixfrom()
  • email.message.Message.is_multipart()
  • email.message.Message.items()
  • email.message.Message.keys()
  • email.message.Message.preamble
  • email.message.Message.replace_header()
  • email.message.Message.set_boundary()
  • email.message.Message.set_charset()
  • email.message.Message.set_default_type()
  • email.message.Message.set_param()
  • email.message.Message.set_payload()
  • email.message.Message.set_type()
  • email.message.Message.set_unixfrom()
  • email.message.Message.values()
  • email.message.Message.walk()
  • email.message.Message.__bytes__()
  • email.message.Message.__contains__()
  • email.message.Message.__delitem__()
  • email.message.Message.__getitem__()
  • email.message.Message.__len__()
  • email.message.Message.__setitem__()
  • email.message.Message.__str__()
  • email.message.MIMEPart
  • email.message: Representing an email message
  • email.message_from_binary_file()
  • email.message_from_bytes()
  • email.message_from_file()
  • email.message_from_string()
  • email.mime.application.MIMEApplication
  • email.mime.audio.MIMEAudio
  • email.mime.base.MIMEBase
  • email.mime.image.MIMEImage
  • email.mime.message.MIMEMessage
  • email.mime.multipart.MIMEMultipart
  • email.mime.nonmultipart.MIMENonMultipart
  • email.mime.text.MIMEText
  • email.mime: Creating email and MIME objects from scratch
  • email.parser.BytesFeedParser
  • email.parser.BytesParser
  • email.parser.BytesParser.parse()
  • email.parser.BytesParser.parsebytes()
  • email.parser.FeedParser
  • email.parser.FeedParser.close()
  • email.parser.FeedParser.feed()
  • email.parser.Parser
  • email.parser.Parser.parse()
  • email.parser.Parser.parsestr()
  • email.parser: Parsing email messages
  • email.policy.compat32
  • email.policy.Compat32.fold()
  • email.policy.Compat32.fold_binary()
  • email.policy.Compat32.header_fetch_parse()
  • email.policy.Compat32.header_source_parse()
  • email.policy.Compat32.header_store_parse()
  • email.policy.Compat32.mangle_from_
  • email.policy.default
  • email.policy.EmailPolicy
  • email.policy.EmailPolicy.content_manager
  • email.policy.EmailPolicy.fold()
  • email.policy.EmailPolicy.fold_binary()
  • email.policy.EmailPolicy.header_factory
  • email.policy.EmailPolicy.header_fetch_parse()
  • email.policy.EmailPolicy.header_max_count()
  • email.policy.EmailPolicy.header_source_parse()
  • email.policy.EmailPolicy.header_store_parse()
  • email.policy.EmailPolicy.refold_source
  • email.policy.EmailPolicy.utf8
  • email.policy.Policy
  • email.policy.Policy.clone()
  • email.policy.Policy.cte_type
  • email.policy.Policy.fold()
  • email.policy.Policy.fold_binary()
  • email.policy.Policy.handle_defect()
  • email.policy.Policy.header_fetch_parse()
  • email.policy.Policy.header_max_count()
  • email.policy.Policy.header_source_parse()
  • email.policy.Policy.header_store_parse()
  • email.policy.Policy.linesep
  • email.policy.Policy.mangle_from_
  • email.policy.Policy.max_line_length
  • email.policy.Policy.raise_on_defect
  • email.policy.Policy.register_defect()
  • email.policy.strict
  • email.policy: Policy Objects
  • email.utils.collapse_rfc2231_value()
  • email.utils.decode_params()
  • email.utils.decode_rfc2231()
  • email.utils.encode_rfc2231()
  • email.utils.formataddr()
  • email.utils.formatdate()
  • email.utils.format_datetime()
  • email.utils.getaddresses()
  • email.utils.localtime()
  • email.utils.make_msgid()
  • email.utils.mktime_tz()
  • email.utils.parseaddr()
  • email.utils.parsedate()
  • email.utils.parsedate_to_datetime()
  • email.utils.parsedate_tz()
  • email.utils.quote()
  • email.utils.unquote()
  • email.utils: Miscellaneous utilities
  • email: Examples
  • json
  • json.dump()
  • json.dumps()
  • json.JSONDecodeError
  • json.JSONDecodeError.colno
  • json.JSONDecodeError.doc
  • json.JSONDecodeError.lineno
  • json.JSONDecodeError.msg
  • json.JSONDecodeError.pos
  • json.JSONDecoder
  • json.JSONDecoder.decode()
  • json.JSONDecoder.raw_decode()
  • json.JSONEncoder
  • json.JSONEncoder.default()
  • json.JSONEncoder.encode()
  • json.JSONEncoder.iterencode()
  • json.load()
  • json.loads()
  • mailbox
  • mailbox.Babyl
  • mailbox.Babyl.get_file()
  • mailbox.Babyl.get_labels()
  • mailbox.Babyl.lock()
  • mailbox.Babyl.unlock()
  • mailbox.BabylMessage
  • mailbox.BabylMessage.add_label()
  • mailbox.BabylMessage.get_labels()
  • mailbox.BabylMessage.get_visible()
  • mailbox.BabylMessage.remove_label()
  • mailbox.BabylMessage.set_labels()
  • mailbox.BabylMessage.set_visible()
  • mailbox.BabylMessage.update_visible()
  • mailbox.Error
  • mailbox.ExternalClashError
  • mailbox.FormatError
  • mailbox.Mailbox
  • mailbox.Mailbox.add()
  • mailbox.Mailbox.clear()
  • mailbox.Mailbox.close()
  • mailbox.Mailbox.discard()
  • mailbox.Mailbox.flush()
  • mailbox.Mailbox.get()
  • mailbox.Mailbox.get_bytes()
  • mailbox.Mailbox.get_file()
  • mailbox.Mailbox.get_message()
  • mailbox.Mailbox.get_string()
  • mailbox.Mailbox.items()
  • mailbox.Mailbox.iteritems()
  • mailbox.Mailbox.iterkeys()
  • mailbox.Mailbox.itervalues()
  • mailbox.Mailbox.keys()
  • mailbox.Mailbox.lock()
  • mailbox.Mailbox.pop()
  • mailbox.Mailbox.popitem()
  • mailbox.Mailbox.remove()
  • mailbox.Mailbox.unlock()
  • mailbox.Mailbox.update()
  • mailbox.Mailbox.values()
  • mailbox.Mailbox.__contains__()
  • mailbox.Mailbox.__delitem__()
  • mailbox.Mailbox.__getitem__()
  • mailbox.Mailbox.__iter__()
  • mailbox.Mailbox.__len__()
  • mailbox.Mailbox.__setitem__()
  • mailbox.Maildir
  • mailbox.Maildir.add()
  • mailbox.Maildir.add_folder()
  • mailbox.Maildir.clean()
  • mailbox.Maildir.close()
  • mailbox.Maildir.flush()
  • mailbox.Maildir.get_file()
  • mailbox.Maildir.get_folder()
  • mailbox.Maildir.list_folders()
  • mailbox.Maildir.lock()
  • mailbox.Maildir.remove_folder()
  • mailbox.Maildir.unlock()
  • mailbox.Maildir.update()
  • mailbox.Maildir.__setitem__()
  • mailbox.MaildirMessage
  • mailbox.MaildirMessage.add_flag()
  • mailbox.MaildirMessage.get_date()
  • mailbox.MaildirMessage.get_flags()
  • mailbox.MaildirMessage.get_info()
  • mailbox.MaildirMessage.get_subdir()
  • mailbox.MaildirMessage.remove_flag()
  • mailbox.MaildirMessage.set_date()
  • mailbox.MaildirMessage.set_flags()
  • mailbox.MaildirMessage.set_info()
  • mailbox.MaildirMessage.set_subdir()
  • mailbox.mbox
  • mailbox.mbox.get_file()
  • mailbox.mbox.lock()
  • mailbox.mbox.unlock()
  • mailbox.mboxMessage
  • mailbox.mboxMessage.add_flag()
  • mailbox.mboxMessage.get_flags()
  • mailbox.mboxMessage.get_from()
  • mailbox.mboxMessage.remove_flag()
  • mailbox.mboxMessage.set_flags()
  • mailbox.mboxMessage.set_from()
  • mailbox.Message
  • mailbox.MH
  • mailbox.MH.add_folder()
  • mailbox.MH.close()
  • mailbox.MH.discard()
  • mailbox.MH.flush()
  • mailbox.MH.get_file()
  • mailbox.MH.get_folder()
  • mailbox.MH.get_sequences()
  • mailbox.MH.list_folders()
  • mailbox.MH.lock()
  • mailbox.MH.pack()
  • mailbox.MH.remove()
  • mailbox.MH.remove_folder()
  • mailbox.MH.set_sequences()
  • mailbox.MH.unlock()
  • mailbox.MH.__delitem__()
  • mailbox.MHMessage
  • mailbox.MHMessage.add_sequence()
  • mailbox.MHMessage.get_sequences()
  • mailbox.MHMessage.remove_sequence()
  • mailbox.MHMessage.set_sequences()
  • mailbox.MMDF
  • mailbox.MMDF.get_file()
  • mailbox.MMDF.lock()
  • mailbox.MMDF.unlock()
  • mailbox.MMDFMessage
  • mailbox.MMDFMessage.add_flag()
  • mailbox.MMDFMessage.get_flags()
  • mailbox.MMDFMessage.get_from()
  • mailbox.MMDFMessage.remove_flag()
  • mailbox.MMDFMessage.set_flags()
  • mailbox.MMDFMessage.set_from()
  • mailbox.NoSuchMailboxError
  • mailbox.NotEmptyError
  • mailcap
  • mailcap.findmatch()
  • mailcap.getcaps()
  • mimetypes
  • mimetypes.add_type()
  • mimetypes.common_types
  • mimetypes.encodings_map
  • mimetypes.guess_all_extensions()
  • mimetypes.guess_extension()
  • mimetypes.guess_type()
  • mimetypes.init()
  • mimetypes.inited
  • mimetypes.knownfiles
  • mimetypes.MimeTypes
  • mimetypes.MimeTypes.encodings_map
  • mimetypes.MimeTypes.guess_all_extensions()
  • mimetypes.MimeTypes.guess_extension()
  • mimetypes.MimeTypes.guess_type()
  • mimetypes.MimeTypes.read()
  • mimetypes.MimeTypes.readfp()
  • mimetypes.MimeTypes.read_windows_registry()
  • mimetypes.MimeTypes.suffix_map
  • mimetypes.MimeTypes.types_map
  • mimetypes.MimeTypes.types_map_inv
  • mimetypes.read_mime_types()
  • mimetypes.suffix_map
  • mimetypes.types_map
  • quopri
  • quopri.decode()
  • quopri.decodestring()
  • quopri.encode()
  • quopri.encodestring()
  • uu
  • uu.decode()
  • uu.encode()
  • uu.Error
  • Debugging & Profiling

  • bdb
  • bdb.Bdb
  • bdb.Bdb.break_anywhere()
  • bdb.Bdb.break_here()
  • bdb.Bdb.canonic()
  • bdb.Bdb.clear_all_breaks()
  • bdb.Bdb.clear_all_file_breaks()
  • bdb.Bdb.clear_bpbynumber()
  • bdb.Bdb.clear_break()
  • bdb.Bdb.dispatch_call()
  • bdb.Bdb.dispatch_exception()
  • bdb.Bdb.dispatch_line()
  • bdb.Bdb.dispatch_return()
  • bdb.Bdb.do_clear()
  • bdb.Bdb.format_stack_entry()
  • bdb.Bdb.get_all_breaks()
  • bdb.Bdb.get_bpbynumber()
  • bdb.Bdb.get_break()
  • bdb.Bdb.get_breaks()
  • bdb.Bdb.get_file_breaks()
  • bdb.Bdb.get_stack()
  • bdb.Bdb.reset()
  • bdb.Bdb.run()
  • bdb.Bdb.runcall()
  • bdb.Bdb.runctx()
  • bdb.Bdb.runeval()
  • bdb.Bdb.set_break()
  • bdb.Bdb.set_continue()
  • bdb.Bdb.set_next()
  • bdb.Bdb.set_quit()
  • bdb.Bdb.set_return()
  • bdb.Bdb.set_step()
  • bdb.Bdb.set_trace()
  • bdb.Bdb.set_until()
  • bdb.Bdb.stop_here()
  • bdb.Bdb.trace_dispatch()
  • bdb.Bdb.user_call()
  • bdb.Bdb.user_exception()
  • bdb.Bdb.user_line()
  • bdb.Bdb.user_return()
  • bdb.BdbQuit
  • bdb.Breakpoint
  • bdb.Breakpoint.bpformat()
  • bdb.Breakpoint.bpprint()
  • bdb.Breakpoint.deleteMe()
  • bdb.Breakpoint.disable()
  • bdb.Breakpoint.enable()
  • bdb.checkfuncname()
  • bdb.effective()
  • bdb.set_trace()
  • faulthandler
  • faulthandler.cancel_dump_traceback_later()
  • faulthandler.disable()
  • faulthandler.dump_traceback()
  • faulthandler.dump_traceback_later()
  • faulthandler.enable()
  • faulthandler.is_enabled()
  • faulthandler.register()
  • faulthandler.unregister()
  • pdb
  • pdb.Pdb
  • pdb.Pdb.run()
  • pdb.Pdb.runcall()
  • pdb.Pdb.runeval()
  • pdb.Pdb.set_trace()
  • pdb.pm()
  • pdb.post_mortem()
  • pdb.run()
  • pdb.runcall()
  • pdb.runeval()
  • pdb.set_trace()
  • profile.Profile
  • profile.Profile.create_stats()
  • profile.Profile.disable()
  • profile.Profile.dump_stats()
  • profile.Profile.enable()
  • profile.Profile.print_stats()
  • profile.Profile.run()
  • profile.Profile.runcall()
  • profile.Profile.runctx()
  • profile.run()
  • profile.runctx()
  • pstats.Stats
  • pstats.Stats.add()
  • pstats.Stats.dump_stats()
  • pstats.Stats.print_callees()
  • pstats.Stats.print_callers()
  • pstats.Stats.print_stats()
  • pstats.Stats.reverse_order()
  • pstats.Stats.sort_stats()
  • pstats.Stats.strip_dirs()
  • The Python Profilers
  • timeit
  • timeit.default_timer()
  • timeit.repeat()
  • timeit.timeit()
  • timeit.Timer
  • timeit.Timer.print_exc()
  • timeit.Timer.repeat()
  • timeit.Timer.timeit()
  • trace
  • trace.CoverageResults
  • trace.CoverageResults.update()
  • trace.CoverageResults.write_results()
  • trace.Trace
  • trace.Trace.results()
  • trace.Trace.run()
  • trace.Trace.runctx()
  • trace.Trace.runfunc()
  • tracemalloc
  • tracemalloc.clear_traces()
  • tracemalloc.Filter
  • tracemalloc.Filter.all_frames
  • tracemalloc.Filter.filename_pattern
  • tracemalloc.Filter.inclusive
  • tracemalloc.Filter.lineno
  • tracemalloc.Frame
  • tracemalloc.Frame.filename
  • tracemalloc.Frame.lineno
  • tracemalloc.get_object_traceback()
  • tracemalloc.get_traceback_limit()
  • tracemalloc.get_traced_memory()
  • tracemalloc.get_tracemalloc_memory()
  • tracemalloc.is_tracing()
  • tracemalloc.Snapshot
  • tracemalloc.Snapshot.compare_to()
  • tracemalloc.Snapshot.dump()
  • tracemalloc.Snapshot.filter_traces()
  • tracemalloc.Snapshot.load()
  • tracemalloc.Snapshot.statistics()
  • tracemalloc.Snapshot.traceback_limit
  • tracemalloc.Snapshot.traces
  • tracemalloc.start()
  • tracemalloc.Statistic
  • tracemalloc.Statistic.count
  • tracemalloc.Statistic.size
  • tracemalloc.Statistic.traceback
  • tracemalloc.StatisticDiff
  • tracemalloc.StatisticDiff.count
  • tracemalloc.StatisticDiff.count_diff
  • tracemalloc.StatisticDiff.size
  • tracemalloc.StatisticDiff.size_diff
  • tracemalloc.StatisticDiff.traceback
  • tracemalloc.stop()
  • tracemalloc.take_snapshot()
  • tracemalloc.Trace
  • tracemalloc.Trace.size
  • tracemalloc.Trace.traceback
  • tracemalloc.Traceback
  • tracemalloc.Traceback.format()
  • Built-in Types

  • bytearray.capitalize()
  • bytearray.center()
  • bytearray.count()
  • bytearray.decode()
  • bytearray.endswith()
  • bytearray.expandtabs()
  • bytearray.find()
  • bytearray.fromhex()
  • bytearray.hex()
  • bytearray.index()
  • bytearray.isalnum()
  • bytearray.isalpha()
  • bytearray.isdigit()
  • bytearray.islower()
  • bytearray.isspace()
  • bytearray.istitle()
  • bytearray.isupper()
  • bytearray.join()
  • bytearray.ljust()
  • bytearray.lower()
  • bytearray.lstrip()
  • bytearray.maketrans()
  • bytearray.partition()
  • bytearray.replace()
  • bytearray.rfind()
  • bytearray.rindex()
  • bytearray.rjust()
  • bytearray.rpartition()
  • bytearray.rsplit()
  • bytearray.rstrip()
  • bytearray.split()
  • bytearray.splitlines()
  • bytearray.startswith()
  • bytearray.strip()
  • bytearray.swapcase()
  • bytearray.title()
  • bytearray.translate()
  • bytearray.upper()
  • bytearray.zfill()
  • bytes.capitalize()
  • bytes.center()
  • bytes.count()
  • bytes.decode()
  • bytes.endswith()
  • bytes.expandtabs()
  • bytes.find()
  • bytes.fromhex()
  • bytes.hex()
  • bytes.index()
  • bytes.isalnum()
  • bytes.isalpha()
  • bytes.isdigit()
  • bytes.islower()
  • bytes.isspace()
  • bytes.istitle()
  • bytes.isupper()
  • bytes.join()
  • bytes.ljust()
  • bytes.lower()
  • bytes.lstrip()
  • bytes.maketrans()
  • bytes.partition()
  • bytes.replace()
  • bytes.rfind()
  • bytes.rindex()
  • bytes.rjust()
  • bytes.rpartition()
  • bytes.rsplit()
  • bytes.rstrip()
  • bytes.split()
  • bytes.splitlines()
  • bytes.startswith()
  • bytes.strip()
  • bytes.swapcase()
  • bytes.title()
  • bytes.translate()
  • bytes.upper()
  • bytes.zfill()
  • class.mro()
  • class.__bases__
  • class.__mro__
  • class.__subclasses__()
  • container.__iter__()
  • contextmanager.__enter__()
  • contextmanager.__exit__()
  • definition.__name__
  • definition.__qualname__
  • dict
  • dict.clear()
  • dict.copy()
  • dict.fromkeys()
  • dict.get()
  • dict.items()
  • dict.keys()
  • dict.pop()
  • dict.popitem()
  • dict.setdefault()
  • dict.update()
  • dict.values()
  • float.as_integer_ratio()
  • float.fromhex()
  • float.hex()
  • float.is_integer()
  • frozenset
  • instance.__class__
  • int.bit_length()
  • int.from_bytes()
  • int.to_bytes()
  • iterator.__iter__()
  • iterator.__next__()
  • list
  • list.sort()
  • memoryview
  • memoryview.cast()
  • memoryview.contiguous
  • memoryview.c_contiguous
  • memoryview.format
  • memoryview.f_contiguous
  • memoryview.hex()
  • memoryview.itemsize
  • memoryview.nbytes
  • memoryview.ndim
  • memoryview.obj
  • memoryview.readonly
  • memoryview.release()
  • memoryview.shape
  • memoryview.strides
  • memoryview.suboffsets
  • memoryview.tobytes()
  • memoryview.tolist()
  • memoryview.__eq__()
  • object.__dict__
  • range
  • range.start
  • range.step
  • range.stop
  • set
  • set.add()
  • set.clear()
  • set.copy()
  • set.difference()
  • set.difference_update()
  • set.discard()
  • set.intersection()
  • set.intersection_update()
  • set.isdisjoint()
  • set.issubset()
  • set.issuperset()
  • set.pop()
  • set.remove()
  • set.symmetric_difference()
  • set.symmetric_difference_update()
  • set.union()
  • set.update()
  • str
  • str.capitalize()
  • str.casefold()
  • str.center()
  • str.count()
  • str.encode()
  • str.endswith()
  • str.expandtabs()
  • str.find()
  • str.format()
  • str.format_map()
  • str.index()
  • str.isalnum()
  • str.isalpha()
  • str.isdecimal()
  • str.isdigit()
  • str.isidentifier()
  • str.islower()
  • str.isnumeric()
  • str.isprintable()
  • str.isspace()
  • str.istitle()
  • str.isupper()
  • str.join()
  • str.ljust()
  • str.lower()
  • str.lstrip()
  • str.maketrans()
  • str.partition()
  • str.replace()
  • str.rfind()
  • str.rindex()
  • str.rjust()
  • str.rpartition()
  • str.rsplit()
  • str.rstrip()
  • str.split()
  • str.splitlines()
  • str.startswith()
  • str.strip()
  • str.swapcase()
  • str.title()
  • str.translate()
  • str.upper()
  • str.zfill()
  • tuple
  • Types
  • Data Compression

  • bz2
  • bz2.BZ2Compressor
  • bz2.BZ2Compressor.compress()
  • bz2.BZ2Compressor.flush()
  • bz2.BZ2Decompressor
  • bz2.BZ2Decompressor.decompress()
  • bz2.BZ2Decompressor.eof
  • bz2.BZ2Decompressor.needs_input
  • bz2.BZ2Decompressor.unused_data
  • bz2.BZ2File
  • bz2.BZ2File.peek()
  • bz2.compress()
  • bz2.decompress()
  • bz2.open()
  • gzip
  • gzip.compress()
  • gzip.decompress()
  • gzip.GzipFile
  • gzip.GzipFile.mtime
  • gzip.GzipFile.peek()
  • gzip.open()
  • lzma
  • lzma.compress()
  • lzma.decompress()
  • lzma.is_check_supported()
  • lzma.LZMACompressor
  • lzma.LZMACompressor.compress()
  • lzma.LZMACompressor.flush()
  • lzma.LZMADecompressor
  • lzma.LZMADecompressor.check
  • lzma.LZMADecompressor.decompress()
  • lzma.LZMADecompressor.eof
  • lzma.LZMADecompressor.needs_input
  • lzma.LZMADecompressor.unused_data
  • lzma.LZMAError
  • lzma.LZMAFile
  • lzma.LZMAFile.peek()
  • lzma.open()
  • tarfile
  • tarfile.CompressionError
  • tarfile.ExtractError
  • tarfile.HeaderError
  • tarfile.is_tarfile()
  • tarfile.open()
  • tarfile.ReadError
  • tarfile.StreamError
  • tarfile.TarError
  • tarfile.TarFile
  • tarfile.TarFile.add()
  • tarfile.TarFile.addfile()
  • tarfile.TarFile.close()
  • tarfile.TarFile.extract()
  • tarfile.TarFile.extractall()
  • tarfile.TarFile.extractfile()
  • tarfile.TarFile.getmember()
  • tarfile.TarFile.getmembers()
  • tarfile.TarFile.getnames()
  • tarfile.TarFile.gettarinfo()
  • tarfile.TarFile.list()
  • tarfile.TarFile.next()
  • tarfile.TarFile.open()
  • tarfile.TarFile.pax_headers
  • tarfile.TarInfo
  • tarfile.TarInfo.frombuf()
  • tarfile.TarInfo.fromtarfile()
  • tarfile.TarInfo.gid
  • tarfile.TarInfo.gname
  • tarfile.TarInfo.isblk()
  • tarfile.TarInfo.ischr()
  • tarfile.TarInfo.isdev()
  • tarfile.TarInfo.isdir()
  • tarfile.TarInfo.isfifo()
  • tarfile.TarInfo.isfile()
  • tarfile.TarInfo.islnk()
  • tarfile.TarInfo.isreg()
  • tarfile.TarInfo.issym()
  • tarfile.TarInfo.linkname
  • tarfile.TarInfo.mode
  • tarfile.TarInfo.mtime
  • tarfile.TarInfo.name
  • tarfile.TarInfo.pax_headers
  • tarfile.TarInfo.size
  • tarfile.TarInfo.tobuf()
  • tarfile.TarInfo.type
  • tarfile.TarInfo.uid
  • tarfile.TarInfo.uname
  • zipfile
  • zipfile.BadZipFile
  • zipfile.is_zipfile()
  • zipfile.LargeZipFile
  • zipfile.PyZipFile
  • zipfile.PyZipFile.writepy()
  • zipfile.ZipFile
  • zipfile.ZipFile.close()
  • zipfile.ZipFile.comment
  • zipfile.ZipFile.debug
  • zipfile.ZipFile.extract()
  • zipfile.ZipFile.extractall()
  • zipfile.ZipFile.getinfo()
  • zipfile.ZipFile.infolist()
  • zipfile.ZipFile.namelist()
  • zipfile.ZipFile.open()
  • zipfile.ZipFile.printdir()
  • zipfile.ZipFile.read()
  • zipfile.ZipFile.setpassword()
  • zipfile.ZipFile.testzip()
  • zipfile.ZipFile.write()
  • zipfile.ZipFile.writestr()
  • zipfile.ZipInfo
  • zipfile.ZipInfo.comment
  • zipfile.ZipInfo.compress_size
  • zipfile.ZipInfo.compress_type
  • zipfile.ZipInfo.CRC
  • zipfile.ZipInfo.create_system
  • zipfile.ZipInfo.create_version
  • zipfile.ZipInfo.date_time
  • zipfile.ZipInfo.external_attr
  • zipfile.ZipInfo.extra
  • zipfile.ZipInfo.extract_version
  • zipfile.ZipInfo.filename
  • zipfile.ZipInfo.file_size
  • zipfile.ZipInfo.flag_bits
  • zipfile.ZipInfo.header_offset
  • zipfile.ZipInfo.internal_attr
  • zipfile.ZipInfo.reserved
  • zipfile.ZipInfo.volume
  • zlib
  • zlib.adler32()
  • zlib.compress()
  • zlib.Compress.compress()
  • zlib.Compress.copy()
  • zlib.Compress.flush()
  • zlib.compressobj()
  • zlib.crc32()
  • zlib.decompress()
  • zlib.Decompress.copy()
  • zlib.Decompress.decompress()
  • zlib.Decompress.eof
  • zlib.Decompress.flush()
  • zlib.Decompress.unconsumed_tail
  • zlib.Decompress.unused_data
  • zlib.decompressobj()
  • zlib.error
  • Internet

  • cgi
  • cgi.escape()
  • cgi.FieldStorage.getfirst()
  • cgi.FieldStorage.getlist()
  • cgi.parse()
  • cgi.parse_header()
  • cgi.parse_multipart()
  • cgi.parse_qs()
  • cgi.parse_qsl()
  • cgi.print_directory()
  • cgi.print_environ()
  • cgi.print_environ_usage()
  • cgi.print_form()
  • cgi.test()
  • cgitb
  • cgitb.enable()
  • cgitb.handler()
  • ftplib
  • ftplib.all_errors
  • ftplib.error_perm
  • ftplib.error_proto
  • ftplib.error_reply
  • ftplib.error_temp
  • ftplib.FTP
  • ftplib.FTP.abort()
  • ftplib.FTP.close()
  • ftplib.FTP.connect()
  • ftplib.FTP.cwd()
  • ftplib.FTP.delete()
  • ftplib.FTP.dir()
  • ftplib.FTP.getwelcome()
  • ftplib.FTP.login()
  • ftplib.FTP.mkd()
  • ftplib.FTP.mlsd()
  • ftplib.FTP.nlst()
  • ftplib.FTP.ntransfercmd()
  • ftplib.FTP.pwd()
  • ftplib.FTP.quit()
  • ftplib.FTP.rename()
  • ftplib.FTP.retrbinary()
  • ftplib.FTP.retrlines()
  • ftplib.FTP.rmd()
  • ftplib.FTP.sendcmd()
  • ftplib.FTP.set_debuglevel()
  • ftplib.FTP.set_pasv()
  • ftplib.FTP.size()
  • ftplib.FTP.storbinary()
  • ftplib.FTP.storlines()
  • ftplib.FTP.transfercmd()
  • ftplib.FTP.voidcmd()
  • ftplib.FTP_TLS
  • ftplib.FTP_TLS.auth()
  • ftplib.FTP_TLS.ccc()
  • ftplib.FTP_TLS.prot_c()
  • ftplib.FTP_TLS.prot_p()
  • ftplib.FTP_TLS.ssl_version
  • http
  • http.client
  • http.client.BadStatusLine
  • http.client.CannotSendHeader
  • http.client.CannotSendRequest
  • http.client.HTTPConnection
  • http.client.HTTPConnection.close()
  • http.client.HTTPConnection.connect()
  • http.client.HTTPConnection.endheaders()
  • http.client.HTTPConnection.getresponse()
  • http.client.HTTPConnection.putheader()
  • http.client.HTTPConnection.putrequest()
  • http.client.HTTPConnection.request()
  • http.client.HTTPConnection.send()
  • http.client.HTTPConnection.set_debuglevel()
  • http.client.HTTPConnection.set_tunnel()
  • http.client.HTTPException
  • http.client.HTTPResponse
  • http.client.HTTPResponse.closed
  • http.client.HTTPResponse.debuglevel
  • http.client.HTTPResponse.fileno()
  • http.client.HTTPResponse.getheader()
  • http.client.HTTPResponse.getheaders()
  • http.client.HTTPResponse.msg
  • http.client.HTTPResponse.read()
  • http.client.HTTPResponse.readinto()
  • http.client.HTTPResponse.reason
  • http.client.HTTPResponse.status
  • http.client.HTTPResponse.version
  • http.client.HTTPSConnection
  • http.client.ImproperConnectionState
  • http.client.IncompleteRead
  • http.client.InvalidURL
  • http.client.LineTooLong
  • http.client.NotConnected
  • http.client.RemoteDisconnected
  • http.client.ResponseNotReady
  • http.client.responses
  • http.client.UnimplementedFileMode
  • http.client.UnknownProtocol
  • http.client.UnknownTransferEncoding
  • http.cookiejar
  • http.cookiejar.Cookie
  • http.cookiejar.Cookie.comment
  • http.cookiejar.Cookie.comment_url
  • http.cookiejar.Cookie.discard
  • http.cookiejar.Cookie.domain_initial_dot
  • http.cookiejar.Cookie.domain_specified
  • http.cookiejar.Cookie.expires
  • http.cookiejar.Cookie.get_nonstandard_attr()
  • http.cookiejar.Cookie.has_nonstandard_attr()
  • http.cookiejar.Cookie.is_expired()
  • http.cookiejar.Cookie.name
  • http.cookiejar.Cookie.path
  • http.cookiejar.Cookie.port
  • http.cookiejar.Cookie.port_specified
  • http.cookiejar.Cookie.rfc2109
  • http.cookiejar.Cookie.secure
  • http.cookiejar.Cookie.set_nonstandard_attr()
  • http.cookiejar.Cookie.value
  • http.cookiejar.Cookie.version
  • http.cookiejar.CookieJar
  • http.cookiejar.CookieJar.add_cookie_header()
  • http.cookiejar.CookieJar.clear()
  • http.cookiejar.CookieJar.clear_session_cookies()
  • http.cookiejar.CookieJar.extract_cookies()
  • http.cookiejar.CookieJar.make_cookies()
  • http.cookiejar.CookieJar.set_cookie()
  • http.cookiejar.CookieJar.set_cookie_if_ok()
  • http.cookiejar.CookieJar.set_policy()
  • http.cookiejar.CookiePolicy
  • http.cookiejar.CookiePolicy.domain_return_ok()
  • http.cookiejar.CookiePolicy.hide_cookie2
  • http.cookiejar.CookiePolicy.netscape
  • http.cookiejar.CookiePolicy.path_return_ok()
  • http.cookiejar.CookiePolicy.return_ok()
  • http.cookiejar.CookiePolicy.rfc2965
  • http.cookiejar.CookiePolicy.set_ok()
  • http.cookiejar.DefaultCookiePolicy
  • http.cookiejar.DefaultCookiePolicy.allowed_domains()
  • http.cookiejar.DefaultCookiePolicy.blocked_domains()
  • http.cookiejar.DefaultCookiePolicy.DomainLiberal
  • http.cookiejar.DefaultCookiePolicy.DomainRFC2965Match
  • http.cookiejar.DefaultCookiePolicy.DomainStrict
  • http.cookiejar.DefaultCookiePolicy.DomainStrictNoDots
  • http.cookiejar.DefaultCookiePolicy.DomainStrictNonDomain
  • http.cookiejar.DefaultCookiePolicy.is_blocked()
  • http.cookiejar.DefaultCookiePolicy.is_not_allowed()
  • http.cookiejar.DefaultCookiePolicy.rfc2109_as_netscape
  • http.cookiejar.DefaultCookiePolicy.set_allowed_domains()
  • http.cookiejar.DefaultCookiePolicy.set_blocked_domains()
  • http.cookiejar.DefaultCookiePolicy.strict_domain
  • http.cookiejar.DefaultCookiePolicy.strict_ns_domain
  • http.cookiejar.DefaultCookiePolicy.strict_ns_set_initial_dollar
  • http.cookiejar.DefaultCookiePolicy.strict_ns_set_path
  • http.cookiejar.DefaultCookiePolicy.strict_ns_unverifiable
  • http.cookiejar.DefaultCookiePolicy.strict_rfc2965_unverifiable
  • http.cookiejar.FileCookieJar
  • http.cookiejar.FileCookieJar.delayload
  • http.cookiejar.FileCookieJar.filename
  • http.cookiejar.FileCookieJar.load()
  • http.cookiejar.FileCookieJar.revert()
  • http.cookiejar.FileCookieJar.save()
  • http.cookiejar.LoadError
  • http.cookiejar.LWPCookieJar
  • http.cookiejar.MozillaCookieJar
  • http.cookies
  • http.cookies.BaseCookie
  • http.cookies.BaseCookie.js_output()
  • http.cookies.BaseCookie.load()
  • http.cookies.BaseCookie.output()
  • http.cookies.BaseCookie.value_decode()
  • http.cookies.BaseCookie.value_encode()
  • http.cookies.CookieError
  • http.cookies.Morsel
  • http.cookies.Morsel.coded_value
  • http.cookies.Morsel.copy()
  • http.cookies.Morsel.isReservedKey()
  • http.cookies.Morsel.js_output()
  • http.cookies.Morsel.key
  • http.cookies.Morsel.output()
  • http.cookies.Morsel.OutputString()
  • http.cookies.Morsel.set()
  • http.cookies.Morsel.setdefault()
  • http.cookies.Morsel.update()
  • http.cookies.Morsel.value
  • http.cookies.SimpleCookie
  • http.HTTPStatus
  • http.server
  • http.server.BaseHTTPRequestHandler
  • http.server.BaseHTTPRequestHandler.address_string()
  • http.server.BaseHTTPRequestHandler.client_address
  • http.server.BaseHTTPRequestHandler.close_connection
  • http.server.BaseHTTPRequestHandler.command
  • http.server.BaseHTTPRequestHandler.date_time_string()
  • http.server.BaseHTTPRequestHandler.end_headers()
  • http.server.BaseHTTPRequestHandler.error_content_type
  • http.server.BaseHTTPRequestHandler.error_message_format
  • http.server.BaseHTTPRequestHandler.flush_headers()
  • http.server.BaseHTTPRequestHandler.handle()
  • http.server.BaseHTTPRequestHandler.handle_expect_100()
  • http.server.BaseHTTPRequestHandler.handle_one_request()
  • http.server.BaseHTTPRequestHandler.headers
  • http.server.BaseHTTPRequestHandler.log_date_time_string()
  • http.server.BaseHTTPRequestHandler.log_error()
  • http.server.BaseHTTPRequestHandler.log_message()
  • http.server.BaseHTTPRequestHandler.log_request()
  • http.server.BaseHTTPRequestHandler.MessageClass
  • http.server.BaseHTTPRequestHandler.path
  • http.server.BaseHTTPRequestHandler.protocol_version
  • http.server.BaseHTTPRequestHandler.requestline
  • http.server.BaseHTTPRequestHandler.request_version
  • http.server.BaseHTTPRequestHandler.responses
  • http.server.BaseHTTPRequestHandler.rfile
  • http.server.BaseHTTPRequestHandler.send_error()
  • http.server.BaseHTTPRequestHandler.send_header()
  • http.server.BaseHTTPRequestHandler.send_response()
  • http.server.BaseHTTPRequestHandler.send_response_only()
  • http.server.BaseHTTPRequestHandler.server
  • http.server.BaseHTTPRequestHandler.server_version
  • http.server.BaseHTTPRequestHandler.sys_version
  • http.server.BaseHTTPRequestHandler.version_string()
  • http.server.BaseHTTPRequestHandler.wfile
  • http.server.CGIHTTPRequestHandler
  • http.server.CGIHTTPRequestHandler.cgi_directories
  • http.server.CGIHTTPRequestHandler.do_POST()
  • http.server.HTTPServer
  • http.server.SimpleHTTPRequestHandler
  • http.server.SimpleHTTPRequestHandler.do_GET()
  • http.server.SimpleHTTPRequestHandler.do_HEAD()
  • http.server.SimpleHTTPRequestHandler.extensions_map
  • http.server.SimpleHTTPRequestHandler.server_version
  • imaplib
  • imaplib.IMAP4
  • imaplib.IMAP4.abort
  • imaplib.IMAP4.append()
  • imaplib.IMAP4.authenticate()
  • imaplib.IMAP4.check()
  • imaplib.IMAP4.close()
  • imaplib.IMAP4.copy()
  • imaplib.IMAP4.create()
  • imaplib.IMAP4.debug
  • imaplib.IMAP4.delete()
  • imaplib.IMAP4.deleteacl()
  • imaplib.IMAP4.enable()
  • imaplib.IMAP4.error
  • imaplib.IMAP4.expunge()
  • imaplib.IMAP4.fetch()
  • imaplib.IMAP4.getacl()
  • imaplib.IMAP4.getannotation()
  • imaplib.IMAP4.getquota()
  • imaplib.IMAP4.getquotaroot()
  • imaplib.IMAP4.list()
  • imaplib.IMAP4.login()
  • imaplib.IMAP4.login_cram_md5()
  • imaplib.IMAP4.logout()
  • imaplib.IMAP4.lsub()
  • imaplib.IMAP4.myrights()
  • imaplib.IMAP4.namespace()
  • imaplib.IMAP4.noop()
  • imaplib.IMAP4.open()
  • imaplib.IMAP4.partial()
  • imaplib.IMAP4.PROTOCOL_VERSION
  • imaplib.IMAP4.proxyauth()
  • imaplib.IMAP4.read()
  • imaplib.IMAP4.readline()
  • imaplib.IMAP4.readonly
  • imaplib.IMAP4.recent()
  • imaplib.IMAP4.rename()
  • imaplib.IMAP4.response()
  • imaplib.IMAP4.search()
  • imaplib.IMAP4.select()
  • imaplib.IMAP4.send()
  • imaplib.IMAP4.setacl()
  • imaplib.IMAP4.setannotation()
  • imaplib.IMAP4.setquota()
  • imaplib.IMAP4.shutdown()
  • imaplib.IMAP4.socket()
  • imaplib.IMAP4.sort()
  • imaplib.IMAP4.starttls()
  • imaplib.IMAP4.status()
  • imaplib.IMAP4.store()
  • imaplib.IMAP4.subscribe()
  • imaplib.IMAP4.thread()
  • imaplib.IMAP4.uid()
  • imaplib.IMAP4.unsubscribe()
  • imaplib.IMAP4.utf8_enabled
  • imaplib.IMAP4.xatom()
  • imaplib.IMAP4_SSL
  • imaplib.IMAP4_stream
  • imaplib.Int2AP()
  • imaplib.Internaldate2tuple()
  • imaplib.ParseFlags()
  • imaplib.Time2Internaldate()
  • ipaddress
  • ipaddress.AddressValueError
  • ipaddress.collapse_addresses()
  • ipaddress.get_mixed_type_key()
  • ipaddress.IPv4Address
  • ipaddress.IPv4Address.compressed
  • ipaddress.IPv4Address.exploded
  • ipaddress.IPv4Address.is_global
  • ipaddress.IPv4Address.is_link_local
  • ipaddress.IPv4Address.is_loopback
  • ipaddress.IPv4Address.is_multicast
  • ipaddress.IPv4Address.is_private
  • ipaddress.IPv4Address.is_reserved
  • ipaddress.IPv4Address.is_unspecified
  • ipaddress.IPv4Address.max_prefixlen
  • ipaddress.IPv4Address.packed
  • ipaddress.IPv4Address.reverse_pointer
  • ipaddress.IPv4Address.version
  • ipaddress.IPv4Interface
  • ipaddress.IPv4Interface.ip
  • ipaddress.IPv4Interface.network
  • ipaddress.IPv4Interface.with_hostmask
  • ipaddress.IPv4Interface.with_netmask
  • ipaddress.IPv4Interface.with_prefixlen
  • ipaddress.IPv4Network
  • ipaddress.IPv4Network.address_exclude()
  • ipaddress.IPv4Network.broadcast_address
  • ipaddress.IPv4Network.compare_networks()
  • ipaddress.IPv4Network.compressed
  • ipaddress.IPv4Network.exploded
  • ipaddress.IPv4Network.hostmask
  • ipaddress.IPv4Network.hosts()
  • ipaddress.IPv4Network.is_link_local
  • ipaddress.IPv4Network.is_loopback
  • ipaddress.IPv4Network.is_multicast
  • ipaddress.IPv4Network.is_private
  • ipaddress.IPv4Network.is_reserved
  • ipaddress.IPv4Network.is_unspecified
  • ipaddress.IPv4Network.max_prefixlen
  • ipaddress.IPv4Network.network_address
  • ipaddress.IPv4Network.num_addresses
  • ipaddress.IPv4Network.overlaps()
  • ipaddress.IPv4Network.prefixlen
  • ipaddress.IPv4Network.subnets()
  • ipaddress.IPv4Network.supernet()
  • ipaddress.IPv4Network.version
  • ipaddress.IPv4Network.with_hostmask
  • ipaddress.IPv4Network.with_netmask
  • ipaddress.IPv4Network.with_prefixlen
  • ipaddress.IPv6Address
  • ipaddress.IPv6Address.compressed
  • ipaddress.IPv6Address.exploded
  • ipaddress.IPv6Address.ipv4_mapped
  • ipaddress.IPv6Address.is_global
  • ipaddress.IPv6Address.is_link_local
  • ipaddress.IPv6Address.is_loopback
  • ipaddress.IPv6Address.is_multicast
  • ipaddress.IPv6Address.is_private
  • ipaddress.IPv6Address.is_reserved
  • ipaddress.IPv6Address.is_site_local
  • ipaddress.IPv6Address.is_unspecified
  • ipaddress.IPv6Address.max_prefixlen
  • ipaddress.IPv6Address.packed
  • ipaddress.IPv6Address.reverse_pointer
  • ipaddress.IPv6Address.sixtofour
  • ipaddress.IPv6Address.teredo
  • ipaddress.IPv6Address.version
  • ipaddress.IPv6Interface
  • ipaddress.IPv6Interface.ip
  • ipaddress.IPv6Interface.network
  • ipaddress.IPv6Interface.with_hostmask
  • ipaddress.IPv6Interface.with_netmask
  • ipaddress.IPv6Interface.with_prefixlen
  • ipaddress.IPv6Network
  • ipaddress.IPv6Network.address_exclude()
  • ipaddress.IPv6Network.broadcast_address
  • ipaddress.IPv6Network.compare_networks()
  • ipaddress.IPv6Network.compressed
  • ipaddress.IPv6Network.exploded
  • ipaddress.IPv6Network.hostmask
  • ipaddress.IPv6Network.hosts()
  • ipaddress.IPv6Network.is_link_local
  • ipaddress.IPv6Network.is_loopback
  • ipaddress.IPv6Network.is_multicast
  • ipaddress.IPv6Network.is_private
  • ipaddress.IPv6Network.is_reserved
  • ipaddress.IPv6Network.is_site_local
  • ipaddress.IPv6Network.is_unspecified
  • ipaddress.IPv6Network.max_prefixlen
  • ipaddress.IPv6Network.network_address
  • ipaddress.IPv6Network.num_addresses
  • ipaddress.IPv6Network.overlaps()
  • ipaddress.IPv6Network.prefixlen
  • ipaddress.IPv6Network.subnets()
  • ipaddress.IPv6Network.supernet()
  • ipaddress.IPv6Network.version
  • ipaddress.IPv6Network.with_hostmask
  • ipaddress.IPv6Network.with_netmask
  • ipaddress.IPv6Network.with_prefixlen
  • ipaddress.ip_address()
  • ipaddress.ip_interface()
  • ipaddress.ip_network()
  • ipaddress.NetmaskValueError
  • ipaddress.summarize_address_range()
  • ipaddress.v4_int_to_packed()
  • ipaddress.v6_int_to_packed()
  • nntplib
  • nntplib.decode_header()
  • nntplib.NNTP
  • nntplib.NNTP.article()
  • nntplib.NNTP.body()
  • nntplib.NNTP.date()
  • nntplib.NNTP.description()
  • nntplib.NNTP.descriptions()
  • nntplib.NNTP.getcapabilities()
  • nntplib.NNTP.getwelcome()
  • nntplib.NNTP.group()
  • nntplib.NNTP.head()
  • nntplib.NNTP.help()
  • nntplib.NNTP.ihave()
  • nntplib.NNTP.last()
  • nntplib.NNTP.list()
  • nntplib.NNTP.login()
  • nntplib.NNTP.newgroups()
  • nntplib.NNTP.newnews()
  • nntplib.NNTP.next()
  • nntplib.NNTP.nntp_implementation
  • nntplib.NNTP.nntp_version
  • nntplib.NNTP.over()
  • nntplib.NNTP.post()
  • nntplib.NNTP.quit()
  • nntplib.NNTP.set_debuglevel()
  • nntplib.NNTP.slave()
  • nntplib.NNTP.starttls()
  • nntplib.NNTP.stat()
  • nntplib.NNTP.xhdr()
  • nntplib.NNTP.xover()
  • nntplib.NNTP.xpath()
  • nntplib.NNTPDataError
  • nntplib.NNTPError
  • nntplib.NNTPError.response
  • nntplib.NNTPPermanentError
  • nntplib.NNTPProtocolError
  • nntplib.NNTPReplyError
  • nntplib.NNTPTemporaryError
  • nntplib.NNTP_SSL
  • poplib
  • poplib.error_proto
  • poplib.POP3
  • poplib.POP3.apop()
  • poplib.POP3.capa()
  • poplib.POP3.dele()
  • poplib.POP3.getwelcome()
  • poplib.POP3.list()
  • poplib.POP3.noop()
  • poplib.POP3.pass_()
  • poplib.POP3.quit()
  • poplib.POP3.retr()
  • poplib.POP3.rpop()
  • poplib.POP3.rset()
  • poplib.POP3.set_debuglevel()
  • poplib.POP3.stat()
  • poplib.POP3.stls()
  • poplib.POP3.top()
  • poplib.POP3.uidl()
  • poplib.POP3.user()
  • poplib.POP3.utf8()
  • poplib.POP3_SSL
  • smtpd
  • smtpd.DebuggingServer
  • smtpd.MailmanProxy
  • smtpd.PureProxy
  • smtpd.SMTPChannel
  • smtpd.SMTPChannel.addr
  • smtpd.SMTPChannel.conn
  • smtpd.SMTPChannel.fqdn
  • smtpd.SMTPChannel.mailfrom
  • smtpd.SMTPChannel.peer
  • smtpd.SMTPChannel.rcpttos
  • smtpd.SMTPChannel.received_data
  • smtpd.SMTPChannel.received_lines
  • smtpd.SMTPChannel.seen_greeting
  • smtpd.SMTPChannel.smtp_server
  • smtpd.SMTPChannel.smtp_state
  • smtpd.SMTPServer
  • smtpd.SMTPServer.channel_class
  • smtpd.SMTPServer.process_message()
  • smtplib
  • smtplib.LMTP
  • smtplib.SMTP
  • smtplib.SMTP.auth()
  • smtplib.SMTP.connect()
  • smtplib.SMTP.docmd()
  • smtplib.SMTP.ehlo()
  • smtplib.SMTP.ehlo_or_helo_if_needed()
  • smtplib.SMTP.has_extn()
  • smtplib.SMTP.helo()
  • smtplib.SMTP.login()
  • smtplib.SMTP.quit()
  • smtplib.SMTP.sendmail()
  • smtplib.SMTP.send_message()
  • smtplib.SMTP.set_debuglevel()
  • smtplib.SMTP.starttls()
  • smtplib.SMTP.verify()
  • smtplib.SMTPAuthenticationError
  • smtplib.SMTPConnectError
  • smtplib.SMTPDataError
  • smtplib.SMTPException
  • smtplib.SMTPHeloError
  • smtplib.SMTPNotSupportedError
  • smtplib.SMTPRecipientsRefused
  • smtplib.SMTPResponseException
  • smtplib.SMTPSenderRefused
  • smtplib.SMTPServerDisconnected
  • smtplib.SMTP_SSL
  • socketserver
  • socketserver.BaseRequestHandler
  • socketserver.BaseRequestHandler.finish()
  • socketserver.BaseRequestHandler.handle()
  • socketserver.BaseRequestHandler.setup()
  • socketserver.BaseServer
  • socketserver.BaseServer.address_family
  • socketserver.BaseServer.allow_reuse_address
  • socketserver.BaseServer.fileno()
  • socketserver.BaseServer.finish_request()
  • socketserver.BaseServer.get_request()
  • socketserver.BaseServer.handle_error()
  • socketserver.BaseServer.handle_request()
  • socketserver.BaseServer.handle_timeout()
  • socketserver.BaseServer.process_request()
  • socketserver.BaseServer.RequestHandlerClass
  • socketserver.BaseServer.request_queue_size
  • socketserver.BaseServer.server_activate()
  • socketserver.BaseServer.server_address
  • socketserver.BaseServer.server_bind()
  • socketserver.BaseServer.server_close()
  • socketserver.BaseServer.serve_forever()
  • socketserver.BaseServer.service_actions()
  • socketserver.BaseServer.shutdown()
  • socketserver.BaseServer.socket
  • socketserver.BaseServer.socket_type
  • socketserver.BaseServer.timeout
  • socketserver.BaseServer.verify_request()
  • socketserver.DatagramRequestHandler
  • socketserver.ForkingMixIn
  • socketserver.ForkingTCPServer
  • socketserver.ForkingUDPServer
  • socketserver.StreamRequestHandler
  • socketserver.TCPServer
  • socketserver.ThreadingMixIn
  • socketserver.ThreadingTCPServer
  • socketserver.ThreadingUDPServer
  • socketserver.UDPServer
  • socketserver.UnixDatagramServer
  • socketserver.UnixStreamServer
  • telnetlib
  • telnetlib.Telnet
  • telnetlib.Telnet.close()
  • telnetlib.Telnet.expect()
  • telnetlib.Telnet.fileno()
  • telnetlib.Telnet.get_socket()
  • telnetlib.Telnet.interact()
  • telnetlib.Telnet.msg()
  • telnetlib.Telnet.mt_interact()
  • telnetlib.Telnet.open()
  • telnetlib.Telnet.read_all()
  • telnetlib.Telnet.read_eager()
  • telnetlib.Telnet.read_lazy()
  • telnetlib.Telnet.read_sb_data()
  • telnetlib.Telnet.read_some()
  • telnetlib.Telnet.read_until()
  • telnetlib.Telnet.read_very_eager()
  • telnetlib.Telnet.read_very_lazy()
  • telnetlib.Telnet.set_debuglevel()
  • telnetlib.Telnet.set_option_negotiation_callback()
  • telnetlib.Telnet.write()
  • urllib
  • urllib.error
  • urllib.error.ContentTooShortError
  • urllib.error.HTTPError
  • urllib.error.HTTPError.code
  • urllib.error.HTTPError.headers
  • urllib.error.HTTPError.reason
  • urllib.error.URLError
  • urllib.error.URLError.reason
  • urllib.parse
  • urllib.parse.DefragResult
  • urllib.parse.DefragResultBytes
  • urllib.parse.ParseResult
  • urllib.parse.ParseResultBytes
  • urllib.parse.parse_qs()
  • urllib.parse.parse_qsl()
  • urllib.parse.quote()
  • urllib.parse.quote_from_bytes()
  • urllib.parse.quote_plus()
  • urllib.parse.SplitResult
  • urllib.parse.SplitResultBytes
  • urllib.parse.unquote()
  • urllib.parse.unquote_plus()
  • urllib.parse.unquote_to_bytes()
  • urllib.parse.urldefrag()
  • urllib.parse.urlencode()
  • urllib.parse.urljoin()
  • urllib.parse.urllib.parse.SplitResult.geturl()
  • urllib.parse.urlparse()
  • urllib.parse.urlsplit()
  • urllib.parse.urlunparse()
  • urllib.parse.urlunsplit()
  • urllib.request
  • urllib.request.AbstractBasicAuthHandler
  • urllib.request.AbstractBasicAuthHandler.http_error_auth_reqed()
  • urllib.request.AbstractDigestAuthHandler
  • urllib.request.AbstractDigestAuthHandler.http_error_auth_reqed()
  • urllib.request.BaseHandler
  • urllib.request.BaseHandler.add_parent()
  • urllib.request.BaseHandler.close()
  • urllib.request.BaseHandler.default_open()
  • urllib.request.BaseHandler.http_error_default()
  • urllib.request.BaseHandler.http_error_nnn()
  • urllib.request.BaseHandler.parent
  • urllib.request.BaseHandler.unknown_open()
  • urllib.request.build_opener()
  • urllib.request.CacheFTPHandler
  • urllib.request.CacheFTPHandler.setMaxConns()
  • urllib.request.CacheFTPHandler.setTimeout()
  • urllib.request.DataHandler
  • urllib.request.DataHandler.data_open()
  • urllib.request.FancyURLopener
  • urllib.request.FancyURLopener.prompt_user_passwd()
  • urllib.request.FileHandler
  • urllib.request.FileHandler.file_open()
  • urllib.request.FTPHandler
  • urllib.request.FTPHandler.ftp_open()
  • urllib.request.getproxies()
  • urllib.request.HTTPBasicAuthHandler
  • urllib.request.HTTPBasicAuthHandler.http_error_401()
  • urllib.request.HTTPCookieProcessor
  • urllib.request.HTTPCookieProcessor.cookiejar
  • urllib.request.HTTPDefaultErrorHandler
  • urllib.request.HTTPDigestAuthHandler
  • urllib.request.HTTPDigestAuthHandler.http_error_401()
  • urllib.request.HTTPErrorProcessor
  • urllib.request.HTTPErrorProcessor.https_response()
  • urllib.request.HTTPErrorProcessor.http_response()
  • urllib.request.HTTPHandler
  • urllib.request.HTTPHandler.http_open()
  • urllib.request.HTTPPasswordMgr
  • urllib.request.HTTPPasswordMgr.add_password()
  • urllib.request.HTTPPasswordMgr.find_user_password()
  • urllib.request.HTTPPasswordMgrWithDefaultRealm
  • urllib.request.HTTPPasswordMgrWithPriorAuth
  • urllib.request.HTTPPasswordMgrWithPriorAuth.add_password()
  • urllib.request.HTTPPasswordMgrWithPriorAuth.is_authenticated()
  • urllib.request.HTTPPasswordMgrWithPriorAuth.update_authenticated()
  • urllib.request.HTTPRedirectHandler
  • urllib.request.HTTPRedirectHandler.http_error_301()
  • urllib.request.HTTPRedirectHandler.http_error_302()
  • urllib.request.HTTPRedirectHandler.http_error_303()
  • urllib.request.HTTPRedirectHandler.http_error_307()
  • urllib.request.HTTPRedirectHandler.redirect_request()
  • urllib.request.HTTPSHandler
  • urllib.request.HTTPSHandler.https_open()
  • urllib.request.install_opener()
  • urllib.request.OpenerDirector
  • urllib.request.OpenerDirector.add_handler()
  • urllib.request.OpenerDirector.error()
  • urllib.request.OpenerDirector.open()
  • urllib.request.pathname2url()
  • urllib.request.ProxyBasicAuthHandler
  • urllib.request.ProxyBasicAuthHandler.http_error_407()
  • urllib.request.ProxyDigestAuthHandler
  • urllib.request.ProxyDigestAuthHandler.http_error_407()
  • urllib.request.ProxyHandler
  • urllib.request.Request
  • urllib.request.Request.add_header()
  • urllib.request.Request.add_unredirected_header()
  • urllib.request.Request.data
  • urllib.request.Request.full_url
  • urllib.request.Request.get_full_url()
  • urllib.request.Request.get_header()
  • urllib.request.Request.get_method()
  • urllib.request.Request.has_header()
  • urllib.request.Request.header_items()
  • urllib.request.Request.host
  • urllib.request.Request.method
  • urllib.request.Request.origin_req_host
  • urllib.request.Request.remove_header()
  • urllib.request.Request.selector
  • urllib.request.Request.set_proxy()
  • urllib.request.Request.type
  • urllib.request.Request.unverifiable
  • urllib.request.UnknownHandler
  • urllib.request.UnknownHandler.unknown_open()
  • urllib.request.url2pathname()
  • urllib.request.urlcleanup()
  • urllib.request.urlopen()
  • urllib.request.URLopener
  • urllib.request.URLopener.open()
  • urllib.request.URLopener.open_unknown()
  • urllib.request.URLopener.retrieve()
  • urllib.request.URLopener.version
  • urllib.request.urlretrieve()
  • urllib.robotparser
  • urllib.robotparser.RobotFileParser
  • urllib.robotparser.RobotFileParser.can_fetch()
  • urllib.robotparser.RobotFileParser.modified()
  • urllib.robotparser.RobotFileParser.mtime()
  • urllib.robotparser.RobotFileParser.parse()
  • urllib.robotparser.RobotFileParser.read()
  • urllib.robotparser.RobotFileParser.set_url()
  • uuid
  • uuid.getnode()
  • uuid.UUID
  • uuid.UUID.bytes
  • uuid.UUID.bytes_le
  • uuid.UUID.fields
  • uuid.UUID.hex
  • uuid.UUID.int
  • uuid.UUID.urn
  • uuid.UUID.variant
  • uuid.UUID.version
  • uuid.uuid1()
  • uuid.uuid3()
  • uuid.uuid4()
  • uuid.uuid5()
  • webbrowser
  • webbrowser.controller.open()
  • webbrowser.controller.open_new()
  • webbrowser.controller.open_new_tab()
  • webbrowser.Error
  • webbrowser.get()
  • webbrowser.open()
  • webbrowser.open_new()
  • webbrowser.open_new_tab()
  • webbrowser.register()
  • wsgiref
  • wsgiref.handlers.BaseCGIHandler
  • wsgiref.handlers.BaseHandler
  • wsgiref.handlers.BaseHandler.add_cgi_vars()
  • wsgiref.handlers.BaseHandler.error_body
  • wsgiref.handlers.BaseHandler.error_headers
  • wsgiref.handlers.BaseHandler.error_output()
  • wsgiref.handlers.BaseHandler.error_status
  • wsgiref.handlers.BaseHandler.get_scheme()
  • wsgiref.handlers.BaseHandler.get_stderr()
  • wsgiref.handlers.BaseHandler.get_stdin()
  • wsgiref.handlers.BaseHandler.http_version
  • wsgiref.handlers.BaseHandler.log_exception()
  • wsgiref.handlers.BaseHandler.origin_server
  • wsgiref.handlers.BaseHandler.os_environ
  • wsgiref.handlers.BaseHandler.run()
  • wsgiref.handlers.BaseHandler.sendfile()
  • wsgiref.handlers.BaseHandler.server_software
  • wsgiref.handlers.BaseHandler.setup_environ()
  • wsgiref.handlers.BaseHandler.traceback_limit
  • wsgiref.handlers.BaseHandler.wsgi_file_wrapper
  • wsgiref.handlers.BaseHandler.wsgi_multiprocess
  • wsgiref.handlers.BaseHandler.wsgi_multithread
  • wsgiref.handlers.BaseHandler.wsgi_run_once
  • wsgiref.handlers.BaseHandler._flush()
  • wsgiref.handlers.BaseHandler._write()
  • wsgiref.handlers.CGIHandler
  • wsgiref.handlers.IISCGIHandler
  • wsgiref.handlers.read_environ()
  • wsgiref.handlers.SimpleHandler
  • wsgiref.headers.Headers
  • wsgiref.headers.Headers.add_header()
  • wsgiref.headers.Headers.get_all()
  • wsgiref.simple_server.demo_app()
  • wsgiref.simple_server.make_server()
  • wsgiref.simple_server.WSGIRequestHandler
  • wsgiref.simple_server.WSGIRequestHandler.get_environ()
  • wsgiref.simple_server.WSGIRequestHandler.get_stderr()
  • wsgiref.simple_server.WSGIRequestHandler.handle()
  • wsgiref.simple_server.WSGIServer
  • wsgiref.simple_server.WSGIServer.get_app()
  • wsgiref.simple_server.WSGIServer.set_app()
  • wsgiref.util.application_uri()
  • wsgiref.util.FileWrapper
  • wsgiref.util.guess_scheme()
  • wsgiref.util.is_hop_by_hop()
  • wsgiref.util.request_uri()
  • wsgiref.util.setup_testing_defaults()
  • wsgiref.util.shift_path_info()
  • wsgiref.validate.validator()
  • xmlrpc
  • xmlrpc.client
  • xmlrpc.client.Binary
  • xmlrpc.client.Binary.data
  • xmlrpc.client.Binary.decode()
  • xmlrpc.client.Binary.encode()
  • xmlrpc.client.DateTime
  • xmlrpc.client.DateTime.decode()
  • xmlrpc.client.DateTime.encode()
  • xmlrpc.client.dumps()
  • xmlrpc.client.Fault
  • xmlrpc.client.Fault.faultCode
  • xmlrpc.client.Fault.faultString
  • xmlrpc.client.loads()
  • xmlrpc.client.MultiCall
  • xmlrpc.client.ProtocolError
  • xmlrpc.client.ProtocolError.errcode
  • xmlrpc.client.ProtocolError.errmsg
  • xmlrpc.client.ProtocolError.headers
  • xmlrpc.client.ProtocolError.url
  • xmlrpc.client.ServerProxy
  • xmlrpc.client.ServerProxy.system.listMethods()
  • xmlrpc.client.ServerProxy.system.methodHelp()
  • xmlrpc.client.ServerProxy.system.methodSignature()
  • xmlrpc.server
  • xmlrpc.server.CGIXMLRPCRequestHandler
  • xmlrpc.server.CGIXMLRPCRequestHandler.handle_request()
  • xmlrpc.server.CGIXMLRPCRequestHandler.register_function()
  • xmlrpc.server.CGIXMLRPCRequestHandler.register_instance()
  • xmlrpc.server.CGIXMLRPCRequestHandler.register_introspection_functions()
  • xmlrpc.server.CGIXMLRPCRequestHandler.register_multicall_functions()
  • xmlrpc.server.DocCGIXMLRPCRequestHandler
  • xmlrpc.server.DocCGIXMLRPCRequestHandler.set_server_documentation()
  • xmlrpc.server.DocCGIXMLRPCRequestHandler.set_server_name()
  • xmlrpc.server.DocCGIXMLRPCRequestHandler.set_server_title()
  • xmlrpc.server.DocXMLRPCRequestHandler
  • xmlrpc.server.DocXMLRPCServer
  • xmlrpc.server.DocXMLRPCServer.set_server_documentation()
  • xmlrpc.server.DocXMLRPCServer.set_server_name()
  • xmlrpc.server.DocXMLRPCServer.set_server_title()
  • xmlrpc.server.SimpleXMLRPCRequestHandler
  • xmlrpc.server.SimpleXMLRPCRequestHandler.rpc_paths
  • xmlrpc.server.SimpleXMLRPCServer
  • xmlrpc.server.SimpleXMLRPCServer.register_function()
  • xmlrpc.server.SimpleXMLRPCServer.register_instance()
  • xmlrpc.server.SimpleXMLRPCServer.register_introspection_functions()
  • xmlrpc.server.SimpleXMLRPCServer.register_multicall_functions()
  • Numeric & Mathematical

  • cmath
  • cmath.acos()
  • cmath.acosh()
  • cmath.asin()
  • cmath.asinh()
  • cmath.atan()
  • cmath.atanh()
  • cmath.cos()
  • cmath.cosh()
  • cmath.e
  • cmath.exp()
  • cmath.isclose()
  • cmath.isfinite()
  • cmath.isinf()
  • cmath.isnan()
  • cmath.log()
  • cmath.log10()
  • cmath.phase()
  • cmath.pi
  • cmath.polar()
  • cmath.rect()
  • cmath.sin()
  • cmath.sinh()
  • cmath.sqrt()
  • cmath.tan()
  • cmath.tanh()
  • decimal
  • decimal.BasicContext
  • decimal.Clamped
  • decimal.Context
  • decimal.Context.abs()
  • decimal.Context.add()
  • decimal.Context.canonical()
  • decimal.Context.clear_flags()
  • decimal.Context.clear_traps()
  • decimal.Context.compare()
  • decimal.Context.compare_signal()
  • decimal.Context.compare_total()
  • decimal.Context.compare_total_mag()
  • decimal.Context.copy()
  • decimal.Context.copy_abs()
  • decimal.Context.copy_decimal()
  • decimal.Context.copy_negate()
  • decimal.Context.copy_sign()
  • decimal.Context.create_decimal()
  • decimal.Context.create_decimal_from_float()
  • decimal.Context.divide()
  • decimal.Context.divide_int()
  • decimal.Context.divmod()
  • decimal.Context.Etiny()
  • decimal.Context.Etop()
  • decimal.Context.exp()
  • decimal.Context.fma()
  • decimal.Context.is_canonical()
  • decimal.Context.is_finite()
  • decimal.Context.is_infinite()
  • decimal.Context.is_nan()
  • decimal.Context.is_normal()
  • decimal.Context.is_qnan()
  • decimal.Context.is_signed()
  • decimal.Context.is_snan()
  • decimal.Context.is_subnormal()
  • decimal.Context.is_zero()
  • decimal.Context.ln()
  • decimal.Context.log10()
  • decimal.Context.logb()
  • decimal.Context.logical_and()
  • decimal.Context.logical_invert()
  • decimal.Context.logical_or()
  • decimal.Context.logical_xor()
  • decimal.Context.max()
  • decimal.Context.max_mag()
  • decimal.Context.min()
  • decimal.Context.minus()
  • decimal.Context.min_mag()
  • decimal.Context.multiply()
  • decimal.Context.next_minus()
  • decimal.Context.next_plus()
  • decimal.Context.next_toward()
  • decimal.Context.normalize()
  • decimal.Context.number_class()
  • decimal.Context.plus()
  • decimal.Context.power()
  • decimal.Context.quantize()
  • decimal.Context.radix()
  • decimal.Context.remainder()
  • decimal.Context.remainder_near()
  • decimal.Context.rotate()
  • decimal.Context.same_quantum()
  • decimal.Context.scaleb()
  • decimal.Context.shift()
  • decimal.Context.sqrt()
  • decimal.Context.subtract()
  • decimal.Context.to_eng_string()
  • decimal.Context.to_integral_exact()
  • decimal.Context.to_sci_string()
  • decimal.Decimal
  • decimal.Decimal.adjusted()
  • decimal.Decimal.as_tuple()
  • decimal.Decimal.canonical()
  • decimal.Decimal.compare()
  • decimal.Decimal.compare_signal()
  • decimal.Decimal.compare_total()
  • decimal.Decimal.compare_total_mag()
  • decimal.Decimal.conjugate()
  • decimal.Decimal.copy_abs()
  • decimal.Decimal.copy_negate()
  • decimal.Decimal.copy_sign()
  • decimal.Decimal.exp()
  • decimal.Decimal.fma()
  • decimal.Decimal.from_float()
  • decimal.Decimal.is_canonical()
  • decimal.Decimal.is_finite()
  • decimal.Decimal.is_infinite()
  • decimal.Decimal.is_nan()
  • decimal.Decimal.is_normal()
  • decimal.Decimal.is_qnan()
  • decimal.Decimal.is_signed()
  • decimal.Decimal.is_snan()
  • decimal.Decimal.is_subnormal()
  • decimal.Decimal.is_zero()
  • decimal.Decimal.ln()
  • decimal.Decimal.log10()
  • decimal.Decimal.logb()
  • decimal.Decimal.logical_and()
  • decimal.Decimal.logical_invert()
  • decimal.Decimal.logical_or()
  • decimal.Decimal.logical_xor()
  • decimal.Decimal.max()
  • decimal.Decimal.max_mag()
  • decimal.Decimal.min()
  • decimal.Decimal.min_mag()
  • decimal.Decimal.next_minus()
  • decimal.Decimal.next_plus()
  • decimal.Decimal.next_toward()
  • decimal.Decimal.normalize()
  • decimal.Decimal.number_class()
  • decimal.Decimal.quantize()
  • decimal.Decimal.radix()
  • decimal.Decimal.remainder_near()
  • decimal.Decimal.rotate()
  • decimal.Decimal.same_quantum()
  • decimal.Decimal.scaleb()
  • decimal.Decimal.shift()
  • decimal.Decimal.sqrt()
  • decimal.Decimal.to_eng_string()
  • decimal.Decimal.to_integral()
  • decimal.Decimal.to_integral_exact()
  • decimal.Decimal.to_integral_value()
  • decimal.DecimalException
  • decimal.DefaultContext
  • decimal.DivisionByZero
  • decimal.ExtendedContext
  • decimal.FloatOperation
  • decimal.getcontext()
  • decimal.Inexact
  • decimal.InvalidOperation
  • decimal.localcontext()
  • decimal.Overflow
  • decimal.Rounded
  • decimal.setcontext()
  • decimal.Subnormal
  • decimal.Underflow
  • fractions
  • fractions.Fraction
  • fractions.Fraction.denominator
  • fractions.Fraction.from_decimal()
  • fractions.Fraction.from_float()
  • fractions.Fraction.limit_denominator()
  • fractions.Fraction.numerator
  • fractions.Fraction.__ceil__()
  • fractions.Fraction.__floor__()
  • fractions.Fraction.__round__()
  • fractions.gcd()
  • math
  • math.acos()
  • math.acosh()
  • math.asin()
  • math.asinh()
  • math.atan()
  • math.atan2()
  • math.atanh()
  • math.ceil()
  • math.copysign()
  • math.cos()
  • math.cosh()
  • math.degrees()
  • math.e
  • math.erf()
  • math.erfc()
  • math.exp()
  • math.expm1()
  • math.fabs()
  • math.factorial()
  • math.floor()
  • math.fmod()
  • math.frexp()
  • math.fsum()
  • math.gamma()
  • math.gcd()
  • math.hypot()
  • math.inf
  • math.isclose()
  • math.isfinite()
  • math.isinf()
  • math.isnan()
  • math.ldexp()
  • math.lgamma()
  • math.log()
  • math.log10()
  • math.log1p()
  • math.log2()
  • math.modf()
  • math.nan
  • math.pi
  • math.pow()
  • math.radians()
  • math.sin()
  • math.sinh()
  • math.sqrt()
  • math.tan()
  • math.tanh()
  • math.trunc()
  • numbers
  • numbers.Complex
  • numbers.Complex.conjugate()
  • numbers.Complex.imag
  • numbers.Complex.real
  • numbers.Integral
  • numbers.Number
  • numbers.Rational
  • numbers.Rational.denominator
  • numbers.Rational.numerator
  • numbers.Real
  • random
  • random.betavariate()
  • random.choice()
  • random.expovariate()
  • random.gammavariate()
  • random.gauss()
  • random.getrandbits()
  • random.getstate()
  • random.lognormvariate()
  • random.normalvariate()
  • random.paretovariate()
  • random.randint()
  • random.random()
  • random.randrange()
  • random.sample()
  • random.seed()
  • random.setstate()
  • random.shuffle()
  • random.SystemRandom
  • random.triangular()
  • random.uniform()
  • random.vonmisesvariate()
  • random.weibullvariate()
  • statistics
  • statistics.mean()
  • statistics.median()
  • statistics.median_grouped()
  • statistics.median_high()
  • statistics.median_low()
  • statistics.mode()
  • statistics.pstdev()
  • statistics.pvariance()
  • statistics.StatisticsError
  • statistics.stdev()
  • statistics.variance()
  • Frameworks

  • cmd
  • cmd.Cmd
  • cmd.Cmd.cmdloop()
  • cmd.Cmd.cmdqueue
  • cmd.Cmd.completedefault()
  • cmd.Cmd.default()
  • cmd.Cmd.doc_header
  • cmd.Cmd.emptyline()
  • cmd.Cmd.identchars
  • cmd.Cmd.intro
  • cmd.Cmd.lastcmd
  • cmd.Cmd.misc_header
  • cmd.Cmd.onecmd()
  • cmd.Cmd.postcmd()
  • cmd.Cmd.postloop()
  • cmd.Cmd.precmd()
  • cmd.Cmd.preloop()
  • cmd.Cmd.prompt
  • cmd.Cmd.ruler
  • cmd.Cmd.undoc_header
  • cmd.Cmd.use_rawinput
  • shlex
  • shlex.quote()
  • shlex.shlex
  • shlex.shlex.commenters
  • shlex.shlex.debug
  • shlex.shlex.eof
  • shlex.shlex.error_leader()
  • shlex.shlex.escape
  • shlex.shlex.escapedquotes
  • shlex.shlex.get_token()
  • shlex.shlex.infile
  • shlex.shlex.instream
  • shlex.shlex.lineno
  • shlex.shlex.pop_source()
  • shlex.shlex.push_source()
  • shlex.shlex.push_token()
  • shlex.shlex.quotes
  • shlex.shlex.read_token()
  • shlex.shlex.source
  • shlex.shlex.sourcehook()
  • shlex.shlex.token
  • shlex.shlex.whitespace
  • shlex.shlex.whitespace_split
  • shlex.shlex.wordchars
  • shlex.split()
  • turtle
  • turtle.addshape()
  • turtle.back()
  • turtle.backward()
  • turtle.begin_fill()
  • turtle.begin_poly()
  • turtle.bgcolor()
  • turtle.bgpic()
  • turtle.bk()
  • turtle.bye()
  • turtle.circle()
  • turtle.clear()
  • turtle.clearscreen()
  • turtle.clearstamp()
  • turtle.clearstamps()
  • turtle.clone()
  • turtle.color()
  • turtle.colormode()
  • turtle.degrees()
  • turtle.delay()
  • turtle.distance()
  • turtle.done()
  • turtle.dot()
  • turtle.down()
  • turtle.end_fill()
  • turtle.end_poly()
  • turtle.exitonclick()
  • turtle.fd()
  • turtle.fillcolor()
  • turtle.filling()
  • turtle.forward()
  • turtle.getcanvas()
  • turtle.getpen()
  • turtle.getscreen()
  • turtle.getshapes()
  • turtle.getturtle()
  • turtle.get_poly()
  • turtle.get_shapepoly()
  • turtle.goto()
  • turtle.heading()
  • turtle.hideturtle()
  • turtle.home()
  • turtle.ht()
  • turtle.isdown()
  • turtle.isvisible()
  • turtle.left()
  • turtle.listen()
  • turtle.lt()
  • turtle.mainloop()
  • turtle.mode()
  • turtle.numinput()
  • turtle.onclick()
  • turtle.ondrag()
  • turtle.onkey()
  • turtle.onkeypress()
  • turtle.onkeyrelease()
  • turtle.onrelease()
  • turtle.onscreenclick()
  • turtle.ontimer()
  • turtle.pd()
  • turtle.pen()
  • turtle.pencolor()
  • turtle.pendown()
  • turtle.pensize()
  • turtle.penup()
  • turtle.pos()
  • turtle.position()
  • turtle.pu()
  • turtle.radians()
  • turtle.RawPen
  • turtle.RawTurtle
  • turtle.register_shape()
  • turtle.reset()
  • turtle.resetscreen()
  • turtle.resizemode()
  • turtle.right()
  • turtle.rt()
  • turtle.Screen
  • turtle.screensize()
  • turtle.ScrolledCanvas
  • turtle.seth()
  • turtle.setheading()
  • turtle.setpos()
  • turtle.setposition()
  • turtle.settiltangle()
  • turtle.setundobuffer()
  • turtle.setup()
  • turtle.setworldcoordinates()
  • turtle.setx()
  • turtle.sety()
  • turtle.Shape
  • turtle.Shape.addcomponent()
  • turtle.shapesize()
  • turtle.shapetransform()
  • turtle.shearfactor()
  • turtle.showturtle()
  • turtle.speed()
  • turtle.st()
  • turtle.stamp()
  • turtle.textinput()
  • turtle.tilt()
  • turtle.tiltangle()
  • turtle.title()
  • turtle.towards()
  • turtle.tracer()
  • turtle.Turtle
  • turtle.turtles()
  • turtle.TurtleScreen
  • turtle.turtlesize()
  • turtle.undo()
  • turtle.undobufferentries()
  • turtle.up()
  • turtle.update()
  • turtle.Vec2D
  • turtle.width()
  • turtle.window_height()
  • turtle.window_width()
  • turtle.write()
  • turtle.write_docstringdict()
  • turtle.xcor()
  • turtle.ycor()
  • Binary Data

  • codecs
  • codecs.backslashreplace_errors()
  • codecs.Codec.decode()
  • codecs.Codec.encode()
  • codecs.CodecInfo
  • codecs.CodecInfo.decode
  • codecs.CodecInfo.encode
  • codecs.CodecInfo.incrementaldecoder
  • codecs.CodecInfo.incrementalencoder
  • codecs.CodecInfo.name
  • codecs.CodecInfo.streamreader
  • codecs.CodecInfo.streamwriter
  • codecs.decode()
  • codecs.encode()
  • codecs.EncodedFile()
  • codecs.getdecoder()
  • codecs.getencoder()
  • codecs.getincrementaldecoder()
  • codecs.getincrementalencoder()
  • codecs.getreader()
  • codecs.getwriter()
  • codecs.ignore_errors()
  • codecs.IncrementalDecoder
  • codecs.IncrementalDecoder.decode()
  • codecs.IncrementalDecoder.getstate()
  • codecs.IncrementalDecoder.reset()
  • codecs.IncrementalDecoder.setstate()
  • codecs.IncrementalEncoder
  • codecs.IncrementalEncoder.encode()
  • codecs.IncrementalEncoder.getstate()
  • codecs.IncrementalEncoder.reset()
  • codecs.IncrementalEncoder.setstate()
  • codecs.iterdecode()
  • codecs.iterencode()
  • codecs.lookup()
  • codecs.lookup_error()
  • codecs.namereplace_errors()
  • codecs.open()
  • codecs.register()
  • codecs.register_error()
  • codecs.replace_errors()
  • codecs.StreamReader
  • codecs.StreamReader.read()
  • codecs.StreamReader.readline()
  • codecs.StreamReader.readlines()
  • codecs.StreamReader.reset()
  • codecs.StreamReaderWriter
  • codecs.StreamRecoder
  • codecs.StreamWriter
  • codecs.StreamWriter.reset()
  • codecs.StreamWriter.write()
  • codecs.StreamWriter.writelines()
  • codecs.strict_errors()
  • codecs.xmlcharrefreplace_errors()
  • encodings.idna.nameprep()
  • encodings.idna.ToASCII()
  • encodings.idna.ToUnicode()
  • struct
  • struct.calcsize()
  • struct.error
  • struct.iter_unpack()
  • struct.pack()
  • struct.pack_into()
  • struct.Struct
  • struct.Struct.format
  • struct.Struct.iter_unpack()
  • struct.Struct.pack()
  • struct.Struct.pack_into()
  • struct.Struct.size
  • struct.Struct.unpack()
  • struct.Struct.unpack_from()
  • struct.unpack()
  • struct.unpack_from()
  • Concurrent Execution

  • concurrent.futures
  • concurrent.futures.as_completed()
  • concurrent.futures.CancelledError
  • concurrent.futures.Executor
  • concurrent.futures.Executor.map()
  • concurrent.futures.Executor.shutdown()
  • concurrent.futures.Executor.submit()
  • concurrent.futures.Future
  • concurrent.futures.Future.add_done_callback()
  • concurrent.futures.Future.cancel()
  • concurrent.futures.Future.cancelled()
  • concurrent.futures.Future.done()
  • concurrent.futures.Future.exception()
  • concurrent.futures.Future.result()
  • concurrent.futures.Future.running()
  • concurrent.futures.Future.set_exception()
  • concurrent.futures.Future.set_result()
  • concurrent.futures.Future.set_running_or_notify_cancel()
  • concurrent.futures.process.BrokenProcessPool
  • concurrent.futures.ProcessPoolExecutor
  • concurrent.futures.ThreadPoolExecutor
  • concurrent.futures.TimeoutError
  • concurrent.futures.wait()
  • dummy_threading
  • multiprocessing
  • multiprocessing.active_children()
  • multiprocessing.Array()
  • multiprocessing.AuthenticationError
  • multiprocessing.Barrier
  • multiprocessing.BoundedSemaphore
  • multiprocessing.BufferTooShort
  • multiprocessing.Condition
  • multiprocessing.Connection
  • multiprocessing.connection.answer_challenge()
  • multiprocessing.connection.Client()
  • multiprocessing.Connection.close()
  • multiprocessing.connection.deliver_challenge()
  • multiprocessing.Connection.fileno()
  • multiprocessing.connection.Listener
  • multiprocessing.connection.Listener.accept()
  • multiprocessing.connection.Listener.address
  • multiprocessing.connection.Listener.close()
  • multiprocessing.connection.Listener.last_accepted
  • multiprocessing.Connection.poll()
  • multiprocessing.Connection.recv()
  • multiprocessing.Connection.recv_bytes()
  • multiprocessing.Connection.recv_bytes_into()
  • multiprocessing.Connection.send()
  • multiprocessing.Connection.send_bytes()
  • multiprocessing.connection.wait()
  • multiprocessing.cpu_count()
  • multiprocessing.current_process()
  • multiprocessing.Event
  • multiprocessing.freeze_support()
  • multiprocessing.get_all_start_methods()
  • multiprocessing.get_context()
  • multiprocessing.get_logger()
  • multiprocessing.get_start_method()
  • multiprocessing.JoinableQueue
  • multiprocessing.JoinableQueue.join()
  • multiprocessing.JoinableQueue.task_done()
  • multiprocessing.Lock
  • multiprocessing.Lock.acquire()
  • multiprocessing.Lock.release()
  • multiprocessing.log_to_stderr()
  • multiprocessing.managers.BaseManager
  • multiprocessing.managers.BaseManager.address
  • multiprocessing.managers.BaseManager.connect()
  • multiprocessing.managers.BaseManager.get_server()
  • multiprocessing.managers.BaseManager.register()
  • multiprocessing.managers.BaseManager.shutdown()
  • multiprocessing.managers.BaseManager.start()
  • multiprocessing.managers.BaseProxy
  • multiprocessing.managers.BaseProxy._callmethod()
  • multiprocessing.managers.BaseProxy._getvalue()
  • multiprocessing.managers.BaseProxy.__repr__()
  • multiprocessing.managers.BaseProxy.__str__()
  • multiprocessing.managers.Namespace
  • multiprocessing.managers.SyncManager
  • multiprocessing.managers.SyncManager.Array()
  • multiprocessing.managers.SyncManager.Barrier()
  • multiprocessing.managers.SyncManager.BoundedSemaphore()
  • multiprocessing.managers.SyncManager.Condition()
  • multiprocessing.managers.SyncManager.dict()
  • multiprocessing.managers.SyncManager.Event()
  • multiprocessing.managers.SyncManager.list()
  • multiprocessing.managers.SyncManager.Lock()
  • multiprocessing.managers.SyncManager.Namespace()
  • multiprocessing.managers.SyncManager.Queue()
  • multiprocessing.managers.SyncManager.RLock()
  • multiprocessing.managers.SyncManager.Semaphore()
  • multiprocessing.managers.SyncManager.Value()
  • multiprocessing.Pipe()
  • multiprocessing.pool.AsyncResult
  • multiprocessing.pool.AsyncResult.get()
  • multiprocessing.pool.AsyncResult.ready()
  • multiprocessing.pool.AsyncResult.successful()
  • multiprocessing.pool.AsyncResult.wait()
  • multiprocessing.pool.Pool
  • multiprocessing.pool.Pool.apply()
  • multiprocessing.pool.Pool.apply_async()
  • multiprocessing.pool.Pool.close()
  • multiprocessing.pool.Pool.imap()
  • multiprocessing.pool.Pool.imap_unordered()
  • multiprocessing.pool.Pool.join()
  • multiprocessing.pool.Pool.map()
  • multiprocessing.pool.Pool.map_async()
  • multiprocessing.pool.Pool.starmap()
  • multiprocessing.pool.Pool.starmap_async()
  • multiprocessing.pool.Pool.terminate()
  • multiprocessing.Process
  • multiprocessing.Process.authkey
  • multiprocessing.Process.daemon
  • multiprocessing.Process.exitcode
  • multiprocessing.Process.is_alive()
  • multiprocessing.Process.join()
  • multiprocessing.Process.name
  • multiprocessing.Process.pid
  • multiprocessing.Process.run()
  • multiprocessing.Process.sentinel
  • multiprocessing.Process.start()
  • multiprocessing.Process.terminate()
  • multiprocessing.ProcessError
  • multiprocessing.Queue
  • multiprocessing.Queue.cancel_join_thread()
  • multiprocessing.Queue.close()
  • multiprocessing.Queue.empty()
  • multiprocessing.Queue.full()
  • multiprocessing.Queue.get()
  • multiprocessing.Queue.get_nowait()
  • multiprocessing.Queue.join_thread()
  • multiprocessing.Queue.put()
  • multiprocessing.Queue.put_nowait()
  • multiprocessing.Queue.qsize()
  • multiprocessing.RLock
  • multiprocessing.RLock.acquire()
  • multiprocessing.RLock.release()
  • multiprocessing.Semaphore
  • multiprocessing.set_executable()
  • multiprocessing.set_start_method()
  • multiprocessing.sharedctypes.Array()
  • multiprocessing.sharedctypes.copy()
  • multiprocessing.sharedctypes.multiprocessing.Manager()
  • multiprocessing.sharedctypes.RawArray()
  • multiprocessing.sharedctypes.RawValue()
  • multiprocessing.sharedctypes.synchronized()
  • multiprocessing.sharedctypes.Value()
  • multiprocessing.SimpleQueue
  • multiprocessing.SimpleQueue.empty()
  • multiprocessing.SimpleQueue.get()
  • multiprocessing.SimpleQueue.put()
  • multiprocessing.TimeoutError
  • multiprocessing.Value()
  • queue
  • queue.Empty
  • queue.Full
  • queue.LifoQueue
  • queue.PriorityQueue
  • queue.Queue
  • queue.Queue.empty()
  • queue.Queue.full()
  • queue.Queue.get()
  • queue.Queue.get_nowait()
  • queue.Queue.join()
  • queue.Queue.put()
  • queue.Queue.put_nowait()
  • queue.Queue.qsize()
  • queue.Queue.task_done()
  • sched
  • sched.scheduler
  • sched.scheduler.cancel()
  • sched.scheduler.empty()
  • sched.scheduler.enter()
  • sched.scheduler.enterabs()
  • sched.scheduler.queue
  • sched.scheduler.run()
  • subprocess
  • subprocess.call()
  • subprocess.CalledProcessError
  • subprocess.CalledProcessError.cmd
  • subprocess.CalledProcessError.output
  • subprocess.CalledProcessError.returncode
  • subprocess.CalledProcessError.stderr
  • subprocess.CalledProcessError.stdout
  • subprocess.check_call()
  • subprocess.check_output()
  • subprocess.CompletedProcess
  • subprocess.CompletedProcess.args
  • subprocess.CompletedProcess.check_returncode()
  • subprocess.CompletedProcess.returncode
  • subprocess.CompletedProcess.stderr
  • subprocess.CompletedProcess.stdout
  • subprocess.getoutput()
  • subprocess.getstatusoutput()
  • subprocess.Popen
  • subprocess.Popen.args
  • subprocess.Popen.communicate()
  • subprocess.Popen.kill()
  • subprocess.Popen.pid
  • subprocess.Popen.poll()
  • subprocess.Popen.returncode
  • subprocess.Popen.send_signal()
  • subprocess.Popen.stderr
  • subprocess.Popen.stdin
  • subprocess.Popen.stdout
  • subprocess.Popen.terminate()
  • subprocess.Popen.wait()
  • subprocess.run()
  • subprocess.STARTUPINFO
  • subprocess.STARTUPINFO.dwFlags
  • subprocess.STARTUPINFO.hStdError
  • subprocess.STARTUPINFO.hStdInput
  • subprocess.STARTUPINFO.hStdOutput
  • subprocess.STARTUPINFO.wShowWindow
  • subprocess.SubprocessError
  • subprocess.TimeoutExpired
  • subprocess.TimeoutExpired.cmd
  • subprocess.TimeoutExpired.output
  • subprocess.TimeoutExpired.stderr
  • subprocess.TimeoutExpired.stdout
  • subprocess.TimeoutExpired.timeout
  • The concurrent package
  • threading
  • threading.active_count()
  • threading.Barrier
  • threading.Barrier.abort()
  • threading.Barrier.broken
  • threading.Barrier.n_waiting
  • threading.Barrier.parties
  • threading.Barrier.reset()
  • threading.Barrier.wait()
  • threading.BoundedSemaphore
  • threading.BrokenBarrierError
  • threading.Condition
  • threading.Condition.acquire()
  • threading.Condition.notify()
  • threading.Condition.notify_all()
  • threading.Condition.release()
  • threading.Condition.wait()
  • threading.Condition.wait_for()
  • threading.current_thread()
  • threading.enumerate()
  • threading.Event
  • threading.Event.clear()
  • threading.Event.is_set()
  • threading.Event.set()
  • threading.Event.wait()
  • threading.get_ident()
  • threading.local
  • threading.Lock
  • threading.Lock.acquire()
  • threading.Lock.release()
  • threading.main_thread()
  • threading.RLock
  • threading.RLock.acquire()
  • threading.RLock.release()
  • threading.Semaphore
  • threading.Semaphore.acquire()
  • threading.Semaphore.release()
  • threading.setprofile()
  • threading.settrace()
  • threading.stack_size()
  • threading.Thread
  • threading.Thread.daemon
  • threading.Thread.getName()
  • threading.Thread.ident
  • threading.Thread.isDaemon()
  • threading.Thread.is_alive()
  • threading.Thread.join()
  • threading.Thread.name
  • threading.Thread.run()
  • threading.Thread.setDaemon()
  • threading.Thread.setName()
  • threading.Thread.start()
  • threading.Timer
  • threading.Timer.cancel()
  • _dummy_thread
  • _thread
  • _thread.allocate_lock()
  • _thread.error
  • _thread.exit()
  • _thread.get_ident()
  • _thread.interrupt_main()
  • _thread.lock.acquire()
  • _thread.lock.locked()
  • _thread.lock.release()
  • _thread.LockType
  • _thread.stack_size()
  • _thread.start_new_thread()
  • File Formats

  • configparser
  • configparser.BasicInterpolation
  • configparser.BOOLEAN_STATES
  • configparser.ConfigParser
  • configparser.ConfigParser.add_section()
  • configparser.ConfigParser.defaults()
  • configparser.ConfigParser.get()
  • configparser.ConfigParser.getboolean()
  • configparser.ConfigParser.getfloat()
  • configparser.ConfigParser.getint()
  • configparser.ConfigParser.has_option()
  • configparser.ConfigParser.has_section()
  • configparser.ConfigParser.items()
  • configparser.ConfigParser.options()
  • configparser.ConfigParser.optionxform()
  • configparser.ConfigParser.read()
  • configparser.ConfigParser.readfp()
  • configparser.ConfigParser.read_dict()
  • configparser.ConfigParser.read_file()
  • configparser.ConfigParser.read_string()
  • configparser.ConfigParser.remove_option()
  • configparser.ConfigParser.remove_section()
  • configparser.ConfigParser.sections()
  • configparser.ConfigParser.set()
  • configparser.ConfigParser.write()
  • configparser.DuplicateOptionError
  • configparser.DuplicateSectionError
  • configparser.Error
  • configparser.ExtendedInterpolation
  • configparser.InterpolationDepthError
  • configparser.InterpolationError
  • configparser.InterpolationMissingOptionError
  • configparser.InterpolationSyntaxError
  • configparser.MissingSectionHeaderError
  • configparser.NoOptionError
  • configparser.NoSectionError
  • configparser.optionxform()
  • configparser.ParsingError
  • configparser.RawConfigParser
  • configparser.RawConfigParser.add_section()
  • configparser.RawConfigParser.set()
  • configparser.SECTCRE
  • csv
  • csv.csvreader.dialect
  • csv.csvreader.fieldnames
  • csv.csvreader.line_num
  • csv.csvreader.__next__()
  • csv.csvwriter.dialect
  • csv.csvwriter.writerow()
  • csv.csvwriter.writerows()
  • csv.Dialect
  • csv.Dialect.delimiter
  • csv.Dialect.doublequote
  • csv.Dialect.escapechar
  • csv.Dialect.lineterminator
  • csv.Dialect.quotechar
  • csv.Dialect.quoting
  • csv.Dialect.skipinitialspace
  • csv.Dialect.strict
  • csv.DictReader
  • csv.DictWriter
  • csv.DictWriter.writeheader()
  • csv.Error
  • csv.excel
  • csv.excel_tab
  • csv.field_size_limit()
  • csv.get_dialect()
  • csv.list_dialects()
  • csv.reader()
  • csv.register_dialect()
  • csv.Sniffer
  • csv.Sniffer.has_header()
  • csv.Sniffer.sniff()
  • csv.unix_dialect
  • csv.unregister_dialect()
  • csv.writer()
  • netrc
  • netrc.netrc
  • netrc.netrc.authenticators()
  • netrc.netrc.hosts
  • netrc.netrc.macros
  • netrc.netrc.__repr__()
  • netrc.NetrcParseError
  • plistlib
  • plistlib.Data
  • plistlib.dump()
  • plistlib.dumps()
  • plistlib.load()
  • plistlib.loads()
  • plistlib.readPlist()
  • plistlib.readPlistFromBytes()
  • plistlib.writePlist()
  • plistlib.writePlistToBytes()
  • xdrlib
  • xdrlib.ConversionError
  • xdrlib.Error
  • xdrlib.Packer
  • xdrlib.Packer.get_buffer()
  • xdrlib.Packer.pack_array()
  • xdrlib.Packer.pack_bytes()
  • xdrlib.Packer.pack_double()
  • xdrlib.Packer.pack_farray()
  • xdrlib.Packer.pack_float()
  • xdrlib.Packer.pack_fopaque()
  • xdrlib.Packer.pack_fstring()
  • xdrlib.Packer.pack_list()
  • xdrlib.Packer.pack_opaque()
  • xdrlib.Packer.pack_string()
  • xdrlib.Packer.reset()
  • xdrlib.Unpacker
  • xdrlib.Unpacker.done()
  • xdrlib.Unpacker.get_buffer()
  • xdrlib.Unpacker.get_position()
  • xdrlib.Unpacker.reset()
  • xdrlib.Unpacker.set_position()
  • xdrlib.Unpacker.unpack_array()
  • xdrlib.Unpacker.unpack_bytes()
  • xdrlib.Unpacker.unpack_double()
  • xdrlib.Unpacker.unpack_farray()
  • xdrlib.Unpacker.unpack_float()
  • xdrlib.Unpacker.unpack_fopaque()
  • xdrlib.Unpacker.unpack_fstring()
  • xdrlib.Unpacker.unpack_list()
  • xdrlib.Unpacker.unpack_opaque()
  • xdrlib.Unpacker.unpack_string()
  • Data Persistence

  • copyreg
  • copyreg.constructor()
  • copyreg.pickle()
  • dbm
  • dbm.dumb.dumbdbm.close()
  • dbm.dumb.dumbdbm.sync()
  • dbm.dumb.error
  • dbm.dumb.open()
  • dbm.error
  • dbm.gnu.error
  • dbm.gnu.gdbm.close()
  • dbm.gnu.gdbm.firstkey()
  • dbm.gnu.gdbm.nextkey()
  • dbm.gnu.gdbm.reorganize()
  • dbm.gnu.gdbm.sync()
  • dbm.gnu.open()
  • dbm.ndbm.error
  • dbm.ndbm.library
  • dbm.ndbm.ndbm.close()
  • dbm.ndbm.open()
  • dbm.open()
  • dbm.whichdb()
  • marshal
  • marshal.dump()
  • marshal.dumps()
  • marshal.load()
  • marshal.loads()
  • marshal.version
  • object.__getnewargs_ex__()
  • object.__getnewargs__()
  • object.__getstate__()
  • object.__reduce_ex__()
  • object.__reduce__()
  • object.__setstate__()
  • pickle
  • pickle.dump()
  • pickle.dumps()
  • pickle.load()
  • pickle.loads()
  • pickle.PickleError
  • pickle.Pickler
  • pickle.Pickler.dispatch_table
  • pickle.Pickler.dump()
  • pickle.Pickler.fast
  • pickle.Pickler.persistent_id()
  • pickle.PicklingError
  • pickle.Unpickler
  • pickle.Unpickler.find_class()
  • pickle.Unpickler.load()
  • pickle.Unpickler.persistent_load()
  • pickle.UnpicklingError
  • shelve
  • shelve.BsdDbShelf
  • shelve.DbfilenameShelf
  • shelve.open()
  • shelve.Shelf
  • shelve.Shelf.close()
  • shelve.Shelf.sync()
  • sqlite3
  • sqlite3.complete_statement()
  • sqlite3.connect()
  • sqlite3.Connection
  • sqlite3.Connection.close()
  • sqlite3.Connection.commit()
  • sqlite3.Connection.create_aggregate()
  • sqlite3.Connection.create_collation()
  • sqlite3.Connection.create_function()
  • sqlite3.Connection.cursor()
  • sqlite3.Connection.enable_load_extension()
  • sqlite3.Connection.execute()
  • sqlite3.Connection.executemany()
  • sqlite3.Connection.executescript()
  • sqlite3.Connection.interrupt()
  • sqlite3.Connection.in_transaction
  • sqlite3.Connection.isolation_level
  • sqlite3.Connection.iterdump()
  • sqlite3.Connection.load_extension()
  • sqlite3.Connection.rollback()
  • sqlite3.Connection.row_factory
  • sqlite3.Connection.set_authorizer()
  • sqlite3.Connection.set_progress_handler()
  • sqlite3.Connection.set_trace_callback()
  • sqlite3.Connection.text_factory
  • sqlite3.Connection.total_changes
  • sqlite3.Cursor
  • sqlite3.Cursor.close()
  • sqlite3.Cursor.connection
  • sqlite3.Cursor.description
  • sqlite3.Cursor.execute()
  • sqlite3.Cursor.executemany()
  • sqlite3.Cursor.executescript()
  • sqlite3.Cursor.fetchall()
  • sqlite3.Cursor.fetchmany()
  • sqlite3.Cursor.fetchone()
  • sqlite3.Cursor.lastrowid
  • sqlite3.Cursor.rowcount
  • sqlite3.DatabaseError
  • sqlite3.enable_callback_tracebacks()
  • sqlite3.Error
  • sqlite3.IntegrityError
  • sqlite3.ProgrammingError
  • sqlite3.register_adapter()
  • sqlite3.register_converter()
  • sqlite3.Row
  • sqlite3.Row.keys()
  • sqlite3.sqlite_version
  • sqlite3.sqlite_version_info
  • sqlite3.version
  • sqlite3.version_info
  • sqlite3.Warning
  • Text Processing

  • difflib
  • difflib.context_diff()
  • difflib.Differ
  • difflib.Differ.compare()
  • difflib.diff_bytes()
  • difflib.get_close_matches()
  • difflib.HtmlDiff
  • difflib.HtmlDiff.make_file()
  • difflib.HtmlDiff.make_table()
  • difflib.HtmlDiff.__init__()
  • difflib.IS_CHARACTER_JUNK()
  • difflib.IS_LINE_JUNK()
  • difflib.ndiff()
  • difflib.restore()
  • difflib.SequenceMatcher
  • difflib.SequenceMatcher.find_longest_match()
  • difflib.SequenceMatcher.get_grouped_opcodes()
  • difflib.SequenceMatcher.get_matching_blocks()
  • difflib.SequenceMatcher.get_opcodes()
  • difflib.SequenceMatcher.quick_ratio()
  • difflib.SequenceMatcher.ratio()
  • difflib.SequenceMatcher.real_quick_ratio()
  • difflib.SequenceMatcher.set_seq1()
  • difflib.SequenceMatcher.set_seq2()
  • difflib.SequenceMatcher.set_seqs()
  • difflib.unified_diff()
  • re
  • re.compile()
  • re.error
  • re.error.colno
  • re.error.lineno
  • re.error.msg
  • re.error.pattern
  • re.error.pos
  • re.escape()
  • re.findall()
  • re.finditer()
  • re.fullmatch()
  • re.match()
  • re.match.end()
  • re.match.endpos
  • re.match.expand()
  • re.match.group()
  • re.match.groupdict()
  • re.match.groups()
  • re.match.lastgroup
  • re.match.lastindex
  • re.match.pos
  • re.match.re
  • re.match.span()
  • re.match.start()
  • re.match.string
  • re.purge()
  • re.regex.findall()
  • re.regex.finditer()
  • re.regex.flags
  • re.regex.fullmatch()
  • re.regex.groupindex
  • re.regex.groups
  • re.regex.match()
  • re.regex.pattern
  • re.regex.search()
  • re.regex.split()
  • re.regex.sub()
  • re.regex.subn()
  • re.search()
  • re.split()
  • re.sub()
  • re.subn()
  • readline
  • readline.add_history()
  • readline.append_history_file()
  • readline.clear_history()
  • readline.get_begidx()
  • readline.get_completer()
  • readline.get_completer_delims()
  • readline.get_completion_type()
  • readline.get_current_history_length()
  • readline.get_endidx()
  • readline.get_history_item()
  • readline.get_history_length()
  • readline.get_line_buffer()
  • readline.insert_text()
  • readline.parse_and_bind()
  • readline.read_history_file()
  • readline.read_init_file()
  • readline.redisplay()
  • readline.remove_history_item()
  • readline.replace_history_item()
  • readline.set_completer()
  • readline.set_completer_delims()
  • readline.set_completion_display_matches_hook()
  • readline.set_history_length()
  • readline.set_pre_input_hook()
  • readline.set_startup_hook()
  • readline.write_history_file()
  • rlcompleter
  • rlcompleter.Completer.complete()
  • string
  • string.ascii_letters
  • string.ascii_lowercase
  • string.ascii_uppercase
  • string.capwords()
  • string.digits
  • string.Formatter
  • string.Formatter.check_unused_args()
  • string.Formatter.convert_field()
  • string.Formatter.format()
  • string.Formatter.format_field()
  • string.Formatter.get_field()
  • string.Formatter.get_value()
  • string.Formatter.parse()
  • string.Formatter.vformat()
  • string.hexdigits
  • string.octdigits
  • string.printable
  • string.punctuation
  • string.Template
  • string.Template.safe_substitute()
  • string.Template.substitute()
  • string.Template.template
  • string.whitespace
  • stringprep
  • stringprep.in_table_a1()
  • stringprep.in_table_b1()
  • stringprep.in_table_c11()
  • stringprep.in_table_c11_c12()
  • stringprep.in_table_c12()
  • stringprep.in_table_c21()
  • stringprep.in_table_c21_c22()
  • stringprep.in_table_c22()
  • stringprep.in_table_c3()
  • stringprep.in_table_c4()
  • stringprep.in_table_c5()
  • stringprep.in_table_c6()
  • stringprep.in_table_c7()
  • stringprep.in_table_c8()
  • stringprep.in_table_c9()
  • stringprep.in_table_d1()
  • stringprep.in_table_d2()
  • stringprep.map_table_b2()
  • stringprep.map_table_b3()
  • textwrap
  • textwrap.dedent()
  • textwrap.fill()
  • textwrap.indent()
  • textwrap.shorten()
  • textwrap.TextWrapper
  • textwrap.TextWrapper.break_long_words
  • textwrap.TextWrapper.break_on_hyphens
  • textwrap.TextWrapper.drop_whitespace
  • textwrap.TextWrapper.expand_tabs
  • textwrap.TextWrapper.fill()
  • textwrap.TextWrapper.fix_sentence_endings
  • textwrap.TextWrapper.initial_indent
  • textwrap.TextWrapper.max_lines
  • textwrap.TextWrapper.placeholder
  • textwrap.TextWrapper.replace_whitespace
  • textwrap.TextWrapper.subsequent_indent
  • textwrap.TextWrapper.tabsize
  • textwrap.TextWrapper.width
  • textwrap.TextWrapper.wrap()
  • textwrap.wrap()
  • unicodedata
  • unicodedata.bidirectional()
  • unicodedata.category()
  • unicodedata.combining()
  • unicodedata.decimal()
  • unicodedata.decomposition()
  • unicodedata.digit()
  • unicodedata.east_asian_width()
  • unicodedata.lookup()
  • unicodedata.mirrored()
  • unicodedata.name()
  • unicodedata.normalize()
  • unicodedata.numeric()
  • unicodedata.ucd_3_2_0
  • unicodedata.unidata_version
  • Development Tools

  • doctest
  • doctest.debug()
  • doctest.DebugRunner
  • doctest.debug_src()
  • doctest.DocFileSuite()
  • doctest.DocTest
  • doctest.DocTest.docstring
  • doctest.DocTest.examples
  • doctest.DocTest.filename
  • doctest.DocTest.globs
  • doctest.DocTest.lineno
  • doctest.DocTest.name
  • doctest.DocTestFailure
  • doctest.DocTestFailure.example
  • doctest.DocTestFailure.got
  • doctest.DocTestFailure.test
  • doctest.DocTestFinder
  • doctest.DocTestFinder.find()
  • doctest.DocTestParser
  • doctest.DocTestParser.get_doctest()
  • doctest.DocTestParser.get_examples()
  • doctest.DocTestParser.parse()
  • doctest.DocTestRunner
  • doctest.DocTestRunner.report_failure()
  • doctest.DocTestRunner.report_start()
  • doctest.DocTestRunner.report_success()
  • doctest.DocTestRunner.report_unexpected_exception()
  • doctest.DocTestRunner.run()
  • doctest.DocTestRunner.summarize()
  • doctest.DocTestSuite()
  • doctest.Example
  • doctest.Example.exc_msg
  • doctest.Example.indent
  • doctest.Example.lineno
  • doctest.Example.options
  • doctest.Example.source
  • doctest.Example.want
  • doctest.OutputChecker
  • doctest.OutputChecker.check_output()
  • doctest.OutputChecker.output_difference()
  • doctest.register_optionflag()
  • doctest.run_docstring_examples()
  • doctest.script_from_examples()
  • doctest.set_unittest_reportflags()
  • doctest.testfile()
  • doctest.testmod()
  • doctest.testsource()
  • doctest.UnexpectedException
  • doctest.UnexpectedException.example
  • doctest.UnexpectedException.exc_info
  • doctest.UnexpectedException.test
  • pydoc
  • test
  • test.support.anticipate_failure()
  • test.support.bind_port()
  • test.support.can_symlink()
  • test.support.captured_stderr()
  • test.support.captured_stdin()
  • test.support.captured_stdout()
  • test.support.change_cwd()
  • test.support.check_warnings()
  • test.support.EnvironmentVarGuard
  • test.support.EnvironmentVarGuard.set()
  • test.support.EnvironmentVarGuard.unset()
  • test.support.findfile()
  • test.support.find_unused_port()
  • test.support.forget()
  • test.support.import_fresh_module()
  • test.support.import_module()
  • test.support.is_jython
  • test.support.is_resource_enabled()
  • test.support.load_package_tests()
  • test.support.make_bad_fd()
  • test.support.requires()
  • test.support.ResourceDenied
  • test.support.run_doctest()
  • test.support.run_unittest()
  • test.support.run_with_locale()
  • test.support.skip_unless_symlink()
  • test.support.SuppressCrashReport
  • test.support.temp_cwd()
  • test.support.temp_dir()
  • test.support.temp_umask()
  • test.support.TestFailed
  • test.support.TransientResource
  • test.support.verbose
  • test.support.WarningsRecorder
  • typing
  • typing.AbstractSet
  • typing.Any
  • typing.AnyStr
  • typing.AsyncGenerator
  • typing.AsyncIterable
  • typing.AsyncIterator
  • typing.Awaitable
  • typing.ByteString
  • typing.Callable
  • typing.cast()
  • typing.ClassVar
  • typing.Container
  • typing.Coroutine
  • typing.DefaultDict
  • typing.Deque
  • typing.Dict
  • typing.FrozenSet
  • typing.Generator
  • typing.Generic
  • typing.get_type_hints()
  • typing.Hashable
  • typing.io
  • typing.ItemsView
  • typing.Iterable
  • typing.Iterator
  • typing.KeysView
  • typing.List
  • typing.Mapping
  • typing.MappingView
  • typing.MutableMapping
  • typing.MutableSequence
  • typing.MutableSet
  • typing.NamedTuple()
  • typing.NewType()
  • typing.no_type_check()
  • typing.no_type_check_decorator()
  • typing.Optional
  • typing.overload()
  • typing.re
  • typing.Reversible
  • typing.Sequence
  • typing.Set
  • typing.Sized
  • typing.SupportsAbs
  • typing.SupportsFloat
  • typing.SupportsInt
  • typing.SupportsRound
  • typing.Text
  • typing.Tuple
  • typing.Type
  • typing.TypeVar
  • typing.Union
  • typing.ValuesView
  • unittest
  • unittest.defaultTestLoader
  • unittest.expectedFailure()
  • unittest.FunctionTestCase
  • unittest.installHandler()
  • unittest.main()
  • unittest.mock
  • unittest.mock.call()
  • unittest.mock.call.call_list()
  • unittest.mock.create_autospec()
  • unittest.mock.MagicMock
  • unittest.mock.Mock
  • unittest.mock.Mock.assert_any_call()
  • unittest.mock.Mock.assert_called_once_with()
  • unittest.mock.Mock.assert_called_with()
  • unittest.mock.Mock.assert_has_calls()
  • unittest.mock.Mock.assert_not_called()
  • unittest.mock.Mock.attach_mock()
  • unittest.mock.Mock.called
  • unittest.mock.Mock.call_args
  • unittest.mock.Mock.call_args_list
  • unittest.mock.Mock.call_count
  • unittest.mock.Mock.configure_mock()
  • unittest.mock.Mock.method_calls
  • unittest.mock.Mock.mock_add_spec()
  • unittest.mock.Mock.mock_calls
  • unittest.mock.Mock.reset_mock()
  • unittest.mock.Mock.return_value
  • unittest.mock.Mock.side_effect
  • unittest.mock.Mock._get_child_mock()
  • unittest.mock.Mock.__class__
  • unittest.mock.Mock.__dir__()
  • unittest.mock.mock_open()
  • unittest.mock.NonCallableMagicMock
  • unittest.mock.NonCallableMock
  • unittest.mock.patch()
  • unittest.mock.patch.dict()
  • unittest.mock.patch.multiple()
  • unittest.mock.patch.object()
  • unittest.mock.patch.stopall()
  • unittest.mock.PropertyMock
  • unittest.mock.sentinel
  • unittest.registerResult()
  • unittest.removeHandler()
  • unittest.removeResult()
  • unittest.skip()
  • unittest.skipIf()
  • unittest.SkipTest
  • unittest.skipUnless()
  • unittest.TestCase
  • unittest.TestCase.addCleanup()
  • unittest.TestCase.addTypeEqualityFunc()
  • unittest.TestCase.assertAlmostEqual()
  • unittest.TestCase.assertCountEqual()
  • unittest.TestCase.assertDictEqual()
  • unittest.TestCase.assertEqual()
  • unittest.TestCase.assertFalse()
  • unittest.TestCase.assertGreater()
  • unittest.TestCase.assertGreaterEqual()
  • unittest.TestCase.assertIn()
  • unittest.TestCase.assertIs()
  • unittest.TestCase.assertIsInstance()
  • unittest.TestCase.assertIsNone()
  • unittest.TestCase.assertIsNot()
  • unittest.TestCase.assertIsNotNone()
  • unittest.TestCase.assertLess()
  • unittest.TestCase.assertLessEqual()
  • unittest.TestCase.assertListEqual()
  • unittest.TestCase.assertLogs()
  • unittest.TestCase.assertMultiLineEqual()
  • unittest.TestCase.assertNotAlmostEqual()
  • unittest.TestCase.assertNotEqual()
  • unittest.TestCase.assertNotIn()
  • unittest.TestCase.assertNotIsInstance()
  • unittest.TestCase.assertNotRegex()
  • unittest.TestCase.assertRaises()
  • unittest.TestCase.assertRaisesRegex()
  • unittest.TestCase.assertRegex()
  • unittest.TestCase.assertSequenceEqual()
  • unittest.TestCase.assertSetEqual()
  • unittest.TestCase.assertTrue()
  • unittest.TestCase.assertTupleEqual()
  • unittest.TestCase.assertWarns()
  • unittest.TestCase.assertWarnsRegex()
  • unittest.TestCase.countTestCases()
  • unittest.TestCase.debug()
  • unittest.TestCase.defaultTestResult()
  • unittest.TestCase.doCleanups()
  • unittest.TestCase.fail()
  • unittest.TestCase.failureException
  • unittest.TestCase.id()
  • unittest.TestCase.longMessage
  • unittest.TestCase.maxDiff
  • unittest.TestCase.output
  • unittest.TestCase.records
  • unittest.TestCase.run()
  • unittest.TestCase.setUp()
  • unittest.TestCase.setUpClass()
  • unittest.TestCase.shortDescription()
  • unittest.TestCase.skipTest()
  • unittest.TestCase.subTest()
  • unittest.TestCase.tearDown()
  • unittest.TestCase.tearDownClass()
  • unittest.TestLoader
  • unittest.TestLoader.discover()
  • unittest.TestLoader.errors
  • unittest.TestLoader.getTestCaseNames()
  • unittest.TestLoader.loadTestsFromModule()
  • unittest.TestLoader.loadTestsFromName()
  • unittest.TestLoader.loadTestsFromNames()
  • unittest.TestLoader.loadTestsFromTestCase()
  • unittest.TestLoader.sortTestMethodsUsing
  • unittest.TestLoader.suiteClass
  • unittest.TestLoader.testMethodPrefix
  • unittest.TestResult
  • unittest.TestResult.addError()
  • unittest.TestResult.addExpectedFailure()
  • unittest.TestResult.addFailure()
  • unittest.TestResult.addSkip()
  • unittest.TestResult.addSubTest()
  • unittest.TestResult.addSuccess()
  • unittest.TestResult.addUnexpectedSuccess()
  • unittest.TestResult.buffer
  • unittest.TestResult.errors
  • unittest.TestResult.expectedFailures
  • unittest.TestResult.failfast
  • unittest.TestResult.failures
  • unittest.TestResult.shouldStop
  • unittest.TestResult.skipped
  • unittest.TestResult.startTest()
  • unittest.TestResult.startTestRun()
  • unittest.TestResult.stop()
  • unittest.TestResult.stopTest()
  • unittest.TestResult.stopTestRun()
  • unittest.TestResult.tb_locals
  • unittest.TestResult.testsRun
  • unittest.TestResult.unexpectedSuccesses
  • unittest.TestResult.wasSuccessful()
  • unittest.TestSuite
  • unittest.TestSuite.addTest()
  • unittest.TestSuite.addTests()
  • unittest.TestSuite.countTestCases()
  • unittest.TestSuite.debug()
  • unittest.TestSuite.run()
  • unittest.TestSuite.__iter__()
  • unittest.TextTestResult
  • unittest.TextTestRunner
  • unittest.TextTestRunner.run()
  • unittest.TextTestRunner._makeResult()
  • File & Directory Access

  • File and Directory Access
  • filecmp
  • filecmp.clear_cache()
  • filecmp.cmp()
  • filecmp.cmpfiles()
  • filecmp.DEFAULT_IGNORES
  • filecmp.dircmp
  • filecmp.dircmp.common
  • filecmp.dircmp.common_dirs
  • filecmp.dircmp.common_files
  • filecmp.dircmp.common_funny
  • filecmp.dircmp.diff_files
  • filecmp.dircmp.funny_files
  • filecmp.dircmp.left
  • filecmp.dircmp.left_list
  • filecmp.dircmp.left_only
  • filecmp.dircmp.report()
  • filecmp.dircmp.report_full_closure()
  • filecmp.dircmp.report_partial_closure()
  • filecmp.dircmp.right
  • filecmp.dircmp.right_list
  • filecmp.dircmp.right_only
  • filecmp.dircmp.same_files
  • filecmp.dircmp.subdirs
  • fileinput
  • fileinput.close()
  • fileinput.FileInput
  • fileinput.filelineno()
  • fileinput.filename()
  • fileinput.fileno()
  • fileinput.hook_compressed()
  • fileinput.hook_encoded()
  • fileinput.input()
  • fileinput.isfirstline()
  • fileinput.isstdin()
  • fileinput.lineno()
  • fileinput.nextfile()
  • fnmatch
  • fnmatch.filter()
  • fnmatch.fnmatch()
  • fnmatch.fnmatchcase()
  • fnmatch.translate()
  • glob
  • glob.escape()
  • glob.glob()
  • glob.iglob()
  • linecache
  • linecache.checkcache()
  • linecache.clearcache()
  • linecache.getline()
  • linecache.lazycache()
  • macpath
  • os.path
  • os.path.abspath()
  • os.path.basename()
  • os.path.commonpath()
  • os.path.commonprefix()
  • os.path.dirname()
  • os.path.exists()
  • os.path.expanduser()
  • os.path.expandvars()
  • os.path.getatime()
  • os.path.getctime()
  • os.path.getmtime()
  • os.path.getsize()
  • os.path.isabs()
  • os.path.isdir()
  • os.path.isfile()
  • os.path.islink()
  • os.path.ismount()
  • os.path.join()
  • os.path.lexists()
  • os.path.normcase()
  • os.path.normpath()
  • os.path.realpath()
  • os.path.relpath()
  • os.path.samefile()
  • os.path.sameopenfile()
  • os.path.samestat()
  • os.path.split()
  • os.path.splitdrive()
  • os.path.splitext()
  • os.path.splitunc()
  • os.path.supports_unicode_filenames
  • pathlib
  • pathlib.Path
  • pathlib.Path.chmod()
  • pathlib.Path.cwd()
  • pathlib.Path.exists()
  • pathlib.Path.expanduser()
  • pathlib.Path.glob()
  • pathlib.Path.group()
  • pathlib.Path.home()
  • pathlib.Path.is_block_device()
  • pathlib.Path.is_char_device()
  • pathlib.Path.is_dir()
  • pathlib.Path.is_fifo()
  • pathlib.Path.is_file()
  • pathlib.Path.is_socket()
  • pathlib.Path.is_symlink()
  • pathlib.Path.iterdir()
  • pathlib.Path.lchmod()
  • pathlib.Path.lstat()
  • pathlib.Path.mkdir()
  • pathlib.Path.open()
  • pathlib.Path.owner()
  • pathlib.Path.read_bytes()
  • pathlib.Path.read_text()
  • pathlib.Path.rename()
  • pathlib.Path.replace()
  • pathlib.Path.resolve()
  • pathlib.Path.rglob()
  • pathlib.Path.rmdir()
  • pathlib.Path.samefile()
  • pathlib.Path.stat()
  • pathlib.Path.symlink_to()
  • pathlib.Path.touch()
  • pathlib.Path.unlink()
  • pathlib.Path.write_bytes()
  • pathlib.Path.write_text()
  • pathlib.PosixPath
  • pathlib.PurePath
  • pathlib.PurePath.anchor
  • pathlib.PurePath.as_posix()
  • pathlib.PurePath.as_uri()
  • pathlib.PurePath.drive
  • pathlib.PurePath.is_absolute()
  • pathlib.PurePath.is_reserved()
  • pathlib.PurePath.joinpath()
  • pathlib.PurePath.match()
  • pathlib.PurePath.name
  • pathlib.PurePath.parent
  • pathlib.PurePath.parents
  • pathlib.PurePath.parts
  • pathlib.PurePath.relative_to()
  • pathlib.PurePath.root
  • pathlib.PurePath.stem
  • pathlib.PurePath.suffix
  • pathlib.PurePath.suffixes
  • pathlib.PurePath.with_name()
  • pathlib.PurePath.with_suffix()
  • pathlib.PurePosixPath
  • pathlib.PureWindowsPath
  • pathlib.WindowsPath
  • shutil
  • shutil.chown()
  • shutil.copy()
  • shutil.copy2()
  • shutil.copyfile()
  • shutil.copyfileobj()
  • shutil.copymode()
  • shutil.copystat()
  • shutil.copytree()
  • shutil.disk_usage()
  • shutil.Error
  • shutil.get_archive_formats()
  • shutil.get_terminal_size()
  • shutil.get_unpack_formats()
  • shutil.ignore_patterns()
  • shutil.make_archive()
  • shutil.move()
  • shutil.register_archive_format()
  • shutil.register_unpack_format()
  • shutil.rmtree()
  • shutil.rmtree.avoids_symlink_attacks
  • shutil.SameFileError
  • shutil.unpack_archive()
  • shutil.unregister_archive_format()
  • shutil.unregister_unpack_format()
  • shutil.which()
  • stat
  • stat.filemode()
  • stat.S_IFMT()
  • stat.S_IMODE()
  • stat.S_ISBLK()
  • stat.S_ISCHR()
  • stat.S_ISDIR()
  • stat.S_ISDOOR()
  • stat.S_ISFIFO()
  • stat.S_ISLNK()
  • stat.S_ISPORT()
  • stat.S_ISREG()
  • stat.S_ISSOCK()
  • stat.S_ISWHT()
  • tempfile
  • tempfile.gettempdir()
  • tempfile.gettempdirb()
  • tempfile.gettempprefix()
  • tempfile.gettempprefixb()
  • tempfile.mkdtemp()
  • tempfile.mkstemp()
  • tempfile.mktemp()
  • tempfile.NamedTemporaryFile()
  • tempfile.SpooledTemporaryFile()
  • tempfile.tempdir
  • tempfile.TemporaryDirectory()
  • tempfile.TemporaryFile()
  • Functional Programming

  • functools
  • functools.cmp_to_key()
  • functools.lru_cache()
  • functools.partial()
  • functools.partial.args
  • functools.partial.func
  • functools.partial.keywords
  • functools.partialmethod
  • functools.reduce()
  • functools.singledispatch()
  • functools.total_ordering()
  • functools.update_wrapper()
  • functools.wraps()
  • itertools
  • itertools.accumulate()
  • itertools.chain()
  • itertools.chain.from_iterable()
  • itertools.combinations()
  • itertools.combinations_with_replacement()
  • itertools.compress()
  • itertools.count()
  • itertools.cycle()
  • itertools.dropwhile()
  • itertools.filterfalse()
  • itertools.groupby()
  • itertools.islice()
  • itertools.permutations()
  • itertools.product()
  • itertools.repeat()
  • itertools.starmap()
  • itertools.takewhile()
  • itertools.tee()
  • itertools.zip_longest()
  • operator
  • operator.abs()
  • operator.add()
  • operator.and_()
  • operator.attrgetter()
  • operator.concat()
  • operator.contains()
  • operator.countOf()
  • operator.delitem()
  • operator.eq()
  • operator.floordiv()
  • operator.ge()
  • operator.getitem()
  • operator.gt()
  • operator.iadd()
  • operator.iand()
  • operator.iconcat()
  • operator.ifloordiv()
  • operator.ilshift()
  • operator.imatmul()
  • operator.imod()
  • operator.imul()
  • operator.index()
  • operator.indexOf()
  • operator.inv()
  • operator.invert()
  • operator.ior()
  • operator.ipow()
  • operator.irshift()
  • operator.isub()
  • operator.is_()
  • operator.is_not()
  • operator.itemgetter()
  • operator.itruediv()
  • operator.ixor()
  • operator.le()
  • operator.length_hint()
  • operator.lshift()
  • operator.lt()
  • operator.matmul()
  • operator.methodcaller()
  • operator.mod()
  • operator.mul()
  • operator.ne()
  • operator.neg()
  • operator.not_()
  • operator.or_()
  • operator.pos()
  • operator.pow()
  • operator.rshift()
  • operator.setitem()
  • operator.sub()
  • operator.truediv()
  • operator.truth()
  • operator.xor()
  • operator.__abs__()
  • operator.__add__()
  • operator.__and__()
  • operator.__concat__()
  • operator.__contains__()
  • operator.__delitem__()
  • operator.__eq__()
  • operator.__floordiv__()
  • operator.__getitem__()
  • operator.__ge__()
  • operator.__gt__()
  • operator.__iadd__()
  • operator.__iand__()
  • operator.__iconcat__()
  • operator.__ifloordiv__()
  • operator.__ilshift__()
  • operator.__imatmul__()
  • operator.__imod__()
  • operator.__imul__()
  • operator.__index__()
  • operator.__invert__()
  • operator.__inv__()
  • operator.__ior__()
  • operator.__ipow__()
  • operator.__irshift__()
  • operator.__isub__()
  • operator.__itruediv__()
  • operator.__ixor__()
  • operator.__le__()
  • operator.__lshift__()
  • operator.__lt__()
  • operator.__matmul__()
  • operator.__mod__()
  • operator.__mul__()
  • operator.__neg__()
  • operator.__ne__()
  • operator.__not__()
  • operator.__or__()
  • operator.__pos__()
  • operator.__pow__()
  • operator.__rshift__()
  • operator.__setitem__()
  • operator.__sub__()
  • operator.__truediv__()
  • operator.__xor__()
  • Structured Markup

  • html
  • html.entities
  • html.entities.codepoint2name
  • html.entities.entitydefs
  • html.entities.html5
  • html.entities.name2codepoint
  • html.escape()
  • html.parser
  • html.parser.HTMLParser
  • html.parser.HTMLParser.close()
  • html.parser.HTMLParser.feed()
  • html.parser.HTMLParser.getpos()
  • html.parser.HTMLParser.get_starttag_text()
  • html.parser.HTMLParser.handle_charref()
  • html.parser.HTMLParser.handle_comment()
  • html.parser.HTMLParser.handle_data()
  • html.parser.HTMLParser.handle_decl()
  • html.parser.HTMLParser.handle_endtag()
  • html.parser.HTMLParser.handle_entityref()
  • html.parser.HTMLParser.handle_pi()
  • html.parser.HTMLParser.handle_startendtag()
  • html.parser.HTMLParser.handle_starttag()
  • html.parser.HTMLParser.reset()
  • html.parser.HTMLParser.unknown_decl()
  • html.unescape()
  • XML Processing Modules
  • xml.dom
  • xml.dom.Attr.localName
  • xml.dom.Attr.name
  • xml.dom.Attr.prefix
  • xml.dom.Attr.value
  • xml.dom.Comment.data
  • xml.dom.Document.createAttribute()
  • xml.dom.Document.createAttributeNS()
  • xml.dom.Document.createComment()
  • xml.dom.Document.createElement()
  • xml.dom.Document.createElementNS()
  • xml.dom.Document.createProcessingInstruction()
  • xml.dom.Document.createTextNode()
  • xml.dom.Document.documentElement
  • xml.dom.Document.getElementsByTagName()
  • xml.dom.Document.getElementsByTagNameNS()
  • xml.dom.DocumentType.entities
  • xml.dom.DocumentType.internalSubset
  • xml.dom.DocumentType.name
  • xml.dom.DocumentType.notations
  • xml.dom.DocumentType.publicId
  • xml.dom.DocumentType.systemId
  • xml.dom.DOMException
  • xml.dom.DOMImplementation.createDocument()
  • xml.dom.DOMImplementation.createDocumentType()
  • xml.dom.DOMImplementation.hasFeature()
  • xml.dom.DomstringSizeErr
  • xml.dom.Element.getAttribute()
  • xml.dom.Element.getAttributeNode()
  • xml.dom.Element.getAttributeNodeNS()
  • xml.dom.Element.getAttributeNS()
  • xml.dom.Element.getElementsByTagName()
  • xml.dom.Element.getElementsByTagNameNS()
  • xml.dom.Element.hasAttribute()
  • xml.dom.Element.hasAttributeNS()
  • xml.dom.Element.removeAttribute()
  • xml.dom.Element.removeAttributeNode()
  • xml.dom.Element.removeAttributeNS()
  • xml.dom.Element.setAttribute()
  • xml.dom.Element.setAttributeNode()
  • xml.dom.Element.setAttributeNodeNS()
  • xml.dom.Element.setAttributeNS()
  • xml.dom.Element.tagName
  • xml.dom.getDOMImplementation()
  • xml.dom.HierarchyRequestErr
  • xml.dom.IndexSizeErr
  • xml.dom.InuseAttributeErr
  • xml.dom.InvalidAccessErr
  • xml.dom.InvalidCharacterErr
  • xml.dom.InvalidModificationErr
  • xml.dom.InvalidStateErr
  • xml.dom.minidom
  • xml.dom.minidom.Node.toprettyxml()
  • xml.dom.minidom.Node.toxml()
  • xml.dom.minidom.Node.unlink()
  • xml.dom.minidom.Node.writexml()
  • xml.dom.minidom.parse()
  • xml.dom.minidom.parseString()
  • xml.dom.NamedNodeMap.item()
  • xml.dom.NamedNodeMap.length
  • xml.dom.NamespaceErr
  • xml.dom.NoDataAllowedErr
  • xml.dom.Node.appendChild()
  • xml.dom.Node.attributes
  • xml.dom.Node.childNodes
  • xml.dom.Node.cloneNode()
  • xml.dom.Node.firstChild
  • xml.dom.Node.hasAttributes()
  • xml.dom.Node.hasChildNodes()
  • xml.dom.Node.insertBefore()
  • xml.dom.Node.isSameNode()
  • xml.dom.Node.lastChild
  • xml.dom.Node.localName
  • xml.dom.Node.namespaceURI
  • xml.dom.Node.nextSibling
  • xml.dom.Node.nodeName
  • xml.dom.Node.nodeType
  • xml.dom.Node.nodeValue
  • xml.dom.Node.normalize()
  • xml.dom.Node.parentNode
  • xml.dom.Node.prefix
  • xml.dom.Node.previousSibling
  • xml.dom.Node.removeChild()
  • xml.dom.Node.replaceChild()
  • xml.dom.NodeList.item()
  • xml.dom.NodeList.length
  • xml.dom.NoModificationAllowedErr
  • xml.dom.NotFoundErr
  • xml.dom.NotSupportedErr
  • xml.dom.ProcessingInstruction.data
  • xml.dom.ProcessingInstruction.target
  • xml.dom.pulldom
  • xml.dom.pulldom.default_bufsize
  • xml.dom.pulldom.DOMEventStream
  • xml.dom.pulldom.DOMEventStream.expandNode()
  • xml.dom.pulldom.DOMEventStream.getEvent()
  • xml.dom.pulldom.DOMEventStream.reset()
  • xml.dom.pulldom.parse()
  • xml.dom.pulldom.parseString()
  • xml.dom.pulldom.PullDom
  • xml.dom.pulldom.SAX2DOM
  • xml.dom.registerDOMImplementation()
  • xml.dom.SyntaxErr
  • xml.dom.Text.data
  • xml.dom.WrongDocumentErr
  • xml.etree.ElementTree
  • xml.etree.ElementTree.Comment()
  • xml.etree.ElementTree.dump()
  • xml.etree.ElementTree.Element
  • xml.etree.ElementTree.Element.append()
  • xml.etree.ElementTree.Element.attrib
  • xml.etree.ElementTree.Element.clear()
  • xml.etree.ElementTree.Element.extend()
  • xml.etree.ElementTree.Element.find()
  • xml.etree.ElementTree.Element.findall()
  • xml.etree.ElementTree.Element.findtext()
  • xml.etree.ElementTree.Element.get()
  • xml.etree.ElementTree.Element.getchildren()
  • xml.etree.ElementTree.Element.getiterator()
  • xml.etree.ElementTree.Element.insert()
  • xml.etree.ElementTree.Element.items()
  • xml.etree.ElementTree.Element.iter()
  • xml.etree.ElementTree.Element.iterfind()
  • xml.etree.ElementTree.Element.itertext()
  • xml.etree.ElementTree.Element.keys()
  • xml.etree.ElementTree.Element.makeelement()
  • xml.etree.ElementTree.Element.remove()
  • xml.etree.ElementTree.Element.set()
  • xml.etree.ElementTree.Element.tag
  • xml.etree.ElementTree.Element.tail
  • xml.etree.ElementTree.Element.text
  • xml.etree.ElementTree.ElementTree
  • xml.etree.ElementTree.ElementTree.find()
  • xml.etree.ElementTree.ElementTree.findall()
  • xml.etree.ElementTree.ElementTree.findtext()
  • xml.etree.ElementTree.ElementTree.getiterator()
  • xml.etree.ElementTree.ElementTree.getroot()
  • xml.etree.ElementTree.ElementTree.iter()
  • xml.etree.ElementTree.ElementTree.iterfind()
  • xml.etree.ElementTree.ElementTree.parse()
  • xml.etree.ElementTree.ElementTree.write()
  • xml.etree.ElementTree.ElementTree._setroot()
  • xml.etree.ElementTree.fromstring()
  • xml.etree.ElementTree.fromstringlist()
  • xml.etree.ElementTree.iselement()
  • xml.etree.ElementTree.iterparse()
  • xml.etree.ElementTree.parse()
  • xml.etree.ElementTree.ParseError
  • xml.etree.ElementTree.ParseError.code
  • xml.etree.ElementTree.ParseError.position
  • xml.etree.ElementTree.ProcessingInstruction()
  • xml.etree.ElementTree.QName
  • xml.etree.ElementTree.register_namespace()
  • xml.etree.ElementTree.SubElement()
  • xml.etree.ElementTree.tostring()
  • xml.etree.ElementTree.tostringlist()
  • xml.etree.ElementTree.TreeBuilder
  • xml.etree.ElementTree.TreeBuilder.close()
  • xml.etree.ElementTree.TreeBuilder.data()
  • xml.etree.ElementTree.TreeBuilder.doctype()
  • xml.etree.ElementTree.TreeBuilder.end()
  • xml.etree.ElementTree.TreeBuilder.start()
  • xml.etree.ElementTree.XML()
  • xml.etree.ElementTree.XMLID()
  • xml.etree.ElementTree.XMLParser
  • xml.etree.ElementTree.XMLParser.close()
  • xml.etree.ElementTree.XMLParser.doctype()
  • xml.etree.ElementTree.XMLParser.feed()
  • xml.etree.ElementTree.XMLPullParser
  • xml.etree.ElementTree.XMLPullParser.close()
  • xml.etree.ElementTree.XMLPullParser.feed()
  • xml.etree.ElementTree.XMLPullParser.read_events()
  • xml.parsers.expat
  • xml.parsers.expat.error
  • xml.parsers.expat.errors.codes
  • xml.parsers.expat.errors.messages
  • xml.parsers.expat.ErrorString()
  • xml.parsers.expat.ExpatError
  • xml.parsers.expat.ExpatError.code
  • xml.parsers.expat.ExpatError.lineno
  • xml.parsers.expat.ExpatError.offset
  • xml.parsers.expat.ParserCreate()
  • xml.parsers.expat.xmlparser.AttlistDeclHandler()
  • xml.parsers.expat.xmlparser.buffer_size
  • xml.parsers.expat.xmlparser.buffer_text
  • xml.parsers.expat.xmlparser.buffer_used
  • xml.parsers.expat.xmlparser.CharacterDataHandler()
  • xml.parsers.expat.xmlparser.CommentHandler()
  • xml.parsers.expat.xmlparser.CurrentByteIndex
  • xml.parsers.expat.xmlparser.CurrentColumnNumber
  • xml.parsers.expat.xmlparser.CurrentLineNumber
  • xml.parsers.expat.xmlparser.DefaultHandler()
  • xml.parsers.expat.xmlparser.DefaultHandlerExpand()
  • xml.parsers.expat.xmlparser.ElementDeclHandler()
  • xml.parsers.expat.xmlparser.EndCdataSectionHandler()
  • xml.parsers.expat.xmlparser.EndDoctypeDeclHandler()
  • xml.parsers.expat.xmlparser.EndElementHandler()
  • xml.parsers.expat.xmlparser.EndNamespaceDeclHandler()
  • xml.parsers.expat.xmlparser.EntityDeclHandler()
  • xml.parsers.expat.xmlparser.ErrorByteIndex
  • xml.parsers.expat.xmlparser.ErrorCode
  • xml.parsers.expat.xmlparser.ErrorColumnNumber
  • xml.parsers.expat.xmlparser.ErrorLineNumber
  • xml.parsers.expat.xmlparser.ExternalEntityParserCreate()
  • xml.parsers.expat.xmlparser.ExternalEntityRefHandler()
  • xml.parsers.expat.xmlparser.GetBase()
  • xml.parsers.expat.xmlparser.GetInputContext()
  • xml.parsers.expat.xmlparser.NotationDeclHandler()
  • xml.parsers.expat.xmlparser.NotStandaloneHandler()
  • xml.parsers.expat.xmlparser.ordered_attributes
  • xml.parsers.expat.xmlparser.Parse()
  • xml.parsers.expat.xmlparser.ParseFile()
  • xml.parsers.expat.xmlparser.ProcessingInstructionHandler()
  • xml.parsers.expat.xmlparser.SetBase()
  • xml.parsers.expat.xmlparser.SetParamEntityParsing()
  • xml.parsers.expat.xmlparser.specified_attributes
  • xml.parsers.expat.xmlparser.StartCdataSectionHandler()
  • xml.parsers.expat.xmlparser.StartDoctypeDeclHandler()
  • xml.parsers.expat.xmlparser.StartElementHandler()
  • xml.parsers.expat.xmlparser.StartNamespaceDeclHandler()
  • xml.parsers.expat.xmlparser.UnparsedEntityDeclHandler()
  • xml.parsers.expat.xmlparser.UseForeignDTD()
  • xml.parsers.expat.xmlparser.XmlDeclHandler()
  • xml.parsers.expat.XMLParserType
  • xml.sax
  • xml.sax.handler
  • xml.sax.handler.all_features
  • xml.sax.handler.all_properties
  • xml.sax.handler.ContentHandler
  • xml.sax.handler.ContentHandler.characters()
  • xml.sax.handler.ContentHandler.endDocument()
  • xml.sax.handler.ContentHandler.endElement()
  • xml.sax.handler.ContentHandler.endElementNS()
  • xml.sax.handler.ContentHandler.endPrefixMapping()
  • xml.sax.handler.ContentHandler.ignorableWhitespace()
  • xml.sax.handler.ContentHandler.processingInstruction()
  • xml.sax.handler.ContentHandler.setDocumentLocator()
  • xml.sax.handler.ContentHandler.skippedEntity()
  • xml.sax.handler.ContentHandler.startDocument()
  • xml.sax.handler.ContentHandler.startElement()
  • xml.sax.handler.ContentHandler.startElementNS()
  • xml.sax.handler.ContentHandler.startPrefixMapping()
  • xml.sax.handler.DTDHandler
  • xml.sax.handler.DTDHandler.notationDecl()
  • xml.sax.handler.DTDHandler.unparsedEntityDecl()
  • xml.sax.handler.EntityResolver
  • xml.sax.handler.EntityResolver.resolveEntity()
  • xml.sax.handler.ErrorHandler
  • xml.sax.handler.ErrorHandler.error()
  • xml.sax.handler.ErrorHandler.fatalError()
  • xml.sax.handler.ErrorHandler.warning()
  • xml.sax.handler.feature_external_ges
  • xml.sax.handler.feature_external_pes
  • xml.sax.handler.feature_namespaces
  • xml.sax.handler.feature_namespace_prefixes
  • xml.sax.handler.feature_string_interning
  • xml.sax.handler.feature_validation
  • xml.sax.handler.property_declaration_handler
  • xml.sax.handler.property_dom_node
  • xml.sax.handler.property_lexical_handler
  • xml.sax.handler.property_xml_string
  • xml.sax.make_parser()
  • xml.sax.parse()
  • xml.sax.parseString()
  • xml.sax.SAXException
  • xml.sax.SAXException.getException()
  • xml.sax.SAXException.getMessage()
  • xml.sax.SAXNotRecognizedException
  • xml.sax.SAXNotSupportedException
  • xml.sax.SAXParseException
  • xml.sax.saxutils
  • xml.sax.saxutils.escape()
  • xml.sax.saxutils.prepare_input_source()
  • xml.sax.saxutils.quoteattr()
  • xml.sax.saxutils.unescape()
  • xml.sax.saxutils.XMLFilterBase
  • xml.sax.saxutils.XMLGenerator
  • xml.sax.xmlreader
  • xml.sax.xmlreader.Attributes.getLength()
  • xml.sax.xmlreader.Attributes.getNames()
  • xml.sax.xmlreader.Attributes.getType()
  • xml.sax.xmlreader.Attributes.getValue()
  • xml.sax.xmlreader.AttributesImpl
  • xml.sax.xmlreader.AttributesNS.getNameByQName()
  • xml.sax.xmlreader.AttributesNS.getQNameByName()
  • xml.sax.xmlreader.AttributesNS.getQNames()
  • xml.sax.xmlreader.AttributesNS.getValueByQName()
  • xml.sax.xmlreader.AttributesNSImpl
  • xml.sax.xmlreader.IncrementalParser
  • xml.sax.xmlreader.IncrementalParser.close()
  • xml.sax.xmlreader.IncrementalParser.feed()
  • xml.sax.xmlreader.IncrementalParser.reset()
  • xml.sax.xmlreader.InputSource
  • xml.sax.xmlreader.InputSource.getByteStream()
  • xml.sax.xmlreader.InputSource.getCharacterStream()
  • xml.sax.xmlreader.InputSource.getEncoding()
  • xml.sax.xmlreader.InputSource.getPublicId()
  • xml.sax.xmlreader.InputSource.getSystemId()
  • xml.sax.xmlreader.InputSource.setByteStream()
  • xml.sax.xmlreader.InputSource.setCharacterStream()
  • xml.sax.xmlreader.InputSource.setEncoding()
  • xml.sax.xmlreader.InputSource.setPublicId()
  • xml.sax.xmlreader.InputSource.setSystemId()
  • xml.sax.xmlreader.Locator
  • xml.sax.xmlreader.Locator.getColumnNumber()
  • xml.sax.xmlreader.Locator.getLineNumber()
  • xml.sax.xmlreader.Locator.getPublicId()
  • xml.sax.xmlreader.Locator.getSystemId()
  • xml.sax.xmlreader.XMLReader
  • xml.sax.xmlreader.XMLReader.getContentHandler()
  • xml.sax.xmlreader.XMLReader.getDTDHandler()
  • xml.sax.xmlreader.XMLReader.getEntityResolver()
  • xml.sax.xmlreader.XMLReader.getErrorHandler()
  • xml.sax.xmlreader.XMLReader.getFeature()
  • xml.sax.xmlreader.XMLReader.getProperty()
  • xml.sax.xmlreader.XMLReader.parse()
  • xml.sax.xmlreader.XMLReader.setContentHandler()
  • xml.sax.xmlreader.XMLReader.setDTDHandler()
  • xml.sax.xmlreader.XMLReader.setEntityResolver()
  • xml.sax.xmlreader.XMLReader.setErrorHandler()
  • xml.sax.xmlreader.XMLReader.setFeature()
  • xml.sax.xmlreader.XMLReader.setLocale()
  • xml.sax.xmlreader.XMLReader.setProperty()
  • Tk

  • IDLE
  • Other Graphical User Interface Packages
  • tkinter
  • tkinter.scrolledtext
  • tkinter.scrolledtext.ScrolledText.frame
  • tkinter.scrolledtext.ScrolledText.vbar
  • tkinter.Tcl()
  • tkinter.tix
  • tkinter.tix.Balloon
  • tkinter.tix.ButtonBox
  • tkinter.tix.CheckList
  • tkinter.tix.ComboBox
  • tkinter.tix.Control
  • tkinter.tix.DirList
  • tkinter.tix.DirSelectBox
  • tkinter.tix.DirSelectDialog
  • tkinter.tix.DirTree
  • tkinter.tix.ExFileSelectBox
  • tkinter.tix.FileEntry
  • tkinter.tix.FileSelectBox
  • tkinter.tix.Form
  • tkinter.tix.HList
  • tkinter.tix.InputOnly
  • tkinter.tix.LabelEntry
  • tkinter.tix.LabelFrame
  • tkinter.tix.ListNoteBook
  • tkinter.tix.Meter
  • tkinter.tix.NoteBook
  • tkinter.tix.OptionMenu
  • tkinter.tix.PanedWindow
  • tkinter.tix.PopupMenu
  • tkinter.tix.Select
  • tkinter.tix.StdButtonBox
  • tkinter.tix.tixCommand
  • tkinter.tix.tixCommand.tix_addbitmapdir()
  • tkinter.tix.tixCommand.tix_cget()
  • tkinter.tix.tixCommand.tix_configure()
  • tkinter.tix.tixCommand.tix_filedialog()
  • tkinter.tix.tixCommand.tix_getbitmap()
  • tkinter.tix.tixCommand.tix_getimage()
  • tkinter.tix.tixCommand.tix_option_get()
  • tkinter.tix.tixCommand.tix_resetoptions()
  • tkinter.tix.Tk
  • tkinter.tix.TList
  • tkinter.tix.Tree
  • tkinter.Tk
  • tkinter.ttk
  • tkinter.ttk.Combobox
  • tkinter.ttk.Combobox.current()
  • tkinter.ttk.Combobox.get()
  • tkinter.ttk.Combobox.set()
  • tkinter.ttk.Notebook
  • tkinter.ttk.Notebook.add()
  • tkinter.ttk.Notebook.enable_traversal()
  • tkinter.ttk.Notebook.forget()
  • tkinter.ttk.Notebook.hide()
  • tkinter.ttk.Notebook.identify()
  • tkinter.ttk.Notebook.index()
  • tkinter.ttk.Notebook.insert()
  • tkinter.ttk.Notebook.select()
  • tkinter.ttk.Notebook.tab()
  • tkinter.ttk.Notebook.tabs()
  • tkinter.ttk.Progressbar
  • tkinter.ttk.Progressbar.start()
  • tkinter.ttk.Progressbar.step()
  • tkinter.ttk.Progressbar.stop()
  • tkinter.ttk.Style
  • tkinter.ttk.Style.configure()
  • tkinter.ttk.Style.element_create()
  • tkinter.ttk.Style.element_names()
  • tkinter.ttk.Style.element_options()
  • tkinter.ttk.Style.layout()
  • tkinter.ttk.Style.lookup()
  • tkinter.ttk.Style.map()
  • tkinter.ttk.Style.theme_create()
  • tkinter.ttk.Style.theme_names()
  • tkinter.ttk.Style.theme_settings()
  • tkinter.ttk.Style.theme_use()
  • tkinter.ttk.Treeview
  • tkinter.ttk.Treeview.bbox()
  • tkinter.ttk.Treeview.column()
  • tkinter.ttk.Treeview.delete()
  • tkinter.ttk.Treeview.detach()
  • tkinter.ttk.Treeview.exists()
  • tkinter.ttk.Treeview.focus()
  • tkinter.ttk.Treeview.get_children()
  • tkinter.ttk.Treeview.heading()
  • tkinter.ttk.Treeview.identify()
  • tkinter.ttk.Treeview.identify_column()
  • tkinter.ttk.Treeview.identify_element()
  • tkinter.ttk.Treeview.identify_region()
  • tkinter.ttk.Treeview.identify_row()
  • tkinter.ttk.Treeview.index()
  • tkinter.ttk.Treeview.insert()
  • tkinter.ttk.Treeview.item()
  • tkinter.ttk.Treeview.move()
  • tkinter.ttk.Treeview.next()
  • tkinter.ttk.Treeview.parent()
  • tkinter.ttk.Treeview.prev()
  • tkinter.ttk.Treeview.reattach()
  • tkinter.ttk.Treeview.see()
  • tkinter.ttk.Treeview.selection()
  • tkinter.ttk.Treeview.selection_add()
  • tkinter.ttk.Treeview.selection_remove()
  • tkinter.ttk.Treeview.selection_set()
  • tkinter.ttk.Treeview.selection_toggle()
  • tkinter.ttk.Treeview.set()
  • tkinter.ttk.Treeview.set_children()
  • tkinter.ttk.Treeview.tag_bind()
  • tkinter.ttk.Treeview.tag_configure()
  • tkinter.ttk.Treeview.tag_has()
  • tkinter.ttk.Treeview.xview()
  • tkinter.ttk.Treeview.yview()
  • tkinter.ttk.Widget
  • tkinter.ttk.Widget.identify()
  • tkinter.ttk.Widget.instate()
  • tkinter.ttk.Widget.state()
  • tkinter.Widget.tk.createfilehandler()
  • tkinter.Widget.tk.deletefilehandler()
  • Importing

  • importlib
  • importlib.abc.ExecutionLoader
  • importlib.abc.ExecutionLoader.get_filename()
  • importlib.abc.FileLoader
  • importlib.abc.FileLoader.get_data()
  • importlib.abc.FileLoader.get_filename()
  • importlib.abc.FileLoader.load_module()
  • importlib.abc.FileLoader.name
  • importlib.abc.FileLoader.path
  • importlib.abc.Finder
  • importlib.abc.Finder.find_module()
  • importlib.abc.InspectLoader
  • importlib.abc.InspectLoader.exec_module()
  • importlib.abc.InspectLoader.get_code()
  • importlib.abc.InspectLoader.get_source()
  • importlib.abc.InspectLoader.is_package()
  • importlib.abc.InspectLoader.load_module()
  • importlib.abc.InspectLoader.source_to_code()
  • importlib.abc.Loader
  • importlib.abc.Loader.create_module()
  • importlib.abc.Loader.exec_module()
  • importlib.abc.Loader.load_module()
  • importlib.abc.Loader.module_repr()
  • importlib.abc.MetaPathFinder
  • importlib.abc.MetaPathFinder.find_module()
  • importlib.abc.MetaPathFinder.find_spec()
  • importlib.abc.MetaPathFinder.invalidate_caches()
  • importlib.abc.PathEntryFinder
  • importlib.abc.PathEntryFinder.find_loader()
  • importlib.abc.PathEntryFinder.find_module()
  • importlib.abc.PathEntryFinder.find_spec()
  • importlib.abc.PathEntryFinder.invalidate_caches()
  • importlib.abc.ResourceLoader
  • importlib.abc.ResourceLoader.get_data()
  • importlib.abc.SourceLoader
  • importlib.abc.SourceLoader.exec_module()
  • importlib.abc.SourceLoader.get_code()
  • importlib.abc.SourceLoader.get_source()
  • importlib.abc.SourceLoader.is_package()
  • importlib.abc.SourceLoader.load_module()
  • importlib.abc.SourceLoader.path_mtime()
  • importlib.abc.SourceLoader.path_stats()
  • importlib.abc.SourceLoader.set_data()
  • importlib.find_loader()
  • importlib.import_module()
  • importlib.invalidate_caches()
  • importlib.machinery.all_suffixes()
  • importlib.machinery.BuiltinImporter
  • importlib.machinery.BYTECODE_SUFFIXES
  • importlib.machinery.DEBUG_BYTECODE_SUFFIXES
  • importlib.machinery.ExtensionFileLoader
  • importlib.machinery.ExtensionFileLoader.create_module()
  • importlib.machinery.ExtensionFileLoader.exec_module()
  • importlib.machinery.ExtensionFileLoader.get_code()
  • importlib.machinery.ExtensionFileLoader.get_filename()
  • importlib.machinery.ExtensionFileLoader.get_source()
  • importlib.machinery.ExtensionFileLoader.is_package()
  • importlib.machinery.ExtensionFileLoader.name
  • importlib.machinery.ExtensionFileLoader.path
  • importlib.machinery.EXTENSION_SUFFIXES
  • importlib.machinery.FileFinder
  • importlib.machinery.FileFinder.find_loader()
  • importlib.machinery.FileFinder.find_spec()
  • importlib.machinery.FileFinder.invalidate_caches()
  • importlib.machinery.FileFinder.path
  • importlib.machinery.FileFinder.path_hook()
  • importlib.machinery.FrozenImporter
  • importlib.machinery.ModuleSpec
  • importlib.machinery.ModuleSpec.cached
  • importlib.machinery.ModuleSpec.has_location
  • importlib.machinery.ModuleSpec.loader
  • importlib.machinery.ModuleSpec.loader_state
  • importlib.machinery.ModuleSpec.name
  • importlib.machinery.ModuleSpec.origin
  • importlib.machinery.ModuleSpec.parent
  • importlib.machinery.ModuleSpec.submodule_search_locations
  • importlib.machinery.OPTIMIZED_BYTECODE_SUFFIXES
  • importlib.machinery.PathFinder
  • importlib.machinery.PathFinder.find_module()
  • importlib.machinery.PathFinder.find_spec()
  • importlib.machinery.PathFinder.invalidate_caches()
  • importlib.machinery.SourceFileLoader
  • importlib.machinery.SourceFileLoader.is_package()
  • importlib.machinery.SourceFileLoader.load_module()
  • importlib.machinery.SourceFileLoader.name
  • importlib.machinery.SourceFileLoader.path
  • importlib.machinery.SourceFileLoader.path_stats()
  • importlib.machinery.SourceFileLoader.set_data()
  • importlib.machinery.SourcelessFileLoader
  • importlib.machinery.SourcelessFileLoader.get_code()
  • importlib.machinery.SourcelessFileLoader.get_source()
  • importlib.machinery.SourcelessFileLoader.is_package()
  • importlib.machinery.SourcelessFileLoader.load_module()
  • importlib.machinery.SourcelessFileLoader.name
  • importlib.machinery.SourcelessFileLoader.path
  • importlib.machinery.SOURCE_SUFFIXES
  • importlib.machinery.WindowsRegistryFinder
  • importlib.reload()
  • importlib.util.cache_from_source()
  • importlib.util.decode_source()
  • importlib.util.find_spec()
  • importlib.util.LazyLoader
  • importlib.util.LazyLoader.factory()
  • importlib.util.MAGIC_NUMBER
  • importlib.util.module_for_loader()
  • importlib.util.module_from_spec()
  • importlib.util.resolve_name()
  • importlib.util.set_loader()
  • importlib.util.set_package()
  • importlib.util.source_from_cache()
  • importlib.util.spec_from_file_location()
  • importlib.util.spec_from_loader()
  • importlib.__import__()
  • modulefinder
  • modulefinder.AddPackagePath()
  • modulefinder.ModuleFinder
  • modulefinder.ModuleFinder.modules
  • modulefinder.ModuleFinder.report()
  • modulefinder.ModuleFinder.run_script()
  • modulefinder.ReplacePackage()
  • pkgutil
  • pkgutil.extend_path()
  • pkgutil.find_loader()
  • pkgutil.get_data()
  • pkgutil.get_importer()
  • pkgutil.get_loader()
  • pkgutil.ImpImporter
  • pkgutil.ImpLoader
  • pkgutil.iter_importers()
  • pkgutil.iter_modules()
  • pkgutil.walk_packages()
  • runpy
  • runpy.run_module()
  • runpy.run_path()
  • zipimport
  • zipimport.zipimporter
  • zipimport.zipimporter.archive
  • zipimport.zipimporter.find_module()
  • zipimport.zipimporter.get_code()
  • zipimport.zipimporter.get_data()
  • zipimport.zipimporter.get_filename()
  • zipimport.zipimporter.get_source()
  • zipimport.zipimporter.is_package()
  • zipimport.zipimporter.load_module()
  • zipimport.zipimporter.prefix
  • zipimport.ZipImportError
  • Logging

  • logging
  • logging.addLevelName()
  • logging.basicConfig()
  • logging.captureWarnings()
  • logging.config
  • logging.config.dictConfig()
  • logging.config.fileConfig()
  • logging.config.listen()
  • logging.config.stopListening()
  • logging.critical()
  • logging.debug()
  • logging.disable()
  • logging.error()
  • logging.exception()
  • logging.FileHandler
  • logging.FileHandler.close()
  • logging.FileHandler.emit()
  • logging.Filter
  • logging.Filter.filter()
  • logging.Formatter
  • logging.Formatter.format()
  • logging.Formatter.formatException()
  • logging.Formatter.formatStack()
  • logging.Formatter.formatTime()
  • logging.getLevelName()
  • logging.getLogger()
  • logging.getLoggerClass()
  • logging.getLogRecordFactory()
  • logging.Handler.acquire()
  • logging.Handler.addFilter()
  • logging.Handler.close()
  • logging.Handler.createLock()
  • logging.Handler.emit()
  • logging.Handler.filter()
  • logging.Handler.flush()
  • logging.Handler.format()
  • logging.Handler.handle()
  • logging.Handler.handleError()
  • logging.Handler.release()
  • logging.Handler.removeFilter()
  • logging.Handler.setFormatter()
  • logging.Handler.setLevel()
  • logging.Handler.__init__()
  • logging.handlers
  • logging.handlers.BaseRotatingHandler
  • logging.handlers.BaseRotatingHandler.namer
  • logging.handlers.BaseRotatingHandler.rotate()
  • logging.handlers.BaseRotatingHandler.rotation_filename()
  • logging.handlers.BaseRotatingHandler.rotator
  • logging.handlers.BufferingHandler
  • logging.handlers.BufferingHandler.emit()
  • logging.handlers.BufferingHandler.flush()
  • logging.handlers.BufferingHandler.shouldFlush()
  • logging.handlers.DatagramHandler
  • logging.handlers.DatagramHandler.emit()
  • logging.handlers.DatagramHandler.makeSocket()
  • logging.handlers.DatagramHandler.send()
  • logging.handlers.HTTPHandler
  • logging.handlers.HTTPHandler.emit()
  • logging.handlers.HTTPHandler.mapLogRecord()
  • logging.handlers.MemoryHandler
  • logging.handlers.MemoryHandler.close()
  • logging.handlers.MemoryHandler.flush()
  • logging.handlers.MemoryHandler.setTarget()
  • logging.handlers.MemoryHandler.shouldFlush()
  • logging.handlers.NTEventLogHandler
  • logging.handlers.NTEventLogHandler.close()
  • logging.handlers.NTEventLogHandler.emit()
  • logging.handlers.NTEventLogHandler.getEventCategory()
  • logging.handlers.NTEventLogHandler.getEventType()
  • logging.handlers.NTEventLogHandler.getMessageID()
  • logging.handlers.QueueHandler
  • logging.handlers.QueueHandler.emit()
  • logging.handlers.QueueHandler.enqueue()
  • logging.handlers.QueueHandler.prepare()
  • logging.handlers.QueueListener
  • logging.handlers.QueueListener.dequeue()
  • logging.handlers.QueueListener.enqueue_sentinel()
  • logging.handlers.QueueListener.handle()
  • logging.handlers.QueueListener.prepare()
  • logging.handlers.QueueListener.start()
  • logging.handlers.QueueListener.stop()
  • logging.handlers.RotatingFileHandler
  • logging.handlers.RotatingFileHandler.doRollover()
  • logging.handlers.RotatingFileHandler.emit()
  • logging.handlers.SMTPHandler
  • logging.handlers.SMTPHandler.emit()
  • logging.handlers.SMTPHandler.getSubject()
  • logging.handlers.SocketHandler
  • logging.handlers.SocketHandler.close()
  • logging.handlers.SocketHandler.createSocket()
  • logging.handlers.SocketHandler.emit()
  • logging.handlers.SocketHandler.handleError()
  • logging.handlers.SocketHandler.makePickle()
  • logging.handlers.SocketHandler.makeSocket()
  • logging.handlers.SocketHandler.send()
  • logging.handlers.SysLogHandler
  • logging.handlers.SysLogHandler.close()
  • logging.handlers.SysLogHandler.emit()
  • logging.handlers.SysLogHandler.encodePriority()
  • logging.handlers.SysLogHandler.mapPriority()
  • logging.handlers.TimedRotatingFileHandler
  • logging.handlers.TimedRotatingFileHandler.doRollover()
  • logging.handlers.TimedRotatingFileHandler.emit()
  • logging.handlers.WatchedFileHandler
  • logging.handlers.WatchedFileHandler.emit()
  • logging.info()
  • logging.lastResort
  • logging.log()
  • logging.Logger
  • logging.Logger.addFilter()
  • logging.Logger.addHandler()
  • logging.Logger.critical()
  • logging.Logger.debug()
  • logging.Logger.error()
  • logging.Logger.exception()
  • logging.Logger.filter()
  • logging.Logger.findCaller()
  • logging.Logger.getChild()
  • logging.Logger.getEffectiveLevel()
  • logging.Logger.handle()
  • logging.Logger.hasHandlers()
  • logging.Logger.info()
  • logging.Logger.isEnabledFor()
  • logging.Logger.log()
  • logging.Logger.makeRecord()
  • logging.Logger.propagate
  • logging.Logger.removeFilter()
  • logging.Logger.removeHandler()
  • logging.Logger.setLevel()
  • logging.Logger.warning()
  • logging.LoggerAdapter
  • logging.LoggerAdapter.process()
  • logging.LogRecord
  • logging.LogRecord.getMessage()
  • logging.makeLogRecord()
  • logging.NullHandler
  • logging.NullHandler.createLock()
  • logging.NullHandler.emit()
  • logging.NullHandler.handle()
  • logging.setLoggerClass()
  • logging.setLogRecordFactory()
  • logging.shutdown()
  • logging.StreamHandler
  • logging.StreamHandler.emit()
  • logging.StreamHandler.flush()
  • logging.warning()
  • MS Windows

  • msilib
  • msilib.add_data()
  • msilib.add_stream()
  • msilib.add_tables()
  • msilib.Binary
  • msilib.CAB
  • msilib.CAB.append()
  • msilib.CAB.commit()
  • msilib.Control
  • msilib.Control.condition()
  • msilib.Control.event()
  • msilib.Control.mapping()
  • msilib.CreateRecord()
  • msilib.Database.Commit()
  • msilib.Database.GetSummaryInformation()
  • msilib.Database.OpenView()
  • msilib.Dialog
  • msilib.Dialog.bitmap()
  • msilib.Dialog.checkbox()
  • msilib.Dialog.control()
  • msilib.Dialog.line()
  • msilib.Dialog.pushbutton()
  • msilib.Dialog.radiogroup()
  • msilib.Dialog.text()
  • msilib.Directory
  • msilib.Directory.add_file()
  • msilib.Directory.glob()
  • msilib.Directory.remove_pyc()
  • msilib.Directory.start_component()
  • msilib.FCICreate()
  • msilib.Feature
  • msilib.Feature.set_current()
  • msilib.gen_uuid()
  • msilib.init_database()
  • msilib.OpenDatabase()
  • msilib.RadioButtonGroup
  • msilib.RadioButtonGroup.add()
  • msilib.Record.ClearData()
  • msilib.Record.GetFieldCount()
  • msilib.Record.GetInteger()
  • msilib.Record.GetString()
  • msilib.Record.SetInteger()
  • msilib.Record.SetStream()
  • msilib.Record.SetString()
  • msilib.schema
  • msilib.sequence
  • msilib.SummaryInformation.GetProperty()
  • msilib.SummaryInformation.GetPropertyCount()
  • msilib.SummaryInformation.Persist()
  • msilib.SummaryInformation.SetProperty()
  • msilib.text
  • msilib.UuidCreate()
  • msilib.View.Close()
  • msilib.View.Execute()
  • msilib.View.Fetch()
  • msilib.View.GetColumnInfo()
  • msilib.View.Modify()
  • msvcrt
  • msvcrt.getch()
  • msvcrt.getche()
  • msvcrt.getwch()
  • msvcrt.getwche()
  • msvcrt.get_osfhandle()
  • msvcrt.heapmin()
  • msvcrt.kbhit()
  • msvcrt.locking()
  • msvcrt.open_osfhandle()
  • msvcrt.putch()
  • msvcrt.putwch()
  • msvcrt.setmode()
  • msvcrt.ungetch()
  • msvcrt.ungetwch()
  • winreg
  • winreg.CloseKey()
  • winreg.ConnectRegistry()
  • winreg.CreateKey()
  • winreg.CreateKeyEx()
  • winreg.DeleteKey()
  • winreg.DeleteKeyEx()
  • winreg.DeleteValue()
  • winreg.DisableReflectionKey()
  • winreg.EnableReflectionKey()
  • winreg.EnumKey()
  • winreg.EnumValue()
  • winreg.ExpandEnvironmentStrings()
  • winreg.FlushKey()
  • winreg.LoadKey()
  • winreg.OpenKey()
  • winreg.OpenKeyEx()
  • winreg.PyHKEY.Close()
  • winreg.PyHKEY.Detach()
  • winreg.PyHKEY.__enter__()
  • winreg.PyHKEY.__exit__()
  • winreg.QueryInfoKey()
  • winreg.QueryReflectionKey()
  • winreg.QueryValue()
  • winreg.QueryValueEx()
  • winreg.SaveKey()
  • winreg.SetValue()
  • winreg.SetValueEx()
  • winsound
  • winsound.Beep()
  • winsound.MessageBeep()
  • winsound.PlaySound()
  • Index

  • index