Python 2.7的内置函数

目录

1. A
   1. abs()
   2. all()
   3. any()
2. B
   1. basestring()
   2. bin()
   3. bool()
   4. bytearray()
3. C
   1. callable()
   2. chr()
   3. classmethod()
   4. cmp()
   5. compile()
   6. complex()
4. D
   1. delattr()
   2. dict()
   3. dir()
   4. divmod()
5. E
   1. enumerate()
   2. eval()
   3. execfile()
6. F
   1. file()
   2. filter()
   3. float()
   4. format()
   5. frozenset()
7. G
   1. getattr()
   2. globals()
8. H
   1. hasattr()
   2. hash()
   3. help()
   4. hex()
9. I
   1. id()
   2. input()
   3. int()
   4. isinstance()
   5. issubclass()
   6. iter()
10. L
    1. len()
    2. list()
    3. locals()
    4. long()
11. M
    1. map()
    2. max()
    3. memoryview()
    4. min(）
12. N
    1. next()
13. O
    1. object()
    2. oct()
    3. open()
    4. ord()
14. P
    1. pow()
    2. print()
    3. property()
15. R
    1. range
    2. raw_input()
    3. reduce()
    4. reload()
    5. repr()
    6. reversed()
    7. round()
16. S
    1. set()
    2. setattr()
    3. slice()
    4. sorted()
    5. staticmethod()
    6. str()
    7. sum()
    8. super()
17. T
    1. tuple()
    2. type()
18. U
    1. unichr()
    2. unicode()
19. V
    1. vars()
20. X
    1. xrange()
21. Z
    1. zip()
22. __
    1. __import__()

A

abs()

abs(x)
返回数字的绝对值。

参数可以是普通或长整数或浮点数。如果参数是一个复数，则返回其大小（复数的模）。

1
2
3

abs(-123) # 123
abs(123)  # 123
abs(complex(3, 4)) # 5.0

all()

all(iterable)
如果iterable的所有元素为真（或迭代器为空），返回True，否则返回False。

1
2
3

all([]) # True
all[1, 2, 3]) # True
all([1, 2, None]) # False

等价于：

1
2
3
4
5

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

any()

any(iterable)
如果iterable的任一元素为真则返回True。如果迭代器为空，返回False。

1
2
3
4

any([]) # False
any([None]) # False
any([1, 2, None]) # True
any([1, None, None]) # True

等价于：

1
2
3
4
5

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

B

basestring()

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

bin()

bin(x)
将整数转换为二进制字符串。

结果是一个有效的Python表达式。如果x不是Python int对象，则必须定义一个返回整数的_index_()方法。

1
2

bin(10) # 0b1010
bin(100) # 0b1100100

bool()

class bool([x])
返回一个布尔值，即True或False。

x为True则返回值为True，x为False返回值为False。

1
2
3
4
5
6
7
8

bool() # False
bool(0) # False
bool(1) # True
bool([]) # False
bool({}) # False
bool(()) # False
bool(True) # True
bool(False) # True

bytearray()

class bytearray([source[, encoding[, errors]]])
返回一个新的字节数组。bytearray类是 0 <= x <256 范围内的可变整数序列。

可选形参 source 可以用不同的方式来初始化数组：

• 如果是unicode，则还必须提供编码（和可选的，错误）参数，bytearray()使用unicode.encode()将unicode转换为字节。
• 如果是一个integer，会初始化大小为该数字的数组，并使用null字节填充。
• 如果是一个符合buffer接口的对象，该对象的只读buffer会用来初始化字节数组。
• 如果是一个iterable可迭代对象，它的元素的范围必须是 0 <= x <256 的整数，它会被用作数组的初始内容。
• 如果没有实参，则创建大小为0的数组。

C

callable()

callable(object)
如果对象参数显示为可调用，则返回True，否则返回False。

如果返回true，则调用仍然可能失败，但如果调用失败，则调用对象将永远不会成功。

chr()

chr(i)
返回一个字符串，其ASCII码为整数i。

参数必须在[0..255]范围内。如果i超出该范围，则会引发ValueError。

1
2

chr(97) # a
chr(65) # A

classmethod()

classmethod(function)
返回一个函数的类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

1
2
3
4

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

cmp()

cmp(x, y)
比较两个对象x和y并根据结果返回一个整数。

如果x < y则返回值为负，如果x == y则返回零，如果x > y则返回为正

1
2
3

cmp(1, 1) # 0
cmp(1, 2) # -1
cmp(2, 1) # 1

compile()

compile(source, filename, mode[, flags[, dont_inherit]])
将源代码编译为代码或AST对象。代码对象可以由exec语句执行，也可以通过调用eval()来评估。

complex()

class complex([real[, imag]])
将字符串或数字转换为复数，返回值为real + imag * j。

1
2

