小编c z*_*c z的帖子

我正在寻找一种模仿终端进行一些自动化测试的方法：即启动一个进程，然后通过将数据发送到标准输入并从标准输出读取来与其交互。例如，将一些输入行发送到标准输入，包括ctrl-c和 ，ctrl-\这将导致向进程发送信号。

使用std::process::Commannd我能够将输入发送到eg cat，并且我还在stdout上看到它的输出，但是发送ctrl-c（据我所知3）不会导致SIGINT发送到shell。例如这个程序应该终止：

use std::process::{Command, Stdio};
use std::io::Write;

fn main() {
    let mut child = Command::new("sh")
        .arg("-c").arg("-i").arg("cat")
        .stdin(Stdio::piped())
        .spawn().unwrap();
    let mut stdin = child.stdin.take().unwrap();
    stdin.write(&[3]).expect("cannot send ctrl-c");
    child.wait();
}

我怀疑问题是发送ctrl-c需要一些 tty 并且通过sh -i它仅处于“交互模式”。

我是否需要成熟并使用例如termion或ncurses？

更新：我在原来的问题中混淆了 shell 和终端。我现在把这事弄清楚了。我还提到了ssh应该是的sh。

我可以引发from另一个异常以提供附加信息，例如：

try:
    age = int(x)
except Exception as ex:
    raise ValueError("{} is not a valid age.".format(x)) from ex

有没有办法从多个异常中获取来源？例如

try:
    age = int(x)
except Exception as ex1:
    try:
        age = date_now().year - parse_date(x).year
    except Exception as ex2:
        raise ValueError("{} is not a valid age or date.".format(x)) from ex1 + ex2

可以直接在类型上调用A classmethod，无论是内联定义还是in的一部分metaclass：

class eggs( type ):
    def f1( cls ):
        print( "eggs" )


class spam( metaclass = eggs ):
    @classmethod
    def f2( cls ):
        print( "spam" )


f = spam()
type(f).f2() #--> spam
type(f).f1() #--> eggs

但是，似乎classmethod无法在实例上调用元类中的定义：

f.f2() #--> spam
f.f1() #--> AttributeError

为什么是这样？

当不可能使用 MyPy 注释这样的变量时，为什么 Mypy 抱怨它需要对列表理解变量进行类型注释？

具体来说，我该如何解决以下错误：

from enum import EnumMeta

def spam( y: EnumMeta ):
    return [[x.value] for x in y]  Mypy: Need type annotation for 'x' 

cast不起作用：

return [[cast(Enum, x).value] for x in y]  Mypy: Need type annotation for 'x'  

即使Mypy不支持注释（x:Enum）在这种情况下，我看到了使用的变量可以使用注释的cast（看到这个帖子）。但是，这cast(Enum, x) 并不能阻止 Mypy 抱怨变量没有首先被注释。

#type:不起作用：

return [[x.value] for x in y] # type: Enum  Mypy: Misplaced type annotation

我还看到for可以使用注释对循环变量进行注释，# type:（参见这篇文章 …

根据这个问题，并假设我对容器本身有一个可变引用，则可以使用以下方法安全地删除迭代器的常量性：

foo::const_iterator cit = ... ;
foo::iterator it = c.erase( cit, cit );

但是，根据此代码，这似乎不适用于forward_list的等效项erase_after::

#include <iostream>
#include <forward_list>

typedef std::forward_list<int>::const_iterator CIT;
typedef std::forward_list<int>::iterator IT;

int main()
{
    std::forward_list<int> m{1, 2, 3};

    CIT cit = m.begin();
    IT it = m.erase_after(cit, cit); // Segmentation fault!

    std::cout << *it;
}

那么有没有办法删除这个类的const迭代器的constness？最好不是通过迭代！

在现代C++ 中，我应该如何管理无主指针？我在想像weak_ptrfor 之类的东西unique_ptr，但这似乎不存在。

