Data File Handling

Both A and R are true and R is the correct explanation of A.

Explanation
In Python, a file is used to store information on a named location in the secondary storage device. Files can be classified into different types such as program files and data files. Program files contain Python scripts (with .py extension), while data files store specific data relevant to their purpose. This classification helps organize and manage files based on their content and usage.

Both A and R are true and R is the correct explanation of A.

Explanation
The file access mode used to add or append data in the file is 'a'. In the 'a' access mode, the file pointer is at the end of the file if the file exists, and the text will be appended at the end of the existing file. If the file does not exist, Python will create a new file and write data to it.

A is false but R is true.

Explanation
Binary files are not an advanced version of text files but rather a different type of file. They serve different purposes and handle data differently. Text files store data as human-readable text using characters, while binary files store data using binary digits (0s and 1s), which are directly understood by computers.

Both A and R are true and R is the correct explanation of A.

Explanation
To work with binary files in Python, we indeed need to import the pickle module. The pickle module is used for serializing and deserializing Python objects and contains two important methods, load() and dump(), for reading and writing data to binary files, respectively.

Both A and R are true and R is the correct explanation of A.

Explanation
The close() method in Python is used to flush any unwritten information, and close the file object, preventing further writing. While closing a file, the system frees up resources such as CPU processor time and memory that were allocated to the file.

Both A and R are true and R is the correct explanation of A.

Explanation
The readline() method in Python reads one complete line from a text file and can also be used to read a specified number (n) of bytes of data from a file up to the newline character (\n).

Both A and R are true but R is not the correct explanation of A.

Explanation
CSV stands for Comma-Separated Values. CSV file format is commonly used for transferring and storing data in a plain text format, especially when dealing with spreadsheet or database-like information.

Both A and R are true and R is the correct explanation of A.

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.

A is true but R is false.

Explanation
In a text file, information is stored in the form of ASCII or Unicode characters. Each line in a text file is terminated by a special character known as End of Line (EOL), and by default, this EOL character is the newline character (\n), which serves as the delimiter for lines in text files.

file1 = open("c:\\test.txt", "r")

Reason — The syntax for 'open()' is: <file variable>/<file object or handle> = open(file_name, access_mode). Therefore, according to this syntax, file1 = open("c:\\test.txt", "r") is the correct statement to open a file for reading. The access mode "r" indicates that the file should be opened in read mode.

fobj = open("c:\\test.txt", "w")

Reason — The syntax for 'open()' is: <file variable>/<file object or handle> = open(file_name, access_mode). Therefore, according to this syntax, fobj = open("c:\\test.txt", "w") is the correct statement to open a file for writing. The access mode "w" indicates that the file should be opened in write mode.

fobj = open("c:\\test.txt", "a")

Reason — The syntax for 'open()' is: <file variable>/<file object or handle> = open(file_name, access_mode). Therefore, according to this syntax, fobj = open("c:\\test.txt", "a") is the correct statement to open a file for writing. The access mode "a" indicates that the file should be opened in append mode.

All of these.

Reason — When we open a file for reading ('r' mode) that doesn't exist, Python raises an error (FileNotFoundError). When we open a file for writing ('w' mode) and the file doesn't exist, a new file is created with the specified name. If we open a file for writing ('w' mode) and the file already exists, the existing file is overwritten with the new file.

fobj.read(2)

Reason — The command fobj.read(2) is used to read two characters from a file object fobj. The read() method without arguments (fobj.read()) reads the entire content of the file, while fobj.readline() reads a single line, and fobj.readlines() reads all lines and returns them as a list.

fobj.read()

Reason — The command fobj.read() is used to read the entire contents of the file as a string from a file object fobj.

True

Reason — Initially, the variable f is assigned None. The code then enters a for loop that runs five times (for i in range(5)). Inside the loop, a file named "data.txt" is opened in write mode ("w") using the with statement. If the value of i is greater than 2, the loop breaks using break. After the loop breaks, the print(f.closed) statement is executed outside the with block. Since the file object f was opened within the with block, it is automatically closed when the block exits. The f.closed attribute returns True if the file is closed, which happens because of the with statement's automatic closing behavior.

