Extracting values from text file

P

Preben Randhol

Hi

A short newbie question. I would like to extract some values from a
given text file directly into python variables. Can this be done simply
by either standard library or other libraries? Some pointers where to
get started would be much appreciated.

An example text file:
-----------
Some text that can span some lines.

Apples 34
56 Ducks

Some more text.

0.5 g butter

-----------------
What I first though was if there was possible to make a filter such as:

Apples (apples)
(ducks) Ducks
(butter) g butter

The data can be put in a hash table.

Or maybe there are better ways? I generally want something that is
flexible so one can easily make a filter settings if the text file
format changes.

Thanks in advance
 
M

MTD

list.txt is a file that contains the following lines:
Apples 34
Bananas 10
Oranges 56
file = open("list.txt","r")
mystring = file.read()
mystring 'Apples 34 \nBananas 10\nOranges 56 '
mylist = mystring.split('\n')
mylist ['Apples 34 ', 'Bananas 10', 'Oranges 56 ']
mydict = {}
for el in mylist:
.... l = el.split()
.... mydict[l[0]] = l[1]
....
mydict {'Apples': '34', 'Oranges': '56', 'Bananas': '10'}
mydict["Apples"] '34'
mydict["Oranges"]
'56'
 
B

bearophileHUGS

First try, probably there are better ways to do it, and it's far from
resilient, it breaks in lot of different ways (example: more than one
number in one line, number with text on both sides of the line, etc.)
I have divided the data munging in many lines so I can see what's
happening, and you can fix/modify the code quikly.

Bye,
bearophile


data1 = """
Some text that can span some lines.
More text
Apples 34
56 Ducks

Some more text.

0.5 g butter
"""

import re
# Separate lines in a list
data2 = data1.split("\n")
print data2, "\n"

# clear lines from trailing and leading spaces, newlines, etc.
data3 = map(str.strip, data2)
print data3, "\n"

# remove blank lines after the stripping
data4 = filter(None, data3)
print data4, "\n"

# create a list of (lines, numbers) of only the lines with a number
inside
patt1 = re.compile("\d+\.?\d*") # No scientific notation
data5 = [(line, n) for line in data4 for n in patt1.findall(line)]
print data5, "\n"

# remove the number from the lines, and strip such lines
data6 = [(line.replace(num, "").strip(), num) for line, num in data5]
print data6, "\n"

def nconv(num):
"To convert a number to an int, and if not possible to a float"
try:
result = int(num)
except ValueError:
result = float(num)
return result

# convert the number strings into ints or floats
data7 = [(line, nconv(num)) for line, num in data6]
print data7, "\n"

# build the final dict of (line: number)
result = dict(data7)
print result, "\n"
 
M

MTD

P.S.
list.txt is a file that contains the following lines:
Apples 34
Bananas 10
Oranges 56
file = open("list.txt","r")
mystring = file.read()
mystring 'Apples 34 \nBananas 10\nOranges 56 '
mylist = mystring.split('\n')
mylist ['Apples 34 ', 'Bananas 10', 'Oranges 56 ']
mydict = {}
for el in mylist:
... l = el.split()
... mydict[l[0]] = l[1]
...
mydict {'Apples': '34', 'Oranges': '56', 'Bananas': '10'}
mydict["Apples"] '34'
mydict["Oranges"]
'56'
 
A

Ant

What I first though was if there was possible to make a filter such as:
Apples (apples)
(ducks) Ducks
(butter) g butter

Try something like:

import re

text = """> Some text that can span some lines.

Apples 34
56 Ducks

Some more text.

"""

filters = {"apples": re.compile(r"Apples\s+(\d+)"),
"ducks": re.compile(r"(\d+)\s+Ducks"),
"butter": re.compile(r"([0-9.]+)\s+g\s+butter")}

out = []

for k,v in filters.iteritems():
matches = v.findall(text)
for match in matches:
out.append((k, match))

print out
 
P

Paul McGuire

Preben Randhol said:
What I first though was if there was possible to make a filter such as:

Apples (apples)
(ducks) Ducks
(butter) g butter

The data can be put in a hash table.

Or maybe there are better ways? I generally want something that is
flexible so one can easily make a filter settings if the text file
format changes.

Here is a simple filter builder using pyparsing. Pyparsing runs in two
passes: first, to parse your filter patterns; then to use the generated
grammar to parse some incoming source string. Pyparsing comes with a
similar EBNF compiler, written by Seo Sanghyeon. I'm sorry this is not
really a newbie example, but it does allow you to easily construct simple
filters, and the implementation will give you something to chew on... :)

