Python 101

1. Check what you have

$ python3 --version
Python 3.12.4

On Mac and Linux the command is python3. On Windows it is usually python or py.

2. The REPL — try things instantly

$ python3
>>> 2 + 2
4
>>> name = "bee"
>>> name.upper()
'BEE'
>>> exit()

REPL = Read, Eval, Print, Loop. This is where you should test every idea in this deck.

3. A script file

# hello.py
print("Hello, World")

$ python3 hello.py
Hello, World

Indentation is the syntax

if True:
    print("inside the block")   # 4 spaces
print("outside the block")

Other languages use { }. Python uses whitespace. The rule: 4 spaces per level, never tabs. Mixing tabs and spaces raises TabError.

Getting help without leaving the REPL

>>> help(len)
>>> dir("text")      # every method on str
>>> "text".upper.__doc__

print basics

print("Hello World")

# many arguments, joined by a space
print("a", 1, True, [1, 2])

end= — what to print after

# default is a newline; override it
print("Welcome to", end=' ')
print("Python")

sep= — what goes between arguments

print('09', '12', '2016', sep='-')
print('user', 'example.com', sep='@')

input returns a string, always

val = input("Enter your value: ")
print(val, type(val))

Printing to a file or stderr

import sys
print("went wrong", file=sys.stderr)

with open("log.txt", "w") as f:
    print("line one", file=f)

Single line — #

# This whole line is a comment
total = 42   # and this trailing part is too

Several lines

# Python has no /* */ block comment.
# You just stack # lines.
# Most editors do this with Cmd+/.

Triple-quoted strings

""" This is technically a string
expression, not a comment. Python
evaluates it and throws it away. """

name = "bee"
print(name)

People use these as block comments. It works, but the real job of triple quotes is the docstring below.

Binding and rebinding

x = "Hello World"   # str
x = 50              # now int
x = 60.5            # now float
x = 3j              # now complex

# Multiple at once
a, b, c = 1, 2, 3
x = y = z = 0

# Swap, no temp needed
a, b = b, a

The built-in types you need on day one

A name is a label, not a box

This picture explains most surprises later in the deck: b = a copies the arrow, not the object.

Naming rules and conventions

Legal: letters, digits, underscore. Cannot start with a digit. Case sensitive. Do not shadow built-ins such as list, str, id, type, sum.

What am I holding?

x = 50
print(type(x))              # <class 'int'>

# Prefer isinstance for checks;
# it respects inheritance.
isinstance(x, int)          # True
isinstance(x, (int, float))  # True

Converting

int("42")        # 42
int(3.99)        # 3   truncates, no rounding
float("3.14")    # 3.14
str(42)          # '42'
bool(0)          # False
list("abc")      # ['a', 'b', 'c']
int("ff", 16)     # 255  base 16
round(3.567, 2)   # 3.57

Type hints — optional, but read them

def greet(name: str, times: int = 1) -> str:
    return ("hi " + name + " ") * times

Hints do nothing at runtime. Python does not enforce them. They are documentation that editors and tools such as mypy can check. You will see them everywhere in production code.

Creating

a = 'single quotes'
b = "double quotes"          # identical
c = """spans
multiple lines"""
d = "say \"hi\" and a\ttab"   # escapes
e = r"C:\new\path"            # raw, no escapes
f = "ab" * 3                  # 'ababab'
g = "a" + "b"                  # 'ab'

Indexing — forwards and backwards

s = "BeePostive"
s[0]     # 'B'   first
s[3]     # 'P'
s[-1]    # 'e'   last
s[-2]    # 'v'   second last
len(s)   # 10
s[99]    # IndexError

Every slice form

s = "BeePostive"
s[3:-2]    # 'Posti'  3 to 2-from-end
s[:3]      # 'Bee'    from the start
s[3:]      # 'Postive' to the end
s[:]       # whole copy
s[::2]     # 'BePsie' every 2nd
s[::-1]    # 'evitsoPeeB' reversed
s[100:]    # ''  slices never IndexError

Indexing out of range raises. Slicing out of range just gives you what exists. Same rules apply to lists and tuples.

The methods you will actually use

The older styles you will still meet

# .format() — pre-3.6 code and templates
"Result is {}".format(5)
"{name} is {age}".format(name="bee", age=3)

# % — very old, avoid in new code
"Result is %d" % 5

Use f-strings. They are faster and you read the value right where it appears.

The full form

x = 10

if x > 5:
    print("x is greater than 5")
elif x == 5:
    print("x is 5")
else:
    print("x is less than 5")

Only the first matching branch runs. elif can repeat any number of times. else is optional.

Nesting and how to avoid it

