小编Tom*_*eus的帖子

for k, v in d.iteritems():
    if type(v) is dict:
        for t, c in v.iteritems():
            print "{0} : {1}".format(t, c)

我正在尝试遍历字典并打印出值不是嵌套字典的所有键值对.如果值是字典,我想进入它并打印出其键值对...等.有帮助吗？

编辑

这个怎么样？它仍然只打印一件事.

def printDict(d):
    for k, v in d.iteritems():
        if type(v) is dict:
            printDict(v)
        else:
            print "{0} : {1}".format(k, v)

完整测试案例

字典:

{u'xml': {u'config': {u'portstatus': {u'status': u'good'}, u'target': u'1'},
      u'port': u'11'}}

结果:

xml : {u'config': {u'portstatus': {u'status': u'good'}, u'target': u'1'}, u'port': u'11'}

我真的很喜欢Github的Atom编辑器!但是,有一件事我被卡住了.

我有时会在没有拼写错误的情况下获得代码注释.因此,我喜欢我的编辑对评论进行拼写检查(例如,像Geany那样).但是我还没有在Atom中工作.

我们以Python代码为例.我尝试通过添加以下内容启用拼写检查:

text.python, text.py

到拼写检查包的"语法"字段.但是,似乎没有为Python代码运行拼写检查.谷歌也没有帮助...

我遇到了一个非常奇怪的过载故障.我能够孤立这个问题,但我不能为它的生活弄清楚出了什么问题.

代码如下

#include <vector>
#include <iostream>

template<class X>
class Foo
{
public:
  Foo(const std::initializer_list<X> &A){}
  Foo(size_t n){}
};

class Bar
{
public:
  Bar() = default;
  Bar(const Foo<size_t> &A, bool a=true, bool b=true){};
};

int main()
{
  Bar A({1,2});
}

编译结果

$ clang++ -std=c++14 so.cpp

so.cpp:21:11: error: call to constructor of 'Bar' is ambiguous
      Bar A({1,2});
          ^ ~~~~~
so.cpp:12:11: note: candidate is the implicit move constructor
    class Bar
          ^
so.cpp:12:11: note: candidate is the implicit copy constructor
so.cpp:16:7: note: candidate constructor …

我目前正在考虑安全关键软件(DO-178C DAL-D)中的C++和编码标准的定义.我正在看MISRA C++,它已经10年了,并且错过了所有C++ 11 ... 17的功能.

虽然保守的安全性通常并不是一个坏主意,但新的语言功能可能有利于安全.

在评论期间,人们必须争论为什么做出某些决定.人们总是可以争辩说,新的语言特征使代码更清晰......从而减少了有关误解的错误; 特别是如果编译器能够测试和验证您的假设.

但很难找到比"让事情变得更清晰"更突出的安全方面的语言特征.现代C++的哪些方面真正有助于安全？

我正在建立一个小练习项目来测试这些想法,目前完全专注于"让编译器检查你的假设".例如,我们刚开始使用[[nodiscard]]并在第一个小时内以这种方式发现至少两个错误.但是现代c ++的哪些方面被设计并且应该考虑到安全性？

最近我在Linux操作系统上开始用Python(Python 3.5)编程.但我对Anaconda感到困惑.实际上是什么？它是Python的版本还是别的什么？如果我不安装Anaconda会有任何限制吗？

我有一系列代表变量变化的线; 每个都有独特的颜色.出于这个原因,我想在绘图旁边添加一个颜色条.所需的输出如下所示.

问题是plot不可映射的对象,即必须手动添加颜色条.我认为我目前的解决方案(下面)是次优的,因为它涉及我不感兴趣控制的尺寸参数.我更喜欢与可映射对象类似的解决方案(当前解决方案下面的示例).

期望的输出

当前解决方案

import numpy             as np
import matplotlib        as mpl
import matplotlib.pyplot as plt

x    = np.linspace(0, 5, 100)
N    = 20
cmap = plt.get_cmap('jet',N)

fig  = plt.figure(figsize=(8,6))
ax1  = fig.add_axes([0.10,0.10,0.70,0.85])

for i,n in enumerate(np.linspace(0,2,N)):
    y = np.sin(x)*x**n
    ax1.plot(x,y,c=cmap(i))

plt.xlabel('x')
plt.ylabel('y')

ax2  = fig.add_axes([0.85,0.10,0.05,0.85])
norm = mpl.colors.Normalize(vmin=0,vmax=2)
cb1  = mpl.colorbar.ColorbarBase(ax2,cmap=cmap,norm=norm,orientation='vertical')

plt.show()

期望的解决方案

(明显替换imshow)

fig,ax = plt.subplots()
cax    = ax.imshow(..)
cbar   = fig.colorbar(cax,aspect=10)
plt.show()

我知道如何导出特定的 conda 环境：

conda activate myenv
conda env export > myenv.yaml

但是如何自动导出所有创建的 conda 环境（在单独的 yaml 文件中，其名称与环境名称相对应）？

我正在尝试使用包装我的C++代码pybind11.在C++中,我有一个Matrix3D充当三维数组(即形状[n,m,p])的类.它具有以下基本签名:

template <class T> class Matrix3D
{

  public:

    std::vector<T> data;
    std::vector<size_t> shape;
    std::vector<size_t> strides;

    Matrix3D<T>();
    Matrix3D<T>(std::vector<size_t>);
    Matrix3D<T>(const Matrix3D<T>&);

    T& operator() (int,int,int);

};

为了最小化包装器代码,我想将此类直接转换为NumPy数组(副本没有问题).例如,我想直接包装以下签名的函数:

Matrix3D<double> func ( const Matrix3D<double>& );

使用包装器代码

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/numpy.h>

namespace py = pybind11;

PYBIND11_PLUGIN(example) {
  py::module m("example", "Module description");
  m.def("func", &func, "Function description" );
  return m.ptr();
}

目前我还有另一个接受和返回的功能py::array_t<double>.但我想避免为每个函数编写一个包装函数,方法是用一些模板替换它.

这已经为Eigen-library(对于数组和(2-D)矩阵)完成.但是代码对我来说太过牵扯,无法从中派生自己的代码.另外,我真的只需要包装一个简单的类.

我有两个排序列表，例如

a = [1, 4, 7, 8]
b = [1, 2, 3, 4, 5, 6]

我想知道每个项目a是否在b. 对于上面的例子，我想找到

a_in_b = [True, True, False, False]

（或具有索引其中a_in_b是True将细太）。

现在，a和b都非常大，因此复杂性是一个问题。如果M = len(a)和N = len(b)。我怎样才能以比M * O(N)利用两个列表都已排序的事实更低的复杂性来做到这一点？

我有一个可耻幼稚的问题：什么是一个转换的最佳方式uint32_t，以一个double0和1之间？

我天真的方法是

double myconvert(uint32_t a)
{
    double n = static_cast<double>(std::numeric_limits<uint32_t>::max() - std::numeric_limits<uint32_t>::min());
    return static_cast<double>(a) / n;
}

但我想知道是否有更好的方法？