complex(3,4) # (3+4j)
complex('3+4j') # (3+4j)

D

delattr()

delattr(object, name)
setattr()相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如delattr(student, ‘name’)等价于del student.name。

1
2
3
4
5
6
7
8
9
10

class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


student = Student(name='wkt', age=24)
print getattr(student, 'name') # wkt
delattr(student, 'name')
print getattr(student, 'name') # AttributeError

dict()

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
创建一个新的字典。

1
2
3
4
5
6

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
a == b == c == d == e # True

dir()

dir([object])
如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为_dir_()的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义_getattr_()或__getattribute__()函数的对象能够自定义dir()来报告它们的属性。

如果对象不提供_dir_()，这个函数会尝试从对象已定义的_dict_属性和类型对象收集信息。结果列表并不总是完整的，如果对象有自定义_getattr\()，那结果可能不准确。

默认的dir()机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

• 如果对象是模块对象，则列表包含模块的属性名称。
• 如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
• 否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。
• 返回的列表按字母表排序。

1
2
3
4
5

import datetime
dir() 
# ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'datetime']
dir(datetime) 
# ['MAXYEAR', 'MINYEAR', '__doc__', '__file__', '__name__', '__package__', 'date', 'datetime', 'datetime_CAPI', 'time', 'timedelta', 'tzinfo']

1
2
3
4
5
6
7

class Person(object):
    def __dir__(self):
        return ['name', 'sex', 'age']


p = Person()
dir(p) # ['age', 'name', 'sex']

divmod()

divmod(a, b)
取两个数（非复数）作为参数，返回由商和余数组成的一对数。

对于普通类型和长整数，结果与(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)。

1
2

divmod(1, 3)  # (0, 1)
divmod(10, 4) # (2, 2)

E

enumerate()

enumerate(sequence, start=0)
返回一个枚举对象。

sequence必须是序列，迭代器或其他支持迭代的对象。

enumerate（）返回的迭代器的next（）方法返回一个包含计数的元组（从start开始，默认为0）和迭代序列获得的值。

1
2
3
4
5
6

seasons = ['spring', 'summer', 'autumn', 'winter']
list(enumerate(seasons))            
# [(0, 'spring'), (1, 'summer'), (2, 'autumn'), (3, 'winter')]

list(enumerate(seasons, start=1))   
# [(1, 'spring'), (2, 'summer'), (3, 'autumn'), (4, 'winter')]

相当于。

1
2
3
4
5

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

eval()

eval(expression[, globals[, locals]])
参数是Unicode或Latin-1编码的字符串以及可选的全局变量和局部变量。如果提供，globals必须是字典。如果提供，则locals可以是任何映射对象。

表达式参数作为Python表达式（技术上讲，条件列表）被解析和评估，使用全局变量和本地字典作为全局和本地名称空间。如果全局字典存在且缺少‘__builtins__’，则在解析表达式之前将当前全局变量复制到全局变量中。这意味着表达式通常具有对标准__builtin__模块的完全访问权限，并且传播受限制的环境。如果省略locals字典，则默认为globals字典。如果省略两个字典，则表达式在调用eval()的环境中执行。返回值是计算表达式的结果。语法错误报告为异常。

1
2

x = 10
eval(' x + 20 ')  # 30

此函数还可用于执行任意代码对象（例如由compile()创建的代码对象）。在这种情况下，传递代码对象而不是字符串。如果代码对象已使用’exec’作为mode参数进行编译，则eval()的返回值将为None。

execfile()

execfile(filename[, globals[, locals]])
此函数类似于exec语句，但解析文件而不是字符串。它与import语句的不同之处在于它不使用模块管理 - 它无条件地读取文件并且不创建新模块。

参数是文件名和两个可选字典。使用全局和本地字典作为全局和本地命名空间，将文件解析并评估为一系列Python语句（类似于模块）。如果提供，则locals可以是任何映射对象。请记住，在模块级别，全局变量和本地变量是相同的字典。如果将两个单独的对象作为全局变量和局部变量传递，则代码将被执行，就像它嵌入在类定义中一样。如果省略locals字典，则默认为globals字典。如果省略两个字典，则表达式在调用execfile（）的环境中执行。返回值为None。

F

file()

file(name[, mode[, buffering]])
文件类型的构造函数，在文件对象一节中进一步描述。构造函数的参数与下面描述的open()内置函数的参数相同。
打开文件时，最好使用open()而不是直接调用此构造函数。file更适合于类型测试（例如，写入isinstance(f，file)）。

filter()

filter(function, iterable)
从iterable的那些元素构造一个列表，该函数返回true。

iterable可以是序列，支持迭代的容器，也可以是迭代器。

如果iterable是字符串或元组，则结果也具有该类型;否则它总是一个列表。如果function为None，即删除所有可迭代的false元素。

