小编Fel*_*lix的帖子

我正在构建一个包含要运行的脚本的包。它们导入脚本正下方的子文件夹中包含的模块。既然__init__Python 3.3 之后就不需要了，那么正确的文件结构和import语句是什么？我不想指定从最顶层文件夹向下的导入，仅作为相对路径，在这里sub/module。

这是文件结构的当前状态：

Root\
    src\
        sub\
            module.py
        script.py
        parent_module.py
    setup.py

# Inside script.py
import sub.module      # Doesn't work
from sub import module # Doesn't work
import src.sub.module  # Does work!

import .sub.module     # Doesn't work
import .parent_module  # Does work!

我想我需要一些 __init__文件，但是那是什么文件，在哪里呢？非常感谢任何帮助，我对包装不太了解。

另外，我当然愿意接受改变结构的建议，如果这能让事情变得更容易的话。

给定许多ID，每个ID都可能连接到同一表中的其他条目，我想找到它们的顶级父级。即，其父ID为的那些行NULL。因此，每个红色单元下方将在层次结构中连接到相应的绿色单元。

从这个答案中借出一个非常类似的问题，这是一个玩具模式。

DECLARE @t TABLE (ID INT, link INT)

INSERT INTO @t VALUES
(1, NULL),
(2, 1),
(3, 2),
(4, 3),
(5, 3),
(6, 2),
(7, 1),

(8, NULL),
(9, 8),
(10, 9),
(11, 9),
(12, 9),
(13, 12),
(14, 12),
(15, 8);

我将有一组ID（例如6和13），并带有两个底层节点。然后，我想要一个结果集，例如（6，1）和（13，8）。为了始终构建每个链接，答案提出了一个通用的表表达式。

WITH cte AS (
    SELECT ID, link
    FROM @t
    WHERE ID IN (6, 13)

    UNION ALL

    SELECT t.ID, t.link
    FROM @t t
    JOIN cte c ON t.ID = c.link
    WHERE t.link IS …

所以我被分配来评估两个查询的性能并得出了令人惊讶的结果.我之前被告知HAVING比较慢,WHERE因为它只在访问行后过滤结果.这似乎是合理的,这个关于SQL子句执行顺序的问题强调了这一点.

但是,我估计以下查询的性能有一些假设,似乎使用HAVING执行实际上更快!

SELECT status, count(status)
FROM customer
GROUP BY status
HAVING status != 'Active' AND status != 'Dormant'

SELECT status, count(status)
FROM customer
WHERE status != 'Active' AND status != 'Dormant'
GROUP BY status

假设是:

• 该表CUSTOMER有100 000条记录
• 访问行的成本是0.01ms(SELECT + COUNT)
• 执行条款的成本是0.005毫秒
• 有三种类型的客户状态,上面两个和'已故'
• 有15000名"死者"客户

基于此,我的估计是:

First query:
    Accessing all rows, FROM: 100 000 * 0.01ms = 1000ms
    GROUP BY: 100 000 * 0.005ms = 500ms
    HAVING (2 conditions, 3 groups): 2 …

我想将数据类序列化为字符串。dataclasses.asdict创建自定义方法就足够简单了__str__。即使对于具有其他数据类或其列表作为成员的类，它也能完美运行。但是，调用str数据类列表会生成repr版本。我想str生成序列化表格并repr保持原样。

import json
from dataclasses import dataclass, asdict


@dataclass
class Ser:
    def __repr__(self):
        print('repr called')
        return json.dumps(asdict(self))

    def __str__(self):
        print('str called')
        return json.dumps(asdict(self))


@dataclass(repr=False)
class C(Ser):
    i: int

    def __str__(self):
        print('child str called')
        return super().__str__()


list_in = json.loads('[{"i": 1}, {"i": 2}]')
data = [C(**i) for i in list_in]
print(data)
print(repr(data))
print(str(data))

上面脚本的输出是：

repr called
repr called
[{"i": 1}, {"i": 2}]
repr called
repr called
[{"i": 1}, {"i": 2}] …

最近,在R2016b中,一个功能被添加到MATLAB中,这在我教的学校引起了很多麻烦.

如今,传统上被视为非法或至少是阴暗数学的公式成功执行:

[1, 2] + [3, 4]'    -> [4, 5; 5, 6]
[1, 2]' + [3, 4, 5] -> [4, 5, 6; 5, 6, 7]

因此,将行向量添加到列向量被视为两个矩阵的相加,从重复向量到"合适"维度可以得到两个矩阵.在旧版本中,这将产生错误消息,通知不可能添加具有不同尺寸的矩阵.

我想问为什么有点宽泛,虽然如果你知道为什么,我很想知道.相反,我会问,有没有办法禁用此功能？对于新手程序员来说,当传统的数学似乎没有排成一行时,这是一个受到伤害的世界,结果矩阵经常被忽视,导致错误只会在以后发生.

我不认为这是MATLAB语法和行为的有用部分,因为它需要太多的解释,阅读程序员的意图.repmat是有原因的,可以引入一个专门的功能来满足这个东西的需要.

基于整数 ID，如何限制引用公共表的两个表不包含另一个表中已经存在的相同元素？

假设创建了个人信息的基本表：

CREATE TABLE person (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    info VARCHAR(10)
);

然后person创建两个表引用：

CREATE TABLE special (
    id INTEGER PRIMARY KEY,
    skill VARCHAR(10),
    FOREIGN KEY (id) REFERENCES person(id)
);

CREATE TABLE snowflake (
    id INTEGER PRIMARY KEY,
    meltingpoint DECIMAL,
    FOREIGN KEY (id) REFERENCES person(id)
);

但是，我想限制两个表包含同一个人。

所以我认为这样的事情可以解决问题，但是 SQLite3 给出了语法错误（在 CHECK 附近）。

ALTER TABLE special ADD CHECK (
    (SELECT COUNT(*) FROM snowflake WHERE snowflake.id = special.id) = 0
);

或基于此答案

ALTER TABLE special ADD CHECK …

PyCharm 执行脚本的方式与普通命令行执行的方式略有不同，这确实让我感到烦恼（哈哈） 。对于像我这样的新手来说，它使得项目和包配置变得困难。

问题：每次运行脚本时，无论是正常运行还是在 Python 控制台（运行 > 编辑配置）中，脚本文件夹和项目根目录都会自动附加到sys.path. 我希望其中之一，但不会两者兼而有之。

那么，有没有办法禁用或以其他方式配置此附加？我想在不操作每个可执行脚本开头的路径的情况下执行此操作，但如果有办法使用启动脚本或某种运行脚本，那就没问题了。