python常用内置模块(colletions/time/random/os/sys/json)

目录

• python常用内置模块
  • collections模块
  • 时间模块time\datetime
  • 随机数模块random
  • os与sys模块
    • os模块（重要）
    • sys模块
  • json模块
    • json实战案例
    • json模块补充说明

python常用内置模块

为何使用模块？

我们将定义好的变量、函数等编写好的程序文件永久保存下来，需要时就通过python test.py方式去反复执行，此时test.py称为脚本script.

常用的内置数据有

常见的内置数据类型：
	dict、list、set、tuple
collections模块还提供了几个数据类型：
	1.Counter     计时器，主要用来计数
	2.deque        双端队列，可以快速的从另外一侧追加和推出对象
	3.defaultdict  带有默认值的字典
	4.namedtuple   生成可以使用名字访问元素内容的tuple
	5.OrderDict    有序字典

collections模块

​ 1.具名元组：namedtuple

eg1:表示二维坐标系
    from collections import namedtuple
    point = namedtuple('点',['x','y'])
    # 生成点的信息
    p1 = point(120,110)
    print(p1)  # 点(x=120, y=110)
    print(p1.x)  # 120
    print(p1.y)  # 110


eg2:扑克牌游戏
    from collections import namedtuple
    game = namedtuple('扑克牌',['number','color'])
    g1 = game('k','红♥')
    g2 = game('3','梅花♣')
    print(g1)  # 扑克牌(number='k', color='红♥')
    print(g2)  # 扑克牌(number='3', color='梅花♣')
    print(g1,g1.number,g1.color)  # 扑克牌(number='k', color='红♥') k 红♥
    print(g1,g2.number,g2.color)  # 扑克牌(number='k', color='红♥') 3 梅花♣
    
    
eg3: 用坐标和半径表示一个圆，也可以用namedtuple定义
    # namedtuple('名称',[属性list])
    Cirle = namedtuple('Cirle',['x','y','r'])
    c = Cirle('2','3','1')
    print(c)  # Cirle(x='2', y='3', r='1')
    print(c.x)  # 2
    print(c.y)  # 3
    

2.deque 双端队列

队列和堆栈
	队列：先进先出
	堆栈：先进后出
队列和堆栈都是一边只能进一边只能出
队列通常是在入队时在队尾添加元素，在出队时，队头弹出元素，而双端队列没有这样的输入输出的限制.这里collections模块中的deque就是双端队列。

使用list 存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，这个时候引入了deque，可以高效的帮助我们插入和删除列表，适合用于队列和栈

	from collections import  deque  # 导入deque功能
	q1 = deque(['a','s','d'])  # 定义一个含元素的列表
	q1.append('B')  # 添加元素
	print(q1)  # deque(['a', 's', 'd', 'B'])
	q1.appendleft('H')
	print(q1)  # deque(['H', 'a', 's', 'd', 'B']) 左边添加元素

	print(q1.pop())  # B
	print(q1.popleft())  # H

3.OrderedDict 有序字典

​ 使用dict,key是无序的，在对dict做迭代时，我们无法确定key的顺序，此时我们使用collection的OrderedDict,可以保持字典的键是有序的

	from collections import OrderedDict
	d = dict([('a',1),('b',2),('c',3)])
	print(d)  # {'a': 1, 'b': 2, 'c': 3}  字典的key是无序的
	d1 = OrderedDict([('a',1),('b',2),('c',3)])
	print(d1)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])  OrderedDict的key是有序的  

	注意：OrderedDict 的key会按照插入的顺序排列，不是key本身排列

4.defaultdict 默认字典

使用dict时，如果引用的Key不存在，就会抛出KeyError。

