Showing posts with label pythonlib. Show all posts
Showing posts with label pythonlib. Show all posts

15 Nov 2010

Python标准库手册 - 4.1 site模块引入的常量


4.1. site模块添加的常量



site模块(启动时会自动导入,除非指定命令行参数-S)添加了一些常量给内置命名空间.它们对于交互式解释环境很有帮助,而且不应该在程序中被使用.



quit([code=None])
exit([code=None])
    当对象被打印时,打印出类似于"使用quit()或Ctrl-D(例如EOF)退出"的信息,被调用时,使用指定的退出code抛出SystemExit异常.

copyright
license
credits
    当对象被打印时,打印出类似于"输入license()查看全部许可内容"的信息,被调用时,用纸张模式显示相应的文字(一次打印一屏).
    


<<4. 内置常量    >>目录    >>5. 内置类型
    



Python标准库手册 - 4. 内置常量


4. 内置常量



    内置的命名空间仅有几个常量,它们是:
    
False
    布尔类型的"假"值
    2.3版本新增
    


True
    布尔类型的"真"值
    2.3版本新增
    
None
    types.NoneType的唯一值.None经常被用来表示值的缺失,当默认参数并未传递给一个函数时.
    2.4版本改动:为None赋值是非法的,并会抛出SyntaxError异常.
    
NotImplemented
    特殊方法"富比较"(rich comparison)(__eq__(), __lt__(), 和friends)可以返回的特殊值,用以表示对给定类型的指定比较方式并未被做实.

Ellipsis
    与扩展切片语法连用的特殊值.

__debug__
    此常量值为True如果Python没有以-0参数启动.参考assert语句.
    
注意
    名称None和__debug__无法被赋值(甚至当做参数名称也不行,抛出SyntaxError),因此他们可被认为是True常量.
    2.7版本改动:当做参数名称对__debug__赋值变为非法.



<<2. 内置函数 - 3 & 3. 次要内置函数    >>目录    >>4.1: site模块添加的常量
    



7 Dec 2009

Python标准库手册 - 2. 内置函数 - 3 & 3. 次要内置函数

2. 内置函数 - 3:S-Z



set([iterable])
    返回一个新集合,元素来自可选参数iterable.set类型在集合类型中有描述 - set, frozenset.
   
    其他容器请参看内置dict,list,tuple类和collections模块.
    2.4版本新增

setattr(object, name, value)
    这是getattr()的对应函数.参数分别是对象,字符串和任意值.字符串可能是一个已有属性或者新的属性.如果object允许,此函数会将value指定给对应属性.例如setattr(x, 'foobar', 123)等价于x.foobar = 123.

slice([start], stop[, step])
    返回由range(start, stop, step)指定的索引集合表示的切片对象.start和step参数默认为None.切片对象含有只读数据属性start, stop和step,它们仅仅返回参数值(或者默认值),而无其他明确的功能;然而它们被Numerical Python和其他第三方扩展使用.扩展索引语句也会生成切片对象.例如: a[start:stop:step]或者a[start:stop, i].参考返回迭代器的替代版本itertools.islice().



sorted(iterable[, cmp[, key[, reverse]]])
    根据iterable的元素,返回一个排过序的新列表.
   
    可选参数cmp, key和reverse与list.sort()方法的参数意义相同(在可变序列类型一节有描述).
   
    cmp指定一个个性化的2参数(迭代器元素)的比较函数,该函数根据第一个参数小于,等于或者大于第二个参数返回负数,0或者正数: cmp=lambda x,y: cmp(x.lower(), y.lower()).默认值是None.
   
    key指定一个从每个列表元素提取比较键值的单参数函数: key=str.lower.默认值为None.
   
    reverse是一个布尔值.如果为True,列表元素的排序会把每次比较都颠倒.
   
    总的来说,key和reverse转换过程比指定一个等价的cmp函数快得多.这是因为对每个列表元素cmp会被多次调用,而key和reverse仅访问每个元素一次.转换老式cmp函数为key函数,请参考ASPN食谱-CmpToKey偏方.
    2.4版本新增

staticmethod(function)
    返回function的静态方法.
   
    静态方法不接受隐含第一参数.采用如下方式定义一个静态方法:
    
    class C:
        @staticmethod
        def f(arg1, arg2, ...): ...


    @staticmethod形式是函数修饰符 - 参看函数定义一节详细描述.

    它可被类(C.f())或者实例(C().f())调用.实例会被忽略.
   
    Python的静态方法与Java或者C++类似.高级概念参看本节classmethod().
   
    更多信息请参考标准类型层次的文档.

    2.2版本新增.
    2.4版本改动:增加函数修饰符.


str([object])
    返回表示object可美观打印的描述字符串.对于字符串对象,返回字符串本身.与repr(object)的不同在于,str(object)不会总尝试返回可被eval()接受的字符串;它的目标是返回一个可打印字符串.如果没有参数,返回空字符串''.
   
    关于字符串更多信息参看序列类型功能描述(字符串也是序列) - str, unicode, list, tuple, buffer, xrange,或者字符串方法一节描述的字符特殊方法.使用模板字符串或者%操作符(字符串格式化操作章节)输出格式化字符串.另外也可参考字符串服务章节,或者unicode().
   
sum(iterable[, start])
    从start开始,对iterable的所有元素从左至右求和,并返回.start默认值为0.iterable的元素一般为数字,不能为字符串.快速正确的字符串序列连接方法是调用''.join(sequence).注意sum(range(n), m)等价于reduce(operator.add, range(n), m).浮点值扩展精度加法参考math.fsum().
    2.3版本新增
   
