python基础7之python3的内置函数

python基础7之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(object):返回一个包含对象的可打印表示的字符串。

>>> repr('print("haha")')
'\'print("haha")\''
>>> repr(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.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('',base=16)
17
>>> int('',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(['','','','','','a','b','c'])
['', '', '', '', '', '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')
上一篇:LeetCode 118. 杨辉三角


下一篇:python3.7内置函数整理笔记