python内置函数总结

Posted 2020-08-14

以下是python3.4版本的内置函数

 

1、abx(x)

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

2、all(iterable)

如果iterable的所有元素为真（或者iterable为空）， 返回True。等同于:

def all(iterable):

     for element in iterable:

         if not element:

              return False

     return True

3、any(iterable)

如果iterable的任一元素为真，返回True。如果iterable为空，返回False。等同于：

def any(iterable):

     for element in iterable:

         if element:

           return True

    return False

 

4、ascii(object)

这个函数跟repr()函数一样，返回一个可打印的对象字符串方式表示。当遇到非ASCII码时，就会输出\x，\u或\U等字符来表示。与Python 2版本里的repr()是等效的函数。

 

>>>print(ascii(10), ascii(9000000), ascii(‘b\31‘), ascii(‘0x\1000‘)) 

10   9000000   ‘b\x19‘   ‘[email protected]‘

 

5、bin(x)

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

 

6、bool([x])

将一个值转化成布尔值，使用标准的真值测试例程。如果x为假或者没有参数，它返回False；否则它返回True。bool也是一个类，它是int的子类。bool不能被继承。它唯一的实例就是False和True

 

7、bytearray([source[, encoding[, errors]]])

返回一个新的字节数组。bytearray类型是一个可变的整数序列，整数范围为0 <= x < 256（即字节）。 它有可变序列的大多数方法，参见Mutable Sequence Types，同时它也有str类型的大多数方法，参见String Methods。

 

source参数可以以不同的方式来初始化数组，它是可选的：

如果是string，必须指明encoding（以及可选的errors）参数；bytearray()使用str.encode()将字符串转化为字节数组。

如果是integer，生成相应大小的数组，元素初始化为空字节。

如果是遵循buffer接口的对象，对象的只读buffer被用来初始化字节数组。

如果是iterable，它的元素必须是整数，其取值范围为0 <= x < 256，用以初始化字节数组。

如果没有参数，它创建一个大小为0的数组。

 

>>> c=bytearray(‘qwe1321‘,‘utf-8‘)

>>> c

bytearray(b‘qwe1321‘)

>>> c[1]

119

 

8、bytes([source[, encoding[, errors]]])

返回一个新的字节数组。bytearray类型是一个不可变的整数序列，整数范围为0 <= x < 256（即字节）。其他类似于bytearray

 

9、callable(object)

如果object参数可调用，返回True；否则返回False。如果返回真，对其调用仍有可能失败；但是如果返回假，对object的调用总是失败。注意类是可调用的（对类调用返回一个新实例）；如果类实例有__call__()方法，则它们也是可调用的

 

10、chr(i)

返回一个单字符字符串，字符的ASCII码为整数i。例如，chr(97)返回字符串‘a‘。 它是ord()的逆运算。参数的取值范围为[0..255]的闭区间；如果i超出取值范围，抛出ValueError。参见unichr()

 

11、classmethod(function)

将function包装成类方法。

 

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

 

class C(object):

    @classmethod

    def f(cls, arg1, arg2, ...):

        ...

@classmethod是函数decorator（装饰器）参见Function definitions中的函数定义。

 

它即可以通过类来调用（如C.f()），也可以通过实例来调用（如C().f()）。除了实例的类，实例本身被忽略。如果在子类上调用类方法，子类对象被传递为隐式的第一个参数。

类方法不同于C++或Java中的静态方法。如果你希望静态方法，参见这节的staticmethod()。需要类方法更多的信息，参见The standard type hierarchy中标准类型层次部分的文档。

 

12、compile(source, filename, mode[, flags[, dont_inherit]])

 

13、complex([real[, imag]])

创建一个复数，它的值为real + imag*j；或者将一个字符串／数字转化成一个复数。如果第一个参数是个字符串，它将被解释成复数，同时函数不能有第二个参数。第二个参数不能是字符串。每个参数必须是数值类型（包括复数）。如果imag被忽略，它的默认值是0，这时该函数就像是int()，long()和float()这样的数值转换函数。如果两个参数都被忽略，返回0j。