fobj.readline()

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

fobj.readlines()

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

A list of strings

Reason — The readlines() method reads all lines from the file into a list and returns a list of strings, where each string represents a line from the file, separated by the new line character '\n'.

pickle

Reason — The dump() function is part of the pickle module in Python. Therefore, to use the dump() function, we need to import the pickle module.

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>).

All of these

Reason — The basic I/O streams related to files are Standard Input (stdin), Standard Output (stdout), and Standard Error (stderr). Standard Input (stdin) is used for receiving input, Standard Output (stdout) is the stream for regular output, and Standard Error (stderr) is specifically designated for error messages and warnings.

fobj.writelines(sequence)

Reason — The syntax for a file object to write sequence data using the writelines() function is fileobject.writelines(sequence). Therefore, fobj.writelines(sequence) is correct.

read, append

Reason — In file handling, the term "r" stands for "read" mode, which is used when we want to read data from a file and "a" stand for "append" mode, which is used when we want to add data to the file.

rw

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

fp.seek(offset, 0)

Reason — The syntax for relative referencing is f.seek(offset, from_what). The statement f.seek(offset, 0) is used to change the file position to an offset value from the start, where 0 sets the reference point at the beginning of the file.

In r+ mode, the pointer is initially placed at the beginning of the file and the pointer is at the end for w+

Reason — In 'r+' mode (read and write), the pointer is initially placed at the beginning of the file. In 'w+' mode (read and write), the pointer is placed at the end of the file.

Comma Separated Values

Reason — The CSV stands for "Comma Separated Values".

csv

Reason — For working with CSV files in Python, there is an inbuilt module called csv. It is used to read and write tabular data in CSV format.

wb+

Reason — 'wb+' mode is used for both writing and reading from a binary file.

fp.tell()

Reason — The tell() method returns the current position of the file read/write pointer within the file. The correct syntax to use it is fp.tell(). Therefore, the correct statement used to retrieve the current position within the file is fp.tell().

results in an error

Reason — If no arguments are passed to the seek() method in Python, it will result in an error because the method expects at least one argument to specify the new position within the file.

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.

reader()

Reason — The reader() function is used to store every record in a CSV file in a reader object, where each record is represented as a list.

string, str()

Reason — For storing numeric data in a text file, it needs to be converted into a string using the 'str()' function. This is because text files store data in the form of characters, and converting numeric data to a string allows it to be written to the file as a sequence of characters.

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.dat in read and write mode are:

1. file1 = open("C:\\Myfiles\\text1.dat", "rb+")

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

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

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.

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:

(a) 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.

(b) 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.

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

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!

(a) 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 file2 in read mode and process it. Similarly, for file3 also we reuse the same file object f.

(b) 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) 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.

(b) 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.

It is a good practice to close a file once we are done with the read and write operations. When we close a file, the system frees the memory allocated to it. Python ensures that any unwritten or unsaved data is flushed (written) to the file before it is closed. Therefore, it is always advised to close the file once our work is done.

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.

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 "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 "Poem.txt" include the following sample text:

PYTHON is a Popular Programming Language.

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

print(count)

9

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
@

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

Samyukta, Mumbai, 35
Anubhav, Chennai, 28
Aniket, Hyderabad, 42
Sarth, Bangalore, 31

f = open('Persons.txt', 'r')
lines = f.readlines()
for line in lines:
    data = line.strip().split(',')
    if len(data) >= 3 and int(data[2]) > 30:
        print('Name:', data[0], 'Address:', data[1])
f.close()        

Name: Samyukta Address:  Mumbai
Name: Aniket Address:  Hyderabad
Name: Sarth Address:  Bangalore

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

A boy is playing there.
There is a playground.
An aeroplane is in the sky.
A cricket match is being played.

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

1. File Mode: 'r+'

fh = open("example.txt", "r+")

2. File Mode: 'wb'

fh = open("bfile.dat", "wb")

