一键安装Oh-My-Zsh

最新经常在新的环境中安装Oh-My-Zsh，所以就写了一个一键安装脚本

一、安装脚本

1
2
3
4
5
6
7
apt install zsh -y
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

echo -nE 'PROMPT="%(?:%{$fg_bold[green]%}%n@%m:%{$fg_bold[red]%}%n@%m)%{$reset_color%}:%{$fg[blue]%}%c%{$reset_color%}$ "' > ~/.oh-my-zsh/themes/killf.zsh-theme
sed -i '/^ZSH_THEME="robbyrussell"/c\ZSH_THEME="killf"' ~/.zshrc
sed -i '/^plugins=(git)/c\plugins=(zsh-autosuggestions)' ~/.zshrc

二、一键安装

1
sh -c "$(curl -fsSL https://raw.githubusercontent.com/killf/install-oh-my-zsh/master/install-oh-my-zsh.sh"

更多内容 >>

Rust中实现动态派发

在Rust中实现动态派发（即多态），在运行时确定具体的函数在某些场景下是非常有用的，比如编写插件系统。Rust中的dyn Trait本质上是一个胖指针，记录数据地址和虚函数表地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
trait Shape {
    fn area(&self) -> f64;
}

struct Square {
    size: f64,
}

impl Square {
    pub fn new(size: f64) -> Square {
        Square { size }
    }
}

impl Shape for Square {
    fn area(&self) -> f64 {
        self.size * self.size
    }
}

struct Circle {
    radius: f64,
}

impl Circle {
    pub fn new(radius: f64) -> Circle {
        Circle { radius }
    }
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

fn area(shape: &dyn Shape) -> f64 {
    shape.area()
}

fn main() {
    let square = Square::new(3.0);
    let circle = Circle::new(3.0);

    println!("square: {}", area(&square));
    println!("circle: {}", area(&circle));
}

测试一下，结果如下：

1
2
square: 9
circle: 28.274333882308138

更多内容 >>

极致的Rust-no_std

Rust支持no_std模式，即不使用标准库，可以大大的减少包的大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#![no_std]
#![no_main]

unsafe extern "C" {
    fn write(fd: i32, buf: *const u8, count: usize) -> isize;
    fn exit(status: i32) -> !;
}

#[panic_handler]
unsafe fn panic(_info: &core::panic::PanicInfo) -> ! {
    exit(-1);
}

#[no_mangle]
unsafe extern "C" fn _start() -> ! {
    let msg = b"hello, world!\n";
    write(1, msg.as_ptr(), msg.len());
    exit(0);        
}

编译命令：

1
2
3
4
5
6
7
8
rustc \
  -C panic=abort \
  -C opt-level=z \
  -C lto \
  -C codegen-units=1 \
  -C strip=symbols \
  -C link-arg=-nostartfiles \
  src/main.rs -o test

测试一下，会显示“hello,world!”，如下：

1
./test

更多内容 >>

快速排序

快排的时间复杂度$O(n*log(n))$，空间复杂度$O(1)$

一、代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>

using namespace std;

template<class T>
void quick_sort(T *data, size_t n) {
    if (n <= 1)return;

    size_t k = 1;
    for (size_t i = 1; i < n; i++) {
        if (data[i] < data[k - 1]) {
            swap(data[k - 1], data[i]);
            k++;
        }
    }

    quick_sort(data, k);
    quick_sort(data + k, n - k);
}
more >>

更多内容 >>

二叉树最小公共祖先

给定一个二叉树和二叉树中的两个不同节点，寻找这个两个节点的最小公共祖先。
思路是：先找到一条路径到这个两个节点中的其中一个，然后从下往上遍历这个节点的各级父节点，寻找这个节点是否包含另外一个节点。

一、算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <vector>

struct Node {
  int value;
  Node *left;
  Node *right;