请注意，如果函数不是None，则filter（function，iterable）等效于[item for item in iterable if function(item)]，如果函数为None，则[item for item in iterable if item]。

1
2
3
4
5
6
7
8
9

x = range(1, 10)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

filter(lambda item: item if item % 2 == 0 else None, x)
# [2, 4, 6, 8]

[item for item in x if item % 2 == 0]
# [2, 4, 6, 8]

float()

class float([x])
返回由数字或字符串x构造的浮点数。

如果参数是字符串，则它必须包含可能已赋值的decimal或浮点数，可能嵌入在空格中。参数也可以是[+|-]nan或[+|-] inf。否则，参数可以是普通或长整数或浮点数，并返回具有相同值（在Python的浮点精度内）的浮点数。

如果没有给出参数，则返回0.0。

format()

format(value[, format_spec])
将值转换为“格式化”表示，由format_spec控制。format_spec的解释取决于value参数的类型，但是大多数内置类型都使用标准格式化语法：Format Specification Mini-Language。

1

'hello {0}'.format('world') # hello world

frozenset()

class frozenset([iterable])
返回一个新的frozenset对象，可选地包含从iterable中获取的元素。
返回一个新的set或frozenset对象，其元素取自iterable。集合的元素必须是可以清除的。要表示集合集，内部集合必须是冻结集合对象。如果未指定iterable，则返回新的空集。

G

getattr()

getattr(object, name[, default])
返回对象命名属性的值。

name必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。

例如，getattr(x, ‘foobar’)等同于x.foobar。如果指定的属性不存在，且提供了default值，则返回它，否则触发AttributeError。

globals()

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

H

hasattr()

hasattr(object, name)
参数是一个对象和一个字符串。如果字符串是对象属性之一的名称，则结果为True，否则为False。（这是通过调用getattr(object,name)并查看它是否引发异常来实现的。）

hash()

hash(object)
返回对象的哈希值（如果有的话）。哈希值是整数，它们用于在字典查找期间快速比较字典键。相等的数字值具有相同的哈希值（即使它们具有不同的类型，如1和1.0的情况）。

help()

help([object])
启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

hex()

hex(x)
将整数（任意大小）转换为前缀为“0x”的小写十六进制字符串。

1
2
3

hex(255)    # 0xff
hex(-220)   # -0xdc
hex(1L)     # 0x1L

I

id()

id(object)
返回对象的“标识”。这是一个整数（或长整数），保证在该生命周期内该对象是唯一且恒定的。

具有非重叠生存期的两个对象可以具有相同的id()值。

input()

input([prompt])
相当于eval(raw_input(prompt))。

此功能不会捕获用户错误。如果输入语法无效，则会引发SyntaxError。如果评估期间出现错误，可能会引发其他异常。所以应该使用raw_input()函数来获取用户的常规输入。

如果加载了readline模块，input()将使用它来提供复杂的行编辑和历史记录功能。

int()

class int(x=0)
class int(x, base=10)
返回由数字或字符串x构造的整数对象，如果没有给出参数，则返回0。

如果x是数字，则它可以是普通整数，长整数或浮点数。

如果x是浮点，则转换将截断为零。

如果参数超出整数范围，则函数返回一个long对象。

如果x不是数字或者给定了base，那么x必须是一个字符串或Unicode对象，表示以radix为基数的整数文字。可选地，文字可以在前面加+或-（之间没有空格）并且用空格包围。base-n文字由数字0到n-1组成，a到z（或A到Z）的值为10到35。

默认base为10。允许的值为0和2-36。 Base-2，-8和-16文字可以选择以0b/0B，0o/0O/0或0x/0X作为前缀，与代码中的整数文字一样。Base0表示将字符串完全解释为整数文字，因此实际基数为2，8，10或16。

1
2
3
4
5
6
7
8

int()                   # 0
int(1.1)                # 1
int('11111', base=2)    # 31
int('11111', base=4)    # 341
int('11111', base=8)    # 4681
int('11111', base=16)   # 69905
int('0xa', base=16)     # 10
int('11111', base=0)    # 11111

isinstance()

isinstance(object, classinfo)
如果object参数是classinfo参数的实例，或者是（直接，间接或虚拟）子类的实例，则返回true。

如果classinfo是类型对象（新样式类）并且object是该类型的对象或其（直接，间接或虚拟）子类，则也返回true。

如果object不是类实例或给定类型的对象，则该函数始终返回false。

如果classinfo是某一个类或类型对象的元组（或递归地，其他此类元组），则如果object是这个类或这种类型的实例，则返回true。

如果classinfo不是类，类型和类的元组或类型的元组，则会引发TypeError异常。

issubclass()

issubclass(class, classinfo)
如果class是classinfo的子类（直接、间接或虚拟的），则返回true。

classinfo可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。

