内置函数
内置函数:就是python提供给你直接可以拿来使用的所有函数 即在无需定义的情况下,直接可以用函数名()调用函数。
数学运算类
1.abs:求数值的绝对值
>>> abs(-2) 2
2.divmod:返回两个数值的商和余数
>>> divmod(5,2) (2, 1) #这里2代表商,1代表余数
3.max:返回可迭代对象中的元素中的最大值或者所有参数的最大值
>>> max(-3,0,2) # 数值默认去数值较大者 3 >>> max(-1,0,key = abs) # 传入了求绝对值函数,则参数都会进行求绝对值后再取较大者 -1 #这里比较后得到的结果任然绝对值前的数字
4.min:返回可迭代对象中的元素中的最小值或者所有参数的最小值
>>> min(-1,-2,3) # 数值默认去数值较小者 -2 >>> min(-1,-2,key = abs) # 传入了求绝对值函数,则参数都会进行求绝对值后再取较小者 -1
5.pow:返回两个数值的幂运算值以及余数
>>> pow(2,3) >>> 2**3 >>> pow(2,3,5) >>> pow(2,3)%5
6.round:对浮点数进行四舍五入求值
>>> round(1.1314926,1) 1.1 >>> round(1.1314926,5) 1.13149 #这里的5代表小数点后保留5位
7.sum:对元素类型是数值的可迭代对象中的每个元素求和
# 传入可迭代对象 >>> sum((1,2,3,4)) 10 # 元素类型必须是数值型,可以带小数点 >>> sum((1.5,2.5,3.5,4.5)) 12.0 >>> sum((1,2,3,4),10) 这里的10表示从10开始,计算时需要将其算入 20
类型转换
bool:根据传入的参数的逻辑值创建一个新的布尔值
>>> bool() #不传入参数显示为False False >>> bool(0) #数值0、空序列等值为False False >>> bool(1) True
int : 根据传入的参数创建一个新的整数
>>> int() #不传入参数时,得到结果0。 0 >>> int(3) 3 >>> int(3.6) 3
float:根据传入的参数创建一个新的浮点数
>>> float() #不提供参数的时候,返回0.0 0.0 >>> float(3) 3.0 >>> float('3') #传入内部为数字的字符时,可以转化为浮点数。 3.0
complex:根据传入参数创建一个新的复数
>>> complex() #当两个参数都不提供时,返回复数 0j。 0j >>> complex('1+2j') #传入字符串创建复数 (1+2j) >>> complex(1,2) #传入数值创建复数 (1+2j)
str:转换为字符形式
>>> str('abc') 'abc' >>> str(123) '123'
bytearray和bytes
>>>b_array = bytearray('你好',encoding='utf-8')#创建一个新的可变字节数组 >>>bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
>>>b_array = bytes('你好',encoding='utf-8')#创建一个新的不可变字节数组 >>>b'\xe4\xbd\xa0\xe5\xa5\xbd'
ord:返回Unicode字符对应的整数
>>> ord('a') 97
chr:返回整数对应的Unicode字符
>>> chr(97) 'a'
bin:将整数转换成2进制字符串
>>> bin(3) '0b11'
oct:将整数转化成8进制数字符串
>>> oct(10) '0o12'
hex:将整数转换成16进制字符串
>>> hex(15) '0xf'
tuple:根据传入的参数创建一个新的元组
>>> tuple() #不传入参数,创建空元组 () >>> tuple('121') #传入可迭代对象。使用其元素创建新的元组 ('1', '2', '1')
list:根据传入的参数创建一个新的列表
>>>list() # 不传入参数,创建空列表 [] >>> list('abcd') # 传入可迭代对象,使用其元素创建新的列表 ['a', 'b', 'c', 'd']
dict:根据传入的参数创建一个新的字典
>>> dict() # 不传入任何参数时,返回空字典。 {} >>> dict(a = 1,b = 2) # 可以传入键值对创建字典。 {'b': 2, 'a': 1} >>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。 {'b': 2, 'a': 1} >>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。 {'b': 2, 'a': 1}
set:根据传入的参数创建一个新的集合, frozenset:根据传入的参数创建一个新的不可变集合
>>>set() # 不传入参数,创建空集合 set() >>> a = set(range(10)) # 传入可迭代对象,创建集合 >>> a {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
enumerate:根据可迭代对象创建枚举对象
seasons = ['Spring', 'Summer', 'Fall', 'Winter'] for i in enumerate(seasons): print(i) #这里结果前面显示的是列表的索引,后面显示的是与其对应的值 (0, 'Spring') (1, 'Summer') (2, 'Fall') (3, 'Winter')
range:根据传入的参数创建一个新的range对象
# a = range(10) # b = range(1,10) # c = range(1,10,3) 顾首不顾尾,3代表步长 # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # [1, 2, 3, 4, 5, 6, 7, 8, 9] # [1, 4, 7]
iter:根据传入的可迭代对象,创建一个迭代器
>>> a = iter('abcd') #字符串序列 >>> a <str_iterator object at 0x03FB4FB0> #此处得到一个迭代器 >>> next(a) 'a' >>> next(a) 'b' >>> next(a) 'c' >>> next(a) 'd' >>> next(a) Traceback (most recent call last): File "<pyshell#29>", line 1, in <module> next(a) StopIteration
slice:根据传入的参数创建一个新的切片对象
# l = (1,2,23,213,5612,342,43) # sli = slice(1,5,2) #slice(1,5,2)=[1:5:2] # print(l[sli])
序列操作
all:判断可迭代对象的每个元素是否都为True值
>>> all([1,2]) #列表中每个元素逻辑值均为True,返回True True >>> all([0,1,2]) #列表中0的逻辑值为False,返回False #元素中只要有一个是False则all返回False False >>> all(()) #空元组 #如果all()括号内是可迭代对象且时空的,则结果为True True >>> all({}) #空字典 True
any:判断可迭代对象的元素是否有为True值的元素
>>> any([0,1,2]) #列表元素只要有一个为True,则返回True True >>> any([0,0]) #列表元素全部为False,则返回False False >>> any([]) #空列表 #如果all()括号内是可迭代对象且时空的,则结果为False False >>> any({}) #空字典 False
filter:使用指定方法过滤可迭代对象的元素
# from math import sqrt # def func(num): # res = sqrt(num) #求平方根 # return res % 1 == 0 #取整 # ret = filter(func,range(1,10)) #filter(函数,可迭代对象) # filter 执行了filter之后的结果集合 <= 执行之前的个数
#filter只管筛选,不会改变原来的值 # for i in ret: # print(i) # 1 # 4 # 9
map:使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象
# ret = map(abs,[1,-4,6,-8]) #利用abs作用于可迭代对象的元素 # print(ret) # for i in ret: # print(i)
#1
#4
#6
#8
next:返回可迭代对象中的下一个元素值
reversed:反转序列生成新的可迭代对象
>>> a = reversed(range(10)) # 传入range对象 >>> a # 转换成迭代器 <range_iterator object at 0x035634E8> >>> list(a) [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
sorted:对可迭代对象进行排序,返回一个新的列表
# l = [1,-4,6,5,-10] # l.sort(key = abs) # 在原列表的基础上进行排序,节省内存
# print(l)
# print(sorted(l,key=abs,reverse=True)) # 生成了一个新列表 不改变原列表 占内存
结果显示:
[1, -4, 5, 6, -10]
[-10, 6, 5, -4, 1]
zip:聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器(拉链)
>>> x = [1,2,3] #长度3 >>> y = [4,5,6,7,8] #长度5 >>> list(zip(x,y)) # 取最小长度3 [(1, 4), (2, 5), (3, 6)]
对象操作
帮助:help 返回对象的帮助信息
dir:返回对象或者当前作用域内的方法列表
print(dir(list)) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__'
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__'
'__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
id:返回对象的唯一标识符(内存地址)
# k=id(1234) # print(k)
4833008
hash:获取对象的哈希值
print(hash('abcd')) #如果输入的对象可哈希,则显示一串数字 -1277073939423528596 print(hash([a,b.c,d])) #如果输入的对象不可哈希,则报错 NameError: name 'a' is not defined
type:返回对象的类型
# print(type('abcd'))
<class 'str'>
len:返回对象的长度
print(len([1,2,3,4]))
4
format:格式化显示值
# 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'
#print(format('abcd', '<20')) #得到一个20个字节的空间,将'abcd'左对齐
#print(format('abcd', '>20')) #得到一个20个字节的空间,将'abcd'右对齐
#print(format('abcd', '^20')) #得到一个20个字节的空间,将'abcd'居中
动态导入模块:import
callable:检测对象是否可被调用
变量操作
globals:返回当前作用域内的全局变量和其值组成的字典
a = 1
globals() # {'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__',
'__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
locals:返回当前作用域内的局部变量和其值组成的字典,如果将locals放入全局作用域,则结果和globals相同
>>> def f(): print('before define a ') print(locals()) #作用域内无变量 a = 1 print('after define a') print(locals()) #作用域内有一个a变量,值为1
{} {a:1} #{变量名:值}
输入输出
input:读取用户输入值
>>>s = input('please input your name:') >>>please input your name:哈哈 >>> s '哈哈'
print:向标准输出对象打印输出
#print(1,2,3,4,5,sep='|',end='*')
1|2|3|4|5*
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕,如果设置为文件句柄,输出到文件
sep: 打印多个值之间的分隔符,默认为空格
end: 每一次打印的结尾,默认为换行符
flush: 立即把内容输出到流文件,不作缓存
文件操作
open:使用指定的模式和编码打开文件,返回文件读写对象
#a = open('test.txt','utf-8') #a.read() #a.close()
编译执行
compile 函数将一个字符串编译为字节代码。
compile(source, filename, mode[, flags[, dont_inherit]])
- source -- 字符串或者AST(Abstract Syntax Trees)对象。。
- filename -- 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
- mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
- flags -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。。
- flags和dont_inherit是用来控制编译源码时的标志
>>> #流程语句使用exec >>> code1 = 'for i in range(0,10): print (i)' >>> c1 = compile(code1,'','exec') #code1表示需要执行的字符串 ‘exec’表示指定编译代码的种类 >>> exec (c1) 0 1 2 3 4 5 6 7 8 9 >>> #简单求值表达式用eval >>> code2 = '1 + 2 + 3 + 4' >>> c2 = compile(code2,'','eval') >>> eval(c2) 10
eval:执行动态表达式求值
#print(eval('1+2+3'))
6
exec:执行动态语句块
# print(exec('a=1+2')) #执行语句 3