Python-常用模块

常用模块

python 提供了很多的常用模块，常用的有下面几个模块，关于日志的 日志模块 ，关于时间 time 和 datetime，关于操作系统 os 模块，关于匹配 re 正则表达式模块，关于随机数模块 random, 关于数学运算 math,后续模块会陆续补充

1. logging

logging 模块是 python 提供给用户做日志搜集, 日志输出这样的一个模块，在用 loggin模块之前我们需要了解 python 中的日志等级

等级	权重值	使用场景
NOTSET	0	不设置
DEBUG	10	程序出现了问题，用于打印详细信息
INFO	20	用于记录有价值的信息，可能后期会使用，或者节点信息
WARNING	30	程序能正常运行，但是可以预警一些事情
ERROR	40	程序部分不能运行，导致程序不能运行记录的信息
CRITICAL	50	程序崩溃，导致程序不能运行记录的信息

import logging


logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')

# 结果如下:
"""
WARNING:root:warning
ERROR:root:error
CRITICAL:root:critical
"""

logging 日志级别默认是 warning ,比 warning 级别低的默认是不记录的，修改日志级别的地方在 logging.basicConfig这个方法里level指定级别

1.1 logging 四大对象

在 logging 模块中需要我们关注的有四大对象， 产生日志的对象-logger, 处理日志对象-Handler, 过滤日志对象-Filter,格式化输出-Formatter
logger
logger就是程序可以直接调用的一个日志接口，可以直接向logger写入日志信息。logger并不是直接实例化使用的，而是通过logging.getLogger(name)来获取对象，事实上logger对象是单例模式，logging是线程安全的，也就是无论程序中哪里需要打日志获取到的logger对象都是同一个。logger不支持多进程

import logging

# 产生日志对象
logger = logging.getLogger('logger')

logger.info('info --> logger')
logger.debug('debug --> logger')
logger.warning('warning --> logger')
logger.error('error --> logger')
logger.critical('critical --> logger')

# 结果如下:
"""
warning --> logger
error --> logger
critical --> logger
"""

由于日志权限默认是 warning, debug 和 info 的信息是不输出的,logger收到日志信息后先判断是否符合level，如果决定要处理就将信息传递给Handlers进行处理。

Handler
handler 集中处理的地方，日志可以打印在终端，也可以保存到文件中，FileHandler 用来打印到文件中, StreamHandler 用来打印到终端,Handler 将 logger 发过来的 信息 进行准确地 分配，送往正确的地方 ,每个 Handler同样有一个日志级别，一个logger 可以拥有 多个handler 也就是说 logger可以根据不同的日志级别将日志传递给不同的handler 。当然也可以相同的级别传递给多个handlers这就根据需求来灵活的设置了

import logging

logger = logging.getLogger('logger')

"""
    将日志保存输出到文件：
    FileHandler类是将日志输出到文件的类， 
    def __init__(self, filename, mode='a', encoding=None, delay=False):
        pass
    需要传入文件名，mode代表写入模式 a 代表追加模式
"""
file_handler = logging.FileHandler('logger.log')


"""
    将日志保输出到终端：
    StreamHandler类是将日志输出到终端的类
    
"""

terminal_handler = logging.StreamHandler()

# 为 logger 增加 handler
logger.addHandler(file_handler)
logger.addHandler(terminal_handler)
# 设置日志等级
logger.setLevel(10)

# 测试
logger.debug('debug ---> logger')
logger.info('info ---> logger')
logger.warning('warning ---> logger')
logger.error('error -----> logger')
logger.critical('critical ---> logger')

# logger.log 和 终端 打印结果如下:
"""
debug ---> logger
info ---> logger
warning ---> logger
error -----> logger
critical ---> logger
"""

Filter

Filter 提供了 更细粒度的判断 ，来 决定日志是否需要打印 。原则上handler获得一个日志就必定会根据级别被统一处理，但是如果handler拥有一个Filter可以对日志进行额外的处理和判断,一般用的比较少

Formatter
Formatter是用于格式化日志输入的，可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式,

格式	描述
%(name)s	Logger的名字，并非用户名，详细查看
%(levelno)s	数字形式的日志级别
%(levelname)s	%(levelname)s
%(pathname)s	调用日志输出函数的模块的完整路径名，可能没有
%(filename)s	调用日志输出函数的模块的文件名
%(module)s	调用日志输出函数的模块名
%(funcName)s	调用日志输出函数的函数名
%(lineno)d	调用日志输出函数的语句所在的代码行
%(created)f	当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d	输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s	字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d	线程ID。可能没有
%(threadName)s	线程名。可能没有
%(process)d	进程ID。可能没有
%(message)s	用户输出的消息