# Hard to follow
if user:
    if user.active:
        if user.admin:
            grant()

# Guard clauses — flat and readable
if not user:
    return
if not user.active:
    return
if not user.admin:
    return
grant()

The one-line conditional expression

status = "adult" if age >= 18 else "minor"

# Reads as: value_if_true if cond else value_if_false
print(f"{n} item{'s' if n != 1 else ''}")

Fine for a short choice. Do not chain three of them together.

match — Python 3.10 and later

match command:
    case "start":
        run()
    case "stop" | "halt":      # either
        halt()
    case _:                    # default
        print("unknown")

A cleaner switch for many fixed cases. Optional knowledge on day one, but you will see it.

for — walk a sequence

for i in range(5):
    print(i)          # prints 0 to 4

for ch in "bee":
    print(ch)         # b, e, e

for item in ["a", "b", "c"]:
    print(item)

for key, value in {"a": 1}.items():
    print(key, value)

There is no C-style for (i=0; i<n; i++). Python loops over the items themselves.

while — repeat until false

i = 0
while i < 5:
    print(i)
    i += 1            # do not forget this

Forget the increment and you have an infinite loop. Ctrl+C stops it.

The read-until-done pattern

while True:
    line = input("> ")
    if line == "quit":
        break
    print("you said", line)

Deliberate infinite loop plus break. This is normal and idiomatic when the exit condition is in the middle.

Nested loops

for row in range(3):
    for col in range(3):
        print(row, col, end="  ")
    print()

A break exits only the innermost loop.

break exits, continue skips

for i in range(10):
    if i == 5:
        break       # leave the loop entirely
    if i == 3:
        continue    # jump to next iteration
    print(i)

3 is skipped by continue. 5 onward never runs because break fired.

else on a loop — the surprising one

for n in [1, 3, 5]:
    if n % 2 == 0:
        print("found an even")
        break
else:
    print("no even numbers at all")

The else runs only if the loop finished without hitting break. Read it as "no break".

zip — walk two sequences in step

names = ["bee", "ant", "fly"]
legs  = [6, 6, 6]

for name, n in zip(names, legs):
    print(name, n)

# zip stops at the shorter one
list(zip([1,2,3], ["a","b"]))
# [(1, 'a'), (2, 'b')]

Other iteration helpers

reversed([1,2,3])        # 3, 2, 1
sorted([3,1,2])          # [1, 2, 3]
sorted(words, key=len)     # by length
sorted(x, reverse=True)    # descending

Create and read

var = ["Bee", "Post", "ive"]
print(var)

mixed = [1, "two", 3.0, [4], None]  # any types
empty = []
built = list("abc")            # ['a','b','c']

var[0]        # 'Bee'
var[-1]       # 'ive'
var[0:2]      # ['Bee', 'Post']  slicing works
len(var)     # 3
"Bee" in var # True

Change in place

x = [3, 1, 2]
x[0] = 99            # [99, 1, 2]
x.append(4)           # add one at the end
x.extend([5, 6])      # add many
x.insert(0, 0)        # at a position
x.remove(99)          # by value, first match
last = x.pop()         # remove and return last
first = x.pop(0)       # by index
del x[0]              # by index, no return
x.sort()               # in place, returns None
x.reverse()            # in place
x.clear()              # empty it

Useful patterns

x = [5, 3, 5, 1]
sum(x)              # 14
min(x), max(x)      # 1, 5
x.count(5)          # 2
x.index(3)          # 1
sorted(set(x))       # [1, 3, 5]  dedupe + sort
", ".join(["a","b"])  # 'a, b'  (strings only)

Create and read

var = ("Bee", "Post", "ive")
print(var)

point = (3, 4)
point[0]         # 3   index like a list
point[0:1]       # (3,)  slice like a list
len(point)       # 2
3 in point      # True

point[0] = 9     # TypeError: does not support
                 # item assignment

Functions return tuples

def min_max(values):
    return min(values), max(values)

lo, hi = min_max([4, 9, 1])
print(lo, hi)

"Multiple return values" in Python is really one tuple, packed on the way out and unpacked on the way in.

Why choose a tuple

• It signals "this will not change" to every reader
• Slightly smaller and faster than a list
• Hashable, so it can be a dict key or a set member. A list cannot.

grid = {(0, 0): "origin", (1, 2): "target"}

Create and read

d = {1: 'Bee', 2: 'For', 3: 'Bee'}
print(d)

user = {"name": "bee", "age": 3}
empty = {}
built = dict(name="bee", age=3)
pairs = dict([("a", 1), ("b", 2)])

