File Handling

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation

Python categorize files broadly into two types: binary files and text files.

1. Binary files — These files store the information in the form of a stream of bytes.
2. Text files — These files store the information in the form of a stream of ASCII or Unicode characters.
   Text files include CSV (Comma-Separated Values) and TSV (Tab-Separated Values) files because they contain human-readable text data and are specific types of delimited text files. In CSV files, fields are separated by commas, while in TSV files, fields are separated by tabs.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation

The file modes "r", "w", and "a" are used to specify the type of operations that can be performed on files in Python. These modes are commonly used with text files, CSV files, and TSV files alike because all of these file types contain human-readable text data. CSV (Comma-Separated Values) and TSV (Tab-Separated Values) are types of delimited text files.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation

When we see file modes like "r", "w", or "a" being used in code, it often implies operations on text files. These modes are commonly associated with reading from, writing to, or appending text data in files. In Python, binary file modes are distinguished from text file modes by appending 'b' suffix to the regular file modes. For example, 'rb', 'wb', 'ab'. The presence of the 'b' suffix indicates that the file is being opened in binary mode, suggesting operations involving binary data.

(b)

Both Assertion and Reason are true but Reason is not the correct explanation of Assertion.

Explanation

A binary file works with byte-streams and 'Pickling' is the process in binary file, where a Python object hierarchy is converted into a byte-stream. Binary files are commonly used as the destination for pickled data. This is because binary files can efficiently store raw binary data, including the byte-streams produced by pickling.

(b)

Both Assertion and Reason are true but Reason is not the correct explanation of Assertion.

Explanation

"Pickling" is the process whereby a Python object hierarchy is converted into a byte-stream. Pickling process is used to work with binary files as a binary file works with byte-streams. This is because binary files can efficiently store raw binary data, including the byte-streams produced by pickling. The use of binary files is just one of the many possible applications of pickling, but not the primary reason for its existence.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation

Every open file maintains a file-pointer, which keeps track of the current position within the file. This file-pointer indicates the location in the file where the next read or write operation will occur. Every read and write operation takes place at the current position of the file pointer. When we perform a read operation, data is read from the file starting at the current position of the file pointer. Similarly, when we perform a write operation, data is written to the file starting at the current position of the file pointer. After each operation, the file pointer is automatically updated to reflect the new position in the file.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation

CSV (Comma Separated Values) is indeed a file format for data storage that resembles a text file. CSV files are plain text files that typically use the .csv extension and contain tabular data organized into rows and columns. The information in CSV files is organized with one record (or row) on each line, and each field (or column) within a record is separated by a comma.

'rb', ab, a + b, r+

Reason —

1. 'rb' — This mode opens the file for reading in binary mode. It will not erase the existing data and allows reading of the file.
2. 'ab' — This mode opens the file for appending in binary mode. It will not erase the existing data but will append new data to the end of the file.
3. 'a + b' — This mode opens the file for reading and appending. It will not erase the existing data and allows both reading from and appending to the file.
4. 'r+' — This mode opens the file for reading and writing. It will not erase the existing data and allows both reading from and writing to the file.

1. data = f.read() — Variable data will be string data type.
2. data = f.read(10) — Variable data will be string data type.
3. data = f.readline() — Variable data will be string data type.
4. data = f.readlines() — Variable data will be list data type.

1. f.readline() — This statement reads a single line from the file f and returns it as a string, including any whitespace characters at the end of the line.
2. f.readline().rstrip() — This statement first reads a single line from the file f, then applies the rstrip() method to remove any trailing whitespace from the end of the line, and returns the modified line as a string.
3. f.readline().strip() — This statement first reads a single line from the file f, then applies the strip() method to remove any leading and trailing whitespace from the start and end of the line, and returns the modified line as a string.
4. f.readline.rstrip('\n') — This is not a valid syntax. The correct syntax is f.readline().rstrip('\n'). This statement first reads a single line from the file f, removes any trailing newline characters from the end of the line, and returns the modified line as a string.

A text file stores information in ASCII or Unicode characters, where each line of text is terminated, (delimited) with a special character known as EOL (End of line) character. In text files some internal manipulations take place when this EOL character is read and written.

A binary file stores the information in form of a stream of bytes. A binary file is just a file that contains information in the same format in which the information is held in memory, i.e., the file content that is returned to us is raw (with no translation or no specific encoding).

CSV (Comma Separated Values) files are delimited files that store tabular data (data stored in rows and columns as we see in spreadsheets or databases) where comma delimits every value. Each line in a CSV file is a data record. Each record consists of one or more fields, separated by commas (or the chosen delimiter).

The functions used to read in plain text files are as follows :

1. read()
2. readline()
3. readlines()

The functions used to write in plain text files are as follows :

1. write()
2. writelines()

The functions used to read and write in binary files are load() and dump() functions of pickle module respectively.

The functions used to read in CSV files are as follows :

1. csv.reader()

The functions used to write in CSV files are as follows :

1. csv.writer()
2. <writerobject>.writerow()
3. <writerobject>.writerows()

1. CSV — Comma Separated Values
2. TSV — Tab Separated Values

file

Reason — A file in itself is a bunch of bytes (information) stored on some storage device like hard-disk, thumb-drive etc with a specific name.

Text files, Binary files

Reason —

1. Text files — Text files are one of the most common formats for storing data. They contain human-readable text and can be created and manipulated using Python's built-in file handling functions like open(), write() etc.

2. Binary files — Binary files store data in a binary format, which means they contain sequences of bytes that may represent any type of data, including text, images, audio, or any other type of information. Python provides facilities for working with binary files through modes like 'rb' (read binary) and 'wb' (write binary).