import logging

logger = logging.getLogger('logger')

file_handler = logging.FileHandler('logger-formatter.log')

terminal_handler = logging.StreamHandler()

"""
    定义模版对象 formatter:
    class Formatter:
         def __init__(self, fmt=None, datefmt=None, style='%'):
            pass
    需要传入的 fmt, datefmt, fmt是格式样式， datefmt 是时间格式化样式
"""
file_formatter = logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

terminal_formatter = logging.Formatter(
    fmt='%(name)s-%(module)s: %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

# handler 对象设置 formatter 输出模版
file_handler.setFormatter(file_formatter)
terminal_handler.setFormatter(terminal_formatter)

# logger 对象设置 handler 日志处理器
logger.addHandler(file_handler)
logger.addHandler(terminal_handler)
logger.setLevel(10)

# 测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

"""
logger-04-logging-formatter: debug
logger-04-logging-formatter: info
logger-04-logging-formatter: warning
logger-04-logging-formatter: error
logger-04-logging-formatter: critical

"""

logging全局配置

logging模块的全局配置，可以在 logging.basicConfig() 函数中通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

import logging

# logging全局配置
logging.basicConfig(
    filename='logging-basicConfig.log',
    filemode='a',
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    level=10
)

# 产生 logger 对象
logger = logging.getLogger('logger-basicConfig')
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

# logger-basicConfig.log 结果如下:
"""
2020-04-15 09:55:33 AM - logger-basicConfig - DEBUG -05-logging-basicConfig:  debug
2020-04-15 09:55:33 AM - logger-basicConfig - INFO -05-logging-basicConfig:  info
2020-04-15 09:55:33 AM - logger-basicConfig - WARNING -05-logging-basicConfig:  warning
2020-04-15 09:55:33 AM - logger-basicConfig - ERROR -05-logging-basicConfig:  error
2020-04-15 09:55:33 AM - logger-basicConfig - CRITICAL -05-logging-basicConfig:  critical
"""

综合示例

import logging

# 1. 产生日志对西那个
logger = logging.getLogger('logger')

# 2. 定义 handler 对象
file_handler = logging.FileHandler('logger-exercise.log')
terminal_handler = logging.StreamHandler()
# handler 设置日志级别
terminal_handler.setLevel(20)

# 3. 定义 formatter 对象
file_formatter = logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)
terminal_formatter = logging.Formatter(
    fmt='%(name)s-%(module)s: %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

# 4. handler 对象设置 输出模版
file_handler.setFormatter(file_formatter)
terminal_handler.setFormatter(terminal_formatter)

# 5. logger 对象添加 handler 日志处理器
logger.addHandler(file_handler)
logger.addHandler(terminal_handler)

# 6. logger 对象设置日志级别
logger.setLevel(40)

# 7. 测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

logger是第一级过滤，然后才能到handler，我们可以给logger和handler同时设置level，但是需要注意的是,logger 先产生日志，logger 应该比 handler 低或者一样

日志继承

import logging

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                              datefmt='%Y-%m-%d %H:%M:%S %p', )

terminal_handler = logging.StreamHandler()
terminal_handler.setFormatter(formatter)

logger1 = logging.getLogger('root')
logger2 = logging.getLogger('root.child1')
logger3 = logging.getLogger('root.child1.child2')

logger1.addHandler(terminal_handler)
logger2.addHandler(terminal_handler)
logger3.addHandler(terminal_handler)
logger1.setLevel(10)
logger2.setLevel(10)
logger3.setLevel(10)

logger1.debug('log1 debug')
logger2.debug('log2 debug')
logger3.debug('log3 debug')
'''
2017-07-28 22:22:05 PM - root - DEBUG -test:  log1 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG -test:  log2 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG -test:  log2 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
'''

django日志配置

