Most Frequently asked Interview Questions of python-2.7

Question: Explain the open() function in Python 2.7 and the difference between 'r' and 'rb' modes.

Answer:

In Python 2.7, the open() function is used to open a file and return a file object, which can then be used to read, write, or manipulate the contents of the file. The open() function allows you to specify different file access modes to control how the file is opened.

The open() Function:

The basic syntax of the open() function is:

file_object = open(file_name, mode)

• file_name: The path to the file you want to open (can be a relative or absolute path).
• mode: A string that specifies the mode in which the file should be opened. The mode determines whether you are reading, writing, or appending to the file and whether the file should be opened in text or binary mode.

Common Modes for open() in Python 2.7:

• 'r': Opens the file for reading. This is the default mode. If the file does not exist, it raises an error.
• 'w': Opens the file for writing. If the file already exists, it truncates it to zero length (i.e., clears the file). If the file does not exist, it creates a new empty file.
• 'a': Opens the file for appending. Data is written at the end of the file. If the file does not exist, it creates a new file.
• 'rb': Opens the file in binary mode for reading.
• 'wb': Opens the file in binary mode for writing.
• 'ab': Opens the file in binary mode for appending.

The Difference Between 'r' and 'rb' Modes:

1. 'r' (Text Mode, Read):

• Purpose: Opens the file for reading text.

• Encoding: In text mode, the file is expected to contain text data. Python handles the conversion between the file’s raw bytes and the string format used by Python. The system’s default encoding (often UTF-8 or ASCII) is used for converting the bytes read from the file into a string.

• End-of-Line Handling: In text mode, Python automatically converts line endings (newlines) depending on the operating system. On Windows, it converts \r\n (carriage return + newline) to \n (newline). On UNIX-like systems, \n is used for line endings.

• Usage Example:

  with open('example.txt', 'r') as f:
      content = f.read()
      print(content)

  In this example, the file is opened in text mode for reading. Python will automatically decode the file’s content into strings and handle newline conversions.

2. 'rb' (Binary Mode, Read):

• Purpose: Opens the file for reading in binary mode.

• Encoding: In binary mode, Python does not attempt to decode the file contents. The data is returned as raw bytes, exactly as it appears in the file. No character encoding is applied, so no conversion between bytes and strings takes place.

• End-of-Line Handling: No automatic newline conversion occurs. The data is read exactly as it is stored in the file, including any \r\n or \n line endings.

• Usage Example:

  with open('example.bin', 'rb') as f:
      content = f.read()
      print(content)

  In this case, the file is opened in binary mode. The contents are returned as raw bytes, which could represent binary data, such as images or non-text files, and would not be subject to any encoding or newline conversion.

Key Differences Between 'r' and 'rb' Modes:

Aspect	'r' (Text Mode)	'rb' (Binary Mode)
File Content	Assumes the file contains text (strings).	Assumes the file contains binary data (raw bytes).
Decoding	Python decodes the file content using the system’s default encoding (e.g., UTF-8).	No decoding is done; the content is read as raw bytes.
End-of-Line Conversion	Converts line endings (\r\n to \n on Windows).	No conversion of line endings (raw bytes are read).
Use Case	Used for reading text files (e.g., .txt, .csv).	Used for reading binary files (e.g., images, videos, .exe files).

When to Use 'r' vs. 'rb':

• Use 'r' (text mode) when you are working with text files (such as .txt, .csv, .html, etc.) and you want Python to handle encoding and newline conversions automatically.
• Use 'rb' (binary mode) when you are working with binary files (such as images, audio files, videos, or any non-text file), as it ensures that Python does not try to decode the data and processes it as raw bytes.

Example Scenarios:

• Text File Example:

  with open('document.txt', 'r') as f:
      content = f.read()
      print(content)  # Text content with automatic newline conversion

• Binary File Example:

  with open('image.png', 'rb') as f:
      content = f.read()
      print(content)  # Raw binary data (bytes) with no newline conversion

Summary:

• The open() function in Python 2.7 is used to open a file for reading, writing, or appending.
• The mode 'r' is used for reading text files, where Python handles character encoding and newline conversions automatically.
• The mode 'rb' is used for reading binary files, where the content is returned as raw bytes, and no encoding or newline conversions are applied.