其他情况，会触发TypeError异常。

iter()

iter(o[, sentinel])
返回一个迭代器对象。

如果没有第二个参数，o必须是支持迭代协议（__iter__()方法）的集合对象，或者它必须支持序列协议（__getitem__()方法，整数参数从0开始）。

如果它不支持这些协议中的任何一个，则引发TypeError。

如果给出第二个参数sentinel，则o必须是可调用对象。
在这种情况下创建的迭代器将为每个对next（）方法的调用调用o而不带参数；如果返回的值等于sentinel，则会引发StopIteration，否则返回该值。

1
2
3
4
5
6
7
8
9
10

it = iter(range(0, 10))
while True:
    try:
        x = next(it)
        print x,
    except StopIteration:
        break

# 0 1 2 3 4 5 6 7 8 9

第二种形式的iter()的一个有用的应用是读取文件的行直到达到某一行。以下示例读取文件，直到readline()方法返回空字符串。

1
2
3

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

L

len()

len(s)
返回对象的长度（元素个数）。

实参可以是序列（如string、bytes、tuple、list或range等）或集合（如dictionary、set或frozen set等）。

list()

class list([iterable])
返回一个列表，其项目与iterable的项目相同且顺序相同。

iterable可以是序列，支持迭代的容器，也可以是迭代器对象。如果iterable已经是一个列表，则会生成并返回一个副本，类似于iterable[:]。例如，list(‘abc’)返回[‘a’,’b’,’c’]和list((1,2,3))返回[1,2,3]。

如果没有给出参数，则返回一个新的空列表，[]。

list是一个可变序列类型。

locals()

locals()
更新并返回表示当前本地符号表的字典。
locals()在函数块中调用时返回自由变量，但在类块中不调用。

long()

class long(x=0)
class long(x, base=10)
返回由字符串或数字x构造的长整型对象。

如果参数是一个字符串，它必须包含一个可能赋值的任意大小的数字，可能嵌入在空格中。

base参数的解释方式与int()相同，并且只能在x为字符串时给出。

否则，参数可以是普通或长整数或浮点数，并返回具有相同值的长整数。将浮点数转换为整数截断（朝向零）。如果没有给出参数，则返回0L。

1
2
3
4
5
6

long()                  # 0
long('111', base=2)     # 7
long('111', base=10)    # 111
long('111', base=16)    # 273
long(1.11)              # 1
long(0.11)              # 0

M

map()

map(function, iterable, …)
将函数应用于iterable的每个项目并返回结果列表。

如果传递了多个可迭代参数，则函数必须采用所有参数，并且并行地应用于所有迭代的项。

如果一个iterable比另一个短，则假定使用None项扩展。

如果function为None，则假定为identity函数；如果有多个参数，map()返回一个由包含所有迭代中相应项的元组组成的列表（一种转置操作）。可迭代参数可以是序列或任何可迭代对象；结果始终是一个列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def add(x, y):
    if x and y:
        return x + y
    else:
        return x if x else y


l1 = range(1, 4)            # [1, 2, 3]
l2 = range(1, 6)            # [1, 2, 3, 4, 5]
map(None, l1)               # [1, 2, 3]
map(lambda x: x + 1, l1)    # [2, 3, 4]
map(None, l1, l2)           # [(1, 1), (2, 2), (3, 3), (None, 4), (None, 5)]
map(add, l1, l2)            # [2, 4, 6, 4, 5]
map(lambda x, y: x + y if x and y else x if x else y, l1, l2)   # [2, 4, 6, 4, 5]

max()

max(iterable[, key])
max(arg1, arg2, *args[, key])
返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果提供了一个位置参数，则iterable必须是非空的可迭代（例如非空字符串，元组或列表）。

返回iterable中的最大项。如果提供了两个或多个位置参数，则返回最大的位置参数。

可选的key参数指定一个单参数排序函数，就像用于list.sort()的函数一样。键参数（如果提供）必须采用关键字形式（例如，max(a, b, c, key = func)）。

1
2
3
4
5

max(-3, 2)                                  # 2
max(-3, 2, key=lambda x: x * x)             # -3
max(range(0, 1), range(0, 3), range(0, 6))  # [0, 1, 2, 3, 4, 5]
max(range(0, 10))                           # 9
max(range(0, 10), key=lambda x: x * -1)     # 0

memoryview()

memoryview(obj)
返回由给定实参创建的“内存视图”对象。

1
2
3
4
5
6

v = memoryview('abc')   # <memory at 0x10e7c03e0>
type(v)                 # <type 'memoryview'>
v.tobytes()             # abc
v.tolist()              # [97, 98, 99]
v.itemsize              # 1
v.readonly              # True

