内置函数总结

 

一、基础数据类型相关（38）

　　一、和数字相关（14）

　　　　1、数据类型（4）　　　　　

　　　　　　1、bool：布尔值

　　　　　　2、int：整数

　　　　　　3、float：浮点数

　　　　　　4、compiex：复数

　　　　2、进制转换（3）

　　　　　　1、bin：将十进制转换成二进制并返回。

　　　　　　2、oct：将十进制转化成八进制字符串并返回。

　　　　　　3、hex：将十进制转化成十六进制字符串并返回。　　　　

# 将十进制转换成二进制并返回。
print(bin(5))  # 0b101
# 将十进制转化成八进制字符串并返回。
print(oct(9))  # 0o11
# 将十进制转化成十六进制字符串并返回。　　
print(hex(10))  # 0xa

　　　　3、数学运算（7）

　　　　　　1、abs：函数返回数字的绝对值

　　　　　　2、divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

　　　　　　3、round：保留浮点数的小数位数，默认保留整数

　　　　　　4、pow：求x**y次幂。（三个参数x**y的结果对z取余）

　　　　　　5、sum：对可迭代对象进行求和计算（可设置初始值）

　　　　　　6、max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）

　　　　　　7、min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）

# *abs：函数返回数字的绝对值。
print(abs(-20)) # 20
#
# *divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(11,3))  # (3, 2)
#
# round：保留浮点数的小数位数，默认保留整数。
print(round(3.1415))    # 3
print(round(3.1415,3))  # 3.142
#
# pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2,3))     # 8
print(pow(2,3,5))   # 3
#
# ***sum：对可迭代对象进行求和计算（可设置初始值）。
print(sum([1,2,3]))     # 6
print(sum([1,2,3],100))     # 106
#
# ***max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
print(max([1,2,3]))     # 3
#
ret = max([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最大值
print(ret)      # -5
# ***min
ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
print(ret)      # 1

　　二、和数据结构相关（24）

　　　　1、序列（13）

　　　　　　1、列表和元组相关（2）

　　　　　　　　1、list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）

　　　　　　　　2、tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）

# 1、list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）
l = list((1,2,3))
print(l)    # [1,2,3]

l = list({'k1':1,'k2':2})
print(l)    # ['k1','k2']
# 2、tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）
tu = tuple((1,2,3))
print(tu)   # (1,2,3)

tu = tuple({'k1':1,'k2':2})
print(tu)   # ('k1','k2')

　　　　　　2、字符串相关（9）

　　　　　　　　1、str：将数据转化成字符串

　　　　　　　　2、format：与具体数据相关，用于计算各种小数，精算等

　　　　　　　　3、bytes：用于不同编码之间的转化

　　　　　　　　4、bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

　　　　　　　　5、memoryview：函数返回给定参数的内存查看对象

　　　　　　　　6、ord：输入字符找该字符编码的位置

　　　　　　　　7、chr：输入位置数字找出其对应的字符

　　　　　　　　8、ascii：是ascii码中的返回该值，不是就返回/u

　　　　　　　　9、repr：返回一个对象的string形式（原形毕露）

# 1、str：将数据转化成字符串
# 2、format：与具体数据相关，用于计算各种小数，精算等,字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '^20'))    # 列为20，test居中
# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
print(format(3,'b')) # 转换成二进制    11
print(format(97,'c')) # 转换unicode成字符 'a'
print(format(11,'d')) # 转换成10进制 '11'
print(format(11,'o')) #转换成8进制  '13'

print(format(11,'x')) #转换成16进制 小写字母表示   'b'
print(format(11,'X')) #转换成16进制 大写字母表示   'B'
print(format(11,'n')) #和d一样     '11'
print(format(11)) #默认和d一样   # '11'

#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
print(format(314159267,'e')) #科学计数法，默认保留6位小数    '3.141593e+08'
print(format(314159267,'0.2e')) #科学计数法，指定保留2位小数 '3.14e+08'
print(format(314159267,'0.2E'))#科学计数法，指定保留2位小数，采用大写E表示  '3.14E+08'
print(format(314159267,'f')) #小数点计数法，默认保留6位小数   '314159267.000000'
print(format(3.14159267000,'f')) #小数点计数法，默认保留6位小数   '3.141593'
print(format(3.14159267000,'0.8f')) #小数点计数法，指定保留8位小数    '3.14159267'
print(format(3.14159267000,'0.10f')) #小数点计数法，指定保留10位小数  '3.1415926700'
print(format(3.14e+1000000,'F'))  #小数点计数法，无穷大转换成大小字母    'INF'

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
print(format(0.00003141566,'.1g')) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点    '3e-05'
print(format(0.00003141566,'.2g')) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点    '3.1e-05'
print(format(0.00003141566,'.3g'))#p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 '3.14e-05'
print(format(0.00003141566,'.3G')) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写  '3.14E-05'
print(format(3.1415926777,'.1g')) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点   '3'
print(format(3.1415926777,'.2g')) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点   '3.1'
print(format(3.1415926777,'.3g')) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点   '3.14'
print(format(0.00003141566,'.1n')) #和g相同    '3e-05'
print(format(0.00003141566,'.3n')) #和g相同    '3.14e-05'
print(format(0.00003141566)) #和g相同  '3.141566e-05'
# 3、bytes：用于不同编码之间的转化
s = '你好'
bs = s.encode('utf-8')
print(bs)   # b'\xe4\xbd\xa0\xe5\xa5\xbd'
s1 = bs.decode('utf-8')
print(s1)   # 你好
bs = bytes(s,encoding='utf-8')
print(bs)   # b'\xe4\xbd\xa0\xe5\xa5\xbd'
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8'))   # b'\xe4\xbd\xa0\xe5\xa5\xbd'
# 4、bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
ret = bytearray('alex',encoding='utf-8')
print(id(ret))  # 2158681328192
print(ret)  # bytearray(b'alex')
print(ret[0])   # 97
ret[0] = 65
print(ret)  # bytearray(b'Alex')
print(id(ret))  # 2158681328192
# 5、memoryview：函数返回给定参数的内存查看对象
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret)) # 6
print(ret)  # <memory at 0x000001BC12D68A08>
print(bytes(ret[:3]).decode('utf-8'))   # 你
print(bytes(ret[3:]).decode('utf-8'))   # 好
# 6、ord：输入字符找该字符编码的位置
print(ord('a')) # 97
# 7、chr：输入位置数字找出其对应的字符
print(chr(97)) # a
# 8、ascii：是ascii码中的返回该值，不是就返回/u
print(ascii('a'))   # 'a'
print(ascii('中'))   # '\u4e2d'
# 9、repr：返回一个对象的string形式（原形毕露）
print(repr(2+3))    # 5

