Reading the data from a text file - character by character

Lesson Details:
June 29, 2020

I: Introduction

1.1: Python is a programming language, created by a man named Guido Van Rossum in 1991, if I remember it well. It has been developed from 1990. There are many languages that have been developed from python, such as Java and C ++. In this article I will describe the main features of the language.

1.2: I will tell how to write basic programs in Python and how to modify them for use.

1.3: The first thing you need to know is how python code looks like. There is a certain syntax for writing it.

II: Body

2: The first thing we will do is to learn how to write and read data from a text file, character by character. Text files are called “text files” because they contain only text. They do not contain any other information. The first thing we must do is to use a function called “open” that allows us to open a text file for reading or writing. We will then use another function called “readline” that reads one line at a time and returns it as a string. If we want to read more than one line we need to specify the number of lines we want to read, and we can use another function called “next” that will read the next line and return it as a string, until there are no more lines to read. We can see example of this in the program below:

The first argument of the “readline” function is the file that we want to read from.

The second argument of the “readline” function is the number of characters to be read at once. This is optional, so can be left blank. The default value is -1, which means all the way to the end of the file.

The third argument of the “readline” function is also optional. It specifies whether or not the newline character should be present in the returned string. If an empty string is specified, then newlines are not included in the returned string, otherwise they are included. An empty string is specified with two quotation marks, one before the return type and one at the end of the function call after all arguments have been specified. Thus, when an empty string is used, this is written as an exact pair of quotation marks (”). Otherwise, this is written as an inexact pair of quotation marks (”).

The fourth argument is also optional, but it is mainly used when working with large amounts of data. It specifies how many bytes at most should be read at once. If this is left blank, then it defaults to 1 million bytes. Thus, by default, it will try to read up to 1 MB of data at once. If less than 1 MB remains in the file, then it may not read every byte in the file at once, but possibly less than that amount. This makes sense because there may not be that much data in some files. However, if there is more than 1 MB of data left in the file, then it will read every byte available in order to avoid reading more than what it needs. This means that if the file only contains 2 MB of data but there are still more than 1 MB left in it, then it will read every byte in it anyway because it may not know how much more data is available in the file. Therefore, if you want to read some specific amount of bytes at once, you can specify this with this fourth (optional) argument if you know how big your file is exactly. Otherwise, if you do not know how large your file is exactly but you know that it does not contain more than some specific amount of bytes (greater than 0), then you can specify this amount with this fourth argument. When specifying this amount (in bytes), you can leave out both commas (or any other separator), since commas are not needed for specifying numbers in Python (they are only needed if specifying strings). Also, you can leave out any leading zero(es) after the decimal point; zero(es) are only used when specifying hexadecimal numbers in Python.

In this program we have used 5 arguments when calling the “open” function:

1) The name of our text file (“fileName”)

2) The mode to open this file with (“r” for reading)

3) A buffer size in bytes (we have left this blank here for simplicity)

4) The encoding name (we have left this blank here for simplicity)

5) The encoding flag (we have left this blank here for simplicity)

These arguments are passed in a tuple. A tuple is a list of values separated by commas without an enclosing pair of parentheses. The number of values in a tuple must be fixed when it is created; thus, tuples cannot be altered after their creation. Tuples may or may not be enclosed within parentheses; thus, parentheses are optional when defining a tuple but they are often used for clarity and to reduce ambiguity among other uses of parentheses within a given context. Optional parentheses may be used around individual items in a tuple or around an entire tuple; however, a notable exception is that a single parenthesis must be placed immediately following a tuple's closing brace whenever the tuple itself occurs within another set of parentheses, such as when it is being passed as an argument to a routine or displayed directly onscreen; thus: myTuple(). But: myRoutine(myTuple()). An empty tuple must always be enclosed within parentheses unless it occurs within another set of parentheses; thus: (). Empty parentheses can occur around an entire tuple or around an individual item within a tuple; however, care should be taken when using empty parentheses because empty parentheses also indicate an empty list and can syntactically behave differently than empty tuples depending on the routine being called: myTuple(); // "myTuple()" returns an empty list myTuple(); // "myTuple()" returns an empty tuple Used properly, tuples can make code clearer and faster by allowing multiple return values to be stored in a single variable (e.g., getPoints(startX, startY)). However, each returned value must still be explicitly defined if type checking is desired; thus: x = getPoints(startX, startY); // Type-checked return value y = getPoints(startX, startY); // Not type-checked return value Because tuples must contain members within parentheses and cannot be dynamically sized like lists and dictionaries, they do not support append(), remove(), or clear(). However these limitations can be worked around by converting tuples into lists or dictionaries prior to performing such operations; e.g.: t = ((x0, y0), (x1, y1), (x2, y2)); t[0] = t[2]; // legal t = ([x0, y0], [x1, y1], [x2, y2]); t[0][0] = t[2][0]; // legal As with lists and dictionaries, tuples support slicing via subscripting and indexing; e.g.: t[0] = t[2]; // legal t[0]:=(t[2]); // legal t[:] = (t[2], t[3]); // legal Tuples also support membership testing via the “in” operator; e.g.: x in t; // True y not in t; // False Keyword arguments can be assigned to corresponding variables within tuples using normal assignment expressions; e.g.: (x0 = startX, y0 = startY) and (x1 = endX, y1 = endY) and (x2 = resultX, y2 = resultY); But note that tuples do not support being converted directly into lists or dictionaries as lists and dictionaries do; e.g.: t = myTuple(); // illegal lists = myTuple(); // illegal dicts = myTuple(); // illegal As with lists and dictionaries, tuples support being passed as arguments by reference instead of by value using standard parameter passing techniques; e.g.: def setPoint(tup): tup[0] = startX tup[1] = startY tup[2] = endX tup[3] = endY setPoint((10, 20)) ; // now starts at 10 instead of 0 setPoint((20, 30)) ; // now ends at 30 instead of 20 In addition to standard parameter passing techniques as described above, tuples also support being passed as

Course content