Top 20+ Python Interview Q&A with Practical Test | Try Personalized AI Help

You can reverse a list in Python using the reverse() method or the slicing technique. Here's how you can use both:

# Using the reverse() method
  my_list = [1, 2, 3, 4]
  my_list.reverse()
  print(my_list)  # Output: [4, 3, 2, 1]
  # Using slicing
  reversed_list = my_list[::-1]
  print(reversed_list)  # Output: [1, 2, 3, 4]

The reverse() method modifies the list in place, while slicing creates a new reversed list.

In Python, mutable objects are those that can be changed after their creation, whereas immutable objects cannot be altered.

# Mutable example
mutable_list = [1, 2, 3]
mutable_list[0] = 100print(mutable_list)  # Output: [100, 2, 3]# Immutable example
immutable_string = "Hello"try:
    immutable_string[0] = "M"except TypeError as e:
    print(e)  # Output: 'str' object does not support item assignment

Common mutable types include lists and dictionaries, while immutables include strings and tuples.

A recursive function for calculating the factorial of a number is defined as calling itself to compute the product sequence from the number down to 1.

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))  # Output: 120

The *args and **kwargs are used in function definitions. *args allows you to pass a variable number of non-keyword arguments to a function. **kwargs allows you to pass a variable number of keyword arguments (name-value pairs). They are useful when you want to create functions that handle a variable amount of input arguments.

The else clause in a Python loop specifies a block of code that is executed after the loop's normal execution is finished, but only if the loop did not terminate by a break statement. This is unique to Python and useful to determine if a loop concluded naturally without external interruption.

for i in range(3):
    print(i)
else:
    print("Executed after the loop completes naturally.")

Thread safety in Python can be ensured by using locks, queues, or other synchronization mechanisms to prevent multiple threads from accessing the same resource simultaneously. The threading module includes Lock , RLock , and Semaphore classes that can be used to synchronize threads.

  import threading

lock = threading.Lock()

def safe_update():
    with lock:
        # perform thread-safe modifications
        pass

thread1 = threading.Thread(target=safe_update)
thread2 = threading.Thread(target=safe_update)
thread1.start()
thread2.start()
thread1.join()
thread2.join()

  

Metaclasses in Python are classes of classes; they define how classes behave. A metaclass in Python is most often used as a class-factory, or to modify class behavior. You can intercept the creation of a class and modify the class's definition by using metaclasses. They are somewhat advanced and are used in complex scenarios like enforcing API standards or modifying class properties dynamically.

The with statement in Python is used for exception handling and simplifies the management of common resources such as file streams. It ensures that resources are properly cleaned up after use, regardless of whether an exception was thrown or not. The with statement eliminates the need for explicit acquisition and release of resources.

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
# The file is automatically closed outside the with block, even if an exception occurs.

Introduced in Python 3.8, the walrus operator ( := ) allows you to assign values to variables as part of an expression. This can make certain constructs more concise, reducing the need for additional lines of code. It's particularly useful in loops or conditions where you want to assign a value to a variable and immediately check its truthiness or other properties in the same expression.

# Classic method
num = input("Enter a number: ")
while num.isdigit():
    num = input("Enter a number: ")

# Using the walrus operator
while (num := input("Enter a number: ")).isdigit():
    pass

Duck typing is a concept related to dynamic typing, where the type or class of an object is less important than the methods it defines. In Python, if an object can perform a required behavior (i.e., "if it quacks like a duck"), that object can be used in any context expecting an object with that behavior. This allows for more flexibility and simplicity in code.

class Duck:
    def quack(self):
        print("Quack, quack!")

class Person:
    def quack(self):
        print("I'm pretending to be a duck!")

def make_it_quack(duck):
    duck.quack()

duck = Duck()
person = Person()
make_it_quack(duck)   # Output: Quack, quack!
make_it_quack(person) # Output: I'm pretending to be a duck!