Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > mutually exclusive arguments to a constructor

Reply
Thread Tools

mutually exclusive arguments to a constructor

 
 
Adam Funk
Guest
Posts: n/a
 
      12-30-2011
(Warning: this question obviously reflects the fact that I am more
accustomed to using Java than Python.)

Suppose I'm creating a class that represents a bearing or azimuth,
created either from a string of traditional bearing notation
("N24d30mE") or from a number indicating the angle in degrees as
usually measured in trigonometry (65.5, measured counter-clockwise
from the x-axis). The class will have methods to return the same
bearing in various formats.

In Java, I would write two constructors, one taking a single String
argument and one taking a single Double argument. But in Python, a
class can have only one __init__ method, although it can have a lot of
optional arguments with default values. What's the correct way to
deal with a situation like the one I've outlined above?


--
Unix is a user-friendly operating system. It's just very choosy about
its friends.
 
Reply With Quote
 
 
 
 
GŁnther Dietrich
Guest
Posts: n/a
 
      12-30-2011
Adam Funk <(E-Mail Removed)> wrote:

>Suppose I'm creating a class that represents a bearing or azimuth,
>created either from a string of traditional bearing notation
>("N24d30mE") or from a number indicating the angle in degrees as
>usually measured in trigonometry (65.5, measured counter-clockwise
>from the x-axis). The class will have methods to return the same
>bearing in various formats.
>
>In Java, I would write two constructors, one taking a single String
>argument and one taking a single Double argument. But in Python, a
>class can have only one __init__ method, although it can have a lot of
>optional arguments with default values. What's the correct way to
>deal with a situation like the one I've outlined above?


You can determine the type of the input data by using isinstance() and
take the appropriate actions depending on this decision:

>>> class MyClass(object):

.... def __init__(self, input_data):
.... if isinstance(input_data, basestring):
.... print "Do actions for string type input"
.... elif isinstance(input_data, float):
.... print "Do actions for float type input"
.... def get_output_data(self):
.... return "output data"
....
>>> a = MyClass("String")

Do actions for string type input
>>> b = MyClass(15.9)

Do actions for float type input



Best regards,

GŁnther
 
Reply With Quote
 
 
 
 
Mel Wilson
Guest
Posts: n/a
 
      12-30-2011
Adam Funk wrote:

> (Warning: this question obviously reflects the fact that I am more
> accustomed to using Java than Python.)
>
> Suppose I'm creating a class that represents a bearing or azimuth,
> created either from a string of traditional bearing notation
> ("N24d30mE") or from a number indicating the angle in degrees as
> usually measured in trigonometry (65.5, measured counter-clockwise
> from the x-axis). The class will have methods to return the same
> bearing in various formats.
>
> In Java, I would write two constructors, one taking a single String
> argument and one taking a single Double argument. But in Python, a
> class can have only one __init__ method, although it can have a lot of
> optional arguments with default values. What's the correct way to
> deal with a situation like the one I've outlined above?


Cleanest from the point of view of the class source code would be factory
functions at the module level, or special classmethods to deal with the less
common cases. You see this a lot in wxPython when they have to deal with
overloaded C++ constructors.

Most like the Java would be to check within __init__ for a string argument
that could be parsed as a bearing, and failing that fall back to treating
the argument as a numeric angle.

Neither fish nor fowl would be to accept named arguments for the different
kinds of values.

Mel.

 
Reply With Quote
 
Arnaud Delobelle
Guest
Posts: n/a
 
      12-30-2011
On 30 December 2011 20:40, Adam Funk <(E-Mail Removed)> wrote:
> (Warning: this question obviously reflects the fact that I am more
> accustomed to using Java than Python.)
>
> Suppose I'm creating a class that represents a bearing or azimuth,
> created either from a string of traditional bearing notation
> ("N24d30mE") or from a number indicating the angle in degrees as
> usually measured in trigonometry (65.5, measured counter-clockwise
> from the x-axis). ¬*The class will have methods to return the same
> bearing in various formats.
>
> In Java, I would write two constructors, one taking a single String
> argument and one taking a single Double argument. ¬*But in Python, a
> class can have only one __init__ method, although it can have a lot of
> optional arguments with default values. ¬*What's the correct way to
> deal with a situation like the one I've outlined above?


(Using Python 3 below)

Method 1
----------
Your __init__ method could take the angle as an argument (which seems
the most natural to me). Then you could have a class method that
takes the string

i.e.

