首页 > 代码库 > Python内置函数.md
Python内置函数.md
Python3 内置函数
abs(x)
返回一个数的绝对值。参数可以是一个整数或者一个浮点数。如果参数是一个复数，那么将返回它的模。
>>> abs(-123456)
123456
>>> abs(123456)
123456
all(iterable)
当 iterable 中所有元素都为 True 时（或者 iterable 为空），返回 True 。相当于：
def all(iterable):
for element in iterable:
if not element:
return False
return True
举例:
>>> all([0,1,""])
False
>>> all([None,2,3])
False
>>> all([0,3])
False
>>> all([1,3])
True
>>> all([])
True
假的参数有：False、0、None、""、[]、()、{}等，查看一个元素是否为假可以使用bool进行查看。
any(iterable)
当 iterable 中有元素为 True 时，则返回 True 。如果当 iterable 为空时，返回 False 。相当于：
def any(iterable):
for element in iterable:
if element:
return True
return False
举例：
>>> any([0,1,3])
True
>>> any([{},(),0])
False
ascii(object)
就像函数 repr() ， 返回一个输入对象的可打印的字符串，但是在返回字符串中去掉非 ASCII 编码的字符，而这些字符在 repr() 生成的字符串中利用编码加 \x ， \u 或 \U 前缀来表示。这个函数所生成的字符串与 Python2 中的 repr() 函数类似。
bin(x)
将一个整数转化为一个二进制字符串。结果是一个可用的 Python 表达式。
举例
返回一个整数的二进制：
>>> bin(100)
‘0b1100100‘
如果 x 不是 Python 中的 int 类型，那么需要定义 __index__() 方法使之返回一个整数。
>>> class myType:
... def __index__(self):
... return 35
...
>>> myvar = myType()
>>> bin(myvar)
‘0b100011‘
bool([x])
将一个值转换为布尔类型，使用标准的真值判断过程。如果 x 为假或者不存在，将返回 False ；否则则返回 True 。 bool 同样是一个类，是 int 的子类， bool 类不能作为其他子类。它仅有的实例是 False 和 True 。
>>> bool([])
False
>>> bool({})
False
>>> bool(0)
False
>>> bool(2)
True
bytearry([source[,encoding[,errors]]])
bytearray([source [, encoding [, errors]]])返回一个byte数组。Bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0 ,255]。
source参数：
- 如果source为整数，则返回一个长度为source的初始化数组；
- 如果source为字符串，则按照指定的encoding将字符串转换为字节序列；
- 如果source为可迭代类型，则元素必须为[0 ,255]中的整数；
- 如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray。
bytes([source[,encoding[,errors]]])
返回一个bytes类型。
callable(object)
返回一个对象是否可以被执行：
>>> def func():
... return 123
...
>>> callable(func)
True
>>> func = 123
>>> callable(func)
False
chr(i)
返回一个数字在ASCII编码中对应的字符，取值范围256个。
>>> chr(66)
‘B‘
>>> chr(5)
‘\x05‘
>>> chr(55)
‘7‘
>>> chr(255)
‘\xff‘
>>> chr(25)
‘\x19‘
>>> chr(65)
‘A‘
compile(source,filenname,mode,flags=0,dont_inherit=False,optimize=-1)
把字符串编译成python可执行的代码。
>>> str = "for i in range(0,6): print(i)"
>>> c = compile(str, ‘‘, ‘exec‘)
>>> exec(c)
0
1
2
3
4
5
complex([real[,imag]])
创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
>>> complex(1, 2)
(1+2j)
# 数字
>>> complex(1)
(1+0j)
# 当做字符串处理
>>> complex("1")
(1+0j)
# 注意：这个地方在“+”号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1+2j)
delattr(object,name)
删除一个对象的属性，相当于del object.name。
dict(**kwarg)
创建一个数据类型为字典。
>>> dic = dict({"k1":"123","k2":"456"})
>>> dic
{‘k1‘: ‘123‘, ‘k2‘: ‘456‘}
dir([object])
返回一个类中的所有方法。
>>> a = [1,2,3]
>>> dir(a)
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]
divmod(a,b)
divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数，返回结果类型为tuple。
>>> divmod(10,3)
(3, 1)
enumerate(iterable,start=0)
遍历可迭代的数据类型，并为元素生成下标。
a = [1,2]
for k,v in enumerate(a):
print(k,v)
print("---------")
b = {‘a‘:1,‘b‘:2}
for i,j in enumerate(b):
print(i,j)
0 1
1 2
---------
0 a
1 b
eval(expression,globals=None,locals=None)
把一个字符串当作一个表达式去执行。
>>> string = "1 + 3"
>>> string
‘1 + 3‘
>>> eval(string)
4
exec(object[,globals[,locals]])
把字符串当作python代码执行。
>>> exec("for n in range(5): print(n)")
0
1
2
3
4
filter(function,iterable)
筛选过滤，循环可迭代的对象，把迭代的对象当作函数的参数，如果符合条件就返回True，否则就返回False。
def func(x):
if x == 11 or x ==22:
return True
ret = filter(func,[11,22,33,44])
for i in ret:
print(i)
11
22
float([x])
将整数和字符串转换成浮点数。
>>> float("124")
124.0
>>> float("123.45")
123.45
>>> float("-123.34")
-123.34
format(value[,format_spec])
字符串格式化。
>>> a = "My name is {0}, age is {1}".format(‘lucky‘, 18)
>>> print(a)
My name is lucky, age is 18
frozenset([iterable])
frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。
getattr(object,name)
获得对象的name属性，当该属性不存在的时候可以使用一个默认值作为返回值。
globals()
获取当前scripts文件内的所有全局变量。
>>> a = 3
>>> bsd = "54asd"
>>> globals()
{‘__doc__‘: None, ‘bsd‘: ‘54asd‘, ‘__package__‘: None, ‘a‘: 3, ‘__spec__‘: None, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>}
hasattr(object,name)
参数是一个对象和一个字符串，如果字符串是对象的某个属性的名称，则结果为True，否则为False。
hash(object)
返回一个对象的hash值。
>>> a = "asdadasdwqeq234sdfdf"
>>> hash(a)
5390438057823015497
help([object])
查看一个类的所有详细方法。
hex(x)
获取一个数的十六进制。
>>> hex(15)
‘0xf‘
id(object)
返回一个对象的内存地址。
>>> a = 123
>>> id(a)
1835400816
input([prompt])
交互式输入。
int(x,base=10)
获取一个数的十进制。
>>> int("31")
31
isinstance(object,classinfo)
判断对象是否是这个类创建的。
>>> li = [11,22,33]
>>> isinstance(li,list)
True
issubclass(class,classinfo)
查看一个对象是否为子类。
iter(object[,sentinel])
创建一个可迭代的对象。
>>> obj = iter([11,22,33,44])
>>> obj
<list_iterator object at 0x000002477DB25198>
>>> for n in obj:
... print(n)
...
11
22
33
44
len(s)
查看一个对象的长度。
>>> name = ‘lucky‘
>>> len(name)
5
list([iterable])
创建一个数据类型为列表。
>>> li = list([11,22,33,44])
>>> li
[11, 22, 33, 44]
locals()
返回当前scripts的局部变量,返回结果为字典格式。
>>> def func():
... name="lucky"
... print(locals())
...
>>> func()
{‘name‘: ‘lucky‘}
map(function,iterable,...)
把可迭代的对象作为函数的值。
>>> ret = map(lambda x: x + 100, [1, 2, 3, 4, 5])
>>> for n in ret:
... print(n)
...
101
102
103
104
105
max(iterable,*[,key,default]) max(arg1,arg2,*args[,key])
获取一个对象中的最大值。
>>> li = [1, 3, 5, 9 ,3]
>>> max(li)
9
memoryview(object)
返回对象object的内存查看对象。
min(iterable,*[,key,default]) min(arg1,arg2,*args[,key])
获取一个对象中的最小值
>>> >>> li = list([11,22,33,44])
>>> li = [11,22,33,44]
>>> min(li)
11
next(iterable[,default])
每次只拿取可迭代对象的一个元素。
>>> obj = iter([11,22,33,44])
>>> next(obj)
11
>>> next(obj)
22
>>> next(obj)
33
>>> next(obj)
44
>>> next(obj)
# 如果没有可迭代的元素了就会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
object
返回一个新的无特征对象。
oct(x)
获取一个字符串的八进制。
>>> oct(13)
‘0o15‘
open(file,mode=‘r‘,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)
文件操作的函数，用来做文件操作的。
ord(c)
把一个字母转换为ASCII对对应表中的数字。
>>> ord("a")
97
>>> ord("t")
116
pow(x,y[,z])
返回一个数的N次方。
>>> pow(2, 10)
1024
>>> pow(2, 20)
1048576
print(*objects,sep=‘ ‘,end=‘\n‘,file=sys.stdout,flush=False)
打印输出。
property(fget=None,fset=None,doc=None)
函数 property() 的作用就是把类中的方法当作属性来访问。
range(sart,stop[,step])
生成一个可迭代序列。
>>> range(10)
range(0, 10)
>>> for n in range(5):
... print(n)
...
0
1
2
3
4
repr(object)
返回一个包含对象的可打印表示的字符串。
reversed(seq)
对一个对象的元素进行反转。
>>> li = [1, 2, 3, 4]
>>> reversed(li)
<list_reverseiterator object at 0x000002CF0EF6A940>
>>> for n in reversed(li):
... print(n)
...
4
3
2
1
round(number[,ndigits])
四舍五入。
>>> round(3.3)
3
>>> round(3.7)
4
set([iterable])
创建一个数据类型为集合。
>>> varss = set([11,222,333])
>>> type(varss)
<class ‘set‘>
setattr(object,name,value)
为一个对象的name属性设置一个value值。
slice(start,stop[,step])
元素的切片操作都是调用的这个方法。
sorted(iterable[,key[,reverse]])
为一个对象的元素进行排序。
>>> li = [ 2, 3, 4, 9, 1, 100]
>>> sorted(li)
[1, 2, 3, 4, 9, 100]
staticmethod(function)
返回一个静态的方法。
str([object[,encoding[,errors]]])
字符串。
sum(iterable[,start])
求和。
>>> sum([11,22,33])
66
super([type[,object-or-type]])
super() 常用于继承中调用父类的方法。
tuple([iterable])
创建一个对象，数据类型为元组。
type(object)
查看一个对象的数据类型。
>>> a = 1
>>> type(a)
<class ‘int‘>
>>> a = "str"
>>> type(a)
<class ‘str‘>
vars([object])
查看一个对象里面有多少个变量。
zip(*iterable)
联合迭代。
>>> li1 = ["k1","k2","k3"]
>>> li2 = ["a","b","c"]
>>> zip(li1,li2)
<zip object at 0x0000026BF1803288>
>>> dic = zip(li1,li2)
>>> for n in dic:
... print(n)
...
(‘k1‘, ‘a‘)
(‘k2‘, ‘b‘)
(‘k3‘, ‘c‘)
__import__(name,globals=None,locals=None,fromlist=(),level=0)
导入模块，把导入的模块作为一个别名。
参考及扩展：
http://docspy3zh.readthedocs.io/en/latest/library/functions.html
http://openskill.cn/article/432
http://blog.csdn.net/lisonglisonglisong/article/details/38960341
https://juejin.im/post/58952b87b123db16a393ffdc
Python内置函数.md