Python 模块

转载请注明出处：https://www.cnblogs.com/Chestnut-g/

1. 模块的含义：

　　用一砣代码实现了某个功能的代码集合。 类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

　　2.模块的分类：

　　模块可分为三种：

• 自定义模块
• 第三方模块
• 内置模块

自定义模块

• 定义模块

情景一：

情景二：

情景三：

• 导入模块：

'''
#import test1    #导入单个模块
#import test1，random   #导入多个模块
#test1.test()     #调用test的方法
#from test1 import *   #导入模块中的所有函数；*号表示占位符，表示所有方法（指定方法）
#from test1 import sayhi as SH   #使用as给函数指定别名
'''

import test1中test1就是自定义模块，你可以导入其他模块中使用。

导入模块其实就是告诉Python解释器去解释哪个py文件。

那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：下面内置模块中的sys.path

内置模块

　　如：os 是系统相关的模块；file是文件操作相关的模块

• sys模块：

　　如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。

　　其他sys的方法如下所示

1 sys.argv           命令行参数List，第一个元素是程序本身路径
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称
7 sys.stdin          输入相关
8 sys.stdout         输出相关
9 sys.stderror          错误相关

　　下面具体介绍几个常用的sys模块方法,详见View Code

'''
#import sys   #sys：系统路径
#from package时先访问init.py文件
#访问属性时直接打印，即不加括号
#访问方法时，需要调用，即加括号（）
'''

#import sys   #sys：系统路径
import sys,os
print(sys.path)
a = os.path.abspath(__file__)
#__file__表示当前程序或文件
# os.path.abspath表示拿到本文件或本程序的路径
b = os.path.dirname(a)  #拿到当前文件的父目录
c = os.path.dirname(b)  #拿到a,b的共同目录
print(a)
print(b)
print(c)
sys.path.append(c)     #sys.path.append把找到的路径插入到sys.path路径当中

#首先访问的是init.py文件
from package import *

#访问属性v
from package.test import v
print(v)

#访问方法
from package import test1
test1.test1()

# import sys,os
# print(sys.path)
# a = os.path.abspath(__file__)
# b = os.path.dirname(a)
# c = os.path.dirname(b)
# print(a)
# print(b)
# print(c)
# # sys.path.append(c)     #sys.path.append把找到的路径插入到sys.path路径当中
# import test1
# test1.test1()
#
# v = "rythhjyetyu"
# def t():
#     print("fuhf")


# 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:
#动态对象

argv -- command line arguments; argv[0] is the script pathname if known
#argv——命令行参数;如果已知，argv[0]是脚本路径名

path -- module search path; path[0] is the script directory, else ''
#路径——模块搜索路径;路径[0]是脚本目录，否则为空目录

modules -- dictionary of loaded modules
模块——加载的模块字典

displayhook -- called to show results in an interactive session
#displayhook——在交互式会话中显示结果的调用

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.
#excepthook——调用来处理除SystemExit之外的任何未捕获的异常在交互式会话中定制打印
或安装定制顶级异常处理程序，分配其他函数来替换这些。

stdin -- standard input file object; used by input()
#标准输入文件对象;通过input()输入

stdout -- standard output file object; used by print()
#标准输出文件对象;通过print()输出
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.
#标准错误对象;用于错误消息通过分配其他文件对象(或行为类似于文件的对象)
对于这些，可以重定向所有解释器的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.
  #这三个只在a之后的交互会话中可用回溯已经打印出来了。

Static objects:
#静态对象:

builtin_module_names -- tuple of module names built into this interpreter
#builtin_module_names——内置于此解释器中的模块名称的元组

copyright -- copyright notice pertaining to this interpreter
#版权——关于此解释器的版权声明

exec_prefix -- prefix used to find the machine-specific Python library
#exec_prefix——用于查找特定于机器的Python库的前缀

executable -- absolute path of the executable binary of the Python interpreter
#可执行——Python解释器可执行二进制文件的绝对路径

float_info -- a struct sequence with information about the float implementation.
#float_info——一个包含关于浮点实现信息的结构序列。

float_repr_style -- string indicating the style of repr() output for floats
#float_repr_style——字符串，指示浮点数的repr()输出的样式

hash_info -- a struct sequence with information about the hash algorithm.
#hash_info——一个包含散列算法信息的结构序列。

hexversion -- version information encoded as a single integer
#hexversion——将版本信息编码为单个整数

implementation -- Python implementation information.
#实现——Python实现信息。

int_info -- a struct sequence with information about the int implementation.
#int_info——一个包含int实现信息的结构序列。

maxsize -- the largest supported length of containers.
#最大支持的容器长度。

maxunicode -- the value of the largest Unicode code point
#maxunicode——最大的Unicode编码点的值

platform -- platform identifier  #平台——平台标识符

prefix -- prefix used to find the Python library
#前缀——用于查找Python库的前缀

thread_info -- a struct sequence with information about the thread implementation.
#thread_info——一个包含线程实现信息的结构序列。

version -- the version of this interpreter as a string
#版本——这个解释器作为字符串的版本

version_info -- version information as a named tuple
#version_info——版本信息作为一个命名元组

dllhandle -- [Windows only] integer handle of the Python DLL
#dllhandle——[Windows专用] Python DLL的整数句柄

winver -- [Windows only] version number of the Python DLL
#winver——[Windows专用]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._
#displayhook()——将对象打印到屏幕上，并将其保存在build ._中

excepthook() -- print an exception and its traceback to sys.stderr
#excepthook()——打印一个异常及其回溯到sys.stderr的回溯

exc_info() -- return thread-safe information about the current exception
#exc_info()——返回关于当前异常的线程安全信息

exit() -- exit the interpreter by raising SystemExit
#exit()——通过提升SystemExit来退出解释器

getdlopenflags() -- returns flags to be used for dlopen() calls
#getdlopenflags()——返回用于dlopen()调用的标志

getprofile() -- get the global profiling function
#getprofile()——获取全局配置函数

getrefcount() -- return the reference count for an object (plus one :-)
#getrefcount()——返回对象的引用计数(加1:-)

getrecursionlimit() -- return the max recursion depth for the interpreter
#getrecursionlimit()——返回解释器的最大递归深度

getsizeof() -- return the size of an object in bytes
#getsizeof()——以字节为单位返回对象的大小

gettrace() -- get the global debug tracing function
#gettrace()——获取全局调试跟踪函数

setcheckinterval() -- control how often the interpreter checks for events
#setcheckinterval()——控制解释器检查事件的频率

setdlopenflags() -- set the flags to be used for dlopen() calls
#setdlopenflags()——设置用于dlopen()调用的标志

setprofile() -- set the global profiling function
#setprofile()——设置全局配置函数

setrecursionlimit() -- set the max recursion depth for the interpreter
#setrecursionlimit()——设置解释器的最大递归深度

settrace() -- set the global debug tracing function
#settrace()——设置全局调试跟踪函数
"""
# no imports

# Variables with simple values

api_version = 1013

base_exec_prefix = 'C:\Users\lenovo\AppData\Local\Programs\Python\Python37'

base_prefix = 'C:\Users\lenovo\AppData\Local\Programs\Python\Python37'

byteorder = 'little'

copyright = 'Copyright (c) 2001-2018 Python Software Foundation.
All Rights Reserved.

Copyright (c) 2000 BeOpen.com.
All Rights Reserved.

Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.

Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved.'

dllhandle = 140718339260416

dont_write_bytecode = True

executable = 'C:\Users\lenovo\AppData\Local\Programs\Python\Python37\python.exe'

exec_prefix = 'C:\Users\lenovo\AppData\Local\Programs\Python\Python37'

float_repr_style = 'short'

hexversion = 50790640

maxsize = 9223372036854775807
maxunicode = 1114111

platform = 'win32'

prefix = 'C:\Users\lenovo\AppData\Local\Programs\Python\Python37'

version = '3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)]'

winver = '3.7'

_framework = ''

_home = None


# functions

def breakpointhook(*args, **kws):
    # real signature unknown; restored from __doc__
    #真正的签名未知;恢复从__doc__
    """
    breakpointhook(*args, **kws)
    This hook function is called by built-in breakpoint().
    #这个钩子函数由内置的断点breakpoint()调用。
    """
    pass


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()
    """
    # callstats() ->整数元组返回一个函数调用统计数据元组，如果在构建Python时定义了
    # CALL_PROFILE的话。否则,返回None。当启用时，该函数返回关于执行的函数调用数量的详细
    # 的、特定于实现的详细信息。返回值是一个11元组，其中元组中的条目的计数为:
    # 0。所有的函数调用
    # 1。调用PyFunction_Type对象
    # 2。不创建参数元组的PyFunction调用
    # 3。不创建参数tuple和绕过PyEval_EvalCodeEx()的PyFunction调用
    # 4。PyMethod调用
    # 5。PyMethod调用绑定方法
    # 6。PyType调用
    # 7。PyCFunction调用
    # 8。发电机的电话
    # 9。所有其他的电话
    # 10。call_function()执行的堆栈pop数
    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.
    """
    #call_tracking (func, args) ->对象调用func(*args)，同时启用跟踪。保存跟踪状态，
    # 然后恢复跟踪状态。这是为了从检查点从调试器调用，以递归地调试其他代码。
    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._
    """
    #没有打印一个对象给sys。并保存在build ._中
    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.
    """
    #异常(excthook, value, traceback) -> None通过在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.
    """
    #ex_info() ->(类型、值、回溯)返回当前栈帧或旧栈帧中except子句捕获的最新异常的信息。
    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).
    #通过提升SystemExit(status)退出解释器。如果状态被省略或没有，它默认为0(即成功)。
    如果状态是整数，它将用作系统退出状态。如果它是另一种对象，它将被打印和系统
    退出状态为1(即，失败)。
    """
    pass


def getallocatedblocks():  # real signature unknown; restored from __doc__
    """
    getallocatedblocks() -> integer
    Return the number of memory blocks currently allocated, regardless of their
    size.
    """
    #getallocatedblocks()——>整数返回当前分配的内存块的数量，而不管它们的大小。
    return 0


def getcheckinterval():  # real signature unknown; restored from __doc__
    """ getcheckinterval() -> current check interval; see setcheckinterval(). """
    #getcheckinterval() ->当前检查间隔;看到setcheckinterval ()。
    pass


def getdefaultencoding():  # real signature unknown; restored from __doc__
    """
    getdefaultencoding() -> string
    Return the current default string encoding used by the Unicode
    implementation.
    """
    #返回Unicode实现使用的当前默认字符串编码。
    return ""


def getfilesystemencodeerrors():  # real signature unknown; restored from __doc__
    """
    getfilesystemencodeerrors() -> string
    Return the error mode used to convert Unicode filenames in
    operating system filenames.
    """
    #返回用于转换操作系统文件名中的Unicode文件名的错误模式。
    return ""


def getfilesystemencoding():  # real signature unknown; restored from __doc__
    """
    getfilesystemencoding() -> string
    Return the encoding used to convert Unicode filenames in
    operating system filenames.
    """
    #返回用于转换操作系统文件名中的Unicode文件名的编码。
    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.
    """
    #getprofile()返回带有sys.setprofile的分析函数集。请参阅库手册中的profiler一章。
    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.
    """
    #getrecursionlimit()返回递归限制的当前值，即Python解释器堆栈的最大深度。这个限制
    # 可以防止无限递归导致C堆栈溢出和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().
    """
    #返回对象的引用计数。返回的计数通常比您预期的要高，因为它包含(临时)引用作为
    # 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(). """
    #当前线程切换间隔;看到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.
    """
    #gettrace()用sys.settrace返回全局调试跟踪函数集。请参阅库手册中的调试器一章
    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.
    """
    #getwindowsversion()以命名元组的形式返回关于Windows运行版本的信息。成员命名
    # 为:major、minor、build、platform、service_pack、service_pack_major、
    # service_pack_minor、suite_mask和product_type。为了向后兼容，只有前5项可以通过
    # 索引获得。所有元素都是数字，除了service_pack和platform_type是字符串，
    # platform_version是3元组。平台总是2。Product_type对于工作站可能是1，对于域控制器
    # 可能是2，对于服务器可能是3。Platform_version是一个包含版本号的三元组，用于识别操作
    # 系统而不是功能检测。
    pass


def get_asyncgen_hooks():  # real signature unknown; restored from __doc__
    """
    get_asyncgen_hooks()
    Return a namedtuple of installed asynchronous generators hooks (firstiter, finalizer).
    """
    #get_asyncgen_hooks()返回一个已安装的异步生成器挂钩的命名元组(firstiter, finalizer)。
    pass


def get_coroutine_origin_tracking_depth(*args, **kwargs):  # real signature unknown
    """ Check status of origin tracking for coroutine objects in this thread. """
    #检查此线程中协程对象的原点跟踪状态。
    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.
    """
    #get_coroutine_wrapper()返回sys.set_coroutine_wrapper所设置的coroutine对象的包装器。
    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.
    """
    #intern(string) -> string``Intern'' the given string.这将进入interned字符串
    # (全局)表中的字符串，其目的是加速字典查找。返回具有相同值的字符串本身或先前嵌入的
    # 字符串对象。
    return ""


def is_finalizing():  # real signature unknown; restored from __doc__
    """
    is_finalizing()
    Return True if Python is exiting.
    """
    #如果Python退出，is_finalizing()返回True。
    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.
    """
    #setcheckinterval(n)告诉Python解释器在每n条指令中检查异步事件。这也会影响线程切换的频率
    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.
    """
    #设置配置函数。它将在每个函数调用和返回时被调用。请参阅库手册中的profiler一章。
    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.
    """
    #setrecursionlimit(n)设置Python解释器堆栈的最大深度为n。这个限制可以防止无限递归
    # 导致C堆栈溢出和Python崩溃。最大的可能极限是平台相关的。
    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).
    """
    #在Python解释器中设置理想的线程切换延迟，如果解释器执行不间断代码的长序列(这是具体
    # 实现和工作负载相关的)，切换线程的实际频率可能会更低。参数必须表示所需的切换延迟
    # (以秒为单位)，典型值为0.005(5毫秒)。
    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.
    """
    #set_asyncgen_hooks(*， firstiter=None, finalizer=None)为异步生成器对象设置一个终结器。
    pass


def set_coroutine_origin_tracking_depth(*args, **kwargs):  # real signature unknown
    """
    Enable or disable origin tracking for coroutine objects in this thread.
    Coroutine objects will track 'depth' frames of traceback information about
    where they came from, available in their cr_origin attribute. Set depth of 0
    to disable.
    """
    #在此线程中启用或禁用协程对象的原点跟踪。协同程序对象将跟踪关于它们来自何处的回溯信息
    # 的“深度”帧，这些信息可以在它们的cr_origin属性中找到。设置深度为0以禁用。
    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.
    """
    #返回一个将每个当前线程T的线程id映射到T的当前堆栈帧的字典。此函数只应用于专门用途。
    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.
    """
    #_enablelegacywindowsfsencoding()将默认的文件系统编码更改为mbcs:替换为与早期
    # Python版本的一致性。有关更多信息，请参见PEP 529。这相当于在启动Python之前定义
    # PYTHONLEGACYWINDOWSFSENCODING环境变量。
    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.
    """
    #bb0 frameobject从调用堆栈返回一个框架对象。如果给定了可选的整数深度，则返回堆栈顶
    # 部下面许多调用的框架对象。如果这比调用堆栈更深，则会引发ValueError。depth的默认值
    # 为0，返回调用堆栈顶部的框架。此功能应仅用于内部和专门用途。
    pass


def __breakpointhook__(*args, **kwargs):  # real signature unknown
    """
    breakpointhook(*args, **kws)
    This hook function is called by built-in breakpoint().
    """
    #breakpointhook(*args， **kws)这个钩子函数是由内置的breakpoint()调用的。
    pass