file = open("c:\\ss.txt", "a")
file = open(r"c:\ss.txt", "a")

Reason —

1. file = open("c:\\ss.txt", "a") — The syntax to open a file c:\ss.txt is f = open("c:\\temp\\data.txt", "a"). Hence according to this syntax file = open("c:\\ss.txt", "a") is correct format.
2. file = open(r"c:\ss.txt", "a") — The syntax to open a file c:\ss.txt with single slash is f = open(r"c:\temp\data.txt","a").The prefix r in front of a string makes it raw string that means there is no special meaning attached to any character. Hence according to this syntax file = open(r"c:\ss.txt", "a") is correct format.

infi.readline()

Reason — The syntax to read a line in a file is <filehandle>.readline(). Hence according to this syntax infi.readline() is correct format.

infi.readlines()

Reason — The syntax to read all lines in a file is <filehandle>.readlines(). Hence according to this syntax infi.readlines() is correct format.

a list of lines

Reason — The readlines() method returns the entire file content in a list where each line is one item of the list.

b

Reason — When we open a file in binary mode by adding 'b' to the file mode, it indicates that the file should be treated as a binary file.

We can write content into a text file opened using 'r' mode

Reason — We can only read content into a text file opened using 'r' mode.

F = open('Notes.txt') ; print(F.read(10))

Reason — The syntax to read and display the first 10 characters of a text file is f = open(file-name) ; print(f.read(10)). Hence according to this syntax, F = open('Notes.txt') ; print(F.read(10)) format is correct.

F = open('Notes.txt', 'A')

Reason — F = open('Notes.txt', 'A'), in this statement mode should be written in small letter 'a'. So the correct statement would be F = open('Notes.txt', 'a').

read()

Reason — read() function is used to read all the characters in a file.

readline()

Reason — readline() function is used to read a single line from file.

write()

Reason — write() function is used to write all the characters in a file.

writelines()

Reason — writelines() function is used to write a list of strings in a file.

wb+

Reason — wb+ mode represents mode of both writing and reading in binary format in file in Python.

rw

Reason — rw is not a valid mode to open file in Python.

r+

Reason — r+ mode in file opening statement results or generates an error if the file does not exist.

fin = open("c:\\pat.txt", "r")

Reason — The syntax to open a file in read-mode only is f = open("c:\\temp\\data.txt", "r"). Hence according to this syntax fin = open("c:\\pat.txt", "r") format is correct.

When you open a file for reading, if the file does not exist, an error occurs.
When you open a file for writing, if the file does not exist, a new file is created.
When you open a file for writing, if the file exists, the existing file is overwritten with the new file.

Reason —

1. When you open a file for writing, if the file does not exist, an error occurs — False.
   When we open a file for writing ("w" mode) and the file does not exist, Python creates a new file.
2. When you open a file for reading, if the file does not exist, the program will open an empty file — False.
   When we try to open a file for reading ("r" mode) that does not exist, Python raises a FileNotFoundError. It does not create an empty file.

fout = open("c:\\pat.txt", "wb")

Reason — The syntax to open a file for writing in binary format is f = open("c:\\temp\\data.txt", "wb"). Hence according to this syntax fout = open("c:\\pat.txt", "wb") format is correct.

fout = open("c:\\pat.txt", "wb+")

Reason — The syntax to open a file for writing as well as reading in binary format is f = open("c:\\temp\\data.txt", "wb+"). Hence according to this syntax fout = open("c:\\pat.txt", "wb+") format is correct.

dump()

Reason — To write an object on to a binary file opened in the write mode, we should use dump() function of pickle module as per following syntax: pickle.dump(<object-to-be-written>, <file-handle-of-open-file>).

It returns the byte position of the file pointer as an integer.

Reason — The tell() function returns the current byte position of file pointer in the file as an integer.

The csv module is used for reading and writing objects in binary files.

Reason — The CSV module is used for reading and writing objects in CSV files.

It places the file pointer at a desired offset within the file.

Reason — The seek() function changes the position of the file-pointer by placing the file-pointer at the specified position in the open file.

file_object.seek(offset[, reference_point])

Reason — The syntax of seek() function is <file-object>.seek(offset[, mode]).

True

Reason — When a file is opened for reading using r mode (text files) or rb mode (binary files), if the file does not exist, Python raises an error.

False

Reason — When a file is opened for writing using w mode (text files) or wb mode (binary files), if the file does not exist, file is created.

True

Reason — When we open a file for writing using w mode (text files) or wb mode (binary files), if the file exists, Python will truncate the existing data and overwrite in the file.

True

Reason — The absolute paths are from the topmost level of the directory structure.

True

Reason — The relative paths are relative to current working directory denoted as a dot(.).

False

Reason — The relative paths are relative to current working directory. Hence, the relative path for a file does change based on the current working directory.

True

Reason — The operations that can be carried out on a file, such as reading, writing, and appending, depend on the file mode specified during the file opening. For example, if a file is opened in read-only mode ('r'), we can only perform read operations on it, whereas if it's opened in write mode ('w'), we can only perform write operations.

True

Reason — If no path is given with a file name in the open() function in Python, then the file is assumed to be located in the current working directory. If the file is not found in the current working directory, Python will raise a 'FileNotFoundError' exception.

False

Reason — In Python, the readline() function reads a single line from the file and returns it as a string, while the readlines() function reads all lines from the file and returns them as a list of strings.

True

Reason — Python automatically flushes the file buffers when closing them i.e., this function is implicitly called by close() function.

True

Reason — When we open a file for writing using w mode (text files) or wb mode (binary files), if the file does not exist, a new file is created.