注意：当从字符串转化成复数的时候，字符串中+或者-两边不能有空白。例如，complex(‘1+2j‘)是可行的，但complex(‘1 + 2j‘)会抛出ValueError异常。

 

14、delattr(object, name)

这个函数和setattr()有关。参数是一个对象和一个字符串。字符串必须是对象的某个属性的名字。只要对象允许，这个函数删除该名字对应的属性。例如，delattr(x, ‘foobar‘)等同于del x.foobar

 

15、dict(**kwarg) 、dict(mapping, **kwarg) 、dict(iterable, **kwarg)

返回一个新字典，从一个可选的位置参数和一个可能为空的关键字参数集合初始化。

如果没有给定位置参数，则创建一个空的字典。如果给定位置参数且它是一个映射对象，则创建一个与该映射对象具有相同的键-值对的一个字典。否则，定位参数必须是一个可迭代的对象。可迭代对象中的每个元素必须本身是具有恰好两个对象的可迭代对象。每个元素的第一个对象就成为新字典的键，第二个对象成为对应的值。如果键出现超过一次，该键的最后一个值将成为新字典中相应的值。

如果给出关键字参数，关键字参数和它们的值会被添加到从位置参数创建的字典。如果正在添加的键已存在，来自关键字参数的值将替换来自位置参数的值。

为了说明，下面所有的例子都返回与{"one": 1, "two": 2, "three": 3}相等的一个字典：

 

>>> a = dict(one=1, two=2, three=3)

>>> b = {‘one‘: 1, ‘two‘: 2, ‘three‘: 3}

>>> c = dict(zip([‘one‘, ‘two‘, ‘three‘], [1, 2, 3]))

>>> d = dict([(‘two‘, 2), (‘one‘, 1), (‘three‘, 3)])

>>> e = dict({‘three‘: 3, ‘one‘: 1, ‘two‘: 2})

>>> a == b == c == d == e

True

 

16、dir([object])

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

 

如果对象有__dir__()方法，该方法被调用且必须返回一个属性列表。这允许实现了定制化的__getattr__()或者__getattribute__()函数的对象定制dir()报告对象属性的方式。

 

如果对象没有提供__dir__()，同时如果对象有定义__dict__属性，dir()会先尝试从__dict__属性中收集信息，然后是对象的类型对象。如果对象是自定义的话，返回列表有可能不完整或不准确__getattr__()。

 

对于不同类型的对象，默认的dir()行为也不同，因为它尝试产生相关的而不是完整的信息：

 

如果对象是模块对象，列表包含模块的属性名。

如果对象是类型或者类对象，列表包含类的属性名，及它的基类的属性名。

否则，列表包含对象的属性名，它的类的属性名和类的基类的属性名。

返回的列表按字母顺序排序。例如：

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

注意 因为dir()主要是为了在交互式环境下使用方便，它尝试提供有意义的名字的集合，而不是提供严格或一致定义的名字的集合，且在不同的版本中，具体的行为也有所变化。例如，如果参数是一个类，那么元类属性就不会出现在结果中。

 

17、divmod(a, b)

