python 内置函数
Table of Contents
1. 常用函数
2. 内置类型转换函数
3. 序列处理函数
4. String模块
Chapter 1. 常用函数
abs(x)
abs()返回一个数字的绝对值。如果给出复数,返回值就是该复数的模。
>>>print abs(-100) 100 >>>print abs(1+2j) 2.2360679775
callable(object)
callable()函数用于测试对象是否可调用,如果可以则返回 1(真);否则返回 0(假)。可调用对象包
“ ”括函数、方法、代码对象...
Table of Contents
1. 常用函数
2. 内置类型转换函数
3. 序列处理函数
4. String模块
Chapter 1. 常用函数
abs(x)
abs()返回一个数字的绝对值。如果给出复数,返回值就是该复数的模。
>>>print abs(-100) 100 >>>print abs(1+2j) 2.2360679775
callable(object)
callable()函数用于测试对象是否可调用,如果可以则返回 1(真);否则返回 0(假)。可调用对象包
“ ”括函数、
、代码对象、类和已经定义了 调用 方法的类实例。
>>> a="123" >>> print callable(a) 0 >>> print callable(chr) 1
cmp(x,y)
cmp()函数比较 x和 y两个对象,并根据比较结果返回一个整数,如果 x
y,则返回 1,如果 x==y则返回 0。
>>>a=1 >>>b=2 >>>c=2 >>> print cmp(a,b) -1 >>> print cmp(b,a) 1 >>> print
cmp(b,c) 0
divmod(x,y)
divmod(x,y)函数完成除法运算,返回商和余数。
>>> divmod(10,3) (3, 1) >>> divmod(9,3) (3, 0)
isinstance(object,class-or-type-or-tuple) -> bool
测试对象类型
>>> a='isinstance test' >>> b=1234 >>> isinstance(a,str) True >>>
isinstance(a,int) False >>> isinstance(b,str) False >>> isinstance(b,int) True
len(object) -> integer
len()函数返回字符串和序列的长度。
>>> len("aa") 2 >>> len([1,2]) 2
pow(x,y[,z])
pow()函数返回以 x为底,y为指数的幂。如果给出 z值,该函数就计算 x的 y次幂值被 z取模的
值。
>>> print pow(2,4) 16 >>> print pow(2,4,2) 0 >>> print pow(2.4,3) 13.824
range([lower,]stop[,step])
range()函数可按参数生成连续的有序整数列表。
>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(1,10) [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1,10,2) [1, 3, 5, 7, 9]
round(x[,n])
round()函数返回浮点数 x的四舍五入值,如给出 n值,则代表舍入到小数点后的位数。
>>> round(3.333) 3.0 >>> round(3) 3.0 >>> round(5.9) 6.0
type(obj)
type()函数可返回对象的数据类型。
>>> type(a) >>> type(copy) >>> type(1)
xrange([lower,]stop[,step])
xrange()函数与 range()类似,但 xrnage()并不创建列表,而是返回一个 xrange对象,它的行为
与列表相似,但是只在需要时才计算列表值,当列表很大时,这个特性能为我们节省内存。
>>> a=xrange(10) >>> print a[0] 0 >>> print a[1] 1 >>> print a[2] 2
Chapter 2. 内置类型转换函数
chr(i)
chr()函数返回ASCII码对应的字符串。
>>> print chr(65) A >>> print chr(66) B >>> print chr(65)+chr(66) AB
complex(real[,imaginary])
complex()函数可把字符串或数字转换为复数。
>>> complex("2+1j") (2+1j) >>> complex("2") (2+0j) >>> complex(2,1) (2+1j)
>>> complex(2L,1) (2+1j)
float(x)
float()函数把一个数字或字符串转换成浮点数。
>>> float("12") 12.0 >>> float(12L) 12.0 >>> float(12.2) 12.199999999999999
hex(x)
hex()函数可把整数转换成十六进制数。
>>> hex(16) '0x10' >>> hex(123) '0x7b'
long(x[,base])
long()函数把数字和字符串转换成长整数,base为可选的基数。
>>> long("123") 123L >>> long(11) 11L
list(x)
list()函数可将序列对象转换成列表。如:
>>> list("hello world") ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] >>> list((1,2,3,4)) [1, 2,
3, 4]
int(x[,base])
int()函数把数字和字符串转换成一个整数,base为可选的基数。
>>> int(3.3) 3 >>> int(3L) 3 >>> int("13") 13 >>> int("14",15) 19
min(x[,y,z...])
min()函数返回给定参数的最小值,参数可以为序列。
>>> min(1,2,3,4) 1 >>> min((1,2,3),(2,3,4)) (1, 2, 3)
max(x[,y,z...])
max()函数返回给定参数的最大值,参数可以为序列。
>>> max(1,2,3,4) 4 >>> max((1,2,3),(2,3,4)) (2, 3, 4)
oct(x)
oct()函数可把给出的整数转换成八进制数。
>>> oct(8) '010' >>> oct(123) '0173'
ord(x)
ord()函数返回一个字符串参数的ASCII码或Unicode值。
>>> ord("a") 97 >>> ord(u"a") 97
str(obj)
str()函数把对象转换成可打印字符串。
>>> str("4") '4' >>> str(4) '4' >>> str(3+2j) '(3+2j)'
tuple(x)
tuple()函数把序列对象转换成 tuple。
>>> tuple("hello world") ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd') >>> tuple([1,2,3,4])
(1, 2, 3, 4)
Chapter 3. 序列处理函数
常用函数中的 len()、max()和min()同样可用于序列。
filter(function,list)
调用 filter()时,它会把一个函数应用于序列中的每个项,并返回该函数返回真值时的所有项,从而
过滤掉返回假值的所有项。
>>> def nobad(s): ... return s.find("bad") == -1 ... >>> s =
["bad","good","bade","we"] >>> filter(nobad,s) ['good', 'we']
这个例子通过把 nobad()函数应用于 s “序列中所有项,过滤掉所有包含 bad”的项。
map(function,list[,list])
map()函数把一个函数应用于序列中所有项,并返回一个列表。
>>> import string >>> s=["python","zope","linux"] >>> map(string.capitalize,s)
['Python', 'Zope', 'Linux']
map()还可同时应用于多个列表。如:
>>> import operator >>> s=[1,2,3]; t=[3,2,1] >>> map(operator.mul,s,t) # s[i]*t[j]
[3, 4, 3]
如果传递一个None值,而不是一个函数,则map()会把每个序列中的相应元素合并起来,并返回
该元组。如:
>>> a=[1,2];b=[3,4];c=[5,6] >>> map(None,a,b,c) [(1, 3, 5), (2, 4, 6)]
reduce(function,seq[,init])
reduce()函数获得序列中前两个项,并把它传递给提供的函数,获得结果后再取序列中的下一项,
连同结果再传递给函数,以此类推,直到处理完所有项为止。
>>> import operator >>> reduce(operator.mul,[2,3,4,5]) # ((2*3)*4)*5 120 >>>
reduce(operator.mul,[2,3,4,5],1) # (((1*2)*3)*4)*5 120 >>> reduce(operator.mul,
[2,3,4,5],2) # (((2*2)*3)*4)*5 240
zip(seq[,seq,...])
zip()函数可把两个或多个序列中的相应项合并在一起,并以元组的格式返回它们,在处理完最短序
列中的所有项后就停止。
>>> zip([1,2,3],[4,5],[7,8,9]) [(1, 4, 7), (2, 5, 8)]
如果参数是一个序列,则 zip()会以一元组的格式返回每个项,如:
>>> zip((1,2,3,4,5)) [(1,), (2,), (3,), (4,), (5,)] >>> zip([1,2,3,4,5]) [(1,), (2,), (3,), (4,),
(5,)]
Chapter 4. String模块
replace(string,old,new[,maxsplit])
字符串的替换函数,把字符串中的 old替换成 new。默认是把 string中所有的 old值替换成 new
值,如果给出maxsplit值,还可控制替换的个数,如果maxsplit为 1,则只替换第一个 old值。
>>>a="11223344" >>>print string.replace(a,"1","one") oneone2223344 >>>print
string.replace(a,"1","one",1) one12223344
capitalize(string)
该函数可把字符串的首个字符替换成大字。
>>> import string >>> print string.capitalize("python") Python
split(string,sep=None,maxsplit=-1)
从 string字符串中返回一个列表,以 sep的值为分界符。
>>> import string >>> ip="192.168.3.3" >>> ip_list=string.split(ip,'.') >>> print
ip_list ['192', '168', '3', '3']
import__( name[, globals[, locals[, fromlist[, level]]]])
被 import 语句调用的函数。它的存在主要是为了你可以用另外一个有兼容接口的函数来改变 import 语
句的语义. 为什么和怎么做的例子, 库模块 ihooks和 rexec. 也可以查看 imp, 它定义了有用的操作,
你可以创建你自己的 __import__()函数.
例如, 语句"import spam" 结果对应下面的调用: __import__('spam', globals(), locals(), [], -1); 语句 "from
spam.ham import eggs" 结果对应调用 "__import__('spam.ham', globals(), locals(), ['eggs'], -1)". 注意即
使 locals()和['eggs']作为参数传递, __import__() 函数不会设置局部变量 eggs; import语句后面的代码完
成这项功能的. (实事上, 标准的执行根本没有使用局部参数 , 仅仅使用 globals决定 import语句声明
package的上下文.)
当 name变量是 package.module 的形式, 正常讲, 将返回顶层包 (第一个点左边的部分), 而不是名为
name的模块. 然而, 当指定一个非空的 formlist 参数,将返回名为 name的模块. 这样做是为了兼容为不
同种类的 import语句产生的字节码; 当使用 "import spam.ham.eggs", 顶层包 spam 必须在导入的空间中,
但是当使用"from spam.ham import eggs", 必须使用 spam.ham子包来查找 eggs变量. 作为这种行为的
工作区间, 使用 getattr()提取需要的组件. 例如, 你可以定义下面:
def my_import(name):
mod = __import__(name)
components = name.split('.')
for comp in components[1:]:
mod = getattr(mod, comp)
return mod
level指定了是否使用相对或绝对导入. 默认是 -1将使用将尝试使用相对或绝对导入. 0 仅使用绝对导入.正
数意味着相对查找模块文件夹的 level层父文件夹中调用__import__ 。
abs( x)
返回一个数的绝对值。参数也许是一个普通或长整型,或者一个浮点数。如果参数是一个复数,返回它
的积。
all( iterable)
如果迭代的所有元素都是真就返回真。
def all(iterable):
for element in iterable:
if not element:
return False
return True
版本 2.5中新增.
any( iterable)
如果迭代中有一个元素为真就返回真。
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中新增.
bool( [x])
将一个值转换为 Boolean,使用标准的真测试程序。如果 x是假或忽略了,将返回 False;否则将返回
True.bool也是一个 class,它是 int的一个子类,bool类不能进一步子类化。它仅有 False和 True两个实
例。
callable( object)
如果 object参数可以调用就返回 True,否则返回 False。如果返回 True,它仍然可能调用失败,但是如果返
回 False,就永远不可能调用成功。注类是可调用的(调用一个类返回一个实例);类的实例如果有一个_
_call__() 方法就是可调用的。
chr( i)
返回一个一个 ascii码是整数 i的字符的字符串。例如,chr(97)返回 string 'a'.这和 ord()刚好相反。这参数
在[0..255]之间,全部包含。如果超出这个范围,就抛出 ValueError
classmethod( function)
返回函数的一个类方法。一个类方法
Return a class method for function. 一个类方法接收类作为它的第一个潜在参数,就像一个实例方法接收
一个实例。声明一个类方法,如下:
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
@classmethod形式是一个函数 decorator。在函数参考手册的第七章有关函数定义的描述寻找更多的细
节.
它即可以在一个类(例如C.f)上调用,也可以在一个实例上调用。这个实例将忽略它的类。如果一个继
承类调用一个类方法,这继承类对象将作为第一个潜在的参数传递。
类方法不同于C++或 Java的静态方法。如果你想这样做,使用 staticmethod() 。
cmp( x, y)
根据比较两介对象 x和 y的结果,返回一个整数。如果 x y,
返回一个正数.
compile( string, filename, kind[, flags[, dont_inherit]])
编译 string为一个代码对象。代码对象能够通过 exec语句执行或者通过调用 eval()计算。这 filename参
数指定代码从哪个文件读取。如果不从文件中读取,就须传递一些可识别的值(通常使
用'')。kind参数指定哪种代码被编译; ‘如果是包含一系列语句组成的子符串可以 exec’,如果是由
一个表达式组成,就'eval', ‘如果由一个交互语句组成就 singlw’(在后面的例子,表达式语句计算的结果不
是 None将打印出来) 。
当编译一个多行语句时,应用两个警告:必须以'\n'作为行结束符,同时输入必须至少以一个'\n'作为结束。
如果是以'\r\n'作为行结束,使用 string的 repalce() ‘方法将其改为 \n’.
可先的参数 flags和 dont_inherit控制影响 string编译的 future 语句。更详细的请参考英文文档。
complex( [real[, imag]])
创建一个复数 real + imag*j或者将一个 string或者 number转化为一个复数. 如果第一个参数是一个字符
串,它将作为复数解释,函数将被调用,而忽略第二个参数。第二个参数不可能是一个字符串。每一个参
数都可能是一个数字类型包括复数.如果 imag省略了, 它默认为 0 ,函数将当作一个数字转换函数像 int(),
long() and float().如果参数都省略了,将返回 0j.
delattr( object, name)
与 setattr()相对的,参数是一个对象和一个 string.string必须是对象的一个属性。函数删除 object这个名
为 string的属性。例如,delattr(x, 'foobar')等价于 del x.foobar
dict( [arg])
以一个可选的位置参数或一组关键词参数初始化一个字典。如果没有给出参数,返回一个空的字典。如
果位置参数 arg 是一个映射对象,返回一个字典映射与映射对象相同的 keys对应同样的值。那么位置参
数应是一个序列,支持迭代的容器,或者是一个迭代对象。参数的每一个元素也必须是其中的一种,同
时每一个包含两个对象。第一个作为新字典的 key,同时第二个作为这个 key的值。如果给定的 key不只
出现一次,这新字典将包含最后一个值。
如果给出的是关键词参数,关键词和与其相关的值都将作为字典的项添加到字典中。如果一个 ke既作为
位置参数和作为一个关键词参数,关键词关联的值将保留在字典中。例如,下面所有返回都等价于
{"one": 2, "two": 3}:
dict({'one': 2, 'two': 3})
dict({'one': 2, 'two': 3}.items())
dict({'one': 2, 'two': 3}.iteritems())
dict(zip(('one', 'two'), (2, 3)))
dict([['two', 3], ['one', 2]])
dict(one=2, two=3)
dict([(['one', 'two'][i-2], i) for i in (2, 3)])
版本 2.2中新增.
dir( [object])
如果没有参数,返回当前 local符号表中名字的列表。如果有一个参数将尝试返回这个参数对象的有效属
性。从对象的__dict__ (如果定义了)属性,类或 type对象收集信息。这个列表不一定是完整的。如果
对象是一个模块对象,list包含模块属性的列表。如果对象是一个 type或 class 对象,列表将包含属性的
名字,同时递归其基地的属性。否则,列表将包含对象属性的名字,类属性的名字,递归若基类的属性
名字。结果列表按字母顺序排序。例如:
>>> import struct
>>> dir()
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)
['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack']
注:因为 dir()主要在交互提示下方便使用,它尝试提供一给有意思的名字而不是尝试提供严格的或与定义
一样的名字,在 relrase 中它的细节行为也许会改变。
divmod( a, b)
用两个数字(不是复数)作为参数,返回 long除法得到的商和余数组成的一对数字。使用混合的操作类
型,混合的类型,将应用应用二进制算术操作。对于一般和长整数,结果与(a // b, a % b)相同。对于浮
点数结果和(q, a % b)相同,q通常是math.floor(a / b),但如果是比 1小,就为 1.在任何情况下 q * b + a
% b与 a很接近,如果 a % b是非 0的,它与 b有相同的符号,同时 0 <= abs(a % b) < abs(b).
enumerate( iterable)
返回 enumerate对象. iterable必须是一个序列, 一个迭代, 或者其它对象它支持迭代.enumerate()返回的
iterator的 next() 方法返回一个元组包含一定的数目(从 0开始)和从迭代中获取的对应的值。
enumerate() 对于获取一个索引系列很有用: (0, seq[0]), (1, seq[1]), (2, seq[2]), .... 版本 2.3中新增.
eval( expression[, globals[, locals]])
该参数是一个字符串和可选的 globals和 locals。如果提供 globals,globals必须是一个字典。如果提供
locals,locals可以是任何映射对象。2.4版本修改:以前 locals 被要求是一个字典。
expression参数是作为一个 Python 表达式被分析和评价(技术上来说,一个条件列表)使用 globals以
及 locals字典作为 global和 local名字空间。如果提供了 globals 字典但没有'__builtins__',当前 globals
在表达式被分析前被复制到 globals 中。这意味着表达式可以完全访问标准 __builtin__模块和受限的环境。
如果 locals字典省略则默认为 globals字典。如果两个字典都被省略,表达式在调用 eval 的环境中执行。
返回值是计算表达式的结果。语法错误为 exceptions 。例如:
>>> x = 1
>>> print eval('x+1')
2
此函数也可以用来执行任意代码的对象(如 compile()创建的)。在这种情况下,传入一个代码对象,而
不是一个字符串。该代码对象必须已编译传给'eval' 作为这种参数。
提示:EXEC语句支持是动态执行语句。execfile()函数支持从一个文件中执行语句。globals()和
locals()函数分别返回当前的 global和 local字典,这对使用 eval()或 execfile ()很有帮助。
execfile( filename[, globals[, locals]])
这个功能类似于 EXEC语句,但分析一个文件,而不是一个字符串。这是不同之处在于它的 import语句
不使用模块管理 - 它无条件读取文件,并不会创建一个新的module 。
该参数是一个文件名和两个可选字典。该文件被作为 Python 语句序列(类似于一个模块)使用 globals
和 locals作为 global and local命名空间来分析和计算。如果提供 locals,locals可以是任何映射对象。
2.4版本修改:以前 locals 被要求是一个字典。如果 locals字典省略则默认为全局字典。如果两个字典都
被省略,表达式 execfile()被调用的环境中执行。返回值为None 。
警告:默认的 locals为下面的 locals():不要尝试修改默认的本地词典。如果你需要看到在函数 execfile()
返回后 locals代码的的影响,传递一个明确的 locals 字典。 execfile()不能用于依赖修改函数的
locals 。
file( filename[, mode[, bufsize]])
文件类型的构造函数,3.9节进一步描述,`文件对象'。构造函数的参数与下面的内建的 open()函数是一
样的。
当打开一个文件,它是最好使用的 open(),而不是直接调用此构造函数。文件更适合检验类型(例如,
isinstance(f, file) )。
版本 2.2中新增.
filter( function, iterable)
function 返回 true时从 iterable的元素中构造一个列表。迭代可以是一个序列,一个支持迭代的容器,或
一个迭代器,如果 Iterable 的是一个字符串或一个元组,其结果也有这种类型的,否则它始终是一个列
表。如果 function是None,假定它是恒等函数,即,迭代是 false 其所有元素都被删除。
请注意,filter(function,iterable),如果函数不为None等价于[item for item in iterable if function(item)],
如果函数为None等价于[item for item in iterable if item] 。
float( [x])
将字符串或数字转换或一个浮点数。如果参数是一个字符串,它必须包含一个可能带符号的十进制或浮
点数,可能嵌入空格。否则,参数可以是一个普通或长整数或浮点数,返回一个与之相同值的浮点数
(在 Python的浮点精度内)。如果没有给出参数,返回 0.0 。
注意:当传递一个字符串,可能会返回NaN和 Infinity,这取决于底层C 库。
frozenset( [iterable])
返回一个 frozenset对象,其元素来自于 Iterable 。 Frozensets组没有更新的方法,但可以哈希和其他组
成员或作为字典键使用。一个 frozenset的元素必须是不可改变。内部 sets 也应是 frozenset对象。如果
迭代没有指定,返回一个新的空集,frozenset ([]) 。版本 2.4 中新增
getattr( object, name[, default])
返回 object名为 name属性的值。名称必须是一个字符串。如果该字符串是对象的其中属性名字,结果
是该属性的值。例如,getattr(x, 'foobar')相当于 x.foobar。如果指定的属性不存在,则返回默认提供的,
否则抛出 AttributeError 。
globals( )
返回代表当前 global符号表字典的字典。这始终是当前模块字典(在一个函数或方法内,是在它被定义
的模块,而不是被调用的模块)。
hasattr( object, name)
该参数是一个对象和一个字符串。如果字符串是对象的其中一个属性,结果为 True,如果没有返回
False 。(这是通过调用的 getattr (对象名称),看是否引发异常与否。)
hash( object)
返回对象(如果有的话)的哈希值。哈希值是整数。它们被用来在词典查找时,作为一个快速比较字典
keys键。具有相同的哈希值,数值相等(即使它们属于不同的类型,因为是 1和 1.0 的情况)。
help( [object])
调用内置的帮助系统。(此功能是为交互使用。)如果没有给出参数,交互式帮助系统启动解释控制台。
如果参数是一个字符串,然后是字符串被作为一个 module,function,class,method,keyword或文档
主题名称和帮助页面名字进行查找后在控制台上打印出来。如果参数是任何其他类型的对象,将产生该
对象的一个帮助页面。版本 2.2中新增.
hex( x)
Convert an integer number (of any size) to a hexadecimal string. The result is a valid Python
expression. Changed in version 2.4: Formerly only returned an unsigned literal.
转换一个(任意大小)整数为十六进制字符串。其结果是一个有效的 Python表达式。在 2.4版本变更:
原只产生一个无符号的文字。
id( object)
返回对象的``identity''。这是一个整数(或长整型),这是保证是唯一的,与对象的生命周期一样长。两
个非重叠的生命周期的对象可能有相同的 ID ()值。(实现注意:这是对象的地址。)
input( [prompt])
警告:此函数是不安全的,因为用户错误的输入!它期待一个有效的 Python表达式作为输入,如果输入
语法上是无效的,将抛出 SyntaxError。如果地计算过程中有一个的错误,将抛出其他 exceptions 。(另
一方面,有时这是你为特殊使用需要写一个快速脚本。)
如果 readline模块被加载,input() 将使用它来提供详细行编辑和历史特性。
考虑使用 raw_input ()函数作为从用户进行一般输入。
int( [x[, radix]])
转换为字符串或数字为纯整数。如果参数是一个字符串,它必须包含一个可能有符号的十进制数作为一
个 Python 整数,可能嵌入空格。以 radix参数给出的基数为基础进行转换(这是默认 10),可以是任何
在[2,36] 范围内的整数,或零。如果基数为零,根据字符串的猜测正确的基数。如果指定的基数 x
是不是一个字符串,引发 TypeError异常。否则,参数可以是一个普通或长整数或浮点数。转换浮点数截
断为整数(直到零)。如果参数是整数范围之外的,将返回一个 long object。如果没有给出参数,返回
0
isinstance( object, classinfo)
返回 true如果该 object参数是 classinfo的一个实例,或其(直接或间接)子类的实例。也返回 true如果
classinfo是一种 type 对象(new-style class)和是该类型或其(直接或间接)子类的对象。如果 object
不是 class一个的实例或者给定类型的对象,函数返回 false 。如果 classinfo既不是一个类的对象也不是
一个 type的对象,它可能是一个包含类或类型的对象的 tuple,也可能包含其他的递归元组(序列类型不
接受)。如果 classinfo不是一个类,类型或元组类,类型,或者这种元组,将抛出一个 TypeError异常。
issubclass( class, classinfo)
返回 true如果 class是 classinfo (直接或间接)的子类。一个类被认为是自己的子类。 classinfo可能是
类对象元组,在这种情况下元组中的每个 classinfo项将被进行测试。在其他任何情况下,抛出一个
TypeError 异常。
iter( o[, sentinel])
返回一个迭代器对象。第一个参数有不同的解释,视第二个参数的存在与否而定。如果没有第二个参数,
o 必须是一个对象的集合,支持迭代协议(__iter__()方法),或者它必须支持序列协议(以整数 0开
始的参数__getitem__() 方法)。如果它不支持这些协议,将抛出 TypeError异常。如果第二个参数,
sentinel,给出,然后 o必须是可调用的对象。在这种情况下创造的每一个迭代器无参调用 o它的
next()方法,如果返回值等于 sentinel,将抛出 StopIteration ,否则将返回其它的值。
len( s)
返回一个对象的长度。参数可以是一个序列(字符串,元组或列表)或映射(词典)。
list( [iterable])
返回一个列表的 items与可迭代的项目相同的顺序且相同的 items。可迭代可以是一个序列,一个容器,
支持迭代,或一个迭代器对象。如果可迭代已经是一个列表,将返回一个副本,类似的于 iterable[:]。例
如,list('abc')返回['a', 'b', 'c']和 list( (1, 2, 3) ) 返回[1,2,3]。如果没有给出参数,返回一个新的空列表,
[] 。
locals( )
更新并返回一个代表当前 local符号表的字典。警告:本词典的内容不应该被修改,更改可能不会影响由
interpreter 用作局部变量的值。
long( [x[, radix]])
转换字符串或数字为一个长整数。如果参数是一个字符串,它必须包含一个任意大小的可能有符号的数
字,并有可能嵌入空格。radix参数解释和 int() 一样,而且只能当 x是一个字符串时才需要它。否则,参
数可以是一个普通或长整数或浮点数,返回与其相同值的长整数。转换浮点数到截断的整数(直到零)。
如果没有给出参数,返回 0L 。
map( function, iterable, ...)
应用 function 在 iterable的每一个项上并返回一个列表。如果有其他可迭代的参数,函数必须采取许多参
数应用于来自所有 iterables 项。如果一个迭代比另一个短,将以None进行扩展。如果 function是
None,将假设为 identity function,如果有多个参数,map()返回一个列表包含所有 iterables相应的项目
的元组组成。可迭代的参数可能是一个序列或任何可迭代的对象,结果总是一个列表。
max( iterable[, args...][key])
一个 Iterable参数,返回其中一个最大的非空可迭代项,(如一个字符串,元组或列表)。如有多个参数,
返回最大的参数。
可选的 key参数指定带一个参数的排序函数,用于 list.sort()。key参数,如果有,必须在以 keyword
的形式(例如,"max(a,b,c,key=func)" )。
min( iterable[, args...][key])
一个 Iterable参数,返回其中一个最小的非空可迭代项,(如一个字符串,元组或列表)。如有多个参数,
返回最小的参数。
可选的 key参数指定带一个参数的排序函数,用于 list.sort()。key参数,如果有,必须在以 keyword
的形式(例如,"max(a,b,c,key=func)" )。
object( )
返回一个新特征的对象。object是所有 new style class的基类。它的方法是新样式类的所有实例共有的。
oct( x)
转换一(任意大小)整数到一个八进制字符串。其结果是一个有效的 Python 表达式。
open( filename[, mode[, bufsize]])
打开一个文件,返回一个在 3.9节中描述的文件类型的对象,`File Objects'。如果文件无法打开,IOError
异常引发。当打开一个文件,最好调用 open(),而不是直接用 file 构造。
前两个参数与 stdio的 fopen()函数一样:filename是要打开的文件名,mode是一个字符串,表示该
文件是如何被打开。
mode ,最常用的值是'r'读,'w'写(文件如果已存在就截断),和'a'追加(在一些Unix系统意味着所有
写入追加到文件尾部,无论其现在的 seek 位置)。如果模式被省略,默认为'r'等。当打开一个二进制文
件,你应该模式值加上'b' ,打开二进制模式,从而提高可行性。(在某些不区分二进制文件和文本文件
‘的系统追加 b’,,它将作为文档)。下面是mode 的可能值:
可选 bufsize参数指定文件的所需缓冲区大小:0表示无缓冲,1表示行缓冲,任何其他的正数使用其大
小(在约)的一个缓冲区。负数 bufsize,使用系统默认,这 tty设备通常使用行缓冲和其他文件的完全缓
冲。如果省略,使用系统默认。
模式'r+', 'w+'和'a+'打开文件进行更新(请注意,'w+'截断该文件)。附加'b'的模式在区分二进制和文本文
件的系统上以二进制方式打开文件,系统上没有这个区别,加入了'b' 没有效果。
ord( c)
给定一个长度为 1的字符串,返回一个整数,当参数是一个Unicode对象,代表字符的Unicode代码,
或参数是一个 8 位字符串,代表其字节值,。例如,ord('a')返回整数 97,ord(u'\u2020')返回 8224。这
是 8位串 chr()和用于Unicode对象的 unichr ()的逆函数。如果给出Unicode参数和 Python是UCS2
Unicode的,字符的代码点必须在范围[0 .. 65535]内,否则字符串的长度是 2,抛出一个 TypeErro 。
pow( x, y[, z])
返回 x的 Y次方,如果给出 z,返回 x的 y次方,模 Z(比 pow(x, y) % z更有效)的。这两个参数的形式
pow(x, y),相当于:x ** y
property( [fget[, fset[, fdel[, doc]]]])
返回一个 new-style类(从 object 派生的类)的属性。
fget是一个获取属性值的 function,同样 fset是设置属性值的 function,fdel为删除属性的函数。典型的
用途是定义一个托管属性 x :
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.")
如果给出,doc将是该属性的文档字符串。否则,属性将复制 fget的文档字符串(如果存在)。这使得有
可能轻松地使用 property() 作为 decorator 创造只读属性:
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
原来的 voltage()方法成为一个`getter'同一名称的只读属性。版本 2.2中新增.
range( [start,] stop[, step])
这是一个通用函数来创建包含算术级数的列表,这是经常使用于循环。该参数必须是普通整数。如果
step参数被省略,默认为 1。如果省略 start 参数,默认为 0。完整形式是返回一个普通整数列表[start,
start + step, start + 2 * step, ...]。step不能为零(否则引发 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的项,reduce这 iterable得到一个数字。例如,
reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 就是计算 ((((1+2)+3)+4)+5)。左参数 x,是累加值和右边的参数,
y,是 iterable中更新的值。如果可选的 initializer 存在,在计算中摆在可迭代的项的前面,当 iterable为
空时,作为默认。如果没有给出 initializer ,则只包含一项,返回第一项。
reload( module)
重新导入先前导入的模块。该参数必须是一个模块对象,因此它之前必须已成功导入。如果您使用外部
编辑器编辑源文件的模块,并想不离开 Python解释器尝试新版本,这是有用的。返回值是模块对象(与
module 参数相同的值)。
当执行 reload(module) 时:
Python模块代码重新编译和模块级代码重新执行,定义绑定在模块词典中名称的新的对象。该扩展模块
初始化函数不会第二调用。
如同 Python 中的其它所有的对象,只有引用计数下降到零,对象才会被回收。
在模块命名空间的名称更新为指向任何新的或更改过的对象。
旧对象的其他引用(如引用外部模块的名字)不会重新绑定到新的对象,必须在每个命名空间更新它们
如果有需要。
还有其他一些警告:
如果一个模块在语法上是正确的,但它的初始化失败,因为它首次导入声明并未绑定它的 locally名字,
但在 sys.modules 模块中存储了一个模块对象(部分初始化)。要重新加载的模块,您必须先 import一
遍(这将绑定名称到部分初始化模块对象),然后才能重新加载()它。
当重新加载一个模块,它的字典(含模块的 global变量)的保留。重新定义的名称将取代旧的定义,所
以这通常不是一个问题。如果一个模块的新版本没有定义一个由旧版本定义的名称,旧的定义仍然存在。
此功能可用于模块的优势,如果它保持 global表或对象的缓存----使用 try语句可以测试 table 的存在和跳
过它的初始化 - 如果需要的话:
try:
cache
except NameError:
cache = {}
这是合法的,尽管一般对于重新加载内建或动态加载的模块不会太有用,除开 SYS,__main__和
__builtin__。在许多情况下,然而,扩展模块的并不被成初始化一次以上,以任意方式重新加载可能
失败。
如果一个模块使用 from ... import ...从另一个模块导入对象的,调用 reload() ,没有从其中导入的对象 -
一个办法是重新执行 from语句,另一个是使用 import和限定名(module.name )。
如果一个模块实例化类的实例,重新加载的模块定义了类不会影响实例中定义方法 - 他们继续使用旧的类
的定义。此对于派生类同样是如。
repr( object)
返回一个字符串,其中包含一个对象的可打印形式。有时是对能够访问一个普通的函数的操作很有用。
对于许多类型,该函数使得试图返回一个字符串,会产生一个对象与传递给 eval()相同的值产生的对象一
样。
reversed( seq)
返回一个反向迭代器。seq必须是一个支持序列协议的对象(__len__()方法和__getitem__()以 0开
始的整数参数的方法)版本 2.4 中新增
round( x[, n])
返回浮点值 x四舍五入到小数点后 n位后数字。如果 n 被省略,默认为零。结果是一个浮点数。
set( [iterable])
返回其元素都是从 iterable得到的 set。元素必须是不可改变的。如果 iterable没有指定,返回一个新的空
集,设置([]). 版本 2.4 中
本文档为【python 内置函数】,请使用软件OFFICE或WPS软件打开。作品中的文字与图均可以修改和编辑,
图片更改请在作品中右键图片并更换,文字修改请直接点击文字进行修改,也可以新增和删除文档中的内容。
[版权声明] 本站所有资料为用户分享产生,若发现您的权利被侵害,请联系客服邮件isharekefu@iask.cn,我们尽快处理。
本作品所展示的图片、画像、字体、音乐的版权可能需版权方额外授权,请谨慎使用。
网站提供的党政主题相关内容(国旗、国徽、党徽..)目的在于配合国家政策宣传,仅限个人学习分享使用,禁止用于任何广告和商用目的。