Sorting Dictionaries by Value

From Web Text to Ranked Words

Suppose you download a text file and want to discover which words occur most often. Counting manually is tedious and error-prone. A Python program can retrieve the text, process every word, store frequencies in a dictionary, and then prepare those dictionary entries for sorting by frequency.

The complete task has two connected parts. First, urllib.request.urlopen() opens a web URL and returns a file-like object. You can iterate over that object line by line as you would iterate over a local file. Second, you transform the text into a dictionary whose keys are words and whose values are total occurrence counts. To sort by those counts, you rebuild each dictionary entry in the opposite order: (value, key) instead of (key, value).

The Counting Pipeline

The response from urlopen() is file-like, but each line arrives as bytes. Decode each line to a string before splitting it into words. The outer loop handles lines; the inner loop handles the words within each line. Every word then updates the same counts dictionary, so its value represents the total across the entire text rather than only the current line.

import urllib.request counts = {} with urllib.request.urlopen(url) as response: for line in response: text = line.decode() for word in text.split(): counts[word] = counts.get(word, 0) + 1

Tracing Each Dictionary Update

A useful way to understand the counter is to pause after every word. The source uses the first two lines But soft what and light through yonder as a small tracing example. Each new word receives a count of 1 because it has not appeared before. If a word appears again later, the dictionary retrieves its current count and increases it.

Making Values Sortable

A word-count dictionary naturally stores entries as (key, value): the word is the key and its frequency is the value. If you place those entries directly into a list, the word appears first in each tuple. Tuple sorting compares the first element first, so the word controls the primary ordering.

The solution is to reconstruct every entry as (value, key). For word counts, that means (count, word). Now the count occupies the first tuple position, so a simple sorted() call compares counts first. The word moves to the second position and can be used when two counts are equal.

counts = {'red': 2, 'blue': 1, 'green': 2}

value_key_pairs = []
for word, count in counts.items():
    value_key_pairs.append((count, word))

sorted_pairs = sorted(value_key_pairs)

[(1, 'blue'), (2, 'green'), (2, 'red')]

Reading Tuple Sort Order

Tuple comparison is lexicographic: Python examines the first element first. If the first elements differ, that decides the order. If they are equal, comparison continues to the next element. Therefore, with (count, word) tuples, counts determine the main order and words determine the order within equal-count groups.

Mistakes in Counting and Sorting

• Processing the byte line as though it were already a string

  Each line from the web source arrives as bytes, so it must be decoded before it can be treated as readable text and split into words.

  Fix: Decode the line first, then split the resulting string.

• Resetting the count instead of incrementing it

  A repeated word is assigned 1 again, so its total occurrence count never accumulates.

  Fix: Use counts[word] = counts.get(word, 0) + 1.

• Updating a different dictionary key than the current word

  Occurrences are collected under the wrong entry, so the dictionary no longer maps each word to its own total.

  Fix: Use the current word as the key in the update expression.

• Sorting the original key-value pairs when the goal is value order

  The word is first, so it controls the primary tuple comparison.

  Fix: Build a new list shaped as (count, word) before calling sorted().

• Expecting a dictionary to be rearranged in place by sorted()

  The technique constructs a list of tuples for sorting; the original dictionary remains the word-to-count mapping.

  Fix: Store and use the sorted list of (value, key) tuples.

Practice the Transformation

Key Takeaways

1. urlopen() returns a file-like object that can be iterated over line by line.
2. Web lines arrive as bytes, so decode them before splitting into words.
3. Use counts[word] = counts.get(word, 0) + 1 to initialize and increment word frequencies.
4. A dictionary entry normally has the shape (key, value); rebuild it as (value, key) when the value should control sorting.
5. Tuple sorting compares the first element first and uses later elements to resolve ties.