super(type[, object-or-type])
    返回一个调用type父类或者胞类的方法的代理对象.在访问类中被重载的继承方法时很有用.搜索顺序与getattr()相同,但是type本身会被跳过.

    type的__mro__属性列出getattr()和super()使用的方法判定搜索顺序.这个属性是动态的,且继承层次更新时会被改变.
   
    如果第二个参数省略,返回的super对象是非绑定的.如果第二参数是object, isinstance(obj, type)必须为真.如果第二个参数是一个type, issubclass(type2, type)必须为真(类方法很有用).

    注意:
    super()只对新式类有效.
   
    super有2个典型应用.单重继承的类层次,super可以不用明确指明名称指代父类,得以提高代码的可维护性.这种用法跟其他编程语言的super极为相似.
   
    第二种用法在动态执行环境下支持合作多重继承.这种用法仅在python中有,绝对不会在静态编译语言或者只支持单重继承的语言中发现.这样让实现"钻石图"成为可能 - 多个基类做实同一个方法.好的设计让这个方法在各种情况下有相同的调用签名(由于调用顺序在执行时被确定,也由于顺序适应类层次的改变,还由于顺序包含在运行之前不知道的兄弟类).
   
    两种情况下,典型的超类调用如下:
    
    class C(B):
        def method(self, arg):
            super(C, self).method(arg)
    

   
    注意super()做实为显式点属性查找绑定过程的一部分,例如super().__getitem__(name).它做实自己的__getattribute__()方法以可预知的,支持合作多重继承的顺序来搜索类.相应的,对于使用语句或者操作符的形如super()[name]的隐式查找,super()并未定义.
   
    还要注意,super()不仅限于用作内部方法.两个参数的形式指明了参数并且做了恰当的引用.
    2.2版本新增

tuple([iterable])
    返回一个元组,其元素与iterable元素相同且有相同的顺序.iterable可能是序列,支持迭代的容器,或者一个迭代对象.如果iterable已经是tuple,不做任何修改返回它.例如,tuple('abc')返回('a','b','c'),tuple([1,2,3])返回(1,2,3).如果未指定参数,返回新的空元组, ().
   
    元组是不可变序列类型,在序列类型中有文档 - str, unicode, list, tuple, buffer, xrange.其他容器参看内置类dict, list,set和collections模块.

type(object)
    返回对象的类型.返回值是类型对象.推荐使用内置函数isinstance()来测试对象的类型.
   
    下面会介绍含有3个参数的type()函数作为构建器使用.

type(name, bases, dict)
    返回一个新的类型对象.这是类语句本质上的动态形式.name字符串是类名,会变成__name__属性;bases元组逐条列出基类,会变成__bases__属性;dict字典是包含类体定义的命名空间,会变成__dict__属性.例如,如下的2条语句创建了相同的类型对象:
    
    >>> class X(object):
    ...     a = 1
    ...
    >>> X = type('X', (object,), dict(a=1))
    

    2.2版本新增

unichr(i)
    返回unicode码是整数i的字符的unicode字符串.例如,unichr(97)返回字符串u'a'.对于unicode字符串,这是ord()函数的逆函数.参数的有效范围基于python如何配置 - 可能是UCS2 [0..0xFFFF]或者UCS4 [0..0x10FFFF].否则抛出ValueError异常.对于ASCII和8位字符串参看chr().
   
    2.0版本新增

unicode([object[, encoding[, errors]]])
    根据下面的模式,返回object的unicode字符串版本:
    如果encoding和/或者error该出,unicode()将使用encoding的解码器对克表示为8位字符串或者字符缓冲区的object解码.encoding参数是一个字符串,它指定了编码的名称;如果是未知的encoding会抛出LookupError异常.异常处理机制会根据errors处理异常;它指定了输入编码字符无效时的处理方式:如果errors是'strict'(默认)会抛出ValueError异常;如果是'ignore'则忽略;'replace'会使用官方unicode替换字符U+FFFD替换不能被编码的输入字符.参考codecs模块.

    如果没有给出可选参数,unicode()的行为类似str(),区别是返回的是Unicode字符串而非8位字符串.明确点说就是,如果对象是Unicode字符串或其子类,将会返回Unicode字符串,而不会附加任何编解码.

    对于提供了__unicode__()方法的对象,会直接无参数呼叫这个函数创建一个unicode字符串.对于其他对象,则请求一个8位字符串版本或者描述,然后使用默认编码器并以'strict'模式转换为unicode字符串.

    关于unicode字符串的更多信息,请参看描述序列功能的序列类型-str(字符串),unicode,list(列表),tuple(元组),buffer,xrange(unicode字符串也是序列),也可以参考字符串方法一节具体关于字符串的方法.为了输出格式化字符串,可以使用字符串格式化操作符一节提供的模板字符串或者%操作符方法,也可参考字符串服务一节.参考str().

    2.0版本新增
    2.2版本改动: 支持__unicode__().


vars([object])
    没有参数时,类似locals().

    如果指定参数为模块,类或者类实例对象(或其他拥有__dict__属性的对象),返回其属性.

    注意:
    返回的字典不可编辑: 对相应的符号表的影响未定义.(目前的实现中,局部变量绑定一般不会被如此影响,但从其他作用域(例如模块)获得的变量会受此影响.可能将来版本会有改变.)