False

Reason — When we open a file for appending using a mode (text files) or ab mode (binary files), if the file exists, the data in the file is retained and new data being written will be appended to the end.

True

Reason — Serialisation is the process of converting Python object hierarchy into a byte stream, so that it can be written into a file.

True

Reason — Serialisation process is also called pickling in Python.

False

Reason — The load() function of the pickle module performs unpickling i.e., a byte stream is converted into an object hierarchy. It is used to read an object on to a binary file opened in a read mode.

False

Reason — The dump() function of the pickle module performs pickling i.e, an object hierarchy is converted into a byte stream. It is used to write an object on to a binary file opened in a write mode.

False

Reason — The separator character of CSV files is called a delimiter. Default and most popular delimiter is comma. Other popular delimiters include the tab (\t), colon (:), pipe (|) and semicolon (;) characters.

True

Reason — CSV files are text files because they consist of human-readable text and use characters to represent data fields, separated by delimiters like commas or tabs.

The differences between "w" and "a" modes are:

File objects are used to read and write data to a file on disk. The file object is used to obtain a reference to the file on disk and open it for a number of different tasks. File object is very important and useful tool as through a file object only, a Python program can work with files stored on hardware. All the functions that we perform on a data file are performed through file objects.

The two different formats of specifying file path for opening the file C:\Myfiles\Text1.txt in read and write mode are:

1. file1 = open("C:\\Myfiles\\Text1.txt", "rb+")

2. file2 = open(r"C:\Myfiles\Text1.txt", "rb+")

pickle

Reason — The pickle module in Python is imported to store and retrieve objects using the process of serialization and deserialization. It allows us to convert Python objects into a byte stream for storage or transmission (serialization) and to convert a byte stream into Python objects (deserialization). This process is commonly referred to as pickling and unpickling. The pickle module provides functions like dump() and load() for serialization and deserialization, respectively.

reader()

Reason — In the CSV module in Python, the reader() function is used to read the contents of a CSV file into an object. This function returns a reader object which can be used to iterate over the rows of the CSV file, where each row is represented as a list of strings. This allows to process the data contained within the CSV file.

When a file is opened for output in write mode ("w" mode) in Python, the behaviour differs depending on whether the mentioned file already exists or not:

(i) If the mentioned file does not exist — If the file specified in the open() function does not exist, Python will create a new file with the given name. The file will be opened for writing, and any data written to it will be written from the beginning of the file.

(ii) If the mentioned file does exist — If the file specified in the open() function already exists, Python will truncate existing data and over-write in the file. It's essential to be cautious when opening existing files in write mode, as any existing data will be lost when the file is opened in "w" mode.

File modes play a crucial role in file operations in Python as they determine how the file will be opened and what operations can be performed on it. Each file mode specifies whether the file should be opened for reading, writing, appending, or a combination of these operations. Additionally, file modes can distinguish between text mode and binary mode, which affects how the file data is handled.

Here are the various text file mode constants in Python and their meanings:

1. "r" — Opens the file for reading only. This is the default mode if no mode is specified.
2. "w" — Opens the file for writing only.
3. "a" — Opens the file for writing, but appends new data to the end of the file.
4. "r+" — Opens the file for both reading and writing.
5. "w+" — Opens the file for writing and reading.
6. "a+" — Opens the file for reading and appending.

Here are the various binary file mode constants in Python and their meanings:

"rb", "wb", "ab", "rb+", "wb+", "ab+" — These modes are similar to their corresponding text modes ("r", "w", "a", "r+", "w+", "a+"), but they operate in binary mode.

(i) The advantages of saving data in binary form are as follows:

1. Efficiency — Binary files store data in a compact binary format, which can lead to smaller file sizes compared to text-based formats. Binary form is efficient for storing raw binary data.
2. Speed — Reading and writing binary data can be faster than text-based formats because there is no need for encoding or decoding operations.
3. Data Integrity — Binary files preserve the exact binary representation of data without any loss of information.

(ii) The advantages of saving data in text form are as follows:

1. Human Readability — Text-based formats, such as plain text files, are human-readable, making them easy to inspect and edit using a text editor.
2. Interoperability — Text files can be easily shared and processed across different platforms and programming languages.
3. Compatibility — Text-based formats are widely supported by various software applications and systems, making them a versatile choice for data interchange and communication.

(iii) The advantages of saving data in CSV files are as follows:

1. Tabular Data Representation — CSV (Comma-Separated Values) files provide a simple and standardized way to represent tabular data, with rows and columns separated by commas.
2. Simplicity — CSV files are easy to create, parse, and manipulate using spreadsheet software.
3. Flexibility — CSV files can store a wide range of data types, including numbers, strings, and dates.
4. Interoperability — CSV files are supported by many software applications, databases, and programming languages, allowing for seamless integration and data exchange between different systems.

Text files should be preferred over binary files when dealing with human-readable data that does not require special encoding or formatting. They are ideal for storing plain text, such as configuration files, logs, or documents, as they are easily editable and can be viewed using a simple text editor. Text files are also more portable and platform-independent, making them suitable for data interchange between different systems.

(a) To open a text file "BOOK.TXT" in read mode : file1 = open("BOOK.TXT", "r")

(b) To open a text file "BOOK.TXT" in write mode : file2 = open("BOOK.TXT", "w")

When a file is opened for output in append mode ("a" mode) in Python, the behaviour differs depending on whether the mentioned file already exists or not:

(i) If the mentioned file does not exist — If the file specified in the open() function does not exist, Python will create a new file with the given name. The file will be opened for writing, and any data written to it will be appended to the end of the file.

