How to Code in Python: Step-by-Step Guide for Beginners

Two Weeks. That's All It Took.

This is kind of a diary. I kept notes during my first two weeks of Python and figured they might be more useful than another polished tutorial. No structure really. Just what I actually did each day, what broke, what worked.

Day 1: Installing Stuff and Feeling Dumb

Spent 40 minutes fighting with the installer because I forgot the PATH checkbox. Apparently everyone does this. Eventually got `python --version` to return something. Felt unreasonably proud.

Wrote `print(2 + 2)` and it printed 4. Then `print("hello")` and it printed hello. This is dumb but I literally smiled at my screen. You're telling a computer what to do and it does it. That feeling doesn't really go away even months later.

Ended day 1 with a script that asked for your name and age and printed a message. Variables, input, f-strings. Three concepts in eight lines of code. Took about 2 hours total including the install headache.

Day 2: The Difference Between = and ==

Wrote an if-statement that didn't work for 45 minutes. The problem: I wrote `if age = 18` instead of `if age == 18`. Single equals is assignment (put this value here), double equals is comparison (are these equal?).

This is the kind of thing that feels obvious after you learn it and impossible before. Every programming language I've touched since has this same distinction so learning it once is worth the pain.

Also learned `elif` which is Python's weird spelling of "else if" and honestly I still think it looks wrong. But you get used to it.

Day 3: Lists Made Sense, Dictionaries Didn't

Lists I got immediately. It's just a sequence of things in order. `["apple", "banana", "cherry"]`. Access items by position: `fruits[0]` gives you "apple". Add new stuff with `.append()`. Loop through things with `for fruit in fruits:`. Pretty straightforward honestly.

Dictionaries took me three days to understand. `{"name": "Alice", "age": 28}`. You look up values by key instead of position: `person["name"]`. The syntax uses curly braces but they're not sets and not JSON and my brain kept confusing all three.

The breakthrough came when I used a dict to count word frequencies. I had a sentence and wanted to know how many times each word appeared. A dict lets you use the word itself as the key and the count as the value. That clicked. Dictionaries are just lookup tables. Once you see them that way they stop being confusing.

Day 4: Loops Broke My Brain Briefly

`for i in range(5)` prints 0 through 4, not 1 through 5. Zero-indexing. Everyone struggles with this for about a week and then it becomes invisible. I can't explain why starting from 0 makes sense in computing. Something about memory offsets and pointer arithmetic. But honestly you don't need to understand why. Just accept that ranges start at 0 and move on.

Also discovered `while` loops. Used one to make a number guessing game where the program says "too high" or "too low" until you get it right. Accidentally created an infinite loop by forgetting to update the guess variable. Had to Ctrl+C to kill it. Terminal flashed for a solid second before it stopped and I genuinely thought I'd broken something permanently. I hadn't. Infinite loops are harmless, just annoying.

Day 5: Functions At Last

`def my_function():` felt like a big deal. It's where you stop writing scripts and start writing programs.

A function is just a named block of code you can reuse. Instead of typing the same 10 lines every time you want to calculate tax, you wrap it in `def calculate_tax(amount):` and call it with `calculate_tax(100)`. The stuff in parentheses is the parameter, the stuff after `return` is what comes back out.

I wrote a function that calculated tip amounts for restaurant bills and one that converted Celsius to Fahrenheit. Both under 5 lines. The feeling of calling `tip(45.50, 18)` and getting back $8.19 was weirdly satisfying.

Also ran into scope for the first time. A variable created inside a function isn't visible outside it. This seems annoying until you realize it prevents a whole category of bugs where two functions accidentally overwrite each other's data.

Days 6-7: Weekend Project

Decided to build something instead of studying. Wrote a script that renamed all the MP3 files in my music folder. They were named things like `track01.mp3` and I wanted `Artist - Song Title.mp3`.

This was way harder than I expected. The file names were embedded in the MP3 metadata, not the filename itself, so I needed a library called `mutagen` to read ID3 tags. Installing it was `pip install mutagen`. Then I had to learn how mutagen worked, which meant reading documentation, which I'd never done before. Documentation is dense and assumes you know things you don't know. Took about 2 hours of trial and error.

The script worked on about 80% of my files. The other 20% had weird metadata formats and the script just skipped them. Good enough. I renamed 400 files in 30 seconds instead of spending a Saturday doing it manually.

This was the moment I understood why people like programming. Not because it's interesting intellectually. Because it saves you from doing tedious garbage.

Day 8: Error Messages Are Actually Helpful

Spent an hour on a bug. The error said `ValueError: invalid literal for int() with base 10: 'abc'`. I had no idea what "base 10" meant. Turned out I was trying to convert the string 'abc' to an integer, which obviously doesn't work. The error message told me exactly what was wrong, I just didn't know how to read it yet.

After this I started actually reading error messages instead of glossing over them in panic. The format is always the same: exception type, a short description, and a line number. Start from the bottom. The last line of the traceback is almost always where the actual problem is.

Day 9: Virtual Environments (Boring But Important)

`python -m venv project_name` creates an isolated Python environment for your project. This means packages you install for one project don't conflict with packages for another project. I ignored this advice for months and eventually my system Python became a mess of incompatible versions. Don't do that. Virtual environments take 5 seconds to set up and they prevent hours of debugging.

Days 10-14: A Slightly Bigger Project

Built a Flask web app. Nothing fancy. A page with a text box where you type a city name and it tells you the current weather using the OpenWeatherMap API.

This combined everything I'd learned: variables, conditionals, loops, functions, file I/O for reading the API key from a config file, error handling for when the API was down or the city didn't exist, HTML for displaying the result, and a bunch of other stuff I'm probably forgetting.

The app was about 60 lines of Python plus 20 lines of HTML. It took me 4 evenings to build and maybe 2 of those evenings were spent fighting with CSS (which is not Python's fault). But at the end, I had a URL I could send to friends and say "look, I built this."

That's the whole thing. Two weeks. I'm not saying you'll be employable in two weeks. You won't. But you'll be past the hardest part, which is going from zero to something. After that, every new thing you learn has context. You know why it matters because you've already bumped into the problem it solves.