Python3 学习(二)-Python的标准库

Python的标准库

内置函数

abs(x)
  返回一个数的绝对值。 参数可以是整数、浮点数或任何实现了 __abs__() 的对象。 如果参数是一个复数，则返回它的模。
  
all(iterable)
  如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True 。

any(iterable)
  如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空，返回 False。

ascii(object)
  与 repr() 类似，返回一个字符串，表示对象的可打印形式。对 repr() 返回的字符串中，非 ASCII 字符会用 \x、\u 和 \U 进行转义。生成的字符串类似于 Python 2 中 repr() 的返回结果。

bin(x)
  将整数转变为以“0b”前缀的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，它必须定义 __index__() 方法，以便返回整数值。

breakpoint(*args, **kws)
  在调用时进入调试器中
  该函数会调用 sys.breakpointhook() ，直接传递 args 和 kws。
  而默认情况下，sys.breakpointhook() 调用 pdb.set_trace() 且没有参数。

callable(object)
  如果参数 object 是可调用的就返回 True，否则返回 False。
  如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。
  请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 __call__() 则它就是可调用的。

chr(i)
  返回 Unicode 码位为整数 i 的字符的字符串格式。
  这是 ord() 的逆函数。

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)
  将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
    source 可以是常规的字符串、字节字符串，或者 AST 对象。
    filename 实参需要是代码读取的文件名；
             如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用 '<string>'）。
    mode 实参指定了编译代码必须用的模式。
         如果 source 是语句序列，可以是 'exec'；
         如果是单一表达式，可以是 'eval'；
         如果是单个交互式语句，可以是 'single'。
         （在最后一种情况下，如果表达式执行结果不是 None 将会被打印出来。）

delattr(object, name)
  如果对象允许，函数会删除命名属性。例如，delattr（x，'foobar'）等效于del x.foobar。

dir()
dir(object)
  如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
  如果对象有一个名为 __dir__() 的方法，那么该方法将被调用，并且必须返回一个属性列表。
  如果对象未提供 __dir__() 方法，该函数会尽量从对象的 __dict__ 属性和其类型对象中收集信息。得到的列表不一定是完整，如果对象带有自定义 __getattr__() 方法时，结果可能不准确。

divmod(a, b)
  以两个（非复数）数字为参数，在作整数除法时，返回商和余数。

enumerate(iterable, start=0)
  返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。
  返回的迭代器的 __next__() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

eval(expression, globals=None, locals=None)
  实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。

exec(object, globals=None, locals=None, /, *, closure=None)
  这个函数支持动态执行 Python 代码。 object 必须是字符串或者代码对象。 如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。

filter(function, iterable)
  相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item) 。
  返回值为filter对象,可以通过list()或者for循环取出内容

format(value, format_spec='')
  将 value 转换为“格式化后”的形式，格式由 format_spec 进行控制。format_spec 的解释方式取决于 value 参数的类型；但大多数内置类型使用一种标准的格式化语法： 格式规格迷你语言。
  默认的 format_spec 是一个空字符串，它通常给出与调用 str(value) 相同的结果。
  调用 format(value, format_spec) 会转换成 type(value).__format__(value, format_spec) ，所以实例字典中的 __format__() 方法将不会调用。如果方法搜索回退到 object 类但 format_spec 不为空，或者如果 format_spec 或返回值不是字符串，则会触发 TypeError 异常。

getattr(object, name)
getattr(object, name, default)
  获取对象的参数值

globals()
  返回实现当前模块命名空间的字典。

hasattr(object, name)
  如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
  （此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。）

hash(object)
  返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
  如果对象实现了自己的 __hash__() 方法，请注意，hash() 根据机器的字长来截断返回值。

help()
help(request)
  启动内置的帮助系统（此函数主要在交互式中使用）。
  如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

hex(x)
  将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象，则必须定义返回整数的 __index__() 方法。

id(object)
  返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

input()
input(prompt)
  如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。
  如果加载了 readline 模块，input() 将使用它来提供复杂的行编辑和历史记录功能。

isinstance(object, classinfo)
  判断对象是否是类的实例
  classinfo 可为类对象的元组（或递归地，其他这样的元组）或 union 类型，这时如果 object 是 classinfo 中任何条目的实例，则返回 True 。

issubclass(class, classinfo)
  如果 class 是 classinfo 的子类（直接、间接或 虚的 ），则返回 True。
  类将视为自己的子类。
  classinfo 可为类对象的元组（或递归地，其他这样的元组）或 union 类型，这时如果 class 是 classinfo 中任何条目的子类，则返回 True 。
  任何其他情况都会触发 TypeError 异常。

