1. What is Python?

Welcome! If you've never written code before, you're in the right place. This tutorial will teach you Python programming from absolute zero, with every example focused on physics applications.

What is Programming?

Programming is the process of writing instructions that a computer can follow. Think of it like writing a very detailed recipe—except instead of cooking ingredients, you're telling a computer exactly what calculations to perform and what to display.

Computers are incredibly fast but not very smart. They do exactly what you tell them, nothing more, nothing less. This means we need to be very precise in our instructions. A programming language like Python provides the vocabulary and grammar for writing these instructions.

Why Python?

Python is a programming language—a way to give instructions to a computer. Among the many programming languages that exist, Python stands out because:

It reads like English: Python code is designed to be readable. Unlike some languages with lots of symbols and brackets, Python uses plain words like if, for, and print. You can often guess what code does just by reading it.
It's interpreted: You can run code line by line and see results immediately—perfect for experimenting and learning. There's no long wait between writing code and seeing what it does.
It's forgiving: Python handles many technical details for you, letting you focus on solving problems rather than fighting with the language.
It has powerful scientific tools: Libraries like NumPy and Matplotlib let you do complex calculations and create publication-quality graphs with just a few lines of code.

Why Python for Physics?

In physics, you'll need to: analyse experimental data, solve equations numerically, run simulations, and create visualisations. Python excels at all of these. Most physics departments now teach Python as the primary programming language, and it's used in research labs around the world.

Your First Program

Let's write your very first program! Every programmer's journey starts with a simple program that displays a message—traditionally "Hello, World!" We'll use Python's print() function to do this.

Understanding the print() Function

A function is a named piece of code that performs a specific task. Think of it like a machine: you put something in, and it does something with it. The print() function's job is to display text on the screen.

To use print():

Write the word print
Follow it with parentheses ()
Put the message you want to display inside the parentheses, surrounded by quotation marks " "

Python - Try editing this!

# Lines starting with # are "comments" - notes for humans
# Python ignores them completely. Use comments to explain your code!

# The print() function displays whatever is inside the parentheses
# Text must be inside quotation marks (single ' or double " work)
print("Hello, Universe!")
print("I'm learning Python for physics!")
print("E = mc²")

Output

Click "Run" to execute the code

Understanding Comments

Notice the lines starting with #? These are called comments. Python completely ignores any line that starts with #. Comments are notes you write to explain your code—they're incredibly important for:

Explaining why you wrote something a certain way
Helping others (and your future self!) understand your code
Temporarily disabling code without deleting it

Try This!

Click in the code box above, change the text inside the quotes to say something else, then click Run again. Try adding a new print() line! You can't break anything—experiment freely!

How This Tutorial Works

Every code example in this tutorial is interactive. You can:

Read the explanation before each code block
Study the code and its comments
Run it to see what happens
Modify it and run again to experiment
Practice with the exercises at the end of each section

The code runs in your browser using real Python—no installation required! Making mistakes is part of learning, so don't be afraid to experiment.

Next: Getting Started

2. Getting Started

While this tutorial runs in your browser, for real projects you'll want Python on your computer. Here's how to set up your environment.

Installing Python

For physics and scientific computing, we recommend Anaconda—a Python distribution that includes all the scientific libraries you'll need:

Go to anaconda.com/download
Download the installer for your operating system
Run the installer and follow the prompts

Anaconda includes Python plus NumPy, Matplotlib, SciPy, Pandas, and Jupyter Notebooks—everything you need for physics work.

Choosing a Code Editor

You'll write code in a code editor or IDE (Integrated Development Environment). Popular options include:

Jupyter Notebook: (included with Anaconda) Great for interactive exploration and combining code with explanations. Perfect for physics labs and research.
Visual Studio Code: Free, powerful, works for any programming language.
Spyder: (included with Anaconda) Similar to MATLAB, designed for scientific work.

Understanding the Interpreter

Python is an interpreted language, meaning it executes code line by line. This is different from compiled languages (like C) where you must compile the entire program before running it.

Python

# Python executes each line in order
print("First line executes")
print("Second line executes")
print("Third line executes")

# You can do calculations directly
print(2 + 2)
print(100 / 4)

Output

Click "Run" to execute the code

Next: Variables & Types

3. Variables and Data Types

In physics, we work with quantities like mass, velocity, and temperature. In Python, we store these values using variables.

What is a Variable?

A variable is like a labelled container where you can store a piece of information. When you create a variable, you're telling Python: "remember this value and give it this name so I can use it later."

Why do we need variables? Consider calculating kinetic energy: KE = ½mv². Without variables, you'd have to type the actual numbers every time. With variables, you can write:

Store the mass in a variable called mass
Store the velocity in a variable called velocity
Calculate 0.5 * mass * velocity**2

If you want to calculate for a different mass, just change the variable's value—you don't have to rewrite the formula!

Creating Variables (Assignment)

You create a variable using the assignment operator =. This is different from the equals sign in mathematics! In programming:

= means "store the value on the right into the variable on the left"
The variable name goes on the left
The value you want to store goes on the right

