Chapter 5 Use Sequences, Sets, Dictionaries, and Text Files

Methods of Built-In Class str

As is the case with some other object-oriented programming languages, string is a built-in class but is named str in Python. The str class has many powerful methods built into it, as detailed below with coding samples.

s.capitalize()

This converts the first character of the first word of string s to upper case and returns the converted string. Please note that characters in string s remain unchanged. This is the same for all string methods: no string method will alter the content of the original string variable. Rather, the method will make a copy of the content, manipulate the copy, and return it.

s.casefold()

Converts all characters of string s into lower case and returns the converted characters.

s.center(space)

Returns a string centred within the given space. Note how the empty whitespace is divided when the number is not even.

s.count(sub)

Returns the number of times a specified value occurs in a string.

s.encode()

Returns an encoded version of characters if they are not in the standard ASCII table. In the example below, there are Chinese characters in the string assigned to variable es.

Please note that the b in b'Python is not a big snake \xe8\x9f\x92\xe8\x9b\x87' indicates that all non-ASCII characters in the string are in byte.

s.endswith(sub)

Returns true if the string ends with the specified value, such as a question mark.

s.expandtabs(ts)

Sets the size of tabs in the string to ts, which is an integer.

s.find(sub)

Searches the string for a substring and returns the position of where it was found.

s.format(*args, **kwargs)

Formats specified values given in the list of position arguments *args, and/or the list of keyword arguments **kwargs into string s, according to the formatting specs given in s.

This is very useful in constructing complex strings.

Please note that when mapping a dictionary, s.format(**mapping) can be used to format a string by mapping values of the Python dictionary to its keys.

Please note that ** has converted the dictionary point into a list of keyword arguments. This formatting can also be done by directly using keyword arguments:

s.format_map(mapping)

Similar to format(**mapping) above. The only difference is that this one takes a dictionary without operator **.

s.index(sub)

Searches the string for a substring and returns the position of the substring. Generates a return error if there is no such substring.

Note that this may not be a good method to test if one string is a substring of another.

s.isalnum()

Returns True if all characters in the string are alphanumeric.

s.isalpha()

Returns True if all characters in the string are in the alphabet, including Unicode characters.

s.isdecimal()

Returns True if all characters in the string are decimals.

s.isdigit()

Returns True if all characters in the string are digits.

s.isidentifier()

Returns True if the string is an identifier by Python’s definition.

s.islower()

Returns True if all characters in the string are lower case.

s.isnumeric()

Returns True if all characters in the string are numeric.

s.isprintable()

Returns True if all characters in the string are printable.

s.isspace()

Returns True if all characters in the string are whitespace.

s.istitle()

Returns True if the string follows the rules of a title—that is, the first letter of each word is upper case, while the rest are not.

s.isupper()

Returns True if all characters in the string are upper case.

sep.join(iterable)

Joins the elements of an iterable with the separator. The iterable can be a list, tuple, string, dictionary, or set. Note that each element of the iterable must be a string. An integer or other number will raise an error.

s.ljust(sl)

Returns a left-justified version of the string within the given size of space.

s.lower()

Converts a string into lower case.

s.lstrip()

Returns a left trim version of the string.

s.maketrans(dict)

s.maketrans(s1, s2)

Return a translation table to be used in translations.

In s.maketrans(dict), key-value pairs of dict provide mapping for translation; in the case of s.maketrans(s1, s2), chars in s1 are mapped to chars in s2 one by one.

s.partition(sub)

Returns a tuple where the string is divided into three parts with sub in the middle.

s.replace(s1, s2)

Returns a string where a specified value is replaced with a specified value.

s.rfind(sub)

Searches the string from the right for a substring and returns the position of where it was first found.

s.rindex(sub)

Searches the string from the right for a substring and returns the index of the substring where it was first found.

s.rjust(sub)

Returns a right-justified version of the string within the given size of space.