iter(object)
iter(object, sentinel)
  返回一个 iterator 对象。
  如果没有第二个实参，object 必须是支持 iterable 协议（有 __iter__() 方法）的集合对象，或必须支持序列协议（有 __getitem__() 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发 TypeError。
  如果有第二个实参 sentinel，那么 object 必须是可调用的对象。这种情况下生成的迭代器，每次迭代调用它的 __next__() 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触发 StopIteration，否则返回调用结果。

len(s)
  返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

locals()
  更新并返回表示当前本地符号表的字典。

map(function, iterable, *iterables)
  函数可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
  返回值为map对象,可以通过list()或者for循环取出内容

max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)
  返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
  如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。
    key 实参指定排序函数用的参数
    default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)
  返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

next(iterator)
next(iterator, default)
  通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

oct(x)
  将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 __index__() 方法返回一个整数。

open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
  打开 file 并返回对应的 file object。 如果该文件不能被打开，则引发 OSError。
    file 是一个 path-like object，表示将要打开的文件的路径（绝对路径或者相对当前工作目录的路径），也可以是要封装文件对应的整数类型文件描述符。（如果给出的是文件描述符，则当返回的 I/O 对象关闭时它也会关闭，除非将 closefd 设为 False 。）
    mode 为打开模式
      'r':读取（默认）
      'w':写入，并先截断文件
      'x':排它性创建，如果文件已存在则失败
      'a':打开文件用于写入，如果文件存在则在末尾追加
      'b':二进制模式
      't':文本模式（默认）
      '+':打开用于更新（读取与写入）
      'w+' 和 'w+b' 模式将打开文件并清空内容。
      而 'r+' 和 'r+b' 模式将打开文件但不清空内容。
    buffering 是一个可选的整数，用于设置缓冲策略。
      0:关闭缓冲（只允许在二进制模式下）
      1:行缓冲（只在文本模式下可用）
      >1:固定大小的块缓冲区的字节大小
      注意，这样指定缓冲区的大小适用于二进制缓冲的 I/O ，但 TextIOWrapper （即用 mode='r+' 打开的文件）会有另一种缓冲。
      要禁用在 TextIOWrapper 缓冲，考虑使用 io.TextIOWrapper.reconfigure() 的 write_through 标志来。
      默认的缓冲策略工作如下:
        二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或使用 io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。
        “交互式”文本文件（ isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用上述策略用于二进制文件。
    encoding 是用于对文件进行解码或编码的编码的名称。
      只能在文本模式下使用。
      默认编码依赖于平台（无论locale.getencoding（）返回什么），但可以使用Python支持的任何文本编码。
    errors 是一个可选的字符串参数，用于指定如何处理编码和解码错误
      这不能在二进制模式下使用。
      可以使用各种标准错误处理程序（列在 错误处理方案 ），但是使用 codecs.register_error() 注册的任何错误处理名称也是有效的。标准名称包括:
        如果存在编码错误，'strict' 会引发 ValueError 异常。 默认值 None 具有相同的效果。
        'ignore' 忽略错误。请注意，忽略编码错误可能会导致数据丢失。
        'replace' 会将替换标记（例如 '?' ）插入有错误数据的地方。
        'surrogateescape' 将把任何不正确的字节表示为 U+DC80 至 U+DCFF 范围内的下方替代码位。 当在写入数据时使用 surrogateescape 错误处理句柄时这些替代码位会被转回到相同的字节。 这适用于处理具有未知编码格式的文件。
        只有在写入文件时才支持 'xmlcharrefreplace'。编码不支持的字符将替换为相应的XML字符引用 &#nnn;。
        'backslashreplace' 用Python的反向转义序列替换格式错误的数据。
        'namereplace' （也只在编写时支持）用 \N{...} 转义序列替换不支持的字符。
    newline 指定如何处理换行符
      从流中读取输入时
        如果 newline 为 None，则启用通用换行模式。输入中的行可以以 '\n'，'\r' 或 '\r\n' 结尾，这些行在返回呼叫者之前被翻译成 '\n' 。
        如果它是 ''，则启用通用换行模式，但行结尾将返回给调用者未翻译。
        如果它具有任何其他合法值，则输入行仅由给定字符串终止，行结尾将返回给调用者未翻译。
      将输出写入流时
        如果 newline 为 None，则写入的任何 '\n' 字符都将转换为系统默认行分隔符 os.linesep。
        如果 newline 是 '' 或 '\n'，则不进行翻译。
        如果 newline 是任何其他合法值，则写入的任何 '\n' 字符将被转换为给定的字符串。
    closefd
      如果 closefd 为 False 且给出的不是文件名而是文件描述符，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出的是文件名，则 closefd 必须为 True （默认值），否则将触发错误。
    opener
      可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。