(ii) If the mentioned file does exist — If the file specified in the open() function already exists, the data in the file is retained and new data being written will be appended to the end of the file.

(i) To process three files sequentially — In this scenario, where we need to process three files sequentially, we would need a single file object, as we can reuse a single file object by opening then processing and closing it for each file sequentially.

For example :

f = open("file1.txt", "r")
# Process file 1 using f
f.close()

f = open("file2.txt", "r")
# Process file 2 using f
f.close()

f = open("file3.txt", "r")
# Process file 3 using f
f.close()

Here, we are reusing the f file object three times sequentially. We start by opening file1 in read mode and store its file handle in file object f. We process file1 and close it. After that, same file object f is again reused to open file 2 in read mode and process it. Similarly, for file3 also we reuse the same file object f.

(ii) To merge two sorted files into a third file — In this scenario, where we need to merge two sorted files into a third file, we would need three file objects, one for each input file and one for the output file. We would open each input file for reading and the output file for writing. Then, we would read data from the input files, compare the data, and write the merged data to the output file. Finally, we would close all three files after the merging operation is complete.

For example :

f1 = open("file1.txt", "r")
f2 = open("file2.txt", "r")
f3 = open("merged.txt", "w")
# Read line from f1
# Read line from f2
# Process lines
# Write line to f3
f1.close()
f2.close()
f3.close()

A CSV (Comma-Separated Values) file is a specific type of text file. The similarities and differences of CSV files with text files are as follows :

The similarities :

1. Both are text-based formats.
2. Both store data in a human-readable format.
3. Both use plain text characters to represent data.
4. Both are platform independent.

The differences :

1. CSV files have a structured format where data is organized into rows and columns, separated by delimiters such as commas, tabs, or semicolons. Text files, on the other hand, can have any structure, and data may not be organized into rows and columns.
2. CSV files are specifically designed for storing tabular data, such as spreadsheets, where each row represents a record and each column represents a field. Text files can contain any type of textual information.
3. CSV files use delimiters (such as commas, tabs, or semicolons) to separate values within each row, while text files do not use delimiters.

Yes, a CSV (Comma-Separated Values) file is different from a binary file. A CSV (Comma-Separated Values) file differs from a binary file in several aspects. CSV files are text-based and structured to store tabular data, with records separated by line breaks and fields by delimiters like commas. They are human-readable and editable using text editors, facilitating data interchange between applications and platforms. In contrast, binary files store data in a non-text, machine-readable format, represented by sequences of bytes. There is no delimiter for a line and no character translations occur. They accommodate diverse data types like images, audio, but are not human-readable and require specialized software for interpretation.

CSV (Comma-Separated Values) files are popular for data storage due to the following reasons:

1. Easier to create.
2. Preferred export and import format for databases and spreadsheets.
3. Capable of storing large amount of data.

To change the delimiter of a CSV file while writing into it, we can specify the desired delimiter when creating the CSV writer object. In Python, we can achieve this using the csv.writer() function from the csv module. By default, the delimiter is a comma (,), but we can change it to any other character, such as a tab (\t), semicolon (;), or pipe (|).

import csv
with open('output.csv', 'w', newline='') as csvfile:  
    csv_writer = csv.writer(csvfile, delimiter=';') 
    csv_writer.writerow(['Name', 'Age', 'City'])
    csv_writer.writerow(['John', 30, 'New York'])
    csv_writer.writerow(['Alice', 25, 'London'])

In this example:

1. We open the CSV file for writing using the open() function with mode 'w'.
2. We create a CSV writer object csv_writer using csv.writer() and specify the desired delimiter using the delimiter parameter.
3. We then use the writerow() method of the CSV writer object to write rows to the CSV file, with each row separated by the specified delimiter.

We may need to suppress the end-of-line (EOL) translation in CSV file handling in Python in specific situations where precise control over line endings is necessary. Different operating systems utilize different conventions for representing line endings in text files. For instance, Windows uses \r\n (carriage return + line feed), Unix-based systems (Linux, macOS) use \n (line feed), and classic Mac OS used \r (carriage return). When reading or writing CSV files intended for compatibility across multiple platforms, suppressing EOL translation ensures that line endings are preserved exactly as they are, without automatic conversion to the platform-specific convention. To suppress EOL translation in CSV file handling in Python, we can use the newline='' parameter when opening the file with the open() function. This parameter instructs Python to suppress EOL translation and preserve the original line endings in the file.

Renaming a text file's extension to ".csv" does not automatically convert it into a CSV (Comma-Separated Values) file. To create a CSV file, we need to ensure that the file's content adheres to :

1. Content Format — A CSV file is structured with data organized into rows and columns, with each field separated by a delimiter, typically a comma (,).
2. Delimiter Usage — CSV files require a specific delimiter (usually a comma) to separate fields.
3. File Encoding — CSV files are often encoded using standard text encodings such as UTF-8 or ASCII.

(i) f = open('diary.txt', 'r') — This line opens the file diary.txt in read mode ('r'). If the file does not exist, Python will raise an error. If the file exists, the data will not be erased.

(ii) f = open('diary.txt', 'w') — This line opens the file diary.txt in write mode ('w'). If the file does not exist, Python creates new file with the specified name. If the file exists, Python will truncate existing data and over-write in the file.

The provided code snippets (a) and (b) are similar in that they both open the file poem.txt in read mode ('r'). However, they differ in how they read the contents of the file:

(a) my_file.read(): This code reads the entire content of the file poem.txt into a single string. It reads until the end of the file (EOF) is reached.

(b) my_file.read(100): This code reads the first 100 characters from the file poem.txt into a string. It reads up to the 100 number of characters or until EOF is reached, whichever comes first.

