python基础之常用内置函数

前言

python有许多内置的函数，它们定义在python的builtins模块，在python的代码中可以直接使用它们。

常用的内置函数

类型转换

• int

python的整数类型都是int类型的实例，但int类也可以被调用，将参数转换成int类型。

class Dog(object):
    def __int__(self):
        return 100

if __name__ == "__main__":
    dog = Dog()
    print(int(dog)) # 100

# int方法调用了参数的__int__魔法方法。

• str:调用参数的__str__方法获取返回值；

• float：调用参数的__float__方法获取返回值；

• complex:调用参数的__complex__方法获取返回值；

class Dog(object):
    def __float__(self):
        return 3.6

    def __complex__(self):
        return (3-4j)

    def __str__(self):
        return 'str'

if __name__ == "__main__":
    dog = Dog()
    print(str(dog)) # str
    print(float(dog)) # 3.6
    print(complex(dog)) # (3-4j)

• dict:将一个对象转化成字典；

• list:将一个对象转化成列表；

• tuple:将一个对象转化成元组；

• slice:创建一个切片对象，list和tuple类型可用；

my = [i for i in range(10)]
print(my[slice(0,3,2)]) # 无论索引、切片操作都调用了可迭代对象的__getitem__方法。

算术计算

abs():求参数的绝对值，只支持一个参数，会调用参数的__abs__魔法方法；只支持int和float类型
bin(*args, **kwargs):返回整数的二进制表示形式，只支持一个参数，调用参数的__bin__方法，只支持int类型
divmod(x, y):求x//y和x%y的值，即商和余数的元组，调用__divmod__方法，只支持int和float类型
hash():获取一个对象的散列值，相等的两个数哈希值相等，反过来不一定成立
hex(*args, **kwargs)：求整数的十六进制表示形式，调用__hex__方法，只支持Int类型
oct(*args, **kwargs)：求整数的八进制表示形式，调用__oct__方法，只支持Int类型
pow(*args, **kwargs):求幂，如pow(3,4)表示3的4字方，pow(3,4,5)表示3**4%5，调用__pow__方法，只支持int和float类型
sum(*args, **kwargs)：求和，只支持由int类型和float类型构成的可迭代对象，调用__sum__方法，支持所有的可迭代类型

• round():对于一个数四舍五入计算,第二参数可以指定精度

print(round(3.5)) # 4
print(round(4.77,1)) # 4.8

迭代运算

• all:对可迭代对象的每个元素进行布尔判断，所有为真返回真，存在假则返回假

print(all((1,'df',[1,2],1.2))) # 结果：True
print(all((None,{1,2}))) # 结果：False

• any:对可迭代对象的每个元素进行布尔判断，所有为假返回假，存在真则返回真

print(any((1,'df',[1,2],''))) # 结果：True
print(any((None,[]))) # 结果：False

• max和min:计算容器或多个值的最大值与最小值，可以通过key参数指定比较的规则，默认是算术大小比较。

print(max([1,2,3,4,5])) # 5
print(max('name','jj','age',key=lambda x:len(x))) # 'name'

• sorted：对任何的可迭代对象进行排序，通过key指定排序规则， reverse指定方向；返回的结果是一个新的对象

print(sorted(['name','age','hight'], key=lambda x:len(x), reverse=False))
print(sorted([4,3,6,8]))

编码运算

• ascii:返回一个对象的ascii编码，windows系统对象默认的编码是ascii，支持大部分类型

print(ascii('我')) # '\u6211'
print(ascii('x')) # 'x'
print(ascii('100')) # '100'
print(ascii(100)) # 100
print(ascii(10000000000000000)) # 10000000000000000

• chr:返回一个整数序号在ascii表中代表的单字符,只支持整数

print(chr(97)) # a
print(chr(4)) # ? 不识别，没有对应的字符

• ord:返回一个单字符代表的Unicode编码。

• compile：将字符串编译为字节代码，方便exec或eval去执行。

语法：compile(source, filename, mode[, flags[, dont_inherit]])
# 参数：
source -- 字符串
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

x = compile('print("hello world")', '', 'exec')
exec(x) # hello world

• eval:用来执行一个字符串表达式，并返回表达式的值。

参数：
expression：表达式字符串
globals：变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals：变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

for example：
x = 3
def test():
    x = 1
    res = eval("x ** 3", globals(), locals())
    print(res)
    return res

if __name__ == "__main__":
    test() # 如果参数只有globals()，值为27，如果提供了locals()，命名空间为本函数，值为1

• exec:执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码,返回的永远是None。

# 参数：
expression：表达式字符串
globals：变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals：变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

for example:

exec("def foo(): print('hello world')")
exec("foo()")

进程结束

• exit()和quit():用来退出进程，抛出SystemExit异常，解释器会捕获该异常退出程序。

