Top 100 Basic Python Interview Questions & Answers for Beginners

Python is a popular choice for both beginners and seasoned developers. As a result, Python proficiency is a highly sought-after skill in today’s job market.

So mastering the fundamentals of Python is crucial for any aspiring programmer. This comprehensive guide contains 100+ basic Python interview questions with detailed answers for beginners such as recent graduate or an experienced professional looking to brush up on their skills.

To help you prepare effectively for your next interview we’ve covered frequently asked question on topics such as data types, operators, control flow, functions, object-oriented programming, and exception handling.

By understanding these core principles and practicing the provided examples, you’ll be well-equipped to demonstrate your Python knowledge and confidently tackle your next interview.

1. What is Python? Enlist some of its benefits

Python is a high-level, interpreted, general-purpose programming language. It emphasizes code readability with its clear syntax, often described as “executable pseudocode,” which makes it easier to learn and use. It supports various programming paradigms, including procedural, object-oriented, and functional programming.

Benefits:

• Easy to learn: Simple syntax and structure.  
• Large community: Extensive support and resources.  
• Versatile: Used in web development, data science, and more.  
• Libraries: Vast collection of pre-built modules for various tasks.  
• Cross-platform: Runs on different operating systems.

2. What is the difference between an interpreted and a compiled language?

• Interpreted Language: Code is executed line by line by an interpreter. The interpreter reads a line of code, executes it, and then moves to the next line. Python is an interpreted language. Changes to the code can be tested immediately without a separate compilation step.
• Compiled Language: Code is first translated into machine code (or bytecode) by a compiler. This creates an executable file that can be run directly by the computer’s processor. C, C++, and Java are examples of compiled languages. Compiled programs generally run faster because the code is already translated, but the compilation process takes time.

Analogy: Imagine you have a recipe in a foreign language.

• Interpreting: You have a translator who reads the recipe line by line and tells you what to do immediately.
• Compiling: You have someone who translates the entire recipe into your language beforehand. Then, you can follow the translated recipe directly.

3. What are the applications of Python?

Python’s versatility makes it suitable for a wide range of applications:

• Web Development: Frameworks like Django and Flask are used for building web applications.
• Data Science and Machine Learning: Libraries like NumPy, Pandas, Scikit-learn, and TensorFlow are essential for data analysis, machine learning, and AI.
• Scripting and Automation: Python is used to automate tasks, create scripts for system administration, and perform repetitive operations.
• Desktop GUI Development: Libraries like Tkinter, PyQt, and Kivy are used for creating graphical user interfaces.
• Game Development: Libraries like Pygame can be used to create simple games.
• Education: Python’s readability makes it a popular language for teaching programming.
• Scientific Computing: Python is used in scientific research and simulations due to its powerful libraries for numerical computation.

4. Is Python case sensitive?

Yes, Python is absolutely case-sensitive. my_variable, My_Variable, and MY_VARIABLE are treated as three distinct variables. Case sensitivity applies to variable names, function names, class names, and other identifiers.

5. Can you tell us if Python is object-oriented or functional programming?

Python is a multi-paradigm language, meaning it supports several programming styles. It is both object-oriented and functional. You can write object-oriented code using classes and objects, and you can also leverage functional programming concepts like lambda functions, map, filter, and reduce. It doesn’t force you into one paradigm or the other, giving you the flexibility to choose the best approach for your specific task.

6. What are loops in Python?

Loops in Python allow the execution of a block of code repeatedly until a specific condition is met. Python primarily supports two types of loops:

• for Loop: Used to iterate over a sequence (e.g., list, tuple, string, dictionary) or range.
• while Loop: Executes as long as a specified condition evaluates to True.

7. What is the purpose of the range() function in a for loop?

The range() function is used to generate a sequence of numbers that a for loop can iterate over. It is particularly useful when you need to iterate a specific number of times or work with a sequence of integers.

Syntax: range(start, stop, step)

• start: The starting value of the sequence (default is 0).
• stop: The ending value (exclusive).
• step: The increment or decrement (default is 1).

Example:

for i in range(1, 6):
    print(i)  # Outputs: 1, 2, 3, 4, 5Code language: Python (python)

8. Calculate the sum of all even numbers between 1 to 100 using loop

Example: using for loop and range()

sum_of_evens = 0  # Initialize the sum
# Start from 2, go up to 101 (exclusive), step by 2
for number in range(2, 101, 2):
    sum_of_evens += number  # Add each even number to the sum
print(f"The sum of even numbers from 1 to 100 is: {sum_of_evens}")
# Output: 2550Code language: Python (python)

Explanation:

1. sum_of_evens = 0: We initialize a variable sum_of_evens to 0 to store the sum of the even numbers.
2. for number in range(2, 101, 2):: This loop iterates through the numbers from 2 up to (but not including) 101, incrementing by 2 in each step. This ensures that we only consider even numbers. range(start, stop, step) is used here.
3. sum_of_evens += number: In each iteration, the current even number (number) is added to the sum_of_evens.
4. print(...): Finally, the calculated sum is printed to the console.

9. Explain the difference between for and while loops

Advantages of for Loops:

1. Simplicity: Ideal for iterating over a sequence of known length.
2. Readability: Clear and concise for fixed iterations.
3. Built-in Features: Easily integrates with functions like range() or enumerate().

Advantages of while Loops:

• Dynamic Conditions: Allows execution based on runtime conditions.
• Flexibility: Useful when the number of iterations is not predetermined.

10. What is the break statement, and how is it used?

The break statement is used to exit a loop prematurely when a specific condition is met.

When a break statement is encountered inside a loop, the loop is immediately terminated, and program control is transferred to the next statement following the loop.

Example:

for i in range(10):
    if i == 5:
        break
    print(i)  # Outputs 0, 1, 2, 3, 4Code language: Python (python)

Explanation: In this example, the loop iterates over numbers from 0 to 9. When i equals 5, the break statement is executed, terminating the loop. As a result, numbers after 4 are not printed.

11. What is the continue statement, and how is it used?

The continue statement skips the current iteration and proceeds to the next iteration of the loop.

Example:

for i in range(5):
    if i == 2:
        continue
    print(i)  # Outputs 0, 1, 3, 4Code language: Python (python)

Explanation: In this example, the loop iterates over the range of numbers from 0 to 4. When the value of i is equal to 2, the continue statement is executed, which skips the rest of the code for that iteration. As a result, the number 2 is not printed, and the loop moves on to the next iteration.

This is useful when you want to avoid executing certain logic for specific cases.

12. How can you use an else clause with loops in Python?

The else clause in a loop executes after the loop finishes, unless the loop is terminated prematurely using break.

Key Points:

1. If the loop runs to completion without encountering a break, the else block is executed.
2. If the loop is terminated by a break, the else block is skipped.

Example 1: When the loop completes normally:

for i in range(3):
    print(i)
else:
    print("Loop completed")
# Output:
# 0
# 1
# 2
# Loop completedCode language: Python (python)

Example 2: When the loop is terminated by a break:

for i in range(5):
    if i == 2:
        break
    print(i)
else:
    print("Loop completed")
# Outputs:
# 0
# 1Code language: Python (python)

Explanation: In the second example, the break statement prevents the loop from completing normally, so the else block is skipped.

13. What is the purpose of the pass statement in loops?

The pass statement is a placeholder that does nothing. It is used when a loop or block is syntactically required but no action is needed.

Example:

for i in range(5):
    if i % 2 == 0:
        pass  # Placeholder for future logic
    print(i)
# Outputs 0, 1, 2, 3, 4Code language: Python (python)

14. What is nested loops? How to use it

Nested loops are loops within loops. The inner loop executes completely for each iteration of the outer loop. It means For every iteration of the outer loop, the inner loop runs all its iterations. The inner and outer loops can be of any type (e.g., for or while).

There can be multiple inner loops within an outer loop, and there’s no limit to how many loops can be nested.

Nested loops are often used for tasks like processing multidimensional data, such as matrices, two-dimensional arrays or nested lists.

Example:

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")Code language: Python (python)

Output:

# i=0, j=0
# i=0, j=1
# i=1, j=0
# i=1, j=1
# i=2, j=0
# i=2, j=1

Explanation: In the above example, the outer loop runs three times (for i values 0, 1, and 2). For each iteration of the outer loop, the inner loop runs twice (for j values 0 and 1). This creates a total of 3 x 2 = 6 iterations.

15. Print Right-angled triangle of stars

Example:

rows = 5  # Number of rows in the triangle
# Outer loop: controls the number of rows
for i in range(1, rows + 1):
    for j in range(1, i + 1):  # Inner loop: controls the number of stars in each row
        print("*", end=" ")  # Print a star and a space (no newline)
    print()  # Move to the next line after each row is printedCode language: Python (python)

Explanation:

• The outer loop (for i in range(...)) controls the rows. The inner loop (for j in range(...)) controls the stars in each row.
• Each row has a number of stars equal to its row number (row 1 has 1 star, row 2 has 2 stars, etc.).
• print("*", end=" ") prints a star followed by a space (staying on the same line).
• print() (without arguments) creates a new line after each row is complete. This combination of loops and print() statements neatly forms the triangular pattern.

16. Why is indentation significant in Python?

Indentation in Python is crucial because it’s how the language defines code blocks (groups of statements). Unlike many other languages that use curly braces {} to delimit blocks, Python uses indentation (spaces or tabs) to indicate which statements belong together.

