do design patterns still apply with Python?

[John Salerno]

Since Python does so many things different, especially compared to
compiled and statically typed languages, do most of the basic design
patterns still apply when writing Python code? If I were to read a
design pattern book (such as Head First Design Patterns), could I apply
their Java examples to Python easily enough, or does Python require a
different perspective when applying patterns?

[shandy.b]

Hi John.

Design patterns aren't tied to any specific implementation so they
should apply to any language. You might find that they can even apply
to solution domains outside of computer science.

Implementation details will usually differ between languages. But the
implementation can also be different using the same language. For
example, you can use Java to implement the Model View Controller design
pattern when writing a web site or when writing a database engine --
the implementation will be very different, but both will be MVC.

In python, you might find it more natural to do design patterns in a
completely different way than they're implemented in Java. For
example, I've heard of using the Singleton pattern in python by just
implementing it as a module, no classes necessary.

sjbrown

[John Salerno]

sh******@gmail. com wrote:

In python, you might find it more natural to do design patterns in a
completely different way than they're implemented in Java. For
example, I've heard of using the Singleton pattern in python by just
implementing it as a module, no classes necessary.

Yeah, that's what I was wondering. I wonder if, after reading a DP book,
I might have to 'unlearn' some things when applying them to Python. But
I suppose I should just do it first and then try to implement them
myself. OOP is just so mind-bending for me that I've kind of put off
patterns right now until I get more comfortable with it. :)

[Grant Edwards]

On 2006-03-02, John Salerno <jo******@NOSPA Mgmail.com> wrote:

Since Python does so many things different, especially compared to
compiled and statically typed languages, do most of the basic design
patterns still apply when writing Python code?

Definitely. Especially plaid, paisley, and a nice medium
houndstooth check. But please, not all at the same time.

--
Grant Edwards grante Yow! Maybe we could paint
at GOLDIE HAWN a rich PRUSSIAN
visi.com BLUE --

[Roy Smith]

In article <8S************ ******@news.tuf ts.edu>,
John Salerno <jo******@NOSPA Mgmail.com> wrote:

Since Python does so many things different, especially compared to
compiled and statically typed languages, do most of the basic design
patterns still apply when writing Python code? If I were to read a
design pattern book (such as Head First Design Patterns), could I apply
their Java examples to Python easily enough, or does Python require a
different perspective when applying patterns?

Many of the classic design patterns apply just fine to Python, at least in
the high-level view. On the other hand, much (most?) of what's in the
classic design pattern books is so tied up with ways around C++/Java type
bondage, it's difficult to see the forest for the trees.

For example, take the most classic of all patterns, Singleton. A typical
C++ Singleton treatment will be all about making constructors private and
shit like that. None of that carries over to Python. What I would do in
Python is have a module-level factory function which caches a single
instance of the class to return to the 2nd and subsequent caller and not
get my panties in a twist over the fact that some clever programmer could
find away around my code and force creation of a second instance.

The basic concepts in the pattern books are worth knowing. You just have
to be able to tease apart the concepts from the language-specific cruft
that so often obfuscates the descriptions.

[ajones]

John Salerno wrote:

Yeah, that's what I was wondering. I wonder if, after reading a DP book,
I might have to 'unlearn' some things when applying them to Python.
I would say adjust instead of unlearn. This is probably true to a
lesser or greater extent of any language for which your DP book was not
written.
But I suppose I should just do it first and then try to implement them
myself. OOP is just so mind-bending for me that I've kind of put off
patterns right now until I get more comfortable with it. :)

I would suggest getting a good grasp on OOP before you get into design
patterns. When most people start with any new concept they tend to try
and see everything in terms of their new toy, so sticking to one or two
new concepts at a time will make things a little easier.

Design patterns are kind of like sarcasm: hard to use well, not always
appropriate, and disgustingly bad when applied to problems they are not
meant to solve. You will do just fine without them until OOP is at
least familiar to you, and by that time you should be a little better
able to use them appropriately.

[Terry Hancock]

On Thu, 02 Mar 2006 16:38:44 -0500
Roy Smith <ro*@panix.co m> wrote:

In article <8S************ ******@news.tuf ts.edu>,
John Salerno <jo******@NOSPA Mgmail.com> wrote:

Since Python does so many things different, especially
compared to compiled and statically typed languages, do
most of the basic design patterns still apply when
writing Python code? If I were to read a design pattern
book (such as Head First Design Patterns), could I apply
their Java examples to Python easily enough, or does
Python require a different perspective when applying
patterns?

[...]
The basic concepts in the pattern books are worth knowing.
You just have
to be able to tease apart the concepts from the
language-specific cruft that so often obfuscates the
descriptions.

This sounds like an article crying out to be written,
"(Learning) Design Patterns with Python".

Has it been written already?

Cheers,
Terry

--
Terry Hancock (ha*****@Anansi Spaceworks.com)
Anansi Spaceworks http://www.AnansiSpaceworks.com

[Paul Rubin]

John Salerno <jo******@NOSPA Mgmail.com> writes:

Since Python does so many things different, especially compared to
compiled and statically typed languages, do most of the basic design
patterns still apply when writing Python code? If I were to read a
design pattern book (such as Head First Design Patterns), could I
apply their Java examples to Python easily enough, or does Python
require a different perspective when applying patterns?

I'd say the relative importance of particular patterns depends on
whether the problems it solves are easier or harder in the language
you're using. Many things that are difficult in Java are easy in
Python, so the patterns in the book aren't terribly relevant.
Somewhat less often, something is easy in Java and difficult in
Python. When that happens, you may need approaches that aren't in the
book. Finally, you have to think of all of these books as different
approaches of explaining elephants to blind men. There's a lot of
murkiness in programming and design patterns are yet another way to
help guide people through it. But the more programming you do, the
better your own internal maps and instincts become, and the less you
need a guidebook that doesn't always correspond to the actual
landscape you're operating in. So consider the books to contain
helpful guidelines but don't feel afraid to trust your own instincts
over them, especially after those instincts become better developed.

[Roy Smith]

In article <7x************ @ruckus.brouhah a.com>,
Paul Rubin <http://ph****@NOSPAM.i nvalid> wrote:

Somewhat less often, something is easy in Java and difficult in
Python.

Example?

[Paul Rubin]

Roy Smith <ro*@panix.co m> writes:

Somewhat less often, something is easy in Java and difficult in
Python.

Example?

Sandboxed code is a real obvious one.