try:
    exit(0)
except SystemExit as e:
    print(e) # 0
    print('jjjj')

# SystemExit会搜集到错误的code，0表示正常退出，1表示异常退出

输入输出

• input:该方法会打开一个交互式的窗口，阻塞等待用户的输入；

• print():这个算是python最常用的方法之一了，在命令窗打印内容，会调用参数的__str__方法,如果该方法不存在则调用__repr__方法，并将返回的值交给file参数。

参数：
values:需要输出的值
sep：设置间隔符，默认为空
end:添加的结束符
file:一个文件对象

for example:
print('name','xx',file=open('./test.txt','w'))

命名空间

• globals():获取所在模块的全局命名空间，即所有的方法、类、变量等名字和对象键值对构成的字典，包括导入的对象；

• locals():获取局部的命名空间，即本类或本函数的的属性、方法等构成的字典；

• vars(p_object):无参数返回locals()，有参数返回参数的__dict___

判断

• callable：判断参数是否支持调用，返回布尔值，本质是判断参数对象存在__call__方法，只支持一个参数

• delattr(x, y):将x对象的y属性删除，如果没有这个属性会报错，所以一般先要判断一下，调用了x的__delattr__方法

class A(object):
    age = 20
    def __init__(self):
        self.name = 'cai'
if __name__ == "__main__":
    a = A()
    delattr(a, 'name') # 实例只能删除实例属性
    delattr(A,'age') # 类只能删除类属性

• hasattr(x,y):判断x对象是否存在y属性

class A(object):
    age = 20
    def __init__(self):
        self.name = 'cai'
if __name__ == "__main__":
    a = A()
    print(hasattr(A,'age')) # True
    print(hasattr(A,'name')) # false
    print(hasattr(a,'age')) # True，实例拥有类的属性
    print(hasattr(a,'name')) # True

• getattr(x,y):获取x对象的y属性，如果没有报错，所以需要判断，实例可以获取类的属性,调用了x对象的__getattribute__方法。

class A(object):
    age = 20
    def __init__(self):
        self.name = 'cai'
if __name__ == "__main__":
    a = A()
    print(getattr(A,'age'))  # 20
    print(getattr(a,'age')) # 20
    print(getattr(a,'name')) # 'cai'
    print(getattr(a,"hight")) # 报错

• setattr(x, y, v):设置x对象的y属性的值是v，如果存在则修改，不存在则创建，调用x对象的__setattr__方法

class A(object):
    age = 20
    def __init__(self):
        self.name = 'cai'

if __name__ == "__main__":
    a = A()
    print(getattr(A,'age'))  # 20
    setattr(A,'age',30) # 修改类属性
    print(getattr(A, 'age')) # 30
    print(getattr(a, 'age')) # 30,如果实例没有盖属性会去寻找类有没有这个属性
    setattr(a, 'age', 40) # 设置实例属性
    print(getattr(A, 'age')) # 30
    print(getattr(a, 'age')) # 40

• isinstance和issubclass:判断一个对象的类型和一个对象是否是另一个对象子类

class A(object):
    age = 20
    def __init__(self):
        self.name = 'cai'

class B(object):
    pass

if __name__ == "__main__":
    a = A()
    print(isinstance(a,A)) # True
    print(isinstance(a,(A,B))) # True 只要有一个符合就返回True
    # 同理issubclass的使用和isinstance一样

其他

• repr():函数将对象转化为供解释器读取的形式。

• iter():获取一个可迭代对象的迭代器，调用参数的__iter__方法；

• next():获取一个迭代器的元素值，调用可迭代对象的__next__方法。

• len():计算一个容器中的项数，会调用参数的__len__方法

• dir:

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法_dir_()，该方法将被调用。如果参数不包含|_dir_()，该方法将最大限度地收集参数信息。

class A(object):
    age = 20
    def __init__(self):
        self.name = 'cai'

if __name__ == "__main__":
    a = A()
    print(dir(a)) # 对实例对象返回[]
    print(dir(A)) # 参数需要是对象、变量、类型。

dir()和__dict__返回的数据的区别在于__dir__获取对象的所有属性、方法的名字组成列表，包括继承父类的；__dict__记录当前类定义的所有的属性、方法的名字与具体对象组成的键值对。

• id:获取一个对象在内存空间中的地址；

总结

• 可以看到很多内置函数的源码都是pass，这是因为源码展示给我们的只有名字而已，方便我们调用，它们的具体实现算法被隐藏;

• 有些方法的算法直接内置在解释器中，可以直接调用；有些会去调用方法的参数相对应的魔法方法，大部分魔法方法的实现算法也内置在了解释器中；

• 内置函数都是作为全局函数来使用的，不需要导入即可直接使用，也就是说解释器启动是就加载了内置函数的上下文；

参考

• https://docs.python.org/3/