3. File Mode: 'a+'

fh = open("try.txt", "a+")

4. File Mode: 'rb'

fh = open("btry.dat", "rb")

It is a good practice to close a file once we are done with the read and write operations. When we close a file, the system frees the memory allocated to it. Python ensures that any unwritten or unsaved data is flushed (written) to the file before it is closed. Therefore, it is always advised to close the file once our work is done. If we do not close file explicitly it will close automatically later when it's no longer in use or when the program terminates, without displaying any error message.

The code given in (a) will open file "practice.txt" in read mode and will read 10 bytes from it. Also, it will not close the file explicitly. On the other hand, the code given in (b) will open file "practice.txt" in read mode and will read the entire content of the file. Furthermore, it will automatically close the file after executing the code due to the with clause.

f = open("new.txt", "w")
while True:
    st = input("Enter next line:")
    if st == "END":
        break
    f.write(st + '\n')
f.close()

f = open("new.txt", "r")
while True:
    st = f.readline()
    if not st:
        break
    if st[0].isupper():
        print(st)
f.close()

Enter next line:Hello world
Enter next line:welcome to     
Enter next line:Python programming
Enter next line:END
Hello world

Python programming

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

Bees hum
leaves rustle
Waves crash
nature's voice whispers

def insert_sentence(file_path, sentence):
    file = open(file_path, 'a')
    file.write(sentence + '\n')
    file.close()
insert_sentence("insert.txt", "life's essence glimmers")

The "insert.txt" file includes following text:

Bees hum
leaves rustle
Waves crash
nature's voice whispers
life's essence glimmers

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

The cat sleeps
The dog barks
The cat jumps
The sun shines

word_index = {}
file = open('Story.txt', 'r')
line_number = 1
lines = file.readlines()
for line in lines:
    words = line.strip().split()
    for word in words:
        if word in word_index:
            word_index[word].append(str(line_number))
        else:
            word_index[word] = [str(line_number)]
    line_number += 1
file.close()

index_file = open('index.txt', 'w')
for word, line_numbers in word_index.items():
    line_numbers_str = ", ".join(line_numbers)
    index_file.write(word + ":" + line_numbers_str + "\n")
index_file.close()

The "index.txt" file includes following text:

The:1, 2, 3, 4
cat:1, 3
sleeps:1
dog:2
barks:2
jumps:3
sun:4
shines:4

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

Welcome to the Garden of Dreams 
#where the ordinary becomes extraordinary
#the impossible becomes possible.

file_name = input("Enter the filename: ")
file = open(file_name, 'r')
lines = file.readlines()
for line in lines:
    if '#' in line:
        print(line)
file.close()

Enter the filename: notes.txt
#where the ordinary becomes extraordinary
#the impossible becomes possible.

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

[2022-04-15 10:00:00] INFO: Application started
[2022-04-15 10:05:00] ERROR: Database connection failed
[2022-04-15 10:10:00] WARNING: Disk space low
[2022-04-15 10:15:00] INFO: User logged in: username=john, ip_address=192.168.1.100

file_name = input("Enter the filename: ")
f = open(file_name, 'r')
lines = f.readlines()
for line in lines[::-1]:
    print(line.rstrip())  
f.close()

Enter the filename: logs.txt 
[2022-04-15 10:15:00] INFO: User logged in: username=john, ip_address=192.168.1.100
[2022-04-15 10:10:00] WARNING: Disk space low
[2022-04-15 10:05:00] ERROR: Database connection failed
[2022-04-15 10:00:00] INFO: Application started

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

  The sky is blue\n 
  
  Clouds float gently in the sky.   
  
  Birds sing sweet melodies.   

file = open('sample.txt', 'r')
lines = file.readlines()
original_size = 0
for line in lines:
    original_size += len(line)
print("Original file size:", original_size)
file.close()

file = open('sample.txt', 'r')
cleaned_size = 0
for line in file:
    cleaned_line = line.strip()
    if cleaned_line:
        cleaned_size += len(cleaned_line)
