If you’re new to Python or programming in general, welcome—you’re in the right place. This chapter is where we start turning ideas into code. Just like learning a new language starts with learning a few key words and phrases, learning Python begins with understanding how to work with basic building blocks: numbers, text, and data containers.
Why is this important? Because whether you’re analyzing customer data, building a machine learning model, or automating a task at work, you’ll rely on these foundational concepts every single time you write code. Think of this chapter as your toolbox—it may seem simple now, but you’ll keep coming back to these tools throughout your data science journey.
And don’t worry if it doesn’t all click right away. Everyone struggles with syntax or logic at first. Learning to code is more like learning to solve puzzles than memorizing rules. Take your time, experiment, and remember: errors are part of the process (even experienced coders Google stuff constantly).
By the end of this chapter, you’ll be able to:
Let’s dive in.
As you read through this chapter, we encourage you to follow along using the companion notebook in Google Colab (or other editor of choice). This interactive notebook lets you run the exact same code examples covered in the chapter—and experiment with your own ideas.
👉 Open the Python Basics Notebook in Colab.
Let’s write a few lines of Python code. Run the following in a Python environment (like Google Colab, Jupyter Notebook, or VS Code) and see what happens:
# Store your name as a string
name = "Taylor"
# Store your age as a number
age = 22
# Print a personalized message
print("Hi " + name + "! You are " + str(age) + " years old.")
# Calculate how many years until you turn 30
years_to_30 = 30 - age
print("You'll turn 30 in " + str(years_to_30) + " years.")Hi Taylor! You are 22 years old.
You'll turn 30 in 8 years.What just happened?
Don’t worry if this isn’t totally clear yet—that’s what this chapter is for. We’ll break it all down step by step.
Everything in Python is an object, and every object has a type. A data type tells Python what kind of value you’re working with—whether it’s a number, a piece of text, or a simple True/False flag. Understanding Python’s core data types is a fundamental step toward writing useful programs.
Let’s walk through a quick introduction to the most common data types you’ll encounter early on. As we progress through this class and book, you’ll explore many more ways to work with and manipulate these data types.
Python has two main types of numbers:
int (integers): whole numbers like 5, 42, or -100float (floating-point): numbers with decimals like 3.14, 0.5, or -2.718You can do all kinds of math with numbers in Python using simple operators:
10 + 3.5 # Addition13.510 * 3.5 # Multiplication35.0Go ahead and run these lines of code in your notebook:
# Basic operations
10 - 3.5 # Subtraction
10 * 3.5 # Multiplication
10 / 3.5 # Division (always returns a float)
# More math
10 ** 3.5 # Exponentiation (10^2 = 100)
10 // 3.5 # Integer division (result is an int)
10 % 3.5 # Modulus (remainder)Sometimes, Python (like all programming languages) can give results that look a little… off. This usually happens because computers represent decimal numbers using floating-point approximation, which isn’t always exact.
For example, you’d expect the following to equal 0.3 but instead…
0.1 + 0.1 + 0.10.30000000000000004This tiny difference is due to how numbers like 0.1 are stored in computer memory. It’s a common issue when doing calculations with decimal values, especially in financial or scientific applications. As we progress, you’ll learn best practices to handle imperfections like this. For now, you could just round it.
round(0.1 + 0.1 + 0.1, ndigits=2)0.3A string is a sequence of characters, enclosed in single or double quotes - whichever you use is personal preference but the output in the Python environment will contain single quotes:
"Hello Taylor!"'Hello Taylor!'Strings can be combined and manipulated in many ways:
# Concatenation
"Hello" + " " + "Taylor!" # Hello Taylor!'Hello Taylor!'Go ahead and run these lines of code in your notebook:
# String repetition
"ha" * 3 # 'hahaha'
# Get first letter (starts at 0)
"Taylor"[0] # 'T'
# Get first three letters
"Taylor"[:3] # 'Tay'Strings are extremely common—you’ll use them to label, format, and present data in readable ways.
In fact, as organizations increasingly rely on data-driven decision-making, a significant portion of their data comes in the form of text. Examples include product descriptions, customer feedback, social media posts, and even log files. Understanding how to work with strings is essential for extracting insights and making sense of this unstructured data.
A Boolean is a special data type with only two values: True and False.
is_raining = True
has_umbrella = FalseIn Python, True and False are capitalized. Writing true or false (lowercase) will result in a NameError. Always ensure proper capitalization when working with booleans.
You’ll mostly use booleans when you write logical conditions, such as comparing values or checking if something is true. Don’t worry, we’ll discuss comparison operators (i.e. >, ==) in a moment.
5 > 3 # True - 5 is greater than 3True5 == 3 # False - 5 does not equal 3FalseGo ahead and run these lines of code in your notebook:
10 < 9
10 > 9
10 <= 9
10 >= 9
10 == 10You can check the type of any object using the type() function:
print(type(10)) # <class 'int'>
print(type("hello")) # <class 'str'><class 'int'>
<class 'str'>print()
When working in a Jupyter notebook, Python will automatically display the result of the last line in a cell if it’s a value (like a string or number). For example:
type(10)
type("hello") # will only show the output of this last linestrBut in most real Python programs—like scripts, functions, or when running multiple lines—you need to use print() to explicitly display something to the user:
print(type(10)) # will print print out this output...
print(type("hello")) # and this output<class 'int'>
<class 'str'>Using print()` is a way to say, “Hey Python, show this to me in the output.” You’ll use it all the time for debugging, building interfaces, or just (as in this case) just to tell Python to display the output of each line of code.
You can also convert between types using built-in functions. For example, the following converts the integer value of 5 to a string '5'.
str(5) # '5' (string to int)'5'And the following converts a string '5' to an integer 5:
int('5') # 5 (int to string)5Go ahead and run these lines of code in your notebook:
print(type(3.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(str(3.14)) # '3.14' (convert decimal to string)
print(bool(0)) # False (0 is treated as False)
print(float(2)) # 2.0 (convert integer to decimal)These conversions come in handy when working with user input or cleaning messy data.
Work through the following tasks in your notebook.
In the last section, we did a lot of math using the same numbers — 10 and 3.5 — over and over again:
# Basic operations
10 - 3.5
10 * 3.5
10 / 3.5That works fine for short examples, but imagine writing a program that needs to use the same values in dozens of different places. What if you want to change one of those values later? You’d have to find and update every instance in your code.
That’s where variables come in.
A variable is a name that refers to a value. You can think of it like labeling a container that holds something useful—like a number, a word, or even a list of things.
Here’s how we could rewrite the examples above using variables:
x = 10
y = 3.5
print(x - y)
print(x * y)
print(x / y)Much cleaner, right?
Variables help you:
And when your programs get more complex, variables become essential for storing user input, results from calculations, or intermediate steps in a data analysis.
=To create a variable, we use the assignment operator (=). This tells Python to take the value on the right and assign it to the name on the left:
greeting = "Hello, world!"This means - store the string "Hello, world!" in a variable called greeting
You can then reuse that variable:
print(greeting)Hello, world!In Python, = does not mean “equal to” like in math. It’s an instruction: assign the value.
Here are basic rules for naming variables in Python:
_ as in _name, though that’s typically reserved for special cases—so avoid starting with _ unless you know what you’re doing)if, True, print, etc.)Some good examples:
age = 25
student_name = "Taylor"
is_logged_in = TrueUse descriptive names when possible—it makes your code easier for others (and future-you) to understand.
Variables can change! When you assign a new value to an existing variable, it overwrites the old one:
x = 5
x = x + 1 # Now x is 6
print(x)6Python always uses the most recent value.
You can assign any data type to a variable—numbers, strings, booleans, and more:
name = "Taylor" # string
gpa = 3.85 # float
is_honors_student = True # booleanAnd Python is flexible — you can even change what type a variable holds:
gpa = "3.85" # Now it's a string!This is called dynamic typing, and it’s part of what makes Python beginner-friendly.
In the previous section on booleans, we saw that comparison expressions—like 5 > 3 — evaluate to either True or False. These expressions are powered by comparison operators, which are used to compare values in Python.
You’ll use comparison operators all the time when writing conditions, checking data, filtering results, or writing logic into your programs.
Here’s a quick cheat sheet of the most common ones:
| Operator | Description | Example | Result |
|---|---|---|---|
== |
Equal to | 5 == 5 |
True |
!= |
Not equal to | 5 != 3 |
True |
> |
Greater than | 10 > 7 |
True |
< |
Less than | 4 < 2 |
False |
>= |
Greater than or equal to | 3 >= 3 |
True |
<= |
Less than or equal to | 8 <= 6 |
False |
All of these expressions return a boolean value: True or False. Try running the following lines of code in your notebook:
print(10 > 3) # True
print(2 < 1) # False
print(4 == 4.0) # True (int and float are treated as equal in value)
print(4 != 5) # True
print(6 >= 7) # False
print(5 <= 5) # TrueYou can also compare strings:
print("apple" == "apple") # True
print("Apple" == "apple") # False (case matters!)
print("cat" < "dog") # True (compares alphabetically)Don’t confuse = and ==:
= is the assignment operator (used to assign a value to a variable)== is the comparison operator (used to check if two values are equal)x = 5 # assignment
print(x == 5) # comparison → TrueNow that you’ve learned about Python’s core data types, how to assign values to variables, and how to make comparisons, let’s put it all together into a small real-world example.
Imagine you’re helping manage event registration for a student club. You want to:
Here’s how you might write that in Python:
# Number of attendees and ticket price
attendees = 48
ticket_price = 12.50
# Calculate total revenue
total_revenue = attendees * ticket_price
# Set a revenue goal
revenue_goal = 600
# Print a summary message
print("You sold " + str(attendees) + " tickets at $" + str(ticket_price) + " each.")
print("Total revenue: $" + str(total_revenue))
# Compare to revenue goal
goal_met = total_revenue >= revenue_goal
print("Did we meet our revenue goal: " + str(goal_met))You sold 48 tickets at $12.5 each.
Total revenue: $600.0
Did we meet our revenue goal: TrueIn these 8 lines of code we’ve combined everything we learned across this chapter:
print() to display helpful messages, combining strings and numeric valuesstr() to convert numeric and boolean data types to strings>=) to return True or False based on whether our total revenue met the goalRemember: GenAI tools are great helpers, but not always correct. Always try to understand the code they give you!
This is your first step toward building programs that do real work. It may not seem fancy now—but you’ve already written a script that stores, processes, and evaluates real-world data.
In this chapter, you learned how to:
=) to store and reuse values with variablesTrue or FalseThese are the essential tools that will support everything you do moving forward—whether you’re analyzing a spreadsheet, building a model, or writing a script to automate a task.
Now that you’ve learned how to work with individual values and variables, it’s time to start thinking bigger—about how we structure and analyze real-world data. In the next module, we’ll go deeper into three key topics:
You’ve built a strong foundation. Next, we’ll build on it and start working with data the way real analysts and scientists do. Let’s keep going!