xrange([start], stop[, step])
    本函数非常类似range(),但是返回一个"xrange"对象而非列表.这是一个不明序列类型,与相应的列表有相同的值,但是并非同时储存这些值.与range()相比,一般情况下xrange()的优势很小(由于xrange()仍然需要在请求值时创建这些值),除非请求的range范围极大而机器内存有限;或者并非所有range的元素会被使用(例如一个循环可能被中途break跳出).

    CPython实现细节: xrange()是简单而快速的.实现可能添加了一些约束来达到此目的.Python的C实现约定所有参数都是原生C的long类型(python的short整型),并要求元素的个数也满足原生C的long类型.如果需要更大的范围,可以使用itertools模块来提供一个代替版本: islice(cout(start,step),(stop-start+step-1)//step).

zip([iterable, ...])
    本函数返回一个列表或元组,其中第i个元组包含每个序列或迭代器参数的第i个元素.返回的列表长度会被截断与最短的序列参数等长.当多个等长参数,zip()与初值参数为None的map()非常类似.如果只有一个序列参数,返回仅含一个元组的列表.如果没有参数,返回一个空列表.

    迭代器按照从左至右顺序赋值,因此可以使用此函数将一系列数据聚类为长度为n的群: zip(*[iter(s)]*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()要求至少一个参数,如果没有指定参数,会抛出TypeError异常而非返回空列表.


__import__(name[, globals[, locals[, fromlist[, level]]]])
    注意:
    这是一个高级函数,日常Python编程不会用到.
   
    本函数会被import声明调用.它可被替代以改变import声明的语义(导入内置模块并指定builtins.__import__),但如今使用import钩子很容易(参考PEP302).直接使用__import__()很少见,除非你想导入一个模块,而此模块的名称仅在运行时可知).
   
    本函数导入模块name,后台使用给定的globals和locals来决定如何解释包里面名称.fromlist指定了需要从name模块中导入的对象或者子模块的名称.标准的实现根本不会使用locals参数,仅使用globals来决定import声明的包内容.

    level指定了使用绝对或者相对导入.默认值为-1,表示绝对和相对导入都会被尝试.0表示仅使用绝对导入.正值表示相对呼叫__import__()的模块的路径需要搜索的父路径数目.

    当name变量形式为package.module,一般的,顶层package(点之前的名称)被返回,而非name指定的模块.但是,如果给出非空参数fromlist,name指定的模块被返回.

    例如,语句import spam返回的字节码类似于下面的代码:
    
    spam = __import__('spam', globals(), locals(), [], -1)
    


    而语句import spam.ham的结果
    
    spam = __import__('spam.ham', globals(), locals(), [], -1)
    


    注意:为何这儿__import()返回顶层模块,由于此模块被import语句绑定了一个名称.

    另一方面,语句from spam.ham import eggs, sausage as saus的结果如下:
    
    _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
    eggs = _temp.eggs
    saus = _temp.sausage
    


    这儿,spam.ham模块被__import__()返回,待导入的名称从此对象获取并指定为相应的名称.
   
    如果你仅仅想简单使用name导入一个模块(在一个包中),可以呼叫__import__()然后查看sys.modules:
    
    >>> import sys
    >>> name = 'foo.bar.baz'
    >>> __import__(name)
    <module 'foo' from ...>
    >>> baz = sys.modules[name]
    >>> baz
    <module 'foo.bar.baz' from ...>
    


    2.5版本新增: 添加level参数; 参数支持关键字.

3. 非必要内置函数



现代的Python编程时有一些内置函数不再需要学习,使用甚至知道.保留于此仅为了保持向后兼容那些使用老版本python写的程序.

Python程序员,培训人员,学生和书籍作者可以直接跳过这些函数而不用考虑是否错过了某些重要的东西.

apply(function, args[, keywords])
    function参数必须是一个可被调用的对象(用户指定或内置函数或者方法,或者一个类对象),args参数必须是一个序列.以args作为参数列表呼叫function函数,参数对象是元组的长度.如果可选参数keywords指定,必须是一个字典并且字典的键值都是字符串.它指定了要被附加到参数列表末尾的关键字参数.呼叫apply()与直接呼叫function(args)是不同的,由于直接呼叫永远都有且仅有一个参数,而apply()相当于呼叫function(*args,**keywrods).

    2.3版本改动: 使用扩展呼叫语法 *args和**keywords.

buffer(object[, offset[, size]])
    object参数必须是支持buffer呼叫接口的对象(例如字符串,数组和buffer).根据对象的参数会创建一个新的buffer对象,该对象是从object对象的开始(或者offset指定的偏移)的切片.切片会扩展到object对象的结尾(或者size参数指定的长度).

coerce(x, y)
    返回一个元组,包含2个数值元素并使用与数学操作符相同的规则转换为一个普通类型.如果无法执行coerce操作,抛出TypeError异常.

intern(string)
    将string输入被interned的字符串的表中兵返回该字符串-返回字符串本身或者其拷贝.此方法在字典查找时略有小小的性能提高-如果字典的键值被interned,同时待查找的键值也被interned,键值比较(哈希之后)会使用指针比较而非字符串比较.一般的,Python中使用的名称都被自动interned,字典被用来保持模块,类或者实例属性拥有interned键值.
   
    2.3版本改动:interned字符串不再被长期保存(像2.2版本及之前的版本中那样);你必须保存intern()返回值的参考以从此方法中得到便利.



<<2. 内置函数-2:I-R    >>目录    >>4. 内置常量
    


Python标准库手册 - 2. 内置函数 - 2

2. 内置函数 - 2: I-R



id(object)
    返回object的标识符.结果是整型(或者长整型),在其生命周期内保证唯一且不变.2个生命周期不重叠的对象可能含有相同的id()值.

    CPython实现细节:这是object的地址.

input([prompt])
    等价于eval(raw_input(prompt))
    
    警告:
    如果用户输入错误,此函数并不安全!它要求一个合法的Python表达式作为输入;如果输入有语法错误,会抛出SyntaxError异常.当执行时,其他异常也可能被抛出.(另一方面,高级用户写快速脚本是正想得到如此的结果?)
    
    如果导入了readline模块,input()会使用它来提供详尽的行编辑和历史功能.
    通常情况下应考虑使用raw_input()函数.
    
int([x[, base]])
    将一个字符串或者数字转换为整型.如果参数是字符串,必须包含能被表示为Python整型的十进制符号数,该字符串可被嵌入白空格.base参数为转换提供了基(默认是10),它可能是属于[2,36]的任意整数或者0.如果base是0,取决于字符串的内容,会检测一个合适的基;表现形式与整型相同.(参考数值)如果base存在且x不是字符串,会抛出TypeError异常.否则参数可能是整型或者长整型或者浮点数.浮点数转换成整型会被截尾(向0).如果参数超出整型范围会返回一个长整型对象.如果不指定参数,返回0.
    
    整数类型在数值类型一节有描述 - int, float, long, complex.



isinstance(object, classinfo)
    如果object参数是classinfo参数的实例,或者是它的(直接或者间接)子类返回true.如果classinfo是一个类型对象(新型类)且object是该类型的对象或者(直接或间接)子类,也会返回true.如果object不是类实例或者给定类型的对象,返回false.如果classinfo既非类对象也非类型对象,它可能是类对象或者类型对象的元组,或者递归包含其他类似元组(其他序列类型不可被接受).如果classinfo不是类,类型,也不是类或类型等这些元组,会抛出TypeError异常.
    
    2.2版本改动:支持类型信息元组.
    
issubclass(class, classinfo)
    如果class是classinfo的(直接或间接)子类返回true.任何类都是自身的子类.classinfo可以使类对象的元组,此时classinfo的每个元素都会执行检测.其他情况下,会抛出TypeError异常.
    
    2.3版本改动:支持类型信息元组.
    
iter(o[, sentinel])
    返回一个迭代对象.根据第二个参数的不同,第一个参数会有不同的解释.如果没有第二个参数,o必需是一个支持迭代协议(__iter__()方法)的对象集合,或者必需支持序列协议(从0开始的整型参数的__getitem()方法).如果它不支持这两种协议,会抛出TypeError异常.如果第二个参数sentinel给出,那么o必须是一个可调用的对象.此时迭代器创建时会无参数调用它的next()方法;如果返回结果等于sentinel,会抛出StopIteration异常,否则返回该结果.
    
    非常有用的iter()第二种形式应用是按行读取一个文件,直至某一特定行.下面的例子按行读取一个文件,直到读到'STOP':
    
    with open("mydata.txt") as fp:
        for line in iter(fp.readline, "STOP"):
            process_line(line)
    

    2.2版本新增

len(s)
    返回一个对象的长度(元素的数目).参数必须是一个序列(字符串,元组或者列表)或者映射(字典).
    
list([iterable])
    返回一个列表,其元素与iterable相同且元素顺序相同.iterable可能是一个序列,支持迭代的容器或者一个迭代对象.如果iterable是一个列表,会拷贝一份返回,类似于iterable[:].例如list('abc')返回['a','b','c'],list((1,2,3))返回[1,2,3].如果未指定参数,返回一个空列表[].
    
    列表是一个可变序列类型,归档于序列类型 - str, unicode, list, tuple, buffer, xrange.其他容器请参考内置类dict, set和tuple, 和collections模块.
    
locals()
    更新并返回表示当前局部符号表的一个字典.在函数代码块内调用locals()会返回自由变量,但是类代码块内则不会.
    
    注意:
    该字典的内容不应被修改;改变可能不会影响local的值和解释器使用的自由变量.
    
long([x[, base]])
    将字符串或者数字转换为长整型.如果参数是字符串,必须包含任意大小的符号数,可能嵌入白空格.base参数的解释方式与int()相同,只有在x是字符串是才需要给出.否则,参数可以是整型,长整型或者浮点数,会返回相同值的长整型.浮点数转换为整型会向0截尾.如果没有参数,返回0L.
    
    长整型请参考数值类型 - int, float, long, complex.
    
map(function, iterable, ...)
    对iterable的每个元素应用function,并返回结果列表.如果有额外的iterable参数,function会同时取这些iterables的元素为参数执行.如果一个iterable长度小于另一个,默认会用None扩展为相同长度.如果function是None,默认使用恒等函数;如果有多个参数,map()返回一个有元组组成的列表,其中元组包含所有iterables的对应元素(类似于对应操作).iterable参数可以使序列或者其他迭代对象.结果永远是列表.(例子翻译时加的)例如:
    
    >>> a = [1,2,3]<br />    >>> b = ['a','b','c']<br />    >>> map(None,a,b)<br />    [(1, 'a'), (2, 'b'), (3, 'c')]<br />    


max(iterable[, args...][, key])
    如果仅有iterable参数,返回非空iterable的最大元素(例如字符串,元组和列表).多于一个参数时,返回其中最大的.
    
    可选参数key指定了一个形如list.sort()的单参数排序函数.如果给定key参数,必须用关键字形式(例如: max(a,b,c,key=func)).
    
    2.5版本改动:支持可选参数key.
    
min(iterable[, args...][, key])
    如果仅有iterable参数,返回非空iterable的最小元素(例如字符串,元组和列表).多于一个参数时,返回其中最小的.

    可选参数key指定了一个形如list.sort()的单参数排序函数.如果给定key参数,必须用关键字形式(例如: max(a,b,c,key=func)).

    2.5版本改动:支持可选参数key.
    
next(iterator[, default])
    调用iterator的next方法取得其下一个元素.如果default参数给定,如果iterator结束返回default,否则抛出StopIteration异常.
    
    2.6版本新增

object()
    返回一个新的对象.object是所有新型类的基础.它有所有新型类实例共有的方法.
    
    2.2版本新增.
    2.3版本改动:该函数不接受任何参数.以前版本可以传入参数,但是会被忽略.


oct(x)
    将整型数字(任意大小)转换为八进制字符串.结果是有效的Python表达式.
    
    2.4版本改动:以前只返回无符号数

open(filename[, mode[, bufsize]])
    打开一个文件,返回一个文件对象(文件对象一节有描述).如果文件不能打开,抛出IOError异常.当需要打开文件时,最好采用open()而非直接调用文件构建器.
    
    前2个参数与stdio的fopen()参数相同:filename是要打开文件名,mode是文件读写类型字符串.
    
    最常用的mode值是'r'-读和'w'-写(会覆盖已存在文件)和'a'-追加(在某些Unix系统上会无视当前位置直接追加到文件末尾).如果省略mode,默认是'r'.默认使用文本类型,当写回文件再读取时会将'\n'转换为平台相关的表示方法.因此,当打开二进制文件时,应该给mode添加'b'以使用二进制读写,这会增加可移植性.(即使在不区分二进制与文本文件而一概视为文档的系统上,添加'b'也是非常有用的)下面列出了mode参数的其他可取值.
    
    可选参数bufsize指定了缓冲区大小:0是无缓冲,1是行缓冲,其他整数则使用(近似)该数大小的缓冲区,负值bufsize则使用系统默认(tty设备是行缓冲,其他文件是全缓冲).如果省略,使用系统默认缓冲区大小.-脚注[2]

    模式'r+','w+'和'a+'可以更新文件(注意'w+'会覆盖文件).添加'b'模式可以在区别对待文本文件和二进制文件的系统上,以二进制方式打开文件;在无区别系统上,'b'不起作用.

    除标准fopen()的模式外,还有'U'或者'rU'.编译Python时通常有通用新行支持;'U'会以文本方式打开文件,但是行会以下列方式之一终止:Unix行结束标志'\n';Mac行结束标志'\r'或者Windows行结束标志'\r\n'.Python一律按照'\n'对待所有这些表示.如果Python编译时没有通用新行支持,'U'与普通文本模式相同.注意:以这种方式打开的文件对象也有一个叫新行的属性,其值为None(如果没有新行被读取),'\n','\r','\r\n'或者包含所有以读取的新行类型的元组.
    
    Python强制模式添加'U'后,以'r','w','a'开始.Python提供了许多文件处理模块,包含fileinput, os, os.path, tempfile和shutil.
    
    2.5版本改动:限定mode字符串的第一个字母.
    
ord(c)
    给定长度为1的字符串c,当是一个unicode对象或者当参数是一个8位字符串时是其字节值,返回表示其Unicode码的整数.例如,ord('a')返回整数97,ord(u'\u2020')返回8224.对于8位字符串,这是chr()的逆函数;对于unicode对象,则是unichr()的逆函数.如果python基于unicode UCS2编译且给定unicode参数,则该字符的码点必须在范围[0...65535],否则字符串长度是2,抛出TypeError异常.

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.(2.2版本新增负指数.2.1版本以前,如果2个参数均为整型且第二个参数为负,会抛出异常.)如果第二个参数是负数,第三个参数必须被省略.如果有参数z,x和y必须是整型且y非负.(2.2版本新增的限定.2.1版本之前,浮点3参数pow()函数会根据平台浮点数舍入规则,返回平台相关的结果.)
    
print([object, ...][, sep=' '][, end='\n'][, file=sys.stdout])
    打印object(s)到文件流,以sep分隔以end结束.sep,end,file参数如果有,必须以关键字形式给出.
    
    所有非关键字形式参数会被转换成字符串(如函数str()),以sep分隔end结束写入流.sep和end都必须是字符串,但也可以是None,这是使用默认值.如果object没有给出,print()写入end.
    
    file参数必须是一个有write(string)方法的对象;如果没有给出或者是None,使用sys.stdout.
    
    注意:
    一般情况下,由于print被认为是print语句,此函数不会被看做内置函数.为了禁用这个功能以使用print()功能,可以在模块顶部使用future语句:
    
    from __future__ import print_function


    2.6版本新增

property([fget[, fset[, fdel[, doc]]]])
    返回新类(从对象衍生出来的类)property属性.
    
    fget是获得属性值的函数,正如fset是设置属性值的函数,fdel是删除属性值的函数.典型用法是定义托管属性x:
    
    class C(object):<br />        def __init__(self):<br />            self._x = None<br /><br />        def getx(self):<br />            return self._x<br />        def setx(self, value):<br />            self._x = value<br />        def delx(self):<br />            del self._x<br />        x = property(getx, setx, delx, "I'm the 'x' property.")<br />    


    如果给出doc参数,必须是property属性的文档字符串.否则,property会拷贝fget的文档字符串(如果存在).这样可以用property()作为修饰符来创建只读属性:
    
    class Parrot(object):<br />        def __init__(self):<br />            self._voltage = 100000<br /><br />        @property<br />        def voltage(self):<br />            """Get the current voltage."""<br />            return self._voltage<br />    

    
    上述代码将voltage()方法转换为有相同名称的"getter"来获得只读属性.

    property对象含有getter, setter和deleter方法,可以用作修饰函数使用对应的存取函数创建property的拷贝.下面的例子是个极好的解释:
    
    class C(object):<br />        def __init__(self):<br />            self._x = None<br /><br />        @property<br />        def x(self):<br />            """I'm the 'x' property."""<br />            return self._x<br /><br />        @x.setter<br />        def x(self, value):<br />            self._x = value<br /><br />        @x.deleter<br />        def x(self):<br />            del self._x<br />    

    
    上面的代码与第一个例子完全相同,可以提供附加函数与原property函数相同的名称(上面例子中的x).
    
    返回的属性也包含fget, fset和fdel属性,这些属性与构建其参数相关.
    2.2版本新增.
    2.5版本改动: 如果没有文档字符串,则使用fget的文档字符串.
    2.6版本改动: 新增getter, setter和deleter属性.


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异常.例如:
    
    >>> range(10)<br />    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />    >>> range(1, 11)<br />    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]<br />    >>> range(0, 30, 5)<br />    [0, 5, 10, 15, 20, 25]<br />    >>> range(0, 10, 3)<br />    [0, 3, 6, 9]<br />    >>> range(0, -10, -1)<br />    [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]<br />    >>> range(0)<br />    []<br />    >>> range(1, 0)<br />    []


