Python interview questions and answers

Question 1

What is Python, and what are its strengths and limitations?

Accepted Answer

Answer: Python is a high-level, interpreted, general-purpose language known for readable syntax that reads close to English. Strengths: easy to read and write, a huge standard library ('batteries included'), dynamically typed so no type declarations, portable across Windows, Mac, and Linux, and a massive ecosystem for web (Django, Flask, FastAPI), data science (NumPy, Pandas), and AI/ML (TensorFlow, PyTorch, scikit-learn). Limitations: slower than compiled languages like C++ or Java because it is interpreted; the Global Interpreter Lock limits CPU-bound multithreading; higher memory use; and it is not a natural fit for mobile apps. Analogy: Python is the friendly all-rounder: quick to pick up, fits almost any job, but not the one you reach for when raw speed is everything. In an interview: Python is a readable, interpreted, dynamically typed general-purpose language with a large standard library and ecosystem, strong in web, data science, and AI. Its weak points are execution speed, CPU-bound threading due to the GIL, and mobile.

Question 2

What is PEP, and what is PEP 8?

Accepted Answer

Answer: PEP stands for Python Enhancement Proposal. It is a numbered design document that either proposes a new language feature or gives information to the Python community. Big language decisions go through the PEP process. PEP 8 is the style guide for Python code. It sets conventions for formatting: 4-space indentation, snake_case for functions and variables, CapWords for classes, UPPER_CASE for constants, a line-length limit (around 79 to 88 characters), and spacing rules. Following it keeps code consistent and readable across a team. Tools like black (formatter) and flake8 / ruff (linters) enforce it. Analogy: PEPs are the rulebook amendments for the language. PEP 8 is the one about how to lay out your writing so everyone's code looks the same. In an interview: A PEP is a Python Enhancement Proposal, the document format for proposing features or sharing guidance. PEP 8 is the code style guide: indentation, naming conventions, line length, and spacing, enforced by formatters and linters.

Question 3

Is Python compiled or interpreted, and is it statically or dynamically typed?

Accepted Answer

Answer: Both questions have a slightly nuanced answer. Compiled vs interpreted: Python first compiles your source to bytecode (the .pyc files you see), then an interpreter (the Python Virtual Machine) runs that bytecode. So there is a compile step, but it targets a virtual machine, not the CPU, and it happens automatically each run. People call it 'interpreted' because you do not run a separate build command. Static vs dynamic typing: Python is dynamically typed. A variable has no fixed type, and types are checked at run time, when an operation actually happens. You can do x = 5 then x = "hi". (Type hints like def f(x: int) are optional annotations that tools like mypy check; the interpreter ignores them.) Analogy: Python quietly translates your code into a middle language and runs that, and it never asks you to promise what type a box will hold, it just checks when you try to use what is inside. In an interview: Python compiles source to bytecode and an interpreter runs that bytecode, with no separate build step, so it is usually called interpreted. It is dynamically typed: variables have no fixed type and types are checked at run time. Type hints are optional and only checked by external tools.

Question 4

What are Python's built-in data types?

Accepted Answer

Answer, grouped by category: Numeric: int, float, complex. Sequence: str (text), list (ordered, changeable), tuple (ordered, fixed), range. Mapping: dict (key-value pairs). Set: set (unordered, unique items), frozenset (a set that cannot change). Boolean: bool (True / False). Binary: bytes, bytearray. And NoneType, whose only value is None. Check a value's type with type(x), or test membership with isinstance(x, int). Analogy: a toolbox with labelled compartments: numbers, ordered lists, labelled lookups, bags of unique things, yes/no flags, and raw bytes. In an interview: Numeric: int, float, complex. Sequences: str, list, tuple, range. Mapping: dict. Sets: set and frozenset. Plus bool, bytes and bytearray, and NoneType. You check with type() or isinstance().

Question 5

What is None in Python, and what is it used for?

Accepted Answer

Answer: None is a special constant that represents 'no value' or 'nothing here'. It is the only value of its own type, NoneType. Common uses: - The default return value of a function that has no return statement. - A default for an optional function argument (def f(items=None)), because a mutable default like [] is a well-known trap. - Initialising a variable that will get a real value later. Always test for it with is: if x is None, not x == None, because is checks identity and None is a singleton. Analogy: None is a filled-in 'not applicable' on a form. It is an actual answer meaning 'there is nothing', not an empty blank. In an interview: None is the single value of NoneType meaning 'no value'. It is what a function returns with no return statement, a safe default for optional arguments, and a placeholder for a not-yet-assigned variable. Check it with 'is None'.

Question 6

What is the difference between mutable and immutable, and which built-in types are which?

Accepted Answer

Answer: A mutable object can be changed in place after it is created. An immutable object cannot; any 'change' actually creates a new object. Immutable: int, float, bool, complex, str, tuple, frozenset, bytes. Mutable: list, dict, set, bytearray, and most custom class instances. Why it matters: 1. Two variables pointing at the same mutable object see each other's changes. With immutables that cannot happen. 2. Only immutable (hashable) objects can be dict keys or set members, which is why you can key by a tuple but not by a list. 3. A mutable default argument (def f(x=[])) is created once and shared across all calls, a classic bug. Analogy: immutable is a printed photo: to change it you take a new one. Mutable is a whiteboard: anyone holding a marker can edit the same board. In an interview: Mutable objects change in place, immutable ones do not. int, float, bool, str, tuple, frozenset, and bytes are immutable; list, dict, set, and bytearray are mutable. It matters for shared references, for what can be a dict key, and for the mutable-default-argument trap.

Question 7

What is type conversion in Python, and how does it happen?

Accepted Answer

Answer: Type conversion is changing a value from one type to another. Implicit (Python does it automatically): when you mix compatible numeric types, Python promotes to the wider one. 2 + 3.0 gives 5.0, because the int is converted to a float. Python never implicitly converts between, say, string and number. Explicit (you do it, also called casting): call the type as a function. int("10") gives 10, str(42) gives "42", float(5) gives 5.0, list("abc") gives ['a','b','c']. int() on a float truncates toward zero: int(3.8) is 3. int() on a non-numeric string raises ValueError. Analogy: implicit conversion is the shop automatically giving you change in the local currency. Explicit conversion is you handing over a note and asking for coins. In an interview: Implicit conversion happens automatically for mixed numeric types, promoting to the wider one. Explicit conversion is calling int(), str(), float(), list() and so on. int() truncates a float and raises ValueError on a non-numeric string.

Question 8

What values are treated as False in Python?

Accepted Answer

Answer: In a boolean context (an if, a while, bool(x)), these are falsy: - False itself - None - Zero of any numeric type: 0, 0.0, 0j - Empty sequences and collections: "", (), [], {}, set(), range(0) Everything else is truthy, including "0", "False", [0], and {}'s non-empty cousins. A custom object is truthy unless it defines __bool__ returning False or __len__ returning 0. This is why if my_list: reads as 'if the list is not empty', and if name: as 'if name is a non-empty string'. Analogy: 'nothing' is falsy: no value (None), zero, or an empty container. Anything with something in it is truthy. In an interview: Falsy values are False, None, numeric zero (0, 0.0, 0j), and empty containers ('', (), [], {}, set()). Everything else is truthy, including the string '0' and the list [0]. Custom objects can control this with __bool__ or __len__.

Question 9

What are Python's numeric types, and how do you write binary, octal, and hex literals?

Accepted Answer

Answer: Three numeric types: int (whole numbers, unlimited size), float (decimals, 64-bit), and complex (a + bj). Integer literals in other bases use a prefix: - Binary: 0b or 0B, e.g. 0b101 is 5 - Octal: 0o or 0O, e.g. 0o10 is 8 - Hexadecimal: 0x or 0X, e.g. 0xFF is 255 Float literals can use scientific notation: 3.14e-10. The underscore is a numeric separator for readability: 1_000_000 is the same as 1000000. Analogy: the prefix tells Python which counting system the digits are in: 0b for base 2, 0o for base 8, 0x for base 16. In an interview: int is unbounded whole numbers, float is 64-bit decimals, complex is a + bj. Base prefixes are 0b for binary, 0o for octal, 0x for hex. Floats support e notation, and underscores are a readability separator in any numeric literal.

Question 10

How do you convert between number bases in Python?

Accepted Answer

