Young Sideways's questions

最后的问题：是否可以用 python 更简洁地编写这个，而不失去容错能力，避免可怕的 bash 正则表达式？
首先，我想说我已经用 Python 编写了大约一周的时间（在此之前，只使用 C/C++）。
我需要ping从我的 python 脚本调用一个命令，不仅有关地址可用性的答案很重要，而且ping.需要注意的是，该脚本将在无法从 pip 传递包的机器上运行。

首先，我以一种相当简单的方式做到了 - 我为输出编写了一个解析器函数subprocess.run，它看起来像这样

SYSTEM_PING_ITERATIONS: int       = 1
SYSTEM_CMD_PING       : str       = "ping -4 -c{0} {1} | tail -n2"

def run_system_cmd(cmd: str) -> Tuple[List[str], int]:
    ret = subprocess.run(cmd,
                         shell=True,
                         executable='/bin/bash',
                         stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT
    )
    output = ret.stdout.decode('utf-8', errors='ignore')
    out_split: List[str] = output.split('\n')
    return (out_split[:-1] if out_split[-1] == '' else out_split, ret.returncode)


def process_ping(interations: int, address: Union[str, List[int]]) -> Dict[str, Union[int, float]]:
    address = address if isinstance(address, str) else '.'.join(map(str, address))

    from_cmd = run_system_cmd(str.format(SYSTEM_CMD_PING, interations, address))
    if from_cmd[1] != 0:
        return {}
    
    output = from_cmd[0]
    if not output or len(output) != 2:
        return {}
    
    suffixes: Dict[str, float] = {
        "ns": 1000000.0,
        "us": 1000.0,
        "ms": 1.0,
        "s" : 0.001
    }
    result: Dict[str, Union[int, float]] = {
        "transmitted": 0  ,
        "received"   : 0  ,
        "loss"       : 0.0,
        "total"      : 0.0,
        "min"        : 0.0,
        "max"        : 0.0,
        "avg"        : 0.0
    }

    data1 = output[0].split(' ')
    if len(data1) < 10:
        return {}
    result['transmitted'] = int(data1[0])
    result['received']    = int(data1[3])
    result['loss']        = float(re.sub('\\D', '', data1[5]))
    result['total']       = float(re.sub('\\D', '', data1[9])) * suffixes[re.sub(r'[^A-Za-z]', '', data1[9])]

    # do not parse further, if destination unreachable
    if result['loss'] == 100.0:
        return result
    
    data2 = output[1].split(' ')[-2:]
    splitted = data2[0].split('/')
    result['min'] = float(splitted[0]) * suffixes[data2[1]]
    result['max'] = float(splitted[2]) * suffixes[data2[1]]
    result['avg'] = float(splitted[1]) * suffixes[data2[1]]

    return result

对于如此简单的任务需要相当多的代码......

在对 python 缺乏足够了解的情况下，我想到的下一件事是更改 bash 命令：

ping -c{0} {1} | tail -n2 | awk -F'[ |,]' '/packets transmitted/ {transmitted=$1; received=$5; loss=$8; time=$13} /rtt min\/avg\/max/ {split($4, rtt, "/"); min=rtt[1]; avg=rtt[2]; max=rtt[3]} END {print transmitted, received, loss, time, min, avg, max, $5}'

对于可访问和不可访问的地址，其输出分别如下：

1 1 0% 0ms 36.477 36.477 36.477 ms

1 0 100% 0ms

这比原始版本更容易解析和检查。

所以现在的问题是：是否可以用 python 更简洁地编写这个，而不失去容错能力，避免可怕的 bash 正则表达式？

任务很简单。创建一个Point模拟空间点的类，存储适当数量的double变量。
最初，我考虑了使用 type 的多重继承的方法Point <- Point1D <- Point2D <- Point3D，但对我来说似乎很草率。
然后我想到了创建一个通用类Point，它将存储具有不同维度值的向量。但是，我也取消了这个选项，因为无法立即直观地确定这个点是多少维。
现在我正试图在变量模板上创建这个类。
我的代码：

template<size_t size>
class Point {
protected:
    double Data[size];
public:
    template<double... args>
    Point(args) {
        /* что нужно написать тут */
    }
};
typedef Point<1> Point1D;
typedef Point<2> Point2D;
typedef Point<3> Point3D;

