pyeval 命令支持的函数

yeval的用法参考python的eval()函数相关的内置函数:推荐参考python帮助文档.
以下为python官方文档翻译内容仅作参考:

abs(x)

返回一个数字的绝对值。参数可以是普通整数、长整数或浮点数。如果参数是复数，则返回其大小。
all(iterable)
如果iterable的所有元素都为真(或者如果iterable为空)，返回True。等价于:

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

新版本2.5

any(iterable)

如果iterable的任何元素为真，则返回True。如果iterable是空的，返回False。等价于:

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

新版本2.5

basestring()

这个抽象类型是str和unicode的超类。它不能被调用或实例化，但是可以用来测试对象是str的实例还是unicode的实例。isinstance(obj, basestring)等价于isinstance(obj， (str, unicode))。
新版本2.3。

bin(x)

将整数转换为二进制字符串。结果是一个有效的Python表达式。如果x不是Python int对象，它必须定义一个返回整数的_index__()方法。
新版本2.6。

class bool([x])

返回一个布尔值，即True或False。x是使用标准的真值测试过程转换的。如果x为false或省略，则返回false;否则返回True。bool也是一个类，它是int的子类。它唯一的例子是假的和真实的。
新版本2.2.1。
如果没有给出参数，这个函数返回False。

class bytearray([source[, encoding[, errors]]])

返回一个新的字节数组。bytearray类是一个范围为0 <= x < 256的可变整数序列。它拥有可变序列的大多数常用方法(在可变序列类型中描述)，以及str类型的大多数方法(参见String方法)。
可选的源参数可以用几种不同的方式初始化数组:
如果是unicode，还必须提供encoding(以及可选的errors)参数; bytearray() 然后使用以下命令将unicode转换为字节 unicode.encode().
如果是integer, 数组将具有该大小，并将使用空字节初始化。
如果对象符合buffer interface，则使用对象的只读缓冲区初始化字节数组.
如果它是可迭代的，那么它必须是0 <= x < 256范围内的整数的迭代，这些整数用作数组的初始内容.
如果它是可迭代的，那么它必须是0 <= x < 256范围内的整数的迭代，这些整数用作数组的初始内容
新版本2.6

callable(object)

如果对象参数显示为可调用，则返回True;如果不可调用，则返回False。如果返回true，仍然有可能调用失败，但如果返回false，则调用对象将永远不会成功。注意类是可调用的(调用类返回一个新实例);如果类实例有一个_call__()方法，那么它们是可调用的.

chr(i)

返回一个字符的字符串，其ASCII码为整数i。例如，chr(97)返回字符串“a”。这是ord()的倒数。参数必须在[0…255]、包容;如果i超出该范围，则会引发ValueError。参见unichr ()。.

classmethod(function)

返回函数的类方法。
类方法接收类作为隐式的第一个参数，就像实例方法接收实例一样。要声明类方法，请使用这个习惯用法:

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

