CS20 Working with Nested Lists

Section 9.22 Working with Nested Lists

This page has several programs for you to write. They all use nested lists.

Exercises Exercises

1.

The Pythagorean theorem lets us find the hypotenuse of a right triangle if we know the length of the two legs of the triangle. In this program, you will have a nested list that contains pairs of leg lengths (for example, [3.0, 4.0] is a sublist describing a triangle whose legs are 3.0 and 4.0 units long).

Your job is to take this nested list and create a new list of the corresponding hypotenuse lengths.

triangle_list = [[3.0, 4.0], [12.0, 5.0], [7.6, 3.2], [8.5, 10.4]]
hypotenuse_list = []  # results go into this list
# your code here
====
from unittest.gui import TestCaseGui

class myTests(TestCaseGui):

def testOne(self):            
        def close_enough(result_list):
            good_list = [[3.0, 4.0], [12.0, 5.0], [7.6, 3.2], [8.5, 10.4]]
            result = True
            index = 0
            if (len(good_list) != len(result_list)):
              result = False
            else:
                while index < len(good_list) and result:
                    good_hyp = ((good_list[index][0] ** 2) + (good_list[index][1] ** 2)) ** 0.5
                    if abs(result_list[index] - good_hyp) < .00001:
                        index = index + 1
                    else:
                        result = False
            return result

self.assertEqual(len(hypotenuse_list), 4, "Result should have 4 entries.")
        self.assertEqual(close_enough(hypotenuse_list), True, "Result has correct calculation.")

myTests().main()

Solution.

This solution does not use any functions

triangle_list = [[3.0, 4.0], [12.0, 5.0], [7.6, 3.2], [8.5, 10.4]]
hypotenuse_list = []
for sublist in triangle_list:
    hypotenuse = (sublist[0] ** 2 + sublist[1] ** 2) ** 0.5
    hypotenuse_list.append(hypotenuse)
print(f"Hypotenuses are {hypotenuse_list}.")

This solution uses a function for calculating the Pythagorean theorem.

    def hypotenuse(first_leg, second_leg):
    """Return length of hypotenuse given leg lengths."""
    
    result = (first_leg ** 2 + second_leg ** 2) ** 0.5
    return result

triangle_list = [[3.0, 4.0], [12.0, 5.0], [7.6, 3.2], [8.5, 10.4]]
hypotenuse_list = []
for sublist in triangle_list:
    hypotenuse_list.append(hypotenuse(sublist[0], sublist[1]))
print(f"Hypotenuses are {hypotenuse_list}.")

2.

Given a nested list of student names, IDs, and three test scores, write a program that prints each student’s name, ID, and average test score. Here is what the output might look like. The program that produced this output used f-strings as described in section 7.10.1 to output the average with one digit after the decimal point. Your output doesn’t have to match exactly, but the information conveyed must be the same.

Average Test Scores
===================
Phuong (#101345): 88.7
Federico (#43617): 90.0
Michele (#81882): 89.9
Steve (#79315): 91.6

3.

In the following program, you will start with a nested list of one week’s worth of low and high temperatures in degrees Celsius. Your program will create a new nested list that contains the low/high pairs, converted to Fahrenheit. The conversion formula for Celsius to Fahrenheit is \(f = {9 \over 5} c + 32\text{.}\)

def nested_to_fahr(celsius_list):
    """Convert nested list of temperature ranges to Fahrenheit.
    Given a list of low/high temperature pairs in degrees Celsius,
    return a corresponding list of pairs in degrees Fahrenheit.
    """
    # your code here

celsius_ranges = [[8.3, 21.1], [12.5, 23.3], [15.6, 21.0], [16.9, 28.4],
                  [15.5, 22.0], [11.5, 21.9], [14.4, 22.8]]

fahr_ranges = nested_to_fahr(celsius_ranges)
print(fahr_ranges)
====
from unittest.gui import TestCaseGui

class myTests(TestCaseGui):

def testOne(self):
        def good_fahr(celsius):
            return celsius / 5 * 9 + 32

def all_pairs(nested_list):
            result = True
            index = 0
            while index < len(nested_list) and result:
                result = len(nested_list[index]) == 2
                index += 1
            return result

def within_delta(a, b):
            return abs(a - b) < .001
            
        def close_enough(nested_list):
            result = True
            index = 0
            while index < len(nested_list) and result:
                pair = nested_list[index]
                result = within_delta(pair[0], good_fahr(celsius_ranges[index][0])) and \
                    within_delta(pair[1], good_fahr(celsius_ranges[index][1]))
                index = index + 1
            return result

self.assertEqual(len(fahr_ranges), 7, "Result should have 7 entries.")
        self.assertEqual(all_pairs(fahr_ranges), True, "Sublists should have two elements.")
        self.assertEqual(close_enough(fahr_ranges), True, "Result has correct calculation.")

myTests().main()

Let’s Think Python: COMSC020 PreTeXt Interactive Edition

Search Results:

Section 9.22 Working with Nested Lists

Exercises Exercises

1.

2.

3.