在长整数除法中，传入两个数字（非复数）作为参数，返回商和余数的二元组。对于混合的操作数类型，应用二元算术运算符的规则。对于普通整数或者长整数，结果等同于(a // b, a % b)。对于浮点数结果是(q, a % b)，q一般是math.floor(a / b)，但也可能比那小1。不管怎样，q * b + a % b非常接近于a，如果a % b非0，它和b符号相同且0 <= abs(a % b) < abs(b)。

 

18、enumerate(sequence, start=0)

返回一个枚举对象。sequence必须是个序列，迭代器iterator，或者支持迭代的对象。enumerate()返回的迭代器的next()方法返回一个元组，它包含一个计数（从start开始，默认为0）和从sequence中迭代得到的值：

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

 

19、eval(expression[, globals[, locals]])

参数是Unicode或者Latin-1编码的字符串，全局变量和局部变量可选。如果有全局变量，globals必须是个字典。如果有局部变量，locals可以是任何映射类型对象。

expression参数被当作Python表达式来解析并演算（技术上来说，是个条件列表），使用globals和locals字典作为全局和局部的命名空间。如果globals字典存在，且缺少‘__builtins__’，在expression被解析之前，当前的全局变量被拷贝进globals。这意味着一般来说expression能完全访问标准__builtin__模块，且受限的环境会传播。如果locals字典被忽略，默认是globals字典。如果都被忽略，表达式在eval()被调用的环境中执行。返回值是被演算的表达式的结果。语法错误报告成异常。例子：

>>> x = 1

>>> print eval(‘x+1‘)

2

该函数也能执行任意的代码对象（如compile()返回的结果）。 在这种情况下，传递代码对象而不是字符串。如果代码对象编译时mode参数为‘exec‘，eval()返回None。

提示：exec语句支持动态的语句执行。execfile()函数支持执行文件中的语句。globals()和locals()函数返回当前的全局变量和局部变量的字典，可以传递给eval()或者execfile()。

参见ast.literal_eval()，该函数能安全演算只含字面量的表达式的字符串。

 

20、exec(object[, globals[, locals]])

 

21、filter(function, iterable)

构造一个列表，列表的元素来自于iterable，对于这些元素function返回真。iterable可以是个序列，支持迭代的容器，或者一个迭代器。如果iterable是个字符串或者元组，则结果也是字符串或者元组；否则结果总是列表。如果function是None，使用特性函数，即为假的iterable被移除。

注意，在function不为None的情况下，filter(function, iterable)等同于[item for item in iterable if function(item)]；否则等同于[item for item in iterable if item]（function为None）。

参见itertools.ifilter()和itertools.ifilterfalse()，以得到该函数的迭代器版本，以及该函数的变体（过滤function返回假的元素）。

 

22、float([x])

将字符串或者数字转化成浮点数。如果参数是字符串，它必须包含小数或者浮点数（可以有符号），周围可以有空白。参数也可以是[+|-]nan或者[+|-]inf。其它情况下，参数可以是原始／长整数或者浮点数，（以Python的浮点数精度）返回具有相同值的浮点数。如果没有参数，返回0.0。

注意 当传递字符串时，依赖于底层的C库，可以返回NaN（Not a Number，不是一个数字）和Infinity（无穷大）这样的值。该函数接受字符串nan（NaN），inf（正无穷大）和-inf（负无穷大）。对于NaN，不区分大小写和+/-号。总是用nan，inf或者-inf来表示NaN和Infinity。

 

23、format(value[, format_spec])

将value转化成“格式化”的表现形式，格式由format_spec控制。对format_spec的解释依赖于value参数的类型，大多数内置类型有标准的格式化语法：Format Specification Mini-Language。

注意 format(value, format_spec)仅仅调用value.__format__(format_spec)。

 

24、frozenset([iterable])

返回一个新的frozenset对象，如果可选参数iterable存在，frozenset的元素来自于iterable。frozenset是个内置类。参见frozenset和Set Types — set, frozenset。

关于其它容器，参见set，list，tuple，和dict类，以及collections模块。

 

25、getattr(object, name[, default])

返回object的属性值。name必须是个字符串。如果字符串是对象某个属性的名字，则返回该属性的值。例如，getattr(x, ‘foobar‘)等同于x.foobar。如果名字指明的属性不存在，且有default参数，default被返回；否则抛出AttributeError。

 

26、globals()

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

 

27、hasattr(object, name)

参数是一个对象和一个字符串。如果字符串是对象某个属性的名字，返回True；否则返回False。（实现方式为调用getattr(object, name)，看它是否抛出异常）。

 

28、hash(object)

返回对象的hash（哈希/散列）值（如果有的话）。hash值是整数。它被用于在字典查找时快速比较字典的键。相同的数值有相同的hash（尽管它们有不同的类型，比如1和1.0）

 

29、help([object])

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

这个函数经由site模块加入内置的命名空间。

 

30、hex(x)

将任意大小的整数转化成以“0x”打头的小写的十六进制字符串，例如：

>>> hex(255)

‘0xff‘

>>> hex(-42)

‘-0x2a‘

>>> hex(1L)

‘0x1L‘

如果x不是Python的int或者long对象，它必须定义__index__()方法以返回一个整数。

参见int()，它将十六进制字符串转化成一个整数。

注意 使用float.hex()方法得到浮点数的十六进制字符串表示。

 

31、id(object)

返回对象的“标识”。这是一个整数（或长整数），保证在对象的生命期内唯一且不变。生命期不重叠的两个对象可以有相同的id()值。

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

 

32、input([prompt])

该函数不会捕获用户错误。如果输入语法不合法，将抛出SyntaxError。如果执行中有错误，将抛出其它异常。

如果有装载readline，input()将会用它来提供复杂的行编辑和历史功能。

建议使用raw_input()函数来得到用户的一般输入。

 

33、int(x=0)、int(x, base=10)

将数字或字符串x转化成一个整数，如果没有参数则返回0。如果x是个数字，它可以是普通整数／长整数，或者浮点数。如果x是浮点数，则向0截断。如果参数超出了整数的范围，则返回长整数对象。

如果x不是个数字，或者存在base参数，则x必须是个表示以base为基数的integer literal（整数字面量）的字符串或者Unicode对象。字面量的前面可以有+或者-（中间不能有空格），周围可以有空白。以n为基数的字面量包含数字0到n-1，用a到z（或者A到Z）来表示10到35。默认的base是10。允许的值为0和2-36。二进制，八进制和十六进制的字面量前面可以有0b/0B，0o/0O/0，或者0x/0X，就像代码中的整数字面量一样。基数0表示严格按整数字面量来解释字符串，所以实际的基数为2，8，10或者16。

整数类型描述于Numeric Types — int, float, long, complex。

 

34、isinstance(object, classinfo)

如果参数object 是参数classinfo 的一个实例；或者是其一个（直接的、间接的或者virtual）子类的实例，返回真。如果classinfo是类型对象（新式类）而object是该类型对象；或者是其子类（直接的，间接的，或者virtual），返回真。如果object不是给定类型的类实例或者对象，该函数总是返回假。如果classinfo既不是类对象，也不是类型对象，它可以是类／类型对象的元组，或者递归包含这样的元组（不接受其它的序列类型）。如果classinfo不是类，类型，类／类型的元组，抛出TypeError异常。

 

35、issubclass(class, classinfo)

如果class是classinfo的子类（直接的，间接的，或者virtual) ，返回真。一个类被认为是它自己的子类。classinfo可以是类对象的元组，这时classinfo中的每个类对象都会被检查。其它情况下，抛出TypeError异常。

 

