A Name Bound to a Value

A variable is a name bound to a value. When you write age = 12, Python stores 12 and lets the name age stand for it everywhere after. Change it with age = 13 and the name now points at the new value; the old one is forgotten. Every value also has a type. 12 is an int — a whole number. 3.5 is a float — a number with a decimal point. "cat" is a str — text, always in quotes. True and False are bool values — yes or no. The type decides what works: you can add two ints, but you cannot add a number to a word.

Assignment binds a name to a value: x = 5 makes x refer to 5. The single = is not the word 'equals' — it means store the value on the right under the name on the left. Re-assigning, x = 8, repoints the name; nothing about the first value lingers. Every value carries a type that fixes its behaviour: int (whole numbers), float (decimals), str (text in quotes), and bool (True or False). Type is a property of the value, not the name, so one name can hold an int now and a str later. Ask Python with type(x) and it will tell you which type a value is.

A variable is a binding between a name and a value; assignment count = 0 creates or updates that binding, and every later use of count looks up whatever value it currently holds. The right side is evaluated first, then stored — which is why count = count + 1 makes sense: read the old value, add one, store it back under the same name. Each value has a type — int, float, str, bool — that determines which operations are legal and what they mean: + joins two strings but sums two ints. Python is dynamically typed: the name carries no type of its own, only whatever value it points to right now, so tracking types as you read is part of tracing.

A variable is a name for a value. Think of a name tag. You put the number 3 on a tag and call it coins. Now, when you say coins, everyone knows you mean 3.

Every value has a kind, called its type. 3 is a number. The word cat is text. True and False are yes-or-no answers. The type tells you what you can do with the value.

A variable is a name in an environment that maps identifiers to values; assignment updates that mapping. Python uses reference semantics over a dynamically typed value space: the name is untyped, and the object it references carries the type. x = 5 binds x to an int object; x = "five" rebinds it to a str object, and the int may be garbage-collected. Types are not annotations the programmer decorates code with — they are properties objects genuinely have at runtime, checked when an operation is attempted. This is why "3" + 5 raises a TypeError rather than guessing: the + operator dispatches on its operands' types and finds no consistent meaning for one str and one int.

In a dynamically typed language, values inhabit a universal domain tagged with runtime types, and operators are partial functions defined only on certain tag combinations; + : int × int → int and str × str → str are distinct overloads with no int × str case, hence the TypeError. A variable is an l-value — a cell in a store — and assignment is the state-updating command store[x] := eval(e, store). The subtlety students meet later, mutation and aliasing, follows from the fact that two names may bind the same object: identity (is) and equality (==) come apart precisely because names denote references into a shared heap, not the values themselves.