Variables and Data Types in Python

Every analysis starts with values: the number of orders, a customer's name, whether a delivery was late, the date an order was placed. A variable is a name you attach to a value so you can use it again later. A data type tells Python what kind of value it is, which decides what you are allowed to do with it. You cannot divide a name by a city, and Python knows that because of types.

This lesson is the foundation for everything that follows. Take your time with it, run the examples yourself and change the numbers. Almost every error message you will see in your first month traces back to a mix-up between variables or types.

What is a variable?

Think of a variable as a label stuck on a box. The box holds a value, and the label is the name you use to find it. When you write:

orders_today = 412

Python does three things in order: it creates the value 412 in memory, creates the name orders_today, and connects the name to the value. The = sign here is assignment, not "equals" as in maths. Read it as "let orders_today refer to 412".

Because a name is just a label, you can move it. After orders_today = 450, the label now sits on a new box and the old value is forgotten. This is why variables are called variable: what they point to can change.

The five basic data types

There are more types (lists, dictionaries, dates), and they each get their own lesson. These five are the atoms that everything else is built from.

Naming variables

Python is strict about a few rules and relaxed about the rest, but professional analysts follow conventions that make code readable months later.

Rules (Python enforces these):

• Names may contain letters, digits and underscores.
• A name cannot start with a digit.
• A name cannot contain spaces or symbols like -, $ or ₹.
• A name cannot be a reserved word such as class, if or for.
• Names are case-sensitive: Revenue and revenue are different.

Conventions (people follow these):

• Use snake_case: lowercase words joined by underscores, e.g. avg_delivery_minutes.
• Choose descriptive names: delivery_minutes beats dm, and x tells nobody anything.
• Write constants in UPPER_CASE, for example FREE_DELIVERY_THRESHOLD = 299. Python does not stop you from changing it; the capitals are a signal to humans.

Worked examples

Example 1: Creating variables for one order

Question: Store the details of a single FreshBasket order in variables and print them.

order_id = "O02299"
customer_city = "Bengaluru"
items_count = 4
basket_value = 612.75
is_prime_member = True
coupon_code = None

print(order_id, customer_city, items_count, basket_value, is_prime_member, coupon_code)

O02299 Bengaluru 4 612.75 True None

How it works: Each line creates a variable. The order id and city are text, so they sit inside quotes. The item count is a whole number, the basket value has decimals, the prime flag is True, and coupon_code is None because this order did not use a coupon. print accepts several values separated by commas and shows them with a space between each.

Reading the result: The six values appear in one line. None prints as the word None, which is Python's way of saying "nothing here".

Example 2: Asking Python for the type

Question: How can I check what type a variable is?

print(type(order_id))
print(type(items_count))
print(type(basket_value))
print(type(is_prime_member))
print(type(coupon_code))

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'NoneType'>

How it works: type() returns the type of whatever you give it. Python writes the answer as <class 'int'>, where "class" is the more general word for type.

Reading the result: order_id is a str, items_count an int, basket_value a float, is_prime_member a bool, and coupon_code a NoneType. Checking types is the first thing to do when a calculation behaves strangely.

Example 3: Types decide what operations work

Question: What happens if I add a number to text?

print(order_id + items_count)

Traceback (most recent call last):
  File "example.py", line 1, in <module>
    print(order_id + items_count)
          ~~~~~~~~~^~~~~~~~~~~~~
TypeError: can only concatenate str (not "int") to str

How it works: The + operator means "add" for numbers and "join" for strings, but it cannot mix the two. Python refuses rather than guessing, and the error message tells you exactly which types clashed.

Reading the result: The TypeError says it can only concatenate (join) str to str, so it will not combine text with an integer. The fix is to convert one side: order_id + str(items_count) gives text, or you can use an f-string. We cover conversion in lesson 6.

Example 4: Reassigning and updating

Question: A customer adds two more items to the cart. Update the count, then add a delivery fee to the basket value.

items_count = items_count + 2
basket_value = basket_value + 25
print(items_count, basket_value)

6 637.75

How it works: items_count = items_count + 2 first evaluates the right side (4 + 2 = 6), then points the name at the result. The same happens for the basket value, which grows by the ₹25 fee.

Reading the result: The cart now has 6 items worth ₹637.75. Python also offers shorthand operators, +=, -=, *= and /=, that do the same thing in fewer keystrokes: items_count += 1 means items_count = items_count + 1. Let us use them for one more update, a 5% GST-style uplift on the basket:

items_count += 1
basket_value *= 1.05
print(items_count, round(basket_value, 2))

7 669.64

After the shorthand updates we have 7 items and ₹669.64. The shorthand is used constantly for counters and running totals.

Example 5: Multiple assignment and swapping

Question: Set several variables at once, and swap two values.

store_a = store_b = 0
morning_orders, evening_orders = 120, 185
print(store_a, store_b, morning_orders, evening_orders)