min(）

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

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

如果提供了一个位置参数，则iterable必须是非空的可迭代（例如非空字符串，元组或列表）。

返回iterable中的最小项。如果提供了两个或多个位置参数，则返回最小的位置参数。

可选的key参数指定一个单参数排序函数，就像用于list.sort()的函数一样。键参数（如果提供）必须采用关键字形式（例如，min(a, b, c, key=func)）。

1
2
3
4
5

min(-3, 2)                                  # -3
min(-3, 2, key=lambda x: x * x)             # 2
min(range(0, 1), range(0, 3), range(0, 6))  # [0]
min(range(0, 10))                           # 0
min(range(0, 10), key=lambda x: x * -1)     # 9

N

next()

next(iterator[, default])
通过调用next()方法从迭代器中检索下一个项目。如果给定default，则在迭代器耗尽时返回，否则引发StopIteration。

1
2
3
4
5
6
7
8

it = iter(range(0, 10))
while True:
    s = next(it, -1)
    print s,
    if s == -1:
        break

# 0 1 2 3 4 5 6 7 8 9 -1

O

object()

class object
返回一个新的无特征对象。object是所有新样式类的基础。它具有新样式类的所有实例共有的方法。

oct()

oct(x)
将整数（任意大小）转换为八进制字符串。结果是一个有效的Python表达式。

1
2
3

oct(8)      # 010
oct(18)     # 022
oct(-128)   # -0200

open()

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

打开文件，返回文件对象部分中描述的文件类型的对象。如果无法打开文件，则引发**IOError**。打开文件时，最好使用open()而不是直接调用文件构造函数。

前两个参数与stdio的fopen()相同：name是要打开的文件名，mode是一个字符串，表示如何打开文件。

最常用的模式值是'r'用于读取，'w'用于写入（截断文件，如果它已经存在），'a'用于追加（在某些Unix系统上意味着所有写入都附加到文件的末尾而不管当前的搜索位置）。如果省略mode，则默认为'r'。默认设置是使用文本模式，可以在写入时将“\n”字符转换为特定于平台的表示，并在读取时返回。因此，在打开二进制文件时，您应该将'b'附加到模式值以在二进制模式下打开文件，这将提高可移植性。

可选的buffering参数指定文件所需的缓冲区大小：0表示无缓冲，1表示行缓冲，任何其他正值表示使用（大约）该大小（以字节为单位）的缓冲区。负缓冲意味着使用系统默认值，通常为tty设备进行行缓冲，并为其他文件进行完全缓冲。如果省略，则使用系统默认值。

模式’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。

ord()

ord(c)
给定一个长度为1的字符串，当参数是unicode对象时，或者参数是8位字符串时的字节值。，返回表示字符的Unicode代码点的整数。

例如，ord(‘a’)返回整数97，ord(u’\u2020’)返回8224。这是8位字符串的chr()和unicode对象的unichr()的反转。如果给出了unicode参数并且Python是使用UCS2 Unicode构建的，则字符的代码点必须在[0..65535]范围内；否则字符串长度为2，将引发TypeError。

1
2
3
4

ord('A')        # 65
chr(65)         # A
unichr(65)      # A
ord(u'\u1024')  # 4132

P

pow()

pow(x, y[, z])
返回x的y次幂；如果z存在，则对z取余（比直接pow(x, y)%z计算更高效）。两个参数形式的pow(x, y)等价于幂运算符：x**y。

参数必须具有数字类型。对于混合操作数类型，二进制算术运算符的强制规则适用。

对于int和long int操作数，结果与操作数具有相同的类型（在强制类型转换之后），除非第二个参数为负；在这种情况下，所有参数都转换为float并传递float结果。例如，10**2返回100，但10**-2返回0.01。

1
2
3
4
5
6
7

pow(2, 10)      # 1024
2 ** 10         # 1024
pow(2, -10)     # 0.0009765625
2 ** -10        # 0.0009765625
pow(2, 10, 10)  # 4
2 ** 10 % 10    # 4
pow(2, -10, 10) # TypeError

print()

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
将对象打印到流文件，由sep分隔，然后结束。 sep，end和file（如果存在）必须作为关键字参数给出。

所有非关键字参数都会被转换为字符串，就像是执行了str()一样，并会被写入到流，以sep且在末尾加上 end。sep和end都必须为字符串；它们也可以为None，这意味着使用默认值。如果没有给出objects，则 print()将只写入end。

file参数必须是带有write(string)方法的对象;如果它不存在或None，将使用sys.stdout。输出缓冲由文件确定。例如，使用file.flush()确保在屏幕上立即显示。

此功能通常不作为内置函数提供，因为名称print被识别为print语句。要禁用该语句并使用print()函数，请在模块顶部使用此future语句：

1

from __future__ import print_function

property()

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

返回新样式类（从object派生的类）的属性。

fget是获取属性值的函数。fset是用于设置属性值的函数。fdel是用于删除属性值的函数。并且doc为属性对象创建文档字符串。
一个典型的用法是定义一个托管属性x:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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，delc.x将调用deleter。

如果给出，doc将成为该property属性的文档字符串。否则该property将拷贝fget的文档字符串（如果存在）。这令使用property() 作为decorator来创建只读的特征属性可以很容易地实现：

1
2
3
4
5
6
7
8

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

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

以上@property装饰器会将voltage()方法转化为一个具有相同名称的只读属性的“getter”，并将voltage的文档字符串设置为“Get the current voltage.”

特征属性对象具有getter，setter以及deleter方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。这最好是用一个例子来解释:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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。

R

range

range(stop)
range(start, stop[, step])
这是一个用于创建包含算术进度的列表的通用函数。它最常用于for循环。

参数必须是普通整数。如果省略step参数，则默认为1。如果省略start参数，则默认为0。

如果step为正，则最后一个元素是最大的start + i * step小于stop；如果step为负数，则最后一个元素是最小的start + i * step大于stop。step不能为零，否则引发ValueError。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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)
# []
range(0, 10, -1)
# []

