如何在Python中使用不同参数编写同名方法 [英] How to write same-name methods with different parameters in python

问题描述

我从Java背景学习Python（3.x）。

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

  p = Person（John）
 list.addPerson（p）
  
 
但为了灵活性，我还希望能够直接在addPerson方法中声明它，如下所示：
  list.addPerson（John）
  
 addPerson方法将能够区分我是否发送一个Person对象或一个字符串。
 
 
 
在Java中，我将创建两个独立的方法，像这样： 
 
 
  void addPerson（Person p）{
 //将人添加到列表
} 
 
 void addPerson（String personName）{
 //创建Person对象
 //将人员添加到列表
} 
  
我无法知道如何在Python中执行此操作。我知道一个type（）函数，我可以用它来检查参数是否是String或Object。但是，这对我来说似乎很混乱。是否有另一种方法呢？
 
 
 
编辑：
 
 
 
我想替代解决方法是这样的（python）：
 
 
  def addPerson（self，person）：
 //检查person是否是字符串
 //创建人物对象
 
 //检查该人是一个Person实例
 //什么也不做
 
 //将人添加到列表
  
但与Java中的重载解决方案相比，它似乎很麻烦。    >解决方案

使用@Kevin指向的引用，您可以执行以下操作：

  from multimethod import multimethod 
 $ b $ class Person（object）：
 def __init __（self，myname）：
 self.name = myname 
 $ b $ def __str __（self） ：
 return self.name 
 $ b $ def __repr __（self）：
 return self .__ str __（）
 
 $ b @multimethod（list，对象）
 def addPerson（l，p）：
l = l + [p] 
返回l 
 
 @multimethod（list，str）
 def addPerson（l，name）：
p = Person（name）
l = l + [ p] 
返回l 
 
 
 alist = [] 
 alist = addPerson（alist，Person（foo））
 alist = addPerson（alist ，bar）
 print（alist）
  

结果如下：

  $ python test.py 
 [foo，bar] 
  

（您需要先安装multimethod）

I'm learning Python (3.x) from a Java background.

I have a python program where I create a personObject and add it to a list.

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

But for flexibility I also want to be able to declare it directly in the addPerson method, like so:

list.addPerson("John")

The addPerson method will be able to differentiate whether or not I'm sending a Person-object or a String.

In Java I would create two separate methods, like this:

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

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

I'm not able to find out how to do this in Python. I know of a type() function, which I could use to check whether or not the parameter is a String or an Object. However, that seems messy to me. Is there another way of doing it?

EDIT:

I guess the alternative workaround would be something like this(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

But it seems messy compared to the overloading solution in Java.

解决方案

Using the reference pointed by @Kevin you can do something like:

from multimethod import multimethod

class Person(object):
    def __init__(self, myname):
        self.name = myname

    def __str__(self):
        return self.name

    def __repr__(self):
        return self.__str__()


@multimethod(list, object)
def addPerson(l, p):
    l = l +[p]
    return l

@multimethod(list, str)
def addPerson(l, name):
    p = Person(name)
    l = l +[p]
    return l


alist = []
alist = addPerson(alist, Person("foo"))
alist = addPerson(alist, "bar")
print(alist)

The result will be:

$ python test.py
[foo, bar]

(you need to install multimethod first)

这篇关于如何在Python中使用不同参数编写同名方法的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！