Python reads mass = 70.0 as "create a variable called 'mass' and store the value 70.0 in it."

Python

# Creating variables - give them descriptive names!
# The = sign assigns the value on the right to the variable on the left
mass = 70.0           # Mass in kilograms
velocity = 15.0       # Velocity in m/s
time = 2.5            # Time in seconds

# Now we can use these variables in calculations
# Python will substitute the stored values automatically
distance = velocity * time

# Display the results
# print() can take multiple items separated by commas
print("Mass:", mass, "kg")
print("Velocity:", velocity, "m/s")
print("Time:", time, "s")
print("Distance travelled:", distance, "m")

Output

Click "Run" to execute the code

Naming Variables

Good variable names make your code readable:

Use descriptive names: velocity is better than v
Names can contain letters, numbers, and underscores: initial_velocity
Names must start with a letter, not a number
Python is case-sensitive: Mass and mass are different variables
Avoid using Python keywords like print, if, for

Data Types: What Kind of Value is This?

Every value in Python has a type that tells Python what kind of data it is and what operations make sense for it. You wouldn't try to divide a person's name by 2, right? Types help Python understand what it can do with each value.

The type() function tells you what type a value is. The main types you'll use in physics are:

Integers (int) — Whole Numbers

Integers are whole numbers without any decimal point: ... -3, -2, -1, 0, 1, 2, 3 ... Use integers for things you count: number of particles, iterations in a simulation, quantum numbers.

Python

# Integers - whole numbers
num_particles = 1000
iterations = 50
quantum_number = 3

print("Number of particles:", num_particles)
print("Type:", type(num_particles))

Output

Click "Run" to execute the code

Floats (float) — Decimal Numbers

Floats (short for "floating-point numbers") are numbers with decimal points. This is your workhorse type for physics—nearly every physical quantity (mass, velocity, energy, etc.) is a float. The "floating point" refers to how the computer stores the decimal point position internally.

Scientific notation: For very large or small numbers, use e notation. Writing 2.998e8 means 2.998 × 10⁸ (299,800,000). Writing 6.626e-34 means 6.626 × 10⁻³⁴.

Python

# Floats - numbers with decimals
temperature = 293.15    # Kelvin
wavelength = 550.0      # nanometers
acceleration = 9.81     # m/s²

# Scientific notation for very large or small numbers
# The 'e' means "times 10 to the power of"
speed_of_light = 2.998e8        # 2.998 × 10⁸ m/s
planck_constant = 6.626e-34     # 6.626 × 10⁻³⁴ J·s
electron_mass = 9.109e-31       # 9.109 × 10⁻³¹ kg

print("Speed of light:", speed_of_light, "m/s")
print("Planck constant:", planck_constant, "J·s")
print("Type:", type(speed_of_light))

Output

Click "Run" to execute the code

Strings (str) — Text

Strings represent text—any sequence of characters. You create a string by enclosing text in quotation marks (either single ' or double " work identically). Use strings for experiment names, file paths, units, labels, and output messages.

f-strings: A special feature called "formatted strings" or "f-strings" lets you embed variable values directly into text. Just put an f before the opening quote and put variable names inside curly braces {}.

Python

# Strings - text in quotes (single or double work the same)
experiment_name = "Projectile Motion Lab"
units = 'meters per second'
formula = "E = mc²"

print(experiment_name)
print("Units:", units)
print("Famous formula:", formula)

# f-strings: put 'f' before the quote, then {variable} inserts the value
distance = 100.5
velocity = 25.0
print(f"The distance is {distance} meters")
print(f"At {velocity} m/s, you would travel {distance} m")

Output

Click "Run" to execute the code

Booleans (bool) — True or False

Booleans have only two possible values: True or False (note the capital letters!). They're named after mathematician George Boole. Booleans are essential for making decisions in your code—"Should I continue the simulation? Has the projectile hit the ground?"

You can create booleans directly, or they're produced when you compare values (we'll use this lots in the Conditionals section).

Python

# Booleans - True or False (note the capitals!)
is_moving = True
has_reached_target = False
simulation_complete = False

print("Is the object moving?", is_moving)
print("Has it reached the target?", has_reached_target)

# Comparisons produce booleans automatically
# The < symbol means "less than"
speed = 25
speed_limit = 30
print("Is speed under limit?", speed < speed_limit)
print("Type of comparison result:", type(speed < speed_limit))

Output

Click "Run" to execute the code

Next: Operators

4. Operators

Operators are special symbols that tell Python to perform calculations or comparisons. Just like in mathematics, operators work on values (called operands) to produce a result. You'll use these constantly for physics calculations.

Arithmetic Operators

Arithmetic operators perform mathematical calculations. Here's the complete list:

+ Addition: adds two numbers
- Subtraction: subtracts the second from the first
* Multiplication: multiplies two numbers
/ Division: divides the first by the second (always returns a float)
// Integer division: divides and rounds down to whole number
% Modulo: returns the remainder after division
** Exponent: raises to a power (e.g., 2**3 = 2³ = 8)