Pyparsing wont be as fast as re's, but I cobbled this filter compiler
together in about 3/4 of an hour, and may serve as a decent prototype for a
more full-featured package.

-- Paul
Pyparsing's home Wiki is at http://pyparsing.wikispaces.com.


-----------------
from pyparsing import *

sourceText = """
Apples 34
56 Ducks

Some more text.

0.5 g butter
"""

patterns = """\
Apples (apples)
(ducks:%) Ducks
(butter:#) g butter"""

def compilePatternList(patternList, openTagChar="(", closeTagChar=")",
greedy=True):
def compileType(s,l,t):
return {
"%" : Word(nums+"-",nums).setName("integer"),
"#" :
Combine(Optional("-")+Word(nums)+"."+Optional(Word(nums))).setName("float"),
"$" : Word(alphas).setName("alphabetic word"),
"*" : Word(printables).setName("char-group")
}[t[0]]
backgroundWord = Word(alphanums).setParseAction(lambda
s,l,t:Literal(t[0]))
matchType = Optional(Suppress(":") + oneOf("% # $
*"),default="*").setParseAction(compileType)
matchPattern = Combine(openTagChar +
Word(alphas,alphanums).setResultsName("nam") +
matchType.setResultsName("typ") +
closeTagChar)
matchPattern.setParseAction(lambda s,l,t:
(t.typ).setResultsName(t.nam) )
patternGrammar = OneOrMore( backgroundWord |
matchPattern ).setParseAction(lambda s,l,t:And([expr for expr in t]))
patterns = []
for p in patternList:
print p,
pattExpr = patternGrammar.parseString(p)[0]
print pattExpr
patterns.append(pattExpr)
altern = (greedy and Or or MatchFirst)
return altern( patterns )

grammar = compilePatternList( patterns.split("\n") )
print grammar

allResults = ParseResults([])
for t,s,e in grammar.scanString(sourceText):
print t
allResults += t
print

print allResults.keys()
for k in allResults.keys():
print k,allResults[k]

-----------------
Prints:
Apples (apples) {"Apples" char-group}
(ducks:%) Ducks {integer "Ducks"}
(butter:#) g butter {float "g" "butter"}
{{"Apples" char-group} ^ {integer "Ducks"} ^ {float "g" "butter"}}
['Apples', '34']
['56', 'Ducks']
['0.5', 'g', 'butter']

['butter', 'apples', 'ducks']
butter 0.5
apples 34
ducks 56
 
M

Mirco Wahab

Thus spoke Preben Randhol (on 2006-06-16 10:36):
A short newbie question. I would like to extract some values from a
given text file directly into python variables. Can this be done simply
by either standard library or other libraries? Some pointers where to
get started would be much appreciated.

I used your example just to try that in python
(i have to improve my python skills), but waved
the white flag after realizing that there's no
easy string/var-into-string interpolation.

I tried to build some parser table
which will then translate hings into a dictionary

v_apples = '\b\S+';
v_ducks = '\b\S+';
v_butter = '\b\S+';

rg_ar = [ "Apples (v_apples)" ,
"(v_ducks) Ducks" ,
"(v_butter) butter" ]

the above interpolation won't work, so I gave up.

To give an idea what I intended, I'll add
the short perl script which I took as a
blue print for my python effort (your
example text may be used):


my @filter = ( # define filter table
"Apples (apples)",
"(ducks) Ducks",
"(butter) g butter",
);
my %varname = (); # variable names will be found in text
my $example = do { local$/; <DATA> }; # read the appended example text
# change <DATA> to <> for std input

for (@filter) { # iterate over filter rules
if( s/\((.+)\)/\\b(\\S+?)\\b/ ) { # pull out variable names ($1)
my $v = $1; # and replace them by '\b(\S)\b'
$varname{$v} = $1 if $example =~ /$_/; # pull values from
} # text to varnames
}


your text prints then:
(for (keys %varname) { print "$_\t=>\t$varname{$_}\n"; })

apples => 34
butter => 0.5
ducks => 56

with variable names taken from your text:

__DATA__
An example text file:
-----------
Some text that can span some lines.
Apples 34
56 Ducks
Some more text.
0.5 g butter
-----------------

Above will do the job in perl, but I have no idea
how to translate this to python, especially, as I
said, the string-to-string interpolation thing for
the build-up regex.

Maybe some experts may help out?

Regards

Mirco
 
M

Mirco Wahab

Thus spoke Mirco Wahab (on 2006-06-16 21:21):
I used your example just to try that in python
(i have to improve my python skills), but waved
the white flag after realizing that there's no
easy string/var-into-string interpolation.

I did another try on it, using all my Python
resources available (and several cups of coffee)
;-)

This scans your text for rules provided
and extracts values and variable names
and prints them at the end.

I had some issues with python then:
- no comment # after line continuation \\
- regular expressions **** **** (as I said before)

==>

DATA = '''
An example text file:
-----------
Some text that can span some lines.
Apples 34
56 Ducks
Some more text.
0.5 g butter
-----------------''' # data must show up before usage

filter = [ # define filter table
'Apples (apples)',
'(ducks) Ducks',
'(butter) g butter',
]
varname = {} # variable names to be found in filter
varscanner = r'\\b(\S+?)\\b' # expression used to extract values
example = DATA # read the appended example text,

import re
for rule in filter: # iterate over filter rules, rules will be in 'rule'
k = re.search(r'\((.+)\)', rule) # pull out variable names ->k
if k.group(1): # pull their values from text
varname[k.group(1)] = \
re.search( re.sub(r'\((.+)\)', varscanner, rule), \
example ).group(1) # use regex in modified 'rule'

for key, val in varname.items(): print key, "\t= ", val # print what's found

<==

I think, the source is quite comprehensible
in Python, as is in Perl - if there weren't
'regex issues' ;-)

Maybe some folks could have a look at it
and convert it to contemporary Python

Below ist the Perl program that was modified
to correspond roughly 1:1 to the Python
source above.

Both will print:
butter = 0.5
apples = 34
ducks = 56

Regards & thanks in advance

Mirco

==>

#/usr/bin/perl
use strict;
use warnings;

my @filter = ( # define filter table
'Apples (apples)',
'(ducks) Ducks',
'(butter) g butter',
);

my ($v, %varname) = ( '', () ); # variable names to be found in filter
my $varscanner = qr{\b(\S+?)\b}; # expression used to extract values
my $example = do { local$/; <DATA> }; # read the appended example text,
# change <DATA> to <> for std input

for (@filter) { # iterate over filter rules, rule line will be implicit ($_)
$v = $1 if s/\((.+)\)/$varscanner/; # pull out variable names ->$1
$varname{$v} = $1 if $example =~ /$_/; # pull their values from text
} # by using modified regex rule $_

print map { "$_\t= $varname{$_}\n"; } keys %varname; # print what's found

__DATA__
An example text file:
-----------
Some text that can span some lines.
Apples 34
56 Ducks
Some more text.
0.5 g butter
 
P

Preben Randhol

Thus spoke Mirco Wahab (on 2006-06-16 21:21):


I did another try on it, using all my Python
resources available (and several cups of coffee)
;-)

