On 5/15/06, bruno at modulix <[EMAIL PROTECTED]> wrote:
> Alex wrote:
> > Hi, this is my first mail to the list so please correct me if Ive done
> > anything wrong.
> >
> > What Im trying to figure out is a good way to organise my code. One
> > class per .py file is a system I like, keeps stuff apart. If I do
> > that, I usually name the .py file to the same as the class in it.
>
> First point is that Python doesn't force you to put everything in
> classes - if you just need a function, well, make it a function !-)
>
> Also, the common pattern is to put closely related
> classes/functions/constants in a same module, and closely related
> modules in the same package. Since Python uses a "one file == one
> module" scheme, the Javaish "one class per file" idiom leads to overly
> complicated imports. And the most common naming scheme for modules is
> 'alllowercase'.
>
>
>
> > File: Foo.py
> > ***********************
> > class Foo:
> > def __init__(self):
> > pass
> > def bar(self):
> > print 'hello world'
> >
> > ************************
> >
> > Now, in my other module, I want to include this class. I tried these two
> > ways:
> >
> >>>> import Foo
> >>>> Foo.Foo.bar()
> >
> > Traceback (most recent call last):
> > File "<stdin>", line 1, in ?
> > TypeError: unbound method bar() must be called with Foo instance as
> > first argument (got nothing instead)
> >
> > Some unbound method error. Have I missunderstood something
>
> Yes:
> 1/ you usually need to instanciate the class to call an instance method
> 1/ in this case, bar doesn't need to be a method, since it doesn't
> depend on the instance it's called on - a plain old function would be a
> better fit.
>
> > or am I on
> > the right track here?
> >
> > I did this to, almost the same thing:
> >
> >>>> from Foo import Foo
> >>>> Foo.bar()
> >
> > Traceback (most recent call last):
> > File "<stdin>", line 1, in ?
> > TypeError: unbound method bar() must be called with Foo instance as
> > first argument (got nothing instead)
> >
> > One thing that I tried that worked ok was this:
> >
> >>>> import Foo
> >>>> instance=Foo.Foo()
> >>>> instance.bar()
> >
> > hello world
> >
> > But in my opinion, this is very ugly.
>
> Nope, it's just OO at work.
>
> > Especially if the class names
> > are long, like my module/class TileDataBaseManager. But is this the
> > "right" way in python?
>
> If you want to import a class from a module and create an instance of
> that class, yes.
>
> > Another (ugly) way that Ive considered is the following. Break it out
> > of the class,
>
> Which would be a sensible thing to do given the current implementation
> of bar().
>
> > save the functions in a file alone,
>
> Nothing prevent you from putting many functions in a same module, you
> know...
>
> > import the file
>
> s/file/module/
>
> > and
> > treat it like a class:
>
> ???
>
> > File: Foo2.py
> > ***********************
> > def bar(self):
> > print 'hello world'
> >
> > ************************
> >
> >>>> import Foo2
> >>>> Foo2.bar()
> >
> > hello world
>
> You don't "treat it like a class", you're just using the normal
> namespace resolution mechanism. Modules are namespaces, classes are
> namespaces, objects (class instances) are namespaces, and the dot is the
> lookup operator (ie : somenamespacename.somename means 'retrieve what's
> actually bound to name 'somename' in namespace 'somenamespacename').
>
> > Very clean from the outside. I would like something like this. But,
> > here, I loose the __init__ function.
>
> Which in the given implementation is just doing nothing.
>
> Ok, I understand that this is just example code. The rule here is:
> - if you need per-instance state management, use a class (that you of
> course need to instanciate - else you can't have per-instance state !-)
> - if you don't need per-instance state management, use a plain function.
>
> > I have to call it manually that
> > is, which s not good. Also, maybe the biggest drawback, its no longer
> > in a class.
>
> def MyFunc():
> pass
>
> print MyFunc.__class__.__name__
>
> Python function's are instances of the function class.
>
> > Maybe its not that important in python but from what Ive
> > learned (in c++) object orientation is something to strive for.
>
> print "object orientation".find("class")
>
> Being OO doesn't mean using classes. <troll>And FWIW, there quite enough
> procedural Java code around to prove that using classes doesn't mean
> doing OO !-) </troll>
>
> > So, to sum it up, I have one class in one file, both with the same
> > name. How do I store/import/handle it in a nice, clean and python-like
> > manner?
>
> Quit the Javaish "one-class-per-file" idiom, don't bother using classes
> when plain old function will do, and you'll be on track...
>
> FWIW, Python's standard lib is open-source, so why not have a look at
> the source code to see how it is organized ?
>
> HTH
> --
> bruno desthuilliers
> python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
> p in '[EMAIL PROTECTED]'.split('@')])"
> --
> http://mail.python.org/mailman/listinfo/python-list
>
Thanks for taking your time to help me out. :) You have cleared out
many of my doubts. BTW, should I post "thank you" stuff here or does
it just clutter? I tried sending an email to your personal email
listed (the one from which you send that mail to the list), but I got
this error:
PERM_FAILURE: DNS Error: Domain name not found
So I guess the entire list will have to be thanked for the help. :)
--
http://mail.python.org/mailman/listinfo/python-list
