Data Types in Programming

Why This Matters

Every piece of data your program handles—from a user's age to their entire shopping cart—needs to be stored in a specific format that tells the computer how to work with it. Data types are the foundation of how programming languages organize, store, and manipulate information. When you're tested on this material, you're not just being asked to define what an integer is—you're being evaluated on whether you understand why you'd choose one data type over another, how different types behave in operations, and what happens when types interact or convert.

Think of data types as falling into categories based on their purpose: primitive types that hold single values, collection types that group multiple values together, and special types that handle unique situations like missing data or complex objects. Don't just memorize definitions—know what problem each data type solves and when you'd reach for one over another. That conceptual understanding is what separates students who ace exams from those who struggle with application questions.

---

Primitive Numeric Types

These are your workhorses for mathematical operations. Numeric primitives store individual numbers directly in memory, making them fast and efficient for calculations.

Integer

• Whole numbers only—no decimal points allowed, which makes them perfect for counting discrete items like loop iterations or array indices
• Memory efficient for exact values; integers use less memory than floats and avoid rounding errors in calculations
• Supports all arithmetic operators including modulo ($\%$), which returns remainders and is essential for problems like determining if a number is even or odd

Float

• Decimal precision for fractional values—use floats when you need measurements, percentages, or any value that isn't a whole number
• Scientific notation support allows representation of extremely large ($3.0 \times 10^{8}$) or small ($1.5 \times 10^{-10}$) values
• Floating-point arithmetic can introduce rounding errors—comparing floats for exact equality is a common bug source (never write if x == 0.1)

---

Text and Character Types

These types handle human-readable data. Characters are the atomic unit; strings are sequences of characters that form meaningful text.

Character

• Single symbol storage—one letter, digit, or special character, typically enclosed in single quotes ('A', '7', '@')
• ASCII/Unicode values mean characters are actually stored as numbers, enabling comparisons and arithmetic ('A' < 'B' evaluates to true)
• Building block for strings—understanding characters helps you grasp how string indexing and manipulation work under the hood

String

• Sequence of characters enclosed in quotes, used for any text data from usernames to entire paragraphs
• Immutable in many languages—operations like concatenation create new strings rather than modifying the original (this matters for memory and performance)
• Rich built-in methods for manipulation: substring(), toUpperCase(), split(), trim()—know these for practical coding questions

---

Logical and Special Types

These types handle truth values and edge cases that don't fit neatly into numeric or text categories.

Boolean

• Binary logic—stores only true or false, named after mathematician George Boole
• Controls program flow through conditionals (if, while) and is the result of all comparison operations ($5 > 3$ returns true)
• Logical operators (AND, OR, NOT) combine booleans for complex conditions—truth tables are commonly tested

Null/None

• Represents absence of value—distinct from zero, empty string, or false; indicates "nothing here" or "not yet assigned"
• Error prevention requires null checks before using variables; accessing properties of null crashes programs (NullPointerException is infamous)
• Intentional emptiness—use null to explicitly signal that data is missing or a function returned no result

---

Collection Types

When you need to store multiple values, collection types organize them efficiently. The key differences are whether elements are ordered, whether they can change size, and how you access them.

Array

• Fixed-size, same-type elements stored in contiguous memory locations for fast access
• Index-based access using zero-based numbering ($array[0]$ is the first element)—random access is $O(1)$ time complexity
• Best for known quantities—use arrays when you know exactly how many elements you need and they won't change

List

• Dynamic sizing allows adding and removing elements without declaring size upfront
• Mixed data types permitted in many languages (Python lists can hold integers, strings, and objects together)
• Flexible but slower than arrays for some operations due to dynamic memory allocation

Dictionary/Map

• Key-value pairs where unique keys map to associated values ({"name": "Alice", "age": 25})
• Fast lookup by key—retrieval is $O(1)$ average time, making dictionaries ideal for data you'll search frequently
• No duplicate keys—assigning to an existing key overwrites the value; keys must be immutable (hashable) types

---

Object-Oriented Types

Objects bundle data and behavior together, enabling more complex and reusable code structures.

Object

• Instance of a class—a class is the blueprint, an object is the actual thing built from it
• Encapsulates state and behavior through properties (data) and methods (functions that operate on that data)
• Foundation of OOP—enables inheritance, polymorphism, and encapsulation, which are core testable concepts in programming courses

---

Quick Reference Table

---

Self-Check Questions

1. You need to store a student's GPA (like 3.75). Would you use an integer or a float, and why might using the wrong type cause problems?

2. Compare and contrast arrays and lists: what are two situations where you'd prefer an array, and two where a list would be better?

3. A program crashes with a "null reference" error. Explain what null represents and how you would prevent this type of error.

4. If you're building a phone contact list where you look up numbers by name, which data type would you choose and why? What would be the keys and values?

5. Why is it dangerous to compare two float values using == for exact equality? What concept about floating-point storage explains this behavior?