MaxU - stop genocide of UA's questions

背景：我们有一个应用程序（用 Python 编写），它从各种来源接收数据，对其进行处理，并将结果存储在结果表中。结果表每次都会被覆盖，因为 结果是根据复杂算法组合来自不同来源的数据。有一个业务需求是能够比较不同日期的结果，因此我们现在将每天的结果存储在历史表中，并带有一个额外的字段tag来标识应用程序的每次运行。

例子：

数据：

 id   company_name   vat_id               url
123  Funny Company   123456 funny-company.com

数据历史：

       tag    id   company_name   vat_id               url
2021-05-23   123  Funny Company   123456 funny-company.com

每次运行的结果变化不大 - 大约 3-5% 的行被更改或添加，因此历史表中有 95% 是重复数据。

问题：请建议一个合适的数据模型，它只允许存储执行的最后一个结果，并且有“增量”表，可以让您轻松有效地
为应用程序的任何一天重新创建结果，并且不会占用太多空间？

UPD：在与受人尊敬的评论中交谈之后0xdb，asanisimov现在我倾向于选择以以下格式保存每天的增量：

在右侧，特定日期的恢复数据。现在我试图从左侧显示的数据中了解如何有效地实现这一点？

链接到 Excel 文件

继续这个问题。

在工作中，我必须使用各种数据源，并且经常遇到质量较差的数据（手动输入系统）并且存储在不符合 3NF（3x 范式）规则的表中。那些。通常多个实体存储在一个单元格中。

例如：

email
-------------------------------------
mail1@mail.com, mail2@domain.com mail3@gmail.com

或者

phone
----------------------------------------------------
0172-1234/567, +49123456789 and 089 / 123-4567

我的团队面临的任务是在不更改数据模型的情况下对这些数据进行梳理和规范化，并以以下形式获取相同的数据：

email
-------------------------------------
mail1@mail.com; mail2@domain.com; mail3@gmail.com

和

phone
----------------------------------------------------
01721234567; 0049123456789; 0891234567

标准化个人电子邮件、电话等的功能。已经实现和测试要对此类数据进行规范化，首先需要以垂直形式（即 done UNPIVOT）解析和获取这些类似 CSV 的字符串，然后应用规范化函数，最后将已经规范化的值打包回 CSV 字符串相同的分隔符 ( '; ')。

在这个答案中，受人尊敬的0xdb展示了如何有效地解析此类数据并生成UNPIVOT. 根据答案中的函数，我编写了以下通用函数，它应该能够使用各种规范化函数对电话号码、WEB 地址和电子邮件进行规范化。

结果就是这个怪物：

create or replace function normalize_csv_values (
    str             varchar2,
    typ             varchar2    := 'phone',
    target_sep      char        := '; '
) return varchar2
as
    pattern     varchar2(64) := '([^[:space:]].*?)((\s*[,;]\s*)|($))';
    tokens      varchartab := varchartab ();
    s           varchar2(96);
    c           int := 0;
    l_res       varchar2(1024);
begin
    case
        when lower(trim(typ)) in ('phone', 'fax')
            then pattern := '([^[:space:]].*?)((' || '\s*(,|;|oder|o\.|or|und|and)\s*' || ')|($))';
        when lower(trim(typ)) in ('url', 'web', 'link')
            then pattern := '([^[:space:]].*?)((' || '[,;]' || ')|($))';
        when lower(trim(typ)) in ('email')
            then pattern := '([^[:space:]].*?)((' || '[[:space:],;/]' || ')|($))';
    end case;
    <<split>> loop c := c + 1;
        s := regexp_substr (str, pattern, 1, c, null, 1);
        exit split when s is null;
        if lower(typ) in ('phone', 'fax') then
            s := normalize_phone(s, 6, 17, '\s*\W?(,|;|oder|o.|und|or)\W?\s*');
        elsif lower(typ) in ('url', 'web', 'link') then
            s := normalize_url(s, '^(w{3,4}\.)');
        elsif lower(typ) in ('email') then
            s := normalize_email(s, '[:space:],;/');
        end if;
        tokens.extend;
        tokens(tokens.last) := s;
    end loop;
    -- pack parsed CSV values back to CSV form, using specified [target_sep]
    select listagg(column_value, target_sep) within group (order by rownum)
    into l_res
    from table(tokens);
    return l_res;
end;
/

问题：