raw_input([prompt])
    如果prompt参数给出,它会被写到标准输出(末尾无新行),然后该函数会读取一行并转换为字符串作为输入(扔掉结尾的新行符)并返回该字符串.如果输入为EOF,抛出EOPError异常.例如:
    
    >>> s = raw_input('--> ')<br />    --> Monty Python's Flying Circus<br />    >>> s<br />    "Monty Python's Flying Circus"<br />    


    如果readline模块被加载,raw_input()会使用它来提供复杂的行编辑和历史功能.

reduce(function, iterable[, initializer])
    对iterable的元素,从左至右循环应用2个参数的function,最后得到一个值.例如,reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算((((1+2)+3)+4)+5).左参数x是累加值,右参数y是迭代的更新值.如果可选参数initializer给出,它会被作为迭代运算的初始值;如果iterable为空则作为默认值返回.如果initializer未给出且iterable仅包含一个元素,则返回该元素.
    
reload(module)
    重新加载一个已被导入的模块.参数必须是一个模块对象,它之前必须被成功导入过.当使用外部编辑器编辑过某个模块的源码,并且想在不离开python解释器的情况下试用新版本时,这个函数很有用.返回值是模块对象(与module参数相同)
    
    当reload(module)被执行时:
        * python模块代码被重新编译,模块级代码被重新执行,定义一个新的绑定到模块字典中名称的对象集合.扩展模块init函数不会被再次执行.
        * 如python中的所有其他对象,原有的对象仅在它们的为0计数时才会被回收.
        * 模块命名空间的名称会被更新以指向新增或改动的对象.
        * 其他旧对象的引用(例如模块之外的名称)不会重新绑定到新的对象,如有必要,它们必须在各自的命名空间被更新.

    其他警告:
    如果一个模块语法正确却初始化出错,第一次导入时会无法局部绑定名称,却会在sys.modules中产生一个(部分初始化的)模块对象.要重新载入该模块,必须再reload()之前先再次导入(会绑定名称到部分初始化的模块对象).

    当一个模块被重新载入,它的字典(包含模块的全局变量)会保留.新的名称定义会覆盖旧的定义,因此一般情况下不会造成问题.如果新版本的模块没有定义在旧模块中已有定义的名称,旧的定义会保留.这个特性可以看作是模块的优点因为它维护了一份全局对象的表或者缓存 - 如有需要,可在try语句中测试表或者跳过初始情况:
    
    try:<br />        cache<br />    except NameError:<br />        cache = {}<br />    

    
    一般情况下,除了sys, __main__和__builtin__,重新载入内置或者动态装载模块不是很有用.然而很多情况下,扩展模块被设计为不会初始化多次,在重新装载时某些情况下可能出错.

    当一个模块使用from ... import ...从另一个模块中导入对象,被导入模块调用reload()并不会重新定义从它中导入的对象 - 一个办法是重新执行from语句,另一种办法是使用import和限定名称(module.*name*).
    
    如果一个模块实例化了一个类实例,重新载入定义该类的模块并不会影响实例定义的方法 - 它们会按照原有类定义的方式使用.这条规则同样适用于衍生类.