ord(c)
  对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
  这是 chr() 的逆函数。

pow(base, exp, mod=None)
  返回 base 的 exp 次幂；
  如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。
  两参数形式 pow(base, exp) 等价于乘方运算符: base**exp

print(*objects, sep=' ', end='\n', file=None, flush=False)
  将 objects 打印输出至 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep 、 end 、 file 和 flush 必须以关键字参数的形式给出。
  如果没有给出 objects，则 print() 将只写入 end。
  file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。
  由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。 对于这些对象，应改用 file.write(...)。

repr(object)
  返回一个对象的可打印描述。
  会调用对象的__repr__()方法

reversed(seq)
  返回一个反向的 iterator。 seq 必须是一个具有 __reversed__() 方法的对象或者是支持该序列协议（具有从 0 开始的整数类型参数的 __len__() 方法和 __getitem__() 方法）。

round(number, ndigits=None)
  返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
  对于支持 round() 方法的内置类型，结果值会舍入至最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数同样接近，则选用偶数。因此，round(0.5) 和 round(-0.5) 均得出 0 而 round(1.5) 则为 2。
  ndigits 可为任意整数值（正数、零或负数）。如果省略了 ndigits 或为 None ，则返回值将为整数。否则返回值与 number 的类型相同。
  对于一般的 Python 对象 number, round 将委托给 number.__round__。

setattr(object, name, value)
  本函数与 getattr() 相对应。其参数为一个对象、一个字符串和一个任意值。字符串可以为某现有属性的名称，或为新属性。只要对象允许，函数会将值赋给属性。如 setattr(x, 'foobar', 123) 等价于 x.foobar = 123。

sorted(iterable, /, *, key=None, reverse=False)
  根据 iterable 中的项返回一个新的已排序列表。
    key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
    reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。
    排序算法只使用 < 在项目之间比较。 虽然定义一个 __lt__() 方法就足以进行排序，但 PEP 8 建议实现所有六个 富比较 。

sum(iterable, /, start=0)
  从 start 开始自左向右对 iterable 的项求和并返回总计值。

vars()
vars(object)
  返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
  模块和实例这样的对象具有可更新的 __dict__ 属性；但是，其它对象的 __dict__ 属性可能会设为限制写入（例如，类会使用 types.MappingProxyType 来防止直接更新字典）。
  不带参数时，vars() 的行为类似 locals()。 请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。
  如果指定了一个对象但它没有 __dict__ 属性（例如，当它所属的类定义了 __slots__ 属性时）则会引发 TypeError 异常。

zip(*iterables, strict=False)
  在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。
  更正式的说法： zip() 返回元组的迭代器，其中第 i 个元组包含的是每个参数迭代器的第 i 个元素。
  不妨换一种方式认识 zip() ：它会把行变成列，把列变成行。这类似于 矩阵转置 。
  zip() 是延迟执行的：直至迭代时才会对元素进行处理，比如 for 循环或放入 list 中。
    strict 表示多个传入的对象长度不同时怎么处理
      False:zip() 在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略。
      True:如果多个迭代对象长度不同，抛出ValueError
    为了让所有的可迭代对象具有相同的长度，长度较短的可用常量进行填充。这可由 itertools.zip_longest() 来完成。

__import__(name, globals=None, locals=None, fromlist=(), level=0)
  此函数会由 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义，但是 强烈 不建议这样做，因为使用导入钩子 (参见 PEP 302) 通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。 同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。

class bool(x=False)
  返回布尔值，True 或 False。

class bytearray(source=b'')
class bytearray(source, encoding)
class bytearray(source, encoding, errors)
  返回一个新的 bytes 数组。bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。
  如果是一个 string，您必须提供 encoding 参数（errors 参数仍是可选的）；bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。
  如果是一个 integer，会初始化大小为该数字的数组，并使用 null 字节填充。
  如果是一个遵循 缓冲区接口 的对象，该对象的只读缓冲区将被用来初始化字节数组。
  如果是一个 iterable 可迭代对象，它的元素的范围必须是 0 <= x < 256 的整数，它会被用作数组的初始内容。
  如果没有实参，则创建大小为 0 的数组。

class bytes(source=b'')
class bytes(source, encoding)
class bytes(source, encoding, errors)
  返回一个新的“bytes”对象，这是一个不可变序列，包含范围为 0 <= x < 256 的整数。
  bytes 是 bytearray 的不可变版本——带有同样不改变序列的方法，支持同样的索引、切片操作。