def __displayhook__(*args, **kwargs):  # real signature unknown
    """
    displayhook(object) -> None
    Print an object to sys.stdout and also save it in builtins._
    """
    #没有打印一个对象给sys。并保存在build ._中
    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.
    """
    #通过在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.
        """
        #找到内置模块。如果指定了“path”，则认为搜索失败。这种方法不赞成使用。使用find_spec ()
        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. """
        #返回None，因为内置模块没有代码对象。
        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. """
        #返回False，因为内置模块从来不是包
        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.
        """
        #将指定的模块加载到sys中。模块并返回它。这种方法不赞成使用。使用加载程序。exec_module代替。
        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.
        """
        #返回模块的repr。该方法不赞成使用。进口机器自己完成这项工作。
        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 = []  # 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,
    False,
    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 = [
    'C:\Program Files\JetBrains\PyCharm Community Edition 2018.1.4\helpers',
    'C:\Users\lenovo\AppData\Local\Programs\Python\Python37\python37.zip',
    'C:\Users\lenovo\AppData\Local\Programs\Python\Python37\DLLs',
    'C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib',
    'C:\Users\lenovo\AppData\Local\Programs\Python\Python37',
    'C:\Users\lenovo\AppData\Local\Programs\Python\Python37\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 = None  # (!) forward: __stdout__, real value is ''

thread_info = (
    'nt',
    None,
    None,
)

version_info = (
    3,
    7,
    0,
    'final',
    0,
)

warnoptions = []

_git = (
    'CPython',
    'v3.7.0',
    '1bf9cc5093',
)

_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

• time模块

　　time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：

1.  time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
2. time.asctime([tupletime])接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
3. time.clock( )用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
4. time.ctime([secs])作用相当于asctime(localtime(secs))，未给参数相当于asctime()
5. time.gmtime([secs])接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
6. time.localtime([secs])接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
7. time.mktime(tupletime)接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
8. time.sleep(secs)推迟调用线程的运行，secs指秒数。
9. time.strftime(fmt[,tupletime])接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
10. time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')根据fmt的格式把一个时间字符串解析为时间元组。
11. time.time( )返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
12. time.tzset()根据环境变量TZ重新初始化时间相关设置。

　　python中时间日期格式化符号：

格式	含义	备注
%a	本地（locale）简化星期名称
%A	本地完整星期名称
%b	本地简化月份名称
%B	本地完整月份名称
%c	本地相应的日期和时间表示
%d	一个月中的第几天（01 - 31）
%H	一天中的第几个小时（24小时制，00 - 23）
%I	第几个小时（12小时制，01 - 12）
%j	一年中的第几天（001 - 366）
%m	月份（01 - 12）
%M	分钟数（00 - 59）
%p	本地am或者pm的相应符	一
%S	秒（01 - 61）	二
%U	一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。	三
%w	一个星期中的第几天（0 - 6，0是星期天）	三
%W	和%U基本相同，不同的是%W以星期一为一个星期的开始。
%x	本地相应日期
%X	本地相应时间
%y	去掉世纪的年份（00 - 99）
%Y	完整的年份
%Z	时区的名字（如果不存在为空字符）
%%	‘%’字符

 　　time模块包含了以下2个非常重要的属性：

序号	属性及描述
1	time.timezone 属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
2	time.tzname 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

备注：

1. “%p”只有与“%I”配合使用才有效果。

2. 文档中强调确实是0 - 61，而不是59，闰年秒占两秒（汗一个）。

3. 当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%U和%W才会被计算。

　　下面具体介绍几个常用的time模块方法，详见View Code

'''time模块：'''
#从1970年开始 到当前时间（时间戳）
import time
print(time.time())

#时区  夏令时：白天多出两天
import time
print(time.localtime())

#中国：东八区
import time
print(time.timezone)

#夏令时
import time
print(time.daylight)

#程序停止几秒
import time
print(time.sleep(8))

#年、月、日、时、分、秒、夏令时
import time
print(time.gmtime())

#进行格式化转换
import time
x = time.localtime()
print(time.strftime("%Y-%m-%d %H:%M:%S",x))

#将格式化字符串变成元组形式
import time
print(time.strptime("2018-11-4 11:04:34","%Y-%m-%d %H:%M:%S"))

'''Python time asctime() 
函数接受时间元组并返回一个可读的形式为  
Tue Dec 11 18:07:14 2008
（2008年12月11日 周二18时07分14秒）的24个字符的字符串
把一个表示时间的元组或者struct_time表示为这种形式：
'Sun Jun 20 23:21:05 1993'。
如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())
'''
#国际标准时间格式
import time
print(time.asctime((2018,11,4,11,4,34,2,227,-1)))

'''
time.ctime([secs])：
把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。
如果参数未给或者为None的时候，将会默认time.time()为参数。
它的作用相当于time.asctime(time.localtime(secs))
'''
#浮点数的秒数
import time
print(time.ctime(5635512.2))
print(time.ctime())

# encoding: utf-8
# module time
# from (built-in)
# by generator 1.145
"""
This module provides various functions to manipulate time values.

There are two standard representations of time.  One is the number
of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer
or a floating point number (to represent fractions of seconds).
The Epoch is system-defined; on Unix, it is generally January 1st, 1970.
The actual value can be retrieved by calling gmtime(0).

The other representation is a tuple of 9 integers giving local time.
The tuple items are:
  year (including century, e.g. 1998)
  month (1-12)
  day (1-31)
  hours (0-23)
  minutes (0-59)
  seconds (0-59)
  weekday (0-6, Monday is 0)
  Julian day (day in the year, 1-366)
  DST (Daylight Savings Time) flag (-1, 0 or 1)
If the DST flag is 0, the time is given in the regular time zone;
if it is 1, the time is given in the DST time zone;
if it is -1, mktime() should guess based on the date and time.
"""
#这个模块提供了各种操作时间值的函数。时间有两种标准表示方式。一个是自纪元以来的秒数，
# 用UTC表示。它可以是整数或浮点数(表示秒的小数)。时代是系统定义的;在Unix上，
# 通常是1970年1月1日。实际值可以通过调用gmtime(0)来检索。
# 另一种表示是一个由9个整数组成的元组，提供本地时间。元组项目有:
#年份(包括世纪，例如1998年)
#月(1 - 12)
#天(1 - 31)
#小时(0-23)
#分钟(0-59)
#秒(0-59)
#星期一(0-6日，星期一0日)
#儒略日(一年中的一天，1-366)
#DST(夏令时)标志(-1,0或1)如果DST标志为0，时间在常规时区给出;如果是1，时间在DST时区
# 给出;如果是-1,mktime()应该根据日期和时间猜测。


# no imports

# Variables with simple values  #带有简单值的变量

altzone = -32400

daylight = 0

timezone = -28800

_STRUCT_TM_ITEMS = 11


# functions

def asctime(p_tuple=None):  # real signature unknown; restored from __doc__
    """
    asctime([tuple]) -> string

    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
    When the time tuple is not present, current time as returned by localtime()
    is used.
    """
    #将时间元组转换为字符串。“1998年6月06日星期六16:26:11”。当time元组不存在时，
    # 使用localtime()返回的当前时间。
    return ""


def clock():  # real signature unknown; restored from __doc__
    """
    clock() -> floating point number

    Return the CPU time or real time since the start of the process or since
    the first call to clock().  This has as much precision as the system
    records.
    """
    #返回进程开始或第一次调用clock()以来的CPU时间或实时时间。这与系统记录一样精确。
    return 0.0


def ctime(seconds=None):  # known case of time.ctime
    """
    ctime(seconds) -> string

    Convert a time in seconds since the Epoch to a string in local time.
    This is equivalent to asctime(localtime(seconds)). When the time tuple is
    not present, current time as returned by localtime() is used.
    """
    #将纪元以来的时间(以秒为单位)转换为本地时间的字符串。这相当于
    #asctime(localtime(seconds))。当time元组不存在时，使用localtime()返回的当前时间。
    return ""


def get_clock_info(name):  # real signature unknown; restored from __doc__
    """
    get_clock_info(name: str) -> dict

    Get information of the specified clock.
    """
    #获取指定时钟的信息。
    return {}


def gmtime(seconds=None):  # real signature unknown; restored from __doc__
    """
    gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
                           tm_sec, tm_wday, tm_yday, tm_isdst)

    Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
    GMT).  When 'seconds' is not passed in, convert the current time instead.

    If the platform supports the tm_gmtoff and tm_zone, they are available as
    attributes only.
    """
    #将大纪元以来的秒转换为表示UTC(即格林尼治时间)的时间元组。如果没有传入“秒”，
    # 则转换当前时间。如果平台支持tm_gmtoff和tm_zone，那么它们只能作为属性使用。
    pass


def localtime(seconds=None):  # real signature unknown; restored from __doc__
    """
    localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
                              tm_sec,tm_wday,tm_yday,tm_isdst)

    Convert seconds since the Epoch to a time tuple expressing local time.
    When 'seconds' is not passed in, convert the current time instead.
    """
    #将大纪元以来的秒转换为表示本地时间的时间元组。如果没有传入“秒”，则转换当前时间。
    pass


def mktime(p_tuple):  # real signature unknown; restored from __doc__
    """
    mktime(tuple) -> floating point number

    Convert a time tuple in local time to seconds since the Epoch.
    Note that mktime(gmtime(0)) will not generally return zero for most
    time zones; instead the returned value will either be equal to that
    of the timezone or altzone attributes on the time module.
    """
    #mktime(元组)->浮点数
    # 将本地时间中的时间元组转换为秒，因为Epoch提示mktime(gmtime(0))通常不会为
    # mos时区返回零;相反，返回的值将等于time模块上的时区属性或altzone属性的值。
    return 0.0


def monotonic():  # real signature unknown; restored from __doc__
    """
    monotonic() -> float

    Monotonic clock, cannot go backward.
    """
    #单调的时钟，不能倒转。
    return 0.0


def monotonic_ns():  # real signature unknown; restored from __doc__
    """
    monotonic_ns() -> int

    Monotonic clock, cannot go backward, as nanoseconds.
    """
    #单调时钟，不能像纳秒那样倒转。
    return 0


def perf_counter():  # real signature unknown; restored from __doc__
    """
    perf_counter() -> float

    Performance counter for benchmarking.
    """
    #性能计数器用于基准测试。
    return 0.0


def perf_counter_ns():  # real signature unknown; restored from __doc__
    """
    perf_counter_ns() -> int

    Performance counter for benchmarking as nanoseconds.
    """
    #性能计数器，用于基准测试为纳秒。
    return 0


def process_time():  # real signature unknown; restored from __doc__
    """
    process_time() -> float

    Process time for profiling: sum of the kernel and user-space CPU time.
    """
    #分析的进程时间:内核和用户空间CPU时间的总和。
    return 0.0


def process_time_ns(*args, **kwargs):  # real signature unknown
    """
    process_time() -> int

    Process time for profiling as nanoseconds:
    sum of the kernel and user-space CPU time.
    """
    #用于分析纳秒的进程时间:内核和用户空间CPU时间的总和。
    pass


def sleep(seconds):  # real signature unknown; restored from __doc__
    """
    sleep(seconds)

    Delay execution for a given number of seconds.  The argument may be
    a floating point number for subsecond precision.
    """
    #对给定的秒数延迟执行。参数可以是次秒精度的浮点数
    pass


def strftime(format, p_tuple=None):  # real signature unknown; restored from __doc__
    """
    strftime(format[, tuple]) -> string

    Convert a time tuple to a string according to a format specification.
    See the library reference manual for formatting codes. When the time tuple
    is not present, current time as returned by localtime() is used.
    #根据格式规范将时间元组转换为字符串。有关格式化代码的库参考手册。
    当time元组不存在时，使用localtime()返回的当前时间

    Commonly used format codes:

    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.

    Other codes may be available on your platform.  See documentation for
    the C library strftime function.
    #在您的平台上可以使用其他代码。请参阅C库strftime函数的文档。
    """
    return ""


def strptime(string, format):  # real signature unknown; restored from __doc__
    """
    strptime(string, format) -> struct_time

    Parse a string to a time tuple according to a format specification.
    See the library reference manual for formatting codes (same as
    strftime()).

    Commonly used format codes:

    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.

    Other codes may be available on your platform.  See documentation for
    the C library strftime function.
    """
    #strptime(字符串，格式)-> struct_time
    #根据格式规范将字符串解析为时间元组。有关格式化代码(与strftime()相同)，请参阅库参考手册。

    #常用格式代码:
    #% Y: 以世纪为十进制的年份。
    #% m: 月份为十进制数[01, 12]。
    #% d: 以小数形式表示的月份日[01, 31]。
    #% H: 小时(24小时时钟)作为小数[00, 23]。
    #% M: 分钟作为小数[00, 59]。
    #% S: 作为小数的秒[00, 61]。
    #% z: 世界时偏移距。
    #% a：本地语言环境的缩写的工作日名称。
    #% A：本地语言环境的完整工作日名称。
    #% b: Locale的缩写名。
    #% B: Locale的全名。
    #% c: 语言环境的适当日期和时间表示。
    #% I: Hour(12小时时钟)作为小数[01, 12]。
    #% p: 现场相当于上午或下午。
    #在您的平台上可以使用其他代码。请参阅C库strftime函数的文档
    return struct_time


def thread_time():  # real signature unknown; restored from __doc__
    """
    thread_time() -> float

    Thread time for profiling: sum of the kernel and user-space CPU time.
    """
    #用于分析的线程时间:内核和用户空间CPU时间的总和。
    return 0.0


def thread_time_ns(*args, **kwargs):  # real signature unknown
    """
    thread_time() -> int

    Thread time for profiling as nanoseconds:
    sum of the kernel and user-space CPU time.
    """
    #用于分析纳秒的线程时间:内核和用户空间CPU时间的总和。
    pass


def time():  # real signature unknown; restored from __doc__
    """
    time() -> floating point number

    Return the current time in seconds since the Epoch.
    Fractions of a second may be present if the system clock provides them.
    """
    #以秒为单位返回纪元以来的当前时间。如果系统时钟提供了几分之一秒的时间，那么可能会出现这种情况。
    return 0.0


def time_ns():  # real signature unknown; restored from __doc__
    """
    time_ns() -> int

    Return the current time in nanoseconds since the Epoch.
    """
    #返回纪元以来的当前时间(以纳秒为单位)。
    return 0


# classes

class struct_time(tuple):
    """
    The time value as returned by gmtime(), localtime(), and strptime(), and
     accepted by asctime(), mktime() and strftime().  May be considered as a
     sequence of 9 integers.
     Note that several fields' values are not the same as those defined by
     the C language standard for struct tm.  For example, the value of the
     field tm_year is the actual year, not year - 1900.  See individual
     fields' descriptions for details.
    """
    #由gmtime()、localtime()和strptime()返回并被asctime()、mktime()和strftime()
    # 接受的时间值。可以认为是9个整数的序列。注意，几个字段的值与struct tm的C语言
    # 标准定义的值不相同。例如，字段tm_year的值是实际年份，而不是年- 1900。有关详细
    # 信息，请参阅各个字段的说明。

    def __init__(self, *args, **kwargs):  # real signature unknown
        pass

    @staticmethod  # known case of __new__
    def __new__(*args, **kwargs):  # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        #创建并返回一个新对象。请参阅帮助(类型)以获得准确的签名。
        pass

    def __reduce__(self, *args, **kwargs):  # real signature unknown
        pass

    def __repr__(self, *args, **kwargs):  # real signature unknown
        """ Return repr(self). """
        pass

    tm_gmtoff = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """offset from UTC in seconds"""  #以秒为单位偏移UTC

    tm_hour = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """hours, range [0, 23]"""

    tm_isdst = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """1 if summer time is in effect, 0 if not, and -1 if unknown"""

    tm_mday = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """day of month, range [1, 31]"""

    tm_min = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """minutes, range [0, 59]"""

    tm_mon = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """month of year, range [1, 12]"""

    tm_sec = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """seconds, range [0, 61])"""

    tm_wday = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """day of week, range [0, 6], Monday is 0"""

    tm_yday = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """day of year, range [1, 366]"""

    tm_year = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """year, for example, 1993"""

    tm_zone = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """abbreviation of timezone name""" #时区名称的缩写

    n_fields = 11
    n_sequence_fields = 9
    n_unnamed_fields = 0


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.
        """
        #找到内置模块。如果指定了“path”，则认为搜索失败。这种方法不赞成使用。使用find_spec ()。
        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. """
        #返回None，因为内置模块没有代码对象。
        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. """
        #返回False，因为内置模块从来不是包
        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.
        """
        #将指定的模块加载到sys中。模块并返回它。这种方法不赞成使用。使用加载程序。exec_module代替。
        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.
        """
        #返回模块的repr。该方法不赞成使用。进口机器自己完成这项工作。
        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  具有复数的变量

tzname = (
    'Öйú±ê׼ʱ¼ä',
    'ÖйúÏÄÁîʱ',
)

__spec__ = None  # (!) real value is ''

• datetime模块：

　　datetime模块用于是date和time模块的合集，datetime有两个常量，MAXYEAR和MINYEAR，分别是9999和1。

　　datetime模块定义了5个类，分别是：

　　1.datetime.date：表示日期的类

　　2.datetime.datetime：表示日期时间的类

　　3.datetime.time：表示时间的类

　　4.datetime.timedelta：表示时间间隔，即两个时间点的间隔

　　5.datetime.tzinfo：时区的相关信息

　　datatime模块主要是借鉴了苍松博客 https://www.cnblogs.com/tkqasn/p/6001134.html 

　　首先，先看下datatime.data类：

　　datetime.date(year, month, day)

　　静态方法和字段

date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；

　　方法和属性

d = date(2011,06,03)#date对象
d.year、date.month、date.day：年、月、日；
d.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
d.timetuple()：返回日期对应的time.struct_time对象；
d.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
d.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
d.isocalendar()：返回格式如(year，month，day)的元组；
d.isoformat()：返回格式如'YEAR-MONTH-DAY’的字符串；
d.strftime(fmt)：和time模块format相同。

　　其次，再看下datatime.time类：

　　datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ) 

　　静态方法和字段

time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；

　　方法和属性

t = datetime.time(10,23,15)#time对象
t.hour、t1.minute、t1.second、t1.microsecond：时、分、秒、微秒；
t.tzinfo：时区信息；
t.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
t.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；
t.strftime(fmt)：同time模块中的format；

　　最后，再看下datatime.datatime类：

　　datetime相当于date和time结合起来。
　　datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )

　　静态方法和字段

datetime.today()：返回一个表示当前本地时间的datetime对象；
datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
datetime.utcnow()：返回一个当前utc时间的datetime对象；#格林威治时间
datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
datetime.combine(date, time)：根据date和time，创建一个datetime对象；
datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

　　方法和属性

dt=datetime.now()#datetime对象
dt.year、month、day、hour、minute、second、microsecond、tzinfo：
dt.date()：获取date对象；
dt.time()：获取time对象；
dt. replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：
dt. timetuple ()
dt. utctimetuple ()
dt. toordinal ()
dt. weekday ()
dt. isocalendar ()
dt. isoformat ([ sep] )
dt. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
dt. strftime (format)

　　下面具体介绍几个常用的datetime模块方法,详见View Code

'''datetime'''
#获取日期
import datetime
print(datetime.date)

#获取时分秒
import datetime
print(datetime.time)

#获取两者的整体
import datetime
print(datetime.datetime)

#获取当前的年月日时分秒
import datetime
print(datetime.datetime.now())

#获取向前或者向后某段时间的时间
import datetime
print(datetime.timedelta(-3))
print(datetime.timedelta(3))
print(datetime.datetime.now()+datetime.timedelta(hours=3))
print(datetime.datetime.now()+datetime.timedelta(minutes=3))

• 随机模块random：

　　下面具体介绍几个常用的random模块方法,详见View Code

'''随机模块random'''
import  random

# 生成随机数,但必须做出相应转换
print(random.random())
print(int(random.random()*100))

# 生成整数随机数
print(random.randint(1,5))

# 生成顺序随机数
print(random.randrange(1,5))

# 随机生成序列中的某一项，可以是元组、列表、字符串
print(random.choice(["a","b","c","d"]))

# 随机生成字符串的两个数
print(random.sample("dgfdgfh",2))

# 随机生成浮点数
print(random.uniform(1,4))

# “洗牌”方法，将传入的序列重新打乱排序
l=[1,3,5,6,8]
random.shuffle(l)
print(l)

"""Random variable generators.

    integers
    --------
           uniform within range

    sequences
    ---------
           pick random element
           pick random sample
           pick weighted random sample
           generate random permutation

    distributions on the real line:
    ------------------------------
           uniform
           triangular
           normal (Gaussian)
           lognormal
           negative exponential
           gamma
           beta
           pareto
           Weibull

    distributions on the circle (angles 0 to 2pi)
    ---------------------------------------------
           circular uniform
           von Mises

General notes on the underlying Mersenne Twister core generator:

* The period is 2**19937-1.
* It is one of the most extensively tested generators in existence.
* The random() method is implemented in C, executes in a single Python step,
  and is, therefore, threadsafe.

"""
'''随机变量发电机。
整数
- - - - - - - - - -
统一的范围内
序列
- - - - - - - - - - - -
选择随机元素
选择随机样本
随机抽样
生成随机排列
实线分布:
-----------------------------
统一的
三角
正常(高斯)
对数正态
负指数
γ
β
帕累托
威布尔
圆上的分布(角度0到2)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
圆形的制服
•冯•米塞斯
关于潜在的Mersenne缠绕核心发生器的一般说明:
*期间为2**1993 -1年。
*它是现存最广泛测试的发电机之一。
* random()方法在C语言中实现，在一个Python步骤中执行，
因此，它是线程安全的。'''

from warnings import warn as _warn
from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
from os import urandom as _urandom
from _collections_abc import Set as _Set, Sequence as _Sequence
from hashlib import sha512 as _sha512
import itertools as _itertools
import bisect as _bisect
import os as _os

__all__ = ["Random","seed","random","uniform","randint","choice","sample",
           "randrange","shuffle","normalvariate","lognormvariate",
           "expovariate","vonmisesvariate","gammavariate","triangular",
           "gauss","betavariate","paretovariate","weibullvariate",
           "getstate","setstate", "getrandbits", "choices",
           "SystemRandom"]

NV_MAGICCONST = 4 * _exp(-0.5)/_sqrt(2.0)
TWOPI = 2.0*_pi
LOG4 = _log(4.0)
SG_MAGICCONST = 1.0 + _log(4.5)
BPF = 53        # Number of bits in a float
RECIP_BPF = 2**-BPF


# Translated by Guido van Rossum from C source provided by
# Adrian Baddeley.  Adapted by Raymond Hettinger for use with
# the Mersenne Twister  and os.urandom() core generators.
#Guido van Rossum从C资料中搜索，Adrian Baddeley提供。由Raymond Hettinger改编，
# 用于Mersenne Twister和os.urandom()核心生成器。

import _random

class Random(_random.Random):
    """Random number generator base class used by bound module functions.

    Used to instantiate instances of Random to get generators that don't
    share state.

    Class Random can also be subclassed if you want to use a different basic
    generator of your own devising: in that case, override the following
    methods:  random(), seed(), getstate(), and setstate().
    Optionally, implement a getrandbits() method so that randrange()
    can cover arbitrarily large ranges.
    """
    #随机数生成器基类用于绑定模块函数。用于实例化随机实例以获得不共享状态的生成器。
    # 如果您想使用自己设计的不同基本生成器，也可以对类Random进行子类化:在这种情况下，
    # 重写以下方法:Random()、seed()、getstate()和setstate()。或者，
    # 实现getrandbits()方法，使randrange()可以覆盖任意大的范围。

    VERSION = 3     # used by getstate/setstate

    def __init__(self, x=None):
        """Initialize an instance.

        Optional argument x controls seeding, as for Random.seed().
        """
        #初始化一个实例。可选参数x控制种子，如Random.seed()。

        self.seed(x)
        self.gauss_next = None

    def seed(self, a=None, version=2):
        """Initialize internal state from hashable object.

        None or no argument seeds from current time or from an operating
        system specific randomness source if available.

        If *a* is an int, all bits are used.

        For version 2 (the default), all of the bits are used if *a* is a str,
        bytes, or bytearray.  For version 1 (provided for reproducing random
        sequences from older versions of Python), the algorithm for str and
        bytes generates a narrower range of seeds.
        """
        #从hashable对象初始化内部状态。没有或没有参数种子来自当前时间或从操作系统
        # 特定随机性源(如果可用)。如果*a*是int，则使用所有位。对于版本2(默认)，
        # 如果*a*是str、字节或bytearray，则使用所有的位。对于版本1(用于从旧版本
        # 的Python中复制随机序列)，str和字节的算法生成的种子范围较窄。

        if version == 1 and isinstance(a, (str, bytes)):
            a = a.decode('latin-1') if isinstance(a, bytes) else a
            x = ord(a[0]) << 7 if a else 0
            for c in map(ord, a):
                x = ((1000003 * x) ^ c) & 0xFFFFFFFFFFFFFFFF
            x ^= len(a)
            a = -2 if x == -1 else x

        if version == 2 and isinstance(a, (str, bytes, bytearray)):
            if isinstance(a, str):
                a = a.encode()
            a += _sha512(a).digest()
            a = int.from_bytes(a, 'big')

        super().seed(a)
        self.gauss_next = None

    def getstate(self):
        """Return internal state; can be passed to setstate() later."""
        #返回内部状态;可以稍后传递给setstate()。
        return self.VERSION, super().getstate(), self.gauss_next

    def setstate(self, state):
        """Restore internal state from object returned by getstate()."""
        #从getstate()返回的对象中恢复内部状态。
        version = state[0]
        if version == 3:
            version, internalstate, self.gauss_next = state
            super().setstate(internalstate)
        elif version == 2:
            version, internalstate, self.gauss_next = state
            # In version 2, the state was saved as signed ints, which causes
            #   inconsistencies between 32/64-bit systems. The state is
            #   really unsigned 32-bit ints, so we convert negative ints from
            #   version 2 to positive longs for version 3.
            try:
                internalstate = tuple(x % (2**32) for x in internalstate)
            except ValueError as e:
                raise TypeError from e
            super().setstate(internalstate)
        else:
            raise ValueError("state with version %s passed to "
                             "Random.setstate() of version %s" %
                             (version, self.VERSION))

## ---- Methods below this point do not need to be overridden when
## ---- subclassing for the purpose of using a different core generator.

## -------------------- pickle support  -------------------

    # Issue 17489: Since __reduce__ was defined to fix #759889 this is no
    # longer called; we leave it here because it has been here since random was
    # rewritten back in 2001 and why risk breaking something.
    def __getstate__(self): # for pickle
        return self.getstate()

    def __setstate__(self, state):  # for pickle
        self.setstate(state)

    def __reduce__(self):
        return self.__class__, (), self.getstate()

## -------------------- integer methods  -------------------

    def randrange(self, start, stop=None, step=1, _int=int):
        """Choose a random item from range(start, stop[, step]).

        This fixes the problem with randint() which includes the
        endpoint; in Python this is usually not what you want.
        """
        #从范围(开始，停止[，步骤])中随机选择一个项目。这修复了randint()中包含
        # 端点的问题;在Python中，这通常不是您想要的。

        # This code is a bit messy to make it fast for the
        # common case while still doing adequate error checking.
        istart = _int(start)
        if istart != start:
            raise ValueError("non-integer arg 1 for randrange()")
        if stop is None:
            if istart > 0:
                return self._randbelow(istart)
            raise ValueError("empty range for randrange()")

        # stop argument supplied.
        istop = _int(stop)
        if istop != stop:
            raise ValueError("non-integer stop for randrange()")
        width = istop - istart
        if step == 1 and width > 0:
            return istart + self._randbelow(width)
        if step == 1:
            raise ValueError("empty range for randrange() (%d,%d, %d)" % (istart, istop, width))

        # Non-unit step argument supplied.  #提供了非单位步骤参数。
        istep = _int(step)
        if istep != step:
            raise ValueError("non-integer step for randrange()")
        if istep > 0:
            n = (width + istep - 1) // istep
        elif istep < 0:
            n = (width + istep + 1) // istep
        else:
            raise ValueError("zero step for randrange()")

        if n <= 0:
            raise ValueError("empty range for randrange()")

        return istart + istep*self._randbelow(n)

    def randint(self, a, b):
        """Return random integer in range [a, b], including both end points.
        """
        #返回范围[a, b]中的随机整数，包括两个端点。

        return self.randrange(a, b+1)

    def _randbelow(self, n, int=int, maxsize=1<<BPF, type=type,
                   Method=_MethodType, BuiltinMethod=_BuiltinMethodType):
        "Return a random int in the range [0,n).  Raises ValueError if n==0."
        #在范围[0,n]中返回一个随机整数。如果n= 0，将引发ValueError。

        random = self.random
        getrandbits = self.getrandbits
        # Only call self.getrandbits if the original random() builtin method
        # has not been overridden or if a new getrandbits() was supplied.
        #只叫自我。如果未覆盖原来的random()内建方法，或者提供了新的getrandbits()，则为getrandbits()。
        if type(random) is BuiltinMethod or type(getrandbits) is Method:
            k = n.bit_length()  # don't use (n-1) here because n can be 1
            r = getrandbits(k)          # 0 <= r < 2**k
            while r >= n:
                r = getrandbits(k)
            return r
        # There's an overridden random() method but no new getrandbits() method,
        # so we can only use random() from here.
        #有一个被重写的random()方法，但是没有新的getrandbits()方法，所以我们只能从这里使用random()。
        if n >= maxsize:
            _warn("Underlying random() generator does not supply 
"
                "enough bits to choose from a population range this large.
"
                "To remove the range limitation, add a getrandbits() method.")
            #基础random()生成器没有提供足够的位从这么大的总体范围中进行选择。
            # 要消除范围限制，添加一个getrandbits()方法.
            return int(random() * n)
        if n == 0:
            raise ValueError("Boundary cannot be zero边界不能为零")
        rem = maxsize % n
        limit = (maxsize - rem) / maxsize   # int(limit * maxsize) % n == 0
        r = random()
        while r >= limit:
            r = random()
        return int(r*maxsize) % n

## -------------------- sequence methods  -------------------

    def choice(self, seq):
        """Choose a random element from a non-empty sequence."""
        #从非空序列中选择一个随机元素。
        try:
            i = self._randbelow(len(seq))
        except ValueError:
            raise IndexError('Cannot choose from an empty sequence') from None
        return seq[i]

    def shuffle(self, x, random=None):
        """Shuffle list x in place, and return None.

        Optional argument random is a 0-argument function returning a
        random float in [0.0, 1.0); if it is the default None, the
        standard random.random will be used.
        """
        #将Shuffle列表x放在适当的位置，并返回None。可选参数random是一个0参数函数，
        # 返回[0.0,1.0]中的一个随机浮点数;如果是默认的None，则为标准随机。将使用random。

        if random is None:
            randbelow = self._randbelow
            for i in reversed(range(1, len(x))):
                # pick an element in x[:i+1] with which to exchange x[i]
                j = randbelow(i+1)
                x[i], x[j] = x[j], x[i]
        else:
            _int = int
            for i in reversed(range(1, len(x))):
                # pick an element in x[:i+1] with which to exchange x[i]
                j = _int(random() * (i+1))
                x[i], x[j] = x[j], x[i]

    def sample(self, population, k):
        """Chooses k unique random elements from a population sequence or set.

        Returns a new list containing elements from the population while
        leaving the original population unchanged.  The resulting list is
        in selection order so that all sub-slices will also be valid random
        samples.  This allows raffle winners (the sample) to be partitioned
        into grand prize and second place winners (the subslices).

        Members of the population need not be hashable or unique.  If the
        population contains repeats, then each occurrence is a possible
        selection in the sample.

        To choose a sample in a range of integers, use range as an argument.
        This is especially fast and space efficient for sampling from a
        large population:   sample(range(10000000), 60)
        """
        #从一个总体序列或集合中选择k个唯一的随机元素。结果列表是按选择顺序排列的，
        # 因此所有的子切片也将是有效的随机样本。这允许抽奖获奖者(样本)被划分为大奖
        # 和第二名获奖者(子部分)。人口中的成员不需要是有用的或独特的。如果总体包含
        # 重复，那么每个事件都是样本中可能的选择。要在整数范围内选择一个样本，使用
        # range作为参数。这对于从大量人群中进行抽样来说特别快速和节省空间:样本
        # (范围(10000000)，60)

        # Sampling without replacement entails tracking either potential
        # selections (the pool) in a list or previous selections in a set.
        ##不进行替换的抽样需要跟踪列表中的潜在选择(池)或集合中的先前选择。

        # When the number of selections is small compared to the
        # population, then tracking selections is efficient, requiring
        # only a small set and an occasional reselection.  For
        # a larger number of selections, the pool tracking method is
        # preferred since the list takes less space than the
        # set and it doesn't suffer from frequent reselections.
        #当选择的数量与总体数量相比很小时，跟踪选择是有效的，只需要一个小的集合和偶尔的重新选择。对于更多的选择，最好使用池跟踪方法，因为列表比集合占用的空间更少，而且不会频繁地重新选择。

        if isinstance(population, _Set):
            population = tuple(population)
        if not isinstance(population, _Sequence):
            raise TypeError("Population must be a sequence or set.  For dicts, use list(d).")
        randbelow = self._randbelow
        n = len(population)
        if not 0 <= k <= n:
            raise ValueError("Sample larger than population or is negative")
        result = [None] * k
        setsize = 21        # size of a small set minus size of an empty list 一个小集合的大小减去一个空列表的大小
        if k > 5:
            setsize += 4 ** _ceil(_log(k * 3, 4)) # table size for big sets
        if n <= setsize:
            # An n-length list is smaller than a k-length set
            pool = list(population)
            for i in range(k):         # invariant:  non-selected at [0,n-i)
                j = randbelow(n-i)
                result[i] = pool[j]
                pool[j] = pool[n-i-1]   # move non-selected item into vacancy
        else:
            selected = set()
            selected_add = selected.add
            for i in range(k):
                j = randbelow(n)
                while j in selected:
                    j = randbelow(n)
                selected_add(j)
                result[i] = population[j]
        return result

    def choices(self, population, weights=None, *, cum_weights=None, k=1):
        """Return a k sized list of population elements chosen with replacement.
        If the relative weights or cumulative weights are not specified,
        the selections are made with equal probability.
        """
        #返回替换后选择的k大小的总体元素列表。如果没有指定相对权重或累积权重，则选择的概率是相等的。
        random = self.random
        if cum_weights is None:
            if weights is None:
                _int = int
                total = len(population)
                return [population[_int(random() * total)] for i in range(k)]
            cum_weights = list(_itertools.accumulate(weights))
        elif weights is not None:
            raise TypeError('Cannot specify both weights and cumulative weights')
        if len(cum_weights) != len(population):
            raise ValueError('The number of weights does not match the population')
        bisect = _bisect.bisect
        total = cum_weights[-1]
        return [population[bisect(cum_weights, random() * total)] for i in range(k)]

## -------------------- real-valued distributions  -------------------

## -------------------- uniform distribution -------------------

    def uniform(self, a, b):
        "Get a random number in the range [a, b) or [a, b] depending on rounding."
        #根据四舍五入，在[a, b]或[a, b]范围内得到一个随机数。
        return a + (b-a) * self.random()

## -------------------- triangular --------------------

    def triangular(self, low=0.0, high=1.0, mode=None):
        """Triangular distribution.

        Continuous distribution bounded by given lower and upper limits,
        and having a given mode value in-between.

        http://en.wikipedia.org/wiki/Triangular_distribution
        """
        #由给定的上限值和下限值所限定的连续分布，并且在两者之间具有给定的模态值。
        u = self.random()
        try:
            c = 0.5 if mode is None else (mode - low) / (high - low)
        except ZeroDivisionError:
            return low
        if u > c:
            u = 1.0 - u
            c = 1.0 - c
            low, high = high, low
        return low + (high - low) * _sqrt(u * c)

## -------------------- normal distribution --------------------

    def normalvariate(self, mu, sigma):
        """Normal distribution.

        mu is the mean, and sigma is the standard deviation.
        """
        #mu是均值，是标准差。
        # mu = mean, sigma = standard deviation

        # Uses Kinderman and Monahan method. Reference: Kinderman,
        # A.J. and Monahan, J.F., "Computer generation of random
        # variables using the ratio of uniform deviates", ACM Trans
        # Math Software, 3, (1977), pp257-260.

        random = self.random
        while 1:
            u1 = random()
            u2 = 1.0 - random()
            z = NV_MAGICCONST*(u1-0.5)/u2
            zz = z*z/4.0
            if zz <= -_log(u2):
                break
        return mu + z*sigma

## -------------------- lognormal distribution --------------------

    def lognormvariate(self, mu, sigma):
        """Log normal distribution.

        If you take the natural logarithm of this distribution, you'll get a
        normal distribution with mean mu and standard deviation sigma.
        mu can have any value, and sigma must be greater than zero.
        """
        #如果对这个分布取自然对数，就会得到均值和标准差的正态分布。可以有任何值，必须大于零。
        return _exp(self.normalvariate(mu, sigma))

## -------------------- exponential distribution --------------------

    def expovariate(self, lambd):
        """Exponential distribution.

        lambd is 1.0 divided by the desired mean.  It should be
        nonzero.  (The parameter would be called "lambda", but that is
        a reserved word in Python.)  Returned values range from 0 to
        positive infinity if lambd is positive, and from negative
        infinity to 0 if lambd is negative.
        """
        #指数分布。lambd等于1。0除以期望的平均值。它应该是非零的。(该参数将被称为
        # “lambda”，但这在Python中是一个保留字。)返回的值范围从0到正无穷，如果lambd
        # 为正，从负无穷到0如果lambd为负。

        # lambd: rate lambd = 1/mean
        # ('lambda' is a Python reserved word)

        # we use 1-random() instead of random() to preclude the
        # possibility of taking the log of zero.
        #我们使用1-random()而不是random()来排除取log(0)的可能性。
        return -_log(1.0 - self.random())/lambd

## -------------------- von Mises distribution --------------------

    def vonmisesvariate(self, mu, kappa):
        """Circular data distribution.

        mu is the mean angle, expressed in radians between 0 and 2*pi, and
        kappa is the concentration parameter, which must be greater than or
        equal to zero.  If kappa is equal to zero, this distribution reduces
        to a uniform random angle over the range 0 to 2*pi.
        """
        #循环数据分布。mu是平均角度，以弧度表示在0到2*之间，kappa是浓度参数，必须
        # 大于等于0。如果kappa等于0，这个分布会在0到2*之间减小为均匀的随机角度。

        # mu:    mean angle (in radians between 0 and 2*pi)
        # mu: 平均角度(弧度在0到2*之间)
        # kappa: concentration parameter kappa (>= 0)
        # if kappa = 0 generate uniform random angle
        #kappa:当kappa = 0时，浓度参数kappa(>= 0)产生均匀随机角

        # Based upon an algorithm published in: Fisher, N.I.,
        # "Statistical Analysis of Circular Data", Cambridge
        # University Press, 1993.
        # 基于Fisher, N.I.的一种算法《循环数据的统计分析》，剑桥大学出版社，1993年。

        # Thanks to Magnus Kessler for a correction to the
        # implementation of step 4.
        #感谢Magnus Kessler更正第4步的实现。

        random = self.random
        if kappa <= 1e-6:
            return TWOPI * random()

        s = 0.5 / kappa
        r = s + _sqrt(1.0 + s * s)

        while 1:
            u1 = random()
            z = _cos(_pi * u1)

            d = z / (r + z)
            u2 = random()
            if u2 < 1.0 - d * d or u2 <= (1.0 - d) * _exp(d):
                break

        q = 1.0 / r
        f = (q + z) / (1.0 + q * z)
        u3 = random()
        if u3 > 0.5:
            theta = (mu + _acos(f)) % TWOPI
        else:
            theta = (mu - _acos(f)) % TWOPI

        return theta

## -------------------- gamma distribution --------------------

    def gammavariate(self, alpha, beta):
        """Gamma distribution.  Not the gamma function!

        Conditions on the parameters are alpha > 0 and beta > 0.
        The probability distribution function is:
        #伽马分布。不是函数!参数的条件是> 0和> 0。概率分布函数为:

                    x ** (alpha - 1) * math.exp(-x / beta)
          pdf(x) =  --------------------------------------
                      math.gamma(alpha) * beta ** alpha

        """

        # alpha > 0, beta > 0, mean is alpha*beta, variance is alpha*beta**2

        # Warning: a few older sources define the gamma distribution in terms
        # of alpha > -1.0
        if alpha <= 0.0 or beta <= 0.0:
            raise ValueError('gammavariate: alpha and beta must be > 0.0')

        random = self.random
        if alpha > 1.0:

            # Uses R.C.H. Cheng, "The generation of Gamma
            # variables with non-integral shape parameters",
            # Applied Statistics, (1977), 26, No. 1, p71-74

            ainv = _sqrt(2.0 * alpha - 1.0)
            bbb = alpha - LOG4
            ccc = alpha + ainv

            while 1:
                u1 = random()
                if not 1e-7 < u1 < .9999999:
                    continue
                u2 = 1.0 - random()
                v = _log(u1/(1.0-u1))/ainv
                x = alpha*_exp(v)
                z = u1*u1*u2
                r = bbb+ccc*v-x
                if r + SG_MAGICCONST - 4.5*z >= 0.0 or r >= _log(z):
                    return x * beta

        elif alpha == 1.0:
            # expovariate(1/beta)
            u = random()
            while u <= 1e-7:
                u = random()
            return -_log(u) * beta

        else:   # alpha is between 0 and 1 (exclusive)

            # Uses ALGORITHM GS of Statistical Computing - Kennedy & Gentle
            #alpha在0到1之间(独家)   #使用统计计算的算法GS - Kennedy & Gentle

            while 1:
                u = random()
                b = (_e + alpha)/_e
                p = b*u
                if p <= 1.0:
                    x = p ** (1.0/alpha)
                else:
                    x = -_log((b-p)/alpha)
                u1 = random()
                if p > 1.0:
                    if u1 <= x ** (alpha - 1.0):
                        break
                elif u1 <= _exp(-x):
                    break
            return x * beta

## -------------------- Gauss (faster alternative) --------------------

    def gauss(self, mu, sigma):
        """Gaussian distribution.

        mu is the mean, and sigma is the standard deviation.  This is
        slightly faster than the normalvariate() function.
        Not thread-safe without a lock around calls.
        """
        #高斯分布。是均值，是标准差。这比normalvariate()函数稍微快一些。没有锁的调用不是线程安全的。

        # When x and y are two variables from [0, 1), uniformly
        # distributed, then
        #
        #    cos(2*pi*x)*sqrt(-2*log(1-y))
        #    sin(2*pi*x)*sqrt(-2*log(1-y))
        #
        # are two *independent* variables with normal distribution
        # 两个独立的变量是否具有正态分布
        # (mu = 0, sigma = 1).
        # (Lambert Meertens)
        # (corrected version; bug discovered by Mike Miller, fixed by LM)
        #(修正版;Mike Miller发现的bug, LM修复

        # Multithreading note: When two threads call this function
        # simultaneously, it is possible that they will receive the
        # same return value.  The window is very small though.  To
        # avoid this, you have to use a lock around all calls.  (I
        # didn't want to slow this down in the serial case by using a
        # lock here.)
        #注意:当两个线程同时调用这个函数时，它们可能会收到相同的返回值。窗户很小。
        # 为了避免这种情况，您必须在所有调用周围使用锁。(我不想在串行情况下使用锁
        # 来减慢速度。)

        random = self.random
        z = self.gauss_next
        self.gauss_next = None
        if z is None:
            x2pi = random() * TWOPI
            g2rad = _sqrt(-2.0 * _log(1.0 - random()))
            z = _cos(x2pi) * g2rad
            self.gauss_next = _sin(x2pi) * g2rad

        return mu + z*sigma

## -------------------- beta --------------------
## See
## http://mail.python.org/pipermail/python-bugs-list/2001-January/003752.html
## for Ivan Frohne's insightful analysis of why the original implementation:
##
##    def betavariate(self, alpha, beta):
##        # Discrete Event Simulation in C, pp 87-88.
##
##        y = self.expovariate(alpha)
##        z = self.expovariate(1.0/beta)
##        return z/(y+z)
##
## was dead wrong, and how it probably got that way.

    def betavariate(self, alpha, beta):
        """Beta distribution.

        Conditions on the parameters are alpha > 0 and beta > 0.
        Returned values range between 0 and 1.
        """
        #贝塔分布。参数的条件是> 0和> 0。返回的值范围在0到1之间。

        # This version due to Janne Sinkkonen, and matches all the std
        # texts (e.g., Knuth Vol 2 Ed 3 pg 134 "the beta distribution").
        #这个版本由于Janne Sinkkonen，并且匹配所有的std文本(例如，Knuth Vol 2 Ed 3 pg 134“beta发行版”)。
        y = self.gammavariate(alpha, 1.0)
        if y == 0:
            return 0.0
        else:
            return y / (y + self.gammavariate(beta, 1.0))

## -------------------- Pareto --------------------

    def paretovariate(self, alpha):
        """Pareto distribution.  alpha is the shape parameter."""
        #帕累托分布。是形状参数。
        # Jain, pg. 495

        u = 1.0 - self.random()
        return 1.0 / u ** (1.0/alpha)

## -------------------- Weibull --------------------

    def weibullvariate(self, alpha, beta):
        """Weibull distribution.

        alpha is the scale parameter and beta is the shape parameter.
        """
        #威布尔分布。是尺度参数，是形状参数。
        # Jain, pg. 499; bug fix courtesy Bill Arms

        u = 1.0 - self.random()
        return alpha * (-_log(u)) ** (1.0/beta)

## --------------- Operating System Random Source  ------------------

class SystemRandom(Random):
    """Alternate random number generator using sources provided
    by the operating system (such as /dev/urandom on Unix or
    CryptGenRandom on Windows).
     Not available on all systems (see os.urandom() for details).
    """
    #使用操作系统提供的源(例如Unix上的/dev/urandom或Windows上的CryptGenRandom)
    # 替换随机数生成器。不能在所有系统上使用(详见os.urandom())。

    def random(self):
        """Get the next random number in the range [0.0, 1.0)."""
        #获取范围内的下一个随机数[0.0,1.0]。
        return (int.from_bytes(_urandom(7), 'big') >> 3) * RECIP_BPF

    def getrandbits(self, k):
        """getrandbits(k) -> x.  Generates an int with k random bits."""
        #getrandbits(k) -> x.用k个随机位生成一个int。
        if k <= 0:
            raise ValueError('number of bits must be greater than zero')
        if k != int(k):
            raise TypeError('number of bits should be an integer')
        numbytes = (k + 7) // 8                       # bits / 8 and rounded up
        x = int.from_bytes(_urandom(numbytes), 'big')
        return x >> (numbytes * 8 - k)                # trim excess bits

    def seed(self, *args, **kwds):
        "Stub method.  Not used for a system random number generator."
        #存根方法。不用于系统随机数生成器。
        return None

    def _notimplemented(self, *args, **kwds):
        "Method should not be called for a system random number generator."
        #方法不应用于系统随机数生成器。
        raise NotImplementedError('System entropy source does not have state.')
    getstate = setstate = _notimplemented

## -------------------- test program --------------------

def _test_generator(n, func, args):
    import time
    print(n, 'times', func.__name__)
    total = 0.0
    sqsum = 0.0
    smallest = 1e10
    largest = -1e10
    t0 = time.time()
    for i in range(n):
        x = func(*args)
        total += x
        sqsum = sqsum + x*x
        smallest = min(x, smallest)
        largest = max(x, largest)
    t1 = time.time()
    print(round(t1-t0, 3), 'sec,', end=' ')
    avg = total/n
    stddev = _sqrt(sqsum/n - avg*avg)
    print('avg %g, stddev %g, min %g, max %g
' % 
              (avg, stddev, smallest, largest))


def _test(N=2000):
    _test_generator(N, random, ())
    _test_generator(N, normalvariate, (0.0, 1.0))
    _test_generator(N, lognormvariate, (0.0, 1.0))
    _test_generator(N, vonmisesvariate, (0.0, 1.0))
    _test_generator(N, gammavariate, (0.01, 1.0))
    _test_generator(N, gammavariate, (0.1, 1.0))
    _test_generator(N, gammavariate, (0.1, 2.0))
    _test_generator(N, gammavariate, (0.5, 1.0))
    _test_generator(N, gammavariate, (0.9, 1.0))
    _test_generator(N, gammavariate, (1.0, 1.0))
    _test_generator(N, gammavariate, (2.0, 1.0))
    _test_generator(N, gammavariate, (20.0, 1.0))
    _test_generator(N, gammavariate, (200.0, 1.0))
    _test_generator(N, gauss, (0.0, 1.0))
    _test_generator(N, betavariate, (3.0, 3.0))
    _test_generator(N, triangular, (0.0, 1.0, 1.0/3.0))

# Create one instance, seeded from current time, and export its methods
# as module-level functions.  The functions share state across all uses
#(both in the user's code and in the Python libraries), but that's fine
# for most programs and is easier for the casual user than making them
# instantiate their own Random() instance.
#创建一个实例，从当前时间播种，并将其方法导出为模块级函数。这些函数在所有的使用中都
# 共享状态(在用户的代码和Python库中都是如此)，但是对于大多数程序来说这没什么问题，
# 而且对于普通用户来说比让它们实例化自己的Random()实例更容易。

_inst = Random()
seed = _inst.seed
random = _inst.random
uniform = _inst.uniform
triangular = _inst.triangular
randint = _inst.randint
choice = _inst.choice
randrange = _inst.randrange
sample = _inst.sample
shuffle = _inst.shuffle
choices = _inst.choices
normalvariate = _inst.normalvariate
lognormvariate = _inst.lognormvariate
expovariate = _inst.expovariate
vonmisesvariate = _inst.vonmisesvariate
gammavariate = _inst.gammavariate
gauss = _inst.gauss
betavariate = _inst.betavariate
paretovariate = _inst.paretovariate
weibullvariate = _inst.weibullvariate
getstate = _inst.getstate
setstate = _inst.setstate
getrandbits = _inst.getrandbits

if hasattr(_os, "fork"):
    _os.register_at_fork(after_in_child=_inst.seed)


if __name__ == '__main__':
    _test()

　　random模块可用来模拟用户登录的随机验证：

import random
Flag=1
i=1
while Flag:
    s = int(random.random() * 10)
    if i<4:
        list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
        c = ['l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u']
        b = [s, 2*s, c[s], list[s]]
        random.shuffle(b)
        a = '%s%s%s%s' % (b[0], b[1], b[2], b[3])
        print(a)
        n=input('请输入验证码:
')

        if n==a:
            print('验证成功')
            Flag=0
        else:
            print('验证失败')
            i+=1
    else:
        print('三次验证失败,请重新登录')
        break

• os模块：

　　提供对操作系统进行调用的接口

os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")          改变当前脚本工作目录；相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep                  当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   运行shell命令，直接显示
os.environ                  获取系统环境变量
os.path.abspath(path)       返回path规范化的绝对路径
os.path.split(path)         将path分割成目录和文件名二元组返回
os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)      返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)         如果path是绝对路径，返回True
os.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

　　下面具体介绍几个常用的OS模块方法,详见View Code

'''os'''
#获取本程序当前的操作目录
import os
print(os.getcwd())

#切换当前目录
import os
os.chdir(r"c:")  #r是用来区分反斜杠，使其有意义
print(os.getcwd())

#返回当前目录(.一点表示当前， ..两点表示返回上级目录)
# （在cmd中使用cd.  cd..用于返回目录)
import os
print(os.curdir)  #当前
print(os.pardir)  #上级

#创建递归目录（多级）
import os
os.makedirs(r'c:/b/c')

#递归删除,直到删除某一项不为空为止
import os
os.removedirs(r'c:/a/b/c')

#逐个创建文件
import os
os.mkdir(r'c:ac')

#逐个删除
import os
os.rmdir(r'c:ac')

#显示指定目录下所有的程序
import os
print(os.listdir("."))  #本目录
print(os.listdir("..")) #上级目录

#删除本目录的文件
import os
os.remove("file.txt")

#修改名字
import os
os.rename(r'',r'')

#显示该文件的目录信息，即创建时间
print(os.stat(r""))

#路径分割符
print(os.sep)  #win--\,\   linux--/

print(os.linesep)

#用分号；表示字符串的分割
print(os.pathsep)

#显示环境变量
print(os.environ)

#nt表示win7系统
print(os.name)  #linux:posix

#显示系统命令,将字符串以乱码形式显示
os.system("dir")

#返回文件绝对路径
print(os.path.dirname(__file__))

#判断是否是一个文件
print(os.path.isfile())

#判断是否是绝对路径
os.path.isabs()

os.path.isdir()

#用于组合路径的方法
print(os.path.join(r''))

#返回文件最后存储时间
print(os.path.getatime("sys源代码.py"))

r"""OS routines for NT or Posix depending on what system we're on.
#NT或Posix的操作系统例程取决于我们所使用的系统。
This exports:
  - all functions from posix or nt, e.g. unlink, stat, etc.
    #posix或nt的所有功能，例如unlink、stat等。
  - os.path is either posixpath or ntpath
    #操作系统。路径是posixpath或ntpath
  - os.name is either 'posix' or 'nt'
    #os.name要么是posix，要么是nt
  - os.curdir is a string representing the current directory (always '.')
    #os.curdir是一个字符串，表示当前目录(总是'.')。
  - os.pardir is a string representing the parent directory (always '..')
    #os.pardir是一个字符串，表示父目录(总是'..')
  - os.sep is the (or a most common) pathname separator ('/' or '\')
    #os.sep是(或最常见的)路径名分隔符('/'或'\')
  - os.extsep is the extension separator (always '.')
    #os.extsep是扩展分隔符(总是'.')。
  - os.altsep is the alternate pathname separator (None or '/')
    #os.altsep是替代路径名分隔符(None或'/')
  - os.pathsep is the component separator used in $PATH etc
    #os.pathsep是用于$PATH等的组件分隔符
  - os.linesep is the line separator in text files ('
' or '
' or '
')
    #os.linesep是文本文件中的行分隔符('
'或'
'或'
')
  - os.defpath is the default search path for executables
    #os.defpath是可执行文件的默认搜索路径
  - os.devnull is the file path of the null device ('/dev/null', etc.)
    #os.devnull是空设备('/dev/null'等)的文件路径
Programs that import and use 'os' stand a better chance of being
portable between different platforms.  Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
#导入和使用“os”的程序更有可能存在在不同平台之间可移植。当然，他们必须这样做只使用
所有平台定义的函数(例如，unlink)，并将所有路径名操作留给操作系统.path(例如，分开并加入)。
"""

#'
import abc
import sys
import stat as st

_names = sys.builtin_module_names

# Note:  more names are added to __all__ later.
__all__ = ["altsep", "curdir", "pardir", "sep", "pathsep", "linesep",
           "defpath", "name", "path", "devnull", "SEEK_SET", "SEEK_CUR",
           "SEEK_END", "fsencode", "fsdecode", "get_exec_path", "fdopen",
           "popen", "extsep"]

def _exists(name):
    return name in globals()

def _get_exports_list(module):
    try:
        return list(module.__all__)
    except AttributeError:
        return [n for n in dir(module) if n[0] != '_']

# Any new dependencies of the os module and/or changes in path separator
# requires updating importlib as well.
if 'posix' in _names:
    name = 'posix'
    linesep = '
'
    from posix import *
    try:
        from posix import _exit
        __all__.append('_exit')
    except ImportError:
        pass
    import posixpath as path

    try:
        from posix import _have_functions
    except ImportError:
        pass

    import posix
    __all__.extend(_get_exports_list(posix))
    del posix

elif 'nt' in _names:
    name = 'nt'
    linesep = '
'
    from nt import *
    try:
        from nt import _exit
        __all__.append('_exit')
    except ImportError:
        pass
    import ntpath as path

    import nt
    __all__.extend(_get_exports_list(nt))
    del nt

    try:
        from nt import _have_functions
    except ImportError:
        pass

else:
    raise ImportError('no os specific module found')

sys.modules['os.path'] = path
from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
    devnull)

del _names


if _exists("_have_functions"):
    _globals = globals()
    def _add(str, fn):
        if (fn in _globals) and (str in _have_functions):
            _set.add(_globals[fn])

    _set = set()
    _add("HAVE_FACCESSAT",  "access")
    _add("HAVE_FCHMODAT",   "chmod")
    _add("HAVE_FCHOWNAT",   "chown")
    _add("HAVE_FSTATAT",    "stat")
    _add("HAVE_FUTIMESAT",  "utime")
    _add("HAVE_LINKAT",     "link")
    _add("HAVE_MKDIRAT",    "mkdir")
    _add("HAVE_MKFIFOAT",   "mkfifo")
    _add("HAVE_MKNODAT",    "mknod")
    _add("HAVE_OPENAT",     "open")
    _add("HAVE_READLINKAT", "readlink")
    _add("HAVE_RENAMEAT",   "rename")
    _add("HAVE_SYMLINKAT",  "symlink")
    _add("HAVE_UNLINKAT",   "unlink")
    _add("HAVE_UNLINKAT",   "rmdir")
    _add("HAVE_UTIMENSAT",  "utime")
    supports_dir_fd = _set

    _set = set()
    _add("HAVE_FACCESSAT",  "access")
    supports_effective_ids = _set

    _set = set()
    _add("HAVE_FCHDIR",     "chdir")
    _add("HAVE_FCHMOD",     "chmod")
    _add("HAVE_FCHOWN",     "chown")
    _add("HAVE_FDOPENDIR",  "listdir")
    _add("HAVE_FDOPENDIR",  "scandir")
    _add("HAVE_FEXECVE",    "execve")
    _set.add(stat) # fstat always works
    _add("HAVE_FTRUNCATE",  "truncate")
    _add("HAVE_FUTIMENS",   "utime")
    _add("HAVE_FUTIMES",    "utime")
    _add("HAVE_FPATHCONF",  "pathconf")
    if _exists("statvfs") and _exists("fstatvfs"): # mac os x10.3
        _add("HAVE_FSTATVFS", "statvfs")
    supports_fd = _set

    _set = set()
    _add("HAVE_FACCESSAT",  "access")
    # Some platforms don't support lchmod().  Often the function exists
    # anyway, as a stub that always returns ENOSUP or perhaps EOPNOTSUPP.
    # (No, I don't know why that's a good design.)  ./configure will detect
    # this and reject it--so HAVE_LCHMOD still won't be defined on such
    # platforms.  This is Very Helpful.
    #
    # However, sometimes platforms without a working lchmod() *do* have
    # fchmodat().  (Examples: Linux kernel 3.2 with glibc 2.15,
    # OpenIndiana 3.x.)  And fchmodat() has a flag that theoretically makes
    # it behave like lchmod().  So in theory it would be a suitable
    # replacement for lchmod().  But when lchmod() doesn't work, fchmodat()'s
    # flag doesn't work *either*.  Sadly ./configure isn't sophisticated
    # enough to detect this condition--it only determines whether or not
    # fchmodat() minimally works.
    #
    # Therefore we simply ignore fchmodat() when deciding whether or not
    # os.chmod supports follow_symlinks.  Just checking lchmod() is
    # sufficient.  After all--if you have a working fchmodat(), your
    # lchmod() almost certainly works too.
    #
    # _add("HAVE_FCHMODAT",   "chmod")
    _add("HAVE_FCHOWNAT",   "chown")
    _add("HAVE_FSTATAT",    "stat")
    _add("HAVE_LCHFLAGS",   "chflags")
    _add("HAVE_LCHMOD",     "chmod")
    if _exists("lchown"): # mac os x10.3
        _add("HAVE_LCHOWN", "chown")
    _add("HAVE_LINKAT",     "link")
    _add("HAVE_LUTIMES",    "utime")
    _add("HAVE_LSTAT",      "stat")
    _add("HAVE_FSTATAT",    "stat")
    _add("HAVE_UTIMENSAT",  "utime")
    _add("MS_WINDOWS",      "stat")
    supports_follow_symlinks = _set

    del _set
    del _have_functions
    del _globals
    del _add


# Python uses fixed values for the SEEK_ constants; they are mapped
# to native constants if necessary in posixmodule.c
# Other possible SEEK values are directly imported from posixmodule.c
SEEK_SET = 0
SEEK_CUR = 1
SEEK_END = 2

# Super directory utilities.
# (Inspired by Eric Raymond; the doc strings are mostly his)

def makedirs(name, mode=0o777, exist_ok=False):
    """makedirs(name [, mode=0o777][, exist_ok=False])

    Super-mkdir; create a leaf directory and all intermediate ones.  Works like
    mkdir, except that any intermediate path segment (not just the rightmost)
    will be created if it does not exist. If the target directory already
    exists, raise an OSError if exist_ok is False. Otherwise no exception is
    raised.  This is recursive.
    """
    #makedirs(名称[，mode=0o777]][， exist_ok=False])Super-mkdir;
    # 创建一个叶子目录和所有中间目录。就像mkdir，除了任何中间路径段(不仅仅是最右边)
    # 将创建如果它不存在。如果目标目录已经存在，如果exist_ok为假，
    # 就启动一个OSError。否则没有例外提高。这是递归的。
    head, tail = path.split(name)
    if not tail:
        head, tail = path.split(head)
    if head and tail and not path.exists(head):
        try:
            makedirs(head, exist_ok=exist_ok)
        except FileExistsError:
            # Defeats race condition when another thread created the path
            #在另一个线程创建路径时击败竞争条件
            pass
        cdir = curdir
        if isinstance(tail, bytes):
            cdir = bytes(curdir, 'ASCII')
        if tail == cdir:           # xxx/newdir/. exists if xxx/newdir exists
            return
    try:
        mkdir(name, mode)
    except OSError:
        # Cannot rely on checking for EEXIST, since the operating system
        # could give priority to other errors like EACCES or EROFS
        # 不能依赖检查EEXIST，因为操作系统优先考虑其他错误，比如EACCES或EROFS
        if not exist_ok or not path.isdir(name):
            raise

def removedirs(name):
    """removedirs(name)

    Super-rmdir; remove a leaf directory and all empty intermediate
    ones.  Works like rmdir except that, if the leaf directory is
    successfully removed, directories corresponding to rightmost path
    segments will be pruned away until either the whole path is
    consumed or an error occurs.  Errors during this latter phase are
    ignored -- they generally mean that a directory was not empty.
    """
    #removedirs(名字)Super-rmdir;删除一个叶子目录和所有空的中间的人。与rmdir类似，
    # 但叶目录除外成功删除，对应于最右边路径的目录部分将被修剪掉，直到整个路径使用或
    # 发生错误。后一阶段的错误是忽略——它们通常意味着目录不是空的。
    rmdir(name)
    head, tail = path.split(name)
    if not tail:
        head, tail = path.split(head)
    while head and tail:
        try:
            rmdir(head)
        except OSError:
            break
        head, tail = path.split(head)

def renames(old, new):
    """renames(old, new)

    Super-rename; create directories as necessary and delete any left
    empty.  Works like rename, except creation of any intermediate
    directories needed to make the new pathname good is attempted
    first.  After the rename, directories corresponding to rightmost
    path segments of the old name will be pruned until either the
    whole path is consumed or a nonempty directory is found.

    Note: this function can fail with the new directory structure made
    if you lack permissions needed to unlink the leaf directory or
    file.
    """
    #重命名(旧的,新的)Super-rename;根据需要创建目录并删除所有剩余的空目录。类似于
    # rename的工作，但是首先尝试创建任何使新路径名良好所需的中间目录。在重命名之后，
    # 对应于旧名称最右边路径段的目录将被删除，直到使用整个路径或找到一个非空目录为止。
    # 注意:如果您缺少解除叶子目录或文件链接所需的权限，那么这个函数可能会失败。

    head, tail = path.split(new)
    if head and tail and not path.exists(head):
        makedirs(head)
    rename(old, new)
    head, tail = path.split(old)
    if head and tail:
        try:
            removedirs(head)
        except OSError:
            pass

__all__.extend(["makedirs", "removedirs", "renames"])

def walk(top, topdown=True, onerror=None, followlinks=False):
    """Directory tree generator.

    For each directory in the directory tree rooted at top (including top
    itself, but excluding '.' and '..'), yields a 3-tuple

        dirpath, dirnames, filenames

    dirpath is a string, the path to the directory.  dirnames is a list of
    the names of the subdirectories in dirpath (excluding '.' and '..').
    filenames is a list of the names of the non-directory files in dirpath.
    Note that the names in the lists are just names, with no path components.
    To get a full path (which begins with top) to a file or directory in
    dirpath, do os.path.join(dirpath, name).

    If optional arg 'topdown' is true or not specified, the triple for a
    directory is generated before the triples for any of its subdirectories
    (directories are generated top down).  If topdown is false, the triple
    for a directory is generated after the triples for all of its
    subdirectories (directories are generated bottom up).

    When topdown is true, the caller can modify the dirnames list in-place
    (e.g., via del or slice assignment), and walk will only recurse into the
    subdirectories whose names remain in dirnames; this can be used to prune the
    search, or to impose a specific order of visiting.  Modifying dirnames when
    topdown is false is ineffective, since the directories in dirnames have
    already been generated by the time dirnames itself is generated. No matter
    the value of topdown, the list of subdirectories is retrieved before the
    tuples for the directory and its subdirectories are generated.

    By default errors from the os.scandir() call are ignored.  If
    optional arg 'onerror' is specified, it should be a function; it
    will be called with one argument, an OSError instance.  It can
    report the error to continue with the walk, or raise the exception
    to abort the walk.  Note that the filename is available as the
    filename attribute of the exception object.

    By default, os.walk does not follow symbolic links to subdirectories on
    systems that support them.  In order to get this functionality, set the
    optional argument 'followlinks' to true.

    Caution:  if you pass a relative pathname for top, don't change the
    current working directory between resumptions of walk.  walk never
    changes the current directory, and assumes that the client doesn't
    either.

    Example:

    import os
    from os.path import join, getsize
    for root, dirs, files in os.walk('python/Lib/email'):
        print(root, "consumes", end="")
        print(sum([getsize(join(root, name)) for name in files]), end="")
        print("bytes in", len(files), "non-directory files")
        if 'CVS' in dirs:
            dirs.remove('CVS')  # don't visit CVS directories
    """
    #目录树生成器。对于根在顶部的目录树中的每个目录(包括顶部本身，但不包括')。，
    # 生成一个3元组dirpath, dirnames, filenames dirpath是一个字符串，目录路径。
    # dirnames是dirpath(不包括')中子目录的名称列表。”和“…”)。filenames文件名是
    # dirpath中非目录文件的名称列表。注意，列表中的名称只是名称，没有路径组件。
    # 要获得指向dirpath文件或目录的完整路径(从顶部开始)，请使用os.path。加入
    # (dirpath、名称)。如果可选的arg '自顶向下'为真或未指定，则目录的三元组在其任何
    # 子目录的三元组之前生成(目录自顶向下生成)。如果自顶向下为false，目录的三元组将
    # 在所有子目录的三元组之后生成(从下往上生成目录)。当topdown为真时，调用者可以就
    # 地修改dirnames列表(例如，通过del或slice赋值)，walk只会递归到名称仍然为
    # dirnames的子目录中;这可以用于删除搜索，或强制执行特定的访问顺序。当自顶向下为
    # false时修改dirnames是无效的，因为在生成dirnames本身时，dirnames中的目录已经
    # 生成了。无论自顶向下的值是多少，子目录列表都会在生成目录及其子目录的元组之前被
    # 检索。默认情况下，os.scandir()调用的错误将被忽略。如果指定了可选的arg
    # 'onerror'，它应该是一个函数;它将使用一个参数调用，一个OSError实例。它可以报
    # 告错误以继续遍历，或者引发异常以中止遍历。注意，文件名作为异常对象的filename
    # 属性可用。默认情况下,操作系统。walk不会跟随支持它的系统上子目录的符号链接。
    # 为了获得这个功能，将可选参数“followlinks”设置为true。注意:如果您为top传递了
    # 一个相对路径名，那么不要在walk的恢复之间更改当前的工作目录。walk从不更改当前
    # 目录，并且假设客户机也不更改。

    top = fspath(top)
    dirs = []
    nondirs = []
    walk_dirs = []

    # We may not have read permission for top, in which case we can't
    # get a list of the files the directory contains.  os.walk
    # always suppressed the exception then, rather than blow up for a
    # minor reason when (say) a thousand readable directories are still
    # left to visit.  That logic is copied here.
    #我们可能没有top的读权限，在这种情况下，我们无法获得目录包含的文件列表。操作系统。
    # 那时，walk总是会抑制异常，而不是因为一个小原因(比如)当仍有1000个可读目录要访
    # 问时就会崩溃。这里复制了这个逻辑。

    try:
        # Note that scandir is global in this module due
        # to earlier import-*.
        #注意，由于前面的import-*， scandir在这个模块中是全局的。
        scandir_it = scandir(top)
    except OSError as error:
        if onerror is not None:
            onerror(error)
        return

    with scandir_it:
        while True:
            try:
                try:
                    entry = next(scandir_it)
                except StopIteration:
                    break
            except OSError as error:
                if onerror is not None:
                    onerror(error)
                return

            try:
                is_dir = entry.is_dir()
            except OSError:
                # If is_dir() raises an OSError, consider that the entry is not
                # a directory, same behaviour than os.path.isdir().
                #如果is_dir()引发一个OSError，则考虑该条目不是一个目录，其行为与os.path.isdir()相同
                is_dir = False

            if is_dir:
                dirs.append(entry.name)
            else:
                nondirs.append(entry.name)

            if not topdown and is_dir:
                # Bottom-up: recurse into sub-directory, but exclude symlinks to
                # directories if followlinks is False
                #自底向上:递归到子目录中，但如果followlinks为False，则排除到目录的符号链接
                if followlinks:
                    walk_into = True
                else:
                    try:
                        is_symlink = entry.is_symlink()
                    except OSError:
                        # If is_symlink() raises an OSError, consider that the
                        # entry is not a symbolic link, same behaviour than
                        # os.path.islink().
                        #如果is_symlink()引发一个OSError，请考虑该条目不是一个符号链接，其行为
                        # 与os.path.islink()相同。

                        is_symlink = False
                    walk_into = not is_symlink

                if walk_into:
                    walk_dirs.append(entry.path)

    # Yield before recursion if going top down 如果从上到下递归，在递归之前要先屈服
    if topdown:
        yield top, dirs, nondirs

        # Recurse into sub-directories 递归到子目录
        islink, join = path.islink, path.join
        for dirname in dirs:
            new_path = join(top, dirname)
            # Issue #23605: os.path.islink() is used instead of caching
            # entry.is_symlink() result during the loop on os.scandir() because
            # the caller can replace the directory entry during the "yield"
            # above.
            #问题#23605:使用os.path.islink()来替代cache .is_symlink()结果，因为调用者
            # 可以在“yield”中替换目录条目。

            if followlinks or not islink(new_path):
                yield from walk(new_path, topdown, onerror, followlinks)
    else:
        # Recurse into sub-directories
        for new_path in walk_dirs:
            yield from walk(new_path, topdown, onerror, followlinks)
        # Yield after recursion if going bottom up 如果从下往上递归，则在递归后屈服
        yield top, dirs, nondirs

__all__.append("walk")

if {open, stat} <= supports_dir_fd and {scandir, stat} <= supports_fd:

    def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None):
        """Directory tree generator.

        This behaves exactly like walk(), except that it yields a 4-tuple

            dirpath, dirnames, filenames, dirfd

        `dirpath`, `dirnames` and `filenames` are identical to walk() output,
        and `dirfd` is a file descriptor referring to the directory `dirpath`.

        The advantage of fwalk() over walk() is that it's safe against symlink
        races (when follow_symlinks is False).

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and top should be relative; top will then be relative to that directory.
          (dir_fd is always supported for fwalk.)

        Caution:
        Since fwalk() yields file descriptors, those are only valid until the
        next iteration step, so you should dup() them if you want to keep them
        for a longer period.

        Example:

        import os
        for root, dirs, files, rootfd in os.fwalk('python/Lib/email'):
            print(root, "consumes", end="")
            print(sum([os.stat(name, dir_fd=rootfd).st_size for name in files]),
                  end="")
            print("bytes in", len(files), "non-directory files")
            if 'CVS' in dirs:
                dirs.remove('CVS')  # don't visit CVS directories
        """
        #目录树生成器。它的行为与walk()完全相同，只是它产生了一个4元组dirpath、
        # dirnames、filenames、dirfd ' dirpath '、' dirnames '和' filenames
        # '与walk()输出相同，而' dirfd '是一个指向目录' dirpath '的文件描述符。
        # 与walk()相比，fwalk()的优点是它对于symlink race(当follow_symlinks为False时)
        # 是安全的。如果dir_fd不是None，它应该是打开到目录的文件描述符，top应该是相对的;
        # 然后top将相对于那个目录。(fwalk始终支持dir_fd。)注意:因为fwalk()产生了文件描述符，
        # 所以这些描述符只在下一个迭代步骤之前有效，所以如果您想长时间保存它们，您应该使用dup()。

        if not isinstance(top, int) or not hasattr(top, '__index__'):
            top = fspath(top)
        # Note: To guard against symlink races, we use the standard
        # lstat()/open()/fstat() trick.
        #注意:为了防止符号链接竞争，我们使用标准的lstat()/open()/fstat()技巧。
        if not follow_symlinks:
            orig_st = stat(top, follow_symlinks=False, dir_fd=dir_fd)
        topfd = open(top, O_RDONLY, dir_fd=dir_fd)
        try:
            if (follow_symlinks or (st.S_ISDIR(orig_st.st_mode) and
                                    path.samestat(orig_st, stat(topfd)))):
                yield from _fwalk(topfd, top, isinstance(top, bytes),
                                  topdown, onerror, follow_symlinks)
        finally:
            close(topfd)

    def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks):
        # Note: This uses O(depth of the directory tree) file descriptors: if
        # necessary, it can be adapted to only require O(1) FDs, see issue
        # #13734.
        #注意:这使用了O(目录树的深度)文件描述符:如果需要，它可以被修改为只需要O(1) FDs，请参阅issue13734

        scandir_it = scandir(topfd)
        dirs = []
        nondirs = []
        entries = None if topdown or follow_symlinks else []
        for entry in scandir_it:
            name = entry.name
            if isbytes:
                name = fsencode(name)
            try:
                if entry.is_dir():
                    dirs.append(name)
                    if entries is not None:
                        entries.append(entry)
                else:
                    nondirs.append(name)
            except OSError:
                try:
                    # Add dangling symlinks, ignore disappeared files
                    #添加悬空符号链接，忽略消失的文件
                    if entry.is_symlink():
                        nondirs.append(name)
                except OSError:
                    pass

        if topdown:
            yield toppath, dirs, nondirs, topfd

        for name in dirs if entries is None else zip(dirs, entries):
            try:
                if not follow_symlinks:
                    if topdown:
                        orig_st = stat(name, dir_fd=topfd, follow_symlinks=False)
                    else:
                        assert entries is not None
                        name, entry = name
                        orig_st = entry.stat(follow_symlinks=False)
                dirfd = open(name, O_RDONLY, dir_fd=topfd)
            except OSError as err:
                if onerror is not None:
                    onerror(err)
                continue
            try:
                if follow_symlinks or path.samestat(orig_st, stat(dirfd)):
                    dirpath = path.join(toppath, name)
                    yield from _fwalk(dirfd, dirpath, isbytes,
                                      topdown, onerror, follow_symlinks)
            finally:
                close(dirfd)

        if not topdown:
            yield toppath, dirs, nondirs, topfd

    __all__.append("fwalk")

# Make sure os.environ exists, at least
#确os.environ至少是存在的
try:
    environ
except NameError:
    environ = {}

def execl(file, *args):
    """execl(file, *args)

    Execute the executable file with argument list args, replacing the
    current process. """
    #execl(文件，*args)用参数列表args执行可执行文件，替换当前进程。
    execv(file, args)

def execle(file, *args):
    """execle(file, *args, env)

    Execute the executable file with argument list args and
    environment env, replacing the current process. """
    #execle(文件，*args, env)用参数列表args和环境env执行可执行文件，替换当前进程。
    env = args[-1]
    execve(file, args[:-1], env)

def execlp(file, *args):
    """execlp(file, *args)

    Execute the executable file (which is searched for along $PATH)
    with argument list args, replacing the current process. """
    #execlp(文件，*args)用参数列表args执行可执行文件(沿着$PATH搜索)，替换当前进程。
    execvp(file, args)

def execlpe(file, *args):
    """execlpe(file, *args, env)

    Execute the executable file (which is searched for along $PATH)
    with argument list args and environment env, replacing the current
    process. """
    #execlpe(文件，*args, env)用参数列表arg和环境env执行可执行文件(沿着$PATH搜索)，
    # 替换当前进程。

    env = args[-1]
    execvpe(file, args[:-1], env)

def execvp(file, args):
    """execvp(file, args)

    Execute the executable file (which is searched for along $PATH)
    with argument list args, replacing the current process.
    args may be a list or tuple of strings. """
    #execvp(文件，args)用参数列表args执行可执行文件(沿着$PATH搜索)，替换当前进程。
    # args可以是字符串的列表或元组。
    _execvpe(file, args)

def execvpe(file, args, env):
    """execvpe(file, args, env)

    Execute the executable file (which is searched for along $PATH)
    with argument list args and environment env , replacing the
    current process.
    args may be a list or tuple of strings. """
    #execvpe(文件，args, env)用参数列表arg和环境env执行可执行文件(沿着$PATH搜索)，
    # 替换当前进程。args可以是字符串的列表或元组。
    _execvpe(file, args, env)

__all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])

def _execvpe(file, args, env=None):
    if env is not None:
        exec_func = execve
        argrest = (args, env)
    else:
        exec_func = execv
        argrest = (args,)
        env = environ

    if path.dirname(file):
        exec_func(file, *argrest)
        return
    saved_exc = None
    path_list = get_exec_path(env)
    if name != 'nt':
        file = fsencode(file)
        path_list = map(fsencode, path_list)
    for dir in path_list:
        fullname = path.join(dir, file)
        try:
            exec_func(fullname, *argrest)
        except (FileNotFoundError, NotADirectoryError) as e:
            last_exc = e
        except OSError as e:
            last_exc = e
            if saved_exc is None:
                saved_exc = e
    if saved_exc is not None:
        raise saved_exc
    raise last_exc


def get_exec_path(env=None):
    """Returns the sequence of directories that will be searched for the
    named executable (similar to a shell) when launching a process.

    *env* must be an environment variable dict or None.  If *env* is None,
    os.environ will be used.
    """
    #返回在启动进程时将搜索命名可执行文件(类似于shell)的目录序列。*env*必须是环境变量dict或无。
    # 如果*env*为空，操作系统。将使用环境。

    # Use a local import instead of a global import to limit the number of
    # modules loaded at startup: the os module is always loaded at startup by
    # Python. It may also avoid a bootstrap issue.
    #使用本地导入而不是全局导入来限制在启动时加载的模块数量:os模块总是在启动时
    # 由Python加载。它还可以避免引导问题。
    import warnings

    if env is None:
        env = environ

    # {b'PATH': ...}.get('PATH') and {'PATH': ...}.get(b'PATH') emit a
    # BytesWarning when using python -b or python -bb: ignore the warning
    with warnings.catch_warnings():
        warnings.simplefilter("ignore", BytesWarning)

        try:
            path_list = env.get('PATH')
        except TypeError:
            path_list = None

        if supports_bytes_environ:
            try:
                path_listb = env[b'PATH']
            except (KeyError, TypeError):
                pass
            else:
                if path_list is not None:
                    raise ValueError(
                        "env cannot contain 'PATH' and b'PATH' keys")
                path_list = path_listb

            if path_list is not None and isinstance(path_list, bytes):
                path_list = fsdecode(path_list)

    if path_list is None:
        path_list = defpath
    return path_list.split(pathsep)


# Change environ to automatically call putenv(), unsetenv if they exist.
#改变环境自动调用putenv()， unsetenv如果它们存在。
from _collections_abc import MutableMapping

class _Environ(MutableMapping):
    def __init__(self, data, encodekey, decodekey, encodevalue, decodevalue, putenv, unsetenv):
        self.encodekey = encodekey
        self.decodekey = decodekey
        self.encodevalue = encodevalue
        self.decodevalue = decodevalue
        self.putenv = putenv
        self.unsetenv = unsetenv
        self._data = data

    def __getitem__(self, key):
        try:
            value = self._data[self.encodekey(key)]
        except KeyError:
            # raise KeyError with the original key value
            raise KeyError(key) from None
        return self.decodevalue(value)

    def __setitem__(self, key, value):
        key = self.encodekey(key)
        value = self.encodevalue(value)
        self.putenv(key, value)
        self._data[key] = value

    def __delitem__(self, key):
        encodedkey = self.encodekey(key)
        self.unsetenv(encodedkey)
        try:
            del self._data[encodedkey]
        except KeyError:
            # raise KeyError with the original key value 使用原始键值引发KeyError
            raise KeyError(key) from None

    def __iter__(self):
        # list() from dict object is an atomic operation
        #dict对象的list()是一个原子操作
        keys = list(self._data)
        for key in keys:
            yield self.decodekey(key)

    def __len__(self):
        return len(self._data)

    def __repr__(self):
        return 'environ({{{}}})'.format(', '.join(
            ('{!r}: {!r}'.format(self.decodekey(key), self.decodevalue(value))
            for key, value in self._data.items())))

    def copy(self):
        return dict(self)

    def setdefault(self, key, value):
        if key not in self:
            self[key] = value
        return self[key]

try:
    _putenv = putenv
except NameError:
    _putenv = lambda key, value: None
else:
    if "putenv" not in __all__:
        __all__.append("putenv")

try:
    _unsetenv = unsetenv
except NameError:
    _unsetenv = lambda key: _putenv(key, "")
else:
    if "unsetenv" not in __all__:
        __all__.append("unsetenv")

def _createenviron():
    if name == 'nt':
        # Where Env Var Names Must Be UPPERCASE 在哪里Env Var名称必须是大写的
        def check_str(value):
            if not isinstance(value, str):
                raise TypeError("str expected, not %s" % type(value).__name__)
            return value
        encode = check_str
        decode = str
        def encodekey(key):
            return encode(key).upper()
        data = {}
        for key, value in environ.items():
            data[encodekey(key)] = value
    else:
        # Where Env Var Names Can Be Mixed Case
        encoding = sys.getfilesystemencoding()
        def encode(value):
            if not isinstance(value, str):
                raise TypeError("str expected, not %s" % type(value).__name__)
            return value.encode(encoding, 'surrogateescape')
        def decode(value):
            return value.decode(encoding, 'surrogateescape')
        encodekey = encode
        data = environ
    return _Environ(data,
        encodekey, decode,
        encode, decode,
        _putenv, _unsetenv)

# unicode environ
environ = _createenviron()
del _createenviron


def getenv(key, default=None):
    """Get an environment variable, return None if it doesn't exist.
    The optional second argument can specify an alternate default.
    key, default and the result are str."""
    #获取一个环境变量，如果它不存在，返回None。可选的第二个参数可以指定另一个默认值。
    # 键、默认值和结果都是str。

    return environ.get(key, default)

supports_bytes_environ = (name != 'nt')
__all__.extend(("getenv", "supports_bytes_environ"))

if supports_bytes_environ:
    def _check_bytes(value):
        if not isinstance(value, bytes):
            raise TypeError("bytes expected, not %s" % type(value).__name__)
        return value

    # bytes environ
    environb = _Environ(environ._data,
        _check_bytes, bytes,
        _check_bytes, bytes,
        _putenv, _unsetenv)
    del _check_bytes

    def getenvb(key, default=None):
        """Get an environment variable, return None if it doesn't exist.
        The optional second argument can specify an alternate default.
        key, default and the result are bytes."""
        #获取一个环境变量，如果它不存在，返回None。可选的第二个参数可以指定另一个默认值。
        # 键、默认值和结果都是字节。

        return environb.get(key, default)

    __all__.extend(("environb", "getenvb"))

def _fscodec():
    encoding = sys.getfilesystemencoding()
    errors = sys.getfilesystemencodeerrors()

    def fsencode(filename):
        """Encode filename (an os.PathLike, bytes, or str) to the filesystem
        encoding with 'surrogateescape' error handler, return bytes unchanged.
        On Windows, use 'strict' error handler if the file system encoding is
        'mbcs' (which is the default encoding).
        """
        #编码文件名(一个操作系统)。使用“surrogateescape”错误处理程序对文件系统进行
        # 编码，返回字节不变。在Windows上，如果文件系统编码是“mbcs”(这是默认编码)，
        # 则使用“严格”错误处理程序。

        filename = fspath(filename)  # Does type-checking of `filename`.
        if isinstance(filename, str):
            return filename.encode(encoding, errors)
        else:
            return filename

    def fsdecode(filename):
        """Decode filename (an os.PathLike, bytes, or str) from the filesystem
        encoding with 'surrogateescape' error handler, return str unchanged. On
        Windows, use 'strict' error handler if the file system encoding is
        'mbcs' (which is the default encoding).
        """
        #解码文件名(一个操作系统)。从带有“surrogateescape”错误处理程序的文件系统编码中，
        # 返回str不变。在Windows上，如果文件系统编码是“mbcs”(这是默认编码)，则使用
        # “严格”错误处理程序。

        filename = fspath(filename)  # Does type-checking of `filename`.
        if isinstance(filename, bytes):
            return filename.decode(encoding, errors)
        else:
            return filename

    return fsencode, fsdecode

fsencode, fsdecode = _fscodec()
del _fscodec

# Supply spawn*() (probably only for Unix) 提供spawn*()(可能只适用于Unix)
if _exists("fork") and not _exists("spawnv") and _exists("execv"):

    P_WAIT = 0
    P_NOWAIT = P_NOWAITO = 1

    __all__.extend(["P_WAIT", "P_NOWAIT", "P_NOWAITO"])

    # XXX Should we support P_DETACH?  I suppose it could fork()**2
    # and close the std I/O streams.  Also, P_OVERLAY is the same
    # as execv*()?
    #我们应该支持P_DETACH吗?我想它可以分叉()**2并关闭std I/O流。另外，P_OVERLAY和execv*()一样?

    def _spawnvef(mode, file, args, env, func):
        # Internal helper; func is the exec*() function to use
        #内部辅助;func是要使用的exec*()函数
        if not isinstance(args, (tuple, list)):
            raise TypeError('argv must be a tuple or a list')
        if not args or not args[0]:
            raise ValueError('argv first element cannot be empty')
        pid = fork()
        if not pid:
            # Child
            try:
                if env is None:
                    func(file, args)
                else:
                    func(file, args, env)
            except:
                _exit(127)
        else:
            # Parent
            if mode == P_NOWAIT:
                return pid # Caller is responsible for waiting!
            while 1:
                wpid, sts = waitpid(pid, 0)
                if WIFSTOPPED(sts):
                    continue
                elif WIFSIGNALED(sts):
                    return -WTERMSIG(sts)
                elif WIFEXITED(sts):
                    return WEXITSTATUS(sts)
                else:
                    raise OSError("Not stopped, signaled or exited???")

    def spawnv(mode, file, args):
        """spawnv(mode, file, args) -> integer

Execute file with arguments from args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        #在子进程中使用args参数执行文件。If mode == P_NOWAIT返回进程的pid。
        # 如果mode == P_WAIT返回进程正常退出的退出代码;否则返回-SIG，其中SIG是终止
        # 进程的信号。

        return _spawnvef(mode, file, args, None, execv)

    def spawnve(mode, file, args, env):
        """spawnve(mode, file, args, env) -> integer

Execute file with arguments from args in a subprocess with the
specified environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        #使用指定环境的子进程中的args参数执行文件。If mode == P_NOWAIT返回进程的pid。
        # 如果mode == P_WAIT返回进程正常退出的退出代码;否则返回-SIG，其中SIG是终止进程
        # 的信号。

        return _spawnvef(mode, file, args, env, execve)

    # Note: spawnvp[e] isn't currently supported on Windows

    def spawnvp(mode, file, args):
        """spawnvp(mode, file, args) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        return _spawnvef(mode, file, args, None, execvp)

    def spawnvpe(mode, file, args, env):
        """spawnvpe(mode, file, args, env) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess with the supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        return _spawnvef(mode, file, args, env, execvpe)


    __all__.extend(["spawnv", "spawnve", "spawnvp", "spawnvpe"])


if _exists("spawnv"):
    # These aren't supplied by the basic Windows code
    # but can be easily implemented in Python

    def spawnl(mode, file, *args):
        """spawnl(mode, file, *args) -> integer

Execute file with arguments from args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        return spawnv(mode, file, args)

    def spawnle(mode, file, *args):
        """spawnle(mode, file, *args, env) -> integer

Execute file with arguments from args in a subprocess with the
supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        env = args[-1]
        return spawnve(mode, file, args[:-1], env)


    __all__.extend(["spawnl", "spawnle"])


if _exists("spawnvp"):
    # At the moment, Windows doesn't implement spawnvp[e],
    # so it won't have spawnlp[e] either.
    def spawnlp(mode, file, *args):
        """spawnlp(mode, file, *args) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess with the supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        return spawnvp(mode, file, args)

    def spawnlpe(mode, file, *args):
        """spawnlpe(mode, file, *args, env) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess with the supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. """
        env = args[-1]
        return spawnvpe(mode, file, args[:-1], env)


    __all__.extend(["spawnlp", "spawnlpe"])


# Supply os.popen()
def popen(cmd, mode="r", buffering=-1):
    if not isinstance(cmd, str):
        raise TypeError("invalid cmd type (%s, expected string)" % type(cmd))
    if mode not in ("r", "w"):
        raise ValueError("invalid mode %r" % mode)
    if buffering == 0 or buffering is None:
        raise ValueError("popen() does not support unbuffered streams")
    import subprocess, io
    if mode == "r":
        proc = subprocess.Popen(cmd,
                                shell=True,
                                stdout=subprocess.PIPE,
                                bufsize=buffering)
        return _wrap_close(io.TextIOWrapper(proc.stdout), proc)
    else:
        proc = subprocess.Popen(cmd,
                                shell=True,
                                stdin=subprocess.PIPE,
                                bufsize=buffering)
        return _wrap_close(io.TextIOWrapper(proc.stdin), proc)

# Helper for popen() -- a proxy for a file whose close waits for the process
class _wrap_close:
    def __init__(self, stream, proc):
        self._stream = stream
        self._proc = proc
    def close(self):
        self._stream.close()
        returncode = self._proc.wait()
        if returncode == 0:
            return None
        if name == 'nt':
            return returncode
        else:
            return returncode << 8  # Shift left to match old behavior
    def __enter__(self):
        return self
    def __exit__(self, *args):
        self.close()
    def __getattr__(self, name):
        return getattr(self._stream, name)
    def __iter__(self):
        return iter(self._stream)

# Supply os.fdopen()
def fdopen(fd, *args, **kwargs):
    if not isinstance(fd, int):
        raise TypeError("invalid fd type (%s, expected integer)" % type(fd))
    import io
    return io.open(fd, *args, **kwargs)


# For testing purposes, make sure the function is available when the C
# implementation exists.
def _fspath(path):
    """Return the path representation of a path-like object.

    If str or bytes is passed in, it is returned unchanged. Otherwise the
    os.PathLike interface is used to get the path representation. If the
    path representation is not str or bytes, TypeError is raised. If the
    provided path is not str, bytes, or os.PathLike, TypeError is raised.
    """
    #返回类路径对象的路径表示。如果传入str或字节，则返回时不会改变。否则,操作系统。
    # 类路径接口用于获取路径表示。如果路径表示不是str或字节，则会引发类型错误。如果
    # 提供的路径不是str、字节或os。类路径，类型错误。

    if isinstance(path, (str, bytes)):
        return path

    # Work from the object's type to match method resolution of other magic
    # methods.
    #从对象的类型开始工作，以匹配其他魔术方法的方法解析。
    path_type = type(path)
    try:
        path_repr = path_type.__fspath__(path)
    except AttributeError:
        if hasattr(path_type, '__fspath__'):
            raise
        else:
            raise TypeError("expected str, bytes or os.PathLike object, "
                            "not " + path_type.__name__)
    if isinstance(path_repr, (str, bytes)):
        return path_repr
    else:
        raise TypeError("expected {}.__fspath__() to return str or bytes, "
                        "not {}".format(path_type.__name__,
                                        type(path_repr).__name__))

# If there is no C implementation, make the pure Python version the
# implementation as transparently as possible.
#如果没有C实现，请尽可能使纯Python版本的实现透明。
if not _exists('fspath'):
    fspath = _fspath
    fspath.__name__ = "fspath"


class PathLike(abc.ABC):

    """Abstract base class for implementing the file system path protocol."""
    #用于实现文件系统路径协议的抽象基类。

    @abc.abstractmethod
    def __fspath__(self):
        """Return the file system path representation of the object."""
        #返回对象的文件系统路径表示。
        raise NotImplementedError

    @classmethod
    def __subclasshook__(cls, subclass):
        return hasattr(subclass, '__fspath__')

• re模块：

　　模式字符串使用特殊的语法来表示一个正则表达式：

　　反斜杠本身需要使用反斜杠转义。

　　由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r' '，等价于 '\t')匹配相应的特殊字符。

　　下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 "amkdfuhudif"中的'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。在[]中的^号表示非、不是的含义。
*	匹配0个或多个的表达式。
+	匹配1个或多个的表达式。
?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
{ n}	精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
{ n,}	匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
w	匹配字母数字及下划线
W	匹配非字母数字及下划线
s	匹配任意空白字符，等价于 [ f].
S	匹配任意非空字符
d	匹配任意数字，等价于 [0-9].
D	匹配任意非数字
A	匹配字符串开始
	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
z	匹配字符串结束
G	匹配最后匹配完成的位置。
	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
B	匹配非单词边界。'erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
, , 等.	匹配一个换行符。匹配一个制表符。等
1...9	匹配第n个分组的内容。
10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

　　下面表格表中是一些特殊的实例：

实例	描述
.	匹配除 " " 之外的任何单个字符。要匹配包括 ' ' 在内的任何字符，请使用象 '[. ]' 的模式。
d	匹配一个数字字符。等价于 [0-9]。
D	匹配一个非数字字符。等价于 [^0-9]。
s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ f v]。
S	匹配任何非空白字符。等价于 [^ f v]。
w	匹配包括下划线的任何单词字符。等价于 [A-Za-z0-9_]。
W	匹配任何非单词字符。等价于 [^A-Za-z0-9_]。

　　re模块中常用的功能函数：

re.match
# 从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
# match(pattern, string, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# falgs  ： 匹配模式

re.search
# 浏览整个字符串去匹配第一个，未匹配成功返回None
# search(pattern, string, flags=0)

re.findall
# 获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
# 空的匹配也会包含在结果中
# findall(pattern, string, flags=0)

re.sub
# 替换匹配成功的指定位置字符串 
# sub(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl   ： 要替换的字符串或可执行对象
# string ： 要匹配的字符串
# count  ： 指定匹配个数
# flags  ： 匹配模式

re.split
# 根据正则匹配分割字符串
# split(pattern, string, maxsplit=0, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# maxsplit：指定分割个数
# flags  ： 匹配模式

re.compile
#编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率。）
# re.compile(pattern,flags=0)
# pattern: 编译时用的表达式字符串。
# flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。

注意：

　　需区分开match和search方法　

　　match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：

• start() 返回匹配开始的位置
• end() 返回匹配结束的位置
• span() 返回一个元组包含匹配 (开始,结束) 的位置
• group() 返回匹配的整个表达式的字符串（即返回所有结果）
• groups() 返回匹配到的分组结果

　　下面具体介绍几个常用的re模块方法,详见View Code

'''re模块'''
import re
res = re.match("^lizid+6","lizi8888088886")  #^代表以什么开头,d表示数字,"."表示任意,"+"表示多个
res1 = re.match("^.+","lizi8888088886")   #"^.+"代表任意匹配多个字符
print(res)
print(res1)
print(res.group())
print(res1.group())

"$"
#匹配结尾
res = re.match(".+","lizi8888088886")
print(res.group())

res = re.search("#.+#","lizi88fgh#good#fg89")
res = re.search("[0-9]+","lizi88fgh#good#fg89")
res = re.search("[0-9]{1,4}","lizi88fgh#good#fg89")
print(res.group())
print(res)

# res = re.findall("","")

# s = "abcd1234###hlizi@34"
# res = re.search("(?P<id>[0-9]+)(?P<name>[a-z]+)",s)
# res1 = re.search("(?P<name>lizi)",s)
# print(res.groupdict())
# print(res1.groupdict())

# res = re.split("[0-9]",s)
# res = re.split("[0-9]+",s)
# res = re.sub("[0-9]+","|",s)

# print(res)

# Secret Labs' Regular Expression Engine
#Secret Labs的正则表达式引擎
# re-compatible interface for the sre matching engine
#sre匹配引擎的重新兼容接口
# Copyright (c) 1998-2001 by Secret Labs AB.  All rights reserved.
#版权所有(c) 1998-2001
# This version of the SRE library can be redistributed under CNRI's
# Python 1.6 license.  For any other use, please contact Secret Labs
# AB (info@pythonware.com).
#这个版本的SRE库可以在CNRI的Python 1.6许可证下重新发布。
# 如有其他用途，请联系Secret Labs AB (info@pythonware.com)。
# Portions of this engine have been developed in cooperation with
# CNRI.  Hewlett-Packard provided funding for 1.6 integration and
# other compatibility work.
#该发动机的部分部件是与CNRI公司合作开发的。惠普为1.6集成和其他兼容性工作提供了资金

r"""Support for regular expressions (RE).  #支持正则表达式(RE)。

This module provides regular expression matching operations similar to
those found in Perl.  It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range.
#这个模块提供了与下面类似的正则表达式匹配操作在Perl中找到的。
它支持8位和Unicode字符串;这两个正在处理的模式和字符串可以包含空字节和
美国ASCII范围以外的字符。

Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves.  You can
concatenate ordinary characters, so last matches the string 'last'.
#正则表达式可以包含特殊字符和普通字符。大多数普通字符，
如“A”、“a”或“0”，都是最简单的正则表达式;他们只是匹配自己。
你可以连接普通字符，最后匹配字符串'last'。


The special characters are:
#特别的字符是：
    "."      Matches any character except a newline.
             #匹配除换行符之外的任何字符。

    "^"      Matches the start of the string.
             #匹配字符串的开头。

    "$"      Matches the end of the string or just before the newline at
             the end of the string.
             #匹配字符串的末尾或在换行符at之前弦的末端

    "*"      Matches 0 or more (greedy) repetitions of the preceding RE.
             Greedy means that it will match as many repetitions as possible.
             #匹配前面RE的0个或多个(贪婪的)重复。贪婪意味着它将匹配尽可能多的重复。

    "+"      Matches 1 or more (greedy) repetitions of the preceding RE.
             #匹配前面RE的一个或多个(贪婪的)重复。

    "?"      Matches 0 or 1 (greedy) of the preceding RE.
             #匹配前一个RE的0或1(贪婪)。

    *?,+?,?? Non-greedy versions of the previous three special characters.
             #前三个特殊字符的非贪婪版本。

    {m,n}    Matches from m to n repetitions of the preceding RE.
             #匹配前一个RE的m到n个重复。

    {m,n}?   Non-greedy version of the above.
             #非贪婪版的上面。

    "\"     Either escapes special characters or signals a special sequence.
             #转义特殊字符或表示特殊序列。

    []       Indicates a set of characters.
             A "^" as the first character indicates a complementing set.
             #表示一组字符。"^"作为第一个字符表示一组补充。

    "|"      A|B, creates an RE that will match either A or B.
             #A|B，创建一个将匹配A或B的RE。

    (...)    Matches the RE inside the parentheses.
             The contents can be retrieved or matched later in the string.
             #匹配括号内的RE。稍后可以在字符串中检索或匹配内容。


    (?aiLmsux) Set the A, I, L, M, S, U, or X flag for the RE (see below).
             #为RE设置A、I、L、M、S、U或X标志(见下面)。

    (?:...)  Non-grouping version of regular parentheses.
             #非分组版本的规则括号。

    (?P<name>...) The substring matched by the group is accessible by name.
             #组匹配的子字符串可以通过名称访问。

    (?P=name)     Matches the text matched earlier by the group named name.
             #匹配前面由名为name的组匹配的文本。

    (?#...)  A comment; ignored.
    (?=...)  Matches if ... matches next, but doesn't consume the string.
             #如果匹配……匹配next，但不使用字符串。

    (?!...)  Matches if ... doesn't match next.
    (?<=...) Matches if preceded by ... (must be fixed length).
    (?<!...) Matches if not preceded by ... (must be fixed length).
    (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
                       the (optional) no pattern otherwise.
                       #如果id/name匹配的组匹配yes模式，(可选)没有其他模式

The special sequences consist of "\" and a character from the list
below.  If the ordinary character is not on the list, then the
resulting RE will match the second character.
#特殊的序列由“\”和列表中的一个字符组成在下面。如果普通字符不在列表中，
则结果RE将匹配第二个字符。

    
umber  Matches the contents of the group of the same number.
             #匹配同一数字组的内容。

    A       Matches only at the start of the string.
             #只在字符串的开头匹配。

           Matches only at the end of the string.
             #只匹配字符串的末尾。

           Matches the empty string, but only at the start or end of a word.
             #匹配空字符串，但仅在单词的开头或结尾。

    B       Matches the empty string, but not at the start or end of a word.
             #匹配空字符串，但不匹配单词的开头或结尾。

    d       Matches any decimal digit; equivalent to the set [0-9] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode digits.
             #匹配任何小数;等于集合[0-9]in带有ASCII标志的字节模式或字符串模式。
             在没有ASCII标志的字符串模式中，它将匹配整个字符串Unicode数字的范围。

    D       Matches any non-digit character; equivalent to [^d].
             #匹配任何非数字字符;相当于^  [d]。

    s       Matches any whitespace character; equivalent to [ 	

fv] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode whitespace characters.
             #匹配任何空白字符;相当于[	

fv] in带有ASCII标志的字节模式或字符串模式。
             在没有ASCII标志的字符串模式中，它将匹配整个字符串Unicode空白字符的范围。

    S       Matches any non-whitespace character; equivalent to [^s].
             #匹配任何非空白字符;相当于^  [s]。

    w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
             in bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the
             range of Unicode alphanumeric characters (letters plus digits
             plus underscore).
             With LOCALE, it will match the set [0-9_] plus characters defined
             as letters for the current locale.
             #匹配任何字母数字字符;
             [相当于- za - z0 - 9 _]使用ASCII标志的字节模式或字符串模式。
             在没有ASCII标志的字符串模式中，它将匹配
             Unicode字母数字字符(字母加数字的范围加上下划线)。
             对于LOCALE，它将匹配集合[0-9_]和定义的字符作为当前语言环境的字母。

    W       Matches the complement of w.
             #匹配w的补码。

    \       Matches a literal backslash.
             #匹配一个字面反斜杠。

This module exports the following functions:
#本模块导出如下功能:

    match     Match a regular expression pattern to the beginning of a string.
              #将正则表达式模式匹配到字符串的开头。

    fullmatch Match a regular expression pattern to all of a string.
              #将正则表达式模式与所有字符串匹配。

    search    Search a string for the presence of a pattern.
              #在字符串中搜索是否存在模式。

    sub       Substitute occurrences of a pattern found in a string.
              #替换字符串中出现的模式。

    subn      Same as sub, but also return the number of substitutions made.
              #与sub相同，但也返回替换次数。

    split     Split a string by the occurrences of a pattern.
              #通过模式的出现来分割字符串。

    findall   Find all occurrences of a pattern in a string.
              #查找字符串中出现的所有模式。

    finditer  Return an iterator yielding a Match object for each match.
              #返回一个迭代器，为每个匹配生成一个匹配对象。

    compile   Compile a pattern into a Pattern object.
              #将模式编译为模式对象。

    purge     Clear the regular expression cache.
              #清除正则表达式缓存。

    escape    Backslash all non-alphanumerics in a string.
              #在字符串中反斜杠所有非字母数字。

Some of the functions in this module takes flags as optional parameters:
#本模块中的一些函数将标志作为可选参数:

    A  ASCII       For string patterns, make w, W, , B, d, D
                   match the corresponding ASCII character categories
                   (rather than the whole Unicode categories, which is the
                   default).
                   For bytes patterns, this flag is the only available
                   behaviour and needn't be specified.
                   #对于字符串模式，制作w，W，，B，d，D匹配相应的ASCII字符类别
                   (而不是整个Unicode类别，也就是违约)。
                   对于字节模式，这个标志是唯一可用的行为和不需要指定。

    I  IGNORECASE  Perform case-insensitive matching.
                   #执行不区分大小写的匹配。

    L  LOCALE      Make w, W, , B, dependent on the current locale.
                   #使w, W, , B,取决于当前区域设置。

    M  MULTILINE   "^" matches the beginning of lines (after a newline)
                   as well as the string.
                   "$" matches the end of lines (before a newline) as well
                   as the end of the string.
                   #"^" 匹配的开始行(换行符)还有绳子。
                   "$" 也匹配行尾(在换行符之前)作为弦的末端。

    S  DOTALL      "." matches any character at all, including the newline.
                   #"." 匹配任何字符，包括换行符。

    X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
                   #为了看起来更漂亮，忽略空白和注释。

    U  UNICODE     For compatibility only. Ignored for string patterns (it
                   is the default), and forbidden for bytes patterns.
                   #仅供兼容性。忽略字符串模式(it为默认)，并且禁止字节模式。

This module also defines an exception 'error'.

"""

import enum
import sre_compile
import sre_parse
import functools
try:
    import _locale
except ImportError:
    _locale = None


# public symbols
__all__ = [
    "match", "fullmatch", "search", "sub", "subn", "split",
    "findall", "finditer", "compile", "purge", "template", "escape",
    "error", "Pattern", "Match", "A", "I", "L", "M", "S", "X", "U",
    "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
    "UNICODE",
]

__version__ = "2.2.1"

class RegexFlag(enum.IntFlag):
    ASCII = sre_compile.SRE_FLAG_ASCII # assume ascii "locale"
    IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
    LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
    UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode "locale"
    MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
    DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
    VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
    A = ASCII
    I = IGNORECASE
    L = LOCALE
    U = UNICODE
    M = MULTILINE
    S = DOTALL
    X = VERBOSE
    # sre extensions (experimental, don't rely on these)
    TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
    T = TEMPLATE
    DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation
globals().update(RegexFlag.__members__)

# sre exception
error = sre_compile.error

# --------------------------------------------------------------------
# public interface

def match(pattern, string, flags=0):
    """Try to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found."""
    #尝试在字符串开头应用模式，返回匹配对象，如果没有找到匹配，则返回None。
    return _compile(pattern, flags).match(string)

def fullmatch(pattern, string, flags=0):
    """Try to apply the pattern to all of the string, returning
    a Match object, or None if no match was found."""
    #尝试将模式应用于所有字符串，返回匹配对象，或者如果没有找到匹配，返回None。
    return _compile(pattern, flags).fullmatch(string)

def search(pattern, string, flags=0):
    """Scan through string looking for a match to the pattern, returning
    a Match object, or None if no match was found."""
    #扫描字符串，查找模式的匹配项，返回匹配对象，如果没有找到匹配项，则返回None。
    return _compile(pattern, flags).search(string)

def sub(pattern, repl, string, count=0, flags=0):
    """Return the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in string by the
    replacement repl.  repl can be either a string or a callable;
    if a string, backslash escapes in it are processed.  If it is
    a callable, it's passed the Match object and must return
    a replacement string to be used."""
    #返回通过替换repl替换字符串中最左边不重叠出现的模式而得到的字符串。
    # repl可以是字符串，也可以是可调用的;如果处理一个字符串，反斜杠转义。
    # 如果它是可调用的，它将传递Match对象，并且必须返回要使用的替换字符串。
    return _compile(pattern, flags).sub(repl, string, count)

def subn(pattern, repl, string, count=0, flags=0):
    """Return a 2-tuple containing (new_string, number).
    new_string is the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in the source
    string by the replacement repl.  number is the number of
    substitutions that were made. repl can be either a string or a
    callable; if a string, backslash escapes in it are processed.
    If it is a callable, it's passed the Match object and must
    return a replacement string to be used."""
    #返回一个包含两个元组(new_string, number)。
    # new_string是通过替换repl替换源字符串中最左边不重叠的模式出现而得到的字符串。
    # number是替换的次数。repl可以是字符串，也可以是可调用的;
    # 如果处理一个字符串，反斜杠转义。如果它是可调用的，它将传递Match对象，
    # 并且必须返回要使用的替换字符串。
    return _compile(pattern, flags).subn(repl, string, count)

def split(pattern, string, maxsplit=0, flags=0):
    """Split the source string by the occurrences of the pattern,
    returning a list containing the resulting substrings.  If
    capturing parentheses are used in pattern, then the text of all
    groups in the pattern are also returned as part of the resulting
    list.  If maxsplit is nonzero, at most maxsplit splits occur,
    and the remainder of the string is returned as the final element
    of the list."""
    #根据模式的出现情况拆分源字符串，返回一个包含结果子字符串的列表。
    # 如果模式中使用捕获括号，那么模式中的所有组的文本也会作为结果列表的一部分返回。
    # 如果maxsplit不为0，那么在大多数情况下会发生maxsplit拆分，
    # 字符串的其余部分作为列表的最后一个元素返回。
    return _compile(pattern, flags).split(string, maxsplit)

def findall(pattern, string, flags=0):
    """Return a list of all non-overlapping matches in the string.

    If one or more capturing groups are present in the pattern, return
    a list of groups; this will be a list of tuples if the pattern
    has more than one group.

    Empty matches are included in the result."""
    #返回字符串中所有不重叠匹配的列表。
    # 如果模式中存在一个或多个捕获组，返回组列表;
    # 如果模式有多个组，那么这将是一个元组列表。
    # 结果中包含了空匹配。
    return _compile(pattern, flags).findall(string)

def finditer(pattern, string, flags=0):
    """Return an iterator over all non-overlapping matches in the
    string.  For each match, the iterator returns a Match object.

    Empty matches are included in the result."""
    #在字符串中所有不重叠的匹配上返回一个迭代器。
    # 对于每个匹配，迭代器返回一个匹配对象。结果中包含了空匹配。
    return _compile(pattern, flags).finditer(string)

def compile(pattern, flags=0):
    "Compile a regular expression pattern, returning a Pattern object."
    #编译正则表达式模式，返回模式对象。  用来筛选
    return _compile(pattern, flags)

def purge():
    "Clear the regular expression caches"
    _cache.clear()
    _compile_repl.cache_clear()

def template(pattern, flags=0):
    "Compile a template pattern, returning a Pattern object"
    return _compile(pattern, flags|T)

# SPECIAL_CHARS
# closing ')', '}' and ']'
# '-' (a range in character set)
# '&', '~', (extended character set operations)
# '#' (comment) and WHITESPACE (ignored) in verbose mode
_special_chars_map = {i: '\' + chr(i) for i in b'()[]{}?*+-|^$\.&~# 	

vf'}

def escape(pattern):
    """
    Escape special characters in a string.
    """
    if isinstance(pattern, str):
        return pattern.translate(_special_chars_map)
    else:
        pattern = str(pattern, 'latin1')
        return pattern.translate(_special_chars_map).encode('latin1')

Pattern = type(sre_compile.compile('', 0))
Match = type(sre_compile.compile('', 0).match(''))

# --------------------------------------------------------------------
# internals

_cache = {}  # ordered!

_MAXCACHE = 512
def _compile(pattern, flags):
    # internal: compile pattern
    #内部:编译模式
    if isinstance(flags, RegexFlag):
        flags = flags.value
    try:
        return _cache[type(pattern), pattern, flags]
    except KeyError:
        pass
    if isinstance(pattern, Pattern):
        if flags:
            raise ValueError(
                "cannot process flags argument with a compiled pattern")
        return pattern
    if not sre_compile.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    p = sre_compile.compile(pattern, flags)
    if not (flags & DEBUG):
        if len(_cache) >= _MAXCACHE:
            # Drop the oldest item
            try:
                del _cache[next(iter(_cache))]
            except (StopIteration, RuntimeError, KeyError):
                pass
        _cache[type(pattern), pattern, flags] = p
    return p

@functools.lru_cache(_MAXCACHE)
def _compile_repl(repl, pattern):
    # internal: compile replacement pattern
    #内部:编译替换模式
    return sre_parse.parse_template(repl, pattern)

def _expand(pattern, match, template):
    # internal: Match.expand implementation hook
    #内部:匹配。扩大实施钩
    template = sre_parse.parse_template(template, pattern)
    return sre_parse.expand_template(template, match)

def _subx(pattern, template):
    # internal: Pattern.sub/subn implementation helper
    #内部:模式。子/ subn实现辅助
    template = _compile_repl(template, pattern)
    if not template[0] and len(template[1]) == 1:
        # literal replacement
        return template[1][0]
    def filter(match, template=template):
        return sre_parse.expand_template(template, match)
    return filter

# register myself for pickling
#注册为酸洗

import copyreg

def _pickle(p):
    return _compile, (p.pattern, p.flags)

copyreg.pickle(Pattern, _pickle, _compile)

# --------------------------------------------------------------------
# experimental stuff (see python-dev discussions for details)

class Scanner:
    def __init__(self, lexicon, flags=0):
        from sre_constants import BRANCH, SUBPATTERN
        if isinstance(flags, RegexFlag):
            flags = flags.value
        self.lexicon = lexicon
        # combine phrases into a compound pattern
        p = []
        s = sre_parse.Pattern()
        s.flags = flags
        for phrase, action in lexicon:
            gid = s.opengroup()
            p.append(sre_parse.SubPattern(s, [
                (SUBPATTERN, (gid, 0, 0, sre_parse.parse(phrase, flags))),
                ]))
            s.closegroup(gid, p[-1])
        p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
        self.scanner = sre_compile.compile(p)
    def scan(self, string):
        result = []
        append = result.append
        match = self.scanner.scanner(string).match
        i = 0
        while True:
            m = match()
            if not m:
                break
            j = m.end()
            if i == j:
                break
            action = self.lexicon[m.lastindex-1][1]
            if callable(action):
                self.match = m
                action = action(self, m.group())
            if action is not None:
                append(action)
            i = j
        return result, string[i:]

练习：

• 进度条：

'''简单进度条1'''
import sys
import time
i = 0
while(True):
    if i<10:
        # print("#",end="") #不加end=时是一列#号，加上之后是一行
        sys.stdout.write("#")  #功能相当于加上end=的print语句
        sys.stdout.flush()     #flush：刷新缓冲区，以0.5s的速度。类似于进度条
        time.sleep(1)
        i+=1
    else:
        break


'''简单进度条2'''
ort sys
import time
l = ["10%","20%","30%","40%","50%","60%","70%","80%","90%","100%"]
for i in range(10):
    sys.stdout.write("
#")  #
:返回光标打印之前位置
    sys.stdout.write(l[i])
    sys.stdout.flush()
    time.sleep(0.5)
import sys
'''引发一个异常，如果没有捕获这个异常就会直接退出，
如果捕获到异常就可以做额外工作'''
sys.exit()