What Are the Key Features of Python?

Dynamic typing means that a name is attached to an object while the program is running. The interpreter learns the type from the object itself, and nobody has to write a type declaration first.

The script below never declares a type, and yet every operation works. You can also ask the running program what type each value has.

# There are no type declarations anywhere in this file.
value = 42
value = 'forty-two'   # giving the name a different type is allowed

print(type(value).__name__)    # str
print(isinstance(value, str))  # True

# The standard library comes with Python, so there is nothing to install.
import csv
import io

text = 'name,score\nAda,99\n'
rows = list(csv.DictReader(io.StringIO(text)))
print(rows[0]['name'], int(rows[0]['score']))

The output is str, then True, and then Ada 99.

The second feature on show here is the standard library. Modules such as csv, json, datetime, pathlib, statistics, itertools, collections, and unittest all ship with CPython, and they are installed by default. Nothing in that script needed pip. This matters in an interview because it changes the question. The real question is not whether Python is powerful. The real question is how much of the everyday work needs no extra package at all.

The practical result of dynamic typing is that type mistakes appear while the program is running, and not while it is being compiled. That is exactly why type hints, which are covered separately, have become normal practice in larger Python projects.

It means that the language arrives with everything you need for a large share of ordinary programming tasks. You do not have to look for a third-party package to do normal work.

The phrase comes from the batteries picture, and the Python Software Foundation made it popular to describe the difference between Python and languages whose standard library is only a very thin core.

More concretely, the standard library includes modules for reading and writing CSV and JSON, for date and time arithmetic with datetime, for working with paths through pathlib and os, for regular expressions with re, for random numbers, for exact arithmetic with decimal and fractions, for descriptive maths with statistics, for data structures with collections and itertools, for concurrency with asyncio, for testing with unittest, and for diagnostics with logging. There is also sqlite3 in the standard library, and that module gives you a full relational database with no server and no installation.

import sqlite3

# A real relational database, with no server and nothing to install.
conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE people (name TEXT, score INTEGER)')
conn.execute('INSERT INTO people VALUES (?, ?)', ('Ada', 99))

row = conn.execute('SELECT name, score FROM people').fetchone()
print(row)
print(type(row).__name__)

That snippet makes the point in a practical way. sqlite3 creates a table, inserts a row, and reads it back. It prints the tuple ('Ada', 99) and the type name tuple, and none of it needed a database server. That is what the phrase means in practice.

The advantage is good dependency hygiene. A script that only uses the standard library runs on any machine with the same Python version. It needs no virtual environment, and it cannot break because a package released a version with different behaviour. For scripts, for glue code, and for small services, that is often the difference between a project that still works in three years and one that does not.

The honest counterweight is that the standard library is not always the best choice. For numerical work, pandas and NumPy are far better than anything in the standard library. For HTTP clients, requests is much easier to use than urllib. The phrase describes a strong starting point, and it is not a reason to refuse third-party packages.

Java gives you one class hierarchy and any number of interfaces, and the language never has to solve a diamond problem. Python lets a class inherit from several parent classes at once, and each of those parents may have parents of its own. When the same method can be reached in more than one way, Python has to decide which one runs. That decision is called the method resolution order.

The order is worked out by the C3 linearisation algorithm. It produces a single chain of classes that runs from left to right and stays consistent with the order in which you listed the parents. You can look at it directly through the __mro__ attribute on any class.

The other structural difference is that Python has no special idea of an interface. A class with no state, whose methods raise NotImplementedError, is just an ordinary base class, and you inherit from it exactly as you inherit from anything else. Python 3.12 added a formal @typing.Protocol class, so that structural interfaces can be written and type checked, but the model at runtime did not change.

The practical advice that interviewers want to hear is this. Multiple inheritance in Python is genuinely useful, and it is also easy to misuse. A mix-in class that adds one narrow piece of behaviour, combined with super() calls, is a well-established pattern. A deep hierarchy that inherits from several concrete classes is usually a sign that the design would be clearer as composition.

In Java, when two interfaces define the same method, the class has to say clearly which one it means. Python settles that for you, but it also gives you the cooperative super() mechanism, so that you can chain the calls instead of quietly replacing them.