Question: What is the difference between deep copy and shallow copy in Python 2.7?

Answer:

In Python, shallow copy and deep copy refer to how objects are copied. They determine how the objects and their nested contents are duplicated, and understanding the difference is important when working with complex data structures like lists, dictionaries, or custom objects.

1. Shallow Copy:

A shallow copy creates a new object but does not create copies of the objects that the original object references. Instead, it only copies the references to the objects. Therefore, if the original object contains references to other objects (e.g., lists within a list), the shallow copy will still refer to the same inner objects.

Key Characteristics of Shallow Copy:

• A new object is created, but the elements inside it (if they are objects themselves) are not copied.
• Changes made to mutable objects (like lists or dictionaries) inside the shallow copy will affect the original object, and vice versa, since both share references to the same inner objects.
• Shallow copy can be created using the copy() method or the copy module.

Example of Shallow Copy:

import copy

# Original list with nested lists
original = [[1, 2, 3], [4, 5, 6]]

# Shallow copy of the original list
shallow_copy = copy.copy(original)

# Modify a nested list in the shallow copy
shallow_copy[0][0] = 'X'

# Print both lists
print("Original:", original)        # [['X', 2, 3], [4, 5, 6]]
print("Shallow Copy:", shallow_copy) # [['X', 2, 3], [4, 5, 6]]

In this example, the shallow copy contains references to the same inner lists as the original. Therefore, modifying a nested list in shallow_copy also affects the corresponding nested list in original.

2. Deep Copy:

A deep copy creates a new object and recursively copies all objects found in the original, including any nested objects. In other words, it creates copies of the objects and their contents, so there is no shared reference between the original and the deep copy. Any changes made to the deep copy do not affect the original object, and vice versa.

Key Characteristics of Deep Copy:

• A new object and all objects referenced by the original object are recursively copied.
• Changes made to the deep copy do not affect the original object, even if the change is to a nested object.
• Deep copy can be created using the copy.deepcopy() function from the copy module.

Example of Deep Copy:

import copy

# Original list with nested lists
original = [[1, 2, 3], [4, 5, 6]]

# Deep copy of the original list
deep_copy = copy.deepcopy(original)

# Modify a nested list in the deep copy
deep_copy[0][0] = 'X'

# Print both lists
print("Original:", original)        # [[1, 2, 3], [4, 5, 6]]
print("Deep Copy:", deep_copy)      # [['X', 2, 3], [4, 5, 6]]

In this example, the deep copy creates entirely new lists for both the outer and inner lists, so changes made to the deep copy do not affect the original list.

Comparison of Shallow Copy vs Deep Copy:

Aspect	Shallow Copy	Deep Copy
Object Creation	Creates a new object, but does not copy nested objects.	Creates a new object and recursively copies all objects, including nested ones.
Nested Objects	Nested objects are not copied; references to the same objects are shared.	Nested objects are copied as well, so the copies are independent.
Impact of Modifications	Modifications to nested objects in the copy affect the original.	Modifications to the copy do not affect the original.
Performance	Faster, as only references to nested objects are copied.	Slower, as all objects and their contents are recursively copied.
Usage	Use when you need a new object, but the nested objects should remain shared.	Use when you need a completely independent copy of the object and its nested contents.

When to Use Shallow vs Deep Copy:

• Shallow Copy:

  • Use shallow copy when you want to create a new object but don’t need to modify the inner objects (or when the inner objects should remain shared between the original and the copy).
  • Suitable for cases where the data structure has immutable objects (like integers or strings) or when you don’t plan to modify the nested objects.

• Deep Copy:

  • Use deep copy when you need a completely independent copy of an object and its nested structures, ensuring that changes made to the copy do not affect the original object.
  • Suitable for complex objects or when working with mutable data structures that may be modified independently.

Summary:

• Shallow Copy: Creates a new object, but nested objects are not copied; they are shared between the original and the copy.
• Deep Copy: Creates a completely independent copy of the object, including all nested objects, ensuring that changes in the copy do not affect the original.

Question: How do you perform string formatting in Python 2.7?

Answer:

In Python 2.7, string formatting can be done in several ways. The most common methods are:

1. Using the % Operator (old-style formatting)
2. Using the str.format() Method (new-style formatting introduced in Python 2.7)

1. Using the % Operator (Old-Style String Formatting)

