10.14. Exercises¶

Below are the datafiles that you have been using so far, and will continue to use for the rest of the chapter.

The file below is travel_plans.txt.

This summer I will be travelling.
I will go to...
Italy: Rome
Greece: Athens
England: London, Manchester
France: Paris, Nice, Lyon
Spain: Madrid, Barcelona, Granada
Austria: Vienna
I will probably not even want to come back!
However, I wonder how I will get by with all the different languages.
I only know English!

The file below is school_prompt.txt.

Writing essays for school can be difficult but
many students find that by researching their topic that they
have more to say and are better informed. Here are the university
we require many undergraduate students to take a first year writing requirement
so that they can
have a solid foundation for their writing skills. This comes
in handy for many students.
Different schools have different requirements, but everyone uses
writing at some point in their academic career, be it essays, research papers,
technical write ups, or scripts.

The file below is emotion_words.txt.

Sad upset blue down melancholy somber bitter troubled
Angry mad enraged irate irritable wrathful outraged infuriated
Happy cheerful content elated joyous delighted lively glad
Confused disoriented puzzled perplexed dazed befuddled
Excited eager thrilled delighted
Scared afraid fearful panicked terrified petrified startled
Nervous anxious jittery jumpy tense uneasy apprehensive

The following sample file called studentdata.txt contains one line for each student in an imaginary class. The students name is the first thing on each line, followed by some exam scores. The number of scores might be different for each student.

joe 10 15 20 30 40 bill 23 16 19 22 sue 8 22 17 14 32 17 24 21 2 9 11 17 grace 12 28 21 45 26 10 john 14 32 25 16 89
Using the text file studentdata.txt write a program that prints out the names of students that have more than six quiz scores.
# Hint: first see if you can write a program that just prints out the number of scores on each line # Then, make it print the number only if the number is at least six # Then, switch it to printing the name instead of the number
f = open("studentdata.txt", "r") for aline in f: items = aline.split() if len(items[1:]) > 6: print(items[0]) f.close()

Create a list called destination using the data stored in travel_plans.txt. Each element of the list should contain a line from the file that lists a country and cities inside that country. Hint: each line that has this information also has a colon : in it.
===== from unittest.gui import TestCaseGui class myTests(TestCaseGui): def testFour(self): self.assertEqual(destination, ['Italy: Rome\n', 'Greece: Athens\n', 'England: London, Manchester\n', 'France: Paris, Nice, Lyon\n', 'Spain: Madrid, Barcelona, Granada\n', 'Austria: Vienna\n'], "Testing that destination is assigned to correct values.") myTests().main()

Create a list called j_emotions that contains every word in emotion_words.txt that begins with the letter “j”.
===== from unittest.gui import TestCaseGui class myTests(TestCaseGui): def testOne(self): self.assertEqual(j_emotions, ['joyous', 'jittery', 'jumpy'], "Testing that j_emotions was created correctly.") myTests().main()

10.14.1. Contributed Exercises¶

Please copy-paste your code solution from https://codeclubprojects.org/en-GB/python/robo-trumps/ ~

Q-1: After completing the reading, what concepts are still unclear to you? If nothing is unclear, what did you find most interesting?

Write code that stores the contents of the months list in a file named months.txt. Store one month per line.

Write the contents of the x and y lists to a file called xy2.dat with one value from x and y on each line, separated by a comma.

x = [-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4,
     -0.30000000000000004, -0.19999999999999996, -0.09999999999999998,
     0.0, 0.10000000000000009, 0.19999999999999996, 0.30000000000000004,
     0.3999999999999999, 0.5, 0.6000000000000001, 0.7, 0.8,
     0.8999999999999999, 1.0]

y = [1.0, 0.78, 0.67, 0.51, 0.27, 0.0, 0.14, 0.19, -0.14, 0.03,
     0.03, -0.09, -0.03, -0.12, 0.14, 0.36, 0.57, 0.63, 0.61, 0.59, 1.01]

====
from unittest.gui import TestCaseGui
import re
import math
class myTests(TestCaseGui):
    def testOne(self):

_x = [-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4,
              -0.30000000000000004, -0.19999999999999996, -0.09999999999999998,
              0.0, 0.10000000000000009, 0.19999999999999996, 0.30000000000000004,
              0.3999999999999999, 0.5, 0.6000000000000001, 0.7, 0.8,
              0.8999999999999999, 1.0]

_y = [1.0, 0.78, 0.67, 0.51, 0.27, 0.0, 0.14, 0.19, -0.14, 0.03,
              0.03, -0.09, -0.03, -0.12, 0.14, 0.36, 0.57, 0.63, 0.61, 0.59, 1.01]

_read_x = []
        _read_y = []
        with open('xy2.dat', 'r') as fh:
            for line in fh:
                x, y = line.split(',')
                _read_x.append(float(x))
                _read_y.append(float(y))

