python中常用的内置函数

1、abs()函数：返回数字的绝对值。

data1 = abs(-20)
data2 = abs(0.3)
print('data1:{}, data2:{}'.format(data1, data2))

#输出结果如下：
data1:20, data2:0.3

2、all()函数：用于判断给定的参数中的所有元素是否是true，如果是则返回值为True，否则返回值为False。

说明：参数必须是可迭代对象，元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。

print('test0:', all({False, 12, 11, 0}))
print('test1:', all([0.1, 1, -1]))
print('test2:', all((None, 11, 2)))
print('test3:', all({0, 22}))
print('test4:', all(['', 'bb', ' ']))

#输出结果如下：
test0: False
test1: True
test2: False
test3: False
test4: False

3、any()函数：与all()函数相反，用于判断给定的参数中是否全部为False，是则返回False，否则返回True。

说明：元素除了是 0、空、False外都算 TRUE。

print('test0:', any({False,  0}))
print('test1:', any([0.1, 1, -1]))
print('test2:', any((None, 11, 2)))
print('test3:', any({0, None}))
print('test4:', any(['', 'bb', ' ']))

#输出结果如下：
test0: False
test1: True
test2: True
test3: False
test4: True

4、bin()函数：返回一个整数int或者长整数long int的二进制表示。

print('bin test1:', bin(5))
print('bin test2:', bin(15))

#输出结果如下：
bin test1: 0b101
bin test2: 0b1111

5、oct() 函数：返回一个整数int或者长整数long int的八进制表示。

print(oct(10))
print(oct(3))
#输出结果如下：
0o12
0o3

6、hex()函数：用于将10进制整数转换成16进制，以字符串形式表示。

print(hex(10))
print(hex(3))
#输出结果如下：
0xa
0x3

7、bool() 函数：用于将给定参数转换为布尔类型。

说明：如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。

print('bool test1:', bool(5))
print('bool test2:', bool())
print('bool test3:', bool(['aaa', '', 11]))

#输出结果如下：
bool test1: True
bool test2: False
bool test3: True

8、callable()函数：用于检查一个对象是否是可调用的。

说明:  对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True。

          如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

          对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。

def test():
    pass
print('test1:', callable(test()))
print('test2:', callable(test))

class A:
    def test2(self):
        pass
print('A1:', callable(A()))
print('A2:', callable(A))

b = 12
print('b1:', callable(b))

#输出结果如下：
test1: False
test2: True
A1: False
A2: True
b1: False

9、divmod()函数：把除数和余数的运算结果结合起来，返回一个包含商和余数的元组（商x，余数y）。

print('test1:', divmod(5, 2))
print('test2:', divmod(10, 2))
print('test3', divmod(1.1, 2))

#输出结果如下：
test1: (2, 1)
test2: (5, 0)
test3 (0.0, 1.1)

10、enumerate() 函数：用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

说明：可添加参数添start 表示下标开始的位置，默认为0。

data = ['a', 'b', 'c', 'd', 'e']
for index, x in enumerate(data):
    print(index, x)

#输出结果如下：
0 a
1 b
2 c
3 d
4 e

data = ['a', 'b', 'c', 'd', 'e']
for index, x in enumerate(data, start=1):
    print(index, x)

#输出结果如下：
1 a
2 b
3 c
4 d
5 e

11、eval()函数：用来执行一个字符串表达式，并返回表达式的值。

print('test1:', eval('2 * 7'))
print('test2:', eval('pow(3, 2)'))
x = 5
print('test3:', eval('3 + x'))

#结果输出如下：
test1: 14
test2: 9
test3: 8

12、exec()函数：执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。 

注：exec中执行语句必须被括在双引号内，不能为单引号。

exec("print('hello world')")
exec("for i in range(5): print('iter time is %d' %i )")
#输出结果如下：
hello world
iter time is 0
iter time is 1
iter time is 2
iter time is 3
iter time is 4

13、filter()函数：用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

说明：该函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def is_odd(n):
    return n % 2 == 1
new_data = filter(is_odd, data)
print('new_data:', list(new_data))

