小编pst*_*tix的帖子

假设在类构造函数上列出初始化空向量的适当方法（如果有）是哪种？：

class Temp {
    private:
        int vals;
        vector<int> A;
    public:
        Temp(int x);
};

所有这些似乎都有效，但是是否有必要执行 #1 或 #2，或者声明就足够了？：

1：显式调用向量构造函数

Temp::Temp(int x):vals(x), A() { }

2：在类 ctor 列表初始化中使用向量列表初始化

Temp::Temp(int x):vals(x), A{} { }

3：从类构造函数列表初始化中排除（仅声明）

Temp::Temp(int x):vals(x) { }

将向量成员包含在类构造函数初始化列表中似乎没有任何价值，因为当我们声明它并返回空向量时会调用它的默认构造函数。

我有一个非常简单的应用程序（只是一个带有标签的窗口），我正在尝试引导自己完成变成单个可执行文件的过程。这是程序目录：

brainfreeze/
   main.py # simple app
   main.kv # kv language style sheet
   config/
      settings.json # json settings panel data (F1 bound)
saving_to/
   (empty at start)

我已经成功地使用 PyInstaller 将程序编译为可执行文件，但只使用了他们文档中描述的一个文件夹捆绑方法；我希望改用一个文件包方法。到目前为止，当我编译时，应用程序启动但它是黑屏（传统上我在main.kv无法加载时看到过这种情况）。我已经阅读了this、this、this甚至 PyInstaller文档，但没有成功编译为单个可执行文件。这是 prog_test.spec：

# -*- mode: python -*-

from kivy.deps import sdl2
from kivy.deps import glew

block_cipher = None

a = Analysis(['..\\brainfreeze\\main.py'],
             pathex=['H:\\TestBed\\single_exe_test'],
             binaries=[],
             data=[],
             hiddenimports=[],
             hookspath=[],
             runtime_hooks=[],
             excludes=[],
             win_no_prefer_redirects=False,
             win_private_assemblies=False,
             cipher=block_cipher)

pyz = PYZ(a.pure, a.zipped_data,
             cipher=block_cipher)

a.datas += [('../brainfreeze/main.kv', 'DATA'), …

根据文档：

要指定同类类型的变长元组，请使用文字省略号，例如 Tuple[int, ...]。普通元组相当于 Tuple[Any, ...]，进而相当于元组。

因此，注释Tuple[int]指定一个包含单个整数的元组；但List[int]意味着可变长度。

如果两者都可以是同源/异质的，为什么必须...使用 withTuple[int, ...]而不能使用 with ？List[int]

默认情况下，pandas.read_csv()会破坏 X、X.1、...、XN 形式的重复 CSV 标头

标志mangle_dupe_cols = False返回：

ValueError: Setting mangle_dupe_cols=False is not supported yet

在我看来，这似乎很愚蠢，为什么你会允许布尔标志但禁用布尔性......

有没有一种方法可以通过 pandas API 最适合通过该read_csv()方法在 DataFrame 初始化时检测/删除重复标头？

可能的解决方案（非 API）：

headers = set(df.columns) # will include 'X' and 'X.1'
n = 0
unique = []
for i in range(len(headers)):
    d = 1
    if i != n:
        continue # skip dupes
    elif (headers[i] + '.' + str(d)) in headers:
        while True: # find next unique element
            d += 1
            n …

致力于ThreadPoolExecutors使用asyncio和替换所有异步调用所使用的服务器查询工具的实现aiohttp。由于网络调用是非阻塞IO，因此大多数过渡都是直接的，保存响应使我感到困惑。

我正在使用的所有示例，甚至是两个库的文档，都使用该示例asyncio.gather()来收集所有等待的结果。就我而言，这些结果可以是许多GB范围内的文件，我不想将它们存储在内存中。

什么是解决此问题的合适方法？是否可以使用asyncio.as_completed()然后：

for f in as_completed(aws):
    earliest_result = await f
    # Assumes `loop` defined under `if __name__` block outside coroutine
    loop = get_event_loop()
    # Run the blocking IO in an exectuor and write to file
    _ = await loop.run_in_executor(None, save_result, earliest_result)

这不是引入线程（假设ThreadPoolExecutor默认情况下使用a ），从而使它成为异步多线程程序，而不是异步单线程程序吗？

此外，这是否可以确保earliest_result在任何时候仅将1 写入文件？我不想await loop.run_in_executor(...)运行该调用，然后出现另一个结果，我尝试运行到同一文件；我想可以限制一个信号量。

有没有办法“扩展”数组并重复最后一个元素来填充扩展？

另一篇文章讨论了扩展和填充，0但我希望重复最后一个值作为填充。

假设我有一个数组：

[[1, 2],
 [3, 4],
 [0, 0]]

我需要插入[5, 6, 6]来替换[0, 0]，显然 NumPy 不允许这样做。但我可以重塑/扩展为：

[[1, 2, 2],
 [3, 4, 4],
 [5, 6, 6]]

我正在读取一个文件，其中值的数量长度可能有所不同，但我需要数组具有相同的形状。执行此操作的一种方法是首先读取文件并找到最大长度，然后再次读取并填充，但该文件有 10GB 以上，因此我更愿意通过“扩展”并重复回填来一次性完成此操作。

我有一个包的以下结构：

/prog
-- /ui
---- /menus
------ __init__.py
------ main_menu.py
------ file_menu.py
-- __init__.py
__init__.py
prog.py

这些是我的导入/类语句：

prog.py：

from prog.ui.menus import MainMenu

/prog/ui/menus/__init__.py：

from prog.ui.menus.file_menu import FileMenu
from prog.ui.menus.main_menu import MainMenu

main_menu.py：

import tkinter as tk
from prog.ui.menus import FileMenu

class MainMenu(tk.Menu):
    
    def __init__(self, master: tk.Tk, **kwargs):
        super().__init__(master, **kwargs)
        self.add_cascade(label='File', menu=FileMenu(self, tearoff=False))

    [...]

file_menu.py：

import tkinter as tk
from prog.ui.menus import MainMenu

class FileMenu(tk.Menu):

    def __init__(self, master: MainMenu, **kwargs):
        super().__init__(master, **kwargs)
        self.add_command(label='Settings')

    [...]

这将导致序列中的循环导入问题：

prog.py-> …

源于这篇文章，但我发现解决方案有一个小问题。

使用df = df.replace({True: 'TRUE', False: 'FALSE'}), 如果一个值是1或0它将被替换。我只想替换实际True或False的值<class 'bool'>。

我怎样才能做到这一点？

我有一个接受输入并返回3项元组的函数:

def f(a, b):
    x = a + 1
    y = x + 2
    z = y + 3
    return (x, y, z)

我从一组元组开始:

my_set = {(1, 2), (3, 4), ... (m, n)}

我需要构建一个列表,但是后面会抛出一个TypeError:

[(a, b, x, y, z, (x, y, z)) for a, b in my_set for x, y, z in f(a, b)]
TypeError: 'int' object is not iterable

我正在审查这篇文章,它显示了一个类似的过程,但由于某种原因,for x, y, z ...它抛出异常并且我不确定我是否只是忽略了一些小的东西.

除了以下方法之外，还有其他方法可以输入相同类型的提示参数：

def foobar(a: int, b: int, c: int, d: str): ...

也许是这样的：

def foobar([a, b, c]: int, d: str): ...

显然是概念性的，但可以减少重复的类型提示