This scans your text for rules provided
and extracts values and variable names
and prints them at the end.

I had some issues with python then:
- no comment # after line continuation \\
- regular expressions **** **** (as I said before)

Thanks! The code is a very good starting point for me! I already
managed to change it and I see I need to make it a bit more robust.

And the next challange I have is to extract n values from one line. I
mean:

23 Apples 234 Lemons 4 Eggs

for example.

Again thanks. And thanks to all others for the suggestions. I have
looked at all and learned a lot of python. I probably will end up with
a mixture of several approaches.

Preben
 
M

Mirco Wahab

Thus spoke Preben Randhol (on 2006-06-17 23:25):
The code is a very good starting point for me! I already
managed to change it and I see I need to make it a bit more robust.

I think, the only thing you have to look at - is
the congruence of the regex-based filter rule and the text.

suppose you have a text:

Apples 34
23 Apples, 234 Lemons 4 Eggs

(note the comma!)
and some rules:
...
'(apples) Apples',
'Apples (apples)',
...

the former program would handle that alright
after changing the variable assignment from:

if k.group(1): varname[k.group(1)] = <value>

to
if k.group(1): varname[k.group(1)] += <value> (note the +=)

and the result would be: 'apples = 57'. It would
add up all values corresponding to one variable.

aehhm ... would be so in Perl, but Python throws
another stone at you:

- you have to explicitly instantiate a dictionary value
(with 0) if/before you want in-place add to it (why is that?)

- you can't have a return value from a regex object
auto-converted to a number even if it _is_ a number
and smells like a number (???)

