1. Introduction to Python

Welcome to this comprehensive Python tutorial! This course is designed for complete beginners with no prior programming experience. By the end, you'll be able to write Python programs to analyse pregnancy and health data.

What is Python?

Python is a programming language—a way for humans to give instructions to computers. Think of it like learning a new language, except instead of communicating with people, you're communicating with a computer.

Python is special because:

It reads like English: Python code is designed to be readable. Even without training, you can often guess what Python code does just by reading it.
It's "interpreted": You can run your code line by line and see immediate results, which makes learning and fixing mistakes (called "debugging") much faster.
It's beginner-friendly: Python allows you to write powerful programs with very few lines of code, so you can focus on solving problems rather than fighting the language.
It's widely used: Python is the #1 language for data science, machine learning, and scientific research. Skills you learn here are directly applicable to real jobs.

Key Terminology

Code: The instructions you write for the computer.
Program: A complete set of code that performs a task.
Run/Execute: Tell the computer to follow your instructions.
Output: What the computer shows you after running your code.

Why Use Python for Pregnancy & Health Data?

While pregnancy is a personal journey, understanding it on a larger scale involves analysing data. Public health officials, researchers, and clinicians analyse data to find patterns, understand risks, and improve care for mothers and babies.

Python is the leading language for this because:

Powerful Data Tools: Libraries (pre-written code packages) like Pandas and Matplotlib make it simple to clean, organise, analyse, and visualise large datasets of patient information.
Reproducibility: A Python script provides a clear, repeatable set of steps for an analysis. This is crucial for scientific validity—other researchers can run your exact analysis and verify your results.
Automation: You can write scripts to automate repetitive tasks, like processing patient records or generating weekly reports, saving time and reducing human error.
Free and Open Source: Python is completely free to use. There are no licensing fees, making it accessible to everyone.

Throughout This Tutorial

We'll work with real-world examples including: maternal age tracking, gestational age calculations, trimester classification, birth weight classification, blood pressure monitoring, APGAR score analysis, and due date calculations.

How This Tutorial Works

This is an interactive tutorial. Each lesson contains:

Explanations: Clear descriptions of each concept in plain language.
Code Examples: Real Python code you can see, edit, and run right in your browser.
Try It Yourself: Opportunities to experiment and practice what you've learned.

The code boxes below run real Python code. Click the green "Run" button to execute the code and see the results. You can also edit the code and run it again—don't worry, you can't break anything!

Your First Python Program

Let's write your first program! The print() function is one of the most basic and useful tools in Python. It displays text (or numbers) on the screen. Whatever you put inside the parentheses will be shown as output.

Python - Your First Program

# This is a comment - it starts with #
# Comments are notes for humans and are ignored by Python

# The print() function displays text on the screen
# Text must be enclosed in quotation marks (either " or ')
print("Hello! Welcome to Python for Health Data!")
print("This is your first Python program.")
print("Congratulations on taking this step!")

Output

Click "Run" to execute the code

Understanding the Code Above

Lines starting with # are called "comments". Python ignores them completely—they're just notes to help humans understand the code.

print("...") is a "function call". Functions are like actions—print is the action of displaying something. The text inside the quotes is what gets displayed.

Try It Yourself!

Now it's your turn! In the code box below, try these exercises:

Change the message to say your name
Add another print() line with a different message
Try removing the quotation marks and see what error you get (this teaches error messages!)

Python - Try Editing This!

# Edit this code and click Run to see what happens!

print("My name is [Your Name Here]")
print("I am learning Python for health data analysis.")

Output

Click "Run" to execute the code

Python Can Do Math!

Python is excellent at performing calculations. You can use it like a very powerful calculator. Here are the basic math operations:

+ Addition (e.g., 5 + 3 gives 8)
- Subtraction (e.g., 10 - 4 gives 6)
* Multiplication (e.g., 6 * 7 gives 42)
/ Division (e.g., 15 / 3 gives 5.0)

Python - Basic Calculations

# Python as a calculator - pregnancy-related calculations

# How many weeks in a typical pregnancy?
total_days = 280
days_per_week = 7
weeks = total_days / days_per_week
print("Weeks in typical pregnancy:", weeks)

# Calculate weeks remaining if currently at week 28
current_week = 28
full_term = 40
remaining = full_term - current_week
print("Weeks remaining:", remaining)

# How many days is that?
remaining_days = remaining * 7
print("Days remaining:", remaining_days)

Output

Click "Run" to execute the code

Notice Something?