Answer: Decimal to another base: bin(x), oct(x), hex(x). These return STRINGS with the prefix: bin(10) is '0b1010', hex(255) is '0xff'. Another base to decimal: int(string, base). int('1010', 2) is 10, int('FF', 16) is 255, int('0x1A', 16) is 26 (the 0x prefix is allowed). int('777', 8) is 511. So the round trip is int(bin(10), 2) == 10. Analogy: bin, oct, hex are 'translate this number into that language, as text'. int(text, base) is 'read this text as a number written in that language'. In an interview: bin(), oct(), and hex() convert a decimal int to a prefixed string in that base. int(string, base) parses a string in a given base back to a decimal int, and it accepts the 0b/0o/0x prefix.

Question 11

What are nan and inf in Python, how do you check for nan, and what does dividing by zero do?

Accepted Answer

Answer: inf and -inf are positive and negative infinity, both of type float. You make them with float('inf') or math.inf. A very large exponent can overflow to inf. nan means 'not a number', also a float. You make it with float('nan') or math.nan. It comes from undefined float operations like math.inf - math.inf. Checking for nan: use math.isnan(x). You cannot use x == math.nan, because nan is not equal to anything, including itself (nan == nan is False). That self-inequality is actually one way to detect it. Dividing by zero: plain Python raises ZeroDivisionError, it does not return inf or nan. (NumPy is different: it warns and returns inf or nan.) Analogy: inf is 'bigger than any number'. nan is 'the answer is meaningless'. And nan is so meaningless it does not even equal itself. In an interview: inf and nan are both floats. inf is infinity, nan is an undefined result like inf minus inf. Check nan with math.isnan, never == , because nan does not equal itself. Plain Python raises ZeroDivisionError on divide by zero rather than returning inf or nan.

Question 12

How does variable assignment work in Python? Do you have to declare variables?

Accepted Answer

Answer: No declaration. A variable comes into existence the moment you assign to it: x = 10. There is no int x; step like in C or Java. A Python variable is a name bound to an object, more like a label on a box than the box itself. y = x makes y point at the same object as x. For an immutable object that is harmless. For a mutable one, changing it through either name is visible through both. Rebinding (x = something_else) just moves the label; it does not touch the old object, which is garbage-collected when no labels point at it. Analogy: variables are sticky notes you put on objects. Assigning is sticking a note on. y = x sticks a second note on the same object. In an interview: Python has no variable declaration; a name exists once you assign to it. A variable is a reference to an object, not the object, so two names can label the same object and, for mutable objects, see each other's changes. Reassigning moves the label only.

Question 13

What are the rules for naming a variable in Python?

Accepted Answer

Answer: A variable name must: - Start with a letter (a-z, A-Z) or an underscore. - Contain only letters, digits, and underscores after that. - Not start with a digit. - Not be a Python keyword (if, while, class, def, return, and so on). Names are case-sensitive: age, Age, and AGE are three different variables. By convention (PEP 8): snake_case for variables and functions, CapWords for classes, UPPER_CASE for constants, a leading underscore for 'internal' names. Analogy: same as usernames on a site: start with a letter or underscore, letters/numbers/underscores only, and some words are reserved. In an interview: Start with a letter or underscore, then letters, digits, or underscores only, never a digit first, and not a keyword. Names are case-sensitive. Convention is snake_case for variables, CapWords for classes, UPPER_CASE for constants.

Question 14

What is variable scope in Python, and what does the global keyword do?

Accepted Answer

Answer: Scope is where a name is visible. Python resolves a name using the LEGB rule, checking in this order: - Local: inside the current function. - Enclosing: an outer function that wraps this one. - Global: the top level of the module. - Built-in: names like len, print, range. Inside a function you can READ a global variable freely. But if you ASSIGN to a name in a function, Python treats it as a new local, unless you declare global name first, which says 'assignments to this name affect the module-level variable'. nonlocal does the same for an enclosing function's variable. Analogy: when you use a name, Python searches outward in rings: your desk, your manager's desk, the company noticeboard, then the dictionary. Writing to the noticeboard from your desk needs a permission slip (global). In an interview: Scope is where a name is visible, resolved by the LEGB order: local, enclosing, global, built-in. You can read a global inside a function, but assigning creates a local unless you declare global (for module level) or nonlocal (for an enclosing function).

Python interview preparation

Python basics

Data types

Numbers

Variables and scope