repr(object)
    返回一个对象的描述字符串,与转换函数生成的值相同(反向引用).此函数可以作为普通函数使用.对于许多类型,此函数尝试返回一个字符串,是把该类型传递给eval()时产生的同名对象;否则描述是尖括号中的一个字符串,该字符串包含了对象和附加信息(通常包含对象的名称和地址)的类型的名称.类可以通过定义__repr__()方法来控制其实例的repr函数返回值.
    
reversed(seq)
    返回一个逆序迭代器.seq必须是一个有__reversed__()方法的对象,或者支持序列协议(__len__()方法和从0开始整数参数的__getitem__()方法).
    
    2.4版本新增.
    2.6版本改动:增加个性化__reversed__()方法的可能.


round(x[, n])
    返回浮点数x四舍五入到小数点后n位的结果.如果n省略,默认为0.结果是浮点数,会向最近的10**(-n)的倍数四舍五入;如果2个倍数同等接近,四舍五入向离开0的方向(例如,round(0.5)结果为1.0,round(-0.5)结果为-1.0).



<<2. 内置函数 - 1:A-H     >>目录     >>2. 内置函数 - 3:S-Z




25 Nov 2009

Python标准库手册 - 2. 内置函数 - 1

2. 内置函数 - 1:A-H



Python解释器有一系列永远可用的内置函数,这些函数在下面以字母顺序列出.

