Python内置函数功能汇总

Python3.x版本中有68个内置函数，为方便查阅相关功能，在此列举出来。

官方原文档戳这里~

在编辑器上（以idle为例），输入

dir(__builtins__)

，从"abs"开始就是Python的内置函数
具体函数名如下图所示 ：

具体可分为以下10类：

1> 数字运算（7个）

😃 abs():返回绝对值

>>>abs(-1)
1

😃 divmod(a,b):商余，分别返回商和余的值

>>>divmod(3,2)
(1, 1)
>>>divmod(3.5,2)   #若为浮点数，则返回的商和余也均为浮点数
(1.0, 1.5)

😃 max():返回可迭代对象中的元素中的最大值或者所有参数的最大值

>>>max(1,3,5)
5
>>>max("12345") #若传入的为可迭代对象
'5'
>>>max(-2 ,1 ,key = abs) #比较两数的绝对值大小，返回绝对值大的数
-2

😃 min:返回可迭代对象中的元素中的最小值或所有参数的最小值，用法同上

>>>min(1, 2, 3)
1
>>>min('1234')
'1'
>>>min(-1, -2, key = abs)
-1

😃 pow:返回两个数值的幂运算值或与指定整数的模

>>>pow(2, 3)  #等价于 2 ** 3
8
>>>pow(2, 3, 5)  #等价于 (2 ** 3) % 5
3

😃 round:对浮点数进行四舍五入

>>> round(3.14159) #若没有参数，则默认保留0位小数
3
>>> round(3.14159,2) # 2代表着保留2位小数
3.14
>>> round(1689,-2)
1700 #小数点左边2位四舍五入，8>5，所以为1700

😃 sum: 对元素类型是数值的可迭代对象中的每个元素求和

>>> sum((1,2,3,1))
7
>>> sum((1,2,3),1)
7
>>>sum((1,2),3.5)
6.5

2> 类型转换 (24个)

😃 bool:根据传入的参数的逻辑值创建一个新的布尔值

>>>bool()
False
>>>bool(0)
False
>>>bool(1)
True
>>>bool(10)
True
#参数在空、0、False等值时才会返回False

😃 int: 根据传入的参数创建一个新的整数

>>>int()
0
>>>
int(3.1)
3

😃 float: 根据传入的参数创建一个新的浮点数

>>> float()
0.0
>>> float(1)
1.0
>>> float("1")
1.0

😃 complex: 根据传入参数创建一个新的复数