s.rpartition(sub)

Returns a tuple where the string is divided into three parts at the substring found from the right.

s.rsplit(sep)

Splits the string at the specified separator and returns a list.

s.rstrip()

Returns a right-trimmed version of the string.

s.split(sep)

Splits the string at the specified separator and returns a list.

s.splitlines()

Splits the string at line breaks and returns a list.

s.startswith(ss)

Returns true if the string starts with the specified value.

s.strip()

Returns a trimmed version of the string.

s.swapcase()

Swaps cases, so lower case becomes upper case, and vice versa.

s.title()

Converts the first character of each word to upper case.

s.translate()

Returns a string translated from s using a translation table created with the maketrans() method.

s.upper()

Converts a string into upper case.

s.zfill(sl)

Fills the string to a specific length with a specified number of 0s at the beginning.

Built-In Functions and Operators for Strings

In addition to the string methods that you can use to manipulate strings, there are built-in functions and operators. The following are some examples.

Use operator + to join strings together

Use operator * to duplicate a string

Use built-in function len(s) to find out the length if a string

Use operator [i:j] to slice a string

Table 5-1 summarizes the operators and built-in functions you can use to manipulate strings.

In addition to the ways discussed above to construct and manipulate strings, Python also provides some methods for constructing and formatting strings nicely.

Constructing and Formatting Strings

Because text is made of strings, and text is very important in representing data, information, and knowledge, there is a need to convert various data objects into well-formatted strings. For this purpose, Python has provided programmers with a very powerful means of formatting strings that may consist of various types of data such as literals, integer numbers, float numbers with different precisions, compound data, and even user-defined objects.

In 2.1, we saw how we could use f/F, r/R, u/U, and b/B to provide some direction on string formation and representation. We also saw that prefixing f or F to a string allows us to conveniently embed expressions into the string with {} and have the expressions be automatically evaluated. In the following, you will see two more ways of formatting strings.

Formatting with %-Led Placeholders

Let’s begin with an example to explain how %-led placeholders are used to format and construct strings:

In the example above, the string before the last percentage sign % is called a formatting string. %3d is a %-led placeholder for an integer that will take a 3-digit spot, whereas %9.5 is a %-led placeholder for a float number, where 9 specifies the total number of digits the float number will take and 5 specifies the total number of decimal digits. The values in the tuple behind the last percentage sign are to be converted and placed into their corresponding placeholders. In the example, the value of n will be converted to an integer and placed into the first placeholder, whereas the value of d will be converted into a float number and placed into the second placeholder.

You can also use named placeholders, as shown in the next example, where the course and language (in the parentheses) are the names of the placeholders.

Note that when named placeholders are used, you will need to use dictionary instead of a tuple behind the last percentage sign.

The general format of a %-led placeholder is as follows:

or the following, if you like to use named placeholders:

The flags may use one or a combination of the characters in Table 5-2.

The width is the total width of space held for the corresponding value, and precision is the number of digits that the decimal portion will take if the value is a float number. The type can be one of the types shown in Table 5-3.

Formatting strings with the format Method

Compared to the two methods we have seen so far, a more formal way of string formatting in Python is using the format method, as shown in the following example:

The {} in the above example is also called a placeholder or replacement field. You can index the placeholders with integer numbers starting from 0, corresponding to the positions of values. You can also name the placeholders, in which case dictionary or keywords arguments need to be used within the format method call. In the example above, if we switch the indices (0 and 1), 99 will be placed as the first integer and 88 will be placed as the second integer, as shown below:

The general form of the replacement field is as follows:

{[field_name] [! conversion] [: format_spec]}

As mentioned before, having the item inside [] is optional; a placeholder can be as simple as an empty {}, as shown in the following example:

In the general form of the replacement field above, field name is something that can be used to identify the object within the arguments of the format method. It can be an integer to identify the position of the object, a name if keyword arguments are used, or a dot notation referring to any attribute of the object, as shown in the following example:

