Python Essentials on fffelipe's world wide web

Interpreter

Mon, 01 Jan 0001 00:00:00 +0000

The interpreter is the python or python3 program installed on your machine.

Real-world example: when you run python app.py, Python reads app.py, executes statements from top to bottom, and reports errors if it finds invalid syntax or runtime problems.

Variables & Types

Mon, 01 Jan 0001 00:00:00 +0000

name = "Felipe" # str
age = 30 # int
ratio = 0.5 # float
active = True # bool
items = None # NoneType

type(age) # <class 'int'>

Type hints (age: int = 30) are optional but increasingly standard; they help with editor autocomplete and tools like mypy.

f-strings

Mon, 01 Jan 0001 00:00:00 +0000

name = "Felipe"
count = 42

print(f"Hello, {name}!")
print(f"Found {count} items")
print(f"Ratio: {count / 100:.2f}") # formatting
print(f"{name=}") # → name='Felipe'

Always prefer f-strings over .format() or % formatting. The = debug syntax is great for quick logging.

REPL

Mon, 01 Jan 0001 00:00:00 +0000

REPL means read, evaluate, print, loop.

Example:

>>> 2 + 2
4

Real-world example: use the REPL to quickly test string methods, math, imports, or small expressions before putting them in a script.

Control Flow

Mon, 01 Jan 0001 00:00:00 +0000

status = response.status_code

if status == 200:
 print("OK")
elif status < 500:
 print("Client error")
else:
 print("Server error")

# ternary
msg = "OK" if status == 200 else "Error"

Standard indent is 4 spaces, never tabs. Most editors (and tools like ruff/black) enforce this automatically.

Loops

Mon, 01 Jan 0001 00:00:00 +0000

for item in items:
 print(item)

for i, item in enumerate(items):
 print(f"{i}: {item}")

for key, value in config.items():
 print(f"{key} = {value}")

while queue:
 process(queue.pop())

enumerate for index+value, .items() for dict pairs, zip for parallel iteration. Avoid for i in range(len(items)); it’s a code smell.

Functions

Mon, 01 Jan 0001 00:00:00 +0000

def greet(name: str, greeting: str = "Hello") -> str:
 return f"{greeting}, {name}!"

greet("Felipe") # uses default
greet("Felipe", greeting="Hey") # keyword arg

# *args and **kwargs
def log(*args, **kwargs):
 print(args, kwargs)

Use type hints in any code others will read. Default arguments must be immutable: never def f(x=[]) (it’s shared across calls).

Types

Mon, 01 Jan 0001 00:00:00 +0000

Common built-in types include:

int for whole numbers
float for decimals
str for text
bool for true/false
list, tuple, dict, and set for collections

Real-world example: "3" + "4" gives text concatenation, while 3 + 4 gives arithmetic.

None & Truthiness

Mon, 01 Jan 0001 00:00:00 +0000

items = []
if not items:
 print("empty")

value = config.get("key") # returns None if missing
if value is None:
 value = "default"

# short version
value = config.get("key") or "default"

Always use is None / is not None to compare with None; == works but is non-idiomatic.

Strings

Mon, 01 Jan 0001 00:00:00 +0000

Examples:

message = "hello"
message.upper()
len(message)

Strings are immutable, meaning operations create new strings rather than changing the original one.

Lists

Mon, 01 Jan 0001 00:00:00 +0000

items = [1, 2, 3]
items.append(4) # [1, 2, 3, 4]
items[0] # 1
items[-1] # 4 (last)
items[1:3] # [2, 3] (slice)
len(items) # 4
[x * 2 for x in items] # comprehension

Slicing is one of Python’s superpowers: [start:end:step]. Negative indices count from the end.

Dictionaries

Mon, 01 Jan 0001 00:00:00 +0000

user = {"name": "Felipe", "role": "admin"}
user["name"] # "Felipe"
user.get("email", "N/A") # safe lookup with default
user["email"] = "f@x.com" # add/update

for key, value in user.items():
 print(key, value)

Use .get() to avoid KeyError when a key might be missing. Dicts preserve insertion order since 3.7.

Tuples & Sets