raw_input()

raw_input([prompt])
如果存在prompt参数，则将其写入标准输出而不带尾随换行符。该函数从输入中读取一行，将其转换为字符串（剥离尾部换行符），然后返回该行。读取EOF时，会引发EOFError。

1
2

s = raw_input("what's your name?\n")    # wangkuntian
print s                                 # wangkuntian

如果加载了readline模块，则raw_input()将使用它来提供精细的行编辑和历史记录功能。

reduce()

reduce(function, iterable[, initializer])
从左到右累加两个参数的函数到iterable项，以便将iterable减少为单个值。例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算的是((((1+2)+3)+4)+5)的值。左参数x是累加值，右参数y是迭代的更新值。如果存在可选的initializer设定项，则它将放置在计算中的iterable项之前，并在iterable为空时用作默认值。如果未给出initializer且iterable只包含一项，则返回第一项。大致相当于：

1
2
3
4
5
6
7
8
9
10
11

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

reload(module)
重新加载以前导入的模块。参数必须是模块对象，因此必须先成功导入。如果您使用外部编辑器编辑了模块源文件并希望在不离开Python解释器的情况下试用新版本，这将非常有用。返回值是模块对象（与模块参数相同）。

执行重载（模块）时：

• 重新编译Python模块的代码并重新执行模块级代码，定义一组新的对象，这些对象绑定到模块字典中的名称。扩展模块的init功能不会第二次调用。
• 与Python中的所有其他对象一样，只有在引用计数降为零后才会回收旧对象。
• 模块名称空间中的名称将更新为指向任何新对象或已更改的对象。
• 对旧对象的其他引用（例如模块外部的名称）不会反弹以引用新对象，如果需要，必须在每个命名空间中进行更新。

还有其他一些警告：
重新加载模块时，将保留其字典（包含模块的全局变量）。名称的重新定义将覆盖旧的定义，因此这通常不是问题。如果新版本的模块未定义旧版本定义的名称，则旧定义仍然存在。如果模块维护对象的全局表或缓存，则此功能可用于模块的优势 - 使用try语句可以测试表的存在并在需要时跳过其初始化：

1
2
3
4

try:
    cache
except NameError:
    cache = {}

重新加载内置或动态加载的模块通常不是很有用。不建议重新加载sys，__main__，builtins和其他关键模块。在许多情况下，扩展模块不是设计为多次初始化，并且在重新加载时可能以任意方式失败。

如果一个模块使用from … import …从另一个模块导入对象，则为另一个模块调用reload（）不会重新定义从它导入的对象 - 一种方法是重新执行from语句，另一种方法是使用导入和限定名称（module.*name*）。

如果模块实例化类的实例，则重新加载定义类的模块不会影响实例的方法定义 - 它们继续使用旧的类定义。派生类也是如此。

repr()

repr(object)
返回包含对象的可打印表示的字符串。这与转换（反向引号）产生的值相同。

能够以普通函数的形式访问此操作有时很有用。对于许多类型，此函数尝试返回一个字符串，该字符串在传递给eval()时会产生具有相同值的对象，否则表示是一个括在尖括号中的字符串，其中包含对象类型的名称以及通常包括对象名称和地址的附加信息。

类可以通过定义__repr__()方法来控制此函数为其实例返回的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

repr(123)                       # 123
repr('123')                     # '123'
repr(object())                  # <object object at 0x10e8b50f0>


class Student(object):
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return 'The student is %s' % self.name


repr(Student('wangkuntian'))    # The student is wangkuntian

reversed()

reversed(seq)
返回一个反向的 iterator。seq必须是一个具有__reversed__()方法的对象或者是支持该序列协议（具有从0开始的整数类型参数的__len__()方法和__getitem__()方法）。