Important: Multiplication and Powers

Python uses * for multiplication (not × or ·) and ** for powers (not ^). So x² is written as x**2, not x^2!

Python

# Basic arithmetic - note the Python symbols!
a = 10
b = 3

print("Addition: 10 + 3 =", a + b)
print("Subtraction: 10 - 3 =", a - b)
print("Multiplication: 10 * 3 =", a * b)  # Use * not ×
print("Division: 10 / 3 =", a / b)         # Always gives float
print("Integer division: 10 // 3 =", a // b)   # Rounds down
print("Modulo (remainder): 10 % 3 =", a % b)   # Useful for cycles!
print("Exponent: 10 ** 3 =", a ** b)           # Use ** not ^

Output

Click "Run" to execute the code

Physics Calculations

Let's put operators to work with real physics formulas. Notice how we translate mathematical notation into Python:

KE = ½mv² becomes 0.5 * mass * velocity**2
E = mc² becomes m * c**2
F = GMm/r² becomes G * M * m / r**2

Python

# Physics formulas translated to Python

# Kinetic energy: KE = ½mv²
# Note: ½ becomes 0.5, and v² becomes velocity**2
mass = 70        # kg
velocity = 10    # m/s
KE = 0.5 * mass * velocity**2
print(f"Kinetic Energy: {KE} Joules")

# Einstein's mass-energy: E = mc²
c = 2.998e8     # speed of light, m/s
m = 0.001       # 1 gram in kg
E = m * c**2    # c squared = c**2
print(f"Energy in 1g of matter: {E:.2e} Joules")

# Gravitational force: F = GMm/r²
G = 6.674e-11   # gravitational constant
M = 5.972e24    # Earth mass, kg
m = 70          # person mass, kg
r = 6.371e6     # Earth radius, m
F = G * M * m / r**2  # Division happens after multiplications
print(f"Weight on Earth: {F:.1f} Newtons")

Output

Click "Run" to execute the code

Comparison Operators

Comparison operators compare two values and return a boolean (True or False). These are essential for making decisions in your code.

> Greater than: is the left bigger than the right?
< Less than: is the left smaller than the right?
>= Greater than or equal
<= Less than or equal
== Equal to: are they the same? (note: two equals signs!)
!= Not equal to: are they different?

Important: = vs ==

A very common mistake! Use = for assignment (storing a value) and == for comparison (checking if equal). x = 5 stores 5 in x. x == 5 checks if x equals 5.

Python

x = 10
y = 5

print("x > y (greater than):", x > y)
print("x < y (less than):", x < y)
print("x >= y (greater or equal):", x >= y)
print("x <= y (less or equal):", x <= y)
print("x == y (equal to):", x == y)      # Note: == for comparison
print("x != y (not equal to):", x != y)

# Physics example: is speed below limit?
speed = 25
limit = 30
print("Under speed limit?", speed < limit)

Output

Click "Run" to execute the code

Logical Operators

Logical operators let you combine multiple conditions into one. Think of them as the words "and", "or", and "not" in English:

and: Both must be True — Returns True only if both conditions are True. Like saying "I need fuel AND good weather to launch."
or: At least one must be True — Returns True if either condition is True. Like saying "I'll eat pizza OR pasta."
not: Flips the value — Returns the opposite: True becomes False, False becomes True.

Python

# Logical operators for combining conditions

# 'and' - ALL conditions must be True
temperature_ok = True
pressure_ok = True
fuel_sufficient = True

# For launch, we need ALL conditions met
can_launch = temperature_ok and pressure_ok and fuel_sufficient
print("Launch approved (all True):", can_launch)

# 'or' - AT LEAST ONE condition must be True
sensor1_working = True
sensor2_working = False
# We only need one working sensor for system to function
system_operational = sensor1_working or sensor2_working
print("System works (at least one True):", system_operational)

# 'not' - flips True to False and vice versa
is_safe = True
is_dangerous = not is_safe  # Flips True to False
print("Is dangerous:", is_dangerous)

Output

Click "Run" to execute the code

Next: Data Structures

5. Data Structures: Lists, Tuples, and Dictionaries

So far, we've stored single values in variables—one mass, one velocity, one time. But in real physics experiments, you rarely work with just one number. You might have:

100 temperature readings taken every second
Positions of 50 particles in a simulation
Properties of multiple elements (mass, charge, radius)

Data structures are containers that hold multiple values. Python provides several types, each suited for different situations.

Lists: Ordered, Changeable Collections

A list is the most commonly used data structure in Python. Think of it as a numbered container that can hold many items in a specific order.

Created with square brackets: [item1, item2, item3]
Ordered: Items stay in the order you put them
Mutable: You can add, remove, or change items after creation
Indexed: Access items by their position number (starting from 0!)

Python

# Creating lists - use square brackets []
time_data = [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
position_data = [0.0, 1.2, 4.9, 11.0, 19.6, 30.6, 44.1]

# Access items by index (IMPORTANT: starts from 0!)
# Index:      0     1     2     3     4     5     6
print("First time value (index 0):", time_data[0])
print("Third position (index 2):", position_data[2])
print("Last position (index -1):", position_data[-1])  # -1 means last

# len() gives the number of items
print("Number of measurements:", len(time_data))

# append() adds a new item to the end
time_data.append(3.5)
position_data.append(60.0)
print("After adding data:", len(time_data), "points")

Output

Click "Run" to execute the code

Important: Indexing Starts at 0

In Python, the first item has index 0, the second has index 1, and so on. This is different from some other languages and takes getting used to!

List Operations

Python

# More list operations
measurements = [23.5, 24.1, 22.8, 25.0, 24.7]

# Calculate statistics
print("All measurements:", measurements)
print("Sum:", sum(measurements))
print("Average:", sum(measurements) / len(measurements))
print("Maximum:", max(measurements))
print("Minimum:", min(measurements))

# Slicing: get a portion of the list
print("First three:", measurements[0:3])    # Index 0, 1, 2
print("Last two:", measurements[-2:])       # Last two items

# Modify an item
measurements[0] = 23.6
print("After correction:", measurements)

Output

Click "Run" to execute the code

Tuples: Ordered, Unchangeable Collections

A tuple is like a list, but immutable—once created, you cannot change it. Use tuples for data that should never be modified, like physical constants or fixed coordinates. Tuples use parentheses ().

Python

# Tuples for fixed data
particle_position = (10.5, -3.0, 0.0)  # (x, y, z) coordinates
origin = (0, 0, 0)

print("Particle position:", particle_position)
print("X coordinate:", particle_position[0])
print("Y coordinate:", particle_position[1])
print("Z coordinate:", particle_position[2])

# Tuple unpacking - very useful!
x, y, z = particle_position
print(f"Unpacked: x={x}, y={y}, z={z}")

# This would cause an error - tuples are immutable:
# particle_position[0] = 5.0  # TypeError!

Output

Click "Run" to execute the code

Dictionaries: Key-Value Pairs

A dictionary stores data as key-value pairs. Instead of accessing items by position, you look them up by their key (like a word in a dictionary). This is perfect for storing properties of objects.

Python

# Dictionary for particle properties
proton = {
    "name": "Proton",
    "symbol": "p",
    "mass_kg": 1.6726e-27,
    "charge_C": 1.6022e-19,
    "spin": 0.5
}

# Access by key
print("Particle:", proton["name"])
print("Mass:", proton["mass_kg"], "kg")
print("Charge:", proton["charge_C"], "C")

# Add new properties
proton["baryon_number"] = 1
print("Baryon number:", proton["baryon_number"])

# Loop through all properties
print("\nAll properties:")
for key, value in proton.items():
    print(f"  {key}: {value}")

Output

Click "Run" to execute the code

Exercise

Create a dictionary for an electron with properties: name, symbol, mass_kg (9.109e-31), charge_C (-1.6022e-19), and spin (0.5). Print its mass.

Next: Conditionals

6. Conditional Statements

So far, our programs run every line of code from top to bottom. But what if we want our code to make decisions? For example:

"If the temperature exceeds 373K, water is boiling"
"If the velocity is negative, the object is moving backward"
"If all launch conditions are met, proceed with launch"

Conditional statements let your code take different paths depending on whether a condition is True or False. This is one of the most powerful concepts in programming!

The if Statement

The if statement is the simplest conditional. It says: "if this condition is True, run this block of code."

Syntax rules:

Start with the keyword if
Follow with a condition (something that evaluates to True or False)
End the line with a colon :
Indent the code block that should run if the condition is True

Python

# Simple if statement
temperature = 373.15  # Kelvin

if temperature >= 373.15:
    print("Water is boiling!")
    print("Steam is being produced.")

print("This always runs (not indented under if)")

Output

Click "Run" to execute the code

Indentation Matters!

Python uses indentation (typically 4 spaces) to define code blocks. All lines at the same indentation level belong to the same block. This is different from languages that use braces {}.

if...else Statements

Use else to specify what happens when the condition is False:

Python

# if...else for binary decisions
velocity = 15.0  # m/s

if velocity > 0:
    print("Object is moving forward")
else:
    print("Object is stationary or moving backward")

# Another example: escape velocity check
escape_velocity = 11186  # m/s for Earth
rocket_speed = 12000     # m/s

if rocket_speed >= escape_velocity:
    print("Rocket will escape Earth's gravity!")
else:
    print(f"Need {escape_velocity - rocket_speed} m/s more to escape")

Output

Click "Run" to execute the code

if...elif...else for Multiple Conditions

When you have more than two possibilities, use elif (short for "else if"):

Python

# Classify matter by temperature (water at 1 atm)
temperature = 50  # Celsius

if temperature <= 0:
    state = "solid (ice)"
elif temperature < 100:
    state = "liquid (water)"
else:
    state = "gas (steam)"

print(f"At {temperature}°C, water is {state}")

# Classify projectile motion
vertical_velocity = 0  # m/s (try changing this!)

if vertical_velocity > 0:
    print("Projectile is rising")
elif vertical_velocity < 0:
    print("Projectile is falling")
else:
    print("Projectile is at its apex (peak height)")

Output

Click "Run" to execute the code

Combining Conditions

Python

# Rocket launch criteria
temperature = 25        # degrees C
wind_speed = 10         # km/h
fuel_level = 95         # percent

temp_ok = 10 <= temperature <= 35  # Between 10 and 35°C
wind_ok = wind_speed < 30
fuel_ok = fuel_level >= 90

if temp_ok and wind_ok and fuel_ok:
    print("All systems GO! Launch approved.")
else:
    print("Launch SCRUBBED. Issues detected:")
    if not temp_ok:
        print(f"  - Temperature {temperature}°C out of range")
    if not wind_ok:
        print(f"  - Wind speed {wind_speed} km/h too high")
    if not fuel_ok:
        print(f"  - Fuel level {fuel_level}% insufficient")

Output

Click "Run" to execute the code

Next: Loops

7. Loops: Repeating Operations

Imagine you need to calculate position at 1000 different time points, or check conditions for 50 particles. Writing 1000 or 50 lines of code would be tedious! Loops solve this by letting you repeat a block of code multiple times.

There are two main types of loops:

for loops: Use when you know how many times to repeat ("do this 10 times" or "do this for each item in a list")
while loops: Use when you repeat until a condition becomes false ("keep going until y < 0")

for Loops: Known Number of Iterations

A for loop iterates over a sequence (like a list or range of numbers) and runs the indented code block once for each item. The syntax is:

for variable in sequence:
    # code to repeat (indented)

Each time through the loop, variable takes on the next value from the sequence. The range() function is commonly used to generate number sequences.

Python

# range(n) generates 0, 1, 2, ..., n-1
print("Counting with range(5):")
for i in range(5):
    print(i)

# range(start, stop) goes from start to stop-1
print("\nrange(2, 7):")
for i in range(2, 7):
    print(i)

# range(start, stop, step) with custom step
print("\nrange(0, 10, 2) - even numbers:")
for i in range(0, 10, 2):
    print(i)

Output

Click "Run" to execute the code

Iterating Over Lists

Python

# Loop directly over list items
wavelengths = [400, 500, 600, 700]  # nm (visible light)
print("Visible light wavelengths:")
for wavelength in wavelengths:
    print(f"  {wavelength} nm")

# Using enumerate to get both index and value
print("\nWith indices:")
for i, wavelength in enumerate(wavelengths):
    print(f"  [{i}] {wavelength} nm")

Output

Click "Run" to execute the code

Physics Example: Projectile Motion

Python

# Simulate projectile height at each second
v0 = 20   # initial velocity, m/s
g = 9.81  # gravity, m/s²

print("Projectile Motion: y = v₀t - ½gt²")
print("-" * 35)
print("Time (s) | Height (m)")
print("-" * 35)

for t in range(6):  # t = 0, 1, 2, 3, 4, 5
    y = v0 * t - 0.5 * g * t**2
    print(f"   {t}     |   {y:6.2f}")

Output

Click "Run" to execute the code

while Loops: Condition-Based Iteration

Use while loops when you don't know in advance how many iterations you need—continue until a condition becomes False.

Python

# Simulate until projectile hits ground
v0 = 20     # initial velocity, m/s
g = 9.81    # gravity
t = 0       # time
dt = 0.1    # time step
y = 0       # height

print("Simulating until projectile hits ground...")
while y >= 0:
    t += dt
    y = v0 * t - 0.5 * g * t**2

# We went one step past landing
landing_time = t - dt
print(f"Projectile landed after {landing_time:.2f} seconds")

# Compare with analytical solution
analytical = 2 * v0 / g
print(f"Analytical solution: {analytical:.2f} seconds")

Output

Click "Run" to execute the code

break and continue

Python

# break: exit loop early
print("Finding first wavelength > 550nm:")
wavelengths = [400, 450, 500, 550, 600, 650, 700]
for w in wavelengths:
    if w > 550:
        print(f"Found: {w} nm")
        break  # Stop searching
    print(f"  Checking {w} nm...")

# continue: skip to next iteration
print("\nPrinting only even time steps:")
for t in range(10):
    if t % 2 != 0:  # Skip odd numbers
        continue
    print(f"t = {t}")

Output

Click "Run" to execute the code

Next: Functions

8. Functions: Reusable Code

A function is a named block of code that performs a specific task. Functions let you write code once and reuse it many times—essential for physics where you repeatedly apply the same formulas.

Defining Functions

You define a function with the def keyword, followed by the function name, parameters in parentheses, and a colon. The function body is indented.

Python

# Define a function
def greet(name):
    """This is a docstring - describes what the function does."""
    print(f"Hello, {name}!")

# Call (use) the function
greet("Physicist")
greet("Student")

# Functions can have multiple parameters
def describe_particle(name, mass, charge):
    print(f"{name}: mass={mass} kg, charge={charge} C")

describe_particle("Electron", 9.109e-31, -1.602e-19)
describe_particle("Proton", 1.673e-27, 1.602e-19)

Output

Click "Run" to execute the code

Return Values

Functions can compute and return a value for use elsewhere:

Python

# Function that returns a value
def kinetic_energy(mass, velocity):
    """Calculate kinetic energy: KE = ½mv²"""
    return 0.5 * mass * velocity**2

# Use the returned value
car_mass = 1500  # kg
car_speed = 25   # m/s
KE = kinetic_energy(car_mass, car_speed)
print(f"Car's kinetic energy: {KE} J")

# Use directly in expressions
print(f"Truck KE: {kinetic_energy(5000, 20)} J")

# Return multiple values (as a tuple)
def motion_quantities(v0, t, g=9.81):
    """Calculate height and velocity for vertical motion."""
    height = v0 * t - 0.5 * g * t**2
    velocity = v0 - g * t
    return height, velocity

h, v = motion_quantities(20, 1.5)
print(f"At t=1.5s: height={h:.2f}m, velocity={v:.2f}m/s")

Output

Click "Run" to execute the code

Default Parameters

Python

import math

def gravitational_force(m1, m2, r, G=6.674e-11):
    """Calculate gravitational force. G has a default value."""
    return G * m1 * m2 / r**2

# Using default G (Earth-Moon)
F_moon = gravitational_force(5.97e24, 7.35e22, 3.84e8)
print(f"Earth-Moon force: {F_moon:.2e} N")

def projectile_range(v0, angle_deg, g=9.81):
    """Calculate projectile range. g defaults to Earth gravity."""
    angle_rad = math.radians(angle_deg)
    return (v0**2 * math.sin(2 * angle_rad)) / g

# Range on Earth
range_earth = projectile_range(50, 45)
print(f"Range on Earth (45°, 50m/s): {range_earth:.1f} m")

# Range on Moon (g = 1.62 m/s²)
range_moon = projectile_range(50, 45, g=1.62)
print(f"Range on Moon (45°, 50m/s): {range_moon:.1f} m")

Output

Click "Run" to execute the code

Why Functions Matter

Reusability: Write formulas once, use many times
Organization: Break complex problems into smaller pieces
Debugging: Test and fix each function independently
Readability: kinetic_energy(m, v) is clearer than 0.5 * m * v**2

Next: Error Handling

9. Error Handling

Errors happen—invalid input, division by zero, files not found. Instead of letting your program crash, you can handle errors gracefully using try...except blocks.

Common Error Types

Python

# This would cause a ZeroDivisionError if we divided by zero
# This would cause a TypeError if we added a string to a number
# This would cause a ValueError if we converted "abc" to int

# Let's demonstrate error types (safely!)
errors = [
    "ZeroDivisionError: 5/0 - dividing by zero",
    "TypeError: 'hello' + 5 - mixing incompatible types",
    "ValueError: int('abc') - invalid conversion",
    "IndexError: list[100] - index out of range",
    "KeyError: dict['missing'] - key not in dictionary"
]

print("Common Python Errors:")
for error in errors:
    print(f"  • {error}")

Output

Click "Run" to execute the code

try...except Blocks

Put risky code in a try block. If an error occurs, Python jumps to the matching except block instead of crashing.

Python

# Calculate resistance R = V/I
def calculate_resistance(voltage, current_str):
    try:
        current = float(current_str)
        resistance = voltage / current
        print(f"Resistance: {resistance:.2f} Ohms")
    except ValueError:
        print("Error: Current must be a number!")
    except ZeroDivisionError:
        print("Error: Current cannot be zero (infinite resistance)")

# Test with different inputs
print("Test 1: Valid input")
calculate_resistance(12, "2")

print("\nTest 2: Zero current")
calculate_resistance(12, "0")

print("\nTest 3: Invalid input")
calculate_resistance(12, "abc")

Output

Click "Run" to execute the code

Handling Multiple Errors

Python

def safe_wavelength_to_frequency(wavelength_nm):
    """Convert wavelength to frequency, handling errors."""
    c = 2.998e8  # speed of light, m/s
    
    try:
        wavelength_m = float(wavelength_nm) * 1e-9
        if wavelength_m <= 0:
            raise ValueError("Wavelength must be positive")
        frequency = c / wavelength_m
        return frequency
    except (ValueError, TypeError) as e:
        print(f"Error: {e}")
        return None

# Test cases
print("550 nm:", safe_wavelength_to_frequency(550))
print("-100 nm:", safe_wavelength_to_frequency(-100))
print("'blue':", safe_wavelength_to_frequency("blue"))

Output

Click "Run" to execute the code

Next: Working with Files

10. Working with Files

In physics, you'll often need to save simulation results or read experimental data from files. Python makes file I/O straightforward.

Note

File operations shown here are simulated in this browser environment. On your local Python installation, these would create real files.

Writing Files

Use open() with mode 'w' to write. The with statement ensures the file is properly closed.

Python

# Simulating file writing
# In a real script, this would create an actual file

# Generate simulation data
data_lines = []
data_lines.append("Time(s),Height(m),Velocity(m/s)")  # Header

v0 = 20
g = 9.81
for t in range(6):
    h = v0 * t - 0.5 * g * t**2
    v = v0 - g * t
    data_lines.append(f"{t},{h:.2f},{v:.2f}")

# Display what would be written
print("Content of 'projectile_data.csv':")
print("-" * 35)
for line in data_lines:
    print(line)
print("-" * 35)
print("(In a real script, this would be saved to disk)")

Output

Click "Run" to execute the code

Reading Files

Python

# Simulating reading a CSV file
# In real code: with open("data.csv", "r") as f:

# Pretend we read this from a file:
file_content = """Time(s),Position(m),Velocity(m/s)
0,0.0,20.0
1,15.1,10.2
2,20.4,0.4
3,15.9,-9.4
4,1.6,-19.2"""

print("Reading experimental data:")
print("-" * 40)

lines = file_content.strip().split("\n")
header = lines[0].split(",")
print(f"Columns: {header}")

# Parse data
times = []
positions = []
for line in lines[1:]:
    t, pos, vel = line.split(",")
    times.append(float(t))
    positions.append(float(pos))

print(f"\nTimes: {times}")
print(f"Positions: {positions}")
print(f"Max height: {max(positions):.1f} m at t={times[positions.index(max(positions))]}s")

Output

Click "Run" to execute the code

Real-World Tip

For complex data files, use libraries like Pandas which can read CSV, Excel, and many other formats with a single line: data = pd.read_csv("file.csv")

Next: Modules & Libraries

11. Modules and Scientific Libraries

Python's real power for physics comes from its ecosystem of scientific libraries. A module is a file containing Python code you can import and use. A library or package is a collection of related modules.

The math Module

Python's built-in math module provides mathematical functions:

Python

import math

# Constants
print(f"π = {math.pi}")
print(f"e = {math.e}")

# Trigonometry (angles in radians!)
angle_deg = 45
angle_rad = math.radians(angle_deg)
print(f"\nsin(45°) = {math.sin(angle_rad):.4f}")
print(f"cos(45°) = {math.cos(angle_rad):.4f}")

# Other useful functions
print(f"\n√2 = {math.sqrt(2):.4f}")
print(f"log₁₀(1000) = {math.log10(1000)}")
print(f"e² = {math.exp(2):.4f}")

Output

Click "Run" to execute the code

Key Scientific Libraries

These are the essential libraries you'll use for physics:

NumPy: Fast numerical arrays and mathematical operations
SciPy: Scientific algorithms (integration, optimization, etc.)
Matplotlib: Plotting and visualisation
Pandas: Data analysis and manipulation

Browser Limitation

NumPy is available in this browser environment! SciPy and Matplotlib require local installation.

Using the math Module for Physics

Python

import math

# Calculate orbital velocity: v = √(GM/r)
G = 6.674e-11
M_sun = 1.989e30  # kg
r_earth = 1.496e11  # Earth-Sun distance in m

v_earth = math.sqrt(G * M_sun / r_earth)
print(f"Earth's orbital velocity: {v_earth/1000:.2f} km/s")

# Orbital period: T = 2πr/v
T_seconds = 2 * math.pi * r_earth / v_earth
T_days = T_seconds / (60 * 60 * 24)
print(f"Earth's orbital period: {T_days:.1f} days")

# De Broglie wavelength: λ = h/(mv)
h = 6.626e-34  # Planck constant
m_e = 9.109e-31  # electron mass
v_e = 2.2e6  # typical electron velocity in atom

wavelength = h / (m_e * v_e)
print(f"\nElectron de Broglie wavelength: {wavelength*1e9:.3f} nm")

Output

Click "Run" to execute the code

Next: Physics Simulations

12. Putting It All Together: Physics Simulations

Now let's combine everything you've learned to build complete physics simulations. These examples demonstrate real scientific computing.

Complete Projectile Motion Simulator

Python

import math

def simulate_projectile(v0, angle_deg, dt=0.1):
    """Complete projectile motion simulation."""
    g = 9.81
    angle_rad = math.radians(angle_deg)
    
    # Initial conditions
    vx = v0 * math.cos(angle_rad)
    vy = v0 * math.sin(angle_rad)
    x, y = 0, 0
    t = 0
    
    # Store trajectory
    trajectory = []
    max_height = 0
    
    while y >= 0:
        trajectory.append((t, x, y))
        max_height = max(max_height, y)
        
        # Update position
        x += vx * dt
        y += vy * dt
        vy -= g * dt
        t += dt
    
    range_achieved = x
    flight_time = t
    
    return trajectory, max_height, range_achieved, flight_time

# Run simulation
v0, angle = 50, 45
traj, h_max, R, T = simulate_projectile(v0, angle)

print(f"Projectile: v₀={v0}m/s, θ={angle}°")
print("=" * 40)
print(f"Maximum height: {h_max:.1f} m")
print(f"Range: {R:.1f} m")
print(f"Flight time: {T:.2f} s")
print(f"\nTrajectory ({len(traj)} points):")
for t, x, y in traj[::5]:  # Every 5th point
    print(f"  t={t:.1f}s: ({x:.1f}, {y:.1f}) m")

Output

Click "Run" to execute the code

Simple Harmonic Oscillator

Python

import math

def harmonic_oscillator(A, omega, phi, t_max, dt=0.1):
    """Simulate simple harmonic motion: x(t) = A*cos(ωt + φ)"""
    results = []
    t = 0
    
    while t <= t_max:
        x = A * math.cos(omega * t + phi)
        v = -A * omega * math.sin(omega * t + phi)
        
        # Energy conservation check
        KE = 0.5 * v**2  # Using m = 1. Actual KE = ½mv²
        PE = 0.5 * omega**2 * x**2  # PE = ½kx², k = mω²
        E_total = KE + PE
        
        results.append((t, x, v, E_total))
        t += dt
    
    return results

# Parameters
A = 0.1       # Amplitude (m)
omega = 2.0   # Angular frequency (rad/s)
phi = 0       # Initial phase
T = 2 * math.pi / omega  # Period

print(f"Simple Harmonic Motion: x(t) = {A}·cos({omega}t)")
print(f"Period T = {T:.2f} s")
print("=" * 50)
print("Time(s) | Position(m) | Velocity(m/s) | Energy")
print("-" * 50)

data = harmonic_oscillator(A, omega, phi, 5)
for t, x, v, E in data[::5]:
    print(f"  {t:5.1f} |   {x:+7.4f}  |    {v:+7.4f}   | {E:.6f}")

Output

Click "Run" to execute the code

Orbital Mechanics Calculator

Python

import math

def orbital_mechanics(M, r):
    """Calculate orbital parameters for circular orbit around mass M at radius r."""
    G = 6.674e-11
    
    v = math.sqrt(G * M / r)  # Orbital velocity
    T = 2 * math.pi * r / v   # Period
    a = v**2 / r              # Centripetal acceleration
    
    return {"velocity": v, "period": T, "acceleration": a}

# Solar system data
sun_mass = 1.989e30  # kg

planets = {
    "Mercury": {"r": 5.79e10, "actual_T_days": 88},
    "Venus":   {"r": 1.08e11, "actual_T_days": 225},
    "Earth":   {"r": 1.50e11, "actual_T_days": 365},
    "Mars":    {"r": 2.28e11, "actual_T_days": 687},
    "Jupiter": {"r": 7.78e11, "actual_T_days": 4333}
}

print("Solar System Orbital Mechanics")
print("=" * 65)
print(f"{'Planet':<10} {'v (km/s)':>10} {'T (days)':>12} {'Actual T':>10} {'Error':>8}")
print("-" * 65)

for planet, data in planets.items():
    params = orbital_mechanics(sun_mass, data["r"])
    v_kms = params["velocity"] / 1000
    T_days = params["period"] / (24 * 3600)
    error_pct = abs(T_days - data["actual_T_days"]) / data["actual_T_days"] * 100
    print(f"{planet:<10} {v_kms:>10.2f} {T_days:>12.1f} {data['actual_T_days']:>10} {error_pct:>7.1f}%")

Output

Click "Run" to execute the code

Numerical Integration: Euler Method

Python

import math

def euler_integration_with_drag(m, v0, b, dt, t_max):
    """Euler method for projectile with air resistance.
    ma = -mg - b*v (drag proportional to velocity)
    """
    g = 9.81
    
    # Initial conditions
    y = 0
    v = v0
    t = 0
    
    results = []
    
    while y >= 0 and t < t_max:
        results.append((t, y, v))
        
        # Acceleration (gravity + drag)
        a = -g - (b/m) * v
        
        # Euler update
        v = v + a * dt
        y = y + v * dt
        t = t + dt
    
    return results

# Compare with and without drag
m = 1.0      # mass (kg)
v0 = 50.0    # initial velocity (m/s)
dt = 0.01    # time step

# Without drag
no_drag = euler_integration_with_drag(m, v0, 0, dt, 15)
# With drag
with_drag = euler_integration_with_drag(m, v0, 0.2, dt, 15)

print("Effect of Air Resistance (Euler Method)")
print("=" * 50)
print(f"Initial velocity: {v0} m/s, Mass: {m} kg")
print(f"\nWithout drag: Max height ≈ {max(y for t,y,v in no_drag):.1f} m")
print(f"With drag (b=0.2): Max height ≈ {max(y for t,y,v in with_drag):.1f} m")

# Analytical max height (no drag): h = v₀²/(2g)
analytical = v0**2 / (2 * 9.81)
print(f"Analytical (no drag): {analytical:.1f} m")

Output

Click "Run" to execute the code

Congratulations!

You've completed the Interactive Python for Physicists course! You now have the skills to:

Write Python programs from scratch
Work with variables, data structures, and functions
Implement loops and conditional logic
Handle errors gracefully
Build physics simulations

Keep practising by modifying the examples above—change parameters, add features, and explore!

View Reference Guide