标签: metaprogramming

如果已经提出并回答了这个问题,请道歉.我需要做的是概念非常简单,但不幸的是我无法在网上找到答案.

我需要在运行时使用自定义名称在Python(Python2.7)中创建动态函数.每个函数的主体也需要在运行时构造,但对于所有函数(几乎)都是相同的.

我从一个名单开始.

func_names = ["func1", "func2", "func3"]

请注意,func_name列表可以包含任意名称列表,因此名称不仅仅是func1,func2,func3,....

我希望结果如下:

    def func1(*args):
        ...

    def func2(*args):
        ...

    def func3(*args):
        ...

我需要这样做的原因是每个函数名称对应一个测试用例,然后从外部世界调用.

更新:没有用户输入.我正在绑一个更大的模块的两端.一端确定测试用例是什么,以及填充测试用例名称的列表.另一端是函数本身,它必须与测试用例的名称进行1:1映射.所以我有测试用例的名称,我知道我想对每个测试用例做什么,我只需要创建具有测试用例名称的函数.由于测试用例的名称是在运行时确定的,因此基于这些测试用例的函数创建也必须在运行时.

更新:我也可以将这个自定义命名函数包装在一个类中,如果这样可以使事情变得更容易.

我可以在字符串中硬编码函数的内容(因为它们几乎相同),或者我可以将它基于先前定义的基类.只需要知道如何用这个内容填充函数.

例如:

    func_content = """
                   for arg in args:
                       print arg
                   """

提前致谢,

马赫迪

是否可以制作自定义操作符,以便您可以执行此类操作？

if ("Hello, world!" contains "Hello") ...

注意:这是一个单独的问题:"这是一个好主意......";)

定义respond_to_missing?与定义相反的重点是什么respond_to?？如果重新定义respond_to?某些课程会出现什么问题？

我有幸遇到的最让我最喜爱/最邪恶的发明之一是constexpr计数器,也就是有状态的元编程.正如帖子中所提到的,它似乎在C++ 14下是合法的,我想知道C++ 17有什么变化吗？

以下是主要基于帖子的实现

template <int N>
struct flag
{
    friend constexpr int adl_flag(flag<N>);
    constexpr operator int() { return N; }
};

template <int N>
struct write
{
    friend constexpr int adl_flag(flag<N>) { return N; }
    static constexpr int value = N;
};

template <int N, int = adl_flag(flag<N>{})>
constexpr int read(int, flag<N>, int R = read(0, flag<N + 1>{}))
{
    return R;
}

template <int N>
constexpr int read(float, flag<N>)
{
    return N;
}

template <int N …

我处于这样一种情况:将一个类'instancemethod作为属性访问它是非常有用的(尽管不是绝对必要的).(这是一个使用getattr为字典设置一些返回值的API,我不想弄乱整齐的小东西)

我记得读过一些关于@attribute装饰器的东西,但我找不到一个(用Python或Django)

TL; DR:

我该怎么做:

class foo:
    bar = "bar"
    def baz(self):
        return "baz"

做这个:

>>> f = foo()
>>> f.baz
"baz"

(为清晰起见而编辑)而不是:

>>> f = foo()
>>> f.baz
<bound method foo.baz of <__builtin__.foo instance at 0x...>>

在Ruby中对类变量执行写入/读取不是线程安全的.对实例变量执行写入/读取似乎是线程安全的.也就是说,对类或元类对象的实例变量执行写/读是否是线程安全的？

在线程安全方面,这三个(人为的)示例之间有什么区别？

例1: 相互排斥

class BestUser # (singleton class)
  @@instance_lock = Mutex.new

  # Memoize instance
  def self.instance
    @@instance_lock.synchronize do
      @@instance ||= best
    end
  end
end

例2: 实例变量存储

class BestUser # (singleton class)
  # Memoize instance
  def self.instance
    @instance ||= best
  end
end

例3: 在METACLASS上安装可变存储器

class BestUser # (singleton class)
  # Memoize instance
  class << self
    def instance
      @instance ||= best
    end
  end
end

在C++中,是否可以枚举枚举(运行时或编译时(首选))并为每次迭代调用函数/生成代码？

示例用例:

enum abc
{    
    start
    a,
    b,
    c,
    end
}    
for each (__enum__member__ in abc)
{    
    function_call(__enum__member__);    
}

合理的重复:

• C++:通过枚举迭代
• 像Eum中的Enum一样使用C++中的Enum？

如何在运行时将实例变量添加到已定义的类,然后从类外部获取并设置其值？

我正在寻找一种元编程解决方案,它允许我在运行时修改类实例,而不是修改最初定义类的源代码.一些解决方案解释了如何在类定义中声明实例变量,但这不是我所要求的.

特别是,是否可以在c#中编译时执行类似于此c ++代码的代码？

template <int N>
struct Factorial 
{
    enum { value = N * Factorial<N - 1>::value };
};

template <>
struct Factorial<0> 
{
    enum { value = 1 };
};

// Factorial<4>::value == 24
// Factorial<0>::value == 1
void foo()
{
    int x = Factorial<4>::value; // == 24
    int y = Factorial<0>::value; // == 1
}

在GCC上用C++ 11进行可变参数模板编程时,偶尔会出现一个错误,上面写着"抱歉,未实现:不能将'Identifier ...'扩展到固定长度的列表中." 如果我删除代码中的"...",那么我会得到一个不同的错误:"错误:参数包没有用'...'扩展".

因此,如果我有"...",GCC会调用该错误,如果我取出"......",GCC也会调用该错误.

我能够处理这个问题的唯一方法是使用不同的方法从头开始完全重写模板元程序,并且(幸运的是)我最终提出了不会导致错误的代码.但我真的很想知道我做错了什么.尽管使用谷歌搜索,尽管进行了大量实验,但我无法确定在产生此错误的可变参数模板代码与没有错误的代码之间做出不同的反应.

错误消息的措辞似乎暗示代码应该按照C++ 11标准工作,但GCC还不支持它.或者它可能是一个编译器错误？

这是产生错误的一些代码.注意:我不需要您为我编写正确的实现,而只是指出导致此特定错误的代码是什么

// Used as a container for a set of types.
template <typename... Types> struct TypePack
{
    // Given a TypePack<T1, T2, T3> and T=T4, returns TypePack<T1, T2, T3, T4>
    template <typename T>
    struct Add
    {
        typedef TypePack<Types..., T> type;
    };
};

// Takes the set (First, Others...) and, while N > 0, adds (First) to TPack.
// TPack is a TypePack containing between 0 and N-1 types.
template <int N, typename …