In the code above, we used words like total_days and weeks to store numbers. These are called variables—and they're the topic of our next lesson!

Getting Started Offline (Optional)

This tutorial runs Python directly in your browser, so you don't need to install anything. However, if you want to write Python on your own computer later, here are your options:

Option 1: Google Colab (Easiest - No Install)

Go to Google Colab. It's free and runs in your browser. You just need a Google account.

Option 2: VS Code + Python (Recommended for Later)

1. Download Python
2. Download VS Code
3. Install the Python extension in VS Code

Option 3: Download This Tutorial

Download the Jupyter notebook version to practice offline:
Download Python_Pregnancy_Tutorial.zip

Next: Variables & Data Types

2. Variables and Data Types

In the last lesson, we used words like total_days and weeks to store numbers. These are called variables, and they're one of the most fundamental concepts in programming.

What is a Variable?

Think of a variable as a labeled box where you can store a piece of information. The label (variable name) helps you remember what's inside, and you can look inside the box whenever you need that information.

In health data, variables might store things like:

A patient's age (e.g., maternal_age = 34)
A measurement (e.g., birth_weight_kg = 3.45)
A patient ID (e.g., patient_id = "PAT-00123")
A yes/no answer (e.g., is_first_pregnancy = True)

Creating Variables

To create a variable in Python, you use the equals sign (=). This is called "assignment"—you're assigning a value to a name.

Important: = Means "Assign", Not "Equals"

In Python, = means "store this value in this variable". It's NOT a mathematical equation. When you write age = 34, you're saying "put the value 34 into the box labeled 'age'".

Python - Creating Variables

# Creating variables is simple: name = value

# Store the patient's age
maternal_age = 34

# Store a patient ID (text needs quotation marks)
patient_id = "PAT-00123"

# Store gestational age in weeks
gestational_age_weeks = 28

# Store whether this is a first pregnancy (True or False)
is_first_pregnancy = False

# Store birth weight as a decimal number
birth_weight_kg = 3.45

# Now we can use these variables!
print("Patient Information:")
print("--------------------")
print("Patient ID:", patient_id)
print("Maternal age:", maternal_age, "years")
print("Gestational age:", gestational_age_weeks, "weeks")
print("First pregnancy:", is_first_pregnancy)
print("Birth weight:", birth_weight_kg, "kg")

Output

Click "Run" to execute the code

Variable Naming Rules

Python has some rules about what you can name your variables:

Variable Naming Rules

✓ Must start with a letter or underscore: age, _temp
✓ Can contain letters, numbers, underscores: patient_id_2
✗ Cannot start with a number: 2nd_patient is NOT valid
✗ Cannot contain spaces: Use underscores instead: birth_weight
✗ Cannot use Python keywords: Words like if, for, print

Best Practice: Use Descriptive Names!

Use names that describe what the variable contains. maternal_age is much clearer than x or ma. Your future self (and colleagues) will thank you!

Data Types: What Kind of Data?

Every variable in Python has a type that tells Python what kind of data it holds. This is important because different types can do different things. Here are the four main types:

1. Integers (int) — Whole Numbers

Numbers without decimal points. Used for things like age, counts, or gestational weeks.

Python - Integers

# Integers are whole numbers (no decimals)
maternal_age = 34
gestational_weeks = 28
number_of_previous_births = 2

# You can do math with integers
weeks_remaining = 40 - gestational_weeks
print("Patient age:", maternal_age)
print("Weeks pregnant:", gestational_weeks)
print("Weeks remaining:", weeks_remaining)
print("Type:", type(maternal_age))

Output

Click "Run" to execute the code

2. Floats (float) — Decimal Numbers

Numbers with decimal points. Used for measurements like weight, temperature, or percentages.

Python - Floats

# Floats are decimal numbers
birth_weight_kg = 3.45
body_temperature_c = 37.2
bmi = 24.8

# Math with floats
weight_in_grams = birth_weight_kg * 1000
print("Birth weight:", birth_weight_kg, "kg")
print("Birth weight:", weight_in_grams, "grams")
print("Type:", type(birth_weight_kg))

Output

Click "Run" to execute the code

3. Strings (str) — Text

Text data enclosed in quotation marks. Used for names, IDs, notes, or any text.

Python - Strings

# Strings are text - must use quotes!
patient_name = "Jane Smith"     # Double quotes work
patient_id = 'PAT-00123'        # Single quotes also work
blood_type = "O+"
notes = "Patient reports normal fetal movement."

