From Python Beginner to Job-Ready: A 6-Month Plan

Going from Python beginner to job-ready in six months is realistic for many people studying part time, but only with a plan that tells you, each month, whether you are on track. Most plans list topics. This one adds a checkpoint: a small exercise you should be able to write from scratch, without looking anything up, by the end of each month. If you can, move on. If you cannot, spend another week before moving on; the checkpoint is a test of what you can produce, not of what you have read.

All six checkpoints are solved below so you can see the expected level. Try each yourself first.

import codecs
import csv
import json
import unittest
from collections import Counter, defaultdict
from datetime import datetime

import io
from contextlib import redirect_stdout

import pandas as pd

with redirect_stdout(io.StringIO()):     # importing "this" prints the Zen of Python; keep only its text
    import this                         # the text lives in this.s, ROT13-encoded

# Month 1 checkpoint: strings, loops and a dictionary
zen = codecs.decode(this.s, "rot13")
words = Counter(w.strip(".,!*-").lower() for w in zen.split() if w.strip(".,!*-"))
print("M1 most common words in the Zen of Python:", ", ".join(f"{w} {n}" for w, n in words.most_common(5)))

# Month 2 checkpoint: reading a CSV with the standard library and grouping
by_weekday = defaultdict(int)
with open("day.csv", newline="") as f:
    for row in csv.DictReader(f):
        by_weekday[datetime.strptime(row["dteday"], "%Y-%m-%d").strftime("%a")] += int(row["cnt"])
print("M2 total bike rentals by weekday:", ", ".join(f"{d} {n:,}" for d, n in sorted(by_weekday.items(), key=lambda x: -x[1])[:3]), "...")


# Month 3 checkpoint: functions and error handling on messy input
def parse_amount(text):
    try:
        return float(text.replace(",", "").replace("Rs", "").strip())
    except ValueError:
        return None


raw = ["1,250", "Rs 300", "", "12.5", "n/a", "4,000.75"]
parsed = [parse_amount(x) for x in raw]
print(f"M3 parsed {sum(p is not None for p in parsed)} of {len(raw)} values, total {sum(p for p in parsed if p is not None):,.2f}; bad: {[r for r, p in zip(raw, parsed) if p is None]}")

# Month 4 checkpoint: write JSON, read it back, compare
summary = {"days": sum(1 for _ in open("day.csv")) - 1, "top_weekday": max(by_weekday, key=by_weekday.get)}
with open("summary.json", "w") as f:
    json.dump(summary, f)
print("M4 JSON round trip equal:", json.load(open("summary.json")) == summary, summary)


# Month 5 checkpoint: a small class with unit tests
class Wallet:
    def __init__(self):
        self.balance = 0.0

    def add(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount


class WalletTest(unittest.TestCase):
    def test_add(self):
        w = Wallet(); w.add(10); w.add(5.5)
        self.assertEqual(w.balance, 15.5)

    def test_rejects_negative(self):
        with self.assertRaises(ValueError):
            Wallet().add(-1)


result = unittest.TextTestRunner(stream=open("tests.log", "w"), verbosity=0).run(unittest.defaultTestLoader.loadTestsFromTestCase(WalletTest))
print(f"M5 unit tests run {result.testsRun}, failures {len(result.failures)}, errors {len(result.errors)}")

# Month 6 checkpoint: a pandas analysis that answers a question
day = pd.read_csv("day.csv", parse_dates=["dteday"])
growth = day.groupby(day.dteday.dt.year).cnt.sum()
print(f"M6 rentals 2011 {growth[2011]:,} -> 2012 {growth[2012]:,} ({growth[2012] / growth[2011] - 1:+.0%})")

M1 most common words in the Zen of Python: is 10, better 8, than 8, the 6, to 5
M2 total bike rentals by weekday: Fri 487,790, Thu 485,395, Sat 477,807 ...
M3 parsed 4 of 6 values, total 5,563.25; bad: ['', 'n/a']
M4 JSON round trip equal: True {'days': 731, 'top_weekday': 'Fri'}
M5 unit tests run 2, failures 0, errors 0
M6 rentals 2011 1,243,103 -> 2012 2,049,576 (+65%)

What "job-ready" means here

By the end, you should be able to take a small, loosely defined data task, such as "summarise last year's sales by month and flag anything unusual", and turn it into tested, readable Python that someone else can run. That is the bar for junior data and Python roles. It does not mean knowing everything; it means being able to get unstuck on your own.

Month 1: the language basics

Weekly focus: values and types, strings, conditions, loops, lists and dictionaries. The official Python tutorial is enough for this month; work through its early chapters with the interpreter open (Python tutorial).

Checkpoint: count the most common words in a piece of text. The solution decodes the Zen of Python, which ships with Python itself, and finds "is" (10 times), "better" and "than" (8 each).

Month 2: working with files and collections

Weekly focus: reading and writing files, the csv module, dates, grouping with dictionaries, sorting with keys.

Checkpoint: total a column by category from a CSV using only the standard library. Applied to two years of daily bike rentals from the UCI repository (UCI: Bike Sharing), Friday came out on top with 487,790 rentals, just ahead of Thursday.

Month 3: functions and errors

Weekly focus: writing functions with clear inputs and outputs, exceptions, and handling messy input without crashing.

Checkpoint: parse a list of messy text values into numbers, keeping track of what failed. Four of six sample values parsed; the empty string and "n/a" were reported as bad rather than silently dropped.

Month 4: data formats and packages

Weekly focus: JSON, virtual environments, installing packages with pip, reading documentation, organising code into modules.

Checkpoint: write a summary to a JSON file, read it back and confirm it matches. Small, but it exercises files, data structures and the habit of checking your own output.

Month 5: classes and tests

Weekly focus: classes where they help, unit tests, reading tracebacks, and using a debugger. Python's built-in unittest framework is enough to start (Python docs: unittest).

Checkpoint: a small class with tests, including a test that bad input raises an error. Both tests ran without failures.

Month 6: pandas and a portfolio project

Weekly focus: pandas for loading, cleaning, grouping and joining data; one complete project written up with a README.

Checkpoint: answer a real question with pandas. Rentals grew from 1,243,103 in 2011 to 2,049,576 in 2012, a 65% increase, three lines of code once the basics are solid.

Choose a direction by month four

Python is used for very different jobs, and the last two months go further if you aim them. If you are heading for data analysis, spend month six on pandas, SQL and a little plotting, and make your project an analysis that ends in a recommendation. For data engineering, add working with APIs, scheduling a script and loading data into a database. For automation and scripting roles, focus on files, the operating system and reliable scripts that run unattended. For web development, a small framework such as Flask or FastAPI replaces pandas in the final month. The checkpoints for months one to five stay the same whichever path you choose, because every direction depends on them.

A typical week

• Three study sessions of about an hour on new material, typing every example.
• One session reproducing earlier code from memory, which is where most retention comes from; see how to learn Python faster.
• One small exercise that mixes this month's topic with earlier ones.

About five to six hours a week is a realistic load alongside a job.

If you fall behind

Falling behind is normal. Do not skip a checkpoint; extend the month instead. A plan that takes eight months but leaves you able to write the checkpoints from memory is worth more than six months of rushing. If one area keeps blocking you, often functions or pandas grouping, spend a week only on small exercises in that area.

After six months

Build two more projects in the area you want to work in, prepare to explain your code line by line, and start applying. For the topics in more depth and in order, see learn Python from scratch; for project ideas, Python projects for beginners.

A guided version of this path, with exercises and projects, is the Python Programming course.

Sources

• The Python Tutorial (Python documentation) — Python Software Foundation
• unittest: Unit testing framework (Python documentation) — Python Software Foundation
• Bike Sharing Dataset (UCI Machine Learning Repository) — UCI Machine Learning Repository