内置函数的思维导图https://www.processon.com/view/5bdbfba6e4b0e452133837a3#map
内置函数:python自带的函数
作用域相关
基于字典的形式获取局部变量和全局变量
globals()——获取全局变量的字典
- any()
如果所有元素中有一个值非0、''或False,那么结果就为True,当iterable所有的值都是0、''或False时,那么结果为False
- ascii()
调用对象的__repr__()方法,获得该方法的返回值.
- bool()
测试一个对象是True还是False.
- bytes()
将一个字符串转换成字节类型
- callable(object)
callable()函数用于测试对象是否可调用,如果可以则返回1(真);否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了 调用 方法的类实例。
- chr(i)
chr()函数返回ASCII码对应的字符串。
- complex(real[,imaginary])
complex()函数可把字符串或数字转换为复数。
- delattr()
删除对象的属性
- dict()
创建数据字典
- dir()
不带参数时返回当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性,方法列表
- divmod(x,y)
divmod(x,y)函数完成除法运算,返回商和余数。
- enumerate()
返回一个可以枚举的对象,该对象的next()方法将返回一个元组
- eval()
将字符串str当成有效的表达式来求值并返回计算结果
s = "1 + 3 +5" print(eval(s)) #9
- exec()
执行字符串或complie方法编译过的字符串,没有返回值
- float(x)
float()函数把一个数字或字符串转换成浮点数。
print(float("12")) #12.0
- format()
格式化输出字符串
print("i am {0},age{1}".format("tom",18))
i am tom,age18
- frozenset()
创建一个不可修改的集合
set
和
frozenset
最本质的区别是前者是可变的,后者是不可变的。当集合对象会被改变时(例如删除,添加元素),只能使用
set
,
一般来说使用fronzet的地方都可以使用
set
。
参数iterable:可迭代对象。
- hex(x)
hex()函数可把整数转换成十六进制数。
locals()——获取执行本方法所在命名空间内的局部变量的字典
def func(): a = 1 b = 2 print(locals()) print(globals()) #始终不变 func(){'b': 2, 'a': 1}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00 000 226639E59E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__ '_ _cac hed__': No ne, 'func': <function func at 0x0000022663AB89D8>}
其他
eval() 将字符串类型的代码执行并返回结果
print(eval('1+2+3+4')) #10
s.upper()全大写,全小写s.lower()全小写
s.swapcase()大小写翻转
s.title()每个隔开(特殊字符或者数字)的单词首字母大写
s.center(20,'~')居中
s6 = s.expandtabs()空白填充
以什么开头s.startswith('alex')startswith('e',2,5)结尾endswith
strip 默认删除前后空格
split str ---->list s.split('a)以a分割符
find 通过元素找索引,找不到返回-1 s = 'alexWUsir' s.find('A')
index通过元素找索引,找不到报错
增加 append insert
元祖 只读列表,可循环查询,可切片。
儿子不能改,孙子可能可以改。
list.reverse()
反向列表中元素
数据类型划分:可变数据类型,不可变数据类型
不可变数据类型:元组,bool int str 可哈希
可变数据类型:list,dict set 不可哈希
dict key 必须是不可变数据类型,可哈希,
value:任意数据类型。
dict 优点:二分查找去查询
存储大量的关系型数据
特点:无序的
# 操作文件
# 读
# read 一次性读
# readlines 一次性读
# readline 一行一行读
#不知道在哪儿结束
#视频 图片 rb bytes 按照字节读
# for循环 —— 最好!!!
# 写
# write
# 光标 —— 文件指针
#seek _ 指定光标移动到某个位置
#tell _ 获取光标当前的位置
#truncate _ 截取文件
# 关闭文件
#close
rename()方法需要两个参数,当前的文件名和新文件名。
remove()方法删除文件,需要提供要删除的文件名作为参数
exec()将自字符串类型的代码执行
print(exec("1+2+3+4")) #没有返回值,结果None exec("print('hello,world')") #hello,world
compile 将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
参数说明:
1. 参数source:字符串或者AST(Abstract Syntax Trees)对象。即需要动态执行的代码段。
2. 参数 filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时,filename参数传入空字符即可。
3. 参数model:指定编译代码的种类,可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时,model应指定为‘exec’;当source中只包含一个简单的求值表达式,model应指定为‘eval’;当source中包含了交互式命令语句,model应指定为'single'。
exec("print('12345')") #12345 eval("print('12345')") #12345 print(exec('1+2+3-4')) #None print(eval('1+2+3-4')) #2
code1 = 'for i in range(0,10): print (i)' compile1 = compile(code1,'','exec') exec(compile1) #0 1 2 3 4 5 6 7 8 9
#简单求值表达式用eval code2 = '1 + 2 + 3 + 4' compile2 = compile(code2,'','eval') print(eval(compile2))
code3 = 'name = input("please input your name:")' compile3 = compile(code3,'','single') # # name #执行前name变量不存在 exec(compile3) print(name) #name在pycharm里飘红,但是可以执行please input your name:
range#可迭代对象,可以for循环,惰性运算
# range(100) #[0,100) # range(5,100) #[5,100) # range(1,100,2) #可迭代对象,可以for循环,惰性运算 # def iter(): #定义迭代器 # return range(100).__iter__() iterator = iter(range(100)) #拿到一个迭代器 print(iterator.__next__()) #0 print(next(iterator)) #1 for i in range(100): print(i) #for循环迭代每一个元素
dir查看参数所属类型的所有内置方法
dir() 默认查看全局空间内的属性,也接受一个参数,查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法 print(dir(int)) #查看整数的内置方法
callable
和调用相关
callable(o),o是参数,看这个变量是不是可调用。
如果o是一个函数名,就会返回True
a = 1 def func():pass print(callable(a)) #不可以调用 print(callable(print)) #可以调用 print(callable(func)) #可以调用
查看关键字用法
ctrl + 左键单击 :pycharm
help:包含所有方法名以及他的使用方法 —— 不知道用法的情况下
在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入quit退出
或者直接执行help(o),o是参数,查看和变量o有关的操作
dir:只包含方法名 —— 想查看某方法是否在这个数据类型中
import 引用模块
import time #时间
import os #操作系统
open() 打开一个文件,返回一个文件操作符
操作文件的模式有r,w,a,rb,wb,ab
可以用encoding指定编码.utf-8,gbk
f = open('文件名','w',encoding='utf-8')
input输入,输入内容是字符串
s = input("请输入内容 : ") print(s)
print输出打印
print(self, *args, sep=' ', end=' ', file=None): """ print(value, ..., sep=' ', end=' ', file=sys.stdout, flush=False) file: 默认是输出到屏幕,如果设置为文件句柄,输出到文件 sep: 打印多个值之间的分隔符,默认为空格 end: 每一次打印的结尾,默认为换行符 flush: 立即把内容输出到流文件,不作缓存 """
f = open('tmp_file','w') print(123,456,sep=',',file = f,flush=True)
##打印进度条
import time for i in range(0,101,2): time.sleep(0.2) char_num = i//2 #打印多少个'*' per_str = ' %s%% : %s ' % (i, '*' * char_num) if i == 100 else ' %s%% : %s'%(i,'*'*char_num) print(per_str,end='', flush=True) # 可以把光标移动到行首但不换行
type(o)返回变量o的数据类型
id(o)返回变量o的内存地址
hash(o)返回一个可hash变量的哈希值,不可hash的变量被hash之后会报错
数字相关
数字——数据类型相关:bool(布尔型),int(整型),float(浮点型),complex(复数),一般用于强转类型
进制转换相关:bin(二进制),oct八进制(),hex(十六进制),一般用于强转类型
数学运算:abs(绝对值),divmod(取商和余),min(最小值),max(最大值),sum(求和),round(取几位小数),pow(幂运算)
abs 取绝对值
print(abs(-5)) #5
divmod 取商余
ret = divmod(10,2) print(ret) #(5, 0)
ret = divmod(3,2)
print(ret) #(1, 1)
ret = divmod(7,2)
print(ret) #(3,1)
round 取几位小数
print(round(3.14159,2)) #取小数位数,后面的2表示去几位小数,结果为3.14
pow 幂运算
print(pow(2,3.5)) #可以是小数,结果11.313708498984761 print(pow(3,2)) #9print(pow(2,3,3)) #x**y%z结果2
sum 求和,接收一个可迭代对象
print(sum([1,2,3,4,5,6],-2)) #后面的-2同样和前面的相加,结果为19 print(sum(range(100))) #4950
min 最小值
print(min([1,-4,0,9,6])) #-4 print(min([],default=0)) #取默认值0 print(min([-9,1,23,5],key=abs)) #匿名函数,序列里先经过后面的函数运算再比较,结果为1 print(min({'z':1,'a':2})) #比较字典键的大小,结果为a
max 最大值
t = (-25,1,3,6,8) print(max(t)) #8 print(max(t,key = abs)) #-25 print(max((),default=100)) #100
数据结构相关
序列:list,tuple,str,format,bytes,bytearry,memoryview,ord,chr,ascii,repr
ret = bytearray('alex',encoding='utf-8') #对比较长的字符串做修改的时候,指定某一处进行修改,不会改变这个bytearry的内存地址 print(id(ret)) #2235695791048 print(ret[0]) #97,a的asii码 ret[0] = 65 print(ret) #bytearray(b'Alex'),小写a变大写A print(id(ret)) #2235695791048,内存不变
ret = memoryview(bytes('你好',encoding='utf-8')) print(len(ret)) #6 print(bytes(ret[:3]).decode('utf-8')) #你 print(bytes(ret[3:]).decode('utf-8')) #好
reversed反转
l = [3,4,2,5,7,1,5] ret = reversed(l) print(ret) # <list_reverseiterator object at 0x000001EFDFF27BA8> print(list(ret)) #[5, 1, 7, 5, 2, 4, 3] l.reverse() print(l) #[5, 1, 7, 5, 2, 4, 3]
slice 实现了切片的函数
l = (1,2,23,213,5612,342,43) sli = slice(1,5,2) #实现了切片的函数 print(l[sli]) #(2, 213) #l[1:5:2] 语法糖
format
print(format('test', '<20'))#20个字符,test左对齐 print(format('test', '>20'))#20个字符,test右对齐 print(format('test', '^20'))#20个字符,test居中
结果:
test
test
test
bytes
#网络编程的时候:能在网络上传递的必须是字节 ret = bytes('你好,哈哈哈,再见',encoding='utf-8') #中间是网络传输的过程 print(ret.decode(encoding='utf-8')) #你好,哈哈哈,再见
ord
print(ord('a')) #97
chr
print(chr(97)) #a
ascii
print(ascii(97)) #97 print(ascii('a') #'a',原内容输出字符,a带引号
repr
print(repr(1)) #1 print(repr('1')) #'1' print(repr('name : %r'%('金老板'))) #'name : '金老板'',整体带引号
enumerate枚举
l = ['笔记本','phone','apple','banana'] for i,j in enumerate(l,1): print(i,j)
输出
1 笔记本
2 phone
3 apple
4 banana
all只要有一个布尔值为False的内容,结果就为False,否则为True
any只要有一个布尔值为True的内容,结果就为True,否则为False
print(all([1,2,3,4,0])) #F print(all([1,2,3,4])) #T print(all([1,2,3,None])) #F print(all([1,2,3,''])) #F print(any([1,None,False])) #T print(any([False,None,False])) #F
zip 拉链函数
print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))
结果[(0, 5, 'a'), (1, 6, 'b')]
filter过滤函数
def is_odd(x): if x>10: return True ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17]) print(list(ret)) #[12, 17]
#filter就是有一个可迭代对象,想要一个新的内容集,是从原可迭代对象中筛选出来的 def func(x): #return x.strip() #‘ ’.strip() ==> '' ==> return False # 'test'.strip() ==> 'test' return x and x.strip() #None False and #去掉所有的空内容和字符串中的空格 l = ['test', None, '', 'str', ' ', 'END'] ret = filter(func,l) print(list(ret)) #新内容少于等于原内容的时候,才能用到filter
map
ret = map(abs,[-1,-5,6,-7]) #abs(-1) = 1 abs(-5) = 5 print(list(ret)) #[1, 5, 6, 7]
filter和map
参数很相近:都是一个函数名+可迭代对象
且返回值很相近:都是返回可迭代对象
区别:
filter是做筛选的,结果还是原来就在可迭代对象中的项
map是对可迭代对象中的每一项做操作的,结果不一定是原来就在可迭代对象中的项
有一个list, L = [1,2,3,4,5,6,7,8],我们要将f(x)=x^2作用于这个list上,那么我们可以使用map函数处理
def func(x): return x*x ret = map(func,[1,2,3,4,5,6,7,8]) print(list(ret)) #[1, 4, 9, 16, 25, 36, 49, 64]
sorted排序
对List、Dict进行排序,Python提供了两个方法
对给定的List L进行排序,
方法1.用List的成员函数sort进行排序,直接修改原列表顺序,节省内存
方法2.用内置函数sorted进行排序,生成新列表,原列表不变
print(sorted([-5,3,-4,2,-1],reverse=True)) #[3, 2, -1, -4, -5],reverse=True默认从大打小排序 print(sorted([-5,3,-4,2,-1],key=abs)) #[-1, 2, 3, -4, -5],按绝对值大小排序(原列表元素不变) l2 = ['ajkhs',(1,2),'a',[1,2,3,4]] print(sorted(l2,key=len,reverse=True)) #['ajkhs', [1, 2, 3, 4], (1, 2), 'a'],按元素长度排序
匿名函数
lambda表达式
def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n print(calc(10))
dic={'k1':10,'k2':100,'k3':30} print(max(dic.values())) #找出字典中最大的值 print(max(dic)) #找出字典中最大的键 print(max(dic,key=lambda k:dic[k])) #找出字典中值最大的键
结果:
100
k3
k2
#找出序列中大于10的数
ret = filter(lambda num:num>10,[1,4,6,823,67,23]) print(list(ret))
#也可以下面这样写 ret = filter(lambda num:True if num>10 else False,[1,4,6,823,67,23]) print(list(ret))
一、数学运算类
1,abs(x)求绝对值参数可以是整型,也可以是复数
2,divmod(a, b)分别取商和余数,整型、浮点型都可以
3,pow(x, y)x的y次幂
4,round(x, n)小数四舍五入
5,sum(iterable)求和
6,int转为int类型
7,bool转为bool类型
8,float转为float类型
二、序列操作
1,enumerate返回一个可枚举的对象,该对象的next()方法将返回一个tuple
2,max(iterable[args][key])返回最大值
3,min(iterable[args][key])返回最小值
4,sorted(iterable,key,reverse)对序列排序
5,reversed反转
三,判断类
1,all集合中的元素都为真的时候为真
2,any集合中的元素有一个为真的时候为真
3,callable检查对象是否可调用
4,dir返回方法或者参数的属性
四,字符串类
1,bytes
2,eval将字符串类型的代码执行并返回结果
3,exec将自字符串类型的代码执行
4,compile将字符串类型的代码编译
5,len返回集合长度
五,函数类
1,filter过滤函数
2,map遍历每个元素,执行function操作
3,zip拉链函数
4,repr用于%r格式化输出
5,range(start, stop, step]) 产生一个可跌代对象,默认从0开始
六,其他
1,input输入
2,print输出
3,hash返回一个可哈希值
4,open打开文件
5,import引用模块
带key值的函数,key=func
min()
max()
sorted()