List Methods and Sorting

From Counts to Rankings

A word-frequency dictionary answers the question “How many times did each word appear?” Its words are keys and its counts are values. To answer a different question—“Which words appeared most often?”—you need the counts to control the ordering. The useful pattern is to build a list of tuples in the form (count, word), sort that list, and then display the first few tuples.

The Data Flow

The complete process has distinct stages. The program reads text, builds a dictionary of word counts, restructures each dictionary entry as a (count, word) tuple, sorts the tuple list in reverse order, selects a prefix of that list, and unpacks each selected tuple for display. Keeping these stages separate makes the final output easier to understand and debug.

Rebuilding the Sortable Structure

A dictionary stores words as keys and frequencies as values. Sorting the dictionary by its keys would organize words, not frequencies. Instead, create a separate list and place each value before its key. A dictionary entry such as word: frequency becomes the tuple (frequency, word). The original dictionary remains unchanged; the list is a new sortable representation.

Reverse Order and Ties

Calling sort(reverse=True) sorts the entire tuple in descending order. Python first compares the tuple's first element, so larger counts come first. If two counts match, Python compares the second elements. Because the whole tuple is being sorted in reverse order, the words are then ordered in reverse alphabetical order.

Selecting the Top Results

After sorting, the most frequent words are at the beginning of the list. The slice lst[:10] starts at index 0 and stops before index 10, so it selects indices 0 through 9. In a loop written as for count, word in lst[:10]:, each tuple is unpacked: its first element is assigned to count and its second element to word.

lst = [(61, "i"), (42, "and"), (5, "to"), (5, "the")]

for count, word in lst[:3]:
    print(count, word)

61 i
42 and
5 to

Tracing a Complete Program

A complete word-frequency program combines file reading, dictionary building, tuple construction, sorting, slicing, and output formatting. The important point is not one particular file-reading implementation; it is the order in which the data changes shape. Text begins as input, becomes word counts, becomes sortable tuples, and finally becomes a short ranked display.

counts = {"i": 61, "and": 42, "the": 5, "to": 5} ranked = [] for word, count in counts.items(): ranked.append((count, word)) ranked.sort(reverse=True) for count, word in ranked[:3]: print(count, word)

In the source program's Romeo and Juliet result, i appears 61 times and and appears 42 times. The displayed words are ordered with the highest frequency first. The smaller example above follows the same ranking logic while using fewer entries so that every stage can be traced directly.

Mistakes with Ranked Lists

• Sorting the word keys instead of the frequency values

  The question is which words have the largest counts, so alphabetical word order is not the primary criterion.

  Fix: Create (count, word) tuples so the count is the first element.

• Putting the word before the count

  Tuple sorting would compare the word first, making the frequency secondary.

  Fix: Use the (count, word) arrangement.

• Expecting ties to remain in an unspecified order

  Python compares the second tuple elements when the counts match.

  Fix: Expect reverse alphabetical ordering of the words when sort(reverse=True) is used.

• Reading lst[:10] as including index 10

  The ending index of this slice is excluded.

  Fix: Interpret lst[:10] as indices 0 through 9.

• Forgetting the tuple's element order during unpacking

  The first loop variable receives the first tuple element.

  Fix: Use for count, word in ranked[:10]: when the tuples are (count, word).

Practice the Transformation

Key Takeaways

1. A frequency dictionary stores words as keys and counts as values, but ranking by frequency requires a new sortable structure.
2. Represent each entry as (count, word) so the count is the primary tuple-sorting element.
3. sort(reverse=True) puts larger counts first and uses reverse alphabetical word order to resolve equal counts.
4. The slice lst[:10] selects the first ten positions, and tuple unpacking assigns each tuple's count and word to loop variables.
5. The pattern separates counting, restructuring, sorting, selecting, and displaying into clear stages.