Correct indentation is not just for readability; it’s part of the syntax. Incorrect indentation will lead to IndentationError and prevent your code from running. Consistent indentation is vital for Python code to be interpreted correctly.

Example: Proper indentation

def greet():
    print("Hello, World!")
greet()Code language: Python (python)

Example: Incorrect indentation

def greet():
print("Hello, World!")  # This will cause an IndentationErrorCode language: Python (python)

17. What are comments in Python, and why are they important?

Comments in Python are lines of code that are ignored by the Python interpreter. They are used to explain what the code does, make it more readable, and document the code.

• Single-line comments start with a #.
• Multi-line comments (docstrings) are enclosed in triple quotes (""" or '''). They are often used to document functions and classes.

Comments are important because they:

• Improve code readability: They explain the logic and purpose of the code, making it easier to understand.
• Aid in debugging: Comments can help you track down errors by explaining the expected behavior of different code sections.
• Facilitate collaboration: Comments make it easier for others (or your future self) to understand and work with your code.
• Documentation: Docstrings can be used to generate documentation for your code.

Example:

# This is a single-line comment
def my_function(x):
    """
    This is a multi-line comment (docstring).
    It explains what the function does and its parameters.
    """
    return x * 2  # This comment explains what this line does.Code language: Python (python)

18. What is the purpose of PYTHONSTARTUP, PYTHONCASEOK, and PYTHONHOME environment variables?

These environment variables influence Python’s behavior, particularly during startup:

1. PYTHONSTARTUP:

This variable specifies the path to a Python file that will be executed before the interactive interpreter starts. It’s useful for setting up your interactive environment, such as importing commonly used modules, defining functions, or customizing the prompt. If set, the file is executed when you start the Python interpreter in interactive mode.

2. PYTHONCASEOK (Windows Only):

On Windows, this variable controls the case-insensitivity of import statements. If set to any value, Python will treat module and package names as case-insensitive. This can be helpful if you’re working with a file system that is case-insensitive, but it’s generally recommended to stick to consistent casing in your code to avoid confusion.

3. PYTHONHOME:

This variable specifies the root directory of your Python installation. It’s used by Python to find its standard libraries and other necessary files. If PYTHONHOME is set, Python will look for these files within the specified directory. This is especially useful if you have multiple Python installations on your system or if you want to run Python from a non-standard location. It can be useful to set this if you are using embedded python or if you do not want to rely on the python path that is set during installation. If not set, Python uses the installation path that was configured during installation.

19. What are the different data types in Python?

Python has several built-in data types. Here are some of the most common ones:

• Numeric:
  • int: Integers (Whole numbers). e.g., -2, 0, 123.
  • float: Numbers with a decimal point (e.g., 3.14, -0.5). c
  • complex: Numbers with a real and imaginary part (e.g., 1+2j).
• String:
  • Textual data, sequences of characters (e.g., “hello”, ‘PYnative’).
• Boolean:
  • bool: Logical values, either True or False.
• Sequence Types:
  • list: Ordered, mutable sequences of items (e.g., [1, 2, “apple”])
  • tuple: Ordered, immutable sequences of items (e.g., (1, 2, “apple”))
  • range: An immutable sequence of numbers, often used for looping.
• Mapping Type:
  • dict: Unordered collections of key-value pairs (e.g., {“name”: “Alice”, “age”: 30})
• Set Types:
  • set: Unordered collections of unique items (e.g., {1, 2, 3}).
  • frozenset: An Immutable version of set
• Binary Types:
  • bytes: Sequence of bytes
  • bytearray: Mutable sequence of bytes
  • memoryview: Allows access to internal data of an object without copying

20. Explain the difference between mutable and immutable data types. Give examples.

• Mutable Data Types: Mutable data types are those whose values can be changed after they are created. Modifying a mutable object doesn’t create a new object; it changes the existing one in place. Examples: list, dict, set, bytearray.
• Immutable Data Types: Immutable data types are those whose values cannot be changed after they are created. Any operation that seems to modify an immutable object actually creates a new object with the changed value. Examples: int, float, str, tuple, bool, frozenset, bytes.

Example:

# Mutable (list)
my_list = [1, 2, 3]
my_list.append(4)  # Modifies the original list
print(my_list)  # Output: [1, 2, 3, 4]
# Immutable (string)
my_string = "hello"
# my_string[0] = "J" # This will give error since strings are immutable
new_string = my_string.upper()  # Creates a NEW string
print(my_string)  # Output: hello (Original is unchanged)
print(new_string) # Output: HELLO (new string is created)
my_tuple = (1,2,3)
# my_tuple[0] = 4 # This will give error since tuples are immutableCode language: Python (python)

21. How do you check the type of an object in Python?

You can check the type of an object in Python using the type() function. Here’s how it works:

Example

my_variable = 10
print(type(my_variable))  # Output: <class 'int'>
my_list =
print(type(my_list))  # Output: <class 'list'>
my_string = "Hello"
print(type(my_string))  # Output: <class 'str'>Code language: Python (python)

The type() function takes an object as an argument and returns its type as a class object. This can be useful for:

• Debugging: To understand the type of a variable if you’re getting unexpected behavior.
• Conditional Logic: To execute different code blocks based on the type of an object.
• Documentation: To make your code more understandable.

22. How does Python implement dynamic typing?

Python uses dynamic typing, which means that the type of a variable is checked at runtime, not during compilation. You don’t need to explicitly declare the type of a variable. Instead, the type is determined at runtime based on the assigned value.

A variable can even change its type during the execution of the program if it is assigned a value of a different type.

Example:

x = 10  # x is an integer
print(type(x))  # Output: <class 'int'>
x = "hello"  # x is now a string
print(type(x))  # Output: <class 'str'>Code language: Python (python)

This flexibility makes Python code more concise and easier to write, but it also means that type errors might occur during runtime, so testing is important.

23. What is type conversion (casting) in Python and how is it performed?

Type conversion (or casting) is the process of changing a variable from one data type to another. Python provides built-in functions for this:

• int(): Converts to integer.
• float(): Converts to floating-point number.
• str(): Converts to string.
• bool(): Converts to boolean.
• list(), tuple(), set(): Convert to list, tuple, or set, respectively (if the object is iterable).

There are two types:

• Implicit conversion (done automatically by Python)
• Explicit conversion (done manually by the programmer)

Example: Implicit conversion

x = 5       # int
y = 2.5     # float
result = x + y  # Python automatically converts int to float
print(result, type(result))  # Output: 7.5 <class 'float'>Code language: Python (python)

Example: Explicit conversion

x = "123"
y = int(x)  # Converts x to an integer
print(type(y))  # Output: <class 'int'>Code language: Python (python)

24. How do you take user input in Python?

You can take user input using the built-in input() function. This function displays a prompt to the user and waits for them to type something and press Enter. The input() function then returns the user’s input as a string.

Example:

name = input("Enter your name: ")
print(f"Hello, {name}!")
age = input("Enter your age: ") # input function always returns string
age = int(age) # convert string to int if needed.
print(f"You are {age} years old.")Code language: Python (python)

25. How is the help() function used?

The help() function in Python is used to get interactive help about objects. These objects can be modules, classes, functions, methods, keywords, or even variables. It’s a built-in way to quickly access documentation and learn about how to use different parts of Python.

Here’s how you can use it:

1. Interactive Interpreter: If you’re using the Python interactive interpreter, you can type help() and press Enter. This will launch the interactive help system. You can then type the name of the object you want help with (e.g., a function name, a module name, a class name) and press Enter. The help information will be displayed. Type q and Enter to exit the help system.
2. Directly on an Object: You can call help() directly on an object by passing the object as an argument. For example, help(print) will display help about the print function. help(os) will display help about the os module.
3. Within Code (Less Common): You can also call help() from within your Python code, although the output will be printed to the console. This is less common for regular use but can be useful for debugging or introspection.

What kind of information does help() provide?

The help() function will typically show you:

• Docstring: The object’s docstring (if it has one). Docstrings are multiline strings used for documentation.
• Signature: The function or method signature, showing the parameters it takes.
• Description: A description of what the object does.
• Methods/Attributes: For classes and modules, it lists the available methods and attributes.

Example:

>>> help(len)  # Get help about the len() function
#... information about len() is displayed...
>>> import os
>>> help(os.path) # Get help about the os.path module
#... help about os.path module
>>> def my_function(x):...     """This is a docstring for my function."""...     return x * 2
>>> help(my_function)  # Get help about my_function (including the docstring)
#... information about my_function is displayed...
>>> help() # Enter the help session
help> keywords # to see all the keywords
help> q # quit the help sessionCode language: Python (python)

In short, help() is a very convenient way to get quick information about Python objects directly from the interpreter or your code. It’s especially useful for exploring new modules and functions. Remember that the quality of the information depends on the presence and quality of docstrings.

26. What are strings in Python? How do you concatenate them?

Strings in Python are used to represent text. They are immutable sequences of characters enclosed in single quotes (') or double quotes (").

Concatenation means joining two or more strings together. Here are the common ways to concatenate strings in Python:

• Using the + operator:
• Using the join() method: This is efficient for concatenating a large number of strings, especially from a list or other iterable.

Example:

string1 = "Hello"
string2 = "PYnative"
# Using the + operator
result = string1 + " " + string2  # Adds a space in between
print(result)  
# Output: Hello World
# using .join()
words = ["This", "is", "a", "sentence."]
result = " ".join(words)
print(result)  
# Output: This is a sentence.Code language: Python (python)

Note: It’s important to note that repeated concatenation using + in a loop can be inefficient due to the creation of new string objects. In such cases, using join() is more efficient.

27. How do you convert a string to an integer?

You can convert a string to an integer using the int() function:

Example:

string_number = "123"
integer_number = int(string_number)
print(integer_number)  # Output: 123
print(type(integer_number)) # Output: <class 'int'>
# If the string cannot be converted to an integer (e.g., "abc" or "3.14"), 
# you'll get a ValueError. You can use error handling to manage thisCode language: Python (python)

28. what is slicing in Python?

Slicing in Python is a powerful technique for extracting portions of sequences, like strings, lists, tuples, and other iterable objects. It allows you to create a new sequence that is a subset of the original, without modifying the original.

Think of it like cutting a slice from a pie. You get a piece of the pie (the slice), but the whole pie remains intact. It uses the colon operator (:) within square brackets.

Here’s how slicing works:

my_str = "Hello, PYnative!"
# Basic slicing: [start:stop:step]
print(my_str[0:5]) 
# Output: Hello (characters from index 0 up to, but not including, 5)
# Omitting start or stop:
print(my_str[:5])   # Output: Hello
print(my_str[7:])   # Output: World!
#creates a shallow copy
print(my_str[:])    # Output: Hello, World! (Entire string)
# using step
print(my_str[7:12:2]) # Output: Wrd (Every 2nd character)
# Negative indexing:
print(my_str[-6:])  # Output: World! (last 6 characters)
my_list = [1, 2, 3, 4, 5]
print(my_list[1:4]) # Output: [2, 3, 4]Code language: Python (python)

Key points about slicing:

• sequence[start:stop:step] creates a slice. start is inclusive, stop is exclusive, and step determines the interval between elements.
• If omitted, start defaults to 0, stop to the sequence’s length, and step to 1.
• Negative indices can be used to access elements from the end of the sequence.

Slicing is a very efficient and concise way to work with sequences in Python. It’s a fundamental technique you’ll use frequently.

29. How can you extract a substring from a string?

To extract a substring from a string, use slicing with the appropriate start and end indices. Substrings can be extracted by specifying the range of characters you want.

Example:

string = "Python Programming"
# Extract substring "Programming"
substring = string[7:]  # Start at index 7 and include the rest
print(substring)  # Output: Programming
# Extract substring "thon Pro"
substring = string[2:10]  # Start at index 2 and stop before index 10
print(substring)  # Output: thon Pro
# Extract substring with a step value (e.g., every second character from "Programming")
substring = string[7::2]
print(substring)  # Output: PormigCode language: Python (python)

30. How can you reverse a string in Python?

The most common and often most efficient way to reverse a string in Python is using slicing. Here’s how:

Example:

my_string = "hello"
reversed_string = my_string[::-1]
print(reversed_string)  # Output: ollehCode language: Python (python)

This works because the [::-1] slice creates a reversed copy of the string.

There are other methods as well, such as using the reversed() function with join(), or iterating through the string in reverse and building a new string. However, slicing is generally the preferred method due to its conciseness and efficiency.

31. What is the output of the following string operations

# case 1:
s = "PYnative"
print(s[2:5])
# case 2:
s = "PYnative"
print(s[::2])
# case 3:
s = "PYnative"
print(s[-3:-1])
# case 4:
s = "Pynative"
print(s[:])Code language: Python (python)

Answer:

Case 1: nat
Case 2: Pntv
Case 3: iv
Case 4: Pynative

32. Reverse a string without using for loop

To reverse a string without built-in functions, you can use a loop to construct the reversed string manually. This approach ensures that each character is processed in reverse order by appending it to the beginning of the result string:

def reverse_string(s):
    reversed_s = ''
    for char in s:
        reversed_s = char + reversed_s
    return reversed_s
# Example usage
print(reverse_string("hello"))  # Output: "olleCode language: Python (python)

33. How are strings immutable in Python, and what does that mean?

Strings in Python are immutable, which means once a string is created, it cannot be changed. Any operation that seems to modify a string will actually create a new string object in memory instead of altering the original string.

Immutability means the content of the object cannot be altered after it’s created. For strings, this implies that individual characters in the string or the entire string cannot be modified in place.

Example:

s = "hello"
s = s + " world"
print(s)  # Output: "hello world"Code language: Python (python)

Here, s + " world" creates a new string object "hello world" and assigns it to s. The original string "hello" remains unaltered in memory.

If you try to directly change a character in the string, Python will throw an error:

s[0] = 'P'  # TypeError: 'str' object does not support item assignmentCode language: Python (python)

34. How to format strings in Python?

Python provides the below techniques to format strings, each with its unique features:

1. .format() Method

Introduced in Python 2.7 and 3.0, the .format() method is more powerful and readable. It allows positional and keyword arguments for substituting values into placeholders.

Example:

name = "Bob"
age = 25
print("My name is {}, and I am {} years old.".format(name, age))
# Output: My name is Bob, and I am 25 years oldCode language: Python (python)

You can also use numbered placeholders or keywords:

print("My name is {0}, and I am {1} years old.".format(name, age))
print("My name is {name}, and I am {age} years old.".format(name=name, age=age))Code language: Python (python)

c. f-Strings (Formatted String Literals)

Introduced in Python 3.6, f-strings are the most concise and efficient way to format strings. By prefixing a string with f, you can directly embed expressions inside curly braces {}.

Example:

name = "Carol"
age = 28
print(f"My name is {name}, and I am {age} years old.")
# Output: My name is Carol, and I am 28 years old.
You can even include expressions:Code language: Python (python)

print(f"Next year, I will be {age + 1} years old.")Code language: Python (python)

Note:

Use f-strings for most modern Python code. They are concise, readable, and expressive.

Use format() for:

• Backward compatibility with Python < 3.6.
• Scenarios requiring advanced formatting.

35. How to check if a string contains only digits?

The isdigit() method returns True if all characters in the string are digits, and False otherwise.

Example:

my_string = "12345"
if my_string.isdigit():
    print("The string contains only digits.")
else:
    print("The string does not contain only digits.")Code language: Python (python)

36. How to removes any leading and trailing whitespace from a string

The strip() method removes any leading and trailing whitespace (spaces, tabs, or newline characters) from a string. It can also remove specific characters if provided as an argument.

Example:

text = "  Hello, World!  "
print(text.strip())   # Output: "Hello, World!"
# Removing specific characters
custom_text = "...Hello..."
print(custom_text.strip('.'))  # Output: "Hello"Code language: Python (python)

37. How to checks if a string starts and ends with the specified prefix

• startswith(): Checks if a string starts with the specified prefix.
• endswith(): Checks if a string ends with the specified suffix.

Both methods return True or False and are useful for validating string formats.

Examples:

filename = "example.txt"
print(filename.startswith("ex"))  # Output: True
print(filename.endswith(".txt"))  # Output: True
url = "https://www.example.com"
print(url.startswith("http"))  # Output: True
print(url.endswith(".org"))    # Output: FalseCode language: Python (python)

38. How to replace substring in Python?

You can replace a substring within a string in Python using the replace() method. Here’s how it works:

Example:

my_string = "Hello, world!"
new_string = my_string.replace("world", "Python")
print(new_string)  # Output: Hello, Python!Code language: Python (python)

The replace() method takes two arguments:

1. The old substring you want to replace.
2. The new substring you want to replace it with.

It returns a new string with the replacements made. The original string remains unchanged.

Optional Argument:

You can also provide an optional third argument to replace() to specify the maximum number of replacements to make:

my_string = "apple apple apple apple"
new_string = my_string.replace("apple", "banana", 2)  # Replace only the first 2 occurrences
print(new_string)  # Output: banana banana apple appleCode language: Python (python)

39. What are functions in Python? Why are they useful?

A function in Python is a block of reusable code designed to perform a specific task.

Functions in Python are defined using the def keyword, followed by the function name, parentheses (which may include parameters), and a colon. The function body is indented.

Why are they useful?

• Modularity: Break down complex problems into smaller, manageable parts.
• Reusability: Write code once and use it multiple times, avoiding repetition.
• Readability: Make code easier to understand by giving meaningful names to blocks of code.
• Maintainability: Easier to modify and debug code when it’s organized into functions.
• Abstraction: Hide the implementation details and expose only the interface.

Example:

def greet(name):
    return f"Hello, {name}!"
print(greet("Alice"))  # Output: Hello, Alice!Code language: Python (python)

40. What are local and global variables in Python?

In Python, variables have a scope that determines where they can be accessed in your code. This leads to the concepts of local and global variables:

• Local Variables: These variables are declared inside a function. They are only accessible within that function. Think of them as belonging exclusively to that function. Once the function finishes running, the local variables are destroyed. Trying to use a local variable outside its function will result in an error.
• Global Variables: These variables are declared outside any function, usually at the top level of your Python script. They are accessible throughout your entire script, including inside functions. They exist from the point where they are defined until the end of the script’s execution.

In simpler terms: Local variables are like temporary workspaces within a function, while global variables are like shared resources accessible to everyone in your script.

Example:

global_var = 10  # Global variable
def my_function():
    local_var = 5  # Local variable
    print(global_var)  # Accessing global variable is allowed
    print(local_var)  # Accessing local variable is allowed
my_function()
print(global_var)  # Accessing global variable is allowed
# print(local_var)  # This will give an error: local_var is not defined outside the functionCode language: Python (python)

41. What is Scope Resolution in Python?

Scope resolution is the process by which Python determines which variable a name refers to when there are multiple variables with the same name in different scopes (local, global, etc.). Python follows the LEGB rule:

1. Local: Inside the current function.
2. Enclosing: In any enclosing functions (if the current function is nested).
3. Global: At the top level of the module.
4. Built-in: In Python’s built-in namespace (e.g., len, print).

Python searches for the variable name in this order. If it finds the variable in the local scope, it uses that one. If not, it moves to the enclosing scope, and so on.

42. What are the types of functions in Python?

Functions in Python can be categorized into:

1. Built-in Functions: Predefined functions like len(), print(), max().
2. User-defined Functions: Functions created by the user.
3. Lambda Functions: Anonymous, single-expression functions.

43. What is the difference between positional and keyword arguments?

• Positional Arguments: Arguments are passed to a function based on their position in the function call. The first argument matches the first parameter, the second argument matches the second parameter, and so on.
• Keyword Arguments: Arguments are passed to a function by explicitly specifying the parameter name along with the value. This allows you to pass arguments in any order.

Example:

def describe_person(name, age):
    print(f"Name: {name}, Age: {age}")
describe_person("Alice", 30)  # Positional arguments
describe_person(age=30, name="Alice")  # Keyword arguments (order doesn't matter)
# You can also mix them
describe_person("Bob", age=25)  # Positional and keyword mixed.Code language: Python (python)

44. What is the return statement used for?

The return statement is used to exit a function and optionally return a value to the caller. When a return statement is encountered, the function’s execution stops, and the specified value (if any) is sent back to where the function was called.

If there is no explicit return statement, or if the return statement is by itself without any value, then the function implicitly returns None.

Example:

def add(x, y):
    return x + y  # Returns the sum
def greet(name):
    print(f"Hello, {name}!")
    return # returns None implicitly
returned_value = greet("Charlie") # Prints Hello, Charlie!, then returns None
print(returned_value) # Output: NoneCode language: Python (python)

45. What is recursion and can you provide a simple recursive function example?

Recursion is a programming technique where a function calls itself within its own definition. It’s like a set of Russian nesting dolls. A recursive function must have a base case – a condition that stops the function from calling itself infinitely – otherwise, it will lead to a stack overflow error.

Example (factorial):

def factorial(n):
    if n == 0:  # Base case: factorial of 0 is 1
        return 1
    else:
        return n * factorial(n - 1)  # Recursive call
print(factorial(5))  # Output: 120Code language: Python (python)

46. What are *args and kwargs in Python functions?

The *args and kwargs you to write flexible and reusable functions that can accept an arbitrary number of arguments. You can use both in a function, but *args must come before **kwargs in the function definition

*args

• *args allows a function to accept any number of positional arguments.
• Inside the function, args is treated as a tuple containing all the additional positional arguments passed to the function.

**kwargs

• **kwargs allows a function to accept any number of keyword arguments.
• Inside the function, kwargs is treated as a dictionary where the keys are the argument names and the values are the corresponding values passed to the function.

Example:

def example_function(*args, **kwargs):
    print("Args:", args)
    print("Kwargs:", kwargs)
example_function(1, 2, 3, name="Alice", age=25)
# Output:
# Args: (1, 2, 3)
# Kwargs: {'name': 'Alice', 'age': 25}Code language: Python (python)

47. What are lambda functions? When are they useful?

Lambda functions are small, anonymous functions defined using the lambda keyword. Their primary purpose is to create simple, one-line functions without needing a formal function definition using def. They are often used in situations where a short function is required, such as:

• As arguments to higher-order functions: Functions like map(), filter(), and sorted() often take functions as arguments. Lambda functions provide a convenient way to define these functions inline.
• For simple operations: When you need a function for a quick task, a lambda function can be more concise than writing a full def function.

Example:

# Using lambda with map() to square each element in a list:
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)  # Output: [1, 4, 9, 16, 25]
# Using lambda with sorted() to sort a list of tuples by the second element:
data = [(1, 5), (3, 2), (2, 8)]
sorted_data = sorted(data, key=lambda item: item[1])
print(sorted_data)  # Output: [(3, 2), (1, 5), (2, 8)]Code language: Python (python)

48. What is a module in Python?

A module in Python is simply a file containing Python code (definitions of functions, classes, variables, etc.). It’s a way to organize and reuse code. Think of it as a single, self-contained unit of code. Modules provide a way to structure your projects, making them more manageable.

49. How do you import modules in Python? Explain the various ways.

Modules can be imported using the import keyword. Common methods are:

Import the entire module:

import math
print(math.sqrt(16))  # Output: 4.0Code language: Python (python)

Import specific functions or variables:

from math import sqrt
print(sqrt(16))  # Output: 4.0Code language: Python (python)

Use aliases:

import math as m
print(m.sqrt(16))  # Output: 4.0Code language: Python (python)

50. What is a package in Python?

A package in Python is a way to organize related modules into a hierarchical structure. It’s a directory that contains:

• One or more Python modules (.py files).
• An __init__.py file (required).
• Sub-packages (subdirectories that are also packages).

Packages help to organize large Python projects by grouping related functionalities together. They also help prevent naming collisions between modules in different parts of a project.

Example:

my_project/
├── my_package/
│   ├── __init__.py
│   ├── module1.py
│   └── module2.py
└── main.pyCode language: Python (python)

In main.py, you could import from the package like this:

from my_package import module1  # Import a module from the package
# Import specific functions from the module in the package
from my_package.module2 import some_function 
module1.my_function()
some_function()Code language: Python (python)

51. What is the purpose of the __init__.py file in a package?

The __init__.py file is required to make Python treat a directory as a package. Even if the file is empty, its presence signals to Python that the directory should be treated as a package, allowing you to import modules from within it.

It also provides a place to put initialization code for the package, such as setting up variables, importing specific modules within the package, or defining what should be imported when a user does from package_name import *.

52. What is namespace in Python?

A namespace in Python is a naming system that ensures that names are unique and avoids naming conflicts. It’s a container that maps names (variables, functions, classes, etc.) to objects.

Different namespaces can exist at different scopes (global, local, built-in), allowing you to use the same name for different things without ambiguity. Think of it like a filing system; different folders (namespaces) can contain files (objects) with the same name without causing confusion.

53. What are lists and tuples? When would you use one over the other?

• Lists: Lists are ordered, mutable sequences. You can change their elements after they are created (add, remove, modify). They are defined using square brackets [].
• Tuples: Tuples are ordered, immutable sequences. Once a tuple is created, its elements cannot be changed. They are defined using parentheses ().

Use lists when:

• You need a collection of items that might need to be modified.
• The order of elements matters.

Use tuples when:

• You have a fixed set of data that should not be changed (e.g., coordinates, records).
• Immutability is important for data integrity (prevents accidental modification).
• Tuples can be used as keys in dictionaries (because they are hashable, unlike lists).
• Slight performance benefit for iteration: Tuples are generally slightly faster to iterate over than lists due to their immutability.

Example:

# List (mutable)
my_list = [1, 2, 3]
my_list.append(4)  # Allowed
my_list[0] = 10    # Allowed
# Tuple (immutable)
my_tuple = (1, 2, 3)
# my_tuple.append(4)  # Not allowed (will raise an error)
# my_tuple[0] = 10    # Not allowed (will raise an error)Code language: Python (python)

54. How do you iterate through a list with indices?

You can iterate over both the index and the element of a list by using the enumerate() function.

The enumerate() function is a built-in Python function that adds a counter to an iterable (like a list, tuple, or string) and returns an enumerate object. This enumerate object is an iterator that yields tuples, where each tuple contains the index and the corresponding element from the iterable.

Example:

my_list = ["apple", "banana", "cherry"]
# Unpacking the tuple into index and item
for index, item in enumerate(my_list):
    print(f"Index: {index}, Item: {item}")Code language: Python (python)

Output:

Index: 0, Item: apple
Index: 1, Item: banana
Index: 2, Item: cherry

55. What is list comprehension? Why is it useful?

List comprehension is a concise and elegant way to create lists in Python. It allows you to generate a new list by applying an expression to each item in an iterable (like another list, tuple, or range) and optionally filtering those items based on a condition.

Here’s a simple example:

numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # Output: [1, 4, 9, 16, 25]Code language: Python (python)

In this example, [x**2 for x in numbers] is the list comprehension. It reads like this: “For each x in the numbers list, calculate x**2 (x squared) and add it to the new list called squares.

You can also add a condition to filter elements:

numbers = [1, 2, 3, 4, 5, 6]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares)  # Output: [4, 16, 36]Code language: Python (python)

Here, the if x % 2 == 0 part filters the numbers, only including even numbers in the calculation of squares.

Why is list comprehension useful?

• Conciseness: It reduces the amount of code needed to create lists, making your code more readable and compact. The equivalent code using a traditional loop would be much longer.
• Readability: List comprehensions often express the intent more clearly than loops, especially for simple transformations. The logic is often easier to grasp at a glance.
• Performance: In some cases, list comprehensions can be slightly more efficient than equivalent loops, although the performance difference is usually not a primary reason for using them. The main benefits are readability and conciseness.

So, list comprehension is a powerful tool for creating and transforming lists in a Pythonic way. It helps you write cleaner, more efficient, and often more readable code, especially when dealing with simple list manipulations.

56. Explain the difference between == and is

In Python, == and is are both comparison operators, but they check different things:

• == (Equality Operator): This operator checks if the values of two objects are the same. It compares the content of the objects.
• is (Identity Operator): This operator checks if two variables refer to the same object in memory. It compares the memory addresses of the objects. Essentially, it verifies if they are the exact same object.

Here’s an example to illustrate the difference:

list1 = [1, 2, 3]
list2 = [1, 2, 3]  # list2 has same values as list1, but is a different object
print(list1 == list2)  # Output: True (values are the same)
print(list1 is list2)   # Output: False (different objects in memory)
list3 = list1  # list3 now refers to the same object as list1
print(list1 == list3)  # Output: True (values are the same)
print(list1 is list3)   # Output: True (same object in memory)
a = 5
b = 5 # For small integers, Python often reuses memory locations
print(a == b) # Output: True
print(a is b) # Output: True (often, but not guaranteed)
c = 257
d = 257 # For larger integers, Python typically creates separate objects
print(c == d) # Output: True
print(c is d) # Output: False
string1 = "hello"
string2 = "hello" # String interning can cause them to point to same memory location
print(string1 == string2) # Output: True
print(string1 is string2) # Output: True (often, but not guaranteed)Code language: Python (python)

Key takeaway: Use == when you want to compare the content of objects. Use is when you need to check if two variables are pointing to the very same object in memory. is is generally used less frequently than ==.

57. What is the difference between del and remove() on lists?

Both del and remove() are used to delete elements from a list, but they work differently:

• remove(): This method removes the first occurrence of a specific value from the list. If the value is not found, it raises a ValueError.
• del: This statement can be used to delete an element at a specific index or a slice of elements. You can also use del to delete the entire list. It does not return the removed value.

Example:

my_list = [10, 20, 30, 20, 40]
my_list.remove(20)  # Removes the first 20
print(my_list)  # Output: [10, 30, 20, 40]
del my_list[1]  # Removes the element at index 1 (30)
print(my_list)  # Output: [10, 20, 40]
del my_list[1:3]  # Removes a slice of elements from index 1 up to (but not including) 3
print(my_list)  # Output: [10]
del my_list # Deletes the whole list
# print(my_list) # This will give NameError now since my_list does not exist anymore.Code language: Python (python)

58. What is the difference between a Shallow Copy and a Deep Copy?

When you copy objects in Python, you need to understand the difference between shallow and deep copies:

• Shallow Copy: A shallow copy creates a new object, but it references the original elements. If the original object contains mutable elements (like lists or dictionaries), changes to those elements will be reflected in the copy, and vice-versa. It copies the references of the inner objects.
• Deep Copy: A deep copy creates a new object and recursively copies all the elements within it. Changes to the elements in the original object will not affect the deep copy, and vice-versa. It copies everything, including the inner objects.

Example:

import copy
original_list = [1, 2, [3, 4]]
# Shallow copy
shallow_copy = copy.copy(original_list)
shallow_copy[2].append(5)  # Modifying the inner list
print(original_list)  # Output: [1, 2, [3, 4, 5]] (Original is also changed!)
print(shallow_copy)  # Output: [1, 2, [3, 4, 5]]
# Deep copy
deep_copy = copy.deepcopy(original_list)
deep_copy[2].append(6)  # Modifying the inner list
print(original_list)  # Output: [1, 2, [3, 4, 5]] (Original is NOT changed!)
print(deep_copy)  # Output: [1, 2, [3, 4, 5, 6]]Code language: Python (python)

In summary, use a deep copy when you want a completely independent copy of an object, especially if it contains mutable elements. Use a shallow copy when you want a new object but are okay with sharing references to the inner elements (and the potential for changes to affect both the original and the copy).

Let’s address these Python interview questions about lists:

59. What is the difference between list append() and extend()?

Both append() and extend() are used to add elements to a list, but they differ in how they add them:

• append(): Adds a single element to the end of the list. The element can be of any type (a number, string, another list, etc.).
• extend(): Adds multiple elements (from an iterable like another list, tuple, or string) to the end of the list. It essentially “extends” the list with the elements from the iterable.

Example:

my_list = [1 ,2, 3]
my_list.append(4)  # Adds the single element 4
print(my_list)  
#Output: [1, 2, 3, 4]
my_list.extend([4,5,6])  # Adds the elements 5, 6, and 7
print(my_list)  
#Output: [1, 2, 3, 4, 4, 5, 6]Code language: Python (python)

60. How will you remove the last object from a list in Python?

There are a few ways to remove the last object from a list:

• pop() (most common): The pop() method removes and returns the last element of the list.
• del: You can use the del statement with the index -1 to remove the last element.

Example:

list1 = [10, 20, 30, 40, 50, 60]
list2 = [30, 40, 50]
last_element = list1.pop()
print(last_element)  # Output: 60
print(list1)  # Output: [10, 20, 30, 40, 50]
del list2[-1]
print(list2)  # Output: [30, 40]Code language: Python (python)

61. How does the zip() function work?

The zip() function takes multiple iterables (like lists, tuples, or strings) as input and returns an iterator of tuples. Each tuple contains corresponding elements from the input iterables. It’s like “zipping” together the iterables.

Example:

names = ["Alice", "Bob", "Charlie"]
ages =
zipped = zip(names, ages)
print(list(zipped))  # Output: [('Alice', 30), ('Bob', 25), ('Charlie', 35)]
# You can also use zip with more than two iterables:
cities = ["New York", "London", "Paris"]
zipped_multiple = zip(names, ages, cities)
print(list(zipped_multiple))  # Output: [('Alice', 30, 'New York'), ('Bob', 25, 'London'), ('Charlie', 35, 'Paris')]Code language: Python (python)

62. How to find the intersection of two lists in Python

Here’s a function to find the intersection of two lists:

Example:

def intersection(list1, list2):
    """
    Returns a new list containing the elements that are common to both input lists.
    """
    return list(set(list1) & set(list2))  # Convert to sets for efficient intersection
list1 = [10, 20, 30, 40, 50, 60]
list2 = [30, 40, 50]
intersection_result = intersection(list1, list2)
print(intersection_result)  
# Output: [40, 50, 30]Code language: Python (python)

Explanation:

1. Convert to sets: Converting the lists to sets (set(list1) and set(list2)) allows us to use the set intersection operator (&) efficiently. Sets automatically handle duplicates and provide fast membership testing.
2. Intersection: The & operator returns a new set containing only the elements that are present in both sets.
3. Convert back to list: The result is converted back to a list (list(...)) before returning.

63. Given a list of numbers find the sum of all odd numbers

• Iterates through the list: It then iterates through each number in the input list.
• Checks for odd numbers: Inside the loop, it uses the modulo operator (%) to check if the number is odd. number % 2 != 0 means that the remainder when the number is divided by 2 is not 0, which is the condition for a number to be odd.
• Adds to sum: If the number is odd, it’s added to the odd_sum.
• Returns the sum: Finally, the function returns the odd_sum.

Solution:

def sum_odd_numbers(numbers):
    if not numbers:  # Check if the list is empty
        return 0
    odd_sum = 0
    for number in numbers:
        if number % 2 != 0:  # Check if the number is odd
            odd_sum += number
    return odd_sum
# Example usage:
numbers1 = [1, 2, 3, 4, 5]
result1 = sum_odd_numbers(numbers1)
print(f"Sum of odd numbers in {numbers1}: {result1}")  # Output: 9Code language: Python (python)

64. What are dictionaries in Python? How do you access values?

Dictionaries in Python are unordered collections of key-value pairs. Each key must be unique and immutable (e.g., strings, numbers, or tuples), while the values can be of any data type. Dictionaries are defined using curly braces {}.

You access values in a dictionary using their corresponding keys:

Example:

my_dict = {"name": "Alice", "age": 30, "city": "New York"}
# Accessing values:
print(my_dict["name"])  # Output: Alice
print(my_dict["age"])   # Output: 30
# If you try to access a key that doesn't exist, you'll get a KeyError.
# To avoid this, you can use the get() method:
print(my_dict.get("country", "Unknown"))  # Output: Unknown (because "country" key doesn't exist)
print(my_dict.get("age")) # Output: 30
# You can also access all keys or all values of a dictionary
print(my_dict.keys()) # Output: dict_keys(['name', 'age', 'city'])
print(my_dict.values()) # Output: dict_values(['Alice', 30, 'New York'])
print(my_dict.items()) # Output: dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])Code language: Python (python)

65. How do you iterate through a dictionary?

There are several ways to iterate through a dictionary in Python:

a) Iterating through keys (default):

my_dict = {"a": 1, "b": 2, "c": 3}
for key in my_dict:  # This iterates through the keys by default
    print(key, my_dict[key])Code language: Python (python)

b) Iterating through keys explicitly:

for key in my_dict.keys():
    print(key, my_dict[key])Code language: Python (python)

c) Iterating through values:

for value in my_dict.values():
    print(value)Code language: Python (python)

d) Iterating through key-value pairs (items):

for key, value in my_dict.items():
    print(key, value)Code language: Python (python)

66. How do you merge two dictionaries in Python?

There are several ways to merge two dictionaries in Python:

1. Using the update() method:

This is the most common and straightforward approach. The update() method adds the key-value pairs from one dictionary to another. If a key already exists in the target dictionary, its value is updated with the value from the other dictionary.

Example:

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4, "a": 5}  # "a" key is present in both
dict1.update(dict2)  # dict1 is modified in place
print(dict1)  # Output: {'a': 5, 'b': 2, 'c': 3, 'd': 4}Code language: Python (python)

2. Using the | operator (Python 3.9+)

For Python 3.9 and later, you can use the union operator | to merge dictionaries. This creates a new dictionary containing the combined key-value pairs. If keys are duplicated, the rightmost dictionary’s value is used.

Example:

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4, "a": 5}
merged_dict = dict1 | dict2  # Creates a new dictionary
print(merged_dict)  # Output: {'a': 5, 'b': 2, 'c': 3, 'd': 4}
print(dict1) # Output: {'a': 1, 'b': 2} (dict1 is not changed)Code language: Python (python)

3. Using the ** operator (Python 3.5+)

This method is more flexible and can be used to merge multiple dictionaries or create a new dictionary by combining existing ones.³ Again, duplicate keys will have the value from the later dictionary in the merge.

Example:

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4, "a": 5}
merged_dict = {**dict1, **dict2}  # Creates a new dictionary
print(merged_dict)  # Output: {'a': 5, 'b': 2, 'c': 3, 'd': 4}
print(dict1) # Output: {'a': 1, 'b': 2} (dict1 is not changed)
dict3 = {"e": 6, "f": 7}
merged_multiple = {**dict1, **dict2, **dict3}
print(merged_multiple)  # Output: {'a': 5, 'b': 2, 'c': 3, 'd': 4, 'e': 6, 'f': 7}Code language: Python (python)

Which Method to Use?

• update(): Modifies the original dictionary in place. Use this if you don’t need to preserve the original dictionaries.
• | (Python 3.9+): Concise syntax for creating a new merged dictionary.
• ** (Python 3.5+): More flexible, especially when merging multiple dictionaries or creating new ones. Good for more complex scenarios.

The update() method is often the most commonly used due to its simplicity and direct modification of the dictionary. However, | and ** are useful when you want to create a new merged dictionary without changing the original dictionaries.

67. What are sets in Python? What are they typically used for?

Sets in Python are unordered collections of unique elements. Duplicate values are automatically removed. Sets are defined using curly braces {}, but unlike dictionaries, they don’t have key-value pairs.

Sets are typically used for:

• Removing duplicates: Converting a list to a set and back to a list is a common way to eliminate duplicates.
• Membership testing: Checking if an element is present in a set is very fast.
• Set operations: Performing mathematical set operations like union, intersection, difference, etc.

Example:

my_set = {1, 2, 2, 3, 4, 4, 5}  # Duplicates are removed
print(my_set)  # Output: {1, 2, 3, 4, 5}
my_list = [1,2,2,3,4,4,5]
unique_list = list(set(my_list)) #remove duplicates from a list
print(unique_list) # Output: [1, 2, 3, 4, 5]
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2)  # Union: {1, 2, 3, 4, 5}
print(set1 & set2)  # Intersection: {3}
print(set1 - set2)  # Difference: {1, 2}Code language: Python (python)

68. What is the difference between // and / in Python?

Both are division operators, but they produce different results:

• / (Regular Division): Performs standard division and returns a floating-point result, even if the operands are integers and the result is a whole number.
• // (Floor Division): Performs division and returns the floor of the result. The floor is the largest integer that is less than or equal to the result. If the operands are integers, the result will also be an integer.

Example:

print(10 / 3)  # Output: 3.3333333333333335
print(10 // 3)  # Output: 3
print(10.0 / 3) # Output: 3.3333333333333335
print(10.0 // 3) # Output: 3.0Code language: Python (python)

69. What is exception handling in Python?

Exception handling is a mechanism to deal with errors that occur during the execution of a program. These errors, called exceptions, can disrupt the normal flow of the program. Exception handling allows you to gracefully manage these errors, preventing the program from crashing and providing a way to recover or handle the situation appropriately.

70. What is the try-except block? Provide an example

The try-except block is the core of exception handling in Python. You put the code that might raise an exception within the try block. The except block defines how to handle a specific type of exception if it occurs.

Example:

try:
    result = 10 / 0  # This will raise a ZeroDivisionError
    print(result) # This will not be executed
except ZeroDivisionError:
    print("Cannot divide by zero!")  # Handle the error
except TypeError: # you can add multiple except blocks
    print("Type error occurred")
except Exception as e: # generic exception block to catch any type of error. Should be used with caution.
    print(f"An error occurred: {e}")
print("Program continues...")  # The program doesn't crashCode language: Python (python)

71. What is the purpose of the finally clause?

The finally clause is an optional part of the try-except block. The code within the finally block always executes, regardless of whether an exception was raised or not. It’s typically used for cleanup tasks, such as closing files, releasing resources, or ensuring that certain actions are always performed.

Example:

try:
    f = open("my_file.txt", "r")
    #... process the file...
except FileNotFoundError:
    print("File not found.")
finally:
    if 'f' in locals() and not f.closed: # check if f is defined and file is not closed
        f.close()  # Close the file, even if there was an error
    print("File operation complete.")Code language: Python (python)

72. How does the else clause work in exception handling?

The else clause in a try-except block is also optional. The code within the else block executes only if no exception occurred in the try block. It’s a good place to put code that should run only when the try block was successful.

Example:

try:
    x = int(input("Enter a number: "))
except ValueError:
    print("Invalid input. Please enter a number.")
else:  # This will run only if no ValueError occurred
    result = x * 2
    print(f"The result is: {result}")
finally:
    print("Input processed.")Code language: Python (python)

73. What are some common built-in exceptions in Python?

Here are some common built-in exceptions in Python:

• ZeroDivisionError: Raised when dividing by zero.
• TypeError: Raised when an operation is performed on incompatible types.
• ValueError: Raised when a function receives an argument of the correct type but an inappropriate value.
• FileNotFoundError: Raised when a file or directory is¹ not found.
• IndexError: Raised when trying to access an index that is out of range for a sequence (like a list).
• KeyError: Raised when trying to access a key that does not exist in a dictionary.
• IOError: Raised when an input/output operation fails (e.g., reading or writing a file).
• ImportError: Raised when a module cannot be imported.
• NameError: Raised when you try to use a variable that has not been defined.

74. What is object-oriented programming?

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects,” which are instances of classes. These objects encapsulate data (attributes) and behavior (methods) and interact with one another to perform tasks. OOP is widely used because it promotes modularity, code reusability, and scalability.

Benefits of OOP:

• Modularity: Code is organized into classes, making it easier to manage and understand.
• Reusability: Through inheritance and polymorphism, code can be reused and extended.
• Maintainability: Encapsulation and abstraction make it easier to modify and maintain the code.
• Scalability: OOP helps design scalable and robust systems.

75. What are classes and objects in Python?

• Class: A class is a blueprint or template for creating objects. It defines the structure and behavior that the objects will have. It’s like a cookie cutter.
• Object: An object is an instance of a class. It’s a concrete realization of the class. It’s like a cookie made using the cookie cutter. Each object has its own set of data (attributes) and can perform the actions defined by the class (methods).

Example:

class Dog:  # Class (blueprint)
    def __init__(self, name, breed):  # Constructor (used to create objects)
        self.name = name  # Attributes
        self.breed = breed
    def bark(self):  # Method
        print("Woof!")
my_dog = Dog("Buddy", "Golden Retriever")  # Object (instance)
another_dog = Dog("Max", "German Shepherd") # Another object
print(my_dog.name)  # Accessing an attribute
my_dog.bark()  # Calling a methodCode language: Python (python)

76. What are attributes and methods in a class?

• Attributes: These are the data or characteristics associated with an object. They represent the state of the object. In the Dog example above, name and breed are attributes.
• Methods: These are functions defined within a class that operate on the object’s data (attributes). They represent the behavior of the object. In the Dog example, bark() is a method.

77. What is inheritance? Give an example

Inheritance allows you to create a new class (derived class or subclass) that inherits attributes and methods from an existing class (base class or superclass). This promotes code reuse and creates a hierarchy of classes.

Example:

class Animal:  # Base class
    def __init__(self, name):
        self.name = name
    def eat(self):
        print("Eating...")
class Dog(Animal):  # Derived class (inherits from Animal)
    def __init__(self, name, breed):
        super().__init__(name)  # Call the base class's constructor to initialize name
        self.breed = breed
    def bark(self):
        print("Woof!")
my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)  # Inherited from Animal
my_dog.eat()  # Inherited from Animal
my_dog.bark()  # Defined in DogCode language: Python (python)

78. What is polymorphism? Give an example

In Python, polymorphism is the ability of objects of different classes to respond to the same method call in their own specific ways.

Polymorphism lets you treat objects of different classes in a uniform way. Imagine you have a Shape class, and then you have subclasses like Circle, Square, and Triangle. Each of these shapes has an area() method, but the way you calculate the area is different for each shape.

The core idea is that the same method name can have different implementations depending on the class of the object.

Example:

class Shape:
    def area(self):
        raise NotImplementedError("area() method must be implemented.")  # Abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):  # Overriding the area() method
        return 3.14159 * self.radius**2
class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):  # Overriding the area() method
        return self.side**2
shapes = [Circle(5), Square(4)]
for shape in shapes:
    print(shape.area())  # Polymorphism: Each object calculates area differentlyCode language: Python (python)

• In this example, both Circle and Square have an area() method, but they calculate the area differently.
• The for loop treats both objects as Shape objects and calls the area() method, but the correct version of the method is called based on the actual type of the object (either Circle or Square).
• This is an example of method overriding which is one of the ways polymorphism can be implemented.

79. What is encapsulation and abstraction?

Encapsulation

Encapsulation is the bundling of data (attributes) and the methods that operate on that data within a single unit (a class). It also involves controlling access to the internal data of an object, preventing direct and inappropriate modification. This helps to protect the integrity of the data and makes the code more modular and maintainable.

Abstraction

Abstraction is the process of hiding complex implementation details and showing only the essential information to the user. It simplifies the interaction with objects by providing a simplified interface. You don’t need to know how a method is implemented internally; you just need to know what it does. Abstraction is often achieved using abstract classes.

Example:

Imagine a TV remote. You don’t need to know the complex electronics inside the remote to change the channel. The remote provides a simple interface (buttons) to interact with the TV. This is abstraction.

In Python, you can achieve abstraction through:

• Abstract Classes (using the abc module): You can define abstract methods in a base class that derived classes must implement. This enforces a certain interface.
• Well-defined methods: By giving meaningful names to methods and documenting their behavior, you can abstract away the implementation details.

80. What is the self keyword used for?

The self keyword is used as the first parameter in instance methods of a class. It refers to the instance of the class that the method is being called on.

When you call a method on an object, Python automatically passes the object itself as the first argument (self). self is how the method can access and modify the object’s attributes.

It’s a convention in python to name the first argument of instance methods as self, but you can name it anything you want, it will still work.

Example:

class MyClass:
    def my_method(self, arg1):  # self refers to the instance
        self.my_attribute = arg1  # Accessing and setting an attribute
obj = MyClass()
obj.my_method(10)  # Python implicitly passes obj as the first argument (self)
print(obj.my_attribute)  # Output: 10Code language: Python (python)

In essence, self is the way an object refers to itself within its own methods.

81. How do you create a constructor in Python?

You create a constructor in Python by defining a special method named __init__ (double underscores init double underscores). This method is automatically called when you create a new object (instance) of a class. The __init__ method is used to initialize the object’s attributes (data).

Example:

class MyClass:
    def __init__(self, arg1, arg2):  # Constructor
        self.attribute1 = arg1  # Initialize instance attributes
        self.attribute2 = arg2
obj = MyClass(10, "hello")  # Creates an object and calls __init__
print(obj.attribute1)  # Output: 10
print(obj.attribute2)  # Output: helloCode language: Python (python)

82. What is method overriding in Python?

Method overriding occurs when a derived class (subclass) defines a method with the same name as a method in its base class (superclass). When you call this method on an object of the derived class, the derived class’s version of the method is executed, overriding the base class’s version.

This allows you to customize the behavior of inherited methods in subclasses.

Example:

class Animal:
    def make_sound(self):
        print("Generic animal sound")
class Dog(Animal):
    def make_sound(self):  # Method overriding
        print("Woof!")
my_dog = Dog()
my_dog.make_sound()  # Output: Woof! (Dog's version is called)
my_animal = Animal()
my_animal.make_sound() # Output: Generic animal sound (Animal's version is called)Code language: Python (python)

83. What is the difference between class variables and instance variables?

• Class Variables: These variables are defined within the class but outside any method. They are shared by all instances of the class. If you modify a class variable, the change is reflected for all objects.
• Instance Variables: These variables are defined inside the __init__ method (or other instance methods) using self.variable_name. Each instance of the class gets its own separate copy of instance variables. Changes to an instance variable of one object do not affect other objects.

Example:

class MyClass:
    class_variable = 0  # Class variable (shared by all instances)
    def __init__(self, value):
        self.instance_variable = value  # each instance has its own
obj1 = MyClass(10)
obj2 = MyClass(20)
print(obj1.class_variable)  # Output: 0
print(obj2.class_variable)  # Output: 0
obj1.class_variable = 1  # Modifying class variable
print(obj1.class_variable)  # Output: 1
print(obj2.class_variable)  # Output: 1 (changed for all instances)
print(obj1.instance_variable)  # Output: 10
print(obj2.instance_variable)  # Output: 20
obj1.instance_variable = 100  # Modifying instance variable
print(obj1.instance_variable)  # Output: 100
print(obj2.instance_variable)  # Output: 20 (only obj1 is affected)Code language: Python (python)

84. What are decorators in Python?

Decorators in Python are a powerful way to modify or enhance functions and methods in a clean and reusable way. They allow you to wrap a function with another function, adding functionality before or after the original function’s execution, without directly changing the original function’s code. They use the @ symbol followed by the decorator function name.

Example:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function.")
        func()  # Call the original function
        print("Something is happening after the function.")
    return wrapper
@my_decorator  # Applying the decorator
def say_hello():
    print("Hello!")
say_hello()Code language: Python (python)

Output:

Something is happening before the function.
Hello!
Something is happening after the function.

85. What is a generator in Python and how does it differ from a normal function?

A generator is a special type of function that returns an iterator. Unlike normal functions that compute and return a value all at once, generators produce a sequence of values one at a time, on demand. This is called “lazy evaluation” and can be very memory-efficient, especially when dealing with large datasets.

Key differences from normal functions:

• yield keyword: Generators use the yield keyword to produce a value and pause their execution. The function’s state is saved, so it can resume from where it left off when the next value is requested.
• Returns an iterator: Generators implicitly return an iterator object.
• Lazy evaluation: Values are generated only when requested, saving memory.

Example:

Imagine you want to generate a sequence of numbers from 1 to 5. A normal function might create a list of these numbers and return it. A generator does this more efficiently:

# Normal function (creates a list in memory)
def generate_numbers_normal(n):
    numbers =
    for i in range(1, n + 1):
        numbers.append(i)
    return numbers
# Generator function (yields values one at a time)
def generate_numbers_generator(n):
    for i in range(1, n + 1):
        yield i  # Yield each number
# Using the generator:
for number in generate_numbers_generator(5):
    print(number)  # Prints 1, 2, 3, 4, 5 (one at a time)
numbers = generate_numbers_normal(5)
print(numbers) # prints all at onceCode language: Python (python)

The generator version doesn’t create the entire list in memory at once. It yields each number as it’s requested, making it more memory-efficient, especially for large ranges.

86. How does the yield keyword work in a function?

The yield keyword is the heart of a generator. When yield is encountered in a function:

1. The function’s state is “frozen.” This includes the values of local variables and the point of execution.
2. The value specified after yield is returned to the caller.
3. The function’s execution is paused.

When the next value from the generator is requested (e.g., using next() or in a for loop), the function’s execution resumes from where it was paused (right after the yield statement).

Example: Let’s illustrate how yield pauses and resumes execution:

def my_generator():
    print("First")
    yield 1
    print("Second")
    yield 2
    print("Third")
    yield 3
gen = my_generator()  # Get the generator object
print(next(gen))  # Output: First, 1
print(next(gen))  # Output: Second, 2
print(next(gen))  # Output: Third, 3
#print(next(gen)) # This will give StopIteration error since all values are yielded.
for i in gen: # this will not print anything since generator is exhausted.
    print(i)Code language: Python (python)

• Each time next(gen) is called, the generator function runs until it hits a yield. It returns the yielded value, and its execution pauses. The next next(gen) call resumes the function from where it left off.
• This continues until the generator is exhausted (no more yield statements), at which point it raises a StopIteration exception.

87. What is an iterator and how is it implemented in Python?

An iterator is an object that allows you to traverse through a sequence of data, one element at a time. It has two essential methods:

• __iter__(): Returns the iterator object itself. This is used when the iterator is used in a context where one is expected, such as for x in iterator.
• __next__(): Returns the next element in the sequence. If there are no more elements, it raises a StopIteration exception.

Implementation:

Iterators can be implemented by creating a class with __iter__() and __next__() methods.

class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current < self.limit:
            value = self.current
            self.current += 1
            return value
        else:
            raise StopIteration
my_iter = MyIterator(5)
for i in my_iter:
    print(i)Code language: Python (python)

88. What is the difference between an iterator and a generator?

• Iterators: Are a more general concept. They are objects with __iter__() and __next__() methods that provide a way to access elements of a sequence one by one.
• Generators: Are a specific type of iterator. They are implemented using functions and the yield keyword, making it easier and more concise to create iterators. All generators are iterators, but not all iterators are generators. Generators automate the creation of the iterator protocol methods (__iter__ and __next__).

Let’s tackle these Python file handling interview questions.

89. How do you open and read a file in Python?

Using with open() (Recommended) we can perform file read and write operations.

This is the preferred method because it ensures the file is automatically closed, even if errors occur. This prevents resource leaks and data corruption.

Example:

try:
    with open("my_file.txt", "r") as file:  # "r" mode for reading
        content = file.read()  # Reads the entire file content into a single string
        print(content)
    # File is automatically closed here
except FileNotFoundError:
    print("File not found.")
except Exception as e:
    print(f"An error occurred: {e}")
# Reading line by line (more efficient for large files):
try:
    with open("my_file.txt", "r") as file:
        for line in file:  # Iterates through each line
            print(line, end="")  # end="" prevents extra newlines
except FileNotFoundError:
    print("File not found.")
except Exception as e:
    print(f"An error occurred: {e}")Code language: Python (python)

Explanation of Key Concepts:

• File Modes: The "r" in open("my_file.txt", "r") specifies that the file is opened in read mode. Other modes include "w" (write), "a" (append), "rb" (read binary), etc.
• read(): The file.read() method reads the entire content of the file and returns it as a single string. Be cautious with very large files, as this can consume significant memory.
• Line-by-Line Reading: Iterating directly over the file object (for line in file:) reads the file line by line. This is the most memory-efficient way to read large files because you only process one line at a time.
• readlines(): The file.readlines() method reads all lines from the file and returns them as a list of strings. Each string in the list represents a line, including the newline character (\n).
• with open(): The with statement is a context manager. It automatically handles the closing of the file, even if exceptions occur within the block. This makes your code more robust and less prone to errors. Always use with open() when possible.
• Error Handling: The try...except block is used to handle potential errors, such as the file not being found (FileNotFoundError). This prevents your program from crashing and allows you to provide informative error messages.

90. How do you write to a file in Python?

Solution:

try:
    file = open("output.txt", "w")  # "w" for writing (overwrites existing content)
    file.write("Hello, world!\n")
    file.write("This is a new line.\n")
    file.close()
    file = open("output.txt", "a")  # "a" for appending (adds to the end)
    file.write("More content.\n")
    file.close()
except Exception as e:
    print(f"An error occurred: {e}")Code language: Python (python)

91. How do you close a file in Python? Why is it important?

We use the file.close() method to close a file. It’s crucial because:

• Resource Management: Files are operating system resources. Leaving them open can lead to resource leaks, especially if you’re working with many files. The OS might limit the number of open files.
• Data Integrity: Data written to a file might be buffered in memory. file.close() flushes this buffer, ensuring that the data is actually written to the disk. Without closing, you risk data loss if your program crashes.
• File Locking: While a file is open for writing, it might be locked by the OS, preventing other programs from accessing it. Closing the file releases the lock.

92. What is the with statement used for in file handling?

The with statement provides a cleaner and safer way to work with files. It automatically handles closing the file, even if exceptions occur.

Example:

try:
    with open("my_file.txt", "r") as file:  # File is automatically closed
        content = file.read()
        print(content)
    # File is automatically closed here
    with open("output.txt", "w") as file:
        file.write("Content written using 'with'.\n")
except FileNotFoundError:
    print("File not found.")
except Exception as e:
    print(f"An error occurred: {e}")Code language: Python (python)

The with statement uses a context manager, which guarantees that the __exit__() method of the file object is called when the block is exited, regardless of whether there were exceptions or not. This __exit__() method is what closes the file. It’s highly recommended to use with whenever you’re working with files.

93. How do you handle exceptions related to file I/O?

Use try...except blocks to handle potential errors:

Example:

try:
    with open("nonexistent_file.txt", "r") as file:
        # Code that might raise an exception
        pass  # Just an example
except FileNotFoundError:  # Specific exception
    print("The file was not found.")
except IOError as e:  # Another specific exception (Input/Output Error)
    print(f"An I/O error occurred: {e}")
except Exception as e:  # Catch-all exception (handle with care)
    print(f"A general error occurred: {e}")
finally: # Optional: Code that always executes (e.g., cleanup)
    print("This will always run")Code language: Python (python)

• Specific Exceptions: Catching specific exceptions like FileNotFoundError or IOError allows you to handle them differently and provide more informative error messages.
• General Exception: Catching a general Exception is useful as a last resort, but it’s often better to be more specific if you can.
• finally Block (Optional): The finally block is useful for cleanup code that must execute, even if an exception occurs. This is a good place to put file closing if you’re not using the with statement (although with is generally preferred).

Remember to choose the appropriate file mode (“r”, “w”, “a”, “rb”, “wb”, etc.) based on your needs. Always use the with statement if possible to ensure files are closed properly. And handle exceptions to make your code more robust.

Let’s address these Python regular expression interview questions.

94. What is a regular expression?

A regular expression (regex or regexp) is a powerful way to search, match, and manipulate strings. It’s a sequence of characters that defines a search pattern. Think of it as a more flexible and powerful version of “find and replace.” Regexes are used for:

• Pattern Matching: Checking if a string matches a specific pattern (e.g., email address format, phone number format).
• Searching: Finding all occurrences of a pattern within a string.
• Replacing: Replacing parts of a string that match a pattern.
• Data Validation: Ensuring that user input or data conforms to certain rules.
• Text Processing: Extracting specific information from text.

95. Get all digits from a string using regular expression:

Solution:

import re
text = "This string contains digits like 123 and 456."
# Method 1 (find all digits):
digits = re.findall(r"\d", text)  # \d matches any digit (0-9)
print(digits)  # Output: ['1', '2', '3', '4', '5', '6']
#Method 2 (find all consecutive digits as a number):
numbers = re.findall(r"\d+", text) # \d+ matches one or more digits
print(numbers) # Output: ['123', '456']Code language: Python (python)

Explanation:

• re.findall(): This function finds all occurrences of the pattern in the string and returns them as a list of strings.
• r"\d": This is the regular expression pattern. \d matches any single digit (0-9). The r prefix indicates a “raw string,” which is recommended for regular expressions to avoid issues with backslashes.
• r"\d+": This regular expression pattern matches one or more consecutive digits.

96. Search any eight-letter word in a string using regular expression:

Solution:

import re
text = "This string has some eight-letter words like computer and internet, and also shorter words."
words = re.findall(r"\b\w{8}\b", text)  # \b for word boundaries, \w for word characters, {8} for length
print(words)  # Output: ['computer', 'internet']
#Case insensitive search
words_case_insensitive = re.findall(r"\b\w{8}\b", text, re.IGNORECASE)
print(words_case_insensitive)  # Output: ['computer', 'internet']Code language: Python (python)

Explanation:

• \b: Matches a word boundary. This ensures that we match whole words and not parts of other words (e.g., “cat” in “scat”).
• \w: Matches any word character (letters, digits, and underscore).
• {8}: Matches exactly eight occurrences of the preceding character or group (in this case, \w).
• re.IGNORECASE: This flag makes the search case-insensitive.

Let’s briefly cover these Python testing and debugging interview questions.

97. Why is testing important in software development?

Testing is crucial because it:

• Finds Bugs: Identifies errors and defects early in the development process.
• Improves Quality: Leads to more reliable and robust software.
• Reduces Costs: Fixing bugs early is cheaper than fixing them later.
• Increases Confidence: Gives developers and stakeholders confidence in the software’s correctness.
• Facilitates Maintenance: Makes it easier to modify and update code without introducing new bugs.

98. What are some Python testing frameworks?

Popular Python testing frameworks include:

• unittest (Built-in): Python’s standard testing framework, good for basic testing.
• pytest: A more feature-rich and easier-to-use framework, highly recommended.
• nose: An older framework, but still used in some projects.

99. How do you debug Python code?

Key debugging tools and techniques:

• print() statements: Simple but effective for understanding program flow and variable values.
• pdb (Python Debugger): A command-line debugger for stepping through code, inspecting variables, and setting breakpoints.
• IDEs (Integrated Development Environments): Most IDEs (like VS Code, PyCharm, Thonny) have built-in debuggers with graphical interfaces.
• Logging: Use the logging module for more structured and persistent debugging information.

100. What are some common debugging techniques?

Common debugging strategies:

• Reproduce the Bug: Make sure you can consistently reproduce the error.
• Isolate the Problem: Narrow down the code section where the bug is likely to be.
• Use Breakpoints: Stop the program’s execution at specific points to examine variables and program state.
• Step Through Code: Execute the code line by line to understand how it works.
• Inspect Variables: Examine the values of variables at different points in the program.
• Use a Debugger: Employ the features of a debugger (breakpoints, stepping, watch variables).
• Rubber Duck Debugging: Explain the code to someone (or something) to find logical flaws.
• Divide and Conquer: If you have a large block of code, divide it into smaller sections and debug each section separately.

Conclusion

Mastering the fundamentals of Python is crucial for any aspiring programmer. This article has provided a comprehensive overview of key Python concepts and common interview questions, designed to help you prepare effectively for your next interview. We’ve covered essential topics such as data types, operators, control flow, functions, object-oriented programming, and exception handling. Remember that simply reading through these questions and answers is not enough. The key to success lies in actively practicing and applying these concepts.

Try writing your own code examples, experimenting with different scenarios, and deepening your understanding of how Python works under the hood. Furthermore, don’t hesitate to explore additional resources, online tutorials, and open-source projects to expand your knowledge and stay up-to-date with the latest advancements in the Python ecosystem. With diligent preparation and a strong grasp of these fundamental principles, you’ll be well on your way to showcasing your Python expertise and landing your dream job.