python基础三：python常用的内置函数小总

最新推荐文章于 2024-09-15 22:31:42 发布

翻滚的小@强

最新推荐文章于 2024-09-15 22:31:42 发布

阅读量474

点赞数 2

分类专栏： # python学习笔记文章标签： python python内置函数

本文链接：https://blog.csdn.net/wuzhongqiang/article/details/106598597

版权

python学习笔记专栏收录该内容

17 篇文章 1 订阅

订阅专栏

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个内置函数

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

len(s): 这个函数应该不陌生吧，求列表的长度或者元素个数的时候可是非常常用的。
```
"""len(s) 返回对象内元素个数"""
dic = {'a':1, 'b': 3}
len(dic)     # 2
```

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 函数。"""

pow(x, y, z=None, /): pow函数求x为底的y次幂，如果z给出，取余，所以python本身就有求幂运算的函数。
```
pow(3, 2, 4)   # 3^2%4=1
```
round(number[, ndigits])：四舍五入， ndigits代表小数点后保留几位
```
round(10.022222, 3)  # 10.022
```
sum(iterable, /, start=0): 求和， /表示前面必须是位置参数，不能是关键字参数， start是求和的初始值
```
a = [1, 4, 2]
sum(a)     # 7
sum(a, 1)  # 8
```
abs(x, /): 绝对值或者复数的模
```
abs(-6)  # 6
```
divmod(a, b): 取商和余数
```
divmod(10, 3)   # (3, 1)
```
complex([real[,imag]]): 创建一个复数，这个可能不常用。
```
complex(1, 2)     # (1+2j)
```

hash(object): 返回对象的哈希值

a = "akjfiajd"
hash(a)         # 不可变对象才可哈希  1641179426338835449

id(object): 返回对象的内存地址，这个一般会用到判断是否两个对象的地址是否相同（是产生了新对象还是原对象的新引用）
```
id(a)   # 1526937895152
```

3. 逻辑运算的两个内置

all(iterable): 接受一个可迭代对象，如果迭代器的所有元素都为真，返回 True，否则返回 False：
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进制

bin(num): 十进制转二进制
oct(num): 十进制转八进制

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. 涉及类的内置函数

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   # 报错

getattr(object, name[, default]): 得到对象的某个属性值
```
getattr(xiaoming, 'name')   # 'xiaoming'
```

hasattr(object, name): 判断对象是否有name属性

hasattr(xiaoming, 'id')  # False
hasattr(xiaoming, 'name')  # True

isinstance(object, classinfo): 判断 object 是否为类 classinfo 的实例，若是，返回 true。
```
from collections.abc import Iterable

isinstance([1, 2, 3], Iterable)
```
issubclass(class, classinfo): 如果 class 是 classinfo 类的子类，返回 True：

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)

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方法之后，实例就可以被调用了