python基础6之python3的内置函数
官方介绍：python3：https://docs.python.org/3/library/functions.html?highlight=built#ascii
python2：https://docs.python.org/2/library/functions.html?highlight=built#ascii
下面介绍python3中具体每个内置函数的使用方法及含义；
abs(x):返回数字的绝对值，参数可以是整数或浮点数，如果参数是复数，则返回其大小。
>>> abs(-1) 1 >>> abs(-2.5) 2.5
all(iterable)：循环可迭代对象的每一个元素，如果括号内的所有元素都是真的，或者如果iterable为空，则返回True，如果有一个为假的那么就返回False。
>>> all([])
True
>>> all([1,2,3,""])
False
>>> all({"a":1,"b":""})
True
any(iterable)：循环判断可迭代对象中的元素，如果有一个元素为真，那么就返回True，否则就返回False。
>>> any([1,2,3]) True >>> any([0,2,3]) True >>> any([0]) False >>> any([-1,True]) True >>> any([-1,None]) True >>> any([None]) False
>>> repr('print("haha")')
'\'print("haha")\''
>>> repr(123)
'123'
>>> repr([1,2,3])
'[1, 2, 3]'
ascii(object)：在对象的类中寻找__repr__方法，获取返回值。
>>> def test(): ... pass ... return 'lady' ... >>> ascii(test()) "'lady'" >>> b=ascii(test()) >>> print(b) 'lady' >>> type(b) <class 'str'>
bin(x)：将整数x转换为二进制字符串，如果x不为Python中int类型，x必须包含方法__index__()并且返回值为integer。
>>> bin(8) '0b1000' >>> x=bin(9) >>> type(x) <class 'str'>
bool([x])：查看一个元素的布尔值，非真即假。
>>> bool(1) True >>> bool(0) False >>> bool([1,2]) True >>> bool([0,2,3]) True >>> bool([]) False
bytearray([source [, encoding [, errors]]])：返回一个byte数组，Bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0 ,255]。
source参数：
如果source为整数，则返回一个长度为source的初始化数组；
如果source为字符串，则按照指定的encoding将字符串转换为字节序列；
如果source为可迭代类型，则元素必须为[0 ,255]中的整数；
如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray。
>>> bytearray(1)
bytearray(b'\x00')
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray('dear',encoding='utf-8')
bytearray(b'dear')
bytes([source[, encoding[, errors]]])：与bytearray类似，返回字节类型数据。
>>> bytes(a) b'\x08\n' >>> bytes(1) b'\x00' >>> bytes([1,2,3]) b'\x01\x02\x03'
callable(object)：判断一个对象是否可调用，可调用返回True。
>>> callable(lambda x:x*2) True >>> callable(bin) True >>> callable([1,2,3]) False
chr(i)：返回一个数字在ASCII编码中对应的字符，取值范围256个。
>>> chr(99) 'c' >>> chr(98) 'b'
classmethod(function)：返回函数的类方法。
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)：把字符串编译成python可执行的代码。
>>> str="print('lady')"
>>> a=compile(str,'','eval')
>>> eval(a)
lady
complex([real[, imag]])：将数字或者字符串转化为复数。如果第一个参数为字符串，则不需要指定第二个参数。
>>> complex(1,2)
(1+2j)
>>> complex(1)
(1+0j)
>>> complex('1+2j')
(1+2j)
delattr(object, name)：删除对象的属性值。
>>> class person():
... def test(self):
... print("in the test")
...
>>> a=person()
>>> a.test()
in the test
>>> delattr(person,'test')#传递name必须是字符串
>>> a.test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'person' object has no attribute 'test'
dir([object]):返回对象中的所有方法。
>>> import sys >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loade r__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdou t__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
divmod(a,b):返回a/b的商和余数。
>>> divmod(15,3) (5, 0)
enumerate(iterable, start=0)：为可迭代对象中的元素生成下标。
>>> d=['a','b','c'] >>> for i,j in enumerate(d): ... print(i,j) ... 0 a 1 b 2 c
eval(expression, globals=None, locals=None)：把一个字符串当作一个表达式去执行。
>>> a="print('my name is wd')"
>>> eval(a)
my name is wd
exec(object[, globals[, locals]]):动态执行python代码，把字符串当作python代码执行。
code=input("please input your code>>")
exec(code)
结果：
please input your code>>print("my lady")
my lady
filter(function, iterable)：筛选可迭代对象中的元素，第一个参数是筛选函数。
>>> res=filter(lambda x:x%2==0,range(10)) >>> for i in res: ... print(i) ... 0 2 4 6 8
float([x])：将整数或者字符串转化为浮点数。
>>> float('1')
1.0
>>> float(1)
1.0
format(value[, format_spec])：格式化字符串（后面会细说）。
>>> s="my name is {},job is {}".format('wd','IT')
>>> print(s)
my name is wd,job is IT
getattr(object, name[, default])：获取对象属性的值，参数那么是字符串。
>>> class test(): ... name="wd" ... age=22 ... >>> getattr(test,'age') 22
frozenset([iterable])：创建不可变集合。
set(可变集合)与frozenset(不可变集合)的区别：
set无序排序且不重复，是可变的，有add（），remove（）等方法。既然是可变的，所以它不存在哈希值。基本功能包括关系测试和消除重复元素.
集合对象还支持union(联合), intersection(交集), difference(差集)和sysmmetric
difference(对称差集)等数学运算.
sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, 或其它类序列的操作。
frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。
>>> a=frozenset('book')
>>> a
frozenset({'o', 'k', 'b'})
>>>
globals()：获取当前文件夹的所有全局变量。
>>> globals()
{'__doc__': None, '__spec__': None, 'a': frozenset({'o', 'k', 'b'}), '__name__':
'__main__', '__builtins__': <module 'builtins' (built-in)>, '__loader__': <clas
s '_frozen_importlib.BuiltinImporter'>, '__package__': None}
hasattr(object, name)：判断对象中是否有某个属性。
>>> class people(): ... name="wd" ... age=22 ... def test(): ... pass ... >>> hasattr(people,'name') True >>> hasattr(people,'test') True
help(object):查看对象的详细使用方法或者帮助手册，对象可以是类，函数等；
>>> import os
>>> help(os)
Help on module os:
NAME
os - OS routines for NT or Posix depending on what system we're on.
DESCRIPTION
hex(x):将x转为16进制。
>>> hex(16) '0x10' >>> hex(18) '0x12' >>>
id(object):查看对象的内存地址。
>>> a=1 >>> id(1),id(a) (1602879952, 1602879952)
int(x,base=10):其他进制转为十进制，第一个参数为字符串，base为进制参数，可以为2，8，16，默认参数是10。
>>> int('0xe',base=16)
14
>>> int('0xa',base=16)
10
>>> int('11',base=16)
17
>>> int('11',base=2)
3
isinstance(object, classinfo)：判断对象是否是这个类创建的。
>>> isinstance([1,2,3],list) True
issubclass(class, classinfo)：判断一个类是否是子类。
iter(object[, sentinel])：生成一个可迭代带对象。
>>> a=[1,2,3,4] >>> b=iter(a) >>> b <list_iterator object at 0x000000000081C8D0> >>> for i in b : ... print(i) ... 1 2 3 4
len(s)：查询一个对象的长度，参数可以是str，list，dict等。
>>> len('abc')
3
>>> len([1,2,3,4])
4
locals()：返回当前作用域的局部变量，以字典形式输出。
>>> def test():
... name="wd"
... print(locals())
...
>>> test()
{'name': 'wd'}
>>> locals()
{'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <mod
ule 'builtins' (built-in)>, '__spec__': None, 'test': <function test at 0x000000
0000B201E0>, '__name__': '__main__', '__package__': None, '__doc__': None}
map(function, iterable, …)：将可迭代对象中的每个元素作为参数传递给函数，并返回值，可以理解为映射关系。
>>> b=map(lambda x:x*2,range(5)) >>> for i in b : ... print(i) ... 0 2 4 6 8
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])：默认返回可迭代对象的最大值，参数key是个函数，如果元素匹配到key函数，则返回第一个匹配到的数，没有匹配到则返回第一个参数。
>>> max([1,4,5,6],key=lambda x:x>1) 4 >>> max([1,4,5,6]) 6 >>> max([1,4,5,6],key=lambda x:x>7)#返回第一个元素 1
memoryview(obj)：返回对象obj的内存查看对象，所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。
v = memoryview(b'abc123')
print(v[1])
print(v[0])
import struct
buf = struct.pack("i"*12, *list(range(12)))
x = memoryview(buf)
y = x.cast('i', shape=[2,2,3])
print(y.tolist())
结果输出如下：
98
97
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])：用法同max，返回最小值。
>>> min([1,2,3]) 1
next(iterator[, default]):调用一次取出迭代器中的一个值，实则调用迭代器中的next方法。
>>> a=iter([1,2,3,4]) >>> next(a) 1 >>> next(a) 2
oct(x):十进制转化为八进制返回字符串类型。
>>> oct(16) '0o20' >>> oct(9) '0o11' >>>
open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：操作文件无需多说。
ord(c)：把字母转化为ascii表中对应的数字。
>>> ord('a')
97
>>> ord('h')
104
pow(x, y[, z])：返回一个数的N次方或者余数，当参数只有x,y时候，返回x的y次方，当有参数z的时候，放回除以z的余数，相当于x**y%z。
>>> pow(2,3) 8 >>> pow(2,3,5) 3
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)：打印输出。
property(fget=None, fset=None, fdel=None, doc=None)：后续更新。
range(start, stop[, step])：生成序列，和python2的区别
>>> for i in range(1,5): ... print(i) ... 1 2 3 4
reversed(seq)：对序列进行反转，并且返回一个迭代器对象。
>>> a=reversed([1,2,3,4]) >>> for i in a: ... print(i) ... 4 3 2 1
round(number[, ndigits])：对数字进行四舍五入。
>>> round(6.6) 7 >>> round(5.42) 5
set([iterable])：创建集合。
>>> set('book')
{'k', 'o', 'b'}
setattr(object, name, value)：给对象设置属性。
>>> class person(): ... name="wd" ... >>> a=person() >>> setattr(a,"age",22) >>> a.age 22
slice(start, stop[, step])：切片，同列表字符串的切片，字符串，列表的切片就是调用的该函数。
sorted(iterable[, key][, reverse])：对可迭代对象进行排序，值得一提的是，可迭代对象数据类型必须一致，才能排序。
>>> sorted([2,3,1,8,7]) [1, 2, 3, 7, 8] >>> sorted(['2','3','1','8','7','a','b','c']) ['1', '2', '3', '7', '8', 'a', 'b', 'c']
staticmethod(function):返回类的静态方法。
str(object=b’’, encoding=’utf-8’, errors=’strict’)：转为字符串。
sum(iterable[, start])：对可迭代对象求和。
>>> sum([1,2,3,4]) 10
super([type[, object-or-type]])：执行父类的构造方法。
tuple([iterable])：创建元祖。
type(object)：查看对象的数据类型。
>>> type(1)
<class 'int'>
>>> type('a')
<class 'str'>
vars([object])：返回对象object的属性和属性值的字典对象。如果默认不输入参数，就打印当前调用位置的属性和属性值，相当于locals()的功能。如果有参数输入，就只打印这个参数相应的属性和属性值。
zip(*iterables)：压缩两或者两个以上个可迭代对象，类似于一一映射，两个对象的时候，可以使用字典转换。
>>> a=[1,2,3]
>>> b=['a','b','c']
>>> c=['i','j','k']
>>> d=zip(a,b)
>>> for i in d:
... print(i)
...
(1, 'a')
(2, 'b')
(3, 'c')
>>> d=dict(zip(a,b))#dict方法生成字典。
>>> d
{1: 'a', 2: 'b', 3: 'c'}
>>> d=zip(a,b,c)#压缩三个可迭代对象
>>> for i in d:
... print(i)
...
(1, 'a', 'i')
(2, 'b', 'j')
(3, 'c', 'k')
