常用模块
Posted 龚旭1994
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了常用模块相关的知识，希望对你有一定的参考价值。
匿名函数lambda
lambda 创建一个匿名函数。不需要显示的指定函数（函数体自带return）
应用场景：应用于一次性的场景，临时使用，
匿名函数最复杂的运算就是三元运算
for i in map(lambda x:x*2 if x>5 else x-1,[1,2,3,4,5,6,7,8,9]): print(i)
匿名就是没有名字 def func(x,y,z=1): return x+y+z 匿名 lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字 func=lambda x,y,z=1:x+y+z func(1,2,3) #让其有名字就没有意义 有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能 匿名函数：一次性使用，随时随时定义 应用：max，min，sorted,map,reduce,filter
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数称之为高阶函数
特点：
1，把一个函数的内存地址当做参数传给另外一个函数
2，一个函数把另外一个函数当做返回值返回
def add(x,y,z): return y(x) +y(z) print(add(3,-5,abs))
内置函数
内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型
abs 绝对值（正值，负值都变成正值）
max（首字母比较最大）
min（最小）
sorted排序（从小到大）
salaries={ \'gx\':3000, \'gxx\':100000000, \'gxgx\':10000, \'gg\':2000 } 迭代字典，取得是key，因而比较的是key的最大和最小值 >>> max(salaries) \'yuanhao\' >>> min(salaries) \'alex\' 可以取values，来比较 >>> max(salaries.values()) >>> min(salaries.values()) 但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键 >>> max(salaries,key=lambda k:salary[k]) \'gxx\' >>> min(salaries,key=lambda k:salary[k]) \'gg\' 也可以通过zip的方式实现 salaries_and_names=zip(salaries.values(),salaries.keys()) 先比较值，值相同则比较键 >>> max(salaries_and_names) (100000000, \'gxx\') salaries_and_names是迭代器，因而只能访问一次 >>> min(salaries_and_names) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: min() arg is an empty sequence sorted(iterable，key=None,reverse=False)
>>> format(\'some string\',\'s\') \'some string\' >>> format(\'some string\') \'some string\' #整形数值可以提供的参数有 \'b\' \'c\' \'d\' \'o\' \'x\' \'X\' \'n\' None >>> 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\' #浮点数可以提供的参数有 \'e\' \'E\' \'f\' \'F\' \'g\' \'G\' \'n\' \'%\' None >>> format(314159267,\'e\') #科学计数法，默认保留6位小数 \'3.141593e+08\' >>> format(314159267,\'0.2e\') #科学计数法，指定保留2位小数 \'3.14e+08\' >>> format(314159267,\'0.2E\') #科学计数法，指定保留2位小数，采用大写E表示 \'3.14E+08\' >>> format(314159267,\'f\') #小数点计数法，默认保留6位小数 \'314159267.000000\' >>> format(3.14159267000,\'f\') #小数点计数法，默认保留6位小数 \'3.141593\' >>> format(3.14159267000,\'0.8f\') #小数点计数法，指定保留8位小数 \'3.14159267\' >>> format(3.14159267000,\'0.10f\') #小数点计数法，指定保留10位小数 \'3.1415926700\' >>> format(3.14e+1000000,\'F\') #小数点计数法，无穷大转换成大小字母 \'INF\' #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 >>> format(0.00003141566,\'.1g\') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 \'3e-05\' >>> format(0.00003141566,\'.2g\') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 \'3.1e-05\' >>> format(0.00003141566,\'.3g\') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 \'3.14e-05\' >>> format(0.00003141566,\'.3G\') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 \'3.14E-05\' >>> format(3.1415926777,\'.1g\') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 \'3\' >>> format(3.1415926777,\'.2g\') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 \'3.1\' >>> format(3.1415926777,\'.3g\') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 \'3.14\' >>> format(0.00003141566,\'.1n\') #和g相同 \'3e-05\' >>> format(0.00003141566,\'.3n\') #和g相同 \'3.14e-05\' >>> format(0.00003141566) #和g相同 \'3.141566e-05\'
time模块
时间相关的操作，时间有三种表示方式：
- 时间戳 1970年1月1日之后的秒，即：time.time()
- 格式化的字符串 2017-11-11 11:11， 即：time.strftime(\'%Y-%m-%d\')
- 结构化时间 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()
print time.time() print time.mktime(time.localtime()) print time.gmtime() #可加时间戳参数 print time.localtime() #可加时间戳参数 print time.strptime(\'2017-11-11\', \'%Y-%m-%d\') print time.strftime(\'%Y-%m-%d\') #默认当前时间 print time.strftime(\'%Y-%m-%d\',time.localtime()) #默认当前时间 print time.asctime() #Mon Aug 7 11:17:03 2017 print time.asctime(time.localtime()) print time.ctime(time.time()) import datetime \'\'\' datetime.date：表示日期的类。常用的属性有year, month, day datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond datetime.datetime：表示日期时间 datetime.timedelta：表示时间间隔，即两个时间点之间的长度 timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]]) strftime("%Y-%m-%d") \'\'\' import datetime print datetime.datetime.now() print datetime.datetime.now() - datetime.timedelta(days=5)
random模块
import random print(random.random())#(0,1)----float 大于0且小于1之间的小数 print(random.randint(1,3)) #[1,3] 大于等于1且小于等于3之间的整数 print(random.randrange(1,3)) #[1,3) 大于等于1且小于3之间的整数 print(random.choice([1,\'23\',[4,5]]))#1或者23或者[4,5] print(random.sample([1,\'23\',[4,5]],2))#列表元素任意2个组合 print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716 item=[1,3,5,7,9] random.shuffle(item) #打乱item的顺序,相当于"洗牌" print(item)
随机验证码 import random checkcode = \'\' for i in range(4): current = random.randrange(0,4) if current != i: temp = chr(random.randint(65,90)) else: temp = random.randint(0,9) checkcode += str(temp) print checkcode
shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutill 压缩模块（高级的文件，文件夹，压缩包，处理模块）
shutill.copyfileobj (将文件内容拷贝至另一个文件)
shutill.copyfile (拷贝文件)
shutill.copymode (仅拷贝权限，内容。组，用户均不变)
shutill.copystat (仅拷贝状态的信息)
shutill.copy(拷贝文件和权限)
shutill.copy2(拷贝文件和状态信息)
shutill.ignore_patterns
shutill.copytree
(递归的去拷贝文件夹)
shutill.rmtree(递归的去删除文件)
shuitll.move(递归的去移动文件，它类似mv命令，其实就是重命名)
shutill.make_archive(创建解压缩，并返回文件路径)
shutil.copyfileobj(fsrc, fdst[, length])（将文件内容拷贝到另一个文件中）
import shutil shutil.copyfileobj(open(\'old.xml\',\'r\'), open(\'new.xml\', \'w\'))
shutil.copyfile(src, dst)（拷贝文件）
shutil.copyfile(\'f1.log\', \'f2.log\') #目标文件无需存在
shutil.copymode(src, dst)（仅拷贝权限。内容、组、用户均不变）
shutil.copymode(\'f1.log\', \'f2.log\') #目标文件必须存在
shutil.copystat(src, dst)（仅拷贝状态的信息，包括：mode bits, atime, mtime, flags）
shutil.copystat(\'f1.log\', \'f2.log\') #目标文件必须存在
shutil.copy(src, dst)（拷贝文件和权限）
import shutil shutil.copy(\'f1.log\', \'f2.log\')
shutil.copy2(src, dst)(拷贝文件和状态信息)
import shutil shutil.copy2(\'f1.log\', \'f2.log\')
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None) (递归的去拷贝文件夹)
import shutil shutil.copytree(\'folder1\', \'folder2\', ignore=shutil.ignore_patterns(\'*.pyc\', \'tmp*\')) #目标目录不能存在，注意对folder2目录父级目录要有可写权限，
ignore的意思是排除
拷贝软链接 import shutil shutil.copytree(\'f1\', \'f2\', symlinks=True, ignore=shutil.ignore_patterns(\'*.pyc\', \'tmp*\')) \'\'\' 通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件 \'\'\'
shutil.rmtree(path[, ignore_errors[, onerror]])（递归的去删除文件）
import shutil shutil.rmtree(\'folder1\')
shutil.move(src, dst)（递归的去移动文件，它类似mv命令，其实就是重命名。）
import shutil shutil.move(\'folder1\', \'folder3\')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
创建压缩包并返回文件路径，例如：zip、tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#将 /data 下的文件打包放置当前程序目录 import shutil ret = shutil.make_archive("data_bak", \'gztar\', root_dir=\'/data\') #将 /data下的文件打包放置 /tmp/目录 import shutil ret = shutil.make_archive("/tmp/data_bak", \'gztar\', root_dir=\'/data\')
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
zipfile压缩解压缩
import zipfile # 压缩 z = zipfile.ZipFile(\'haha.zip\', \'w\') z.write(\'a.log\') z.write(\'data.data\') z.close() # 解压 z = zipfile.ZipFile(\'haha.zip\', \'r\') z.extractall(path=\'.\') z.close()
tarfile压缩解压缩 import tarfile # 压缩 >>> t=tarfile.open(\'/tmp/egon.tar\',\'w\') >>> t.add(\'/test1/a.py\',arcname=\'a.bak\') >>> t.add(\'/test1/b.py\',arcname=\'b.bak\') >>> t.close() # 解压 >>> t=tarfile.open(\'/tmp/egon.tar\',\'r\') >>> t.extractall(\'/egon\') >>> t.close()
json&pickle模块（序列化）
Python中用于序列化的两个模块
- json 用于【字符串】和 【python基本数据类型】 间进行转换
- pickle 用于【python特有的类型】 和 【python基本数据类型】间进行转换
Json模块提供了四个功能：dumps、dump、loads、load
pickle模块提供了四个功能：dumps、dump、loads、load
序列化和反序列化主要用于动态数据存储
pickle.dumps 序列化 内存-->硬盘
pickle.loads 反序列化 硬盘-->内存
什么是序列化？
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，
在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
为什么要序列化？
1：持久保存状态 2：跨平台数据交互
如何序列化之json和pickle：
json
json: 用于字符串和python数据类型间进行转换(更适合跨语言，字符串，基本数据类型)，
json 的写入是字符串形式用w模式,只支持序列化python的str,int,float,set,list,dict,tuple数据类型,但json可和其他语言序列化
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的javascript语言的对象，JSON和Python内置的数据类型对应如下：
import pickle dic={\'name\':\'alvin\',\'age\':23,\'sex\':\'male\'} print(type(dic))#<class \'dict\'> j=pickle.dumps(dic) print(type(j))#<class \'bytes\'> f=open(\'序列化对象_pickle\',\'wb\')#注意是w是写入str,wb是写入bytes,j是\'bytes\' f.write(j) #-------------------等价于pickle.dump(dic,f) f.close() #-------------------------反序列化 import pickle f=open(\'序列化对象_pickle\',\'rb\') data=pickle.loads(f.read())# 等价于data=pickle.load(f)通过loads反序列化时，一定要使用双引号，否则有可能会报错
print(data[\'age\'])
注意：
import json
#dct="{\'1\':111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{\'one\': 1}
dct=\'{"1":"111"}\'
print(json.loads(dct))
#conclusion:
# 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads
pickle
pickle: 用于python特有的类型和python的数据类型间进行转换（更适合所有类型的序列化，仅适用于python）
pickle的写入是二进制形式用wb模式,可以序列化python任何数据类型
import pickle dic={\'name\':\'gongxu\',\'age\':23,\'sex\':\'girl\'} print(type(dic))#<class \'dict\'> j=pickle.dumps(dic) print(type(j))#<class \'bytes\'> f=open(\'序列化对象_pickle\',\'wb\')#注意是w是写入str,wb是写入bytes,j是\'bytes\' f.write(j) #-------------------等价于pickle.dump(dic,f) f.close() #-------------------------反序列化 import pickle f=open(\'序列化对象_pickle\',\'rb\') data=pickle.loads(f.read())# 等价于data=pickle.load(f) print(data[\'age\'])
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
如下2个py文件功能是实现数据的动态存档
这个文件的作用,读取内存数据写入到db文件
import pickle #import json as pickle 这是用json执行 注意把wb改成w account={ "id":63232223, "credit":15000, "balance":8000, "expire_date":"2020-5-21", "password":"sdfsf" } f=open("account1.db","wb") f.write(pickle.dumps(account)) #相当于pickle.dump(account,f) f.close()
这个文件的作用,读取db文件写入到内存
import pickle #import json as pickle 这是用json执行 注意把rb改成r f=open("account1.db","rb") account=pickle.loads(f.read())#相当于account=pickle.load(f) print(account) print(account["id"]) #可以加如下,执行后注释 在执行看值是否改变 account["balance"]-=3400 f=open("account1.db","wb") f.write(pickle.dumps(account)) f.close()
shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve #内存写入db文件, 字典形式, f=shelve.open(r\'sheve.txt\') f["student1"]={"name":"egon","age":18,"height":"180cm"} print(f[\'student1\']) f.close() #读取db文件的数据 f=shelve.open(r\'sheve.txt\') print(f[\'student1\']) print(f[\'student1\']["name"]) f.close()
configparser（configparser用于处理特定格式的文件，其本质上是利用open来操作文件。(（把所有类型都当做字符串处理)）
getint 转换成整数
getfloat 转换成浮点数
getboolean 转换成布尔值
指定格式 # 注释1 ; 注释2
[section1] # 节点 k1 = v1 # 值 k2:v2 # 值 [section2] # 节点 k1 = v1 # 值
获取所有节点 import configparser
config = configparser.ConfigParser()
config.read(\'hahaha\', encoding=\'utf-8\')
ret = config.sections()
print(ret)
获取指定节点下所有的键值对 import configparser config = configparser.ConfigParser() config.read(\'hahaha\', encoding=\'utf-8\') ret = config.items(\'section1\') print(ret)
获取指定节点下所有的建 import configparser config = configparser.ConfigParser() config.read(\'hahaha\', encoding=\'utf-8\') ret = config.options(\'section1\') print(ret)
获取指定节点下指定key的值 import configparser config = configparser.ConfigParser() config.read(\'hahaha\', encoding=\'utf-8\') v = config.get(\'section1\', \'k1\') # v = config.getint(\'section1\', \'k1\') # v = config.getfloat(\'section1\', \'k1\') # v = config.getboolean(\'section1\', \'k1\')(v)