Learn Python in 30 Days: Free Day-by-Day Plan With Lessons

Quick answer

Thirty days is enough to learn Python fundamentals and write small useful programs if you follow a plan:

• Daily time budget: 60–90 minutes on weekdays, 2–3 hours on one weekend day. About 40 hours total.
• Material: weeks 1–2 use the free, in-browser Python Foundations course, with each day linked to a lesson below. Weeks 3–4 cover files, packages, HTTP requests and testing, which our courses do not teach, using free outside resources (the official Python tutorial, the free online chapters of Automate the Boring Stuff, the pytest docs); classes link to Python Intermediate.
• Week 1: variables, f-strings, conditionals, loops. Project: a number-guessing game.
• Week 2: lists, functions, dictionaries, tuples, sets, comprehensions, errors. Project: a command-line to-do list.
• Week 3: files, CSV/JSON, modules, pip and virtual environments. Project: a file organiser or expense tracker.
• Week 4: classes, working with a real dataset, a small API call, tests, and a capstone project you choose.

What "learning Python in 30 days" realistically means: at the end you can read most beginner-level Python, write programs of 100–200 lines that solve a real problem, debug your own mistakes and know what to learn next. It does not mean job-ready. That takes months more, and this plan tells you what comes after.

What matters before you start

Pick a time and protect it

Consistency beats intensity. Forty-five focused minutes every day beats a five-hour Sunday binge followed by a week off, because each day's material builds on the previous day's. Put it in your calendar.

Type, do not watch

Every lesson in this plan involves writing code. Reading or watching without typing gives the feeling of progress without the substance. Retype every example, then change something and predict the result.

Set up once, then stop fiddling

Python Foundations runs in the browser, so you can begin immediately. By the end of week 1 install Python and an editor locally for the projects and for the week 3–4 material, which is not in our courses; our guide to the best Python IDE for beginners takes fifteen minutes to follow. After that, resist the urge to rearrange your tools.

Keep a log

One Markdown file or notebook: date, what you covered, one thing that confused you, one thing that clicked. On day 30 it will be the most motivating document you own.

Know your "done" criteria

Each week below ends with a checklist. If you cannot tick it, repeat a day rather than moving on. Slipping to 35 or 40 days is fine; skipping fundamentals is not.

The 30-day Python plan

Week 1: Python basics (days 1–7)

Goal: run programs, store and transform values, make decisions, repeat work. Each day links to the Python Foundations lesson to complete.

• Day 1: What Python is and how code runs. Lesson 1 — Hello, Python: print, comments and your first error on purpose.
• Day 2: Lesson 2 — Variables: storing values, integers, floats, strings and booleans, arithmetic and type conversion.
• Day 3: Lesson 3 — f-strings: formatting text with embedded values. Then try string indexing and slicing in the editor on your own.
• Day 4: Lesson 4 — if / else: if, elif, else, comparison and logical operators. Add input() to read a value from the user.
• Day 5: Lesson 5 — Loops: for loops and range(), accumulator patterns (sums, counts, maximums). Read the error messages you hit (TypeError, NameError, ValueError) without panic.
• Day 6: Review day. Redo the exercises you found hardest from lessons 1–5. Install Python and an editor locally.
• Day 7 (project): A number-guessing game. The program picks a random number, the player guesses, the program says higher or lower and counts attempts. Use a while loop (look it up in the official tutorial if needed) and add input validation so a non-number does not crash it.

Done when you can: write a program that takes input, converts types, uses if/elif/else and a loop correctly and explain what every line does.

Week 2: Collections, functions and errors (days 8–14)

Goal: organise data, structure code into reusable pieces and handle failures. Still in Python Foundations.

• Day 8: Lesson 6 — Lists and Lesson 7 — Functions: creating, indexing and appending to lists; defining functions with parameters and return values.
• Day 9: Lesson 8 — Dictionaries and Lesson 9 — String toolkit: key-value lookups, upper(), lower(), split(), join().
• Day 10: Lesson 10 — Dictionary methods and Lesson 11 — Tuples & unpacking: get(), items(), counting things with a dictionary, immutable groups.
• Day 11: Lesson 12 — Sets and Lesson 13 — enumerate & zip: unique values, looping with an index, pairing lists.
• Day 12: Lesson 14 — Ternary expressions, Lesson 15 — Unpacking tricks and Lesson 16 — Putting it together: combine a function, a loop and a condition.
• Day 13: Lesson 17 — List comprehensions and Lesson 18 — Errors: try / except. Review day: redo weak spots.
• Day 14 (project): A command-line to-do list. Add, list, complete and delete tasks stored in a list of dictionaries. Every action should be its own function. Stretch goal: Lesson 20 — Mini project: word counter as a warm-up, and save tasks to a file (preview of week 3).

Done when you can: use a list, a dictionary, a tuple and a set appropriately, write a function with parameters and a return value without looking it up, and catch a specific exception.

Week 3: Files, modules and packages (days 15–21)

Goal: work with data outside your program. None of this week is in our courses; it uses free outside resources, which are linked per day.

• Day 15: Reading and writing text files with open() and the with statement. Read chapter 7 of the official Python tutorial, "Reading and Writing Files", and the free online Automate the Boring Stuff chapter on files.
• Day 16: CSV and JSON with the standard library modules csv and json. Automate the Boring Stuff has a free online chapter on working with CSV files and JSON data; the csv and json module docs are the reference. Load a file, transform it, save it.
• Day 17: Exceptions in depth: else, finally, raising your own, and when not to catch. Chapter 8 of the official tutorial, "Errors and Exceptions", then revisit Foundations Lesson 22 — Custom exceptions.
• Day 18: Modules and imports: splitting code across files, if __name__ == "__main__", exploring os, pathlib, datetime, random and math. Chapter 6 of the official tutorial, "Modules".
• Day 19: Installing third-party packages with pip in a virtual environment: chapter 12 of the official tutorial, "Virtual Environments and Packages". Install requests, call a public API and print part of the JSON, following the requests quickstart.
• Day 20: Review day. Debugging practice: deliberately break yesterday's code three ways and fix it using the debugger, not just print.
• Day 21 (project): Choose one: a file organiser that sorts a downloads folder into subfolders by extension, or an expense tracker that stores entries in a CSV or JSON file and prints monthly totals. Both must handle missing files and bad input gracefully.

Done when you can: read and write a file safely, load JSON from an API, install a package into a virtual environment and explain why catching every exception is a bad idea.

Week 4: Classes, data, tests and a capstone (days 22–30)

Goal: understand object-oriented basics, touch real data, write a test, and build something you chose. Classes come from Python Intermediate; data and testing again use outside resources.

• Day 22: Python Intermediate, Lesson 3 — Classes & objects: attributes, methods, __init__, and when a class is clearer than a dictionary.
• Day 23: Python Intermediate, Lesson 12 — Inheritance, plus __str__ and class attributes from chapter 9 of the official tutorial, "Classes". Refactor the to-do list to use a Task class.
• Day 24: Working with structured data: loading a real CSV dataset, filtering and aggregating with plain Python using what you learned on day 16. A first look at what a library like pandas does for you.
• Day 25: A small web API call end to end: fetch data with requests, parse it, store it to a file, print a summary. Or, if you prefer the web, the first lessons of Django Foundations.
• Day 26: Writing tests with pytest for the functions in your week 2 and 3 projects, following the pytest "Get Started" page (or the standard library's unittest). Our courses do not cover testing; the docs are short and enough for a first test file. Testing is the habit that separates hobby code from maintainable code.
• Day 27: Capstone planning. Choose a project that interests you, write down the features, split them into functions and classes. Suggestions: a quiz app with questions in JSON, a habit tracker, a weather dashboard in the terminal, a flashcard tool with spaced repetition, or a simple text adventure.
• Days 28–29: Build the capstone. Commit to Git at the end of each day and write a README explaining how to run it.
• Day 30: Finish, test, tidy. Write in your log what you can do now that you could not on day 1, and what confused you most. Push it to GitHub.

Done when you can: define a class with methods, write a test for a function, load and summarise a data file, and run a 100–200 line program you designed yourself from a blank file.

What "done" looks like after 30 days

You should be able to:

• Read beginner and much intermediate Python and predict what it does.
• Write programs that take input, process collections, use files, call an API and handle errors.
• Organise code into functions, modules and simple classes.
• Debug with a debugger and with well-placed print statements.
• Use Git for your own projects at a basic level.
• Explain, in plain words, what a variable, loop, function, dictionary, exception and class are.

You will not yet be ready for a developer job, and anyone promising that in 30 days is selling something. What you will have is the foundation that makes the next six months productive.

Common mistakes

1. Binge-watching on day 1, nothing on days 2–5. Spread the hours; the material compounds.
2. Skipping projects because "I understand the lesson". Understanding a lesson and writing a program from a blank file are different skills.
3. Switching courses mid-plan. Finish this one, then add others from our list of the best free Python courses.
4. Copying project code from the internet or an AI. Use help for specific errors, not for the whole solution.
5. Starting with pandas, Django or machine learning in week 1. Libraries are confusing until the language is comfortable.
6. Quitting when a day runs long. Repeat the day. A 35-day plan completed beats a 30-day plan abandoned.
7. Not writing anything down. Your log and your Git history are the proof you are progressing.

After day 30: what comes next

• Weeks 5–8: the rest of Python Intermediate: comprehensions, lambda and map, args and kwargs, sorting with key, Counter and defaultdict, itertools, generators, decorators, context managers, dataclasses and properties. One project per fortnight.
• Then pick a direction: web with Django Foundations, data with SQL Deep Dive and Databases Foundations, or problem-solving with Algorithms Foundations and Data Structures.
• Keep building. The Python tutorials hub has practical walkthroughs for the projects above and many more.

Next step

Open Python Foundations and complete day 1 now, before closing this tab. It takes about an hour and nothing to install. The free online chapters of Automate the Boring Stuff with Python carry weeks 3 and 4; the print edition is handy if you prefer paper. Get the book on Amazon (paid link)