Mon, 01 Jan 0001 00:00:00 +0000

# tuples: fixed structure
point = (10, 20)
x, y = point # unpacking

# sets: uniqueness, fast membership tests
seen = {1, 2, 3}
seen.add(4)
2 in seen # True (O(1))
list(set(items)) # dedupe a list

Tuples for fixed records (coordinates, multiple return values). Sets when you need uniqueness or fast in checks.

Comprehensions

Mon, 01 Jan 0001 00:00:00 +0000

# list comprehension
evens = [x for x in range(10) if x % 2 == 0]

# dict comprehension
squares = {x: x**2 for x in range(5)}

# filter + transform
names = [u["name"].upper() for u in users if u["active"]]

Readable for simple cases. If a comprehension grows past one line or has nested loops, use a regular for-loop instead.

Iterating Patterns

Mon, 01 Jan 0001 00:00:00 +0000

names = ["Ana", "Bob", "Cy"]
ages = [30, 25, 28]

for i, name in enumerate(names):
 print(i, name)

for name, age in zip(names, ages):
 print(name, age)

for k, v in config.items():
 print(k, v)

These three handle 90% of iteration patterns. zip stops at the shortest iterable.

Sets

Mon, 01 Jan 0001 00:00:00 +0000

Example:

tags = {"python", "git", "python"}
print(tags) # {'python', 'git'}

Real-world example: use a set to remove duplicates or quickly test whether an item has already been seen.

Imports

Mon, 01 Jan 0001 00:00:00 +0000

import os # whole module
from pathlib import Path # specific name
from datetime import datetime as dt # alias

# your own modules
from utils.auth import validate

Group imports: stdlib first, then third-party, then your own, separated by blank lines. Tools like ruff enforce this automatically.

uv Project Setup

Mon, 01 Jan 0001 00:00:00 +0000

uv init my-project # new project scaffold
cd my-project

uv add requests # adds to pyproject.toml + installs
uv add --dev pytest ruff # dev-only deps
uv remove requests
uv sync # install everything from pyproject.toml

uv init creates .venv/ (auto-gitignored), pyproject.toml, and uv.lock. No need to activate the venv manually; uv run handles it.

uv run

Mon, 01 Jan 0001 00:00:00 +0000

uv run python script.py
uv run pytest
uv run python -m mypackage.cli

# one-off scripts with inline deps
uv run --with requests script.py

Replaces the old source .venv/bin/activate && python ... ritual. uv run auto-syncs deps if pyproject.toml has changed since the last run.

Python Versions

Mon, 01 Jan 0001 00:00:00 +0000

uv python install 3.12
uv python install 3.11
uv python list # available + installed

# pin the project to a version
uv python pin 3.12 # writes .python-version

# one-off run with a different version
uv run --python 3.11 script.py

No more pyenv, brew install python@3.x, or fighting system Python. uv installs versions side-by-side and picks the right one based on .python-version.

return vs print

Mon, 01 Jan 0001 00:00:00 +0000

Example:

def add(a, b):
 return a + b

result = add(2, 3)
print(result)

Real-world example: use return when other code needs the result. Use print for humans reading terminal output.

pyproject.toml

Mon, 01 Jan 0001 00:00:00 +0000

[project]
name = "my-tool"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
 "requests>=2.31",
 "pydantic>=2.0",
]

[tool.uv]
dev-dependencies = [
 "pytest>=8.0",
 "ruff>=0.1",
]

One file replaces requirements.txt, setup.py, and various tool configs. Tools like ruff and pytest can also be configured here under [tool.*] sections.

Scope

Mon, 01 Jan 0001 00:00:00 +0000

Variables created inside a function are local to that function.

Example:

def greet():
 message = "hello"
 return message

Real-world example: local scope helps functions avoid accidentally changing unrelated parts of a program.

uv tool (uvx)

Mon, 01 Jan 0001 00:00:00 +0000

uv tool install ruff
uv tool install httpie
uv tool list

# run without installing
uv tool run black file.py
uvx black file.py # short form

For tools you want available everywhere (linters, formatters, CLIs). Each gets its own isolated env. uvx is shorthand for uv tool run, handy for one-offs.

