[pyhton]python内建方法

撸一遍python的内建方法

这样做的好处就是：我如果要完成一个功能的时候，如果能用内建方法完成，就用内建方法。这样可以提高效率，同时使自己的代码更加优雅。哎呦？那岂不是撸完就是python高手了？我先帮大家试试效果，请静候我的反馈！

反馈：内建方法全部看完了，并敲完所有的内建方法，收获还是有的，但是发现不了解的知识更多了。内建方法属于python的标准库中的一章。python的标准库中还有很多值得一看的章节。python2.7.8中文标准库文档，这些内容我粗略的看了一遍。这个内建方法的学习笔记我周三就写完了，本来想在写内建类型的学习笔记。但是发现太多了！而且我发现，看的太多记下的东西就会变少，所以我打算把重心转移到我自己练手的项目中（现在还没什么值得分享的东西，等拿得出手肯定会告诉大家的）。我想把学习标准库中收获的技巧用到我的项目中，这样学以致用才能真正融汇贯通。这就是我的下一步学习计划：通过实际项目，运用python标准库中的技巧！

结论就是：看完标准库我还没有成为高手，但是我收获了很多知识，基础牢固了一些。下一步打算在我自己的项目中运用这些技巧，提高自己的能力和技术！

相关资料

官方文档－内建方法(英文)－2.7.11

官方文档－内建方法(中文)－2.7.8

内建方法

常用内建方法
all	divmod	input	open	staticmethod
abs	enumerate	int	ord	str
any	eval	isinstance	pow	sum
basestring	execfile	issubclass	print	super
bin	file	iter	property	tuple
bool	filter	len	range	type
bytearray	float	list	raw_input	unichr
callable	format	locals	reduce	unicode
chr	frozenset	long	reload	vars
classmethod	getattr	map	repr	xrange
cmp	globals	max	reversed	zip
compile	hasattr	memoryview	round	import
complex	hash	min	set	apply
delattr	help	next	setattr	buffer
dict	hex	object	slice	coerce
dir	id	oct	sorted	intern

说明:

[,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，或者支持迭代的对象：

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