常用模块

古城微笑少年丶 2021-11-09 16:06 364阅读 0赞

*  collection模块
 *  时间模块time datatime
    
     *  time 模块
     *  datetime 模块
     *  random 模块
     *  os 模块
     *  sys 模块
     *  序列化模块

## collection模块 ##

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1：namedtuple：生成可以使用名字来访问元素内容的tuple。

2：deque：双端队列，可以快速的从另外一侧追加和退出对象。

3：Counter：计数器，主要用来计数。

4：OrderedDict：有序字典

5：defaultdict：带有默认值的字典

#### namedtuple（具名元组） ####

例：表示坐标点的x和y

from collections import namedtuple
    
    point = namedtuple('坐标',['x','y'])
    point1 = namedtuple('坐标','x y')
    p = point(9,9)
    p1 = point1(9,9)
    print(p)

# 坐标(x=9, y=9)
    # 坐标(x=9, y=9)

用具名元组来记录一个城市的信息

from collections import namedtuple
    Country = namedtuple('中国','name city')
    c = Country('广西','桂林')
    print(c)

# 中国(name='广西', person='桂林')

#### deque 双端队列 ####

from collections import deque
    
    q = deque(['a','b','c'])
    q.append(1) # 
    q.appendleft(3)
    print(q)
    
    q.insert(2,'插队') # 可以通过 insert 进行索引插入元素
    print(q)

# deque([3, 'a', 'b', 'c', 1])
    # deque([3, 'a', '插队', 'b', 'c', 1])

#### Counter 计数器 ####

from collections import Counter
    
    s = Counter('aaasdsdsddddddsad')
    print(s)

# Counter({'d': 9, 'a': 4, 's': 4})

#### OrdereDict 有序字典 ####

from collections import OrderedDict
    
    d = dict([('a',1),('b',2),('c',3)])
    print(d) # dict 的 key 是无序的
    od = OrderedDict([('b',2),('c',3),('a',1)])
    print(od) # OrderedDict 的 key 是有序的

# {'a': 1, 'b': 2, 'c': 3}
    # OrderedDict([('b', 2), ('c', 3), ('a', 1)])

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

#### defaultdict 带有默认值的字典 ####

有如下值集合 \[11,22,33,44,55,66,77,88,,99,90..\]，将所有大于 66的值保存至字典的第一个key中，将小于 66的值保存至第二个key的值中。  
即： \{'k1': 大于66, 'k2': 小于66\}

values = [11,22,33,44,55,66,77,88,99,90]
    
    dic = {}
    for i in values:
        if i > 66:
            if 'k1' not in dic:
                dic['k1'] = []
            dic['k1'].append(i)
        else:
            if 'k2' not in dic:
                dic['k2'] = []
            dic['k2'].append(i)
    print(dic)

# {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}

from collections import defaultdict
    
    values = [11,22,33,44,55,66,77,88,99,90]
    dic = defaultdict(list)
    
    for i in values:
        if i > 66:
            dic['k1'].append(i)
        else:
            dic['k2'].append(i)
    print(dic)

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

## 时间模块time datatime ##

### time 模块 ###

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct\_time)、格式化的时间字符串：