(a)

my_file = open('poemBTH.txt', 'r')
my_file.read()

God made the Earth;
Man made confining countries
And their fancy-frozen boundaries.
But with unfound boundLess Love
I behold the borderLand of my India
Expanding into the World.
HaiL, mother of religions, Lotus, scenic beauty, and sages!

This code reads the entire content of the file poemBTH.txt into a single string. Since no specific number of characters is specified, it will read until the end of the file (EOF) is reached.

(b)

my_file = open('poemBTH.txt', 'r') 
my_file.read(100)

God made the Earth;
Man made confining countries
And their fancy-frozen boundaries.
But with unfound 

This code reads the first 100 characters from the file "poemBTH.txt" into a string. It is important to note that the newline at the end of each line will also be counted as a character.

The code will result in an error because at line 3 there is a syntax error. The correct syntax is s2 = obj1.readline().

The corrected code will be:

obj1 = open("poemBTH.txt", "r")
s1 = obj1.readline()
s2 = obj1.readline()
s3 = obj1.read(15)
print(s3)
print(obj1.readline())
obj1.close()

And their fancy
-frozen boundaries.

1. obj1 = open("poemBTH.txt", "r") — This line opens the file named poemBTH.txt in read mode ("r") and assigns the file object to the variable obj1.
2. s1 = obj1.readline() — This line reads the first line from the file obj1 and assigns it to the variable s1.
3. s2 = obj1.readline() — This line reads the next line from the file obj1, starting from the position where the file pointer currently is, which is the beginning of the second line (from the previous readline() call). Then assigns it to the variable s2.
4. s3 = obj1.read(15) — This line reads the next 15 characters from the file obj1, starting from the position where the file pointer currently is, which is the beginning of third line (from the previous readline() call) and assigns them to the variable s3.
5. print(s3) — This line prints the contents of s3.
6. print(obj1.readline()) — This line attempts to read the next line from the file obj1 and print it. However, since the file pointer is already ahead by 15 characters (from the previous read(15) call), this line will start reading from where the file pointer is currently positioned i.e., from "-" up to end of line.
7. obj1.close() — This line closes the file obj1.

Let the file "contacts.txt" include following sample text:

Kumar 8574075846
Priya 5873472904
Neetu 7897656378

with open("contacts.txt", "r") as file:
    for line in file:
        name, phone = line.strip().split()
        print("Name: " + name + " \t Phone: " + phone) 

Name: Kumar     Phone: 8574075846
Name: Priya     Phone: 5873472904
Name: Neetu     Phone: 7897656378

As mentioned in the note, the output of above code fragments together in succession is as follows:

A. Output 1
God made the Earth;
Man made confining countries
And their fancy-frozen boundaries.
But with unfound boundLess Love
I behold the borderLand of my India
Expanding into the World.
HaiL, mother of religions, Lotus, scenic beauty, and sages!

B. Output 2


C. Output 3


D. Output 4

E. Output of Readlines function is
[]

After executing file1.read() in code snippet (a), the file pointer will be moved to the end of the file (EOF) because all the content has been read. Therefore, subsequent read operations, such as file1.readline(), file1.read(9), and file1.readlines(), will start from the end of the file (EOF) and will not read any further content, resulting in empty outputs for those print statements.

This code opens a CSV file named contacts.csv in append mode, as indicated by the mode "a". This mode allows new data to be added to the end of the file without overwriting existing content. It then prompts the user to enter a name and a phone number through the console using the input() function. After receiving input, it concatenates the name and phno separated by a comma, and appends a newline character '\n' to signify the end of the line. Finally, it writes this concatenated string to the CSV file using the write() method of the file object. This operation effectively adds a new record to the CSV file with the provided name and phone number.

The code asks the user to enter a name. It then searches for the name in "contacts.csv" file. If found, the name and phone number are printed as the output.

1. name = input("Enter name :") — This line prompts the user to enter a name through the console, and the entered name is stored in the variable name.
2. file = open("contacts.csv", "r") — This line opens the file contacts.csv in read mode and assigns the file object to the variable file.
3. for line in file: — This line initiates a for loop that iterates over each line in the file handle (file represents the opened file object), which enables interaction with the file's content. During each iteration, the current line is stored in the variable line.
4. if name in line: — Within the loop, it checks if the inputted name exists in the current line using the in operator.
5. print(line) — If the name is found in the current line, this line prints the entire line to the console.

The code is calculating the number of lines present in the file poemBTH.txt.

7

1. f = open("poemBTH.txt", "r") — This line opens a file named poemBTH.txt in read mode ("r") and assigns the file object to the variable f.
2. nl = 0 — This line initializes a variable nl to 0.
3. for line in f: — By iterating over the file handle using a for loop as shown, we can read the contents of the file line by line.
4. nl += 1 — Within the for loop, this statement increments the value of nl by 1 for each iteration, effectively counting the number of lines in the file.
5. print(nl) — After the for loop completes, this statement prints the value of nl, which represents the total number of lines in the file.

Dunzo

1. import pickle — Imports the pickle module, which is used for serializing and deserializing Python objects.
2. ID = {1: "Ziva", 2: "53050", 3: "IT", 4: "38", 5: "Dunzo"} — Defines a dictionary named ID with keys and values.
3. fin = open("Emp.pkl", "wb") — Opens a file named Emp.pkl in binary write mode ("wb").
4. pickle.dump(ID, fin) — Serializes the ID dictionary and writes it to the file handle fin using the pickle.dump() function.
5. fin.close() — Closes the file fin after writing the pickled data.
6. fout = open("Emp.pkl", 'rb') — Opens the file Emp.pkl again, this time in binary read mode ("rb"), to read the pickled data.
7. ID = pickle.load(fout) — Deserializes the data from the file fout using the pickle.load() function and assigns it to the variable ID. This effectively restores the original dictionary from the pickled data.
8. print(ID[5]) — Prints the value associated with key 5 in the restored ID dictionary, which is "Dunzo".

