相关疑难解决方法(0)

我试图在Python中实现方法重载:

class A:
    def stackoverflow(self):    
        print 'first method'
    def stackoverflow(self, i):
        print 'second method', i

ob=A()
ob.stackoverflow(2)

但输出是second method 2; 类似的:

class A:
    def stackoverflow(self):    
        print 'first method'
    def stackoverflow(self, i):
        print 'second method', i

ob=A()
ob.stackoverflow()

给

Traceback (most recent call last):
  File "my.py", line 9, in <module>
    ob.stackoverflow()
TypeError: stackoverflow() takes exactly 2 arguments (1 given)

我该如何工作？

而不是支持方法重载Ruby覆盖现有方法.任何人都可以解释为什么语言是这样设计的？

是否有可能在Python中重载函数？在C#中,我会做类似的事情

void myfunction (int first, string second)
{
//some code
}
void myfunction (int first, string second , float third)
{
//some different code
}

然后当我调用函数时,它会根据参数的数量区分两者.是否有可能在Python中做类似的事情？

在编写单元测试时,我有时剪切并粘贴测试,不记得更改方法名称.这导致覆盖先前的测试,有效地隐藏它并阻止它运行.例如;

class WidgetTestCase(unittest.TestCase):

  def test_foo_should_do_some_behavior(self):
    self.assertEquals(42, self.widget.foo())

  def test_foo_should_do_some_behavior(self):
    self.widget.bar()
    self.assertEquals(314, self.widget.foo())

在这种情况下,只会调用后一个测试.是否有一种以编程方式捕获此类错误的方法,而不是直接解析原始源代码？

我想在Python中使用重载。我知道这在设计上是不可能的（Python 是动态类型语言），这里有关于这个主题的很好的帖子。这就是为什么我可以使用诸如多重调度（多方法）之类的东西。我正在考虑最好的解决方案，即为任何函数或类方法实现多重分派。Python 中是否有原生包含的解决方案？

在我的例子中，使用 singledispatch （在 3.4 中添加到 Python 中）是不够的（因为只考虑第一个参数的类型，而我需要multiple）。

我还知道我可以使用关键字参数（即具有单个函数并通过检查所有参数来驱动行为），但是当您有很多参数和组合时，它会变得复杂。

到目前为止，我能够找到这两个库（不包含在Python标准库中）：

• multimethod - 提供一个装饰器，用于向函数添加多个参数分派，可以使用与functools.singledispatch相同的注册风格，与注释配合良好，甚至可以与带注释的谓词配合使用，或者multimeta为类提供特殊的命名空间
• multipledispatch - 还提供用于多参数分派的装饰器，不适用于注释，并且与以前的库相比，对我来说看起来不太强大

基本用法如下：

from multimethod import multimethod

@multimethod
def add(x: int, y: int):
    ...

@multimethod
def add(x: str, y: str):
    ...

或者

from multipledispatch import dispatch

@dispatch(int, int)
def add(x, y):
    ...

@dispatch(str, str)
def add(x, y):
    ...

这个功能看起来非常相似。

我主要有两个问题：

• 这些多重调度实现中的一种是否比另一种带来任何（不利）优势？（例如支持的类型，速度，性能，限制，...）它似乎具有可比性，但我对此不确定，因为后者（multipledispatch）似乎更受欢迎（检查 GitHub 星星）但维护较少（我什至会说不成熟）。
• 是否还有其他解决方案（即使是包含在 Python 标准库中的解决方案）？

我正在从Java背景学习Python(3.x).

我有一个python程序,我在其中创建一个personObject并将其添加到列表中.

p = Person("John")
list.addPerson(p)

但是为了灵活性,我还希望能够直接在addPerson方法中声明它,如下所示:

list.addPerson("John")

addPerson方法将能够区分我是否发送Person-object或String.

在Java中,我将创建两个单独的方法,如下所示:

void addPerson(Person p) {
    //Add person to list
}

void addPerson(String personName) {
    //Create Person object
    //Add person to list
}

我无法在Python中找到如何做到这一点.我知道一个type()函数,我可以用它来检查参数是String还是Object.然而,这对我来说似乎很混乱.还有另一种方法吗？

编辑:

