Python内置函数大全

朝朝不暮

已于 2023-12-25 17:05:55 修改

阅读量1.1k

点赞数 30

文章标签： python 算法开发语言

于 2023-12-12 13:54:15 首次发布

本文链接：https://blog.csdn.net/MCine4186/article/details/134843486

版权

一.数学运算(7个)

1.abs() 2. divmod() 3.max() 4.min() 5.pow：

6.round：对浮点数进行四舍五入求值

7.sum：对元素类型是数值的可迭代对象中的每个元素求和

二.类型转换(24个)

1.bool： 2.int： 3.float： 4.str：

5.complex：根据传入参数创建一个新的复数

6.bytearray：根据传入的参数创建一个新的字节数组

7.bytes：根据传入的参数创建一个新的不可变字节数组

8.memoryview：根据传入的参数创建一个新的内存查看对象

9.ord：返回Unicode字符对应的整数

10.chr：返回整数所对应的Unicode字符

11.bin：将整数转换成2进制字符串

12.oct：将整数转化成8进制数字符串

13.hex：将整数转换成16进制字符串

14.tuple：根据传入的参数创建一个新的元组

15.list：根据传入的参数创建一个新的列表

16.dict：根据传入的参数创建一个新的字典

17.set：根据传入的参数创建一个新的集合

18.frozenset：根据传入的参数创建一个新的不可变集合

19.enumerate：根据可迭代对象创建枚举对象

20.range：根据传入的参数创建一个新的range对象

21.iter：根据传入的参数创建一个新的可迭代对象

22.slice：根据传入的参数创建一个新的切片对象

23.super：根据传入的参数创建一个新的子类和父类关系的代理对象

24.object：创建一个新的object对象

三.操作序列(9个)

1.all：判断可迭代对象的每个元素是否都为True值

2.any：判断可迭代对象的元素是否有为True值的元素

3.filter：使用指定方法过滤可迭代对象的元素

4.map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

5.next：返回可迭代对象中的下一个元素值

6.reversed：反转序列生成新的可迭代对象

7.sorted：对可迭代对象进行排序，返回一个新的列表

8.zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

9.reduce：

四.对象操作(7个)

1.help:返回对象的帮助信息

2.dir：返回对象或者当前作用域内的属性列表

3.id：返回对象的唯一标识符

4.hash：获取对象的哈希值

5.type：返回对象的类型，或者根据传入的参数创建一个新的类型

6.len：返回对象的长度

7.ascii：返回对象的可打印表字符串表现方式

8.format：格式化显示值

9.vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

五.反射操作(8个)

1.import 动态导入模块

2.isinstance：判断对象是否是类或者类型元组中任意类元素的实例

3.issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类

5.getattr：获取对象的属性值

6.setattr：设置对象的属性值

7.delattr：删除对象的属性

8.callable：检测对象是否可被调用

六.变量操作(2个)

1.globals：返回当前作用域内的全局变量和其值组成的字典

2.locals：返回当前作用域内的局部变量和其值组成的字典

1.open：使用指定的模式和编码打开文件，返回文件读写对象

九.编译执行(4个)

1.compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

2.eval: 执行动态表达式求值

3.exec：执行动态语句块

4.repr：返回一个对象的字符串表现形式(给解释器)

十.装饰器(3个)

1.property：标示属性的装饰器

2.classmethod：标示方法为类方法的装饰器

3.staticmethod：标示方法为静态方法的装饰器

十一.其他

1.lambda的使用

一.数学运算(7个)

1.abs() ---取绝对值

abs(-2)#>>2      类型int
abs(-2.1)#>>2.1  类型float

2. divmod() ---返回两个数值的商和余数(左商右余，返回类型为元组)

divmod(5,2) #>>(2,1) 返回类型元组(tuple)

3.max() ---返回可迭代对象中的元素中的最大值或者所有参数的最大值

max(1,2,3) #>>3
max('1234') #>>4
max(-1,0)   #>>0
max(-1,0,key=abs)#传入绝对值函数,>>-1