# 日志配置
LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    # 格式配置
    'formatters': {
        'simple': {
            'format': '%(asctime)s %(module)s.%(funcName)s: %(message)s',
            'datefmt': '%Y-%m-%d %H:%M:%S',
        },
        'verbose': {
            'format': ('%(asctime)s %(levelname)s [%(process)d-%(threadName)s] '
                    '%(module)s.%(funcName)s line %(lineno)d: %(message)s'),
            'datefmt': '%Y-%m-%d %H:%M:%S',
        }
    },
    # Handler 配置
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'level': 'DEBUG' if DEBUG else 'WARNING'
        },
        'info': {
            'class': 'logging.handlers.TimedRotatingFileHandler',
            'filename': f'{BASE_DIR}/logs/info.log',  # 日志保存路径
            'when': 'D',        # 每天切割日志
            'backupCount': 5,  # 日志保留 30 天
            'formatter': 'simple',
            'level': 'INFO',
        },
        'error': {
            'class': 'logging.handlers.TimedRotatingFileHandler',
            'filename': f'{BASE_DIR}/logs/error.log',  # 日志保存路径
            'when': 'W0',      # 每周一切割日志
            'backupCount': 4,  # 日志保留 4 周
            'formatter': 'verbose',
            'level': 'WARNING',
        }
    },
    # Logger 配置
    'loggers': {
        'django': {
            'handlers': ['console'],
        },
        'inf': {
            'handlers': ['info'],
            'propagate': True,
            'level': 'INFO',
        },
        'err': {
            'handlers': ['error'],
            'propagate': True,
            'level': 'WARNING',
        }
    }
}

2. random模块

random 是 python中一个随机数模块，常用的方法如下

方法	说明
random.random()	大于0且小于1之间的小数
random.randint(start, end)	大于等于 start 且小于等于 end 之间的整数
random.randrange(start,end)	大于等于 start 且小于 end 之间的整数
random.choice(iterable)	随机返回iterable中的元素
random.shuffle(iterable)	打乱iterable中的元素顺序
random.uniform(start, end)	大于 start 小于 end 的小数

import random

res = random.random()
print(res)
# 结果: 0.8060619496371143

res = random.randint(100, 1000)
print(res)
# 结果: 616

res = random.randrange(100, 1000)
print(res)
# 结果: 191

res = random.uniform(100, 1000)
print(res)
# 结果: 576.5857552312236

res = random.choice(['红楼梦', '百年孤独', '约翰.克里斯朵夫', '渴望生活'])
print(res)
# 结果: 约翰.克里斯朵夫

books = ['红楼梦', '百年孤独', '约翰.克里斯朵夫', '渴望生活']
random.shuffle(books)
print(books)
# 结果: ['渴望生活', '百年孤独', '约翰.克里斯朵夫', '红楼梦']

生成随机长度验证码

def gen_random_code(length=4):
    """
    产生一个指定长度的随机码
    :params length: 验证码长度
    :return v_code: 验证码
    """
    rand_num = random.randrange(0, 10 ** length)
    template = '%%0%sd' % length
    v_code = template % rand_num
    return v_code


v_code = gen_random_code(6)
print(v_code)
# 结果: 691925

3. os模块

os模块是一个python提供与操作系统交互的一个接口，常用方法如下
|属性|描述|

os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
s.chdir("dirname")	改变当前脚本工作目录；相当于shell下cd
os.curdir	返回当前目录: ('.')
os.pardir	获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')	可生成多层递归目录
os.removedirs('dirname1')	若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')	生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')	删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')	列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()	删除一个文件
os.rename("oldname","newname")	重命名文件/目录
os.stat('path/filename')	获取文件/目录信息
os.sep	输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep	输出当前平台使用的行终止符，win下为"\",Linux下为""
os.pathsep	输出用于分割文件路径的字符串 win下为:;,Linux下为:
os.name	输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")	运行shell命令，直接显示
os.environ	获取系统环境变量
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)	如果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.getatime(path)	返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)	返回path的大小

import os

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
print(BASE_DIR)

print(os.getcwd())
# 结果:  /Users/wuchang/Desktop/life/python/python/mine/action/python-基础入门/05-常用模块
print(os.environ)
# 结果:  environ({'PATH': .... 'HOME': '/Users/wuchang'})

if os.path.exists(BASE_DIR + '/03-os'):
    # 删除单极非空目录
    os.rmdir(BASE_DIR + '/03-os')

# 如果存在，会抛异常
os.mkdir('03-os')

if os.path.exists(BASE_DIR + '/03-os-os'):
    # 删除多层级目录，如果目录非空，抛出异常
    os.removedirs(BASE_DIR + '/03-os-os/03-os/03-os')

# 如果存在，会抛异常
os.makedirs('03-os-os/03-os/03-os')

# 列出该路径下的子目录和文件
path_list = os.listdir(BASE_DIR)
print(path_list)

if os.path.exists(BASE_DIR + '/test.py'):
    # 删除文件
    os.remove(BASE_DIR + '/test.py')

with open('test.py', 'w') as fw:
    fw.write('print("hello world")')

# 重命名文件和目录名字
os.renames(BASE_DIR + '/test.py', BASE_DIR + '/new_test.py')
os.renames(BASE_DIR + '/03-os', BASE_DIR + '/new-03-os')

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