从示例中可以看出，我尝试创建一个类，然后根据模板参数重新定义它。我只挑出了 1 个减号——无法控制传输参数的数量，但这对我来说并不重要。
构造函数调用应该看起来像这样。

Point2D MyPoint(1. , 2.);

现在是问题本身：如何正确描述这个类，以便它至少大致按预期工作。也许您可以告诉我如何在代码的结构或美观方面更正确地编写。ps我真的不想将选项与cstdargand一起使用:)std::initializer_list

/ ---------- UDP ---------- / 我
也试过这样描述：

template<size_t size, typename... args>
class Point {
protected:
    double Data[size];
public:
    Point(args ... Args) {
        // ????
    }
};
typedef Point<1, double> Point1D;
typedef Point<2, double, double> Point2D;
typedef Point<3, double, double, double> Point3D;

我编写用于排序数字的函数。我想尝试使它们与类型无关。为此，我传入了比较函数内部，这将在内部得到解决：
排序函数的原型：

void bubble_sort(void *array, int count, size_t size, int(*comparer)(void*, void*, size_t));

（我传递数组的大小就int好像，用负值，按降序排序）

比较功能分为3类：

1. 有符号整数
2. 无符号整数
3. 分数

比较特点：

inline int icompare(void* a, void* b, size_t size) {
    assert(size <= sizeof(int64_t));
    int64_t _a, _b;
    memcpy(&_a, a, size);
    memcpy(&_b, b, size);
    return _a < _b ? -1 : (_a > _b ? 1 : 0);
}
inline int ucompare(void* a, void* b, size_t size) {
    assert(size <= sizeof(uint64_t));
    uint64_t _a, _b;
    memcpy(&_a, a, size);
    memcpy(&_b, b, size);
    return _a < _b ? -1 : (_a > _b ? 1 : 0);
}
inline static int lfcompare(long double a, long double b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}
inline int fcompare(void* a, void* b, size_t size) {
    assert(size <= sizeof(long double));
    if (size == sizeof(float))
        return lfcompare((long double)*(float*)a, (long double)*(float*)b);
    if (size == sizeof(double))
        return lfcompare((long double)*(double*)a, (long double)*(double*)b);
    if (size == sizeof(long double))
        return lfcompare(*(long double*)a, *(long double*)b);
    return 0;
}

如果无符号整数和小数整数工作正常，则有符号整数不能正常工作。由于错误地复制了数字的符号和结构，感觉一切都在飞翔。帮助我找到解决方案或建议 f-th 比较的替代拼写。谢谢你。

有许多字符串，由不同数量的子字符串组成。
所有子字符串都用空格分隔。
第一个子字符串总是以 '>' 开头，之后可能还有几个字符。
除了最后一个，其余的都放在方括号中，里面有必要的数据，格式为“[key=value]”，value可以包含空格。这些子串可以交换。最后一个子字符串是一组不间断的大写拉丁字符。

需要从这个集合中选择几个必要的子串，放到一个类对象中

行示例：

>dfg|sf_sdfg0.1 [gene=aziz] [musor1=otyuj] [musor2=fsdgk] [protein=73545] KHGDBSS
>vgv|kjs_u9.5_W [protein=pivo vkusno] [musor3=dsfg] [gene=mama] LJDFSGJKHKGJGKB

您需要拔出 keygene=和protein=最后一行
. 输出应该是一个字符串数组：

{"aziz", "73545", "KHGDBSS"}
{"mama", "pivo vkusno", "LJDFSGJKHKGJGKB"}

如果字符串没有 key gene=，则必须跳过它。

PS 现在有一个工作变体，在检查行的出现和提取索引的堆上。它工作缓慢，恐怕要加快它需要“正则表达式”，我还不是朋友，或者其他一些我什至不知道的尖锐技巧。

UDP忘记补充了，属性行总是从新行开始，写在一行中，大写拉丁文的最后部分总是从下一行开始，分成70个字符的块。

>idf|sdf [attr1=x] [attr2=y] [attr3=z]
DFG..DFF // 70 символов
DRF..RGE // 70 символов
WEL..TRT // 70 символов
RRG // Остаток переноса