Python Roadmap for Beginners: From First Line of Code to Job-Ready

Python is the most popular programming language in the world in 2026, and for good reason. Its syntax reads like English, its ecosystem covers everything from web apps to machine learning, and the job market is enormous. If you're picking your first language, Python is a safe bet.

But "learn Python" is vague advice. Learn it for what? Web development? Data science? AI? Automation? The fundamentals are the same, but the career paths diverge significantly after month two. This roadmap covers the common foundation and then branches into the tracks that actually lead to jobs.

Stage 1: Python Fundamentals (Month 1)

This is the same regardless of which track you pick later. Every Python developer needs these.

Week 1-2: The Absolute Basics

# Variables and data types
name = "Alex"
age = 28
is_developer = True
hourly_rate = 75.50

# Lists (ordered, mutable)
languages = ["Python", "JavaScript", "Go"]
languages.append("Rust")

# Dictionaries (key-value pairs)
developer = {
    "name": "Alex",
    "languages": languages,
    "years_experience": 3,
}

# f-strings (the only string formatting you need)
print(f"{name} knows {len(languages)} languages")

What to focus on:

• Variables: strings, integers, floats, booleans
• Collections: lists, dictionaries, tuples, sets
• Operators: arithmetic, comparison, logical
• Input/output: print(), input(), f-strings
• Type conversion: int(), str(), float()

Week 2-3: Control Flow and Functions

# Functions with type hints (get used to these early)
def calculate_grade(scores: list[float]) -> str:
    average = sum(scores) / len(scores)
    if average >= 90:
        return "A"
    elif average >= 80:
        return "B"
    elif average >= 70:
        return "C"
    elif average >= 60:
        return "D"
    return "F"

# List comprehensions -- Python's secret weapon
scores = [85, 92, 78, 95, 88]
passing_scores = [s for s in scores if s >= 80]

# Loops
for i, score in enumerate(scores):
    print(f"Test {i + 1}: {score}")