class Bearing:
def __init__(self, angle):
self.angle = angle
# or whatever your internal reprsentation is
@classmethod
def fromstring(cls, string):
# Here, work out the angle from the string
return cls(angle)

So you can do:

b = Bearing(65.5)

or

b = Bearing.fromstring("N24d30mE")

Method 2
----------

You can test the type of the argument of the __init__ method

class Bearing:
def __init__(self, arg):
if isinstance(arg, str):
# here calculate the value of angle
else:
angle = float(angle)
self.angle = angle

Now you can do:

b = Bearing(65.5)

or

b = Bearing("N24d30mE")

Both methods are used for builtin types:

>>> int('12')

12
>>> int(12.5)

12
>>> dict([(1, 2), (3, 4)])

{1: 2, 3: 4}
>>> dict.fromkeys([1, 2])

{1: None, 2: None}

HTH

--
Arnaud
 
Reply With Quote
 
Steven D'Aprano
Guest
Posts: n/a
 
      12-30-2011
On Fri, 30 Dec 2011 20:40:16 +0000, Adam Funk wrote:

> (Warning: this question obviously reflects the fact that I am more
> accustomed to using Java than Python.)
>
> Suppose I'm creating a class that represents a bearing or azimuth,
> created either from a string of traditional bearing notation
> ("N24d30mE") or from a number indicating the angle in degrees as usually
> measured in trigonometry (65.5, measured counter-clockwise from the
> x-axis). The class will have methods to return the same bearing in
> various formats.
>
> In Java, I would write two constructors, one taking a single String
> argument and one taking a single Double argument. But in Python, a
> class can have only one __init__ method, although it can have a lot of
> optional arguments with default values. What's the correct way to deal
> with a situation like the one I've outlined above?


The most idiomatic way to do this would be with named constructor
functions, or by testing the argument type in __init__. For example:

# Method 1
class Azimuth(object):
def __init__(self, angle):
# Initialise an azimuth object from an angle (float)
self._angle = float(angle)
@classmethod
def from_bearing(cls, bearing):
# Create an azimuth object from a bearing (string).
angle = cls.bearing_to_angle(bearing)
return cls(angle)
@staticmethod
def bearing_to_angle(bearing):
# Convert a bearing (string) into a float.
return 0.0 # whatever...


Note some features of this version:

* Normal methods receive the instance as first argument, "self".

* We use the classmethod and staticmethod decorators to create class
and static methods. Be warned that the meaning of these are NOT
the same as in Java!

* Class methods receive the class object as first argument, "cls".
Hence the name. Note that in Python, classes are objects too.

* We make from_bearing a class method, so we can call it from either
the class itself:

ang = Azimuth.from_bearing("25N14E")

or from an existing instance:

ang2 = ang.from_bearing("17N31W")

* Static methods don't receive either the class or the instance. They
are equivalent to a top level function, except encapsulated inside
a class.


# Method 2
class Azimuth(object):
def __init__(self, arg):
# Initialise an azimuth object from arg, either an angle (float)
# or a bearing (string).
if isinstance(arg, str):
angle = bearing_to_angle(arg)
else:
angle = float(arg)
self._angle = float(angle)

def bearing_to_angle(bearing):
# Convert a bearing (string) into a float.
return 0.0 # whatever...


Note that in this example, I've turned bearing_to_angle into a regular
function outside of the class instead of a static method. Just because I
can. This is probably slightly more idiomatic than the use of static
methods.


Either method is acceptable, although the first is slightly more "pure"
because it doesn't use isinstance. The second may fail if the user passes
a string-like object which behaves identically to strings, but doesn't
inherit from str. If you care about that, you should prefer the first way
with an explicit from_bearing method.



--
Steven
 
Reply With Quote
 
Steven D'Aprano
Guest
Posts: n/a
 
      12-30-2011
On Fri, 30 Dec 2011 21:18:29 +0000, Jason Friedman wrote:

> class azimuth:
> def __init__(self, bearing, heading):


It is conventional, and recommended, to use an initial capital letter for
classes. (Yes, Python built-ins violate that rule, and indeed so do some
non-built-ins.) See PEP 8 for the recommended style guide.


[...]
> @staticmethod
> def getBearingInstance(bearing):
> return azimuth(bearing, None)
> @staticmethod
> def getHeadingInstance(heading):
> return azimuth(None, heading)


In this case, you should use classmethod rather than staticmethod and
avoid hard-coding the class:

@classmethod
def getBearingInstance(cls, bearing):
return cls(bearing, None)

That way subclassing will work correctly:


class MyAzimuth(azimuth):
pass