# You can combine (concatenate) strings with +
full_info = patient_name + " - " + patient_id
print("Patient:", full_info)
print("Blood type:", blood_type)
print("Notes:", notes)
print("Type:", type(patient_name))

Output

Click "Run" to execute the code

4. Booleans (bool) — True/False

Values that can only be True or False. Perfect for yes/no questions.

Python - Booleans

# Booleans are True or False (note the capital letters!)
is_first_pregnancy = True
has_gestational_diabetes = False
is_high_risk = True

# Booleans often come from comparisons
maternal_age = 38
is_advanced_maternal_age = maternal_age >= 35  # Is age 35 or more?

print("First pregnancy?", is_first_pregnancy)
print("Has gestational diabetes?", has_gestational_diabetes)
print("Age:", maternal_age)
print("Advanced maternal age (35+)?", is_advanced_maternal_age)
print("Type:", type(is_first_pregnancy))

Output

Click "Run" to execute the code

Operators: Doing Things with Variables

Now that you know how to store data, let's learn how to work with it using operators.

Arithmetic Operators (Math)

Python - Math Operators

# Math operators in Python
gestational_days = 196

# Division: days to weeks
weeks = gestational_days / 7
print(f"{gestational_days} days = {weeks} weeks")

# Integer division: whole weeks only (// drops the decimal)
whole_weeks = gestational_days // 7
print(f"Complete weeks: {whole_weeks}")

# Modulo: remaining days after complete weeks
remaining_days = gestational_days % 7
print(f"Plus {remaining_days} extra days")

# So: 196 days = 28 weeks and 0 days

Output

Click "Run" to execute the code

Comparison Operators

Comparison operators compare two values and return True or False:

Python - Comparison Operators

# Comparison operators return True or False
birth_weight_g = 2400
maternal_age = 38

# Is the weight less than 2500g (low birth weight)?
is_low_weight = birth_weight_g < 2500
print(f"Weight {birth_weight_g}g - Low birth weight? {is_low_weight}")

# Is the age 35 or greater?
is_advanced_age = maternal_age >= 35
print(f"Age {maternal_age} - Advanced maternal age? {is_advanced_age}")

# Is the weight exactly 2500?
is_exactly_2500 = birth_weight_g == 2500  # Note: == for comparison!
print(f"Weight exactly 2500g? {is_exactly_2500}")

# Is the weight NOT low?
is_not_low = birth_weight_g >= 2500
print(f"Weight is NOT low? {is_not_low}")

Output

Click "Run" to execute the code

= vs ==

= means "assign a value" (put something in a variable)
== means "is equal to?" (compare two values)

This is a common source of confusion for beginners!

F-Strings: Easy Text Formatting

You've seen f"..." in some examples. These are called f-strings (formatted strings), and they're the easiest way to combine text with variables:

Python - F-Strings

# F-strings let you embed variables inside text
patient_name = "Jane Smith"
age = 34
weight_kg = 3.456

# Put an f before the quotes, then use {variable_name}
print(f"Patient: {patient_name}")
print(f"Age: {age} years")

# You can even do math inside the braces!
print(f"Weight: {weight_kg * 1000} grams")

# Format decimals: :.2f means 2 decimal places
print(f"Weight (formatted): {weight_kg:.2f} kg")

Output

Click "Run" to execute the code

Next: Data Structures

3. Data Structures: Lists and Dictionaries

So far we've stored single values in variables. But what if you need to track multiple blood pressure readings over time? Or store all the information about a patient in one place? That's where data structures come in.

Lists: Storing Multiple Items in Order

A list is like a numbered container that holds multiple items in a specific order. Think of it like a patient's chart where measurements are recorded chronologically.

Lists are created using square brackets [], with items separated by commas:

Python - Creating Lists

# Creating lists - use square brackets []
# List of blood pressure readings
bp_readings = ["120/80", "118/76", "125/82", "130/85"]

# List of gestational ages at check-ups (in weeks)
checkup_weeks = [12, 20, 28, 32, 36, 38, 40]

# List of daily fetal movement counts
kick_counts = [8, 12, 10, 15, 9, 11, 14]

# Lists can hold any type of data!
print("Blood pressure readings:", bp_readings)
print("Check-up weeks:", checkup_weeks)
print("Daily kick counts:", kick_counts)

Output

Click "Run" to execute the code

Accessing Items by Index

Each item in a list has a position number called an index. Important: Python counts from 0!

Lists Start at Index 0, Not 1!

The first item is at index [0], the second at index [1], and so on. This trips up many beginners!
You can also use negative indices: [-1] is the last item, [-2] is second to last.