class complex(real=0, imag=0)
class complex(string)
  返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。
  每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。
  对于一个普通 Python 对象 x，complex(x) 会委托给 x.__complex__()。 如果 __complex__() 未定义则将回退至 __float__()。 如果 __float__() 未定义则将回退至 __index__()。

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
  创建一个新的字典。dict 对象是一个字典类。

class float(x=0.0)
  返回从数字或字符串 x 生成的浮点数。
  对于一个普通 Python 对象 x，float(x) 会委托给 x.__float__()。 如果 __float__() 未定义则将回退至 __index__()。
  如果没有实参，则返回 0.0 。

class frozenset(iterable=set())
  返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素。

class int(x=0)
class int(x, base=10)
  返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。 
  如果 x 定义了 __int__()，int(x) 将返回 x.__int__()。 
  否则如果 x 定义了 __index__()，它将返回 x.__index__()。 
  否则如果 x 定义了 __trunc__()，它将返回 x.__trunc__()。 
  对于浮点数，它将向零舍入。

class list
class list(iterable)
  返回一个列表

class memoryview(object)
  返回由给定实参创建的“内存视图”对象。

class object
  返回一个不带特征的新对象。object 是所有类的基类。它带有所有 Python 类实例均通用的方法。本函数不接受任何参数。

class property(fget=None, fset=None, fdel=None, doc=None)
  返回 property 属性。
  fget 是获取属性值的函数。
  fset 是用于设置属性值的函数。
  fdel 是用于删除属性值的函数。
  doc 为属性对象创建文档字符串，如果未设定则取fget函数的文档字符串。
  一个典型的用法是定义一个托管属性 x:
    x = property(getx, setx, delx, "I'm the 'x' property.")
  装饰器应用为@property/@属性名.setter/@属性名.deleter

class range(stop)
class range(start, stop, step=1)
  返回不可变序列range对象

class set
class set(iterable)
  返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。

class slice(stop)
class slice(start, stop, step=1)
  返回一个 slice 对象，代表由 range(start, stop, step) 指定索引集的切片。 其中参数 start 和 step 的默认值为 None。
  切片对象具有只读数据属性 start 、stop 和 step，只是返回对应的参数值（或默认值）。

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
  返回一个 str 版本的 object 。

class super
class super(type, object_or_type=None)
  返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重载的继承方法很有用。

class tuple
class tuple(iterable)
  返回不可变序列tuple对象

class type(object)
class type(name, bases, dict, **kwds)
  传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。
  传入三个参数时，返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式，name 字符串即类名并会成为 __name__ 属性；bases 元组包含基类并会成为 __bases__ 属性；如果为空则会添加所有类的终极基类 object。 dict 字典包含类主体的属性和方法定义；它在成为 __dict__ 属性之前可能会被拷贝或包装。


@classmethod
  把一个方法封装成类方法。
@staticmethod
  将方法转换为静态方法。

模块

sys模块

  sys模块，它里面提供了一些变量和函数，使我们可以获取到Python解析器的信息或者通过函数来操作Python解析器

  sys.argv
    一个列表，其中包含了被传递给 Python 脚本的命令行参数。
    argv[0] 为脚本的名称（是否是完整的路径名取决于操作系统）。如果是通过 Python 解释器的命令行参数 -c 来执行的， argv[0] 会被设置成字符串 '-c' 。如果没有脚本名被传递给 Python 解释器， argv[0] 为空字符串。

  sys.modules
    这是一个字典，它将模块名称映射到已经被加载的模块。
    这可以被操纵来强制重新加载模块和其他技巧。然而，替换这个字典不一定会像预期的那样工作，从字典中删除重要的项目可能会导致 Python 出错。
    如果你想对这个全局字典进行迭代，一定要使用 sys.modules.copy() 或 tuple(sys.modules) 来避免异常，因为它的大小在迭代过程中可能会因为其他线程中的代码或活动的副作用而改变。

  sys.path
    一个由字符串组成的列表，用于指定模块的搜索路径。
    初始化自环境变量 PYTHONPATH，再加上一条与安装有关的默认路径。

  sys.platform
    本字符串是一个平台标识符
    对于 Unix 系统（除 Linux 和 AIX 外），该字符串是 Python 构建时的 uname -s 返回的小写操作系统名称，并附加了 uname -r 返回的系统版本的第一部分，如 'sunos5' 或 'freebsd8'。除非需要检测特定版本的系统，否则建议使用以下习惯用法:
      if sys.platform.startswith('freebsd'):
    AIX:'aix'
    Emscripten:'emscripten'
    Linux:'linux'
    WASI:'wasi'
    Windows:'win32'
    Windows/Cygwin:'cygwin'
    macOS:'darwin'

  sys.exit([arg])
    引发一个 SystemExit 异常，表示打算退出解释器。
    可选参数 arg 可以是表示退出状态的整数（默认为 0），也可以是其他类型的对象。
    如果它是整数，则 shell 等将 0 视为“成功终止”，非零值视为“异常终止”。大多数系统要求该值的范围是 0--127，否则会产生不确定的结果。
    如果传入 None 等同于传入 0，如果传入其他对象则将其打印至 stderr，且退出代码为 1。
    由于 exit() 最终 "只" 引发了一个异常，它只在从主线程调用时退出进程，而异常不会被拦截。 try 语句的 finally 子句所指定的清理动作会被遵守，并且有可能在外层拦截退出的尝试。

  sys.stdin
  sys.stdout
  sys.stderr
    解释器用于标准输入、标准输出和标准错误的 文件对象

