内建方法

说明:[,xxx]表示为可选参数。

abs(x)

返回x的绝对值，例如：

abs(-1.23) # 1.23

all(iterable)

如果iterable(迭代对象)的所有元素为真（或者iterable为空：[],”,()等），返回True。例如：

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

any(iterable)

如果iterable中只要又一个元素为真，就返回True。例如：

any([1,2,3,0]) # True

basestring()

它是str和unicode的超类，不能被调用或者实例化。只能用来测试一个对象是不是str或unicode的实例。例如：

a = u‘a‘
b = ‘b‘
isinstance(a, basestring) # True
isinstance(b, basestring) # True

bin()

将整数转成二进制字符串。

bin(3) # ‘0b11‘

bool()

将一个值转化成布尔值。

bool(1) # True
bool(0) # True
bool(‘‘) # False
bool(‘ ‘) # True
bool([]) # False

bytearray()

结合memoryview，实现改变str类型对象的值。请移步python内建类型

callable(object)

如果object参数可调用，返回True；否则返回False。对类的调用，返回一个新的实例。对于实例，如果实例有call方法，则该实例也是可以调用的。例如：

class TestCallable(object):
    def __init__(self):
        pass

    def __call__(self):
        pass

callable(TestCallable) # True
callable(TestCallable()) # True

chr(i)

返回一个字符，该字符的ASCII码为整数i。i的取值范围：0 <= x < 255

chr(100) # ‘d‘
ord(‘d‘) # 100

classmethod(functions)

将传入的方法包装成类方法（类方法是指，类不需要实力化就可以直接调用的方法）。
类方法的第一个参数必须为类（约定俗称用cls代表），实例方法的第一个参数必须为实例（约定俗称为self），这两种接收参数的方法叫做：隐式第一参数（implicit first argument）。静态方法（通过@staticmethod装饰的方法)不需要如上述两个方法的隐式参数。

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

注意：通过@classmethod修饰的方法，为类方法。类可以直接调用（如C.f())；实例也可以直接调用（如C().f())，切记类方法中不能操作实例的属性。如果子类调用类方法，子类对象被传递为隐式的第一个参数（也就是cls为子类对象）。

cmp(x, y)

比较两个对象x和y，当x < y返回’-1’；x > y返回’1’;x == y返回0

cmo(1, 3) # -1
cmp(3, 1) # 1
cmp(1, 1) # 0

注意：bool(-1)结果为True

compile(source, filename, mode)

compile可以将字符串或者Unicode字符串编译成代码对象。代码对象可以通过exec或eval执行。

• 参数source：字符串或者AST（Abstract Syntax Trees）对象。
• 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

• 参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。

  source ="if cmp(1, 1)==0: print ‘yes‘"
  test_compile = compile(source, ‘‘, ‘exec‘)
  exec(test_compile)  #yes

  注意：source是字符串，要注意引号和双引号，最后指定什么model，就用那种方法执行。compile返回的类型是code。

complex(str)

创建一个复数。

complex(‘1+2j‘) #可行
complex(‘1 + 2j‘) #报错(因为字符串中‘+‘或者‘-‘两遍不能有空白)

delattr(object, name)

参数是一个对象和一个字符串(name为字符串类型)，字符串必须是该对象的某个属性名。效果是：删除该对象的name对应的属性。

class Test(object):
    def __init__(self):
        self.name = ‘XueWeiHan‘
test_delatter = Test()
test_delatter.name # XueWeiHan
delattr(test_delatter, ‘name‘)
test_delatter.name # 报错，没有name属性，删除成功

dict()

创建一个新字典。

dict(a=1) # {‘a‘: 1}

dir(object)

如果没有参数，返回当前本地作用域的名字列表。如果有参数，返回该参数的属性列表(属性和方法)。
如果类中定义了__dir__方法，则dir()会先默认从__dict__属性中收集信息。

import time
type(time)  # model
dir(time)   # [‘__doc__‘,‘__file__‘,...,‘sleep‘,‘strftime‘,]就是time.可以调用的属性和方法
class TestDir(object):
    def __dir__(self):
        return [‘TestDir1‘, ‘TestDir2‘]
dir(TestDir)  # [‘TestDir1‘, ‘TestDir2‘]

