__init__ is the initialiser

Rustom Mody rustompmody at gmail.com
Sat Feb 1 06:31:31 CET 2014


On Saturday, February 1, 2014 10:53:08 AM UTC+5:30, Steven D'Aprano wrote:
> On Fri, 31 Jan 2014 22:16:59 -0500, Terry Reedy wrote:

> > Creating a painting on canvas has two similar phases. Prepare a generic
> > blank canvas stretched on a frame and coated with a white undercoat.
> > Paint a particular picture. Would you say that the second step is not
> > creating anything?

> A dubious analogy, since there are artists who would say that attacking 
> the canvas with a knife and setting the remains on fire count as a form 
> of artistic creation :-)

> "Creation" can mean various things in English. One might argue that the 
> only creation was the guy at the factory who made the canvas, and the 
> people who made the paints. After that comes the preparation stage, 
> followed by the splashing-paint-on-canvas stage.

> If you want to use "creating" to refer to the splashing-paint stage, then 
> I think the closest analogy in Python is the stuff which happens *after* 
> __init__ is called. Using a class often means modifying it as you go (in 
> much the same way that using a canvas requires modifying it as you go), 
> and it's never *completely* prepared until just before you stop using it. 
> One adds data, modifies the data, moves data from one attribute to 
> another, sets up temporary data attributes, calls methods which modify 
> the instance, and finally get the final answer you want, at which point 
> your task is done and the instance is thrown away. Think of a dict:

> d = {}  # Dict is constructed.
> for key in data:
>     key = process(key)
>     if condition():
>         d[key] = something(key)

> Is all that work also not part of the object construction process? If we 
> write it like this:

> d = dict(something(key) for key in map(process, data) if condition())

> you'd probably call it the constructor. But the two bits of code do the 
> same thing.

> While we talk about a constructor as if the process of constructing an 
> object was black and white with a clear and obvious dividing line, in 
> practice its often fuzzy, with a lot of grey. (That's one of the 
> objections the functional crowd has with mutable objects.)

> So to answer your question: no, in context of programming, I would *not* 
> call the putting-paint-to-canvas stage of artist painting to be 
> "creation". I would call it *using* the constructed object (the canvas). 
> Whether that *use* of the canvas happens to be *artistic* creation or 
> mere derivative pap is another story :-)


http://en.wikipedia.org/wiki/Four_causes

[Replace cause by create(ion) ]



More information about the Python-list mailing list