4.min() ---返回可迭代对象中的元素中的最小值或者所有参数的最小值

min(1,2,3) #>>1
min('1234')#>>1
min(-1,-2)#>>-2
min(-1,-2,key=abs) #传入绝对值函数,>>-2

5.pow：返回两个数值的幂运算值或其与指定整数的模值

pow(2,3) #>>2**3=8

6.round：对浮点数进行四舍五入求值

round(3.1415926,1)#>>3.1
round(3.1415926,4)#>>3.1416

7.sum：对元素类型是数值的可迭代对象中的每个元素求和

a=sum((1,2,3,4))
b=sum([1,2,3,4])
print(a)
print(b)#>>10

二.类型转换(24个)

1.bool：根据传入的参数的逻辑值创建一个新的布尔值

bool()#未传入参数
#>>False
bool(0)#0、空序列等为False
#>>False
bool(1)
#>>True

2.int：根据传入的参数创建一个新的整数

int()#不传入时为0
#>>0
int('123')
#>>123

3.float：根据传入的参数创建一个新的浮点数

float()
#>>0.0
float(3)
#>>3.0
float('3')
#>>3.0

4.str：返回一个对象的字符串表现形式(给用户)

str()#>>''
str(None)#>>'None'
str(123)#>>'123'

5.complex：根据传入参数创建一个新的复数

complex()#什么都不传入时,返回复数0j
#>>0j
complex('1+2j') #传入字符串创建复数
#>>1+2j
complex(1,2)#实部，虚部
#>>1+2j

6.bytearray：根据传入的参数创建一个新的字节数组

bytearray('中文','utf-8')

7.bytes：根据传入的参数创建一个新的不可变字节数组

bytes('中文','utf-8')

8.memoryview：根据传入的参数创建一个新的内存查看对象

v = memoryview(b'abcefg')

9.ord：返回Unicode字符对应的整数

ord(a)
#>>97

10.chr：返回整数所对应的Unicode字符

chr(97)#参数类型为整数
#>>a

11.bin：将整数转换成2进制字符串

bin(6)
#>>0b110

12.oct：将整数转化成8进制数字符串

oct(10)
#>>0o12

13.hex：将整数转换成16进制字符串

hex(15)
#>>0xf

14.tuple：根据传入的参数创建一个新的元组

tuple() #不传入参数，创建空元组
#>>()
tuple('121') #传入可迭代对象。使用其元素创建新的元组
#>>('1', '2', '1')

a,*ids=map(int,input().split(' '))
print(tuple(ids))
#1 2 3 4 5  >>(2,3,4,5)

15.list：根据传入的参数创建一个新的列表

list()#不传入参数创建空列表
#>>[]
list('abcd')
#>>['a','b','c','d']

16.dict：根据传入的参数创建一个新的字典

dict()#不传入参数创建空字典
#>>{}
dict(a=1,b=2)
#>>{'a': 1, 'b': 2}
dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典
#>>{'a': 1, 'b': 2}
dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典
#>>{'a': 1, 'b': 2}

17.set：根据传入的参数创建一个新的集合

set() # 不传入参数，创建空集合
#>>set()
set(range(10)) # 传入可迭代对象，创建集合
#>>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}       -----<class 'set'>

18.frozenset：根据传入的参数创建一个新的不可变集合

frozenset(range(10))
#>>{0,1,2,3,4,5,6,7,8,9}

19.enumerate：根据可迭代对象创建枚举对象

enumerate(iterable, start=0)
iterable->一个可遍历的数据对象实例
start->索引对象实例的起始索引值

seasons = ['Spring', 'Summer', 'Autumn', 'Winter']
a=list(enumerate(seasons))
print(a)#>>[(0, 'Spring'), (1, 'Summer'), (2, 'Autumn'), (3, 'Winter')]
b=list(enumerate(seasons,start=1))#指定起始值
print(b)#>>[(1, 'Spring'), (2, 'Summer'), (3, 'Autumn'), (4, 'Winter')]