The code raises an error because write() function does not work in binary file. To write an object on to a binary file dump() function of pickle module is used.

This code will produce no output.

By default, csv.reader() uses a comma (,) as the delimiter to separate values in a CSV file. But the delimiter in the file data.csv is semicolon (;), hence the rows won't split correctly, leading to each row being treated as a single string. When the code checks if the row contains the word 'the', it will only print rows where 'the' appears in the entire row. Therefore, the given code will not output anything.

import csv
f = open('attendees1.csv') #error
csv_f = csv.writer(f)

To use the csv.writer() function, the file should be opened in write mode ('w'). The corrected code is :

import csv
f = open('attendees1.csv', 'w')
csv_f = csv.writer(f)

import csv
f = open('attendees1.csv') #error 1
csv_f = csv.reader() #error 2
for row in csv_f:
    print(row)

1. To use the csv.reader() function, the file should be opened in read mode ('r').
2. The reader object should be in syntax <name-of-reader-object> = csv.reader(<file-handle>).

The corrected code is :

import csv
f = open('attendees1.csv', 'r')
csv_f = csv.reader(f)
for row in csv_f:
    print(row)

import pickle
data = ['one', 2, [3, 4, 5]]
with open('data.dat', 'wb' : #error 1
  pickle.dump(data) #error 2

1. There is a syntax error in the open() function call. The closing parenthesis is missing in the open() function call. Also, file handle is not mentioned.
2. The pickle.dump() function requires two arguments - the object to be pickled and the file object to which the pickled data will be written. However, in the provided code, the pickle.dump() function is missing the file object argument.

The corrected code is :

import pickle
data = ['one', 2, [3, 4, 5]]
with open('data.dat', 'wb') as f:
  pickle.dump(data, f)

Let the file "input.txt" include the following sample text:

In    the beginning  there  was    chaos.
Out of  the chaos  came order.
The universe  began to take shape.
Stars  formed  and galaxies were  born.
Life   emerged  in the  vast  expanse.

with open("input.txt", 'r') as f:
    with open("output.txt", 'w') as fout:
        for line in f:
            modified_line = ' '.join(line.split())
            fout.write(modified_line + '\n')

The file "output.txt" includes following text:

In the beginning there was chaos.
Out of the chaos came order.
The universe began to take shape.
Stars formed and galaxies were born.
Life emerged in the vast expanse.

Let the file "sports.dat" include the following sample records:

Athletics - Rahul
Swimming - Tanvi
Athletics - Akash
Cycling - Kabir
Athletics - Riya

def filter_records(input_file, output_file):
    with open(input_file, 'r') as f_in:
        with open(output_file, 'w') as f_out:
            for line in f_in:
                event, participant = line.strip().split(' - ')
                if event == 'Athletics':
                    f_out.write(line)

 
filter_records('sports.dat', 'Athletic.dat')

The file "Atheletic.dat" includes following records:

Athletics - Rahul
Athletics - Akash
Athletics - Riya

Let the file "telephone.txt" include the following sample records:

Arvind 7258031 
Sachin 7259197
Karuna 8479939

with open("telephone.txt", "r") as file:
    f = file.readlines()
    for line in f:
        name, number = line.split()
        print(name, '\t\t' ,number)

Arvind           7258031
Sachin           7259197
Karuna           8479939

Let the file "Poem.txt" include the following sample text:

To be or not to be, that is the question.
The quick brown fox jumps over the lazy dog.
To infinity and beyond!
The sun sets in the west.
To be successful, one must work hard.

to_count = 0
the_count = 0

with open("Poem.txt", 'r') as file:
    for line in file:
        words = line.split()
        for word in words:
            if word.lower() == 'to':
                to_count += 1
            elif word.lower() == 'the':
                the_count += 1

print("count of 'to': ", to_count)
print("count of 'the': ", the_count)

count of 'to': 4
count of 'the': 5

Let the file "STORY.TXT" include the following sample text:

Updated information
As simplified by official websites.

def AMCount(file_path):
    count_a = 0
    count_m = 0
    with open(file_path, 'r') as file:
        ch = ' '
        while ch:
            ch = file.read(1)
            ch_low = ch.lower()
            if ch_low == 'a':
                count_a += 1
            elif ch_low == 'm':
                count_m += 1

    print("A or a:", count_a)
    print("M or m:", count_m)

AMCount("STORY.TXT")

A or a: 4 
M or m: 2

Let the file "Article.txt" include the following sample text:

PYTHON is a Popular Programming Language.

with open("Article.txt", 'r') as file:
    text = file.read()
    count = 0
    for char in text:
        if char.isupper():
            count += 1

print(count)

9

Let the file "MYNOTES.TXT" include the following sample text:

Kangaroo is a mammal native to Australia.
Lion is a large carnivorous.
Koala is an arboreal herbivorous.
Elephant is a large herbivorous mammal.

def display_lines(file_name):
    with open(file_name, 'r') as file:
        line = file.readline()
        while line:
            if line.strip().startswith('K'):
                print(line.strip())
            line = file.readline()

display_lines("MYNOTES.TXT")

Kangaroo is a mammal native to Australia.
Koala is an arboreal herbivorous.

Let "STORY.TXT" file contain the following text:

Once upon a time, there was a little boy named Jay
He had a dog named Leo

def DISPLAYWORDS(file_name):
    with open(file_name, 'r') as file:
        for line in file:
            words = line.split()
            for word in words:
                if len(word) < 4:
                    print(word)
        for line in file:
            words = line.split()
            for word in words:
                if len(word) < 4:
                    print(word)

DISPLAYWORDS("STORY.TXT")

a
was
a
boy
Jay
He
had
a
dog
Leo

lower_file = open("LOWER.txt", 'w')
upper_file = open("UPPER.txt", 'w')
others_file = open("OTHERS.txt", 'w')
ans = 'y'
while ans == 'y':
    char = input("Enter a character: ")
    if char.islower():
        lower_file.write(char + "\n")
    elif char.isupper():
        upper_file.write(char + "\n")
    else:
        others_file.write(char + "\n")
    ans = input("Want to enter a character? (y/n): ")
lower_file.close()
upper_file.close()
others_file.close()

Enter a character: e
Want to enter a character? (y/n): y
Enter a character: A
Want to enter a character? (y/n): y
Enter a character: D
Want to enter a character? (y/n): y
Enter a character: c
Want to enter a character? (y/n): y
Enter a character: 7
Want to enter a character? (y/n): y
Enter a character: @
Want to enter a character? (y/n): n

The file "LOWER.txt" includes:

e
c

The file "UPPER.txt" includes:

A
D

The file "OTHERS.txt" includes:

7
@

The file "LINES.TXT" contains the following lines:

A boy is playing there.
There is a playground.
An aeroplane is in the sky.
Alphabets & numbers are allowed in password.

def count_lines(file_name):
    count = 0
    with open(file_name, 'r') as file:
        for line in file:
            if line.strip().startswith('A'):
                count += 1
    print(count)

count_lines("LINES.TXT")

3

Let the sample file "myfile.txt" contain the following text:

Hello world! This is a test file.
It contains some characters until the first $ is encountered.

count = 0
with open("myfile.txt", 'r') as file:
    while True:
        char = file.read(1)  
        if char == '$' or not char:  
            break
        count += 1
print(count)

78

with open('STRS.txt', 'w') as filout:
    ans = 'y'
    while ans == 'y':
        string = input("Enter a string: ")
        filout.write(string + "\n")  
        ans = input("Want to enter more strings?(y/n)...")    

Enter a string: Hello
Want to enter more strings?(y/n)...y
Enter a string: world!
Want to enter more strings?(y/n)...n

The file "STRS.txt" includes:

Hello
world!

Let the file "staff.dat" include following data:

Staff1 = {'Staffcode': 'S0102', 'Name': 'Sanya'}
Staff2 = {'Staffcode': 'S0104', 'Name': 'Anand'}
Staff3 = {'Staffcode': 'S0105', 'Name': 'Aditya'}

import pickle

def search_and_display_staff(staff_code):
    found = False

    try:
        file = open("staff.dat", "rb")
        
        while True:
            staff_data = pickle.load(file)
            if staff_data['Staffcode'] == staff_code:
                print("Staffcode:", staff_data['Staffcode'])
                print("Name:", staff_data['Name'])
                found = True
                
    except EOFError:
        if found == False:
            print("End of file reached. No such records found.")
        else:
            print("Search Successful")
        file.close()

search_and_display_staff('S0105')

Staffcode: S0105
Name: Aditya

Let the file "COMPANY.DAT" include following data:

Company1 = {'CompID': '1001', 'CName': 'ABC', 'Turnover': 500000}
Company2 = {'CompID': '1003', 'CName': 'DEF', 'Turnover': 600000}
Company3 = {'CompID': '1005', 'CName': 'LMN', 'Turnover': 900000}

import pickle

def company(comp_id):
    found = False

    try:
        file = open("COMPANY.DAT", "rb")
        while True:
            company_data = pickle.load(file)
            if company_data['CompID'] == comp_id:
                print("Company ID:", company_data['CompID'])
                print("Company Name:", company_data['CName'])
                print("Turnover:", company_data['Turnover'])
                found = True
                
            
    except EOFError:
        if found == False:
            print("End of file reached. No such records found.")
        else:
            print("Search Successful")
        file.close()

company('1005')

Company ID: 1005
Company Name: LMN
Turnover: 900000

Let the dictionary contained in file "TRAIN.DAT" be as shown below:

Train1 = {'Tno': '1234', 'From': 'Mumbai', 'To': 'Delhi'}
Train2 = {'Tno': '5678', 'From': 'Chennai', 'To': 'Delhi'}
Train3 = {'Tno': '9012', 'From': 'Kolkata', 'To': 'Mumbai'}
Train4 = {'Tno': '3456', 'From': 'Delhi', 'To': 'Bangalore'}
Train5 = {'Tno': '7890', 'From': 'Pune', 'To': 'Delhi'}

import pickle

def search_trains():
    found = False

    try:
        file = open("TRAIN.DAT", "rb")

        while True:
            trains = pickle.load(file)
            if trains['To'] == "Delhi":
                print("Train no: ", trains['Tno'])
                print("From: ", trains['From'])
                print("To: ", trains['To'])
                found = True
                
    except EOFError:
        if found == False:
            print("End of file reached. No such records found.")
        else:
            print("Search Successful")
        file.close()

search_trains()

Train no:  1234
From:  Mumbai
To:  Delhi
Train no:  5678
From:  Chennai
To:  Delhi
Train no:  7890
From:  Pune
To:  Delhi
Search Successful

Let the file "Book.dat" include following data:

Book1 = [1001, Midnight's Children, Salman Rushdie, 29.99]
Book2 = [1004, A Suitable Boy, Vikram Seth, 59.9]
Book3 = [1003, The White Tiger, Aravind Adiga, 49.5]
Book4 = [1002, The Satanic Verses, Salman Rushdie, 39.23]

import pickle

def CreateFile():
        file = open("Book.dat", "ab")
        BookNo = int(input("Enter Book Number: "))
        Book_Name = input("Enter Book Name: ")
        Author = input("Enter Author Name: ")
        Price = float(input("Enter Price: "))
        record = [BookNo, Book_Name, Author, Price]
        pickle.dump(record, file)
        file.close()
    
def CountRec(authorName):
    count = 0
    found = False
    try:
        file = open("Book.dat", "rb")
        while True:
            record = pickle.load(file)
            if record[2] == authorName:
                count += 1
                found = True

    except EOFError:
        if found == False:
            print("End of file reached. No such records found.")
        else:
            print("Search successful")
        file.close()
        return count

CreateFile()
author = input("Enter Author name to count books: ")
print("Number of books by", author, ":", CountRec(author))

Enter Book Number: 1008
Enter Book Name: Three Thousand Stiches
Enter Author Name: Sudha Murty
Enter Price: 200
Enter Author name to count books: Salman Rushdie
Search successful
Number of books by Salman Rushdie : 2

The file "NOTES.TXT" contains:

This is a sample file.  
The file contains many sentences.   
But need only sentences which have only 5 words.

def Show_words(file_name):
    with open(file_name, 'r') as file:
        for line in file:
            words = line.strip().split()
            if len(words) == 5:
                print(line.strip())


Show_words('NOTES.TXT')

This is a sample file.  
The file contains many sentences.

Let "example.csv" file contain the following data:

Name    Age    Gender
Kavya   25     Female
Kunal   30     Male
Nisha   28     Female

import csv

with open("example.csv", 'r', newline='') as file:
    reader = csv.reader(file, delimiter='\t')
    for row in reader:
        print(row)

['Name    Age    Gender']
['Kavya   25     Female']
['Kunal   30     Male']
['Nisha   28     Female']

import csv

def write_nested_list(data, file_name):
    with open(file_name, 'w', newline='') as file:
        writer = csv.writer(file)
        writer.writerows(data)
    
def read_csv(file_name):
    with open(file_name, 'r') as file:
        reader = csv.reader(file)
        for row in reader:
            print(row)


nested_list = [['Name', 'Age', 'Gender'],
                ['Prateek', '14', 'Male'],
                ['Ananya', '24', 'Female'],
                ['Aryan', '44', 'Male']]


write_nested_list(nested_list, 'output.csv')

print("Content of 'output.csv':")
read_csv('output.csv')

['Name', 'Age', 'Gender']
['Prateek', '14', 'Male']
['Ananya', '24', 'Female']
['Aryan', '44', 'Male']

Let "original.csv" file contain the following data:

Product,Price,Quantity
Apple,1.99,100
Banana,0.99,150
Orange,2.49,80

import csv

def change_delimiter(input_file, output_file, input_delimiter, output_delimiter):
    with open(input_file, 'r', newline='') as f_in:
        reader = csv.reader(f_in, delimiter = input_delimiter)
        data = list(reader)

    with open(output_file, 'w', newline='') as f_out:
        writer = csv.writer(f_out, delimiter = output_delimiter)
        writer.writerows(data)

change_delimiter('original.csv', 'modified.csv', ',', '|')

Contents of "modified.csv":

Product|Price|Quantity
Apple|1.99|100
Banana|0.99|150
Orange|2.49|80

Let "input.csv" file contain the following data:

check1,10,A
check2,20,B
data1,30,C
check3,40,D
data2,50,E

import csv

def filter(input_file, output_file):
    with open(input_file, 'r', newline='') as f_in, open(output_file, 'w', newline='') as f_out:
        reader = csv.reader(f_in)
        writer = csv.writer(f_out)
        
        for row in reader:
            if not row[0].startswith('check'):
                writer.writerow(row)

filter('input.csv', 'output.csv')

Contents of "output.csv":

data1,30,C
data2,50,E

The difference between a binary file and CSV file is that binary files are used for storing complex data in a non-human-readable format and they store data in a sequence of bytes, while CSV files are plain text files used for storing structured tabular data in a human-readable text format.

Let the file "furdata.csv" include following data:

[1, table, 20000]
[2, chair, 12000]
[3, board, 10000]

import csv

def add():
    
    with open('furdata.csv', mode='a', newline='') as file:
        writer = csv.writer(file)
        fid = input("Enter furniture id: ")
        fname = input("Enter furniture name: ")
        fprice = float(input("Enter furniture price: "))
        writer.writerow([fid, fname, fprice])
        print("Record added successfully to 'furdata.csv'")
    
def search():
    found = False
    with open('furdata.csv', mode='r') as file:
        reader = csv.reader(file)
        print("Records of furniture with price more than 10000:")
        for row in reader:
            if len(row) == 3 and float(row[2]) > 10000:
                print("Furniture ID:", row[0])
                print("Furniture Name:", row[1])
                print("Furniture Price:", row[2])
                print()
                found = True
    
    if found == False:
        print("No records of furniture with price more than 10000 found")

add()
search()

Enter furniture id: 9
Enter furniture name: desk
Enter furniture price: 3000
Record added successfully to 'furdata.csv'
Records of furniture with price more than 10000:
Furniture ID: 1
Furniture Name:  table
Furniture Price:  20000

Furniture ID: 2
Furniture Name:  chair
Furniture Price:  12000