Path: csiph.com!fu-berlin.de!uni-berlin.de!not-for-mail
From: Dennis Lee Bieber <wlfraed@ix.netcom.com>
Newsgroups: comp.lang.python
Subject: Re: Considering migrating to Python from Visual Basic 6 for engineering applications
Date: Sun, 21 Feb 2016 13:39:51 -0500
Organization: IISS Elusive Unicorn
Lines: 113
Message-ID: <mailman.21.1456079993.20994.python-list@python.org>
References: <mailman.5.1455808876.2289.python-list@python.org> <f136cf1a-b332-485f-889a-ef701ca5993c@googlegroups.com> <mailman.20.1455823868.2289.python-list@python.org> <9e57761f-26e1-41c5-8e71-23800de1fdd3@googlegroups.com> <mailman.48.1455890911.2289.python-list@python.org> <7f9c473e-b0c2-4d77-91d1-d0733c93b12d@googlegroups.com> <pYydnYLkXtvuh1XLnZ2dnUU7-SGdnZ2d@giganews.com> <23d8156f-1808-4395-9c04-27d2984fe67c@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Precedence: list
Xref: csiph.com comp.lang.python:103314

On Sat, 20 Feb 2016 10:38:40 -0800 (PST), wrong.address.1@gmail.com
declaimed the following:

>
>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
>
	Are characters rationed on this job? Names that mean something?

	I note that you read a text file -- letting the runtime convert "words"
into integers (presume they've been declared as such somewhere), and then
immediately convert one of them back into text. Granted, it IS used as an
integer later but one gets the impression above that all three "integers"
just get converted back to text.
    
>    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
>
	Ignoring that "Dvarname" is undefined, it looks like you are reading --
one at a time (ie; by "words") values that are being converted to floating
point format, only to immediately have the runtime convert them back to
text format so you can string concatenate them with a blank separator.

	You also seem to be relying upon BASIC's tendency to ignore end-of-line
marks (after reading the three integers, the next read ignores the line
feed and reads the first float) AND its tendency to leave partial lines in
the stream for the next read request.

-=-=-=-=-
f8 = open("N020S.TXT", "r")

(ND, NIN, NT) = [int(x) for x in f8.readline().strip().split()]
#only works if there are three valid integers on the line

#skipping the three assignments as i suspect you are referencing
#GUI form objects and that depends then on the framework in use

DINCOL = [float(x) for x in f8.readline().strip().split()]
if len(DINCOL) != NIN:
	#expected NIN values, but got a different number of values

Text12 = " ".join(str(x) for x in DINCOL)

#assumption: all NIN-count floats are on one line; if they can spread
#across multiple lines, the I/O will need to get fancier
#upto, yes, reading large buffers, stripping new-lines, and doing
#your own "word" parsing -- though .split() does take a
#parameter on how many splits to make, so 
#	rest = " ".join(f8.read().split("\n"))
#		read entire file, split on lines, rejoin with space
#	while rest:
#		fld, rest = rest.split(None, 1)
#		do something with fld	
-=-=-=-=-

	For "ignore new lines" type I/O, you could maybe make a generator
function to handle the word fetching... Something like (I've not written a
generator before)...

def words(fname):
	fin = open(fname, "r")
	contents = " ".join(fin.read().split("\n"))
	fin.close
	while contents:
		aword, contents = contents.split(None, 1)
		yield aword

reader = words("N020S.TXT")
ND = int(reader.next())
NIN = int(reader.next())
NT = int(reader.next())

DINCOL = []
for _ in xrange(NIN):
	DINCOL.append(float(reader.next()))
text12 = " ".join(str(x) for x in DINCOL)


	If the input files are really huge, you would have to modify the
generator to read in chunks, and when one chunk is nearly consumed,  read
the next chunk and concatenate it... Could use lines for the chunks

def words(fname):
	fin = open(fname, "r")
	for line in fin:
		contents = line.strip()
		while contents:	#warning: will skip over blank lines
			aword, contents = contents.split(None, 1)
			yield aword
	fin.close()

	Of course, since the file read is all done inside the generator, if you
suddenly need a multiple word string, you will have problems, since no
indicator of end-of-line is seen outside this generator.

	Expanding up to the next level, you could create a class, with methods
to handle explicit data types, cognizance of the EOL, allowing blank lines
if, say, the input request is for a string, etc.

-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
    wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/