Python Working with Data.

Control Flow taught us to process records. Now we'll understand the records themselves: how text is cleaned, how ordered collections work, and how named fields become the building blocks of inventory reports and future automation.

• Distinguish strings, lists, dictionaries, tuples and sets by the problem they solve.
• Access list items by index, slice safely and recognize mutable versus immutable values.
• Read and update dictionary records using keys, get() and predictable missing-value defaults.
• Transform and filter inventory records with loops without overwriting the original data.
• Handle split(), strip(), join(), enumerate(), sorted() and basic type conversion.
• Build a small report from structured device records and check edge cases.
• Translate a familiar for loop into a short list comprehension, then decide which is easier to read.
• Copy, sort, remove and update list or dictionary values without corrupting the source.

An IP address, hostname or ticket message starts as text. Strings are sequences of characters: you can index or slice them, but not change one character in place. Normalize incoming text before comparing it. strip removes surrounding whitespace; lower creates a lowercase copy; split divides a string into a list using a delimiter. Keep the original when you need an audit trail.

raw = '  SW-EDGE-01, Offline  '
parts = raw.strip().split(',')
host = parts[0].lower()
state = parts[1].strip().lower()
print(host, state)

A Python list holds an ordered collection of items. Lists are mutable, so append(), assignment and pop() modify the same object. Indices start at zero; -1 refers to the last element. A slice such as items[1:3] includes index 1 but excludes index 3. A shallow list slice copies its outer container, not nested objects.

ports = [22, 80, 443]
ports.append(3389)
print(ports[0])
print(ports[1:3])
print(len(ports))

A list can change in place, unlike a string. Understand the difference between assigning another name to the same list and creating a shallow copy: alias = ports refers to the same list, while copy = ports.copy() creates an independent outer list. The sort() method changes a list and returns None; sorted(ports) builds a new sorted list. pop(index) removes and returns the entry at that index, so a careless pop can shift all later positions. Try these operations on fictional port lists before updating any real configuration.

ports = [443, 22, 3389, 80]
copy = ports.copy()
removed = copy.pop(2)
copy.sort()
print(ports)
print(copy)
print(removed)

clean = ports.copy()
clean.pop(1)

A list tracks items by position; a dictionary tracks values by unique hashable keys. This is an excellent fit for inventory records with hostname, role and status. A missing key raises KeyError when accessed with brackets. Use get(key, default) when a field is optional and that default is explicitly meaningful; do not silently pretend missing evidence is healthy.

device = {'hostname': 'SW-01', 'status': 'offline'}
print(device['hostname'])
print(device.get('site', 'unknown'))
device['status'] = 'online'
print(device['status'])

A dictionary stores keys and values rather than numeric positions. You can add a new field with record['site'] = 'HQ', replace a value with update(), and remove a key with pop(key, default) or del. Without a default, pop raises KeyError if the key does not exist. When reading a dictionary, items() yields key/value pairs and keys() yields keys; iteration over a dictionary directly also visits its keys. Copies are shallow, just like list copies, so protect the original inventory when reporting.

original = {'host': 'SW-01', 'status': 'online', 'legacy': True}
review = original.copy()
review.update({'status': 'offline', 'site': 'HQ'})
review.pop('legacy', None)
print(original['status'])
print(sorted(review.items()))

An IT inventory often consists of a list of dictionaries. Each dictionary describes one device and the list holds all the records. Loop through those records and access fields by name. When data is inconsistent, normalize status carefully. The sample is fictional and does not connect to live systems.

devices = [
    {'hostname': 'SW-01', 'status': 'online'},
    {'hostname': 'AP-02', 'status': 'offline'},
]
for device in devices:
    print(device['hostname'], device['status'])

[
  {
    "host": "AP-02",
    "site": "BR1",
    "status": "offline"
  },
  {
    "host": "FW-01",
    "site": "HQ",
    "status": "offline"
  },
  {
    "host": "SRV-01",
    "site": "BR2",
    "status": "unknown"
  },
  {
    "host": "SW-01",
    "site": "HQ",
    "status": "online"
  }
]

Real operations reports answer questions such as which devices are offline. Begin with an empty results list, inspect every record, append matches, and report after the loop. Avoid accidentally assigning the original list to your results; this would make your edits affect the input. Normalize status for case and whitespace differences before comparing.

devices = [
    {'host': 'SW-01', 'status': 'Online'},
    {'host': 'AP-02', 'status': ' offline '},
]
offline_hosts = []
for device in devices:
    if device['status'].strip().lower() == 'offline':
        offline_hosts.append(device['host'])
print(offline_hosts)

Tuples are ordered immutable sequences; they are useful for values you want to keep grouped without changing their positions. Sets store unique hashable elements and support membership checks, but they do not preserve an indexable sequence. Converting a list to a set removes duplicates, and printing a set is not guaranteed to use a stable order. Sort for deterministic output.

sites = ['HQ', 'BR1', 'HQ', 'BR2']
unique_sites = set(sites)
print(len(unique_sites))
print(sorted(unique_sites))

You already know how to start with an empty list, loop over records, test a condition and append matches. A list comprehension is a shorter expression for that same common pattern. Read the version with a for loop first, then compare it with [expression for item in collection if condition]. Both produce a new list without removing the original records. You do not have to prefer the shorter syntax if the expanded loop is easier to debug.

devices = [{'host':'SW-01','status':'online'},
           {'host':'AP-02','status':'offline'}]
slow_way = []
for device in devices:
    if device['status'] == 'offline':
        slow_way.append(device['host'])
short_way = [device['host'] for device in devices
             if device['status'] == 'offline']
print(slow_way == short_way)
print(short_way)

An inventory may arrive as a delimited text line. split() separates fields; strip() cleans them; int() converts a numeric-looking string to an integer and can raise ValueError for bad input. enumerate() supplies a counter plus the current item as you loop, usually starting at zero. For example, for position, hostname in enumerate(['SW-01', 'AP-02'], start=1): prints positions 1 and 2 when you print(position, hostname). sorted() returns a sorted new list. join() combines a sequence of strings into a readable report; nonstrings must be converted first.

raw = 'SW-01,443,online'
name, port_text, status = [part.strip() for part in raw.split(',')]
port = int(port_text)
print(f'{name}: {port} / {status}')

A useful first automation reads a collection, classifies its records, and prints a reliable summary. Keep the original inventory available, store intermediate results separately, then report counts and hostnames. Test zero failures, several failures and missing or malformed statuses. This prepares you for CSV, JSON, file handling and API requests later in the Python path.

inventory = [
    {'host': 'SW-01', 'status': 'online'},
    {'host': 'AP-02', 'status': 'offline'},
    {'host': 'FW-01', 'status': 'offline'},
]
offline = [d['host'] for d in inventory if d.get('status') == 'offline']
print(f"{len(offline)} offline: {', '.join(sorted(offline))}")

Use the same real in-browser Python environment from earlier lessons. Start by normalizing a messy status string, then continue to eight more data-handling challenges, including copying, sorting, dictionary updates and tuple unpacking, in Practice.

Python's official tutorial explains these types in greater detail, including behaviors you'll revisit during file handling and automation.