python中超级实用的30个内置函数

python的内置函数是指不需要任何导入，就可以使用的函数

max(iterable, *[, default=obj, key=func])

内置函数max的作用是找到最大值，对所有容器型数据都可以使用

• 找到容器的最大值

In [311]: a = [1,2,3,3,3,4,2,3]
In [312]: max(a)
Out[312]: 4

# 对于集合，默认是找出键的最大值
In [320]: di = {'a':3,'b1':1,'c':4}
In [321]: max(di)
Out[321]: 'c'

In [316]: max('63447')
Out[316]: '7'
# 这里要注意，对于字符串，max是按照第一个字符的Ascii码比较的
In [318]: max({'3','10','7'})
Out[318]: '7'
In [319]: max({'3','9','7'})
Out[319]: '9'

• 找到列表最多重复的元素

In [313]: max(a,key=lambda x: a.count(x))
Out[313]: 3

• 如果容器为0，设置默认值为0

In [315]: max([],default=0)
Out[315]: 0

• 当内置函数max使用lambda时，lambda里的x就是容器里面的一个个元素

# 找到年龄最大的人
In [323]: a = [{'name':'a','age':18,'gender':'male'},{'name':'b','age':20,'gender':'female'}]

In [324]: max(a,key=lambda x: x['age'])
Out[324]: {'name': 'b', 'age': 20, 'gender': 'female'}

• 找到每一个列表中第二个元素最大的列表

In [325]: lst = [[1,3],[0,6],[4,5]]
In [326]: max(lst,key=lambda x: x[1])
Out[326]: [0, 6]

sum(iterable, start=0, /)

• 列表(所有容器型数据均可)求和

In [327]: a = [1,3,2,1,4,2]

In [328]: sum(a)
Out[328]: 13

In [329]: sum(a,2) # start=2 表示求和的初始值为 2
Out[329]: 15

sorted(iterable, /, *, key=None, reverse=False)

• 列表排序

In [330]: a = [1,2,3,3,4,2,3]
# 默认从小到大排序
In [331]: sorted(a)
Out[331]: [1, 2, 2, 3, 3, 3, 4]
# 从大到小排序
In [332]: sorted(a,reverse=True)
Out[332]: [4, 3, 3, 3, 2, 2, 1]

• 按照每一个列表的第二个元素排序

In [333]: lst = [[1,4],[3,2]]
In [334]: sorted(lst,key = lambda x:x[1])
Out[334]: [[3, 2], [1, 4]]

• 字典排序

# 对字典直接使用sorted是对键排序
In [335]: d = {'a':5,'c':7,'d':6}
In [336]: sorted(d)
Out[336]: ['a', 'c', 'd']
# 按照字典的值排序，注意是d.items()
In [337]: sorted(d.items(),key = lambda x:x[1])
Out[337]: [('a', 5), ('d', 6), ('c', 7)]

len(obj, /)

• 求容器中元素的个数

In [340]: dic = {'a':1,'b':3}
In [341]: len(dic)
Out[341]: 2

In [342]: s = 'abc'
In [343]: len(s)
Out[343]: 3

pow(x, y, z=None, /)

• x 为底的 y 次幂，如果 z 给出，取余

In [344]: pow(3, 2)
Out[344]: 9

In [345]: pow(3, 2, 4)
Out[345]: 1

round(number, ndigits=None)

• 四舍五入，ndigits 代表小数点后保留几位

In [346]: round(10.0222222, 3)
Out[346]: 10.022

In [347]: round(10.02252222, 3)
Out[347]: 10.023

In [349]: round(10.0222222)
Out[349]: 10
# 默认ndigits为0，返回int
In [348]: type(round(10.0222222))
Out[348]: int

abs(x, /)

In [350]: abs(-6)
Out[350]: 6

In [351]: abs(-10.223555)
Out[351]: 10.223555

all(iterable, /)

• 接受一个迭代器，如果迭代器的所有元素都为真，返回 True，否则返回 False

In [352]: all([1,0,3,6])
Out[352]: False

In [353]: all([1,2,3])
Out[353]: True

any(iterable, /)

• 接受一个迭代器，如果迭代器里有一个元素为真，返回 True，否则返回 False

In [354]: any([0,0,0,[]])
Out[354]: False

In [355]: any([0,0,1])
Out[355]: True

bin(number, /)

• 将十进制转换为二进制，返回二进制的字符串

In [356]: bin(10)
Out[356]: '0b1010'
# 0b代表二进制
In [357]: 0b1010
Out[357]: 10

oct(number, /)

• 将十进制转换为八进制，返回八进制的字符串

In [358]: oct(12)
Out[358]: '0o14'
# 0o代表八进制
In [359]: 0o14
Out[359]: 12

hex(number, /)

• 将十进制转换为十六进制，返回十六进制的字符串

In [360]: hex(15)
Out[360]: '0xf'
# 0x代表16进制
In [361]: 0xf
Out[361]: 15

bool(x)

• 如果是一个值，如果为0返回False，如果为1返回True，如果是一个容器，容器为空返回Flase，容器不为空返回True

In [362]: bool(0)
Out[362]: False

In [363]: bool(1)
Out[363]: True

In [364]: bool([1,0,0,0])
Out[364]: True

In [365]: bool([0])
Out[365]: True

In [366]: bool([])
Out[366]: False
# 容器中如果是空元素，也返回True
In [367]: bool([[],[]])
Out[367]: True

In [368]: bool([[]])
Out[368]: True

str(object=’’)

• 将字符类型、数值类型等转换为字符串类型