36、iter(object[, sentinel])

返回一个iterator对象。根据有无第二个参数，对第一个参数的解释相差很大。如果没有第二个参数，o必须是个集合对象，要么支持迭代协议（即 __iter__()方法），要么支持序列协议（即__getitem__()方法，整数参数从0开始）。 如果这些协议都不支持，抛出TypeError。如果有第二个参数sentinel，o必须是个可调用对象。这种情况下返回的迭代，每当调用其next()方法时，将会调用o（不带参数）；如果返回值等于sentinel，抛出StopIteration，否则返回该值。

第二种形式的iter()的一个有用的应用就是读一个文件的行，直到读到特定行。下面的例子读一个文件，直到readline()方法返回一个空字符串：

with open(‘mydata.txt‘) as fp:

    for line in iter(fp.readline, ‘‘):

        process_line(line)

 

37、len(s)

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

 

38、list([iterable])

返回一个列表，其元素来自于iterable（保持相同的值和顺序）。iterable可以是个序列，支持迭代的容器，或者迭代器对象。如果iterable已经是个列表，返回其拷贝，类似于iterable[:]。例如，list(‘abc‘)返回[‘a‘, ‘b‘, ‘c‘]，list( (1, 2, 3) )返回[1, 2, 3]。如果没有参数，返回一个新的空的列表，[]。