with these two nasty surprises, out extractor-loop
looks like this:

for rule in filter:
k = re.search(r'\((.+)\)', rule) # pull out variable names ->k
if k.group(1): # pull their values from text
if not varname.has_key(k.group(1)): varname[k.group(1)] = 0;
varname[k.group(1)] += float( \
re.search( re.sub(r'\((.+)\)', varscanner, rule), \
example ).group(1) ) # use regex in modified 'rule'


whereas the in Perl-loop, only + to += would change

for (@filter) {
$v = $1 if s/\((.+)\)/$varscanner/; # pull out variable names ->$1
$varname{$v} += $1 if $example =~ /$_/; # pull their values from text
}


I'll add the complete python program which handles
all cases you mentioned.

Regards

Mirco

==>

DATA = '''
An example text file:
-----------
Some text that can span some lines.
Apples 34
23 Apples, 234 Lemons 4 Eggs
56 Ducks

Some more text.
0.5 g butter
----------------------------------''' # data must show up before usage

filter = [ # define filter table
'(apples) Apples',
'Apples (apples)',
'(ducks) Ducks',
'(lemons) Lemons',
'(eggs) Eggs',
'(butter) g butter',
]
varname = {} # variable names to be found in filter
varscanner = r'\\b(\S+?)\\b' # expression used to extract values
example = DATA # read the appended example text,

import re
for rule in filter: # iterate over filter rules, rules will be in 'rule'
k = re.search(r'\((.+)\)', rule) # pull out variable names ->k
if k.group(1): # pull their values from text
if not varname.has_key(k.group(1)): varname[k.group(1)] = 0;
varname[k.group(1)] += float( \
re.search( re.sub(r'\((.+)\)', varscanner, rule), \
example ).group(1) ) # use regex in modified 'rule'

for key, val in varname.items(): print key, "\t= ", val # print what's found

<==
 
D

Dennis Lee Bieber

- you have to explicitly instantiate a dictionary value
(with 0) if/before you want in-place add to it (why is that?)
Uhm... Not quite...
aDict = {}
newKey = "My, Myself, and I"
aDict[newKey] = aDict.get(newKey, 0) + 1
aDict {'My, Myself, and I': 1}
aDict[newKey] = aDict.get(newKey, 0) + 2
aDict {'My, Myself, and I': 3}

dict.get(key, default)

returns the value associated by key, IFF key exists in the
dictionary, otherwise it returns the value defined for default.
--
Wulfraed Dennis Lee Bieber KD6MOG
(e-mail address removed) (e-mail address removed)
HTTP://wlfraed.home.netcom.com/
(Bestiaria Support Staff: (e-mail address removed))
HTTP://www.bestiaria.com/
 
M

Mirco Wahab

Thus spoke Dennis Lee Bieber (on 2006-06-18 06:29):
Uhm... Not quite...
...
dict.get(key, default)

returns the value associated by key, IFF key exists in the
dictionary, otherwise it returns the value defined for default.

Thanks, Dennis, for your help on this part I bragged about.

Now the extractor loop, according to your suggestion, can
be written shorter:

for rule in filter:
k = re.search(r'\((.+)\)', rule) # pull out variable names ->k
if k.group(1): # pull their values from text
varname[k.group(1)] = varname.get(k.group(1), 0) + float( \
re.search( re.sub(r'\((.+)\)', varscanner, rule), \
example ).group(1) ) # use regex in modified 'rule'

For the other issue I stumbled upon:

- no DWIM-ism (do what I mean) on 'value' addition

a = '1'
a += '1.1111'
print a

will print
11.1111

and not 2.1111, as in 'dynamically typed', 'operator based' languages.
(maybe the lack of a simple string-concatenation operator is the reason?)

whereas:

a = '1'
a += 1.1111
print a

will fail magnificently. These thing would come handy
when working with text/table driven computations (as above)

How could one approach these things without needing to
get too explicitly about 'type conversions'
(Python is supposed to be 'dynamically typed'?).


Regards & thanks

Mirco
 
P

Preben Randhol

For the other issue I stumbled upon:

- no DWIM-ism (do what I mean) on 'value' addition

a = '1'
a += '1.1111'
print a

will print
11.1111

and not 2.1111, as in 'dynamically typed', 'operator based' languages.
(maybe the lack of a simple string-concatenation operator is the
reason?)

