Python—内置函数

abs(x)：

返回一个数的绝对值。参数可以是一个整数或浮点数。如果一个参数是复数，那么返回它的模。

all(iterable)：

当 iterable 中所有元素都为 True 时（或者 iterable 为空），返回 True 。

any(iterable)：

当 iterable 中有元素为 True 时，则返回 True 。如果当 iterable 为空时，返回 False。

ascii(object)：

类似repr()，返回一个字符串，包含可打印的对象，但通过 repr() 返回的字符串中非 ASCII 字符，使用 \x，\u 或者\U 进行转义。这将生成类似于 repr() 在 Python 2 中返回的字符串。

bool([x])：

返回一个布尔值，True 或 False。将会使用真值测试 标准对x 进行转换。如果 x 的值为 false 或被省略，这将返回 False;否则，将返回 True。bool类是 int 的子类 。它不能进一步子类化。其唯一的实例是 False 和 True 。

callable(object)：

如果该 object是可调用的，返回 True ,否则返回 False 。如果返回True，对其调用仍有可能失败；但是如果返回False，对object的调用总是失败。请注意，类是可调用的（调用类将返回一个新的实例）。如果实例的类有__call__()方法，则它是可调用；否则它是不可调用的。

chr(i)：返回表示Unicode码点为整数i的字符的字符串。例如，chr(97)返回字符串'a'，而chr(8364)返回字符串'€'它是ord()的逆操作。

classmethod(function)：

将函数包装成类方法。

　　类方法接受类作为隐式的第一个参数，就像实例方法接受实例作为隐式的第一个参数一样。声明一个类方法，使用这样的惯例：

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

dir([object])：

如果没有参数，返回当前本地作用域内的名字列表。如果有参数，尝试返回参数所指明对象的合法属性的列表。

divmod(a, b)：

取两个（非复数）数字作为参数，并在使用整数除法时返回由商和余数组成的一对数字。

enumerate(iterable, start=0)：返回一个枚举对象。iterable 必须是一个序列、一个迭代器，或者其它某种支持迭代的对象。enumerate()返回的迭代器的__next__()方法返回一个元组，该元组包含一个计数（从start开始，默认为0）和迭代iterable得到的值。

>>> 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)：

参数是字符串和可选的全局变量和局部变量。如果有全局变量，globals必须是个字典。如果有局部变量，locals可以是任何映射类型对象。expression参数被当作Python表达式来解析并演算（技术上来说，是个条件列表），使用globals和locals字典作为全局和局部的命名空间。如果globals字典存在，且缺少‘__builtins__’，在expression被解析之前，当前的全局变量被拷贝进globals。这意味着expression通常具有对标准builtins的完全访问权限，并且传播受限环境。如果locals字典被忽略，默认是globals字典。如果两个字典都省略，则在调用eval()的环境中执行表达式。返回值是被演算的表达式的结果。语法错误报告成异常。例子：

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

此函数也可用于执行任意代码对象（例如由compile()创建的代码对象）。在这种情况下，传递代码对象而不是字符串。如果代码对象已使用'exec'作为mode参数编译，则eval()的返回值将为None 。

提示：exec()函数支持语句的动态执行。globals()和locals()函数分别返回当前的全局和局部字典，可以用于传递给eval或exec()。

exec(object[, globals[, locals]])：

这个函数支持动态执行Python代码。object必须是一个字符串或代码对象。如果它是一个字符串，该字符串被解析为一套Python语句，然后执行（除非语法错误发生）。[1]如果它是一个代码对象，只是简单地执行它。在所有情况下，执行的代码应该可以作为有效的文件输入（参见“参考手册”中的“文件输入”部分）。请注意，即使在传递给exec()函数的代码上下文中，函数定义外面的return和yield 语句可能不被执行。返回值为None。

在所有情况下，如果省略可选部分，则代码在当前作用域中执行。如果只提供globals，它必须是一个字典，它将用于全局变量和局部变量。如果提供globals和locals，它们分别用于全局变量和局部变量。如果存在，locals可以是任意的映射类型对象。记住在模块级别，全局和局部字典是同一个字典。如果exec的globals和locals是独立的两个对象，代码的执行就像它嵌入在类定义中一样。

如果globals字典的__builtins__键没有值，则会给这个赋予一个内置模块builtins字典的引用。这样，你可以在将globals传递给exec()之前插入自己的__builtins__字典，来控制执行的代码可访问的builtins。

