Dynamic Typing, Stubs, and Namespaces in Python

Here's a breakdown of these three concepts in Python:

1. Dynamic Typing:

  • Python is a dynamically typed language. This means that the type of a variable is not declared when it's created but determined at runtime based on the value assigned to it.
  • For example:

Python
x = 5  # x is an integer (int)
x = "Hello"  # x is now a string (str)

  • This flexibility can be convenient for rapid development but might lead to errors if you accidentally assign incompatible types later in your code.

2. Stubs:

  • Stubs are special files (usually with the .pyi extension) that provide type information for existing Python modules or libraries.
  • They are not actual code but act as a blueprint for static type checkers like mypy.
  • Stubs help static type checkers understand the expected types of functions, variables, and arguments in a module. This allows for early detection of potential type errors.
  • You don't typically need to create stubs for standard library modules as they come with pre-defined stubs.
  • However, if you're working with a third-party library that lacks stubs or has incomplete ones, you might need to create your own stubs.

3. Namespaces:

  • Namespaces are a way of organizing code and preventing naming conflicts.
  • In Python, modules create namespaces. When you import a module, its functions, variables, and classes are placed in its namespace.
  • This helps avoid conflicts if you have functions or variables with the same name in different modules.

Here's how these concepts interact:

  • Dynamic typing and namespaces work together naturally. Namespaces prevent variables and functions with the same name from clashing, even if their types are different.
  • Stubs can be used to provide type information for modules regardless of their dynamic typing nature. This allows static type checkers to understand the expected behavior of functions and variables within those modules.

Example:

Python
# my_math.py (without stubs)
def add(x, y):
  return x + y

# my_calculations.py (using my_math)
from my_math import add

result = add(5, "hello")  # This will cause a TypeError at runtime

With Stubs:

Python
# my_math.pyi (stub file)
from typing import Union

def add(x: int, y: int) -> int:
  ...

# my_calculations.py (using my_math)
from my_math import add

result = add(5, 3)  # This works fine
# result = add(5, "hello")  # mypy will raise an error during type check
Suche
Kategorien
Mehr lesen
Computer Programming
Range and Nested Loops
Range Function (range()) The range() function is a built-in function in Python used to generate...
Computer Programming
Functions, Parameters, and Return Values in python
Python uses functions extensively! Here's how functions, parameters, and return values work in...
Computer Programming
HTML forms
Here's a simple HTML form structure that includes a text input field, a submit button, and a...
Von HTML PROGRAMMING LANGUAGE 2024-10-01 09:29:09 0 10KB
Computer Programming
HTML Table Padding & Spacing
HTML Table Padding and Spacing Padding and spacing in HTML tables control the amount of space...
Von HTML PROGRAMMING LANGUAGE 2024-09-06 01:33:49 0 11KB
Technology
History of Python and Computer Hardware
As computer programming started to get popular and evolve in the 1960’s and 70’s,...
Tebtalks https://tebtalks.com