16-python-bao

2020-05-19 09:54:09 作者：互联网

# 序列化：转向一个字符串数据类型
# 序列：字符串

# 写文件
# 网络上传输的时候
# 从数据类型 --> 字符串的过程 序列化
# 从字符串 --> 数据类型的过程 反序列化

# json：通用的序列化格式，只有很少的一部分数据类型通过json转化成字符串
# pickle：所有的python中的数据类型都可以转化成字符串形式，但是只有python能理解，切部分反序列化以来代码
# shelve：序列化句柄直接操作，非常方便。

# json dumps loads 数字、字符串、列表、字典、元祖（序列化和反序列化会变成list），操作内存中的数据
'''
import json
dic = {'k1': 'v1'}
print(type(dic), dic)
str_d = json.dumps(dic)             # 序列化
print(type(str_d), str_d)
dic_d = json.loads(str_d)
print(type(dic_d), dic_d)
'''

# json dump load 操作文件，只能一次性的写进去，一次性的读出来
'''
import json
dic = {'k1': '中国'}
f = open('a', mode='w', encoding='utf-8')
json.dump(dic, f, ensure_ascii=False)               # 默认True
f = open('a', mode='r', encoding='utf-8')
res = json.load(f)
f.close()
print(type(res), res)
'''

# 会报错
'''
import json
dic = {'k1': '中国'}
f = open('a', mode='w', encoding='utf-8')
# json.dump(dic, f, ensure_ascii=False)               # 默认True
# json.dump(dic, f, ensure_ascii=False)               # 默认True

f = open('a', mode='r', encoding='utf-8')
res = json.load(f)
f.close()
print(type(res), res)
'''

# json
# dumps {} --> '{}\n'
# 一行一行的度
# '{}\n'
# '{}' loads
'''
import json
f = open('file', mode='w', encoding='utf-8')
l1 = []
# l = [{'k1': '1'}, {'k2': '2'}, {'k2': '2'}]
# for dic in l:
#     str_dic = json.dumps(dic)
#     f.write(str_dic+'\n')
for line in f:
    dic = json.loads(line.strip())
    l1.append(dic)
f.close()
print(l1)
'''

# pickle：
import pickle
import time
'''
dic = {'k1': '中国'}
str_dic = pickle.dumps(dic)
print(str_dic)

dic2 = pickle.loads(str_dic)
print(dic2)

dic = {'k1': '中国'}
# f = open('pickle_file', mode='wb')
# pickle.dump(dic, f)

f = open('pickle_file', mode='rb')
res = pickle.load(f)
f.close()
print(res)

# 分布load
struct_time1 = time.localtime(1000000000)
struct_time2 = time.localtime(2000000000)
f = open('pickle_file', mode='wb')
pickle.dump(struct_time1, f)
pickle.dump(struct_time2, f)
f.close()

f1 = open('pickle_file', 'rb')
struct_time11 = pickle.load(f1)
struct_time22 = pickle.load(f1)
print(struct_time11.tm_year)
print(struct_time22.tm_year)
'''

# shelve：限制不能多个应用同一时间往同一个db进行写操作
'''
import shelve
f = shelve.open('shelve_file')
f['key'] = {'int': 10, 'float': 9.5, 'string': 'asd'}
f.close()
f1 = shelve.open('shelve_file')
existing = f1['key']    # 去除数据直接使用key可以获取，但是如果key不存在会报错
f1.close()
print(existing)
'''

# 找到模块
# 先从sys.modules里查看是否已经被导入
# 如果没有被导入，就一句sys.path路径去寻找模块
# 找到了就导入，创建这个模块的命名空间
# 创建这个模块的命名空间
# 把文件中的名字都放到命名空间里
# import model_02
# model_02.read1()
# print(model_02.money)

# import model_02
# import sys
# print(sys.modules.keys())
# print(sys.path)

# import time as t
# print(t.time())

# 连接数据库
# 登陆认证
# 增删改查
# 关闭数据库

# 所有的模块导入都应该尽量网上写
# 导入顺序：内置-->扩展django-->自定义

# 单独从某个模块中导入一个方法或者变量
# from time import sleep
# sleep(2)

# 导入模块中的所有方法
from time import *

# import
# 模块名，变量名和本文件重的变量名完全不冲突
# import 模块名 as 重命名的模块名：提高代码的兼容性
# import 模块1，模块2

# from import
# from 模块名 import 变量名
# 直接使用变量名就可以完成操作
# 但是如果本文件中有相同的变量名会发生冲突
# from 模块名 import 变量名字 as 重命名变量名
# from 模块名 import *：将所有模块中的额所有变量名都放到内存中，如果本文件中有相同的变量名会发生冲突
# from 模块名 import * 和 __all__是一对
# 如果 没有这个变量就会导入所有的名字
# 如果有all只导入列表中的名字

# 在模块中有一个变量：__name__。当直接执行这个模块时，这个变量的值为__main__。
# 当在其他模块中引用这个模块时，这个变量就等于模块的名字。

# 包：一大堆模块的集合

# 把解决一类问题的模块放在同一个文件夹里 --> 包
# import os
# os.makedirs('glance/api')
# os.makedirs('glance/cmd')
# os.makedirs('glance/db')
# l = []
# l.append(open('glance/__init__.py', 'w'))
# l.append(open('glance/api/__init__.py', 'w'))
# l.append(open('glance/api/policy.py', 'w'))
# l.append(open('glance/api/versions.py', 'w'))
# l.append(open('glance/cmd/__init__.py', 'w'))
# l.append(open('glance/cmd/manage.py', 'w'))
# l.append(open('glance/db/models.py', 'w'))
# map(lambda f: f.close(), l)

# import glance.api.policy
#
# glance.api.policy.get()

# from glance.api import policy
# policy.get()

# 还可以在sys.path中append一个路径

# import glance
# glance.api.policy.get()

# 绝对路径：不能挪动，但是直观，不管在包内部还是外部，导入即可使用
# 相对路径：可以挪动，但是不直观，且不能在包里直接调用模块

标签：16,python,dic,模块,import,print,bao,glance,open
来源： https://www.cnblogs.com/Daspig/p/12915179.html