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') #这次就不会打印消息了
浙公网安备 33010602011771号