morning_orders, evening_orders = evening_orders, morning_orders
print(morning_orders, evening_orders)

0 0 120 185
185 120

How it works: store_a = store_b = 0 points both names at the same value. The comma form a, b = 120, 185 unpacks two values into two names in one statement. The swap works because Python evaluates the whole right side first (the pair 185, 120) and only then assigns, so no temporary variable is needed.

Reading the result: The names swapped values cleanly: morning is now 185 and evening is 120. This idiom is a Python favourite.

Example 6: Invalid names

Question: What happens if I break the naming rules?

2nd_order = "O00002"

  File "example.py", line 1
      2nd_order = "O00002"
      ^
  SyntaxError: invalid decimal literal

class = "Premium"

  File "example.py", line 1
      class = "Premium"
            ^
  SyntaxError: invalid syntax

How it works: Names cannot start with a digit, and class is a reserved word that Python needs for itself. Both produce a SyntaxError before any code runs, which means the problem is with the grammar of the line itself.

Reading the result: A SyntaxError points at the offending part of the line with carets. Rename the variable (order_2 and customer_class) and the problem disappears. Also avoid reusing built-in names such as list, sum, max or type for variables, because doing so hides the built-in function and causes confusing errors later.

Example 7: None means "no value"

Question: One order was cancelled so it has no delivery time. How do I represent that, and how do I test for it?

delivery_minutes = None

print(delivery_minutes is None)
print(delivery_minutes == 0)

delivery_minutes = 27
print(delivery_minutes is None)

True
False
False

How it works: None is a special value that means "nothing". Use is None to test for it. Note that None is not the same as 0: zero minutes is a real (impossible) delivery time, whereas None says the information does not exist.

Reading the result: The first test prints True, the comparison with zero prints False, and after we assign 27 the is None test becomes False. In pandas the equivalent of None is a missing value (NaN), which you will meet in the data cleaning lessons.

Example 8: Dynamic typing

Question: Can a variable change type during a program?

x = 10
print(type(x))

x = "ten"
print(type(x))

x = 10.0
print(type(x), isinstance(x, float), isinstance(x, int))

<class 'int'>
<class 'str'>
<class 'float'> True False

How it works: Python is dynamically typed: the type belongs to the value, not to the variable name. The same label x can point at an integer, then text, then a float. isinstance(value, type) is the cleaner way to ask "is this a float?" and returns True or False.

Reading the result: The three prints show int, then str, then float. This flexibility makes Python quick to write, but it also means mistakes surface at run time rather than before. Good naming and a habit of checking type() when results look odd protect you.

Common mistakes

1. Confusing = with ==. A single = assigns; a double == compares. Writing if x = 5: is a syntax error.

2. Using a variable before creating it.

print(total_discount)

Traceback (most recent call last):
  File "example.py", line 1, in <module>
    print(total_discount)
          ^^^^^^^^^^^^^^
NameError: name 'total_discount' is not defined

3. Overwriting a built-in name. If you write max = 50, you can no longer call max([1, 2, 3]). Pick names like max_orders instead.

4. Believing that b = a copies the value for lists and other mutable objects. For numbers and strings the difference does not show, but you will see in the lists lesson that two names can point at the same list. Keep this idea in the back of your mind.

5. Quotes around numbers. "412" is text, not a number. "412" + "8" gives "4128", not 420.

Practice questions

Practice 1 (Easy): Describe a product

Create variables for a product: product_name ("Masala Chai 500g"), price (245), in_stock (True). Print them in one line.

product_name = "Masala Chai 500g"
price = 245
in_stock = True
print(product_name, price, in_stock)

Masala Chai 500g 245 True

Practice 2 (Medium): Update a running total

Start with revenue = 0. Add three orders of ₹480, ₹1250.50 and ₹615 using +=, then print the total and its type.

revenue = 0
revenue += 480
revenue += 1250.50
revenue += 615
print(revenue, type(revenue))

2345.5 <class 'float'>

Practice 3 (Hard): Swap and check

Two stores have these delivery averages: store_x = 22.5 and store_y = 27.0. Swap them without a third variable, then print which one is now the smaller and what the type of each is.

store_x, store_y = 22.5, 27.0
store_x, store_y = store_y, store_x
print("x:", store_x, "y:", store_y)
print("smaller:", min(store_x, store_y))
print(type(store_x), type(store_y))

x: 27.0 y: 22.5
smaller: 22.5
<class 'float'> <class 'float'>

Key takeaways

• A variable is a name attached to a value, created with =; reassigning moves the name to a new value.
• The five basic types are int, float, str, bool and None. Check any value with type() or isinstance().
• Use descriptive snake_case names, never start with a digit, and do not reuse reserved words or built-in names.
• Types decide which operations are legal; mixing text and numbers raises a TypeError.
• +=, -=, *= and /= update a variable compactly, and a, b = b, a swaps two values.
• None means "no value" and is tested with is None; it is not the same as zero or an empty string.