list是可变序列类型，见文档Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange。关于其它容器参见内置dict，set，和tuple类，以及collections模块。

 

39、locals()

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

注意：不应该修改该字典的内容；所做的改变不一定会影响到解释器所用的局部和自由变量的值。

 

40、map(function, iterable, ...)

将function应用于iterable的每一个元素，返回结果的列表。如果有额外的iterable参数，并行的从这些参数中取元素，并调用function。如果一个参数比另外的要短，将以None扩展该参数元素。如果function是None使用特性函数；如果有多个参数，map()返回一元组列表，元组包含从各个参数中取得的对应的元素（某种变换操作）。iterable参数可以是序列或者任意可迭代对象；结果总是列表。

 

41、max(iterable, *[, key, default]) 、max(arg1, arg2, *args[, key])

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

如果有一个位置参数，iterable必须是个非空的可迭代对象（如非空字符串，元组或者列表）。返回可迭代对象中最大的元素。如果有2个或更多的位置参数，返回最大位置参数。

可选的key参数指明了有一个参数的排序函数，如list.sort()中使用的排序函数。如果iterable为空，则返回default，如果iterable为空且default未设置的话则引发ValueError错误；如果有key参数，它必须是关键字参数（例如，max(a,b,c,key=func)

 

42、memoryview(obj)

 

43、min(iterable, *[, key, default]) 、min(arg1, arg2, *args[, key])

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

如果有一个位置参数，iterable必须是个非空的可迭代对象（如非空字符串，元组或者列表）。返回可迭代对象中最小的元素。如果有2个或更多的位置参数，返回最小位置参数。

可选的key参数指明了有一个参数的排序函数，如list.sort()中使用的排序函数。如果iterable为空，则返回default，如果iterable为空且default未设置的话则引发ValueError错误；如果有key参数，它必须是关键字参数（例如，max(a,b,c,key=func)

 

44、next(iterator[, default])

通过调用iterator的next()方法，得到它的下一个元素。如果有default参数，在迭代器迭代完所有元素之后返回该参数；否则抛出StopIteration。

 

45、object()

返回一个新的无特征的对象。object是所有新式类的基类。它有对所有新式类的实例通用的方法。

 

46、oct(x)

将一个（任意尺寸）整数转化成一个八进制字符串。结果是一个合法的Python表达式。

 