Python - Accessing List Items

# Weekly weight measurements during pregnancy (kg)
weekly_weights = [60.2, 60.8, 61.5, 62.1, 62.9]
#                  [0]   [1]   [2]   [3]   [4]  <- Index positions

# Access by positive index (counting from start)
print("First weight (index 0):", weekly_weights[0], "kg")
print("Third weight (index 2):", weekly_weights[2], "kg")

# Access by negative index (counting from end)
print("Last weight (index -1):", weekly_weights[-1], "kg")
print("Second to last (index -2):", weekly_weights[-2], "kg")

# How many items in the list? Use len()
print("Number of measurements:", len(weekly_weights))

Output

Click "Run" to execute the code

Modifying Lists

Lists are mutable, meaning you can change them after creating them:

Python - Modifying Lists

# Start with some APGAR scores
apgar_scores = [7, 8, 9]
print("Initial scores:", apgar_scores)

# Add a new score at the end with .append()
apgar_scores.append(9)
print("After append(9):", apgar_scores)

# Change a value at a specific index
apgar_scores[0] = 8  # Change first score from 7 to 8
print("After changing index 0:", apgar_scores)

# Remove the last item with .pop()
removed = apgar_scores.pop()
print(f"Removed {removed}, now:", apgar_scores)

# Calculate statistics
print("Average score:", sum(apgar_scores) / len(apgar_scores))

Output

Click "Run" to execute the code

Common List Methods

list.append(item) - Add item to end
list.pop() - Remove and return last item
list.insert(index, item) - Insert item at position
len(list) - Get number of items
sum(list) - Add up all numbers in list
min(list) / max(list) - Get smallest/largest

Dictionaries: Labeled Data

A dictionary stores data in key-value pairs. Think of it like a patient record where each piece of information has a label (key) and a value.

Dictionaries are created using curly braces {} with key: value pairs:

Python - Creating Dictionaries

# A patient record as a dictionary
patient = {
    "name": "Jane Smith",
    "age": 32,
    "patient_id": "PAT-00456",
    "gestational_weeks": 28,
    "is_high_risk": False,
    "blood_type": "O+"
}

# Access values using their keys
print("Patient name:", patient["name"])
print("Age:", patient["age"])
print("Weeks pregnant:", patient["gestational_weeks"])
print("High risk?", patient["is_high_risk"])

Output

Click "Run" to execute the code

Why Dictionaries Are Powerful

Unlike lists where you access items by number (index 0, 1, 2...), dictionaries let you access data by meaningful names. This makes your code much more readable!

Python - Working with Dictionaries

# A newborn's birth record
newborn = {
    "birth_weight_g": 3450,
    "length_cm": 51,
    "apgar_1min": 8,
    "apgar_5min": 9,
    "delivery_type": "Vaginal",
    "birth_date": "2024-01-15"
}

# Access values by key
print("Birth Record")
print("-" * 30)
print(f"Weight: {newborn['birth_weight_g']} grams")
print(f"Length: {newborn['length_cm']} cm")
print(f"APGAR (1 min): {newborn['apgar_1min']}")
print(f"APGAR (5 min): {newborn['apgar_5min']}")
print(f"Delivery: {newborn['delivery_type']}")

# Add a new key-value pair
newborn["pediatrician"] = "Dr. Johnson"
print(f"Pediatrician: {newborn['pediatrician']}")

# Update a value
newborn["apgar_5min"] = 10  # Updated after rechecking
print(f"Updated APGAR (5 min): {newborn['apgar_5min']}")

Output

Click "Run" to execute the code

Lists vs Dictionaries: When to Use Which?

Use Lists when: You have a collection of similar items in order (e.g., weekly measurements, list of patients)
Use Dictionaries when: You have different pieces of information about one thing (e.g., a patient record with name, age, ID, etc.)

Lists of Dictionaries: Real-World Data

In real health data, you often have lists of dictionaries—multiple patient records, each containing multiple fields:

Python - Lists of Dictionaries

# Multiple patient records in a list
patients = [
    {"name": "Alice", "age": 28, "weeks": 32},
    {"name": "Bob", "age": 35, "weeks": 24},
    {"name": "Carol", "age": 31, "weeks": 38}
]

# Access the first patient
print("First patient:", patients[0]["name"])

# Loop through all patients
print("\nAll Patients:")
print("-" * 30)
for patient in patients:
    print(f"{patient['name']}, Age {patient['age']}, Week {patient['weeks']}")

Output

Click "Run" to execute the code

