If you've ever asked anyone which language to learn first, chances are they said Python. Not because it's the fastest, or the most powerful, or even the most in-demand for every job out there — it's because Python gets out of your way. You spend less time fighting the syntax and more time actually solving the problem in front of you, which matters a lot when you're still figuring out what a "problem" even looks like in code.

So what is it, really?

Python is a general-purpose language, which is just a fancy way of saying it isn't built for one specific job. People use it to build websites, automate boring tasks, crunch data, train machine learning models, or just write a quick script to rename five hundred files at once. It was created by Guido van Rossum back in the late 1980s, and readability was one of his stated goals from day one — code that reads almost like plain English.

Here's what that looks like in practice

name = "Sam"
if len(name) > 2:
    print("Hello, " + name)

No curly braces, no semicolons at the end of every line, nothing decorative. Indentation isn't just a style choice in Python either — it's how the language knows where a block of code starts and stops. Get the spacing wrong and your program simply won't run. This trips up almost everyone at least once, and yes, it's a little annoying the first time it happens to you, but you get used to it fast.

Why beginners tend to stick with it

• You can write something useful in your first sitting, not your first week.
• Error messages are usually readable, not a wall of cryptic symbols.
• There's a huge ecosystem of free libraries for almost anything: web scraping, data analysis, image processing, you name it.
• It's genuinely used in serious, well-paid jobs, not just as a "beginner language" you graduate out of.

What it isn't great at

Python trades some raw speed for that readability. It isn't what you would reach for to build a video game engine, or something running on a tiny chip with almost no memory. For jobs like that, a language like C++ is usually the better fit — there's a whole set of tutorials on this site about exactly that. But for a huge slice of everyday programming, scripts, websites, data work, automation, Python is more than fast enough, and the time you save writing and debugging it usually matters more than a few milliseconds you might save elsewhere.

Where to go from here

The real way to learn Python isn't to read about it, it's to open a file and start typing. The next tutorial walks through variables and the basic building blocks you'll use in literally every Python program you ever write, so that's a good place to head next.

Every program, no matter how big, is really just a pile of values being stored, changed and passed around. In Python, a variable is just a name attached to a value, and unlike some languages, you never have to tell Python ahead of time what type of value that name is going to hold.

Creating a variable

age = 25
name = "Maria"
price = 9.99
is_member = True

No int, no String keyword, no declaring anything up front. You just write the name, an equals sign, and the value, and Python figures out the rest. This is what people mean when they call Python "dynamically typed" — the type lives with the value, not with the variable name itself.

The types you'll meet on day one

• int — whole numbers, like 25 or -3.
• float — numbers with a decimal point, like 9.99.
• str — text, wrapped in quotes, either single or double, Python doesn't mind which as long as you're consistent.
• bool — just True or False, and yes, they are capitalised.

Working with strings

Strings come up constantly, so it's worth getting comfortable with them early. You can glue two strings together with a plus sign, but a much nicer way in modern Python is an f-string:

name = "Maria"
age = 25
print(f"{name} is {age} years old")

That little f right before the opening quote tells Python "look inside the curly braces and substitute real values." Once you start using f-strings you'll probably never go back to gluing strings together with plus signs — it's just so much easier to read.

Checking a variable's type

print(type(age))     # <class 'int'>
print(type(price))   # <class 'float'>

You won't use type() much in everyday code, but it's genuinely useful when you're debugging and something isn't behaving the way you expect — half the time the bug turns out to be a value that's a string when you assumed it was a number.

A gotcha worth knowing early

Dividing two integers in Python always hands you a float back, even if the division is exact:

result = 10 / 2
print(result)  # 5.0, not 5

If you actually want integer division that drops the remainder, use two slash characters instead of one: 10 // 2 gives you 5. Small detail, but it catches people off guard more often than you would think, usually the first time a "5" they expected shows up as "5.0" somewhere it matters.

What is next

Once single values feel comfortable, the natural next step is storing groups of them — lists, tuples and dictionaries — which is exactly what the next tutorial covers.

Single values only get you so far. Real programs deal with groups of things — a list of names, a set of scores, a lookup table of prices. Python gives you three main containers for this, and honestly, figuring out which one to reach for is half the battle when you're starting out.

Lists: the one you'll use most

fruits = ["apple", "banana", "cherry"]
fruits.append("date")
print(fruits[0])       # apple
print(fruits[-1])      # date

A list is an ordered, changeable collection. You can add to it, remove from it, sort it, loop through it — it does basically everything you would expect. Notice fruits[-1] grabs the last item without you needing to know how long the list is. Little touches like that are exactly why people enjoy writing Python.

Tuples: like a list, but locked

point = (3, 4)
x, y = point
print(x, y)  # 3 4

A tuple looks almost identical to a list but can't be changed once created. Why would you want that? Mostly to signal intent — if a set of values genuinely shouldn't change, like coordinates, using a tuple communicates that clearly, and it also happens to be a touch faster than a list. That second line, by the way, is called unpacking, and it's one of Python's nicer conveniences: pulling several values out of a tuple in one go.

