Python刚开始学时这些模块不常见,但是却挺好用

曾经终败给现在 2022-12-01 15:39 169阅读 0赞

### Python基础不常见,但是挺好用的模块 ###

*  双端队列
 *   *  案例
 *  日期
 *   *  calendar
     *   *  calendar(year,w=2,l=1,c=6)
         *  isleap(year)
         *  leapdays(y1,y2)
         *  month(year,month,w=2,l=1)
         *  monthrange(year,month)
         *  monthcalendar(year,month)
         *  weekday(year,month,day)
 *  Json
 *   *  对于Json文件大处理
 *  数据操作
 *   *  pickle
     *  shelve
 *  大文件的读取
 *   *  基本方法
     *  常用函数
 *  日志
 *  定位特定类型文件
 *   *  fnmatch
     *  glob

# 双端队列 #

**双端队列（deque）同时具备栈和队列的特征，栈是先进后出的数据结构，队列是先进先出的数据结构（请先知道这个概念），所以双端队列可以从序列的任何一端添加和删除项。**

## 案例 ##

""" 将列表[1,2,3]最左边和最右边添加一个数,然后在删除他们 """
    from _collections import deque
    if __name__ == '__main__':
        lst=[1,2,3]
        #创建一个双端队列
        double_end_queue=deque(lst)
        #向最左边添加一个数
        double_end_queue.appendleft(4)
        # 向最右边添加一个数
        double_end_queue.append(5)
        print(double_end_queue) #deque([4, 1, 2, 3, 5])
        # 向最左边删除一个数
        double_end_queue.popleft()
        # 向最右边删除一个数
        double_end_queue.pop()
        print(double_end_queue) #deque([1, 2, 3])

**函数 popleft() 是去掉最左边的项并返回该项，pop() 是去掉最右边的项并返回该项。接下来我们来做一个小题，加深一下印象：判断一下一个词是不是回文。判断回文的话我们都知道，最简单的就是从一个词的两端向中间扫描，只要两端的字符匹配，一直弹出直到到达中间：**

# 日期 #

**在我们的日常生活当中，「时间」这个词是比较笼统和含糊的。在物理学的概念中，「时间」是一个非常清晰的概念，在我们的 Python 中，时间是可以通过相关模块来实现的**

## calendar ##

import calendar
    print(calendar.month(2020,8))

![在这里插入图片描述][20200827211354496.png_pic_center]  
**上面的代码轻而易举的得到了 2020 年 8 月的日历，并且排列还相当整齐，这个就是 calender 模块。大家可以用 dir() 去查看这个模块下所有的内容。**

### calendar(year,w=2,l=1,c=6) ###

**返回 year 年的年历，3 个月一行，间隔距离为 c，每日宽度间隔为 w 字符，每行长度为 21 \* w + 18 +2 \* c，l 是每星期行数**

import calendar
    print(calendar.calendar(2020))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center]

### isleap(year) ###

**这个是判断是否为闰年，是则返回 true，否则返回 false**  
![在这里插入图片描述][20200827211855841.png_pic_center]

### leapdays(y1,y2) ###

**返回 y1，y2 两年之间的闰年总数，左闭右开区间，在这点上和序列的切片一样**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 1]

### month(year,month,w=2,l=1) ###

**返回 year 年 mouth 月日历，两行标题，一周一行。每日间隔宽度为 w 字符，每行的长度为 7 \* w +6，l 是每个星期的行数。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 2]

### monthrange(year,month) ###

**返回一个元组，里面有两个整数。第一个整数代表着该月的第一天是从星期几开始的（从 0 开始，依次为星期一，星期二…直到 6 代表星期日）。第二个整数代表该月一共多少天。**  
![在这里插入图片描述][20200827212020486.png_pic_center]

### monthcalendar(year,month) ###

**返回一个列表，列表内的元素还是列表，每个子列表代表一个星期，都是从星期一到星期日，如果没有本月的日期的话，则为 0。**

### weekday(year,month,day) ###

