Variables and Data Types

With a working interpreter, the Python for Beginners series can start writing real code. A variable in Python is a name glued to a value — no declaration keyword, no type annotation, no ceremony. This chapter covers how names are created, how they must be spelled, the handful of built-in types you will use daily, and how to check at any moment what a value actually is.

Variables without declarations

Assignment is the declaration. There is no let, no const, no int before the name: writing name = value creates the variable if it does not exist and repoints it if it does.

course = "Python for Beginners"
lessons = 24
price = 0.0
is_free = True

lessons = lessons + 1
print(course, lessons, price, is_free)

Expected output:

Python for Beginners 25 0.0 True

Under the hood the name holds a reference to a value object, and lessons = lessons + 1 builds a new integer and points the name at it. A name must be assigned before it is read — otherwise you get NameError: name 'course_name' is not defined, Python’s version of JavaScript’s ReferenceError.

Naming rules and snake_case

The grammar is simple; the conventions are what make code readable. Rules enforced by the interpreter:

• Names may contain letters, digits and underscores — week_3, total_refunds, _internal.
• They may not start with a digit — 3rd_place is a syntax error.
• They are case sensitive — Total and total are two different variables.
• They may not be keywords — if, class, import, None and friends are reserved (import keyword; keyword.kwlist lists them all).

PEP 8, the community style guide, then asks for a shape per kind of name. Python accepts TotalPrice for a variable, but readers will assume it is a class — matching the convention costs nothing and saves a mental translation on every line:

The four built-in types you need first

You will meet classes and tuples in later chapters; day-to-day Python leans on four value types, plus one special value.

print(type(42), type(3.14), type("Ada"), type(True), type(None))

Expected output:

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

None is the closest Python gets to JavaScript’s null, but unlike undefined there is only one — a name that was never assigned raises NameError rather than quietly returning a hole in your data.

Dynamic typing: type() and isinstance()

Because the value carries the type, you can always ask what it is. type() returns the exact class; isinstance() answers yes or no and understands inheritance (chapter 16), so it is usually the better test in real code:

value = 10
print(type(value), isinstance(value, int))

value = "ten"
print(type(value), isinstance(value, int))

Expected output:

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

Mutable vs immutable (a preview). Every value in Python is either immutable — the object never changes, so a new name or a new object is created instead — or mutable, where the object can be edited in place. Numbers and strings are immutable:

score = 10
copy = score
score = 11
print(score, copy)

words = ["a", "b"]
words.append("c")
print(words)

Expected output:

11 10
['a', 'b', 'c']

The integer 10 was never modified — score was repointed at a new 11, so copy still holds the old value. The list, by contrast, was edited in place and every name pointing at it sees the change. Lists and dictionaries get chapters 8 and 9; keep the distinction visible from now on.

Multiple assignment and tuple unpacking

One statement can fill several names. Chained assignment gives every name the same value; assignment from a sequence spreads the values out — and because the right side is evaluated before anything is bound, swapping two names needs no temporary variable:

a = b = c = 0
print(a, b, c)

x, y = 1, 2
x, y = y, x
print(x, y)

first, last = "Ada", "Lovelace"
print(first, last)

Expected output:

0 0 0
2 1
Ada Lovelace

This pattern — called tuple unpacking — is everywhere in idiomatic Python: function returns, loop counters and column headers all lean on it. The number of names on the left must match the number of values on the right, or Python raises ValueError: not enough values to unpack.

A worked example

Everything in this chapter, in one short program. Read it, predict the output, then run it:

name = "Ada"
age = 36
height = 1.67
is_active = True

print(name, "is", age, "years old")
print("Type of height:", type(height))
print("Active account:", is_active)
print(name, age, height, is_active)
print("Next year:", age + 1)

Expected output:

Ada is 36 years old
Type of height: <class 'float'>
Active account: True
Ada 36 1.67 True
Next year: 37

Four names, four types, one print() per idea. Note that type() reports the class itself and that 1.67 printed as 1.67 rather than 1.6700000000000001 — Python trims the binary noise when the shortest round-trip form is the true one.

Common mistakes

• Writing a declaration keyword — let total = 0 or int total = 0 is a SyntaxError; assignment alone is enough.
• camelCase out of habit — it runs, but it reads as foreign Python; use snake_case for variables and functions.
• Reading a name before assigning it — NameError: name 'x' is not defined usually means a typo, not a missing import.
• Comparing floats for exact equality — 0.1 + 0.2 == 0.3 is False; chapter 5 covers the tolerance pattern.
• Assuming None means false — it does in a condition, but as a value None is its own type; distinguishing “missing” from 0 or "" is a feature, not an annoyance.

Practice checklist

1. Create five variables for a book (title, pages, price, in print, rating) with the correct types, and print them in one line and in five.
2. Predict then verify type() for -3, 7.0, "", True and None.
3. Swap two names without a temporary variable, then unpack three values into three names in a single statement.
4. Run the mutable and immutable example, then prove the integer was untouched by printing copy after the reassignment.
5. Rename every camelCase variable you have written so far to snake_case and rerun the programs to confirm nothing broke.

What's next?

Values are stored, named and typed; the next chapter takes the text type apart — indexing, slicing, methods and the f-string you will use in nearly every program: Strings and f-Strings.