abs(x)
    返回数字的绝对值.参数可能是简单或者长整型,或者浮点数.如果参数是复数,返回它的模.

all(iterable)
    返回True,如果iterable的所有元素都为true(或者iterable为空). 等价于:
    
    def all(iterable):
        for element in iterable:
            if not element:
                return False
        return True
    

     Python2.5新增

any(iterable)
    如果iterable的任一元素为true,返回Ture.如果iterable为空则返回False.等价于:
    
    def any(iterable):
        for element in iterable:
            if element:
                return True
        return False
    

    Python2.5新增
    



basestring()
    这个抽象类型是str和unicode的超类.它不能被调用或者实例化,但是可以被用来测试某个对象是否是str或者unicode的实例. isinstance(obj, basestring)等价于 isinstance(obj, (str, unicode)).
    Python2.3新增

bin(x)
    将整数转换为二进制字符串,结果是有效的python表达式.如果x不是Python中的整型,必须定义一个返回整型的__index__()方法.
    Python2.6新增

bool([x])
    转换x为布尔值,按照标准真值检测过程.如果x是flase或省略,返回False; 否则返回True. bool也是一个类,是int的子类.bool类不能再被子类化,它仅有的实例是False和True.

    Python2.2.1新增
    2.3版改动: 如果指明参数,该函数返回False.


callable(object)
    如果对象参数可以被调用返回True,否则返回Flase.如果返回true,仍然可能调用失败,但是如果返回false,调用则永远不会成功.注意类是可调用的(调用一个类返回一个新的实例);类实例也可以被调用如果它们有__call__()方法.

chr(i)
    返回整型i对应的ASCII字符.例如chr(97)返回字符'a'.这是ord()的逆函数.参数必须属于[0,255];如果超出这个范围,ValueError异常会被抛出.参看unichr().

classmethod(function)
    返回function的类方法.
    类方法接受类自身作为隐含的第一参数,就好像实例方法接受实例本身.声明类方法采用如下习惯:
    
    class C:
        @classmethod
        def f(cls, arg1, arg2, ...): ...
    

    @classmethod形式是函数修饰符 - 参考函数定义描述.

    该函数可以被类调用(如C.f())或者类的实例调用(如C().f()),作为类的实例,实例将被忽略.如果一个类方法被衍生类调用,衍生类对象作为隐含的第一参数被传递.

    类方法不同于C++或者Java的静态方法.如果你想要静态方法,参看本节的staticmethod()函数.

    查阅标准类型层次文档可以看到更多关于类方法的信息.

    2.2版本新增
    2.4版本改变:增加函数修饰语法


