Go ahead and download the file the “old-fashioned” way by clicking on the URL, just to confirm that it is indeed a text file.

Notice how the actual filename, when you ignore the directories in its path, is the same for the URL as for where I’m telling you to save the file, i.e. ssa-babynames-nationwide-2014.txt

As you might have guessed, there’s a Python helper function to isolate the base filename as a string, for your convenience. Use it if you think it saves you some typing (which, well, is generally one of the best reasons to learn new functions and syntax):

>>> from os.path import basename
>>> basename("/hello/world/file.txt")
'file.txt'
>>> basename("http://www.example.com/whatev/file.txt")
'file.txt'

If you want, you can write downloaded data to the destination path and close the file. Then re-open the file for reading and count the lines, all in the same script. It will happen so fast that you could do it a 100 times without noticable delay.

If you want to feel more graceful about it, you could store the text of the response in a variable:

mytxt = resp.text

Then write the contents of that mytxt variable into the destination file path, i.e. tempdata/ssa-babynames-nationwide-2014.txt…then call the splitlines() method of the mytxt string object, which returns a list of strings based on splitting on the newline character, and call len() on that list:

(on second thought, there’s probably no need to assign a new variable, since the script is so short…)

len(mytxt.splitlines())

Whatever gets you excited about downloading and reading text files…

After this exercise, the other exercises in this set won’t require you to bring in the requests nor the makedirs function. We only need to download the file once.

• Inside the for-loop with which you iterate and read each line of text, you should be calling the string object’s split() method, which pretty much does what it says. Check out the Python documentation for a more detailed explanation.

• When you call the string’s split() function, it returns a list of strings.

• If a string looks like a number – e.g. "42" – it is still a string, i.e. the result of "42" + "42" is probably not what you want it to be. Use one of the number types’s constructor functions – e.g. int() – to convert strings into numbers.

Remember that we can check a string for the existence of a substring with the in keyword:

if "hel" in "hello":
     print("hey there")

If you want to feel especially Pythonic, you can use Python’s “unpacking” feature to assign variables the values in a sequence (e.g. a list or tuple) in a slick one-liner:

name, sex, babies = line.strip().split(',')

I probably should’ve formally covered regular expressions in the lessons by now, as they are exactly the kind of thing we want when the text you’re looking for has some unpredictable variation. Oh well, in this example, we just have to check for the two variations of "Khaleesi".

But feel free to use them if you know them. They are absolutely the best thing to use here.

Even though we haven’t formally learned how to sort a basic Python list, nevermind a list of lists, that won’t be required for this exercise.

By default, the Social Security Administration lists the names in order of gender – "F", then "M", and then by their respective count, in descending order.

This means that the first 5 lines of the file happen to be the first 5 baby girl names with the most babies named. This also means when we iterate through all of the girl names, the first 5 baby boy names will be the 5 most popular baby boy names. So we can do this using an if-statement or two.

However, if you want to do it the proper way, you can check out the Python documentation for the built-in sorted function, including this how-to guide. In later exercises, this is how we will be sorting our sequences.

Pretty much the same thing as exercise b.py

Remember that string objects are sequences, and like lists, can have their last member be accessed using square-bracket notation and the index value of -1.

The way to do this exercise is not to have a massive if/elif/else conditional branch, even though it would technically work.

Instead, use a dictionary, in which its keys are the letters of the alphabet, and the values are the current count of babies for a given letter.

For example, instead of doing this (assuming fileobject is the file of records):

ax = 0
bx = 0
cx = 0
for line in fileobject:
    name, sex, babies = line.strip().split(',')
    last_letter = name[-1]
    if last_letter == 'a':
        ax += int(babies)
    elif last_letter == 'b':
        bx += int(babies)
    elif last_letter == 'c':
        cx += int(babies)

# etc.

Try this:

mydict = {}
for line in fileobject:
    name, sex, babies = line.strip().split(',')
    last_letter = name[-1]
    if mydict.get(last_letter):
        mydict[last_letter] += int(babies)
    else:
        mydict[last_letter] = int(babies)

If you don’t understand the puprose of the if-statement, or the get() method, recall what happens when you try to access a dictionary’s key without it being previously set.

If you feel pretty confident about dictionaries and iterable objects in general, feel free to use the defaultdict or even the Counter types – both of which are in the collections module and offer a few relevant conveniences if you take the time to study and try them out.

For the final part of this exercise, in which you print the list of sums in alphabetical order, remember that you can’t simply iterate through the dictionary of counts like this:

for key, val in mydict.items():
    print(key + ':', val)

This doesn’t work because dictionaries are unordered collections…those keys won’t come out in alphabetical or any non-arbitrary order.

We can get around this by iterating through a sequence that we know to be in alphabetical order, even if we have to create it ourselves:

for letter in 'abcdefg':
     val = mydict[letter]
     # etc

Python has the string module for common string operations, including constants, such as string.ascii_letters which lists all lower and uppercase letters from a to Z. You probably want to use string.ascii_lowercase, rather than manually typing out the alphabet, no matter how well you’ve memorized your abcs:

>>> import string
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'