In this string formatting example, the first placeholder is {0}, in which integer 0 indicates that the value of the first argument of the format method call will be placed here; the second placeholder is {0.real}, which indicates that the value of the attribute real of the first object pf the format method call will be converted and inserted in that location; and the third placeholder is {0.imag}, which indicates that the value of the attribute imag of the first object of the format method call will be converted and inserted in that location. It is up to the programmer to use the right attribute names or to compose the right reference to a valid object or value within the arguments of the format method call.

Please note that conversion in the general form of the replacement field above is led by an exclamation mark !, which is followed by a letter: r, s, or a. The combination !r is used to convert the value into a raw string, !s is used to convert the value into a normal string, and !a is used to convert the value into standard ASCII, as shown in the following examples:

Please note the difference between the two outputs using !s and !a in particular.

It may also have been noted that with !r, the quotation marks surrounding the argument remain in the output, whereas with !s, the quotation marks have disappeared from the output. This is true when the argument for the !r is a string.

When the argument for !r is not a string, especially when it is a complicated object, o, the !r will cause the placeholder to be replaced with the result of o.repr(), which in turn calls the dunder method __repr__() defined for the object’s class. You will learn how to define and use Python dunder methods later in Chapter 7.

In string formatting with format method, formatting specification is led by a colon :, which is followed by formatting instructions, including the following:

1. 1. justification or alignment: > for right justification, < for left justification, ^ for centre justification
2. 2. with/without sign for numbers: + for always showing the sign, − for only show the minus sign, and ' ' for showing a whitespace when the number is positive
3. 3. the total number of letter spaces allocated to the data, such as in {:6d}, where 6 specifies that 6 letter spaces are taken by the integer number
4. 4. the number of decimal digits for float numbers, such as in {:6.2f}, in which the 2 specifies the decimal, so the float number will be rounded to take 2 spaces
5. 5. data type conversion indicates what data will be converted and inserted into the placeholder; the types of data include
   1. a. s for string
   2. b. d for integer
   3. c. f for float number
   4. d. x or X for hex number
   5. e. o for octal number
   6. f. b for binary number
   7. g. #x, #X, #o, and #b to prefix the numbers 0x, 0X, 0o, and 0b, respectively

The following example shows how the data type conversions work:

If you wish the output of a placeholder to be left, right, or centre justified within the given space, <, >, or ^ can be used to lead the format spec, as shown in the following example:

If you want the extra space to be filled with a special character, such as #, you can put the character between the colon and <, >, or ^, as shown below:

By this point, we have learned three ways of constructing and formatting strings: the first one is to use the f/F prefix, the second is to use a %-led placeholder, and the last is to use the format method.

Among the three, the first one is the most compact and good for simple string construction without any fancy formatting. The expression within each {} will be evaluated, and the value will be converted into a string with which the placeholder is replaced as is.

Both the second and the third way can be used to construct and format more complex strings from various objects. The difference between the two is that the second, using a %-led placeholder, is more casual, whereas the third is more formal and the code more readable.

Regular Expressions

Information processing and text manipulation are important uses for modern computers, and regular expressions, called “REs” or “regexes” for short, were developed as a powerful way to manipulate text. Many modern programming languages have special libraries for searching and manipulating text using regular expressions. In Python, a standard module called re was developed for that purpose.

To correctly use the re module, we first must understand what regular expressions are and how to construct a regular expression that genuinely defines the strings we want to find and/or manipulate within a text because almost all functions/methods of the re module are based on such defined regular expressions.

What is a regular expression? A regular expression is a pattern that describes certain text or literal strings. Examples of some useful patterns include telephone numbers, email addresses, URLs, and many others.

