小编Kor*_*ose的帖子

假设我有一个vector带有各种条目,我想插入另一个向量,同时省略满足条件的条目.

例如,我想插入一个向量,同时省略所有三个.

{1, 3, 2, 3, 4, 5, 3} -> { /* previous content, */ 1, 2, 4, 5}

到目前为止我提出的用途std::partition,它不保留相对顺序并重新排列源向量.

std::vector<int> source({1, 3, 2, 3, 4, 5, 3});
std::vector<int> target;

auto partition = std::partition(std::begin(source),
                   std::end(source), [](const auto& a) { return a == 3; });
target.insert(std::begin(target), partition, std::end(source));

我正在寻找的更多是一个迭代器,它检查条件并在条件不满足时继续运行.像这样的东西:

target.insert(std::begin(target),
              conditional_begin(source, [](const auto& a) { return a != 3; },
              conditional_end(source));

我想一个conditional_end函数是必要的,因为std::end它将返回一个不同的迭代器类型conditional_begin.

也许我忽略了一些事情,所以我的问题是:

• 标准库是否提供类似的东西？
• 有没有不同的简单方法来实现我的目标？
• 有没有一种简单的方法来实现条件迭代器功能？

我有一个包含一些数据的数据框,我想要转换,以便一列的值定义新列.

>>> import pandas as pd
>>> df = pd.DataFrame([['a','a','b','b'],[6,7,8,9]]).T
>>> df
   A  B
0  a  6
1  a  7
2  b  8
3  b  9

列的值A应为新数据帧的列名.转换的结果应如下所示:

   a  b
0  6  8
1  7  9

到目前为止我想出的并没有完全发挥作用:

>>> pd.DataFrame({ k : df.loc[df['A'] == k, 'B'] for k in df['A'].unique() })
     a    b
0    6  NaN
1    7  NaN
2  NaN    8
3  NaN    9

除了这是不正确的,我想无论如何可能还有更有效的方法.我真的很难理解如何处理大熊猫的事情.

目前我正在尝试使用std::filesystem. 我正在使用 MinGW-W64 GCC 7.1.0 在 Windows 7 64 位上工作。由于此编译器不支持std::filesystem，我必须包含实验版本并与-lstdc++fs.

#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;

在我想创建嵌套目录之前，这工作得很好。如果我使用 一次创建一个目录create_directory()，则一切正常。现在，如果我create_directories()改为使用，它会抛出一个filesystem_error如果目录之一已经存在。

fs::path levelA{"."};
fs::path levelB{"folder"};
fs::path levelAB = levelA / levelB;  // "./folder"

bool create_separately; // set this bool as needed

if (create_separately) {
  /* This works perfectly */
  fs::create_directory(levelA);
  fs::create_directory(levelAB);
}
else {
  /* This throws because "." already exists */
  fs::create_directories(levelAB);
}

对比实验版和标准版的文档，标准版多加一句： …

在模板函数我试图创建一个std::vector与它value_type依赖于模板参数的函数的成员函数。该模板参数被限制为包含具有特定功能的特定类型的唯一指针的向量。例如：

/* somewhere in the code */
std::vector< std::unique_ptr< Widget > > myVec;
/* work with myVec and fill it, then call the relevant function */
func(myVec);

现在函数func需要检索的成员函数的返回类型member_func的Widget。请注意，Widget也可以是不同的类型，只要它具有成员函数member_func。

template <typename Vec>
void func(const Vec& vec) {
  using ret_type = decltype(Vec::value_type::element_type::member_func()); // Doesn't work
  std::vector< ret_type > local_vec;
}

我尝试了各种方法，例如std::result_of,std::invoke_result和decltype，但我似乎无法让它工作。这甚至是可能的，如果是，如何实现？

目前我正在尝试可视化我正在使用seaborn处理的一些数据。我需要使用逗号作为小数点分隔符，所以我正在考虑简单地更改区域设置。我找到了类似问题的答案，它设置区域设置并使用 matplotlib 来绘制一些数据。

这也适用于我，但是当直接使用 seaborn 而不是 matplotlib 时，它不再使用区域设置。不幸的是，我在seaborn中找不到任何可以更改的设置或任何其他解决方法。有办法吗？

这里有一些示例性数据。请注意，我必须使用'german'而不是"de_DE". xlabel 均使用标准点作为小数点分隔符。

import locale
# Set to German locale to get comma decimal separator
locale.setlocale(locale.LC_NUMERIC, 'german')

import pandas as pd
import seaborn as sns

import matplotlib.pyplot as plt
# Tell matplotlib to use the locale we set above
plt.rcParams['axes.formatter.use_locale'] = True

df = pd.DataFrame([[1,2,3],[4,5,6]]).T
df.columns = [0.3,0.7]

sns.boxplot(data=df)

目前我正在尝试为<<我正在处理的类重载插入操作符.出于某种原因,我将其分成两个函数,并从另一个函数中调用一个函数.切换到模板后,它不再起作用了.在查找问题之后,我发现了两个阶段查找和背后的一些推理.

基本上,我试图做的是以下内容:

template <typename Foo, typename Bar>
class MyClass {
public:
  using foo_t = Foo;
  using bar_t = Bar;

  bar_t some_func() const { /* do something */ }
};

/* Level 2 operator */
template <typename Foo, typename Bar>
std::ostream& operator<<(std::ostream& out, const typename MyClass<Foo,Bar>::bar_t& bar) {
  return out << some_other_func(bar);
}

/* Level 1 operator calls level 2 operator */
template <typename Foo, typename Bar>
std::ostream& operator<<(std::ostream& out, const MyClass<Foo,Bar>& myClass) {
  return …

我目前正在处理的一个类有一个定义各种函数的类型的成员.由于各种原因,我的类应该是这种类型的包装器(例如,使其成为线程安全的).无论如何,一些类型的函数可以通过,如下所示:

class MyClass {
  // ... some functions to work with member_

  /* Pass through clear() function of member_ */
  void clear() {
    member_.clear()
  }

private:
  WrappedType member_;
};

这并不是那么糟糕,而且我还可以灵活地添加更多功能,MyClass::clear()以备不时之需.然而,如果我有一些这些传递函数,它会膨胀MyClass,对我来说会让它更难阅读.

所以我想知道是否有一个很好的单行方式(除了将上层定义写成一行)传递WrappedType的成员函数,就像使基类成员可用:

/* Pass through clear() in an easier and cleaner way */
using clear = member_.clear; // Unfortunately, this obviously doesn't compile

在我当前的项目中,我试图将私有成员函数作为参数传递给另一个函数.在我的代码中,另一个函数是不同类的成员函数,但为了保持简单,这里它是一个自由函数.

void outside_function(std::function<void(int)> func) {
  // do something with func
}


class MyClass {
public:
  void run();

private:
  bool my_func(double); // defined in source file
};

现在,从里面run我想提出my_func到outside_function作为参数.由于签名run不符合参数的要求,我不能简单地传递它.使用适配器模式是我的第一次尝试,当我被提醒时,成员函数隐式地将this指针作为第一个参数.这个答案建议使用lambda表达式,这就是我所做的.

void MyClass::run() {
  outside_function([this](int a) -> void {
    double d = static_cast<double>(a);
    this->my_func(d);
  });
}

为什么这样做？从我的理解,outside_function无法访问my_func.为什么我不my_func先公开？这是编译器做的事情还是我不知道的一些C++规则？

此外,这种方法是否有任何可能会破坏我的代码？