Python Programming Glossary 50 Terms You Must Know in 2026

5.  Data type   Kind of value: int, float, str, bool, list...
6.  String      Text in quotes: "hello"
7.  List        Ordered, changeable collection: [1, 2, 3]
8.  Tuple       Ordered, unchangeable collection: (1, 2)
9.  Dictionary  Key-value pairs: {"name": "Asha"}
10. Set         Unordered unique items: {1, 2, 3}
11. Iterable    Anything you can loop over (list, str, dict)
12. Indentation Spaces that define code blocks in Python
13. None        Python's "no value" object
14. f-string    Formatted string: f"Total: {price}"

scores = [70, 85, 90]          # list (mutable)
scores.append(60)              # changed in place

point = (3, 4)                 # tuple (immutable)
student = {"name": "Asha", "city": "Noida"}   # dictionary

for s in scores:               # a list is iterable
    if s >= 80:
        print(f"{s} is a distinction")

try:
    int("abc")
except ValueError as e:        # exception handling
    print("Not a number:", e)

19. Parameter    Name in the def line that receives a value
20. Return value Result a function sends back with return
21. *args        Collects extra positional arguments as a tuple
22. **kwargs     Collects extra keyword arguments as a dict
23. Lambda       Small anonymous function: lambda x: x * 2
24. Scope        Where a name can be used (local, global)
25. Object       An instance created from a class
26. Method       A function defined inside a class
27. self         Refers to the current object inside methods
28. Inheritance  A class reusing and extending another class

import time

def timer(func):                       # a decorator
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

class Student:                         # a class
    def __init__(self, name):          # self = this object
        self.name = name

    @timer
    def greet(self, greeting="Hello"):  # a method
        return f"{greeting}, {self.name}"

print(Student("Rahul").greet())

33. requirements.txt  File listing a project's packages
34. PyPI              Python Package Index, where pip finds packages
35. Interpreter       The program that runs Python code
36. REPL              Interactive prompt: type code, see result
37. Script            A .py file you run directly
38. __name__          "__main__" when a file is run directly
39. Linter            Tool that flags style and simple errors
40. Formatter         Tool that rewrites code style (e.g. black)
41. Unit test         Small test for one function
42. Debugger          Tool to pause code and inspect values (pdb)

python -m venv .venv                 # create virtual environment
source .venv/bin/activate            # activate (Windows: .venv\Scripts\activate)
pip install requests pytest          # install packages
pip freeze > requirements.txt        # record versions
pip install -r requirements.txt      # recreate elsewhere
python -m pytest -q                  # run unit tests
python -m pdb app.py                 # start the debugger

43. List comprehension
    Build a list in one line:
    squares = [n * n for n in range(10) if n % 2 == 0]

44. Generator
    A function that yields values one at a time,
    saving memory:
    def count_up(n):
        for i in range(n):
            yield i

45. Context manager
    Sets up and cleans up automatically with "with":
    with open("data.txt") as f:
        text = f.read()

46. Type hint
    Optional annotation of expected types:
    def total(prices: list[float]) -> float:
        return sum(prices)

47. Dataclass
    Class that auto-creates __init__ and more:
    from dataclasses import dataclass
    @dataclass
    class Item:
        name: str
        price: float

48. Iterator
    Object returning items one by one with next()

49. async / await
    Lets code wait for slow I/O (like network calls)
    without blocking other tasks:
    import asyncio
    async def main():
        await asyncio.sleep(1)
        print("done")
    asyncio.run(main())

50. GIL (Global Interpreter Lock)
    In standard CPython, a lock that lets only one
    thread run Python bytecode at a time; matters
    for CPU-heavy multithreaded code.