To be able to correctly define a regular expression precisely describing the strings we want to find and manipulate, we must first understand and remember the rules of regular expressions, as well as special characters and sequences that have special meanings in a re module. Since regular expressions are strings themselves, they should be quoted with single or double quotation marks. For simplicity, however, we may omit some quotation marks in our discussion when we know what we are talking about in the context.

Plain literals such as a, b, c,…z, A, B, C,…Z, and numeric digits such as 0, 1, 2,…9 can be directly used in a regular expression to construct a pattern, such as Python, Foo, Canada. Some symbols in the ASCII table have been given special meanings in re. These symbols, called metacharacters, are shown in Table 5-4.

The above are the basic rules for constructing regular expressions or regex patterns. Using these rules, we can write regular expressions to define most string patterns we are interested in.

The following are some examples of regex patterns:

• 780-\d{7}, pattern for telephone numbers in Edmonton, Alberta
• \$\d+\.\d{2}, pattern for currency representations in accounting
• [A-Z]{3}-\d{3}, pattern for licence plate numbers

The re module is also empowered with the following extension rules, which all begin with a question mark ? within a pair of parentheses. Although surrounded by a pair of parentheses, an extension rule, except (?P<name>…), does not create a new group.

(?aiLmsux)

Here, ? is followed by one or more letters from set a, i, L, m, s, u, and x, setting the corresponding flags for the re engine. (?a) sets re.A, meaning ASCII-only matching; (?i) sets re.I, meaning ignore case when matching; (?L) sets re.L, meaning local dependent; (?m) sets re.M, meaning multiple lines; (?s) sets re.S, meaning dot matches all characters including newline; (?u) sets re.U, meaning Unicode matching; (?x) sets re.X, meaning verbose matching. These flags are defined in the re module. The details can be found by running help(re).

The flags can be used at the beginning of a regular expression in place of passing the optional flag arguments to re functions or methods of pattern object.

(?aiLmsux-imsx:…)

Sets or removes the corresponding flags. (?a-u…) will remove Unicode matching.

(?:…)

Is a noncapturing version of regular parentheses, meaning the match cannot be retrieved or referenced later.

(?P<name>…)

Makes the substring matched by the group accessible by name.

(?P=name)

Matches the text matched earlier by given name.