# 将path分割成目录和文件名二元组返回
file_path = os.path.split(__file__)
print(file_path)

# 返回 文件的 目录
file_dir = os.path.dirname(__file__)
print(file_dir)

# 判断是否是目录
res = os.path.isdir(__file__)
print(res)

# 判断是否是文件
res = os.path.isfile(__file__)
print(res)

# 判断是否是绝对路径
res = os.path.isabs(__file__)
print(res)

# 路径拼接
file_path = os.path.join(BASE_DIR, 'new_test.py')
print(file_path)

递归显示当前路径下的所有文件

all_file = []

def show_file_path(dir_path):
    path_lists = os.listdir(dir_path)
    for path_item in path_lists:
        new_path = os.path.join(dir_path, path_item)
        if os.path.isdir(new_path):
            show_file_path(new_path)
        else:
            all_file.append(new_path)
    return all_file


show_file_path(BASE_DIR)
print(all_file)

4 time和datetime

time 和 datetime 是python用来处理时间模块的，在使用 time和datetime之前，必须要了解一个概念 时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型

time

属性	描述
time.time()	返回一个当前的时间戳
time.localtime()	返回一个 time.struct_time时间对象，里面有当前时间信息
time.strftime("%Y-%m-%d %X")	格式化时间
time.gmtime()	返回 UTC 时间

datetime

属性	描述
datetime.datetime.now()	获取当前时间
datetime.date.fromtimestamp(time.time())	时间戳直接转成日期格式
datetime.timedelta(num)	两个datetime之间的时间差

时间类型转换
timestamp <--> struct_time

localtime = time.localtime()
timestamp = time.mktime(localtime)
print(timestamp)
# 结果: 1586937108.0

timestamp = time.time()
localtime = time.localtime(timestamp)
print(localtime)
# 本地时区时间
# 结果: time.struct_time(tm_year=2020, tm_mon=4, tm_mday=15, tm_hour=15, tm_min=51, tm_sec=48, tm_wday=2, tm_yday=106, tm_isdst=0)

timestamp = time.time()
localtime = time.gmtime(timestamp)
print(localtime)
# UTC时间
# 结果: time.struct_time(tm_year=2020, tm_mon=4, tm_mday=15, tm_hour=7, tm_min=55, tm_sec=31, tm_wday=2, tm_yday=106, tm_isdst=0)

struct_time <--> format_time

localtime = time.strftime("%Y-%m-%d %X", time.localtime())
print(localtime)
# 结果:2020-04-15 16:03:09

struct_time = time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
print(struct_time)
# 结果: struct_time = time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')

• 常用时间的获取

# 返回今天开始的时间戳
today_start_timestamp = int(time.mktime(datetime.date.today().timetuple()))
print(today_start_timestamp)
# 今天日期
today = datetime.date.today()
# 昨天时间
yesterday = today - datetime.timedelta(days=1)
# 明天时间
tomorrow = today + datetime.timedelta(days=1)
acquire = today + datetime.timedelta(days=2)
# 昨天开始时间戳
yesterday_start_time = int(time.mktime(time.strptime(str(yesterday), '%Y-%m-%d')))
# 昨天结束时间戳
yesterday_end_time = int(time.mktime(time.strptime(str(today), '%Y-%m-%d'))) - 1
# 今天开始时间戳
today_start_time = yesterday_end_time + 1
# 今天结束时间戳
today_end_time = int(time.mktime(time.strptime(str(tomorrow), '%Y-%m-%d'))) - 1
# 明天开始时间戳
tomorrow_start_time = int(time.mktime(time.strptime(str(tomorrow), '%Y-%m-%d')))
# 明天结束时间戳
tomorrow_end_time = int(time.mktime(time.strptime(str(acquire), '%Y-%m-%d'))) - 1

5. pickle

基本的数据序列和反序列化。通过pickle模块的 序列化操作 我们能够将程序中运行的对象信息 保存到文件中去，永久存储；通过 pickle模块的 反序列化操作，我们能够从文件中 创建上一次程序保存的对象

序列化到文件

import pickle

books = ['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南']

with open('books', 'wb') as fw:
    pickle.dump(books, fw)


with open('books', 'rb') as fr:
    books = pickle.load(fr)
    print(books, type(books))
    
# 结果: ['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南'] <class 'list'>

序列化到内存

movies = {
    'china': ['霸王别姬', '一一', '牯岭街少年杀人事件', '让子弹飞'],
    'usa': ['美国往事', '爱尔兰人', '七宗罪', '阿凡达'],
    'japan': ['海街日记', '东京物语', '秋刀鱼之味', '被嫌弃的松子的一生'],
    'books': books
}

