python 对象序列化xml_Python_基础_(模块，time，random，os，sys，json，shelve，xml，序列化反序列化)...

一，Import的基本用法

import

1.执行对应的文件

2.引入变量名

3.当一个文件被import，索贝import中的代码会被执行一遍，例如当 import cal  ##cla中有inport("xxx")，则会输出

## Import引用方法

#cal.py文件中

defadd(x,y)return x +y

#test.py文件中#引用方法1

importcalprint(cal.add(1,2)) #如果用import直接引用，则只能用cal.add方式调用add方法

#引用方法2

from cal importaddprint(add(1,2)) #直接可以使用add方法

## import的路径问题

1.例如当文件test.py执行时，会将自己的上层目录传到sys.path中，通过上层目录可找到下层的目录文件

2.当前的执行文件为test.py，且test.py所在的文件夹为Hello，则文件Hello为sys.path中唯一识别的路径，只能通过该路径进行查找其它所要引入的文件

## 多个文件嵌套问题

add为cal.py中的方法，cal.py在文件dir2中，dir2在dir1中，dir1在dir中

#方法1

from dir.dir1.dir2 importcalprint(cal.add(1,2))#方法2

from dir.dir1.dir2.cal importaddprint(add(2,3))#方法3(不建议使用)

from dir.dir1 importdir2print(dir2.cal.add (3,4))

## __name__ 的作用

1，当在执行文件中直接执行 print(__name__) 　　　　　  　# 输出字符串 __main__

2，当在调用文件(在cal文件中)中执行 print(__name__) 　# 输出的为当引用文件的路径  dir.dir1.dir2.cal

3，判断文件是否为执行文件 if __name__ = "__main__" 　　# 如果当前的文件为执行文件

二，各个模块

模块：功能模块是指数据说明、可执行语句等程序元素的集合，它是指单独命名的可通过名字来访问的过程、函数，子程序或宏调用。功能模块化是将程序划分成若干个功能模块，每个功能模块完成了一个子功能，再把这些功能模块总起来组成一个整体。以满足所要求的整个系统的功能。

## time模块

#时间戳

time.time() #1543898846.79 表示从1970.1.1经历的秒数(1970是unix诞生日期)

#结构化时间当地时间

time.localtime() #得到一个结构化时间(可以操作具体的某个值)#time.struct_time(tm_year=2018, tm_mon=12, tm_mday=18, tm_hour=15, tm_min=2, tm_sec=59, tm_wday=1, tm_yday=352, tm_isdst=0)

t=time.localtime()print(t.tm_yday) #显示tm_yday 325

#结构化时间，世界标准时间UTC

time.gmtime()#time.struct_time(tm_year=2018, tm_mon=12, tm_mday=18, tm_hour=7, tm_min=6, tm_sec=0, tm_wday=1, tm_yday=352, tm_isdst=0)

#将时间戳转成结构化时间

time.localtime(time.time())

#将结构化时间转为时间戳

time.mktime(time.localtime())

#将结构化时间转换成字符串时间

time.strftime("%Y-%m-%d %X",time.localtime()) #%X代表 时分秒 2018-12-18 15:08:43

#将字符串时间转为结构化时间

time.strptime("2018:10:10:10:10:10","%Y:%m:%d:%X")#time.struct_time(tm_year=2018, tm_mon=10, tm_mday=10, tm_hour=10, tm_min=10, tm_sec=10, tm_wday=2, tm_yday=283, tm_isdst=-1)

#线程推迟指定是将执行，单位秒

time.sleep(x)

importdatetime()print(datetime.datetime()) #显示为 2016-12-12 17.50.36.316449

## random模块

random.random() #生成0~1的浮点数

random.randint(1,5) #[1,5]

random.randrange(1,5) #[1,5)

random.choice([11,22,33]) #对可迭代对象中的元素中的进行随机取得

random.sample(([11,22,33,44]),2) #随机在可迭代对象中选取两个

random.uniform(1,3) #取得范围中随机的浮点型 2.4779013205711236

ret= [12,3,4,5,6]

random.shuffle(ret)#进行随机排列

print(ret)

#随机验证码

importrandomdefverofication():

res= ""

for i in range(5):

num= random.randint(0,9)

letter= chr(random.randint(61,122))

code=str(random.choice([num,letter]))

res+=codereturnresprint(verofication())

## os模块

os.getcwd() #获取当前的工作路径

os.chdir("dirname") #改变当前的工作目录，在原本目录下添加新的目录

os.curdir#返回当前目录

os.pardir#".." 获取当前目录的父目录字符串名

os.makedirs('name1/name2') #可生成多层递归目录

os.removedirs('name') #若该目录为空，则删除，并递归到上一级目录，如若也为空，则删除

os.mkdir('dirname') #生成单级目录

os.rmdir('dirname') #删除单级空目录，若目录不为空则无法删除，报错

os.listdir('dirname') #列出指定目录下的所有文件和子目录，包括隐藏文件，以列表方式输出

os.remove("name") #删除一个文件

os.rename("old","new") #重命名文件或目录

os.stat('path/filename') #获取文件或目录信息

#输出中有文件创建时间，文件修改时间

os.sep#输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"(使用sep方便与在win与Linux中转换程序)

os.linesep #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"

os.pathsep#输出用于分割文件路径的字符串 win下为";",Linux下为":",环境变量中的分割方式

os.name#输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command") #运行shell命令，直接显示

os.environ#获取系统环境变量path环境变量

os.path.abspath(path)#返回path规范化的绝对路径

os.path.split(path)#将path分割成目录和文件名二元组返回，将文件路径和文件名分开

os.path.dirname(path)#返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)#返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path)#路径如果存在，返回True；如果path不存在，返回False

os.path.isabs(path)#如果path是绝对路径，返回True

os.path.isfile(path)#如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path)#如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]])#将多个路径组合后返回，第一个绝对路径之前的参数将被忽略os.path.join(a,b) # 将路径a 和路径b拼接起来

os.path.getatime(path)#文件或者目录的最后存取时间

os.path.getmtime(path)#文件或者目录的最后修改时间

## sys模块

sys.argv #['F:/Python_Project/Test/sys模块.py'] 命令行参数List，第一个元素是程序本身路径

sys.exit(n) #退出程序，正常退出时exit(0)

sys.version #获取Python解释程序的版本信息

3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)]

sys.maxint #最大的Int值

sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值['F:\\Python_Project\\Test',

'F:\\Python_Project\\Test',

'F:\\Python_Project\\Test\\Scripts\\python37.zip',

'C:\\Python3\\DLLs', 'C:\\Python3\\lib',

'C:\\Python3',

'F:\\Python_Project\\Test\\lib\\site-packages',

'F:\\Python_Project\\Test\\lib\\site-packages\\setuptools-39.1.0-py3.7.egg',

'F:\\Python_Project\\Test\\lib\\site-packages\\pip-10.0.1-py3.7.egg',

'D:\\Software\\PyCharm 2018.2.2\\helpers\\pycharm_matplotlib_backend']

sys.platform #win32 返回操作系统平台名称，不同的平台显示不同的值(判断什么系统，执行什么操作)

## 进度条

importsys,timefor i in range(50):

sys.stdout.write("#")

time.sleep(2)

sys.stdout.flush()#刷新

## json模块

# json可以进行任何语言间的数据交换

1：将数据中的单引号或三引号转为双引号

2：将dic转成json类型字符串

3：所有的数据类型均可以转为json类型字符串

importjson

dic= {'name':'henry'}

data=json.dumps(dic)print(data) #{"name": "henry"}

print(type(data)) #

# 将json类型的字符串重新转为字典类型

new_data =json.loads(data)print(new_data) #{'name': 'henry'}

print(type(new_data)) #

# dumps与loads的用法

#写：将一个字典转成json形式字符串再写到文件hello中

dic = {"name":"henry"}

f= open("hello","w")

dic_str=json.dumps(dic)

f.write(dic_str)

#读：将文件hello中的字符串数据读取出来，并转成字典形式

f_read = open("hello","r")

data=json.loads(f_read.read())print(data) #{'name': 'henry'}

# dump与load用法

#写

dic = {"name":"henry"}

f= open("hello","w")

json.dump(dic,f)#一步相当于做了两件事

#读

f_read = open("hello","r")

data= json.load(f_read) #一步相当于两步

print(data)

## 注：dumps与loads不一定要配合使用，当文件中的数据没以dumps写入，但格式符合json规范(以双引号包含)，用loads就能进行读取

## pickle模块

1：pickle在使用上与json并无区别，有四个方法 dumps loads dump load

2：pickle的区别：json序列化后为字符串，pickle序列化后为字节形式

3：pickle支持的数据类型更多，pickle可以序列化函数，类...

## 序列化与反序列化

序列化：将对象或变量从内存中变为可存储或可传输的过程称为序列化

反序列化：将变量或内容从序列化的对象重新读到内存中的过程称为反序列化