os模块

  os 模块让我们可以对操作系统进行访问

  os.environ
    一个 mapping 对象，其中键值是代表进程环境的字符串。 例如，environ['HOME'] 是你的主目录（在某些平台上）的路径名，相当于 C 中的 getenv("HOME")。
    这个映射是在第一次导入 os 模块时捕获的，通常作为 Python 启动时处理 site.py 的一部分。除了通过直接修改 os.environ 之外，在此之后对环境所做的更改不会反映在 os.environ 中。
    该映射除了可以用于查询环境外，还能用于修改环境。当该映射被修改时，将自动调用 putenv()。
    在Unix系统上，键和值会使用 sys.getfilesystemencoding() 和 'surrogateescape' 的错误处理。如果你想使用其他的编码，使用 environb。
    在Windows系统上，键值全部为大写
  os.environb
    environ 的字节版本：一个 mapping 对象，其中键值都是 bytes 对象，代表进程环境。 environ 和 environb 是同步的（修改 environb 会更新 environ，反之亦然）。
    只有在 supports_bytes_environ 为 True 的时候 environb 才是可用的。
  os.getenv(key, default=None)
    取得环境变量值,如果不存在返回default值。会使用os.environ
  os.getenvb(key, default=None)
    getenv的字节版本,取得环境变量值,如果不存在返回default值。会使用os.environ
  os.putenv(key, value, /)
    将名为 key 的环境变量值设置为 value。该变量名修改会影响由 os.system()， popen() ，fork() 和 execv() 发起的子进程。会使用os.environ

  os.chdir(path)
    将当前工作目录更改为 path。
  os.fchdir(fd)
    将当前工作目录更改为文件描述符 fd 指向的目录。fd 必须指向打开的目录而非文件。
    从 Python 3.3 开始，它等效于 os.chdir(fd)。
  os.chroot(path)
    将当前进程的根目录更改为 path。
  os.getcwd()
    返回表示当前工作目录的字符串。
  os.fspath(path)
    返回路径的文件系统表示。
    如果传入的是 str 或 bytes 类型的字符串，将原样返回。否则 __fspath__() 将被调用，如果得到的是一个 str 或 bytes 类型的对象，那就返回这个值。其他所有情况则会抛出 TypeError  异常。
  os.chflags(path, flags, *, follow_symlinks=True)
    将 path 的 flags 设置为其他由数字表示的 flags。flags 可以用以下值按位或组合起来（以下值在 stat 模块中定义）：
      stat.UF_NODUMP      不要转储文件
      stat.UF_IMMUTABLE   文件不能被更改
      stat.UF_APPEND      文件只能被附加
      stat.UF_OPAQUE      当通过联合堆栈查看时，目录是不透明的
      stat.UF_NOUNLINK    文件不能重命名或删除
      stat.UF_COMPRESSED  文件是压缩存储的（macOS 10.6+）
      stat.UF_HIDDEN      文件不可被显示在 GUI 中（macOS 10.5+）
      stat.SF_ARCHIVED    文件可能已存档
      stat.SF_IMMUTABLE   文件不能被更改
      stat.SF_APPEND      文件只能被附加
      stat.SF_NOUNLINK    文件不能重命名或删除
      stat.SF_SNAPSHOT    文件有一个快照文件
  os.chmod(path, mode, *, dir_fd=None, follow_symlinks=True)
    将 path 的 mode 更改为其他由数字表示的 mode。mode 可以用以下值之一，也可以将它们按位或组合起来（以下值在 stat 模块中定义）：
      stat.S_ISUID        设置 UID 位
      stat.S_ISGID        设置分组 ID 位。
      stat.S_ENFMT        System V 执行文件锁定。 此旗标是与 S_ISGID 共享的：文件/记录锁定会针对未设置分组执行位 (S_IXGRP) 的文件强制执行。
      stat.S_ISVTX        固定位。 当对目录设置该位时则意味着此目录中的文件只能由文件所有者、目录所有者或特权进程来重命名或删除。
      stat.S_IREAD        Unix V7 中 S_IRUSR 的同义词
      stat.S_IWRITE       Unix V7 中 S_IWUSR 的同义词
      stat.S_IEXEC        Unix V7 中 S_IXUSR 的同义词
      stat.S_IRWXU        文件所有者权限的掩码
      stat.S_IRUSR        所有者具有读取权限
      stat.S_IWUSR        所有者具有写入权限
      stat.S_IXUSR        所有者具有执行权限
      stat.S_IRWXG        组权限的掩码
      stat.S_IRGRP        组具有读取权限
      stat.S_IWGRP        组具有写入权限
      stat.S_IXGRP        组具有执行权限
      stat.S_IRWXO        其他人（不在组中）的权限掩码
      stat.S_IROTH        其他人具有读取权限
      stat.S_IWOTH        其他人具有写入权限
      stat.S_IXOTH        其他人具有执行权限
  os.listdir(path='.')
    返回一个包含由 path 指定目录中条目名称组成的列表。 该列表按任意顺序排列，并且不包括特殊条目 '.' 和 '..'，即使它们存在于目录中。 
  os.mkdir(path, mode=0o777, *, dir_fd=None)
    创建一个名为 path 的目录，应用以数字表示的权限模式 mode。
    如果目录已经存在， 抛出FileExistsError 。如果路径中的父目录不存在，则会引发 FileNotFoundError 。
  os.makedirs(name, mode=0o777, exist_ok=False)
    递归目录创建函数。与 mkdir() 类似，但会自动创建到达最后一级目录所需要的中间目录。
    如果目录已经存在并且exist_ok=Fals，抛出FileExistsError 。
  os.remove(path, *, dir_fd=None)
    删除文件
  os.removedirs(name)
    递归删除目录。工作方式类似于 rmdir()，不同之处在于，如果成功删除了末尾一级目录，removedirs() 会尝试依次删除 path 中提到的每个父目录，直到抛出错误为止（但该错误会被忽略，因为这通常表示父目录不是空目录）。
    如果无法成功删除末尾一级目录，则抛出 OSError 异常。
  os.rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
    将文件或目录 src 重命名为 dst。
  os.renames(old, new)
    递归重命名目录或文件。工作方式类似 rename()，除了会首先创建新路径所需的中间目录。重命名后，将调用 removedirs() 删除旧路径中不需要的目录。
  os.rmdir(path, *, dir_fd=None)
    删除目录，只能删除空目录

  os.system(command)
    在子外壳程序中执行此命令（一个字符串）。相当与在cmd中执行命令。
    这是通过调用标准 C 函数 system() 来实现的，并受到同样的限制。 对 sys.stdin 的更改等不会反映在所执行命令的环境中。 如果 command 生成了任何输出，它将被发送到解释器的标准输出流。 C 标准没有指明这个 C 函数返回值的含义，因此这个 Python 函数的返回值取决于具体系统。

