代码 on 醉后的星星

Win32_API修改EXE文件ICON图标

Sun, 13 Jul 2025 00:00:00 +0000

说明

EXE文件的ICON图标一般由数个图标组成，在更新ICON图标时需要逐一添加每个图标，再添加ICON_GROUP目录，可以使用ResourceHacker软件进行查看。

EXE文件中的图标数据结构和ICON图标文件结构很相似，唯一区别在于ICON图标的ICONDIRENTRY最后一个字段标注的是图像数据首地址，EXE文件的GRPICONDIRENTRY最后一个字段标注的是图标的ID。

代码

#include <windows.h>
#include <stdio.h>

#pragma pack(push, 2) //结构体需要双字节对齐

typedef struct
{
 WORD idReserved; // Reserved (must be 0)
 WORD idType; // Resource Type (1 for icons)
 WORD idCount; // How many images?
 // ICONDIRENTRY idEntries[1]; // An entry for each image (idCount of 'em)
} ICONDIR;

typedef struct
{
 BYTE bWidth; // Width, in pixels, of the image
 BYTE bHeight; // Height, in pixels, of the image
 BYTE bColorCount; // Number of colors in image (0 if >=8bpp)
 BYTE bReserved; // Reserved ( must be 0)
 WORD wPlanes; // Color Planes
 WORD wBitCount; // Bits per pixel
 DWORD dwBytesInRes; // How many bytes in this resource?
 DWORD dwImageOffset; // Where in the file is this image?
} ICONDIRENTRY;

typedef struct
{
 BITMAPINFOHEADER icHeader; // DIB header
 RGBQUAD icColors[1]; // Color table
 BYTE icXOR[1]; // DIB bits for XOR mask
 BYTE icAND[1]; // DIB bits for AND mask
} ICONIMAGE;

typedef struct
{
 WORD idReserved; // Reserved (must be 0)
 WORD idType; // Resource type (1 for icons)
 WORD idCount; // How many images?
 // GRPICONDIRENTRY idEntries[1]; // The entries for each image
} GRPICONDIR;

typedef struct
{
 BYTE bWidth; // Width, in pixels, of the image
 BYTE bHeight; // Height, in pixels, of the image
 BYTE bColorCount; // Number of colors in image (0 if >=8bpp)
 BYTE bReserved; // Reserved
 WORD wPlanes; // Color Planes
 WORD wBitCount; // Bits per pixel
 DWORD dwBytesInRes; // how many bytes in this resource?
 WORD nID; // the ID
} GRPICONDIRENTRY;

#pragma pack(pop)

int main(int argc, char *argv[]) {
 // if (argc != 3) {
 // printf("Usage: %s <target_exe> <new_icon.ico>\n", argv[0]);
 // return 1;
 // }
 //
 // const char *exePath = argv[1];
 // const char *iconPath = argv[2];

 char exePath[] = "pip.exe";
 char iconPath[] = "app.ico";

 // 打开图标文件
 HANDLE hIcon = CreateFile(iconPath, GENERIC_READ, 0, NULL,
 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 if (hIcon == INVALID_HANDLE_VALUE) {
 printf("[%lu]Error opening icon file\n", GetLastError());
 return 1;
 }
 // 获取图标文件大小
 DWORD iconSize = GetFileSize(hIcon, NULL);
 if (iconSize == INVALID_FILE_SIZE) {
 printf("[%lu]Error getting icon file size\n", GetLastError());
 CloseHandle(hIcon);
 return 1;
 }
 // 读取图标文件
 BYTE* iconData = malloc(iconSize);
 DWORD bytesRead;
 if (!ReadFile(hIcon, iconData, iconSize, &bytesRead, NULL) || bytesRead != iconSize) {
 printf("[%lu]Error reading icon file\n", GetLastError());
 free(iconData);
 CloseHandle(hIcon);
 return 1;
 }
 CloseHandle(hIcon);

 // 解析图标文件目录
 ICONDIR* iconDir = (ICONDIR*)iconData;
 if (iconDir->idReserved != 0 || iconDir->idType != 1) {
 printf("Invalid icon file format\n");
 free(iconData);
 return 1;
 }

 // 计算图标组资源大小
 DWORD groupSize = sizeof(GRPICONDIR) + iconDir->idCount * sizeof(GRPICONDIRENTRY);
 BYTE* groupData = malloc(groupSize);
 GRPICONDIR* grpIconDir = (GRPICONDIR*)groupData;
 grpIconDir->idReserved = 0;
 grpIconDir->idType = 1; // RT_ICON
 grpIconDir->idCount = iconDir->idCount;

 // 创建图标组资源
 ICONDIRENTRY* iconEntries = (ICONDIRENTRY*)(iconData + sizeof(ICONDIR));
 GRPICONDIRENTRY* grpEntries = (GRPICONDIRENTRY*)(groupData + sizeof(GRPICONDIR));

 for (int i = 0; i < iconDir->idCount; i++) {
 grpEntries[i].bWidth = iconEntries[i].bWidth;
 grpEntries[i].bHeight = iconEntries[i].bHeight;
 grpEntries[i].bColorCount = iconEntries[i].bColorCount;
 grpEntries[i].bReserved = iconEntries[i].bReserved;
 grpEntries[i].wPlanes = iconEntries[i].wPlanes;
 grpEntries[i].wBitCount = iconEntries[i].wBitCount;
 grpEntries[i].dwBytesInRes = iconEntries[i].dwBytesInRes;
 grpEntries[i].nID = i + 1; // 资源ID从1开始
 }

 // 开始更新EXE资源
 HANDLE hUpdate = BeginUpdateResource(exePath, FALSE);
 if (hUpdate == NULL) {
 printf("BeginUpdateResource failed: %lu\n", GetLastError());
 free(iconData);
 free(groupData);
 return 1;
 }
 // 删除现有的图标组资源
 if (!UpdateResource(hUpdate, RT_GROUP_ICON, MAKEINTRESOURCE(101),
 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), NULL, 0)) {
 printf("[%lu]Warning: Failed to remove old icon group ID-101\n", GetLastError());

 }

 // 删除现有的图标资源
 for (int i = 1; i <= 7; i++) { // 删除ID 1-7的图标资源
 if (!UpdateResource(hUpdate, RT_ICON, MAKEINTRESOURCE(i),
 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), NULL, 0)) {
 printf("[%lu]Warning: Failed to remove old icon ID-%d\n", GetLastError(), i);
 };
 }

 // 添加新的图标组资源
 if (!UpdateResource(hUpdate, RT_GROUP_ICON, MAKEINTRESOURCE(101),
 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
 groupData, groupSize)) {
 printf("[%lu]UpdateResource (group icon) failed\n", GetLastError());
 free(iconData);
 free(groupData);
 EndUpdateResource(hUpdate, TRUE);
 return 1;
 }

 // 添加各个图标资源
 for (int i = 0; i < iconDir->idCount; i++) {
 DWORD offset = iconEntries[i].dwImageOffset;
 DWORD size = iconEntries[i].dwBytesInRes;

 if (offset + size > iconSize) {
 printf("Icon data out of bounds: entry %d\n", i);
 continue;
 }

 if (!UpdateResource(hUpdate, RT_ICON, MAKEINTRESOURCE(i + 1),
 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
 iconData + offset, size)) {
 printf("[%lu]UpdateResource (icon %d) failed\n", i, GetLastError());
 }
 }

 // 完成资源更新
 if (!EndUpdateResource(hUpdate, FALSE)) {
 printf("[%lu]EndUpdateResource failed\n", GetLastError());
 free(iconData);
 free(groupData);
 return 1;
 }

 printf("Icon group updated successfully!\n");
 free(iconData);
 free(groupData);
 return 0;
}

VS2019配置pthread多线程

Tue, 28 Jun 2022 15:32:00 +0000

在VS里用MS编译器不能直接调用pthread库，需要先自行下载该库： http://sourceware.org/pub/pthreads-win32/pthreads-w32-2-9-1-release.zip 解压后用的到的只有Pre-built.2文件夹下的文件。

配置

如下图分别配置三大项：

包含目录–>…\pthreads-w32-2-9-1-release\Pre-built.2\include
库目录–>…\pthreads-w32-2-9-1-release\Pre-built.2\lib\x86
附加依赖项–>pthreadVC2.lib

如果代码运行报错：“timespec”;”struct”类型重定义。解决方法：在pthread.h在第35行加入如下代码：

#define HAVE_STRUCT_TIMESPEC

或者在项目属性->C\C++->预处理器->预处理器定义添加HAVE_STRUCT_TIMESPEC。

如果代码运行报错：找不到pthreadVC2.dll。解决方法：将pthreadVC2.dll拷贝到项目的Debug目录下

示例代码

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <pthread.h> //使用多线程时需要添加<pthread.h>这个头文件

int s = 0;

void* transmit(void* args) {
 char* name = (char*)args;
 for (int i = 0; i < 1000; i++) {
 s++;
 printf("----------%s : s = %d----------\n", name, s);
 Sleep(1000);
 }
}

void* receive(void* args) {
 char* name = (char*)args;
 while (1)
 {
 printf("%s : s = %d\n", name, s);
 Sleep(100);
 }
}

int main() {
 pthread_t tx, rx;

 pthread_create(&tx, NULL, transmit, "TX");
 pthread_create(&rx, NULL, receive, "RX");

 pthread_join(tx, NULL);
 pthread_join(rx, NULL);

 return 0;
}

参考

https://www.cnblogs.com/maycpou/p/13895295.html https://zhuanlan.zhihu.com/p/97418361

npm基本命令

Sat, 12 Feb 2022 14:26:00 +0000

npm -v

初始化

npm init
默认参数
npm init -y

查看已安装包

当前环境中的包
npm list
系统环境中的包
npm list -g

安装

npm install <Module Name>
or
npm i <Module Name>
安装到系统坏境中
npm i <Module Name> -g
安装到生产环境
npm i <Module Name> --save
or
npm i <Module Name> -S
安装到开发坏境
npm i <Module Name> --save-dev
or
npm i <Module Name> -D

淘宝cnpm

npm install -g cnpm

运行

npm run <Script Name>

帮助

npm help
npm -l

设置镜像

npm config set registry https://registry.npm.taobao.org
查看镜像
npm config get registry

Python调用子进程subprocess

Thu, 13 May 2021 03:06:00 +0000

subprocess库用于在控制台中调用子进程，可以模拟控制台命令输入输出。

subprocess.run

如果只是简单调用运行第三方程序的话，使用subprocess.run最为简单。下面以调用ping命令为例

# 直接在控制台输出 但由于编码问题中文为乱码
subprocess.run(['ping', 'baidu.com'])
subprocess.run('ping baidu.com', shell=True)
# 通过stdout来获取输出
p = subprocess.run(['ping', 'baidu.com'], stdout=subprocess.PIPE)
print(p.stdout.decode('gbk'))

subprocess.Popen

下面以下面这个相加函数为例，利用subprocess.Popen来调用它

#!/usr/bin/env python
# -*- coding: utf-8 -*-
n = int(input())
nums = []
while n > 0:
 a, b = list(map(int, input().strip().split()))
 nums.append([a, b])
 n -= 1
for a, b in nums:
 print(f'{a}+{b}={a + b}')

仿照牛客网上测试程序的流程来进行输入输出，注意stdin的用法

def test(pyfile, datafile):
 p = subprocess.Popen(['python.exe', pyfile], stdin=subprocess.PIPE)
 with open(datafile) as f:
 line = f.readline()
 print('..........输入..........')
 while line:
 print(line.strip())
 p.stdin.write(line.encode())
 line = f.readline()

 p.stdin.close()
 print('..........输出..........')
 p.wait(2000)


test('add.py', 'data.txt')

# ..........输入..........
# 3
# 1 2
# 5 6
# 7 8
# ..........输出..........
# 1+2=3
# 5+6=11
# 7+8=15

如果有多个测试用例，可以在输入数据时用一个标志符#进行分割

def tests(pyfile, datafile):
 with open(datafile) as f:
 line = f.readline()
 n = 0
 while line.strip().startswith('#'):
 n += 1
 p = subprocess.Popen(['python.exe', pyfile], stdin=subprocess.PIPE)
 line = f.readline()
 print(f'..........案例[{n}]输入..........')
 while line:
 print(line.strip())
 p.stdin.write(line.encode())
 line = f.readline()
 if line.strip().startswith('#'):
 break
 p.stdin.close()
 print(f'..........案例[{n}]输出..........')
 p.wait()


tests('add.py', 'data.txt')
# ..........案例[1]输入..........
# 3
# 1 2
# 5 6
# 7 8
# ..........案例[1]输出..........
# 1+2=3
# 5+6=11
# 7+8=15
# ..........案例[2]输入..........
# 2
# 1 2
# 5 6
# 7 8
# ..........案例[2]输出..........
# 1+2=3
# 5+6=11

参考

https://www.runoob.com/w3cnote/python3-subprocess.html https://docs.python.org/zh-cn/3/library/subprocess.html

CSS盒子居中的几种方法

Thu, 13 May 2021 02:32:35 +0000

<!DOCTYPE html>
<html lang="en">
 <head>
 <meta charset="UTF-8" />
 <meta http-equiv="X-UA-Compatible" content="IE=edge" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <title>Document</title>
 <style>
 .container {
 background-color: darkorange;
 width: 500px;
 height: 500px;
 }
 .content {
 background-color: cyan;
 width: 200px;
 height: 200px;
 }
 </style>
 </head>
 <body>
 <div class="container">
 <div class="content"></div>
 </div>
 </body>
</html>

定位布局

.container {
 position: relative;
}
.content {
 position: absolute;
 top: 0;
 right: 0;
 bottom: 0;
 left: 0;
 margin: auto;
}

定位+移动布局

.container {
 position: relative;
}
.content {
 position: absolute;
 top: 50%;
 left: 50%;
 transform: translate(-50%, -50%);
}

flex 布局

.container {
 display: flex;
 justify-content: center;
 align-items: center;
}

grid 布局

.container {
 display: grid;
 align-items: center;
 justify-items: center;
}

inline-block 布局

.container {
 text-align: center;
 line-height: 500px;
}
.content {
 display: inline-block;
 vertical-align: middle;
}

table-cell 布局

.container {
 display: table-cell;
 vertical-align: middle;
}
.content {
 margin: auto;
}

各种排序算法的Python实现

Thu, 15 Apr 2021 07:26:00 +0000

