Programming In Python

The pickle.dump() method is used to write data to a binary file.
It serializes a Python object and writes it to an open binary file in write mode,
commonly opened with 'wb'.
If the file is opened in read-only binary mode ('rb'),
trying to write using pickle.dump() will cause an error,
because the file does not allow writing.
Therefore, Assertion (A) is true.
However, Reason (R) is false because pickle.dump() does not read;
instead, pickle.load() is used to read from a binary file.
Hence, the correct choice is (C).

In Python, the dict() function is a built-in constructor
that creates a new dictionary object.
It can take key-value pairs or other mappings to create a dictionary.
keys(), values(), and items() are methods that work on an existing dictionary,
but they do not create a new dictionary.
keys() returns a view of the dictionary’s keys,
values() returns a view of its values,
and items() returns a view of its key-value pairs as tuples.
Only dict() actually creates and returns a dictionary object.
Therefore, option (A) is correct.

The variable N is a string with the value `'5'`.
Inside the try block, print('WORD' + N, end='#') concatenates `'WORD'` and `'5'`.
Since both are strings, the concatenation works without error.
So, `'WORD5'` is printed followed by `#`.
Since no exception occurs, the except block is skipped.
The finally block always executes, so `'OVER'` is printed immediately after.
The final output is `'WORD5#OVER'`.
Therefore, option (B) is the correct answer.

A function named Change is defined that takes N as a parameter.
Inside the function, N is increased by 10 and then printed with `$ $15`.
So, option (A) is the correct answer.

In this question, a dictionary D is defined with keys `'S01'` and `'S02'` and values 95 and 96 respectively.
The for loop iterates over D.
When a for loop iterates over a dictionary in Python, it iterates over the keys by default.
So, I takes the value `'S01'` first, then `'S02'`.
Inside the loop, the print() function prints the key and adds `#` at the end without moving to a new line.
Therefore, the output will be `S01#S02#`.
It will not print the values 95 and 96 because only the keys are accessed in the loop.
So, option (A) is the correct answer.

In Python, the is operator checks for object identity,
which means it returns True if two variables point to the same memory location.
This is different from the equality operator == which checks if the values are the same.
For example, two identical lists may have equal values but not the same identity.
The is not operator checks for the opposite — it returns True if the variables do not share the same identity.
The and and or operators are logical operators and do not check memory locations.
Therefore, the operator that checks if both variables refer to the same object in memory is is.
So, the correct answer is option (A).

The list L is defined as ['TIC', 'TAC'].
The slicing notation [::-1] is used to reverse the entire list.
So, L[::-1] will reverse the order of the elements in the list.
The first element 'TIC' will move to the last position,
and the second element 'TAC' will move to the first position.
Therefore, the output will be ['TAC', 'TIC'].
Options (A) and (C) show the reversed strings, but the strings themselves are not reversed — only the list is reversed.
So, option (D) is the correct answer.

The print() function in Python prints objects to the standard output.
Its syntax allows you to pass multiple positional arguments first, followed by keyword arguments.
Common keyword arguments include sep for separator and end for line ending.
Option (A) is valid: it prints `"A"` and `10` with end="*" to modify the line ending.
Option (C) is valid: it prints `"A"` and `10` with sep="*" between them.
Option (D) is valid: `"A"*10` evaluates to `"AAAAAAAAAA"`, which is fine.
Option (B) is invalid because it mixes positional arguments after a keyword argument.
In Python, positional arguments must come first — any positional argument after a keyword argument raises a SyntaxError.
Therefore, the invalid statement is option (B).

In Python, an identifier is a name used to identify a variable, function, class, module, or object.
An identifier must not be a reserved keyword or built-in keyword in Python.
Options (A) global, (C) def, and (D) with are all Python keywords, so they cannot be used as identifiers.
Option (B) Break starts with an uppercase `B`, so it is not the same as the lowercase break keyword.
Python is case-sensitive, so Break is not a keyword — it is a valid identifier.
Therefore, the correct answer is option (B).

In the given string, game = "Olympic2024", we are trying to find the index of the character `"C"`.
However, Python’s string index method is case-sensitive.
The string `"Olympic2024"` contains a lowercase `"c"` at position 6, but not an uppercase `"C"`.
The index() method searches for the exact match and raises a ValueError if the substring is not found.
Unlike the find() method, which returns -1 when not found, index() throws an error.
Since `"C"` (uppercase) does not exist in the string, Python will raise a ValueError.
Therefore, the correct answer is option (D).

Let’s break down the expression step by step according to Python’s operator precedence rules.
In Python, the exponentiation operator `**` has the highest priority among arithmetic operators.
So, we first calculate the exponent: .
Next, the modulo operator `%` is evaluated: means we find the remainder when 14 is divided by 9.
Since 9 goes into 14 once with a remainder of 5, we have .
After that, the multiplication operator `*` is applied.
So, we multiply the result by 4: .
Hence, the final output of print(14%3**2*4) is 20.
This shows the importance of understanding the correct order of operations when writing or reading Python expressions.
Ignoring precedence rules can easily lead to wrong results in calculations.
Always use parentheses if you want to change the default order and make your code more readable.
Therefore, option (C) is the correct answer.

Python lists are one of the most widely used data structures in Python programming.
They are ordered, mutable, and can store a collection of items in a single variable.
Unlike arrays in languages like C or Java, Python lists are not restricted to a single data type.
This means you can have an integer, a float, a string, and even another list as elements of the same list.
For example, the list [1, "Hello", 3.14, [2, 3]] is completely valid in Python.
This dynamic typing feature provides flexibility and makes Python powerful for rapid development.
However, while it is possible to mix data types, sometimes it is good practice to keep elements of the same type for logical consistency or when performing operations that expect uniform data.
Therefore, the statement that a Python list must always contain elements of the same data type is False.