python 内建函数详解及相关示例

abs (x )
返回x 的绝对值；当x 是复数时，返回x 的模。没错，python内建支持复数，见下面的complex () 函数。

all (iterable )
当iterable 里的每项都为真时，才返回真，等效于：

def
 all
(
iterable)
:

    for
 element in
 iterable:

        if
 not
 element:

            return
 False


    return
 True

any (iterable )
只要iterable 里有一项为真，就返回真，等效于：

def
 any
(
iterable)
:

    for
 element in
 iterable:

        if
 element:

            return
 True


    return
 False

basestring ()
这是 str 和 unicode 的抽象类，它不能被调用也不能被实例化，但是可以用在 isinstance 函数里进行判断，isinstance(obj, basestring) 等效于 isinstance(obj, (str, unicode)).

>>>
isinstance
(
123
, basestring
)


False




>>>
isinstance
(
"123"
, basestring
)


True




>>>
isinstance
(
u"一二三"
, basestring
)


True

bin (x )
如果x 是一个整数，则返回一个与x 等值的二进制python表达式；如果x 不是一个整数类型，则x 的 类需要有一个可以返回一个整数的__index__ ()函数。

 

bool ([x ])
返回一个布尔型的值，如果x 为False或者没传x 参数的时候返回False，否则返回True。

 

callable (object )
判断object 是否可调用，如果object 是 函数、类、或者含有__call__ () 的类对象的话，将返回True。

 

chr (i )
返回一个单个字符的字符串，此字符的ascii码值为i (0<=i <=255)，此函数是ord 函 数的反函数。如果参数大于255而想得到一个unicode字符的话，需要使用unichr ()

 

classmethod (function )
返回一个类的方法（类的方法有别于实例的方法，是不需要实例化也可以通过类名访问的方法），定义一个类的方法需要用这样的形式：

class
 C:

    @classmethod


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

        pass

cmp (x , y )
比较两个对象x 和y 。如果x 小于y ，返回负数；大于返回正数；等于返回0。

 

compile (source , filename , mode [, flags [, dont_inherit ]])
把source 字符串编译成一个AST对象 ，暂时用不 到，先略过。

 

complex ([real [, imag ]])
用传入的实部和虚部创建一个复数对象。

 

delattr (object , name )
删除对象的属性，相当于 del object.name ，可以和setattr 配合使用。

 

dict ([arg ])
建立一个新的字典型数据，可以从参数里获取数据。

>>>
 dict
(
{
"a"
:"b"
,"c"
:"d"
}
)


{
'a'
: 'b'
, 'c'
: 'd'
}

dir ([object ])
如果不加参数，返回当前执行环境下的变量名的列表。
如果加了object 参数，则会根据复杂的规则得到object 的属性名列表，需要注意的是，当object 定 义了__dir__ ()或者 __getattr__ ()方法时，返回的结果并不 一定正确。
示例：

>>>
 dir
(
)


[
'__builtins__'
, '__doc__'
, '__name__'
, '__package__'
]




>>>
 t=[
1
,2
]


>>>
 dir
(
)


[
'__builtins__'
, '__doc__'
, '__name__'
, '__package__'
, 't'
]




>>>
 dir
(
t)


[
'__add__'
, '__class__'
, '__contains__'
, '__delattr__'
, '__delitem__'
, '__delslice__'
, '__doc__'
, '__eq__'
, '__format__'
, 

 '__ge__'
, '__getattribute__'
, '__getitem__'
, '__getslice__'
, '__gt__'
, '__hash__'
, '__iadd__'
, '__imul__'
, '__init__'
,

 '__iter__'
, '__le__'
, '__len__'
, '__lt__'
, '__mul__'
, '__ne__'
, '__new__'
, '__reduce__'
, '__reduce_ex__'
, '__repr__'
,

 '__reversed__'
, '__rmul__'
, '__setattr__'
, '__setitem__'
, '__setslice__'
, '__sizeof__'
, '__str__'
, '__subclasshook__'
,

 'append'
, 'count'
, 'extend'
, 'index'
, 'insert'
, 'pop'
, 'remove'
, 'reverse'
, 'sort'
]