注意：dir()主要是方便交互环境

divmod(a, b)

效果：a除以b，返回商和余数的二元组（两个数组成的元组）

divmod(5, 2)  #(2, 1)

enumerate(sequence, start=0)

返回一个枚举对象。sequence必须是序列，迭代器iterator，或者支持迭代的对象：

迭代器Iterators:
迭代器仅是一容器对象，它实现了迭代器协议。它有两个基本方法：
1）next方法
返回容器的下一个元素
2）__iter__方法
返回迭代器自身

names = [‘Xuweihan‘, ‘James‘, ‘Kobe‘]
enumerate_data = (names, start=0)  #这是个枚举类型数据
list(enumerate_data)  #[(0, ‘Xuweihan‘), (1, ‘James‘), (2, ‘Kobe‘)]

list(enumerate(names, 1))  #[(1, ‘Xuweihan‘), (2, ‘James‘), (3, ‘Kobe‘)]

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

注意：enumerate是生成器，惰性计算。可以调用next()

eval(expression[,globals()[,locals()]])

expression参数被当作python表达式执行。使用globals()和locals()指定执行的代码中变量是全局变量还是本地变量。代码例子如下：

a = 1  #全局变量

def add_one():
    a = 2  #本地变量
    eval(‘a+1‘, globals())  #结果为 2
    eval(‘a+1‘, locals())  #结果为 3

execfile(filename[,globals[,locals]])

该函数类似exec（上面的那个），不同的是他解析一个文件，而不是字符串。它不同与__import__语句的地方在于，它不使用模块管理——它无条件的读入文件且不会创建一个新模块。
(不常用)

file()

file类型的构造函数。打开一个文件的时候，建议使用open()而不使用file()。file更适合类型检测例如：isinstance(f, file)。

filter(functions, iterable)

构造一个列表，列表的元素来自于iterable，返回对于这些元素function返回True的元素。iterable可以是个序列，支持迭代的容器或者一个迭代器。
filter函数相当于过滤，返回符合functions的列表中的元素。带判断的列表生成式:[i for i in list if i]

test_list = [‘python‘, ‘ruby‘, ‘node.js‘]
result = filter((lambda x: x==‘python‘), test_list)  ＃结果：[‘python‘]

float()

将字符串或者数字转化成浮点数。

float(‘.3333‘)  #0.3333
float(‘a.333‘)  #报错
float(1)  #1.0

format(value[,format_spec])

将value转化成“格式化”的表现形式，格式由format_spec控制。

_string = ‘{name} is a pythoner‘.format(name=‘Xueweihan‘)
print _string  # ‘Xueweihan is a pythoner‘

frozenset()

返回一个新的forzenset对象。就是一个不可变的集合，所以存在哈希值，可以作为字典的key。
注意：python的集合类型不支持整数。

getattr(object, name[,default])

返回object的属性值。name必须是个字符串。如果名字指明的属性不存在，则返回default参数。

例如：getattr(x, ‘test‘)等于x.test。

globals()

globals(x)，x成为全局变量。

hasattr(object, name)

参数是一个对象和一个字符串。如果对象含有该属性则返回True；否则返回False。

hash(object)

返回对象的hash值。hash值是整数，它被用于字典查找时快速比较字典的键。相同的数值有相同的hash（例如：1和1.0的hash值相同）

help([object])

调用帮助系统（主要用于交互式的使用过程中）。如果没有指定object的话，则进入交互式的help帮助系统。

hex()

将number类型的数据，转化成“0x”打头小写的十六进制字符串：

hex(33)  #‘-0x21‘

#float类型数据
float.hex(0.32)  #‘0x1.47ae147ae147bp-2‘

id(object)

返回对象的“表示”，这是一个整数，在对象的生命期内唯一且不变。
注意：CPython中：id就是对象的内存地址。

id(33)  # 140300932661128

a = 33
id(a)  # 140300932661128

b = 33
id(b)  # 140300932661128

input()

获取用户的输入。

建议用：raw_input

int(x, base=10)

将数字或字符串x转化成一个整数，如果没有参数则返回0。

isinstance(object, classinfo)

如果参数object是参数classinfo的一个实例；或者是一个子类的实例，最终返回真。

推荐使用这个而不是用type进行判断。

