参考:[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

# 1 安装FastAPI





```powershell
# python 3.8
pip install fastapi uvicorn python-multipart
```

# 2 简单的例子 启动FastAPI服务

需要学习：

- 路由组织

- CORS跨域问题

- uvicorn启动

`run1.py  : `

```python
# -*- coding:utf-8 -*-
import uvicorn
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from test_ok import app03
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=["*"],
)
app.include_router(app03, prefix='/c3', tags=['test 3'])
@app.get("/hello")
async def path_params01():
    return {"hello world"}
if __name__ == '__main__':
    uvicorn.run('run1:app', host='0.0.0.0', port=8001, reload=True, debug=True, workers=1)
```

`test_ok.py :`

```python
# -*- coding:utf-8 -*-
from fastapi import APIRouter
app03 = APIRouter()
@app03.get("/path/parameters")
def path_params01():
    return {"message": "This is a message"}
```

`启动：`

```powershell
sudo /home/kevin_xie/miniconda3/envs/fastapi/bin/python run1.py
```


# 3 启动服务 单一文件

`run1.py :`

```python
# -*- coding:utf-8 -*-
import uvicorn
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
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.get("/hello")
async def path_params01():
    return {"hello world"}
if __name__ == '__main__':
    uvicorn.run('run1:app', host='0.0.0.0', port=8001, reload=True, debug=True, workers=1)
```

`启动：`

```powershell
sudo /home/kevin_xie/miniconda3/envs/fastapi/bin/python run1.py
```

# 3 使用UploadFile上传图片和表单

```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
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(...)
):
    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
    }
if __name__ == '__main__':
    uvicorn.run('run1:app', host='0.0.0.0', port=8001, reload=True, debug=True, workers=1)
```

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


# 4 使用File上传图片和表单 

```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)
```


# 5 特点对比，为什么选FastAPI 

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

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

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

# 参考

FastAPI中文文档：[https://fastapi.tiangolo.com/zh/features/](https://fastapi.tiangolo.com/zh/features/)

FastAPI的一个项目：[https://github.com/liaogx/fastapi-tutorial](https://github.com/liaogx/fastapi-tutorial)

FastAPI 学习笔记 demo FastAPI对比特点 为什么选FastAPI 开启服务

Python





```python
# coding:utf-8
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return "HELLO WORLD"
if __name__ == '__main__':
    app.run(host="0.0.0.0", debug=True, port=2020)
```

gunicorn.conf
```python
workers = 5  # 定义同时开启的处理请求的进程数量，根据网站流量适当调整
worker_class = "gevent"  # 采用gevent库，支持异步处理请求，提高吞吐量
bind = "0.0.0.0:2333"
```


运行sh

```python
nohup /home/kevin_xie/miniconda3/envs/py37kevin/bin/gunicorn app:app -c gunicorn.conf.py >> flask.log 2>&1 &
```

flask 拉起 gunicorn

初始化数据库信息





```
# coding:utf-8
import sqlite3
# 没有就建立数据库 有的话就打开
conn = sqlite3.connect('wulian.db')
cursor = conn.cursor()
cursor.execute('create table tempbiao (id varchar(20) primary key, tempvalue float(32),kaiguan int(16))')
cursor.execute('insert into tempbiao (id, tempvalue,kaiguan) values (\'1\', \'2.365\', \'0\')')
cursor.close()
conn.commit()
conn.close()
```

开启服务

```
# coding:utf-8
from flask import Flask
from gevent.pywsgi import WSGIServer
import sqlite3
app = Flask(__name__)
# 接受浮点数字 传感器访问
@app.route('/mcum/<float:revNo>')
def mcum(revNo):
    # 没有就建立数据库 有的话就打开
    conn = sqlite3.connect('wulian.db')
    cursor = conn.cursor()
    sql = "Update tempbiao Set tempvalue='{0}' Where ID='{1}'".format(revNo, '1')
    cursor.execute(sql)
    conn.commit()
    cursor.close()
    conn.close()
    return '写入的结果是 %f' % revNo
@app.route('/androidm/<int:NO>')
def androidmodifykaiguan(NO):
    # 没有就建立数据库 有的话就打开
    conn = sqlite3.connect('wulian.db')
    cursor = conn.cursor()
    sql = "Update tempbiao Set kaiguan='{0}' Where ID='{1}'".format(NO, '1')
    cursor.execute(sql)
    conn.commit()
    cursor.close()
    conn.close()
    return "OK"
# 手机查询数据库变量 返回回去
@app.route('/androidcheck')
def checkdata():
    # 没有就建立数据库 有的话就打开
    conn = sqlite3.connect('wulian.db')
    cursor = conn.cursor()
    cursor.execute('select * from tempbiao where id=?', ('1',))
    checkresult = cursor.fetchall()
    cursor.close()
    conn.close()
    checkresult=str(list(checkresult[0])[1])
    return checkresult
@app.route('/mcucheck')
def mcugetkaigaun():
    # 没有就建立数据库 有的话就打开
    conn = sqlite3.connect('wulian.db')
    cursor = conn.cursor()
    cursor.execute('select * from tempbiao where id=?', ('1',))
    checkresult = cursor.fetchall()
    print(checkresult)
    cursor.close()
    conn.close()
    checkresult=str(list(checkresult[0])[2])
    return checkresult
if __name__ == '__main__':
    # http_server = WSGIServer(('0.0.0.0', 5000), app)
    # http_server.serve_forever()
    app.run(port=5000)
```

Flask sqlite3 服务器脚本

安装





> apt update apt upgrade apt install gcc wget

> http://www.python.org/ftp/python/3.7.0/Python-3.7.0.tgz tar -xvzf

> Python-3.7.0.tgz cd Python-3.7.0 ./configure --with-ssl make

> 

> sudo apt install build-essential python-dev python-setuptools

> python-pip python-smbus build-essential libncursesw5-dev libgdbm-dev

> libc6-dev zlib1g-dev libsqlite3-dev tk-dev libssl-dev openssl

> libffi-dev

> 

> sudo make install

安装Python编译外部模块文件使用的Python-dev

> sudo apt install aptitude 

> sudo apt install python-dev

升级

> sudo pip3 install --upgrade pip

阿里云服务器Ubuntu18.04，安装Python版本Python3.7

新的Ubuntu 18.04阿里云服务器





保持python2.7不动，安装python3.5

进入Xshell.

执行

更新apt
```
apt update
```

linux 安装python3

[**教程地址点我**](https://www.w3cschool.cn/flask/flask_variable_rules.html)





## 1、靠装饰器绑定URL规则和函数

```
#coding:utf-8
from flask import Flask
from gevent.pywsgi import WSGIServer
app = Flask(__name__)
# 靠装饰器绑定URL规则和函数
@app.route('/hello')
def hello_world():
    return 'Hello World!'
if __name__ == '__main__':
    http_server = WSGIServer(('0.0.0.0', 5000), app)
    http_server.serve_forever()
```

## 2、通过向规则参数添加变量部分，可以动态构建URL。

@app.route('/hello/<name>')

@app.route('/blog/<int:postID>')

@app.route('/rev/<float:revNo>')

@app.route('/python/')

```
# coding:utf-8
from flask import Flask
from gevent.pywsgi import WSGIServer
app = Flask(__name__)
# 接受浮点数字
@app.route('/revdata/<float:revNo>')
def revision(revNo):
    result = revNo * 3.
    return '接收到的数值乘以三的结果是 %f' % result
if __name__ == '__main__':
    http_server = WSGIServer(('0.0.0.0', 5000), app)
    http_server.serve_forever()
```

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

## 3、依靠动态URL，直接把这个数值存入数据库

3.1 新建一个python脚本。里面写创建一个数据库wulian.db，创建一个表tempbiao（id，tempvalue），然后插入一条记录里。然后运行。
```
# coding:utf-8
import sqlite3
# 没有就建立数据库 有的话就打开
conn = sqlite3.connect('wulian.db')
cursor = conn.cursor()
cursor.execute('create table tempbiao (id varchar(20) primary key, tempvalue float(32))')
cursor.execute('insert into tempbiao (id, tempvalue) values (\'1\', \'2.365\')')
cursor.close()
conn.commit()
conn.close()
```

打开服务器路径下查看，的确创建了wulian.db：

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

3.2 查看数据库wulian.db里tempbiao 表里的记录。新建一个python脚本。

```
# coding:utf-8
import sqlite3
# 没有就建立数据库 有的话就打开
conn = sqlite3.connect('wulian.db')
cursor = conn.cursor()
cursor.execute('select * from tempbiao where id=?', ('1',))
print (cursor.fetchall())
cursor.close()
conn.close()
```

print输出了：[(u'1', 2.365)]

3.3 修改数据库wulian.db里tempbiao 表里的记录。将浏览器传入的url信息写入数据库（这样可不安全）。

 
```
# coding:utf-8
from flask import Flask
from gevent.pywsgi import WSGIServer
import sqlite3
app = Flask(__name__)
# 接受浮点数字
@app.route('/revdata/<float:revNo>')
def revision(revNo):
    # 没有就建立数据库 有的话就打开
    conn = sqlite3.connect('wulian.db')
    cursor = conn.cursor()
    sql = "Update tempbiao Set tempvalue='{0}' Where ID='{1}'".format(revNo, '1')
    cursor.execute(sql)
    conn.commit()
    cursor.close()
    conn.close()
    return '写入的结果是 %f' % revNo
if __name__ == '__main__':
    http_server = WSGIServer(('0.0.0.0', 5000), app)
    http_server.serve_forever()
```

这样后，浏览器访问一下：

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

再次查看这条表记录[(u'1', 14.1)]