1. 写在前面

这篇文章整理一下python常用的内置函数， 所谓python的内置函数，就是不用import就可以直接使用， 并且用起来也非常方便， 所以在这里集中总结一下。

由于这些内置函数非常简单， 所以这里不会详细介绍原理， 依然是从使用的角度出发， 给出使用案例， 首先， 先列出来目前我遇到过的内置函数：

  • 数学运算的10个： len(), max(), pow(), round(), sum(), abs(), divmod(), complex(), hash(), id()
  • 逻辑运算的2个： all(), any()
  • 进制转化的3个： bin(), oct(), hex()
  • 类型函数：bool(), bytes(), str(), chr(), odr(), dict(), object(), int(), float(), frozenset(), list(), range(), set(), slict(), tuple(), type(), zip()
  • 与类对象相关：delattr(), getattr(), hasattr(), dir(), isinstance(), issubclass(), super(), callable()

这些函数是python内置的， 直接用即可， 非常方便。 下面给出一些例子：

2. 数学运算的10个内置函数

我们先从数学运算的这几个开始：

  1. len(s): 这个函数应该不陌生吧， 求列表的长度或者元素个数的时候可是非常常用的。
"""len(s) 返回对象内元素个数"""
dic = {'a':1, 'b': 3}
len(dic)     # 2
  1. max(iterable, * [, key, default])： 返回最大值, * 表示命名关键字参数， 简单的讲，就是* 后面如果要写参数， 必须是关键字参数，也就是key=value的形式。 之前整理的默认参数， 可变参数， 关键字参数， 命名关键字参数的知识在这里就用上了。 这个函数也非常常用， 比如返回列表中的最大值或者字典中的最小值。 有max也就有min, 这两个用法一样。
max(3, 1, 4, 2, 1)    # 4
max({'a': 3, 'b1': 1, 'c': 4})      #  'c'  默认是字典键最大， 如果要值最大， 传key

a = [{'name':'xiaoming','age':18,'gender':'male'},{'name':'xiaohong', 'age':20, 'gender': 'female'}]
max(a, key=lambda x:x['age'])  #{'name': 'xiaohong', 'age': 20, 'gender': 'female'}

"""max、min 函数都有一个参数 key，它们也被称为 key 函数，key 函数一般结合更紧凑的 lambda 函数。"""
  1. pow(x, y, z=None, /): pow函数求x为底的y次幂， 如果z给出， 取余， 所以python本身就有求幂运算的函数。
pow(3, 2, 4)   # 3^2%4=1
  1. round(number[, ndigits])： 四舍五入， ndigits代表小数点后保留几位
round(10.022222, 3)  # 10.022
  1. sum(iterable, /, start=0): 求和， /表示前面必须是位置参数， 不能是关键字参数， start是求和的初始值
a = [1, 4, 2]
sum(a)     # 7
sum(a, 1)  # 8
  1. abs(x, /): 绝对值或者复数的模
abs(-6)  # 6
  1. divmod(a, b): 取商和余数
divmod(10, 3)   # (3, 1)
  1. complex([real[,imag]]): 创建一个复数， 这个可能不常用。
complex(1, 2)     # (1+2j)
  1. hash(object): 返回对象的哈希值
a = "akjfiajd"
hash(a)         # 不可变对象才可哈希  1641179426338835449
  1. id(object): 返回对象的内存地址， 这个一般会用到判断是否两个对象的地址是否相同（是产生了新对象还是原对象的新引用）
id(a)   # 1526937895152

3. 逻辑运算的两个内置

  1. all(iterable): 接受一个可迭代对象，如果迭代器的所有元素都为真，返回 True，否则返回 False：
  2. any(iterable): 接受一个可迭代对象，如果迭代器里有一个元素为真，返回 True，否则返回 False：
all([1, 0, 3, 6])  # False
all([1, 2, 3])  # True

any([0, 0, 1])  # True
any([0, 0, []]) # False

4. 进制转化的3个内置函数

十进制转二进制， 八进制和16进制

  1. bin(num): 十进制转二进制
  2. oct(num): 十进制转八进制
  3. hex(num): 十进制转十六进制
bin(10)    # '0b1010'
oct(10)    # '0o12'
hex(15)   # '0xf'

5. 类型相关的内置函数

# bool([x])  测试一个对象是True还是False
bool([0, 0, 0])  # True
bool([])    # False

