Python for Absolute Beginners: Your First 7 Days of Code

I've taught Python to over 500 absolute beginners—people who'd never written a line of code in their lives. Some were accountants, some were designers, one was a retired chef who wanted to build a recipe database. Every single one of them was capable of writing meaningful Python programs within one week. Not "hello world." Real programs that did useful things.

The secret is structure. Most coding courses throw too much at you too fast. This guide is different. Each day has exactly one new concept, one exercise, and one mini-project. Do the work. Skip nothing. At the end of day 7, you'll have built something you can actually use.

>>> print("Hello, I'm learning Python!")
>>> 42 * 3
>>> "Python" + " " + "is" + " " + "fun"
>>> len("supercalifragilisticexpialidocious")

name = "Alice"
age = 28
height = 1.68
is_student = True

print(f"{name} is {age} years old and {height}m tall.")
# Output: Alice is 28 years old and 1.68m tall.

# Lists
hobbies = ["reading", "coding", "hiking"]
hobbies.append("cooking")
print(hobbies[0])  # reading
print(len(hobbies))  # 4

# Dictionaries
person = {
    "name": "Bob",
    "skills": ["Python", "Excel", "SQL"],
    "years_experience": 3
}
print(person["name"])  # Bob

# For loop
for hobby in hobbies:
    print(f"I enjoy {hobby}")

def calculate_bmi(weight_kg, height_m):
    bmi = weight_kg / (height_m ** 2)
    if bmi < 18.5:
        category = "underweight"
    elif bmi < 25:
        category = "healthy"
    elif bmi < 30:
        category = "overweight"
    else:
        category = "obese"
    return round(bmi, 1), category

result, category = calculate_bmi(70, 1.75)
print(f"BMI: {result} — {category}")

# Writing to a file
with open("notes.txt", "w") as file:
    file.write("Day 1: Learned variables\n")
    file.write("Day 2: Learned lists\n")

# Reading from a file
with open("notes.txt", "r") as file:
    content = file.read()
    print(content)

# Reading line by line
with open("notes.txt", "r") as file:
    for line in file:
        print(f"Read: {line.strip()}")

# 1. Random — generate random data
import random
dice = random.randint(1, 6)
print(f"You rolled a {dice}")

# 2. Datetime — work with dates
from datetime import datetime
today = datetime.now()
print(f"Today is {today.strftime('%A, %B %d, %Y')}")

# 3. CSV — handle spreadsheets
import csv
with open("data.csv", "r") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["Name"], row["Score"])

import json
import os
from datetime import datetime

EXPENSE_FILE = "expenses.json"

def load_expenses():
    if os.path.exists(EXPENSE_FILE):
        with open(EXPENSE_FILE, "r") as f:
            return json.load(f)
    return []

def add_expense(amount, category, description):
    expenses = load_expenses()
    expense = {
        "amount": amount,
        "category": category,
        "description": description,
        "date": datetime.now().strftime("%Y-%m-%d")
    }
    expenses.append(expense)
    with open(EXPENSE_FILE, "w") as f:
        json.dump(expenses, f, indent=2)
    print(f"✅ Added: ${amount} for {description}")

def show_summary():
    expenses = load_expenses()
    total = sum(e["amount"] for e in expenses)
    by_category = {}
    for e in expenses:
        by_category[e["category"]] = by_category.get(e["category"], 0) + e["amount"]

    print(f"\n💰 Total Spent: ${total:.2f}")
    print("📊 By Category:")
    for cat, amt in sorted(by_category.items(), key=lambda x: x[1], reverse=True):
        print(f"   {cat}: ${amt:.2f}")
    print(f"📝 Total Entries: {len(expenses)}")

# Main program loop
print("=== Expense Tracker ===")
while True:
    print("\n1. Add expense")
    print("2. View summary")
    print("3. Quit")
    choice = input("Choose: ")

    if choice == "1":
        amount = float(input("Amount: $"))
        category = input("Category (Food/Transport/Entertainment/etc): ")
        desc = input("Description: ")
        add_expense(amount, category, desc)
    elif choice == "2":
        show_summary()
    elif choice == "3":
        print("Goodbye!")
        break

Every year, thousands of people open a Python tutorial on Saturday morning, type print("Hello World"), feel a rush of progress, and then stall by Wednesday. The reason is rarely intelligence. It’s almost always a lack of structure. You don’t need three months of abstract theory. You need seven focused days where each session builds on the last, so that by the end you can actually write a small program that solves a real problem instead of another toy exercise.

This plan is built around a single assumption: you want to see results quickly. If that sounds like you, this week is the fastest honest path from zero to a working script. We skip the trivia, we use the tools professionals actually use, and we keep every exercise tied to something you could show to a friend or use at work.

Every year, thousands of people open a Python tutorial on Saturday morning, type print("Hello World"), feel a rush of progress, and then stall by Wednesday. The reason is rarely intelligence. It’s almost always a lack of structure. You don’t need three months of abstract theory. You need seven focused days where each session builds on the last, so that by the end you can actually write a small program that solves a real problem instead of another toy exercise.

This plan is built around a single assumption: you want to see results quickly. If that sounds like you, this week is the fastest honest path from zero to a working script. We skip the trivia, we use the tools professionals actually use, and we keep every exercise tied to something you could show to a friend or use at work.

Day 1: Install the right Python and stop using the wrong editor

The biggest beginner trap is avoiding the terminal. Trust me, the terminal is your friend. Start by installing Python from the official site (python.org) or through your package manager, and verify the version with python --version. If it prints 3.10 or newer, you are ready. Many laptops still ship with Python 2 lurking around, and running old tutorials can cause confusing errors, so type that command and check.

Next, install VS Code or use any editor you like, but enable the Python extension. The simple things that save beginners hours are autocomplete, inline error highlighting, and a proper debugger. You do not need a fancy IDE for week one. You need an editor that highlights mistakes before you run the code. That alone will remove half your frustration.

Finally, set up a virtual environment right away. Run python -m venv venv in your project folder. It sounds technical, but it basically gives your project its own private toolbox so packages you install later won’t clash with other projects. Get used to activating it source venv/bin/activate on macOS/Linux or venv\Scripts\activate on Windows. This habit will save you from dependency hell later.

If you want a guided tour of syntax fundamentals before you start, the references over on SkillGoHub can reinforce Day 1. But the core message stands: environment first, then code.

Day 2: Variables, types, and the first program that matters

Spend today on the four data types you will use constantly: integers, floats, strings, and booleans. Write small scripts that mix them. Convert strings to integers with int(), concatenate strings, and check whether a comparison returns True or False. Do not memorize every built-in. Learn the ones that appear in every real script.

Then make something useful. Build a tip calculator that takes a bill amount, adds a tip percentage, and splits it across people. It is small, but it exercises variables, input, type conversion, and output. That combination is the entire literacy of Python scripting. When you finish, save it as tips.py and run it from the terminal. Running code from the command line, not just clicking run in an editor, is a skill worth building early because it transfers to servers and automation.

For anyone learning Python alongside a broader purpose, combining it with related skills speeds up retention. A can mount on top of this week, and if you plan to use Python for numbers, a look at the Python for finance section shows how the same basics scale to real datasets.

Day 3: Lists and loops, with a real difference

Lists are the workhorse of Python. Today, learn to create lists, access items by index, slice them, append, and remove items. Then learn for and while loops. The classic mistake beginners make is assuming loops are for “advanced” people. In reality, a week-one programmer who understands loops can already automate tedious tasks.

Your exercise today: take a list of prices, apply a 10 percent discount to each, and print the new total. Use a loop, not copy-paste. Then rewrite the same logic with a list comprehension, which is Python’s more concise way of building lists. Being able to read both styles matters, because most real code you find online will use comprehensions.

Write a short helper that tells you if a number is even. Then use it inside a loop over the numbers 1 to 20. Play with range() and understand the difference between a zero-based index and a one-based counting loop. If you nail this, you have already cleared the biggest conceptual hurdle that stops most self-taught learners.

Day 4: Functions are the difference between scripts and software

Day one through three made you a scripter. Day four is when you start thinking like a programmer. Functions let you package a block of logic, give it a name, and reuse it. The rule for week one is simple: any block of code you write twice becomes a function.

Take your discount logic from yesterday and turn it into a function that accepts a price and a discount rate, then returns the discounted price. Then build a second function that applies that to a whole list. Now write a third function that validates the input, refusing negative prices. You have just experienced refactoring, and it feels good.

Understand return vs print. A function that print()s is only useful for humans. A function that returns ships its result to other code, which is what enables automation and bigger programs. Test each function by calling it with sample data and checking the result. This is your first taste of debugging by deliberately looking for edge cases, like an empty list or a zero discount.

Day 5: Dictionaries and files, the gateway to automation

Dictionaries let you store key-value pairs, like a mini address book. Today you will learn to create one, look up values, update them, and loop through keys and values. This is the data structure behind JSON, configuration files, and most APIs, so it is not optional.

Then add file I/O. Open a text file, read its lines, and write a new file. Combine it with a dictionary: read a simple CSV-like file of names and scores, store them in a dictionary keyed by name, and print the highest scorer. This is the exact pattern used in countless real scripts that parse logs or generate reports.

If you are enjoying the structured approach, the broader continues after this week, and a general track can fill in gaps around debugging and project organization that pure Python tutorials often skip. Learning the surrounding habits is what turns syntax into shipped programs.

Day 6: Build one real project from start to finish

Today you combine everything. Pick a small real project, something with a wireframe output, not a guessing game. A good choice: a to-do list manager that stores tasks in a file, lets you add or mark items complete, and prints the list. It uses variables, strings, lists, loops, functions, dictionaries, and file I/O. That is an entire week of skills in one program.

Resist the urge to add features. Scope it tight: add, list, complete, save, load. Write it top to bottom, test each function as you go, and keep a running comment at the top explaining what the script does. By the end of today you should have a working file that you genuinely built, and you should be able to run it fresh and see your saved tasks come back from disk.

Every programmer learns that a small working program outperforms a half-finished ambitious one. Ship the to-do app. If it saves and reloads correctly, you have internalized the core skill: turning requirements into working code. That is what employers test, not vocabulary.

Day 7: Refactor, share, and zoom out

Day seven is about polishing and perspective. Open your to-do program and look for duplication. Refactor repeated blocks into functions. Add a missing error check, like what happens when the file is empty. This cleanup instinct is what separates programmers who maintain code from those who just write it and walk away.

Then share it. Put it on GitHub or simply send it to a friend. The act of explaining your code to someone else surfaces gaps in your own understanding, and it builds the communication skill that interviews actually reward. If you are ready to containerize and deploy that project, a Docker beginners guide is the natural continuation, because every real world project eventually runs in a container, because every real project lives in a repository.

Finally, zoom out and see where Python fits. Later you can branch into web development, where a JavaScript for beginners path complements your backend skills, or into data work building on the finance examples. The point is that your first week already gives you a transferable foundation, and the fastest growth after day seven comes from building something real every single day, not from reading more tutorials.

A reality check on common week-one pitfalls

None of these tools make you a better programmer by themselves. Pick one, master it, and move on. The pitfall is switching editors every two days, which is the fastest way to burn your momentum.

For more, check out: and python programming.

FAQ

Do I really need a virtual environment on day one?

Yes, and here is why. If you install packages globally, you will eventually install two versions of the same library and break another project. A virtual environment keeps each project isolated. The two commands you need are python -m venv venv and activating it, and you will never fight messy dependency conflicts if you start this habit on day one.

Is VS Code too heavy for a beginner, or should I use a simpler editor?

VS Code is a good default because it is free, popular, and has the Python extension that catches syntax errors as you type. If the interface feels overwhelming, Thonny or Mu are gentler introductions. You can always move to VS Code after a week. The important thing is consistency, not which editor wins an argument.

I keep getting a “pyth not defined” error. What is wrong with my code?

That error usually means you misspelled a variable name or a keyword. Python is case-sensitive, so Print and print are different. The most common cause in week one is using pyth or pritn instead of print. Read the exact error message, because Python tells you the line number and the name it could not find.

Should I focus on Python 2 or Python 3 before starting?

Only Python 3. Python 2 reached end of life years ago and receives no security updates. Almost every modern library and tutorial assumes Python 3, and features like f-strings and modern type hints do not exist in Python 2. If your computer still defaults to an old version, install 3 separately and make sure python --version shows 3.x.

How do I know when I am “done” with week one?

You are done when you can open a terminal, create a new script, and write a small program that reads input and produces output without looking up examples for every line. If your to-do app from day six saves and reloads correctly, you have hit that bar. From there, the next best step is one real project per week, not one more tutorial.