Python





```python
import json
import xmltodict
d = xmltodict.parse("""
   <mydocument has="an attribute">
     <and>
       <many>elements</many>
       <many>more elements</many>
     </and>
     <plus a="complex">
       element as well
     </plus>
   </mydocument>
""")
print(json.dumps(d, indent=4))
xml_res = xmltodict.unparse(d, pretty=True)
print(xml_res)
```

Python xml 转 dict 转 json

参考：





[https://stackoverflow.com/questions/50807744/apply-css-class-to-pandas-dataframe-using-to-html](https://stackoverflow.com/questions/50807744/apply-css-class-to-pandas-dataframe-using-to-html)

Python Pandas html CSS 表单处理

Python





```python
import ctypes
import os
import platform
import sys
def get_free_space_mb(folder):
    """ Return folder/drive
     space (in bytes)
    """
    if platform.system() == 'Windows':
        free_bytes = ctypes.c_ulonglong(0)
        ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(folder), None, None, ctypes.pointer(free_bytes))
        return free_bytes.value / 1024 / 1024 / 1024
    else:
        st = os.statvfs(folder)
        return st.f_bavail * st.f_frsize / 1024 / 1024 / 1024.
if __name__ == '__main__':
    print("这个目录剩余空间:", get_free_space_mb("/run/user/1009"), "G")
```

结果：

这个目录剩余空间: 12.574710845947266 G

Python 统计磁盘目录剩余空间大小 硬盘

Python





```python
import requests  # 发送HTTP 请求模块
import json  # json 解析模块
# cv2 转 base64
import base64
import cv2
import urllib
def encode_image(filename):
    """
    编码图片
    :param filename: str 本地图片文件名
    :return: str 编码后的字符串
        eg:
        src="data:image/gif;base64,R0lGODlhMwAxAIAAAAAAAP///
            yH5BAAAAAAALAAAAAAzADEAAAK8jI+pBr0PowytzotTtbm/DTqQ6C3hGX
            ElcraA9jIr66ozVpM3nseUvYP1UEHF0FUUHkNJxhLZfEJNvol06tzwrgd
            LbXsFZYmSMPnHLB+zNJFbq15+SOf50+6rG7lKOjwV1ibGdhHYRVYVJ9Wn
            k2HWtLdIWMSH9lfyODZoZTb4xdnpxQSEF9oyOWIqp6gaI9pI1Qo7BijbF
            ZkoaAtEeiiLeKn72xM7vMZofJy8zJys2UxsCT3kO229LH1tXAAAOw=="
    """
    # 1、文件读取
    ext = filename.split(".")[-1]
    with open(filename, "rb") as f:
        img = f.read()
    # 2、base64编码
    data = base64.b64encode(img).decode()
    # 3、图片编码字符串拼接
    src = "data:image/{ext};base64,{data}".format(ext=ext, data=data)
    return src
png_uri = encode_image(r"picture\444.png")
url = 'http://smoking.market.alicloudapi.com/ai_image_detect/ai_smoking/v1'
# 请求头
headers = {
    # 根据API的要求，定义相对应的Content - Type
    "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
    # 权限指定 APPCODE
    'Authorization': 'APPCODE 6ee3b7d95c9d4dce9ab38df723ec7efd'
}
a = "data:image/png;base64,"
r = requests.post(url, headers=headers, data={"IMAGE": png_uri})
print(r.text)
```


参考 ：https://blog.csdn.net/mouday/article/details/93489508

Python base64 阿里云 API 市场 的 requests 请求

（1）用POST方法传输；





（2）用requests.post的json参数传是可以的，直接给，requests.post自动转成json；

（3）用requests.post的data参数传也是可以的，给成json字符串；

（4）POST的请求头部可给可不给，会自动识别，但是接口有自己特殊的请求头部的时候一定得给，比如下图：

![在这里插入图片描述](/static/img/images/00310.png)

写法1
```python
import requests
res = requests.post(url="http://0.0.0.0:8001/items/1",
                    json={
                        "name": "Foo",
                        "description": "A very nice Item",
                        "price": 35.4,
                        "tax": 3.2,
                    },
                    headers={"Content-Type": "application/json; charset=UTF-8"}
                    )
print(res.text)
```

写法2
```python
import json
import requests
res = requests.post(url="http://0.0.0.0:8001/items/1",
                    data=json.dumps({
                        "name": "Foo",
                        "description": "A very nice Item",
                        "price": 35.4,
                        "tax": 3.2,
                    }),
                    headers={"Content-Type": "application/json; charset=UTF-8"}
                    )
print(res.text)
```

Python requests post application/json

修改video_path = 'test1.mp4' 这一句即可，源码地址：https://github.com/hongcyu/char_painting





```python
import cv2
from PIL import Image, ImageFont, ImageDraw
import os
from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize
# =========================
# coding:UTF-8
# 视频转字符画含音频version-1
# 参考1：https://blog.csdn.net/mp624183768/article/details/81161260
# 参考2：https://blog.csdn.net/qq_42820064/article/details/90958577
# 参考3：https://blog.csdn.net/zj360202/article/details/79026891
# =========================
def get_char(r, g, b, alpha=256):
    ascii_char = list(r"#TONGHUIgogoggoWGPZ*@$C&998798213123123128?3345462I1>;\';][.../]'\]!:-;. ")
    # ascii_char = list("#RMNHQODBWGPZ*@$C&98?32I1>!:-;. ")
    # ascii_char = list("$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[]?-_+~<>i!lI;:oa+>!:+. ")
    if alpha == 0:
        return ''
    length = len(ascii_char)
    gray = int(0.2126 * r + 0.7152 * g + 0.0722 * b)
    unit = (256.0 + 1) / len(ascii_char)
    return ascii_char[int(gray / unit)]
# 将视频转换为图片 并进行计数，返回总共生成了多少张图片！
def video_to_pic(vp):
    # vp = cv2.VideoCapture(video_path)
    number = 0
    if vp.isOpened():
        r, frame = vp.read()
        if not os.path.exists('cache_pic'):
            os.mkdir('cache_pic')
        os.chdir('cache_pic')
    else:
        r = False
    while r:
        number += 1
        cv2.imwrite(str(number) + '.jpg', frame)
        r, frame = vp.read()
    print('\n由视频一共生成了{}张图片！'.format(number))
    os.chdir("..")
    return number
def img_to_char(image_path, raw_width, raw_height, task):
    width = int(raw_width / 6)
    height = int(raw_height / 15)
    im = Image.open(image_path).convert('RGB')  # 必须以RGB模式打开
    im = im.resize((width, height), Image.NEAREST)
    txt = ''
    color = []
    for i in range(height):
        for j in range(width):
            pixel = im.getpixel((j, i))
            color.append((pixel[0], pixel[1], pixel[2]))  # 将颜色加入进行索引
            if len(pixel) == 4:
                txt += get_char(pixel[0], pixel[1], pixel[2], pixel[3])
            else:
                txt += get_char(pixel[0], pixel[1], pixel[2])
        txt += '\n'
        color.append((255, 255, 255))
    im_txt = Image.new("RGB", (raw_width, raw_height), (255, 255, 255))
    dr = ImageDraw.Draw(im_txt)
    # font = ImageFont.truetype('consola.ttf', 10, encoding='unic') #改为这个字体会让图片比例改变
    font = ImageFont.load_default().font
    x, y = 0, 0
    font_w, font_h = font.getsize(txt[1])
    font_h *= 1.37  # 调整字体大小
    for i in range(len(txt)):
        if (txt[i] == '\n'):
            x += font_h
            y = -font_w
        dr.text((y, x), txt[i], fill=color[i])
        y += font_w
    os.chdir('cache_char')
    im_txt.save(str(task) + '.jpg')
    os.chdir("..")
    return 0
def star_to_char(number, save_pic_path):
    if not os.path.exists('cache_char'):
        os.mkdir('cache_char')
    img_path_list = [save_pic_path + r'/{}.jpg'.format(i) for i in range(1, number + 1)]  # 生成目标图片文件的路径列表
    task = 0
    for image_path in img_path_list:
        img_width, img_height = Image.open(image_path).size  # 获取图片的分辨率
        task += 1
        img_to_char(image_path, img_width, img_height, task)
        print('{}/{} is finished.'.format(task, number))
    print('=======================')
    print('All image was finished!')
    print('=======================')
    return 0
def process_bar(percent, start_str='', end_str='', total_length=0):
    # 进度条
    bar = ''.join("■ " * int(percent * total_length)) + ''
    bar = '\r' + start_str + bar.ljust(total_length) + ' {:0>4.1f}%|'.format(percent * 100) + end_str
    print(bar, end='', flush=True)
def jpg_to_video(char_image_path, FPS):
    video_fourcc = VideoWriter_fourcc(*"MP42")  # 设置视频编码器,这里使用使用MP42编码器,可以生成更小的视频文件
    char_img_path_list = [char_image_path + r'/{}.jpg'.format(i) for i in range(1, number + 1)]  # 生成目标字符图片文件的路径列表
    char_img_test = Image.open(char_img_path_list[1]).size  # 获取图片的分辨率
    if not os.path.exists('video'):
        os.mkdir('video')
    video_writter = VideoWriter('video/new_char_video.avi', video_fourcc, FPS, char_img_test)
    sum = len(char_img_path_list)
    count = 0
    for image_path in char_img_path_list:
        img = cv2.imread(image_path)
        video_writter.write(img)
        end_str = '100%'
        count = count + 1
        process_bar(count / sum, start_str='', end_str=end_str, total_length=15)
    video_writter.release()
    print('\n')
    print('=======================')
    print('The video is finished!')
    print('=======================')
if __name__ == '__main__':
    video_path = 'test1.mp4'
    save_pic_path = 'cache_pic'
    save_charpic_path = 'cache_char'
    vp = cv2.VideoCapture(video_path)
    number = video_to_pic(vp)
    FPS = vp.get(cv2.CAP_PROP_FPS)
    star_to_char(number, save_pic_path)
    vp.release()
    jpg_to_video(save_charpic_path, FPS)
```

还是有人不会用，下面具体一点。前提是你会python，你需要有python环境。

安装程序的依赖包：
```
pip install opencv-python pillow
```

把代码弄进去，同级目录下加入一个test1.mp4，然后直接运行代码。

![在这里插入图片描述](/static/img/images/00311.png)

就能得到效果视频了：

![在这里插入图片描述](/static/img/images/00312.gif)

Python 井川里予 当程序员看多了 程序 生成 字符画

参考：[https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html](https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html)





3080Ti 好像只能用CUDA 11 ，最终我装了CUDA 11.1。

# 1 显卡驱动安装

这个是越高版本越好，因为向下兼容CUDA。安装支持你显卡的最高版本即可！

搜索驱动并安装：

[https://www.nvidia.com/Download/index.aspx?lang=en-us](https://www.nvidia.com/Download/index.aspx?lang=en-us)

![在这里插入图片描述](/static/img/images/00313.png)

![在这里插入图片描述](/static/img/images/00314.png)

# 2 CUDA安装

参考看这里：[https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html)

从 CUDA 11.0 开始，由于 CUDA 库（例如 cuFFT 和 CUB）中的 C++11 要求，推荐的最低 GCC 编译器至少为 GCC 6。

如何升级gcc：

```python
# 教程 https://www.cnblogs.com/jixiaohua/p/11732225.html
sudo yum install centos-release-scl  # 安装centos-release-scl  红帽自带工具让原始gcc和你新安装的共存
sudo yum install devtoolset-8-gcc*  #安装devtoolset，注意，如果想安装7.*版本的，就改成devtoolset-7-gcc*，以此类推
scl enable devtoolset-8 bash  # 激活对应的devtoolset，所以你可以一次安装多个版本的devtoolset，需要的时候用下面这条命令切换到对应的版本
gcc -v # 查看版本
# 避免下次重启终端后还是会恢复到gcc4.8.5,所以：
cd /usr/bin/  # 去这个目录
mv /usr/bin/gcc /usr/bin/gcc-4.8.5  # 备份原有gcc
ln -s /opt/rh/devtoolset-8/root/bin/gcc /usr/bin/gcc   # 软链接
mv /usr/bin/g++ /usr/bin/g++-4.8.5    # 备份  没有的话可以不管
ln -s /opt/rh/devtoolset-8/root/bin/g++ /usr/bin/g++   # 软链接  没有的话可以不管
gcc --version  # 查看版本
g++ --version  # 查看版本
```



查看你的centos系统内核版本，应该满足下面图里的要求：
```python
uname -srm
输出结果：
Linux 3.10.0-957.12.2.el7.x86_64 x86_64
3 - 内核版本.
10 - 主修订版本.
0-957 - 次要修订版本.
12 - 补丁版本.
```

![在这里插入图片描述](/static/img/images/00315.png)




下载cuda的run文件：

[https://developer.nvidia.com/cuda-toolkit-archive](https://developer.nvidia.com/cuda-toolkit-archive)

![在这里插入图片描述](/static/img/images/00316.png)


linux下载与安装很方便：

```python
wget https://developer.download.nvidia.com/compute/cuda/11.1.0/local_installers/cuda_11.1.0_455.23.05_linux.run
sudo sh cuda_11.1.0_455.23.05_linux.run
```

安装时不用选择选卡驱动，其他的选上然后安装即可。

成功安装后看到：

```python
(base) [root@localhost ~]# sh cuda_11.1.0_455.23.05_linux.run
===========
= Summary =
===========
Driver:   Not Selected
Toolkit:  Installed in /usr/local/cuda-11.1/
Samples:  Installed in /root/, but missing recommended libraries
Please make sure that
 -   PATH includes /usr/local/cuda-11.1/bin
 -   LD_LIBRARY_PATH includes /usr/local/cuda-11.1/lib64, or, add /usr/local/cuda-11.1/lib64 to /etc/ld.so.conf and run ldconfig as root
To uninstall the CUDA Toolkit, run cuda-uninstaller in /usr/local/cuda-11.1/bin
***WARNING: Incomplete installation! This installation did not install the CUDA Driver. A driver of version at least .00 is required for CUDA 11.1 functionality to work.
To install the driver using this installer, run the following command, replacing <CudaInstaller> with the name of this run file:
    sudo <CudaInstaller>.run --silent --driver
Logfile is /var/log/cuda-installer.log
```



所以增加环境变量

```python
vim /etc/profile  # 进入文件写env变量
# 在最后添加三句话env
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-11.1/lib64
export PATH=$PATH:/usr/local/cuda-11.1/bin
export CUDA_HOME=$CUDA_HOME:/usr/local/cuda-11.1
# 也可以这样添加
export LD_LIBRARY_PATH=/usr/local/cuda-11.1/lib64
export PATH=$PATH:/usr/local/cuda-11.1/bin
export CUDA_HOME=/usr/local/cuda-11.1
source /etc/profile # 生效env变量
```


此时就能查看CUDA版本：

```python
(torch111_k) [root@localhost ~]# nvcc -V
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2020 NVIDIA Corporation
Built on Tue_Sep_15_19:10:02_PDT_2020
Cuda compilation tools, release 11.1, V11.1.74
Build cuda_11.1.TC455_06.29069683_0
```

关于安装CUDA出现的`WARNING: Incomplete installation!`提示：别管他！



# 3 cuDNN

参考看这里：[https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html](https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html)

下载链接：[https://developer.nvidia.com/zh-cn/cudnn](https://developer.nvidia.com/zh-cn/cudnn)

需要注册登陆才能下载，下载与CUDA版本对应的版本：

![在这里插入图片描述](/static/img/images/00317.png)

安装很简单：

```python
tar -zxvf cudnn-11.1-linux-x64-v8.0.5.39.tgz # 解压后就是cuda文件夹
sudo cp cuda/include/cudnn*.h /usr/local/cuda/include 
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64 
sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn*
```

验证cudnn安装成功：

```python
# CUDA 10.2
conda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia
vim test.py
```

```python
import torch
# 若正常则静默
a = torch.tensor(1.)
# 若正常则静默
print(a.cuda())
# 若正常则返回 tensor(1., device='cuda:0')
from torch.backends import cudnn
# 若正常则静默
print(cudnn.is_available())
# 若正常则返回 True
print(cudnn.is_acceptable(a.cuda()))
# 若正常则返回 True
```


# 总的来说

```shell
#!/bin/bash
cd /data
scp -r root@10.10.14.36:/data/datagpu/ /data
sudo yum install wget vim -y
sudo yum install centos-release-scl -y # 安装centos-release-scl  红帽自带工具让原始gcc和你新安装的共存
sudo yum install devtoolset-8-gcc*  -y  #安装devtoolset，注意，如果想安装7.*版本的，就改成devtoolset-7-gcc*，以此类推
scl enable devtoolset-8 bash  # 激活对应的devtoolset，所以你可以一次安装多个版本的devtoolset，需要的时候用下面这条命令切换到对应的版本
gcc -v # 查看版本
cd /data/datagpu/
sh cuda_11.1.0_455.23.05_linux.run
echo "export LD_LIBRARY_PATH=/usr/local/cuda-11.1/lib64" >>/etc/profile
echo "export PATH=$PATH:/usr/local/cuda-11.1/bin" >>/etc/profile
echo "export CUDA_HOME=/usr/local/cuda-11.1" >>/etc/profile
source /etc/profile
nvcc -V
tar -zxvf cudnn-11.1-linux-x64-v8.0.5.39.tgz # 解压后就是cuda文件夹
sudo cp cuda/include/cudnn*.h /usr/local/cuda/include 
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64 
sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn*
sh Miniconda3-py38_4.9.2-Linux-x86_64.sh
rm -rf ~/.condarc
vim ~/.condarc
channels:
  - defaults
show_channel_urls: true
channel_alias: https://mirrors.bfsu.edu.cn/anaconda
default_channels:
  - https://mirrors.bfsu.edu.cn/anaconda/pkgs/main
  - https://mirrors.bfsu.edu.cn/anaconda/pkgs/free
  - https://mirrors.bfsu.edu.cn/anaconda/pkgs/r
  - https://mirrors.bfsu.edu.cn/anaconda/pkgs/pro
  - https://mirrors.bfsu.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.bfsu.edu.cn/anaconda/cloud
  msys2: https://mirrors.bfsu.edu.cn/anaconda/cloud
  bioconda: https://mirrors.bfsu.edu.cn/anaconda/cloud
  menpo: https://mirrors.bfsu.edu.cn/anaconda/cloud
  pytorch: https://mirrors.bfsu.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.bfsu.edu.cn/anaconda/cloud
source ~/.bashrc
conda create -n torch python=3.8
source ~/.bashrc
conda activate torch
conda install -y pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia
python test.py
```

Linux CentOS7 深度学习环境 安装 CUDA Cudnn 验证安装成功 3080Ti 显卡 pytorch验证

Python





```python
yum whatprovides */lspci
yum install pciutils
```

这样就能：

```python
lspci  | grep -i vga
```

没有可用软件包 lspci yum install pciutils

Python





```python
img = cv2.imread(os.path.join(filepath, name))
dst = cv2.resize(img, (img.shape[1]//4, img.shape[0]//4))
cv2.imwrite(os.path.join(aimpath, "image" + str(num).zfill(6)) + ".jpg", dst)
```

Python opencv 图像缩放

Python tsfresh 自动计算大量的时间序列特征

[https://zhuanlan.zhihu.com/p/99069186](https://zhuanlan.zhihu.com/p/99069186)

LightGBM 决策树 gradient boosting framework

图片文件如果相同，md5是一样的。于是利用此进行图片去重。





```python
import os
import hashlib
def get_md5(file):
    file = open(file, 'rb')
    md5 = hashlib.md5(file.read())
    file.close()
    md5_values = md5.hexdigest()
    return md5_values
file_path =  r"D:\Users\Administrator\Desktop\smokingsig\yolov5k\images"
os.chdir(file_path)
file_list = os.listdir(file_path)
md5_list = []
for file in file_list:
    md5 = get_md5(file)
    if md5 not in md5_list:
        md5_list.append(md5)
    else:
        os.remove(file)
```

相似度  计算量非常大，不太好用：
```python
# -*- encoding=utf-8 -*-
import cv2
import os
class dup_picture:
    def __init__(self):
        self.orb = cv2.ORB_create()
        self.bf = cv2.BFMatcher(cv2.NORM_HAMMING)
    def get_pic_desc(self, img1_path: str):
        img1 = cv2.imread(img1_path, cv2.IMREAD_GRAYSCALE)
        kp1, des1 = self.orb.detectAndCompute(img1, None)
        return des1
    def get_similary(self, des1, des2):
        # knn筛选结果
        matches = self.bf.knnMatch(des1, trainDescriptors=des2, k=2)
        # 查看最大匹配点数目
        good = [m for (m, n) in matches if m.distance < 0.75 * n.distance]
        if len(matches) == 0:
            return 0
        similary = len(good) / len(matches)
        return similary
if __name__ == '__main__':
    duptool = dup_picture()
    file_path = r"D:\PycharmProjects\downloadpicture\all_smoking_picture"
    file_list = os.listdir(file_path)
    file_list = list(filter(lambda x: x.endswith(".jpg"), file_list))  # must .jpg pic
    os.chdir(file_path)
    unique_list = [duptool.get_pic_desc(file_list[0]), ]
    for k,file in enumerate(file_list[1:]):
        print(k)
        des = duptool.get_pic_desc(file)
        if des is None:
            os.remove(file)
            continue
        for des_i in unique_list:
            if duptool.get_similary(des, des_i) > 0.5:
                os.remove(file)
                print(file)
                break
        else:  # Smooth and uninterrupted execution completed
            unique_list.append(des)
```


其余labels处理：

```python
import os
imagespath = r"D:\Users\Administrator\Desktop\smokingsig\yolov5k\images"
labelspath = r"D:\Users\Administrator\Desktop\yololabels"
img_list = os.listdir(imagespath)
lab_list = os.listdir(labelspath)
# ---- read label ----> if none label ----> delete label file
for name in lab_list:
    lfile = os.path.join(labelspath, name)
    if "image" in name:
        with open(lfile, "r") as f:
            res = f.readlines()
        if len(res) == 0:
            os.remove(lfile)
# ---- read label ----> if  label str too short ----> delete label file
for name in lab_list:
    lfile = os.path.join(labelspath, name)
    if "image" in name:
        with open(lfile, "r") as f:
            res = f.readlines()
        if len(res[0]) < 3:
            os.remove(lfile)
# ---- read images names ----> if have not label file ----> delete imgfile
for name in img_list:
    if name[:-4] + ".txt" not in lab_list:
        os.remove(os.path.join(imagespath, name))
```

Python 图片去重 图片文件去重 依据相似度去重 cv2.ORB

# 四种POST 请求方式：





[https://imququ.com/post/four-ways-to-post-data-in-http.html#toc-2](https://imququ.com/post/four-ways-to-post-data-in-http.html#toc-2)

Content-Type: application/x-www-form-urlencoded  最原始表单，参数单一，不能传文件。

Content-Type:multipart/form-data  改进后的表单，能传文件。

Content-Type: application/json  倾向于传json，json规范导致前后端传数据都喜欢用这个，数据生产和消费简单。

# FastAPI 中如何支持

[https://fastapi.tiangolo.com/zh/tutorial/schema-extra-example/](https://fastapi.tiangolo.com/zh/tutorial/schema-extra-example/)

把函数参数改为Body解析即可，而不是FORM解析。

```python
# -*- coding:utf-8 -*-
import traceback
import uvicorn
from typing import Optional
from fastapi import Body, FastAPI
from pydantic import BaseModel
from fastapi.middleware.cors import CORSMiddleware
app = FastAPI(
    title='FastAPI',
    description='FastAPI',
    version='1.0.0',
    docs_url='/docs',
    redoc_url='/redocs',
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None
@app.post("/items/{item_id}")
async def update_item(
        item_id: int,
        item: Item = Body(
            ...,
            example={
                "name": "Foo",
                "description": "A very nice Item",
                "price": 35.4,
                "tax": 3.2,
            },
        ),
):
    results = {"item_id": item_id, "item": item}
    return results
if __name__ == '__main__':
    uvicorn.run('fastapia:app', host='0.0.0.0', port=8001, reload=False, debug=False, workers=1)
```

# PostMan 测试

修改请求头

![在这里插入图片描述](/static/img/images/00319.png)

写raw的原生json字符串

![在这里插入图片描述](/static/img/images/00320.png)


```python
import requests
requests.post(url="http://0.0.0.0:8001/items/1",
              json={
                  "name": "Foo",
                  "description": "A very nice Item",
                  "price": 35.4,
                  "tax": 3.2,
              },
              )
```

FastAPI python content-type: application/json

参考:[https://blog.csdn.net/haveanybody/article/details/86494063](https://blog.csdn.net/haveanybody/article/details/86494063)





# 基础

cv2 打开图片，tensor的shape是（im_height, im_width, channel），BGR格式。**cv2.imread返回的是numpy.ndarray张量。**

pillow 打开图片，RGB格式。Pillow读出来的是PIL.Image.Image对象。

# 打开图片与保存图片

```python
##PIL 读取、保存图片方法
from PIL import Image
img = Image.open("eee.jpg")
img.save("eee_result.jpg")
##cv2 读取、保存图片方法
import cv2
img = cv2.imread("eee.jpg")
cv2.imwrite("eee_result.jpg", img)
##图片文件打开为base64
import base64
def img_base64(img_path):
    with open(img_path, "rb") as f:
        base64_str = base64.b64encode(f.read())
    return base64_str
```

# CV2中的  BGR转RGB

```python
from matplotlib import pyplot as plt
import cv2
img = cv2.imread("eee.jpg")
cv2.imwrite("eee_result.jpg", img)
imgrgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(imgrgb)
plt.show()
```

# PIL CV2 的相互转换

```python
## PIL转cv2
import cv2
from PIL import Image
import numpy as np
img_rgb = Image.open("eee.jpg")
img_bgr = cv2.cvtColor(np.asarray(img_rgb), cv2.COLOR_RGB2BGR) # 成为cv2的numpy.ndarray
```

```python
## PIL转cv2
import cv2
from PIL import Image
img_bgr = cv2.imread("eee.jpg")
img_rgb = Image.fromarray(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)) # 成为Pillow的PIL.Image.Image对象
```


# PIL base64 的相互转换

```python
##PIL转base64
import base64
from io import BytesIO
from PIL import Image
def pillow_to_base64(image):
    img_buffer = BytesIO()
    image.save(img_buffer, format='JPEG')
    byte_data = img_buffer.getvalue()
    base64_str = base64.b64encode(byte_data)
    return base64_str
# example
img = Image.open("eee.jpg")
print(pillow_to_base64(img))
```

```python
##PIL转base64
import base64
from io import BytesIO
from PIL import Image
def base64_to_pillow(base64_str):
    image = base64.b64decode(base64_str)
    image = BytesIO(image)
    image = Image.open(image)
    return image
# example
with open("eee.jpg", "rb") as f:
    base64_str = base64.b64encode(f.read())
print(base64_to_pillow(base64_str))
```

# CV2 base64 的相互转换

```python
# cv2 转 base64
import base64
import cv2
def cv2_to_base64(image):
    base64_str = cv2.imencode('.jpg', image)[1].tostring()
    base64_str = base64.b64encode(base64_str)
    return base64_str
# example
image = cv2.imread("eee.jpg")
print(cv2_to_base64(image))
```

```python
# base64 转 cv2
import base64
import numpy as np
import cv2
from PIL import Image
from io import BytesIO
def base64_to_cv2(base64_str):
    imgString = base64.b64decode(base64_str)
    nparr = np.frombuffer(imgString, np.uint8)
    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
    return image
# example
with open("eee.jpg", "rb") as f:
    base64_str = base64.b64encode(f.read())
print(base64_to_cv2(base64_str))
```


# FastAPI中bytes 转CV2

```python
img = cv2.imdecode(np.frombuffer(file, dtype=np.uint8), cv2.IMREAD_COLOR)
```

# FastAPI中uploadfile  转CV2

```python
img = cv2.imdecode(np.fromstring(fileb.file.read(), np.uint8), cv2.IMREAD_COLOR)
```


# CV2 numpy  转成 字节流（open("file.jpg",'rb')）

参考：[https://blog.csdn.net/sinat_29957455/article/details/107208432](https://blog.csdn.net/sinat_29957455/article/details/107208432)

```python
img = cv2.imread("lpr1.png")
# 对数组的图片格式进行编码
success, encoded_image = cv2.imencode(".jpg", img)
# 将数组转为bytes
f = encoded_image.tobytes()
```

cv2 pillow base64 bytes uploadfile 图片文件之间的转换 FastAPI

#  FastAPI 服务





下面是代码，

`@app.post("/files/")` 路由让我们可以传文件。

`@app.post("/uploadfiles/")`路由让我们可以传多个文件。

需要保证：

（1） uvicorn.run中写的是文件名：app名，确保自己的文件名。

（2）`# python 3.8   pip install fastapi uvicorn python-multipart`

```python
# -*- coding:utf-8 -*-
import traceback
from typing import List, Optional, Union
import uvicorn
from fastapi.middleware.cors import CORSMiddleware
from fastapi import FastAPI, File, Form, UploadFile
import cv2
import numpy as np
app = FastAPI(
    title='FastAPI Tutorial',
    description='FastAPI教程',
    version='1.0.0',
    docs_url='/docs',
    redoc_url='/redocs',
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
@app.post("/files/")
async def alg_file(
        fileb: UploadFile = File(...),
        token: str = Form(...)
):
    try:
        img = cv2.imdecode(np.fromstring(fileb.file.read(), np.uint8), cv2.IMREAD_COLOR)
        return {
            "token": token,
            "filename": fileb.filename,
            "content_type": fileb.content_type,
            "size": img.shape
        }
    except:
        traceback.print_exc()
        return -1
@app.post("/uploadfiles/")
async def create_upload_files(files: List[UploadFile] = File(...)):
    return {"filenames": [file.filename for file in files]}
@app.post("/filesper/")
def filesper(
        file: Optional[bytes] = File(None),
        fileb: Optional[UploadFile] = File(None),
        filepath: Optional[str] = Form(None),
):
    try:
        if file:
            img = cv2.imdecode(np.frombuffer(file, dtype=np.uint8), cv2.IMREAD_COLOR)
            return {
                "size": img.shape,
                "style": "bytes"
            }
        if fileb:
            img = cv2.imdecode(np.fromstring(fileb.file.read(), np.uint8), cv2.IMREAD_COLOR)
            return {
                "filename": fileb.filename,
                "content_type": fileb.content_type,
                "size": img.shape,
                "style": "UploadFile"
            }
        if filepath:
            return {
                "str": filepath,
                "style": "str"
            }
    except:
        traceback.print_exc()
        return -1
if __name__ == '__main__':
    uvicorn.run('yolo5fastapi:app', host='0.0.0.0', port=8001, reload=False, debug=False, workers=1)
```


#  requests 测试

## requests 单一文件上传

测试上传一个图片文件：

```python
import requests
url = "http://0.0.0.0:8001/files/"
with open("/home/kevin_xie/yifeinfs/pycharm_k/yolov5_v2/kevin/picture/realcamera.jpg", "rb") as f:
    res = requests.post(url=url, data={"token": "sdas"}, files={"fileb": f}, timeout=None)
    print(res.json())
```

返回：

```python
{'token': 'sdas', 'filename': 'realcamera.jpg', 'content_type': '', 'size': [720, 1280, 3]}
```

## requests 多个文件上传

注意给文件参数的方式，元组和列表均可，可自由尝试。
```python
import requests
url = "http://0.0.0.0:8001/uploadfiles/"
with open("/home/kevin_xie/yifeinfs/pycharm_k/yolov5_v2/kevin/picture/realcamera.jpg", "rb") as f:
    res = requests.post(url=url, files=[("files", f), ("files", f), ("files", f)], timeout=None)
    print(res.json())
```

Python fastapi requests 传文件方式 上传文件 上传多个文件 UploadFile模板方式 上传图片

# 1 Flask 路由阻塞





当启动一个Flask APP如下，在同一浏览器开2个窗口访问这个服务（我的是http://172.18.43.32:8001/hello），前一个请求没返回时，另外一个窗口的相同请求不会有反应。

这是浏览器的锅，同一请求会顺序执行，此时可以用同一台电脑的不同浏览器测试，可以发现不会存在路由阻塞。
```python
import time
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello_world():
    print("receive !")
    time.sleep(20)
    return 'Hello World!'
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)
```

# 2 requests访问

- 换个方式，使用requests访问，线程池中100个线程同时执行访问：

```python
import requests
from concurrent.futures import ThreadPoolExecutor
def task():
    res = requests.request(method="GET", url="http://172.18.43.32:8001/hello", timeout=None)
executor = ThreadPoolExecutor(max_workers=100)
for i in range(100):
    executor.submit(task)
```

还是可以看见不会阻塞。


# 3 FastAPI 路由阻塞

下面的情况下，访问就会阻塞。


```python
# -*- coding:utf-8 -*-
import asyncio
import time
import uvicorn
from fastapi.middleware.cors import CORSMiddleware
from fastapi import FastAPI, File, Form, UploadFile
import cv2
import numpy as np
app = FastAPI(
    title='FastAPI Tutorial',
    description='FastAPI教程',
    version='1.0.0',
    docs_url='/docs',
    redoc_url='/redocs',
)
@app.get("/hello")
async def hl():
    print("receive !")
    time.sleep(20)
    return {
        "token": "ads"
    }
def fastweb():
    uvicorn.run('deal:app', host='0.0.0.0', port=8001, reload=False, debug=False, workers=1)
if __name__ == '__main__':
    fastweb()
```

原因：在async标识的函数中使用同步方法time.sleep(20)，这导致了一个异步程序之间的同步问题，出现了错误！这种写法本身就是错误的，加async 是想利用Python的协程机制 将路由变成异步请求， 进一步提高并发量！只要考虑加async ，那么就得好好设计函数内部， 多用一些异步方法，比如可以写成：

```python
@app.get("/hello")
async def hl():
    print("receive !")
    await asyncio.sleep(20)
    return {
        "token": "ads"
    }
```

设计合理就会极大利用起协程异步，从而极大提高并发量，设计不合理就是呆瓜。若是分不清，还是老老实实和Flask一样写法：

```python
@app.get("/hello")
def hl():
    print("receive !")
    time.sleep(20)
    return {
        "token": "ads"
    }
```

这样也是出现不了路由阻塞的。

# 4 总结：同步并发 异步并发

1 Flask 中的属于同步并发，可以无阻塞访问！但要注意别让浏览器欺骗你！

2 FastAPI 支持异步框架，支持是支持，前提是你得用好它，不然就呆瓜。用好了并发量就提升了！

3 FastAPI 中同样支持Flask 那样子的同步并发，和Flask 一样一样的，但要注意写法！

4 FastAPI 貌似比 Flask 更强大！

# 参考

java web

golang 协程

Flask FastAPI 路由阻塞 Web Python 访问同一url出现阻塞 同步 异步 并发

# 何为bytes？





是Python3的数据类型，详见：[http://c.biancheng.net/view/2175.html](http://c.biancheng.net/view/2175.html)。

# np.frombuffer

返回一维数组：

![在这里插入图片描述](/static/img/images/00321.png)

# cv2.imdecode

cv2.imdecode()函数从指定的内存缓存中读取数据，并把数据转换(解码)成图像格式;主要用于从网络传输数据中恢复出图像。

cv2.imencode()函数是将图片格式转换(编码)成流数据，赋值到内存缓存中;主要用于图像数据格式的压缩，方便网络传输。

# bytes转图片numpy矩阵
```python
img = cv2.imdecode(np.frombuffer(file, dtype=np.uint8), cv2.IMREAD_COLOR)
```

# 逆运算 numpy矩阵转bytes

这里的img_bytes 就是bytes的file
```python
# 对数组的图片格式进行编码
success, encoded_image = cv2.imencode(".jpg", img)
# 将数组转为bytes
img_bytes = encoded_image.tostring()
```

# bytes转图片numpy矩阵


# 完整代码：

```python
# -*- coding:utf-8 -*-
import uvicorn
from fastapi.middleware.cors import CORSMiddleware
from fastapi import FastAPI, File, Form, UploadFile
import cv2
import numpy as np
from io import BytesIO
app = FastAPI(
    title='FastAPI Tutorial',
    description='FastAPI教程',
    version='1.0.0',
    docs_url='/docs',
    redoc_url='/redocs',
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
@app.post("/files/")
async def alg_file(
        file: bytes = File(...),
        token: str = Form(...)
):
    img = cv2.imdecode(np.frombuffer(file, dtype=np.uint8), 1)
    return {
        "token": token,
        "size": img.shape
    }
if __name__ == '__main__':
    uvicorn.run('run1:app', host='0.0.0.0', port=8002, reload=True, debug=True, workers=1)
```

FastAPI bytes转矩阵 bytes转图片 bytes opencv URL传文件 POST FORM Python

Opencv 读取的图片是BGR 矩阵：




```python
import cv2 
import matplotlib.pyplot as plt
img=cv2.imread('./res.jpg')
plt.imshow(img)
plt.show()
```

plt显示方法imshow是默认矩阵是RGB的，

![在这里插入图片描述](/static/img/images/00322.png)

想要正确显示，需要：

```python
imgrgb= cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(imgrgb)
plt.show()
```

![在这里插入图片描述](/static/img/images/00323.png)

Opencv Python 图片通道 BGR 转 RGB imgrgb= cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

读取




```python
import cv2
import numpy as np 
img = cv2.imdecode(np.fromfile("./人物-1.jpg", dtype=np.uint8), 1) # img是矩阵
```

写入：

```python
import cv2
cv2.imencode('.jpg', img)[1].tofile(os.path.join(self.keyword, self.keyword + str(count) + ".jpg"))
```

Python cv2.imread 无法打开中文路径的图像

当有字典x和字典y，想合并为字典z。





-------------------------------

Python 3.9 + 提供了最简单的方法：

`z = x | y          # NOTE: 3.9+ ONLY`

-------------------------------

Python 3.5 + 的方法：

`z = {**x, **y}`

-------------------------------

Python 3.4 or lower  的方法，使用update方法写一个合并方法：

```python
def merge_dicts(*dict_args):
    """
    Given any number of dictionaries, shallow copy and merge into a new dict,
    precedence goes to key-value pairs in latter dictionaries.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result
```

或者直接：

`z = x.update( y )`

-------------------------------

参考1 ： [stackoverflow](https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression-taking-union-of-dictiona)