But you don't add two values. you add two strings. If you want numbers
you must convert the strings.
How could one approach these things without needing to
get too explicitly about 'type conversions'
(Python is supposed to be 'dynamically typed'?).

Yes, but how can Python know that you want to add to numbers and not
concate two strings?
 
M

Mirco Wahab

Thus spoke Preben Randhol (on 2006-06-18 13:34):
But you don't add two values. you add two strings. If you
want numbers you must convert the strings.

Why? At least - if its obvious, what I want.
Yes, but how can Python know that you want to add to
numbers and not concate two strings?

The programming language should make some
rules regarding its operators and their
meaning.

Compare:

# want to add NUMBERS ('1' + '1.1111'/1.1111 = 2.1111)
#
# in python in perl
#
a1 = int( '1' ) $a1 = '1';
a1 += float( '1.1111' ) $a1 += '1.1111';
print a1 print $a1;

a2 = int( '1' ) $a2 = '1';
a2 += 1.1111 $a2 += 1.1111;
print a2 print $a2;

# want to add strings ('1' . '1.1111'/1.1111 = 11.1111)
#
b1 = '1' $b1 = '1';
b1 += '1.1111'; $b1 .= '1.1111';
print b1 print $b1;

b2 = '1' $b2 = '1';
b2 += str( 1.1111 ) $b2 .= 1.1111;
print b2 print $b2;


You see the picture? Pythons designer made the
same mistake as the Java/Javascript designer -
they use the _same_ operator (+) for number _addition_
and string _concatenation_, which is, imho, cumbersome.

If you have an operator with meaning "add numbers" (+)
and one for "add strings" (.), the language could then
do the obvious for you.

Why would one go from C/C++ to "dynamical typed"
things, if he has to be so explicit on easy
things?

Of course, you will get along with it, you
'learn' the corresponding 'python-phrases'
that do specific things, you get used to it.
But if you come, like me, from elsewhere,
there is sometimes something to rant on ;-)

I really try to get into it (Python), but
I'm, in such cases, more or less shocked -
and try express that , but I'm not interested
in 'language supremacy' discussions and the like.

BTW.: what exactly did you try to solve?
What would be a 'complete example' where
the parser has to chew on?

Regards

Mirco
 
M

Marc 'BlackJack' Rintsch

You see the picture? Pythons designer made the
same mistake as the Java/Javascript designer -
they use the _same_ operator (+) for number _addition_
and string _concatenation_, which is, imho, cumbersome.

And ``+`` means also list/tuple concatenation and really anything for user
defined types.
If you have an operator with meaning "add numbers" (+)
and one for "add strings" (.), the language could then
do the obvious for you.

The dot also has already a meaning, it's the attribute lookup operator.
Why would one go from C/C++ to "dynamical typed"
things, if he has to be so explicit on easy
things?

Strings that act sometimes as strings and sometimes as numbers when used
with ``+`` are quite confusing. Two relevant lines from the Zen of Python:

Explicit is better than implicit.
In the face of ambiguity, refuse the temptation to guess.

And don't mix up weakly and dynamically typed. Python is dynamically and
strictly typed.

Ciao,
Marc 'BlackJack' Rintsch
 
M

Mirco Wahab

Thus spoke Marc 'BlackJack' Rintsch (on 2006-06-18 18:54):
And ``+`` means also list/tuple concatenation and really anything for user
defined types.


The dot also has already a meaning, it's the attribute lookup operator.

Yes, that may be the real reason?
Strings that act sometimes as strings and sometimes as numbers when used
with ``+`` are quite confusing.

No, thats not what I tried to say, it's rather:

/things/ act _always_ as strings and _always_ as
numbers _when used_ as a 'string' or as a 'number'.

I don't consider that one 'confusing'.
Two relevant lines from the Zen of Python:
Explicit is better than implicit.
In the face of ambiguity, refuse the temptation to guess.

This is, iirc, /exactly/ the reason why in (e.g.) Perl
they put sigils ($%@) in front of the variables. So all
gets explicit - there's no more ambiguity ...
And don't mix up weakly and dynamically typed.
Python is dynamically and strictly typed.

OK, right. I didn't separate 'strict' from
'weak' regarding data types.

I think I got used too much to these
nice 'backhand conversions'. I'm sure
I wouldn't have blinked once if I had
gone directly from C++ (or Java) to Python,
but now I have still the Perl disease in
my bones ;-)

Regards

Mirco
 
P

Preben Randhol

Thus spoke Preben Randhol (on 2006-06-18 13:34):