Next: Conditionals

4. Making Decisions: Conditional Logic

In healthcare, programs often need to make decisions: Is this blood pressure high? What trimester is this patient in? Is the birth weight concerning? Conditionals allow your program to execute different code based on whether conditions are true or false.

The if Statement

The if statement is the simplest form of conditional logic. It runs a block of code only if a condition is true:

Python - Basic if Statement

# Basic if statement
maternal_age = 38

# Check if age is 35 or above (advanced maternal age)
if maternal_age >= 35:
    print("⚠️ Advanced Maternal Age")
    print("Additional monitoring recommended")

print("Age check complete")  # This always runs

Output

Click "Run" to execute the code

Indentation is Crucial!

In Python, indentation (4 spaces or 1 tab) determines what code belongs to the if statement. The indented lines only run if the condition is true. The non-indented line at the end always runs.

This is different from many other languages—Python uses indentation instead of curly braces!

if-else: Two Paths

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

Python - if-else Statement

# if-else: two different paths
gestational_weeks = 37

if gestational_weeks < 37:
    print("Preterm (before 37 weeks)")
    print("⚠️ May require special care")
else:
    print("Term (37 weeks or later)")
    print("✓ Full development expected")

# Try changing gestational_weeks to 35 and run again!

Output

Click "Run" to execute the code

if-elif-else: Multiple Paths

Use elif (short for "else if") when you have more than two possibilities:

Python - Trimester Classification

# Classify pregnancy into trimesters
gestational_age = 28  # Try changing: 8, 15, 28, 38

print(f"Gestational age: {gestational_age} weeks")
print()

if gestational_age <= 12:
    trimester = "First Trimester (Weeks 1-12)"
    info = "Major organ development occurs"
    risk_note = "Highest risk for miscarriage"
elif gestational_age <= 27:
    trimester = "Second Trimester (Weeks 13-27)"
    info = "Baby grows rapidly, movement begins"
    risk_note = "Generally lowest risk period"
else:
    trimester = "Third Trimester (Weeks 28-40)"
    info = "Final development, preparing for birth"
    risk_note = "Monitor for preterm labor"

print(f"Stage: {trimester}")
print(f"Development: {info}")
print(f"Note: {risk_note}")

Output

Click "Run" to execute the code

How if-elif-else Works

Python checks each condition from top to bottom:
1. If the if condition is True → run that block, skip the rest
2. If False → check the first elif
3. Keep checking until one is True or you reach else
4. else runs only if ALL previous conditions were False

Birth Weight Classification

Here's a practical example classifying newborn birth weight:

Python - Birth Weight Classification

# Birth weight classification
birth_weight_g = 3200  # Try: 1200, 2200, 3200, 4300

print(f"Birth weight: {birth_weight_g} grams")
print("-" * 35)

if birth_weight_g < 1500:
    category = "Very Low Birth Weight"
    status = "🔴 NICU care likely needed"
elif birth_weight_g < 2500:
    category = "Low Birth Weight"
    status = "🟡 Close monitoring recommended"
elif birth_weight_g <= 4000:
    category = "Normal Birth Weight"
    status = "🟢 Healthy range"
else:
    category = "Macrosomia (High Birth Weight)"
    status = "🟡 Monitor for complications"

print(f"Category: {category}")
print(f"Status: {status}")

Output

Click "Run" to execute the code

Combining Conditions with and/or

Sometimes you need to check multiple conditions together:

and - Both conditions must be True
or - At least one condition must be True
not - Reverses True/False

Python - Combining Conditions

# High-risk pregnancy assessment
maternal_age = 38
has_diabetes = True
has_hypertension = False

print("Risk Assessment")
print("=" * 30)
print(f"Maternal age: {maternal_age}")
print(f"Diabetes: {has_diabetes}")
print(f"Hypertension: {has_hypertension}")
print()

# Using 'or' - true if ANY condition is met
if maternal_age >= 35 or has_diabetes or has_hypertension:
    print("⚠️ High-risk factors present")
else:
    print("✓ No high-risk factors identified")

# Using 'and' - true only if BOTH are true
if maternal_age >= 35 and has_diabetes:
    print("⚠️ Both advanced age AND diabetes - extra care needed")

Output

Click "Run" to execute the code

Practice Makes Perfect!

Try modifying the values in the examples above and running them again. Change gestational_age to different values (8, 15, 30), or change the boolean values (True/False) to see how the output changes.

Next: Loops

5. Loops: Repeating Actions