file.close()
print("Cleaned file size:", cleaned_size)

Original file size: 126
Cleaned file size: 74

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

Dew on petals, morning's gift.
silent moon, silver glow.
Winds whisper, secrets shared.
rain's embrace, earth's renewal.

def Remove_Lowercase(input_file, output_file):
    input_file = open(input_file, 'r')
    output_file = open(output_file, 'w')
    for line in input_file:
        if line.strip() and line[0].isupper():
            output_file.write(line)
    input_file.close()
    output_file.close()

input_file = 'file1.txt'
output_file = 'file2.txt'
Remove_Lowercase(input_file, output_file)

The file "file2.txt" includes following text:

Dew on petals, morning's gift.
Winds whisper, secrets shared.

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

Soft whispers of the wind.
A melody in the trees.
Sun-kissed petals dance.
A garden's quiet song.

file_name = 'f1.txt'
line_number = 1
f = open(file_name, 'r')
for line in f:
    print("Line", line_number, ":", line.strip())
    line_number += 1
f.close()

Line 1 : Soft whispers of the wind.
Line 2 : A melody in the trees.
Line 3 : Sun-kissed petals dance.
Line 4 : A garden's quiet song.

(a) To open a file named "RESULT.DAT" for output:
file = open("RESULT.DAT")

(b) To go to the end of the file at any time:
file.seek(0, 2)

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

1001, Ankit Singh, 50000, Manager
1002, Neha Patel, 45000, Developer

file = open("emp.txt", "a")
file.write("1003, Manoj Tiwari, 48000, Analyst\n")
file.write("1004, Aarti Gupta, 52000, Engineer\n")

The file "emp.txt" include the following text:

1001, Ankit Singh, 50000, Manager
1002, Neha Patel, 45000, Developer
1003, Manoj Tiwari, 48000, Analyst
1004, Aarti Gupta, 52000, Engineer

The first code opens 'file.txt' in read mode, initializes a file object (fp) for further file operations, and reads its entire content using fp.read(). The second code also opens 'file.txt' in read mode, initializes a file object (fp) for further file operations, but it doesn't perform any read operation.

Hello, world! 
How are you?

The code first opens a file named 'output.txt' in write mode ('w'), writes the strings 'Hello, world!' and 'How are you?' to the file with a newline character in between, creating a new line between the two strings in the file. It then closes the file and reopens it again in read mode (default mode). Finally, it reads the entire content of the file and prints it.

30

The code opens the file 'ABC.txt' in read mode ('r') and creates a file object named f1. The next line, size = len(f1.read()), reads the entire contents of the file 'ABC.txt', returning a string containing the file's contents. Then, len() calculates the length of this string and assigns it to the variable size. After the f1.read() operation, the file pointer is positioned at the end of the file. The code then prints the size. The subsequent line, data = f1.read(5), attempts to read the first 5 characters from the file 'ABC.txt' using f1.read(5). However, since the file pointer is already at the end of the file, there are no characters left to read. Therefore, this read(5) operation will return an empty string. Finally, the code prints the value of data, which is an empty string.

4
8

The code imports pickle module in Python. Initially, it creates two lists: list1 with numbers from 2 to 10 and list2 as an empty list. It then iterates through list1 and appends numbers divisible by both 2 and 4 to list2. After that, it opens a binary file named "bin.dat" in write-binary mode ("wb") and uses pickle.dump() to serialize list2 and write it to the file. The file is then closed. Later, the code opens the same file in read-binary mode ("rb") and uses pickle.load() to deserialize the data from the file into the variable data. Finally, it iterates through data and prints each element, which in this case are the numbers from list2 that satisfy the conditions (divisible by both 2 and 4).

Let the file "Student.dat" include the following sample data:

Radhika 80
Shaurya 35
Sonia 38
Anirudh 45

import pickle

def display_students(file_name):
        file = open(file_name, 'rb')
        students = pickle.load(file) 
        for student in students:
            name = student[0]
            score = student[1]
            if score < 40:
                print(name)
        file.close()