  Node(const int &value, Node *left = nullptr, Node *right = nullptr) : value(value), left(left), right(right) {}
};

Node *find_path(Node *node, Node *n1, Node *n2, std::vector<Node *> &path) {
  path.push_back(node);
  if (node == n1 || node == n2)return node;

  Node *result = nullptr;
  if (node->left && (result = find_path(node->left, n1, n2, path))) return result;
  if (node->right && (result = find_path(node->right, n1, n2, path))) return result;

  path.pop_back();
  return nullptr;
}

bool find_child(Node *node, Node *child) {
  return node == child || (node->left && find_child(node->left, child)) ||
         (node->right && find_child(node->right, child));
}

Node *find_parent(Node *node, Node *n1, Node *n2) {
  std::vector<Node *> path;
  auto n = find_path(node, n1, n2, path);
  if (!n)return n;

  Node *last = nullptr, *target = n == n1 ? n2 : n1;
  for (auto iter = path.rbegin(); iter != path.rend(); iter++) {
    Node *parent = *iter;
    if (last) {
      parent = last == parent->left ? parent->right : parent->left;
    }
    if (find_child(parent, target))return *iter;
    last = *iter;
  }

  return nullptr;
}
more >>

更多内容 >>

LRU算法

LRU全称Least Recently Used，即最近最久未使用算法，表示如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。时间复杂度$O(1)$，空间复杂度$O(1)$。

一、代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <iostream>

using namespace std;

template<class K, class V, class H = hash<K>, int SIZE = 1024>
class LRUCache {
private:
    struct Node {
        K key;
        V value;
        Node *hash_prev;
        Node *hash_next;
        Node *list_prev;
        Node *list_next;

        Node() = default;
    };

public:
    LRUCache() : count(0), hash_map(), head(nullptr), tail(nullptr) {}

    ~LRUCache() {
        for (Node *p = head, *n = nullptr; p; n = p->list_next, delete (p), p = n);
    }

private:
    Node *find(const K &key) {
        size_t hash_key = hash(key) % SIZE;
        for (Node *p = hash_map[hash_key].hash_next; p; p = p->hash_next) {
            if (p->key == key) {
                return p;
            }
        }
        return nullptr;
    }

public:
    bool get(const K &key, V &value) {
        Node *target = find(key);
        if (target) {
            value = target->value;
            return true;
        }

        return false;
    }

    void put(const K &key, const V &value) {
        Node *target = find(key);

        if (target) {
            target->value = value;
            if (target->list_prev)target->list_prev->list_next = target->list_next;
            if (target->list_next)target->list_next->list_prev = target->list_prev;
            target->list_prev = nullptr;
            target->list_next = head;
            head->list_prev = target;
            head = target;
            return;
        }

        target = new Node();
        target->key = key;
        target->value = value;
        target->list_next = head;
        if (head)head->list_prev = target;
        head = target;
        if (tail == nullptr)tail = target;

        size_t hash_key = hash(key) % SIZE;
        if (hash_map[hash_key].hash_prev == nullptr) {
            hash_map[hash_key].hash_prev = target;
            hash_map[hash_key].hash_next = target;
        } else {
            target->hash_prev = hash_map[hash_key].hash_prev;
            hash_map[hash_key].hash_prev->hash_next = target;
            hash_map[hash_key].hash_prev = target;
        }

        if (count<SIZE) {
            count++;
            return;
        }

        Node *new_tail = tail;
        if (tail->hash_prev)tail->hash_prev->hash_next = tail->hash_next;
        if (tail->hash_next)tail->hash_next->hash_prev = tail->hash_prev;
        delete (tail);

        tail = new_tail;
        tail->list_next = nullptr;
    }

private:
    size_t count;
    Node hash_map[SIZE];
    Node *head;
    Node *tail;
    H hash;
};
more >>

更多内容 >>

在项目中集成IPython

为了查看/修改一个长时间运行系统的内部状态，可以集成IPython，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import time
import signal

from IPython.terminal.embed import InteractiveShellEmbed
from IPython.core.autocall import ExitAutocall


class ExitCommand(ExitAutocall):
    def __call__(self):
        if "running" in self._ip.user_ns:
            self._ip.user_ns['running'] = False
        self._ip.ask_exit()


class CustomShell(InteractiveShellEmbed):
    def init_user_ns(self):
        super().init_user_ns()
        self.user_ns["exit"] = ExitCommand()


running = True
pause = False


def handler(signum, frame):
    global pause
    pause = True


signal.signal(signal.SIGINT, handler)

a = 0
while running:
    a += 1
    print(f"{a}")

    if pause:
        CustomShell().mainloop()
        pause = False

    time.sleep(1)

更多内容 >>

使用Python访问MySql数据库

一、简介

通常，数据库是持久化的最佳方案，几乎每个稍微大一点的系统都会用到数据库，市面上存在各种各样的数据库系统，本文采用一种最常用的数据库系统——MySql。

访问数据库的方式大体上可以分为两种，一种是直接（或间接）基于数据库驱动的类SQL的方式，另外一种在数据库驱动之上更高抽象的ORM方式。
pymysql是采用Python语言编写的MySql数据库驱动，其优点是安装便捷（可以查看源码哦~），缺点是速度没有那么快，但也基本能满足日常需求（对于性能要求比较高的场景，可考虑mysqldb）。
sqlalchemy是高层次的ORM框架，支持多种数据库和多种数据库驱动。
sqlacodegen可以根据已有的数据库生成sqlalchemy的模型文件，避免手工同步数据库和模型。

本文简单介绍pymysql+sqlalchemy+sqlacodegen的联合使用。

more >>

更多内容 >>

使用Python编写RPCServer

周末抽空研究了一下vscode中的lsp，lsp是基于rpc协议的，于是就尝试做了一个简单的RPCServer。

RPCServer的使用与Flask类似，如下:

1
2
3
4
5
6
7
8
9
10
11
from rpc_server import RpcServer

app = RpcServer()


@app.method('initialize')
def initialize(params) -> str:
    return "Hello"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=7788)
