python内置函数及其作用,python常用内置函数大全

大家好，给大家分享一下python有哪些常用的内置函数，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！

数学相关

1.abs(a) : 求取绝对值。abs(-1)

2.max(list) : 求取list最大值Python中Turtle画蝴蝶。max([1,2,3])

3.min(list) : 求取list最小值。min([1,2,3])

4.sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6

5.sorted(list) : 排序，返回排序后的list。
6.len(list) : list长度,len([1,2,3])

7.divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)

8.pow(a,b) : 获取乘方数。pow(2,3) >>> 8
9.round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14

10.range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]

类型转换
int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65
其他

eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
exec() : 执行python语句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']

defaultdict定义查询可以查询字典中没有的返回为0或空或【】。

dict1 = defaultdict(int)
dict2 = defaultdict(set)
dict3 = defaultdict(str)
dict4 = defaultdict(list)
dict1[2] ='two'
 
print(dict1[1])
print(dict2[1])
print(dict3[1])
print(dict4[1])
 
 

0
set()
 

Python collections.Counter用法
什么是collections
Counter
Counter操作
例子
什么是collections
collections在python官方文档中的解释是High-performance container datatypes，直接的中文翻译解释高性能容量数据类型。
它总共包含五种数据类型：

其中Counter中文意思是计数器，也就是我们常用于统计的一种数据类型，在使用Counter之后可以让我们的代码更加简单易读。

Counter
我们先看一个简单的例子：

#统计词频
colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
result = {}
for color in colors:
    if result.get(color)==None:
        result[color]=1
    else:
        result[color]+=1
print (result)
#{'red': 2, 'blue': 3, 'green': 1}
1
2
3
4
5
6
7
8
9
10
下面我们看用Counter怎么实现：

from collections import Counter
colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
c = Counter(colors)
print (dict(c))
1
2
3
4
显然代码更加简单了，也更容易读和维护了。

Counter操作
可以创建一个空的Counter：

cnt = Counter()
1
之后在空的Counter上进行一些操作。
也可以创建的时候传进去一个迭代器（数组，字符串，字典等）：

c = Counter('gallahad')                 # 传进字符串
c = Counter({'red': 4, 'blue': 2})      # 传进字典
c = Counter(cats=4, dogs=8)             # 传进元组
1
2
3
判断是否包含某元素，可以转化为dict然后通过dict判断，Counter也带有函数可以判断：

c = Counter(['eggs', 'ham'])
c['bacon']                              # 不存在就返回0
#0
1
2
3
删除元素：

c['sausage'] = 0                        # counter entry with a zero count
del c['sausage']   
1
2
获得所有元素：

c = Counter(a=4, b=2, c=0, d=-2)
list(c.elements())
#['a', 'a', 'a', 'a', 'b', 'b']
1
2
3
查看最常见出现的k个元素：

Counter('abracadabra').most_common(3)
#[('a', 5), ('r', 2), ('b', 2)]
1
2
Counter更新：

c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
c + d                       # 相加
#Counter({'a': 4, 'b': 3})
c - d                       # 相减，如果小于等于0，删去
#Counter({'a': 2})
c & d                       # 求最小
#Counter({'a': 1, 'b': 1})
c | d                       # 求最大
#Counter({'a': 3, 'b': 2})
1
2
3
4
5
6
7
8
9
10
例子
例子：读文件统计词频并按照出现次数排序，文件是以空格隔开的单词的诸多句子：

from collections import Counter
lines = open("./data/input.txt","r").read().splitlines()
lines = [lines[i].split(" ") for i in range(len(lines))]
words = []
for line in lines:
    words.extend(line)
result = Counter(words)
print (result.most_common(10))
1
2
3
4
5
6
7
8
当需要统计的文件比较大，使用read()一次读不完的情况：

from collections import Counter
result = Counter()
with open("./data/input.txt","r") as f:
    while True:
        lines = f.read(1024).splitlines()
        if lines==[]:
            break
        lines = [lines[i].split(" ") for i in range(len(lines))]
        words = []
        for line in lines:
            words.extend(line)
        tmp = Counter(words)
        result+=tmp

print (result.most_common(10))

python内置函数sum()与map()

# sum(iterable, start=0, /)  将iterable中每一个元素相加,再加上start的值
print(sum([0, 1, 2]))
print(sum((2, 3, 4), 1))  # 元组计算总和后再加 1
print(sum([0, 1, 2, 3, 4], 2)) # 列表计算总和后再加 2
输出:
3
10
12
#map(func, *iterables) --> map object
#将func函数依次作用于iterables中的每一个元素,返回一个迭代器对象
def f(x):
    return x*x