我想替代解决方法将是这样的(python):

def addPerson(self, person):
    //check if person is string
        //Create person object

    //Check that person is a Person instance
        //Do nothing

    //Add person to list

但与Java中的重载解决方案相比,它看起来很混乱.

是否可以通过将参数传递给表单构造函数来使我的表单标签动态化？

我正在考虑类似于以下代码的内容：

class MyForm(Form):

    def __init__(self, fruit):
        Form.__init__(self)
        self.fruit = fruit

    name = StringField('Do you like' + fruit + "?")

@app.route('/' ,methods=["GET","POST"])
def home():
    form = NameForm("bananas")

无论我尝试什么，文本输入框的标签似乎永远无法访问变量“fruit” - 即我似乎无法使标签动态化。

可能只是因为我对 Python 对象的理解不够深入，无法理解为什么这是不可能的。

嗨,我正在学习计算机科学,我要求我必须在python中编写两个具有相同名称的函数.我该怎么办？

class QueueCards:
    def __init__(self):
        self.cards = []

    def Add(self, other):
        self.cards.insert(0, other)

    def Add(self, listCards, numCards):
        for i in numCards:
            card = listCards.GetCard(i)
            self.Add(card)

Count()是队列的大小.谢谢.

我写了一段代码来确定一个典型的回文字符串.我通过返回字符串的reverse()方法的定义来做到这一点.我也渴望拥有相同的方法,但是在虚空形式中,因为未来的某些需求.当我将后者添加到代码中时,有效输出将变为无效.所以,问题是定义两个具有相同名称但返回类型不同的方法是否合法？如果没有,请让我知道如何使用void-type方法编写此代码.

class detector(object):
    def __init__(self,string):
        self.string = string

    forbidden = (' ','!','?','.','-','_','&','%',"#",",")

    def eliminator(self):
        for item in self.forbidden:
            if item in self.string:
                self.string = self.string.replace(item,"")

    def reverse(self):
        return self.string[::-1]            

    #def reverse(self):
    #    self.string = self.string[::-1]    I am prone to add this method

    def check(self):
        reversed = self.reverse()
        if self.string == reversed:
            print("Yes")
        else:
            print("No")

det = detector("rise to vote, sir!")
det.eliminator()
det.check()

当我添加注释行时,有效的"是"变为"否"!

这是上一个问题的后续问题（我再次发布）：PyQt4 QProcess 状态始终为 0，各种插槽也不起作用

代码（修改）：

主要应用：qprocess_test.py

#!/usr/bin/python

import sys
from PyQt4 import QtGui, QtCore
from PyQt4.QtCore import QProcess


class Example(QtGui.QWidget):


    def __init__(self):
        super(Example, self).__init__()
        self.command = "./testCommand.py"
        self.args = [""]
        self.initUI()

    def initUI(self):               
        hbox = QtGui.QHBoxLayout()
        hbox.addStretch(1)

        qbtn = QtGui.QPushButton('Start', self)
        qbtn.clicked.connect(self.toggleProcess)
        qbtn.resize(qbtn.sizeHint())
        hbox.addWidget(qbtn)

        # This button is for testing the responsiveness of the GUI after the QProcess has been started
        qbtn2 = QtGui.QPushButton('Click me', self)
        qbtn2.setCheckable(True)
        qbtn2.toggled.connect(self.toggleButton)
        qbtn2.resize(qbtn2.sizeHint())
        hbox.addWidget(qbtn2)

        self.setLayout(hbox)
        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('QProcess controlled by a …

在 python 中，我似乎无法重载以下函数：

#!/usr/bin/env python

import subprocess
def my_function (a) :
    subprocess.call(['proc', a])
    return;

def my_function (a, b) :
    subprocess.call(['proc','-i',a,b])
    return;

def my_function (a, b, c, d) :
    subprocess.call(['proc','-i',a,b,'-u',c,d])
    return; 

例如，当我打电话时：

mymodules.my_function("a", "b")

我得到：

Traceback (most recent call last):
  File "sample.py", line 11, in <module>
    mymodules.my_function("a", "b") 
TypeError: my_function() takes exactly 4 arguments (2 given)

为什么它尝试调用带有 4 个参数的函数？