如果希望key不存在时，返回一个默认值，就可以用`defaultdict：

	from collections import defaultdict
	dd = defaultdict(lambda: 'N/A')
	dd['key1'] = 'abc'
	dd['key1'] # key1存在
	# 'abc'
	dd['key2'] # key2不存在，返回默认值
	# 'N/A'

练习题

有一个列表，l1 = [11,22,33,44,566,77,88,55,99,88]，将所有大于66的值保存字典的第一个key值，剩下的存放于字典的第二个key值

	from collections import defaultdict
	l1 = [11,22,33,44,566,77,88,55,99,88]
	dict1 = defaultdict(list)
	print(dict1)  # defaultdict(<class 'list'>, {})

	for i in l1:
		if i >66:
			dict1['k1'].append(i)
		else:
			dict1['k2'].append(i)

	print(dict1)  # defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55], 'k1': [566, 77, 88, 99, 88]})

时间模块time\datetime

time模块

三种时间表现形式
    1.时间戳
        秒数
    2.结构化时间
        主要是给计算机看的，人看不适应
    3.格式化时间
        主要是给人看的
    Y	m	d	H	M	S	X
    年	月	日	时	分	秒	时:分:秒

代码实现：

# 导入时间模块
	import time

# 时间戳
	time.time()
	print(time.time())  # 1666165810.4114015

# 时间字符串
	print(time.strftime('%Y-%m-%d'))  # 2022-10-19
	print(time.strftime('%Y/%m/%d'))  # 2022/10/19
	print(time.strftime('%Y/%m/%d  %H:%M:%S'))  # 2022/10/19  15:56:52
	print(time.strftime('%Y/%m/%d  %X'))  # 2022/10/19  15:56:52


# 时间元组：localtime将一个时间戳转换成当前时区的struct_time
	print(time.localtime())  
        """     
        打印结果为
        time.struct_time(tm_year=2022, tm_mon=10, 
        tm_mday=19, tm_hour=15, tm_min=59, tm_sec=13, 
        tm_wday=2, tm_yday=292, tm_isdst=0)
        """
        
        
 # 让程序原地阻塞指定的秒数
  	time.time(8)  
  
  
  注意：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

datetime模块

1.两种导入方式获取查看当地时间

"""  datetime"""
# 方式一：获取当前的datetime
    from datetime import datetime
    a = datetime.now()
    print('当前日期：',a)  # 当前日期： 2022-10-19 16:16:16.266254
    c = datetime.utcnow()
    print('世界时间：',c)  # 世界时间： 2022-10-19 08:20:13.713343


# 方式二：获取当前的datetime
    import datetime
    b = datetime.datetime.now()
    print('当前日期：',b)  # 当前日期： 2022-10-19 16:16:16.266254
    print(datetime.datetime.today())  # 2022-10-19 16:17:29.847966
    print(datetime.date.today())  # 2022-10-19

2.同时导入date和datetime

datetime  年月日  时分秒
date      年月日 
time      时分秒（后续会有此规律）

from datetime import date,datetime
print(date.today())  # 2022-10-19
print(datetime.today())  # 2022-10-19 16:27:29.955615

3.用指定日期时间创建datetime

import datetime
t = datetime.datetime(2008,8,8,8,8,8)  # 不能填零
print('指定日期：',t)  # 指定日期： 2008-08-08 08:08:08

4.将字符串转换成datetime类型

将下列的字符串转成为datetime类型
""" 
'2008/8/8'
'2016年9月13日星期六'
'2020年6月24日星期六6时6分6秒'
'10/19/2022'
'10/19/2022 8:42:12'
"""

import datetime
t1 = datetime.datetime.strptime('2008/8/8','%Y/%m/%d')
print(t1)   # 2008-08-08 00:00:00
t2 = datetime.datetime.strptime('2016年9月13日星期六','%Y年%m月%d日星期六')
print(t2)  # 2016-09-13 00:00:00
t3 = datetime.datetime.strptime('2020年6月24日星期六6时6分6秒','%Y年%m月%d日星期六%H时%M分%S秒')  # 数字必须写阿拉伯数字
print(t3)  # 2020-06-24 06:06:06
t4 = datetime.datetime.strptime('10/19/2022','%m/%d/%Y')
print(t4)  # 2022-10-19 00:00:00
t5 = datetime.datetime.strptime('10/19/2022 8:42:12','%m/%d/%Y  %H:%M:%S')
print(t5)  # 2022-10-19 08:42:12

5.将datetime类型转换为字符串

"""
2008年8月8日星期六，18时18分18秒
Saturday,September 30,2010
8/30/2021  18:30 AM
June 30,2021
"""

from datetime import datetime
t1 = datetime(2008,8,8,18,18,18)
print(t1.strftime('%Y年%m月%d日%A,%H时%M分%S秒'))  # 2008年08月08日Friday,18时18分18秒
print(t1.strftime('%A,%B %d,%Y'))  # Friday,August 08,2008
t2 = datetime(2021,8,30,8,30,34)
print(t2.strftime('%m/%d/%Y %I:%M:%S%p'))  # 08/30/2021 08:30:34AM
print(t2.strftime('%m/%d/%Y %H:%M:%S'))  # 08/30/2021 08:30:34
t3 = datetime(2021,6,30)
print(t3.strftime('%B %d %Y'))  # June 30 2021

6.代码是如何将时间进行天数或者秒数的相加

import datetime
t1 =  datetime.date.today()
print(t1)   # 2022-10-19
t2 = datetime.timedelta(days=6)
print(t1+t2)  # 2022-10-25


t3 = datetime.datetime.today()
print(t3)  # 2022-10-19 18:11:21.935837
t4 = datetime.timedelta(minutes=30)
print(t3+t4)  # 2022-10-19 18:42:21.593501

7.用系统时间输出以下字符串

"""
今天是2022年10月19日
今天是这周的第几天
今天是今年的第几天
今周是今年的第几周
今天是当月的第几天
"""

from datetime import datetime
# 获取当前系统时间
t = datetime.now()
print(t)  # 2022-10-19 17:29:27.145155
print(t.strftime('今天是%Y年%m月%d日'))  # 今天是2022年10月19日
print(t.strftime('今天是这周的第%w天'))  # 今天是这周的第3天
print(t.strftime('今天是今年的第%j天'))  # 今天是今年的第292天
print(t.strftime('今周是今年的第%W周'))  # 今周是今年的第42周
print(t.strftime('今天是当月的第%d天'))  # 今天是当月的第19天

8.日期时间的格式化字符串

%a 星期几的简写;如 星期三为Web
%A 星期几的全称;如 星期三为Wednesday
%b 月份的简写; 如4月份为Apr
%B 月份的全称; 如4月份为April
%c 标准的日期的时间串;（如： 04/07/10 10:43:39）
%C 年份的后两位数字
%d 十进制表示的每月的第几天
%D 月/天/年
%e 在两字符域中，十进制表示的每月的第几天
%F 年-月-日
%g 年份的后两位数字，使用基于周的年
%G 年分，使用基于周的年
%h 简写的月份名
%H 24小时制的小时
%I 12小时制的小时
%j 十进制表示的每年的第几天
%m 十进制表示的月份
%M 十时制表示的分钟数
%n 新行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟：hh:mm
%S 十进制的秒数
%t 水平制表符
%T 显示时分秒：hh:mm:ss
%u 每周的第几天，星期一为第一天 （值从0到6，星期一为0）
%U 第年的第几周，把星期日做为第一天（值从0到53）
%V 每年的第几周，使用基于周的年
%w 十进制表示的星期几（值从0到6，星期天为0）
%W 每年的第几周，把星期一做为第一天（值从0到53）
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份（值从0到99）
%Y 带世纪部分的十制年份
%z，%Z 时区名称，如果不能得到时区名称则返回空字符。
%% 百分号

资源来源于：
作者：半夏0921
链接：https://www.jianshu.com/p/da59e7900b26

随机数模块random

1.导入模块

#  导入随机数
import random

2.随机小数random() uniform()

print(random.random())  #大于0小于1之间的小数 0.8705054721763096  
print(random.uniform(1,5))  # 大于1小于5的小数  1.250392711400564

3.随机整数 randint() randrange()

print(random.randint(1,6))  # 随机产生1-6之间的整数
print(random.randrange(1,100,2))  # 随机产生指定的整数1-100之间的奇数

4.随机选择一个或多个样本 choice choices sample

print(random.choice(['一等奖','二等奖','三等奖','欢迎再来']))  # 随机抽取一个样本 三等奖
print(random.choices(['一等奖','二等奖','三等奖','欢迎再来']))  # 随机抽取一个样本  ['二等奖']
print(random.sample(['kiki','kimi','rose','kevin','jerry','lili'],2))  # 随机抽取样本数 ['kimi', 'jerry']

5.打乱列表顺序

l1 = [3,5,6,9,67,4,34,97,34,'A','G','J','K','B','L']
random.shuffle(l1)
print(l1)  # 随机打乱数据集[34, 4, 'A', 67, 'L', 'G', 9, 97, 6, 5, 34, 3, 'J', 'K', 'B']

练习题—图片验证码

'''图片验证码: 每一位都可以是大写字母 小写字母 数字  要求：4位'''
import random
def get_code(n):

    code = ''
    for i in range(n):
        # 1.先产生随机的大写字母  小写字母  数字
        random_upper = chr(random.randint(65,90))
        random_lower = chr(random.randint(97,122))
        randon_int = str(random.randint(0,9))
        # 2.随机三选一
        temp = random.choice([random_upper,random_lower,randon_int])
        code += temp

    return code
result = get_code(4)
print(result)  # 7RTT

result1 = get_code(10)
print(result1)  # y3lC7Uxnq4

os与sys模块

os与sys模块的区别

os模块主要与操作系统打交道

sys模块主要与python解释器打交道

os模块（重要）

1.创建目录（文件夹）

os.mkdir(r'a1')  # 相对路径 在执行文件所在的路径下创建目录  可以创建单级目录
os.mkdir(r'd2\d22\d222')  # 不可以创建多级目录
os.makedirs(r'd2\d22\d222')  # 可以创建多层递归目录
os.makedirs(r'd3')  # 也可以创建单级目录

2.删除目录（文件夹）

os.rmdir(r'a1')  # 可以删除单级目录
os.rmdir(r'd2\d22\d222')  # 不可以一次性删除多级目录
os.removedirs(r'd2\d22')  # 可以删除多级目录
os.removedirs(r'd2\d22\d222')  # 只能删除空的多级目录
os.rmdir(r'd3')  # 只能删除空的单级目录

3.列举指定路径下内容名称

print(os.listdir())  # ['.idea', '01 os模块.py', 'd2'] 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
print(os.listdir(r'D:\\'))  # [ 'Typora', '笔记', '腾讯会议', '谷歌下载......]

4.删除\重命名文件

os.rename(r'b.txt',r'bbb.txt')
os.remove(r'bbb.txt')

5.获取/切换当前工作目录

print(os.getcwd())  # D:\PycharmProjects\test19
os.chdir('..')   # 切换到上一级目录
print(os.getcwd())  # D:\PycharmProjects
os.mkdir(r'hei')

6.动态获取项目根路径（重要）

print(os.path.abspath(__file__))  # 获取执行文件的绝对路径  D:\PycharmProjects\test19\01 os模块.py
print(os.path.dirname(__file__))  #  获取执行文件所在目录路径  D:/PycharmProjects/test19

7.判断路径是否存在（文件、目录）

print(os.path.exists(r'01 os模块.py'))  # 判断文件路径是否存在   True
print(os.path.exists(r'D:\PycharmProjects\test19'))  # 判断目录是否存在  True\
print(os.path.isfile(r'01 os模块.py'))  # 判断路径是否是文件  True
print(os.path.isfile(r'D:\PycharmProjects\test19'))  # 判断路径是否是文件  False
print(os.path.isdir(r'01 os模块.py'))  #  Falae
print(os.path.isdir(r'D:\PycharmProjects\test19'))  # True

8.路径接口（重要）

s1 = r'D:\PycharmProjects\test19'
s2 = r'01 os模块.py'
print(f'{s1}\{s2}')  # D:\PycharmProjects\test19\01 os模块.py
""" 设计到路径拼接一定不要自己做，因为不同的操作系统路径分隔符不一样"""
print(os.path.join(s1,s2))  # D:\PycharmProjects\test19\01 os模块.py

9.获取文件大小（字节）

print(os.path.getsize(r'a.txt'))  # 12

sys模块

import sys
print(sys.path)  # 获取执行文件的sys.path
print(sys.getrecursionlimit())  # 获取python解释器默认最大递归深度
print(sys.setrecursionlimit(2000))  # 修改python解释器默认最大递归深度  None
print(sys.version)  # 3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC v.1927 64 bit (AMD64)]  查看系统版本信息
print(sys.platform)  # 平台信息 win32 （了解即可）

res = sys.argv
if len(res) != 3:
    print('执行命令缺少了用户名或密码')
else:
    username = res[1]
    password = res[2]
    if username == 'kiki' and password == '123':
        print('kiki,您的文件正在正常执行')
    else:
        print('你不是kiki,无权执行该文件')

json模块

引入：字典转为str(字典)很简单，但是str(字典)如何转为字典呢，下面就引入了json模块，可以帮我实现这个功能。

json模块也称为序列化模块，序列化就是将原本的字典、列表等内容转换成一个字符串的过程。序列化可以打破语言限制实现不同的编程语言之间数据交互。

序列化的目的：

1.以某种存储形式是自定义对象持久化

2.将对象从一个地方传递到另一个地方

3.使程序更具维护性

1.json 格式数据的形式

d1 = {"name":"rose","pwd":666}

上述这种情形就是json模式，要求是字符串类型并且引号都是双引号


注意：下面这种是————字典
d1 = {"name":"rose","pwd":666}
print(d1,type(d1))  # {'name': 'rose', 'pwd': 666}  <class 'dict'>

2.json格式数据的作用

1.解释器的字典
d = {'name':'kimi','pwd':123}
print(d,type(d))  # {'name': 'kimi', 'pwd': 123} <class 'dict'>

2.json模块>>>是字符串
import json  # 引入json 模块
result = json.dumps(d)  # 把字典用json 读取成字符串
print(result,type(result))  # {"name": "kimi", "pwd": 123} <class 'str'>

3.json相关操作

针对数据
	json.dumps()
	json.loads()
	
针对文件
	json.dump()
	json.load()

4.如何将字典写入文件并且取出来之后还可以是字典？

文件读取

d1 = {'name': 'rose', 'pwd': 666}
with open(r'aa.py','w',encoding='utf8') as f:
    f.write(str(d1))
with open(r'aa.py','r',encoding='utf8') as f1:
    date = f1.read()
    print((date,type(date)))  # ("{'name': 'rose', 'pwd': 666}", <class 'str'>)

序列化

	import json  # 引入json
方式一：dumps
	with open(r'aa.py','w',encoding='utf8') as f2:
	json_str = json.dumps(d1)  # '{}'  序列化：数据类型>>>json格式字符串
	f2.write(json_str)   # # 将序列化的文本写进文件,并以{"name": "rose", "pwd": 666}形式展示
方式二：dump
	with open(r'aa.py','w',encoding='utf8') as f2:
    	json.dump(d1,f2)  # 将数据序列化并写入文件 {"name": "rose", "pwd": 666}
    

反序列化

    import json  # 引入json
方式一：loads()
    with open(r'aa.py','r',encoding='utf8') as f4:
        json_str = f4.read()
        json_dict = json.loads(json_str)  # 反序列化：json格式字符>>>数据类型
        print(json_dict,type(json_dict))  # {'name': 'rose', 'pwd': 666} <class 'dict'>


方式二：load()
    result = json.load(f4)
    print(result,type(result))  # {'name': 'rose', 'pwd': 666} <class 'dict'>

    for line in f4:
        print(json.loads(line))

json实战案例

def register():
    # 用户注册功能
    # 第一步 注册
    import os
    import json

    #1.获取执行文件所在的路径
    base_dir = os.path.dirname(__file__)
    print(base_dir)  # D:/PycharmProjects/test19

    # 2.拼接出databash目录的路径
    db_dir = os.path.join(base_dir,'databash')
    print(db_dir)  # D:/PycharmProjects/test19\databash

    # 3.创建databash目录
    if not os.path.isdir(db_dir):
        os.mkdir(db_dir)

    # 4。获取用户数据
    username= input('请输入您的用户名>>>:').strip()
    password = input('请输入您的密码>>>:').strip()


    # 5.判断用户名是否已存在
    print(os.listdir(db_dir))
    user_file_path = os.path.join(db_dir,f'{username}.json')
    if not os.path.exists(user_file_path):
        # 6.如果不存在，构建字典
        user_dict = {
            'username':username,
            'password':password,
            'age':18
        }
        with open(user_file_path,'w',encoding='utf8') as f1:
            json.dump(user_dict,f1)
            print('注册成功')
    else:
        print('用户已注册')
    

第二步：登录功能

def login():

    # 2.登录功能
    import os
    import json
    # 1.获取执行文件当前路径
    base_file = os.path.dirname(__file__)
    print(base_file)  # D:/PycharmProjects/test19

    # 2.拼接出字典数据所在的databash路径
    data_file_path= os.path.join(base_file,'databash')
    print(data_file_path)  # D:/PycharmProjects/test19\databash

    # 3.获取用户名
    username = input('请输入你的名字>>>:').strip()

    #4.拼接出上述用户组成文件路径
    target_user_path = os.path.join(data_file_path,f'{username}.json')
    """  5.将用户名生成的文件路径跟databash目录路径进行拼接"""
    if not os.path.isfile(target_user_path):
        """ 6.判断路径是不是文件，不是文件的话用户名不存在"""
        print('用户名不存在')
    else:# 7.是文件，文件存在
        password = input('请输入用户名密码>>>:').strip()
        #8.获取用户名真是数据字典
        with open(target_user_path,'r',encoding='utf8') as f2:
            real_user = json.load(f2)
            if password == real_user.get('password'):
                print('登录成功')
            else:
                print('密码错误')

json模块补充说明

import json

d = {'name':'kevin老师','pwd':123}
res = json.dumps(d)  # 针对中文会自动转码  我们在查看的时候不方便
print(res)  # {"name": "kevin\u8001\u5e08", "pwd": 123}

# res = json.dumps(d,ensure_ascii=False)
# print(d)  # {'name': 'kevin老师', 'pwd': 123}