Dictionaries: look things up by name, not position

person = {"name": "Ann", "age": 30}
print(person["name"])     # Ann
person["age"] = 31

Instead of a numeric position, a dictionary looks values up by a key, the same way a real dictionary looks up a word to find its meaning. This is the container to reach for whenever "position one, two, three" doesn't make sense, but "give me the value for this name" does.

Looping through each of them

for fruit in fruits:
    print(fruit)

for key, value in person.items():
    print(key, "->", value)

A quick way to decide which one to use

• Order matters and you might add or remove items — use a list.
• The values should never change once set — use a tuple.
• You need to look values up by a meaningful name instead of position — use a dictionary.

You genuinely won't go far wrong reaching for a list by default and switching to a dictionary the moment you catch yourself thinking "I wish I could look this up by name instead of counting positions." That instinct, once it clicks, basically never goes away.

Two things every single program eventually needs to do: make a choice, and repeat something. Python handles both with less punctuation than most languages, which is either delightful or slightly unsettling the first time you see it, depending on where you're coming from.

if, elif, else

age = 20
if age < 13:
    print("Child")
elif age < 20:
    print("Teenager")
else:
    print("Adult")

Notice there's no "else if" — Python uses elif, one word, no space. Also notice the colon at the end of each condition, and the indentation underneath it. That indentation isn't decoration, it's literally what tells Python which lines belong to which branch. Four spaces is the convention almost everyone follows, and honestly, just let your editor handle it rather than counting spaces by hand.

The for loop

for i in range(5):
    print(i)

This prints 0 through 4. range(5) generates five numbers starting from zero, which trips up basically every beginner at least once — you ask for range(5) expecting 1 through 5, and Python hands you 0 through 4 instead. Once you know it's coming, it stops being surprising.

Looping over real things, not just numbers

colors = ["red", "green", "blue"]
for color in colors:
    print(color)

This is honestly the loop you'll write most often in Python. Rather than looping over a range of numbers and then indexing into a list, you just loop directly over the list itself. It reads closer to plain English, and that's very much the point.

The while loop

count = 0
while count < 3:
    print(count)
    count += 1

Use while when you genuinely don't know ahead of time how many times you'll repeat something, waiting for a condition to change rather than counting through a fixed range.

break and continue

break jumps out of a loop entirely, and continue skips straight to the next round without finishing the current one. Both are handy, but if you find yourself reaching for them constantly, it's often a sign the loop's condition could be written more clearly in the first place. Not always — sometimes they really are the right tool — but worth a second thought.

One thing to watch for

Because indentation is meaningful, mixing tabs and spaces in the same file can cause errors that are maddening to track down, since two lines can look identical on screen but be indented differently underneath. Pick one — spaces are the near-universal convention in Python — and stick with it.

At some point you'll catch yourself copying and pasting the same few lines of code for the third time, and that's usually the moment a function starts to feel less like a "nice to have" and more like something you actually need.

The basics

def greet(name):
    print(f"Hello, {name}!")

greet("Sam")

def starts a function definition, followed by a name and, in parentheses, whatever inputs it needs. Nothing shocking if you've seen functions in other languages — the main visual difference is, once again, no curly braces, just a colon and an indented block.

Returning a value

def add(a, b):
    return a + b

total = add(2, 3)
print(total)  # 5

A function that doesn't explicitly return anything hands back None by default, which is Python's way of saying "nothing here." This catches people out occasionally — you call a function expecting a value, print it, and get None, because somewhere along the way a return statement got forgotten.

Default values for parameters

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Sam")               # Hello, Sam!
greet("Sam", "Hey")        # Hey, Sam!

Giving a parameter a default value makes it optional. Callers can leave it out entirely and get sensible behaviour, or supply their own value when the default doesn't fit.

Keyword arguments

Python lets you call a function by naming its parameters directly, rather than relying purely on the order you list them, which is especially handy once a function has more than two or three parameters and you don't want to count commas to figure out which value goes where:

greet(name="Sam", greeting="Hey")
greet(greeting="Hey", name="Sam")  # order doesn't matter here

A small design tip

A function should really do one job. If you find yourself naming a function processAndSaveAndEmailUser, that's usually a hint it's doing three jobs stitched together, and splitting it into three smaller functions almost always makes the code easier to test and easier to read six months later when you've forgotten exactly how it works.

Why bother

Functions aren't just about avoiding repeated typing, although that's a nice side effect. They give a chunk of logic a name, and a good name tells the reader what is happening without them needing to read every line inside it. That's the real payoff, and it only grows as a program gets bigger.

Sooner or later almost every real program needs to read something from disk or save something to it — a config file, a log, a CSV export, whatever it might be. Python makes this refreshingly painless compared to a lot of languages.

Writing to a file

with open("notes.txt", "w") as f:
    f.write("Hello, file!")