cmp(x, y)
    比较2个对象x和y,并且根据其结果返回一个整型.如果x<y返回负数;如果x==y返回0,正数如果x>y.

compile(source, filename, mode[, flags[, dont_inherit]])
    编译source为代码或AST对象.代码对象可被exec语句执行或者调用eval()执行.source可以是一个字符串或者AST对象.关于如何使用AST对象,请参看ast模块文档.

    参数filename指定了代码从何处读读取,如果不是从文件读入,应该传入一些可被识别的值.

    参数mode指定何种代码会被编译:
        exec:     source包含一系列语句
        eval:     单独表达式
        single: 单独的交互式语句.
    最后一种情况下,表达式语句会被执行,返回非None的结果并打印.

    可选参数flags和dont_inherit控制哪些未来版本语句会影响source编译.如果都未指定(或者均为0),代码会连同现有的(目前包含且生效的)的未来版本语句一起编译;如果flags给定而dont_inherit没有指定(或为0),那么被flags指定的未来版本语句会被强制使用;如果dont_inherit是非零整数,则现行的未来版本语句会被忽略.

    未来版本语句由位来控制,这些位联合在一起可以控制多条语句.用来指定一个给定未来版本语句的位阀可以参考__future__模块中_Feature实例的compiler_flag属性.

    如果被编译的source无效,这个函数会抛出SyntaxError,如果source包含空字节,会抛出TypeError.

    注意:
    当用多行语句编译一个字符串是,行结束符必需由一个新行字符('\n')表示,并且输入必需由至少一个行结束符结束.如果行结束符由('\r\n')表示,可以用str.replace()替换为'\n'.
    2.3版本改动: 加入flags和dont_inherit参数
    2.6版本改动: 支持编译AST对象.


complex([real[, imag]])
    创建一个复数,其值为 real + imag*j 或者将字符串或数字转换为复数.如果第一个参数为字符串,会被当做复数对待,不能再输入第二个参数.第二个参数永远不能字符串.每个参数可以使任意的数值类型(包括复数).如果省略imag参数,默认为0,此时该函数相当于一个数值转换函数int(), long()或者float().如果2个参数均省略,返回0j.

    复数类型在数值类型中有描述 - int, float, long, complex.

delattr(object, name)
    这是setattr()的近亲.参数为一个对象和一个字符串.字符串必须是该对象某一属性的名称.该函数会删除对象的对应属性,如果对象允许删除.例如delattr(x, 'foobar')等价于del x.foobar.

dict([arg])
    创建一个新数据字典,其元素来自于可选参数arg.字典类型 - dict - 在影射类型中有描述.

    其他容器可参看内置的列表(list),集合(set), 元组(tuple)类,或者集合(collections)模块.

dir([object])
    没有参数,会返回当前局部作用域内的名称列表.如果有输入参数,会尝试返回object的有效属性列表.

    如果object有名为__dir__()的方法,会调用该方法且必须返回属性列表.这样会允许用户定制对象的__getattr__()和__getattribute__()方法以改变dir()返回其属性列表.

    如果object没有提供__dir__()方法,该函数会尝试从object的__dict__属性(如果存在的话)和他的类型对象收集尽可能多的信息.当object的__getattr__()方法被改写时,结果列表可能不完整,或者不准确.

    dir()的默认行为根据对象类型的不同而不同,因为它总是试图返回最相关的,而非最完整的信息:
        * 如果object是模块,结果包含该模块的属性的名称.
        * 如果object是类,结果包含该类的属性,以及递归式回溯得到的其基类的属性.
        * 否则,结果将包含object的名称,其所属类的属性的名称,和递归回溯直至其基类的属性之名称.

    结果列表以字母顺序排列,例如:
    
    >>> import struct
    >>> dir()   # doctest: +SKIP
    ['__builtins__', '__doc__', '__name__', 'struct']
    >>> dir(struct)   # doctest: +NORMALIZE_WHITESPACE
    ['Struct', '__builtins__', '__doc__', '__file__', '__name__',
     '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
     'unpack', 'unpack_from']
    >>> class Foo(object):
    ...     def __dir__(self):
    ...         return ["kan", "ga", "roo"]
    ...
    >>> f = Foo()
    >>> dir(f)
    ['ga', 'kan', 'roo']


    注意:
    由于dir()主要是为了在交互式命令提示符下提供方便,所以它会尝试返回一系列有意义的名称集合,而并非最完整或者定义一致的名称集合.而且其具体的机制也会根据发行版本不同而不同.例如,当参数是一个类时,元类属性不会出现在结果列表中.