　　　　　　3、相关内置函数（2）

　　　　　　　　1、reversed：将一个序列翻转，并返回此翻转序列的迭代器

　　　　　　　　2、slice：构造一个切片对象，用于列表的切片

# 1、reversed：将一个序列翻转，并返回此翻转序列的迭代器
ite = reversed(['a',2,3,'c',4,2])
for i in ite:
    print(i)
# 2
# 4
# c
# 3
# 2
# a
# 2、slice：构造一个切片对象，用于列表的切片
li = ['a','b','c','d','e','f','g']
sli_obj = slice(3)
print(li[sli_obj])  # ['a', 'b', 'c']

sli_obj = slice(0,7,2)
print(li[sli_obj])  # ['a', 'c', 'e', 'g']

　　　　2、数据集合（3）

　　　　　　1、dict：创建一个字典

　　　　　　2、set：创建一个集合

　　　　　　3、frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

　　　　3、相关内置函数（8）

　　　　　　1、len：返回一个对象中元素的个数

　　　　　　2、sorted：对所有可迭代的对象进行排序操作

　　　　　　3、enumerate：枚举，返回一个枚举对象

　　　　　　4、all：可迭代对象中，全都是True才是True

　　　　　　5、any：可迭代对象中，有一个True就是True

　　　　　　6、zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

　　　　　　7、filter：过滤

　　　　　　8、map：会根据提供的函数对指定序列做映射

