Python Tutorial for Beginners 3: Integers and Floats - Working with Numeric Data

Python’s numeric toolbox hinges on two core types—integers and floats—and the practical rules for operating on them. Integers represent whole numbers (like 3), while floats represent decimal values (like 3.14). Python’s built-in `type()` function makes the distinction explicit, returning `int` for whole-number variables and `float` when decimals appear. That difference matters because it affects how arithmetic results behave, especially with division.

Arithmetic operators cover the everyday calculations: addition (`+`), subtraction (`-`), multiplication (`*`), and exponentiation (`**`). Division is where Python 3’s behavior stands out. Using `/` performs true division and preserves decimals—so `3 / 2` yields `1.5` in Python 3, whereas Python 2 would have dropped the decimal and returned `1`. When the goal is to discard the fractional part, floor division uses `//`, so `3 // 2` becomes `1`. For remainders, the modulo operator `%` returns what’s left after division; `3 % 2` gives `1`.

Modulo becomes especially useful for parity checks. Dividing any integer by 2 produces only two possible remainders: `0` or `1`. If `n % 2` equals `0`, the number is even; if it equals `1`, the number is odd. Examples like `2 % 2 = 0`, `3 % 2 = 1`, `4 % 2 = 0`, and `5 % 2 = 1` illustrate the pattern and show why this check is reliable.

Python also follows standard order of operations, with parentheses able to override precedence. Without parentheses, `3 * 2 + 1` evaluates multiplication first and produces `7`. With parentheses—`3 * (2 + 1)`—the addition happens first, changing the result to `9`. For updating values repeatedly, Python offers both the explicit increment form (`num = num + 1`) and a shorthand (`num += 1`). The same shorthand works with other operations, such as multiplying via `num *= 10`.

Built-in numeric functions round out the toolkit. `abs()` returns absolute value by removing negative signs (e.g., `abs(-3)` becomes `3`). `round()` rounds to the nearest integer by default, and it can take a second argument to control decimal precision—`round(3.75)` becomes `4`, while `round(23.8, 1)` rounds to one digit after the decimal.

Comparisons produce boolean `True`/`False` results, using operators like `==` (equality), `!=` (not equal), `>`, `<`, `>=`, and `<=`. A key detail is that equality uses `==`, not `=`—the single equals sign is assignment.

Finally, numeric bugs often come from type confusion: values that look like numbers may actually be strings. Adding `'100'` and `'200'` concatenates into `'100200'` rather than producing `300`. The fix is casting—converting string numerals into integers with `int(num1)` and `int(num2)`—so arithmetic behaves as expected. This foundation sets up the next step: working with sequences like lists, sets, and tuples.