logging模块

logging.basicConfig(**kwargs)
  通过使用默认的 Formatter 创建一个 StreamHandler 并将其加入根日志记录器来为日志记录系统执行基本配置。
  如果没有为根日志记录器定义处理器则 debug(), info(), warning(), error() 和 critical() 等函数将自动调用 basicConfig()。
  如果根日志记录器已配置了处理器则此函数将不执行任何操作，除非关键字参数 force 被设为 True。

  参数：
    filename
      使用指定的文件名创建一个 FileHandler，而不是 StreamHandler。
    filemode
      如果指定了 filename，则用此 模式 打开该文件。 默认模式为 'a'。
    format
      使用指定的格式字符串作为处理器。 默认为属性以冒号分隔的 levelname, name 和 message。
    datefmt
      使用指定的日期/时间格式，与 time.strftime() 所接受的格式相同。
    style
      如果指定了 format，将为格式字符串使用此风格。 '%', '{' 或 '$' 分别对应于 printf 风格, str.format() 或 string.Template。 默认为 '%'。
    level
      设置根记录器级别为指定的 level.
    stream
      使用指定的流初始化 StreamHandler。 请注意此参数与 filename 不兼容 —— 如果两者同时存在，则会引发 ValueError。
    handlers
      如果指定，这应为一个包含要加入根日志记录器的已创建处理器的可迭代对象。
      任何尚未设置格式描述符的处理器将被设置为在此函数中创建的默认格式描述符。
      请注意此参数与 filename 或 stream 不兼容 —— 如果两者同时存在，则会引发 ValueError。
    force
      如果将此关键字参数指定为 true，则在执行其他参数指定的配置之前，将移除并关闭附加到根记录器的所有现有处理器。
    encoding
      如果此关键字参数与 filename 一同被指定，则其值会在创建 FileHandler 时被使用，因而也会在打开输出文件时被使用。
    errors
      如果此关键字参数与 filename 一同被指定，则其值会在创建 FileHandler 时被使用，因而也会在打开输出文件时被使用。 
      如果未指定，则会使用值 'backslashreplace'。 请注意如果指定为 None，它将被原样传给 open()，这意味着它将会当作传入 'errors' 一样处理。

  参数format中可用的LogRecord 属性
    args
      此属性不需要用户进行格式化。
      合并到 msg 以产生 message 的包含参数的元组，或是其中的值将被用于合并的字典（当只有一个参数且其类型为字典时）。
    asctime
      %(asctime)s
      表示人类易读的 LogRecord 生成时间。 默认形式为 '2003-07-08 16:49:45,896' （逗号之后的数字为时间的毫秒部分）。
    created
      %(created)f
      LogRecord 被创建的时间（即 time.time() 的返回值）。
    exc_info
      此属性不需要用户进行格式化。
      异常元组（例如 sys.exc_info）或者如未发生异常则为 None。
    filename
      %(filename)s
      pathname 的文件名部分。
    funcName
      %(funcName)s
      函数名包括调用日志记录.
    levelname
      %(levelname)s
      消息文本记录级别（'DEBUG'，'INFO'，'WARNING'，'ERROR'，'CRITICAL'）。
    levelno
      %(levelno)s
      消息数字的记录级别 (DEBUG, INFO, WARNING, ERROR, CRITICAL).
    lineno
      %(lineno)d
      发出日志记录调用所在的源行号（如果可用）。
    message
      %(message)s
      记入日志的消息，即 msg % args 的结果。 这是在发起调用 Formatter.format() 时设置的。
    module
      %(module)s
      模块 (filename 的名称部分)。
    msecs
      %(msecs)d
      LogRecord 被创建的时间的毫秒部分。
    msg
      此属性不需要用户进行格式化。
      在原始日志记录调用中传入的格式字符串。 与 args 合并以产生 message，或是一个任意对象 (参见 使用任意对象作为消息)。
    name
      %(name)s
      用于记录调用的日志记录器名称。
    pathname
      发出日志记录调用的源文件的完整路径名（如果可用）。
    process
      %(process)d
      进程ID（如果可用）
    processName
      %(processName)s
      进程名（如果可用）
    relativeCreated
      %(relativeCreated)d
      以毫秒数表示的 LogRecord 被创建的时间，即相对于 logging 模块被加载时间的差值。
    stack_info
      此属性不需要用户进行格式化。
      当前线程中从堆栈底部起向上直到包括日志记录调用并引发创建当前记录堆栈帧创建的堆栈帧信息（如果可用）。
    thread
      %(thread)d
      线程ID（如果可用）
    threadName
      %(threadName)s
      线程名（如果可用）