more >>

更多内容 >>

使用Python绘制函数曲线

有个需求是寻找一个连续函数，来统计图片中的像素修改数量，使用该函数做为loss，能够迫使模型减少修改图像的像素，因此需要一个绘制函数曲线的方法。

目标函数应该在0处有极大的梯度，在x=0附近以极快的速度从0变为1，因此考虑对sigmoid的函数进行增强，如下图:

代码如下:

1
2
3
4
5
6
7
8
9
import numpy as np
import utils


def sigmoid_ext(x, beta=20):
    return 1 / (1 + np.exp(-beta * x))


utils.plot(sigmoid_ext, start=-1, end=1, pn=50, save_file="f.png")
more >>

更多内容 >>

使用C++编写Python扩展

C++的高效 + Python的简单 = 无与伦比的利器

总结一下使用C++编写Python扩展的方法和基本步骤，其中用到swig

通常需要4类文件，比如example.h、example.cpp、example.i、setup.py，可以任意选择你喜欢的IDE

一、example.h

头文件需要被C编译器识别，如下：

1
2
3
4
5
6
#ifndef PYTHON_EXAMPLE_H
#define PYTHON_EXAMPLE_H

int fact(int n);

#endif //PYTHON_EXAMPLE_H

二、example.cpp

1
2
3
4
5
6
7
#include "example.h"

int fact(int n) {
    if (n < 0) return 0;
    else if (n == 0) return 1;
    else return n * fact(n - 1);
}

三、example.i

swig脚本，用于生成胶水代码。注意，应当把头文件添加到生成的文件中，代码如下：

1
2
3
4
5
6
7
%module example

%{
#include "example.h"
%};

%include "example.h"

四、setup.py

用于生成python扩展的配置文件，代码如下：

1
2
3
4
5
from setuptools import setup, Extension

example_module = Extension('_example', sources=['example.cpp', 'example.i'], swig_opts=["-c++"])

setup(name="example", version="0.0.1", ext_modules=[example_module])

五、编译和测试

使用如下命令进行编译：

1
2
3
4
python setup.py build_ext --inplace     # 编译，构建扩展
python setup.py install                 # 安装到系统环境中
python setup.py devlop                  # 开发模式，不会安装到系统环境中
pip uninstall example                   # 卸载软件包

使用时，像使用普通模块一样即可:

1
2
import example
print(example.fact(10))     # 3628800

更多内容 >>

Python轻量级的bit数组

bit数组（位数组）是一个保存大规模对象（通常以万计）状态的有力工具，本文采用内置的bytearray来实现一个轻量级的bit数组，当然你也可以选择使用已发布的bitarray（使用pip进行安装即可），该组件采用c语言编写，功能齐全、性能良好，值得推荐。

既然已经有了类似的工具，为啥还要重复造轮子？

  1. 为了使项目尽可能少的依赖其他外部组件，使项目轻量化
  2. 外部组件通常是不可控的，不利于系统结构的优化调整
  3. 世上只有两种程序员，一种是造过轮子的，另一种是没造过轮子的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class bitarray():
    def __init__(self, length, buffer: bytearray = None):
        self.length = length
        self.buffer = buffer or bytearray((length + 7) // 8)

    def __getitem__(self, item):
        if item < 0 or item >= self.length:
            raise IndexError("index out of range")

        index = item // 8
        offset = item % 8

        byte = self.buffer[index]
        mask = 128 >> offset
        return byte & mask == mask

    def __setitem__(self, item, value):
        if item < 0 or item >= self.length:
            raise IndexError("index out of range")

        index = item // 8
        offset = item % 8

        byte = self.buffer[index]
        if value:
            byte = byte | (128 >> offset)
        else:
            byte = byte & ~(128 >> offset)
        self.buffer[index] = byte


if __name__ == '__main__':
    bs = bitarray(1024 * 10)
    print(bs[0])

    bs[0] = True
    print(bs[0])

    bs[0] = False
    print(bs[0])

更多内容 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

真正使人进步的,是不断总结。