SRP (Single Responsibility Principle)你能告诉我如何以原则和的方式分解这个函数DRY (Don't Repeat Yourself)吗？

也许您可以以某种方式编写通用 RegEx 并制作一个包装函数来调用必要的规范化函数？

如何扩展以下正则表达式（在 POSIX 标准中）以使值,, ;, /, , 即 逗号、分号、斜杠、空格和制表符的组合。

初始数据示例：

ID  EMAIL
--  --------------------------------------------------
1   NULL
2   mail1@domain.com
3   mail1@domain.com; mail2@domain.com, mail3@mail.com
4   mail1@domain.com, mail2@domain.com
5   mail1@domain.com mail2@domain.com

在 这封DB Fiddle邮件中，我尝试从每一行中提取第二封电子邮件，并希望得到以下结果（输出数据集）：

ID  EMAIL
--  --------------------------------------------------
1   NULL
2   NULL
3   mail2@domain.com
4   mail2@domain.com
5   mail2@domain.com

那些。结果不应该包含分隔符：,, ;, /， 我尝试添加一个 POSIX 值[:space:]来处理空格和制表符，但结果是错误的：

select
  id,
  regexp_substr (email, '(.*?)(([[:space:],;/])|($))', 1, 2, null, 1) as second_email
from tab;

ID  EMAIL
--  --------------------------------------------------
1   NULL
2   NULL
3   NULL
4   NULL
5   mail2@domain.com

请告诉我如何修复 POSIX RegEx。

注意：我正在使用 Oracle 12.2，它不理解 RegEx 字符\s，所以我只需要使用 POSIX 标准支持的正则表达式。

PS 在这个例子中，我总是从字符串中提取第二个值——这是一个简化的（最小可重现的）例子。事实上，这是函数的一部分，它应该能够提取任何第 N 个值（N它将作为参数传递给函数）。

我有一个名为 like 的列'Max Mustermann'，我需要解析first_name和last_name. 问题是，有时会出现一个企业名称，而不是一个名称，而是几个人的名称或由 4-5 个单词组成的名称。正常名称必须至少包含 2 个字母。NULL在这种情况下，我想得到first_nameand last_name。告诉我，如何使用 SQL 或 PL / SQL（DB：Oracle 12.2）来完成？

输入示例：

NAME
Max Mustermann
Doe, John
Ursula von der Leyen
Рога и Копыта
J Li

结果，我想得到以下信息：

FIRST_NAME      LAST_NAME
Max             Mustermann
John            Doe
NULL            NULL
NULL            NULL
NULL            Li

自己尝试解决方案：

select 
  regexp_replace(name, '^([[:alpha:]]{2,})[[:space:]]+([[:alpha:]]{2,})$', '\1') as first_name,
  regexp_replace(name, '^([[:alpha:]]{2,})[[:space:]]+([[:alpha:]]{2,})$', '\2') as last_name
from table_name

自己尝试的解决方案通常适用于由两个单词组成的名称。如果有更多的单词，那么整个原始值都落入first_name和 into 。last_name

回答这个问题时，我想到了如何使用非向量化函数加速处理以 Pandas Series / DataFrame 形式呈现的数据，而且我们无法更改。

在这个问题中，数据处理包括使用natasha.

创建我们要加速的函数的代码是：

from natasha import MorphVocab, AddrExtractor

morph_vocab = MorphVocab()
addr_extractor = AddrExtractor(morph_vocab)

PART_TYPES = [
    "индекс", "город", 
    "улица", "проспект", "шоссе", "переулок", "проезд",
    "дом", "корпус"
]

def parse_addr(
        addr_str, 
        addr_extractor=addr_extractor, 
        min_addr_len=10
):
    if not addr_str or len(str(addr_str)) < min_addr_len:
        return None
    ext = addr_extractor.find(addr_str)
    if not ext:
        return None
    return {part.type: part.value for part in ext.fact.parts}

def combine_addr_str(parsed_addr, part_types=PART_TYPES):
    if not parsed_addr:
        return None
    return " ".join(
        parsed_addr[part_type]
        for part_type in part_types
        if parsed_addr.get(part_type)
    )

def get_addr_str(addr_str):
    return combine_addr_str(parse_addr(addr_str))

该任务的目的不是为了并行化而并行化，而是加速调用一个接受并返回标量值的函数到pandas.Series/ pandas.DataFrame。

链接到示例数据- Excel 文件包含从该问题的示例数据中获取的 200 个随机地址

要将数据读入 Pandas DataFrame：

import pandas as pd

filename = "/tmp/sample.xlsx" # NOTE:у кажите правильный путь к файлу!
df = pd.read_excel(filename)

建议您的解决方案！

请告诉我如何更改以下代码：

with temp as
(
    select 108 Name, 'test' Project, 'string-1 , string-2 ; string-3' Error  from dual
    union all
    select 109, 'test2', 'single string' from dual
)
select distinct
  t.name, t.project,
  trim(regexp_substr(t.error, '[^,;]+', 1, levels.column_value))  as error
from 
  temp t,
  table(cast(multiset(select level from dual connect by  level <= length (regexp_replace(t.error, '[^,;]+'))  + 1) as sys.OdciNumberList)) levels
order by name;

进入一个通用函数，该函数接受一个字符串作为参数（例如：）'string--1, string-2 ; string-3 , string-4'和一个指定搜索行分隔符的正则表达式（例如：）'\s*[,;]\s*'：

FUNCTION csvstr2tab(
    p_str      IN VARCHAR2,
    p_sep_re   IN VARCHAR2   DEFAULT '\s*[,;]\s*'
)
...

作为我自己的尝试，这是一个使用固定行分隔符 ( ',') 完成给定任务的函数：

create or replace type admin.strtable as table of varchar2(1000);
/

create or replace
function admin.str2tbl ( p_str in varchar2 ) return strtable
as
  l_str long default p_str || ',';
  l_n number;
    l_data strtable := strtable();
begin
  loop
    l_n := instr( l_str, ',' );
    exit when (nvl(l_n,0) = 0);
    l_data.extend;
    l_data( l_data.count ) := ltrim(rtrim(substr(l_str,1,l_n-1)));
    l_str := substr( l_str, l_n+1 );
  end loop;
  return l_data;
end;
/

P.S. sql<>小提琴

更新：我使用缩写 CSV 只是为了表明我正在处理包含分隔符分隔的子字符串的字符串。事实上，输入字符串根本不一定是“有效”的 CSV。

需要自动将 CSV 转换为 Excel，以便自动设置适当的列宽，自动设置列“自动过滤器”，并自动冻结带有列名称的顶行等。

使用将 CSV 文件转换为 Excel 格式的 Pandas 模块的解决方案：

import pandas as pd

pd.read_csv("filename.csv").to_excel("filename.xlsx", index=False)

问题：但是自动“自动过滤器”、适应数据宽度或列名宽度的列宽以及冻结列名的行呢？

除了众所周知的之外，找到所有小于 N 的素数的最快算法是什么：

• 埃拉托色尼筛
• 阿特金筛
• 筛子孙达拉玛

什么是一些快速的 Python 实现（Vanilla、Numpy 等）？

Eratosthenes 筛子的幼稚实现：

def eratosthenes2(n):
    multiples = set()
    for i in range(2, n+1):
        if i not in multiples:
            yield i
            multiples.update(range(i*i, n+1, i))

SO英文版中的类似问题

PS 创建这个问题的想法与不断涌现的新问题有关，即如何有效地实现查找所有小于 N 的素数。

官方文档显示了在通过文件名掩码复制树时如何过滤文件：

from shutil import copytree, ignore_patterns
    
copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))

如何通过其他属性过滤文件，例如创建/修改日期、大小等？

在回答这个问题时，我尝试实现一个递归函数，以使用 Maclaurin 级数计算余弦，达到指定的精度 (epsilon)。

公式：

我只是不知道如何实施精度检查来完成/退出递归。

这是没有精度检查的功能草图：

import math

def cosine_rec(x, i=0, err=10**9, eps=1e-5):
    if i < 1:
        return 1
    # как проверить текущую ошибку ???
    res = (-1)**i * (x**(2*i) / math.factorial(2*i))
    return res + cosine_rec(x, i+1, err=err, eps=eps)

PS 使用迭代算法，一切都很简单，所以请不要提供非递归的解决方案。

在这个问题中，有一些代码可以简化形式写成这样：

>>> '1' in '111' == True
False

为什么会这样？毕竟，根据“运算符优先级”表，和in和==具有相同的优先级，必须从左到右执行。

那些。假设这种构造是等价的是合乎逻辑的：

>>> ('1' in '111') == True
True

在对自然文本进行分类时，出现了一个问题，即如何在有和没有文本规范化的情况下直观地显示文本的频率特征。

首先想到的是条形图，但不可能超过 20-30 个单词——一切都太小而且难以理解。

通过规范化，我的意思是将词带入它们的正常（规范）形式。

我尝试以答案的形式找到解决方案，但看看其他解决方案和想法会很有趣。

在回答这个问题时，我想比较不同分类器对评论/推文的情感（色调）评估的有效性。

我不确定这个问题是否完全符合 StackOverflow 规则，但我相信它对对自然文本分类问题感兴趣的人很有用。

PS我尝试以答案的形式解决问题。

回答这个问题，我开始对更通用的解决方案感兴趣......

有一个任意嵌套的列表，例如：

['1','2', ['1',['2','4',['5','6']]],'7','8']

有必要将该函数应用于列表的所有元素（包括所有嵌套元素），同时保持其结构。

例如，将所有元素转化为数字，然后平方得到：

[1, 4, [1, [4, 16, [25, 36]]], 49, 64]

我发布了自己的解决方案，但我有兴趣查看替代（更有趣）的解决方案。