Python Syntax, Variables, and Core Data Structures

What Is Python and Why Does It Matter in Data Science?

Python is an interpreted, general-purpose programming language that has become the dominant tool in data science and analytics. Its readable syntax, large standard library, and rich ecosystem of data-focused packages — including pandas, NumPy, and Matplotlib — make it practical for everything from quick data cleaning to building machine learning models. Google Data Analytics and CompTIA Data+ both expect candidates to understand how Python stores and manipulates data, so mastering the fundamentals in this lesson directly supports your certification goals.

All work in this lesson takes place inside Jupyter Notebook, a browser-based environment that lets you run code one cell at a time and see output immediately. Before running any cell, always predict what the output will be and record it in your lab log. Comparing your prediction to the actual output is the single fastest way to find gaps in your mental model.

Variables and Assignment

A variable is a named container that holds a value. In Python you create a variable the moment you assign a value to it — there is no separate declaration step.

```python

city = "Denver"

population = 715522

growth_rate = 1.37

is_capital = False

```

The name on the left receives the value on the right. Python is case-sensitive, so `City` and `city` are two different variables. Follow PEP 8 naming conventions: use lowercase letters and underscores for variable names (`growth_rate`, not `GrowthRate`).

Core Data Types

Python tracks the type of every value automatically. The four scalar (single-value) types you will use constantly are:

• int — whole numbers: `715522`, `-10`, `0`
• float — decimal numbers: `1.37`, `98.6`, `-0.5`
• str — text enclosed in single or double quotes: `"Denver"`, `'CO'`
• bool — logical values: `True` or `False` (capital first letter; no quotes)

Use the built-in function `type()` to inspect any value: `type(1.37)` returns `<class 'float'>`. Use `int()`, `float()`, and `str()` to convert between types when needed — for example, reading a CSV often delivers numbers as strings that must be cast to `int` or `float` before arithmetic.

Lists

A list is an ordered, mutable (changeable) sequence of values enclosed in square brackets.

```python

populations = [715522, 2161000, 897000, 305704]

```

Key operations:

• Index (zero-based): `populations[0]` returns `715522`; `populations[-1]` returns the last item.
• Slice: `populations[1:3]` returns `[2161000, 897000]` — the end index is excluded.
• Append: `populations.append(500000)` adds an item to the end.
• Update: `populations[0] = 720000` replaces a value in place.

Lists can hold mixed types, but in data work it is best practice to keep one type per list to avoid unexpected errors during calculations.

Tuples

A tuple is an ordered, immutable (unchangeable) sequence enclosed in parentheses.

```python

coordinates = (39.7392, -104.9903)

```

Because tuples cannot be altered after creation, they are ideal for fixed data like geographic coordinates, RGB color codes, or column header definitions. Indexing and slicing work the same way as with lists. Attempting to assign a new value to a tuple index raises a `TypeError`.

Dictionaries

A dictionary stores data as key-value pairs enclosed in curly braces. Keys must be unique and are usually strings or integers.

```python

sensor_readings = {

"temperature_c": 22.4,

"humidity_pct": 58.1,

"co2_ppm": 412

}

```

Key operations:

• Retrieve: `sensor_readings["temperature_c"]` returns `22.4`.
• Add or update: `sensor_readings["pressure_hpa"] = 1013.2` either creates a new key or overwrites an existing one.
• Keys and values: `sensor_readings.keys()` and `sensor_readings.values()` return views of each.
• Check membership: `"humidity_pct" in sensor_readings` returns `True`.

Dictionaries are the backbone of many data pipelines because they map field names to values, mirroring the structure of JSON records and database rows.

PEP 8 and Code Safety

PEP 8 is the official Python style guide. Following it makes your code readable to colleagues and reduces errors:

• Limit lines to 79 characters.
• Use four spaces for indentation (not tabs).
• Leave a blank line between logical sections.
• Write descriptive variable names: `avg_temperature` rather than `x`.

In a data environment, poorly named variables and missing comments are a form of data integrity risk — the next analyst may misread your intent and introduce errors. Always add a comment explaining your approach, especially when indexing or slicing.

While this lesson involves no physical hazards, never run unknown code on production data systems. Always develop and test in an isolated environment such as a local Jupyter instance or a sandboxed cloud notebook. Back up your work to the shared repository regularly using descriptive commit messages so changes are traceable.

Checking Your Work

Before submitting your notebook:

1. Restart the kernel and run all cells top to bottom — this catches errors caused by running cells out of order.

2. Confirm each exercise cell produces the expected output.

3. Verify every exercise includes a comment (`# ...`) explaining the approach.

4. Run a quick PEP 8 check using your notebook's linting tool or the `pycodestyle` package.

Submit the corrected notebook to the shared repository with a commit message that describes what you changed, for example: `Fix indexing error in exercise 7; add PEP 8 spacing`.