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() #
# 可以指定转换16进制
int('f', 16) #
# 指定转换2进制
int('', 2) #
# 指定转换8进制
int('', 8) #
数据类型-float
float()函数用于将整数和字符串转换成浮点数
float(1) # 1.0
float(112) # 112.0
float(-123.6) # -123.6
# 字符串
float('') # 123.0
数据类型-complex
complex()函数用于创建一个值为real+imag*j的复数,或者转化一个字符串或数为复数
complex(1, 2) # (1 + 2j)
complex(1) # 数字(1 + 0j)
# 如果第一个参数为字符串,则不需要指定第二个参数
complex("") # 当做字符串处理(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)) #
数学运算-divmod
divmod()函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组
print(divmod(10, 3)) # (3, 1)
数学运算-round
round()函数返回浮点数x的四舍五入值
print(round(3.5)) #
print(round(3.1415, 2)) # 3.14
数学运算-pow
pow(a, b)函数求a的b次幂,如果有三个参数则求完次幂后对第三个数取余
pow(2, 10) #
# 2的10次方除以100取余数
pow(2, 10, 100) #
# 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)) #
数学运算-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)) #
# 列表嵌套取字典中年龄最大的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('唐') #
序列-字符串(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('大家好,\n \t我叫coco')) # '大家好,\n \t我叫coco'
print('大家好我叫coco') # 大家好我叫coco
# %r 原封不动的写出来
name = 'cat'
print('我叫%r' % name) # 我叫'cat'
序列-字节(bytes)
bytes()函数可以将参数转换成字节,encoding指定编码,decode指定解码
name = "你好"
print(bytes(name, encoding='gbk')) # b'\xc4\xe3\xba\xc3'
print(bytes(name, encoding='gbk').decode('gbk')) # 你好
序列-字节(bytearray)
bytearray()函数返回一个新字节数组,这个数组里的元素是可变的,并且每个元素的值得范围是'[0,256)'
ret = bytearray('coco',encoding='utf-8')
print(ret[0]) #
print(ret) # bytearray(b'coco')
print(bytearray([1,2,3])) # bytearray(b'\x01\x02\x03')
序列-字节(memoryview)
memoryview()函数查看bytes在内存中的情况
s = memoryview("coco".encode("utf-8")) # 查看bytes字节在内存中的情况
print(s) # <memory at 0x00000000048DCAC8>
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1]) #
print(v[-1]) #
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) #
l = [1,2,3,4,5]
# 列表元素个数
len(l) #
其他-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) #
删除-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) #
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) #
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)) #
字符串类型代码的执行-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) #
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) #
hash(str([1,2,3])) # -4688137874008436223
hash(str(sorted({'':1}))) # -4466824049926549424
内存相关-id
id()函数获取到对象的内存地址
name = 'coco'
id(name) #
文件操作相关-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 == '':
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