• If/elif/else
• For loops and while loops
• Functions (parameters, return values, default arguments)
• List comprehensions (learn these early -- they're everywhere in Python)
• enumerate(), zip(), range()

Week 3-4: Data Structures in Practice

# Working with nested data -- this comes up constantly
users = [
    {"name": "Alice", "age": 30, "active": True},
    {"name": "Bob", "age": 25, "active": False},
    {"name": "Charlie", "age": 35, "active": True},
]

# Filter and transform
active_names = [user["name"] for user in users if user["active"]]

# Dictionary comprehension
name_to_age = {user["name"]: user["age"] for user in users}

# Sorting
sorted_users = sorted(users, key=lambda u: u["age"], reverse=True)

Build something by end of month 1. A command-line contact book, a quiz game, a budget tracker -- anything that uses variables, functions, loops, and dictionaries together.

Stage 2: Intermediate Python (Month 2)

Object-Oriented Programming

Here's the thing about OOP -- beginners either skip it entirely or spend way too long on abstract theory. You need the practical parts:

class BankAccount:
    def __init__(self, owner: str, balance: float = 0):
        self.owner = owner
        self._balance = balance  # convention: underscore = "private"
        self._transactions: list[dict] = []

@property
    def balance(self) -> float:
        return self._balance

def deposit(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self._balance += amount
        self._transactions.append({"type": "deposit", "amount": amount})

def withdraw(self, amount: float) -> None:
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        self._balance -= amount
        self._transactions.append({"type": "withdrawal", "amount": amount})

def __repr__(self) -> str:
        return f"BankAccount(owner='{self.owner}', balance={self._balance:.2f})"

Learn: classes, __init__, instance methods, properties, inheritance (basic), dunder methods (__repr__, __str__, __len__).

Don't learn yet: metaclasses, abstract base classes, multiple inheritance. You'll probably never need metaclasses.

File Handling and Error Handling

import json
from pathlib import Path

def load_config(filepath: str) -> dict:
    path = Path(filepath)
    if not path.exists():
        raise FileNotFoundError(f"Config not found: {filepath}")

try:
        with open(path) as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in {filepath}: {e}")

Modules, Packages, and pip

• Importing standard library modules (os, json, datetime, pathlib, collections)
• Installing third-party packages with pip
• Virtual environments -- this is non-negotiable. Use python -m venv or uv (faster alternative)
• Writing your own modules and packages

# Virtual environment basics -- do this for every project
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# .venv\Scripts\activate   # Windows
pip install requests flask
pip freeze > requirements.txt

Stage 3: Pick Your Track (Month 3+)

This is where paths diverge. Here's an honest comparison:

Track	Technologies	Job Market (2026)	Typical Entry Salary	Difficulty
Web (Backend)	Django, FastAPI, PostgreSQL	Strong	$70K-$100K	Moderate
Data Science	pandas, numpy, matplotlib, SQL	Very strong	$75K-$110K	Moderate-High
AI/ML	scikit-learn, PyTorch, transformers	Hot but competitive	$85K-$130K	High
Automation/Scripting	requests, selenium, beautifulsoup	Moderate	$55K-$85K	Low-Moderate

Track A: Web Development (Backend)

Build APIs and web applications. The most straightforward path to employment.

# FastAPI example -- modern, fast, great developer experience
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class Task(BaseModel):
    title: str
    description: str = ""
    completed: bool = False

tasks: dict[int, Task] = {}
next_id = 1

@app.post("/tasks", status_code=201)
def create_task(task: Task):
    global next_id
    tasks[next_id] = task
    task_id = next_id
    next_id += 1
    return {"id": task_id, **task.model_dump()}

@app.get("/tasks/{task_id}")
def get_task(task_id: int):
    if task_id not in tasks:
        raise HTTPException(status_code=404, detail="Task not found")
    return {"id": task_id, **tasks[task_id].model_dump()}

Learn: FastAPI or Django, SQL + PostgreSQL, REST API design, authentication, deployment (Docker, Railway/Fly.io).

Track B: Data Science

The hottest Python track. Strong math background helps but isn't strictly required.

import pandas as pd

# Real-world data analysis pattern
df = pd.read_csv("sales_data.csv")

# Clean and transform
df["date"] = pd.to_datetime(df["date"])
df["revenue"] = df["quantity"] * df["price"]

# Analyze
monthly_revenue = (
    df.groupby(df["date"].dt.to_period("M"))["revenue"]
    .sum()
    .reset_index()
)

# Find top products
top_products = (
    df.groupby("product_name")["revenue"]
    .sum()
    .sort_values(ascending=False)
    .head(10)
)

Learn: pandas, numpy, matplotlib/seaborn, SQL, Jupyter notebooks, basic statistics.

Track C: AI/ML

The most hyped track. Let's be honest: most entry-level "AI Engineer" roles actually require strong data science fundamentals plus some ML knowledge on top.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Basic ML workflow
X_train, X_test, y_train, y_test = train_test_split(
    features, labels, test_size=0.2, random_state=42
)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
print(classification_report(y_test, predictions))

Learn: scikit-learn (start here, not PyTorch), feature engineering, model evaluation, then PyTorch/transformers for deep learning.

Track D: Automation and Scripting

The easiest track to start earning money with. Freelancing opportunities are real.

import requests
from bs4 import BeautifulSoup

def scrape_job_listings(url: str) -> list[dict]:
    response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
    response.raise_for_status()

soup = BeautifulSoup(response.text, "html.parser")
    jobs = []

for card in soup.select(".job-card"):
        jobs.append({
            "title": card.select_one(".title").text.strip(),
            "company": card.select_one(".company").text.strip(),
            "location": card.select_one(".location").text.strip(),
        })

return jobs

Learn: requests, BeautifulSoup, selenium, file manipulation (CSV, JSON, Excel with openpyxl), scheduling (cron, APScheduler).

What Makes a Python Developer Employable

Let's be honest about what separates someone who "knows Python" from someone who gets hired:

1. Virtual environments and dependency management -- If you install everything globally, you're not ready for a team.
2. Git proficiency -- Every Python team uses git. No exceptions.
3. Testing with pytest -- Even basic tests show professionalism.
4. Code structure -- Proper modules, not everything in one 500-line file.
5. Reading documentation -- The ability to pick up a new library by reading its docs, not watching a tutorial.

# A pytest test -- learn to write these
def test_calculate_grade_returns_a_for_high_scores():
    assert calculate_grade([95, 92, 98]) == "A"

def test_calculate_grade_returns_f_for_low_scores():
    assert calculate_grade([40, 35, 50]) == "F"

def test_calculate_grade_handles_boundary():
    assert calculate_grade([90, 90, 90]) == "A"
    assert calculate_grade([89, 89, 89]) == "B"

The Learning Timeline

Month	Focus	Milestone
1	Python fundamentals	CLI project on GitHub
2	OOP, file handling, modules, pip	2nd project, using virtual envs
3-4	Track-specific learning	Track project (API, data analysis, etc.)
5-6	Deeper track skills + testing	Portfolio-worthy project
7+	Job search, interview prep	Contributing to open source

Start Coding Now

Python has the lowest barrier to entry of any major language. You can open a terminal, type python3, and start writing code in seconds. There's no excuse to wait.

For structured Python practice problems -- from beginner fundamentals through interview-level challenges -- check out CodeUp.dev. It's hands-on practice, not passive learning, and that's what actually makes the difference.

Write your first function today. Not tomorrow. Today.