Imagine you need to analyse 100 patient records. You wouldn't want to write the same code 100 times! Loops let you repeat code automatically, making them essential for processing health data at scale.

The for Loop

The most common loop in Python is the for loop. It goes through each item in a list (or other collection) one at a time:

Python - Basic for Loop

# A simple for loop
gestational_weeks = [12, 20, 28, 32, 36, 40]

print("Prenatal Check-up Schedule:")
print("-" * 30)

for week in gestational_weeks:
    print(f"Week {week}: Scheduled appointment")

print()
print("All appointments displayed!")

Output

Click "Run" to execute the code

How the for Loop Works

for week in gestational_weeks:

1. Take the first item from the list → store it in week → run the indented code
2. Take the next item → store it in week → run the code again
3. Continue until all items have been processed

The variable name (week) can be anything you choose—but use descriptive names!

Using range() for Counting

Sometimes you want to repeat something a specific number of times. Use range():

Python - Using range()

# range(n) counts from 0 to n-1
print("Counting trimesters:")
for i in range(3):
    print(f"Trimester {i + 1}")  # Add 1 because range starts at 0

print()

# range(start, end) counts from start to end-1
print("Weeks in third trimester (28-40):")
for week in range(28, 41):  # 41 because end is exclusive
    print(f"Week {week}", end=" ")  # end=" " prints on same line

Output

Click "Run" to execute the code

range() Tips

range(5) → 0, 1, 2, 3, 4 (5 numbers, starting at 0)
range(1, 6) → 1, 2, 3, 4, 5 (from 1 up to, but not including, 6)
range(0, 10, 2) → 0, 2, 4, 6, 8 (count by 2s)

Loops with Conditionals

Combining loops with if statements is very powerful—you can check each item and respond accordingly:

Python - Loop + Conditional

# Blood pressure readings to analyze
bp_readings = ["120/80", "125/85", "142/91", "118/78", "138/88"]

print("Blood Pressure Analysis:")
print("-" * 40)

for reading in bp_readings:
    # Split into systolic/diastolic
    parts = reading.split('/')
    systolic = int(parts[0])
    diastolic = int(parts[1])
    
    # Classify based on values
    if systolic >= 140 or diastolic >= 90:
        status = "🔴 HIGH - Alert!"
    elif systolic >= 130 or diastolic >= 85:
        status = "🟡 Elevated"
    else:
        status = "🟢 Normal"
    
    print(f"{reading}: {status}")

Output

Click "Run" to execute the code

Accumulating Values in a Loop

A common pattern is to build up a result as you loop through data:

Python - Accumulating Values

# APGAR scores from multiple newborns
apgar_scores = [8, 9, 7, 9, 10, 8, 9, 7]

# Calculate statistics manually using a loop
total = 0  # Start with 0
for score in apgar_scores:
    total = total + score  # Add each score to total

# Calculate average
count = len(apgar_scores)
average = total / count

print("APGAR Score Statistics:")
print("-" * 30)
print(f"Number of newborns: {count}")
print(f"Total of all scores: {total}")
print(f"Average score: {average:.1f}")
print(f"Lowest: {min(apgar_scores)}")
print(f"Highest: {max(apgar_scores)}")

Output

Click "Run" to execute the code

Looping Through Dictionaries

You can also loop through patient records stored as dictionaries:

Python - Looping Through Patient Records

# Multiple patient records
patients = [
    {"name": "Alice", "age": 28, "weeks": 32, "high_risk": False},
    {"name": "Barbara", "age": 38, "weeks": 24, "high_risk": True},
    {"name": "Carol", "age": 31, "weeks": 38, "high_risk": False}
]

print("Patient Dashboard")
print("=" * 50)

for patient in patients:
    print(f"\nPatient: {patient['name']}")
    print(f"  Age: {patient['age']} years")
    print(f"  Gestational Week: {patient['weeks']}")
    
    if patient['high_risk']:
        print("  Status: ⚠️ HIGH RISK")
    else:
        print("  Status: ✓ Normal")

Output

Click "Run" to execute the code

Next: Functions

6. Functions: Reusable Code

Imagine you need to calculate the BMI for 50 patients. Writing the formula weight / (height * height) 50 times would be tedious and prone to errors. Functions let you write code once and reuse it whenever you need it.

Parts of a Function

A function is like a recipe: it takes ingredients (inputs), does something with them (processing), and gives you a result (output).

Function Anatomy

def function_name(parameter):
    """Docstring explaining what it does"""
    # ... code that does something ...
    return result

