python-workout on jonah vairon

python workout: exercise 19

Fri, 30 Jan 2026 00:00:00 +0000

problem

Write a function, passwd_to_dict, that reads from a Unix-style “password file”, commonly stored as /etc/passwd, and returns a dict. The function should return a dict based on /etc/passwd in which the dict’s keys are usernames and the values are the users’ IDs (i.e the first and third fields in the comma-separated fields of an /etc/passwd entry).

attempts

This should be straightforward. We can split each line on colons and extract the first and third fields:

python workout: exercise 18

Wed, 28 Jan 2026 00:00:00 +0000

problem

Write a function (get_final_line) that takes a filename as an argument. The function should return that file’s final line on the screen.

attempts

first

My first thought is to just readlines() and index into the last element with -1. But that seems to defeat the implied purpose of the exercise – to explore hte possibility that “I’m only interested in a single line”.

Maybe it’s worth looking at the docs.

python workout: exercise 17

Tue, 27 Jan 2026 00:00:00 +0000

problem

Write a function, called how_many_different_numbers, that takes a single list of integers and returns the number of different integers it contains.

attempts

The first thing that comes to mind is to just use a set and get its length/size:

def how_many_different_numbers(numbers: list[int]) -> int:
    return len(set(numbers))

numbers = [1, 2, 3, 1, 2, 3, 4, 1]

print(how_many_different_numbers(numbers))

solution

The book’s implementation:

def how_many_different_numbers(numbers):
    unique_numbers = set(numbers)
    return len(unique_numbers)

Pretty much the same thing.

beyond the exercise

server log ip addresses

problem

python workout: exercise 16

Tue, 26 Aug 2025 00:00:00 +0100

dictdiff

problem

Write a function, dictdiff, that takes two dicts as arguments. The function returns a new dict that expresses the difference between the two dicts.

If there are no differences between the dicts, dictdiff returns an empty dict. For each key-value pair that differs, the return value of dictdiff will have a key-value pair in which the value is a list containing the values from the two different dicts. If one of the dicts doesn’t contain that key, it should contain None. The following provides some examples:

python workout: exercise 15

Sat, 23 Aug 2025 00:00:00 +0100

rainfall

problem

Another use for dicts is to accumulate data over the life of a program. In this exercise, you’ll use a dict for just that. Specifically, write a function, get_rainfall, that tracks rainfall in a number of cit- ies. Users of your program will enter the name of a city; if the city name is blank, then the function prints a report (which I’ll describe) before exiting. If the city name isn’t blank, then the program should also ask the user how much rain has fallen in that city (typically measured in millimeters). After the user enters the quantity of rain, the program again asks them for a city name, rainfall amount, and so on—until the user presses Enter instead of typing the name of a city. When the user enters a blank city name, the program exits—but first, it reports how much total rainfall there was in each city. Thus, if I enter

python workout: exercise 14

Sun, 17 Aug 2025 00:00:00 +0100

restaurant

problem

In this exercise, I want you to create a new constant dict, called MENU, representing the possible items you can order at a restaurant. The keys will be strings, and the val- ues will be prices (i.e., integers). You should then write a function, restaurant, that asks the user to enter an order:

If the user enters the name of a dish on the menu, the program prints the price and the running total. It then asks the user again for their order.

If the user enters the name of a dish not on the menu, the program scolds the user (mildly). It then asks the user again for their order.

If the user enters an empty string, the program stops prompting and prints the total amount.

For example, a session with the user might look like this:

python workout: exercise 13

Sat, 16 Aug 2025 00:00:00 +0100

printing tuple records

problem

For example, assume we’re in charge of an international summit in London. We know how many hours it’ll take each of several world leaders to arrive:
PEOPLE = [('Donald', 'Trump', 7.85),
          ('Vladimir', 'Putin', 3.626),
          ('Jinping', 'Xi', 10.603)]
The planner for this summit needs to have a list of the world leaders who are coming, along with the time it’ll take for them to arrive. However, this travel planner doesn’t need the degree of precision that the computer has provided; it’s enough for us to have two digits after the decimal point.

python workout: exercise 12

Thu, 14 Aug 2025 00:00:00 +0100

word with most repeated letters

problem

Write a function, most_repeating_word, that takes a sequence of strings as input. The function should return the string that contains the greatest number of repeated let- ters. In other words

For each word, find the letter that appears the most times.

Find the word whose most-repeated letter appears more than any other.

That is, if words is set to
words = ['this', 'is', 'an', 'elementary', 'test', 'example']
then your function should return elementary.

python workout: exercise 11

Tue, 12 Aug 2025 00:00:00 +0100

alphabetising names

problem

Let’s assume you have phone book data in a list of dicts, as follows:
PEOPLE = [{'first':'Reuven', 'last':'Lerner',
           'email':'reuven@lerner.co.il'},
          {'first':'Donald', 'last':'Trump',
           'email':'president@whitehouse.gov'},
          {'first':'Vladimir', 'last':'Putin',
           'email':'president@kremvax.ru'}]
First of all, if these are the only people in your phone book, then you should rethink whether Python programming is truly the best use of your time and connections. Regardless, write a function, alphabetize_names, that assumes the existence of a PEOPLE constant defined as shown in the code. The function should return the list of dicts, but sorted by last name and then by first name.

python workout: exercise 10

Sun, 10 Aug 2025 00:00:00 +0100

summing anything

problem

This challenge asks you to redefine the mysum function we defined in chapter 1, such that it can take any number of arguments. The arguments must all be of the same type and know how to respond to the + operator. (Thus, the function should work with numbers, strings, lists, and tuples, but not with sets and dicts.)

The result should be a new, longer sequence of the type provided by the parameters. Thus, the result of mysum('abc', 'def') will be the string abcdef, and the result of mysum([1,2,3], [4,5,6]) will be the six-element list [1,2,3,4,5,6]. Of course, it should also still return the integer 6 if we invoke mysum(1,2,3).

python workout: exercise 9

Fri, 08 Aug 2025 00:00:00 +0100

first-last

problem

Write a function, firstlast, that takes a sequence (string, list, or tuple) and returns the first and last elements of that sequence, in a two-element sequence of the same type. So firstlast('abc') will return the string ac, while firstlast([1,2,3,4]) will return the list [1,4].

attempts

We can just use slices to get the first and last element, the real challenge to me seems to be returning a sequence of the same type as the input.

python workout: exercise 8

Thu, 07 Aug 2025 00:00:00 +0100

sorting a string

problem

In this exercise, you’ll explore this idea by writing a function, strsort, that takes a single string as its input and returns a string. The returned string should contain the same characters as the input, except that its characters should be sorted in order, from the lowest Unicode value to the highest Unicode value. For example, the result of invoking strsort('cba') will be the string abc.