>>> complex()
0j
>>> complex(1, 2)
(1+2j)
>>> complex("1+2j)
(1+2j)
#注意区分数学中的复数为i,计算器中为j

😃 str: 返回参数的字符串表现形式

>>> str()
''
>>> str(True)
'True'
>>> str('a')
'a'
>>> str(1)
'1'

😃 ord: 返回Unicode字符对应的整数

>>> ord('a')
97

😃 chr: 返回整数所对应的Unicode字符

>>>chr(97)
'a'

😃 bytearray: 根据传入的参数创建一个新的字节数组

>>> bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

😃 bytes: 根据传入的参数创建一个新的不可变字节数组

>>> bytes('中文','utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'

😃 memoryview: 根据传入的参数创建一个新的内存查看对象

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103

😃 bin: 将整数转换成二进制字符串

>>> bin(5)
'0b101'

😃 oct: 将整数转换成八进制字符串

>>> oct(9)
'0o11'

😃 hex: 将整数转换成十六进制字符串

>>> hex(10)
'0xa'

😃 tuple(): 根据传入的参数创建一个新的元组

>>> tuple()
()
>>> tuple('123')
('1',  '2',  '3')

😃 list: 根据传入的参数创建一个新的列表

>>> list()
[]
>>> list('123')
['1', '2', '3']

😃 dict: 根据传入的参数创建一个新的字典

>>> dict()
{}
>>> dict(zip(['a','b'],[1,2])) #创建存在映射的字典
{'a' : 1, 'b' : 2}
>>> dict(a = 1,b = 2)
{'a': 1, 'b': 2}

😃 set: 根据传入的参数创建一个新的集合

>>> set()
set()
>>> a = set(range(10)); a     # 传入可迭代对象，创建集合
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

😃 frozenset: 根据传入的参数创建一个新的不可变集合

#frozen set，冰冻的集合，即为不可变集合
>>> a = frozenset(range(10)); a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

😃 enumerate: 根据可迭代对象创建枚举对象

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) #指定起始值
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

😃 range: 根据传入的参数创建一个新的range对象

>>> a = range(5); a
range(0, 5)
>>> list(a)
[0, 1, 2, 3, 4]
# 左闭右开，左闭右开，左闭右开，重要的事说三遍

😃 iter：根据传入的参数创建一个新的可迭代对象

>>> a = iter('ab');a
<str_iterator object at 0x000002192886A7F0>
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
next(a)
StopIteration

😃 slice：根据传入的参数创建一个新的切片对象

>>> c1 = slice(1);c1
slice(None, 1, None)
>>> c2 = slice(1,2);c2
slice(1, 2, None)
>>> c3 = slice(1,2,3);c3
slice(1, 2, 3)

😃 super：根据传入的参数创建一个新的子类和父类关系的代理对象

>>> class A(object):	#定义父类A
def __init__(self):
print('A.__init__')

>>> class B(A):	#定义子类B，继承A
def __init__(self):
print('B.__init__')
super().__init__()
>>> b = B()	#super调用父类方法
B.__init__
A.__init__

😃 object：创建一个新的object对象

>>> a = object()
>>> a.name = 'Anny'
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
a.name = 'Anny'
AttributeError: 'object' object has no attribute 'name'

3> 序列操作 (8个）

😃 all：判断可迭代对象的每个元素是否都为True值

>>> all(())	#空元组
True
>>> all({})	#空字典
True
>>> all([1,2])	#列表中每个元素逻辑值均为True，返回True
True
>>> all([0,1,2])	#列表中0的逻辑值为False，返回False
False

😃 any：判断可迭代对象的元素是否有为True值的元素

>>> any([])	#空列表
False
>>> any({})	#空字典
False
>>> any([0,1,2])	#列表元素有一个为True，返回True
True
>>> any([0,0])	#列表元素全部为False，返回False
False

😃 filter：使用指定方法过滤可迭代对象的元素

>>> a = list(range(1,10)) #定义序列
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> def if_odd(x): #定义奇数判断函数
return x%2==1

>>> list(filter(if_odd,a)) #筛选序列中的奇数
[1, 3, 5, 7, 9]

😃 map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

>>> a = map(ord,'abcd'); a
<map object at 0x03994E50>
>>> list(a)
[97, 98, 99, 100]

😃 next：返回可迭代对象中的下一个元素值

>>> a = iter('ab')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
next(a)
StopIteration
>>> next(a,'2')
'2'
#传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常

😃 reversed：反转序列生成新的可迭代对象

>>> a = reversed(range(10));a
<range_iterator object at 0x0000021928845710>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> b = range(10)
>>> list(b)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

😃 sorted：对可迭代对象进行排序，返回一个新的列表

>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']

>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']

>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']

😃 zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

>>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]

4> 对象操作 (7个)

😃 help: 返回对象的帮助信息

>>> help(print)
Help on built-in function print in module builtins:

print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file:  a file-like object (stream); defaults to the current sys.stdout.
sep:   string inserted between values, default a space.
end:   string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

😃 dir:返回对象或者当前作用域内的属性列表

>>> dir(print)
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']

😃 id：返回对象的唯一标识符

# Python采用的是 基于值的内存管理方式(仅适用于-5至256的整数和短字符串)
值在内存中只有一份，多个变量指向同一块内存地址
>>> x = 3
>>> y = 3
>>> id(x)
1989136176
>>> id(y)
1989136176

😃 hash：获取对象的哈希值

>>> a = 1.0;type(a)
<class 'float'>

😃 len：返回对象的长度

>>> len('abcd12$')
7
>>> len({'a':1, 'b':2, 'c':3, 'd':4})
4
>>> len(range(10))
10

😃 ascii：返回对象的可打印表字符串表现方式

>>> ascii(1)
'1'
>>> ascii('中文') #非ascii字符
"'\\u4e2d\\u6587'"

😃 format：格式化显示值

>>> format(3,'b') #转换成2进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'

😃 vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

>>> class A(object):
pass
>>> a.__dict__
{}
>>> vars(a)
{}
>>> a.name = 'Kim'
>>> a.__dict__
{'name': 'Kim'}
>>> vars(a)
{'name': 'Kim'}

5> 序列操作(8个)

😃 import：动态导入模块

index = __import__('index')
index.sayHello()

😃 isinstance：判断对象是否是类或者类型元组中任意类元素的实例

>>> isinstance(1,int)
True
>>> isinstance(1,str)
False
>>> isinstance(1,(int,str))
True

😃 issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类

>>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True

😃 hasattr：检查对象是否含有属性

#定义类A
>>> class Student:
def __init__(self,name):
self.name = name

>>> s = Student('Aim')
>>> hasattr(s,'name')   #a含有name属性
True
>>> hasattr(s,'age')      #a不含有age属性
False

😃 getattr：获取对象的属性值

#定义类Student
>>> class Student:
def __init__(self,name):
self.name = name

>>> getattr(s,'name') #存在属性name
'Aim'
>>> getattr(s,'age',6) #不存在属性age，但提供了默认值，返回默认值
>>> getattr(s,'age') #不存在属性age，未提供默认值，调用报错
Traceback (most recent call last):
File "<pyshell#17>", line 1, in <module>
getattr(s,'age')
AttributeError: 'Stduent' object has no attri
20000
bute 'age'

😃 setattr：设置对象的属性值

>>> class Student:
def __init__(self,name):
self.name = name

>>> a = Student('Kim')
>>> a.name
'Kim'
>>> setattr(a,'name','Bob')
>>> a.name
'Bob'

😃 delattr：删除对象的属性

#定义类A
>>> class A:
def __init__(self,name):
self.name = name
def sayHello(self):
print('hello',self.name)

#测试属性和方法
>>> a.name
'小麦'
>>> a.sayHello()
hello 小麦

#删除属性
>>> delattr(a,'name')
>>> a.name
Traceback (most recent call last):
File "<pyshell#47>", line 1, in <module>
a.name
AttributeError: 'A' object has no attribute 'name'

😃 callable：检测对象是否可被调用

>>> class B: #定义类B
def __call__(self):
print('instances are callable now.')

>>> callable(B) #类B是可调用对象
True
>>> b = B() #调用类B
>>> callable(b) #实例b是可调用对象
True
>>> b() #调用实例b成功
instances are callable now.

6> 变量操作(2个)

😃 globals：返回当前作用域内的全局变量和其值组成的字典

>>> globals()
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
>>> a = 1
>>> globals() #多了一个a
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}

