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的模块名是运行时才可知的。就不详述了。