user["name"]              # 'bee'
user["missing"]           # KeyError!
user.get("missing")        # None, no error
user.get("missing", 0)     # 0, your default
"name" in user           # True (checks keys)
len(user)                 # 2

Add, update, delete

user["email"] = "b@hive.io"   # add or overwrite
user.update({"age": 4})       # merge a dict in
user.setdefault("tags", [])   # set only if absent

del user["email"]             # KeyError if absent
user.pop("email", None)       # safe remove
user.clear()                   # empty it

# Merge two dicts (3.9+)
merged = defaults | overrides

Keys must be hashable

ok = {"str": 1, 42: 2, (1, 2): 3}   # fine
bad = {[1, 2]: "x"}   # TypeError:
                       # unhashable type: 'list'

Keys must be immutable: strings, numbers, tuples of immutables. Values can be anything, including lists and other dicts.

Create

var = {"Bee", "For", "Bee"}
print(var)

The duplicate vanished, and the print order is not the order you typed. Both are expected.

s = set([1, 2, 2, 3])   # {1, 2, 3}
s = set("hello")         # {'h','e','l','o'}

Change

s = {1, 2}
s.add(3)          # {1, 2, 3}
s.add(3)          # no change, no error
s.discard(9)      # safe, no error if absent
s.remove(9)       # KeyError if absent
s.update([4, 5])  # add many
2 in s            # True, and very fast

From loop to comprehension

# The long way
squares = []
for n in range(5):
    squares.append(n * n)

# The same thing
squares = [n * n for n in range(5)]
print(squares)

Shape: [ expression for item in iterable ]

Add a filter

# keep only what passes the if
evens = [n for n in range(10) if n % 2 == 0]
# [0, 2, 4, 6, 8]

names = [u["name"] for u in users
         if u["active"]]

# if/else goes BEFORE the for
labels = ["even" if n % 2 == 0 else "odd"
          for n in range(4)]

Nested

matrix = [[1, 2], [3, 4]]

# flatten: read the fors left to right
flat = [x for row in matrix for x in row]
# [1, 2, 3, 4]

Define and call

# A simple Python function
def fun():
    print("Welcome to BeePostive")

# Nothing happens until you call it
fun()

def name ( params ) colon, then an indented body. Define before you call.

Parameters

# Check whether x is even or odd
def even_odd(x):
    if x % 2 == 0:
        print("even")
    else:
        print("odd")

even_odd(2)
even_odd(3)

return ends the function

def add(a, b):
    return a + b        # hands the value back

def is_true(a):
    return bool(a)

print(f"add is {add(2, 3)}")
print(f"is_true is {is_true(2 < 5)}")

Returning several values

def func():
    return 1, 2, 3, 4, 5

one, two, three, four, five = func()
print(one, two, three, four, five)

The values are packed into a tuple on the way out and unpacked on the way in.

Functions are objects too

def double(n): return n * 2

f = double            # no parens: the function itself
f(5)                  # 10

list(map(double, [1, 2]))  # [2, 4]
sorted(words, key=len)     # pass a function in

# lambda: a tiny unnamed function
sorted(users, key=lambda u: u["age"])

Positional, keyword, default

def connect(host, port, timeout=30):
    ...

connect("db.local", 5432)              # positional
connect("db.local", port=5432)         # keyword
connect(port=5432, host="db.local")    # any order
connect("db.local", 5432, 5)           # override default

# Defaults must come last
def bad(a=1, b): ...   # SyntaxError

Unpacking at the call site

def my_fun(arg1, arg2, arg3):
    print("arg1:", arg1)
    print("arg2:", arg2)
    print("arg3:", arg3)

args = ("Bee", "for", "Bee")
my_fun(*args)              # spread a sequence

kwargs = {"arg1": "Bee", "arg2": "for",
          "arg3": "Bee"}
my_fun(**kwargs)           # spread a dict

*args — any number of positionals

def total(*args):
    print(type(args))    # <class 'tuple'>
    return sum(args)

total(1, 2, 3)        # 6
total()                # 0

Inside the function args is a plain tuple of whatever was passed.

**kwargs — any number of named

def show(**kwargs):
    print(type(kwargs))  # <class 'dict'>
    for k, v in kwargs.items():
        print(k, "=", v)

show(host="db", port=5432)

The names args and kwargs are convention. The * and ** are what matter.

Scope: names are local by default

count = 0              # module level (global)

def bump():
    count = 99         # a NEW local name

bump()
print(count)           # still 0

Assigning inside a function creates a local name. Python looks up names Local → Enclosing → Global → Built-in.

def bump():
    global count      # works, but avoid
    count += 1

# Better: take it in, hand it back
def bump(count):
    return count + 1