例子

例如，如果我有一个A拥有指针的类，我应该使用unique_ptr<X>而不是旧X*指针，例如

class A
{
    std::unique_ptr<X> _myX;
};

但是如果我有另一个B使用这个指针的类，我在这里做什么？使用 C 风格的指针，我会这样做：

class B
{
    X* _someX;
};

这似乎是正确的，但从代码中看不出我引用了另一个对象的指针（例如，读者可能认为我可能没有使用智能指针）。

我考虑了以下几点

• std::shared_ptr<X>- 似乎是浪费引用计数，因为A它保证比B.
• std::weak_ptr<X> - 仅适用于 shared_ptr
• X& - 仅当 X& 在 B 的构造函数中可用时才有效

这似乎是一个明显的问题，如果之前有人问过，很抱歉。我环顾四周，看到了这个问题，但不幸的是，在一个特定情况下，OP 询问“是否可以使用 X*”。我正在寻找我通常应该做的事情而不是X*，（如果有的话！）。

当我#include <windows.h>在C或C++中时,我被迫决定字符的格式,其中TCHAR等于char或wchar_t.

我环顾四周相当多的并尽可能的职位如这一个或类似网站这点破wchar_t事儿来了约一个很久以前UTF8之前,对各种原因,并不是一个特别好的解决方案的Unicode现代编程.然而,这些并没有说明已经运行的现有系统的支持wchar_t.

所以我的问题是,我应该使用哪一个？如果我使用普通的char遗嘱将来会被MS抛弃,因为在一天结束时,wchar_tAPI 的版本是最近的？或者,如果我使用wchar_t,将我的代码运行在其他现代平台上是否会很痛苦,这些平台后来使用charUTF8中的普通版本开发？

我想在某些动态创建的对象上提供文档(在我的程序中),但仍然可以使用他们的类文档.设置__doc__似乎是一种合适的方法.但是,我在这方面的Python帮助中找不到很多细节,在实例上提供文档是否有任何技术问题？例如:

class MyClass:
    """
    A description of the class goes here.
    """

a = MyClass()
a.__doc__ = "A description of the object"

print( MyClass.__doc__ )
print( a.__doc__ )

我目前使用系统范围的互斥锁来处理我的 Flask 应用程序中的多处理。

由于 GIL，以及最终多处理已经为我提供并发性这一事实，我不想也不必担心我的应用程序中的多线程。

我可以让 Flask 开发服务器运行单线程吗？

顺便说一句，如果我使用 Gunicorn 进行部署，是否可以这样做（即运行多个进程，所有进程都是单线程的）？

def myfn():
    class MyClass:
        pass


    return MyClass()


a = myfn()
b = myfn()

print(type(a) is type(b))

在这里我们可以看到type(a) 不是 type(b).这总是保证是这样的吗？为什么解释器不优化这个,因为定义MyClass不依赖于传递给的任何参数myfn？

我创建了一个 C++ 概念，用于检查模板类 是否T可以从固定类 构造CData&。

T = CThing对于无法从 构造的特定对象CData&，我的概念似乎传递了对该类的引用，即T = CThing&，这不是我想要的，因为它会导致我的模板解析不正确。

不仅如此，我不知道为什么这段代码甚至可以编译，因为它成功地CThing&从引用初始化了引用CData&，这是一个完全不相关的类。

我在下面添加了一个 MWE 来展示我的意思。

据我所知：

• return T(data);T当isCThing&且 data 为 时应该是不可能的CData&，但这是有效的。
• 概念IsConstructable应该失败CThing&，但它通过了。
• std::cout << thing.Value甚至不应该到达，但它被调用（并产生垃圾输出）。

有人可以解释一下发生了什么事吗？

#include <iostream>

struct CThing { int Value; };
struct CData { };

template <typename T> concept IsConstructable = requires(CData& data, T t) { T(data); };

template<typename T> struct …