On Saturday, 20 February 2016 09:49:17 UTC+2, Larry Hudson wrote:
> On 02/19/2016 10:14 AM, wrong.addres...@gmail.com wrote:
> [snip]
> >
> > This is precisely reading one character at a time. If not exactly reading
> > one character, it is effectively looking at each character to assemble the
> > number. Not a good sign. I guess there might be libraries which will help
> > read numbers better, but I would expect a good language to be able to
> > handle this basic thing for engineers - to read numbers like Fortran and
> > Basic do.
> >
> > Still, if I have misunderstood something, I will be glad to be corrected. I
> > would generally know that the first three numbers will be floating point,
> > the next will be something and then the next will be something else, etc.
> > Does that help or does one still have to look at each character and
> > determine how to place it in a number?
> >
> > Thanks for your patience. I don't want surprises later on, which is why I
> > am asking very stupid questions.
> >
> It absolutely does NOT require reading a character at a time! You are
> reading the data from a
> text file, which means everything is a string. These strings (or
> sub-strings) can represent
> integers, floats, dates, phone numbers or whatever. Your example data
> implies a free-form
> style, where it is then necessary to determine the data type for each of
> these (sub)strings
> individually. Of course, if your data has a defined fixed format, this is
> simplified -- but
> they are still initially strings that have to be converted. String
> processing in Python is very
> powerful and versatile.
>
> BTW, it does no good to continue to think strictly in BASIC techniques.
> Python is a different
> language with a different approach to attacking problems. If you try to
> write BASIC (or C or
> Java or ...) programs in Python syntax you'll just get bad programs. Forget
> trying to find
> features in Python that are identical to the features of BASIC. Python
> requires a different
> mind-set to use it properly -- just like any other language.
>
> Here is a rather naive somewhat brute-force way to read your example data.
> I'm using a Python
> list here to simulate the file reading. (Actually, using read() instead of
> readline() will also
> give this list.) Python lists are essentially the same as arrays in other
> languages, but much
> more powerful and versatile. Two examples of the differences between arrays
> and lists are: can
> use mixed data types, you are not restricted to all the same data type, and
> the size of lists
> are dynamic -- they grow or shrink as necessary.
>
> Comments start with a #
> Strings in Python can be delimited by single-quotes ('), double-quotes (") or
> triple-quotes ("""
> or '''). Triple-quoted strings can be multi-line text. The triple-quote
> here is used as what
> Python calls a docstring, which it saves internally for documenting your
> program.
>
> <code>
> # Define a function to determine the data type a string represents
> def chktyp(s):
> """Check string s for int, float or string. Returns the data and a type
> code"""
> try:
> return int(s), 'int' # Try to convert to int, return it if
> successful
> except ValueError: # No, it's not an int
> pass # Drop into float test
> try:
> return float(s), 'float' # Try to convert to float, return it if
> successful
> except ValueError: # No, it's not a float
> return s, 'str' # It must be a string
>
> # Here is your (simulated) data as a list of strings
> data = [
> '2 12.657823 0.1823467E-04 114 0',
> '3 4 5 9 11',
> '"Lower"', # Could be left simply as "Lower"
> '278.15']
>
> # Process the data
> for line in data: # For each line of the data
> dat = line.split() # Make a list of the sub-strings in the
> line
> for stng in dat: # For each substring
> dt, tp = chktyp(stng) # Get the data and the type
> print('{} is a {}'.format(dt, tp)) # Print this data
> </code>
>
> Running this example gives this result:
>
> 2 is a int
> 12.657823 is a float
> 1.823467e-05 is a float
> 114 is a int
> 0 is a int
> 3 is a int
> 4 is a int
> 5 is a int
> 9 is a int
> 11 is a int
> "Lower" is a str
> 278.15 is a float
>
> I hope this gives you a slight hint about the Python way of doing things.
> Yes, of course it's
> very different from BASIC, but if you can pick up on the Pythonic way of
> doing things I think
> you might at least find it useful.
>
> -=- Larry -=-
I realise that this file i/o will have to be thought of in a different way if I
start to use Python. This may still be worthwhile inspite of the complexity and
loss in readability of the code.
To give an example of the kind of things I have to read (and I have to read
numbers from several files usually), here is some VB6 code:
Open "N020S.TXT" For Input As #8
Input #8, ND, NIN, NT ' all integers
Text9.Text = ND
Text1 = CStr(NIN)
Text4 = NT
Text12 = ""
For i = 1 To NIN
Input #8, DINCOL(i) ' single precision floating point vector
Text12 = Text12.Text & DINCOL(i) & " "
If Dvarname(1) <> "" Then varname(i) = Dvarname(NLCOL(i)) ' strings
Next i
etc..
The data file (written by another VB6 code) contains in the first few lines:
10 6 1
8.65 0.2192347 3.33E-4 44 0.0051 6
9
1
2 1
3
How complicated could this get in Python? Reading the numbers is one thing, and
then placing the values in text boxes of the GUI. Or can I write my own reading
subroutines which can then be called like
ReadVBstyle 8, ND, NIN, NT
to make the code more readable?
--
https://mail.python.org/mailman/listinfo/python-list
