Python内置函数介绍
Python/C API:https://docs.python.org/2/
内置函数:
abs(number) #返回值是一个数字的绝对值,如果是复数,返回值是复数的模
abs(-1.2) #返回 1.2 abs(1.2) #返回 1.2 abs(-1-1j) #返回 1.41421356237
all(iterable) #所有的值为真时才为真,只要有一个是假就是假
def all(iterable): for element in iterable: if not element: return False return True
True >>> all(['a', 'b', '', 'd']) #列表list,存在一个为空的元素 False >>> all([0, 1,2, 3]) #列表list,存在一个为0的元素 False >>> all(('a', 'b', 'c', 'd')) #元组tuple,元素都不为空或0 True >>> all(('a', 'b', '', 'd')) #元组tuple,存在一个为空的元素 False >>> all((0, 1,2, 3)) #元组tuple,存在一个为0的元素 False >>> all([]) # 空列表 True >>> all(()) # 空元组 True
any(iterable) #只要有一个为真就是真
def any(iterable): for element in iterable: if element: return False return True
>>> any(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0 True >>> any(['a', 'b', '', 'd']) #列表list,存在一个为空的元素 True >>> any([0, '', False]) #列表list,元素全为0,'',false False >>> any(('a', 'b', 'c', 'd')) #元组tuple,元素都不为空或0 True >>> any(('a', 'b', '', 'd')) #元组tuple,存在一个为空的元素 True >>> any((0, '', False)) #元组tuple,元素全为0,'',false False >>> any([]) # 空列表 False >>> any(()) # 空元组 False
apply(p_object, args=None, kwargs=None)
# 用于当函数参数已经存在于一个元组或字典中时,间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args,任何参数都不会被传递,kwargs是一个包含关键字参数的字典。
# 没有带参数 def say(): print 'say in' apply(say) # 只带元组的参数 def say(a, b): print a, b apply(say,("hello", "张三python")) # function(object, *args) # 带关键字参数 def say(a=1,b=2): print a,b def haha(**kw): apply(say,(),kw) # function(object, (), **keywords) print haha(a='a',b='b')
# apply()的返回值就是func()的返回值,apply()的元素参数是有序的,元素的顺序必须和func()形式参数的顺序一致
bin(number) #将整数x转换为二进制字符串,如果x不为Python中int类型,x必须包含方法__index__()并且返回值为integer
#整数的情况, 前面多了0b,这是表示二进制的意思。 bin(521) '0b1000001001' #非整型的情况,必须包含__index__()方法切返回值为integer的类型 class Type: def __index__(self): return 8 testbin = Type() print bin(testbin) '0b1000'
callable(p_object) #检查对象object是否可调用。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。
>>> class A: def add(a, b): return a + b >>> callable(A) True >>> a = A() >>> callable(a) False >>> class B: def __call__(self): return 0 >>> callable(B) True >>> b = B() >>> callable(b) #类是可调用的,而类的实例实现了__call__()方法才可调用 True
chr(i) # 返回整数i对应的ASCII字符,i取值范围[0, 255]之间的正数
>>> chr(27) '\x1b' >>> chr(97) 'a' >>> chr(98) 'b'
cmp(x, y) # 函数用于比较2个对象,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
>>> cmp(80, 100) -1 >>> cmp(180, 100) 1 >>> cmp(-80, 100) -1 >>> cmp(80, -100) 1 >>> cmp(80, 80) 0
coerce(x, y) # 如果有一个操作数是复数, 另一个操作数被转换为复数;否则,如果有一个操作数是浮点数, 另一个操作数被转换为浮点数;否则, 如果有一个操作数是长整数,则另一个操作数被转换为长整数;否则,两者必然都是普通整数,无须类型转换
>>> coerce(1, 2) (1, 2) >>> >>> coerce(1.3, 134L) (1.3, 134.0) >>> >>> coerce(1, 134L) (1L, 134L) >>> >>> coerce(1j, 134L) (1j, (134+0j)) >>> >>> coerce(1.23-41j, 134 ((1.23-41j), (134+0j))
compile(source, filename, mode, flags=None, dont_inherit=None) # 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()或者single进行求值。
>>> code = "for i in range(0, 10): print i" >>> cmpcode = compile(code, '', 'exec') >>> exec cmpcode >>> str = "3 * 4 + 5" >>> a = compile(str,'','eval') >>> eval(a) 17
copyright(*args, **kwargs) # 用于打印许可文本的交互式提示对象,投稿人及版权声明
>>> copyright()
delattr(p_object, name) # 删除object对象名为name的属性
>>> class Person: def __init__(self, name, age): self.name = name self.age = age >>> p = Person("canon", 25) >>> dir(p) ['__doc__', '__init__', '__module__', 'age', 'name'] >>> delattr(p, "age") >>> dir(p) ['__doc__', '__init__', '__module__', 'name']
dir(p_object=None) # 不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
>>> import struct
>>> dir() # show the names in the module namespace ['__builtins__', '__doc__', '__name__', 'struct'] >>> dir(struct) # show the names in the struct module ['Struct', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from'] >>> class Shape(object): def __dir__(self): return ['area', 'perimeter', 'location'] >>> s = Shape() >>> dir(s) ['area', 'location', 'perimeter']
divmod(x, y) # 返回的是a//b(除法取整)以及a对b的余数,返回结果类型为tuple
>>> divmod(9,2) (4, 1) >>> divmod(11,3) (3, 2) >>> divmod(1+2j,1+0.5j) ((1+0j), 1.5j)
eval(source, globals=None, locals=None) #将字符串str当成有效的表达式来求值并返回计算结果
>>> a = '1*2+3' >>> b =eval(a) >>> print b 5 >>> a = "{1: 'a', 2: 'b'}" >>> b = eval(a) >>> b = eval(a) >>> print b {1: 'a', 2: 'b'}
execfile(filename, globals=None, locals=None) # 用来执行一个文件
>>> execfile('test1.py')
exit(*args, **kwargs) # builtin.exit 是一个 Quitter 对象,这个对象的 call 方法会抛出一个 SystemExit 异常
>>> exit(0) #无错误退出 >>> exit(1) #有错误退出 >>> exit() #退出代码是告诉解释器的(或操作系统)
filter(function_or_none, sequence) #该函数根据function参数返回的结果是否为真来过滤list参数中的项,最后返回一个新列表
>>>a=[1,2,3,4,5,6,7] >>>b=filter(lambda x:x>5, a) >>>print b [6,7] >>>a=[0,1,2,3,4,5,6,7] #filter参数值为None,就使用identity()函数,list参数中所有为假的元素都将被删除 >>>b=filter(None, a) >>>print b [1,2,3,4,5,6,7]
format(value, format_spec=None) #格式化字符串
>>> '{:,}'.format(1234567890) #千位分割 1,234,567,890 >>> '{:b}'.format(17) #b、d、o、x分别是二进制、十进制、八进制、十六进制, 2f是百分位的小数 '10001' >>> class Person: def __init__(self,name,age): self.name,self.age = name,age def __str__(self): return 'This guy is {self.name},is {self.age} old'.format(self=self) >>> str(Person('cjn',18)) 'This guy is kzc,is 18 old'
getattr(object, name, default=None) # 获取对象object的属性或者方法,如果存在打印出来,如果不存在,打印出默认值,默认值可选。需要注意的是,如果是返回的对象的方法,返回的是方法的内存地址,如果需要运行这个方法,可以在后面添加一对括号
>>> func = getattr(obj, "method") # 与result = obj.method(args)相同 >>> result = func(args) >>> result = getattr(obj, "method")(args) >>> class test(): name="cjn" def run(self): return "HelloWord" >>> t=test() >>> getattr(t, "name") #获取name属性,存在就打印出来。 'cjn' >>> getattr(t, "run") #获取run方法,存在就打印出方法的内存地址。 <bound method test.run of <__main__.test instance at 0x0269C878>> >>> getattr(t, "run")() #获取run方法,后面加括号可以将这个方法运行。 'HelloWord' >>> getattr(t, "age") #获取一个不存在的属性。 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: test instance has no attribute 'age' >>> getattr(t, "age","18") #若属性不存在,返回一个默认值。 '18'
globals() #在当前作用域下,查看全局变量;返回基于字典的访问全局变量的方式
>>> b = 'cjn' >>> print globals() {'b': 'cjn', '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PyCharm/PycharmProjects/test/test.py', '__package__': None, '__name__': '__main__', 'foo': <function foo at 0x0000000002EF6CF8>, '__doc__': None}
hasattr(p_object, name) #判断一个对象里面是否有name属性或者name方法,返回BOOL值,有name特性返回True, 否则返回False
>>> class test(): name="cjn" def run(self): return "HelloWord" >>> t=test() >>> hasattr(t, "name") #判断对象有name属性 True >>> hasattr(t, "run") #判断对象有run方法 True
hash(p_object) # 返回的哈希值是使用一个整数表示,通常使用在字典里,以便实现快速查询键值,参数为数字类型
>>> print(hash('abc')) -1600925533 >>> print(hash(2.0)) 2 >>> print(hash(2)) 2
help(with_a_twist) #查看函数或模块用途的详细说明
>>> help(len) Help on built-in function len in module __builtin__: len(...) len(object) -> integer Return the number of items of a sequence or collection.
hex(number) # 整数转换为十六进制的字符串
>>> hex(10) '0xa' >>> hex(100) '0x64'
id(p_object) # 获得对象的内存地址,如果两个对象的内存地址是一样的,那么这两个对象肯定是一个对象
>>> class test: def test(): print test >>> a = test() >>> id(a) 52681032L
input(prompt=None) # 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用双引号将它括起来,否则它会引发一个 SyntaxError
>>> input_A = input("Input: ") >>> Input: "abc" # 输入abc时,需要加上括号
intern(string) # 值相同的字符串对象只会保存一份,是共用的
>>> a = intern('abc') >>> b = intern('abc') >>> print id(a) 38508424 >>> print id(b) 38508424
isinstance(p_object, class_or_type_or_tuple) # 判断一个对象是否是一个已知的类型;若object为对象,判断实例是否是这个类或者对象,若object为变量,判断变量是否是这个类型
>>> class objA: pass >>> A = objA() >>> B = 'a','v' >>> C = 'a string' >>> lst = [1,2,3,4] >>> print isinstance(A, objA) True >>> print isinstance(B, tuple) True >>> print isinstance(C, basestring) True >>> isinstance(lst, list) True >>> isinstance(lst, (int, str, list) ) True
issubclass(C, B) # 判断类参数C是否是类型参数B的子类
>>> class Line: pass >>> class RedLine(Line): pass >>> class Rect: pass >>> print(issubclass(RedLine, Line)) True >>> print(issubclass(Rect, Line)) False
iter(source, sentinel=None) # 迭代器为类序列对象提供了一个类序列的接口, 而且它还允许程序员迭代非序列类型,包括用户定义的对象、字典的键、一个文件的行等
i = iter('abcd') for k in i: print k s = {'one':1,'two':2,'three':3}
m = iter(s) for k in m: print k
len(p_object) # 返回字符串长度
>>> s = {'one':1,'two':2,'three':3} >>> print len(s) 3 >>> a = '12345789' >>> print len(a) 8
license(*args, **kwargs)
>>> license()
locals() # 返回基于字典的访问局部变量的方式
>>> def foo(arg, a): x = 1 y = 'xxxxxx' for i in range(10): j = 1 k = i print locals() >>> foo(1,2) {'a': 2, 'i': 9, 'k': 9, 'j': 1, 'arg': 1, 'y': 'xxxxxx', 'x': 1}
map(function, sequence, *sequence_1) # 第一个参数接收一个函数名,第二个参数接收一个可迭代对象;接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回
ls = [1,2,3] rs = map(str, ls) print rs #打印结果 ['1', '2', '3'] lt = [1, 2, 3, 4, 5, 6] def add(num): return num + 1 rs = map(add, lt) print rs #打印结果 [2,3,4,5,6,7]
max(*args, **kwargs) # 返回给定参数的最大值,参数可以为序列
print "max(80, 100, 1000) : ", max(80, 100, 1000) print "max(-20, 100, 400) : ", max(-20, 100, 400) print "max(-80, -20, -10) : ", max(-80, -20, -10) print "max(0, 100, -400) : ", max(0, 100, -400)
min(*args, **kwargs) # 返回给定参数的最小值,参数可以为序列
print "min(80, 100, 1000) : ", min(80, 100, 1000) print "min(-20, 100, 400) : ", min(-20, 100, 400) print "min(-80, -20, -10) : ", min(-80, -20, -10) print "min(0, 100, -400) : ", min(0, 100, -400)
next(iterator, default=None) # 用在一个循环中,当一个文件被作为一个迭代器通常使用的next()方法被调用多次.此方法返回下一个输入行,或引发StopIteration异常的EOF被击中时
fo = open("foo.txt", "r") print "Name of the file: ", fo.name for index in range(5): line = fo.next() print "Line No %d - %s" % (index, line) fo.close()
oct(number) # 一个整数转换成8进制字符串。如果传入浮点数或者字符串均会报错
>>> a = oct(10) >>> a '0o12' # 如果传入参数不是整数,则其必须是一个定义了__index__并返回整数函数的类的实例对象 # 定义了__index__函数,而且返回值是int类型,能转换 >>> class Student: def __init__(self,name,age): self.name = name self.age = age def __index__(self): return self.age >>> a = Student('Kim',10) >>> oct(a) '0o12'
open(name, mode=None, buffering=None) # 打开文件
#open(路径+文件名,读写模式) f=open('/tmp/hello.txt','w') #读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式 如:'rb','wb','r+b'等等 读写模式的类型有: rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278) w 以写方式打开, a 以追加模式打开 (从 EOF 开始, 必要时创建新文件) r+ 以读写模式打开 w+ 以读写模式打开 (参见 w ) a+ 以读写模式打开 (参见 a ) rb 以二进制读模式打开 wb 以二进制写模式打开 (参见 w ) ab 以二进制追加模式打开 (参见 a ) rb+ 以二进制读写模式打开 (参见 r+ ) wb+ 以二进制读写模式打开 (参见 w+ ) ab+ 以二进制读写模式打开 (参见 a+ )
ord(c) # 以一个字符(长度为1的字符串)作为参数,返回对应的ASCII数值,或者Unicode数值,如果所给的Unicode字符超出了你的Python定义范围,则会引发一个TypeError的异常
>>> ord('a') 97 >>> ord(u'\ufffff') Traceback (most recent call last): File "<stdin>", line 1, in ? ord(u'\ufffff') TypeError: ord() expected a character, but string of length 2 found >>> ord(u'\u2345') 9029
pow(x, y, z=None) # 返回 xy(x的y次方) 的值。
>>> pow(100, 2) 10000
print(*args, **kwargs) # 打印相应的信息
>>> a = '123456' >>> print a 123456
quit(*args, **kwargs) # 退出程序
a = input("input quit to quit:") if a.upper() == 'QUIT': quit() else: print 'continue' pass
range(start=None, stop=None, step=None) # 输出一个顺序的list
>>> range(1,5) #代表从1到5(不包含5) [1, 2, 3, 4] >>> range(1,5,2) #代表从1到5,间隔2(不包含5) [1, 3] >>> range(5) #代表从0到5(不包含5) [0, 1, 2, 3, 4]
raw_input(prompt=None) # 能接收 字符串 ,raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)
>>> raw_input_A = raw_input("raw_input: ") >>> raw_input: abc
reduce(function, sequence, initial=None) # reduce内建函数是一个二元操作函数,他用来将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给reduce中的函数 func()(必须是一个二元操作函数)先对集合中的第1,2个数据进行操作,得到的结果再与第三个数据用func()函数运算,最后得到一个结果
# 第一种方式: def myadd(x,y): return x+y sum=reduce(myadd,(1,2,3,4,5,6,7)) print sum # 第二种方式 sum=reduce(lambda x,y:x+y,(1,2,3,4,5,6,7)) print sum
reload(module) # 对已经加载的模块进行重新加载,一般用于原模块有变化等特殊情况,reload前该模块必须已经import过
import os reload(os) # reload会重新加载已加载的模块,但原来已经使用的实例还是会使用旧的模块,而新生产的实例会使用新的模块;reload后还是用原来的内存地址;不能支持from。。import。。格式的模块进行重新加载。
repr(p_object) # 将任意值转为字符串;转化为供解释器读取的形式
>>> obj='I love Python' >>> obj==eval(repr(obj)) True
round(number, ndigits=None) # 返回浮点数x的四舍五入值
print round(80.23456, 2) print round(100.000056, 3) print round(-100.000056, 3)
setattr(p_object, name, value) # 给对象的属性赋值,若属性不存在,先创建再赋值
>>> class test(): name="cjn" def run(self): return "HelloWord" >>> t=test() >>> hasattr(t, "age") #判断属性是否存在 False >>> setattr(t, "age", "18") #为属相赋值,并没有返回值 >>> hasattr(t, "age") #属性存在了 True
sorted(iterable, cmp=None, key=None, reverse=False) # 对List、Dict进行排序;reverse=False默认是逆序,True为正序
# 对数组进行排序 >>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),] >>> sorted(students, key=lambda student : student[2]) #按年龄进行排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] # 对字典进行排序 >>> from operator import itemgetter, attrgetter >>> d = {'data1':3, 'data2':1, 'data3':2, 'data4':4} >>> sorted(d.iteritems(), key=itemgetter(1), reverse=True) [('data4', 4), ('data1', 3), ('data3', 2), ('data2', 1)]
sum(sequence, start=None) # 求和函数
>>> sum([1,2,3]) 6 >>> sum(range(1,11)) 55 >>> a = range(1,11) >>> b = range(1,10) >>> c = sum([item for item in a if item in b]) >>> print c 45
unichr(i) # 用一个范围的整数作参数,返回一个对应的Unicode字符;如果是配置为USC2的Unicode,那么它的允许范围就是range(65536)或0x0000-0xFFFF;如果配置为UCS4,那么这个值应该是range(1114112)或0x000000-0x110000。如果提供的参数不在允许的范围内,则会报一个ValueError的异常
>>> unichr(20013) u'\u4e2d' >>> print unichr(20013) 中
vars(p_object=None) # 实现返回对象object的属性和属性值的字典对象
>>> print(vars()) {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None} >>> class Foo: a = 1 >>> print(vars(Foo)) {'a': 1, '__module__': '__main__', '__doc__': None} >>> foo = Foo() >>> print(vars(foo)) {}
zip(seq1, seq2, *more_seqs) # 接受任意多个(包括0个和1个)序列作为参数,返回一个tuple列表
x = [1, 2, 3] y = [4, 5, 6] z = [7, 8, 9] xyz = zip(x, y, z) print xyz # 运行的结果是:[(1, 4, 7), (2, 5, 8), (3, 6, 9)] # zip(*xyz) 等价于 zip(x, y, z) x = [1, 2, 3] r = zip(* [x] * 3) print r # 运行的结果是:[(1, 1, 1), (2, 2, 2), (3, 3, 3)]
__import__(name, globals={}, locals={}, fromlist=[], level=-1) # 只接收字符串作为参数;import语句就是调用这个函数进行导入工作的,import sys <==>sys = __import__('sys')
# 通过字符串来动态导入模块
__import__('os',globals(),locals(),['path','pip']) # 等价于from os import path, pip
''' 通过字符串动态重新加载模块;试试reload('os')直接报错,虽然不能直接reload但是可以先unimport一个模块,然后再__import__来重新加载模块。
在Python解释里可以通过globals(),locals(),vars(),dir()等函数查看到当前环境下加载的模块及其位置,但是这些都只能看不能删除,所以无法unimport;
不过除此之外还有一个地方是专门存放模块的,这就是sys.modules,通过sys.modules可以查看所有的已加载并且成功的模块,而且比globals要多,说明默认会加载一些额外的模块 ''' import sys __import__('a') #第一次导入会打印消息 del sys.modules['a'] #unimport __import__('a') #再次导入还是会打印消息,因为已经unimport一次了 __import__('a') #这次就不会打印消息了