(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1999-12-06’

%y 两位数的年份表示（00-99）
    %Y 四位数的年份表示（000-9999）
    %m 月份（01-12）
    %d 月内中的一天（0-31）
    %H 24小时制小时数（0-23）
    %I 12小时制小时数（01-12）
    %M 分钟数（00=59）
    %S 秒（00-59）
    %a 本地简化星期名称
    %A 本地完整星期名称
    %b 本地简化的月份名称
    %B 本地完整的月份名称
    %c 本地相应的日期表示和时间表示
    %j 年内的一天（001-366）
    %p 本地A.M.或P.M.的等价符
    %U 一年中的星期数（00-53）星期天为星期的开始
    %w 星期（0-6），星期天为星期的开始
    %W 一年中的星期数（00-53）星期一为星期的开始
    %x 本地相应的日期表示
    %X 本地相应的时间表示
    %Z 当前时区的名称
    %% %号本身

(3)元组(struct\_time) ：struct\_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

import time 
    print(time.time()) # 时间戳
    # 1563442062.862509
    
    print(time.strftime('%Y-%m-%d %X')) # 格式化时间
    # 2019-07-18 17:29:46
    print(time.strftime('%Y-%m-%d %H-%M-%S'))
    # 2019-07-18 17-29-46
    
    print(time.localtime()) # 结构化时间
    # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=17, tm_min=30, tm_sec=52, tm_wday=3, tm_yday=199, tm_isdst=0)

#### 几种格式之间的转换 ####

![827651-20170724144151992-1508626640.png][]

import time
    
    # 时间戳转换结构化时间
    res = time.time()
    print(time.gmtime(res))
    print(time.localtime(res))
    # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=34, tm_sec=8, tm_wday=3, tm_yday=199, tm_isdst=0)
    # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=34, tm_sec=8, tm_wday=3, tm_yday=199, tm_isdst=0)
    
    # 结构化时间转换时间戳
    res = time.localtime()
    print(time.mktime(res))
    # 1563446202.0

import time
    
    # 结构化时间转换格式化时间
    res = time.localtime()
    print(time.strftime('%Y-%m-%d',res))
    # 2019-07-18
    
    # 格式化时间转换结构化时间
    res = time.strftime('%Y-%m-%d %X')
    print(time.strptime(res,'%Y-%m-%d %X'))
    # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=46, tm_sec=37, tm_wday=3, tm_yday=199, tm_isdst=-1)

### datetime 模块 ###

import datetime
    
    # 自定义时间
    res = datetime.date(2019,7,18)
    print(res)
    # 2019-07-18
    
    # 获取本地时间
    print(datetime.date.today)
    res = datetime.datetime.today()
    print(res)
    # 2019-07-18 
    # 2019-07-18 18:52:39.687587
    
    # 无论是年月日，还是年月日时分秒对象都可以调用以下方法获取针对性的数据
    # 以上面的 res 举例
    print(res.year) # 获取年份
    print(res.month) # 获取月份
    print(res.day) # 获取日
    print(res.weekday()) # 获取星期 0表示周一
    print(res.isoweekday()) # 获取星期 1表示周一
    # 2019
    # 7
    # 18
    # 3
    # 4
    
    # timedelta 对象
    today = datetime.date.today()
    tdelta = datetime.timedelta(days=3)
    print(f'今天日期{today}')
    print(f'从今天向后推3天:{today+tdelta}')
    # 今天日期2019-07-18
    # 从今天向后推3天:2019-07-21

日期对象 = 日期对象 +/- timedelta

timedelta 对象 = 日期对象 +/- 日期对象

验证：

import datetime
    
    now_date = datetime.date.today()
    day = datetime.timedelta(days=7)
    
    now_date1 = now_date+day # 日期对象 = 日期对象 +/- timedelta
    print(type(now_date))
    day1 = now_date1 - now_date # timedelta 对象 = 日期对象 +/- 日期对象
    print(day1)

# <class 'datetime.date'>
    #　7 days, 0:00:00

### random 模块 ###

import random
    # 随机小数
    random.random() # 大于0且小于1之间的小数
    # 0.6860937326862173
    random.uniform(1,3) # 大于1小于3直接的小数
    # 2.3627834021598133
    
    # 随机整数
    random.randint(1,5) # 大于等于1小于等于5之间的整数
    # 1
    random.randrange(1,10,2) # 大于等于1小于10之间的奇数
    # 7
    
    # 随机返回一个
    random.choice([1,'23',[1,2,3]]) # 1或者23或者[1,2,3]
    # 23
    # 随机返回多个
    random.sample([1,2,3,'23',[4,5,6]],3) # 列表中任意3个元素的组合
    # [3, 1, [4, 5, 6]]
    
    # 打乱列表顺序
    l = [1,2,3,4,5]
    random.shuffle(l) # 打乱次序
    print(l)
    # [4, 5, 3, 1, 2]

随机生成验证码

def get_code(n):
        code = ''
        for i in range(n):
            num = str(random.randint(0,9))
            upper_letter = chr(random.randint(65,90))
            lower_letter = chr(random.randint(97,122))
            code += random.choice([num,upper_letter,lower_letter])
        return code
    res = get_code(6)
    print(res)

# okULb3

### os 模块 ###

os 模块是与操作系统交互的一个接口

import os
    
    os.mkdir('文件夹名') # 自动创建文件夹
    print(os.path.exists(r'文件路径')) # 判断文件是否存在
    print(os.path.exists(r'文件夹路径')) # 判断文件夹是否存在
    print(os.path.isfile(r'文件路径')) # 只能判断文件是否存在，不能判断文件夹
    
    os.rmdir(r'文件夹路径') # 只删除空文件夹
    
    print(os.getcwd()) # 获取当前文件所在的文件夹路径
    print(os.chdir(r'另一个文件夹的路径')) # 切换当前所在的目录
    print(os.getcwd())
    
    print(os.path.getsize(r'文件夹或文件路径')) #　获取文件大小

### sys 模块 ###

sys 模块是与 python 解释器交互的一个接口

import sys
    
    sys.path.append('路径') # 将某个路径添加到系统的环境变量中
    print(sys.platform) # 返回操作系统的名称
    print(sys.version) # 获取 python 解释器的版本

### 序列化模块 ###

序列：字符串

序列化：将其它数据类型转换成字符串的过程。

反序列化：字符串转成其它数据类型。

序列化的目的

1：以某种存储形式使用自定义对象持久化。

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

3：是程序更具有维护性。

#### json 和 pickle 模块 ####

用于序列化的两个模块

json，用于字符串和 python 数据类型间进行转换。

pickle，用于 python 特有的数据类型和 python 的数据类型进行转换。

注意：pickle 仅用于 python

*  json

# dumps 和 loads
    import json
    
    dic = {'a':1,'b':2,'c':3}
    res = json.dumps(dic) # 序列化：将一个字典转换成一个字符串
    print(res,type(res))
    # {"a": 1, "b": 2, "c": 3} <class 'str'>
    res1 = json.loads(res) # 反序列化：将一个字符串格式的字典转换成一个字典
    # 注意：要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示。
    print(res1,type(res1))
    # {'a': 1, 'b': 2, 'c': 3} <class 'dict'>
    
    # 也可处理嵌套的数据类型
    lis = [1,2,['a','b','c'],3,{'k1':'a','k2':'b','k3':'c'}]
    res = json.dumps(lis)
    print(res)
    # [1, 2, ["a", "b", "c"], 3, {"k1": "a", "k2": "b", "k3": "c"}]
    res1 = json.loads(res)
    print(res1)
    # [1, 2, ['a', 'b', 'c'], 3, {'k1': 'a', 'k2': 'b', 'k3': 'c'}]

# dump 和 load
    import json
    
    dic = {'name':'zkim','age':18,'hobby':'running'}
    with open('user_info','w',encoding='utf-8')as f:
        json.dump(dic,f)
    # dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
    
    with open('user_info','r',encoding='utf-8')as f:
        res = json.load(f)
        print(res)
    # load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回

*  pickle

import pickle
    
    # dumps 和 loads
    dic = {'name':'zkim','hobby':'running'}
    str_dic = pickle.dumps(dic)
    print(str_dic) # 一串二进制
    
    str_dic1 = pickle.loads(str_dic)
    print(str_dic1) 
    # {'name': 'zkim', 'hobby': 'running'}
    
    
    # dump 和 load
    with open('userinfo.txt','wb')as f:
        pickle.dump(dic,f)
    with open('userinfo.txt','rb')as f:
        res = pickle.load(f)
        print(res)
    # {'name': 'zkim', 'hobby': 'running'}

转载于:https://www.cnblogs.com/jincoco/p/11210771.html

[827651-20170724144151992-1508626640.png]: /images/20211109/98e8e7aa21f64c91910d0f9831460a8a.png