r = map(f, [1, 2, 3, 4, 5])
print(list(r))
#输出为[1, 4, 9, 16, 25]

Python数字、字符串、数组相互转换
Python数组转数字
[3, 7, 6, 8, 9]转为37689

nums=[3, 7, 6, 8, 9]
a = 0
for num in nums:
    a = a *10 + num
print(a)#37689
1
2
3
4
5
Python数字转数组
1234转为[1, 2, 3, 4]

b = 1234
b = [ int(x) for x in str(b) ]
print(b)#[1, 2, 3, 4]
1
2
3
Python字符串转数组
"zagiee"转为[‘z’, ‘a’, ‘g’, ‘i’, ‘e’, ‘e’]

b = "zagiee"
print(list(b))#['z', 'a', 'g', 'i', 'e', 'e']
1
2
Python数组转字符串
a= [2,1,3]
print(''.join(map(str, a)))#213
c = ['z', 'a', 'g', 'i', 'e', 'e']
print(''.join(c))#zagiee
1
2
3
4
Python字符数组转数字型数组
[‘1’, ‘5’, ‘6’, ‘28’]转为[1, 5, 6, 28]

numbers = ['1', '5', '6', '28']
numbers = [ int(x) for x in numbers ]
print(numbers)#[1, 5, 6, 28]
1
2
3
Python数字型数组转字符数组
[1, 5, 6, 28]转为[‘1’, ‘5’, ‘6’, ‘28’]

numbers = [1, 5, 6, 28]
numbers = [ str(x) for x in numbers ]
print(numbers)#['1', '5', '6', '28']

用python实现字符串反转的16种方法

方法一：反转列表法 
a = ‘abcdef’
b = list(a)
b.reverse()
b = ‘’.join(b)
print(b)

Python中，列表可以进行反转，我们只要把字符串转换成列表，使用reverse()方法，进行反转，然后再使用字符串的join()方法遍历列表，合并成一个字符串。 
方法二：循环反向迭代法
a = ‘abcdef’
b = ‘’
for i in a:
    b = i + b
print(b)

字符串属于序列的一种，我们可以使用for循环遍历字符串，然后，不断反向赋值给变量b，最后输出变量b，就完成了字符串反转。

方法三：反向循环迭代法
a = ‘abcdef’
b = ‘’
for i in a[::-1]:
    #b = b + i
    b += i
print(b)

字符串本身就可以进行切片，当然也可以设置步长为-1，进行倒序。然后，再进行遍历，迭代变量b，也可以达到反转效果，逻辑和方法二相同。

方法四：倒序切片法
a = ‘abcdef’
b = a[::-1]
print(b)

方法二和方法三的终极版本，直接反转，一步到位。 
方法五：遍历索引法
a = ‘abcdef’
b = ‘’
for i in range(1,len(a)+1):
    b = b + a[-i]
print(b)

字符串作为序列，可以进行索引，我们先遍历索引数字，然后倒序提取字母，然后合并成字符串。

方法六：列表弹出法
a = ‘abcdef’
a = list(a)
b = ‘’
while len(a) > 0:
    b = b + a.pop()
print(b)

列表有一种弹出的方法pop()，弹出其中某个元素，默认为最后一个元素。我们设置变量b，然后不断弹出字符串的最后一个字符，加入变量b中，最终使得字符串反转。 
方法七：列表解析式法
a = ‘abcdef’
b = ‘’.join(i for i in a[::-1])
print(b)

方法三的简便写法，使用列表解析式，简化代码书写。最后同样通过join()方法，反转合并字符串。

方法八：反向遍历索引法
a = ‘abcdef’
b = ‘’.join(i for i in a[::-1])
print(b)

range()函数有三个参数：start,end,step，且左闭右开，我们从最后一个索引开始，最开始的索引结束，倒序遍历索引，然后反向提取字符串，最后合并。是方法五的逆向思维。

方法九：累积相加法
a = ‘abcdef’
from functools import reduce
def f(x,y):
    return y + x
b = reduce(f,a)
print(b)

使用python中的reduce()函数。先创建一个字符串倒序相加函数和字符串，一起传入reduce函数中，运行，就可以进行字符串倒序累积相加，最后反转字符串。 
方法十：匿名函数法
a = ‘abcdef’
b = reduce(lambda x,y:y+x,a)
print(b)

方法九的进阶版，使用lambda匿名函数创建字符串倒序相加函数，然后进行累积，得到字符串反转结果。 
方法十一：列表倒序法
a = ‘abcdef’
a = list(a)
a.sort(reverse=True)
b = ‘’.join(a)
print(b)