1.内置函数分类
思维导图: https://www.processon.com/view/link/5dcabc48e4b0bd68d813b24f
2.基础数据类型-和数字相关的函数(14)
数据类型-bool
bool()函数用于将给定参数转换为布尔类型,如果没有参数,返回 False
bool 是 int 的子类
print(bool(0)) # False # bool 是 int 子类 issubclass(bool, int) # True
数据类型-int
int()函数将给定的数据转换成int值,如果不给值则返回0
# 不传入参数时,得到结果0 int() # 0 # 可以指定转换16进制 int('f', 16) # 15 # 指定转换2进制 int('11', 2) # 3 # 指定转换8进制 int('11', 8) # 9
数据类型-float
float()函数用于将整数和字符串转换成浮点数
float(1) # 1.0 float(112) # 112.0 float(-123.6) # -123.6 # 字符串 float('123') # 123.0
数据类型-complex
complex()函数用于创建一个值为real+imag*j的复数,或者转化一个字符串或数为复数
complex(1, 2) # (1 + 2j) complex(1) # 数字(1 + 0j) # 如果第一个参数为字符串,则不需要指定第二个参数 complex("1") # 当做字符串处理(1 + 0j) # 注意: 这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错 complex("1+2j") # (1 + 2j)
进制转换-bin
bin()十进制转二进制
print(bin(3)) # 0b11
进制转换-oct
oct()函数将一个整数转换成8进制字符串
print(oct(10)) # 0o12
进制转换-hex
hex()函数用于将10进制整数转换成16进制,以字符串形式表示
print(hex(10)) # 0xa print(type(hex(12))) # <class 'str'>
数学运算-abs
abs()函数返回数字的绝对值
print(abs(-1)) # 1
数学运算-divmod
divmod()函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组
print(divmod(10, 3)) # (3, 1)
数学运算-round
round()函数返回浮点数x的四舍五入值
print(round(3.5)) # 4 print(round(3.1415, 2)) # 3.14
数学运算-pow
pow(a, b)函数求a的b次幂,如果有三个参数则求完次幂后对第三个数取余
pow(2, 10) # 1024 # 2的10次方除以100取余数 pow(2, 10, 100) # 24 # pow x**y%z print(pow(2, 3)) # 2的3次方 ==>8 print(pow(2, 3, 7)) # 2**3%7 ==>1
数学运算-sum
sum()函数对序列进行求和计算
t1 = [1, 2, 3, 4] print(sum(t1)) # 10
数学运算-min
min()函数处理的是可迭代对象相当于for循环取出每个元素进行比较,然后取最小值,不同类型不能进行比较
元素与元素比较是从元素的第一个位置开始,第一个位置分出大小,后面位置不需比较,实际比较的是Unicode值
list1 = [1, 10, -50, 100] print(min(list1)) # -50
数学运算-max
max()函数处理的是可迭代对象相当于for循环取出每个元素进行比较,然后取最大值,不同类型不能进行比较
元素与元素比较是从元素的第一个位置开始,第一个位置分出大小,后面位置不需比较,实际比较的是Unicode值
list1 = [1, 10, -50, 100] print(max(list1)) # 100 # 列表嵌套取字典中年龄最大的key和value people = [ {"name": "zhangsan", "age": 18}, {"name": "lisi", "age": 15}, {"name": "wangwu", "age": 22}, {"name": "dingliu", "age": 30} ] print(max(people, key=lambda dic: dic["age"])) # {'name': 'dingliu', 'age': 30}
3.基础数据类型-和数据结构相关的函数(24)
序列-字符串(str)
str()函数将对象转化为字符串
str(10) # '10' str(list(x for x in range(5))) # '[0, 1, 2, 3, 4]'
序列-字符串(format)
format()与具体数据相关,用于计算各种小数,精算等
# 字符串 print(format('test', '<20')) # 左对齐 print(format('test', '>20')) # 右对齐 print(format('test', '^20')) # 居中 # 数值 print(format(3, 'b')) # 二进制 print(format(97, 'c')) # 转换成unicode字符 print(format(11, 'd')) # 十进制 print(format(11, 'o')) # 八进制 print(format(11, 'x')) # 十六进制(小写字母) print(format(11, 'X')) # 十六进制(大写字母) print(format(11, 'n')) # 和d一样 print(format(11)) # 和d一样 # 浮点数 print(format(123456789, 'e')) # 科学计数法默认保6位小数 print(format(123456789, '0.2e')) # 科学计数法保留2位小数(小写) print(format(123456789, '0.2E')) # 科学计数法保留2位小数(大写) print(format(1.23456789, 'f')) # 小数点计数法保留6位小数 print(format(1.23456789, '0.2f')) # 小数点计数法保留2位小数 print(format(1.23456789, '0.10f')) # 小数点计数法保留10位小数 print(format(1.23456789e+10000, 'F')) # 小数点计数法,很大的时候输出无穷大: INF
序列-字符串(ord)
ord()函数以一个字符长度为1的字符串作为参数,返回对应的 ASCII 数值,或者 Unicode 数值
print(ord("a"), ord("A")) # 97 65 # 返回对应的Unicode值 ord('唐') # 21776
序列-字符串(chr)
chr()函数用一个范围在range(256)内也就是0～255的整数作参数,返回一个对应ASCII字符
# 十六进制 print (chr(0x30), chr(0x31), chr(0x61)) # 0 1 a # 十进制 print (chr(48), chr(49), chr(97)) # 0 1 a
序列-字符串(ascii)
ascii()函数是ascii码中的返回该值 不是就返回Unicode或对象的内存地址
print(ascii('a')) # 'a' print(ascii('好')) # 'u597d'
序列-字符串(repr)
repr()函数返回一个对象的str形式供解释器读取
# repr 就是原封不动的输出, 引号和转义字符都不起作用 print(repr('大家好, 我叫coco')) # '大家好, 我叫coco' print('大家好我叫coco') # 大家好我叫coco # %r 原封不动的写出来 name = 'cat' print('我叫%r' % name) # 我叫'cat'
序列-字节(bytes)
bytes()函数可以将参数转换成字节,encoding指定编码,decode指定解码
name = "你好" print(bytes(name, encoding='gbk')) # b'xc4xe3xbaxc3' print(bytes(name, encoding='gbk').decode('gbk')) # 你好
序列-字节(bytearray)
bytearray()函数返回一个新字节数组,这个数组里的元素是可变的,并且每个元素的值得范围是'[0,256)'
ret = bytearray('coco',encoding='utf-8') print(ret[0]) # 99 print(ret) # bytearray(b'coco') print(bytearray([1,2,3])) # bytearray(b'x01x02x03')
序列-字节(memoryview)
memoryview()函数查看bytes在内存中的情况
s = memoryview("coco".encode("utf-8")) # 查看bytes字节在内存中的情况 print(s) # <memory at 0x00000000048DCAC8> v = memoryview(bytearray("abcefg", 'utf-8')) print(v[1]) # 98 print(v[-1]) # 103 print(v[1:4]) # <memory at 0x10f543a08> print(v[1:4].tobytes()) # b'bce'
序列-列表(list)
list()函数将一个可迭代对象转换成列表
list({'name': 'coco', 'age': 18}) # ['name', 'age']
list('abcdee') # ['a', 'b', 'c', 'd', 'e', 'e']序列-元祖(tuple)
tuple()函数将一个可迭代对象转换成元组
# 针对字典会返回字典的key组成的tuple tuple({1:2,3:4}) # (1, 3) tuple([1,2,3,4]) # (1, 2, 3, 4)
序列-翻转(reversed)
reversed()函数将一个序列翻转,返回翻转序列的迭代器
list(reversed(range(10))) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
序列-自定义切片(slice)
slice()函数自定义切片
myslice = slice(5) # 设置截取5个元素的切片 myslice # slice(None, 5, None) arr = range(10) arr # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 截取5个元素 arr[myslice] # [0, 1, 2, 3, 4]
数据集合-字典(dict)
dict()函数创建一个字典
# 创建空字典 dict() # {} # 传入关键字 dict(a='a', b='b', t='t') # {'a': 'a', 'b': 'b', 't': 't'} # 映射函数方式来构造字典 dict(zip(['one', 'two', 'three'], [1, 2, 3])) # {'three': 3, 'two': 2, 'one': 1} # 可迭代对象方式来构造字典 dict([('one', 1), ('two', 2), ('three', 3)]) # {'three': 3, 'two': 2, 'one': 1}
数据集合-集合(set)
set()函数创建一个集合
x = set('runoob') y = set('google') x, y # 重复的被删除 ({'b', 'n', 'o', 'r', 'u'}, {'e', 'g', 'l', 'o'}) x & y # 交集 {'o'} x | y # 并集 {'b', 'e', 'g', 'l', 'n', 'o', 'r', 'u'} x - y # 差集 {'b', 'n', 'r', 'u'}
数据集合-固定集合(frozenset)
frozenset()函数返回一个冻结的集合,冻结后集合不能再添加或删除任何元素
a = frozenset(range(10)) # 生成一个新的不可变集合 a # frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) b = frozenset('runoob') # 创建不可变集合 b # frozenset(['b', 'r', 'u', 'o', 'n'])
其他-len
len()函数返回对象(字符,列表,元组等)长度或项目个数
str = "runoob" # 字符串长度 len(str) # 6 l = [1,2,3,4,5] # 列表元素个数 len(l) # 5
其他-sorted
sorted()函数对所有可迭代的对象进行排序操作
list1 = [1, 3, 5, 2, 9] print(sorted(list1)) # 排序本质就是比较Unicode值的大小,不同类型无法排序 # sorted列表嵌套排序 people1 = [ {"name": "zhangsan", "age": 18}, {"name": "lisi", "age": 15}, {"name": "wangwu", "age": 22}, {"name": "dingliu", "age": 30} ] print(sorted(people1, key=lambda dic: dic["age"])) # 按age从小到大排序
其他-enumerate
enumerate()函数用于将一个可遍历的数据对象(如列表,元组或字符串)
# 组合为一个索引序列同时列出数据和数据下标,一般用在 for 循环遍历当中 lst = ["coco", "angels", "cat"] # enumerate(lst, 1) 可以指定开始下标 # for index, el in enumerate(lst, 1): for index, el in enumerate(lst): print(str(index)+"==>"+el, end=' ') # 0==>coco 1==>angels 2==>cat
其他-all
all()函数将可迭代对象中的所有元素做布尔运算,1个为 False 全都为 False
# all 如果可迭代对象为空,则返回True all([]) # True print(all([1, "ss", ()])) # False
其他-any
any()函数判断给定的可迭代对象中有一个是 True, 结果就是 True, 全部为 False,则返回 False
any([0, 1, 2]) # True any([None, (), {}]) # False
其他-zip
zip()函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表,
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同
l1 = [1,2,3,] l2 = ['a','b','c',5] l3 = ('*','**',(1,2,3)) for i in zip(l1,l2,l3): print(i, end= ' ') # (1, 'a', '*') (2, 'b', '**') (3, 'c', (1, 2, 3))
其他-filter
filter()函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素的迭代器
def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(list(newlist)) # [1, 3, 5, 7, 9]
其他-map
map()函数会根据提供的函数对指定序列做映射
def square(x): """计算平方数""" return x ** 2 # 计算列表各个元素的平方 list(map(square, [1,2,3,4,5])) # [1, 4, 9, 16, 25] # 使用 lambda 匿名函数 list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # [1, 4, 9, 16, 25] # 提供了两个列表,对相同位置的列表数据进行相加 list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])) # [3, 7, 11, 15, 19]
4.作用域相关的函数(2)
全局变量-globals
globals()函数查看全局变量,包含系统提供的全局变量
a='coco' print(globals()) # globals 函数返回一个全局变量的字典,包括所有导入的变量 """ {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'coco', '__package__': None} """
局部变量-locals
locals()函数查看当前级别的局部变量,包含当前级别系统提供的局部变量
def runoob(arg): # 两个局部变量: arg,z z = 1 print (locals()) runoob(4) # {'z': 1, 'arg': 4}返回一个'变量名:绑定值'对应的字典
5.反射相关的函数(4)
判断-hasattr
hasattr()函数用于判断对象是否包含对应的属性
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x')) # True print(hasattr(point1, 'y')) # True print(hasattr(point1, 'z')) # True print(hasattr(point1, 'no')) # False没有该属性
获取-getattr
getattr()函数用于返回一个对象属性值
class A: bar = 1 a = A() getattr(a, 'bar') # 获取属性 bar 值1 getattr(a, 'bar2') # 属性 bar2 不存在,触发异常 '''异常提示 AttributeError Traceback (most recent call last) <ipython-input-1-51bf4194ae4f> in <module> 5 a = A() 6 getattr(a, 'bar') # 获取属性 bar 值1 ----> 7 getattr(a, 'bar2') AttributeError: 'A' object has no attribute 'bar2' ''' getattr(a, 'bar2', 3) # 属性 bar2 不存在,但设置了默认值3
设置-setattr
setattr()函数用于设置属性值,该属性不一定是存在的,如果属性不存在会创建一个新的对象属性,并对属性赋值
class A(): name = "runoob" a = A() setattr(a, "age", 28) print(a.age) # 28
删除-delattr
delattr()函数用于删除属性
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ',point1.x) # ('x = ', 10) print('y = ',point1.y) # ('y = ', -5) print('z = ',point1.z) # ('z = ', 0) delattr(Coordinate, 'z') print('--删除 z 属性后--') # --删除 z 属性后-- print('x = ',point1.x) # ('x = ', 10) print('y = ',point1.y) # ('y = ', -5) # 会触发错误 print('z = ',point1.z) # AttributeError: Coordinate instance has no attribute 'z'
6.迭代器生成器相关的函数(3)
range
range()生成器函数可创建一个整数迭代器
list(x for x in range(10) if x % 2 == 0) # [0, 2, 4, 6, 8]
next
next()函数让迭代器向下执行一次,内部实际使用了__next__()方法返回迭代器的下一个项目
# 首先获得Iterator对象 it = iter([1, 2, 3, 4, 5]) # 其次循环拿值 while True: try: # 获得下一个值 x = next(it) print(x, end=' ') # 1 2 3 4 5 except StopIteration: # 遇到StopIteration就退出循环 break
iter
iter()函数获取迭代器,内部实际使用的是__iter__()方法来获取迭代器
lst = [1, 2, 3] for i in iter(lst): print(i, end=' ') # 1 2 3
7.面向对象相关的函数(9)
isinstance
isinstance(obj,cls)函数检查obj是否是类 cls 的对象
isinstance() 与 type() 区别:
type()函数不会认为子类是一种父类类型,即不考虑继承关系
isinstance()函数会认为子类是一种父类类型,即考虑继承关系
print(isinstance(123, int)) # True
class A: pass class B(A): pass isinstance(A(), A) # True type(A()) == A # True isinstance(B(), A) # True type(B()) == A # False
issubclass
issubclass(sub, super)函数检查sub类是否是 super 类的派生类
class A: pass class B(A): pass print(issubclass(B,A)) # 返回 True
object
object()函数返回一个没有特征的新对象,object是所有类的基类,它具有所有Python类实例的通用方法,object函数不接受任何实参
由于 object 没有 __dict__字典 因此无法将任何属性赋给 object 的实例
class A: pass a = A() print("实例a的__dict__字典: %s" % a.__dict__) obj = object() print(obj.__dict__) # 报错,object()实例化的对象没有__dict__属性 """执行结果 实例a的__dict__字典: {} --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) <ipython-input-22-e65e48d77a62> in <module> 7 8 obj = object() ----> 9 print(obj.__dict__) # 报错,object()实例化的对象没有__dict__属性 AttributeError: 'object' object has no attribute '__dict__' """
staticmethod
staticmethod()函数修饰对应的方法变成静态方法,被装饰的方法不需要任何参数
class C: @staticmethod def run(): print('静态方法运行了') C.run() # 静态方法无需实例化 cobj = C() cobj.run() # 也可以实例化后调用
classmethod
classmethod()函数修饰对应的方法变成类方法,不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数
classmethod()函数修饰对应的方法可以来调用类的属性,类的方法
class A: bar = 1 def func1(self): self.b = 3 print ('foo') @classmethod def func2(cls): print ('func2') # func2 print (cls.bar) # 1 cls().func1() # foo A.func2() # 不需要实例化便可直接用类名调用
property
property()函数修饰对应的方法变成静态属性
class A: # property将类中的方法伪装成类属性来调用 @property def test(self): print('test') a = A() a.test # test
super
super()函数是用于调用父类(超类)的一个方法
super()函数常用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,
会涉及到查找顺序(MRO),重复调用(钻石继承)等种种问题,MRO就是类的方法解析顺序表,即继承父类方法的顺序表
class A: def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super().add(x) b = B() b.add(2) # 3
vars
vars()函数以字典的形式查看对象的内置方法,不加参数查看当前级别的局部变量,包含当前级别系统提供的局部变量
msg = "xcafsfa" print(locals()) # {'msg': 'xcafsfa'} print(vars()) # {'msg': 'xcafsfa'} print(vars(int)) # {'__repr__': <slot wrapper '__repr__' of 'int' objects>, ...}
type
type()函数如果你只有第一个参数则返回对象的类型,三个参数时返回新的类型对象
# 一个参数 type(1) # <type 'int'> type('runoob') # <type 'str'> type([2]) # <type 'list'> type({0:'zero'}) # <type 'dict'> x = 1 # 判断类型是否相等 type( x ) == int # True # 三个参数 class X: a = 1 X = type('X', (object,), dict(a=1)) # 产生一个新的类型对象 X X # <class '__main__.X'>
8.其他函数(13)
字符串类型代码的执行-eval
eval()函数用来执行一个字符串表达式,把字符串中的数据结构提取出来,并返回表达式的值
# eval把字符串中的数据结构提取出来 str1 = "{'name':'coco'}" d1 = eval(str1) print(type(d1)) # <class 'dict'> # eval把字符串中的表达式作计算 str2 = "(1+2)*3-3" print(eval(str2)) # 6
字符串类型代码的执行-exec
exec()函数把字符串以代码的方式执行
exec(""" for i in range(10):print(i) """) exec(""" def func(): print("我是coco") func() """)
字符串类型代码的执行-compile
compile()函数将字符串类型的代码变异,代码对象能够通过 exec() 语句来执行或者 eval() 进行求值
有返回值的字符串形式的代码用 eval(); 没有返回值的字符串形式的代码用 exec()
compile()函数参数说明
参数一: resource 要执行的代码,动态代码片段
参数二: 文件名,代码存放的文件名,当传入了第一个参数的时候,这个参数给空就可以了
参数三: 模式,取值有3个:
exec: 一般放一些流程语句的时候
eval: resource只存放一个求值表达式
single: resource存放的代码有交互的时候mode应为single
code1 = "for i in range(10): print(i, end=' ')" c1 = compile(code1, "", mode="exec") # compile并不会执行代码,只是编译 # 执行编译后的代码 exec(c1) # 0 1 2 3 4 5 6 7 8 9
code2 = "1+2+3" c2 = compile(code2, "", mode="eval") a = eval(c2) print(a) # 6
code3 = "name = input('请输入你的名字:')" c3 = compile(code3, "", mode="single") exec(c3) print(name)
输入-input
input()函数接受一个标准输入数据,返回为 str 类型
print(input('请输入:')) print(input('请输入:') or "-1") # 用户直接回车返回字符串 '-1'
输出-print
print()函数打印输出,end=设定以什么结尾,sep=设置间隔符
print("https:/","www.cnblogs.com","tangxuecheng",sep="/") # https://www.cnblogs.com/tangxuecheng
内存相关-hash
hash()算法函数,可hash的数据类型即不可变数据类型,不可hash的数据类型即可变数据类型
hash特性1: hash无论传入的参数长短,hash得出的值长度固定
hash特性2: 不能根据hash结果值推算传入的具体数据
hash('test') # -7108862475672989075 hash(1) # 1 hash(str([1,2,3])) # -4688137874008436223 hash(str(sorted({'1':1}))) # -4466824049926549424
内存相关-id
id()函数获取到对象的内存地址
name = 'coco' id(name) # 78357592
文件操作相关-open
open()函数用于口打开一个文件,返回一个文件句柄file对象
f = open('a.xtx', 'w') f.write('hello') f.close()
模块相关-__import__
__import__()函数用于动态加载类和函数,如果一个模块经常变化就可以使用 __import__() 来动态载入
import os print ('在 a.py 文件中 %s' % id(os)) # 在 a.py 文件中 30713320 import sys __import__('a') # 导入 a.py 模块
帮助-help
help()函数查看帮助
print(help(hash)) # 查看方法的具体解释
调用相关-callable
callable(obj)函数用于检查一个对象是否可调用,如果返回True,obj有可能调用失败,如果返回False那调用绝对不会成功
class A: def method(self): return 0 callable(A) # 类返回True a = A() callable(a) # 没有实现__call__返回False class B: def __call__(self): return 0 callable(B) # True b = B() callable(b) # 实现__call__返回 True
查看内置属性-dir
dir()函数不带参数时,返回当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性和方法列表
如果参数包含方法__dir__(),该方法将被调用,如果参数不包含__dir__(),该方法将最大限度地收集参数信息
print(dir(all)) # ['__call__', '__class__', '__delattr__'...]
内建除错-breakpoint
breakpoint()函数在未设置 PYTHONBREAKPOINT 环境变量的情况下,会中断当前程序并进入 pdb 调试器
import time print(time.ctime()) breakpoint() print('Good morning') """执行结果 Sun Jul 26 19:58:37 2020 --Return-- > <ipython-input-26-ba7b402eb64c>(4)<module>()->None -> breakpoint() (Pdb) """
# 原理剖析 # In builtins. def breakpoint(*args, **kws): import sys missing = object() hook = getattr(sys, 'breakpointhook', missing) if hook is missing: raise RuntimeError('lost sys.breakpointhook') return hook(*args, **kws) # In sys. def breakpointhook(*args, **kws): import importlib, os, warnings hookname = os.getenv('PYTHONBREAKPOINT') if hookname is None or len(hookname) == 0: hookname = 'pdb.set_trace' elif hookname == '0': return None modname, dot, funcname = hookname.rpartition('.') if dot == '': modname = 'builtins' try: module = importlib.import_module(modname) hook = getattr(module, funcname) except: warnings.warn( 'Ignoring unimportable $PYTHONBREAKPOINT: {}'.format( hookname), RuntimeWarning) return hook(*args, **kws) __breakpointhook__ = breakpointhook