filter(function, iterable)：

用iterable中传入function后返回True的元素构造一个迭代器。iterable可以是个序列，支持迭代的容器，或者一个迭代器。如果function是None，使用特性函数，即为False的iterable中的元素被移除。

注意filter(function, iterable) 如果函数不是 None等效于生成器表达式 (item for item in iterable if function(item)) 。如果函数是 None ，(item for item in iterable if item)

globals()：

返回表示当前全局符号表的字典。它总是当前模块的字典（在函数或者方法中，它指定义的模块而不是调用的模块）。

hash(object)：

返回该对象的哈希值（如果有的话）. 哈希值应该是一个整数。哈希值用于在查找字典时快速地比较字典的键。相等数值的哈希值相同。

help([object])：

调用内置的帮助系统。（这个函数主要用于交互式使用。）如果没有参数，在解释器的控制台启动交互式帮助系统。如果参数是个字符串，该字符串被当作模块名，函数名，类名，方法名，关键字或者文档主题而被查询，在控制台上打印帮助页面。如果参数是其它某种对象，生成关于对象的帮助页面。

hex(x)：

将整数转换为以“0x”为前缀的小写十六进制字符串，例如：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

id(object)：

返回对象的“标识”。这是一个整数，它保证在该对象的生命周期内是唯一的和恒定的。具有不重叠寿命的两个对象可以具有相同的id()值。

CPython实现细节：这是内存中对象的地址。

input([prompt])：

如果有prompt参数，则将它输出到标准输出且不带换行。该函数然后从标准输入读取一行，将它转换成一个字符串（去掉一个末尾的换行符），然后返回它。当读取到EOF时，会产生EOFError。例子：

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

iter(object[, sentinel])：

返回一个迭代器对象。根据有无第二个参数，对第一个参数的解释相差很大。没有第二个参数，object必须是一个支持迭代协议（__iter__()方法）的容器对象，或者它必须支持序列协议（从 0开始的整数参数的__getitem__() 方法）。如果它不支持这些协议任何一个，将引发TypeError。如果给出第二个参数sentinel，那么object必须是一个可调用的对象。这种情况下创建的迭代器将在每次调用时不带参数调用object的__next__()方法；如果返回的值等于sentinel，将引发StopIteration，否则返回这个值。

iter()第二个参数的有用的一个场景是读取文件的行直至到达某个特定的行。下面的示例读取一个文件，直至readline()方法返回一个空字符串：

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

len(s)：

返回对象的长度（元素的个数）。参数可以是序列（如字符串，字节，元组，列表或者范围）或者集合（如字典，集合或者固定集合）。

locals()：

更新和返回表示当前局部符号表的字典。当locals()在函数代码块中调用时会返回自由变量，但是在类代码块中不会。

map(function, iterable, ...)：

返回一个迭代器，对iterable的每个项应用function，并yield结果。如果传递多个iterable参数，function必须接受这么多参数，并应用到从iterables并行提取的项中。如果有多个iterable，迭代器在最短的iterable耗尽时停止。

max(iterable, *[, key, default])：

max(arg1, arg2, *args[, key])：

返回可迭代的对象中的最大的元素，或者返回2个或多个参数中的最大的参数。

填入的位置参数应该是可迭代的（ iterable）对象.返回可迭代对象中最大的元素。如果有2个或更多的位置参数，返回最大位置参数。

有两个可选的仅关键字参数。key参数指定类似于用于list.sort()的单参数排序函数。default参数指定如果提供的iterable为空则要返回的对象。如果迭代器为空并且未提供default，则会引发ValueError。

如果多个项目是最大的，则函数返回遇到的第一个项目。

min(iterable, *[, key, default])：

min(arg1, arg2, *args[, key])：

返回可迭代的对象中的最小的元素，或者返回2个或多个参数中的最小的参数。

如果提供了一个位置参数，它应该是一个可迭代对象。返回可迭代对象中最小的元素。如果有2个或更多的位置参数，返回最小的位置参数。

有两个可选的仅关键字参数。键参数指定类似于用于list.sort()的单参数排序函数。默认参数指定如果提供的iterable为空则要返回的对象。如果迭代器为空并且未提供default，则会引发ValueError。

如果多个项目是最小的，函数返回遇到的第一个。

