02 Variables, Expressions, and Input/Output

Names and data

Programs work by storing information, computing new values, receiving information, and producing results. The central idea is that names, values, and operations work together to describe what a program should do.

A variable is a name associated with a value. For example, a name such as price can refer to the price of an item, while quantity can refer to how many items are being considered. A descriptive name makes the purpose of data easier to understand.

A value is the data itself. It may be a number, a string, a Boolean value, or another supported kind of object. A name and its value are related but different: answer is a name, while $42$ is a value that the name might refer to.

A constant is a value that the program intends not to change. Python commonly communicates this intention with uppercase names such as TAX_RATE and MAX_ATTEMPTS, but uppercase spelling is a convention rather than an enforcement mechanism.

A literal is a value written directly in source code. Examples include $0$, $3.14$, the string "hello", True, and None.

Takeaway: Variables provide meaningful names, values provide data, constants communicate intended fixed rules, and literals write data directly in code.

Assignment and changing values

Assignment gives a variable a value. In Python, = evaluates the expression on the right and then associates the result with the name on the left. For example, assigning $80$ to score makes score refer to that value.

Assignment is evaluated in order. If score already refers to $80$, then an update equivalent to score = score + 5 first reads the old value, computes $85$, and stores the new value. This is why a statement such as x = x + 1 is valid in programming: it means to increase the current value of x by $1$, not to assert mathematical equality.

Multiple assignment can bind several names at once, as in first, second = 10, 20. The first name receives $10$, and the second receives $20$.

Augmented assignment combines an operation with assignment. For instance, count += 2 has the same practical update effect as adding $2$ to the current value of count and storing the result. Other common forms include -=, *=, /=, and %=.

Keep separate variables when both an original and an updated value are needed. Replacing price with a discounted result is appropriate only when the original price is no longer required.

Takeaway: Read assignment from right to left as an evaluation followed by storage, and remember that execution order determines which value is available.

Expressions and operators

An expression is code that produces a value. A literal, a variable reference, an arithmetic calculation, a comparison, or a function call can serve as an expression. An assignment statement commonly evaluates an expression on its right side before storing the result.

Arithmetic operators support calculations. Addition, subtraction, multiplication, division, floor division, remainder, and exponentiation can be written with +, -, *, /, //, %, and **. For example, $7 + 2 = 9$, $7 \mathbin{//} 2 = 3$, and 7 \mathbin{%} 2 = 1. The + operator can also join strings, such as combining a first name, a space, and a last name.

Comparison operators produce Boolean values. They include <, <=, >, >=, ==, and !=. The distinction between = and == is essential: = performs assignment, while == tests whether two values are equal.

Logical operators combine conditions. and is true when both conditions are true, or is true when at least one condition is true, and not reverses a truth value. For example, access may require both a valid ticket and sufficient age.

Parentheses make grouping explicit. Multiplication normally occurs before addition, so $2 + 3 \mathbin{*} 4 = 14$, whereas $(2 + 3) \mathbin{*} 4 = 20$. A useful order is parentheses, exponentiation, multiplication or division, addition or subtraction, comparisons, and then logical operations.

Operands must be compatible. Adding two numbers is appropriate, but adding a number directly to a string causes a type error. Convert a value explicitly when the intended operation requires a different type.

Takeaway: Expressions calculate values, operators determine how values are combined, and parentheses make intent clear.

Following program state

A program’s program state is the complete collection of values that matter at a particular moment. State changes as statements execute.

Consider the sequence in which balance begins at $100$, decreases by $25$, and then increases by $10$. After the three statements, its successive values are $100$, $75$, and $85$. The current value depends on every earlier assignment that affected it.

A reliable tracing method is:

1. List the important variables.

2. Read statements from top to bottom.

3. Record each variable’s value after every statement.

4. Use the recorded current values when evaluating the next expression.

A variable should receive a value before the program uses it. Using a name too early can cause an error or an unintended result, depending on the language and context.

Takeaway: Execution order matters because each statement reads the current state and may create a new state.

Receiving and converting input

Input is information supplied to a program from outside it. In Python, input() reads a line of text and returns a string. Even when a user enters digits, the returned data is text rather than a numeric value.

When arithmetic is needed, convert the text explicitly. int(...) produces an integer when the text has the expected integer format, while float(...) produces a floating-point number when the text has the expected format. A conversion such as int("twenty") cannot succeed because the text does not represent an integer in the required form.

A typical data flow is:

1. Read the first value.

2. Read the second value.

3. Convert the values to suitable types.

4. Compute an expression using the converted values.

5. Store the result in a variable.

For example, if two inputs represent $2$ and $3$, concatenating the unconverted strings produces "23", whereas converting them to integers before addition produces $5$. Robust programs eventually validate input and handle invalid data instead of assuming every response has the expected format.

Takeaway: Treat text received from input() as text until an explicit, successful conversion gives it the type needed for the next operation.

Producing clear output

Output is information produced by a program. Python’s print() function normally writes text to the screen, separates multiple arguments with spaces, and ends with a newline.

A program can print separate values, such as an item count and a price, or combine text and values with an f-string. An f-string evaluates expressions inside braces before displaying the resulting text. For example, inserting a calculated area displays the result of multiplying width by height rather than displaying the expression as unevaluated text.

Formatting controls presentation without changing the underlying value. A price such as $12.5$ can be displayed with two digits after the decimal point, producing a presentation such as $12.50.

A complete small calculation often follows this pattern:

1. Read an item name.

2. Convert a price to a floating-point value.

3. Convert a quantity to an integer.

4. Compute a subtotal with $\text{price} \mathbin{*} \text{quantity}$.

5. Compute tax using a named rate.

6. Add subtotal and tax to obtain the total.

7. Print each result with readable labels and formatting.

This pattern connects literals, variables, assignment, expressions, input, conversion, output, and changing program state. Clear names and explicit parentheses make the data flow easier to verify.

Takeaway: Good output presents computed values clearly, while good input handling ensures that those values were obtained from appropriately typed data.