小编Wlo*_*oHu的帖子

简化的情况

public class A {
    protected A() { }
    protected A Make() { return new A(); }
}

public class B : A {
    A a = new A(); //inaccessible due to protection level
    B b = new B();

    private B()
    {
        A c = new A();//inaccessible due to protection level
        a = new A(); //inaccessible due to protection level
        a = Make();
    }
}

为什么使用A类保护的构造函数在B类中创建A的实例是不可能的？

在我看来,受保护的构造函数就像受保护的方法,因此应该可以在子类中运行它.

pytest设置主要基于fixtures，我喜欢这种方法，因为它更原子、更明确，并且在xUnit 中限制类继承更少。是否有任何约定或指南来制作固定装置而不是辅助功能？¹考虑代码：

def create_flavored_cake(flavor):
    return Cake(flavor)

def test_chocolate():
    cake = create_flavored_cake('chocolate')
    assert cake.is_yummy()

def test_broccoli():
    cake = create_flavored_cake('broccoli')
    assert cake.is_yummy()

def test_broccoli_with_risins():
    cake = create_flavored_cake('broccoli')
    cake.add('risins')
    assert cake.is_yummy()

应该create_flavored_cake改成夹具吗？²这种测试具有相同语句但参数不同的场景是否应该触发我将辅助函数转换为夹具以允许更容易的参数化并减少重复？³我应该只将夹具用于设置和拆卸吗？⁴或者没关系，按照惯例，如果有的话，它应该从一开始就使用fixture？⁵

我真的不喜欢通过 参数化装置indirect，但似乎没有更好的方法。那是因为这是一种不好的做法吗？⁶ 我知道我也可以使用pytest.mark.parametrize哪个看起来更好 IMO。那么我应该在使用夹具、辅助函数和其他一些方法（如果有更好的解决方案）之间划清界限，同时还要考虑对它们进行参数化？⁷

我已经添加了问题参考的上标。您不必对所有人都给出答案。

案例类似于:Git:丢弃分散的本地分支上的所有更改.

区别:

• 我想丢弃已推送到远程存储库的更改,
• git push origin foo:foo --force 被拒绝(原点不允许推力).

给定提交图:

A--B--C--O1--O2--O3 (foo)
       \
         L1--L2--L3 (origin/foo)

如果可能,我想实现这个目标:

A--B--C--O1--O2--O3 (foo origin/foo)

如果以上是不可能的,那么以下对我来说是好的:

A--B--C--O1--O2--O3--M1 (foo)
       \            /
         L1--L2--L3 (origin/foo)

但我希望git diff M1..03是空的,即丢弃所引入的所有变化origin/foo.和-s ours策略并没有帮助,因为这仅适用于冲突和冲突的非-变化仍然会被添加到M1.

怎么做到这一点？

解决方案(Mohan Kumar P撰写)

删除远程分支并推送.git如果跟踪(检查git branch -vv),应自动创建远程分支.

为达到这个:

A--B--C--O1--O2--O3 (foo origin/foo)
       \
         L1--L2--L3

类型:

git push origin --delete foo
git checkout foo  # Git ? 1.6.6.
git push origin foo

我无法在Python中生成示例,其中显示了布尔运算符优先级规则以及短路评估.我可以用以下方式显示运算符优先级

print(1 or 0 and 0)  # Returns 1 because `or` is evaluated 2nd.

但是当我将其更改为此时,出现短路问题:

def yay(): print('yay'); return True
def nay(): print('nay')
def nope(): print('nope')
print(yay() or nay() and nope())  # Prints "yay\nTrue"

对于每一个的4种可能性时表达式之前or是True它是唯一的求值表达式.如果运算符优先级有效,则应打印"nay\nnope\nyay\nTrue"或"nay\nyay\nTrue"短路,因为and应该首先进行评估.

从这个例子中可以想到的是,Python从左到右读取布尔表达式,并在结果已知时结束,无论运算符优先级如何.

我的错误在哪里或者我错过了什么？请举例说明and第一次评估它是否可见,这不是由于代码从左到右解释.

鉴于课程:

enum ThingEnum { A,B,C}

interface IThing { }

class A : IThing { }

class B : IThing { }

class C: IThing { }

我脑子里有两个实现IThingFactory.一个使用switch:

class ThingFactory
{
    public IThing MakeThing(ThingEnum type)
    {
        switch (type)
        {
            case ThingEnum.A:
                return new A();
                break;
            case ThingEnum.B:
                return new B();
                break;
            case ThingEnum.C:
                return new C();
                break;
            default:
                break;
        }
    }
}

另一个使用抽象和方法重载:

class ThingFactory
{
    public IThing Make(A a)
    {
        return new A();
    }

    public IThing …