确认你的socks端口：





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

然后程序可以这么写：

```python
import requests
import socks
import socket
# 创建 SOCKS5 代理连接
socks.set_default_proxy(socks.SOCKS5, "127.0.0.1", 10808)
socket.socket = socks.socksocket
# 发送请求
response = requests.get("https://www.flickr.com/search/?text=%E5%8F%AF%E7%88%B1%E7%9A%84", proxies={"https": "socks5://127.0.0.1:10808"})
print(response.text)
```

【Python】Python程序中使用request库连接外国网站的方法

pyheif github： [https://github.com/carsales/pyheif](https://github.com/carsales/pyheif)





Ubuntu Linux Python 3.7 安装 pyheif：

```sh
 pip install pyheif pillow
```

转单张图片：

```python
from PIL import Image
import pyheif
heif_file = pyheif.read("1.HEIC")
image = Image.frombytes(
    heif_file.mode,
    heif_file.size,
    heif_file.data,
    "raw",
    heif_file.mode,
    heif_file.stride,
)
# 保存为同名jpg
image.save("1.jpg")
```

将某个目录下的所有HEIC文件转为jpg，并删除原jpg：

```python
import os
from PIL import Image
import pyheif
src = r"/mnt/d/download/0207后提交（v1.0.2模型反馈）"
def find_all_files(directory):
    for root, dirs, files in os.walk(directory):
        for file in files:
            yield os.path.join(root, file)
files = find_all_files(src)
for file in files:
    if file.endswith(".HEIC"):
        print(file)
        # 读取heic文件
        heif_file = pyheif.read(file)
        image = Image.frombytes(
            heif_file.mode,
            heif_file.size,
            heif_file.data,
            "raw",
            heif_file.mode,
            heif_file.stride,
        )
        # 保存为同名jpg
        image.save(file.replace("HEIC", "jpg"))
        # 删除
        os.remove(file)
```

上述代码实现了一个将指定目录下所有.HEIC格式的图片文件转换成同名.jpg格式并删除原文件的功能。

首先导入了必要的库：os（用于文件和目录操作）、Pillow中的Image（用于图像处理）、以及pyheif（用于读取HEIC格式的图片文件）。

然后定义了一个函数 find_all_files，该函数使用 os.walk 遍历指定目录下的所有文件和子目录，并通过 yield 逐一返回文件路径。

接下来，通过调用 find_all_files 函数，获取指定目录下的所有文件路径，然后循环处理每个文件。如果文件路径以 .HEIC 结尾，说明该文件是HEIC格式的图片文件，于是就调用 pyheif.read 读取该文件，并使用 Image.frombytes 将读取的HEIC数据转换为Pillow中的Image对象。随后，将Image对象保存为同名.jpg文件，并使用 os.remove 删除原文件。

注意：此代码需要在支持读取HEIC格式的Python环境下运行，否则会出现无法识别.HEIC文件的错误。

Python HEIC图片转jpg

参考：[https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/wo-xie-le--9c7a4/](https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/wo-xie-le--9c7a4/)






#  1 基本介绍

二分查找法（Binary Search）是一种在**有序数组**中查找某一特定元素的搜索算法。其基本思想是，首先将整个有序数列分成前后两部分，判断在哪个部分中可能会找到要查找的数，然后递归地在那个部分中查找。

具体来说，首先选择数列的中间元素。如果要查找的数比中间元素小，则在数列的左半部分继续查找；如果要查找的数比中间元素大，则在数列的右半部分继续查找；如果相等，则找到了要查找的数。这样一直递归进行，直到找到要查找的数或者整个数列被查找完。

二分查找法的时间复杂度为 O(log n)，其中 n 是数列中的元素个数。由于其在有序数列中查找元素的时间复杂度较低，因此常用于大规模有序数列的查找。

> 二分查找并不简单，Knuth 大佬（发明 KMP 算法的那位）都说二分查找：思路很简单，细节是魔鬼。

- 有哪些细节：

> while循环中使用 low <= high 还是 low < high ？ 

> if条件里写<还是<=? 是low = mid +1？

> 还是low = mid ？



# 2 基本的二分查找

基本的二分查找中有序数组里的元素没有重复数值，而二分查找的目的就是找到符合条件的下标。

比如想在有序数组 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9] 中找到元素5的index，该如何写python代码呢：