name guard

Mon, 01 Jan 0001 00:00:00 +0000

Example:

def main():
 print("running")

if __name__ == "__main__":
 main()

Real-world example: this lets a file be both importable as a module and runnable as a script without accidentally executing script behavior during import.

Standard Library

Mon, 01 Jan 0001 00:00:00 +0000

from pathlib import Path
import json, os, re
from datetime import datetime, timedelta

Path("config.json").read_text()
json.loads(raw)
os.environ.get("API_KEY")
datetime.now() - timedelta(days=7)
re.match(r"^\d+$", "123")

Prefer pathlib over the older os.path. os.environ for env vars. json for parsing API responses and config files.

File I/O

Mon, 01 Jan 0001 00:00:00 +0000

# read
with open("data.txt") as f:
 content = f.read()

# read line by line
with open("log.txt") as f:
 for line in f:
 process(line.strip())

# write
with open("out.txt", "w") as f:
 f.write("hello\n")

Always use with; it closes the file even on errors. For JSON, use json.load(f) / json.dump(data, f).

Virtual environments

Mon, 01 Jan 0001 00:00:00 +0000

Example:

python -m venv .venv
source .venv/bin/activate

Real-world example: one project can use Django 5 while another older project still uses Django 3, without package conflicts.

Error Handling

Mon, 01 Jan 0001 00:00:00 +0000

try:
 data = json.loads(raw)
except json.JSONDecodeError as e:
 print(f"Bad JSON: {e}")
 data = {}
except Exception as e:
 logger.exception("Unexpected error")
 raise
finally:
 cleanup()

Catch specific exceptions when you can recover. Bare except: hides bugs. Use logger.exception to capture the full traceback.

pip

Mon, 01 Jan 0001 00:00:00 +0000

Examples:

pip install requests
pip freeze > requirements.txt

Real-world example: use requirements.txt or another dependency file so another developer can install the same packages your project needs.

pathlib

Mon, 01 Jan 0001 00:00:00 +0000

from pathlib import Path

p = Path("data") / "users.json" # joining
p.exists()
p.parent # Path("data")
p.suffix # ".json"
p.read_text()
p.write_text("hello")

for f in Path(".").glob("*.py"):
 print(f)

The / operator for joining paths is way cleaner than os.path.join. Works on all platforms and handles Windows backslashes for you.

subprocess

Mon, 01 Jan 0001 00:00:00 +0000

import subprocess

result = subprocess.run(
 ["git", "status", "--short"],
 capture_output=True,
 text=True,
 check=True,
)
print(result.stdout)

Always pass arguments as a list (not a string) to avoid shell injection. check=True raises on non-zero exit codes, saving you from silent failures.

argparse

Mon, 01 Jan 0001 00:00:00 +0000

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("filename")
parser.add_argument("--verbose", "-v", action="store_true")
parser.add_argument("--limit", type=int, default=10)

args = parser.parse_args()
print(args.filename, args.verbose, args.limit)

Auto-generates --help text. For richer CLIs (subcommands, colored output), libraries like click or typer are popular alternatives.

Context managers

Mon, 01 Jan 0001 00:00:00 +0000

The with statement uses context managers.

Example:

with open("notes.txt") as file:
 text = file.read()

Real-world example: files opened with with are closed automatically, even if an error happens while reading.

Set Up a New Project

Mon, 01 Jan 0001 00:00:00 +0000

# 1. Create the project scaffold
uv init my-tool
cd my-tool

# 2. Pin a Python version
uv python pin 3.12

# 3. Add runtime + dev deps
uv add requests pydantic
uv add --dev pytest ruff

# 4. Initialize git
git init
# uv has already created a .gitignore covering .venv/ etc.
git add . && git commit -m "Initial commit"

uv init scaffolds a working project in seconds: pyproject.toml, .gitignore, .python-version, README. uv add updates pyproject.toml and the lockfile in one step. The lockfile (uv.lock) should be committed.

Run Scripts & Modules

Mon, 01 Jan 0001 00:00:00 +0000