(?#…)

Is a comment; ignored.

(?=…)

Matches if… matches next but does not consume the string being searched, which means that the current position in string remains unchanged. This is called a lookahead assertion.

John (?=Doe) will match John only if it is followed by Doe.

(?!…)

Matches if… does not match next.

Jon (?!Doe) will match Jon only if it is not followed by Doe.

(?<=…)

Matches if preceded by… (must be fixed length).

(?<=John) Doe will find a match in John Doe because there is John before Doe.

(?<!…)

Matches if not preceded by… (must be fixed length).

(?<!John) Doe will find a match in Joe Doe because there is not Joe before Doe.

(?(id)yes pattern | no pattern)

(?(name)yes pattern | no pattern)

Match yes pattern if the group with id or name is matched; match no pattern otherwise.

To do text manipulation and information processing using regular expressions in Python, we will need to use a module in the standard Python library called Re. Similarly, we will need to import the module before using it, as shown below:

Using the dir(re) statement, you can find out what names are defined in the module, as shown below, but you will need to use help(re) to find out the core functions and methods you can use from the re module.

The following are functions defined in the re module:

Compile a pattern into a pattern object and return the compiled pattern object for more effective uses later.

re.match(pattern, string, flags=0)

Match a regular expression pattern to the beginning of a string. Return None if no match is found.

re.fullmatch(pattern, string, flags=0)

Match a regular expression pattern to all of a string. Return None if no match is found.

re.search(pattern, string, flags=0)

Search a string for the presence of a pattern; return the first match object. Return None if no match is found.

re.sub(pattern, replacing, string, count=0, flags=0)

Substitute occurrences of a pattern found in a string by replacing and return the resulted string.

re.subn(pattern, replacing, string, count=0, flags=0)

Same as sub, but also return the number of substitutions made.

re.split(pattern, string, maxsplit=0, flags=0)

Split a string by the occurrences of a pattern and return a list of substrings cut by the pattern.

re.findall(pattern, string, flags=0)

Find all occurrences of a pattern in a string and return a list of matches.

re.finditer(pattern, string, flags=0)

Return an iterator yielding a match object for each match.

re.purge()

Clear the regular expression cache.

re.escape(pattern)

Backslash all nonalphanumerics in a string.

Suppose we want to write a program to check if a name given by a user is a legitimate Python identifier. We can define a regex pattern for a Python identifier as shown below:

Before using the re module, we need to import it, as shown below:

The next step will be to get an input from the user and test it:

Trim the whitespace at the beginning and the end of the name just in case:

Then, we do the real test:

The complete code of the program is shown in the code section of Table 5-6.

List Comprehension

The following is an example that constructs a list of odd numbers from 1 to 100:

In the example, the expression before for represents the items of the list; the for loop will run through the item expression in each iteration. This list can also be generated using the for loop with an if clause, as shown below:

In the example above, the list item expression will be evaluated in every iteration of the for loop only if the condition of the if clause is met. In fact, we can put any condition on the iteration variable i. For example, assume we have a Boolean function isPrime(N) that can test if number N is prime or not; then the following statement will produce a list of prime numbers in the given range:

Please note that the list item expression before for can be anything whose value is a legitimate list item, as shown in the example below:

For item expressions involving two variables or more, nested for statements can be used. For example, the following statement will generate a list of combinations of some years and months:

Set Comprehension

A set is a collection of unique unordered items. With that in mind, set comprehension is similar to list comprehension, except that the items are enclosed in curly brackets, as shown in the example below:

What would happen if items generated from the iteration were duplicated? No worries! The implementation of set comprehension can take care of that. If we want to find out all the unique words contained in a web document, we can simply use set comprehension to get them, as shown below:

The example above took a web document at https://scis.athabascau.ca, pulled all the unique words used in the document into a set, and printed the number of unique words used, which is 969.

As you can see, we could get the unique words in a document very easily by using set comprehension. How would we find out the ratio between the number of unique words and the total number of words used?

Dictionary Comprehension

Dictionary comprehension is very similar to set comprehension, except that we need to add a key and colon before each item to make a dictionary item, as shown in the following:

This can also be written in nested for clauses, as shown below:

Opening and Closing a File

To use a file, the first step is to open the file using the built-in function open. The following will open a file for writing:

The statement above opened the file mypoem.txt in the current working directory and returned a stream, which was then assigned to variable f, often called a file handle.

The general syntax of the open statement is as follows:

The statement opens a file and returns a stream or file object; it will raise OSError upon failure. In the statement, file is a text or byte string referring to the file to be opened. It may include the path to the actual file if the file is not in the current working directory.

Apart from the first argument for the name of the file to be opened, all other arguments have default values, which means that these arguments are optional. If no value is supplied, the default value will be used.

The second argument is called mode. It is optional with a default value r, which means “open a text file for reading.” This argument is used to tell the program what to do with the file after opening. Because reading from a text file is not always what you want it to do with a file, the argument is not optional. All available values for the mode argument are shown in Table 5-7.

The file to be opened or created can be either a text file, referred to as t, or a binary file containing raw bytes, referred as b. To explicitly specify whether the file is a text or binary file, t or b can be used in combination with each of the values in Table 5-7. The default file type is text, so you do not have to use t if the file is a text file. So in the example above, the statement is equivalent to the following, in which t is used to explicitly indicate that it is a text file:

In both examples, we assigned the file stream returned from the open statement to a variable f, which is called the file handle. After the file is opened, all operations on the file—such as read, write, append, or even close—must be appended to the file handle. Every file must be closed using the f.close() method after open and use unless the file is opened within a with statement, in which case a context manager will take over access to the file and close it when the job is done, as in the sample code below:

When not using the with statement, you will need to use the following instead:

The third argument is called buffering. It takes an optional integer used to specify the buffering policy of the file operation. Passing 0 turns off buffering, but it is only allowed for binary files. Passing 1 selects line buffering, which is only allowed for text files. Passing an integer greater than 1 specifies the actual size of a fixed-size chunk buffer. When no buffering argument is provided, the default value −1 is used, which means that if the file is a binary file, the file will be buffered in a fixed-size chunk; if the file is a text file, line buffering policy is used, which means that the data will be flush to the actual file (on a disk such as a hard drive) from the buffer (a portion of internal memory to buffer the data) after each line was written.

The fourth argument is encoding, which specifies how the data in the file are encoded. This argument only makes sense for text files. The default value is platform dependent. If you believe that the encoding of data on a file is not the default, you can specify whatever encoding in which the data are encoded. However, the encoding must be supported by Python. In most cases, UTF-8 is the default encoding.

The next optional argument is errors, which takes a string if provided. The string specifies how encoding errors should be handled. Again, this argument only makes sense if the file is a text file. The same is true for the optional newline argument, which controls how universal newlines work in a text file. The optional newline argument can take the following:

• • None
• • ,
• • \n
• • \r
• • \rn

Once a file is opened, a list of methods can be used to operate on the file object, as detailed below.

Write or Append to a File

New data can be added to a file in two different manners. The first one is to overwrite everything already in the file and place the new data at the beginning of the file, and the second one is to keep the data already in the file and append the new data to the end of the existing data. The write methods are the same for both, but the file must be opened with a different mode depending on the operation. That is, mode w or x must be used to open a file for writing the data from the beginning of the file, and mode a must be used to append new data, as you will see shortly in the examples.

There are two methods for writing to a file. The first one is f.write(string), which writes string to the file referred by f. The second method is f.writelines(sequence), in which the sequence is any iterable object, such as a list or tuple, but often a list of strings. The following is an example of opening or creating a file (if the file does not exist yet) for writing data from the beginning of the file using the write(string) method:

The resulting file will read,

If you could write only this one line of your poem and had to close the file and shut down the computer, you would be more likely to continue from where you had stopped the next time you came back to the poem. So you need to append the new lines to the file. This is done by opening the file in a mode, as shown below:

The file is extended with one more line of poem:

Note that the write method will only write a string to the file. As such, anything that is not a string must be converted into a string before being written to the file, as shown in the following example:

Also, because of buffering, the data you write to a file will not immediately show up in the actual file until you close the file or use the flush() method to flush the data in the buffer out to the file, as shown below:

The write(string) method can only write one string to a file each time. To write multiple strings to a file, the writelines(sequence) method is used. However, keep in mind that writelines() does not automatically write one string on each line. You will still need to add \n at the beginning of the string if you want it to be on the next line or at the end of the string if you don’t want anything behind the string on the same line.

Recall the example of printing a 9 × 9 multiplication table. Now we can write the table to a text file so that you can print it out whenever you want. This is shown in the two examples below:

The output of the program is in the file my9x9table.txt:

To use the writelines(sequence) method, we need to store the results in a list first; each item of the list will be printed on one line. The code is shown as follows:

The result is the same as in the my9x9table.txt text shown above.

Reading from a File

To read from a file, three methods can be used. These methods are read([size]), readline([size]), and readlines([sizehint]).

Use the read([size]) method to read the entire file and return the entire contents as a single string or, if the optional size argument is given, to read the specified number of bytes and return the contents as a single string. The following example shows how the 9 × 9 multiplication table is read using the read([size]) method:

If size is given, only that number of bytes will be read, as shown in the next example:

Because the given size is so small, only a small portion of the multiplication table has been read from the file.

Our next method for reading data from a file is readline([size]). This method will read and return one entire line from the file if the optional size argument is not provided or if the integer value is equal to or greater than the size of the line. If the provided size is smaller than the actual size of the line being read, then only part of that line, equal to the size in bytes, will be read and returned, as shown in the following example:

Using this method to read all the lines of the 9 × 9 multiplication table in the file shown in the previous examples, we will need to put it in a loop and read line by line until the end of the file. In Python, however, there is no effective way to test if it has reached the end of the file. For this particular file, since we know there is no blank line before the end of the file, we will use an empty string to signify the end of the file. The revised code is shown below:

The code above does not look so neat. In fact, since the text file is treated as an iterator in Python, with one item for each line, the above code can be simply written as follows:

The output is the same as above.

Using a context manager with the code can be further simplified as follows:

Considering the fact that a text file is an iterator, the built-in function next(iterator) can be used to iterate the file line by line. However, it would raise a StopIteration error if it reached the end of the file. The following example shows how to use next(iterator) to read and print the entire multiplication table:

The third method for reading data from a file is readlines([sizehint]), where optional sizehint, if provided, should be an integer hinting at the amount of data to be read. Again, it is only available for text files. As the name implies, it reads multiple lines into a Python list until the end of the file, or as much as defined by sizehint, if the argument is provided. For example, if the total amount of data of the first n lines is less than sizehint, but the first n + 1 lines is greater than sizehint, then the method will read (n + 1) lines. So it will read whole lines rather than partial, in contrast to the readline([size]) method.

Sometimes, we might like to read from a particular portion of a file, just like we want to start reading a book from a specific page. How can we do that in Python?

Imagine there is a pointer indicating where the reading will start in a file. In Python, several methods can be used to adjust the pointer.

The first method is f.tell(), which determines where the pointer is in terms of how many bytes ahead it is, as shown in the following example:

The output above shows where each line starts. For example, the end of the file is at 603. So with this information, the code using the readline([size]) method to read the multiplication table previously given can be easily revised to the following:

What if we want to read from a specific point in the file? To do that, we need to move the pointer to that point. That brings us to the second method of adjusting the pointer, which is f.seek(offset, start), in which the offset is how much to move it from the start. The default value for start is the current position of the pointer in the file. It would have been 0 when the file opened.

So suppose we want to read the line of the multiplication table 138 bytes from the beginning of the file. We would have to move the pointer to 138 first. From 0 at the beginning, the offset would be 138 as well. The code is shown below:

Update Existing Content of a Text File

In a text file, how do we replace an existing line with something else? To achieve this, we need to take the following steps:

1. 1. Open the file in r+ mode
2. 2. Find out the position of the line
3. 3. Move the file pointer to that position using f.seek(offset, start)
4. 4. Write whatever you want to the file, which will replace the original content on that line

An example of such an update is shown below:

The updated content of the file is shown below:

Note that if there is less new content than the original, only part of the original is replaced.

We can also replace a single original line with multiple lines, as shown below:

The updated file is shown below:

However, if the total size of the new written data is longer than the line being replaced, part of the line or lines under will be overwritten. Therefore, if you want to replace a specific line of the text file exactly, you will need to write just enough to cover the existing data—no more, no less.

Deleting Portion of a Text File

To delete a portion of existing data from a file, you will need to use the f.truncate([size]). If the optional size argument is given, the file will be truncated to that size or the size of the file. Otherwise, the file will be truncated to the current file position. So if a file is freshly opened in w, w+, a, or a+ mode, f.truncate() will remove all data from the beginning to the end of the file. Please note that if the optional size argument is given and greater than 0, the file must be opened in a or a+ mode in order to truncate the file to the expected size.

The resulting content of the file is shown below:

Please note that only part of the content in the file is left.

If the file is opened in w or w+ mode, the file will be truncated to a size of 0 regardless.

With all we have learned so far, we are ready to design and code a program to analyze an article stored in a text file. The program is shown in Table 5-8.