logging.getLogger(name=None)
  返回具有指定 name 的日志记录器，或者当 name 为 None 时返回层级结构中的根日志记录器。 
  如果指定了 name，它通常是以点号分隔的带层级结构的名称，如 'a'、'a.b' 或 'a.b.c.d'。 这些名称的选择完全取决于使用 logging 的开发者。
  所有用给定的 name 对该函数的调用都将返回相同的日志记录器实例。 这意味着日志记录器实例不需要在应用的各部分间传递。

记录器对象.setLevel(level)
  给处理器设置阈值为 level 。日志级别小于 level 将被忽略。
  创建处理器时，日志级别被设置为 NOTSET （所有的消息都会被处理）。
    CRITICAL 50
    ERROR    40
    WARNING  30
    INFO     20
    DEBUG    10
    NOTSET   0

logging/记录器对象.debug(msg, *args, **kwargs)
  在根日志记录器/此记录器 上记录一条 DEBUG 级别的消息。
  msg 是消息格式字符串，而 args 是用于字符串格式化操作合并到 msg 的参数。
  在 kwargs 中有三个关键字参数会被检查: 
    exc_info
      参数如果不为假值则会将异常信息添加到日志记录消息。
      如果提供了异常元组（为 sys.exc_info() 的返回值格式）或异常实例则它会被使用；在其他情况下，会调用 sys.exc_info() 以获取异常信息。
    stack_info
      默认为 False。
      如果为 True，则将堆栈信息添加到日志消息中，包括实际的日志调用。
      请注意，这与通过指定 exc_info 显示的堆栈信息不同：前者是从堆栈底部到当前线程中的日志记录调用的堆栈帧，而后者是在搜索异常处理程序时，跟踪异常而打开的堆栈帧的信息。
    extra
      它可被用来传递一个字典，该字典会被用来填充为日志记录事件创建并附带用户自定义属性的 LogRecord 的 __dict__。 之后将可按你的需要使用这些自定义属性。
      extra 中传入的字典的键不应与日志系统使用的键冲突。
        FORMAT = '%(asctime)s %(clientip)-15s %(user)-8s %(message)s'
        logging.basicConfig(format=FORMAT)
        d = {'clientip': '192.168.0.1', 'user': 'fbloggs'}
        logging.warning('Protocol problem: %s', 'connection reset', extra=d)
        # 2006-02-08 22:20:02,165 192.168.0.1 fbloggs  Protocol problem: connection reset

