Understanding Values, Variables, and Core Data Types

Values vs. Variables: What You Actually Work With

When you write Python code, you are constantly working with values. A value is a piece of data: a number like 42, a word like "hello", a truth value like True, or a collection like [1, 2, 3].

A variable is a name you choose that points to (refers to) a value. Variables help you store values so you can reuse them, change them, and make your code readable.

Think of it like labeling a container: the label (variable name) is not the thing itself (value), but it lets you refer to the thing easily.

x = 10

In this line:

• x is the variable name
• = is the assignment operator (it assigns a value to a name)
• 10 is the value

Python reads this as: “assign the value 10 to the name x.” It is not a math equation.

Continue in our app.

You can listen to the audiobook with the screen off, receive a free certificate for this course, and also have access to 5,000 other free online courses.

Or continue reading below...

Download the app

Reassigning Variables

Variables can be reassigned to new values at any time.

x = 10
x = 25

After the second line, x refers to 25, not 10. The old value isn’t “inside” the variable; the name now points somewhere else.

Variables Are Not Boxes (A Helpful Mental Model)

Many beginners imagine a variable as a box that “contains” a value. A more accurate model is: a variable is a label attached to a value. This matters when you start working with lists and other mutable objects, because multiple variables can refer to the same value.

a = [1, 2, 3]
b = a

Here, both a and b refer to the same list. If the list changes through one name, you’ll see the change through the other name too.

Core Data Types: The Building Blocks

Python has several core data types you’ll use constantly. Each type represents a different kind of value and supports different operations.

• int: whole numbers (e.g., 0, -7, 2026)
• float: decimal numbers (e.g., 3.14, -0.5)
• str: text (strings) (e.g., "Python")
• bool: truth values (True or False)
• NoneType: the special value None meaning “no value” or “not set”
• list: ordered, changeable collection (e.g., ["eggs", "milk"])
• tuple: ordered, usually unchangeable collection (e.g., (10, 20))
• dict: key-value mapping (e.g., {"name": "Ava", "age": 12})
• set: unordered collection of unique items (e.g., {1, 2, 3})

You can check a value’s type using type().

type(10)        # int
type(3.14)      # float
type("hi")      # str
type(True)      # bool

Step-by-Step: Inspecting Types and Values

Try this sequence to build intuition about values and types:

age = 12
pi = 3.14159
name = "Sam"
is_student = True
nothing_yet = None

print(age, type(age))
print(pi, type(pi))
print(name, type(name))
print(is_student, type(is_student))
print(nothing_yet, type(nothing_yet))

Notice how each variable name refers to a value, and each value has a type.

Numbers: int and float

Numbers are used for counting, measuring, and calculations.

int: Whole Numbers

int values have no decimal point.

apples = 5
bananas = 2
total_fruit = apples + bananas

Common operations include:

• Addition: +
• Subtraction: -
• Multiplication: *
• Integer division (quotient only): //
• Remainder: %
• Exponent: **