47、open(file, mode=‘r‘, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

 

48、ord(c)

给定一个长度为一的字符串，如果参数是unicode对象，则返回表示字符的代码点的整数；如果参数是八位字符串，返回字节值。例如，ord(‘a‘)返回整数97，ord(u‘\u2020‘)返回8224。它是八位字符串chr()的反函数，也是unicode对象unichr()的反函数。如果参数是unicode且构建Python时添加了UCS2 Unicode支持，那么字符的码点必须在[0..65535]的闭区间；如果字符串的长度为2，则抛出TypeError。

 

49、pow(x, y[, z])

返回x 的 y次幂; 如果 z 提供的时候，, 返回 x 的 y 次幂，然后对  z 取模。(这样比 pow(x, y) % z) 更高效。两个参数的形式 pow(x, y) 与使用 操作符: x**y 是等价的。

参数必须是数字类型的。由于操作数是混合类型的，二进制计算的原因需要一些强制的规定。对于整型和长整型的操作数，计算结果和操作数（强制后的）是相同的类型。除非第二个 参数是负数。在这种情况下, 所有的参数都会被转化成浮点型，并且会返回一个浮点的结果。例如, 10**2 返回 100, 但 10**-2 返回0.01. (这个新特性被加入在Python2.2中在Python2.1和之前的版本中,如果两个参数是整型，并且第二个参数为负数的情况下，会抛出一个异常。）如果第二个参数为负数，那么第三个参数必须省略。如果提供参数 z , x and y 必须为整数，而且y要是非负整数。(这个限制是在Python2.2加入的。Python2.1以及之前的版本, 三个参数都是浮点型的pow() 版本，返回的结果依赖 平台 对于浮点数的取整情况。)

 

50、print(*objects, sep=‘ ‘, end=‘\n‘, file=sys.stdout, flush=False) 

以sep分割，end的值结尾，将对象打印到文件流中。sep, end 和 file，如果提供这三个参数的话，必须以键值的形式。

所有非键值形式提供的参数，都被转化为字符串，就像用str()转化那样。然后写到 文件流中，以 sep 分割， end 结尾。sep and end 都必须是字符串形式的; 也可以留成 None, 这样会使用默认值。如果没有打印 对象, print() 只打印一个 结束符号 end.

file 参数一定要是含有 write(string)方法的对象 ; 如果该参数为空，或为None, 默认使用sys.stdout 作为输出。是否输出缓冲通常是由文件确定的，但如果刷新关键字flush参数是真的，流被强制刷新。

 

52、property(fget=None, fset=None, fdel=None, doc=None) 

 

53、range(start, stop[, step])

这是一个创建包含数列的列表的通用函数。它最常用于for循环。参数必须为普通的整数。如果step参数省略，则默认为1。如果start参数省略，则默认为0。该函数的完整形式返回一个整数列表[start, start + step, start + 2 * step, ...]。如果step为正，则最后一个元素start + i * step最大且小于stop；如果step为负，则最后一个元素start + i * step最小且大于stop。step必须不能为零（否则会引发ValueError）。

 

54、repr(object)

返回某个对象可打印形式的字符串。它与字符串转换式（反引号）产生的值相同。有时候能够把这个操作作为一个普通的函数访问非常有用。For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. 类可以通过定义__repr__()方法控制该函数对其实例的返回。

 

55、reversed(seq)

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

 

56、round(number[, ndigits])

返回一个浮点型 近似值，保留小数点后 ndigits 位。如果省略ndigits，它默认为零。结果是一个浮点数。该值将被圆整为距离10的负ndigits次方的最近的某个倍数; 如果有两个倍数离的一样近,结果取离0较远的（所以，例如，round(0.5)是1.0 且round(-0.5)是-1.0）。

注意：浮点数round()的行为可能让人惊讶，例如round(2.675, 2)给出的是2.67 而不是期望的2.68。这不是一个错误：大部分十进制小数不能用浮点数精确表示，它是因为这样的一个事实的结果。更多信息，请参阅Floating Point Arithmetic: Issues and Limitations。

set([iterable])

返回一个新的set 对象，其元素可以从可选的iterable获得。set是一个内建的类。 关于该类的文档，请参阅set和集合类型 — set, frozenset。

关于其它容器请参阅内建的frozenset、list、tuple和dict类，还有collections模块。

 

57、setattr(object, name, value)

getattr()的相反操作。参数是一个对象、一个字符串和任何一个值。字符串可以是一个已存在属性的名字也可以是一个新属性的名字。该函数将值赋值给属性，只要对象允许。例如，setattr(x, ‘foobar‘, 123)等同于x.foobar = 123。

 

58、slice(start, stop[, step])

返回一个slice对象，表示由索引range(start, stop, step)指出的集合。start和step参数默认为None。切片对象具有只读属性start、stop和step，它们仅仅返回参数的值（或者它们的默认值）。它们没有其他显式的函数；它是它们用于Numerical Python和其它第三方扩展。在使用扩展的索引语法时同样会生成切片对象。例如：a[start:stop:step]或a[start:stop, i]。返回迭代器的另外一个版本可以参阅itertools.islice()。

 

59、sorted(iterable[, key][, reverse]) 

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

key和reverse与list.sort()方法的参数含义相同（在可变的序列类型一节描述）。

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

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

通常情况下，key和reverse转换处理比指定一个等同的cmp函数要快得多。这是因为cmp为每个元素调用多次但是key和reverse只会触摸每个元素一次。使用functools.cmp_to_key()来转换旧式的cmp函数为key函数。

 

60、staticmethod(function)

返回function的一个静态方法。

静态方法不接受隐式的第一个参数（也就是实例名称self）。要声明静态方法，请使用下面的习惯方式：

class C(object):

    @staticmethod

    def f(arg1, arg2, ...):

        ...

@staticmethod形式是一个函数装饰器 – 细节请参阅函数定义中函数定义的描述。

它既可以在类上调用（例如C.f()）也可以在实例上调用（例如C().f()）。除了它的类型，实例其他的内容都被忽略。

 

61、str(object=b‘‘, encoding=‘utf-8‘, errors=‘strict‘)

返回一个字符串，包含对象的友好的可打印表示形式。对于字符串，它返回字符串本身。与repr(object)的区别是str(object)不会永远试图返回一个eval()可接受的字符串；它的目标是返回一个可打印的字符串。如果没有给出参数，则返回空字符串‘‘。

 

62、sum(iterable[, start])

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

对于某些使用场景，有比sum()更好的选择。连接字符串序列的首选和快速的方式是调用‘‘.join(sequence)。如要相加扩展精度的浮点数，请参阅math.fsum()。若要连接一系列的可迭代量，可以考虑使用itertools.chain()。

 

63、super(type[, object-or-type])

返回一个代理对象，这个对象指派方法给一个父类或者同类. 这对进入类中被覆盖的继承方法非常有用。搜索顺序和 getattr() 一样。而它自己的 类型 则被忽略。

type的__mro__属性罗列了用getattr()和super()来搜索排序的解决方法。它可以随着继承关系的变化，动态的更新。

如果没有第二个参数，则返回未绑定的super对象 If the second argument is an object, isinstance(obj, type) must be true. If the second argument is a type, issubclass(type2, type) must be true (this is useful for classmethods)。

 

64、tuple([iterable])

返回一个元组，其元素及顺序与iterable的元素相同。iterable可以是一个序列、支持迭代操作的容器或迭代器对象。如果iterable已经是一个元组，它将被原样返回。例如，tuple(‘abc‘)返回(‘a‘, ‘b‘, ‘c‘)，tuple([1, 2, 3])返回(1, 2, 3)。如果没有给出参数，则返回一个空的元组()。

tuple是一个不可变序列类型，其文档在序列类型 — str, unicode, list, tuple, bytearray, buffer, xrange。关于其它容器，请参阅内建的dict、list和set类以及collections模块。

 

65、type(name, bases, dict)

只有一个参数时，返回object的类型。返回值是一个类型对象。建议使用内建函数isinstance()测试一个对象的类型。

带有三个参数时，返回一个新的类型对象。它本质上是class语句的动态形式。name字符串是类的名字且将成为__name__属性；bases元组逐条列举基类并成为__bases__属性；dict字典是包含类体定义的命名空间并成为__dict__属性。例如，下面的两条语句创建完全相同的type对象：

>>> class X(object):

...     a = 1

...

>>> X = type(‘X‘, (object,), dict(a=1))

 

66、vars([object])

返回模块、类、实例或其它任何具有__dict__属性的对象的__dict__属性。

模块和实例这样的对象具有可更新的__dict__属性；然而，其它对象可能对它们的__dict__属性具有写限制（例如，新式类使用dictproxy 来防止直接的字典更新）。

如果不带参数，则vars()的行为类似locals()。注意，局部字典只用于读取因为对局部字典的更新被忽略。

 

67、zip(*iterables)

该函数返回一个以元组为元素的列表，其中第 i 个元组包含每个参数序列的第 i 个元素。返回的列表长度被截断为最短的参数序列的长度。当多个参数都具有相同的长度时，zip()类似于带有一个初始参数为None的map()。只有一个序列参数时，它返回一个1元组的列表。没有参数时，它返回一个空的列表。

可以保证迭代按从左向右的计算顺序。这使得使用zip(*[iter(s)]*n)来将一系列数据分类归并为长度为n的组成为习惯用法。

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

>>> x = [1, 2, 3]

>>> y = [4, 5, 6]

>>> zipped = zip(x, y)

>>> zipped

[(1, 4), (2, 5), (3, 6)]

>>> x2, y2 = zip(*zipped)

>>> x == list(x2) and y == list(y2)

True

 

68、__import__(name, globals=None, locals=None, fromlist=(), level=0)