Python Data Types: A Deep Dive

In the world of healthcare, we deal with a wide range of data, from patient names and lab values to imaging files and diagnosis reports. Before we can analyze or process this data using Python, we need to understand what type of data we are working with.

In this episode, we will explore:

What Python data types are and why they matter
The difference between structured and unstructured medical data
Python's basic data types: int, float, str, bool
Common Python collections: lists, tuples, and dictionaries
How to check data types using type() and isinstance()

You will also see real-life healthcare examples that show how data types help organize and protect medical information.

🧠 What are Python data types, and why do they matter in healthcare?

In Python, every piece of data, like a number, a word, or a True/False value, has a type. Knowing the data type helps Python (and you) decide what you can and cannot do with that data. Python data types are the basic tools that help developers and analysts manage the large amounts of medical information created every day.

📋Understanding structured vs unstructured medical data

The medical field deals with two primary categories of information that require different processing approaches:

✅ Structured medical data is very organized and fits well into traditional databases. This includes:

Patient demographics
Vital signs measurements
Laboratory test results
Medication dosages

✅ Unstructured data doesn't have a set format but holds very valuable clinical insights. This includes:

Clinical notes and discharge summaries
Medical images (X-rays, MRIs, CT scans, ultrasounds)
Transcribed conversations between doctors and patients
Patient-generated health data from wearable devices
Genetic sequencing reports

📌 Data Types in Python

Python provides several built-in data types that align perfectly with healthcare needs:

Numeric types (int, float) handle quantitative medical data like patient ages, blood pressure readings, and lab values.
```
  patient_age = 50     #This is an integer number
  body_temperature = 98.6      #This is a float number
```
- Integers (int): Perfect for whole numbers like patient age, heart rate, or step counts.
- Floating-point numbers (float): Ideal for measurements with decimal values such as body temperature (98.6°F), or medication dosages (2.5mg).
String types (str) are immutable, meaning they can’t be changed after they are created. This makes them safer for storing sensitive patient information, as it prevents accidental changes.

Strings are written inside single quotes ‘’ or double quotes “”.
```
  patient_name = "Ali"
  diagnosis = 'Hypertension'
```
Boolean types (bool) represent true/false values, ideal for test results and condition flags:
- Laboratory test results (positive/negative)
- Patient status flags (admitted/discharged)
- Insurance verification (covered/not covered)
```
  is_discharged = False
  covered_with_insurance = True
```

Working with Python Collections: Lists, Tuples, and Dictionaries

In real-life healthcare and data science, we often need to manage groups of related information, like a list of symptoms, a fixed range of lab values, or detailed patient records. Python gives us special tools called collections to handle this kind of data efficiently.

In this section, you will learn about Lists for storing changeable data like medications, Tuples for storing fixed data sets like reference ranges, and Dictionaries for pairing labels with values like a patient’s name, age, and test results.

These structures help keep your data organized, readable, and accessible, which is especially important when working with medical information or building healthcare applications.

Let’s explore each one and see how they work in simple, real-world examples:

Lists can be changed, which means they are mutable. They are written with square brackets []. Lists are ordered collections, making them great for:
1. Tracking symptoms that may change during treatment
```
 symptoms = ["fever", "cough", "fatigue"]
 print(symptoms)
```
  1. Recording vital sign measurements over time
  2. Storing patient visit history
Tuples store collections of related values, like symptoms or medications. They are immutable (unchangeable) ordered collections and are written with parentheses ().

Use tuples when you want to protect the data from being changed. ideal for:
- Lab result reference ranges that shouldn't change

    hemoglobin_range = (12.0, 15.5)  # Lower and upper limit (g/dL)
    print("Hemoglobin normal range:", hemoglobin_range)

Dictionaries map keys to values, making them perfect for linking patient IDs to records. They are written inside curly brackets.

  patient_record = {
      "patient_id": "MRN12345",
      "name": "Sama Ahmed",
      "age": 25,
      "blood_type": "O+",
      "allergies": ["Penicillin", "Sulfa"],
      "vital_signs": {"temperature": 98.6, "blood_pressure": "120/80"}
  }

Don't worry about the dictionary syntax. We will cover this in more detail in future episodes.

🧠 How to check data types in Python

You can use Python’s built-in function type() to find out the data type of any variable.

 heart_rate = 85
 print(type(heart_rate))  # Output: <class 'int'>

Note that the output shows you the 'class' type of the data, which is ‘int‘, an integer.

Try this on your device:

 # Patient details
 patient_name = "Amina Yusuf"          # str
 patient_age = 34                      # int
 patient_temp = 38.2                   # float
 is_discharged = False                 # bool

 # Checking data types
 print(type(patient_name))
 print(type(patient_age))
 print(type(patient_temp))
 print(type(is_discharged))

For medical applications, type() offers a quick way to confirm that patient data is in the expected format before performing calculations or analysis.

Using isinstance() for Safer and Smarter Type Checking

While type() tells you the exact type of a value, isinstance() is more flexible and often better when your program needs to handle different (but related) data types.

Let’s say we want to know whether a piece of data is a number, a string, or something else.

Here’s how you can do it:

# Let's try with a number
heart_rate = 85

print(isinstance(heart_rate, int))  # This will print: True

# Now try with a word (a string)
blood_type = "O+"

print(isinstance(blood_type, int))  # This will print: False
print(isinstance(blood_type, str))  # This will print: True

isinstance(value, type) This is the syntax for isinstance.
It checks: “Is this value of this type?”

If yes, it prints True
If no, it prints False
You can even check two types at once:
```
  age = 30
  print(isinstance(age, (int, float)))  # Will be True if age is int or float
```
✅ Why This Is Helpful

When working with real patient data, it’s important to:
- Know what type of data you are dealing with (number, text, etc.)
- Avoid mistakes like doing math on words

So isinstance() is like asking:

"Is this value a number or text?"
And Python answers: True or False

Now, try this and let me know what the outputs are:

    temperature = 98.6
    print(isinstance(temperature, float)) 

    patient_name = "Amina"
    print(isinstance(patient_name, str))

🧪 Practice Exercise: Organize and Check Patient Data

Create a Python program that stores the following information about a patient:

Full name
Age
Body temperature
Is the patient under observation? (yes/no)
Allergies list
Hemoglobin reference range
Patient’s blood type

Use both type() and isinstance() to print the data types of each variable.

💻 What to do:

Use print() to show each variable’s value
Use type() to check its data type
Try isinstance() on at least 3 variables to see if they match the expected type

📩 Once you complete the exercise, please send your code and results to my email so I can review your progress and provide feedback. saja@sajamedtech.com

✅ Conclusion: Why Data Types Matter in Medical Coding

Understanding data types is one of the most important skills you can learn as a beginner programmer, especially in healthcare, where working with sensitive and structured data is part of daily operations.

Knowing whether a piece of data is a number, a word, or a true/false value helps you:

Use the right logic and operations
Prevent errors in calculations
Ensure patient data stays clean and accurate
Work confidently with larger and more complex datasets in the future

In the next episode, we’ll begin a deeper exploration of each Python data type, starting with strings. You will learn how to work with text data, apply basic string operations, and understand why this is important in managing healthcare records.

See you tomorrow!

Episode 6: Exploring Data Types in Python