Python Basics: Variables, Data Types, and Operators

1. Variables: Naming Your Data

Think about your work as a project manager. You don't refer to a budget item as "that money for the thing in Q3." You give it a specific name, like Q3_Marketing_Campaign_Budget, so everyone on the team knows exactly what you're talking about.

Variables in programming serve the same purpose. They are simply names or labels that you assign to values stored in the computer's memory. This makes your code readable, reusable, and easier to manage.

To see what this means in practice, please watch this very short introduction.

Assigning and Using Variables

As you saw, you create a variable using the assignment operator (=).

# variable_name = value
number_of_users = 1500
campaign_name = "Summer Sale 2024"

Once a variable is defined, you can use its name in place of the value. Let's explore a practical example from a business context.

A key concept in Python is that variables are references to objects. When you write number_of_users = 1500, you're not putting the number 1500 inside the variable. Instead, Python creates an integer object with the value 1500 in memory, and the variable number_of_users simply points to that object. This distinction will become more important as we work with more complex data.

2. Fundamental Data Types

Every value in Python has a data type, which tells Python what kind of data it is and what operations are allowed on it. For now, we'll focus on four fundamental types.

To see them in action, the next video will walk through each one with examples.

Let's summarize those core types:

• Integers (int): Whole numbers, positive or negative. Used for counting things, like users, clicks, or page views.

  • clicks = 3500
  • inventory_count = -10 (maybe representing a stock deficit)

• Floats (float): Numbers with a decimal point. Used for measurements and calculations where precision is needed, like rates or financial values.

  • conversion_rate = 0.045
  • cost_per_click = 1.25

• Strings (str): A sequence of characters, used for text. You must enclose them in single (') or double (") quotes.

  • user_segment = "High-Value Customers"
  • ad_creative_id = 'AD482-B'

• Booleans (bool): Represents one of two values: True or False. Crucial for logic and decision-making. Note that they are case-sensitive.

  • is_registered_user = True
  • has_completed_purchase = False

You can always check the type of a variable using Python's built-in type() function:

cpc = 1.25
print(type(cpc))
# Output: <class 'float'>

campaign_name = "Summer Sale"
print(type(campaign_name))
# Output: <class 'str'>

3. Operators: Performing Actions on Data

If variables and data types are the "nouns" of programming, operators are the "verbs." They let you perform calculations, comparisons, and assignments.

Arithmetic Operators

These are used for mathematical calculations.

The Python for Business reading has some great examples of using these in financial calculations.

Comparison Operators

These are used to compare two values. The result of a comparison is always a Boolean (True or False).

This is extremely useful in business analysis. For example, you might create a boolean flag like this:
is_high_value_order = order_total > 100.00

4. Writing Your First Script: An AdTech Example

Let's combine everything we've learned. A critical part of writing professional code is using clear, descriptive variable names.

Now, let's apply these principles. Imagine you have the following data for an online ad campaign and you need to calculate two key metrics: Click-Through Rate (CTR) and Cost Per Click (CPC).

• CTR = (Total Clicks / Total Impressions) * 100
• CPC = Total Spend / Total Clicks

Here is a simple Python script to perform these calculations. Try typing this out yourself in a code editor or a Jupyter Notebook.

# 1. Define variables with data from our campaign
impressions = 500000
clicks = 2500
total_spend = 1200.50

# 2. Calculate the metrics using arithmetic operators
# We multiply by 100 to express CTR as a percentage
click_through_rate = (clicks / impressions) * 100
cost_per_click = total_spend / clicks

# 3. Print the results to the screen
# The 'f' before the string allows us to embed variables directly. It's called an f-string.
print(f"Campaign Results:")
print(f"Click-Through Rate (CTR): {click_through_rate}%")
print(f"Cost Per Click (CPC): ${cost_per_click}")

When you run this script, you should see an output that neatly summarizes your campaign's performance. Notice how the descriptive variable names make the formulas easy to understand.

Conclusion

Excellent work! You've just taken your first steps into the world of Python. While these concepts are simple, they are the absolute foundation upon which all complex programs are built.

Key Takeaways:

• Variables are named references used to store and access data (e.g., total_spend = 1200.50).
• The fundamental data types determine what kind of value a variable holds: int (whole numbers), float (decimals), str (text), and bool (True/False).
• Operators are the symbols that perform actions, like * for multiplication and > for comparison.
• Writing clean code with descriptive variable names (like cost_per_click instead of cpc) is essential for professional work.

Preview of the Next Lesson:
So far, we've only worked with single values. But what about handling entire lists of customers, or all the performance metrics for a campaign? In our next lesson, we will learn to work with core data structures: lists, tuples, and dictionaries. These will allow you to group and manage collections of data, unlocking much more powerful analysis.