@classmethod表单是一个函数装饰器，有关详细信息，请参阅函数定义中的函数定义描述。它可以在类(如C.f())上调用，也可以在实例(如C().f()上调用。除了类之外，实例将被忽略。如果为派生类调用类方法，则将派生类对象作为隐含的第一个参数传递。
类方法与c++或Java静态方法不同。
有关类方法的更多信息，请参阅标准类型层次结构中关于标准类型层次结构的文档。
新版本2.2。
在2.4版中更改:添加了函数装饰器语法。

cmp(x, y)

比较两个对象x和y，并根据结果返回一个整数。如果x < y，返回值为负;如果x == y，返回值为零;如果x > y，返回值严格为正。

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

将源代码编译为代码或AST对象。代码对象可以由exec语句执行，也可以通过调用eval()来计算。源代码可以是Unicode字符串、Latin-1编码的字符串或AST对象。有关如何使用ast对象的信息，请参阅ast模块文档。
文件名参数应该给出读取代码的文件;通过一些可识别的值,如果不是抰读取一个文件(“<字符串>”是常用的)。
mode参数指定必须编译什么样的代码;如果source由一系列语句组成，它可以是“exec”;如果它由一个表达式组成，它可以是“eval”;如果它由一个交互语句组成，它可以是“single”(在后一种情况下，计算值为None之外的表达式语句将被打印出来)。
可选参数标志和dont_inherit控制哪些将来的语句(参见PEP 236)会影响源代码的编译。如果两者都不存在(或者两者都为零)，则使用调用compile()的代码中有效的未来语句编译代码。如果给出了flags参数，并且dont_inherit不是(或为零)，那么除了那些无论如何都会使用的语句之外，还将使用flags参数指定的未来语句。如果dont_inherit是一个非零整数，那么flags参数是it，那么将忽略围绕编译调用的未来语句.
将来的语句是由位指定的，这些位可以被逐位对齐来指定多个语句。在_future__模块的_Feature实例上，可以找到指定给定特性所需的位字段compiler_flag属性。
如果编译的源无效，则此函数引发SyntaxError;如果源包含空字节，则引发TypeError。
如果希望将Python代码解析为其AST表示形式，请参见ast .parse()。
注意在“single”或“eval”模式下编译带有多行代码的字符串时，必须用至少一个换行字符终止输入。这是为了方便检测代码模块中不完整和完整的语句。
在2.3版中进行了更改:添加了标志和dont_inherit参数。
版本2.6中的变化:支持编译AST对象。
版本2.7中修改:允许使用Windows和Mac换行。另外，在“exec”模式下的输入不再需要以换行结束。

class complex([real[, imag]])

返回值为real + imag*1j的复数，或将字符串或数字转换为复数。如果第一个参数是字符串，那么它将被解释为一个复数，并且必须在没有第二个参数的情况下调用该函数。第二个参数永远不能是字符串。每个参数可以是任何数字类型(包括复数)。如果省略imag，它的默认值为零，该函数充当一个数字转换函数，如int()、long()和float()。如果省略了两个参数，则返回0j。
从字符串转换时，字符串必须不包含中心+或-运算符周围的空格。例如，complex(‘1+2j’)可以，但是complex(‘1+2j’)会引发ValueError。
复杂类型用数值类型int、float、long和complex来描述。

delattr(object, name)

这是setattr()的一个相对项。参数是一个对象和一个字符串。必须的名字字符串对象抯属性之一。如果对象允许，函数将删除named属性。例如，delattr(x， ‘foobar’)等价于del x.foobar。class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
创建一个新字典。dict对象是dictionary类。有关该类的文档，请参阅dict和映射类型dict。
对于其他容器，请参见内置列表、set和tuple类，以及collections模块。

dir([object])

如果没有参数，返回当前局部作用域中的名称列表。使用参数时，尝试返回该对象的有效属性列表。
如果对象有一个名为_dir__()的方法，就会调用该方法，并且必须返回属性列表。这允许实现自定义的_getattr__()或_getattribute__()函数的对象自定义dir()报告其属性的方式。
如果对象不提供__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()主要是为了方便在交互提示符中使用而提供的，所以它试图提供一组有趣的名称，而不是一组严格定义或一致定义的名称，并且它的详细行为可能会随着版本的不同而变化。例如，当参数是一个类时，元类属性不在结果列表中。

divmod(a, b)

以两个(非复数)数字作为参数，使用长除法时返回由它们的商和余数组成的一对数字。对于混合操作数类型，适用二进制算术运算符规则。对于普通整数和长整数，结果与(a // b, a % b)相同，对于浮点数，结果是(q, a % b)，其中q通常是数学。(a / b)层，但可能比这低1层。在任何情况下q * b + a % b都非常接近a，如果a % b是非零的，它与b有相同的符号，0 <= abs(a % b) < abs(b)。
在2.3版中进行了更改:不建议使用带有复数的divmod()。

enumerate(sequence, start=0)

返回枚举对象。序列必须是序列、迭代器或其他支持迭代的对象。enumerate()返回的迭代器的next()方法返回一个元组，其中包含一个count(从默认值为0开始)和遍历序列获得的值:

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

新版本2.3。
更改版本2.6:添加了start参数。

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

参数是Unicode或Latin-1编码的字符串和可选的全局变量和局部变量。如果提供了全局变量，那么它必须是一个字典。如果提供了，局部变量可以是任何映射对象。
在2.4版中进行了更改:以前，local必须是字典。
表达式参数作为Python表达式(从技术上讲，是一个条件列表)进行解析和计算，使用全局和局部字典作为全局和本地命名空间。如果存在全局字典,缺乏_builtins__,当前全局变量复制到全局解析表达式。这意味着表达式通常可以完全访问标准的……builtin__模块，并传播受限制的环境。如果省略了局部字典，它默认为全局字典。如果省略了这两个字典，表达式将在环境中执行:

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

这个函数还可以用来执行任意的代码对象(如compile()创建的代码对象)。在本例中，传递代码对象而不是字符串。如果代码对象编译与执行的模式参数,eval()抯将没有返回值。
Hints: exec语句支持语句的动态执行。execfile()函数支持从文件中执行语句。globals()和localals()函数分别返回当前的全局和本地字典，这对于传递给eval()或execfile()使用可能很有用。
参见ast.literal_eval()获得一个函数，该函数可以使用只包含文字的表达式安全地计算字符串。

execfile(filename[, globals[, locals]])

这个函数类似于exec语句，但是解析文件而不是字符串。它与import语句的不同之处在于它不使用模块管理——它无条件地读取文件并且不创建新的模块。[1]
参数是一个文件名和两个可选字典。使用全局和局部字典作为全局和本地命名空间，将文件解析为Python语句序列(类似于模块)并对其进行评估。如果提供了，局部变量可以是任何映射对象。请记住，在模块级，全局变量和局部变量是相同的字典
注意
默认局部变量的作用与下面的函数局部变量()所描述的一样:不应该尝试修改默认局部变量字典。如果需要在函数execfile()返回后查看代码对局部变量的影响，请传递显式局部变量字典。execfile()不能可靠地使用修改本地函数.
file(name[, mode[, buffering]])
文件类型的构造函数，将在“文件对象”节中进一步描述。构造函数抯参数相同的open()内置函数描述如下。
当打开一个文件时,它抯比使用open(),而不是直接调用该构造函数。file更适合于类型测试(例如，编写isinstance(f, file))。
新版本2.2。

filter(function, iterable)

从iterable的那些元素中构造一个列表，其中函数返回true。iterable可以是序列、支持迭代的容器或迭代器。如果iterable是字符串或元组，则结果也具有该类型;否则它总是一个列表。如果函数为None，则假定恒等函数，也就是说，iterable中所有为false的元素都被删除.
注意filter(function, iterable)等价于[item for item in iterable if function(item)] if function不为空，[item for item in iterable if item] if function为空。
有关此函数的迭代器版本，请参见itertools.ifilter()和itertools.ifilterfalse()，其中包括对函数返回false的元素进行筛选的变体
class float([x])
返回由数字或字符串x构造的浮点数。
如果参数是字符串，它必须包含一个可能有符号的小数或浮点数，可能嵌入到空格中。参数也可以是[+|-]nan或[+|-]inf。否则,该参数可以是一个普通或者长整数或浮点数,和一个浮点数相同的值(在Python抯浮点精度)返回。如果没有给出参数，则返回0.0。
注意
当传入一个字符串时，NaN和Infinity的值可能会返回，这取决于底层的C库。Float接受字符串nan、inf和-inf表示nan和正无穷或负无穷。对于NaN，大小写和前导+被忽略，前导-被忽略。Float总是表示NaN和∞为NaN、inf或-inf。
浮点类型用数字类型int、float、long和complex来描述
format(value[, format_spec])
将值转换为ormatted表示形式(由format_spec控制)。format_spec的解释将取决于值参数的类型，但是有一种标准格式语法被大多数内置类型使用:Format Specification Mini-Language。
注意
format(value, format_spec)只调用value. format_(format_spec)。
新版本2.6。

class frozenset([iterable])

返回一个新的frozenset对象，可选地使用iterable中的元素。frozenset是一个内置类。有关该类的文档，请参阅frozenset和Set Types - Set, frozenset。
对于其他容器，请参见内置的set、list、tuple和dict类，以及collections模块。
新版本2.4。

getattr(object, name[, default])

返回对象的命名属性的值。名称必须是字符串。如果字符串是对象抯属性之一的名字,结果是,属性的值。例如，getattr(x， ‘foobar’)等价于x.foobar。如果指定的属性不存在，则返回默认值，否则将引发AttributeError。

globals()

返回表示当前全局符号表的字典。这始终是当前模块的字典(在函数或方法中，这是定义它的模块，而不是调用它的模块)。

hasattr(object, name)

参数是一个对象和一个字符串。结果是真的如果字符串是对象抯属性之一的名字,如果不是假的。(这是通过调用getattr(对象、名称)并查看它是否引发异常来实现的。)

hash(object)

返回对象的哈希值(如果它有哈希值)。哈希值是整数。它们用于在字典查找期间快速比较字典键。比较equal的数值具有相同的散列值(即使它们属于不同的类型，如1和1.0)。help([object])
调用内置的帮助系统。(此函数用于交互使用。)如果没有给出参数，交互式帮助系统将在解释器控制台启动。如果参数是字符串，那么该字符串将作为模块、函数、类、方法、关键字或文档主题的名称进行查找，并在控制台上打印帮助页面。如果参数是任何其他类型的对象，则生成该对象上的帮助页面。
这个函数由site模块添加到内置的命名空间中。
新版本2.2。

hex(x)

把一个整数(任何大小)转换成一个小写的十六进制字符串前缀为0x，例如:

>>> hex(255)'0xff'>>> hex(-42)'-0x2a'>>> hex(1L)'0x1L'

如果x不是Python int或long对象，它必须定义一个返回字符串的……hex__()方法。
要将十六进制字符串转换为以16为基数的整数，请参见int()。
请注意
要获得浮点数的十六进制字符串表示形式，请使用float.hex()方法。
在2.4版本中更改:以前只返回无符号的文字。

id(object)

返回对象的dentity。这是一个整数(或长整数)，保证该对象在其生命周期内是唯一且不变的。具有非重叠生存期的两个对象可能具有相同的id()值。
CPython实现细节:这是内存中对象的地址。

input([prompt])

相当于eval (raw_input(提示))。
此函数不捕获用户错误。如果输入在语法上无效，则会引发SyntaxError。如果在计算过程中出现错误，可能会引发其他异常。
如果加载了readline模块，那么input()将使用它来提供详细的行编辑和历史特性。
考虑对来自用户的一般输入使用raw_input()函数。

class int(x=0)

class int(x, base=10)

返回一个由数字或字符串x构造的整数对象，如果没有给出参数，则返回0。如果x是一个数字，它可以是普通整数、长整数或浮点数。如果x是浮点数，则转换截断为零。如果参数超出整数范围，则函数返回一个长对象。
如果x不是一个数字，或者给定基数，那么x必须是一个字符串或Unicode对象，表示基数为整数的文字。可选地，文字前面可以加上+或-(中间没有空格)，并由空格包围。base-n文字由数字0到n-1组成，A到z(或A到z)的值为10到35。默认基数是10。允许的值是0和2 36。Base-2、-8和-16字面值可以选择前缀为0b/ 0b、0o/ 0o/0或0x/ 0x，就像代码中的整数字面值一样。以0为底意味着将字符串精确地解释为整数文本，因此实际的基数是2、8、10或16。整数类型以整型、浮点型、长型和复杂型来描述。

isinstance(object, classinfo)

如果对象参数是classinfo参数的实例，或其子类的实例(直接、间接或虚拟)，则返回true。如果classinfo是一个类型对象(new-style类)，而object是该类型的对象或其子类(直接、间接或虚拟)的对象，则返回true。如果对象不是类实例或给定类型的对象，函数总是返回false。如果classinfo是类或类型对象的元组(或递归地，其他此类元组)，如果object是任何类或类型的实例，则返回true。如果classinfo不是类、类型或类的元组.

issubclass(class, classinfo)

如果类是classinfo的子类(直接、间接或虚拟)，则返回true。一个类被认为是它自己的子类。classinfo可能是类对象的元组，在这种情况下，classinfo中的每个条目都将被检查。在任何其他情况下，都会引发一个TypeError异常。
在2.3版中进行了更改:添加了对类型信息元组的支持。

iter(o[, sentinel])

返回一个迭代器对象。第一个参数的解释非常不同，这取决于第二个参数的存在。如果没有第二个参数，o必须是一个支持迭代协议(iter_()方法)的集合对象，或者它必须支持序列协议(getitem_()方法，整数参数从0开始)。如果给出第二个参数sentinel，那么o必须是一个可调用的对象。在本例中创建的迭代器将调用o，而对其next()方法的每个调用都没有参数;如果返回的值等于sentinel，则将引发StopIteration，否则将返回该值。iter()的第二种形式的一个有用的应用程序是读取文件的行，直到到达某一行为止。下面的示例读取一个文件，直到readline()方法返回一个空字符串:

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

新版本2.2。

len(s)

返回对象的长度(项的数量)。参数可以是序列(如字符串、字节、元组、列表或范围)或集合(如字典、集或冻结集)。
class list([iterable])
返回一个列表，其中的项与可迭代项相同，且顺序相同。iterable可以是序列、支持迭代的容器或iterator对象。如果iterable已经是一个列表，那么将生成一个副本并返回，类似于iterable[:]。例如，list(‘abc’)返回[‘a’， ‘b’， ‘c’]， list((1,2,3))返回[1,2,3]。如果没有给出参数，则返回一个新的空列表[]。list是一个可变的序列类型，在序列类型str、unicode、list、tuple、bytearray、buffer和xrange中都有记录。对于其他容器，请参阅内置的dict、set和tuple类以及collections模块。

locals()

更新并返回表示当前本地符号表的字典。自由变量在函数块中调用时由局部变量()返回，但在类块中不返回。
请注意
本词典内容不得修改;更改可能不会影响解释器使用的局部变量和自由变量的值。

class long(x=0)

class long(x, base=10)

返回一个由字符串或数字x构造的长整数对象。如果参数是字符串，它必须包含一个任意大小的可能有符号的数字，可能嵌入到空格中。基本参数的解释方法与int()相同，并且只能在x是字符串时才给出。否则，参数可以是普通整数、长整数或浮点数，然后返回一个具有相同值的长整数。浮点数到整数的转换会截断(接近于零)。如果没有给出参数，则返回0L。long类型用数字类型int、float、long和complex来描述。

map(function, iterable, …)

将函数应用于iterable的每个项并返回结果列表。如果传递了额外的可迭代参数，函数必须接受那么多参数，并并行地应用于所有可迭代的项。如果一个迭代器比另一个迭代器短，则假定扩展时没有项。如果函数为零，则假设恒等函数;如果有多个参数，map()返回一个由元组组成的列表，其中包含来自所有迭代的对应项(一种转置操作)。可迭代参数可以是序列或任何可迭代对象;结果总是一个列表。

max(iterable[, key])

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

返回可迭代的或两个或多个参数中最大的项。如果提供了一个位置参数，iterable必须是非空的iterable(例如非空字符串、元组或列表)。返回iterable中最大的项。如果提供了两个或多个位置参数，则返回最大的位置参数。可选键参数指定一个单参数排序函数，类似于list.sort()。如果提供了key参数，那么它必须是关键字形式(例如max(a,b,c,key=func))。版本2.5中的更改:增加了对可选键参数的支持。

memoryview(obj)

返回从给定参数创建的emory视图对象。有关更多信息，请参见memoryview类型。

min(iterable[, key])

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

返回可迭代的或两个或多个参数中最小的项。
如果提供了一个位置参数，iterable必须是非空的iterable(例如非空字符串、元组或列表)。返回iterable中最小的项。如果提供了两个或多个位置参数，则返回最小的位置参数。
可选键参数指定一个单参数排序函数，类似于list.sort()。如果提供了key参数，那么它必须是关键字形式(例如，min(a,b,c,key=func))。
版本2.5中的更改:增加了对opt的支持
next(iterator[, default])
通过调用迭代器的next()方法从迭代器中检索下一项。如果给出了缺省值，则在迭代器耗尽时返回缺省值，否则将引发StopIteration。
新版本2.6。

class object

返回一个新的无特征对象。对象是所有新样式类的基础。它具有与所有新样式类实例相同的方法。
新版本2.2。
版本2.3中的更改:此函数不接受任何参数。以前，它接受论点，但忽视它们。

oct(x)

将整数(任何大小)转换为八进制字符串。结果是一个有效的Python表达式。
在2.4版本中更改:以前只返回无符号的文字。

open(name[, mode[, buffering]])

打开一个文件，返回“文件对象”节中描述的文件类型的对象。如果文件无法打开，则会引发IOError。在打开文件时，最好使用open()，而不是直接调用文件构造函数。前两个参数与stdio fopen()相同:name是要打开的文件名，mode是指示如何打开文件的字符串。mode最常用的值是“r”表示读取，“w”表示写入(如果文件已经存在，就截断它)，“a”表示附加(在某些Unix系统中，这意味着所有的写入都附加到文件的末尾，而不管当前的查找位置)。如果省略模式，则默认为“r”。默认情况下是使用文本模式，它可以在写入和读取时将’\n’字符转换为特定于平台的表示形式。因此，在打开二进制文件时，应该在模式值后面加上“b”，以二进制模式打开文件，这将提高可移植性。(即使在不以不同方式对待二进制文件和文本文件的系统上，附加“b”也是有用的，因为它充当文档。)有关模式的更多可能值，请参见下面。可选缓冲参数指定所需的文件缓冲区大小:0表示未缓冲，1表示行缓冲，任何其他正值表示使用(近似)该大小的缓冲区(以字节为单位)。负缓冲意味着使用系统默认值，通常是tty设备的行缓冲和其他文件的完全缓冲。如果省略，则使用系统默认值。[2]模式“r+”、“w+”、“a+”打开文件进行更新(读写);注意，‘w+‘会截断文件。在区分二进制文件和文本文件的系统上，将“b”附加到以二进制模式打开文件的模式;系统上没有抰这个区别,添加“b”没有影响。除了标准的fopen()值模式外，模式可以是“U”或“rU”。Python通常使用通用换行支持构建;提供“U”将以文本文件的形式打开文件，但是行可以被下列任何一种终止:Unix的行尾约定“\n”、Macintosh约定“\r”或Windows约定“\r\n”。所有这些外部表示都被Python程序视为“\n”。如果Python是在没有通用换行的情况下构建的，则支持与普通文本模式相同的“U”模式。注意，这样打开的文件对象还有一个名为newlines的属性，它的值为None(如果还没有看到换行)、’\n’、’\r’、’\r\n’或一个包含所看到的所有换行类型的元组。Python强制模式在去掉“U”之后，以“r”、“w”或“a”开头。Python提供了许多文件处理模块，包括fileinput、os、os。path、tempfile和shutil。版本2.5中更改:引入了对模式字符串首字母的限制。

ord( c )

给定长度为1的字符串，当参数为Unicode对象时，返回一个整数，表示字符的Unicode编码点;当参数为8位字符串时，返回一个字节的值。例如，ord(‘a’)返回整数97,ord(u’\u2020’)返回8224。这是8位字符串的chr()和unicode对象的unichr()的倒数。如果一个unicode参数和Python建于UCS2 unicode,那么角色抯代码点必须在区间[0 . .65535]包容性;否则，字符串长度为2，将引发一个类型错误。

pow(x, y[, z])

返回x的y次方;如果存在z，则将x返回到y的模z次方(计算效率比pow(x, y) % z更高)。参数必须具有数值类型。对于混合操作数类型，应用二进制算术运算符的强制规则。对于int和long int操作数，除非第二个参数是负数，否则结果的类型与操作数相同(强制之后);在这种情况下，所有参数都转换为float，并交付一个float结果。例如，102返回100，但是10-2返回0.01。(最后一个特性是在Python 2.2中添加的。在Python 2.1和以前的版本中，如果两个参数都是整数类型，而第二个参数是负数，则会引发异常。)如果第二个参数是负数，则必须省略第三个参数。如果z存在，x和y必须是整数类型，而y必须是非负的。(这个限制是在Python 2.2中添加的。在Python 2.1和以前的版本中，float 3-argument pow()根据浮点四舍五入事故返回平台相关的结果。

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)

将对象打印到流文件中，以sep分隔，后跟end。sep、end和file(如果存在)必须作为关键字参数给出。
所有非关键字参数都转换为str()这样的字符串，并写入流中，以sep分隔，后跟end。sep和end都必须是字符串;它们也可以是None，这意味着使用默认值。如果没有对象，print()将直接写入end。
文件参数必须是一个带有写(字符串)方法的对象;如果它不存在或没有，sys。将使用stdout。输出缓冲由文件决定。使用file.flush()确保，例如，立即出现在屏幕上。注意，这个函数通常不能作为内置函数使用，因为name print被识别为print语句。要禁用该语句并使用print()函数，请在模块顶部使用这个future语句:

from __future__ import print_function

新版本2.6

class property([fget[, fset[, fdel[, doc]]]])

返回新样式类(从对象派生的类)的属性。fget是一个获取属性值的函数。fset是一个用于设置属性值的函数。fdel是一个删除属性值的函数。doc为属性创建一个docstring。一个典型的用法是定义托管属性:

class C(object):
def __init__(self):
    self._x = None

def getx(self):
    return self._x

def setx(self, value):
    self._x = value

def delx(self):
    del self._x

x = property(getx, setx, delx, "I'm the 'x' property.")

如果c是c的一个实例，则c。x将调用getter c。x = value将调用setter和del c。删除人x。
如果给定，doc将是属性的docstring。否则,房地产将复制fget抯docstring(如果它存在的话)。这使得使用property()作为装饰器轻松创建只读属性成为可能::

class Parrot(object):
def __init__(self):
    self._voltage = 100000

@property
def voltage(self):
    """Get the current voltage."""
    return self._voltage

@property装饰器将voltage()方法转换为同名只读属性的etter，并将电压的docstring设置为et当前电压。
属性对象具有getter、setter和deleter方法，可作为装饰器使用，这些方法创建属性的副本，并将相应的访问器函数设置为修饰后的函数。这最好用一个例子来解释:

class C(object):
def __init__(self):
    self._x = None

@property
def x(self):
    """I'm the 'x' property."""
    return self._x

@x.setter
def x(self, value):
    self._x = value

@x.deleter
def x(self):
    del self._x

这段代码与第一个示例完全相同。确保为附加函数提供与原始属性相同的名称(本例中为x)。
返回的属性对象还具有与构造函数参数对应的属性fget、fset和fdel。
新版本2.2。
在版本2.5中更改:如果没有给定文档，则使用fget docstring。
在2.6版中进行了更改:添加了getter、setter和deleter属性。

range(stop)

range(start, stop[, step])

这是一个多功能函数，用于创建包含等差数列的列表。它最常用于for循环。参数必须是普通整数。如果省略step参数，则默认值为1。如果省略start参数，则默认值为0。完整的表单返回一个普通整数列表[start, start + step, start + 2 * step，…]。如果步长为正，则最后一个元素是最大的开始+ i *步长小于停止;如果step是负数，最后一个元素是最小的start + i * step大于stop。步骤不能为零(否则会引发ValueError)。例子:

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

raw_input([prompt])
如果出现prompt参数，则将其写入标准输出，不带换行符。然后，函数从输入中读取一行，将其转换为字符串(去掉后面的换行)，并返回该字符串。当读取EOF时，会引发EOFError。例子:

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

如果加载了readline模块，那么raw_input()将使用它来提供详细的行编辑和历史特性

reduce(function, iterable[, initializer])

从左到右，将两个参数的函数累积应用于iterable项，从而将iterable减少到一个值。例如,减少(λx, y: x + y,[1、2、3、4、5))计算((((1 + 2)+ (3)+ 4)+ 5)。左边的参数x是累积值，右边的参数y是来自iterable的更新值。如果存在可选初始化器，则将其放在计算中iterable的项之前，并在iterable为空时作为默认值。如果没有提供初始化器，且iterable只包含一个项，则返回第一个项。约等:

def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
    try:
        initializer = next(it)
    except StopIteration:
        raise TypeError('reduce() of empty sequence with no initial value')
accum_value = initializer
for x in it:
    accum_value = function(accum_value, x)
return accum_value

reload(module)

重新加载以前导入的模块。该参数必须是一个模块对象，因此之前必须成功导入它。如果您使用外部编辑器编辑了模块源文件，并且希望在不离开Python解释器的情况下尝试新版本，那么这将非常有用。返回值是模块对象(与模块参数相同)。
执行重载(模块)时:
Python模块代码被重新编译，模块级代码被重新执行，定义一组新的对象，这些对象绑定到模块字典中的名称。扩展模块的init函数不会被第二次调用。
与Python中的所有其他对象一样，旧对象只有在它们的引用计数降为零之后才会被回收。模块名称空间中的名称被更新为指向任何新的或更改的对象。
对旧对象的其他引用(例如模块外部的名称)不是回跳以引用新对象，如果需要，必须在每个出现新对象的名称空间中进行更新。
还有一些其他的注意事项:
当加载模块时,它的字典(包含模块抯全局变量)被保留。名称的重新定义将覆盖旧的定义，所以这通常不是问题。如果模块的新版本没有定义由旧版本定义的名称，则保留旧定义。这一特性可用于模块抯优势维持全球表或对象缓存试试语句测试表存在,可以跳过它如果需要初始化:

try:
cacheexcept NameError:
cache = {}

通常，重新加载内置或动态加载的模块不是很有用。不建议重新加载sys、main_、内置程序和其他关键模块。在许多情况下，扩展模块的初始化设计不超过一次，并且在重新加载时可能以任意方式失败。如果一个模块使用from import从另一个模块导入对象，那么为另一个模块调用reload()不会重新定义从它导入的对象。如果一个模块实例化了一个类的实例，那么重新加载定义该类的模块不会影响它们继续使用旧类定义的实例的方法定义。派生类也是如此。

repr(object)

返回包含对象可打印表示形式的字符串。这与转换(反引号)产生的值相同。有时，能够以普通函数的形式访问这个操作是有用的。对于许多类型,这个函数试图返回一个字符串,将产生一个对象具有相同的价值传递给eval(),否则表示是用尖括号括起来的字符串,它包含的类型对象的名称加上额外的信息通常包括对象的名称和地址。类可以控制这个函数的

retreversed(seq)

返回一个反向迭代器。seq必须是一个对象，该对象具有一个……reversed__()方法或支持序列协议(具有从0开始的整数参数的……len__()方法和……getitem__()方法)。
新版本2.4。
在2.6版中进行了更改:增加了编写定制的……reversed__()方法的可能性。

round(number[, ndigits])

返回浮点值number四舍五入到小数点后的ndigits。如果省略ndigit，它默认为零。结果是一个浮点数。值四舍五入到最接近的10的幂减ndigit的倍数;如果两个倍数相等，则四舍五入是在离0很远的地方完成的(例如，round(0.5)是1.0,round(-0.5)是-1.0)。注意，round()对于浮点数的行为可能令人惊讶:例如，round(2.675, 2)给出的是2.67，而不是预期的2.68。这不是一个错误:它抯大多数十进制分数的结果可以抰一样一个浮点数表示。有关更多信息，请参见浮点运算:问题和限制。

class set([iterable])

返回一个新的set对象，可选地使用iterable中的元素。set是一个内置类。有关该类的文档，请参阅set和set Types—set, frozenset。
对于其他容器，请参阅内置的frozenset、list、tuple和dict类，以及collections模块。
新版本2.4。

setattr(object, name, value)

这是getattr()的对应项。参数是一个对象、一个字符串和一个任意值。字符串可以命名现有属性或新属性。如果对象允许，函数将该值赋给属性。例如，setattr(x， ‘foobar’， 123)等于x。foobar = 123。

class slice(stop)

class slice(start, stop[, step])

返回一个切片对象，该对象表示range(start、stop、step)指定的一组索引。start和step参数默认为None。Slice对象具有只读数据属性start、stop和step，这些属性只返回参数值(或它们的默认值)。它们没有其他显式的功能;然而，它们被Numerical Python和其他第三方扩展使用。当使用扩展索引语法时，还会生成Slice对象。例如:a[start:stop:step]或a[start:stop, i]。有关返回迭代器的替代版本，请参见itertools.islice()。

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

从iterable中的项返回一个新的排序列表。可选参数cmp、key和reverse与list.sort()方法的参数具有相同的含义(在可变序列类型一节中进行了描述)。cmp指定一个由两个参数(迭代元素)组成的自定义比较函数，根据第一个参数是小于、等于还是大于第二个参数，该函数应该返回一个负数、零还是正数:cmp=lambda x,y: cmp(x.lower()， y.lower())。默认值是None。key指定一个参数的函数，用于从每个列表元素中提取一个比较键:key=str.lower。默认值是None(直接比较元素)。reverse是一个布尔值。如果将列表元素设置为True，则列表元素的排序方式与每个比较的顺序相反。通常，键和反向转换过程比指定等效的cmp函数要快得多。这是因为cmp对每个列表元素调用多次，而键和反向触摸每个元素仅一次。使用functools.cmp_to_key()将旧式cmp函数转换为key函数。内置的sort()函数保证是稳定的。排序是稳定的，如果它保证不改变比较相等的元素的相对顺序，这有助于在多个遍历中排序(例如，按部门排序，然后按工资级别排序)。有关排序示例和简短的排序教程，请参见如何排序。新版本2.4。

staticmethod(function)

返回函数的静态方法。
静态方法不接受隐式的第一个参数。要声明一个静态方法，可以使用这个习语:

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

@staticmethod表单是一个函数装饰器——详细信息请参阅函数定义中的函数定义描述。
它可以在类(如C.f())上调用，也可以在实例(如C().f()上调用。除了类之外，实例将被忽略。
Python中的静态方法类似于Java或c++中的方法。另请参阅classmethod()，以了解用于创建替代类构造函数的变体。
有关静态方法的更多信息，请参阅标准类型层次结构中关于标准类型层次结构的文档。
新版本2.2.在2.4版中更改:添加了函数装饰器语法。

class str(object=’’)

返回一个包含对象的可打印表示形式的字符串。对于字符串，这将返回字符串本身。与repr(object)不同的是，str(object)并不总是试图返回eval()可以接受的字符串;它的目标是返回一个可打印的字符串。如果没有给出参数，返回空字符串，”。有关字符串的更多信息，请参见序列类型str、unicode、list、tuple、bytearray、buffer、描述序列功能的xrange(字符串是序列)，以及String methods部分中描述的特定于字符串的方法。要输出格式化字符串，请使用模板字符串或字符串格式化操作节中描述的%操作符。此外，请参见String Services部分。参见unicode ()。

sum(iterable[, start])

和开始，从左到右迭代的项，并返回总数。start默认值为0。iterable抯项目通常是数字,开始值不能是一个字符串。
对于某些用例，sum()有很好的替代方法。连接字符串序列的首选快速方法是调用“.join(sequence)”。要添加具有扩展精度的浮点值，请参见math.fsum()。要串联一系列迭代器，可以考虑使用itertools.chain()。
新版本2.3

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

返回一个代理对象，该对象将方法调用委托给类型的父类或同级类。这对于访问已在类中重写的继承方法非常有用。搜索顺序与getattr()使用的顺序相同，只是跳过了类型本身。类型的_mro__属性列出getattr()和super()使用的方法解析搜索顺序。该属性是动态的，可以在更新继承层次结构时更改。如果省略第二个参数，返回的超对象将被解除绑定。如果第二个参数是一个对象，isinstance(obj, type)必须为真。如果第二个参数是类型，issubclass(type2, type)必须为真(这对于类方法很有用)。注意super()只适用于新样式的类。super有两个典型的用例。在单继承的类层次结构中，可以使用super引用父类而不显式地命名它们，从而使代码更易于维护。这种用法与super在其他编程语言中的用法非常相似。第二个用例是支持动态执行环境中的协作多重继承。这个用例是Python特有的，在静态编译语言或只支持单继承的语言中是找不到的。这使得它可以实现揹iamond图在多个基类实现相同的方法。好的设计要求该方法在每种情况下都具有相同的调用签名(因为调用的顺序在运行时确定，因为该顺序适应类层次结构中的更改，而且该顺序可以包含运行时之前未知的同级类)。对于这两个用例，一个典型的超类调用是这样的:

class C(B):
def method(self, arg):
    super(C, self).method(arg)

注意，super()是作为绑定过程的一部分实现的，用于显式点状属性查找，如super(). getitem_(name)。它通过实现自己的_getattribute__()方法来实现这一点，该方法用于按照支持协作多重继承的可预测顺序搜索类。因此，对于使用语句或super()[name]等操作符进行隐式查找，super()是未定义的。还要注意super()并不仅限于在内部方法中使用。这两种参数形式精确地指定参数并提供适当的引用。有关如何使用super()设计协作类的实用建议，请参阅使用super()指南。新版本2.2。

tuple([iterable])

返回一个元组，其中的项与可迭代项相同，且顺序相同。iterable可以是序列、支持迭代的容器或iterator对象。如果iterable已经是一个元组，那么它将不加更改地返回。例如，tuple(‘abc’)返回(‘a’， ‘b’， ‘c’)， tuple([1,2,3])返回(1,2,3)。元组是一种不可变的序列类型，在序列类型str、unicode、list、tuple、bytearray、buffer和xrange中都有记录。对于其他容器，请参阅内置的dict、list、set类和collections模块。

class type(object)

class type(name, bases, dict)

使用一个参数，返回对象的类型。返回值是一个类型对象。建议使用isinstance()内置函数来测试对象的类型。
使用三个参数，返回一个新类型对象。这本质上是类语句的一种动态形式。名称字符串是类名，并成为_name__属性;基元组逐项列出基类并成为_bases__属性;dict字典是包含类主体定义的命名空间，并成为了_dict__属性。例如，下面两个语句创建相同的语句:

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

新版本2.2。

unichr(i)

返回一个字符的Unicode字符串，该字符的Unicode代码是整数i。例如，unichr(97)返回字符串u’a’。这是Unicode字符串的ord()的倒数。参数的有效范围取决于Python是如何配置的——它可以是UCS2 [0…0xFFFF]或UCS4 [0…0x10FFFF]。否则将引发ValueError。有关ASCII和8位字符串，请参见chr()。
新版本2.0。

unicode(object=’’)

unicode(object[, encoding[, errors]])

使用以下模式之一返回对象的Unicode字符串版本:如果给定编码和/或错误，Unicode()将解码对象，该对象可以是8位字符串，也可以是使用codec编码的字符缓冲区。编码参数是给出编码名称的字符串;如果不知道编码，则引发LookupError。根据错误进行错误处理;这指定了对输入编码中无效字符的处理。如果错误是“严格的”(默认值)，则错误将引发ValueError，而“忽略”值将导致错误被无声地忽略，而“替换”值将导致使用官方Unicode替换字符U+FFFD来替换无法解码的输入字符。参见编解码器模块。如果没有提供可选参数，unicode()将模拟str()的行为，只是它返回unicode字符串而不是8位字符串。更准确地说，如果对象是Unicode字符串或子类，它将返回该Unicode字符串，而不应用任何附加的解码。对于提供了_unicode__()方法的对象，它将不带参数地调用该方法来创建Unicode字符串。对于所有其他对象，将请求8位字符串版本或表示形式，然后在“严格”模式下使用编码解码器将其转换为Unicode字符串。有关Unicode字符串的更多信息，请参见序列类型str、Unicode、list、tuple、bytearray、buffer、xrange，其中描述了序列功能(Unicode字符串是序列)，以及String methods部分中描述的特定于字符串的方法。要输出格式化字符串，请使用模板字符串或字符串格式化操作节中描述的%操作符。此外，请参见String Services部分。参见str ()。
新版本2.0。
在版本2.2中进行了更改:添加了对……unicode__()的支持。

vars([object])

返回模块、类、实例或任何其他具有* * 属性的对象的 * *属性。
模块和实例等对象具有可更新的_dict__属性;但是，其他对象可能对它们的_dict__属性有写限制(例如，新样式的类使用dictproxy来阻止直接的字典更新)。
没有参数，vars()就像local()一样。注意，局部字典只对读取有用，因为对局部字典的更新将被忽略。

xrange(stop)

xrange(start, stop[, step])

这个函数与range()非常相似，但是返回一个xrange对象而不是一个列表。这是一个不透明的序列类型，它生成与相应列表相同的值，但实际上并不同时存储它们。xrange()的优势范围()是最小的(因为xrange()仍有创建值要求时),只有当一个非常大的范围是用于发生在内存食紧机或当所有范围的元素是从未使用过(如当循环通常与打破终止)。有关xrange对象的更多信息，请参见xrange类型和序列类型str、unicode、list、tuple、bytearray、buffer、xrange。CPython实现细节:xrange()旨在简单而快速。实现可能会为此施加限制。Python限制所有参数的C实现本机C多头(搒长的矮Python整数),也需要适合的元素数量在原生C长。如果需要更大的范围，可以使用itertools模块创建一个替代版本:islice(count(start, step)， (stop-start+step 1+2*(step<0))//step)。

zip([iterable, …])

这个函数返回一个元组列表，其中第i元组包含来自每个参数序列或迭代器的第i个元素。返回列表的长度被截断为最短参数序列的长度。当有多个长度相同的参数时，zip()类似于map()，初始参数为None。使用一个序列参数，它返回一个由1元组组成的列表。没有参数时，它返回一个空列表。保证了迭代器从左到右的计算顺序。这使得使用zip(*[iter(s)]n)将数据序列聚类成n个长度组的习惯用法成为可能。zip()可以与操作符一起用于解压缩列表:

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

新版本2.0。
在2.4版中进行了更改:以前，zip()至少需要一个参数，而zip()会引发一个类型错误，而不是返回一个空列表。

import(name[, globals[, locals[, fromlist[, level]]]])

注意，与importlib.import_module()不同，这是一个高级函数，在日常Python编程中并不需要。这个函数由import语句调用。为了改变import语句的语义，可以替换它(通过导入_builtin__模块并将其赋值为_builtin_ . import_)，但是现在使用import钩子通常更简单(见PEP 302)。直接使用……import__()是很少见的，除非您想导入一个模块，而这个模块的名称只有在运行时才知道。该函数导入模块名称，可能使用给定的全局变量和局部变量来确定如何在包上下文中解释该名称。fromlist给出了应该从按名称提供的模块中导入的对象或子模块的名称。标准实现根本不使用它的局部变量参数，只使用它的全局变量来确定import语句的包上下文。level指定是使用绝对导入还是相对导入。默认值是-1，表示将尝试绝对导入和相对导入。0表示只执行绝对导入。level的正值表示要搜索的父目录的数量，这些父目录相对于调用_import__()的模块的目录。当name变量属于表单包时。通常，返回顶层包(直到第一个点的名称)，而不是按名称命名的模块。但是，当给出非空fromlist参数时，将返回按名称命名的模块。
传入参数’spam’的代码结果如下:

spam = __import__('spam', globals(), locals(), [], -1)

.

spam = __import__('spam.ham', globals(), locals(), [], -1)

.

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)eggs = _temp.eggssaus = _temp.sausage

这里的apam.ham模块从import__()返回。从该对象中检索要导入的名称，并将其分配给各自的名称。
如果只想按名称导入模块(可能是在包中)，请使用importlib.import_module()。
版本2.5中更改:添加了level参数。
在2.5版中进行了更改:添加了对参数的关键字支持。

次要的内部函数

有几个内置函数不再是学习、了解或在现代Python编程中使用的必要函数。它们被保存在这里是为了维护与为旧版本Python编写的程序的向后兼容性。
Python程序员、培训人员、学生和图书作者应该可以自由地绕过这些函数，而不必担心遗漏一些重要的东西。

apply(function, args[, keywords])

函数参数必须是一个可调用的对象(用户定义的或内置的函数或方法，或类对象)，args参数必须是一个序列。以args作为参数列表调用函数;参数的数量是元组的长度。如果出现可选关键字参数，则它必须是一个键为字符串的字典。它指定要添加到参数列表末尾的关键字参数。调用apply()不同于仅仅调用function(args)，因为在这种情况下总是只有一个参数。apply()的使用相当于function(*args， **keywords)。从2.3版开始就不推荐:使用function(*args， **keywords)而不是apply(function, args, keywords)(参见解包参数列表)。

buffer(object[, offset[, size]])

对象参数必须是支持缓冲区调用接口的对象(例如字符串、数组和缓冲区)。将创建一个引用对象参数的新缓冲区对象。缓冲区对象将是对象开头的一个切片(或指定偏移量的切片)。切片将扩展到对象的末尾(或者具有由size参数给出的长度)。

coerce(x, y)

返回一个元组，该元组由转换为公共类型的两个数值参数组成，使用与算术运算相同的规则。如果无法强制，则引发类型错误。

intern(string)

在带字符串表中输入字符串，并返回带字符串本身或副本。如果对字典中的键进行了Interning，并且对查找键进行了interned，那么键比较(散列之后)可以通过指针比较而不是字符串比较来完成，那么对字符串进行Interning对提高字典查找的性能很有用。通常情况下，Python程序中使用的名称是自动链接的，用于保存模块、类或实例属性的字典具有链接键。
在2.3版中进行了更改:中间字符串不是不朽的(就像以前在Python 2.2中一样);您必须保留对intern()返回值的引用，以便从中获益.