angle = MyAzimuth.getBearingInstance("N24d30mE")

will return a MyAzimuth instance instead of an azimuth instance.



--
Steven
 
Reply With Quote
 
Roy Smith
Guest
Posts: n/a
 
      12-30-2011
In article <(E-Mail Removed)>,
Adam Funk <(E-Mail Removed)> wrote:

> (Warning: this question obviously reflects the fact that I am more
> accustomed to using Java than Python.)
>
> Suppose I'm creating a class that represents a bearing or azimuth,
> created either from a string of traditional bearing notation
> ("N24d30mE") or from a number indicating the angle in degrees as
> usually measured in trigonometry (65.5, measured counter-clockwise
> from the x-axis).


There's two ways to do this.

One would be to have the __init__ method switch on the type of its
argument:

def __init__(self, bearing_or_azimuth):
if isinstance(bearing_or_azimuth, basestring):
# do the bearing thing
else:
# do the azimuth thing

I suspect many people would consider that unpythonic. The other way
would be what, in the C++/Java world, would be called the "named
constructor idiom". Just write two factory functions:

class DirectionIndicatingThingie:
@staticmethod
def from_bearing(cls, bearing):
dit = DirectionIndicatingThingie()
dit.direction = whatever
return dit

and likewise for from_azimuth()

"But!", some C++/Java type bondage addicts might cry, "there's nothing
to prevent somebody from creating a DirectionIndicatingThingie directly,
bypassing the factory functions. There's no way to make the constructor
private!". To which the free-willed pythonistas would respond, "If it
hurts when you do that, don't do that".
 
Reply With Quote
 
Chris Angelico
Guest
Posts: n/a
 
      12-30-2011
On Sat, Dec 31, 2011 at 10:24 AM, Roy Smith <(E-Mail Removed)> wrote:
> "But!", some C++/Java type bondage addicts might cry, "there's nothing
> to prevent somebody from creating a DirectionIndicatingThingie directly,
> bypassing the factory functions. *There's no way to make the constructor
> private!". *To which the free-willed pythonistas would respond, "If it
> hurts when you do that, don't do that".


You know a Python programmer's been at your C++ code when it opens:
#define class struct

ChrisA
 
Reply With Quote
 
Roy Smith
Guest
Posts: n/a
 
      12-30-2011
In article <(E-Mail Removed)>,
Chris Angelico <(E-Mail Removed)> wrote:

> On Sat, Dec 31, 2011 at 10:24 AM, Roy Smith <(E-Mail Removed)> wrote:
> > "But!", some C++/Java type bondage addicts might cry, "there's nothing
> > to prevent somebody from creating a DirectionIndicatingThingie directly,
> > bypassing the factory functions. *There's no way to make the constructor
> > private!". *To which the free-willed pythonistas would respond, "If it
> > hurts when you do that, don't do that".

>
> You know a Python programmer's been at your C++ code when it opens:
> #define class struct


Why stop there?

#define private public
 
Reply With Quote
 
Chris Angelico
Guest
Posts: n/a
 
      12-30-2011
On Sat, Dec 31, 2011 at 10:39 AM, Roy Smith <(E-Mail Removed)> wrote:
> In article <(E-Mail Removed)>,
> *Chris Angelico <(E-Mail Removed)> wrote:
>
>> You know a Python programmer's been at your C++ code when it opens:
>> #define class struct

>
> Why stop there?
>
> #define private public


Probably yeah, do both. Anyway, life's so much easier when you don't
have to write trivial getter/setter methods (and then maintain them).
I've never had a situation where I've changed a private member while
keeping the getters and setters unchanged; the ONLY benefit accessor
methods have ever given to me personally has been logging (and
granted, that is hard to do without them - since you can't override
__getitem__ in C++ - but how often do you really need that facility?).

I used to believe in the separation of interface from implementation.
Then I realised that most of the separation was transparent anyway,
and gave up on it. And then realised why the separation is a good idea
after all.

ChrisA
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
argparse -- mutually exclusive sets of arguments? Roy Smith Python 2 11-24-2012 01:07 AM
'SelectedIndex' and 'SelectedValue' attributes are mutually exclusive (part 2) Stimp ASP .Net 5 11-08-2005 04:16 PM
'SelectedIndex' and 'SelectedValue' attributes are mutually exclusive Stimp ASP .Net 2 10-24-2005 01:53 PM
mutually exclusive radio button js ASP .Net 2 05-19-2005 04:27 PM
Mutually exclusive ALuPin VHDL 2 09-07-2004 04:41 PM



Advertisments