😃 locals：返回当前作用域内的局部变量和其值组成的字典

>>> def f():
print('before define a ')
print(locals()) #作用域内无变量
a = 1
print('after define a')
print(locals()) #作用域内有一个a变量，值为1

>>> f
<function f at 0x03D40588>
>>> f()
before define a
{}
after define a
{'a': 1}

7> 交互操作(2个)

😃 print：向标准输出对象打印输出

>>> print(1,2,3)
1 2 3
>>> print(1,2,3,sep = '+')
1+2+3
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?

😃 input：读取用户输入值

>>> s = input('please input your name:')
please input your name:Ain
>>> s
'Ain'

8> 文件操作 (1个)

😃 open：使用指定的模式和编码打开文件，返回文件读写对象

#t为文本读写，b为二进制读写
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a.close()

9> 编译执行 (4个)

😃 compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

#流程语句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)
0
1
2
3
4
5
6
7
8
9

😃 eval：执行动态表达式求值

#执行语句
>>> exec('a=1+2');a
3

😃 repr：返回一个对象的字符串表现形式(给解释器)

>>> a = 'some text'
>>> str(a)
'some text'
>>> repr(a)
"'some text'"

10> 装饰器 (3个)

😃 property：标示属性的装饰器

>>> class C:
def __init__(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self,value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value

>>> c = C()
>>> c.name    #访问属性

>>> c.name = None  #设置属性时进行验证
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
c.name = None
File "<pyshell#81>", line 11, in name
raise RuntimeError('name can not be None')
RuntimeError: name can not be None

#设置属性
>>> c.name = 'Kim'
>>> c.name # 访问属性
'Kim'

>>> del c.name
#删除属性，不提供deleter则不能删除
Traceback (most recent call last):
File "<pyshell#87>", line 1, in <module>
del c.name
AttributeError: can't delete attribute
>>> c.name
'Kim'

😃 classmethod：标示方法为类方法的装饰器

>>> class C:
@classmethod
def f(cls,arg1):
print(cls)
print(arg1)

>>> C.f('类对象调用类方法')
<class '__main__.C'>
类对象调用类方法

>>> c = C()
>>> c.f('类实例对象调用类方法')
<class '__main__.C'>
类实例对象调用类方法

😃 staticmethod：标示方法为静态方法的装饰器

# 使用装饰器定义静态方法
>>> class Student(object):
def __init__(self,name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好！')

>>> Student.sayHello('en') #类调用,'en'传给了lang参数
en
Welcome!

>>> b = Student('Kim')
>>> b.sayHello('zh')  #类实例对象调用,'zh'传给了lang参数
zh
你好

参考文献：
参考1
参考2
Unicode字符百科