isinstance(1, int)  #True

issubclass(class, classinfo)

如果class是classinfo的子类，则返回真。

iter(o[,sentinel])

返回一个iterator(迭代器)对象。如果没有第二个参数，o必须是个集合独享，要么支持迭代协议参考，要么支持序列协议。例如：

for x in [1, 2, 3]:
    pass

#等同于
it = iter([1, 2, 3])

while True:
    try:
        x = next(it)
    except StopIteration:
        break

如果有第二个参数sentinel，o必须是个可调用对象。使用场景：

# 读取一个文件的行，直到读到特定行
with open(‘test.txt‘) as fp:
    for line in iter(fp.readline, ‘‘):
        process_line(line)

len(s)

返回对象的长度（元素的个数）。s可以是：序列或者集合。

len(‘xueweihan‘)  #9

list([iterable])

返回一个列表，其中的元素来自于iterable。iterable可以是个序列，支持迭代的容器，或者迭代器对象。

list(‘xueweihan‘)  #[‘x‘, ‘u‘, ‘e‘, ‘w‘, ‘e‘, ‘i‘, ‘h‘, ‘a‘, ‘n‘]

locals()

把传入的变量，修饰成局部变量。

long()

将一个字符串或者数字传化成一个长整数。

map()

遍历iterable的每个元素，并把元素作为参数传入function，返回结果的列表。

def add_two(num):
    return num+2
num_list = [1,2,3,4,5]
map(add_two, num_list) #[3,4,5,6,7]

max()

返回可迭代的对象中最大的元素。

memoryview()

返回memoryview对象，它允许Python代码访问对象的内部数据而不用复制，只要该对象支持缓冲区协议。
如有疑问请参考python内建类型memoryview

min()

返回可迭代的对象中的最小的元素。

next(iterator[,default])

通过调用iterator(迭代器)的next()方法，得到它的下一个元素。如果有default参数，在迭代器迭代完之后返回该参数；否则抛出StopIteration。

test_next_data = iter([1,2,3])
print next(test_next_data, ‘Done‘)  #1
print next(test_next_data, ‘Done‘)  #2
print next(test_next_data, ‘Done‘)  #3
print next(test_next_data, ‘Done‘)  #Done

注意:通过iter()返回的就是迭代器。

object()

object是所有新式类的基类

class A(object):
    pass
#继承于object的类为新式类

oct()

将任意一个整数转成一个八进制字符串。

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

打开文件的方法，返回一个file类型对象。如果文件不能打开抛出IOError。
mode：用什么方式打开文件。’r’读文件；’w’写文件；’a’附加。如果没有mode，默认是’r’。
buffering: 缓冲

ord()

参考：chr()

注意:如果是unicode,则返回unicode码

pow(x, y[,z])

返回x的y次幂：x**y
如果有z参数：(x**y) % z

print()

这个方法可以输出内容到file对象。
注意:不常用，为了使print语句失效，而是用print()函数。（print和print()不是一个东西）可以在你的模块上面使用future语句：from __future__ import print_function

property()

property其实就是个控制属性的权限的方法。同时实现，经property装饰的方法，可通过Object.xxx调用属性，把实例方法，变成实例的属性。这样做的好处是：可以在方法中实现限制条件，同时限制可执行的操作。

class Student(object):
    def __init__(self):
        self._name = None
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, value):
    if value != ‘xueweihan‘:
        self._name = value
    @name.deleter
    def name(self):
        print ‘del name!‘
        del self._name
s = Student()
s.name = ‘aaa‘
s.name  #赋值成功‘aaa‘
s.name = ‘xueweihan‘
s.name  #赋值失败‘aaa‘
del s.name  #‘del name!’

注意:@property可以控制属性，比如只读属性：不实现@xxx.setter和@xxx.deleter就可以了。

range(start, stop[,step])

用于创建列表，‘要头不要尾’。setp参数为步长

range(5)  #[0, 1, 2, 3, 4]
range(2, 4)  #[2, 3]
range(10, 20, 5)  #[10, 15]

raw_input()

获取控制台的输入

reduce(function,iterable[,initializer])

将带有两个参数的function累计地应用到iterable的元素上，从左向右。如果提供可选的参数initializer，它在计算时放在可迭代序列的最前面，并且当可迭代序列为空时作为默认值。例如：