logging/记录器对象.info(msg, *args, **kwargs)
  在根日志记录器/此记录器 上记录一条 INFO 级别的消息。

logging/记录器对象.warning(msg, *args, **kwargs)
  在根日志记录器/此记录器 上记录一条 WARNING 级别的消息。

logging/记录器对象.error(msg, *args, **kwargs)
  在根日志记录器/此记录器 上记录一条 ERROR 级别的消息。

logging/记录器对象.critical(msg, *args, **kwargs)
  在根日志记录器/此记录器 上记录一条 CRITICAL 级别的消息。

json模块

json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
  将 obj 序列化为 JSON 格式化流形式的 fp (支持 .write() 的 file-like object)。
  skipkeys
    如果是 true，那么那些不是基本对象（包括 str, int、float、bool、None）的字典的键会被跳过；否则引发一个 TypeError。
  ensure_ascii
    是否对非 ASCII 字符转义
  check_circular
    是否做循环引用的检查。为False时，如果有循环引用会抛出RecursionError
  allow_nan
    为True时， JSON 规格范围外的 float 类型值（nan、inf 和 -inf）输出为 JavaScript 等价形式（NaN、Infinity 和 -Infinity）。
    为Falses时，对应的值会引发ValueError。
  indent
    默认None，为不换行不缩进
    为<=0或者""时，只换行不缩进
    为正整数时，换行并且每一层缩进同样数量的空格
    为字符串时 (比如 "\t")，换行并且那个字符串会被用于缩进每一层。
  separators
    当被指定时，应当是一个 (item_separator, key_separator) 元组。
    当 indent 为 None 时，默认值取 (', ', ': ')，否则取 (',', ': ')
  default
    被指定时，其应该是一个函数，每当某个对象无法被序列化时它会被调用。
    它应该返回该对象的一个可以被 JSON 编码的版本或者引发一个 TypeError。
    如果没有被指定，则会直接引发 TypeError。
  sort_keys
    为True时,字典的输出会以键的顺序排序
  cls
    指定自定义的 JSONEncoder 子类（比如：覆盖了 default() 方法来序列化额外的类型）

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
  将 obj 序列化为 JSON 格式的 str。 其参数的含义与 dump() 中的相同。

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
  将 fp (一个支持 .read() 并包含一个 JSON 文档的 text file 或者 binary file) 反序列化为一个 Python 对象。
  object_hook
    可选函数，入参为解析得到的字典，通过函数转换为自定义的对象。
  object_pairs_hook
    可选函数，入参为解析得到的有序的键值对表，通过函数转换为自定义的对象。
    如果 object_hook 也被定义， object_pairs_hook 优先。
  parse_float
    用于解析JSON浮点数的函数，默认为float(num_str)
  parse_int
    用于解析JSON整数的函数，默认为int(num_str)
  parse_constant
    出现'-Infinity' ， 'Infinity' ， 'NaN'时调用此函数返回解析值。
  cls
    指定自定义的JSONDecoder 子类

json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
  将 s (一个包含 JSON 文档的 str, bytes 或 bytearray 实例) 反序列化为 Python 对象。
  其他参数的含义与 load() 中的相同。