标签: optional-arguments

伙计们,我刚刚开始使用python并且对可选参数感到困惑,比如我有这样的程序:

class B:
   pass

class A:
    def __init__(self, builds = B()):
        self.builds = builds

如果我创建A两次

b = A()
c = A()

并打印他们的构建

print b.builds
print c.builds

我发现他们正在使用完全相同的对象,

<__main__.B instance at 0x68ee0>
<__main__.B instance at 0x68ee0>

但它不是我想要的,因为如果b改变一些内部构建状态,c对象中的那个也将被改变.

是否可以通过使用此可选参数语法每次重新创建此可选参数？

假设我有一个如下所示的函数它需​​要3个参数,2个具有可选值

private void  myfunc (int a, int b=2, int c=3)
{
  //do some stuff here related to a,b,c
}

现在我想调用这个函数如下可能吗？

myfunc(3,,5)

所以我希望它使用默认参数b = 2

但它正是这样给出错误的.

这里是错误消息

Argument missing

C#4.5

我想有以下语法:

python utility.py file1 FILE1 file2 FILE2

其中file1和file2是可选参数.使用这种语法很简单:

python utility.py --file1 FILE1 --file2 FILE2

运用

parser.add_argument('--file1',type=file)
parser.add_argument('--file2',type=file)

但是,如果我删除破折号,argparse开始将其解释为位置而非可选参数......

换句话说,是否可以专门告诉argparse一个参数是可选的还是位置的,这样我可以有没有破折号的可选参数？

我今天遇到了这个,我很惊讶我之前没有注意到它.给出一个简单的C#程序,类似于以下内容:

public class Program
{
    public static void Main(string[] args)
    {
        Method(); // Called the method with no arguments.
        Method("a string"); // Called the method with a string.

        Console.ReadLine();
    }

    public static void Method()
    {
        Console.WriteLine("Called the method with no arguments.");
    }

    public static void Method(string aString = "a string")
    {
        Console.WriteLine("Called the method with a string.");
    }
}

您将获得每个方法调用的注释中显示的输出.

我理解为什么编译器会选择它所做的重载,但为什么首先允许这样做呢？我不是在问什么是重载决策规则,我理解这些规则,但我想知道是否存在技术上的原因,为什么编译器允许基本上具有相同签名的两个重载？

据我所知,一个带有签名的函数重载只是通过另外一个可选参数与另一个重载不同,只提供了如果只需要参数(和所有前面的参数).

它所做的一件事是让程序员(可能没有给予足够的重视)认为他们正在调用与他们实际存在的不同的重载.

我想这是一个相当罕见的情况下,以及为什么这是允许的可能只是因为它根本不值得的复杂性,以禁止它的答案,但有另一个原因,C#允许函数重载从其他人的不同仅通过有一个附加的可选争论？

可能重复:
重写方法的C#可选参数

这是以下代码的输出:

Peter: -1
Peter: 0
Fred: 1
Fred: 1

你能解释我为什么彼得的号召p.TellYourAge(),并p.DoSomething()是不相同？

这里是自己尝试的代码(VS2010和FW 4):

    static void Main(string[] args)
    {
        Peter p = new Peter();
        p.TellYourAge(); // expected -1, result: -1
        p.DoSomething(); // expected -1, result: 0

        Fred f = new Fred();
        f.TellYourAge(1); // expected 1, result: 1
        f.DoSomething(); // expected 1, result: 1

        Console.ReadKey();
    }
}

public abstract class Person
{
    public abstract void TellYourAge(int age); // abstract method without default value
}

public class Peter …

以下代码无法编译.

type A(?arg) =
  member __.Arg : string option = arg

type B(?arg) =
  inherit A(arg) //ERROR expected type string but has type 'a option

我假设这是因为必须提供选项的基础类型的实例,并且编译器处理传递Some/ None基于语法.

假设我的假设已被正确假设,是否有解决方法？是否可以传播可选参数？