Why? At least - if its obvious, what I want.

If I say: I want something to eat.

Can you know if I want a dessert or a dinner ? ;-)

My point is that you don't specify. In your case you show that pyhton
is polymorphic, and that can have side-effects... Since in Python
you cannot define what type a function should accept you can throw
anything to it and it will happily much at it as best it can.

Computers are dumb and it is better that one give them enough
instructions than to let them second guess you IMHO....

My other language of choice is Ada. Ada is quite the opposite of
Python in being a very strictly typed language. It takes some getting
used to Python for me ;-) In my opinion Ada95 & Ada2005 got strict
typing correct, while Java only partially is strictly typed. C/C++ is
not. Anyway Ada and Python has different targets so I can happily play
with both static and dynamic typing.

I can recommend Ada as it will teach you to a very good programming
style that can be used when using other language.
 
D

Dennis Lee Bieber

(Python is supposed to be 'dynamically typed'?).
Which, in Python, means that the /names/ can be attached to
/objects/ of any type... But an object (string, integer, float, class
instance) is strongly typed, and always is that type.

a = 1.23
a = "3.21"
a = open("some.file", "r")

"a" is attached to a float in the first, and then attached to a string
in the second -- and to an open file stream in the third. But nothing in
Python will implicitly turn that string or file into a float.

Maybe you'd be happier with the behavior of REXX?

C:\Documents and Settings\Dennis Lee Bieber>rexx
a = "3.21"
b = 1.23
say a + b
^Z
4.44

C:\Documents and Settings\Dennis Lee Bieber>

REXX only has "one" type -- string... but attempts to convert
strings at runtime to numeric types if the operator involved wants
numeric data.

C:\Documents and Settings\Dennis Lee Bieber>rexx
a = "3.1a"
b = 1.23
say a + b
^Z
3 +++ say a + b
Error 41 running "<stdin>", line 3: Bad arithmetic conversion
--
Wulfraed Dennis Lee Bieber KD6MOG
(e-mail address removed) (e-mail address removed)
HTTP://wlfraed.home.netcom.com/
(Bestiaria Support Staff: (e-mail address removed))
HTTP://www.bestiaria.com/
 
D

Dennis Lee Bieber

OK, right. I didn't separate 'strict' from
'weak' regarding data types.
One thing to consider... Python is different from practically all
other languages in how it handles "variables".

In other languages, "variables" are "boxes" (memory addresses) and
an assignment operation puts a copy of the right hand side INTO the box.
In a strong/static typed language, each box has a "shape" that only
holds one type of data. In a dynamic language, the boxes can change to
hold any type of data; and in a weak language the data essentially has
NO type -- the type is determined by the operator used on it.

Python's "variables" are "names on Post-it Notes" that do not have a
fixed box (address). An assignment operation works by finding whatever
box (memory) currently holds the value of a right hand side, and rather
than copying that to a new box, sticks the Post-it Note onto the
existing box. One thing this means is that a single box (Python object)
can have many Post-it Notes (names) stuck to it.

a = 1.23 finds/creates a FLOAT object in memory, then sticks
"a" to the outside of that object.

a = "3.23" finds/creates a STRING object in memory, finds the
"a" that is stuck to 1.23, and MOVES the "a" to stick to the string
object. If 1.23 now has no other names stuck to it, it is marked for
deletion.

In both cases, the OBJECT the name "a" is stuck on has a fixed type,
and the type can not change.
I think I got used too much to these
nice 'backhand conversions'. I'm sure
I wouldn't have blinked once if I had
gone directly from C++ (or Java) to Python,
but now I have still the Perl disease in
my bones ;-)

The only cure for that is complete and painful bone marrow
transplant <G> As a start, after six months of no PERL go back and try
reading some of your code.
--
Wulfraed Dennis Lee Bieber KD6MOG
(e-mail address removed) (e-mail address removed)
HTTP://wlfraed.home.netcom.com/
(Bestiaria Support Staff: (e-mail address removed))
HTTP://www.bestiaria.com/
 
M

Mirco Wahab

Thus spoke Dennis Lee Bieber (on 2006-06-18 22:37):
The only cure for that is complete and painful bone marrow
transplant <G> As a start, after six months of no PERL go back and try
reading some of your code.

Uhhh, this is like giving the
mounted knight a longbow and
push him onto the battlefield
of Agincourt ;-)

Regards

Mirco
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,483
Members
44,902
Latest member
Elena68X5

Latest Threads

Top