#顺序查找
def linear_search(li,val):
    for ind,v in enumerate(li):  #enumerate会给可迭代对象对应一个索引
        if v==val:
            return ind
        else:
            return

20.range：根据传入的参数创建一个新的range对象

a=range(10)
b=range(1,10)
c=range(1,10,3)                  #range()左闭右开 [1,10) ，第三个参数为步长
print(a)#>>range(0, 10)
print(b)#>>range(1, 10)
print(c)#>>range(1, 10, 3)       -----<class 'range'>
print(list(c))#>>[1, 4, 7]

21.iter：根据传入的参数创建一个新的可迭代对象

a = iter('abcd') #字符串序列
print(a)    #>><str_iterator object at 0x00000247DEDF08B0>
for _ in range(4):
    print(next(a))
    #>>a
    #>>b
    #>>c
    #>>d

22.slice：根据传入的参数创建一个新的切片对象

c1 = slice(5)
print(c1)          #>>slice(None, 5, None)
c2 = slice(2,5)
print(c2)          #>>slice(2, 5, None)
c3 = slice(1,10,3)
print(c3)          #>>slice(1, 10, 3)

23.super：根据传入的参数创建一个新的子类和父类关系的代理对象

class A:
    def __init__(self):
        print("Enter A")
        print("Leave A")

class B(A):
    def __init__(self):
        print("Enter B")
        super(B, self).__init__()
        print("Leave B")

class C(A):
    def __init__(self):
        print("Enter C")
        super(C, self).__init__()
        print("Leave C")

class D(A):
    def __init__(self):
        print("Enter D")
        super(D, self).__init__()
        print("Leave D")

class E(B, C, D):
    def __init__(self):
        print("Enter E")
        super(E, self).__init__()
        print("Leave E")

E()

运行结果:

#(E, (B, C, D), A, A, (D, C, B), E)


Enter E
Enter B
Enter C
Enter D
Enter A
Leave A
Leave D
Leave C
Leave B
Leave E

24.object：创建一个新的object对象

a=object()
print(a)    #>>   <object object at 0x000001BB70A67820>

a.name='John'#不能设置属性

三.操作序列(9个)

1.all：判断可迭代对象的每个元素是否都为True值

all([1,2])#列表中每个元素逻辑值均为True，返回True    ----<class 'bool'>
all([0,1,2])    #列表中0的逻辑值为False，返回False
all([])   #空列表
#>> True
all(())   #空元组
#>> True
all({})   #空字典
#>> True

2.any：判断可迭代对象的元素是否有为True值的元素

any([0,1,2])   #列表有一个Ture，返回True
any([0,0])     #False
any([])        #空列表、空元组、空字典  >>False

3.filter：使用指定方法过滤可迭代对象的元素

def ji(x):
    if x%2=1:
        return True    #为真值即可
print(list(filter(ji,range(10))))
#>> [1, 3, 5, 7, 9]

'''
filter() 函数把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False，来决定保留或丢弃该元素。

参数说明：

(1) function：用于实现判断的函数，可以为 None。
(2) iterable：可迭代对象，如列表、range 对象等。
(3) 返回值：返回一个迭代器对象。
'''

4.map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

def square(x):
    return x*x
map(square,[1,2,3,4])  #>> [1,4,9,16]
map(str,[1,2,3,4])     #>> ['1','2','3','4']

5.next：返回可迭代对象中的下一个元素值

a = iter('abcd')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)

6.reversed：反转序列生成新的可迭代对象

a=reversed(range(10))
list(a)  #>>[9,8,7,6,5,4,3,2,1,0]

7.sorted：对可迭代对象进行排序，返回一个新的列表

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

iterable：待排序的序列
key：排序规则
reverse：指定排序的方式，默认值False，即升序排列

a = ['a','b','d','c','B','A']
sorted(a)   #>>['A', 'B', 'a', 'b', 'c', 'd']   #默认按字符ASCII码排序
sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
#>> ['a', 'A', 'b', 'B', 'c', 'd']
a=[1,4,2,9,3,7,6]
sorted(a,key=None,reverse=False)    #>>[1, 2, 3, 4, 6, 7, 9]  
sorted(a,key=None,reverse=True)     #>>[9, 7, 6, 4, 3, 2, 1]