This is the traditional way of formatting strings in Python. It is similar to the C programming language’s printf-style formatting.

Syntax:

formatted_string = "some text %s some more text" % (value)

• %s is used to insert a string.
• %d is used to insert integers.
• %f is used for floating-point numbers.

You can use multiple placeholders in a single string, and each placeholder can be mapped to a corresponding value.

Example:

name = "John"
age = 25

# Using the % operator to format the string
formatted_string = "My name is %s and I am %d years old." % (name, age)

print(formatted_string)
# Output: My name is John and I am 25 years old.

Other placeholders:

• %s: String (or any object, converted using str()).
• %d or %i: Integer.
• %f: Floating-point number.
• %x: Hexadecimal representation of an integer.
• %%: To escape the percent symbol itself.

You can also specify the width and precision of the value being formatted.

Example with width and precision:

pi = 3.14159265
formatted_string = "Pi to two decimal places: %.2f" % pi
print(formatted_string)
# Output: Pi to two decimal places: 3.14

2. Using the str.format() Method (New-Style String Formatting)

Introduced in Python 2.7, str.format() allows for more powerful and readable formatting. It uses curly braces {} as placeholders, and you can reference variables directly inside the string.

Syntax:

formatted_string = "some text {} some more text".format(value)

Example:

name = "John"
age = 25

# Using str.format() to format the string
formatted_string = "My name is {} and I am {} years old.".format(name, age)

print(formatted_string)
# Output: My name is John and I am 25 years old.

You can also use positional and keyword arguments in the str.format() method:

Positional arguments:

formatted_string = "The first number is {}, and the second is {}.".format(1, 2)
print(formatted_string)
# Output: The first number is 1, and the second is 2.

Keyword arguments:

formatted_string = "My name is {name} and I am {age} years old.".format(name="John", age=25)
print(formatted_string)
# Output: My name is John and I am 25 years old.

Using index placeholders:

You can also refer to the arguments by their index position.

formatted_string = "The first number is {0}, and the second is {1}.".format(1, 2)
print(formatted_string)
# Output: The first number is 1, and the second is 2.

Specifying formatting for numbers:

The str.format() method allows you to specify how numbers should be formatted directly in the string.

pi = 3.14159265
formatted_string = "Pi to two decimal places: {:.2f}".format(pi)
print(formatted_string)
# Output: Pi to two decimal places: 3.14

Using positional and keyword arguments together:

formatted_string = "Name: {0}, Age: {1}, Job: {job}".format("John", 25, job="Developer")
print(formatted_string)
# Output: Name: John, Age: 25, Job: Developer

Comparison of % vs. str.format():

• Flexibility: str.format() is more flexible and readable compared to % formatting, especially when you need to refer to variables by name or want more complex formatting options.
• Readability: str.format() allows for more readable and maintainable code with its use of named placeholders and keyword arguments.
• Compatibility: % formatting is the traditional method, and is still widely used in older codebases, but str.format() provides a more modern approach.

3. Template Strings (Less Common)

Python 2.7 also includes a string.Template class for simpler string formatting. This approach uses $ for placeholders, which can be easier for some use cases (e.g., when formatting user input).

Example:

from string import Template

name = "John"
age = 25

# Using Template strings for formatting
template = Template("My name is $name and I am $age years old.")
formatted_string = template.substitute(name=name, age=age)

print(formatted_string)
# Output: My name is John and I am 25 years old.

Summary of Methods:

• % Operator: Old-style formatting, less readable for complex cases.
• str.format(): New-style formatting, more flexible and readable, supports positional and keyword arguments.
• string.Template: Simpler, suitable for cases with user-generated input but less powerful than str.format().

Conclusion:

In Python 2.7, the primary methods for string formatting are the % operator (older style) and the str.format() method (new style). While % is still commonly used, str.format() offers a more modern, readable, and flexible approach for string interpolation and is recommended for new code.

Question: What is the difference between a list and a tuple in Python 2.7?

Answer:

In Python 2.7, lists and tuples are both used to store collections of items, but they have some key differences. Here’s a detailed breakdown of the main distinctions:

1. Mutability:

• List: A list is mutable, meaning that you can modify its content (add, remove, or change items) after it has been created.
• Tuple: A tuple is immutable, meaning that once it is created, its contents cannot be changed. You cannot add, remove, or modify elements of a tuple.