**输入年月日，返回该日是星期几（需要注意的是，返回值依然按照从 0 到 6 依次对应星期一到星期日）。**  
![在这里插入图片描述][20200827212203105.png_pic_center]

# Json #

**Json是一种由道格拉斯构想设计、轻量级的数据交换语言，以文字为基础，且易于让人阅读。尽管JSON 是 JavaScript 的一个子集，但JSON 是独立于语言的文本格式，并且采用了类似 C 语言家族的一些习惯。**  
**JSON 构建于两种结构基础之上：**

*  “名称/值”对的集合。不同的语言中，它被理解为对象（object），记录（record），结构（struct），字典（dictionary），哈希表（hash table）等。
 *  值的有序列表。在某些语言中，它被理解为数组（array），类似于 Python 中的类表。  
    Python 标准库中有 JSON 模块，主要是执行序列化和反序列化功能
 *  序列化：encoding，把一个 Python 对象编码转化成 JSON 字符串；
 *  反序列化：decoding，把 JSON 格式字符串解码转换为 Python 数据对象

import json
    data = [{ 'name':'rocky','like':('python','c++'),'age':23}]
    #JSON序列化
    data=json.dumps(data)
    print(data,type(data)) # [{"name": "rocky", "like": ["python", "c++"], "age": 23}] <class 'str'>
    #JSON反序列化
    data=json.loads(data)
    print(data,type(data)) # [{'name': 'rocky', 'like': ['python', 'c++'], 'age': 23}] <class 'list'>

## 对于Json文件大处理 ##

import tempfile
    data = [{ 'name':'rocky','like':('python','c++'),'age':23}]
    f=tempfile.NamedTemporaryFile(mode='w+')
    json.dumps(data,f)
    f.flush()
    print(open(f.name,'r').read()) #[{"name": "rocky", "like": ["python", "c++"], "age": 23}]

# 数据操作 #

## pickle ##

**pickle是可以将数据以序列化的形式存入文件中,虽然对用户不好,但是对计算机特别友好**

import pickle
    integer = [1,2,3,4,5]
    f = open('test.dat','wb')
    #序列化
    pickle.dump(integer,f)
    f.close()
    #反序列化
    integer = pickle.load(open('test.dat','rb'))
    print(integer) # [1, 2, 3, 4, 5]

## shelve ##

**由于数据的复杂程度,pickle只能完成一部分工作,从而引入了新的模块shelve**

import shelve
    s = shelve.open('test.db')
    s['name'] = 'rocky'
    s['like'] = 'python'
    s['age'] = 23
    s['content'] = { 'first':'good good study','second':'day day up'}
    s.close()
    #遍历
    s = shelve.open('test.db')
    for k in s:
    	print(k,s[k])

**test.db**  
![在这里插入图片描述][20200827221029518.png_pic_center]  
**运行结果:**  
![在这里插入图片描述][20200827221104200.png_pic_center]

# 大文件的读取 #

**如果文件不是很大的话，这种做法能够保证读取的速度，但是如果文件内容很大，大到差不多内存那么大或者更大的时候，就不能这么做了。但是 Python 早就替你考虑到了，Python 中有一个 fileinput 模块，可以使用它来操作。**

import fileinput
    with fileinput.input(files='text.html') as f:
        for line in f:
            print(line,end="")

当出现如下错误:  
**UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0x80 in position 1517: illegal multibyte sequence**  
可以说明其编码有问题,我们可以将其转换成utf8,具体措施如下:

import fileinput
    
    with fileinput.input(files='text.html',openhook=fileinput.hook_encoded("utf8")) as f:
        for line in f:
            print(line,end="")

## 基本方法 ##

fileinput.input(files=None, inplace=False, backup='', bufsize=0, mode='r', openhook=None)

files:                  #文件的路径列表，默认是stdin方式，多文件['1.txt','2.txt',...]
    inplace:                #是否将标准输出的结果写回文件，默认不取代
    backup:                 #备份文件的扩展名，只指定扩展名，如.bak。如果该文件的备份文件已存在，则会自动覆盖。
    bufsize:                #缓冲区大小，默认为0，如果文件很大，可以修改此参数，一般默认即可
    mode:                   #读写模式，默认为只读
    openhook:               #该钩子用于控制打开的所有文件，比如说编码方式等;