# bytes([source[, encoding[, errors]]])　　 将一个字符串转换成字节类型
s = 'apple'
bytes(s, encoding='utf-8')   # b'apple'

# str(object='')   将字符类型、数值类型等转换为字符串类型
i = 100
str(i)      # '100'

# chr(i)  查看十进制整数对应的 ASCII 字符
chr(65)  # 'A'

# ord(c)  查看某个 ASCII 字符对应的十进制数
ord('A')    # 65

# dict()   创建数据字典
# int()  x 可能为字符串或数值，将 x 转换为一个整数。
# float()  将一个字符串或整数转换为浮点数：


# set()  返回一个集合对象，并允许创建后再增加、删除元素。集合的一大优点，容器里不允许有重复元素，因此可对列表内的元素去重。
# frozenset([iterable])　　 创建一个不可修改的冻结集合，一旦创建不允许增删元素。
# tuple([iterable])   创建一个不可修改的元组对象：
# list()  返回可变序列类型   list 函数还常用在，可迭代类型（Iterable）转化为列表。
m = map(lambda i: str(i), [1, 2, 3])
l = list(m)    # 转一下才能看到
l        # ['1', '2', '3']

# type(object)   查看对象的类型  type 函数是非常实用的，阅读他人代码时，若函数参数类型没有显示给出，就会用到 type 函数。
# zip(*iterables)  创建一个迭代器，聚合每个可迭代对象的元素。参数前带 *，意味着是可变序列参数，可传入 1 个，2 个或多个参数。

6. 涉及类的内置函数

  1. delattr(object, name): 删除对象的属性，在不需要某个或某些属性时，这个方法就会很有用。
class Student():
    def __init__(self, id=None, name=None):
        self.id = id
        self.name = name

xiaoming = Student(1, 'xiaoming')
xiaoming.id           # 1

delattr(xiaoming, 'id')
xiaoming.id   # 报错
  1. getattr(object, name[, default]): 得到对象的某个属性值
getattr(xiaoming, 'name')   # 'xiaoming'
  1. hasattr(object, name): 判断对象是否有name属性
hasattr(xiaoming, 'id')  # False
hasattr(xiaoming, 'name')  # True
  1. isinstance(object, classinfo): 判断 object 是否为类 classinfo 的实例，若是，返回 true。
from collections.abc import Iterable

isinstance([1, 2, 3], Iterable)
  1. issubclass(class, classinfo): 如果 class 是 classinfo 类的子类，返回 True：
  2. super([type[, object-or-type]]): 返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。
class Parent():
    def __init__(self, x):
        self.v = x
    
    def add(self, x):
        return self.v + x

class Son(Parent):
    def add(self, y):
        r = super().add(y)   # #直接调用父类的add方法
        print(r)      #子类的add与父类相比，能实现对结果的打印功能

Son(1).add(2)
  1. callable(object): 判断对象是否可被调用，能被调用的对象就是一个 callable 对象，比如函数 str、int 等都是可被调用的。
callable(str) # True
callable('skfajf')  # False   实例不可被调用

如果类的实例， 那么肯定是不能被调用的， 但是如果想让实例被调用， 必须重写Student类上的__call__方法。 就是想整理这个例子， 因为在神经网络自定义层的时候， 往往就有一个这样的方法：

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

xiaoming = Student('001', 'xiaoming')

callable(xiaoming)     # False

上面的xiaoming是不能被调用的， 因为这是个实例对象。 而我们如果重写Student类上的__call__方法之后：

# 如果想xiaoming可以被调用， 必须要重写 Student 类上 __call__ 方法：
class Student():
    def __init__(self, id=None, name=None):
        self.id = id
        self.name = name
    
    def __call__(self):
        print('重写call方法之后，实例就可以被调用了')


xiaohua = Student('001', 'xiaohua')
callable(xiaohua) # True
xiaohua()   # 重写call方法之后，实例就可以被调用了

会发现这个实例对象竟然可以被调用了， 并且调用的时候自动调用Student类的__call__函数。 这个在自定义一些网络层或者神经网络的代码调试那里会经常遇到这种写法。

关于内置函数， 就先整理到这里， 这次的内置函数比较多， 不用刻意记住， 经常使用， 内化于心， 时间久了， 或许会产生很大的功效 😉。