#或者使用lamada表达式
new_data1 = filter(lambda x: x %2 ==1, data)
print('new_data1:', list(new_data1))

#输出结果如下：
new_data: [1, 3, 5, 7, 9]
new_data1: [1, 3, 5, 7, 9]

14、getattr() 函数：用于返回一个对象属性值。

        hasattr() 函数：用于判断对象是否包含对应的属性。

class Test(object):
    def aa(self):
        pass
    def bb(self):
        return 9
    x = 11
    y = 20
    z = 0

test = Test()
print('hasattr:', hasattr(test, 'aa'))
print('hasattr:', hasattr(test, 'bb'))
print('hasattr:', hasattr(test, 'x'))

print('getattr:', getattr(test, 'aa'))
print('getattr:', getattr(test, 'bb'))
print('getattr:', getattr(test, 'x'))

#输出结果如下：
hasattr: True
hasattr: True
hasattr: True
getattr: <bound method Test.aa of <__main__.Test object at 0x0000000002980438>>
getattr: <bound method Test.bb of <__main__.Test object at 0x0000000002980438>>
getattr: 11

15、id()函数：返回对象的唯一标识符，标识符是一个整数。

说明：CPython 中id()函数用于获取对象的内存地址。

a = 10
b = [11, 2, 9]
c = {'xx':1, 'yy':2}
d = c
print('a id:{}, b id:{}, c id:{}, d id:{}'.format(id(a), id(b), id(c), id(d)))

#输出结果如下：
a id:8791342179440, b id:6054536, c id:6519904, d id:6519904

16、isinstance() 函数：用来判断一个对象是否是一个已知的类型，返回布尔值，类似 type()。

isinstance() 与 type() 区别：

       type() 不会认为子类是一种父类类型，不考虑继承关系。

       isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

a = 2
print('test1:', isinstance(a, int))
print('test2:', isinstance(a, str))
print('test3:', isinstance(a, (str, int, list))) #只能为元组类型


#isinstance 与 type的差异
class A(object):
    pass
class B(A):
    pass
print('isinstance1:', isinstance(A(), A))
print('type1:', type(A()) == A)
print('isinstance2:', isinstance(B(), A))
print('type2:', type(B()) == A)

#输出结果如下：
test1: True
test2: False
test3: True
isinstance1: True
type1: True
isinstance2: True
type2: False

17、issubclass() 函数：用于判断参数 class 是否是类型参数 classinfo 的子类。

class A:
    pass
class B(A):
    pass
print(issubclass(B, A))
#输出结果如下：
True

18、iter() 函数：用来生成迭代器。

说明：list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器，然后可以对获取到的迭代器不断用next()函数来获取下条数据。iter()函数实际上就是调了可迭代对象的 __iter__ 方法。

注意：当已经迭代完最后一个数据之后，再次调用next()函数会抛出 StopIteration的异常，来告诉我们所有数据都已迭代完成。

next() 函数：用于返回迭代器的下一个项目。 

data = [1, 2, 3, 4]
for i in iter(data):
    print(i)

x = iter(data)
print('index0:', next(x))
print('index1:', next(x))
print('index2:', next(x))
print('index3:', next(x))
print('index4:', next(x))

#输出结果如下：
1
2
3
4
index0: 1
index1: 2
index2: 3
index3: 4
Traceback (most recent call last):
  File "D:/workspace/python/test/test1.py", line 12, in <module>
    print('index4:', next(x))
StopIteration

19、len() 函数：返回对象（字符、列表、元组等）长度或元素个数。

由于使用太常见，具体使用略。

20、map()函数：会根据提供的函数对指定序列做映射。

说明：第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

注意：关于返回值，Python 2.x 返回列表，Python 3.x 返回迭代器。

def square(x):
    return x ** 2

data = [1, 2, 3, 4, 5]

new_data1 = map(square, data)
new_data2 = map(lambda x: x**2, data)
print(list(new_data1))
print(list(new_data2))

data2 = [2, 3, 4, 5, 6]
new_data3 = map(lambda x, y: x+y, data, data2)
print(list(new_data3))

#输出结果如下：
[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]
[3, 5, 7, 9, 11]