Example:

# List example (mutable)
my_list = [1, 2, 3]
my_list[0] = 10  # This is allowed
print(my_list)  # Output: [10, 2, 3]

# Tuple example (immutable)
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # This will raise a TypeError

2. Syntax:

• List: Lists are created using square brackets [].
• Tuple: Tuples are created using parentheses ().

Example:

# List
my_list = [1, 2, 3]

# Tuple
my_tuple = (1, 2, 3)

3. Performance:

• List: Lists have more overhead due to their mutability, meaning they are slower for certain operations compared to tuples.
• Tuple: Tuples are generally faster than lists because they are immutable, and their memory layout is more compact.

Example:

import time

# List performance
start = time.time()
list_example = [i for i in range(1000000)]
end = time.time()
print("List creation took:", end - start)

# Tuple performance
start = time.time()
tuple_example = tuple(i for i in range(1000000))
end = time.time()
print("Tuple creation took:", end - start)

Tuples are typically faster for iteration, comparison, and access due to their immutability.

4. Methods:

• List: Lists support a variety of built-in methods for modification, such as append(), remove(), pop(), insert(), extend(), and more.
• Tuple: Tuples have very limited methods since they are immutable. They only support methods like count() and index(), which help you search for occurrences of elements or find their position.

Example:

# List methods
my_list = [1, 2, 3]
my_list.append(4)   # Adds an element
my_list.remove(2)   # Removes an element
print(my_list)      # Output: [1, 3, 4]

# Tuple methods (limited)
my_tuple = (1, 2, 3, 2)
print(my_tuple.count(2))  # Output: 2
print(my_tuple.index(3))  # Output: 2

5. Use Cases:

• List: Since lists are mutable, they are more suitable for use cases where you need to change the contents of a collection dynamically. For example, you would use a list when collecting items that need to be modified (e.g., adding or removing items).
• Tuple: Tuples are used when you need a collection that should remain constant throughout the program. They are often used to represent fixed data, such as coordinates (e.g., (x, y)), or to store collections of items that should not be changed. Tuples are also used as dictionary keys because they are hashable (since they are immutable), while lists are not.

6. Hashability:

• List: Lists are not hashable because they are mutable. This means you cannot use lists as dictionary keys or set elements.
• Tuple: Tuples are hashable (as long as all their elements are hashable). This allows tuples to be used as keys in dictionaries and elements in sets.

Example:

# Using a tuple as a dictionary key
my_dict = {}
my_tuple = (1, 2)
my_dict[my_tuple] = "value"  # This is allowed

# Using a list as a dictionary key (will raise an error)
my_list = [1, 2]
# my_dict[my_list] = "value"  # This will raise a TypeError

7. Memory Consumption:

• List: Due to their mutability, lists tend to use more memory than tuples.
• Tuple: Since tuples are immutable, they require less memory, making them more efficient for storing data when memory usage is a concern.

8. Destructuring:

• Both lists and tuples can be used for unpacking, but since tuples are often used for fixed collections of values, they are more commonly seen in this context.

Example:

# List unpacking
my_list = [1, 2, 3]
a, b, c = my_list
print(a, b, c)  # Output: 1 2 3

# Tuple unpacking
my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)  # Output: 1 2 3

Summary of Differences:

Feature	List	Tuple
Mutability	Mutable (can be changed)	Immutable (cannot be changed)
Syntax	Created with square brackets []	Created with parentheses ()
Methods	More methods available (e.g., append(), remove())	Fewer methods available (e.g., count(), index())
Performance	Slower (due to mutability)	Faster (due to immutability)
Hashability	Not hashable (cannot be used as dict keys)	Hashable (can be used as dict keys)
Memory	Higher memory usage	Lower memory usage
Use Cases	Dynamic collections, collections that need modification	Fixed collections, used for constant data

Conclusion:

• Lists are more flexible and suitable for cases where you need to modify the collection (add, remove, or change items).
• Tuples are best for fixed collections of data that should remain unchanged and are more memory-efficient and faster for read-only operations. They can also be used as dictionary keys, which lists cannot.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as python-2.7 interview questions, python-2.7 interview experiences, and details about various python-2.7 job positions. Click here to check it out.