display_students('student.dat')

Shaurya
Sonia

Let the file "PRODUCT.dat" include the following sample data:

{'prod_code': 'AB', 'prod_desc': 'Books', 'stock': 50}
{'prod_code': 'AC', 'prod_desc': 'Pens', 'stock': 75}
{'prod_code': 'AD', 'prod_desc': 'Pencils', 'stock': 30}

import pickle

def update_stock(file_name, product_code, new_stock):
    products = [] 
    f = open(file_name, 'rb')
    while True:
        try:
            product = pickle.load(f)
            products.append(product)
        except EOFError:
            break
    f.close()               
    updated = False
    for product in products:
        if product['prod_code'] == product_code:
            product['stock'] = new_stock
            updated = True
            break  
    f = open(file_name, 'wb')
    for product in products:
       pickle.dump(product, f)
    f.close()
P_code = input("Enter the product code: ")
New = int(input("Enter the new stock value: "))
update_stock('PRODUCT.DAT', P_code, New)

Enter the product code: AB
Enter the new stock value: 100

The file "PRODUCT.dat" include the following updated data:

{'prod_code': 'AB', 'prod_desc': 'Books', 'stock': 100}
{'prod_code': 'AC', 'prod_desc': 'Pens', 'stock': 75}
{'prod_code': 'AD', 'prod_desc': 'Pencils', 'stock': 30}

Let the file "STUDENT.dat" include the following sample data:

[['101', 'Aishwarya', 97.0], 
['102', 'Sakshi', 85.0], 
['103', 'Prateek', 70.0]]

import pickle

def display_students(filename):
        file = open(filename, 'rb')
        student_records = pickle.load(file)
        above_75 = []
        for student in student_records:
            if student[2] > 75.0:
                above_75.append(student)
        if above_75:
            print("Students with percentage above 75:")
            for student in above_75:
                print("Admission Number:", student[0], "Name:", student[1], "Percentage:", student[2])
        file.close()
display_students("STUDENT.DAT")

Students with percentage above 75:
Admission Number: 101 Name: Aishwarya Percentage: 97.0
Admission Number: 102 Name: Sakshi Percentage: 85.0

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+")

(a) To open a text file "BOOK.TXT" in read and append mode :
file_read_append = open("BOOK.TXT", "a+")

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

(c) To open a text file "BOOK.TXT" in append mode :
file_append = open("BOOK.TXT", "a")

The code imports the CSV module, opens 'contacts.csv' in append mode, prompts the user for input of a name and phone number, writes data to the CSV file, and then closes the file.

Let the file "contacts.csv" include the following sample data:

Aniketh,9876546707
Sanjeeth,8976548689
Amrutha,6786778908

import csv
with open("con.csv", "r") as file:
    csvreader = csv.reader(file)
    for row in csvreader:
        if row:
            name = row[0]
            phone = row[1]
            print("Name:", name,"\t\t" "Phone:", phone)

Name: Aniketh         Phone: 7868478767
Name: Sanjeeth        Phone: 6766474789
Name: Amrutha         Phone: 8749374678

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.

import pickle

with open("item.dat", 'wb') as itemfile:
    n = int(input("How many records to be entered? "))
    for i in range(n):
        ino = int(input("Enter item no: "))
        iname = input("Enter item name: ")
        qty = int(input("Enter quantity: "))
        price = float(input("Enter price: "))
        item = {"Item no": ino, "Item Name": iname, "Qty": qty, "Price": price}
        pickle.dump(item, itemfile)
    print("Successfully written item data")


with open("item.dat", "rb") as file:
    try:
        while True:
            item = pickle.load(file)
            print("\nItem No:", item["Item no"])
            print("Item Name:", item["Item Name"])
            print("Quantity:", item["Qty"])
            print("Price per item:", item["Price"])
            print("Amount:", item["Qty"] * item["Price"])
    except EOFError:
        pass  