21、max()函数：返回给定参数的最大值，参数可以为序列。

       min()函数：返回给定参数的最小值，参数可以为序列。

由于使用太常见，具体使用略。

22、pow()函数：返回x的y次方的值。

注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

print(pow(2, 3))
import math
print(math.pow(2, 3))

#输出结果如下：
8
8.0

23、range()函数：可创建一个整数列表，一般用在 for 循环中。

由于使用太常见，具体使用略。

24、reduce() 函数：会对参数序列中元素进行累积。

注意：在Python3 ，reduce()被放置在functools模块里，如果想要使用它，需要先引入functools模块。

from functools import reduce
data = [1, 2, 3, 4]
result = reduce(lambda x, y: x+y, data)
print(result)
#输出结果如下：
10

25、reverse() 函数：用于反向列表中元素， 与list.reverse()作用相同。

说明：reversed(seq)要转换的序列，可以是 tuple, string, list 或 range。

data = [1, 2, 3, 4]
print('reversed data:', list(reversed(data)))

#输出结果如下：
reversed data: [4, 3, 2, 1]

26、round() 函数：返回浮点数x的四舍五入值。（除非对精确度没什么要求，否则尽量避开用round()函数）

#默认取整，第二个参数设置小数点个数
print("round(80.23456) : ", round(80.23456))
print("round(80.53456) : ", round(80.53456))
print("round(80.23456, 2) : ", round(80.23456, 2))
print("round(100.004456, 3) : ", round(100.004456, 3))
print("round(-100.004456, 3) : ", round(-100.004456, 3))

#输出结果如下：
round(80.23456) :  80
round(80.53456) :  81
round(80.23456, 2) :  80.23
round(100.004456, 3) :  100.004
round(-100.004456, 3) :  -100.004

27、set() 函数：创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

a = set('hello world')
print(a)

b = set([1, 2, 3, 4, 5])
c = set([2, 4, 6, 8, 10])
print(b & c)
print(b | c)
print(b - c)

#输出结果如下：
{'e', ' ', 'w', 'd', 'r', 'h', 'l', 'o'}
{2, 4}
{1, 2, 3, 4, 5, 6, 8, 10}
{1, 3, 5}

28、slice() 函数：实现切片对象，主要用在切片操作函数里的参数传递。

说明：slice()中可以传递参数，start, stop, step。

data = [x for x in range(10)]
x = slice(1)
print(data[x])

x = slice(1, 6)
print(data[x])

x = slice(1, 6, 2)
print(data[x])

#输出结果如下：
[0]
[1, 2, 3, 4, 5]
[1, 3, 5]

29、sorted() 函数：对所有可迭代的对象进行排序（默认升序）操作。

sorted(iterable, cmp=None, key=None, reverse=False)

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

data = [x for x in range(10)]
print(sorted(data, reverse=True))

dict = {str(x):x  for x in range(10)}
#只对key值进行排序
print(sorted(dict, reverse=True))

#默认按key进行排序
print(sorted(dict.items(), reverse=True))

#用匿名函数实现按value进行排序
print(sorted(dict.items(), key=lambda x:x[1], reverse=True))

#输出结果如下：
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
['9', '8', '7', '6', '5', '4', '3', '2', '1', '0']
[('9', 9), ('8', 8), ('7', 7), ('6', 6), ('5', 5), ('4', 4), ('3', 3), ('2', 2), ('1', 1), ('0', 0)]
[('9', 9), ('8', 8), ('7', 7), ('6', 6), ('5', 5), ('4', 4), ('3', 3), ('2', 2), ('1', 1), ('0', 0)]

30、super() 函数：用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

具体用法请参考：https://www.runoob.com/python/python-func-super.html

31、zip() 函数：用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

说明：如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = ['hh', 'aa', 'dd', 'cc', 'ee', 'ff']
c = [i for i in zip(a, b) if i[0] < 4]
print(c)
 
#输出结果
[(0, 'hh'), (1, 'aa'), (2, 'dd'), (3, 'cc')]

原文参考链接：https://www.cnblogs.com/wujiaqing/p/10709207.html