# 1、len：返回一个对象中元素的个数
li = [1,2,3]
print(len(li))  # 3
# 2、sorted：对所有可迭代的对象进行排序操作
L = [('a', 1), ('c', 3), ('d', 4), ('b', 2), ]
sorted(L, key=lambda x: x[1])  # 利用key
print(L)    # [('a', 1), ('c', 3), ('d', 4), ('b', 2)]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
a = sorted(students, key=lambda s: s[2])  # 按年龄排序
print(a)    # [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
b = sorted(students, key=lambda s: s[2], reverse=True)  # 按降序
print(b)    # [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
# 3、enumerate：枚举，返回一个枚举对象
for i,j in enumerate([1,2,3],1):
    print(i,j)
# 1 1
# 2 2
# 3 3
# 4、all：可迭代对象中，全都是True才是True
print(all([1,2,True,0]))    # Faluse
# 5、any：可迭代对象中，有一个True就是True
print(any([1,'',0]))        # True
# 6、zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
    print(i)
# (1, 'a', '*')
# (2, 'b', '**')
# (3, 'c', (1, 2, 3))
# 7、filter：过滤
#filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True
#类似于[i for i in range(10) if i > 3]
def func(x):return x%2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i)
# 2
# 4
# 6
# 8、map：会根据提供的函数对指定序列做映射
a = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
for i in a:print(i) 
# 7
# 11
# 15
# 19

二、作用域相关（2）

　　　　1、locals：函数会以字典的类型返回当前位置的全部局部变量

　　　　2、globals：函数以字典的类型返回全部全局变量

def func(argv):
    c = 2
    print(locals()) # {'c': 2, 'argv': 3}
    print(globals())    # {'__cached__': None, '__doc__': None, '__name__': '__main__', 'func': <function func at 0x000001CBF2AC17B8>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CBF286F470>, '__file__': 'D:/python第11期/分/test/test32.py', '__package__': None}
func(3)

三、迭代器/生成器（3）

　　　　1、range：函数可创建一个整数对象，一般用于for循环中

　　　　2、next：内部实际使用了__next__方法，返回迭代器的下一个项目

　　　　3、iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）

# 1、range：函数可创建一个整数对象，一般用于for循环中
li = []
for i in range(10):
    li.append(i)
print(li)   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 2、next：内部实际使用了__next__方法，返回迭代器的下一个项目
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
li = []
while True:
    try:
        # 获得下一个值:
        x = next(it)
        li.append(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
print(li)   # [1, 2, 3, 4, 5]
# 3、iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）
from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable))  # True
print(isinstance(l,Iterator))  # False
l1 = iter(l)
print(isinstance(l1,Iterable))  # True
print(isinstance(l1,Iterator))  # True

四、反射相关（4）

　　　　1、setattr：设置属性

　　　　2、delattr：删除属性

　　　　3、getattr：获取属性

　　　　4、hasattr：检验是否含有某属性

class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性
print(hasattr(obj,'name'))  # True
print(hasattr(obj,'say_hi'))    # True

#获取属性
n=getattr(obj,'name')
print(n)    # egon
func=getattr(obj,'say_hi')
func()  # hi,egon

print(getattr(obj,'aaaaaaaa','不存在啊')) # 不存在啊

#设置属性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__) # {'show_name': <function <lambda> at 0x000001EADD5E17B8>, 'name': 'egon', 'sb': True, 'age': 73}
print(obj.show_name(obj))   # egonsb

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')
# delattr(obj,'show_name111')#不存在,则报错
print(obj.__dict__) # {'sb': True, 'name': 'egon'}

五、面向对象相关（9）

　　1、type：type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象

　　2、isinstance：isinstance(obj,cls)检查是否obj是否是类 cls 的对象

　　3、issubclass：issubclass(sub, super)检查sub类是否是 super 类的派生类

　　4、classmethod：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

　　5、object：新式类中所有类的父类

　　6、property：@property 能够将一个方法伪装成一个属性

　　7、staticmethod：python staticmethod 返回函数的静态方法

　　8、super：super() 函数是用于调用父类(超类)的一个方法。

　　9、vars：vars() 函数返回对象object的属性和属性值的字典对象。