8.zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

x = [1,2,3] #长度3
y = [4,5,6,7,8] #长度5
list(zip(x,y)) # 取最小长度3
#>> [(1, 4), (2, 5), (3, 6)]

9.reduce：先将 sequence 的前两个 item 传给 function，即 function(item1, item2)，函数的返回值和 sequence 的下一个 item 再传给 function，即 function(function(item1, item2), item3)，如此迭代，直到 sequence 没有元素，如果有 initial，则作为初始值调用。

reduce(lambda x, y: x * y, [1, 2, 3, 4])  # 相当于 ((1 * 2) * 3) * 4
#>>24

四.对象操作(7个)

1.help:返回对象的帮助信息

help(str) #自行尝试

2.dir：返回对象或者当前作用域内的属性列表

import math
dir(math)

3.id：返回对象的唯一标识符

a='Hello World!'
id(a)    #>> 1931871364208

4.hash：获取对象的哈希值

hash('Hello World')
#>>688806338109182509

5.type：返回对象的类型，或者根据传入的参数创建一个新的类型

type(1)   #>>   <class 'int'>
#使用type函数创建类型D，含有属性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
d=D()
d.InfoD
#>> 'some thing defined in D'

6.len：返回对象的长度

len('abcd')#>>4
len([1,2,3,4]) #>>4
#字符串，字节数组，元组，列表，range对象，字典，集合，不可变集合 均可

7.ascii：返回对象的可打印表字符串表现方式

ascii(1)   #>>'1'
ascii('a')   #>>"'a'"
ascii('中文')  #>>'\u4e2d\u6587'  非ascii字符

8.format：格式化显示值

#字符串可以提供的参数 's' None
format('some string','s')
#>> 'some string'
format('some string')
#>> 'some string'
#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
format(3,'b') #转换成二进制
#>>'11'
format(97,'c') #转换unicode成字符
#>>'a'
format(11,'d') #转换成10进制
#>>'11'
format(11,'o') #转换成8进制
#>>'13'
format(11,'x') #转换成16进制 小写字母表示
#>>'b'
format(11,'X') #转换成16进制 大写字母表示
#>>'B'
format(11,'n') #和d一样
#>>'11'
format(11) #默认和d一样
#>>'11'
#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
format(314159267,'e') #科学计数法，默认保留6位小数
#>> '3.141593e+08'
format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
#>> '3.14E+08'
format(314159267,'f') #小数点计数法，默认保留6位小数
#>> '314159267.000000'
format(3.14159267000,'f') #小数点计数法，默认保留6位小数
#>> '3.141593'
format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
#>> '3.14159267'
format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
#>> '3.1415926700'
format(3.14e+1000000,'F')  #小数点计数法，无穷大转换成大小字母
#>> 'INF'
#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
#>> '3e-05'
format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
#>> '3.1e-05'
format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
#>> '3.14e-05'
format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
#>> '3.14E-05'
format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
#>> '3'
format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
#>> '3'
format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
#>> '3.14'
format(0.00003141566,'.1n') #和g相同
#>> '3e-05'
format(0.00003141566,'.3n') #和g相同
#>> '3.14e-05'
format(0.00003141566) #和g相同
#>> '3.141566e-05'

9.vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

class a(object):
    pass
a.name='kim'
vars(a)
print(a.__dict__)
#>> {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'a' objects>, '__weakref__': <attribute '__weakref__' of 'a' objects>, '__doc__': None, 'name': 'kim'}

五.反射操作(8个)

1.import 动态导入模块

import math
#import 库函数/同列表py文件

2.isinstance：判断对象是否是类或者类型元组中任意类元素的实例

isinstance(1,int)
#>> True
isinstance(1,str)
#>> Fasle
isinstance(1,(int,str))
#>> True

3.issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类

issubclass(bool,int)
#>> True
issubclass(bool,str)
#>> False
issubclass(bool,(str,int))
#>> True

