python3标准库sys模块

待我称王封你为后i 2022-05-11 07:04 380阅读 0赞

# 1.sys模块源代码 #

> \# encoding: utf-8  
> \# module sys  
> \# from (built-in)  
> \# by generator 1.145  
> """  
> This module provides access to some objects used or maintained by the  
> interpreter and to functions that interact strongly with the interpreter.
> 
> Dynamic objects:
> 
> modules -- dictionary of loaded modules
> 
> displayhook -- called to show results in an interactive session  
> excepthook -- called to handle any uncaught exception other than SystemExit  
>   To customize printing in an interactive session or to install a custom  
>   top-level exception handler, assign other functions to replace these.
> 
> stdin -- standard input file object; used by input()  
> stderr -- standard error object; used for error messages  
>   By assigning other file objects (or objects that behave like files)  
>   to these, it is possible to redirect all of the interpreter's I/O.
> 
> last\_type -- type of last uncaught exception  
> last\_value -- value of last uncaught exception  
> last\_traceback -- traceback of last uncaught exception  
>   These three are only available in an interactive session after a  
>   traceback has been printed.
> 
> Static objects:
> 
> builtin\_module\_names -- tuple of module names built into this interpreter  
> copyright -- copyright notice pertaining to this interpreter  
> exec\_prefix -- prefix used to find the machine-specific Python library  
> executable -- absolute path of the executable binary of the Python interpreter  
> float\_info -- a struct sequence with information about the float implementation.  
> float\_repr\_style -- string indicating the style of repr() output for floats  
> hash\_info -- a struct sequence with information about the hash algorithm.  
> hexversion -- version information encoded as a single integer  
> implementation -- Python implementation information.  
> int\_info -- a struct sequence with information about the int implementation..  
> maxunicode -- the value of the largest Unicode code point  
> prefix -- prefix used to find the Python library  
> thread\_info -- a struct sequence with information about the thread implementation.  
> version\_info -- version information as a named tuple  
> dllhandle -- \[Windows only\] integer handle of the Python DLL  
> winver -- \[Windows only\] version number of the Python DLL  
> \_enablelegacywindowsfsencoding -- \[Windows only\]   
> \_\_stdin\_\_ -- the original stdin; don't touch!  
> \_\_stdout\_\_ -- the original stdout; don't touch!  
> \_\_stderr\_\_ -- the original stderr; don't touch!  
> \_\_displayhook\_\_ -- the original displayhook; don't touch!  
> \_\_excepthook\_\_ -- the original excepthook; don't touch!
> 
> Functions:
> 
> displayhook() -- print an object to the screen, and save it in builtins.\_  
> excepthook() -- print an exception and its traceback to sys.stderr  
> exc\_info() -- return thread-safe information about the current exception  
> **exit() -- exit the interpreter by raising SystemExit**  
> getdlopenflags() -- returns flags to be used for dlopen() calls  
> getprofile() -- get the global profiling function  
> getrefcount() -- return the reference count for an object (plus one :-)  
> getrecursionlimit() -- return the max recursion depth for the interpreter  
> getsizeof() -- return the size of an object in bytes  
> gettrace() -- get the global debug tracing function  
> setcheckinterval() -- control how often the interpreter checks for events  
> setdlopenflags() -- set the flags to be used for dlopen() calls  
> setprofile() -- set the global profiling function  
> setrecursionlimit() -- set the max recursion depth for the interpreter  
> settrace() -- set the global debug tracing function  
> """  
> \# no imports
> 
> \# Variables with simple values
> 
> api\_version = 1013
> 
> base\_exec\_prefix = 'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36'
> 
> base\_prefix = 'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36'
> 
> byteorder = 'little'
> 
> copyright = 'Copyright (c) 2001-2017 Python Software Foundation.\\nAll Rights Reserved.\\n\\nCopyright (c) 2000 BeOpen.com.\\nAll Rights Reserved.\\n\\nCopyright (c) 1995-2001 Corporation for National Research Initiatives.\\nAll Rights Reserved.\\n\\nCopyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.\\nAll Rights Reserved.'
> 
> dllhandle = 1943601152
> 
> dont\_write\_bytecode = True
> 
> executable = 'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36\\\\python.exe'
> 
> exec\_prefix = 'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36'
> 
> float\_repr\_style = 'short'
> 
> hexversion = 50725616
> 
>  
> 
> **\# maxsize -- the largest supported length of containers**
> 
> **maxsize** = 9223372036854775807
> 
>  
> 
> maxunicode = 1114111
> 
>  
> 
> **\# platform -- platform identifier  
> platform** = 'win32'
> 
>  
> 
> prefix = 'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36'
> 
>  
> 
> **\# version -- the version of this interpreter as a string  
> version** = '3.6.2 (v3.6.2:5fd33b5, Jul  8 2017, 04:57:36) \[MSC v.1900 64 bit (AMD64)\]'
> 
>  
> 
> winver = '3.6'
> 
> \_home = None
> 
> \# functions
> 
> def callstats(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     callstats() -> tuple of integers  
>       
>     Return a tuple of function call statistics, if CALL\_PROFILE was defined  
>     when Python was built.  Otherwise, return None.  
>       
>     When enabled, this function returns detailed, implementation-specific  
>     details about the number of function calls executed. The return value is  
>     a 11-tuple where the entries in the tuple are counts of:  
>     0. all function calls  
>     1. calls to PyFunction\_Type objects  
>     2. PyFunction calls that do not create an argument tuple  
>     3. PyFunction calls that do not create an argument tuple  
>        and bypass PyEval\_EvalCodeEx()  
>     4. PyMethod calls  
>     5. PyMethod calls on bound methods  
>     6. PyType calls  
>     7. PyCFunction calls  
>     8. generator calls  
>     9. All other calls  
>     10. Number of stack pops performed by call\_function()  
>     """  
>     return ()
> 
> def call\_tracing(func, args): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     call\_tracing(func, args) -> object  
>       
>     Call func(\*args), while tracing is enabled.  The tracing state is  
>     saved, and restored afterwards.  This is intended to be called from  
>     a debugger from a checkpoint, to recursively debug some other code.  
>     """  
>     return object()
> 
> def displayhook(p\_object): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     displayhook(object) -> None  
>       
>     Print an object to sys.stdout and also save it in builtins.\_  
>     """  
>     pass
> 
> def excepthook(exctype, value, traceback): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     excepthook(exctype, value, traceback) -> None  
>       
>     Handle an exception by displaying it with a traceback on sys.stderr.  
>     """  
>     pass
> 
> def exc\_info(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     exc\_info() -> (type, value, traceback)  
>       
>     Return information about the most recent exception caught by an except  
>     clause in the current stack frame or in an older stack frame.  
>     """  
>     pass
> 
> def exit(status=None): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     exit(\[status\])  
>       
>     Exit the interpreter by raising SystemExit(status).  
>     If the status is omitted or None, it defaults to zero (i.e., success).  
>     If the status is an integer, it will be used as the system exit status.  
>     If it is another kind of object, it will be printed and the system  
>     exit status will be one (i.e., failure).  
>     """  
>     pass
> 
> def getallocatedblocks(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getallocatedblocks() -> integer  
>       
>     Return the number of memory blocks currently allocated, regardless of their  
>     size.  
>     """  
>     return 0
> 
> def getcheckinterval(): \# real signature unknown; restored from \_\_doc\_\_  
>     """ getcheckinterval() -> current check interval; see setcheckinterval(). """  
>     pass
> 
> def getdefaultencoding(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getdefaultencoding() -> string  
>       
>     Return the current default string encoding used by the Unicode   
>     implementation.  
>     """  
>     return ""
> 
> def getfilesystemencodeerrors(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getfilesystemencodeerrors() -> string  
>       
>     Return the error mode used to convert Unicode filenames in  
>     operating system filenames.  
>     """  
>     return ""
> 
> def getfilesystemencoding(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getfilesystemencoding() -> string  
>       
>     Return the encoding used to convert Unicode filenames in  
>     operating system filenames.  
>     """  
>     return ""
> 
> def getprofile(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getprofile()  
>       
>     Return the profiling function set with sys.setprofile.  
>     See the profiler chapter in the library manual.  
>     """  
>     pass
> 
> def getrecursionlimit(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getrecursionlimit()  
>       
>     Return the current value of the recursion limit, the maximum depth  
>     of the Python interpreter stack.  This limit prevents infinite  
>     recursion from causing an overflow of the C stack and crashing Python.  
>     """  
>     pass
> 
> def getrefcount(p\_object): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getrefcount(object) -> integer  
>       
>     Return the reference count of object.  The count returned is generally  
>     one higher than you might expect, because it includes the (temporary)  
>     reference as an argument to getrefcount().  
>     """  
>     return 0
> 
> def getsizeof(p\_object, default): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getsizeof(object, default) -> int  
>       
>     Return the size of object in bytes.  
>     """  
>     return 0
> 
> def getswitchinterval(): \# real signature unknown; restored from \_\_doc\_\_  
>     """ getswitchinterval() -> current thread switch interval; see setswitchinterval(). """  
>     pass
> 
> def gettrace(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     gettrace()  
>       
>     Return the global debug tracing function set with sys.settrace.  
>     See the debugger chapter in the library manual.  
>     """  
>     pass
> 
> def getwindowsversion(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     getwindowsversion()  
>       
>     Return information about the running version of Windows as a named tuple.  
>     The members are named: major, minor, build, platform, service\_pack,  
>     service\_pack\_major, service\_pack\_minor, suite\_mask, and product\_type. For  
>     backward compatibility, only the first 5 items are available by indexing.  
>     All elements are numbers, except service\_pack and platform\_type which are  
>     strings, and platform\_version which is a 3-tuple. Platform is always 2.  
>     Product\_type may be 1 for a workstation, 2 for a domain controller, 3 for a  
>     server. Platform\_version is a 3-tuple containing a version number that is  
>     intended for identifying the OS rather than feature detection.  
>     """  
>     pass
> 
> def get\_asyncgen\_hooks(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     get\_asyncgen\_hooks()  
>       
>     Return a namedtuple of installed asynchronous generators hooks (firstiter, finalizer).  
>     """  
>     pass
> 
> def get\_coroutine\_wrapper(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     get\_coroutine\_wrapper()  
>       
>     Return the wrapper for coroutine objects set by sys.set\_coroutine\_wrapper.  
>     """  
>     pass
> 
> def intern(string): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     intern(string) -> string  
>       
>     \`\`Intern'' the given string.  This enters the string in the (global)  
>     table of interned strings whose purpose is to speed up dictionary lookups.  
>     Return the string itself or the previously interned string object with the  
>     same value.  
>     """  
>     return ""
> 
> def is\_finalizing(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     is\_finalizing()  
>     Return True if Python is exiting.  
>     """  
>     pass
> 
> def setcheckinterval(n): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     setcheckinterval(n)  
>       
>     Tell the Python interpreter to check for asynchronous events every  
>     n instructions.  This also affects how often thread switches occur.  
>     """  
>     pass
> 
> def setprofile(function): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     setprofile(function)  
>       
>     Set the profiling function.  It will be called on each function call  
>     and return.  See the profiler chapter in the library manual.  
>     """  
>     pass
> 
> def setrecursionlimit(n): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     setrecursionlimit(n)  
>       
>     Set the maximum depth of the Python interpreter stack to n.  This  
>     limit prevents infinite recursion from causing an overflow of the C  
>     stack and crashing Python.  The highest possible limit is platform-  
>     dependent.  
>     """  
>     pass
> 
> def setswitchinterval(n): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     setswitchinterval(n)  
>       
>     Set the ideal thread switching delay inside the Python interpreter  
>     The actual frequency of switching threads can be lower if the  
>     interpreter executes long sequences of uninterruptible code  
>     (this is implementation-specific and workload-dependent).  
>       
>     The parameter must represent the desired switching delay in seconds  
>     A typical value is 0.005 (5 milliseconds).  
>     """  
>     pass
> 
> def settrace(function): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     settrace(function)  
>       
>     Set the global debug tracing function.  It will be called on each  
>     function call.  See the debugger chapter in the library manual.  
>     """  
>     pass
> 
> def set\_asyncgen\_hooks(\*args, \*\*kwargs): \# real signature unknown; NOTE: unreliably restored from \_\_doc\_\_   
>     """  
>     set\_asyncgen\_hooks(\*, firstiter=None, finalizer=None)  
>       
>     Set a finalizer for async generators objects.  
>     """  
>     pass
> 
> def set\_coroutine\_wrapper(wrapper): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     set\_coroutine\_wrapper(wrapper)  
>       
>     Set a wrapper for coroutine objects.  
>     """  
>     pass
> 
> def \_clear\_type\_cache(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     \_clear\_type\_cache() -> None  
>     Clear the internal type lookup cache.  
>     """  
>     pass
> 
> def \_current\_frames(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     \_current\_frames() -> dictionary  
>       
>     Return a dictionary mapping each current thread T's thread id to T's  
>     current stack frame.  
>       
>     This function should be used for specialized purposes only.  
>     """  
>     return \{\}
> 
> def \_debugmallocstats(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     \_debugmallocstats()  
>       
>     Print summary info to stderr about the state of  
>     pymalloc's structures.  
>       
>     In Py\_DEBUG mode, also perform some expensive internal consistency  
>     checks.  
>     """  
>     pass
> 
> def \_enablelegacywindowsfsencoding(): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     \_enablelegacywindowsfsencoding()  
>       
>     Changes the default filesystem encoding to mbcs:replace for consistency  
>     with earlier versions of Python. See PEP 529 for more information.  
>       
>     This is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING   
>     environment variable before launching Python.  
>     """  
>     pass
> 
> def \_getframe(depth=None): \# real signature unknown; restored from \_\_doc\_\_  
>     """  
>     \_getframe(\[depth\]) -> frameobject  
>       
>     Return a frame object from the call stack.  If optional integer depth is  
>     given, return the frame object that many calls below the top of the stack.  
>     If that is deeper than the call stack, ValueError is raised.  The default  
>     for depth is zero, returning the frame at the top of the call stack.  
>       
>     This function should be used for internal and specialized  
>     purposes only.  
>     """  
>     pass
> 
> def \_\_displayhook\_\_(\*args, \*\*kwargs): \# real signature unknown  
>     """  
>     displayhook(object) -> None  
>       
>     Print an object to sys.stdout and also save it in builtins.\_  
>     """  
>     pass
> 
> def \_\_excepthook\_\_(\*args, \*\*kwargs): \# real signature unknown  
>     """  
>     excepthook(exctype, value, traceback) -> None  
>       
>     Handle an exception by displaying it with a traceback on sys.stderr.  
>     """  
>     pass
> 
> def \_\_interactivehook\_\_(): \# reliably restored by inspect  
>     \# no doc  
>     pass
> 
> \# classes
> 
> class \_\_loader\_\_(object):  
>     """  
>     Meta path import for built-in modules.  
>       
>         All methods are either class or static methods to avoid the need to  
>         instantiate the class.  
>     """  
>     @classmethod  
>     def create\_module(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """ Create a built-in module """  
>         pass
> 
>     @classmethod  
>     def exec\_module(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """ Exec a built-in module """  
>         pass
> 
>     @classmethod  
>     def find\_module(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """  
>         Find the built-in module.  
>           
>                 If 'path' is ever specified then the search is considered a failure.  
>           
>                 This method is deprecated.  Use find\_spec() instead.  
>         """  
>         pass
> 
>     @classmethod  
>     def find\_spec(cls, \*args, \*\*kwargs): \# real signature unknown  
>         pass
> 
>     @classmethod  
>     def get\_code(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """ Return None as built-in modules do not have code objects. """  
>         pass
> 
>     @classmethod  
>     def get\_source(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """ Return None as built-in modules do not have source code. """  
>         pass
> 
>     @classmethod  
>     def is\_package(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """ Return False as built-in modules are never packages. """  
>         pass
> 
>     @classmethod  
>     def load\_module(cls, \*args, \*\*kwargs): \# real signature unknown  
>         """  
>         Load the specified module into sys.modules and return it.  
>           
>             This method is deprecated.  Use loader.exec\_module instead.  
>         """  
>         pass
> 
>     def module\_repr(module): \# reliably restored by inspect  
>         """  
>         Return repr for the module.  
>           
>                 The method is deprecated.  The import machinery does the job itself.  
>         """  
>         pass
> 
>     def \_\_init\_\_(self, \*args, \*\*kwargs): \# real signature unknown  
>         pass
> 
>     \_\_weakref\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  \# default  
>     """list of weak references to the object (if defined)"""
> 
>   
>     \_\_dict\_\_ = None \# (!) real value is ''
> 
>   
> \# variables with complex values
> 
> **\# argv -- command line arguments; argv\[0\] is the script pathname if known  
> argv** = \[\] \# real value of type <class 'list'> skipped
> 
> builtin\_module\_names = () \# real value of type <class 'tuple'> skipped
> 
> flags = (  
>     0,  
>     0,  
>     0,  
>     0,  
>     1,  
>     0,  
>     0,  
>     0,  
>     0,  
>     0,  
>     0,  
>     1,  
>     0,  
> )
> 
> float\_info = (  
>     1.7976931348623157e+308,  
>     1024,  
>     308,  
>     2.2250738585072014e-308,  
>     -1021,  
>     -307,  
>     15,  
>     53,  
>     2.220446049250313e-16,  
>     2,  
>     1,  
> )
> 
> hash\_info = (  
>     64,  
>     2305843009213693951,  
>     314159,  
>     0,  
>     1000003,  
>     'siphash24',  
>     64,  
>     128,  
>     0,  
> )
> 
> implementation = None \# (!) real value is ''
> 
> int\_info = (  
>     30,  
>     4,  
> )
> 
> meta\_path = \[  
>     \_\_loader\_\_,  
>     None, \# (!) real value is ''  
>     None, \# (!) real value is ''  
> \]
> 
> modules = \{\} \# real value of type <class 'dict'> skipped
> 
> **\# path -- module search path; path\[0\] is the script directory, else ''  
> path** = \[  
>     'C:\\\\BuildAgent\\\\work\\\\87ad6919b0049fba\\\\out\\\\classes\\\\production\\\\intellij.python.helpers',  
>     'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36\\\\python36.zip',  
>     'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36\\\\DLLs',  
>     'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36\\\\lib',  
>     'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36',  
>     'C:\\\\BuildAgent\\\\system\\\\.persistent\_cache\\\\pycharm\\\\pythons4skeletons\\\\python36\\\\lib\\\\site-packages',  
> \]
> 
> path\_hooks = \[  
>     None, \# (!) real value is ''  
>     None, \# (!) real value is ''  
> \]
> 
> path\_importer\_cache = \{\} \# real value of type <class 'dict'> skipped
> 
> stderr = None \# (!) real value is ''
> 
> stdin = None \# (!) forward: \_\_stdin\_\_, real value is ''
> 
> **\# stdout -- standard output file object; used by print()  
> stdout** = None \# (!) forward: \_\_stdout\_\_, real value is ''
> 
> thread\_info = (  
>     'nt',  
>     None,  
>     None,  
> )
> 
> version\_info = (  
>     3,  
>     6,  
>     2,  
>     'final',  
>     0,  
> )
> 
> warnoptions = \[\]
> 
> \_git = (  
>     'CPython',  
>     'v3.6.2',  
>     '5fd33b5',  
> )
> 
> \_xoptions = \{\}
> 
> \_\_spec\_\_ = None \# (!) real value is ''
> 
> \_\_stderr\_\_ = stderr
> 
> \_\_stdin\_\_ = None \# (!) real value is ''
> 
> \_\_stdout\_\_ = None \# (!) real value is ''
> 
> \# intermittent names  
> exc\_value = Exception()  
> exc\_traceback=None

# 2.sys模块的常见用法 #

import sys
    
    
    # 输出命令行参数list。第一个参数：程序路径；后边的参数依次为命令行输入
    print(sys.argv)
    
    # 获取python解释程序的版本信息
    print(sys.version)
    
    # 容器所支持的最大长度
    print(sys.maxsize)
    
    # 搜索模块的路径
    print(sys.path)
    
    # 操作系统平台名称
    print(sys.platform)
    
    # 标准输出与标准输入
    print(sys.stdout.write("Please:"))
    val = sys.stdin.readline()[:-1]      # 切片的目的是去除字符串末尾的‘\n’
    print(val)
    
    # 退出程序
    sys.exit("this is error!")