Technologies Coding Problems Bookmarks Learning Paths

Technologies Coding Problems Bookmarks Learning Paths

AI-powered interview preparation platform. Practice with curated questions, mock interviews, and personalized learning paths to crack your dream tech interview.

Quick Links

Technologies
Saved Questions
Pricing

Company

About Us
Contact Us

Legal

Privacy Policy
Terms of Use

© 2026 nextRound. All rights reserved.

What is an Interpreted language? | Basics | Python Interview Questions | NextRound.in

Questions

2 of 12

1Is Python a compiled language or an interpreted language?

2What is an Interpreted language?

3What causes a reference cycle, and how does Python's garbage collector handle it?

4Why can floating-point arithmetic in Python produce results like `0.1 + 0.2 != 0.3`? How would you correctly compare floats?

5Why does Python not require explicit variable declarations, and how does dynamic typing affect variable assignment internally?

6How does Python manage memory for objects internally (reference counting and the object model)?

7What are Python's built-in data types, and how are they categorized (mutable vs. immutable)?

8How does Python evaluate chained comparisons like `1 < x < 10`?

9What is the difference between `is` and `==`?

10What is the difference between a shallow copy and a deep copy? When would each cause bugs?

11Why can `a = 256; b = 256; a is b` return `True`, but `a = 257; b = 257; a is b` return `False` in some Python implementations?

12What is the difference between `/` and `//` in Python?

Python

Control Flow and Functions

Data Structures

Comprehensions & Functional Programming

Iterators, Generators & Decorators

Object-Oriented Programming

Exception Handling & Debugging

Concurrency & Parallelism

Performance & Optimization

Modules, Packaging & Environment

Type Hinting & Modern Python

System Design & Architecture with Python

Best Practices & Design Patterns

Edge Cases & Tricky Interview Questions

02 / 12

What is an Interpreted language?

Difficulty: 3/10

execution model, bytecode, runtime behavior

An Interpreted language executes its statements line by line. Languages such as Python, Javascript, R, PHP, and Ruby are prime examples of Interpreted languages. Programs written in an interpreted language runs directly from the source code, with no intermediary compilation step.

Scenario Questions

0-2 years experience

1You're writing a script that processes CSV files. Walk me through what happens from the moment you run `python process.py` to when your first line of code executes.
2A teammate says 'Python is slow because it's interpreted.' How would you respond, and what simple experiment could you run to test that claim?
3You're debugging a `NameError` that only happens in production. What tools does the interpreter give you to inspect state at the point of failure?

2-5 years experience

1Your team is containerizing a Python API. The Docker image is huge and startup latency matters. What interpreter-level knobs would you tune, and what tradeoffs come with each?
2A background job using `multiprocessing` runs fine locally but deadlocks in staging. How does the interpreter's GIL and fork behavior contribute, and what would you change?
3You're adding a C extension for a hot path. What happens at the interpreter boundary when Python calls into C and back, and how do you ensure reference counting doesn't leak?

5-8 years experience

1You're evaluating PyPy vs CPython for a high-throughput ingestion pipeline. Beyond 'PyPy is faster,' what runtime behaviors (JIT warmup, memory profile, C extension compatibility) would you stress-test before migrating?
2A legacy monolith uses `exec()` on user-supplied config strings. How does the interpreter's dynamic execution model create security and observability risks, and how would you sandbox or replace it?
3Your team wants to embed Python as a scripting layer in a Go service. What interpreter initialization, thread state, and memory management challenges arise when the host isn't the main process?

8+ years experience

1The org is standardizing on a single Python runtime across ML, web, and CLI teams. How do you design a runtime governance model that balances version upgrades, C extension ABI stability, and team autonomy?
2A critical service hits interpreter startup latency limits at scale (thousands of short-lived invocations). You're considering ahead-of-time compilation (e.g., Nuitka, GraalPy) or a persistent worker pool. What architectural tradeoffs do you present to leadership?
3You're leading a migration from Python 3.8 to 3.12 across 200+ services. Beyond syntax changes, what interpreter-level changes (specializing adaptive interpreter, subinterpreters, error messages) require coordinated rollout and testing strategies?

Follow-up Questions

How does the bytecode cache (.pyc files) affect startup time and deployment?
What changes if you switch from CPython to PyPy for a CPU-bound service?
How would you debug a production issue that only appears under the interpreter but not in your local REPL?

Sharethis question

Share via WhatsApp, X, Facebook, LinkedIn or copy link. Open Graph preview enabled.