
Python has six built-in scalar types: `int`, `float`, `str`, `bool`, `None`, and `bytes`. Everything in Python is an object, so every value carries its type with it. `type(x)` returns the object's class; `isinstance(x, SomeType)` tests membership, including subclasses.

<ExamplePair>
<ExampleProse>

Each scalar type has a literal form. `type()` returns the class of any value.

</ExampleProse>
<ExampleCode>

```python
type(42)        # <class 'int'>
type(3.14)      # <class 'float'>
type("hi")      # <class 'str'>
type(True)      # <class 'bool'>
type(None)      # <class 'NoneType'>
type(b"bytes")  # <class 'bytes'>
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`isinstance(x, T)` is the idiomatic way to check a value's type at runtime because it respects inheritance. `bool` is a subclass of `int`, so `isinstance(True, int)` is `True`. This can produce surprises if you expect the check to be strict.

</ExampleProse>
<ExampleCode>

```python
isinstance(42, int)      # True
isinstance(3.14, float)  # True
isinstance("hi", str)    # True

# bool is a subclass of int
isinstance(True, int)    # True  <- not False
isinstance(True, bool)   # True
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`==` compares values; `is` compares identity (whether two names point to the exact same object in memory). Use `==` for value comparison and `is` only for `None`, `True`, `False`, and sentinel singletons.

</ExampleProse>
<ExampleCode>

```python
1 == 1.0    # True  - same value, different types
1 is 1.0    # False - different objects

x = None
x is None   # True  - canonical None check
x == None   # True  - works, but non-idiomatic
```

</ExampleCode>
</ExamplePair>

<InProduction>
`bool` is a subclass of `int` (`True == 1`, `isinstance(True, int)` is `True`) and this leaks into JSON serialisation, `sum()`, and dict keys - a function expecting an integer silently accepts `True`. Use `is` only for `None`, `True`, `False`, and sentinel singletons; use `==` for value comparison everywhere else.
</InProduction>


Python's built-in scalar types: int, float, str, bool, None, and bytes - with identity versus equality.

Values


Variables in Python are name bindings, not declarations. An assignment `x = 1` creates a name `x` that points to the integer `1`; re-assigning `x = 2` rebinds the name to a different object. The original object is unchanged, and Python's garbage collector reclaims it if no other names point to it.

<ExamplePair>
<ExampleProse>

Simple assignment, multiple assignment on one line, and in-place swap all work without a temporary variable.

</ExampleProse>
<ExampleCode>

```python
x = 10
a, b = 1, 2        # multiple assignment
a, b = b, a        # swap without a temp variable

print(a, b)        # 2 1
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

When a function reads a variable, Python searches scopes in LEGB order: Local, Enclosing, Global, Built-in. A function can read an outer variable without any extra keyword.

</ExampleProse>
<ExampleCode>

```python
x = "global"

def show():
    print(x)   # reads the global x - no keyword needed

show()         # global
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The `UnboundLocalError` trap: if a function assigns to a name anywhere in its body, Python treats that name as local for the *entire* function, even before the assignment line. Reading it before the assignment raises `UnboundLocalError`. Use `nonlocal` (for a name in an enclosing function) or `global` (for a module-level name) when a rebinding is intentional.

</ExampleProse>
<ExampleCode>

```python
count = 0

def broken():
    print(count)  # UnboundLocalError! assignment below makes count local
    count = count + 1

def fixed():
    global count
    print(count)  # 0 - now unambiguously the global
    count = count + 1
```

</ExampleCode>
</ExamplePair>

<InProduction>
Python rebinds names; it does not declare them. A function that assigns to `x` shadows any outer `x` for the entire function body, even before the assignment line - reading it earlier raises `UnboundLocalError`. Reach for `nonlocal` only when closure state genuinely belongs to the enclosing function; class state belongs on `self`.
</InProduction>


Variables in Python are name bindings. Understand multiple assignment, LEGB scope, and the UnboundLocalError trap.

Variables


The smallest runnable Python program prints a message to the console. Run it with `python file.py`, or add a shebang line (`#!/usr/bin/env python3`) to make the file executable directly. The `if __name__ == "__main__":` guard lets the same file act as both a runnable script and an importable module.

<ExamplePair>
<ExampleProse>

`print()` writes its argument to stdout, followed by a newline. This is how Python says hello to the world.

</ExampleProse>
<ExampleCode>

```python
print("Hello, World!")
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Running the script produces:

</ExampleProse>
<ExampleCode>

```shell
Hello, World!
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Wrapping your script logic inside `if __name__ == "__main__":` lets the file be imported by another module without running the script body. `__name__` is the module's name when imported, or `"__main__"` when run directly.

</ExampleProse>
<ExampleCode>

```python
def greet(name):
    print(f"Hello, {name}!")

if __name__ == "__main__":
    greet("World")
```

</ExampleCode>
</ExamplePair>

<InProduction>
`print()` is fine for scripts and CLIs. Production services need the stdlib `logging` module (or structlog) so log levels, structured fields, and request-correlation IDs survive into Datadog or Loki. Plain `print()` writes to stdout with no level metadata and cannot be silenced without code changes.
</InProduction>


The smallest runnable Python program - printing a message and understanding the script guard pattern.