# 1、type：type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象
# isinstance() 与 type() 区别：
#     type() 不会认为子类是一种父类类型，不考虑继承关系。
#     isinstance() 会认为子类是一种父类类型，考虑继承关系。
# 如果要判断两个类型是否相同推荐使用 isinstance()。
class A:pass
class B(A):pass
print(isinstance(A(), A))  # True
print(type(A()) == A)  # True
print(isinstance(B(), A))  # True
print(type(B()) == A)  # False
# 2、isinstance：isinstance(obj,cls)检查是否obj是否是类 cls 的对象

# 3、issubclass：issubclass(sub, super)检查sub类是否是 super 类的派生类
class A:pass
class B(A):pass
print(issubclass(B, A)) # True
# 4、classmethod：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
class A:
    bar = 1
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
A.func2()
# func2
# 1
# 5、object：新式类中所有类的父类
# 6、property：@property 能够将一个方法伪装成一个属性
class Person:
    def __init__(self,name,weight,height):
        self.name = name
        self.__height = height
        self.__weight = weight
    @property
    def bmi(self):
        return self.__weight / self.__height ** 2
p = Person('大表哥',92,1.85)
print(p.bmi)    # 26.880934989043094
p._Person__weight = 90
print(p.bmi)    # 26.296566837107374
# 7、staticmethod：python staticmethod 返回函数的静态方法
class C:
    @staticmethod
    def f():
        print(111)
C.f()  # 静态方法无需实例化  111
cobj = C()
cobj.f()  # 也可以实例化后调用   111
# 8、super：super() 函数是用于调用父类(超类)的一个方法。
# python3.x
class A:pass
class B(A):
    def add(self, x):
        super().add(x)
# python2.x
class A(object):   # Python2.x 记得继承 object
    pass
class B(A):
    def add(self, x):
        super(B, self).add(x)
# 9、vars：vars() 函数返回对象object的属性和属性值的字典对象。
print(vars())   # {'p': <__main__.Person object at 0x000001F973A0F780>, 'C': <class '__main__.C'>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F9737BF470>, '__doc__': None, 'Person': <class '__main__.Person'>, '__file__': 'D:/python第11期/分/test/test32.py', 'B': <class '__main__.B'>, '__package__': None, '__name__': '__main__', 'cobj': <__main__.C object at 0x000001F973A0F860>, '__builtins__': <module 'builtins' (built-in)>, '__cached__': None, 'A': <class '__main__.A'>, '__spec__': None}
class A:pass    # {'__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>}

 

六、其他（12）

　　一、字符串类型代码的执行（3）

　　　　1、eval：将字符串类型的代码执行并返回结果

　　　　2、exec：将自字符串类型的代码执行

　　　　3、compile：将字符串类型的代码编译

# 1、eval：将字符串类型的代码执行并返回结果
print(eval('1+1'))  # 2

# 2、exec：将自字符串类型的代码执行
s = '''
li = []
for i in [1,2,3]:
    li.append(i)
print(li)
'''
exec(s) # [1, 2, 3]
# 3、compile：将字符串类型的代码编译
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
print(eval(compile2))   # 10

　　二、输入输出（2）

　　　　1、input：输入

　　　　2、print：输出

　　三、内存相关（2）

　　　　1、hash(o)：o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错

　　　　2、id(o)：o是参数，返回一个变量的内存地址

# 1、hash(o)：o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错
print(hash('alex'))     # -7697999738255044320
print(hash(True))   # 1
# 2、id(o)：o是参数，返回一个变量的内存地址
print(id(1))    # 1400918816

　　四、文件操作相关（1）

　　　　1、open：打开一个文件，返回一个文件操作符(文件句柄)

　　五、模块相关（1）

　　　　1、__import__：导入一个模块，函数用于动态加载类和函数 。

　　六、帮助（1）

　　　　1、help：帮助方法

　　七、调用相关（1）

　　　　1、callable(o)：o是参数，看这个变量是不是可调用，如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

# 1、callable(o)：o是参数，看这个变量是不是可调用，如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
print(callable(0))  # False
class A:pass
print(callable(A))  # True

　　八、查看内置属性（1）

　　　　1、dir：默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量

>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

 

内置函数思维导图：https://www.processon.com/view/link/5ae949b8e4b09b1bf63730c4