self.assertEqual(len(_read_x), len(_x), 'Checking x values')
        self.assertEqual(len(_read_y), len(_y), 'Checking y values')
        for i in range(len(_x)):
            self.assertAlmostEqual(_read_x[i], _x[i], 7, 'Checking x['+str(i)+']')
            self.assertAlmostEqual(_read_y[i], _y[i], 7, 'Checking y['+str(i)+']')
myTests().main()

Generate 101 evenly spaced values between -5 and 5 and compute \(x^3\) of each of these values. Write the result to a file called pow3.csv with one value of \(x\) and \(x^3\) per line, separated by a comma. Your first two lines should look like

-5.,-125.
-4.9,-117.649

The seasonal average monthly rainfall in inches recorded at the Van Nuys Airport as of 2019 are provide in the file van_nuys_seasonal_rainfall.dat. Read in the data from the file and calculate and print out the

total,
mean, and
standard deviation,

each on a separate line.

The standard deviation is given by

\[\sigma = \sqrt{\frac{1}{N-1}\sum_{i=1}^N (x_i - \bar{x})^2 },\]

where \(\bar{x}\) is the mean. You may use the sum function.

2.44
3.12
1.61
0.69
0.23
0.02
0.03
0.02
0.12
0.55
0.69
1.67

====

from unittest.gui import TestCaseGui
import re
class myTests(TestCaseGui):
    def testOne(self):
        rainfall = []
        with open("van_nuys_seasonal_rainfall.dat", 'r') as fh:
            for line in fh:
                rainfall.append(float(line))

output = self.getOutput().split('\n')
        total = sum(rainfall)
        mean = total/len(rainfall)
        sum_sq = 0
        for value in rainfall:
            sum_sq += (value - mean)**2
        stdev = (sum_sq/(len(rainfall)-1))**0.5
        self.assertAlmostEqual(float(output[0]), total, 7, 'Checking total')
        self.assertAlmostEqual(float(output[1]), mean, 7, 'Checking mean')
        self.assertAlmostEqual(float(output[2]), stdev, 7, 'Checking standard deviation')
        if re.search(r'[^#]+= *open', self.getEditorText(), re.M):

self.assertTrue(re.search(r'[^#]+\.close\(', self.getEditorText(), re.M), 'Checking for matching open and close statements')
        else:
            self.assertTrue(re.search(r'with[ (] *open', self.getEditorText(), re.M), 'Checking open statement')

myTests().main()

xy.dat contains two floating point numbers per line, separated by a comma. Read the contents of xy.dat and store the first number of each line in a list called x and the second in a list called y. Values should be stored as floats.

-2.0,3.97
-1.75,2.94
-1.5,2.25
-1.25,1.59
-1.0,0.97
-0.75,0.43
-0.5,0.38
-0.25,-0.13
0.0,0.01
0.25,0.17
0.5,0.13
0.75,0.57
1.0,1.03
1.25,1.51
1.5,2.28
1.75,3.14
2.0,3.97
2.25,5.1
2.5,6.07
2.75,7.56
3.0,8.94

====
from unittest.gui import TestCaseGui
import re
import math
class myTests(TestCaseGui):
    def testOne(self):

_read_x = []
        _read_y = []
        with open('xy.dat', 'r') as fh:
            for line in fh:
                _x, _y = line.split(',')
                _read_x.append(float(_x))
                _read_y.append(float(_y))

self.assertEqual(len(x), len(_read_x), 'Checking x values')
        self.assertEqual(len(y), len(_read_y), 'Checking y values')
        for i in range(len(_read_x)):
            self.assertAlmostEqual(x[i], _read_x[i], 7, 'Checking x['+str(i)+']')
            self.assertAlmostEqual(y[i], _read_y[i], 7, 'Checking y['+str(i)+']')
        if re.search(r'[^#]+= *open', self.getEditorText(), re.M):

How often does “red” and “scarlet” appear in Sir. Arthur Conan Doyle’s “The Study in Scarlet”. Use the scarlet.txt file to determine and return your values as red_count and scarlet_count.

Using altair, plot a histogram of lengths of the words in the words5000.csv file. Your lengths should be saved in a list called list_len and passed to altair.

Using words5000.csv and scarlet.csv . Determine the counts for each part of speech in the story. The counts should be stored in a variable part_count and the parts of speech should be stored in a variable part_o_speech, they should be in the order the appear in the word list. Plot the histogram using altair. If the word isn’t in the 5000 word list skip it in the count.

Using the code from above, create a csv with the part_o_speech and part_count variables. They data should be comma separated and saved to a file named parts.csv

You have attempted of activities on this page

Next Section - 10.15. Chapter Assessment