How many records to be entered? 5
Enter item no: 11
Enter item name: Mobile
Enter quantity: 4
Enter price: 20000
Enter item no: 12
Enter item name: Laptop
Enter quantity: 2
Enter price: 35000
Enter item no: 13
Enter item name: Computer
Enter quantity: 1
Enter price: 50000
Enter item no: 14
Enter item name: Television
Enter quantity: 4
Enter price: 25000 

Item No: 11
Item Name: Mobile
Quantity: 4
Price per item: 20000.0
Amount: 80000.0

Item No: 12
Item Name: Laptop
Quantity: 2
Price per item: 35000.0
Amount: 70000.0

Item No: 13
Item Name: Computer
Quantity: 1
Price per item: 50000.0
Amount: 50000.0

Item No: 14
Item Name: Television
Quantity: 4
Price per item: 25000.0
Amount: 100000.0

import csv

with open("Groceries.csv", mode = 'w', newline = '') as file:
    writer = csv.writer(file)
    
    while True:
        item_code = int(input("Enter Item Code: "))        
        name = input("Enter Name of the Item: ")
        price = float(input("Enter Price: "))
        quantity = int(input("Enter Quantity: "))
        
        writer.writerow([item_code, name, price, quantity])
        choice = input("Wish to enter more records (Y/N)?: ")
        if choice.upper() == 'N':
            break

The file "Groceries.csv" includes following records:

101,Soaps,45.5,5
102,Atta,34.0,2
103,Maggie,70.0,1

True

Reason — An absolute path always starts from the root folder, which is the top-level directory in a file system.

False

Reason — It is necessary to always create the file in the same default folder where Python has been installed.

True

Reason — There is no delimiter for a line in a binary file because binary files store data in a sequence of binary digits (bits and bytes) that represent the actual information being stored, such as numbers, images, audio, or other types of data.

False

Reason — Binary files store data in a sequence of binary digits (bits and bytes), not in ASCII or Unicode characters.

False

Reason — The readline() function reads one line at a time from a file, starting from the current cursor position up to and including the end of the line character (\n).

True

Reason — The close() function breaks the link between the file object and the file on the disk. It flushes any unwritten information and closes the file object, preventing further writing operations.

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 will raise FileNotFound error.

False

Reason — The default file open mode in Python is read mode ('r'). If the mode is not specified when opening a file, Python assumes it to be in read mode by default.

False

Reason — Opening a file in append mode 'a' for text files or 'ab' for binary files does not erase the previous data. Instead, it allows data to be added to the end of the file without overwriting or erasing existing content.

True

Reason — In Python, a file mode defines the types of operations that can be performed on the file, such as reading, writing, appending, etc.

False

Reason — A stream is defined as a sequence of bytes or bits.

True

Reason — The readlines() function reads all lines from the file into a list. It starts reading from the cursor position up to the end of the file and returns a list of strings, with each string separated by the newline character '\n'.

True

Reason — Data maintained inside the file is termed as "persistent" data, i.e., it is permanent in nature. Python allows us to read data from and save data to external text files permanently on secondary storage media.

True

Reason — The 'with' statement ensures that all resources allocated to file objects are deallocated automatically once we stop using the file. In the case of exceptions also, we are not required to explicitly close the file using the 'with' statement.

True

Reason — The csv module in Python can handle CSV files correctly irrespective of the operating system on which the files were created. This module facilitates the reading and writing of tabular data in CSV format.

False

Reason — The csv module in Python needs to be explicitly imported into the program using the import csv statement before it can be used for reading CSV files. It's not automatically available.

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.

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 — The reader object in the csv module is an iterable that provides access to each line of a CSV file, with each line represented as a list of fields.

True

Reason — The writerow() method in the csv module allows us to write a list of fields to a CSV file.

True

Reason — The comma (,) is the most popular and default delimiter for a CSV file. This means that values in the file are separated by commas by default.

True

Reason — The tell() function returns the current position of file read/write pointer within the file.

True

Reason — In the seek() method of Python, the offset argument indicates the number of bytes by which the file read/write pointer should be moved.

False

Reason — If the offset value is set to 2, end of the file would be taken as seek position.