divmod (a , b )
通常返回a 和b 的商和余数组成的元组： (a // b, a % b) 。参数不能是复数。

 

enumerate (sequence [, start =0])
返回一个列举后的对象，sequence 要支持迭代。返回的对象支持next()方法，此方法依次返回一个从start 开 始增长的序数和sequence 里的元素组成的元组。看以下的例子：

>>>
 enu=enumerate
(
[
'Spring'
, 'Summer'
, 'Fall'
, 'Winter'
]
)


>>>
 enu.next
(
)


(
0
, 'Spring'
)




>>>
 enu.next
(
)


(
1
, 'Summer'
)




>>>
 for
 i, season in
 enu:

...     print
 i, season

... 

2
 Fall

3
 Winter

eval (expression [, globals [, locals ]])
执行expression 表达式，可以用globals 和locals 来限制expression 能 访问的变量。
值得注意的是，expression 不仅可以是明文的字符串，还可以是compile()函数返回的代码对象。

 

execfile (filename [, globals [, locals ]])
此函数类似exec 表 达式。只是从文件里读取表达式。它和import的区别在于，execfile会无条件地读取文件，而且不会生成新的模块。
globals 和locals 的用法和上面的eval同理。

 

file (filename [, mode [, bufsize ]])
File 类型 的构造函数，参数的作用和下面提到的open()函数是一样的。
值得注意的是，open()函数更适合于打开一个文件，而file函数更适用于类型测试，例如： isinstance(f, file)

 

filter (function , iterable )
构造一个function (iterable )为true的list。当然iterable 为字 符串或者tuple的时候，返回的类型也是字符串或者tuple，否则返回list。

>>>
 filter
(
lambda
 c: c in
 'abc'
, 'abcdcba'
)


'abccba'




>>>
 filter
(
lambda
 i: i <
 3
, (
1
, 2
, 3
, 2
, 1
)
)


(
1
, 2
, 2
, 1
)




>>>










 filter










(










lambda










 i: i <










 3










, [










1










, 2










, 4










, 2










, 1










]










)






















[










1










, 2










, 2










, 1










]

如果function 为None，则iterable 为false的元素将被剔除。也就是说，function 不 为None的时候，filter(function, iterable) 等效于[item for item in iterable if function(item)] ，否则等效于[item for item in iterable if item]

float ([x ])
传入一个字符串或者整数或者float，返回一个float数据。

format (value [, format_spec ])
根据format_spec 格式化输出value 的值，实际上只是调用了value.__format__(format_spec) ， 很多内建类型都有标准的输出函数 。

frozenset ([iterable ])
由iterable 创建一个frozenset对 象 ，frozenset是set的一个子类，它和set的区别在于它不支持某些可以修改set的操作，例如：add、remove、pop、 clear等。可以理解为一个set的常量。

getattr (object , name [, default ])
获得对象的属性值，name 必须是字符串，如果name 是object 的属性，则getattr(x, 'foobar') 相当于x.foobar ，如果name 不是object 的 属性，则返回default ，如果没有default 就会抛出AttributeError意外。

globals ()
返回一个包含当前“全局符号表”的dict。

hasattr (object , name )
参数是一个对象和一个字符串，如果object 对象有名为name 的属性，则返回True，否则返回False。在 执行getattr(object, name) 之前，可以以此来检测属性的存在性。

hash (object )
如果可能的话，返回object 的hash值，hash值是一个整型的数字，用于快速比较两个对象。两个相等的数字型对象将有相同的 hash值，比如：

>>>










 hash










(










1










)










 == hash










(










1.0










)






















True

help ([object ])
调用内建的帮助系统（交互式）。
如果省略参数，则会进入帮助控制台，出现help> 的提示符，输入相应内容就可以查看相应的帮助。
如果参数是字符串，则在模块名、函数名、类名、方法名、关键字及文档和帮助主题里搜索此字符串，并显示。
如果参数是其他类型的对象，则显示此对象的帮助信息。

hex (x )
将任何长度的整型数字转化为16进制的字符串。
如果转换浮点数为16进制，则须使用float.hex() 方法。

id (object )
返回一个整型（或者长整型）的object 的唯一标识符。注意：两个生命周期没有交叉的对象，也许会返回同一个标识符。（在 CPython里，其实就是返回object 的地址）

input ([prompt ])
等效于 eval(raw_input(prompt))
返回用户输入的python表达式的值，一句话：注意安全。

int ([x [, base ]])
根据x 的值返回一个整数，x 可以是一个含有数字信息的字符串或者数字类型（整型/浮点型/长整型/复数）。可选的base 参 数，代表进制，可以是2~36之间的数字或者0。如果base 的值为0，将会根据x 的值选取适当 的 基数。如果不提供任何参数，将返回0。

isinstance (object , classinfo )
如果object 是classinfo 或者classinfo 的子类的实例，或者是和classinfo 同 类的对象，则返回True。classinfo 也可以是类或者对象组成的tuple，这时候，object 只要是classinfo 里 的一者就返回True：

>>>










 isinstance










(










1










, (










int










,float










)










 )






















True






















>>>










 isinstance










(










1.0










, (










int










,float










)










 )






















True






















>>>










 isinstance










(










"1.0"










, (










int










,float










)










 )






















False

issubclass (class , classinfo )
如果class 是classinfo 的直接或者间接之类的话，就返回True。一个类也被视为自己的之类。同上例，classinfo 也 可以是tuple。

iter (o [, sentinel ])
返回一个“迭代器”对象，根据sentinel 的设置不停地对第一个参数进线取值。当忽略第二个参数时，o 必须是一 个支持__iter__() 或 者__getitem__() 方 法的对象，否则将会抛出TypeError例外。如果提供了sentinel 参数，o 必须是一个可调用的对象，这时 将不停地调用此方法，并返回迭代器的项，知道返回的值等于sentinel 为止，这时将抛出StopIteration。
第二种形式特别适用于打开一个文件，一行行处理文本，知道遇到特定的行：

with










 open










(










"mydata.txt"










)










 as










 fp:











    for










 line in










 iter










(










fp.readline










, "STOP"










)










:











        process_line(










line)

len (s )
返回s 的长度，也就是项数。自建会调用__len__函数取值。

list ([iterable ])
返回一个含有所有iterable 中的元素的list对象。如果参数为空，则返回空的list。

locals ()
和上面的globals() 对应，返回一个包含当前“局部符号表”的dict。在函数里调用的时候，将排除在类中声明的变量。

long ([x [, base ]])
根据字符串或者数字类型的参数，返回一个长整型的数字。参数的含义和上面的int 类似。

map (function , iterable , … )
对iterable 里的每项执行function 函数，并把结果以一个list的形式返回。如果有3个以上的参数， 则后面的参数也需要是可迭代的，map会把额外的参数传给function ，例如，这样可以把两个tuple一一相加得到一个 list：

>>>










 map










(










lambda










 x, add: x + add, (










2










, 4










, 5










)










, (










1










, 3










, 6










)










 )






















[










3










, 7










, 11










]

如迭代器的长度不一致，缺失的项将用None代替：

>>>










 map










(










lambda










 x, add: x + add, (










2










, 4










, 5










)










, (










1










, 3










)










)






















Traceback (










most recent call last)










:











  File "<stdin>"










, line 1










, in










 <










module>






















  File "<stdin>"










, line 1










, in










 <










lambda>






















TypeError










: unsupported operand type










(










s)










 for










 +: 'int'










 and










 'NoneType'

如果function 为None，将用 identity function 代替（好像就是直入直出）。

max (iterable [, args ...][, key ])
如果只给一个参数，就返回iterable 里最大的项；如果是多个参数的话，则返回参数里最大的项。

>>>










 max










(










"abcd"










)






















'd'






















>>>










 max










(










1










, 2










, 3










)






















3

额外的key参数，是用于比较的函数，比如，下面这个可以得到各项除3的余数最大的一个：

>>>










 max










(










[










1










, 2










, 3










, 4










]










, key=lambda










 x: x %










 3










)






















2

min (iterable [, args ...][, key ])
同上，求最小值。

next (iterator [, default ])
依次返回迭代器iterator 的项。当iterator 没有更多的项时，如果有default 参 数，则返回default ，否则抛出StopIteration例外。

>>>










 a = iter










(










range










(










3










)










)






















>>>










 next(










a)






















0






















>>>










 next(










a)






















1






















>>>










 next(










a)






















2






















>>>










 next(










a)






















Traceback (










most recent call last)










:











  File "<stdin>"










, line 1










, in










 <










module>






















StopIteration






















>>>










 next(










a, "No More Item..."










)






















'No More Item...'

object ()
返回一个空的对象，但是此对象会有一些公有的属性：

>>>










 o = object










(










)






















>>>










 dir










(










o)






















[










'__class__'










, '__delattr__'










, '__doc__'










, '__format__'










, '__getattribute__'










, '__hash__'










, '__init__'










, '__new__'










, '__reduce__'










, '__reduce_ex__'










, '__repr__'










, '__setattr__'










, '__sizeof__'










, '__str__'










, '__subclasshook__'










]

oct (x )
将任意精度的十进制整数x 转换成八进制。

open (filename [, mode [, bufsize ]])
打开文件，返回一个文 件对象 ，如果文件打不开，将抛出IOError 错误。
filename 参数，是要打开的文件名。
mode 参数是打开方式，通常是'r' 表示读，'w' 表示写（如果已存在则会覆 盖），'a' 表示追加。缺省为'r' 。另外，缺省使用的是文本模式，会把'/n' 转 成系统相关的换行符，如果要避免这个引起的问题，需要在各个模式后面加一个'b' 表示使用二进制模式。另外还有些’+uU’之 类的模式，不常用，也就不介绍了吧。
可选的bufsize 参数表示缓冲区的大小。0表示不缓冲，1表示行缓冲，其他正数表示近视的缓冲区字节数，负数表示使用系统默认值。 默认是0。

ord (c )
给定一个长度为1的字符串或者unicode字符，返回该字符的ascii码或者unicode码，前一种情况是chr() 的 反函数，后一种情况是unichr() 的反函数。

pow (x , y [, z ])
返回x 的y 次方，也就是x**y 。如果有z 的话，返回x 的y 次 方除z 得到的余数（这个比pow(x, y) % z 更高效
如果第二个参数是负数的话，将返回浮点型的数据，而且这个时候不能有z 。

print ([object , ... ][, sep =' '][, end ='/n'][, file =sys.stdout ])
输出一个或多个object 到file ，中间用sep 间隔，并在结尾加上end 。
后3个参数如果给出的话，必须用keyword arguments的形式，也就是必须指定参数名，否则将一概被视为object 的一 部分而被输出。
需要注意的是和python 2.6前的print关键字的区别。

property ([fget [, fset [, fdel [, doc ]]]])
返回一个属性，参数分别是获取、设置和删除的函数外加doc string，看例子吧：

>>>










 class










 C(










object










)










:











...     def










 __init__










(










self










)










:











...         self










._x = None






















...     def










 getx(










self










)










:











...         print










 "OK. give you:"










, self










._x











...         return










 self










._x











...     def










 setx(










self










, value)










:











...         print










 "Now x is:"










, value











...         self










._x = value











...     def










 delx(










self










)










:











...         del










 self










._x











...     x










 = property










(










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










)






















... 











>>>










 a = C(










)






















>>>










 a.x










 = 123






















Now x is










: 123






















>>>










 print










 a.x






















OK. give










 you: 123






















123






















>>>










 help










(










a.x










)






















OK. give










 you: 123






















 











>>>










 help










(










C.x










)






















#这里可以看到I'm the 'x' property.

range ([start ], stop [, step ])
方便地产生一个包含等差数列的list，如果忽略start ，则默认为0；如果忽略step ，则默认为1。经常被用 于for循环里。注意返回的结果并不包含stop 。

raw_input ([prompt ])
从输入读入一行字符串，结尾的回车将被去掉。如果提供了prompt 参数，将做为输入的提示符。

reduce (function , iterable [, initializer ])
将两个参数的function 函数循环应用到迭代器的各项，例如reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 相当于((((1+2)+3)+4)+5) 。如果提供了可选的initializer 参 数，则会将它放在迭代器的前面进行运算。

reload (module )
重新加载之前已经导入的模块。当你在设计一个模块，并用外部编辑器更新了它的代码时，可以用reload重新导入此模块，来验证模块的正确性。
reload执行时候的具体细节这里就不描述了。

repr (object )
返回一个尽量包含object 的信息的字符串，其实交互式python解释器，在输入一个对象回车的时候，就是返回对象的repr值。
对于很多常见的对象，返回的值都尽可能地使得能够被eval 解释并返回对象本身；另外的就尽量包含所在的域信息和类型或者地址 等。
一个类可以通过__repr__() 方 法自定义repr的返回值。

reversed (seq )
返回一个倒序的迭代器。seq 要么支持 __reversed__() 方法，要么支持取项的操作（也就是支持__len__()方法和从0开始的整数值的__getitem__()方法）。
例子：

>>>










 reversed










(










range










(










5










)










)






















<










listreverseiterator object










 at 0x80a658c>






















>>>










 [










i for










 i in










 reversed










(










range










(










5










)










)










]






















[










4










, 3










, 2










, 1










, 0










]

round (x [, n ])
将浮点数x 四舍五入取整到小数点后n 位小数。n 的默认值是0，也就是取整。

set ([iterable ])
由迭代器iterable 返回一个集合对象，集合中的元素是随机顺序，但是不重复的。此函数在去掉列表的重复项的时候，特别有用：

>>>










 l = [










1










, 2










, 3










, 2










, 4










, 3










]






















>>>










 set










(










l)






















set










(










[










1










, 2










, 3










, 4










]










)






















>>>










 list










(










set










(










l)










)






















[










1










, 2










, 3










, 4










]






















>>>










 ''










.join










(










set










(










"hello"










)










)






















'helo'

setattr (object , name , value )
此函数和getattr() 配合使用，setattr(x, 'foobar', 123) 相当于x.foobar = 123 。

slice ([start ], stop [, step ])
返回一个分片对象，分片对象就只包含了start , stop , step 这3个信息，它在 python内部和一些第三方库中广泛被使用，其实类似a[1:3]这样的操作也会生成分片对象。如果省略start 和step ， 将默认为None。
可以看到下面两者其实是等效的：

>>>










 range










(










5










)










[










slice










(










1










, 4










, 2










)










]






















[










1










, 3










]






















>>>










 range










(










5










)










[










1










:4










:2










]






















[










1










, 3










]

sorted (iterable [, cmp [, key [, reverse ]]])
返回一个排序后的列表，用于排序的元素来自iterable ，后面的参数控制排序的过程。
cmp 是自定义的比较函数，接受两个参数，返回负数表示第一个参数较小，返回0表示两者一样大，返回正数表示第一个参数较大。
key 可以理解为每个参数的求值函数。如果提供了key ，则在比较前，先对每个先用key进线求职，对结果再进行排 序，但是返回的排序后的结果还是之前的值。
reverse 如果是True，则按降序排列，默认是从小到大的升序。
看例子：

#正常的排序






















>>>










 sorted










(










[










1










, 5










, 3










, 4










, 6










]










)






















[










1










, 3










, 4










, 5










, 6










]






















#倒序






















>>>










 sorted










(










[










1










, 5










, 3










, 4










, 6










]










, reverse=True










)






















[










6










, 5










, 4










, 3










, 1










]






















#提供了key，结果是除3的余数谁最小，谁就排前






















>>>










 sorted










(










[










1










, 5










, 3










, 4










, 6










]










, key=lambda










 x: x%










3)






















[










3










, 6










, 1










, 4










, 5










]






















#用cmp实现的版本






















>>>










 sorted










(










[










1










, 5










, 3










, 4










, 6










]










, cmp










=lambda










 x,y: x%










3 - y%










3)






















[










3










, 6










, 1










, 4










, 5










]

值得注意的是，虽然cmp 和key 都可以实现上面的除3余数排列，但是因为cmp 要对每次 比较的两个元素都调用一次函数，所以，效率不如key 来得高。

staticmethod (function )
返回一个静态方法function
要声明一个静态方法，需要使用如下的语法：

class










 C:











    @staticmethod






















    def










 f(










arg1, arg2, ...)










: ...

静态方法可以被类本身调用（例如：C.f() ）也可以被类的对象调用（例如：C().f() ）。

str ([object ])
返回一个精确可打印的字符串，来说明object 。和repr(object) 不同，str(object) 返 回的字符串不一定能被eval()执行来得到对象本身，str(object) 的目标只是可打印和可读。

sum (iterable [, start ])
对iterable 在start 做为初值的基础上进行累加。start 的默认值为0。
注意此方法不能对字符串进行相加（连接）操作，连接字符串还是用''.join(sequence) 好了。另外，sum(range(n), m) 等价于reduce(operator.add, range(n), m) ，要更精确地对浮点数进行累 加，请使用math.fsum() 。

super (type [, object-or-type ])
返回一个指代type 的父类或者兄弟类的对象，可以用这个对象间接地调用父类或者兄弟类的方法。在有复杂的类继承关系结构的时候，会很 有用。用到的时候可以自行研究下这文 章 。

tuple ([iterable ])
返回一个tuple对象（元组），元素来自iterable 。如果省略参数，将返回空的元组。

type (object )
返回object 的类型，返回值本身是个“类型对象”。注意，进行类型判断建议使用isinstance() 函 数。

>>>










 type










(










1










)






















<










type 'int'










>






















>>>










 type










(










type










(










1










)










)






















<










type 'type'










>






















>>>










 type










(










1










)










 == int










  #非常不建议这样的使用方法。






















True






















>>>










 isinstance










(










1










,int










)










   #建议这样使用。






















True

type (name , bases , dict )
不同于上面那个一个参数的type，这个方法用于快速构造一个类，传入的3个参数将分别转化为所得到的类的__name__，__bases__和 __dict__。
例如，下面这两个X是等价的：

>>>










 class










 X(










object










)










:











...     a










 = 1






















...











>>>










 X = type










(










'X'










, (










object










,)










, dict










(










a=1










)










)

unichr (i )
返回一个单个字符的unicode串，此字符的unicode码值为i 。对于Unicode，此函数也是ord()的反函数。i 的 范围由python解释器的编译环境决定。

unicode ([object [, encoding [, errors ]]])
返回一个代表object 的unicode字符串。
如果给定了encoding 和/或errors ，将用ascii或者encoding 指定的编码 对object 进行解码，在遇到解码错误的时候，errors 的值将影响函数的下一步动作：如果errors 的 值是'strict' （默认值），将会抛出ValueError错误；如果errors 的值是'ignore' 将 会忽略错误，继续解码；如果errors 是'replace' ，将使用U+FFFD来替换当前字符。
看个例子，我的utf8环境下：

>>>










 unicode










(










'我是bones7456'










, encoding='utf8'










)






















u'/u










6211/u










662fbones7456'






















>>>










 print










 unicode










(










'我是bones7456'










, encoding='utf8'










)










 #可见解码成功






















我是bones7456











>>>










 unicode










(










'我是bones7456'










)










 #不指定编码方式，将默认使用ascii解码，失败了。






















Traceback (










most recent call last)










:











  File "<stdin>"










, line 1










, in










 <










module>






















UnicodeDecodeError










: 'ascii'










 codec can't decode byte 0xe6 in position 0: ordinal not in range(128)











>>> unicode('










我是bones7456', errors='










ignore') #忽略失败，可以得到英文数字部分











u'










bones7456'











>>> unicode('










我是bones7456', errors='










replace') #替换的话，会加上一堆？？？哈哈。











u'










/ufffd/ufffd/ufffd/ufffd/ufffd/ufffdbones7456'











>>> print unicode('










我是bones7456', errors='










replace')






















u'/u










6211/u










662fbones7456'

如果没有后面的俩参数，unicode() 的行为类似于str() ，只不过返回的 unicode字符串而已。
如果，object 对象提供了__unicode__()方法，将调用此方法来返回一个可被用户自定义的unicode串。

vars ([object ])
如果省略object ，vars() 和locals()类似，如果object 是模块、 类、类的对象或者其他还有__dict__属性的对象的话，就返回它的__dict__。

xrange ([start ], stop [, step ])
此函数和range()非常类似，但是返回的不是一个列表，而是一个xrange对象。xrange对象在被引用时，也能生成列表的各项，但是这些项不是 同时存在于内存里的。xrange和range比的优势是更小巧，更快。

zip ([iterable , ... ])
哈，说到这个函数，我还给python官方文档提过一个bug ， 因为之前版本的文档的示例代码有点小问题，前因后果可以看这里 。
zip函数返回一个元组的列表，第i 个元组，就包含了每个iterable 的第i 项。如果参数的 各iterable 不一样长，会别截取到最短的值，这个值也就是结果列表的长度。
然后，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

__import__ (name [, globals [, locals [, fromlist [, level ]]]])
此函数被import语句调用。代码中很少会用到这个函数，除非你要import的模块名是运行时才可知的。就不详述了。