1
2

list(reversed(range(10)))
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

round()

round(number[, ndigits])
返回舍入到小数点后的ndigits数字的浮点值数字。如果省略ndigits，则默认为零。

结果是一个浮点数。将值四舍五入为函数减去ndigits的最接近的10的倍数；如果两个倍数相等，则舍入远离0（因此，例如，round(0.5)为1.0，round(-0.5)为-1.0）。

S

set()

class set([iterable])
返回一个新的set对象，可以选择带有从iterable获取的元素。set是一个内置类型。

setattr()

setattr(object, name, value)
此函数与getattr()两相对应。其参数为一个对象、一个字符串和一个任意值。字符串指定一个现有属性或者新增属性。函数会将值赋给该属性，只要对象允许这种操作。例如，setattr(x, ‘foobar’, 123)等价于 x.foobar = 123。

slice()

class slice(stop)
class slice(start, stop[, step])
返回一个表示由range(start, stop, step)所指定索引集的slice对象。其中start和step参数默认为None。

切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性start，stop 和 step。它们没有其他的显式功能；不过它们会被NumPy以及其他第三方扩展所使用。切片对象也会在使用扩展索引语法时被生成。例如：a[start:stop:step]或a[start:stop, i]。

sorted()

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（直接比较元素）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import random


class Student(object):
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return 'student: %s' % self.name


students = [Student(str(random.randint(0, 5))) for i in range(0, 5)]
# [student: 3, student: 0, student: 5, student: 2, student: 4]
sorted(students, cmp=lambda x, y: cmp(x.name, y.name))
# [student: 0, student: 2, student: 3, student: 4, student: 5]
sorted(students, key=lambda x: x.name)
# [student: 0, student: 2, student: 3, student: 4, student: 5]

staticmethod()

staticmethod(function)
返回一个静态的函数方法。
静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法：

1
2
3
4

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

str()

class str(object=’’)
返回一个包含对象的可打印表示的字符串。

对于字符串，这将返回字符串本身。与repr(object)的区别在于str(object)并不总是尝试返回eval()可接受的字符串；它的目标是返回一个可打印的字符串。

如果没有给出参数，则返回空字符串’’。

sum()

sum(iterable[, start])
从start开始自左向右对iterable中的项求和并返回总计值。

start默认为0。iterable的项通常为数字，开始值则不允许为字符串。

1
2

x = range(0, 10)    # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sum(x, 10)          # 55

super()

super(type[, object-or-type])
返回一个代理对象，它会将方法调用委托给type指定的父类或兄弟类。这对于访问已在类中被重载的继承方法很有用。搜索顺序与 getattr()所使用的相同，只是type指定的类型本身会被跳过。

type的__mro__属性列出了getattr()和super()所使用的方法解析顺序。该属性是动态的，可以在继承层级结构更新的时候任意改变。

如果省略第二个参数，则返回的超类对象是未绑定的。如果第二个参数为一个对象，则isinstance(obj, type)必须为真值。如果第二个参数为一个类型，则issubclass(type2, type)必须为真值（这适用于类方法）。

super 有两个典型用例。

1. 在具有单继承的类层级结构中，super可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。这种用法与其他编程语言中super的用法非常相似。
2. 用例是在动态执行环境中支持协作多重继承。此用例为Python所独有，在静态编译语言或仅支持单继承的语言中是不存在的。这使得实现“菱形图”成为可能，在这时会有多个基类实现相同的方法。好的设计强制要求这种方法在每个情况下具有相同的调用签名（因为调用顺序是在运行时确定的，也因为该顺序要适应类层级结构的更改，还因为该顺序可能包含在运行时之前未知的兄弟类）。

1
2
3

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

T

tuple()

tuple([iterable])
返回一个元组，其元素与iterable的项目相同且顺序相同。

iterable可以是一个序列，一个支持迭代的容器，或一个迭代器对象。如果iterable已经是一个元组，则返回不变。例如，tuple(‘abc’)返回(‘a’, ‘b’, ‘c’)和tuple([1, 2, 3])返回(1, 2, 3)。如果没有给出参数，则返回一个新的空元组()。

type()

class type(object)
class type(name, bases, dict)
使用一个参数时，返回对象的类型。返回值是一个类型对象。建议使用isinstance()内置函数来测试对象的类型。

使用三个参数时，返回一个新类型对象。这实际上是类语句的动态形式。名称字符串是类名，并成为__name__属性；base元组列出基类并成为__bases__属性；dict字典是包含类体定义的命名空间，并成为__dict__属性。例如，以下两个语句创建相同的类型对象：

1
2
3
4

class X(object):
    a = 1

X = type('X', (object,), dict(a=1))

U

unichr()

unichr(i)
返回Unicode代码为整数i的一个字符的Unicode字符串。例如，unichr(97)返回字符串u’a’。这是Unicode字符串的ord()的反转。