## 常用函数 ##

fileinput.input()       #返回能够用于for循环遍历的对象
    fileinput.filename()    #返回当前文件的名称
    fileinput.lineno()      #返回当前已经读取的行的数量（或者序号）
    fileinput.filelineno()  #返回当前读取的行的行号
    fileinput.isfirstline() #检查当前行是否是文件的第一行
    fileinput.isstdin()     #判断最后一行是否从stdin中读取
    fileinput.close()       #关闭队列

# 日志 #

import logging
    logging.basicConfig(
    level= logging.DEBUG,
    format = '%(asctime)s : %(levelname)s : %(message)s',
    filename= "test.log"
    )
    logging.debug('debug message')
    logging.info("info message")
    logging.warn('warn message')
    logging.error("error message")
    logging.critical('critical message')

![在这里插入图片描述][20200827224334532.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 3]

# 定位特定类型文件 #

## fnmatch ##

**fnmatch这是一个专门用来进行文件名匹配的库，支持使用通配符来进行文字匹配（比如’\*’，’?'等）**  
**其只有4个函数:**

*  **fnmatch：判断文件名是否符合特定的模式；**
 *  **fnmatchcase：判断文件名是否符合特定的模式（不区分大小写）；**
 *  **filter：返回输入列表中，符合特定模式的文件名列表；**
 *  **translate：将通配符模式转换成正则表达式**

import os
    import fnmatch
    print(os.listdir('.'))
    #['1.bin', 'a.txt', 'anchor.json', 'b.txt', 'Img', 'Itertools使用.py', 'test', 'test.db.bak', 'test.db.dat', 'test.db.dir', 'test.log', 'test.py', 'test2.py', '__init__.py', '__pycache__']
    print([txt for txt in os.listdir('.') if fnmatch.fnmatch(txt, '*.txt')]) #['a.txt', 'b.txt']
    print([file for file in os.listdir('.') if fnmatch.fnmatch(file, '[a-c]*')]) # ['a.txt', 'anchor.json', 'b.txt']
    print([file for file in os.listdir('.') if fnmatch.fnmatch(file, '[!a-c]*')]) #['1.bin', 'Img', 'Itertools使用.py', 'test', 'test.db.bak', 'test.db.dat', 'test.db.dir', 'test.log', 'test.py', 'test2.py', '__init__.py', '__pycache__']

## glob ##

**glob可以直接忽略os.path这个参数**

import glob
    print( glob.glob('*.txt')) #['a.txt', 'b.txt']
    print( glob.glob('[a-c]*')) #['a.txt', 'anchor.json', 'b.txt']
    print( glob.glob('[!a-c]*')) # ['1.bin', 'Img', 'Itertools使用.py', 'test', 'test.db.bak', 'test.db.dat', 'test.db.dir', 'test.log', 'test.py', 'test2.py', '__init__.py', '__pycache__']

[20200827211354496.png_pic_center]: /images/20221123/d83abbabca5c49afb4a97ae2ba1d51f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/c42d966e635a46cda48d7115a41c2f4b.png
[20200827211855841.png_pic_center]: /images/20221123/a66a9de0a6df4f6fb798fa12c664253f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/f13c81f462e04669900b068f43505dd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/ed9b4a781fa647b9be9b8533ff8ee199.png
[20200827212020486.png_pic_center]: /images/20221123/758240a09a604cf5b751881637e3763b.png
[20200827212203105.png_pic_center]: /images/20221123/f30de9039f82467897b331324911e0bf.png
[20200827221029518.png_pic_center]: /images/20221123/63f8e35dd8034303b7883e9ffaaf55e3.png
[20200827221104200.png_pic_center]: /images/20221123/488d805b920d44ebb473d1a625bd3b1b.png
[20200827224334532.png_pic_center]: /images/20221123/e451adf2d48241c29b18be2faa8e53c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMzA5NTI1ODAy_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/26d867886b9c42d0904bd4fb978d19f2.png