之前使用milvus+vgg做图像检索，好像一切都是黑匣子，今日看到一篇pdf介绍图像检索。大体说来，使用一些滤波器提取图像内容的特征表达，然后使用索引加速的一些方式来做图像检索。想来milvus内部也是使用了KD-tree之类的算法搜索树。





- 相似检索

颜色、纹理、形状

局部特征点

词包（Bag of visual word）

- 大数据集的索引加速

KD-tree

局部敏感哈希（Locality Sensitive Hash）

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

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



pdf: 
```cpp
链接：https://pan.baidu.com/s/1BvuDhyXkdDKyoB2ofmzXJA 
提取码：4h7j 
--来自百度网盘超级会员V8的分享
```

【基于图像内容】图像检索 Image retrieval

是小波变换的内容，有空得学习一下小波变换：





[https://www.cnblogs.com/picassooo/p/13390115.html](https://www.cnblogs.com/picassooo/p/13390115.html)

【图像处理】Gabor滤波器 纹理特征提取

首先弄一个带宽高的服务器：




```
https://www.aliyun.com/minisite/goods?userCode=28kqeewo&accounttraceid=70263e6b6d5141c4807d779046c7ae45qyor
```

然后参考：

[https://www.cnblogs.com/6324/p/12516047.html](https://www.cnblogs.com/6324/p/12516047.html)

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

注意这个：

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

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

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

windows10如何使用：

[https://www.kuaidaili.com/doc/using/win10/](https://www.kuaidaili.com/doc/using/win10/)

CentOS 搭建服务器 阿里云使用

（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

# 四种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

# 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)]

Flask 学习过程

[https://wenku.baidu.com/view/f2167c06cdbff121dd36a32d7375a417866fc182.html?from=search](https://wenku.baidu.com/view/f2167c06cdbff121dd36a32d7375a417866fc182.html?from=search)





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

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

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

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

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

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

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

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

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

linux系统命令

# 1、基础条件：





**装了Xshell：**

[https://blog.csdn.net/x1131230123/article/details/101104888](https://blog.csdn.net/x1131230123/article/details/101104888)

**有了阿里云服务器，并打开5000端口。**

[https://blog.csdn.net/x1131230123/article/details/101105151](https://blog.csdn.net/x1131230123/article/details/101105151)

**安装了pycharm**

[https://blog.csdn.net/x1131230123/article/details/101106986](https://blog.csdn.net/x1131230123/article/details/101106986)

**为pycharm添加了ssh远程解释器**

[https://blog.csdn.net/x1131230123/article/details/101105052](https://blog.csdn.net/x1131230123/article/details/101105052)



# 2、打开pycharm，创建flask项目，写入代码。

```
from flask import Flask
from gevent.pywsgi import WSGIServer
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello World!'
if __name__ == '__main__':
    http_server = WSGIServer(('0.0.0.0', 5000), app)
    http_server.serve_forever()
```

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

# 3、点击运行，让文件同步到服务器。（其实这一步就已经完事了，后面介绍的是从服务器搞事情）

我这里映射到服务器的 /tmp/pycharm_project_209

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

4、打开Xshell，找到文件夹 /tmp/pycharm_project_209

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

5、

在后台进程一直运行这个flask项目命令：nohup python app.py &

然后输入exit，退出ssh连接。

这样这个项目就一直运行在服务器后台进程了。

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

6、打开随便一台联网电脑的浏览器，可以连接上。

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

6、再次连接ssh，查看进程命令ps -aux |grep py

可以看到这个命令在后台运行着。

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

7、kill掉进程命令 kill 1263

发布Flask项目到服务器

Jetbrains 官方下载这个盒子。





 

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

分别是写C的，写java的，写php的，写python的。破解方法都一样。


=======    Jetbrains Activation Code And License Server Crack    =======

 =======                     https://zhile.io                     =======


破解教程均由上述提供。

安装好pycharm后，打开，选试用，选VM

在打开的vmoptions编辑窗口末行添加："-javaagent:/absolute/path/to/jetbrains-agent.jar"

一定要自己确认好路径，填错会导致IDE打不开！！！最好使用绝对路径。


然后重新打开软件，填入code。

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

 

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

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

 



-javaagent:D:\Program Files\JetBrains\jetbrains-agent\jetbrains-agent.jar


 


写入code

pycharm 专业版

还是学生，可便宜。





怎么选服务器类型？

[https://yq.aliyun.com/articles/714858](https://yq.aliyun.com/articles/714858)

自己玩WEB开发选轻量应用服务器，随时一言不合直接重置系统就行。

没学生优惠得自己看着配置来。

预装环境可以由应用型的或者纯净系统，没都没有。

区域没得选，不是学生的话可以买在国外的服务器（这样域名绑定服务器的时候就不用备案了，不要域名DNS绑定的就不用考虑国外还是国内）。

国内主机网络稳定得多（估计是政策原因）。

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

进阿里云网站，登录，然后点击  购买的轻量服务器。

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

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

就可以看到刚购买的服务器。

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

阿里服务器不是所有端口直接开放暴露的，需要自己配置。22端口是ssh端口，80是默认访问端口，后面5000是我自己加的，准备开发一个flask项目放5000端口。

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

远程SSH连接需要配置密码，重置系统后密码失效，得重新配置。

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

可以申请一个域名，绑定到你的服务器IP

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

阿里云服务器 配置与使用

新建一个flask项目





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

1 配置远程服务器解释器

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

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

 形成文件映射

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

 配置好后 可以去这个界面看配置

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

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

 

3 发布

 直接运行，会在服务器端运行。