divmod(a, b)
    返回2个数(非复数)的商和余数(使用长除法).对于混合操作数类型,会应用二元算术运算规则.对于整型和长整形,结果与(a // b, a % b)相同;对于浮点数,结果等价于(q, a % b),其中q等于常用的除法math.floor(a / b)但是可能会比这个结果少1. 无论在何种情况之下, q * b + a % b都跟a非常接近, 如果a % b结果非零,则结果与b的符号相同,并且0 <= abs(a % b) < abs(b).

    2.3版本改动:弃用复数的divmod().

enumerate(sequence[, start=0])
    返回枚举对象.sequence必须是一个序列,迭代器或者其他支持迭代的对象.由enumerate()返回的迭代器的next()方法,将返回一个包含计数器(默认从0开始)和对应值的元组.enumerate()对于获得有索引的序列非常有效: (0, seq[0]), (1, seq[1]), (2, seq[2]), ... 例如:
    
    >>> for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']):
    ...     print i, season
    0 Spring
    1 Summer
    2 Fall
    3 Winter

    2.3版本新增.
    2.6版本改动: 新增start参数.


eval(expression[, globals[, locals]])
    参数为一个字符串,可选参数包括globals和locals.如果提供了可选参数,globals必须是一个字典,locals可以是任意的映射对象.
    2.4改动: locals正式要求为一个字典.

    expression参数被当做Python表达式(技术上来讲,是条件列表)分析和执行,globals和locals会作为全局和局部命名空间.如果globals字典存在并缺少__builtins__,当前的globals会在表达式被分析前复制到globals.这意味着expression一般对标准的__builtin__模块拥有完全访问权限,限制环境也会被遗传.如果locals字典被省略,它默认等于globals字典.如果均被省略,expression会在调用eval()的环境下被执行.返回值是执行expression的记过.语法错误会作为异常报告.例如:
    
    >>> x = 1
    >>> print eval('x+1')
    2


    这个函数也可以被用来执行任意的代码对象(例如由compile()创建的).在这种情况下,要传递一个代码对象而不是字符串.如果代码对象已经被exec作为kind参数编译,eval()将返回None.

    提示:exec语句支持动态执行语句,execfile()函数支持动态执行文件.globals()和locals()将相应的返回当前全局和局部字典,这些参数可以传递给eval()或execfile().

execfile(filename[, globals[, locals]])
    该函数类似于exec语句,唯一的区别就是分析一个文件而非字符串.但由于它不使用模块管理,所以不同于import语句 - 它无条件读取一个文件而且不会创建一个新的模块.-脚注1-

    参数包含文件名和2个可选的字典.文件会以globals和locals作为全局和局部命名空间,当做一系列Python语句(类似于模块)被分析和执行.如果有locals参数,它可以使任意的映射对象.

    2.4版本改动:正式要求locals是一个字典.

    如果locals字典被省略,默认等于globals字典.如果都被省略,该函数会在execfile()被调用的环境下执行,返回值是None.

    注意:
    默认的locals()函数的行为如下:
    一般不应尝试修改默认的locals字典.如果你需要看到局部代码被execfile()执行后返回的效果,可以传递一个明确的locals字典.使用execfile()修改函数的locals参数是不可信的.

file(filename[, mode[, bufsize]])
    文件类型的构造函数,在文件对象一节有详细描述.构造器的参数与下面描述的内置函数open()相同.

    当打开一个文件时,最好使用open()而不是直接调用此构造函数.file更适合被用来做类型测试(例如,isinstance(f, file)).

    2.2版本新增

filter(function, iterable)
    构造一个列表,其元素是以iterable的元素为参数执行function时返回true的元素.iterable必须是序列,支持迭代的容器或者迭代器.如果iterable是一个字符串或者元组,结果也是相应的类型;否则永远是列表.如果function是None,则认为是恒等函数,则iterable的所有是false的元素会被删除.

    注意:如果function不是None,filter(function, iterable)等价于[item for item in iterable if function(item)];如果function是None,则它等价于[item for item in iterable if item].

    参考它的互补函数itertools.filterfalse(),该函数会返回以iterable的元素为参数执行function时返回false的元素.

float([x])
    将一个字符串或者数字转换为浮点数.如果参数是字符串,则必须包含白空格的有正负号的十进制或者浮点数.参数也可以是[+|-]nan或者[+|-]inf.否则,参数可能是整型,长整形或者浮点数,会返回一个等值的浮点数(在Python的浮点数精度下).如果无参数,返回0.0.

    注意:
    当传递一个字符串时,可能返回NaN或者Infinity,这依赖于底层的C库函数.对于NaN,float接受字符串nan, inf和-inf;对于infinity,有正无穷和负无穷.对于NaN来说,+和-会被忽略,float永远将NaN和infinity表示为nan, inf和-inf.

    浮点类型在数值类型一节有详细描述 - int, float, long, complex.

format(value[, format_spec])
    将value转换为由format_spec指定的格式化表达方式.其中format_spec取决于value参数的类型.但是,仍然有一个被大部分内置类型采用的标准格式化语法:格式化简短说明(参看8.1.3.1)

    注意:format(value, format_spec)只不过是调用value.__format__(format_spec)而已.
    2.6新增

frozenset([iterable])
    返回一个frozenset类型,如果有可选参数iterable,元素来自于iterable.frozenset类型的说明参看集合类型 - Set, frozenset(参考6.7).

    其他的容器参考内置类dict, list, tuple和collections模块.

    2.4版本新增

getattr(object, name[, default])
    返回对象的对应属性的值.name必须是字符串.如果该字符串是object某一属性的名称,返回该属性的值.例如getattr(x, 'foobar')等价于x.foobar.如果该属性不存在,返回default.如果未提供default参数,抛出AttributeError异常.

globals()
    以字典形式返回当前全局符号表,结果永远是当前模块的字典(在一个函数或者方法内部,是它被定义的模块,而非调用它的模块).
    
hasattr(object, name)
    参数是一个对象和一个字符串.如果字符串是对象的某个属性名称返回True,否则返回False.(另一个办法是调用getattr(object, name)看它是否抛出异常.)

hash(object)
    返回object的哈希值(如果有).哈希值是整数,在搜索字典时被用来快速比较字典键值.相同的数值拥有相同的哈希值(即使它们类型不同,例如1和1.0).

help([object])
    调用内置的帮助系统.(该函数主要用于交互式环境)如果未指明参数,解释器命令行的交互式帮助系统会.如果参数是字符串,会以该字符串为名称搜索模块,函数,类,方法,关键字或者文档题目,然后打印帮助页面.如果参数是其他任意对象,会生成关于该对象的帮助页面.
    
    该函数被site模块加入内置命名空间.
    2.2版本新增

hex(x)
    将一个整数(任意大小)转换为十六进制字符串,结果是一个有效的Python表达式.
    
    注意:
    如果要得到浮点数的十六进制字符串表达式,可以用float.hex()方法.
    2.4版本改动:正式只返回无符号表达式


<<1. 简介    >>目录    >>2. 内置函数-2:I-R