The with block is the important part here, and it's worth pausing on. It guarantees the file gets closed properly once you're done with it, even if something goes wrong halfway through writing. Without it, you would have to remember to call f.close() yourself, and forgetting to close a file is a classic, sneaky source of bugs, especially on Windows where a still-open file can refuse to be deleted or renamed by another program.

Reading a file back

with open("notes.txt", "r") as f:
    content = f.read()
    print(content)

Reading line by line

For a bigger file, reading the whole thing into memory at once isn't always ideal. Looping over the file directly reads it one line at a time instead:

with open("notes.txt", "r") as f:
    for line in f:
        print(line.strip())

That .strip() at the end removes the trailing newline character that comes along with each line — forget it, and you won'tice odd extra blank-looking gaps whenever you print the lines out.

The write modes, quickly

• "w" — write, and overwrite the file completely if it already exists. Be careful with this one.
• "a" — append, adding new content to the end without touching what is already there.
• "r" — read, the default if you leave the mode out entirely.

What happens if the file doesn't exist?

Opening a file in read mode when it doesn't exist raises a FileNotFoundError, which will crash your program unless you handle it. Wrapping the open call in a try/except block is the usual fix, something the next-but-one tutorial on error handling covers properly, but it's worth knowing this particular error exists before it surprises you the first time.

Working with paths sensibly

If your program deals with more than a file or two, the pathlib module is worth knowing about early rather than gluing file paths together as raw strings, especially since Windows and Mac or Linux use different slash characters in their paths, and pathlib quietly handles that difference for you.

Python isn't purely an object-oriented language the way some others insist you be, but classes are everywhere in real Python code, and at some point you'll need to write your own rather than just using ones from a library.

A basic class

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(f"{self.name} says woof!")

my_dog = Dog("Rex")
my_dog.bark()  # Rex says woof!

__init__ is the constructor — it runs automatically the moment you create a new object, and its job is usually just to set up the object's starting values. self refers to the specific object being worked with, and yes, you've to write it as the first parameter of every method, even though you never actually pass it in yourself; Python fills it in automatically behind the scenes.

Why self trips people up

Honestly, self confuses almost everyone the first week they see it, mostly because it looks like it shouldn't be necessary. Just remember: inside a class, self.name means "this particular object's name," as opposed to some other Dog object that might exist elsewhere with a different name. Once that clicks, the rest of Python's classes feel a lot less mysterious.

Adding more behaviour

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} says woof!")

    def is_senior(self):
        return self.age >= 8

Creating several objects

dog1 = Dog("Rex", 3)
dog2 = Dog("Bella", 9)
print(dog2.is_senior())  # True

dog1 and dog2 are two entirely separate objects, each with its own name and age, even though both were built from the exact same Dog class. Changing one never touches the other.

A note on inheritance

class Puppy(Dog):
    def is_senior(self):
        return False

Here Puppy reuses everything from Dog but overrides is_senior with its own answer, since presumably no puppy is a senior dog. Same idea as inheritance in other object-oriented languages, just with noticeably less ceremony around it.

Do you always need classes?

Not really, and that's fine. Plenty of good Python code is just functions operating on dictionaries and lists, with no classes anywhere in sight. Reach for a class once you notice the same group of data and the functions that operate on it keep travelling together everywhere — that's usually the sign it's time to wrap them up into one.

Things break. A file won't exist, a user will type letters where you expected a number, an API call will time out. The question isn't whether your program will hit an error eventually, it's what happens when it does.

The basic try/except

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")

Code that might fail goes inside try. If it raises an exception, Python jumps straight into the matching except block instead of crashing the whole program. Without this, that division would stop your entire script dead, printing a traceback and exiting.

Catching more than one kind of error

try:
    value = int(input("Enter a number: "))
    result = 10 / value
except ValueError:
    print("That wasn't a valid number.")
except ZeroDivisionError:
    print("You can't divide by zero!")

Stacking multiple except blocks lets you respond differently depending on exactly what went wrong, which is almost always better than lumping every possible failure into one generic message.

The as keyword, for when you need the details

try:
    open("missing.txt")
except FileNotFoundError as e:
    print(f"Could not open the file: {e}")

finally: the block that always runs

try:
    f = open("data.txt")
    # work with the file
finally:
    f.close()

Whatever happens inside try, whether it succeeds or blows up with an exception, the finally block always runs. It's the natural spot for cleanup work, like making sure a file gets closed. That said, for files specifically, the with block from the earlier files tutorial already handles this for you automatically, which is honestly the better habit to build.

Don't just write "except:" and move on

A bare except with no specific error type catches literally everything, including mistakes you probably didn't mean to hide, like a typo in a variable name. It's tempting when you just want the program to stop crashing, but it tends to bury real bugs rather than fix them. At the very least, catch Exception specifically rather than a totally bare except, and consider printing or logging what actually went wrong.

Raising your own errors

def withdraw(balance, amount):
    if amount > balance:
        raise ValueError("Insufficient funds")
    return balance - amount

Sometimes the most helpful thing your own code can do is fail loudly and clearly, right at the point something is obviously wrong, rather than quietly continuing with bad data and causing a much more confusing failure somewhere else later on.