node-formidable模块

Posted 2023-05-09

参考技术A 对解析上传的文件数据做了很好的抽象。 其实说白了，处理文件上传“就是”处理POST数据 —— 但是，麻烦的是在具体的处理细节,node-formidable模块就是将通过HTTP POST请求提交的表单，在Node.js中可以被解析。
安装

引用

我们要做的就是创建一个新的IncomingForm
官网demo

Python 常用模块 -- collections模块,time模块,random模块,os模块,sys模块

主要内容:

　　一. 模块的简单认识

　　二. collections模块

　　三. time时间模块

　　四. random模块

　　五. os模块

　　六. sys模块

 

一. 模块的简单认识

模块: 模块就是把装有特定功能的代码进行归类的结果
引入模块的方式:
(1) import 模块
(2) from 位置 import 模块

 

二. collections模块
collections模块主要封装了一些关于集合类的相关操作. 如我们学过的iterable,iterator等等.
除此以外, collections还提供了一些除了基本数据类型以外的数据集合类型.
如: Counter, deque, OrderDict, defaultdict, namedtuple

1. Counter
　　Counter是一个计数器,主要用来计数.
(1)用普通方法计算一个字符串中每个字符出现的次数:

s = "Dava likes a pig"
dic = {}
for c in s:
    dic[c] = dic.get(c, 0) + 1
print(dic)
# 以上代码执行结果:
# {‘D‘: 1, ‘a‘: 3, ‘v‘: 1, ‘ ‘: 3, ‘l‘: 1, ‘i‘: 2, ‘k‘: 1, ‘e‘: 1, ‘s‘: 1, ‘p‘: 1, ‘g‘: 1}

(2)引入collections模块中的Counter方法:

from collections import Counter
s = "Dava likes a pig"
print(Counter(s))
# 以上代码执行结果:
# Counter({‘a‘: 3, ‘ ‘: 3, ‘i‘: 2, ‘D‘: 1, ‘v‘: 1, ‘l‘: 1, ‘k‘: 1, ‘e‘: 1, ‘s‘: 1, ‘p‘: 1, ‘g‘: 1})

 

2. deque 双向队列
在学习双向队列之前,我们需要了解两种数据结构(重点):
　　(1)队列: FIFO(First In First Out) --> 先进先出
　　(2)栈: FILO(First In Last Out) --> 先进后出

(1)队列:

import queue
# 创建队列
q = queue.Queue()
# 在q中放入元素
q.put("汪峰")
q.put("章子怡")
q.put("刘德华")
# 获取元素
print(q.get())  # 汪峰
print(q.get())  # 章子怡
print(q.get())  # 刘德华
print(q.get())  # 阻塞了,该代码在等待下一个元素进入队列

# 注意: 如果队列里没有元素了, 也就再也拿不出来元素了.此时程序被阻塞

(2)栈: 1)入栈 ---> 2)出栈
栈的属性: 1)载体(list)   2)大小(size)   3)栈顶指针(下一个装元素的位置)
注意: 以下代码有严重的并发问题!

class StackFullError(Exception): pass
class StackEmptyError(Exception): pass
class Stack:
    def __init__(self, size):
        self.index = 0
        self.size = size
        self.lst = []

    def push(self, element):
        if self.index < self.size:
            self.lst.insert(self.index, element)
            self.index += 1
        else:
            raise StackFullError("the stack is full")

    def pop(self):
        if self.index > 0:
            self.index -= 1
            return self.lst[self.index]

 

在了解了队列和栈的概念以后,,我们再来看双向队列deque:

from collections import deque
q = deque()                     # 创建双向队列
q.append("汪峰")                # 默认从右侧添加
q.append("章子怡")
q.appendleft("赵又廷")          # 从左侧添加
q.appendleft("高圆圆")
print(q)

q.pop()                         # 默认从右侧删除
q.popleft()                     # 从左侧删除
print(q)

# 以上代码执行结果:
# deque([‘高圆圆‘, ‘赵又廷‘, ‘汪峰‘, ‘章子怡‘])
# deque([‘赵又廷‘, ‘汪峰‘])

 