注：排序算法的稳定性指相等的元素在排序前后相对位置是否变化，稳定排序主要用于不同键值比较，比如ACM成绩排序，先按分数排序，相同分数再按用时最短排序。

冒泡排序

不断比较相邻元素，每次遍历将最大值移至队尾。

def bubble(arr):
 swapped = True
 end = len(arr)
 while swapped:
 swapped = False
 for i in range(1, end):
 if arr[i-1] > arr[i]:
 arr[i-1], arr[i] = arr[i], arr[i-1]
 swapped = True
 end -= 1
 return arr

选择排序

每次遍历找到一个最小值，将其移至队首。

def selection(arr):
 for start in range(len(arr)-1):
 mini = start
 for i in range(start+1, len(arr)):
 if arr[i] < arr[mini]:
 mini = i
 arr[start], arr[mini] = arr[mini], arr[start]
 return arr

插入排序

很像打麻将，每摸到一张牌，就依次比较将其插入正确的位置。

def insertion(arr):
 for cur in range(len(arr)):
 for i in range(cur-1, -1, -1):
 if arr[cur] < arr[i]:
 arr[cur], arr[i] = arr[i], arr[cur]
 cur = i
 else:
 break
 return arr

归并排序

分分合合

def merge(arr):
 l = len(arr)
 if l <= 1:
 return arr
 arrleft = merge(arr[:l//2])
 arright = merge(arr[l//2:])
 res = []
 while arrleft or arright:
 if arrleft and arright:
 res.append(arrleft.pop(
 0) if arrleft[0] < arright[0] else arright.pop(0))
 elif arrleft:
 res.append(arrleft.pop(0))
 elif arright:
 res.append(arright.pop(0))
 return res

快速排序

选一个基准，然后将基准放在正确的位置上，并保证左边比基准小，右边比基准大，再一直递推下去。

def quick(arr):
 def _quick(i, j):
 if i >= j:
 return
 # 这里选取左端点为参考点
 pivot = arr[i]
 low = i
 high = j
 while i != j:
 # 从右往左 找小于pivot的
 while i < j and arr[j] >= pivot:
 j -= 1
 arr[i] = arr[j]
 # 从左往右 找大于pivot的
 while i < j and arr[i] <= pivot:
 i += 1
 arr[j] = arr[i]
 arr[i] = pivot
 _quick(low, i-1)
 _quick(i+1, high)
 return arr
 return _quick(0, len(arr)-1)

堆排序

每次将堆顶元素和最后一个元素交换，交换后上浮

class HeapSort:
 def __init__(self, arr):
 self.arr = arr
 self.len = len(arr)
 for i in range(len(arr)//2, -1, -1):
 self.heapify(i)

 def heapify(self, i):
 left = 2*i+1
 right = 2*i+2
 largest = i
 if left < self.len and self.arr[left] > self.arr[largest]:
 largest = left
 if right < self.len and self.arr[right] > self.arr[largest]:
 largest = right

 if largest != i:
 self.swap(i, largest)
 self.heapify(largest)

 def swap(self, a, b):
 self.arr[a], self.arr[b] = self.arr[b], self.arr[a]


def heapSort(arr):
 heapq = HeapSort(arr)
 for i in range(len(arr)-1, 0, -1):
 heapq.swap(0, i)
 heapq.len -= 1
 heapq.heapify(0)
 return heapq.arr

计数排序

统计每个数字出现的次数，然后依次取出，适合都是整数且数字集中的场景。

def count(arr):
 if not arr:
 return arr
 minn = min(arr)
 maxn = max(arr)
 dic = {n: 0 for n in range(minn, maxn+1)}
 for n in arr:
 dic[n] += 1
 res = []
 for n in range(minn, maxn+1):
 res += [n]*dic[n]
 return res

基数排序

先创建10个队列（0~9桶），先按个位放入桶中，然后依次清空桶，然后是十位… 适合整数，数据跨度较大的场景。

def radix(arr):
 buckets = [[] for _ in range(10)]
 flag = True
 rad = 1
 while flag:
 flag = False
 for n in arr:
 buckets[n // rad % 10].append(n)
 if not flag and n % rad < n:
 flag = True
 i = 0
 for bucket in buckets:
 while bucket:
 arr[i] = bucket.pop(0)
 i += 1
 rad *= 10
 return arr

桶排序

每个桶有不同的范围，桶内有自己的排序算法

参考

https://visualgo.net/zh/sorting

PyQt多行文本QPlainTextEdit拖放文件后光标不动解决方法

Tue, 26 Jan 2021 14:32:00 +0000

如标题所示，在重写了QPlainTextEdit的拖放方法后，发现拖放文件后光标就不动了，但编辑功能正常，就很奇怪，虽然不会报bug，但很影响使用，文档里翻了半天没有找到问题，换了个搜索姿势后找到了和我遇到相同问题的人，并且解决方法也很奇特。

解决方法

方法来自：PyQt5 QTextEdit重写dropEvent方法后拖入文件光标不动的问题问题出在重写的dropEvent方法上，只需要加一句super().dropEvent(event)重新继承方法即可。

class MyQPlainTextEdit(QPlainTextEdit):
 """实现文件拖放功能"""

 def __init__(self, parent=None):
 super().__init__(parent)
 self.setAcceptDrops(True)

 def dragEnterEvent(self, e):
 if e.mimeData().text().endswith('.srt'):
 e.accept()
 else:
 e.ignore()

 def dropEvent(self, e):
 path = e.mimeData().text().replace('file:///', '')
 super().dropEvent(e) # 加这一句即可
 self.setPlainText(path)

单层离散Hopfield神经网络(DHNN)程序实现

Fri, 03 Jul 2020 08:09:00 +0000

DHNN网络由n个神经元组成，每个神经元取值为1或-1。

每个神经元既是输入，也是输出，如果采用异步更新的策略，每次只更新一个神经元，更新顺序可以任意。激活函数为符号函数，大于等于零激活为1，反之为-1，每个神经元没有自反馈，即权重矩阵对角线为零。

DHNN输入一个值后，神经元状态不断更新后最终会收敛于某个“吸引子”。“吸引子”就是网络存储的记忆，是通过网络权重存储的。网络权重的计算方法一般有下面两种：联立方程求解法和外积和法。一般后面的方法用得较多。 DHNN网络是批学习网络，一次性输入样本一次性学习。输入的样本即“吸引子”，若样本值两两正交，则网络最稳定，理论上样本数上限为n。但一般很难做到两两正交，减少样本数（p<0.14n）可以提高抗畸变性，否则会出现“伪吸引子”。

DHNN网络可以靠下面的能量函数判断收敛状态，随着网络更新，能量函数处于递减趋势。

程序实现

下面是一个简单的python实现程序，可以输入简单样本和预测目标后进行不断更新。 [button color=“primary” icon=“fa fa-github” url=“https://github.com/kizx/DHNN” type=""]Github地址[/button]

# -*- coding: utf-8 -*-
import numpy as np
import time


def sgn(x):
 """激活函数"""
 y = 1 if x >= 0 else -1
 return y


class DHNN:
 def __init__(self, v0, tra):
 """初始化"""
 self.n = np.size(v0) # 神经元个数
 self.W = np.diag(np.zeros(self.n)) # 权矩阵 对角线元素为零的对称矩阵
 self.V = v0 # 神经元状态 取值:{-1,1}
 self.Ip = np.zeros(self.n) # 偏置矢量
 self.T = np.zeros(self.n) # 阈值矢量
 self.train(tra)

 def update(self, i):
 """网络更新"""
 net = np.dot(self.V, self.W[:, i]) + self.Ip[i] - self.T[i]
 self.V[i] = sgn(net)
 E = -1 / 2 * np.dot(np.dot(self.V.T, self.W), self.V) - np.dot(self.Ip.T, self.V) + np.dot(self.T.T, self.V)
 # print('能量', E)
 # print('状态', self.V)
 return E, sgn(net)

 def train(self, sample):
 """网络权重计算（记忆存储）"""
 S = sample
 for i in range(self.n):
 for j in range(self.n):
 delta = 1 if i == j else 0
 a = []
 for m in S:
 a_ = m[i] * m[j]
 a.append(a_)
 self.W[i, j] = (1 - delta) * np.sum(a)
 print('权重\n', self.W)


if __name__ == '__main__':
 St = np.array([[-1, -1, 1, 1],
 [-1, 1, 1, -1]])
 test = DHNN(np.array([1, 1, -1, 1]), St)
 while True:
 time.sleep(1)
 test.update(3)

上面这个程序我还做了一个gui界面用于上课演示。当我将上面的程序用于手写数字识别时，图片采用16*16共256个神经元，当样本数量小于4个时，还有点效果，当样本数多了之后，某些“伪吸引子”和样本的吸引力实在太强导致网络效果极差。想必用于实际用途需要更多的改进算法。

参考

https://zhuanlan.zhihu.com/p/144624580 https://blog.csdn.net/qq_41185868/article/details/80789989 https://blog.csdn.net/weixin_42398658/article/details/84027012 https://space.bilibili.com/529985682/video

再谈Python读取stl模型

Sun, 14 Jun 2020 14:28:00 +0000

[post cid=“184” /] 前面借助vtk库实现读取stl模型，不过这有点杀鸡牛刀了，因为stl模型本身并不复杂，参考这篇文章。自己手写一个读取stl的程序也很简单，但我就是懒得写怎么办 ::aru:cryingface::

stl库

其实前面已经尝试过用这个库了，但是当时总是报错。这个库还有个官方文档，之所以报错是因为这个库太老了，也没人维护。但知道了读取stl的原理后就好办了，把源码修改几处就可以在py3环境下使用了，以下是测试代码。

import stl
with open('kiki.stl', 'rb') as f:
kiki = stl.read_binary_file(f)
print(kiki.facets[0].normal, kiki.facets[0].vertices)
print(kiki.name)

其实修改也很简单，把下面后面的strip去掉后，再将两处xrange改成range就行了。

# return struct.unpack('80s', bytes)[0].strip('\0')
return struct.unpack('80s', bytes)[0]

numpy-stl库

最好用的东西当然得放最后面，这个库依赖于numpy，功能丰富，可读取、修改、保存stl模型，不过要注意的是这里import的包名也是stl，和上面的包名是一样的，要先卸载上面的stl包再安装numpy-stl。官方文档：https://pythonhosted.org/numpy-stl/usage.html

import numpy
from stl import mesh

your_mesh = mesh.Mesh.from_file('cube.stl')

print('法线', your_mesh.normals)
print('点', your_mesh.points)
print('v0表示三角面第一个点', your_mesh.v0)
print('x表示所有点的x坐标', your_mesh.x)

Python读取stl模型并获取点坐标值

Sat, 13 Jun 2020 16:03:00 +0000

本来以为python应该有个专门的库用来读取stl模型，实际上也的确有个叫 stl的库，不过经测试这个库完全没法用(或许是我不会用？)。后来发现vtk库可以读取并显示stl模型，查了一下vtk无法直接pip安装，需要手动下载whl https://www.lfd.uci.edu/~gohlke/pythonlibs/#vtk，下载时根据自己python版本下载就行了，下载完进入工程venv环境进行pip安装。

pip install VTK?8.2.0?cp37?cp37m?win32.whl

读取代码

关于vtk库，我只是听说过但从来没用过，反正照着下面的代码可以正常读取stl模型，然后输出所有顶点坐标并显示出来。

import vtk

# Read from file
stlreader = vtk.vtkSTLReader()
stlreader.SetFileName("cube.stl")

# 输出所有点坐标
stlreader.Update()
stlMapper = vtk.vtkPolyDataMapper()
stlMapper.SetInputConnection(stlreader.GetOutputPort())
p = [0, 0, 0]
polydata = stlreader.GetOutput()
for i in range(polydata.GetNumberOfPoints()):
 polydata.GetPoint(i, p)
 print(p)

cylinderMapper = vtk.vtkPolyDataMapper() # 渲染多边形几何数据
cylinderMapper.SetInputConnection(stlreader.GetOutputPort()) # VTK可视化管线的输入数据接口 ，对应的可视化管线输出数据的接口为GetOutputPort()；
cylinderActor = vtk.vtkActor()
cylinderActor.SetMapper(cylinderMapper) # 设置生成几何图元的Mapper。即连接一个Actor到可视化管线的末端(可视化管线的末端就是Mapper)。
renderer = vtk.vtkRenderer() # 负责管理场景的渲染过程
renderer.AddActor(cylinderActor)
renderer.SetBackground(0.1, 0.2, 0.4)
renWin = vtk.vtkRenderWindow() # 将操作系统与VTK渲染引擎连接到一起。
renWin.AddRenderer(renderer)
renWin.SetSize(300, 300)
iren = vtk.vtkRenderWindowInteractor() # 提供平台独立的响应鼠标、键盘和时钟事件的交互机制
iren.SetRenderWindow(renWin)

# 交互器样式的一种，该样式下，用户是通过控制相机对物体作旋转、放大、缩小等操作
style = vtk.vtkInteractorStyleTrackballCamera()

iren.SetInteractorStyle(style)
iren.Initialize()
iren.Start()

# Clean up
# del cylinder
del stlreader
del cylinderMapper
del cylinderActor
del renderer
del renWin
del iren

后记

其实stl文件有两种编码，一种是Ascall模式，可以直接用记事本打开，其中按规定记录了模型信息，如果能掌握这种规定的话，直接通过文本读取就可以获取坐标信息了，另外一种格式是二进制格式，这个就没法用记事本打开了，不过肯定也是按某种规定编码的。 [post cid=“185” /]

参考

VTK中获取STL模型点的坐标以及对其进行变换从文件读取STL数据 Python配置VTK库

Visual Studio配置glut/freeglut开发环境

Mon, 01 Jun 2020 08:17:00 +0000

glut/freeglut是opengl的一个封装库，虽然现在一般都是用glfw了，但一些教材和课堂上仍旧采用glut库，没办法，那就来配置一下吧。其中glut比较古老，而且好像闭源且早已不再维护了，其官网首页也直接推荐到freeglut库。freeglut是glut的开源版，且一直有人维护。 glut官网：https://www.opengl.org/resources/libraries/glut/ freeglut官网下载：https://www.transmissionzero.co.uk/software/freeglut-devel/

ps:其实网上也有不少教程，但那些教程都是直接把下载好的库复制到系统文件夹和VS文件夹下，这种做法实在不优雅，更正常的做法应该是在VS的工程里进行属性配置才对。

freeglut配置

从上面的官网点击Download freeglut 3.0.0 for MSVC下载二进制库下载解压到一个你喜欢的目录。然后配置三大件：添加include头文件添加lib目录添加lib项，其中opengl32.lib不添加好像也行，我是配置glfw时看要加上，所以这里顺手也加上了。 ps：如果是vs2019，include和lib位置放到这里也可以如果此时运行会报无法找到dll的错误，将C:\dev\freeglut\bin的目录添加到系统Path变量下就行了(添加后工程得重启才能生效) 测试代码：

#include <GL/glut.h>

void Show()
{
 glClear(GL_COLOR_BUFFER_BIT);
 glRectf(-0.5f, -0.5f, 0.5f, 0.5f);
 glFlush();
}
int main(int argc, char* argv[])
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
 glutInitWindowPosition(100, 100);
 glutInitWindowSize(500, 500);
 glutCreateWindow("OpenGL-窗口");
 glutDisplayFunc(Show);
 glutMainLoop();
 return 0;
}

官方的Hello-GLUT测试代码：https://github.com/TransmissionZero/Hello-GLUT 建议自己复制粘贴这些代码运行

glut配置

如果非要用glut也不是不行，官方下载地址：https://www.opengl.org/resources/libraries/glut/glut_downloads.php#windows 选择Download the GLUT 3.6 headers and pre-compiled libraries: glutdlls36.zip下载应该就可以。下载解压后就5个文件和一个readme，这怎么用？网上的教程都是分别塞到系统目录和VS安装目录下的，这里我觉得可以像上面freeglut一样进行配置，手动将这5个文件安排成和freeglut相似的目录结构：新建三个bin,include/GL,lib目录然后将5个文件一一放进去，将bin的目录添加到系统path环境变量。然后后面在VS里的设置就和上面freeglut一样了，只需要将相应名称改一下就行了，测试代码也是一样的。

Windows编译安装CGAL

Mon, 25 May 2020 18:11:00 +0000

CGAL是一个C++计算几何算法库，官方安装说明：https://doc.cgal.org/latest/Manual/windows.html 我的配置是win10+vs2019，已安装有CMake。 [button color=“success” icon=“fa fa-download” url=“https://pan.2bboy.com/Public/Software/CGAL/” type=""]我用到的所有安装文件[/button]

下载安装boost

CGAL依赖于boost库，因此需要先安装boost，二进制boost下载地址：https://sourceforge.net/projects/boost/files/boost-binaries/ 根据官网说明选择1.17.0版本即可，然后下载具体版本根据vs版本和位数来选择，14.0对应VC2015，14.1对应VC2017，14.2对应VC2019，因此我选择boost_1_71_0-msvc-14.2-64.exe下载即可。下载解压到硬盘，比如解压到C:\dev\目录下，然后设置环境变量。

BOOST_LIBRARYDIR = C:\dev\libboost_1_71_0\lib64-msvc-XX.Y

BOOST_INCLUDEDIR = C:\dev\libboost_1_71_0

最后将C:\dev\libboost_1_71_0\lib64-msvc-XX.Y添加到系统环境变量PATH中。

自己编译

如果不直接下载二进制文件，自己来编译也是可以的（我刚开始就这么干的(ー_ー)!!）下载解压boost源文件：https://sourceforge.net/projects/boost/files/boost-binaries/ 解压过程比较慢，解压后得到一堆文件，运行解压目录下的bootstrap.bat文件进行编译。第一次运行会报下面的错误：

'cl' 不是内部或外部命令，也不是可运行的程序或批处理文件。

解决方法是将C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.26.28801\bin\Hostx64\x64添加到系统变量，然后运行vs的命令行工具x64 Native Tools Command Prompt for VS 2019(用系统的命令行会报错)，这个命令行不能直接cd切到另一个盘符下，需要先输入d:切换盘符才行。然后cd d:\boost\boost_1_66_0切换到文件目录，输入bootstrap.bat运行，然后目录下就会生成几个文件，其中有个b2.exe，直接运行会报错。解决方法是打开project-config.jam，修改为

import option ;

using msvc : 16.0 : "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.26.28801\bin\Hostx64\x64\c1.exe";

option.set keep-going : false ;

然后输入b2.exe --with-system --with-thread进行编译，不带后面参数会编译所有库，相当费时间，只编译需要的库就好。编译好的lib库在"/stage/lib"下，将根目录和lib目录添加到系统变量。

下载安装CGAL

从github上下载CGAL-5.0.2-Setup.exe：https://github.com/CGAL/cgal/releases 点击安装，安装到最后应该会有一个弹窗提醒手动设置环境变量，那就将C:\dev\CGAL-5.0.2\auxiliary\gmp\lib添加到环境变量PATH中。

其他可选依赖

Qt

下载地址：https://www.qt.io/offline-installers 或 http://download.qt.io/official_releases/ 安装时勾选MSVC2017的编译器和Qt Script(有些demo可能会用到)，如果硬盘够大的话，把下面几个Qt都勾了也没什么不好。如果现在不勾选，后面再想安装就会很麻烦，具体方法可以自行百度。完成后添加QTDIR的系统变量，路径为根目录C:\Qt\Qt5.12.8，然后添加之前勾选的编译器系统坏境路径C:\Qt\Qt5.12.8\5.12.8\msvc2017_64\bin到PATH中。

Eigen

下载地址：http://eigen.tuxfamily.org/index.php?title=Main_Page

Cmake编译运行

然后我们按照官网上的说明进入examples\Triangulation_2目录，新建一个build文件夹，然后启动Cmake，设置源文件夹和输出文件夹，如果用下面的命令行启动的话会自动设置好。

C:\dev\CGAL-5.0.2> cd examples\Triangulation_2
C:\dev\CGAL-5.0.2\examples\Triangulation_2> mkdir build
C:\dev\CGAL-5.0.2\examples\Triangulation_2> cd build
C:\dev\CGAL-5.0.2\examples\Triangulation_2\build> cmake-gui ..

点击左下角Configure进行配置，一般要点两次。继续点击Generate。生成成功的话在build目录下会生成Triangulation_2_Examples.sln文件，点击打开或者点击Open Project也可以直接打开，在vs里生成不报错应该就没问题。但是直接点击(ctrl)F5会报错无法启动程序，那是因为当前项目是CMake自动生成的ALL_BUILD，需要将别的项目切换为当前项目（不会用vs的我被这个给坑了好久。。。）

官网上面是一个编译了一个三角剖分Triangulation的example，运行起来没有什么意思。其实我们可以对CGAL里的任何一个demo或者example进行编译，当然也可以对整个CGAL文件夹或demo/examples文件夹进行编译，只要文件夹下有CMakeLists.txt文件就能被CMake编译，不过整个编译文件夹容易出错，因为包含了更多的库，可能这些库我们并没有装全，而且全部编译后的工程文件太大对电脑性能要求也更高。下面是编译demo文件夹后，运行P4HDT2的界面。

参考

https://blog.csdn.net/u013094443/article/details/51106015 https://blog.csdn.net/s_lisheng/article/details/72871218 https://zhuanlan.zhihu.com/p/99814130

Pyqt提升控件为自定义控件的方法(动态加载ui文件)

Tue, 12 May 2020 16:43:00 +0000

[post cid=“159” /] 我之前需要对一个QLineEdit控件实现文件拖拽的功能，在折腾一番后发现只有继承QLineEdit类重写方法才能实现我的功能，但我是用动态加载ui文件的方法，所以没办法直接加载我写的自定义控件，当时是用把原控件删除了再把自己的控件加进去的野蛮方法，但后来我看了黑羽的新教程才知道Qt设计师里右键有个提升控件功能就是专门解决这个问题的。

class MainWindow(QObject):

 def __init__(self):
 super().__init__()
 self.ui = QUiLoader().load('static/mainwindow.ui')

 self.ui.file_path.deleteLater() # 删除原有的路径框
 self.ui.file_path = MyQLine() # 新建自己的替换原有的
 self.ui.file_path.setPlaceholderText('浏览或拖拽SRT字幕文件到这里')
 self.ui.horizontalLayout_2.addWidget(self.ui.file_path)
 self.ui.horizontalLayout_2.addWidget(self.ui.file)
...

方法

先新建一个MyWidget.py文件用于写自定义控件。

from PySide2.QtWidgets import QLineEdit


class MyQLine(QLineEdit):
 """实现文件拖放功能"""

 def __init__(self, parent=None):
 super().__init__(parent)
 self.setAcceptDrops(True)

 def dragEnterEvent(self, e):
 if e.mimeData().text().endswith('.srt'): # 这里只接受拖入srt文件，别的文件拖入无效
 e.accept()
 else:
 e.ignore()

 def dropEvent(self, e):
 path = e.mimeData().text().replace('file:///', '')
 self.setText(path)

先在Qt设计师里右键提升控件，提升控件的基类一般就是控件自身本来的类，提升的类名称就是自定义的类名称，头文件是指自定义的类所在的库的名称。如果搞不清这里，可以将ui文件转为py文件，然后查看import部分就明白了。

这里就要注意了，这个提升的类名的路径是基于我们ui文件而言的，所以我这里ui文件必须和MyWidget.py在同一目录下，而且必须保证这里不能有报错，比如我之前在自定义MyQLine时没有传入parent参数就会报错。

然后就是在主程序里加载界面就行了，如果用的是Pyside2还需要加一步注册

class MainWindow(QObject):

 def __init__(self):
 super().__init__()
 loader = QUiLoader()
 loader.registerCustomWidget(MyQLine) # 注册
 self.ui = loader.load('mainwindow.ui')
···

参考

http://www.python3.vip/tut/py/gui/pyqtgraph-2/ https://blog.csdn.net/qq937772489/article/details/81332037

Windows本地部署3d-photo-inpainting项目

Mon, 27 Apr 2020 12:12:00 +0000

前几天我接触了一个由2D图片生成3D视频的开源项目：https://github.com/vt-vl-lab/3d-photo-inpainting [post cid=“168” /] 当时是在谷歌的Colab平台上运行的，在线平台虽方便，但是连接性不好，时断时续的体验差。最蛋疼的是运行环境不能被保存，第二天想用就得从头安装环境，相当耽误时间。于是我就试了本地部署该项目，虽然官方给出的Linux上的部署教程，但我又不是程序员，懒得整一套Linux系统了，就仿照着在Windows上部署了一下，结果是完全可行的。

前提

电脑已安装Anaconda
电脑GPU支持cuda加速并安装相应版本cuda驱动

[post cid=“146” /]

步骤

打开Anaconda控制台新建一个环境

conda create -n 3DP python=3.7 anaconda
conda activate 3DP

下载项目和模型

git clone git@github.com:vt-vl-lab/3d-photo-inpainting.git

手动下载这里面的4个模型并放置在相应文件夹：https://github.com/vt-vl-lab/3d-photo-inpainting/blob/master/download.sh [scode type=“blue”]这一步我下好并打包放在一起了：https://pan.2bboy.com/Public/Software/www/3d-photo-inpainting.zip[/scode]

下载依赖库

cd 3d-photo-inpainting
pip install -r requirements.txt
conda install pytorch==1.4.0 torchvision==0.5.0 cudatoolkit==10.1.243 -c pytorch

下载速度感人请试着换源或代理 [post cid=“163” /]

将jpg格式的图片放在image目录下，运行命令

python main.py --config argument.yml

Pyqt加载ui文件界面的方法

Mon, 13 Apr 2020 15:55:00 +0000

注意我这里主界面ui文件是一个QWidget，不是一个QMainWindow，QMainWindow的稍有不同。

动态加载

动态加载不用将ui文件转换为py文件，边改界面就能边用，很是方便，适合绝大多数情况，这种方法唯一的缺点大概就是编程时控件不能进行自动补全，因为IDE没法知道控件继承自哪里。 [tabs] [tab name=“Pyside2的加载方法” active=“true”]

from PySide2.QtWidgets import QApplication
from PySide2.QtUiTools import QUiLoader


class Window:
 def __init__(self):
 self.ui = QUiLoader().load('view.ui') # 假设我们的ui文件为view.ui


app = QApplication([])
window = Window()
window.ui.show()
app.exec_()

官网教程:https://doc.qt.io/qtforpython/tutorials/basictutorial/uifiles.html [/tab] [tab name=“Pyqt5的加载方法”]

from PyQt5.QtWidgets import QApplication
from PyQt5 import uic


class Window:
 def __init__(self):
 self.ui = uic.loadUi("view.ui")


app = QApplication([])
window = Window()
window.ui.show()
app.exec_()

[/tab] [/tabs]

静态加载

就是先用uic工具将ui文件转换成py文件，然后再导入ui文件，每次ui文件更新都需要重新转换一次。适合需要对控件功能进行重写的场合，一句话就是辅助手写ui而已，另一个在用pyinstaller打包时这样应该能减小打包后的体积，因为转换出来的py文件默认from PySide2.QtWidgets import *，直接导入了所有包，如果按需导入的话应该可以减小一点体积，不过经我测试只减小了1M不到的体积，意义不大。 [tabs] [tab name=“Pyside2的加载方法” active=“true”]

from PySide2.QtWidgets import QApplication, QWidget
from view import Ui_Form
import sys


class Window(QWidget): # 这里继承QWidget,因为我的ui主界面是Widget,官网上这点不一样
 def __init__(self):
 super().__init__()
 self.ui = Ui_Form()
 self.ui.setupUi(self)


if __name__ == "__main__":
 app = QApplication([])
 window = Window()
 window.show() # 这里不是self.ui
 app.exec_()

[/tab] [tab name=“Pyqt5的加载方法”] 和前面类似，注意要用Pyqt5的uic工具进行转换才行，因为生成的py文件自动导入的包名不一样。 [/tab] [/tabs]

总结

动态加载不能进行代码自动补全，打包时ui文件也必须一同打包；静态加载每次手动转换麻烦了点，但转换后因为有了明确的代码可以自动补全代码，进行一些高级编程时有问题也可以更好的debug。所以我觉得最好先用动态加载的方法把界面先搞定，然后写代码时再切到静态加载方法。

conda设置国内镜像源

Tue, 07 Apr 2020 08:59:00 +0000

与 pip设置pypi源不同，conda需要设置的源是anaconda的源，annaconda的国内镜像目前好像只有清华。科大那个现在直接重定向转到清华，已经不能用了。

设置

与pip设置pypi源类似，conda可以在windows用户目录下创建一个.condarc文件，然后写入以下内容即可。

ssl_verify: true
channels:
 - defaults
show_channel_urls: true
channel_alias: https://mirrors.tuna.tsinghua.edu.cn/anaconda
default_channels:
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/pro
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
 conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud

如果无法创建这个文件，可以使用以下命令创建。

conda config --set show_channel_urls yes

如果命令行一个个添加源也是可以的。

conda config --add channels 源地址

参考

https://mirrors.tuna.tsinghua.edu.cn/help/anaconda/ http://mirrors.ustc.edu.cn/help/anaconda.html

Python处理和保存json文件注意事项

Fri, 27 Mar 2020 11:00:00 +0000

Python处理json文件很简单，只需要import json即可，所需要掌握的函数也只有以下四个。 json.dumps(obj)：将python数据类型转化为str类型 json.dump(obj,fp)：将python数据写入文件fp中

import json

dic = {'a': 'aa', 'b': 'bb', 'c': {'c1': 'cc', 'c2': 'cc'}}
with open('config.json', 'w') as f:
 # 先转换成字符串再写入
 config = json.dumps(dic)
 f.write(config)
 # 直接写入
 json.dump(dic, f)

为了美观，我们一般加上参数config = json.dumps(dic, indent=4)，首行缩进4个字符。

json.load(fp)：从json文件中读取数据 json.loas(str)：将str类型转换为python数据类型

# 一般是下面这种用法
with open('config.json', 'r') as f:
 config = json.load(f)
# 这种很少用
config = json.loads(json.dumps(dic))

注意事项

有时候我们需要读取一个json文件，文件必须确保先被创建

if not os.path.exists('config.json'):
 with open('config.json', 'w') as f:
 f.write('{}') # 写入一个空字典，确保后面读取后不会出错

对配置进行改动后再保存，需要先清空配置文件

with open('config.json', 'r+') as f: # 这里只能用'r+'模式打开
 config = json.load(f) # 读取json文件
 config.pop('c') # 剔除参数

 # 不加下面两句就会在文件末尾继续续写
 f.seek(0) # 指针移到文件头
 f.truncate() # 清空文件

 json.dump(config, f, indent=2) # 写入新配置

或者采用下面的分开读取和写入的方法

with open('config.json', 'r') as f:
 config = json.load(f) # 读取json文件
config.pop('c') # 剔除参数
with open('config.json', 'w') as f: # 'w'模式打开文件默认先清空
 json.dump(config, f, indent=2) # 写入新配置

pyqt实现文件拖放获取路径

Sat, 21 Mar 2020 14:11:00 +0000

文件拖放自动填充路径操作本应该是个很简单的操作，结果搜到的教程都在讲控件的拖拽，几经折磨后终于算是实现了这个功能吧。

操作

首先，要知道pyqt的控件有个setAcceptDrops(bool)方法可以设置控件是否接受拖放这个动作，如果是用qt设计师设计的界面可以看到该属性是默认打开的，既然默认打开，那么理论就应该可以实现文件拖放功能。但实际操作时我却发现在IDE里可以拖放，但是到了实际的桌面却无法拖放，这一点我真是无法理解啊。。

因此我只好去看了一些拖拽的教程，发现在重写一个新的QLineEdit类的情况下是可以使用的，重写的类如下：

class MyQLine(QLineEdit):
 """实现文件拖放功能"""

 def __init__(self):
 super().__init__()
 self.setAcceptDrops(True) # 设置接受拖放动作

 def dragEnterEvent(self, e):
 if e.mimeData().text().endswith('.srt'): # 如果是.srt结尾的路径接受
 e.accept()
 else:
 e.ignore()

 def dropEvent(self, e): # 放下文件后的动作
 path = e.mimeData().text().replace('file:///', '') # 删除多余开头
 self.setText(path)

最关键的是e.mimeData().text()获取路径，这里的mimeData()可以参考官方说明 https://doc.qt.io/qtforpython/PySide2/QtCore/QMimeData.html。在上面的动图里能看到拖放文件后获得的文件路径是以’file:///‘开头的，所以需要去掉这玩意，剩下的应该很简单了。

还有一个问题就是我是用qt设计师设计界面然后动态导入的，我自己新建了一个单行文本控件后，哪怕控件名字和之前的名字一样，最后生成的界面里还是会出现两个文本框，但我又不想在qt设计师里删除原来的文本框。所以我只好来个移花接木，把原来的文本框删掉并替换成我自己的。

self.ui.file_path.deleteLater() # 删除原有的路径框
self.ui.file_path = MyQLine() # 新建自己的替换原有的
self.ui.file_path.setPlaceholderText('浏览或拖拽SRT字幕文件到这里')
self.ui.horizontalLayout_2.addWidget(self.ui.file_path)
self.ui.horizontalLayout_2.addWidget(self.ui.file)

针对上面的问题我后来找到了解决方案。 [post cid=“173” /]

pip设置pypi国内镜像

Wed, 11 Mar 2020 12:14:00 +0000

开源镜像站

[scode type=“blue”]阿里镜像https://mirrors.aliyun.com/pypi/simple/[/scode]

[scode type=“blue”]网易镜像https://mirrors.163.com/pypi/simple/[/scode]

[scode type=“blue”]清华镜像https://pypi.tuna.tsinghua.edu.cn/simple[/scode]

[scode type=“blue”]豆瓣镜像https://pypi.doubanio.com/simple/[/scode]

临时使用

使用pip的时候在后面加上-i参数，指定pip源： pip install xxx -i 镜像地址

一劳永逸

Linux/Unix中使用

~/.pip/pip.conf 修改pip.conf

[global]
index-url = 镜像地址

Windows中使用

一句命令 pip config set global.index-url 镜像地址

这句命令命令干了什么事呢，其实就是创建了一个pip.ini文件，我们也可以手动创建，在哪创建呢，我们输入 pip config list -v 得到如下输出

D:\admin\Desktop>pip config list -v
For variant 'global', will try loading 'C:\ProgramData\pip\pip.ini'
For variant 'user', will try loading 'C:\Users\admin\pip\pip.ini'
For variant 'user', will try loading 'C:\Users\admin\AppData\Roaming\pip\pip.ini'
For variant 'site', will try loading 'c:\users\admin\appdata\local\programs\python\python37-32\pip.ini'
global.index-url='https://mirrors.aliyun.com/pypi/simple/'
install.trusted-host='mirrors.aliyun.com'

可以看出pip安装时搜索pip.ini来源的路径以及搜索到的镜像源，所以我们只需向其中任一个路径创建一个pip文件夹，然后创建pip.ini文件就行了，可以看到前面的路径都是类似系统路径，最后一个路径是pip环境的路径，所以靠后的路径优先级是更高的，但一般我们只需在系统环境里设置一下就可以一劳永逸了，上面的一句命令行是向Roaming路径（也就是%APPDATA%路径）写入pip/pip.ini。 pip.ini里可以这样写

[global]
index-url = https://mirrors.aliyun.com/pypi/simple/

[install]
trusted-host=mirrors.aliyun.com

下面的一句trusted-host是添加信任防止报错

参考

http://mirrors.163.com/.help/pypi.html https://mirror.tuna.tsinghua.edu.cn/help/pypi/ https://developer.aliyun.com/mirror/pypi?spm=a2c6h.13651102.0.0.3e221b11kAuK9K https://pip.pypa.io/en/stable/user_guide/#config-file

Pyinstaller打包的正确姿势

Wed, 04 Mar 2020 06:03:00 +0000

python打包成exe程序的方法有不少，但最常用的还是pyinstaller，打包python程序主要是为了给那些不懂python的人用的，而且如果是像pyqt一类的图形界面程序，打包一下也会变得更易用。

安装

建议被打包的程序都放在一个虚拟环境中，不论是用venv，pipenv还是conda都是可以的，然后在虚拟环境中安装pyinstaller。

pip install pyinstaller

使用

命令行进入虚拟环境，使用pyinstaller就是一条命令行的事，命令的格式如下： pyinstaller [选项] xxx.py 其中选项可以用命令 pyinstaller -h 查看，常用命令如下:

选项	功能
-h, –help	帮助
–distpath DIR	生成exe程序的位置，默认在当前目录的dist文件下
–workpath WORKPATH	生成临时文件的位置，默认在当前目录的build文件下
–clean	清除生成的文件（重新生成前先清除）
-D, –onedir	打包成一个包含exe程序的文件夹
-F, –onefile	打包成一个独立的exe程序（运行起来会慢很多）
–hidden-import MODULENAME	有些依赖包是动态导入的需手动导入告诉pyinstaller
-d {all,imports,bootloader,noarchive}	生成debug版本
-w, –windowed, –noconsole	隐藏命令行窗口
-i <FILE.ico or FILE.exe,ID or FILE.icns>	为程序添加ico图标
-n NAME, –name NAME	为exe程序指定名称，默认和py程序名一样

打包完成后会生成三个文件(夹)：build，dist，以及一个.spec文件，这个文件记录你的打包参数，可以直接在里面修改参数，然后执行以下命令直接打包，对于依赖复杂的程序这么做更方便，毕竟谁也不想每次打包都输那么长的命令行。 pyinstaller xxx.spec 至于spec文件具体怎么用参考官方文档。

一些坑

打包pyqt程序

[scode type=“blue”] 虽然理论上程序打包很简单，但实际上可能会遇到各种问题，在打包pyqt程序时如果用的是动态导入ui文件，那么就得加上 --hidden-import PySide2.QtXml 并且把ui文件也一同放入exe文件夹内，因为程序并不会打包ui文件；如果程序用到了什么像图标，图片之类的静态文件，也需要都放到exe文件夹下。 [/scode]

单个程序还是文件夹

[scode type=“blue”] 程序打包默认打包成一个文件夹，使用-F参数可以打包成一个单独的exe程序，但经测试，单独一个程序启动速度起码慢了10倍不止，所以建议还是默认文件夹方式，但文件夹太乱了怎么办，可以采取后面的方法整理一下。另外我发现我的程序在打包成一个独立的exe的情况下，隐藏命令行窗口的话，程序中间有个命令无法正常运行，但是打包成文件夹就可以正常运行，由此可见打包成文件夹的容错率更大。 [/scode] [tabs] [tab name=“方法1. 利用runtime-hook参数” active=“true”] 新建一个runtimehook.py文件：

import sys
import os

currentdir = os.path.dirname(sys.argv[0])
libdir = os.path.join(currentdir, "lib")
print(currentdir)
sys.path.append(libdir)
os.environ['path'] += ';./lib'

然后打包时加上参数 --runtime-hook="runtimehook.py" ，这样就可以把除了下面的几个文件外的库文件放到一个lib文件夹中了。

base_library.zip
xxxx.exe
xxxx.exe.manifest
python37.dll

这个方法摘自白月黑羽，注意文件夹不能放到lib里。[/tab] [tab name=“方法2. 利用快捷方式”] 新建一个快捷方式或者符号链接，可以参照我另一篇文章。不过在自己电脑新建的快捷方式不能打包发给别人，因为绝对路径不一样，如果用符号链接的话在打成压缩包时会被打回原型。所以我们可以仿照某些软件安装包的样子做一个自解压的压缩包，在解压软件安装时加上生成桌面快捷方式的选项。打包可以用一些打包工具（比如某些压缩工具就带这个功能），直接打包生成自解压的exe文件然后还带桌面快捷方式，这样显得更高大上。[/tab] [/tabs]

隐藏命令行窗口

[scode type=“blue”]

如果你是gui程序自然不希望出现命令行，那么加上-w参数就行了。
另外隐藏命令行的话，就无法查看报错信息，那么只能在程序里捕捉异常然后通过gui的方法把错误显示出来。但这种错误显示通常不能获取多少有用信息，只是给用户看的。
有时候程序隐藏了窗口，但运行时总有黑黑的命令行窗口不时的闪现出来，网上查找到的弹窗多半是因为程序中引用了os.system引起的，但其实任何可能调用命令行窗口的程序命令都有可能导致弹窗。
比如我的程序因为黑窗口闪现太快肉眼无法捕捉，为了看清这个窗口究竟是什么，我利用录屏一帧帧查看发现是ffmpeg.exe的窗口，好吧，我的程序的pydub库的确用到了它，但怎么让它消失呢，我找到了一篇参考文章。因为pydub库的源码是直接使用subprocess调用ffmpeg.exe和ffprobe.exe的，只需要在audio_segment.py和utils.py文件中调用subprocess.Popen()时指定参数 shell=True, stdin=subprocess.PIPE 即可。 [/scode]

参考

Pyinstaller文档：https://pyinstaller.readthedocs.io/en/stable/ 白月黑羽教Python：http://www.python3.vip/doc/tutorial/python/level2/gui/qt_04/

字幕朗读器——由字幕文件生成音频

Mon, 27 Jan 2020 12:46:00 +0000

最新版本请转下面这篇 [post cid=“210” /]

这是什么

起因是我做视频懒得说话，最多在视频做好后加上字幕，但光有字幕没语音感觉还是差了点意思。市面上有很多文本朗读器，可是我并没有找到一款能朗读字幕的应用，我这里的朗读字幕指语音能自动和字幕时间轴匹配。虽然有几款播放器（potplayer、kmplayer、VLC）自带字幕朗读功能，通过一边朗读一遍录音的话就可以得到我想要的音频，但这种做法过于笨拙。本着学习的目的，我试着用py写了一个小程序实现了字幕朗读的功能。

实现原理

充分利用已有的轮子

通过百度AI平台和阿里云语音服务实现语音合成
利用srt库处理srt字幕文件
利用pydub库对声音进行合成和拼接

代码

写完了发现比想象中要简单，几行代码就搞定了。目前只支持SRT格式的字幕文件，反正字幕文件间可以互相转，对于复杂的字幕可能引发的bug现在一概忽略（比如字幕重叠、一句话语音过长，多轨字幕等）。另外目前都是单线程，速度可能有点慢，程序可能出现假死无响应状态，只要后台文件一直在增加，大可不用管。（因为语音平台都是限制并发数的，感觉多线程有必要？）现已添加多线程。 [scode type=“green”]代码地址：https://github.com/kizx/subtitle2audio[/scode]

下载

[button color=“success” icon=“fa fa-download” url=“https://pan.2bboy.com/Public/Software/%E5%AD%97%E5%B9%95%E6%9C%97%E8%AF%BB/” type=""]onedrive下载地址[/button]

[button color=“success” icon=“fa fa-download” url=“https://wws.lanzous.com/b01hhub9g” type=""]蓝奏云下载密码:gyb3[/button]

使用

[tabs] [tab name="~~v1.0 控制台版~~"]

安装依赖 pip install -r requirements.txt
安装 ffmpeg

下载解压ffmpeg
将解压的 ffmpeg/bin 路径添加到系统环境变量

填写百度 KEY在百度 AI 平台获取相关 KEY ，打开 main.py 填写相应 KEY
启动 python main.py [.srt文件] [/tab] [tab name="~~v1.1 web-gui版~~"]
安装 ffmpeg

下载解压ffmpeg
将解压的 ffmpeg/bin 路径添加到系统环境变量

安装依赖

python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt

启动 flask run浏览器打开 http://127.0.0.1:5000/ 获取并填写相关 key 后点击生成，所有生成的文件在 output 文件夹内。 [/tab] [tab name=“v2.x pyqt-gui版” active=“true”]
安装 ffmpeg

下载解压ffmpeg
将解压的 ffmpeg/bin 路径添加到系统环境变量（可能需要重启电脑）

下载运行下载地址使用前需自行获取相关key

由于申请不了谷歌api，目前做不了谷歌接口报毒请添加白名单或者信任，我自己电脑都报毒→_→，不放心自己下载源码运行

[/tab] [/tabs]

视频案例演示

后记

后来发现一个有同样功能的软件：http://www.cross-plus-a.com/cn/balabolka.htm 打开工具->字幕转换器功能就是，这功能藏的太隐秘当初都没找到。

后后来发现一个叫字幕说的网站也有类似的服务，不过介绍来看，这个是输入文本，然后生成同步的语音和字幕。虽然节省了做字幕的功夫，但这种只适合那种一刻不停的说的视频，适用性还有待提高（有空我也可以整合实现这种功能）。

Python音频处理——pydub库

Sat, 25 Jan 2020 15:41:00 +0000

官方安装说明

下载解压ffmpeg或libav
将解压的ffmpeg/bin路径添加到系统环境变量
pip install pydub

使用教程

百度语音合成平台使用

Sat, 25 Jan 2020 10:22:00 +0000

自主调用

api_key = 'FpGBW******Mvz2SDG'
secret_key = 'Poxd******XR27G7y'
token_url = f'https://openapi.baidu.com/oauth/2.0/token?grant_type=client_credentials&client_id={api_key}&client_secret={secret_key}'
print(token_url) # 从这个链接获取token

token = '24.6430b0df******-18339246' # 获取到的token
test_url = f'http://tsn.baidu.com/text2audio?lan=zh&ctp=1&cuid=abcdxxx&tok={token}&tex=%e7%99%be%e5%ba%a6%e4%bd%a0%e5%a5%bd&vol=9&per=0&spd=5&pit=5&aue=3'
print(test_url) # 从这个链接获取音频

请求方式及参数基本说明

利用官方SDK

from aip import AipSpeech

""" 你的 APPID AK SK """
APP_ID = '18***46'
API_KEY = 'FpGBW******vz2SDG'
SECRET_KEY = 'Poxd******XR27G7y'

client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)

result = client.synthesis('你好百度', 'zh', 1, {
 'vol': 5,
})

if not isinstance(result, dict):
 with open('auido.mp3', 'wb') as f:
 f.write(result)

Google Golab——免费的GPU深度学习平台

Mon, 13 Jan 2020 03:41:00 +0000

官方教程 Google Colab——用谷歌免费GPU跑你的深度学习代码如何正确地使用Google Colab 在COLAB中使用GOOGLE云端硬盘中的教程数据

经验

在菜单的修改->笔记本设置中开启GPU
使用命令行命令只需在命令前加!
挂载google硬盘使用以下命令

from google.colab import drive
drive.mount('/content/drive')

但实际上硬盘根目录在/content/drive/My Drive，这个目录是固定的，直接输入这个目录会提示目录包含空格，太沙雕了，需要使用python命令切换工作目录

import os
os.chdir("/content/drive/My Drive")
！ls #查看当前目录
print(os.getcwd()) #或者
print(os.listdir(os.getcwd()))

不过有一说一，google硬盘速度还是很快的

安装PyTorch 虽然google的cuda版本是10.0的，我懒得找相应的包了，直接!pip3 install torch torchvision即可

Win10安装PyTorch（GPU）

Sat, 11 Jan 2020 10:48:00 +0000

先确保你的电脑的独显支持CUDA，否则只能用CPU运算。这里可以查看自己显卡型号是否支持CUDA以及CUDA计算能力：https://developer.nvidia.com/ 安装工具：Anaconda 常用命令这是官方安装指南：https://pytorch.org/get-started/locally/#anaconda

安装CUDA

官方安装指南：https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html 查看自己的显卡驱动型号支持的CUDA版本：

方式一

在命令行里依次输入下面两条命令

cd C:\Program Files\NVIDIA Corporation\NVSMI
nvidia-smi.exe

然后根据显示的 Driver Version 和下面的图确定自己驱动支持的cude版本上面这张表来自：https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions

方式二

通过NVIDIA的控制面板查看自己显卡驱动版本：https://jingyan.baidu.com/article/363872ecf07d652f4ba16fda.html

确定CUDA版本后去官网下载：https://developer.nvidia.com/cuda-toolkit-archive 根据自己系统选择相应版本下载后安装。下载完成后点击安装即可，安装完在cmd控制台输入nvcc -V返回版本信息即安装成功。注：有些安装教程会要求安装cudnn，我这里暂时不用

安装PyTorch

因为是用Anaconda安装，先进入Anaconda控制台新建一个环境并激活，然后进入https://pytorch.org/get-started/locally/#anaconda 选择你要安装的版本和方式，会自动生成一条安装命令，复制命令粘贴运行。安装过程可能会很艰辛，主要就是那个pytorch的包太大了，足足有480M，建议试试换镜像源看看速度是否会提升，反正我最后是开了全局代理才下下来的。其他安装方式也可以试试。安装完成后输入python然后运行以下代码，返回Ture就说明CUDA是可以使用的

import torch
torch.torch.cuda.is_available()

Anaconda常用命令

Sat, 11 Jan 2020 08:03:00 +0000

Anaconda简单入门

命令

# 查看conda版本
conda --version
conda -V
# 获取帮助
conda --help
conda -h
# 查看当前环境
conda env list
# 新建环境
conda create -n env_name
conda create -n your_env_name python=3.7
conda create -n your_env_name python=3.7 numpy pandas
# 保存环境
conda env export > environment.yml
# 从保存环境新建
conda env create -f environment.yml
# 删除环境
conda remove -n env_name --all
# 一键更新
conda update --all
# 环境切换
activate env_name
conda deactivate env_name
# 包管理
conda install/updata/remove
# 换源
参考:https://blog.csdn.net/observador/article/details/83618540
保存在用户目录.condarc文件中
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --set show_channel_urls yes
# 换回默认的源
conda config --remove-key channels

腾讯云函数入门

Thu, 09 Jan 2020 13:43:00 +0000

使用腾讯云控制台城建函数

之前安装onedrive云盘用的就是这种方式，装多了感觉就简单了，官方文档：https://cloud.tencent.com/document/product/583/37509

使用控制台创建函数

官方文档：https://cloud.tencent.com/document/product/583/37510 其实就是使用cmd控制台来创建，和hexo或者git操作有点类似。这里简单说下步骤：

安装scf：pip install scf 可通过scf --version查看是否安装成功
配置账号：scf configure set 账号信息可以查看链接
初始化项目：scf init
cd进入项目后本地调试运行函数scf native invoke --no-event，调试参数见链接，说一下调试环境python或nodejs均可，如果是用scf local invoke则需要docker。
编写函数和配置文件
部署scf deploy,成功后在腾讯云控制台可以查看
将 serviceId 复制到 template.yaml

VSCode插件

官方教程：https://cloud.tencent.com/document/product/583/37511 在插件市场搜索Tencent Serverless安装结果第一个即可，将之前的命令都按钮化了，更简单直观，还能在vscode里debug。

为云函数打包依赖

函数用到了第三方依赖需自行打包随函数一起上传：https://cloud.tencent.com/developer/article/1443081

aiohttp异步编程入门

Mon, 30 Dec 2019 03:56:00 +0000

教程官方教程就够了： https://docs.aiohttp.org/en/latest/client.html

案例：

import aiohttp
import aiofiles
import asyncio


async def yiyan():
 '''简单的get请求'''
 async with aiohttp.ClientSession() as session:
 async with session.get('https://api.n-1.cn/yiyan') as response:
 print(await response.text())


async def acgpic1(name):
 '''下载是异步的'''
 async with aiohttp.ClientSession() as session:
 async with session.get('https://api.n-1.cn/ACG') as response:
 print(f'下载{name}中...')
 pic = await response.read()
 print(f'{name}下载完成')
 with open(f'{name}.jpg', 'wb+') as f:
 f.write(pic)
 print(f'{name}保存完毕')


async def acgpic2(name):
 '''下载是异步的 保存也是异步的(虽然这里没体现出来)'''
 async with aiohttp.ClientSession() as session:
 async with session.get('https://api.n-1.cn/ACG') as response:
 print(f'下载{name}中...')
 pic = await response.read()
 print(f'{name}下载完成')
 async with aiofiles.open(f'{name}.jpg', 'wb') as f:
 print(f'{name}保存中...')
 await f.write(pic)
 print(f'{name}保存完毕')


loop = asyncio.get_event_loop()
task = [acgpic1(i) for i in range(10)]
loop.run_until_complete(asyncio.wait(task))

Git常用命令

Sun, 24 Nov 2019 02:30:00 +0000

https://gitee.com/help/categories/43 https://git-scm.com/book/zh/v2/ https://git-scm.com/book/zh/v2/%E6%9C%8D%E5%8A%A1%E5%99%A8%E4%B8%8A%E7%9A%84-Git-%E7%94%9F%E6%88%90-SSH-%E5%85%AC%E9%92%A5

初始化

# 设置用户信息
git config --global user.name kizx
git config --global user.email kizxmoe@gmail.com
# 查看设置
git config --list
# 生成密钥
ssh-keygen
# 查看公钥
cat ~/.ssh/id_rsa.pub

创建仓库

# 初始化
git init
# 添加所有文件
git add .
# 提交
git commit -m "first commit"
# 添加远程仓库
git remote add origin git@gitee.com:kizx/rime.git
# 推送
git push -u origin master

利用QQ机器人发送时光机

Fri, 15 Nov 2019 12:38:00 +0000

现在handsome主题已经有了微信公众号和浏览器拓展两种方式向时光机发送消息，那么自然就想到QQ端是否也可以做到，所以我就通过对浏览器扩展发送时光机进行抓包，然后基于酷Q和nonebot，实现了通过向QQ小号发送消息的方式向时光机发送消息。 [scode type=“share”]代码见github[/scode]

使用方法

和微信公众号的用法大同小异，所有消息需要私聊机器人

发送帮助时光机查看帮助信息发送绑定然后根据提示输入绑定信息，发送解绑取消绑定发送时光鸡然后根据提示输入你要发送的消息（也可以一次性输入时光鸡你要发送的消息中间加空格即可）发送开始然后可以逐条发送消息，发送结束结束混合消息，发送取消取消发送发送的第一条消息如果以#开头即为私密消息发送博客获取博客地址发送图床更改图床

如有需要，可以直接加群体验我已经搭建好的QQ机器人 [button color=“success” icon=“fa fa-qq” url="//shang.qq.com/wpa/qunwpa?idkey=786f97195ca56ef0a1888eef7e803fabee0b70cb01d6dbf0c2295454797d803b"]QQ群 642739195[/button]

已知问题

由于QQ可以在一条消息里同时塞进文字和图片，所以发送单条消息也可以达到混合消息的效果，但经我测试在QQ手机客户端如果一条消息同时包含文字和图片，那么图片会无法解析，但是电脑的TIM客户端不存在这个问题。这个问题出在酷Q上，所以要同时发送文字和图片，在手机客户端最好采用逐条发送的模式。
由于handsome_6.0对上传的图片进行了压缩，所以上传gif图片会被压缩成jpg图片，因此图片增加图床功能并默认采用QQ图片的源地址，省去了下载和上传操作，速度更快，但QQ源图片腾讯可能采取限制而无法引用，而且目前已知腾讯对这些图片的缓存会过一段时间就清掉，所以QQ源图床慎用。最好的当然是接入自己的图床，暂时先懒得弄。

安装方法（Windows）

你可以先在自己的电脑上安装和熟悉使用

1. 准备

所有需要下载的东西已打包->点击下载因为是基于酷Q和Python运行的，所以需要先安装酷Q Air->下载地址，然后打开酷Q，登陆你的作为QQ机器人的QQ小号，熟悉酷Q的使用，尤其是插件的安装和启用，酷Q论坛里也有许多其他插件可供玩耍。然后下载安装python，建议下载安装Python 3.7.x 32位版本，因为我是基于这个版本开发的，别的版本尤其是最新的3.8版本可能会有未知的不兼容的bug。安装的时候记得勾选环境变量。

2. 安装插件

这里可以参考CoolQ HTTP API官方说明将io.github.richardchien.coolqhttpapi.cpk移动至酷Q的app文件下，然后重启酷Q或者在应用管理里重载应用，在应用管理里选中HTTP API插件，点击启用，接下来几个弹窗统统选是。启用成功后会弹出控制台窗口。 [scode type=“yellow”]如果弹窗提示应用加载失败，先安装[ Visual C++ 可再发行软件包]( Visual C++ 可再发行软件包)[/scode]

3.启用nonebot

这里可以参考Nonebot官方说明如果你之前成功开启了插件，那么酷Q的data/app/io.github.richardchien.coolqhttpapi/config/目录中应该已经有了一个名为 .json 的文件（为你登录的 QQ 账号），修改其中的内容如下： [collapse status=“false” title=“json文件内容”]

{
 "host": "[::]",
 "port": 5700,
 "use_http": true,
 "ws_host": "[::]",
 "ws_port": 6700,
 "use_ws": false,
 "ws_reverse_url": "",
 "ws_reverse_api_url": "ws://127.0.0.1:8080/ws/api/",
 "ws_reverse_event_url": "ws://127.0.0.1:8080/ws/event/",
 "ws_reverse_reconnect_interval": 3000,
 "ws_reverse_reconnect_on_code_1000": true,
 "use_ws_reverse": true,
 "post_url": "",
 "access_token": "",
 "secret": "",
 "post_message_format": "string",
 "serve_data_files": false,
 "update_source": "github",
 "update_channel": "stable",
 "auto_check_update": false,
 "auto_perform_update": false,
 "show_log_console": true,
 "log_level": "info"
}

[/collapse]

然后下载找到我写的coolq-cross-bot文件，用python运行该文件夹下的bot.py文件，运行前要先安装依赖库。

[tabs] [tab name=“运行方式” active=“true”] 打开命令提示符窗口，执行以下命令：

pip install nonebot
pip install aiohttp

然后在控制台进入coolq-cross-bot文件夹内，输入python bot.py运行该文件，当然也可以用IDE运行。 [/tab] [/tabs] [scode type=“yellow”]阿里云服务器如果一直卡在下载图片且ping不通c2cpicdw.qpic.cn可能是因为节点问题，需添加host记录113.96.232.144 c2cpicdw.qpic.cn [/scode] 最后重启酷Q软件或者重载插件，弹出来的控制台如下显示成功字样则代表配置成功，这时你就可以私聊机器人发送初始化创建一个数据库后就可以使用了（初始化命令只需执行一次，用于在文件目录下新建bind_info.sqlite文件用于记录绑定信息）,最后要注意两个控制台窗口都不能关闭，你可以选择新建一个桌面单独用于运行他们。

安装方法（Linux）

详细参考：CoolQ HTTP API官方说明 Linux系统需要在docker中运行酷Q，所以要先安装docker，安装教程请自行百度，以下仅供参考，以我的Ubuntu16.04 64位为例，ssh连上服务器后运行以下命令安装docker

$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh

然后安装酷Q和HTTP API插件（配置参数无所谓，后面手动替换）

$ docker pull richardchien/cqhttp:latest
$ mkdir coolq # 用于存储 酷Q 的程序文件
$ docker run -ti --rm --name cqhttp-test \
 -v $(pwd)/coolq:/home/user/coolq \  # 将宿主目录挂载到容器内用于持久化 酷Q 的程序文件
 -p 9000:9000 \  # noVNC 端口，用于从浏览器控制 酷Q
 -p 5700:5700 \  # HTTP API 插件开放的端口
 -e COOLQ_ACCOUNT=123456 \ # 要登录的 QQ 账号，可选但建议填
 -e CQHTTP_POST_URL=http://example.com:8080 \  # 事件上报地址
 -e CQHTTP_SERVE_DATA_FILES=yes \  # 允许通过 HTTP 接口访问 酷Q 数据文件
 richardchien/cqhttp:latest

然后访问 http://[你的服务器IP]:9000/ 进入 noVNC（默认密码 MAX8char），登录酷Q，即可开始使用（插件已自动启用，配置文件也根据启动命令的环境变量自动生成了） [scode type=“yellow”]如果阿里云主机注意要先开放相应的端口，默认是9000端口[/scode] 把coolq-cross-bot文件夹上传至服务器，将之前的json文件也上传至服务器并替换掉app/io.github.richardchien.coolqhttpapi/下的ini配置文件（注意将配置文件中127.0.0.1换成172.17.0.1），然后用python3命令运行文件下的bot.py，重启插件

进阶自定义修改（可选）

1. 自定义命令

其实时光机的触发命令不仅可以是‘时光机’，也可以是‘时光鸡’、‘时光姬’等，具体可以在 coolq-cross-bot/plugins/handsome/timeji.py 源码中找到类似下面的语句自行进行修改。 @on_command('timeji', aliases=('时光鸡', '时光机', '时光姬', '动态', '说说')) 其他命令类似。

2. 添加消息来源

如上图所示，在时光机消息的来源处，如果不对handsome的源码进行修改，就会显示来自未知浏览器，找到handsome/libs/UA.php文件，在文件的最后加入如下所示的QQ的来源，名称可以自定义。

public function returnTimeUa(){
 if ($this->ua == "weixin" || $this->ua == "weChat"){
 return array("title"=>_mt("微信公众号"),
 "icon"=>"compass");
 }elseif ($this->ua == "crx"){
 return array("title"=>_mt("Chrome扩展"),
 "icon"=>"chrome");
 }elseif ($this->ua == "qq"){
 return array("title"=>_mt("QQ时光姬"),
 "icon"=>"compass");
 }else{
 $ua = $this->returnOS();
 $ua["icon"] = "disc";
 return $ua;
 }
 }

3.添加消息来源前的图标（6.0主题不需要了）

主题默认呈现出来的都是清一色的小圆点图标，要更改消息来源前的小图标，首先要添加fontawesome图标，然后找到handsome/component/say.php，找到下面第一条语句，改成第二句。

# 找到下面这一句
<i class="glyphicon glyphicon-record m-l-sm"></i>&nbsp;
# 改成下面这样
<i class="<?php echo $ua->returnTimeUa()['icon'] ?> m-l-sm"></i>&nbsp;

Python爬虫学习

Wed, 06 Nov 2019 09:21:00 +0000

import requests
from bs4 import BeautifulSoup
from lxml import etree

url = "http://www.doutula.com/"
headers = {
 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36'}
response = requests.get(url, headers=headers)

soup = BeautifulSoup(response.text, 'lxml')

# 保存网页html内容
with open('content.html', 'w', encoding="utf-8") as f:
 html = soup.prettify()
 f.write(html)

# 通过find_all()选择
html = soup.find_all('img', class_="img-responsive lazy image_dta")
links = [i['data-original'] for i in html]

# 通过css选择
html = soup.select("img[data-original]")
links = [i['data-original'] for i in html]

# 通过xpath选择
root = etree.HTML(response.text)
links = root.xpath('//img/@data-original')

# 保存图片
for index, link in enumerate(links):
 img = requests.get(link)
 with open('img/'+str(index)+'.jpg', 'wb+') as f:
 f.write(img.content)

Pycharm之自定义工具

Sat, 02 Nov 2019 06:05:00 +0000

可以在Tool里添加工具来代替某些命令行操作，新建一个工程后，建议使用系统环境解释器，这样安装包时可以直接安装到环境中，这样在别的工程里也能用上，使用虚拟环境的话，虚拟环境变动了就找不到工具了，当然本质上只要在选择程序时选择环境里的程序就行了。添加的地方在setting->Tools->External Tools。

示例

1. Qt Designer

首先确保库中安装了pyqt5，然后如下图配置

program: C:\Users\ZXIN\Anaconda3\Library\bin\designer.exe
working directory: $ProjectFileDir$

也可以安装pyqt5-tools，然后在Scripts中找到程序

2. PyUIC

program: C:\Users\ZXIN\Anaconda3\Scripts\pyuic5.exe
Arguments: $FileName$ -o $FileNameWithoutExtension$.py
working directory: $FileDir$

3. autopep8

program: C:\Users\ZXIN\AppData\Roaming\Python\Python37\Scripts\autopep8.exe
Arguments: --in-place --aggressive --aggressive $FilePath$
working directory: $ProjectFileDir$

4. Black

需要先安装black

program: C:\Users\ZXIN\AppData\Roaming\Python\Python37\Scripts\black.exe
Arguments: $FilePath$
working directory: $FileDir$

Nonebot酷Q应用开发

Wed, 30 Oct 2019 13:49:00 +0000

前面已经研究过Python和C++的酷Q应用开发流程了，其中慕晓飞大大的SDK虽然前期配置需要一定经验，但配置好后上手很快很简单的，但这个SDK不支持并发是最大的硬伤，限制了其使用范围。而C++的SDK无疑写起来过于麻烦，好在该SDK的大神richardchien在C++ SDK的基础上开发出了基于HTTP的API接口，由此衍生出了基于该HTTP API的多种语言开发版本，其中就有同样是该作者基于Quart框架开发的Nonebot,支持异步处理是其最大的特点，但也由于对消息封装的过于深入，使得在入手使用Nonebot带来不小的挑战。

入门

要使用Nonebot得先从HTTP API开始，先根据这篇说明：https://cqhttp.cc/docs/4.12/#/ 完成对HTTP API的成功调用，然后再到我们的Nonebot出场，官方的入门文档写的已经很仔细了：https://nonebot.cqp.moe/guide/installation.html，走完这篇入门文档，应该很容易就实现了案例中的天气和图灵机器人案例。接下来来梳理以下Nonebot的编写逻辑，他将消息处理分为on_command，on_natural_language，on_request（其他的暂不清楚）几个类型，command用于处理命令，也是用的最多的类型，这里就不用我们手动检测消息里的命令关键字了，然后未被匹配的消息会送到natural_language中处理，如果没有natural_language消息就会被忽略。request用于处理加群请求等非消息类的任务。还有许多细节问题就需要慢慢研究了，比如想在群聊中也是用命令，可以加only_to_me=False参数。要主动调用HTTP API可以使用如下方式：

bot = session.bot
# bot = nonebot.get_bot()
await bot.send_private_msg(user_id=12345678, message='你好～')

要获得上报事件中的参数，需要访问session.ctx。然后下面这个例子是发送测试获得该消息的上报内容，发送其他消息则会复读。

from nonebot import on_command, CommandSession
from nonebot import on_natural_language, NLPSession, IntentCommand

__plugin_name__ = '测试'
__plugin_usage__ = '测试 命令'


@on_command('test', aliases=('测试',), only_to_me=False)
async def test(session: CommandSession):
 ctx = session.ctx
 await session.send(str(ctx))


@on_natural_language(only_to_me=False)
async def repeat(session: NLPSession):
 msg = session.ctx["message"]
 await session.send(msg)

还有更多应用后续再研究。。。

C++酷Q应用开发

Sat, 26 Oct 2019 09:31:00 +0000

以前自己的水平不够，这个项目一直搞不懂，现在起码能跑通了，其实也是比较简单的，项目地址：https://github.com/richardchien/coolq-cpp-sdk

步骤

在该装的东西都装了后，在cmd中依次执行以下命令即可。其中最后一个命令，可能需要先进powershell管理员模式运行Set-ExecutionPolicy并选择是来打开权限。另外由于网络原因，可能会在Unpacking objects这一步卡住，我是通过加速来解决的。

git clone https://github.com/richardchien/coolq-cpp-sdk.git my-awesome-app
cd my-awesome-app
git submodule init
git submodule update
powershell .\scripts\prepare_prebuilt.ps1

然后编译项目，把编译出来的相应文件丢进酷Q的dev文件夹里就行了。

powershell .\scripts\generate.ps1 Release
powershell .\scripts\build.ps1 Release

Python多进程，多线程，协程

Wed, 23 Oct 2019 12:31:00 +0000

以下仅为个人理解

进程——在windows的任务管理器里看到的一个个程序就是进程，最常看见的多进程就是浏览器的多进程，一个程序启动后至少会有一个进程，通常为了效率，会给多核CPU每个核分配几个进程以充分利用CPU。进程之间互不影响，一个进程挂了并不会影响另一个进程。
线程——一个进程至少会有一个线程，线程是最小的执行单位。一个进程可以有多线程，多线程可以提高效率。一个线程挂了会导致该进程挂了从而该进程下的线程都会挂掉。
协程——协程类似于线程，但在控制上稍有不同，是比线程更轻便的一种运行方式，通常和异步IO相关。
并行——并行就是指同时执行多个任务。
并发——和并行差不多意思，应用场合不同。
同步——一个任务执行完了再去执行下一个任务。
异步——一个任务执行到一半转而执行另一个任务收到消息后再回头处理等待的任务

这里有一个更为详细和硬核的教程：https://github.com/denglj/aiotutorial

2、多进程

Python由于CPython解释器的原因，似乎对多进程并不支持，但是可以通过multiprocessing调用多个解释器来实现多进程。

from multiprocessing import Process
import os
import time


# 子进程要执行的代码
def run_proc(name):
 print('Run child process %d (%s)...' % (name, os.getpid()))
 time.sleep(5)


if __name__ == '__main__':
 start = time.perf_counter()
 print('Parent process %s.' % os.getpid())
 p = []
 for i in range(5):
 p.append(Process(target=run_proc, args=(i,)))
 print('Child process will start.')
 for i in range(5):
 p[i].start()
 [x.join() for x in p]
 print('Child process end.')
 end = time.perf_counter()
 print('cost time:', end - start)

从最后的运行时间可以看出该代码实现了5个进程的并行，从任务管理器里也可以看到多个Python进程。也可以通过pool模块来开启多进程，其中运行中的进程数和CPU的核数是匹配的。

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
 print('Run task %s (%s)...' % (name, os.getpid()))
 start = time.time()
 time.sleep(random.random() * 3)
 end = time.time()
 print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
 print('Parent process %s.' % os.getpid())
 p = Pool(4)
 for i in range(5):
 p.apply_async(long_time_task, args=(i,))
 print('Waiting for all subprocesses done...')
 p.close()
 p.join()
 print('All subprocesses done.')

3、多线程

实现

多线程要用到threading模块，新线程调用函数的方法一般有两种，一种是直接调用threading.Thread等指定target的参数，一种是通过新写一个对象继承threading.Thread，然后重写run方法。

import time
import threading

def water():
 print('开始烧水')
 time.sleep(5)
 print('水烧开了')


def rice():
 print('开始煮饭')
 time.sleep(10)
 print('饭煮熟了')


start = time.time()
t1=threading.Thread(target=water)
t2=threading.Thread(target=rice)
t1.start()
t2.start()
t1.join()
t2.join()
stop = time.time()
print(stop - start)

锁

一个线程锁的结构通常如下，线程的运行通常是并行的，如果线程之间需要共同处理某个数据，那么该数据可能就会失控，这是我们就希望一个线程在处理数据时别的线程不要插手，这就是锁的作用。

lock = threading.Lock()
def run_thread(n):
 for i in range(100000):
 # 先要获取锁:
 lock.acquire()
 try:
 change_it(n)
 finally:
 # 释放锁:
 lock.release()

join

在程序末尾经常能看到一个join函数，该函数本来的作用应该是在某处插入一个线程，并且只有当该线程结束时才能继续执行其他命令。被用在程序最后是为了保证所有子线程结束后再结束主线程，没有这句你就会发现你的主线程会比子线程先结束。

守护线程

一个程序的线程之间可以是不平等的，分为普通线程和守护线程。进程也有守护进程，守护进程会在主进程代码运行结束的情况下，立即挂掉。普通线程在主线程结束后仍然可以继续运行，引用说法“该进程内所有非守护线程全部都运行完毕后,守护线程才会挂掉”。这东西到底有什么用我还没搞清楚。。。守护线程的实现方法是设置线程的.daemon=True

4、协程

Python的协程是通过yield来完成的，yield本质是一个生成器，可以通过next()来进行迭代，还可以通过send()来传递参数，多任务并发使用起来很方便。

import time

def func1():
 while True:
 yield
 time.sleep(1)
 print('func1')

def func2():
 g = func1()
 for i in range(3):
 next(g)
 time.sleep(1)
 print('func2')

start = time.time()
func2()
stop = time.time()
print(stop - start)

协程想要并行还需要借用其他一些库比如asyncio

import threading
import time
import asyncio


@asyncio.coroutine
def water():
 print('开始烧水')
 yield from asyncio.sleep(5)
 print('水烧开了')


@asyncio.coroutine
def rice():
 print('开始煮饭')
 yield from asyncio.sleep(10)
 print('饭煮熟了')


start = time.time()
loop = asyncio.get_event_loop()
tasks = [water(), rice()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
stop = time.time()
print(stop - start)

这个程序最终需要时间仅为10秒多点，因此是并行的，但要注意这利用的是 yield from asyncio.sleep(5)，这里代表的是一个IO阻塞，并不是什么函数放在这里都能够并行的。

Matplotlib学习

Mon, 14 Oct 2019 13:46:00 +0000

安装

python -m pip install -U matplotlib

练习

import numpy as np
import matplotlib.pyplot as plt

# 导入 matplotlib 的所有内容（nympy 可以用 np 这个名字来使用）
#from pylab import *

# 创建一个 8 * 6 点（point）的图，并设置分辨率为 80
plt.figure(figsize=(8,6), dpi=100)


X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)

# 创建一个新的 2 * 2 的子图，接下来的图样绘制在其中的第 1 块
plt.subplot(2,2,1)
# 绘制余弦曲线，使用蓝色的、连续的、宽度为 1 （像素）的线条
plt.plot(X, C, color="blue", linewidth=1.0, linestyle="-")

# 绘制正弦曲线，使用绿色的、连续的、宽度为 1 （像素）的线条
plt.subplot(2,2,2)
plt.plot(X, S, color="green", linewidth=1.0, linestyle="-")

#回执第三个合并图
plt.subplot(2,2,3)
plt.plot(X, C, color="blue", linewidth=1.0, linestyle="-")
plt.plot(X, S, color="green", linewidth=1.0, linestyle="-")

# 设置轴的上下限
xmin ,xmax = X.min(), X.max()
ymin, ymax = C.min(), C.max()
dx = (xmax - xmin) * 0.1
dy = (ymax - ymin) * 0.1
plt.xlim(xmin - dx, xmax + dx)
plt.ylim(ymin - dy, ymax + dy)

# 设置横轴记号
plt.xticks(np.linspace(-4,4,9,endpoint=True))
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
 [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
# 设置纵轴记号
plt.yticks(np.linspace(-1,1,5,endpoint=True))


#改变坐标轴位置
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))

#增加图例
plt.plot(X, C, color="blue", linewidth=2.5, linestyle="-", label="cosine")
plt.plot(X, S, color="red", linewidth=2.5, linestyle="-", label="sine")
plt.legend(loc='upper left')

#标注特殊点
t = 2*np.pi/3
plt.plot([t,t],[0,np.cos(t)], color ='blue', linewidth=2.5, linestyle="--")
plt.scatter([t,],[np.cos(t),], 50, color ='blue')

plt.annotate(r'$\sin(\frac{2\pi}{3})=\frac{\sqrt{3}}{2}$',
 xy=(t, np.sin(t)), xycoords='data',
 xytext=(+10, +30), textcoords='offset points', fontsize=8,
 arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

plt.plot([t,t],[0,np.sin(t)], color ='red', linewidth=2.5, linestyle="--")
plt.scatter([t,],[np.sin(t),], 50, color ='red')

plt.annotate(r'$\cos(\frac{2\pi}{3})=-\frac{1}{2}$',
 xy=(t, np.cos(t)), xycoords='data',
 xytext=(-90, -50), textcoords='offset points', fontsize=8,
 arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

#文字无遮挡
for label in ax.get_xticklabels() + ax.get_yticklabels():
 label.set_fontsize(8)
 label.set_bbox(dict(facecolor='green', edgecolor='None', alpha=0.5 ))


#保存图片
plt.savefig("exercice_2.png",dpi=200)

# 在屏幕上显示
plt.show()

Windows下使用make命令

Sun, 13 Oct 2019 08:47:03 +0000

看CMake教程时每次在cmake后都会跟着一个make命令，Linux系统下天然有这个命令。但是我的电脑装了MinGW，也设了环境变量却用不了make命令。

解决

先去MinGW的安装目录下的bin目录里看看有没有mingw32-make.exe文件，如果没有用以下命令下载： mingw-get install gcc g++ mingw32-make 然后将该文件重命名为make.exe即可。这样通过CMake利用MinGW编译生成MakeFile相关文件，直接调用make命令就能生成可执行文件了，比起用微软的VS要方便不少。

CMake+VS2017编译OpenCV程序

Fri, 11 Oct 2019 16:27:00 +0000

起因来自下面的OpenCVd官方的一个教程，尝试使用CMake。

https://docs.opencv.org/4.1.1/db/df5/tutorial_linux_gcc_cmake.html

但是按照官方的教程会出现很多问题。

建立工程

先建立下面的这样一个结构
主函数代码

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
using namespace cv;
int main(int argc, char** argv )
{

 Mat image;
 image = imread( "C:\\Users\\ZXIN\\Desktop\\001.png" );
 namedWindow("Display Image", WINDOW_AUTOSIZE );
 imshow("Display Image", image);

 waitKey(0);

 return 0;
}

CMakeLists.txt内容

cmake_minimum_required(VERSION 2.8)
project( DisplayImage )
find_package( OpenCV REQUIRED )
add_executable( DisplayImage DisplayImage.cpp )
target_link_libraries( DisplayImage ${OpenCV_LIBS} )

编译

如果在命令行cmake的话会找不到路径，所以我改用CMake GUI，先选择CMakeLists所在文件夹和编译后的一个空文件夹
点击Configure，按下图配置，点击Finish
这是应该会报错，这是就体现gui的方便之处了，点击替换正确的OpenCV路径
如果还有报错的话，建议gui左上角清除CMake缓存重新开始，没有问题的话继续点击Generate和Open Project，软件自动打开build下的VS工程文件，VS里右键生成解决方案即可。

用Astyle为Qt Creator添加代码自动格式化功能

Wed, 09 Oct 2019 11:55:00 +0000

先要下载安装Astyle https://sourceforge.net/projects/astyle/files/

2. 添加Beautifier插件

打开Qt Creator，在帮助->关于插件中打开Beautifier插件

3. 配置Astyle

打开工具->选项->Beautifier

设置Astyle的路径

设置自定义风格

风格可以参考官方说明http://astyle.sourceforge.net/astyle.html#_Brace%20Style%20Options

4. 设置快捷键

在选项->环境->键盘里搜索format，选择相应项设置快捷键，当然我们设置了保存时自动规范，不用快捷键也行，在工具菜单栏里也可以相应命令

参考：

https://www.techieliang.com/2018/01/873/

OpenCV + Qt 配置

Mon, 07 Oct 2019 14:20:00 +0000

假设已经下载安装了OpenCV和Qt并且配置好了OpenCV的环境变量，环境变量设置可以参考以前的文章。

CMake编译

许多教程都会从CMake编译OpenCV开始，但其实我们下载的安装包解压后已经编译好了，bulid文件下就是编译后的文件，除非有特殊要求，可以不用亲自编译。主要是我尝试用CMake编译Source但是报错失败了，就此作罢。

编写pri文件

新建一个文件，重命名为opencv.pri，写入以下内容，其实和在VS2017里配置库环境是一样的道理。

INCLUDEPATH += c:/opencv/build/include
Debug: {
LIBS += -lc:/opencv/build/x64/vc15/lib/opencv_world411d
}
Release: {
LIBS += -lc:/opencv/build/x64/vc15/lib/opencv_world411
}

新建工程

在Qt里新建一个最普通的工程，编译器选择VS2017 64bit，新建完成后在工程的pro文件最后添加刚才的pri文件路径： include(c:/opencv/opencv.pri)

测试代码

在main函数里进行测试

#include "mainwindow.h"
#include <QApplication>
#include "opencv2/opencv.hpp"

int main(int argc, char *argv[])
{
 QApplication a(argc, argv);


 using namespace cv;
 Mat img = imread("../001.png");
 imshow("TEST",img);
 waitKey(0);

 return a.exec();
}

NumPy学习（二）

Thu, 26 Sep 2019 10:18:00 +0000

1. 加减

得益于广播机制，numpy的算术比较灵活

import numpy as np

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
b = np.array([[10, 20, 30, 40], [50, 60, 70, 80]])
c = a + b
d = a + 10
e = a + [1, 2, 3, 4]
print(c)
print(d)
print(e)

注意：当两个数据类型不同的数组相加减时，结果以范围大的为准，比如uint8+float32=float32，uint8超出范围数据溢出时对255取模后减1。

2. 乘除

import numpy as np

a = np.array([1, 2, 0], np.uint8)
b = np.array([125, 150, 200], np.uint8)
# 乘法
print(a * b)
print(np.multiply(2, b))
# 除法
print(b / a)
# 矩阵乘法
print(np.dot(a, b.T))
print(a @ b.T)

3. 其他运算

方法	示例	注意事项
转置	A.T
转置	np.transpose(A)
改变形状	A.reshape(4,2)
改变形状	np.resize(A, (4,2))
迭代	for element in A.flat:
迭代	A.flatten()
迭代	for element in np.nditer(A):
展开	A.ravel()	会改变原数组
分割	np.split(A,3)
添加	np.append(A, [7,8,9],axis=1)
插入	np.insert(A, 2, [7,8,9],axis=1)
删除	np.deleter(A,1,axis = 1)
乘方	np.power(A,2)
乘方	**

NumPy学习（一）

Wed, 25 Sep 2019 08:43:00 +0000

1. 安装和学习

pip安装 pip install numpy
Anaconda自带

学习资源

2. ndarray

import numpy as np
# 一维数列
a1 = np.array([1, 2, 3])
print(a1)
# 二维数列
a2 = np.array([[1, 2], [3, 4]])
print(a2)
# 定义最小维度
a3 = np.array([1, 2, 3, 4], ndmin=2)
print(a3)
# 指定数据类型
a4 = np.array([1, 2, 3], dtype=np.float32)
print(a4)

3. 数据类型

import numpy as np
# 使用标量类型
dt1 = np.dtype(np.int32)
print(dt1)
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt2 = np.dtype('i4')
print(dt2)
# 还可以像结构体一样用
student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50), ('xyz', 18, 75)], dtype=student)
print(a)
print(a['name'])
print(a[1])

4. 数组属性

import numpy as np

a = np.array([[0, 1, 2, 3], [4, 5, 6, 7]])
# 维度
print(a.ndim)
# 各维度大小
print(a.shape)
# 现在调整其大小
a.shape = (4, 2)
print(a)
b = a.reshape(2, 4)
print(b)
print(b.ndim)
# b 现在拥有三个维度
b = a.reshape(2, 1, 4)
print(b)
print(b.ndim)
# 数组元素的字节大小 
x = np.array([1,2,3], dtype = np.int8)
print (x.itemsize)

5.特殊数组

import numpy as np
# 未初始化的数组
x = np.empty([3, 2], dtype=int)
print(x)
# 元素为零
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5, ), dtype=np.int)
print(y)
# 自定义类型
z = np.zeros((2, 2), dtype=[('x', 'i4'), ('y', 'f4')])
print(z)
# 对角矩阵
x = np.eye(4)
print(x)
# 从列表或元组转换
# numpy.asarray(a, dtype = None, order = None)
x = [1, 2, 3]
a = np.asarray(x)
print(a)
x[0] = 0
print(x)
# 序列
# numpy.arange(start, stop, step, dtype)
x = np.arange(10, 20, 2)
print(x)
# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
x = np.linspace(10, 20, 6)
print(x)
# 重复
b = np.array([1, 2, 3])
bb = np.tile(b, (2, ))
print(bb)

6. 数组切片

import numpy as np

a = np.arange(10)
print(a)
s = slice(2, 7, 2) # 从索引 2 开始到索引 7 停止，间隔为2
print(a[s])
b = a[2:7:2] # 效果同上
print(b)

a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
# 从某个索引处开始切割
print(a[1:, 1:])
print(a[1:, [1, 2]])
print(a[:, 0]) #获取列元素

7. 高级索引

import numpy as np

x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0, 1, 2], [0, 1, 0]] #获取数组中(0,0)，(1,1)和(2,0)位置处的元素
print(y)

x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
rows = np.array([[0, 0], [3, 3]])
cols = np.array([[0, 2], [0, 2]]) # 获取四个角元素
y = x[rows, cols]
print(y)
# 通过判断布尔
x[x > 5] = 0
print(x)
# 通过索引
x = np.arange(32).reshape((8, 4))
print(x[[4, 2, 1, 7]])
x = np.arange(32).reshape((8, 4))
print(x[np.ix_([0, 1, 6, 7], [3, 2, 1, 0])])

OpenCV + Visual Studio2017 配置

Wed, 11 Sep 2019 17:25:00 +0000

1. 下载安装OpenCV并添加环境变量

下载地址：https://opencv.org/releases/ 安装参考：http://c.biancheng.net/view/1104.html 我安装的是Opencv4.1.1版本，然后管理员cmd命令添加环境变量，其实不用命令手动添加也行,不过这一步似乎不是必须的，但可能会与某些步骤有关联。 setx -m OPENCV_DIR C:\opencv\build\x64\vc15 然后添加以下OpenCV环境变量到PATH中，VS2017应该对应的是vc15，不过都加进去也不会出错。路径直接填%OPENCV_DIR%\bin也行。 C:\opencv\build\x64\vc14\bin C:\opencv\build\x64\vc15\bin

2. 新建工程

打开vs2017，新建控制台程序，将系统平台改成64位，在项目上右键属性配置下列项目

点击VC++目录->包含目录，添加include文件夹目录
点击VC++目录->库目录，添加lib文件夹目录
点击链接库->输入->附加项，添加lib，其中opencv_world411d.lib为debug模式用的，opencv_world411.lib为release模式用的，都可以在lib文件夹下找到

3. 测试代码

打开一张图片进行测试

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
using namespace cv;
int main()
{
 Mat img = imread("C:\\Users\\ZXIN\\Desktop\\cv\\001.png");
 imshow("001", img);
 waitKey(0);
 return 0;
}

OpenCV + Anaconda + VSCode 配置

Wed, 11 Sep 2019 08:23:00 +0000

我这个搭配有点奇怪，但是顺手最重要嘛，先收藏几个教程 OpenCV教程

下载安装OpenCV https://opencv.org/releases/
下载安装Anaconda https://www.anaconda.com/distribution/
配置文件如果都是默认安装路径的话，将C:\opencv\build\python\cv2\python-3.7\cv2.cp37-win_amd64.pyd复制到C:\Users\ZXIN\Anaconda3\Lib目录下
新建测试文件打开VSCode，将左下角Python运行环境切换到Anaconda的Python解释器，敲入一下测试代码：

import cv2
img = cv2.imread("001.png")
cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Python酷Q应用开发

Tue, 03 Sep 2019 16:59:00 +0000

前言

酷Q机器人应用一般都是用易语言开发的，但是一方面不想再多学一门易语言，另一方面开发脚本还是用Python比较舒服。关于Python的酷Q的SDK我在论坛找了一下，目前用的比较多的有两个（现在应该是三个了，见文末），一个是基于http的none-bot，功能更强大，但上手有一定难度，所以最简单的我觉得还是慕晓飞大大的 Python酷Q_SDK_X
本站更多关于酷Q的文章：点我

环境配置

首先需要按照文档的说明配置开发环境，这点文档讲的很详细，就不赘述了，需要注意的是：

酷Q本身是32位程序，开发时只支持32位的Python。
还有一点就是app_id应该按照官方规范来，否则可能会出问题，规范说明。
酷Q升级后开发环境的目录移动至酷Q的dev目录下，如果酷Q没有自动更正的话请手动更正。更正方法为，在dev目录下新建cn.muxiaofei.coolq_sdk_x文件夹，将原来的cn.muxiaofei.coolq_sdk_x.dll和cn.muxiaofei.coolq_sdk_x.json重命名为app.dll和app.json移动至新建的文件夹下，其他不变。

配置完环境，如果不出意外的话，应该就能在酷Q日志的DEBUG里看到输出的hello world。

编写程序

接下来就是敲自己的代码了，这个SDK的所有事件处理和API调用都在CQPlusHandler.py文件的?MainHandler类中进行编写，关于事件和参数的说明在开发文档中都有说明，API可以通过输入self.api的代码提示进行查看，也可以转到一个_api.py的文件中查看，至于这些API函数和参数的意义基本上看名字就能猜到八九分了，具体使用方法需要自己去尝试。
新手需要注意的是这个CQPlusHandler.py程序是由酷Q软件自动执行的，不需要在Python的IDE里点运行，当然你点了也没用，如果setting里的DEBUG参数你没改的话，只要修改代码并保存，修改的代码就会实时生效。
然后需要说明的就是@和表情，这个需要使用CQ码，CQ码详细介绍。但一般只需在QQ中发一条包含@或表情的消息，然后通过酷Q的日志就能直接进行右键复制了，复制后只需将相应的格式通过字符串的格式和普通消息一样输出就行了。
举个例子，在CQPlusHandler.py文件中写入以下代码就能实现在群聊里复读并@发言的人的功能：

# -*- coding:utf-8 -*-

import cqplus

class MainHandler(cqplus.CQPlusHandler):
 def handle_event(self, event, params):
 if event == "on_group_msg":
 msg = '[CQ:at,qq=' + str(params['from_qq']) + ']' + params['msg']
 self.api.send_group_msg(params['from_group'], msg)

案例

然后下面是我根据需求给群友写的一个自助Roll游戏的插件，和论坛上我能找到的抽奖插件相比，这个插件的特点在于完全由qq消息进行命令，可以直接丢到服务器上就不用管了，另一个特点是可以同时进行多个Roll游戏活动而互不干扰，以下是一个使用案例。这个应用其实还有一些功能我想过但还没加进去，以后根据需要有时间再看看吧，我把我写的垃圾代码放在了GitHub上，希望可以给有需要的人一点有价值的参考：Github链接

已知问题

打包

最后就是应用的打包，直接使用打包生成的cpk文件会报错，需要像开发应用一样配置好环境并把源程序也放进去，唯一的差别就在于可以不用进入酷Q的开发者模式，所以要丢到服务器上的话，还有一丢丢的麻烦。由于Python的SDK的特性，编写的插件就不能像论坛上别的插件一样只发布cpk文件即可，而且使用者还需配置环境，对于普通用户来说过于麻烦了，所以这个还是只适合开发者自己使用。

消息并发处理

由于Python的GLI锁机制，本插件不支持并发处理。表现为有事件发生时，比如各种消息和定时器事件，插件便会调用一次CQPlusHandler.py进行事件处理，所以当上一次事件还未处理完时，下一个事件又紧接着发，这时便会发生内存报错。虽然报错了程序并不会崩溃，不过如果程序要处理网络请求一类的耗时任务，这个缺陷是致命的。要想避免这种报错，只在CQPlusHandler.py文件里下功夫（比如用多线程）应该是不行的，估计得从源码上想想办法才行。不过我的机器人不需要处理大量消息，消息处理的也很快，所以凑合用用也还行。
后来有大神重新写了个支持并发的python SDK，现在也更推荐使用这个或者更高级的nonebot。

加速Python的几种方法

Sun, 04 Aug 2019 17:12:00 +0000

前言

注意以下内容均为本人主观操作感受，运行环境为Win10+python3.7_32位，仅供本人日后查阅

众所周知，python是一门优美而简洁的编程语言，其最大的不足在于运行速度过于感人，而C语言作为最接近底层的高级语言，速度快是他最大的优势。python被誉为胶水语言，应该有办法和C语言胶和起来，我查阅资料发现python调用C语言最普遍的方式大概有三种：

将C语言的函数编译成dll动态链接库，然后通过python的ctypes模块对dll进行调用。
借由cython先将python代码编译成C语言代码，然后再讲C代码编译成.pyd文件直接在python中导入进行调用，cython本身有一定语法，不过不会一般也不太影响使用。
使用Swig可以将C代码直接封装成python代码，过程略为复杂，优点是可以为多种语言提供接口。

以上几种方法的原理和过程下图很好的解释了：

本文以斐波拉契函数为例，探究python和C的合璧之法。

import time

def fib(n):
 if n == 0:
 return 0
 elif n == 1:
 return 1
 else:
 return fib(n-1) + fib(n-2)

start=time.time()
print("计算结果:%d" % fib(40))
end=time.time()
print('python time cost:',end-start)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int fib(int n)
{
 if (n == 0)
 {
 return 0;
 }
 else if (n == 1)
 {
 return 1;
 }
 else
 {
 return fib(n - 1) + fib(n - 2);
 }
}

int main()
{
 clock_t start, end;
 start = clock();
 printf("计算结果:%d\n", fib(40));
 end = clock();
 printf("C cost time:%f", (double)(end - start) / CLOCKS_PER_SEC);
 system("pause");
 return 0;
}

通过运行上面的代码可以得到运行时间：

纯python：
计算结果:102334155
python time cost: 87.49325394630432

纯C语言：
计算结果:102334155
C cost time:0.863000

差不多差了两个数量级吧。。。

1. 通过ctypes调用dll

首先得先生成一个dll，你可以在ide里新建一个dll工程进行创建。更简单的做法是利用下面的gcc命令直接在cmd里进行编译，但前提是你已经装了Mingw或者并Mingw-w64且设置了环境变量，其中有个比较坑的地方就是你编译出来的dll位数要和你的python位数要匹配，像我笔记本上装的是Mingw-w64，而pyhton是32位的，32的python无法调用64位的dll，而这位Mingw-w64虽说同时支持64位和32位，但是前提是安装时勾选的是sjlj而不是seh，seh不支持32位！

安装Mingw建议用下面这位up的工具，简单快捷。
【一键】20秒配置VScodeC语言C++开发环境！
安装Mingw-w64可以参考：Mingw-w64安装

用于编译dll的c语言代码只需给出函数就好了：

int fib(int n)
{
 if(n == 0)
 {
 return 0;
 }
 else if(n == 1)
 {
 return 1;
 }
 else
 {
 return fib(n-1) + fib(n-2);
 }
}

下面是cmd中将C原文件编译成dll的命令：

gcc -fPIC -shared name.c -o name.dll

如果是sjlj的Mingw-w64加上-m32可以编译出32位dll：

gcc -fPIC -shared -m32?name.c -o?name.dll

然后在python中导入ctypes模块就可以调用dll了：

import ctypes
import time

start=time.time()
fibpy=ctypes.CDLL('fibpy.dll')
print("计算结果:%d" % fibpy.fib(40))
end=time.time()
print('dll time cost:',end-start)

ctype调用dll运行时间：

计算结果:102334155

dll time cost: 0.9999649524688721

因为只有一个函数，还调用的是C语言的，所以速度和纯C差不多。

2. cython

先给出官方的一个教程：官方教程

使用cython首先要安装cython模块：

pip install Cython

然后你需要安装Mingw进行一番配置或者直接下载安装Visual Studio安装C++环境，因为我用的是Mingw-win64，所以自然就先抛弃后面那个巨无霸选用前者，一番尝试后发现还是Visual Studio真香。当然可能单纯的是因为Mingw-win64不支持而已，用Mingw的话应该是可以的（但愿）。

安装完环境后就可以直接把之前的纯python代码中的函数部分进行cython转换，不过需要现将其后缀名改为.pyx，然后需要再创建一个setup.py文件，其中写入代码：

from distutils.core import setup
from Cython.Build import cythonize
setup(
? ? ext_modules = cythonize("fibcy.pyx")
)

然后还是cmd中执行：

python setup.py build_ext --inplace

这时应该会生成一个.pyd文件，这个文件本质和前面的dll应该差不多，可以通过import在python中使用：

import time
import fibcy

start=time.time()
print("计算结果:%d" % fibcy.fib(40))
end=time.time()
print('cython time cost:',end-start)

运行结果：

计算结果:102334155

cython time cost: 15.108871698379517

可以看到即使是在没有使用任何cython语法的情况下，cython的加速能力也是令人惊叹的，运行速度提高了一个数量级左右！

3. Swig

同样先给出一个教程参考：Swig教程

其实swig的原理和前面也差不多，但是过程更为复杂。首先当然要安装swig，下载解压后同样添加到系统环境变量。

然后要准备的有C语言源文件，一个.i文件，还有一个setup.py文件。

#include <stdio.h>

int fib(int n)
{
 if (n == 0)
 {
 return 0;
 }
 else if (n == 1)
 {
 return 1;
 }
 else
 {
 return fib(n - 1) + fib(n - 2);
 }
}

%module fib
%{
#include <stdio.h>
%}
extern int fib(int n);

from setuptools import setup,Extension
setup( name='fib',
 version='1.0',
 ext_modules=[Extension('_fib', ['fib.c', 'fib.i'])]
 )

最后在命令行运行setup.py：

python setup.py build_ext --inplace

最后生成的文件中应该有一个python文件，可以直接进行调用，除此之外我发现还有一个.pyd文件，果然和前面的方法都差不多呢，导入运行方法也和之前相同。

运行结果：

计算结果:102334155

swig time cost: 0.6825790405273438

居然比纯C语言还要快！大概是因为去掉了计时模块的缘故，可能python的计时模块比C的要快？结果还是很匪夷所思呢？

4. namba的@jit加速

namba加速不同于以上3种方法，上面3种方法多多少少会和C语言扯上点关系。numba则是直接在python源文件里通过加上一些代码直接运行并获得加速效果，本质原理也是使数据向静态靠拢，但是实现过程与上面3种方法相比更简单，可以参考官方入门教程

下面具体看一下实现过程：首先肯定是要先安装numba包

pip install numba

然后只需在Python代码中导入numba并用jit修饰相应的函

import time
from numba import jit

@jit(nopython=True)
def fib(n):
 if n == 0:
 return 0
 elif n == 1:
 return 1
 else:
 return fib(n-1) + fib(n-2)

start=time.time()
print("计算结果:%d" % fib(40))
end=time.time()
print('numba@jit time cost:',end-start)

运行结果：

计算结果:102334155

numba@jit time cost: 1.2832109928131104

加速效果可以说是相当惊人的，比cython要快，而且操作也特别简单，不用导来导去，和numpy相配合使用可以使运行速度得到极大的提升。

总结

方案	运行时间
纯Python	87.49325394630432
纯C语言	0.863000
ctypes	0.9999649524688721
cython	15.108871698379517
swig	0.6825790405273438
numba	1.2832109928131104

python结合c语言的三种方法中ctypes方法最简单，将C代码直接编译成dll即可使用，cython可以为现有的python代码加速，swig可以直接将C转换为python，就是有点麻烦，但速度是最快的。numba的jit加速比上面三种方法都要更简单，只需在python源码里加几句就行了，而且速度也很可观。

代码 on 醉后的星星

Win32_API修改EXE文件ICON图标

说明

代码

VS2019配置pthread多线程

配置

示例代码

参考

npm基本命令

Python调用子进程subprocess

subprocess.run

subprocess.Popen

参考

CSS盒子居中的几种方法

定位布局

定位+移动布局

flex 布局

grid 布局

inline-block 布局

table-cell 布局

各种排序算法的Python实现

冒泡排序

选择排序

插入排序

归并排序

快速排序

堆排序

计数排序

基数排序

桶排序

参考

PyQt多行文本QPlainTextEdit拖放文件后光标不动解决方法

解决方法

单层离散Hopfield神经网络(DHNN)程序实现

程序实现

参考

再谈Python读取stl模型

stl库

numpy-stl库

Python读取stl模型并获取点坐标值

读取代码

后记

参考

Visual Studio配置glut/freeglut开发环境

freeglut配置

glut配置

Windows编译安装CGAL

下载安装boost

自己编译

下载安装CGAL

其他可选依赖

Qt

Eigen

Cmake编译运行

参考

Pyqt提升控件为自定义控件的方法(动态加载ui文件)

方法

参考

Windows本地部署3d-photo-inpainting项目

前提

步骤

更多设置

Pyqt加载ui文件界面的方法

动态加载

静态加载

总结

conda设置国内镜像源

设置

参考

Python处理和保存json文件注意事项

注意事项

pyqt实现文件拖放获取路径

操作

pip设置pypi国内镜像

开源镜像站

临时使用

一劳永逸

Linux/Unix中使用

Windows中使用

参考