```python
def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:  # 结束条件是 low > high， 为什么不用<符号呢：因为当low=high时，还需要判断一次，不然[low,high]就会被漏掉
        mid = (low + high) // 2  # 和mid=low+(high-low)//2是一样的结果，low+(high-low)//2可以防止大数溢出
        if arr[mid] < x:
            low = mid + 1  # 在区间 [mid+1, high] 中查找
        elif arr[mid] > x:
            high = mid - 1  # 在区间 [low, mid-1] 中查找
        elif arr[mid] == x:
            return mid
    return -1
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x = 5
result = binary_search(arr, x)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")
```

# 3 左边界 vs 右边界，查找相等的元素

当有序数组中存在重复值，即是由多个元素可以满足条件，返回哪一个下标更合适呢？

比如 arr = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]， 找数值5，那么左边界index是4，右边界index是6。 

如果有序数组中有重复值，并且你想找到左边界的下标，你可以在二分查找的基础上，做一些改变来实现这个功能。

下面的代码展示了左边界和右边界的代码：

```python
def binary_search_leftright(arr, x):
    low = 0
    high = len(arr) - 1
    result = -1
    while low <= high:  # 结束条件是 low > high， 为什么不用<符号呢：因为当low=high时，还需要判断一次，不然[low,high]就会被漏掉
        mid = (low + high) // 2  # 和mid=low+(high-low)//2是一样的结果，low+(high-low)//2可以防止大数溢出
        if arr[mid] < x:
            low = mid + 1  # 在区间 [mid+1, high] 中查找
        elif arr[mid] > x:
            high = mid - 1  # 在区间 [low, mid-1] 中查找
        elif arr[mid] == x:
            result = mid  # 记录符合条件的下标
            # high = mid - 1  # 在区间 [low, mid-1] 中查找，这就很灵性，意味着找到了，但是还要继续找，而且趋势是往左找. 即找左边界。
            low = mid + 1  # 在区间 [mid+1, high] 中查找，这就很灵性，意味着找到了，但是还要继续找，而且趋势是往右找. 即找右边界。
    return result
arr = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]
x = 5
result = binary_search_left(arr, x)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")
```

# 4 难度升级，找到 x<6 的右边界

在 arr = [4, 4, 5, 5, 6, 6, 7, 8, 9] 中找到一个元素x，满足x<6，且x是右边界元素：
```python
def binary_search_right(arr, x):
    low = 0
    high = len(arr) - 1
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < x:
            low = mid + 1  # 继续在[mid+1, high]中查找，因为想找右边界
        else:
            high = mid  # 为什么不是mid-1呢?
    if arr[high] >= x:
        return high - 1
    else:
        return high
arr = [4, 4, 5, 5, 6, 6, 7, 8, 9]
x = 6
result = binary_search_right(arr, x)
print(result)
```

函数返回 high - 1 或者返回high。


- 如果将条件改为while low <= high呢，这样不可以吗？

> 如果你将循环的条件改为 while low <= high，在数组中查找小于目标值的右边界的时候是会有问题的。

> 

> 当low==high时，如果arr[high] >= x 那么最终返回值就是high -1,而实际上并不是小于目标值的右边界。

> 

> 因此，在二分查找中查找右边界时，循环条件应该是 low < high.

> 

> 这样当循环结束时，high指向的就是第一个大于等于目标值的位置，而high - 1就是小于目标值的右边界

> 

> 所以，在二分查找中查找右边界时，循环条件应该是 low < high 而非 low <= high,这是为了确保查找的正确性

> 

> 除此之外，还可能发生死循环。


- 那为什么是high = mid ，而不是high = mid -1？

> 在查找小于目标值的右边界时，如果循环条件是 low < high, 当 arr[mid] >= x 时,如果 high = mid -1 会使得 high 不满足循环条件,从而导致循环终止，而不是移动到小于目标值的右边界。

> 

> 而赋值high = mid会使得high = mid或者 high =

> mid-1,这样high总是满足循环条件且正确地找到了第一个大于等于目标值的位置,而high-1就是小于目标值的右边界。

> 

> 所以如果你想在查找小于目标值的右边界时，应该让 high = mid。这样可以保证查找的正确性。


# 5 找到 x>5 的左边界

在 arr = [4, 4, 5, 5, 6, 6, 7, 8, 9] 中找到一个元素x，满足x>5，且x是左边界元素：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] <= x:
            low = mid + 1
        else:
            high = mid - 1
    return low
