问题
How to declare few methods with the same name ,but with different numbers of parameters or different types in one class?
What I must to change in this class:
class MyClass:
""""""
#----------------------------------------------------------------------
def __init__(self):
"""Constructor"""
def my_method(self,parameter_A_that_Must_Be_String):
print parameter_A_that_Must_Be_String
def my_method(self,parameter_A_that_Must_Be_String,parameter_B_that_Must_Be_String):
print parameter_A_that_Must_Be_String
print parameter_B_that_Must_Be_String
def my_method(self,parameter_A_that_Must_Be_String,parameter_A_that_Must_Be_Int):
print parameter_A_that_Must_Be_String * parameter_A_that_Must_Be_Int
回答1:
You can have a function that takes in variable number of arguments.
def my_method(*args, **kwds):
# do something
# when you call the method
my_method(a1, a2, k1=a3, k2=a4)
# you get:
args = (a1, a2)
kwds = {'k1':a3, 'k2':a4}
So you can modify your function as follows:
def my_method(*args):
if len(args) == 1 and isinstance(args[0], str):
# case 1
elif len(args) == 2 and isinstance(args[1], int):
# case 2
elif len(args) == 2 and isinstance(args[1], str):
# case 3
回答2:
You can't. There are not overloads or multimethods or similar things. One name refers to one thing. As far as the language is concerned anyway, you can always emulate them yourself... You could check types with isinstance (but please do it properly - e.g. in Python 2, use basestring to detect both strings and unicode), but it's ugly, generally discouraged and rarely useful. If the methods do different things, give them different names. Consider polymorphism as well.
回答3:
Short answer: you can't (see this previous discussion). Typically you'd use something like (you could add more type checking and reorder):
def my_method(self,parameter_A, parameter_B=None):
if isinstance(parameter_B, int):
print parameter_A * parameter_B
else:
print parameter_A
if parameter_B is not None:
print parameter_B
回答4:
You can try multimethods in Python:
http://www.artima.com/weblogs/viewpost.jsp?thread=101605
But I don't believe multimethod is a way to go. Rather objects that you pass to a method should have common interface. You are trying to achieve method overloading similar to the one in C++, but it is very rarely required in python. One way to do this is a cascade of ifs using isinstance, but that's ugly.
回答5:
This cannot work. No matter how many arguments you have, the name m will be overriden with the second m method.
class C:
def m(self):
print('m first')
def m(self, x):
print(f'm second {x}')
ci=C();
#ci.m() # will not work TypeError: m() missing 1 required positional argument: 'x'
ci.m(1) # works
The output will simple be:
m second 1
回答6:
Python is nothing like Java.
There is not really types, just objects with methods.
There is way to test if a passed object is from a class, but it is mainly bad practices.
However, the code you want to produce for the two first methods should be something like
class MyClass(object):
def my_method(self, str1, str2=None):
print str1
if str2: print str2
For the third, well... Use a different name...
回答7:
You probably want a pattern similar to the following: Note that adding '_' to the beginning of a method name is convention for marking a private method.
class MyClass:
""""""
#----------------------------------------------------------------------
def __init__(self):
"""Constructor"""
def my_method(self,parameter_A_that_Must_Be_String, param2=None):
if type(param2) == str:
return self._my_method_extra_string_version(parameter_A_that_Must_Be_String, param2)
elif type(param2) == int:
return self._my_method_extra_int_version(parameter_A_that_Must_Be_String, param2)
else:
pass # use the default behavior in this function
print parameter_A_that_Must_Be_String
def _my_method_extra_string_version(self,parameter_A_that_Must_Be_String, parameter_B_that_Must_Be_String):
print parameter_A_that_Must_Be_String
print parameter_B_that_Must_Be_String
def _my_method_extra_int_version(self,parameter_A_that_Must_Be_String, parameter_A_that_Must_Be_Int):
print parameter_A_that_Must_Be_String * parameter_A_that_Must_Be_Int
回答8:
class MyClass:
def __init__(this, foo_str, bar_int):
this.__foo = foo_str
this.__bar = bar_int
def foo(this, new=None):
if new != None:
try:
this.__foo = str(new)
except ValueError:
print("Illegal value. foo unchanged.")
return this.__foo
def bar(this, new=None):
if new != None:
try:
this.__bar = int(new)
except ValueError:
print("Illegal value. bar unchanged.")
return this.__bar
obj = MyClass("test", 42)
print(obj.foo(), obj.bar())
print(obj.foo("tset"), obj.bar(24))
print(obj.foo(42), obj.bar("test"))
Output:
test 42
tset 24
Illegal value. bar unchanged.
42 24
回答9:
I think one very simple example is missing from all the answers, and that is: what to do when the only difference between variations on the method is the number of arguments. The answer still is to use a method with variable number of arguments.
Say, you start with a method that requires use of two arguments
def method(int_a, str_b):
print("Got arguments: '{0}' and '{1}'".format(int_a, str_b)
then you need to add a variant with just the second argument (say, because the integer is redundant), the solution is very simple:
def _method_2_param(int_a, str_b):
print("Got arguments: '{0}' and '{1}'".format(int_a, str_b))
def _method_1_param(str_b):
print("Got argument: '{0}'".format(str_b))
def method(*args, **kwargs):
if len(args) + len(kwargs) == 2:
return _method_2_param(args, kwargs)
elif len(args) + len(kwargs) == 1:
return _method_1_param(args, kwargs)
else:
raise TypeError("Method requires one or two arguments")
The nice thing about this solution is that no matter if the calling code used keyword arguments or positional arguments before, it will still continue to work.
来源：https://stackoverflow.com/questions/5079609/methods-with-the-same-name-in-one-class-in-python