开发文章

Python常用内建方法

内建方法

常用内建方法  
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(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字符串编译成代码对象。代码对象可以通过execeval执行。

  • 参数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

感谢 樊海鹏 支持 磐实编程网 原文地址:
blog.csdn.net/weixin_36082485/article/details/53158779#class

上一篇:C++顺序容器详解

下一篇:C++智能指针

文章信息

发布时间:2016-11-15

作者:樊海鹏

发布者:aquwcw

浏览次数: