The Two Things That Actually Confused Me Learning Python (That No Course Explains)

A genuine beginner's notes: the jargon courses never define, and the 'for lists in my_lists' naming illusion that makes Python code look like magic —…

I run a coding education site — and I'm still learning to code myself, working through Python on Codecademy in the evenings. That combination turns out to be useful: every time a lesson confuses me, I'm holding a live specimen of the exact thing courses get wrong. Here are the two that got me this week.

1. Courses use words they never explain

Every course does this. The lesson says something like:

Four words in that sentence — define , parameter , call , return — were never actually explained to me. The course just started using them, and I was expected to absorb what they meant from context. Sometimes you can. Often you half-can, and that half-understanding quietly compounds until, three lessons later, nothing makes sense and you don't know why.

Here's the plain-English version I wish someone had pinned to the top of my course:

Word

What it actually means

def / define

"Dear Python, here's a recipe. Don't cook it yet — just remember it."

call

"Now cook that recipe." Writing my_function() with the brackets is the calling.

parameter

The blank space in the recipe: "a function that takes some list ".

argument

The real thing you shove into that blank when you call it.

return

What the function hands back to you when it finishes. Not the same as printing!

iterate

Fancy word for "go through the items one at a time." That's it. That's the whole word.

None of these are hard. What's hard is being expected to know them while also learning the actual concept. Two unknowns in one sentence is how beginners drown.

2. The naming illusion: for lists in my_lists

This one properly broke my brain for a while. A lesson showed me something like:

And I sat there asking questions the course never answered:

The answer — which feels obvious after someone says it, and invisible before — is:

Python only owns a few words in that snippet: def , for , in , print . Everything else — print_shopping , my_lists , lists — is a name some human invented on the spot, and Python would be equally happy with anything else. This works identically:

banana isn't connected to anything. It's just the label the loop sticks on whichever item it's currently holding . The course's choice of lists — a plural word, suspiciously similar to my_lists — was genuinely a bad teaching choice , because it made me think the names were mechanically related. They're not. The for X in Y pattern means: "take each item in Y , temporarily call it X , and run the indented lines."

So when you're reading any Python code, there are really two languages on the screen:

Once I started mentally sorting every line into those two buckets, code got dramatically easier to read. Nobody had told me to do that.

One real trap while we're here

There's a bonus reason the example above is worse than it looks: you can name things after Python's built-in features, and Python won't stop you — it'll just quietly break something else:

By naming a variable list , you've papered over Python's built-in list() function, and the error you get later doesn't mention that at all. As a beginner you had no chance. (Rule of thumb: if your editor colours a name differently when you type it, pick a different name.)

What I'm doing about it

I can't fix other people's courses, but I can fix mine. Because of exactly this experience, we're building two things into every lesson on this site:

If you're learning right now and something in a lesson feels confusing, I genuinely want to hear about it — the odds are good it's not you, it's the lesson. That's been the biggest thing learning to code has taught me so far: most "I'm too stupid for this" moments are actually "nobody explained one word" moments.

Related articles

Links on this page