2 Variables and Data Types

Names, Values, and Types

Python programs work with values such as numbers, text, and truth values. A name gives a readable way to refer to an object, while a variable is commonly understood as a name whose binding can change during execution.

Python uses Dynamic typing: the type belongs to the object currently referred to, not permanently to the name. For example, a name may first refer to an integer and later refer to a string. Names are case-sensitive and should communicate purpose, commonly through snake_case, such as student_name or total_cost.

A data type describes what kind of value an object represents and which operations make sense for it. The main basic types are:

• int: integer values such as $0$, $42$, and $-7$.

• float: approximate floating-point values such as $3.14$ and $-0.5$.

• complex: complex numbers such as $2 + 3j$.

• str: text values.

• bool: the truth values True and False.

• NoneType: the type of the single value None, commonly used to represent no value.

Use type() when you need to inspect the type of an object.

Takeaway: Names provide readable access to objects, and Python determines the type from the value currently bound to each name.

Binding and Rebinding Names

Assignment binds a name to the result of an expression with the operator $=$. The right-hand expression is evaluated first. For example, if width is $8$ and height is $5$, the expression for the area is:

Assignment can rebind a name. If temperature is first assigned $18$ and then assigned $21$, it refers to $21$ afterward. Assignment is therefore different from mathematical equality: $=$ performs binding in Python, while $==$ compares values.

Python also supports multiple assignment. Two names can receive two values in one statement, and the existing values can be swapped without a temporary name because the right-hand side is evaluated before the new bindings take effect. Augmented assignment, such as count += 1, updates a value using its previous value.

A name must be assigned before it is read. Attempting to use an unassigned name produces a NameError.

Takeaway: Assignment controls which object a name refers to, and reassignment changes that reference rather than changing the meaning of the name itself.

Numeric Values and Operations

Python provides familiar operations for numeric values. For an integer whole with value $17$, the main arithmetic operators behave as follows:

• Addition uses $+$, so $17 + 3 = 20$.

• Subtraction uses $-$, so $17 - 5 = 12$.

• Multiplication uses $\times$, so $17 \times 2 = 34$.

• Ordinary division uses $/$ conceptually and produces a float; $17 \div 2 = 8.5$.

• Floor division uses // and returns the floor of the quotient; $17 \mathbin{//} 2 = 8$.

• The remainder operation uses %; $17 \bmod 5 = 2$.

• Exponentiation uses **; $2^3 = 8$.

When an operation combines an integer and a floating-point value, Python generally performs the calculation using a floating-point value. Floating-point numbers are approximate, so a decimal calculation such as $0.1 + 0.2$ may display as $0.30000000000000004$. Applications that require exact decimal precision may need a specialized decimal type.

Takeaway: Choose the arithmetic operator according to whether you need ordinary division, a floor quotient, a remainder, or a power, and remember that floating-point results can be approximate.

Converting Between Types

Type conversion changes a value into another type. Common constructors include int(), float(), str(), bool(), and complex().

Examples include converting the text "25" to the integer $25$, converting "19.99" to a floating-point value, and converting $404$ to text. The input must be compatible with the requested type. For instance, int("2.5") is invalid because the text represents a decimal value rather than an integer literal.

Converting a float to an int discards the fractional part rather than rounding. Thus, int(7.9) produces $7$, while int(-7.9) produces $-7$.

The input() function always returns a string. Convert that result before performing numeric operations. A program that receives an age should convert the input to int before adding a year or comparing it with a numeric threshold.

Convert values near the boundary where their intended meaning becomes known, such as immediately after user input. This keeps later calculations and comparisons consistent.

Takeaway: Conversion is necessary when a value arrives in the wrong representation, but the conversion must match the value’s actual content.

Working with Text

A string is an immutable sequence of Unicode characters. Single quotes, double quotes, and triple quotes can delimit string literals. Raw-string notation can be useful when text contains backslashes.

Strings support several operations:

• Concatenation joins strings with +.

• Repetition creates repeated text with *.

• Indexing retrieves one position, starting at index $0$.

• Negative indexing counts from the end.

• Slicing creates a portion of a string, such as the characters from one boundary up to another.

• len() reports the number of characters.

• An f-string inserts current values into readable text.

Because strings are immutable, an operation cannot replace one character inside an existing string. Instead, it creates a new string and the name can be rebound to that new value.

For example, adding a title to the name Maya creates a new value such as Dr. Maya; it does not modify the original string object in place.

Takeaway: Treat strings as sequences that can be inspected and used to build new text, not as mutable character containers.

Conditions and Truth Values

A Boolean expression produces a truth value through comparison or logic. The comparison operators are less than $<$, less than or equal to $<=$, greater than $>$, greater than or equal to $>=$, equal to $==$, and not equal to $!=$.

Do not confuse assignment $=$ with comparison $==$. An assignment changes a binding, while a comparison asks whether two values match. For example, a program can assign limit the value $10$, then evaluate whether limit == 10 is true.

Use and, or, and not to combine conditions. A condition such as being at least $18$ and having an identification document requires both parts to be true. A condition using or is true when at least one part is true. not reverses a truth value.

Python also assigns truth values to many non-Boolean objects. False, None, numeric zero, empty strings, and empty collections are false in Boolean contexts; most other values are true. This allows concise checks, although explicit comparisons are clearer when a program must distinguish among zero, None, and an empty string.

and and or use short-circuit evaluation: Python may stop as soon as the final result is known. This can prevent unnecessary evaluation of later expressions.

Takeaway: Use comparisons to produce conditions, logical operators to combine them, and explicit checks when different false-like values have different meanings.

Practical Patterns and Review

A reliable Python workflow keeps values compatible with the operations being applied to them.

1. Choose a descriptive name that reflects the value’s purpose.

2. Inspect an unfamiliar value with type() and print().

3. Convert input as soon as its intended meaning is known.

4. Compare compatible types rather than comparing a number directly with text.

5. Use clear Boolean conditions when distinguishing among values such as zero, None, and an empty string.

For a simple total, a program might keep a quantity as an integer, a unit price as a floating-point value, and calculate the result with:

The important design principle is consistency: each name should refer to a value whose type matches the operations the program needs to perform.

Final takeaway: Python programs become easier to understand and debug when names are clear, assignments are deliberate, types are known, conversions happen at boundaries, and conditions compare compatible values.