json：

如果要在不同的编程语言中进行传递对象，就必须将对象序列化为标准格式，比如XML，但更好的是将其序列换为JSON，因为利用Json序列后的对象就是一个字符串格式，能被所有的编程语言进行读取，也方便进行存储或进行传输，Json为标准格式，且传输的熟读比XML块

#序列化

dic = {"name":"henry"}

f= open("hello","w")

dic_str=json.dumps(dic)print(dic_str)　　　　#

f.write(dic_str)

#反序列化

f_read = open("hello","r")

data=json.loads(f_read.read())print(data)　　　　　　#

print(data) #{'name': 'henry'}

##shelve模块

在使用json或pickle来进行存储数据时，能dump多次，当load只能取到最新的dump数据，因为先前的数据已经被覆盖掉了，这里就能使用到shelve模块

shelve模块可以持久化所有pickle支持的数据类型

# 数据持久化

importshelve,datetime

dic_list= {"name":"henry","age":18} #字典

list_list = ["Python","Java","C++"] #列表

t = datetime.datetime.now() #时间类型

with shelve.open("test_shelve") as f:

f["dic_list_t"] =dic_list

f["list_list_t"] =list_list

f["t_t"] =t

f.close()

# 执行代码后产生三个文件

#test_shelve.bak

'dic_list_t', (0, 43)'list_list_t', (512, 42)'t_t', (1024, 44

#test_shelve.dat

�}q (X nameqX henryqX ageqKu.

�]q (X PythonqX JavaqX C++qe.

�cdatetime

datetime

q C

�4��q�qRq.

#test_shelve.dir

'dic_list_t', (0, 43)'list_list_t', (512, 42)'t_t', (1024, 44)

# 用get进行读取

with shelve.open("test_shelve") as f:print(f.get("dic_list_t"))print(f.get("list_list_t"))print(f.get("t_t"))

## xml模块

# test_xml.xml文件中的内容

2

2008

141100

5

2011

59900

69

2011

13600

# 获取文档树的跟

importxml.etree.ElementTree as ET

tree= ET.parse("test_xml.xml")

root= tree.getroot() #获得文档树的根data

print(root) #

# 遍历xml文档

for child inroot:print(child.tag,child.attrib) #child.tag为root下一层标签名，child.attrib为root下一层中所有的属性及名称

for i inchild:print(i.tag,i.attrib)　　　　#i.tag为child下一层标签名，i.attrib为child下一层中所有的属性及名称#输出

country {'name': 'Liechtenstein'}

rank {'updated': 'yes'}

year {}

gdppc {}

neighbor {'name': 'Austria', 'direction': 'E'}

neighbor {'name': 'Switzerland', 'direction': 'W'}

country {'name': 'Singapore'}

rank {'updated': 'yes'}

year {}

gdppc {}

neighbor {'name': 'Malaysia', 'direction': 'N'}

country {'name': 'Panama'}

rank {'updated': 'yes'}

year {}

gdppc {}

neighbor {'name': 'Costa Rica', 'direction': 'W'}

neighbor {'name': 'Colombia', 'direction': 'E'}

# 中遍历xml文件中的year节点

for i in root.iter("year"):print(i.tag,i.text) #节点名称 节点值

#输出

year 2008year2011year2011

# 修改标签的值

for i in root.iter("year"):

new_year= int(i.text) + 1i.text=str(new_year)

tree.write("test_xml.xml")　#将修改后的数据重新写到新的文件中，可以以原文件同名

# 给标签添加属性和值

for i in root.iter("year"):

i.set("new_attrib","new_value")

tree.write("test_xml.xml")#修改后的值

2008

2011

2011

# 删除

for countr in root.findall("country"):

rank= int(countr.find("rank").text)if rank > 50:

root.remove(countr)

tree.write("test_xml.xml")

# 创建一个xml文件

importxml.etree.ElementTree as ET

new_xml= ET.Element("root_name")　　#根节点

name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})

age= ET.SubElement(name,"age",attrib={"cheeked":"no"})

sex= ET.SubElement(name,"sex")

sex.text= "男"name= ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})

age= ET.SubElement(name,"age",attrib={"cheeked":"yes"})

age.text= "18"sex= ET.SubElement(name,"sex")

sex.text= "女"et= ET.ElementTree(new_xml)　　#生成文档对象

et.write("text.xml",encoding="UTF-8",xml_declaration=True)#文件名，字符编码，是否显示头信息

## re模块(正则表达式)