def: Keyword that defines a function
parameter: Variable that receives input (the ingredients)
return: Keyword that sends back the result

Creating Your First Function

Let's create a simple function to calculate BMI:

Python - BMI Function

def calculate_bmi(weight_kg, height_m):
    """Calculates Body Mass Index (BMI)."""
    bmi = weight_kg / (height_m * height_m)
    return bmi

# Now we can use (call) the function!
# Patient A: 70kg, 1.75m
bmi_a = calculate_bmi(70, 1.75)
print(f"Patient A BMI: {bmi_a:.1f}")

# Patient B: 90kg, 1.80m
bmi_b = calculate_bmi(90, 1.80)
print(f"Patient B BMI: {bmi_b:.1f}")

# Patient C: 55kg, 1.60m
print(f"Patient C BMI: {calculate_bmi(55, 1.60):.1f}")

Output

Click "Run" to execute the code

Functions with Logic

Functions can contain any code, including if statements. Let's make a function that checks for fever:

Python - Clinical Logic Function

def check_temperature(temp_c):
    """Checks if a temperature indicates fever."""
    if temp_c >= 38.0:
        return "Fever (High)"
    elif temp_c >= 37.5:
        return "Low-grade fever"
    else:
        return "Normal temperature"

# Test the function with different values
temps = [36.6, 37.8, 38.4, 37.0]

for t in temps:
    result = check_temperature(t)
    print(f"{t}°C: {result}")

Output

Click "Run" to execute the code

A Real-World Example: Due Date Calculator

Let's build a function to estimate a due date. We'll use Python's datetime module to handle dates.

Python - Due Date Calculator

from datetime import datetime, timedelta

def calculate_due_date(lmp_date_str):
    """
    Calculates Estimated Due Date (EDD) from Last Menstrual Period.
    Rule: EDD = LMP + 280 days (40 weeks)
    """
    # 1. Convert string "YYYY-MM-DD" to a date object
    lmp_date = datetime.strptime(lmp_date_str, '%Y-%m-%d')
    
    # 2. Add 280 days
    edd = lmp_date + timedelta(days=280)
    
    # 3. Convert back to string to read it
    return edd.strftime('%Y-%m-%d')

# Test it
lmp = "2024-01-15"
due_date = calculate_due_date(lmp)

print(f"LMP Date:      {lmp}")
print(f"Due Date (EDD): {due_date}")

Output

Click "Run" to execute the code

Functions Returning Multiple Values

Functions can return more than one piece of information. This is useful for returning a result AND a status message.

Python - Multiple Return Values

def classify_birth_weight(grams):
    """Categorizes birth weight and returns category AND notes."""
    if grams < 2500:
        return "Low Birth Weight", "Monitor closely"
    elif grams > 4000:
        return "Macrosomia", "Check for diabetes"
    else:
        return "Normal", "Routine care"

# Test with a list of weights
weights = [3200, 2100, 4300, 3500]

print("Birth Weight Screening:")
print("-" * 40)

for w in weights:
    # Unpack the two returned values into two variables
    category, plan = classify_birth_weight(w)
    print(f"Weight {w}g: {category} ({plan})")

Output

Click "Run" to execute the code

Next: Error Handling

7. Error Handling: Expecting the Unexpected

In the real world, health data is messy. You'll encounter missing values, typos (like "O positive" instead of "O+"), or text where numbers should be. If you don't handle these errors, your program will crash.

The try-except Block

Python uses try and except to handle errors gracefully:

try:
    # Attempt to run this code...
except ErrorName:
    # If that specific error happens, run this code instead!

Handling User Input Errors

Let's try to convert a string to a number. If the string contains letters, Python raises a ValueError.

Python - Handling ValueError

# A list of gestational weeks from a spreadsheet
# Some entries are typos or missing!
entries = ["38", "40", "39", "unknown", "37", "N/A", "41"]

print("Processing gestational ages:")
print("-" * 30)

for entry in entries:
    try:
        weeks = int(entry)  # Try to convert to integer
        print(f"✓ Valid: {weeks} weeks")
    except ValueError:
        # This runs if int(entry) fails
        print(f"⚠️ Error: Could not convert '{entry}'")

print("-" * 30)
print("Processing complete - program didn't crash!")

Output

Click "Run" to execute the code

Cleaning Data with Error Handling

Error handling is essential for "cleaning" data so you can analyse it. Let's filter out invalid APGAR scores so we can calculate an accurate average.

Python - Data Cleaning

# Raw APGAR scores (0-10) with some messy data
raw_scores = [9, 8, "missing", 10, "7.5", 9, "error", 8]