# 1. Run a script or module
uv run python script.py
uv run python -m mypackage.cli # for packages

# 2. Run an entry point defined in pyproject.toml
uv run mytool # if [project.scripts] defines it

# 3. The "main" guard (only runs when executed directly)
def main():
 ...

if __name__ == "__main__":
 main()

Use python -m form when running anything inside a package; direct execution breaks relative imports. The __main__ guard prevents code from running when the file is imported elsewhere.

None

Mon, 01 Jan 0001 00:00:00 +0000

Use is None instead of == None. None is a singleton (only one None object exists in a Python program), so identity (is) is the canonical and override-proof check.

Example:

if result is None:
 print("nothing found")

Real-world example: a lookup function might return None when it cannot find a matching user.

Read JSON Config

Mon, 01 Jan 0001 00:00:00 +0000

import json
from pathlib import Path

CONFIG_PATH = Path.home() / ".myapp" / "config.json"
DEFAULTS = {"theme": "dark", "port": 8080}

def load_config() -> dict:
 if not CONFIG_PATH.exists():
 return DEFAULTS
 try:
 user = json.loads(CONFIG_PATH.read_text())
 return {**DEFAULTS, **user}
 except json.JSONDecodeError as e:
 print(f"Invalid config: {e}")
 return DEFAULTS

Merge defaults with user config so missing keys fall back gracefully. For richer validation (types, required fields), reach for pydantic.

Classes and objects

Mon, 01 Jan 0001 00:00:00 +0000

Example:

class User:
 def __init__(self, name):
 self.name = name

user = User("Felipe")

Real-world example: use classes to model concepts like users, posts, invoices, or game characters.

Debug

Mon, 01 Jan 0001 00:00:00 +0000

# 1. print debugging (quick and dirty)
print(f"{user=} {response.status=}")

# 2. drop into pdb at any line
breakpoint() # then: n, s, c, p var, q

# 3. logging (for real apps)
import logging
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
log.debug("payload: %s", payload)

breakpoint() is built into Python 3.7+; it pauses execution so you can inspect state interactively. For production code use logging, never print, so output can be configured per environment.

self

Mon, 01 Jan 0001 00:00:00 +0000

Example:

class Counter:
 def __init__(self):
 self.count = 0

 def increment(self):
 self.count += 1

Real-world example: self.count belongs to one specific counter object, not every counter at once.

Test with pytest

Mon, 01 Jan 0001 00:00:00 +0000

# test_auth.py
from auth import validate_email

def test_valid_email():
 assert validate_email("a@b.com")

def test_rejects_missing_at():
 assert not validate_email("invalid")

# parametrize for many cases
import pytest

@pytest.mark.parametrize("email", ["a@b.com", "x@y.io"])
def test_various_valid(email):
 assert validate_email(email)

# run
uv run pytest -v
uv run pytest tests/test_auth.py::test_valid_email

Test what’s likely to break, not implementation details. Run with -v for verbose output, -k name to filter by test name, -x to stop at first failure.

Generators

Mon, 01 Jan 0001 00:00:00 +0000

Example:

def countdown(n):
 while n > 0:
 yield n
 n -= 1

Real-world example: generators are useful for processing large files or streams because they do not need to keep every value in memory.

Type hints

Mon, 01 Jan 0001 00:00:00 +0000

Example:

def greet(name: str) -> str:
 return f"hello, {name}"

Python usually does not enforce type hints at runtime, but editors and checkers can use them to find bugs earlier.

Python Essentials on fffelipe's world wide web

Interpreter

Variables & Types

f-strings

REPL

Control Flow

Loops

Functions

Types

None & Truthiness

Strings

Lists

Dictionaries

Tuples & Sets

Comprehensions

Iterating Patterns

Sets

Imports

uv Project Setup

uv run

Python Versions

return vs print

pyproject.toml

Scope

uv tool (uvx)

__name__ guard

Standard Library

File I/O

Virtual environments

Error Handling

pip

pathlib

subprocess

argparse

Context managers

Set Up a New Project

Run Scripts & Modules

None

Read JSON Config

Classes and objects

Debug

self

Test with pytest

Generators

Type hints

name guard