4.hasattr：检查对象是否含有属性

#定义类A
class Student:
    def __init__(self,name):
        self.name = name

        
s = Student('Aim')
hasattr(s,'name') #a含有name属性
#>> True
hasattr(s,'age') #a不含有age属性
#>> False

5.getattr：获取对象的属性值

#定义类Student
class Student:
    def __init__(self,name):
        self.name = name

getattr(s,'name') #存在属性name
#>> 'John'

6.setattr：设置对象的属性值

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

        
a = Student('John')
print(a.name)
#>> 'John'

7.delattr：删除对象的属性

class Student:
    def __init__(self,name):
        self.name = name
a= Student('John')
delattr(a,'name')

8.callable：检测对象是否可被调用

class B: #定义类B
    def __init__(self):
        print('B.call is True')
print(callable(B))
B()
#>> True
#>> B.call is True

六.变量操作(2个)

1.globals：返回当前作用域内的全局变量和其值组成的字典

>>> globals()
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
>>> a = 1
>>> globals() #多了一个a
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}

2.locals：返回当前作用域内的局部变量和其值组成的字典

def awa():
    print('is a')
    print(locals())
    a=1
    print(locals())
awa()
'''
is a
{}
{'a': 1}
'''

七.交互操作(2个)

1.print: 向标准输出对象打印输出

print('Hello World')

2.input: 读取用户输入值

age=int(input('请问您多大了：'))
a,b=map(int,input().split(' '))

八.文件操作(1个)

1.open：使用指定的模式和编码打开文件，返回文件读写对象

a=open('text.text','rt')    #rt 即write
a.read()    #读写操作

一般文件操作不会使用内置函数，建议调用os库或者是pathlib库

九.编译执行(4个)

1.compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)

2.eval: 执行动态表达式求值

eval('1+2+3+4')
#>> 10

3.exec：执行动态语句块

exec('a=1+2') #执行语句
print(a)
#>> 3

4.repr：返回一个对象的字符串表现形式(给解释器)

a='Hello World'
print(repr(a))
#>> 'Hello World'

十.装饰器(3个)

1.property：标示属性的装饰器

class C:
    def __init__(self):
        self._name = ''
    @property
    def name(self):
        """i'm the 'name' property."""
        return self._name
    @name.setter
    def name(self,value):
        if value is None:
            raise RuntimeError('name can not be None')
        else:
            self._name = value

2.classmethod：标示方法为类方法的装饰器

class C:
    @classmethod
    def f(cls,arg1):
        print(cls)
        print(arg1)
C.f('e')
#>> <class '__main__.C'>
#>> e

3.staticmethod：标示方法为静态方法的装饰器

class Student(object):
    def __init__(self,name):
        self.name = name
    @staticmethod

十一.其他

1.lambda的使用

万能之王 Lambda 函数:

lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数的方法。lambda 函数实际生成了一个函数对象。
lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。

lambda arg1,arg2,arg3… : <表达式> arg1/arg2/arg3
为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。

Lambda函数只在一行中编写和创建，而在普通函数的中使用缩进
一般情况下，我们不使用Lambda函数，而是将其与高阶函数一起使用。高阶函数是一种需要多个函数来完成任务的函数，或者当一个函数返回任何另一个函数时，可以选择使用Lambda函数。

f = lambda a,b,c:a+b+c
print(f(2,3,4))
g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))

部分Python内置函数接受函数作为参数,典型的此类内置函数有这些:

filter函数
此时lambda函数用于指定过滤列表元素的条件。例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是[3]。
sorted函数
此时lambda函数用于指定对列表中所有元素进行排序的准则。例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。
map函数
此时lambda函数用于指定对列表中每一个元素的共同操作。例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1，其结果[2, 3, 4]。
reduce函数
此时lambda函数用于指定列表中两两相邻元素的结合条件。例如reduce(lambda a, b: ‘{}, {}’.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来，其结果是’1, 2, 3, 4, 5, 6, 7, 8, 9’