arr = [4, 4, 5, 5, 6, 6, 7, 8, 9]
x = 5
result = binary_search_left(arr, x)
print(result)
```

或者：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr)
    while low < high:
        mid = (low + high) // 2
        if arr[mid] <= x:
            low = mid + 1
        else:
            high = mid 
    return low
```


# 6 总结模板

当使用 "while low <= high" 时，要想结束循环，就需要更严格的判断，从而就不需要再单独对low 和high 进行特判。

如果要查找左边界（x>5的左边界）：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] <= x: # 如果是x>=5，这里就需要改变查找区间
            low = mid + 1
        else:
            high = mid - 1
    return low
```

如果要查找右边界（x<6的右边界）：

```python
def binary_search_right(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] < x: # 如果是x<=6，这里就需要改变查找区间
            low = mid + 1
        else:
            high = mid - 1
    return high
```

【算法题目】一文搞懂二分查找法

# 代码





PyMuPDF的版本不同，似乎方法也不同，所以建议指定一个版本。

安装：

```sh
pip install PyMuPDF==1.21.1
```

代码：

```python
import os
import fitz
# 提取每一页的图片对象单独保存
def muExtractImages(pdf_name, pic_save_path):
    doc = fitz.open(pdf_name)
    for itm,page in enumerate(doc):
        try:
            tupleImage = page.get_images()
            for xref0 in tupleImage:  # 取第一个元组
                xref = xref0[0]  # 最终取得xref  ok
                img = doc.extract_image(xref)  # 获取文件扩展名，图片内容 等信息
                imageFilename = os.path.join(pic_save_path, str(itm) + '_' + str(xref) + '.' + img['ext'])
                imgout = open(imageFilename, 'wb')  # byte方式新建图片
                imgout.write(img["image"])  # 当前提取的图片写入磁盘
                imgout.close()
        except:
            continue
    doc.close()
# 将每一页作为图片，保存到某个目录
def pdf_image(pdf_name, pic_save_path):
    img_paths = []
    doc = fitz.open(pdf_name)
    for i, pg in enumerate(doc.pages()):
        page = pg  # 获得每一页的对象
        trans = fitz.Matrix(3.0, 3.0)
        pm = page.get_pixmap(matrix=trans, alpha=False)  # 获得每一页的流对象
        img_path = str(i + 1) + '.jpg'
        img_path = os.path.join(pic_save_path, img_path)
        pm.save(img_path)
        img_paths.append(img_path)
    doc.close()
    return img_paths
if __name__ == '__main__':
    file_path = r'F:\BaiduNetdiskDownload\语文-状元笔记\语文-状元笔记\1.pdf'  # pdf_name 文件路径
    dir_path = r'F:\BaiduNetdiskDownload\语文-状元笔记\语文-状元笔记\1'  # 存放图片的文件夹
    muExtractImages(file_path, dir_path)
```

# PyMuPDF介绍

PyMuPDF是一个用于操作PDF文件的Python库。它是基于MuPDF库的Python绑定，提供了一组高级功能，可以用于读取，修改和写入PDF文件。

主要特性：

支持多种PDF版本，包括PDF 1.7（Acrobat 8.0）

支持读取加密和签名的PDF文件

支持修改PDF文件的内容，包括文本，图像，链接和表单

支持创建新的PDF文件或合并现有的PDF文件

支持渲染PDF页面为图像，包括多种格式（如PNG，JPEG，TIFF）

支持对PDF文件进行搜索和提取文本

Python PyMuPDF 提取PDF文件中的图片到指定目录保存，PDF将每一页都保存为图片

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





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

Python：

```python
import math
# 逆时针旋转angle
def rotate(angle, pointP, pointQ):
    x2, y2 = pointQ  # 旋转中心点
    x1, y1 = pointP  # 旋转前的点
    x = x2 + (x1 - x2) * math.cos(angle) - (y1 - y2) * math.sin(angle)
    y = y2 + (x1 - x2) * math.sin(angle) + (y1 - y2) * math.cos(angle)
    return [x, y]
```

【Python】opencv图形旋转，坐标点旋转，坐标绕原点旋转

额外介绍一点别的，如何docker 快速启动一个PaddleOCR的能力见这里：[https://qq742971636.blog.csdn.net/article/details/135109278](https://qq742971636.blog.csdn.net/article/details/135109278)






python包：`pip install baidu-aip`

详细教程：[https://www.jianshu.com/p/e10dc43c38d0](https://www.jianshu.com/p/e10dc43c38d0)

我的代码：
```python
import json
import os
import shutil
import cv2
from aip import AipOcr
from tqdm import tqdm
# """ 你的 APPID AK SK  图2的内容"""
APP_ID = '27145052'
API_KEY = '26T8PoG7inAFTF3MF99E0Pbg  '
SECRET_KEY = 'CCbIfR0f9wLMgPXs3c0G6MTYwawpwZXi '
client = AipOcr(APP_ID, API_KEY, SECRET_KEY)
def get_file_content(filePath):
    with open(filePath, 'rb') as fp:
        return fp.read()
rootpath = r"C:\Users\dong.xie\Desktop\xsz111\学生证\u=693650192"
print(rootpath)
res = {}
files = os.listdir(rootpath)
for file in tqdm(files):
    try:
        fname = os.path.join(rootpath, file)
        image = get_file_content(fname)
        """ 调用通用文字识别, 图片参数为本地图片 """
        results = client.general(image)
        res[fname] = results
    except:
        print("error", fname)
```


最好的方式还是ocr+docker：

[https://github.com/PaddlePaddle/PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)

【Python】快捷调用百度ocr能力

原因是png图片里面的profile ，好像又听说高版本的png在做什么。






解决方式很简单，重写一下这个图。


下面程序会读取 r"/ssd/xd/datasets/multilabelsTask/"下面的所有jpg和png图，多进程方式地重写一下图片，注意，如果opencv打不开这个图，这个图会被删除：
```python
import multiprocessing
import os
import cv2
import numpy as np
def listPathAllfiles(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
def overwrite(files1):
    for fname in files1:
        try:
            if fname.endswith(".jpg"):
                img = cv2.imdecode(np.fromfile(fname, dtype=np.uint8), 1)  # img是矩阵
                cv2.imencode('.jpg', img)[1].tofile(fname)
            elif fname.endswith(".png"):
                img = cv2.imdecode(np.fromfile(fname, dtype=np.uint8), 1)  # img是矩阵
                cv2.imencode('.png', img)[1].tofile(fname)
        except:
            os.remove(fname)
            print(fname)
if __name__ == '__main__':
    root = r"/ssd/xd/datasets/multilabelsTask/"
    files = listPathAllfiles(root)
    p = multiprocessing.Pool()  # 创建一个包含2个进程的进程池
    # split files to several parts
    for i in range(0, len(files), 10000):
        p.apply_async(func=overwrite, args=(files[i:i + 1000],))  # 往池子里加一个异步执行的子进城
    p.close()  # 等子进程执行完毕后关闭进程池
    p.join()  # 主进程等待
```

【opencv】【python】libpng warning: iCCP: known incorrect sRGB profile 解决

[http://www.ityouknow.com/python/2019/12/31/python-word-105.html](http://www.ityouknow.com/python/2019/12/31/python-word-105.html)

【Python】Python 操作 Word

下面代码会将List的files分为List[List[...],...]的样子，每隔1000个就是一个子列表，最后除不尽的那个子列表的元素个数 小于等于 1000。




```
files=[files[i:i + 1000]   for i in range(0, len(files), 1000)]
```

多进程应用，下面的代码使用多进程执行overwrite函数，将所有jpg和png文件重写或者删除。
```python
import multiprocessing
import os
import cv2
def listPathAllfiles(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
def overwrite(files1):
    for fname in files1:
        try:
            if fname.endswith(".jpg") or fname.endswith(".png"):
                img = cv2.imread(fname)
                cv2.imwrite(fname, img)
        except:
            os.remove(fname)
            print(fname)
if __name__ == '__main__':
    root = r"/ssd/xd/datasets/multilabel"
    files = listPathAllfiles(root)
    p = multiprocessing.Pool()  # 创建一个包含2个进程的进程池
    # split files to several parts
    for i in range(0, len(files), 1000):
        p.apply_async(func=overwrite, args=(files[i:i + 1000],))  # 往池子里加一个异步执行的子进城
    p.close()  # 等子进程执行完毕后关闭进程池
    p.join()  # 主进程等待
```

【python】优雅列表拆分，列表等分，列表生成子列表

解决办法很简单：





（1）pip uninstall opencv-python或者那些contrib之类的模块。

（2）安装更低的版本，比如4.4。

```
pip install opencv-python==4.5.2.52
pip install opencv-contrib-python==4.5.2.52
```

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

【Python】Opencv python windows 不提示 不补全 的解决办法

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