# 默认为空
In [383]: str()
Out[383]: ''
In [369]: i =123
In [370]: str(i)
Out[370]: '123'
In [371]: str(10.235)
Out[371]: '10.235'

ord(c, /)

• 查看某个字符对应的ASCII码，必须传入单个字符串

In [372]: ord('A')
Out[372]: 65

In [374]: ord('0')
Out[374]: 48

dict()、dict(mapping)、dict(iterable)

• 创建数据字典
• dict()，通过构造函数常见字典
• dict(mapping)，通过映射创建字典
• dict(iterable)，通过迭代器创建字典

In [92]: dict()
Out[92]: {}

In [93]: dict(a='a',b='b')
Out[93]: {'a': 'a', 'b': 'b'}

In [94]: dict(zip(['a','b'],[1,2]))
Out[94]: {'a': 1, 'b': 2}

In [95]: dict([('a',1),('b',2)])
Out[95]: {'a': 1, 'b': 2}

object()

• 返回一个根对象，它是所有类的基类

In [137]: o = object()
In [138]: type(o)
Out[138]: object

• 使用python内置函数dir，返回object的属性、方法列表

In [379]: dir(o)
Out[379]: 
['__class__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']

int(x, base=10)

int(x, base =10)，x 可能为字符串或数值，将 x 转换为一个整数，base是基数

In [380]: int('12')
Out[380]: 12
# int没有四舍五入的功能
In [382]: int(13.56)
Out[382]: 13

• int的基数base有很大的作用，可以将任何一个其它进制的数据转化为十进制

# 将八进制转化为十进制
# 1*8+2
In [384]: int('12',8)
Out[384]: 10
# 将16进制转化为10进制
# 1*16+2
In [386]: int('12',16)
Out[386]: 18
# 二进制转十进制
int('0100',2)

• 将其它进制的数据转化为十进制的时候，传入的x必须是字符串，否则报错

# x必须是字符串
In [387]: int(12,16)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-387-2153b26001c8> in <module>
----> 1 int(12,16)

TypeError: int() can't convert non-string with explicit base

float(x=0, /)

• 将一个字符串或整数转换为浮点数

In [390]: float()
Out[390]: 0.0

In [388]: float('30.01')
Out[388]: 30.01

In [389]: float(30)
Out[389]: 30.0

list(iterable=(), /)

• 将一个容器转化为列表类型

In [391]: a = {1,2,3}
In [392]: list(a)
Out[392]: [1, 2, 3]

In [393]: d = {'a':1,'b':2,'c':3}
In [394]: list(d)
Out[394]: ['a', 'b', 'c']

In [395]: list(d.items())
Out[395]: [('a', 1), ('b', 2), ('c', 3)]

set()、set(iterable)

• set()创建一个空的集合对象
• set(iterable)返回一个集合对象，并允许创建后再增加、删除元素。

集合的一大优点，容器里不允许有重复元素，因此可对列表内的元素去重。

In [397]: a=set()
In [399]: a.add('a')
In [400]: a
Out[400]: {'a'}

In [401]: a = [1,2,1,3,4]
In [402]: set(a)
Out[402]: {1, 2, 3, 4}

slice(stop)、slice(start, stop[, step])

返回一个由 range(start, stop, step) 所指定索引集的 slice 对象

In [403]: a = [1,2,1,3,4,6,7]

In [404]: a[slice(0,7,2)] #等价于a[0:7:2]
Out[404]: [1, 1, 4, 7]
In [405]: a[0:7:2]
Out[405]: [1, 1, 4, 7]

tuple(iterable=(), /)

• 将一个迭代器转化为元祖

In [409]: a = [1,2,3]
In [410]: tuple(a)
Out[410]: (1, 2, 3)

In [411]: t = tuple(range(1,10,2))
In [412]: t
Out[412]: (1, 3, 5, 7, 9)

type(object)

• 查看对象的类型

In [413]: type([1,2,3])
Out[413]: list

In [414]: type((1,2,3))
Out[414]: tuple

In [415]: type({1,2,3})
Out[415]: set

In [416]: type({'a':1,'b':2})
Out[416]: dict

zip(*iterables)

• 创建一个迭代器，聚合每个可迭代对象的元素的元祖。

• 参数前带 *，意味着是可变序列参数，可传入 1 个，2 个或多个参数。

a = [1,2,3]
for i in zip(a):
    print(i)
"""
    (1,)
    (2,)
    (3,)
"""
b = ['a','b','c']
for m,n in zip(a,b):
    print(m,n)
"""
    1 a
    2 b
    3 c
"""

dir([object])

• 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时返回参数的属性、方法列表

In [417]: lst = [1,2,3]
In [418]: dir(lst)
Out[418]: 
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

isinstance(object, classinfo)

• 判断 object 是否为类 classinfo 的实例，若是，返回 true

class Node():
    def __init__(self,value):
        self.value = value
node = Node('node')
isinstance(node,Node)
# 输出 True

map(func, *iterables)

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

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

# 计算平方
def square(x) :            
    return x ** 2
 
In [426]: list(map(square, [1,2,3,4,5])) # 计算列表各个元素的平方
Out[426]: [1, 4, 9, 16, 25]

In [427]: list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # 使用 lambda 匿名函数
Out[427]: [1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
In [428]: list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
Out[428]: [3, 7, 11, 15, 19]

reversed(sequence, /)

• 逆置序列，返回一个迭代器

In [421]: ''.join(reversed('123'))
Out[421]: '321'
In [422]: list(reversed([1,2,3]))
Out[422]: [3, 2, 1]