> I'm fairly new to python, and trying to get used to the indentation. I
> just encountered my first problem with it. I wrote the following code:
>
> for ord in f_ord:
> if not ordliste.has_key(ord) :
> ordliste[ord] = {}
> for word in e_ord:
> if ordliste[ord].has_key(word) :
> ordliste[ord][word] += 1
> else :
> ordliste[ord][word] = 1
>
> and then later realized I had to put in one more if-test at the
> beginning of the loop. In most languages I've used, this would be simple
> -- I would simply enclose lines 2-8 in curly braces and put the if-test
> in front.
Hi Arild,
Try using functions more. Well-written functions can help to support the
kind of rapid changes that you're making to your program, and to reduce
the nesting that you're seeing.
Concretely, there's a block in the code that updates the dictionary data
structure.
> if not ordliste.has_key(ord) :
> ordliste[ord] = {}
> for word in e_ord:
> if ordliste[ord].has_key(word) :
> ordliste[ord][word] += 1
> else :
> ordliste[ord][word] = 1
We can turn that block into a full-fledged function:
################################################
def update_ordliste(ordliste, ord, words):
if not ordliste.has_key(ord):
ordliste[ord] = {}
for word in words:
if ordliste[ord].has_key(word) :
ordliste[ord][word] += 1
else:
ordliste[ord][word] = 1
################################################
(There is actually a nicer way to write update_ordliste, but I'll leave
that for another time.)
Once we have this, we can revisit the original code, and turn:
> for ord in f_ord:
> if not ordliste.has_key(ord) :
> ordliste[ord] = {}
> for word in e_ord:
> if ordliste[ord].has_key(word) :
> ordliste[ord][word] += 1
> else :
> ordliste[ord][word] = 1
into:
#########################################
for ord in f_ord:
update_ordliste(ordliste, ord, e_ord)
#########################################
This code is in a form that should be easier to change more rapidly, since
the block is itself not too nested or long.
The general idea is that, when we have a for loop on a fairly long and
substantial block, there's often a name we can give to the concept that
it's doing. "update_ordliste" is not such a good, descriptive name,
though: if you can think of a better name, please feel free to change it.
*grin*
> When I try do it in python, however, it seems I have to do the
> indentation all over.
With the refactored code above, we can support this kind of change with
very little work:
#############################################
for ord in f_ord:
if not ord in tegn:
update_ordliste(ordliste, ord, e_ord)
#############################################
> This isn't really a problem in this case, as the expression is quite
> small, and I can quickly check the indentation line by line. But I can't
> begin to imagine what a hassle that would be if my expression was 70
> lines and not 7.
Text editors for Python often support indenting whole blocks. If you're
using Emacs, for example, "C-c >" should indent a block forward. I'm sure
that other Python-aware text editors provide similar tools.
What IDE are you using?
You bring up a good point that it's a hassle to adjust long blocks of
code. One way to attack this problem is to avoid it altogether: it's
often very possible to refactor the code to make code blocks smaller or
simpler.
_______________________________________________
Tutor maillist - Tutor@python.org
http://mail.python.org/mailman/listinfo/tutor