reduce((lambda x,y: x+y), [1, 2, 3, 4])
#相当于计算(((1+2)+3)+4)

reload(module)

如果你重新修改了模块，并且不打算停止重新启动python解释器的情况下使用该模块的最新版本。那么就使用reload()，在reload之前就需要确保import过。

# test_reload.py
print ‘a‘

import test_reload  #‘a‘
#修改test_reload.py ——> print ‘b‘

import test_reload  #什么都输出，因为没有之前已经import过了，所以没有重新加载

reload(test_reload)  #‘b‘重新加载成功！

repr(object)

精准的返回某个对象可打印形式的字符串。返回的值，可以通过eval()执行。

a = repr(‘a‘)  #"‘a‘"

reversed(seq)

返回一个反向的迭代器。seq必须是一个具有__reversed__()方法或支持序列协议的对象（实现__len__()和__getitem__()方法）。

test_reverse = reversed([1, 2, 3, 4])  #<listreverseiterator object at 0x10bcab810>
test_reverse.next   #4

注意:可以编写一个定制的__reversed__()方法的可能。

round(number[, ndigits])

返回一个浮点数的近似值，保留小数点后ndigits位，默认ndigits为零。这个方法不好用，因为近似值不是四舍五入。

round(2.675,2)  #2.67

set([iterable])

返回一个集合对象，iterable是可迭代的对象。

setattr(object,name,value)

给object的属性赋值，可以是存在的属性，也可以是不存的属性。例如：setattr(s, ‘name‘,‘xueweihan‘)等同于s.name=‘xueweihan‘

slice()

常用的切片方法：

a = [1, 2, 3]
a[1:2]  #2

sorted(iterable[,cmp[,key[,reverse]]])

用于iterable对象排序的方法。

• cmp指定一个自定义的带有两个参数的比较函数（可迭代的元素），它应该根据第一个参数是小于、等于还是大于第二个参数返回负数、零或者正数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。
• key指定一个带有一个参数的函数，它用于从每个列表元素选择一个比较的关键字：key=str.lower。默认值是None（直接比较元素）。
• reverse是一个布尔值。如果设置为True，那么列表元素以反向比较排序。

class Student:
    def __init__(self, name, grade, age):
            self.name = name
            self.grade = grade
            self.age = age
    def __repr__(self):
            return repr((self.name, self.grade, self.age))

student_objects = [
    Student(‘john‘, ‘A‘, 15),
    Student(‘jane‘, ‘B‘, 12),
    Student(‘dave‘, ‘B‘, 10),
]
sorted(student_objects, key=lambda student: student.age)   # sort by age
#结果为：[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

staticmethod(function)

返回一个静态方法。

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

注意:静态方法基可以在类上调用C.f()，也可以在实例上调用C().f()。

str(object=”)

返回一个字符串，包含对象的友好可打印表达形式。
注意:print调用的就是对象的__str__方法

sum(iterable[,start])

将iterable的元素从左向右相加并返回总和。

sum([1, 2, 3])  #6
sum([1, 2, 3], 2)  #8

super()

用于显性的指定父类的方法。同时实现方法的绑定。

class C(B):
    def method(self, arg):
        super(C, self).method(arg)  #C的父类实例的method()

tuple([iterable])

返回一个元素，元素顺序和iterable的元素相同。

type(object)

返回object的类型。

type(name, bases, dict)

class X(object):
    a = 1

X = type(‘X‘, (object,), dict(a=1))  # 当传入三个参数时，返回一个新的类型对象。

unichr(i)

返回Unicode类型数据i的Unicode码。例如：unichr(97)返回字符串u‘a‘。

unicode(object=”)

返回object的Unicode版字符串

vars([object])

返回模块，类，实例或者其他任何具有__dict__属性的对象的__dict__属性。(key:value形式的__dict__属性)

xrange(x)

和range()方法一样，区别就是它返回的是一个xrange对象而不是一个列表。惰性计算！当x很大的时候，一定要用xrange。

zip([iterable,…])

该函数返回一个元组的列表，其中第i个元素包含每个元素的序列的第i个元素。

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__()
这种高级引入模块的方法，不常用，所以pass