是否有可能写出类似的结构？
我想以某种方式设置类型T的参数的默认值.

    private T GetNumericVal<T>(string sColName, T defVal = 0)
    {
        string sVal = GetStrVal(sColName);
        T nRes;
        if (!T.TryParse(sVal, out nRes))
            return defVal;

        return nRes;
    }

另外,我发现以下链接: 通用类型转换FROM字符串
我认为,此代码必须工作

private T GetNumericVal<T>(string sColName, T defVal = default(T)) where T : IConvertible
{
    string sVal = GetStrVal(sColName);
    try
    {
        return (T)Convert.ChangeType(sVal, typeof(T));
    }
    catch (FormatException)
    {
        return defVal;
    }            
}

C#和F#具有默认(或可选)参数的不同实现.

在C#语言中,当您为参数添加默认值时,您不会更改其基础类型(我的意思是参数的类型).实际上C#中的可选参数是一个轻量级的语法糖:

class CSharpOptionalArgs
{
  public static void Foo(int n = 0) {}
}

// Somewhere in the call site

CSharpOptionalArgs.Foo();
// Call to Foo() will be transformed by C# compiler
// *at compile time* to something like:
const int nArg = GetFoosDefaultArgFromTheMetadata();
CSharpOptionalArgs.Foo(nArg);

但是F#以不同的方式实现了这个功能.与C#不同,F#可选参数在被调用者站点解析,但不在调用者站点解析:

type FSharpOptionalArgs() =
    static let defaultValue() = 42

    static member public Foo(?xArg) =
        // Callee site decides what value to use if caller does not specifies it
        let x = defaultArg …

我正在尝试创建一个可能作为输入接收多个或几个字典的函数.我正在使用以下代码:

def merge_many_dics(dic1,dic2,dic3=True,dic4=True,dic5=True,dic6=True,dic7=True,dic8=True,dic9=True,dic10=True):
"""
Merging up to 10 dictionaries with same keys and different values
:return: a dictionary containing the common dates as keys and both values as values
"""
manydics = {}
for k in dic1.viewkeys() & dic2.viewkeys() & dic3.viewkeys() & dic4.viewkeys() & dic5.viewkeys() & dic6.viewkeys()\
        & dic7.viewkeys() & dic8.viewkeys() & dic9.viewkeys() & dic10.viewkeys():
    manydics[k] = (dic1[k], dic2[k],dic3[k],dic4[k],dic5[k],dic6[k],dic7[k],dic8[k],dic9[k],dic10[k])

return manydics

请注意,我试图将参数dic3,dic4,dic5等等于"True",因此当它们未被指定并且在函数中被调用时,没有任何反应.但是我收到以下错误:

Traceback (most recent call last):
File "/Users/File.py", line 616, in <module>
main_dic=merge_many_dics(dic1,dic2,dic3,dic4)
File "/Users/File.py", line 132, in merge_many_dics …

对于我在 Python 中的代码，我想使用特定参数调用许多函数。但是，对于某些函数，该参数没有任何作用。不过，出于兼容性原因，我想添加这个论点。例如，考虑以下最小工作示例：

def my_function(unused=False):
    """ Function with unused argument. """
    return True

显然，这个参数unused没有被使用，所以 Pylint 抛出了一个警告：

W0613: Unused argument 'redundant' (unused-argument)

我的观点是，我不希望删除的说法unused，因为函数my_function会以类似的方式被称为用于许多其它功能unused 使用。

我的问题：如何在不删除可选参数的情况下避免来自 Pylint 的警告？

选项 1：我可以想到两个选项，但这些选项都不能满足我。一种选择是添加一些无用的代码，例如unused使用

def my_function(unused=False):
    """ Function with unused argument. """
    if unused:
        dummy = 10
        del dummy
    return True

这感觉像是在浪费资源，而且只会使代码变得混乱。

选项 2：第二个选项是抑制警告，例如，像这样：

def my_function(unused=False):
    """ Function with unused argument. """
    # pylint: disable=unused-argument
    return True

我也不太喜欢这个选项，因为通常 Pylint 警告是不良风格的标志，所以我更希望采用不同的编码方式来避免这种警告。

我还有什么其他选择？