next(iterator[, default])：

通过调用__next__()方法从迭代器中检索下一个项目。如果有default参数，在迭代器迭代完所有元素之后返回该参数；否则抛出StopIteration。

oct(x)：

将整数转换为八进制字符串。结果是一个合法的Python表达式。如果x不是Python int对象，则必须定义一个返回整数的__index__()方法。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：

打开 file 并返回一个相应的 文件对象.如果文件不能被打开, 抛出 OSError 异常.

参数 file 是一个字符串表示的文件名称，或者一个数组表示的文件名称。文件名称可以是相对当前目录的路径，也可以是绝对路径表示。（如果给出了一个文件描述器，则当关闭返回的I / O对象时除外，除非closefd设置为False。

参数 mode 是指明打开文件的模式。默认值是'r'，表示使用文本的方式打开文件来读取。其他常见值为'w'用于写入（如果文件已经存在则截断文件），'x'用于排他性创建，'a' （在某些 Unix系统上，意味着全部写入追加到文件的末尾，而不管当前的查找位置）。在文本模式下，如果未指定encoding，则使用的编码取决于平台：locale.getpreferredencoding（False）以获取当前语言环境编码。（对于读取和写入原始字节，使用二进制模式，不指定编码。可用的模式有：

字符	含义
'r'	打开阅读（默认）
'w'	打开写入，首先截断文件
'x'	打开以供独占创建，如果文件已存在则失败
'a'	打开以供写入，如果存在，则附加到文件的末尾
'b'	二进制模式
't'	文本模式（默认）
'+'	打开磁盘文件进行更新（读写）

 

 

 

 

 

 

 

 

ord(c)：

给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode代码点的整数。例如，ord('a')返回整数97和ord('€')（欧元符号）返回8364。这是chr()的逆操作。

pow(x, y[, z])：

返回x的y次方; 如果提供z参数， 返回x 的y次方再除以z的余数 (计算效率比pow(x, y) % z更高)。双参数形式pow(x, y)等效于使用幂操作符号：x**y 。

参数必须是数字类型的。由于操作数是混合类型的，二进制计算的原因需要一些强制的规定。对于int操作数，结果具有与操作数相同的类型（强制后），除非第二个参数为负；在这种情况下，所有参数都转换为float，并传递float结果。

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)：

将object打印到文本流file，由sep分隔，尾部接end。sep, end 和 file，如果提供这三个参数的话，必须以关键参数的形式。

range(stop)：

range(start, stop[, step])：

range实际上是Ranges和Sequence Types — list, tuple, range中描述的不可变序列类型，而不是函数。

reversed(seq)：

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

round(number[, ndigits])：

返回number舍入到小数点后ndigits位的浮点值。如果省略ndigits，将返回最接近输入的整数。底层调用的是number.__round__(ndigits)。

sorted(iterable[, key][, reverse])：

依据iterable中的元素返回一个新的排好序的列表。

具有两个可选参数，它们必须指明为关键字参数。

key指示一个带有一个参数的函数，它用于从列表的每个元素中提取比较的关键字：key=str.lower。默认值是None（直接比较元素）。

reverse是一个布尔值。如果设置为True，那么列表中元素反过来比较来排序。

sum(iterable[, start])：

将start以及iterable的元素从左向右相加并返回总和。start默认为0。iterable的元素通常是数字，start值不允许是一个字符串。

tuple([iterable])：

而不是一个函数，tuple实际上是一个不变序列类型

zip(*iterables)：

创建一个迭代器，聚合来自每个迭代器的元素。

返回一个由元组构成的迭代器，其中第i个元组包含来自每一组参数序列或可迭代量的第i元素。当最短输入可迭代被耗尽时，迭代器停止。使用单个可迭代参数，它返回1元组的迭代器。没有参数，它返回一个空迭代器。等同于：

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

可以保证迭代按从左向右的计算顺序。这使得使用zip(*[iter(s)]*n)将数据序列聚类为n长度组的习语成为可能。这重复了相同的迭代器n次，以使每个输出元组具有对迭代器的n调用的结果。这具有将输入划分为n个长块的效果。

zip()当迭代器元素不一致时，循环停止在较短的迭代器元素，较长的迭代器元素会被舍弃。

zip() 与 * 操作符一起可以用来 unzip 一个列表：

>>> 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