3. namedtuple 命名元组
命名元组,即给元组内的元素进行命名,例如,我们把(x, y)看作是一个元组,
同时, 我们还可以认为这是一个点坐标. 此时, 我们就可以使用namedtuple对元素进行命名.

from collections import namedtuple
point = namedtuple("Point", ["x", "y"])     # namedtuple方法类似于 定义一个简单的类
p = point(1, 2)     # 命名元组
print(p)
# 以上代码执行结果:
# Point(x=1, y=2)

 

4. OrderedDict和defaultdict
(1) OrderedDict -- 指有序字典(字典的key是有序的)

先观察一般情况下创建的字典:

dic = {"a": 1, "b": 2, "c": 3}
print(dic)
# 执行结果:
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

再观察用OrderedDict方法创建的字典:

from collections import OrderedDict
od = OrderededDict({"a": 1, "b": 2, "c": 3})
print(od)
print(od.get("b"))
print(od["b"])
# 以上代码执行结果:
# OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
# 2
# 2

 

(2) defaultdict -- 可以给字典设置默认值, 当key不存在时, 直接获取默认值

from collections import defaultdict
dd = defaultdict(list)  # 这里的默认值参数必须是可调用的(callable). 在这里, list是可调用的, 因为 list()有意义, 它是一个空列表
dd["汪峰"] = "乐坛半壁江山"
print(dd["刘德华"])    # 当key不存在的时候,会自动执行构造方法中传递的内容
print(dd["汪峰"])
# 以上代码执行结果是:
# []
# 乐坛半壁江山

 

(3)处理字典时setdefault与defaultdict各自的用法, 举例说明:
例1: setdefault(key, default=None)
题目内容: 把列表中大于66和小于66的数字各自分类

lst = [11, 22, 33, 44, 55, 66, 77, 88, 99]
dic = {}
for el in lst:
    if el > 66:
        dic.setdefault("大于66的值有", []).append(el)
    else:
        dic.setdefault("小于等于66的值有", []).append(el)
print(dic)
# 以上代码执行结果是:
# {‘小于等于66的值有‘: [11, 22, 33, 44, 55, 66], ‘大于66的值有‘: [77, 88, 99]}

例2: defaultdict(callable)
题目内容: 把列表中大于66和小于66的数字各自分类

from collections import defaultdict
lst = [11, 22, 33, 44, 55, 66, 77, 88, 99]
dd = defaultdict(list)
for el in lst:
    if el > 66:
        dd["大于66的值有"].append(el)
    else:
        dd["小于等于66的值有"].append(el)
print(dd)
# 以上代码执行结果:
# defaultdict(<class ‘list‘>, {‘小于等于66的值有‘: [11, 22, 33, 44, 55, 66], ‘大于66的值有‘: [77, 88, 99]})

 

 

三. time时间模块(重点)

1. 时间戳 -- 当前系统时间(给计算机使用)

import time
print(time.time())
# 执行结果:
# 1538998798.0641088 --> 这个就是当前系统时间,也称时间戳,它是给计算机使用的

 

2. 格式化时间(日常生活中常用的)

import time
s = time.strftime("%Y/%m/%d %H:%M:%S")
print(s)
# 执行结果:
# 2018/10/08 19:43:27 --> 格式化时间指的是我们能看懂的时间,这里的"%Y/%m/%d %H:%M:%S"是就是时间格式,它是可以根据要求进行更改的

日期格式化标准:
%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. 结构化时间(用于时间格式的转化,时间差计算)

import time
print(time.localtime())
# 执行结果:
# time.struct_time(tm_year=2018, tm_mon=10, tm_mday=8, tm_hour=19, tm_min=52, tm_sec=12, tm_wday=0, tm_yday=281, tm_isdst=0)

 

4. 时间的相关操作

(1)把时间戳转化为格式化时间
步骤: 时间戳 --> 结构化时间 --> 格式化时间

举例说明:

# 已知数据库中存储了这样一个时间: 1888888888, 请将它转化成 xxxx年xx月xx日 的形式
import time
t = time.localtime(1888888888)      # 把"时间戳"结构化
s = time.strftime("%Y-%m-%d %H:%M:%S", t)   # 把"结构化时间"格式化
print(s)
# 执行结果:
# 2029-11-09 11:21:28

 