print(7 // 3)   # 2
print(7 % 3)    # 1
print(2 ** 5)   # 32

float: Decimal Numbers

float values include a decimal point (even if it’s .0).

price = 2.50
quantity = 3
cost = price * quantity
print(cost)  # 7.5

When you mix int and float in an operation, Python usually produces a float.

print(5 + 2.0)  # 7.0

Step-by-Step: A Mini “Change Calculator”

This example shows how numeric types and operators work together.

paid = 20
price = 13
change = paid - price

quarters = change // 25
change = change % 25

dimes = change // 10
change = change % 10

nickels = change // 5
change = change % 5

pennies = change

print(quarters, dimes, nickels, pennies)

This script uses // and % to break down a number into parts. (If you want realistic money handling, you often store cents as integers to avoid floating-point rounding issues.)

Text: str (Strings)

A string is text. In Python, strings are written in quotes: single quotes ' ' or double quotes " ". Both work; choose one style and be consistent.

greeting = "Hello"
name = 'Mina'

Combining Strings

You can combine strings using + (concatenation).

full = greeting + ", " + name
print(full)

Be careful: + does not automatically convert numbers to strings.

age = 12
# print("Age: " + age)  # This would cause an error

Convert the number first using str():

print("Age: " + str(age))

f-strings: Clean String Formatting

f-strings are a beginner-friendly way to insert values into text.

age = 12
print(f"{name} is {age} years old")

Inside the curly braces, you can put variables or even expressions.

width = 5
height = 3
print(f"Area: {width * height}")

Useful String Basics

• Length with len()
• Indexing to get a character (starts at 0)
• Slicing to get part of a string

word = "Python"
print(len(word))     # 6
print(word[0])       # P
print(word[1:4])     # yth
print(word[-1])      # n

Strings are immutable, meaning you can’t change them in place. If you “modify” a string, you are actually creating a new string.

word = "cat"
word = word + "s"   # creates a new string "cats"

Step-by-Step: Cleaning User Text

Text often needs cleaning. Here is a practical sequence using common string methods:

raw = "   Ada Lovelace   "
clean = raw.strip()          # remove spaces at both ends
lower = clean.lower()        # make lowercase
upper = clean.upper()        # make uppercase

print(clean)
print(lower)
print(upper)

Methods like strip(), lower(), and upper() return new strings.

True/False: bool

A boolean is either True or False. Booleans are essential for decision-making and conditions.

is_raining = False
has_umbrella = True

Booleans often come from comparisons:

print(10 > 3)     # True
print(5 == 5)     # True
print(5 != 5)     # False
print(2 <= 1)     # False

And can be combined with logical operators:

• and: both must be true
• or: at least one must be true
• not: flips true/false

age = 12
has_ticket = True
can_enter = (age >= 12) and has_ticket
print(can_enter)

Truthiness: Values That Behave Like True/False

In conditions, Python treats some values as “truthy” or “falsy.” This is useful, but you should understand it clearly.

• Falsy: 0, 0.0, "", [], {}, set(), None
• Truthy: most other values

name = ""
if name:
    print("Name provided")
else:
    print("Name is empty")

The Special Value None

None represents “no value yet” or “unknown.” It is commonly used as a placeholder.

best_score = None

You often check for None using is (not ==).

if best_score is None:
    print("No score recorded yet")

None is not the same as 0 or "". Those are real values; None means “nothing here.”

Collections: list, tuple, dict, set

Collections hold multiple values. Choosing the right collection type makes your code simpler and safer.

list: Ordered and Changeable

A list is an ordered collection you can modify (add, remove, replace items).

shopping = ["milk", "bread", "eggs"]
shopping.append("apples")
shopping[0] = "oat milk"
print(shopping)

Lists are great when:

• Order matters
• You need to add/remove items
• You may have duplicates

Common list operations:

numbers = [10, 20, 30]
print(len(numbers))
print(numbers[1])
print(numbers[0:2])

numbers.remove(20)
print(numbers)

Step-by-Step: Tracking Daily Temperatures

This example shows how a list can store changing data.

temps = []

temps.append(21.5)
temps.append(19.0)
temps.append(23.25)

average = sum(temps) / len(temps)
print(f"Readings: {temps}")
print(f"Average: {average}")

The list starts empty, then grows as you append readings.

tuple: Ordered and Usually Unchangeable

A tuple is like a list, but you typically don’t change it. This makes tuples good for fixed groups of values, such as coordinates.

point = (3, 7)
print(point[0])

Tuples are useful when:

• You want a fixed structure
• You want to signal “do not modify this”

Python also uses tuples in multiple assignment (unpacking):

x, y = (3, 7)
print(x)
print(y)

dict: Key-Value Pairs

A dictionary maps keys to values. Use it when you want to look up information by a name or identifier.

student = {"name": "Kai", "age": 12, "grade": 7}
print(student["name"])

You can add or update entries by assigning to a key:

student["age"] = 13
student["city"] = "Oslo"

To safely access a key that might not exist, use get():

nickname = student.get("nickname")
print(nickname)  # None if missing

Step-by-Step: Counting Items with a Dictionary

Counting is a common real-world task. Here is a clear approach:

words = ["red", "blue", "red", "green", "blue", "red"]
counts = {}

for w in words:
    if w in counts:
        counts[w] = counts[w] + 1
    else:
        counts[w] = 1

print(counts)

This builds a dictionary where each word is a key and the value is how many times it appears.

set: Unique Items

A set stores unique values (no duplicates). Sets are useful for membership tests and removing duplicates.

colors = {"red", "blue", "red"}
print(colors)  # duplicates removed

Membership checks are fast and readable:

allowed = {"admin", "editor"}
role = "viewer"
print(role in allowed)  # False

Type Conversion (Casting): Turning One Type into Another

Sometimes you need to convert values between types. Common conversions include:

• int("123") converts a numeric string to an integer
• float("3.14") converts a numeric string to a float
• str(123) converts a number to text
• bool(value) converts a value to True/False based on truthiness

text_age = "12"
age = int(text_age)
print(age + 1)  # 13

Be careful: conversion can fail if the text is not in the right format.

# int("twelve") would cause an error

Step-by-Step: Reading Input and Converting It

input() always returns a string. If you want a number, you must convert it.

text = input("Enter a number: ")
number = int(text)
print(number * 2)

If the user types something that isn’t a whole number, int() will fail. Later, you can learn to handle that with error handling, but the key idea here is: input starts as str.

Mutability: Why Some Values “Change” and Others Don’t

One of the most important ideas for beginners is mutability.

• Immutable types cannot be changed in place: int, float, str, bool, tuple
• Mutable types can be changed in place: list, dict, set

This affects how variables behave when multiple names refer to the same value.

Example: Immutable (int)

a = 10
b = a
b = b + 1
print(a)  # 10
print(b)  # 11

b = b + 1 creates a new integer value and reassigns b. It does not change a.

Example: Mutable (list)

a = [1, 2]
b = a
b.append(3)
print(a)  # [1, 2, 3]
print(b)  # [1, 2, 3]

Because the list is mutable, modifying it through b also affects what a refers to (the same list).

Step-by-Step: Making a Real Copy of a List

If you want a separate list, make a copy.

a = [1, 2]
b = a.copy()

b.append(3)
print(a)  # [1, 2]
print(b)  # [1, 2, 3]

Now a and b refer to different lists.

Naming Variables: Clarity Beats Cleverness

Good variable names make code easier to understand. Use names that describe what the value represents.

• Prefer total_price over tp
• Prefer student_count over sc
• Avoid using built-in names like list, dict, str as variable names

Python variable names commonly use snake_case (lowercase with underscores).

total_seconds = 125
minutes = total_seconds // 60
seconds = total_seconds % 60
print(f"{minutes} minutes and {seconds} seconds")

Putting It Together: A Small Useful Script Using Multiple Types

This script combines strings, numbers, booleans, and a dictionary to store and display simple profile data.

Step-by-Step: Build a Simple Profile Record

Step 1: Collect input (strings at first).

name = input("Name: ")
age_text = input("Age: ")
city = input("City: ")

Step 2: Convert age to an integer so you can do numeric comparisons.

age = int(age_text)

Step 3: Create a boolean based on a rule (for example, whether the person is a teen).

is_teen = (age >= 13) and (age <= 19)

Step 4: Store everything in a dictionary for easy access by key.

profile = {
    "name": name,
    "age": age,
    "city": city,
    "is_teen": is_teen
}

Step 5: Display a friendly message using an f-string.

print(f"Profile: {profile['name']} ({profile['age']}) from {profile['city']}")
print(f"Teen: {profile['is_teen']}")

This example shows a common pattern: input starts as strings, you convert what needs to be numeric, you compute booleans from comparisons, and you store related data in a dictionary.