clean_scores = []
skipped_count = 0

print("Cleaning Data...")

for score in raw_scores:
    try:
        # Convert to integer
        # Note: int("7.5") fails, but float("7.5") works
        clean_score = int(score)
        
        # Check if score is in valid range (0-10)
        if 0 <= clean_score <= 10:
            clean_scores.append(clean_score)
        else:
            print(f"  Skipped (out of range): {clean_score}")
            skipped_count += 1
            
    except ValueError:
        print(f"  Skipped (not a number): '{score}'")
        skipped_count += 1

# Calculate average of CLEAN data only
if len(clean_scores) > 0:
    average = sum(clean_scores) / len(clean_scores)
    print("\nResults:")
    print(f"Valid scores: {clean_scores}")
    print(f"Average APGAR: {average:.1f}")
else:
    print("No valid scores found.")

Output

Click "Run" to execute the code

Catching Multiple Errors (Advanced)

Sometimes different things can go wrong. You can have multiple except blocks:

Python - Multiple Exceptions

def calculate_bmi(weight, height):
    try:
        return weight / (height * height)
    except ZeroDivisionError:
        return "Error: Height cannot be zero"
    except TypeError:
        return "Error: Inputs must be numbers"

# Test cases
print("1. Normal:", calculate_bmi(70, 1.75))
print("2. Zero Height:", calculate_bmi(70, 0))
print("3. Text Input:", calculate_bmi("70", "1.75"))

Output

Click "Run" to execute the code

Next: Data Analysis

8. Putting It All Together: Capstone Project

Congratulations! You've learned the building blocks of Python. Now, let's combine them into a real data analysis script. We'll analyse a dataset of patient outcomes to identify preterm births and weight abnormalities.

Comprehensive Patient Analysis

The Plan

1. Data Structure: A list of dictionaries (Patient Database)
2. Logic: Functions to classify weight and check term status
3. Analysis: A loop to process each patient and update statistics
4. Output: A summary report

Python - Final Project

# --- STEP 1: DEFINE OUR DATA (Lists & Dictionaries) ---
patients = [
    {"id": "P001", "age": 28, "weeks": 38, "weight_g": 3200},
    {"id": "P002", "age": 35, "weeks": 36, "weight_g": 2400},
    {"id": "P003", "age": 24, "weeks": 40, "weight_g": 3800},
    {"id": "P004", "age": 32, "weeks": 37, "weight_g": 4200},
    {"id": "P005", "age": 29, "weeks": 35, "weight_g": 2100}
]

# --- STEP 2: DEFINE OUR HELPERS (Functions & Conditionals) ---
def classify_weight(weight):
    """Returns 'Low', 'Normal', or 'High' based on grams."""
    if weight < 2500: return "Low"
    elif weight > 4000: return "High"
    else: return "Normal"

def is_preterm(weeks):
    """Returns True if born before 37 weeks."""
    return weeks < 37

# --- STEP 3: ANALYSE THE DATA (Loops & Accumulators) ---
print("PATIENT ANALYSIS REPORT")
print("=" * 40)

# Initialize counters
stats = {
    "total": len(patients),
    "preterm": 0,
    "weight_counts": {"Low": 0, "Normal": 0, "High": 0}
}

for patient in patients:
    # 1. Apply logic
    weight_cat = classify_weight(patient["weight_g"])
    preterm = is_preterm(patient["weeks"])
    
    # 2. Update stats
    stats["weight_counts"][weight_cat] += 1
    if preterm:
        stats["preterm"] += 1
    
    # 3. Print individual result
    status_icon = "⚠️" if preterm else "✓"
    print(f"Patient {patient['id']}: {status_icon} Weeks: {patient['weeks']}, Weight: {weight_cat}")

# --- STEP 4: PRINT SUMMARY REPORT ---
print("\n" + "=" * 40)
print("POPULATION STATISTICS")
print("=" * 40)
print(f"Total Patients Analysed: {stats['total']}")
print(f"Preterm Birth Rate:      {(stats['preterm']/stats['total'])*100:.1f}%")
print(f"Weight Distribution:     {stats['weight_counts']}")

Output

Click "Run" to execute the code

Congratulations!

You've completed the Python for Health Data tutorial! You now know how to work with variables, data structures, conditionals, loops, functions, and error handling—all skills you can apply to real health data analysis.

Continue Learning

Download the Jupyter notebook version of this tutorial to practice on your own computer with larger datasets:

Download Tutorial Notebook