Python内置函数和常量

内置函数

• abs(x) : 返回一个数字的绝对值，参数可以为一个整数或浮点数，如果参数为复数，则返回它的模。

• all(iter) : 当iter中所有元素均为True时，或者iter为空时，返回True。效果类似如下：

  def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

• any(iter) : 当iter中所有元素为True时返回True，iter为空时返回False，类似：

  def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

• ascii(obj) : 类似repr()，返回一个输入对象的可打印字符串，但是在返回字符串中去掉非ASCII编码字符。类似python2中的repr()。

• bin(x) : 将一个整数转化为一个二进制字符串，结果是一个可用的Python表达式，如果x不是Python中的int类型，则需要定义index()方法使之返回一个整数。

• bool([x]) : 将一个值转换为布尔类型。

• bytearray([source[, encoding[, errors]]]) : 返回一个新的字节数组，该bytearray类型是0<=x<256范围内的可变整数序列。同时具有可变序列和bytes类型的大多数方法。

• bytes([source[, encoding[, errors]]]) : 返回一个新的字节类型。

• callable(obj) : 检查对象的可调用性。返回False的对象肯定不能调用，但返回True的对象仍有可能调用失败。

• chr(i) : 返回表示Unicode码的整数的字符串，例如chr(97)返回字符串’a’。与之功能相反的函数为ord()。接收整数范围为0~1114111，超出范围会抛出ValueError的异常。

• classmethod(func) : 返回一个类方法。一个类方法接收类本身作为第一个参数，声明方法：

  class C:
    @classmethod  
    def func(cls, arg1, arg2, ...): ...

  可以被类调用（C.func()），也可以被实例调用（C().func()）

• delattr(obj, name) : 参数分别为一个对象和一个字符串，其中字符串必须对应对象中的一个属性，可以删除对象中的对应属性。delattr(x, ‘foobar’) = del x.foobar

• dict([arg]) : 创建一个新字典。

• dir(obj) : 参数为空时返回本地作用域内的名字列表，有参数时，则尝试返回该对象有效属性的列表。

  >>> import struct
  >>> dir()   # show the names in the module namespace
  ['__builtins__', '__doc__', '__name__', 'struct']
  >>> dir(struct)   # show the names in the struct module
  ['Struct', '__builtins__', '__doc__', '__file__', '__name__',
  '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
  'unpack', 'unpack_from']
  >>> class Shape(object):
        def __dir__(self):
            return ['area', 'perimeter', 'location']
  >>> s = Shape()
  >>> dir(s)
  ['area', 'perimeter', 'location']

