Top 50 Python Interview Questions

Python is a high-level, interpreted, object-oriented programming language known for its simple and readable syntax, which makes it a popular first language and a productive choice for scripting, web backends, data science, and automation alike.

print("Hello, Python!")

Python is easy to learn and use, an interpreted language (no separate compile step), dynamically typed (no need to declare variable types), object-oriented, backed by a large standard library, and cross-platform. Together these make it beginner-friendly, versatile, and widely used across web development, AI, data science, and automation.

Interpreted languages (like Python and JavaScript) execute code line by line with no separate compilation step, which makes iterating faster but execution somewhat slower. Compiled languages (like C, C++, and Java) convert the entire program into machine code before running it, which takes an extra build step but usually runs faster.

PEP 8 is Python's official style guide - a set of conventions for writing clean, readable, and consistent code (naming conventions, indentation, line length, and more). Following it improves code readability, keeps a codebase consistent, and makes collaborating with a team much easier.

Variables are names used to store data values in memory. Python is dynamically typed, so you never declare a type up front - the type is inferred from whatever value you assign, and it can even change if you reassign the variable to a value of a different type.

x = 10        # x is integer
name = "Python"  # name is string
is_fun = True    # is_fun is boolean
print(x, name, is_fun)

Python has several built-in data types: `int`, `float`, and `complex` for numbers; `str` for text; `list`, `tuple`, and `set` for collections; `dict` for key-value pairs; `bool` for True/False; and `NoneType` for the absence of a value (`None`).

A list is mutable (its contents can be changed after creation) and uses square brackets `[ ]`; it's slightly slower and offers more built-in methods. A tuple is immutable (cannot be changed after creation), uses parentheses `( )`, and is faster with fewer methods - useful for data that should never change, like coordinates or fixed configuration values.

lst = [1, 2, 3]
lst[0] = 10       # OK - lists are mutable

tup = (1, 2, 3)
tup[0] = 10       # TypeError - tuples are immutable

A dictionary stores data as key-value pairs, letting you look up a value instantly by its key instead of searching through a list by position. Keys must be unique and hashable (strings, numbers, or tuples); values can be anything.

student = {"name": "John", "age": 22}
print(student["name"])   # John
student["age"] = 23
print(student)            # {'name': 'John', 'age': 23}

A set is an unordered collection of unique elements - duplicates are automatically discarded when you build one. Sets support fast membership tests and operations like union, intersection, and difference, and are commonly used to de-duplicate data or compare two collections.

numbers = {1, 2, 2, 3, 3, 4}
print(numbers)     # {1, 2, 3, 4}
numbers.add(5)
numbers.remove(2)
print(numbers)     # {1, 3, 4, 5}

Type casting is the process of converting a value from one data type into another, using functions like `int()`, `float()`, `str()`, `list()`, `tuple()`, and `set()`. It is commonly needed when combining user input (always a string) with numeric calculations.

x = "10"
y = int(x)      # type casting to int
z = float(y)    # type casting to float
print(x, type(x))  # 10 <class 'str'>
print(y, type(y))  # 10 <class 'int'>
print(z, type(z))  # 10.0 <class 'float'>

Arithmetic operators perform mathematical operations: `+` addition, `-` subtraction, `*` multiplication, `/` division (always returns a float), `%` modulus (remainder), `**` exponent (power), and `//` floor division (division rounded down to the nearest whole number).

print(5 + 3)   # 8
print(5 - 3)   # 2
print(5 * 3)   # 15
print(5 / 2)   # 2.5
print(5 % 2)   # 1
print(2 ** 3)  # 8
print(5 // 2)  # 2

`=` is the assignment operator - it stores a value in a variable. `==` is the comparison operator - it checks whether two values are equal and returns a boolean. Mixing them up (writing `x = y` inside a condition instead of `x == y`) is a classic beginner syntax error.

x = 10   # assignment (stores value)
y = 10   # assignment
print(x == y)  # True (comparison)

Logical operators combine conditional statements: `and` is True only if both sides are True, `or` is True if at least one side is True, and `not` reverses (negates) the result of a condition.

print(True and False)  # False
print(True or False)   # True
print(not True)         # False

The `%` operator returns the remainder after division. It's frequently used to check whether a number is even or odd, or to wrap an index around a fixed range. In Python, the result of `%` always has the same sign as the divisor, so the remainder for a negative dividend is non-negative when the divisor is positive.

print(10 % 3)    # 1
print(25 % 4)    # 1
print(-10 % 3)   # 2 (remainder is always non-negative here)

Operator precedence determines the order in which operations are evaluated in an expression - higher-precedence operators run first. From highest to lowest: parentheses `()`, exponent `**`, unary +/-, then `*` `/` `//` `%`, then `+` `-`, then comparisons, then `not`, `and`, `or`, and finally assignment operators. When in doubt, parentheses make the intended order explicit.

x = 2 + 3 * 4 ** 2
# Step 1: 4 ** 2 = 16
# Step 2: 3 * 16 = 48
# Step 3: 2 + 48 = 50
print(x)  # 50