参数的有效范围取决于Python的配置方式 - 可能是UCS2[0..0xFFFF]或UCS4[0..0x10FFFF]。否则会引发ValueError。

1
2

ord('A')    # 65
unichr(65)  # A

unicode()

unicode(object=’’)
unicode(object[, encoding[, errors]])
使用以下模式之一返回对象的Unicode字符串版本：

• 如果给出了encoding和/或errors，unicode()将使用编解码器解码对象，该对象可以是8位字符串或字符缓冲区。encoding参数是一个给出编码名称的字符串；如果编码未知，则引发LookupError。错误处理是根据错误完成的；这指定了对输入编码中无效的字符的处理。如果错误是’strict’（默认值），则会在出现错误时引发ValueError，而值为’ignore’会导致错误被忽略，值为’replace’会导致官方Unicode替换字符，U+FFFD替换无法解码的输入字符。
• 如果没有给出可选参数，unicode()将模仿str()的行为，返回Unicode字符串而不是8位字符串。更确切地说，如果object是Unicode字符串或子类，它将返回该Unicode字符串，而不应用任何其他解码。
• 对于提供__unicode__()方法的对象，它将调用此方法而不使用参数来创建Unicode字符串。对于所有其他对象，请求8位字符串版本或表示，然后使用’strict’模式下的默认编码的编解码器将其转换为Unicode字符串。

  1 2 3 4 5 6 7 8 9 10 11

  class Student(object): def __init__(self, name): self.name = name def __unicode__(self): return u'student: %s' % self.name unicode(Student('wangkuntian')) # student: wangkuntian unicode('王', encoding='utf-8') # 王 unicode('呼yue', errors='ignore') # yue

V

vars()

vars([object])
返回模块、类、实例或任何其它具有__dict__属性的对象的__dict__属性。

模块和实例等对象具有可更新的__dict__属性；但是，其他对象可能对其__dict__属性有写限制（例如，新式类使用dictproxy来防止直接字典更新）。

1
2
3
4
5
6

class Student(object):
    def __init__(self, name):
        self.name = name


vars(Student('wangkuntian'))    # {'name': 'wangkuntian'}

X

xrange()

xrange(stop)
xrange(start, stop[, step])
此函数与range()非常相似，但返回xrange对象而不是list。

这是一个不透明的序列类型，它产生与相应列表相同的值，而不是实际同时存储它们。xrange()在range()上的优势是最小的（因为xrange()在被要求时仍需要创建值），除非在内存饥饿的机器上使用非常大的范围或者当所有范围的元素都是没用过（例如当循环通常以break结束时）。

Z

zip()

zip([iterable, …])
此函数返回元组列表，其中第i个元组包含来自每个参数序列或迭代的第i个元素。返回的列表的长度被截断为最短参数序列的长度。

当有多个参数长度相同时，zip()类似于map()，初始参数为None。使用单个序列参数，它返回一个1元组的列表。没有参数，它返回一个空列表。

保证了迭代的从左到右的评估顺序。这使得使用zip(*[iter(s)]*n)将数据序列聚类成n长度组的习惯成为可能。

zip()与*运算符相结合可以用来拆解一个列表：

1
2
3
4
5
6

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)              # [(1, 4), (2, 5), (3, 6)]
x2, y2 = zip(*zipped)
x == list(x2) and y == list(y2) # True

__

__import__()

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

import语句调用此函数。它可以替换（通过导入__builtin__模块并分配给__builtin__.__import__）以更改import语句的语义，但是现在通常使用导入钩子更简单。直接使用__import__()很少见，除非您要导入名称仅在运行时已知的模块。

该函数会导入name模块，有可能使用给定的globals和locals来确定如何在包的上下文中解读名称。fromlist给出了应该从由name 指定的模块导入对象或子模块的名称。标准实现完全不使用其locals参数，而仅使用globals参数来确定import语句的包上下文。

level指定是使用绝对导入还是相对导入。默认值为-1表示将同时尝试绝对与相对导入。0表示仅执行绝对导入。level的正值表示要搜索的父目录相对于调用__import__()的模块的目录的数量。

当name变量的形式为package.module时，通常将会返回最高层级的包（第一个点号之前的名称），而不是以name命名的模块。 但是，当给出了非空的fromlist参数时，则将返回以name命名的模块。

例如，语句import spam的结果将为与以下代码作用相同的字节码：

1

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

语句import spam.ham的结果将为以下调用：

1

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

语句from spam.ham import eggs, sausage as saus 的结果将为：

1
2
3

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

在这里，spam.ham模块会由__import__()返回。要导入的对象将从此对象中提取并赋值给它们对应的名称。

如果你只想按名称导入模块（可能在包中），请使用importlib.import_module()。