• divmod(a, b) : 当两个参数都为整数时，返回(a//b, a%b)；当有一个为浮点数时，返回(q, a%b)，其中q一般情况是math.floor(a/b)的结果，但也可能比这个结果小1。

• enumerate(iter, start=0) : 返回一个列举对象，其中iter必须为序列，或可迭代。该列举对象的next()方法返回一个由计数（start开始）和对应值组成的元组。举例：

  >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
  >>> list(enumerate(seasons))
  [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
  >>> list(enumerate(seasons, start=1))
  [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

  相当于：

  def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

• eval(expression, globals=None, locals=None) : expression为字符串，global必须为字典，locals可以为任意映射对象。主要功能为将字符串转换为对应的python语句，使用globals和locals字典作为全局和局部命名空间，返回值为执行语句后的结果：

  >>> x = 1
  >>> eval('x+1')
  2 

• filter(function, iter) : 对iter中的元素进行过滤，其中function为过滤条件，function返回false的元素会被过滤掉，当function为None时，iter中的所有元素都会被过滤掉。filter函数和列表生成式的作用有点相似(item for item in iterable if function(item)，或item for item in iterable if item).

• float([x]) : 将字符串或数字转换成浮点。如果参数为字符串，则需要包含小数数字。举例：

  >>> float('+1.23')
  1.23
  >>> float('   -12345\n')
  -12345.0
  >>> float('1e-003')
  0.001
  >>> float('+1E6')
  1000000.0
  >>> float('-Infinity')
  -inf

• frozenset([iterable]) : 返回一个frozenset对象，属于容器对象。

• getattr(obj, name[, default]) : 返回obj对象中属性名为name的属性。getattr(x, ‘foobar’) = x.foobar。如果属性不存在则返回default，否则会抛出AttributeError。

• hasattr(obj, name) : 判断obj对象是否有属性名为name的属性。

• help(obj) : 唤醒内置帮助系统，提供帮助的交互。当不提供参数时，交互系统进入一个交互控制台。如果参数为字符串，则帮助系统会查找任何名字为该参数的帮助信息；如果参数是一个对象，则会显示一个帮助页面

• id(obj) : 返回对象的唯一标识，为一个整数。

• input([prompt]) : 接收用户输入内容，读取一行内容并将其转化为字符串并返回。其中prompt为输入提示内容：

  >>> s = input('--> ')
  --> Monty Python's Flying Circus
  >>> s
  "Monty Python's Flying Circus"

• int([number|string[,base]]) : 将一个数字或字符串转化为整数，如果未传参数，返回0；否则返回参数number.int()。浮点数会截止到0位，字符串字面必须是基数为数字的，可以在前边加上’+’或’-‘(中间不能有空格)，两边可以添加空格。base参数默认值为10，可选值为2，8，10，16。

• isinstance(obj, classinfo) : 如果obj参数是classinfo参数的一个实例，则返回True，否则返回False。classinfo可以为一个类，或一个类组成的元组，否则会抛出TypeError的错误。

• issubclass(class, classinfo) : 判断class是不是classinfo的子类。同样的，classinfo也可以是由类组成的元组，否则抛出TypeError异常。

• iter(obj, [sentinel]) : 返回迭代器对象。第一个参数会受第二个参数影响，如果没有第二个参数，则第一个参数必须是支持迭代协议（iter**()方法）的集合对象，或者必须支持序列协议（__**getitem**()整数参数始终为0），否则会引发TypeError。如果给出了第二个参数，那obj必须为可调用对象，此时创建的迭代器将为调用其__**next()方法。如果迭代的返回值等于sentinal参数，则抛出Stopiteration，否则继续迭代并返回值。此方法可以用来按行迭代读取文件内容，遇到空字符则返回：

  with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

• len(s) : 返回一个对象的长度，参数可以为序列或映射。

• list([iterable]) : 返回一个由iterable元素组成的同序列表。iterable可以为支持迭代的序列、容器，或是一个迭代器对象。如果iterable已经是一个列表，会拷贝一份该列表并返回，类似iterable[:]。举例：

  list('abc') --->  ['a', 'b', 'c']
  list((1, 2, 3))  --->  [1, 2, 3]
  
  # 如果iterable参数为空，则返回空列表
  

• max(iterm, [args.., ], *[, key]) : 单个可迭代参数，则返回参数中最大的值；如果是多个参数，则返回参数中最大的值。

• min(iterm, [args.., ], *[, key]) : 用法同max，返回最小。

• next(iter, [, default]) : 通过调用iter的next()方法来获取下一个值。如果default赋值，当iter元素耗尽时，返回default，否则会引发StopIteration异常。

• object() : 返回一个没什么功能的对象。object是所有类的基础，拥有所有python类实例的通用方法。不接收任何参数。

• oct(x) : 将一个整数转化为八进制字符串。结果是一个合法的python表达式。如果参数x不是python的int对象，则要求参数具有返回整数的index()方法。

• open(file, mode=”r”, buffering=-1, encoding=None, errors=None, newline=None, closefd=True) : 打开文件并返回通信流。如果打不开文件则会抛出IOError异常。

  file是字符串或字节对象，提供要打开的路径名或要打开的文件的文件描述符。

  mode是打开文件方式的字符串，具体对应关系如下：

参数	作用
‘r’	只读（默认）
‘w’	只写，会覆盖原来的内容
‘a’	只写，将内容追加到已有内容的后边
‘b’	二进制模式，跟’r’ 和’w’结合使用
‘t’	文本模式（默认）
‘+’	以更新的状态打开磁盘文件，与’r’和’w’结合使用
‘U’	通用换行模式（方便向后兼容，不推荐新代码中使用）

buffering是设置缓存模式的参数。0—关闭缓存，仅用于二进制模式；1—按行取缓存，仅用于文本模式

• ord(C) : 返回字符对应Unicode表的编号，与chr()功能相反。

• pow(x, y[,z]) : 返回x的y次方幂，等于x**y。如果提供了z参数，则返回pow(x, y) % z。

• print([obj,…,]*, sep=”, end=’\n’, file=sys.stdout) : 打印一个或多个对象，以stdout的方式输出，多个对象打印结果以sep参数提供的字符串分隔，打印结束后以end参数的值结尾。

• range([start, ]stop[,step]) : 一个用来创建数字迭代生成器的函数。通常用于for循环，参数必须为整数，默认步长参数为1，开始参数默认为0。完整形式返回方式为：[start, start+step, start+2*step, …]。如果步长为整数，最后一个元素为比stop小的最大start+i*step；如果步长为负数，最后一个元素为start+i*step中比stop大的最小值。步长不能为零，否则会抛出ValueError异常。

  >>> list(range(10))
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> list(range(1, 11))
  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  >>> list(range(0, 30, 5))
  [0, 5, 10, 15, 20, 25]
  >>> list(range(0, 10, 3))
  [0, 3, 6, 9]
  >>> list(range(0, -10, -1))
  [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
  >>> list(range(0))
  []
  >>> list(range(1, 0))
  []

  需要注意的是，该方法支持索引，切片并且支持负数索引：

  >>> r = range(0, 20, 2)
  >>> r
  range(0, 20, 2)
  >>> 11 in r
  False
  >>> 10 in r
  True
  >>> r.index(10)
  5
  >>> r[5]
  10
  >>> r[:5]
  range(0, 10, 2)
  >>> r[-1]
  18

• repr(object) :返回一个包含对象可打印表示的字符串。通常会返回一个尖括号包裹的字符串，包含了对象类型名称以及附加信息。一个类通常可以定义一个repr()方法来控制返回的内容。

• reversed(seq) : 返回一个反向迭代器。其中seq必须具有reversed()方法或者支持序列协议。

• round(x[, n]) : 将浮点数x的小数点后面的浮点值舍为n位数，n默认为0。委托给x.round()方法执行。

• set([iterable]) : 返回一个新集合，如果传入了参数，则以参数中的值构造集合。

• setattr(obj, name, value) : 给obj对象设置一个属性，该属性名为name，属性值为value。setattr(x, ‘foobar’, 123) == x.foobar=123。

• sorted(iterable[,key][,reverse]): 返回一个排好序的列表，其中元素为iterable的元素。key参数指定每个元素的对比规则，默认为空；reverse参数是一个布尔值，如果为True则按逆序排。

• staticmethod(function) : 返回函数的静态方法。静态方法不接受未指明的第一个参数（参考classmethod会默认接收cls为第一个参数），声明方式为：

  class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

  静态方法同时可以在类和实例对象中调用。Python的静态方法和Java、C++的静态方法类似。

• str([object[,encoding[, errors]]]) : 返回对象的字符串形式。encoding参数为转换字符串的编码方式，传入的是字符串，如果传入未知编码方式，则会抛出LookupError异常。errors为处理异常的方式，当为’strict’时，会第一时间抛出ValueError错误；当值为’ignore’时，会静默处理异常；当值为’replace’时，会把无法解码的字符替换为Unicode。如果只给了object参数，则会返回对象的str()方法返回的值。

• super([type[, object-or-type]]) : 返回一个代理对象，委托调用超类或兄弟类的方法，一般用于继承并覆盖同名方法。寻找方法顺序与继承顺序一致。使用方法如下：

  class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

• tuple([iterable]) : 返回一个元组，如果iterable参数不为空，则该元组的元素为iterable中的元素。

• type(object) : 返回一个对象的类型，与object.class方法返回的内容一致。

• type(name, bases, dict) : 返回一个新的type类。实际上所有的类都可以由这个方法构成的：

  >>> class X:
  ...     a = 1
  ...
  >>> X = type('X', (object,), dict(a=1))

• zip(*iterables) : 返回一个由元组组成的迭代器，第i个元组由iterable的第i个元素组成。元组个数取决于最短的iterable。当只传入一个iterable参数时，返回的元组只包含一个元素。不传入参数，则返回一个空的迭代器。功能类似于：

  def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterables = [iter(it) for it in iterables]
    while iterables:
        result = []
        for it in iterables:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

  返回元组的左右顺序都是确定的，所以可以确保zip输出的结果的稳定性。

  >>> x = [1, 2, 3]
  >>> y = [4, 5, 6]
  >>> zipped = zip(x, y)
  >>> list(zipped)
  [(1, 4), (2, 5), (3, 6)]
  >>> x2, y2 = zip(*zip(x, y))
  >>> x == list(x2) and y == list(y2)
  True

• __import__(name, globals={}, locals={}, fromlist=[], level=0) : 该函数由import调用，通过导入builtins模块来导入该方法，用的比较少，除非在已知导入模块的名称时使用。可以通过globals和locals来确定包的上下文的名称。而fromlist则给出了需要导入的对象或子模块的名字。标准使用方式一般不使用locals这个参数，而且只有在决定包的上下文引用时才使用globals参数。level参数用来区分是相对引用还是绝对引用。0表示绝对引用，正数则表示相对引用。

内置常量

Python命名空间中有一些内置的常量：

• False : bool值中的假，对该值声明变量时会引发SyntaxError错误。

• True : bool值中的真，对该值声明变量时会引发SyntaxError错误。

• None : 属于types.NoneType的惟一的值，经常用于表示值的缺失，很多时候用在未对函数默认参数赋值的时候，对该值声明变量时会引发SyntaxError错误。

• NotImplemented : 通常由一些用来比较的特殊方法，如eq()、__lt()等作为结果返回，用来告知某些类型之间无法进行比较。

• Ellipsis : 表现形式为’…’，类似省略号，bool测试返回True。

• debug : 当Python解释器以-O参数模式启动时，返回False，否则返回True

site模块添加的常量：

• quit(code=None) & exit(code=None) : 用来停止程序并退出解释器环境，code参数为退出时打印的信息，当被调用时，会抛出SystemExit异常并终止代码的执行。

• copyright & license & credits : 用来打印一些版本内容等信息。