movies = pickle.dumps(movies)
print(type(movies))
# 结果: <class 'bytes'>

movies = pickle.loads(movies)
print(movies, type(movies))
# 结果:{'china': ['霸王别姬', '一一', '牯岭街少年杀人事件', '让子弹飞'], 'usa': ['美国往事', '爱尔兰人', '七宗罪', '阿凡达'], 'japan': ['海街日记', '东京物语', '秋刀鱼之味', '被嫌弃的松子的一生'], 'books': ['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南']} <class 'dict'>

pickle.dumps 序列化到内存中是一个 bytes 类型

6. json

json是python中常用的模块，经常用于数据之间的转换，json字符串 到 python 对象的转换,常用方法如下:

序列化到文件

"""
    参数说明:
        ensure_ascii：默认True，保证转换后的json全是ascii字符，非ascii字符都会被转义。
                        如果数据中包含中文或非ascii字符，最好将ensure_ascii设置为False，保证输出结果正常。
        indent：缩进，默认None，没有缩进，设置为正整数，输出格式会按指定的半角空格数缩进。
        separators：设置分隔符，默认分隔符为(,和:)
        sort_keys：默认False，输出结果是否按照字典中的key进行排序
"""
import json

movies = {
    'china': ['霸王别姬', '一一', '牯岭街少年杀人事件', '让子弹飞'],
    'usa': ['美国往事', '爱尔兰人', '七宗罪', '阿凡达'],
    'japan': ['海街日记', '东京物语', '秋刀鱼之味', '被嫌弃的松子的一生'],
    'books':['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南']
}
with open('movies.json', 'w+') as fw:
    json.dump(movies, fw, ensure_ascii=False, indent=4, separators=',:', sort_keys=True)


with open('movies.json', 'r+') as fp:
    dict_movies = json.load(fp)
    print(type(movies), movies)
# 结果: <class 'dict'> {'books': ['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南'], 'china': ['霸王别姬', '一一', '牯岭街少年杀人事件', '让子弹飞'], 'japan': ['海街日记', '东京物语', '秋刀鱼之味', '被嫌弃的松子的一生'], 'usa': ['美国往事', '爱尔兰人', '七宗罪', '阿凡达']}

序列化到内存

import json

movies = {
    'china': ['霸王别姬', '一一', '牯岭街少年杀人事件', '让子弹飞'],
    'usa': ['美国往事', '爱尔兰人', '七宗罪', '阿凡达'],
    'japan': ['海街日记', '东京物语', '秋刀鱼之味', '被嫌弃的松子的一生'],
    'books':['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南']
}

json_movies = json.dumps(movies, ensure_ascii=False, indent=4, separators=',:', sort_keys=True)
print(json_movies)
# 结果如下:
"""
{
    "books":[
        "javascript权威指南",
        "css权威指南",
        "现代操作系统",
        "HTTP权威指南"
    ],
    "china":[
        "霸王别姬",
        "一一",
        "牯岭街少年杀人事件",
        "让子弹飞"
    ],
    "japan":[
        "海街日记",
        "东京物语",
        "秋刀鱼之味",
        "被嫌弃的松子的一生"
    ],
    "usa":[
        "美国往事",
        "爱尔兰人",
        "七宗罪",
        "阿凡达"
    ]
}
"""

dict_movies = json.loads(json_movies)
print(dict_movies)
# 结果: {'books': ['javascript权威指南', 'css权威指南', '现代操作系统', 'HTTP权威指南'], 'china': ['霸王别姬', '一一', '牯岭街少年杀人事件', '让子弹飞'], 'japan': ['海街日记', '东京物语', '秋刀鱼之味', '被嫌弃的松子的一生'], 'usa': ['美国往事', '爱尔兰人', '七宗罪', '阿凡达']}

7. hashlib

hashlib 模块是python中的一个加密模块, 这个模块针对不同的安全哈希和消息摘要算法实现了一个通用的接口。包括 FIPS 的 SHA1 等软法, 以及 RSA 的 MD5 算法

md5加密

import hashlib

password = 'hello world'
h_md5 = hashlib.md5()
h_md5.update(password.encode('utf-8'))
new_password = h_md5.hexdigest()

print(new_password)
# 结果: 5eb63bbbe01eeed093cb22bb8f5acdc3

SHA1

import hashlib
password = 'hello world'
sha1 = hashlib.sha1()
sha1.update(password.encode('utf-8'))
new_password = sha1.hexdigest()

print(new_password)
# 结果: 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed