Python for Beginners: Your First Program in 5 Minutes

Have you ever wondered how apps like Instagram, Spotify, or YouTube actually work? Behind every app, website, and game, there's code — instructions written by a person telling the computer what to do.

Python is one of the most popular languages for writing those instructions. It reads almost like plain English, so you can focus on solving problems instead of fighting confusing syntax.

In this tutorial, you'll write your first Python program, learn how Python handles text and numbers, and start using variables to store information. Every code example on this page is live — you can click Run, change things, and see what happens instantly. No setup needed.

There's a fun tradition in programming: the very first thing you do in any new language is make it say "Hello, World!" It's a quick handshake between you and the language — proof that everything works.

In some languages, this takes 5 or more lines of code. In Python, it takes just one:

Click the Run button above. You should see Hello, World! appear below the code. That's it — you just ran a Python program!

Let's break down what just happened:

Try changing the message inside the quotes and running it again. Try printing your own name. Try adding a second print() on a new line:

Each print() shows up on its own line. Python reads your code from top to bottom, one line at a time, like reading a book.

The order you write things is the order they run. This is one of the most important ideas in programming.

A comment is a note you write inside your code that Python completely ignores. You create one by starting a line with the # symbol.

Why would you want Python to ignore something? Because comments are for humans, not computers. They help you (and anyone else reading your code) understand what's going on.

Think of comments like sticky notes on a recipe. The oven doesn't read them, but they help you remember why you added extra salt or what temperature worked best.

Everything in Python has a type. A type is like a label that tells Python what kind of data something is and what you can do with it.

The two most basic types are strings (text) and numbers. Understanding the difference between them will save you from a lot of confusing errors.

A string is any text wrapped in quotation marks. You can use single quotes ('hello') or double quotes ("hello") — they work exactly the same way.

Strings can hold anything — letters, numbers, spaces, punctuation, even emoji. As long as it's inside quotes, Python treats it as text.

Numbers in Python come in two flavors:

Here's something that trips up almost every beginner. "42" (with quotes) and 42 (without quotes) are completely different things to Python.

One is text. The other is a number. They look the same when printed, but they behave very differently:

"42" + "8" gives "428" because + between strings means "stick them together." This is called concatenation.

42 + 8 gives 50 because + between numbers means "add them." Same operator, completely different behavior depending on the type.

The type() function tells you exactly what kind of data you're working with. When something isn't behaving the way you expect, checking the type is usually the first thing to try.

Python works great as a calculator. It handles numbers of any size without breaking a sweat — unlike some other languages that choke on big numbers.

Here are all the math operators you'll use:

Most of these work like regular math class. But a few might be new to you.

`/` (division) always gives you a decimal result, even when it divides evenly. 10 / 2 gives 5.0, not 5. This catches a lot of people off guard.

`//` (floor division) divides and then rounds down to the nearest whole number. Think of it as "division, but throw away everything after the decimal point."

`%` (modulo) gives you the remainder after dividing. For example, 15 ÷ 4 = 3 with a remainder of 3. This is surprisingly useful — you can check if a number is even (n % 2 == 0), make values wrap around (like hours on a clock: 13 % 12 = 1), and much more.

` (exponent)** raises a number to a power. 2 ** 10` means "2 multiplied by itself 10 times," which gives 1024.

Python follows the standard math order of operations (PEMDAS). You can use parentheses to change the order:

So far, we've been working with values directly — print(42), print(2 + 3). That works for quick calculations, but real programs need to remember values and use them later.

That's what variables are for. Think of a variable as a labeled container. You give it a name, put a value inside, and then use that name whenever you need the value.

name = "Alice" creates a variable called name and stores the string "Alice" in it. The = sign is the assignment operator — it doesn't mean "equals" like in math. It means "store this value in this name."

Read name = "Alice" as: "name gets Alice." This distinction matters and will save you confusion later.

Notice there's no let, var, or const keyword. In JavaScript you'd write let name = "Alice". In Python, you just write name = "Alice". Python also doesn't need type declarations — it figures out the type from the value automatically.

Variables can change. You can give them a new value at any time:

The line score = score + 5 looks weird if you think of = as "equals." But remember, = means "assign."

Read it as: "take the current value of score (10), add 5 to get 15, and store that result back in score." This pattern — updating a variable based on its current value — shows up everywhere in programming.

In almost every program, you'll need to mix variables into text. Showing a welcome message with someone's name, displaying a score, printing a receipt — these all require combining data with text.

Python has a wonderful tool for this called f-strings (the "f" stands for "formatted"). Put the letter f before the opening quote, then put any variable or expression inside {curly braces}:

The magic is in the {curly braces}. Python evaluates whatever expression is inside, converts the result to text, and plugs it into the string.

You can put almost anything inside the braces — variables, math, function calls, even comparisons. Let's see a more practical example:

Compare that to the old way of building strings — using + to stitch pieces together:

The old way requires str(age) to manually convert the number to text. Remember — you can't use + to join a string and a number directly.

f-strings handle that conversion automatically. They're cleaner, faster, and less error-prone. Always use them for new code.

Let's combine everything into one small program. This shows the pattern you'll use in every Python project: store data in variables, do calculations, and display the results.

Don't worry about the :.2f part — that just means "show exactly 2 decimal places" (so 4.5 displays as 4.50). We'll cover formatting in detail later.

The important thing is the pattern: store data → do calculations → display results. That's the core of every program, whether it's 10 lines or 10,000.

Try changing the meal_cost, tax_rate, or tip_rate and running it again!

Now it's your turn! These exercises go in order from easiest to hardest, and each one uses what you've learned.

A few tips before you start:

These aren't just beginner concepts you'll outgrow. They're the foundation of every Python program. Even the most advanced code is creative combinations of these building blocks.

In the next tutorial — [Variables and Data Types](/python/variables-and-data-types) — you'll go deeper into how Python stores data. You'll learn about booleans (True/False), None, and type conversion.

You'll also discover why 0.1 + 0.2 doesn't equal 0.3 in Python (or any programming language) — and what to do about it.