Python





```
AttributeError: partially initialized module 'qrcode' has no attribute 'make' (most likely due to a circular import)
```

不要使用qrcode作为你的文件名即可解决这个问题。

AttributeError: partially initialized module ‘qrcode‘ has no attribute ‘make‘ (most likely due to a

<html>





    <head>

        <title></title>

    </head>

    <body>

        <table>

            <tbody>

                <tr>

                    <th>

                        类别

                    </th>

                    <th>

                        规范

                    </th>

                    <th>

                        示例

                    </th>

                </tr>

                <tr>

                    <td>

                        模块名

                    </td>

                    <td>

                        小写字母，单词之间用_分割

                    </td>

                    <td>

                        ad_stats.py

                    </td>

                </tr>

                <tr>

                    <td>

                        包名

                    </td>

                    <td>

                        小写字母，单词之间用_分割

                    </td>

                    <td>

                        &nbsp;

                    </td>

                </tr>

                <tr>

                    <td>

                        类名

                    </td>

                    <td>

                        单词首字母大写

                    </td>

                    <td>

                        AdStats

                    </td>

                </tr>

                <tr>

                    <td>

                        全局变量名

                    </td>

                    <td>

                        大写字母，单词之间用_分割

                    </td>

                    <td>

                        COLOR_WRITE

                    </td>

                </tr>

                <tr>

                    <td>

                        普通变量

                    </td>

                    <td>

                        小写字母，单词之间用_分割

                    </td>

                    <td>

                        this_is_a_var

                    </td>

                </tr>

                <tr>

                    <td>

                        实例变量

                    </td>

                    <td>

                        以_开头，其他和普通变量一样

                    </td>

                    <td>

                        _instance_var

                    </td>

                </tr>

                <tr>

                    <td>

                        私有实例变量

                    </td>

                    <td>

                        以__开头（两个下划线），其他和普通变量一样

                    </td>

                    <td>

                        __private_var

                    </td>

                </tr>

                <tr>

                    <td>

                        专有变量

                    </td>

                    <td>

                        以__开头，__结尾，一般为python的自有变量

                    </td>

                    <td>

                        __doc__

                    </td>

                </tr>

                <tr>

                    <td>

                        普通函数

                    </td>

                    <td>

                        小写字母，单词之间用_分割

                    </td>

                    <td>

                        get_name()

                    </td>

                </tr>

                <tr>

                    <td>

                        私有函数

                    </td>

                    <td>

                        以__开头（两个下划线），其他和普通变量一样

                    </td>

                    <td>

                        __get_name()

                    </td>

                </tr>

                <tr>

                    <td>

                        文件名

                    </td>

                    <td>

                        全小写，可使用下划线

                    </td>

                    <td>

                        &nbsp;

                    </td>

                </tr>

            </tbody>

        </table>

    </body>

</html>

【Python】命名规范

# 1 对于numpy.ndarray，可以使用shape查看形状





下图形状是（3，2, 1），如何得到的？ 第一层 [ ] 中含有3个元素， 单拿一个元素出来， 有2个元素， blabla…

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

# 2 axis是如何定义？

从shape上理解更快。

axis=0，相当于拆除第1层 [ ]  ，剩下元素shape会是 （2, 1）。下图中红框叠加sum起来就是这个形状。

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

axis=1，相当于拆除第2层 [ ]  ，剩下元素shape会是 （3, 1）。

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

axis=2，相当于拆除第3层 [ ]  ，剩下元素shape会是 （3, 2）。

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


代码：
```python
import numpy as np
kl = [2, 2, 3, 3, 7, 7]
npa = np.asarray(kl).reshape((3, 2, 1))
print(npa)
print("--------")
print(np.sum(npa, axis=0))
print("--------")
print(np.sum(npa, axis=1))
print("--------")
print(np.sum(npa, axis=2))
```

# 3 方向的含义

**Axis or axes along which a sum is performed.**

这里的along 很关键，在很多库包里，无论叫 Axis 、axes 、dim ， 都是指沿着哪一个dim去计算， 如果用shape去理解，会快一些。

比如在Softmax中：

```python
import torch
from torch import nn
m = nn.Softmax(dim=1)
input = torch.randn(2, 3)
print(input)
output = m(input)
print(output)
```

得到：

```
tensor([[-0.6087, -0.5550, -0.2106],
        [-0.4120,  0.7185, -1.3630]])
tensor([[0.2822, 0.2977, 0.4201],
        [0.2230, 0.6908, 0.0862]])
```

Softmax的那个方向的数字加起来会是1，代码里面是(dim=1)，也就是想形成的shape是（2，），去掉3。

所以是用 [-0.6087, -0.5550, -0.2106] 和 [-0.4120,  0.7185, -1.3630] 在算 Softmax。

结果也正是如此，[0.2822, 0.2977, 0.4201]或者 [0.2230, 0.6908, 0.0862] 加起来就是1 。

【numpy】axis 维度 是什么 Softmax中dim方向是什么

玩这个板子，记录一下板子对应资源引脚。





```c
1 有源蜂鸣器 PB7 高电平响
2 小灯从左到右低电平点亮 PC11 PC6 PC7 PC8 PC9 PB8 PB9 PC12 
3 独立按键,都需要内部上拉
右按键 PA1 
左按键 PA2
上按键 PA3
下按键 PA4
其余两个的左 PA5
其余两个得右 PA6
4 
```

晨启科技 单片机C程序开发 STM32F103RCT6板子对应资源引脚

ref [https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html](https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html)





```python
import numpy as np
np.random.seed(666)
# Return random floats in the half-open interval [0.0, 1.0).
print(np.random.random(size=[3, 6]))
print(np.random.random())
# Return random floats in the half-open interval [0.0, 1.0).
print(np.random.rand(3, 6))
print(np.random.rand())
# randint(low, high=None, size=None, dtype=int)
# [low, high) or [0, low)
print(np.random.randint(5, size=(2, 4)))
# [low, high) .samples from a uniform distribution.
print(np.random.uniform(-4, 4, 3))
#  "standard normal" distribution.
print(np.random.randn(3, 6))
print(np.random.randn())
# Generates a random sample from a given 1-D array
print(np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0]))
```

Python numpy.random模块 随机数模块

f是Polygon，fblock可以是fblock或者LineString，判断对象是否和f这个Polygon是否有相交等关系：




```python
if f.crosses(fblock) or f.contains(fblock) or f.overlaps(fblock)
```

g1是GeoDataFrame，qq是GeoDataFrame，取出qq在g1里面的部分，截断的：
```python
g1 = GeoDataFrame([{'geometry': fblock}])
res_intersection = geopandas.overlay(g1, qq, how='intersection')
res = list(res_intersection.loc[0, "geometry"].coords)
```

geopandas 取与图像有关联的图像

官网说明书：https://github.com/SeleniumHQ/docker-selenium





执行：
```python
docker run -d -p 4444:4444 --shm-size="2g" selenium/standalone-chrome:98.0
```

Python代码：

```python
# -*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.chrome.options import Options
# 创建一个参数对象，用来控制chrome是否以无界面模式打开
ch_op = Options()
# 设置谷歌浏览器的页面无可视化，如果需要可视化请注释这两行代码
ch_op.add_argument('--headless')
ch_op.add_argument('--disable-gpu')
# ch_op.add_argument('disable-dev-shm-usage')
driver = webdriver.Remote(
    command_executor="http://0.0.0.0:4444/wd/hub",
    desired_capabilities=DesiredCapabilities.CHROME,
    options=ch_op
)
driver.get("http://www.baidu.com")
print(driver.page_source)
driver.quit()
```

Docker selenium Python 可靠的selenium Docker环境

最开始想用GeoPandas造轮子，但大可不必：





[https://docs.mapbox.com/mapbox-tiling-service/examples/natural-earth-countries-and-polygon-simplification/](https://docs.mapbox.com/mapbox-tiling-service/examples/natural-earth-countries-and-polygon-simplification/)

简化行政地图边界 简化地图边界的方法 GeoPandas

Windows、Linux





```python
# -*- coding: UTF8 -*-
import os
import time
def TimeStampToTime(timestamp):
    timeStruct = time.localtime(timestamp)
    return time.strftime('%Y-%m-%d %H:%M:%S', timeStruct)
def get_FileCreateTime(filePath):
    # '''获取文件的创建时间'''
    # filePath = unicode(filePath,'utf8')
    t = os.path.getctime(filePath)
    return TimeStampToTime(t)
def get_FileModifyTime(filePath):
    # '''获取文件的修改时间'''
    # filePath = unicode(filePath, 'utf8')
    t = os.path.getmtime(filePath)
    return TimeStampToTime(t)
def get_FileAccessTime(filePath):
    # '''获取文件的访问时间'''
    # filePath = unicode(filePath, 'utf8')
    t = os.path.getatime(filePath)
    return TimeStampToTime(t)
def get_FileSize(filePath):
    # '''获取文件的大小,结果保留两位小数，单位为MB'''
    # filePath = unicode(filePath,'utf8')
    fsize = os.path.getsize(filePath)
    fsize = fsize / float(1024 * 1024)
    return round(fsize, 2)
if __name__ == '__main__':
    path = r"D:\Desktop\实际图每隔30分钟\kevin_picture_alg_need_collect"
    print(get_FileCreateTime(path))
    print(get_FileModifyTime(path))
    print(get_FileAccessTime(path))
    print(get_FileSize(path))
```

Python 获取文件或者文件夹的修改日期 获取文件的修改时间、访问时间、创建时间、大小占用

参考：https://www.zhihu.com/question/26930016






# 1 、 普通的装饰器

不影响函数本身的执行功能，在函数执行的时候额外做一些其他的事情：

```python
import logging
def use_logging(func):  # 传入函数对象
    def wrapper(*args, **kwargs):
        logging.warning("%s is running k" % func.__name__)  # 做一些装饰器的工作
        return func(*args, **kwargs)  # 返回函数对象执行结果
    return wrapper  # 返回函数
def bar():
    print("i am bar")
bar = use_logging(bar)  # 返回的是一个函数对象
bar()
```

通过@语法糖，装饰器可以很漂亮地给函数用上，增加程序的可读性：

```python
import logging
def use_logging(func):  # 传入函数对象
    def wrapper(*args, **kwargs):
        logging.warning("%s is running k" % func.__name__)  # 做一些装饰器的工作
        return func(*args, **kwargs)  # 返回函数对象执行结果
    return wrapper  # 返回函数
@use_logging
def bar():
    print("i am bar")
@use_logging
def foo():
    print("i am foo")
bar()
```

# 2 、 带参数的装饰器

对原有参数再包装了一次：
```python
import logging
def use_logging(level):  # 传入函数对象
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "warning":
                logging.warning("%s is running k" % func.__name__)  # 做一些装饰器的工作
            return func(*args, **kwargs)  # 返回函数对象执行结果
        return wrapper
    return decorator  # 返回函数
@use_logging(level="warning")
def bar():
    print("i am bar")
bar()
```

# 3 、 类装饰器

```python
class Foo():
    def __init__(self, func):
        self._func = func
    def __call__(self, *args, **kwargs):
        print("class decorator running")
        self._func()
        print("class decorator end")
@Foo
def bar():
    print("i am bar")
bar()
```

# 4 、functools.wraps

在之前的装饰器，为函数装上了装饰器后函数的元信息丢失（如`__name__`），functools.wraps可以让装饰器不改变函数的元信息。

```python
from functools import wraps
def logged(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("was called")
        return func(*args, **kwargs)  # 返回函数对象执行结果
    return wrapper  # 返回函数
@logged
def bar():
    print("i am bar")
    return "HHHH"
print(bar.__name__)
print(bar())
```

Python 的装饰器是什么 如何使用

Python





```python
import cv2
class DataConvert():
    """
    表达方式 说明
    x1,y1,x2,y2 (x1,y1)为左上角坐标，(x2,y2)为右下角坐标
    x1,y1,w,h (x1,y1)为左上角坐标，w为目标区域宽度，h为目标区域高度
    xc,yc,w,h (xc,yc)为目标区域中心坐标，w为目标区域宽度，h为目标区域高度 COCO标注
    """
    def __init__(self):
        pass
    @staticmethod
    def cvtx0y0whTox1y1x2y2(x0, y0, w, h, imgShape):
        # "0.530921 0.666667 0.622368 0.666667"=>(167, 169, 639, 507)
        # labelme 的COCO标注格式就是 中心点x+中心点y+宽+高 （归一化的）
        # 此函数出来的就是 左上点  右下点  （未归一化的）
        height, width, c = imgShape
        x1, y1, x2, y2 = int((x0 - w * 0.5) * width), \
                         int((y0 - h * 0.5) * height), \
                         int((x0 + w * 0.5) * width), \
                         int((y0 + h * 0.5) * height)
        return x1, y1, x2, y2
    @staticmethod
    def cvtx1y1x2y2Tox0y0wh(x1, y1, x2, y2, imgShape):
        # (167, 169, 639, 507)=>"0.530921 0.666667 0.622368 0.666667"
        # 左上点  右下点  （未归一化的） => 中心点x+中心点y+宽+高 （归一化的）
        height, width, c = imgShape
        x0, y0, w, h = (x1 + x2) / 2 / width, (y1 + y2) / 2 / height, (x2 - x1) / width, (y2 - y1) / height,
        return x0, y0, w, h
if __name__ == '__main__':
    img = cv2.imread("jg02387.jpg")
    shape = img.shape
    x1, y1, x2, y2 = DataConvert.cvtx0y0whTox1y1x2y2(0.530921, 0.666667, 0.622368, 0.666667, shape)
    print(x1, y1, x2, y2)
    print(DataConvert.cvtx1y1x2y2Tox0y0wh(x1, y1, x2, y2, shape))
```

labelme COCO格式数据 与 左上角右下角格式数据 相互转化

1 、 为一个文件夹的图片改变文件名称




```python
import os
prefix = input("前缀\n")
startNumber = input("开始的数字\n")
father = r"D:\Desktop\jinggai\jinggai3"
for k, fileName in enumerate(os.listdir(father), int(startNumber)):
    if fileName.endswith("jpg"):
        os.rename(os.path.join(father, fileName), os.path.join(father, prefix + str(k).zfill(5) + ".jpg"))
```

2 、 已经为一些图片标注，然后利用标注清除一个文件夹中没有带labels的图片

```python 
import os
images = r"D:\Desktop\jinggai\images"
labels = r"D:\Desktop\jinggai\labels"
imgFileNameList = os.listdir(images)
labelFileNameList = os.listdir(labels)
for fileName in imgFileNameList:
    if fileName.endswith(".jpg"):
        if fileName[:-4] + ".txt" not in labelFileNameList:
            os.remove(os.path.join(images, fileName))
    else:
        os.remove(os.path.join(images, fileName))
print("当前图片剩余多少张==>", len(imgFileNameList))
print("当前图片标注剩余多少个文件==>", len(labelFileNameList), labelFileNameList)
```

3、 使用算法服务标注数据，将label结果写入到一个文件夹中

```python
# -*- coding: utf-8 -*-
import os
import requests
import cv2
imgpath = r"D:\Desktop\jinggai\jinggai"
labelspath = r"D:\Desktop\jinggai\labels"
class DataConvert():
    """
    表达方式 说明
    x1,y1,x2,y2 (x1,y1)为左上角坐标，(x2,y2)为右下角坐标
    x1,y1,w,h (x1,y1)为左上角坐标，w为目标区域宽度，h为目标区域高度
    xc,yc,w,h (xc,yc)为目标区域中心坐标，w为目标区域宽度，h为目标区域高度 COCO标注
    """
    def __init__(self):
        pass
    @staticmethod
    def cvtx0y0whTox1y1x2y2(x0, y0, w, h, imgShape):
        # "0.530921 0.666667 0.622368 0.666667"=>(167, 169, 639, 507)
        # labelme 的COCO标注格式就是 中心点x+中心点y+宽+高 （归一化的）
        # 此函数出来的就是 左上点  右下点  （未归一化的）
        height, width, c = imgShape
        x1, y1, x2, y2 = int((x0 - w * 0.5) * width), \
                         int((y0 - h * 0.5) * height), \
                         int((x0 + w * 0.5) * width), \
                         int((y0 + h * 0.5) * height)
        return x1, y1, x2, y2
    @staticmethod
    def cvtx1y1x2y2Tox0y0wh(x1, y1, x2, y2, imgShape):
        # (167, 169, 639, 507)=>"0.530921 0.666667 0.622368 0.666667"
        # 左上点  右下点  （未归一化的） => 中心点x+中心点y+宽+高 （归一化的）
        height, width, c = imgShape
        x0, y0, w, h = (x1 + x2) / 2 / width, (y1 + y2) / 2 / height, (x2 - x1) / width, (y2 - y1) / height,
        return x0, y0, w, h
files = os.listdir(imgpath)
for file in files:
    filep = os.path.join(imgpath, file)
    res = requests.post(url="http://172.18.43.32:8012/alg_analyse_bytes/",
                        files={"file": open(filep, "rb")}).json()
    labelfile = os.path.join(labelspath, file[:-4] + ".txt")
    if len(res["data"]) != 0:
        img = cv2.imread(filep)
        shape = img.shape
        for data in res["data"]:
            bboxs0 = data["bbox"]
            bboxs0 = list(map(int, bboxs0))
            poss = DataConvert.cvtx1y1x2y2Tox0y0wh(*bboxs0, shape)
            poss = list(map(lambda x: str(round(x, 6)), poss))
            open(labelfile, "a+").write("0 " + " ".join(poss) + "\r\n")
```

4、每张图都必有labels的前提下，让图片文件夹文件数量和label文件夹文件数量一致。

```python
import os
images = r"D:\Desktop\jinggai\jinggai_nano\images"
labels = r"D:\Desktop\jinggai\jinggai_nano\labels"
imgFileNameList = os.listdir(images)
labelFileNameList = os.listdir(labels)
for fileName in imgFileNameList:
    if fileName.endswith(".jpg"):
        if fileName[:-4] + ".txt" not in labelFileNameList:
            os.remove(os.path.join(images, fileName))
    else:
        os.remove(os.path.join(images, fileName))
imgFileNameList = os.listdir(images)
labelFileNameList = os.listdir(labels)
for fileName in labelFileNameList:
    if fileName.endswith(".txt"):
        if (fileName[:-4] + ".jpg" not in imgFileNameList) or (len(str(open(os.path.join(labels, fileName), "r").readlines())) < 7):
            os.remove(os.path.join(labels, fileName))
    else:
        os.remove(os.path.join(labels, fileName))
imgFileNameList = os.listdir(images)
labelFileNameList = os.listdir(labels)
print("当前图片剩余多少张==>", len(imgFileNameList))
print("当前图片标注剩余多少个文件==>", len(labelFileNameList), labelFileNameList)
```

5、有图片和对应的xml标注：

将图片全部改名，重写到另外一个文件夹；

将对应的xml标注文件改名；

```python
import os
import traceback
import cv2
import numpy as np
prefix = input("前缀\n")
startNumber = input("开始的数字\n")
father = r"D:\fireandsmoke\images"
father_labels = r"D:\fireandsmoke\annotations"
for k, fileName in enumerate(os.listdir(father), int(startNumber)):
    try:
        img = cv2.imdecode(np.fromfile(os.path.join(father, fileName), dtype=np.uint8), 1)  # img是矩阵
        cv2.imwrite(os.path.join(r"D:\fireandsmoke\tarimg", prefix + str(k).zfill(5) + ".jpg"), img)
        os.rename(os.path.join(father_labels, fileName.split(".")[0] + ".xml"),
                  os.path.join(father_labels, prefix + str(k).zfill(5) + ".xml"))
    except:
        traceback.print_exc()
```

6、 xml标记文件转COCO的txt文件。

```python
import xml.etree.ElementTree as ET
import os
xmldir = r"D:\fireandsmoke\annotations"
txtdir = r"D:\fireandsmoke\labels"
classes = ['fire']  # 标签名
def convert_annotation(img_id_filename):
    image_id = img_id_filename[:-4]  # xml文件的文件名，不带后缀
    in_file = open(os.path.join(xmldir, '%s.xml' % (image_id), ), encoding='UTF-8')  # 打开xml
    out_file = open(os.path.join(txtdir, '%s.txt' % (image_id), ), 'w')  # 最终写入txt文件，这里打开
    tree = ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    size_width = int(size.find('width').text)  # 图片宽
    size_height = int(size.find('height').text)  # 图片高
    for obj in root.iter('object'):  # 遍历标记
        difficult = obj.find('difficult').text  # 是否是难样本
        cls = obj.find('name').text  # 标签分类名
        if cls not in classes or int(difficult) == 1:  # 需要是想要的标签+需要不是难样本
            continue
        cls_id = classes.index(cls)  # COCO里面的第一个数字表示是第几类
        xmlbox = obj.find('bndbox')
        b = [float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
             float(xmlbox.find('ymax').text)]  # 注意这里顺序
        if size_width == 0 or size_height == 0:
            print("不合理的图，程序会删除这张图", image_id)
            in_file.close()
            os.remove(os.path.join(xmldir, '%s.xml' % (image_id)))
            continue
        # 标注越界修正
        if b[0] > size_width:
            b[0] = size_width
        if b[1] > size_width:
            b[1] = size_width
        if b[2] > size_height:
            b[2] = size_height
        if b[3] > size_height:
            b[3] = size_height
        txt_data = [((b[0] + b[1]) / 2.0 - 1) / size_width, ((b[2] + b[3]) / 2.0 - 1) / size_height,
                    (b[1] - b[0]) / size_width, (b[3] - b[2]) / size_height]
        txt_data = list(map(lambda x: round(x, 6), txt_data))
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in txt_data]) + '\n')
    in_file.close()
    out_file.close()
def getClsName():
    clsSet = set()
    xmllist = os.listdir(xmldir)
    for img_id in xmllist:
        img_id_filename = img_id
        image_id = img_id_filename[:-4]  # xml文件的文件名，不带后缀
        in_file = open(os.path.join(xmldir, '%s.xml' % (image_id), ), encoding='UTF-8')  # 打开xml
        tree = ET.parse(in_file)
        root = tree.getroot()
        for obj in root.iter('object'):  # 遍历标记
            cls = obj.find('name').text  # 标签分类名
            clsSet.add(cls)
        in_file.close()
    print(clsSet)
# imglist = os.listdir(imgdir)
# xmllist = os.listdir(xmldir)
# # 测试图片是否损坏
# for img_id in imglist:
#     try:
#         cv2img = cv2.imread(os.path.join(imgdir, img_id))
#     except:
#         os.remove(os.path.join(imgdir, img_id))
if __name__ == '__main__':
    xmllist = os.listdir(xmldir)
    for img_id in xmllist:
        convert_annotation(img_id)
```

Python 目标检测 数据清洗与标注 常用程序记录

windows 10 Python 使用 requests出现报错：





```
  File "D:\Miniconda3\lib\ssl.py", line 500, in wrap_socket
    return self.sslsocket_class._create(
  File "D:\Miniconda3\lib\ssl.py", line 997, in _create
    raise ValueError("check_hostname requires server_hostname")
ValueError: check_hostname requires server_hostname
```

解决方法：

把 VPN 关了就行了。

ValueError: check_hostname requires server_hostname

参考这个大佬：[https://blog.csdn.net/BF02jgtRS00XKtCx/article/details/111188806](https://blog.csdn.net/BF02jgtRS00XKtCx/article/details/111188806)






```shell
pip install python-docx
```


add_float_picture.py

```python
# -*- coding: utf-8 -*-
# filename: add_float_picture.py
'''
Implement floating image based on python-docx.
- Text wrapping style: BEHIND TEXT <wp:anchor behindDoc="1">
- Picture position: top-left corner of PAGE `<wp:positionH relativeFrom="page">`.
Create a docx sample (Layout | Positions | More Layout Options) and explore the
source xml (Open as a zip | word | document.xml) to implement other text wrapping
styles and position modes per `CT_Anchor._anchor_xml()`.
'''
from docx.oxml import parse_xml, register_element_cls
from docx.oxml.ns import nsdecls
from docx.oxml.shape import CT_Picture
from docx.oxml.xmlchemy import BaseOxmlElement, OneAndOnlyOne
# refer to docx.oxml.shape.CT_Inline
class CT_Anchor(BaseOxmlElement):
    """
    ``<w:anchor>`` element, container for a floating image.
    """
    extent = OneAndOnlyOne('wp:extent')
    docPr = OneAndOnlyOne('wp:docPr')
    graphic = OneAndOnlyOne('a:graphic')
    @classmethod
    def new(cls, cx, cy, shape_id, pic, pos_x, pos_y):
        """
        Return a new ``<wp:anchor>`` element populated with the values passed
        as parameters.
        """
        anchor = parse_xml(cls._anchor_xml(pos_x, pos_y))
        anchor.extent.cx = cx
        anchor.extent.cy = cy
        anchor.docPr.id = shape_id
        anchor.docPr.name = 'Picture %d' % shape_id
        anchor.graphic.graphicData.uri = (
            'http://schemas.openxmlformats.org/drawingml/2006/picture'
        )
        anchor.graphic.graphicData._insert_pic(pic)
        return anchor
    @classmethod
    def new_pic_anchor(cls, shape_id, rId, filename, cx, cy, pos_x, pos_y):
        """
        Return a new `wp:anchor` element containing the `pic:pic` element
        specified by the argument values.
        """
        pic_id = 0  # Word doesn't seem to use this, but does not omit it
        pic = CT_Picture.new(pic_id, filename, rId, cx, cy)
        anchor = cls.new(cx, cy, shape_id, pic, pos_x, pos_y)
        anchor.graphic.graphicData._insert_pic(pic)
        return anchor
    @classmethod
    def _anchor_xml(cls, pos_x, pos_y):
        return (
                '<wp:anchor distT="0" distB="0" distL="0" distR="0" simplePos="0" relativeHeight="0" \n'
                '           behindDoc="1" locked="0" layoutInCell="1" allowOverlap="1" \n'
                '           %s>\n'
                '  <wp:simplePos x="0" y="0"/>\n'
                '  <wp:positionH relativeFrom="page">\n'
                '    <wp:posOffset>%d</wp:posOffset>\n'
                '  </wp:positionH>\n'
                '  <wp:positionV relativeFrom="page">\n'
                '    <wp:posOffset>%d</wp:posOffset>\n'
                '  </wp:positionV>\n'
                '  <wp:extent cx="914400" cy="914400"/>\n'
                '  <wp:wrapNone/>\n'
                '  <wp:docPr id="666" name="unnamed"/>\n'
                '  <wp:cNvGraphicFramePr>\n'
                '    <a:graphicFrameLocks noChangeAspect="1"/>\n'
                '  </wp:cNvGraphicFramePr>\n'
                '  <a:graphic>\n'
                '    <a:graphicData uri="URI not set"/>\n'
                '  </a:graphic>\n'
                '</wp:anchor>' % (nsdecls('wp', 'a', 'pic', 'r'), int(pos_x), int(pos_y))
        )
# refer to docx.parts.story.BaseStoryPart.new_pic_inline
def new_pic_anchor(part, image_descriptor, width, height, pos_x, pos_y):
    """Return a newly-created `w:anchor` element.
    The element contains the image specified by *image_descriptor* and is scaled
    based on the values of *width* and *height*.
    """
    rId, image = part.get_or_add_image(image_descriptor)
    cx, cy = image.scaled_dimensions(width, height)
    shape_id, filename = part.next_id, image.filename
    return CT_Anchor.new_pic_anchor(shape_id, rId, filename, cx, cy, pos_x, pos_y)
# refer to docx.text.run.add_picture
def add_float_picture(p, image_path_or_stream, width=None, height=None, pos_x=0, pos_y=0):
    """Add float picture at fixed position `pos_x` and `pos_y` to the top-left point of page.
    """
    run = p.add_run()
    anchor = new_pic_anchor(run.part, image_path_or_stream, width, height, pos_x, pos_y)
    run._r.add_drawing(anchor)
# refer to docx.oxml.__init__.py
register_element_cls('wp:anchor', CT_Anchor)
```


mian.py

```python
from docx import Document
from docx.shared import Inches, Pt, Cm
from add_float_picture import add_float_picture
if __name__ == '__main__':
    document = Document("test1.docx")
    # add a floating picture
    p = document.paragraphs[0]
    add_float_picture(p, 'mingzi.png', width=Cm(3.0), pos_x=Cm(14), pos_y=Cm(3))
    # add text
    document.save('output.docx')
```

python docx 添加浮空图片

Python





```python
import base64
import os
import time
import traceback
import cv2
from multiprocessing import Manager, Process
import uvicorn
from fastapi.middleware.cors import CORSMiddleware
from fastapi import FastAPI, File, Form, UploadFile
import requests
model_config = {
    "process_N": 1,
    "port": 8099,
    "FastAPIWorks": 1  # must be number 1
}
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=["*"],
)
updatelabel = 1
def get_db():
    global updatelabel
    updatelabel += 1
    table = "i am table" + str(updatelabel)
    return {"updatelabel": updatelabel, "table": table}
camera_info = Manager().list()
camera_info.append(get_db())
@app.get("/emq/")
def alg_analyse_bytes(a: int):
    if a == 1:
        camera_info[0] = get_db()
    return "ok"
@app.post("/init_process/")
def init_process(process_num: int = Form(...), passwd: str = Form(...)):
    if passwd == "woshimima":
        if process_num <= 8:
            for i in range(process_num):
                Process(target=deal_picture, args=(camera_info,)).start()
    return 1
def deal_picture(camera_info):
    camera_info_copy = dict(camera_info[0]).copy()
    while True:
        try:
            if camera_info_copy["updatelabel"] != camera_info[0]["updatelabel"]:
                camera_info_copy = dict(camera_info[0]).copy()
            print(camera_info_copy)
        except:
            traceback.print_exc()
def cv2_to_base64(image):
    base64_str = cv2.imencode('.jpg', image)[1].tostring()
    base64_str = base64.b64encode(base64_str)
    return base64_str
def init_model():
    time.sleep(1)
    requests.post("http://0.0.0.0:" + str(model_config["port"]) + "/init_process",
                  data={"process_num": model_config["process_N"],
                        "passwd": "woshimima"})
    print(f"algorithm already start ")
if __name__ == '__main__':
    modulename = os.path.basename(os.path.abspath(__file__)).split(".")[0]
    Process(target=init_model).start()
    uvicorn.run(modulename + ':app',
                host='0.0.0.0',
                port=model_config["port"],
                reload=False,
                debug=False,
                workers=model_config["FastAPIWorks"])
```

在Python中，一种在多进程中，利用标签向进程分享无冲突全局变量，且开放Web接口的方法

参考：[https://zhuanlan.zhihu.com/p/143009848](https://zhuanlan.zhihu.com/p/143009848)





鼠标移至标题栏–>单击鼠标右键–>属性–>取消勾选快速编辑模式


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

windows cmd 执行程序卡住不动 需要回车 假死现象

实现将文件放入windows剪切板功能。






C++:

```C++
#include <iostream>
#include <windows.h>
#include <shlobj.h>
int CopyFileToClipboard(char szFileName[]);
int main()
{
 CopyFileToClipboard("C:\\Users\\Administrator\\Desktop\\test\\hello.txt");
 return 0;
}
int CopyFileToClipboard(char szFileName[])
{
 UINT uDropEffect;
 HGLOBAL hGblEffect;
 LPDWORD lpdDropEffect;
 DROPFILES stDrop;
 HGLOBAL hGblFiles;
 LPSTR lpData;
 uDropEffect = RegisterClipboardFormat("Preferred DropEffect");
 hGblEffect = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(DWORD));
 lpdDropEffect = (LPDWORD)GlobalLock(hGblEffect);
 *lpdDropEffect = DROPEFFECT_COPY;//复制; 剪贴则du用DROPEFFECT_MOVE
 GlobalUnlock(hGblEffect);
 stDrop.pFiles = sizeof(DROPFILES);
 stDrop.pt.x = 0;
 stDrop.pt.y = 0;
 stDrop.fNC = FALSE;
 stDrop.fWide = FALSE;
 hGblFiles = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, \
  sizeof(DROPFILES) + strlen(szFileName) + 2);
 lpData = (LPSTR)GlobalLock(hGblFiles);
 memcpy(lpData, &stDrop, sizeof(DROPFILES));
 strcpy(lpData + sizeof(DROPFILES), szFileName);
 GlobalUnlock(hGblFiles);
 OpenClipboard(NULL);
 EmptyClipboard();
 SetClipboardData(CF_HDROP, hGblFiles);
 SetClipboardData(uDropEffect, hGblEffect);
 CloseClipboard();
 return 1;
}
```


python：

```python
import ctypes
from ctypes import wintypes
import pythoncom
import win32clipboard
class DROPFILES(ctypes.Structure):
    _fields_ = (('pFiles', wintypes.DWORD),
                ('pt',     wintypes.POINT),
                ('fNC',    wintypes.BOOL),
                ('fWide',  wintypes.BOOL))
def clip_files(file_list):
    offset = ctypes.sizeof(DROPFILES)
    length = sum(len(p) + 1 for p in file_list) + 1
    size = offset + length * ctypes.sizeof(ctypes.c_wchar)
    buf = (ctypes.c_char * size)()
    df = DROPFILES.from_buffer(buf)
    df.pFiles, df.fWide = offset, True
    for path in file_list:
        array_t = ctypes.c_wchar * (len(path) + 1)
        path_buf = array_t.from_buffer(buf, offset)
        path_buf.value = path
        offset += ctypes.sizeof(path_buf)
    stg = pythoncom.STGMEDIUM()    
    stg.set(pythoncom.TYMED_HGLOBAL, buf)
    win32clipboard.OpenClipboard()
    try:
        win32clipboard.SetClipboardData(win32clipboard.CF_HDROP,
                                        stg.data)
    finally:
        win32clipboard.CloseClipboard()
if __name__ == '__main__':
    import os
    clip_files([os.path.abspath(__file__)])
```

参考：https://www.codenong.com/37552092/

https://blog.csdn.net/Yoryky/article/details/109118588

python C++ 将文件放入剪切板 之后ctrl+V即可

# 1 借助sublime删除注释





在自己的用户路径下C:\Users\ALG\AppData\Roaming\Sublime Text\Packages\User建立文件remove_comments.py：

```python
import sublime_plugin
import sublime
class RemoveCommentsCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        comments = self.view.find_by_selector('comment')
        for region in reversed(comments):
            self.view.erase(edit, region)
```

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

这里的默认路径就是刚才的路径：

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

使用 ctrl+`  打开sublime命令行：

```shell
view.run_command('remove_comments')
```

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

# 2 其他脚本

修改这里：

config.py

```python
import os
jklp = r"D:\Desktop\AI算法库-吸烟检测算法V1.2"
algname = os.path.basename(jklp)
```

执行这里：

huihui1.py

```python
import os
import re
from config import *
def all_path(dirname):
    result = []
    for maindir, subdir, file_name_list in os.walk(dirname):
        for filename in file_name_list:
            apath = os.path.join(maindir, filename)
            result.append(apath)
    return result
path = jklp
result = []
for name in all_path(path):
    name1 = os.path.join(path, name)
    if name1.endswith(".py"):
        try:
            singleTxt = open(name1, "r", encoding="utf-8").readlines()
            if len(singleTxt) > 10:
                result.extend("\nprint(wqeqweuiqdbkasbd1231241241241241)\n")
                result.append(f"\nprint qqqqqqqqqqqqqqqqqqqqqqqqqqqq {os.path.basename(name)}\n")
                result.extend(singleTxt)
        except:
            pass
open("result.py", "w", encoding='utf-8').writelines(result)
```



使用 sublime删除注释后再使用这里：


huihui2.py

```python
import os
import re
from config import *
Txt = open(r"D:\Desktop\result.py", "r", encoding="utf-8").read()
Txt = Txt.replace("print qqqqqqqqqqqqqqqqqqqqqqqqqqqq", "#")
Txt = Txt.replace("print(wqeqweuiqdbkasbd1231241241241241)", f'"""\nCopyright 2017-2022 ------ Inc \n{algname} \n"""')
open("result1.py", "w", encoding='utf-8').write(Txt)
import os
import re
Txt = open("result1.py", "r", encoding="utf-8").readlines()
Txt = list(filter(lambda x: len(x) > 2, Txt))
# os.remove("result2.py")
open(f"{algname}.py", "w", encoding='utf-8').writelines(Txt)
```

Python 删除python程序的注释

Python





```python
from multiprocessing import Queue, Manager, Process
import time
def process1(queuex: Queue):
    while True:
        queuex.put("dasfdsa")
        time.sleep(1)
def process2(queuex: Queue):
    while True:
        if not queuex.empty():
            path = queuex.get()
            print(path)
if __name__ == '__main__':
    manager = Manager()
    dataq = manager.Queue()
    p1 = Process(target=process1, args=(dataq,))
    p2 = Process(target=process2, args=(dataq,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
```

Python 多进程通信

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





安装 
```shell
pip install kafka-python
```

生产者
```python
from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers='101.112.143.254:59092')
future = producer.send('topic_wx_notice', key=b'my_key', value='my_valuefdsfsdf啊沙发舒服'.encode(), partition=0)
result = future.get(timeout=10)
print(result)
```

消费者

给group_id后，同一个group里面的消费者去消费消息只能消费一次。
```python
from kafka import KafkaConsumer
consumer = KafkaConsumer('topic_wx_notice', bootstrap_servers='101.112.143.254:59092',group_id="weiyiid",
                         value_deserializer=lambda m: m.decode())
for msg in consumer:
    print(msg)
```