Reading is fine, assigning is the trigger

LIMIT = 10

def check(n):
    return n < LIMIT   # reads global, fine

Anatomy of a traceback

Last line = what went wrong. Line above it = where. Everything above that is how you got there.

Exceptions you will meet first

Raising your own

def set_age(n):
    if n < 0:
        raise ValueError(f"age cannot be {n}")

# Your own exception type
class ConfigError(Exception):
    """Config is missing or invalid."""

try:
    parse()
except ValueError as err:
    raise ConfigError("bad config") from err

Three ways to read

with open("data.txt", encoding="utf-8") as f:
    everything = f.read()        # one big string

with open("data.txt", encoding="utf-8") as f:
    lines = f.readlines()        # list of lines

# Best for big files: stream line by line
with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip("\n"))

Iterating the file object never loads the whole thing into memory.

Writing

# "w" truncates the file first!
with open("out.txt", "w", encoding="utf-8") as f:
    f.write("first line\n")
    f.writelines(["a\n", "b\n"])

# "a" appends to the end
with open("out.txt", "a", encoding="utf-8") as f:
    f.write("appended\n")

Modes

Opening with "w" deletes the existing contents immediately. Use "a" when you meant to add.

Paths — use pathlib

from pathlib import Path

p = Path("data") / "input.txt"   # cross-platform
p.exists()
p.suffix                        # '.txt'
p.stem                          # 'input'
text = p.read_text(encoding="utf-8")
p.write_text("hello", encoding="utf-8")

for f in Path("logs").glob("*.log"):
    print(f.name)

Import forms

import math                # math.sqrt(9)
import numpy as np          # np.array(...)
from math import sqrt, pi   # sqrt(9)
from pathlib import Path     # Path("x")

from math import *          # never do this

Wildcard imports dump unknown names into your namespace and silently shadow your own variables.

Your own module

# utils.py
def greet(name):
    return f"hi {name}"

# main.py, same folder
from utils import greet
print(greet("bee"))

Import order (PEP 8)

import json                   # 1. standard library
from pathlib import Path

import requests               # 2. third party

from myapp.utils import greet  # 3. your code

Standard library worth knowing on day one

Small tastes

import random, datetime
from collections import Counter

random.choice(["a", "b"])       # 'b'
random.randint(1, 6)           # 4

today = datetime.date.today()
print(today.isoformat())        # '2026-08-21'

Counter("mississippi").most_common(2)
# [('i', 4), ('s', 4)]

Define a class

class Dog:
    species = "Canis familiaris"   # class attribute,
                                   # shared by all

    def __init__(self, name, age):
        self.name = name           # instance attributes,
        self.age = age             # one set per object

    def speak(self):
        return f"{self.name} says woof"

    def __repr__(self):
        return f"Dog({self.name!r}, {self.age})"

Make and use objects

a = Dog("Rex", 3)      # calls __init__
b = Dog("Ada", 5)

print(a.name)          # Rex
print(a.speak())       # Rex says woof
print(a)               # Dog('Rex', 3)   via __repr__
print(b.species)       # shared class attribute

a.age = 4              # attributes are mutable
isinstance(a, Dog)     # True

One blueprint, many objects

Dunder methods — hooks into syntax

"Dunder" = double underscore. Python calls these for you.

The pythonic getter: @property

class Car:
    @property
    def make(self):
        return self._make

c.make        # no parentheses, reads like a field

2. Inheritance — reuse and specialise

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "..."

class Dog(Animal):          # Dog IS AN Animal
    def __init__(self, name, breed):
        super().__init__(name)   # run parent setup
        self.breed = breed
    def speak(self):            # override
        return "woof"

d = Dog("Rex", "lab")
d.name          # 'Rex'   inherited
d.speak()       # 'woof'  overridden
isinstance(d, Animal)   # True

3. Polymorphism — same call, different behaviour

class Cat(Animal):
    def speak(self): return "meow"

for a in [Dog("Rex", "lab"), Cat("Tom")]:
    print(a.speak())      # woof, then meow

The loop does not care which class it has. Python takes this further with duck typing: if an object has a .speak(), it works, inheritance or not.

4. Abstraction — publish the what, hide the how

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self): ...

class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s ** 2

Shape()      # TypeError: abstract
Square(3).area()   # 9

Callers depend on "a Shape has an area()", not on how any particular shape computes it.

Learn next, roughly in this order

Practice beats reading

• Count word frequency in a text file (dict or Counter)
• Read a CSV and print a per-column summary
• A command line to-do list backed by JSON
• FizzBuzz, then rewrite it three different ways
• Take any loop you wrote today and turn it into a comprehension, then decide which reads better