(2)把格式化时间转化成时间戳
步骤: 格式化时间 --> 结构化时间 --> 时间戳

举例说明:

import time
s = "2020-10-01 12:18:34"
t = time.strptime(s, "%Y-%m-%d %H:%M:%S")   # 把格式化时间结构化
print(time.mktime(t))   # 把结构化时间转换成时间戳
# 执行结果:
# 1601525914.0

从以上两个例子可以看出: 在对时间进行格式转换时, 都必须要先将该时间转换成"结构化时间".所以可以把结构化时间当作是一个中间站.

 

(3)计算时间差

# 已知两个格式化时间, 它们分别是"2017-09-11 08:30:00"和"2017-09-12 11:00:00", 计算它们的时间差
import time
true_time1 = time.mktime(time.strptime("2017-09-11 08:30:00", "%Y-%m-%d %H:%M:%S"))
true_time2 = time.mktime(time.strptime("2017-09-12 11:00:00", "%Y-%m-%d %H:%M:%S"))
def_time = true_time2 - true_time1
struct_time = time.localtime(def_time)
print("时间差是: {0}年{1}月{2}日{3}小时{4}分钟{5}秒".format(struct_time.tm_year-1970, struct_time.tm_mon-1, struct_time.tm_mday-1, struct_time.tm_hour, struct_time.tm_min, struct_time.tm_sec))

# 执行结果:
# 时间差是: 0年0月1日10小时30分钟0秒

 

 

四. random模块 -- 所有与"随机"相关的内容都在random模块中

import random               # 引入模块

print(random.random())      # 拿到闭区间[0, 1]内的随机小数

print(random.uniform(a, b)) # 拿到闭区间[a, b]内的随机小数

print(random.randint(a, b)) # 拿到闭区间[a, b]内的随机整数

print(random.randrange(a, b, step))     # 拿到列表list(range(a, b, step))中的一个随机数
print(random.randrange(1, 10, 2))       # 拿到列表[1, 3, 5, 7, 9]中的一个随机数

print(random.choice(list(el1, el2, el3, ...)))     # 拿到列表list()中的一个随机元素
print(random.choice(["汪峰", "王力宏", ["白蛇传", "天龙八部"]]))      # 拿到列表["汪峰", "王力宏", ["白蛇传", 天龙八部]]中的一个随机元素

print(random.sample(list(el1, el2, el3, ...), num))    # 从列表list()中任意拿出num个元素,返回这num个元素组成的列表
print(random.sample([1, "23", [4, 5]], 2)   # 从列表[1, "23", [4, 5]]中任意拿出2个元素, 返回这2个元素组成的列表, 如[[4, 5], ‘23‘]

random.shuffle(list(el1, el2, el3, ...))    # 打乱列表中所有元素的顺序,返回打乱后的列表
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
random.shuffle(lst)
print(lst)
# 执行结果:
# [5, 0, 1, 7, 9, 6, 3, 4, 8, 2]            # 打乱了列表lst中所有元素的顺序, 最后返回的是乱序的列表

 

 

五. os模块 -- 所有和操作系统相关的内容都在os模块中

import os

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.system("bash command")           # 运行shell命令, 直接显示

os.popen("bash command").read()     # 运行shell命令, 获取执行结果

os.getcwd()                         # 获取当前工作目录, 即当前脚本工作目录. 相当于shell下cd

# os.path

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

os.path.split(path)                 # 将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所指向的文件或者目录的最后访问时间

 

 

六. sys模块 -- 所有和Python解释器相关的操作都在sys模块

以下操作只能在命令提示符中使用

import sys

sys.argv        # 命令行参数列表, 第一个元素是程序本身路径

sys.version     # 获取Python解释器程序的版本信息

sys.path        # 返回模块的搜索路径, 初始化时使用PYTHONPATH环境变量的值

sys.platform    # 返回操作系统平台名称

sys.exit(1)     # 退出程序, 正常退出时使用exit(0), 错误退出时使用sys.exit(1)