Unit 3 - Data Structures: Strings and Lists

Table of Contents

1. Strings; Slicing
2. String Methods
3. String Formatting
4. Lists; Looping through a list
5. Applications using Lists
6. Nested loops

3.0. Strings and Slicing

3.0.0. Overview

We've spent some time looking at numbers in Python— int and float values. Now we can turn out attention to looking at two different types of data collections: strings (str) and lists (list).

In both cases, individual elements of the structure can be referred to by their index, or position, starting at position 0.

Let's get started!

3.1. Basic Strings and Slicing

Strings are simply a sequence of characters, and we can easily refer to them by their index, or position in the string.

3.1.1. Additional string operations

In addition to slicing, there are a number of string operations that may be useful:

Of these operations, being able to determine the length of a string and being able to concatenate two strings are definitely among the most valuable.

3.1.2. ASCII, and converting strings to numbers

The American Standard Code for Information Interchange (ASCII) represents all alphanumeric characters has coded number, which is how every character that we type, or view on the screen, or keep in a file, gets represented in the memory of the computer. It's occasionally convenient for us to be able to convert from a character to its ASCII code, and back again.

Let's see what some of those ASCII codes look like.

We can use ord, chr, and float to do various conversions:

3.2. String Methods

3.2.0. Overview

Objects like strings (value of the str type) in Python come with a set of built-in functions called methods. We can use string methods to interact with strings.

3.2.1. Methods

In a couple of weeks we're going to introduce the idea of an object. In Python, just about everything is an "object," and objects may be grouped into classes. The objects "Richard", "Fletch", and "Ms. Bush" are all objects of the class str (strings). The function main() is an object of the class function. The values 3, 17, and -204 are all objects of the class int (integers).

Later on we'll go over this in more detail, and learn how we can even design our own classes so that we can create our own objects. For now, though, it's important to realize that most of these objects have methods that allow you to do stuff with the object.

Because we're looking at strings right now, let's take a look at some string methods that you can use to manipulate the string in question.

Here are some other string methods that you may find useful at some point.

3.2.2. Practical Use of String Methods

Let's take a look at one quick use of one of the string methods that we might be able to use right away.

In writing programs, you'll have occasion to ask the user to respond to a "yes or no" question. What's one way that we can check their response?

This will work, perhaps, but what if they just enter a "Y" instead of the full word "Yes"? You might suggest that they follow the directions more carefully, but in the interests of keeping our program running more cleanly, perhaps we could do this:

But what if they type "Yes" now? "Yes" is not equal to "Y". But maybe this will work...

That looks at the first character of the string and checks to see if it's a "Y". But what if they enter a lower-case "y"?

This is the answer we want. It'll accept a broad range of responses without failing—"Yes","YES","Y","yes","y", and even "yeah"—and give our program the best chance of continuing uninterrupted.

One other common strategy is to give the user a default value that will be automatically selected if s/he just hits the <Enter> key. (This default value in a text interface is usually indicted by capitalizing it.) When a string is expected and the <Enter> key is pressed, the null string ('' or "") is stored in the variable. We can use check to see if the default value was entered by looking for the null string or if the first character is a y.

Note that this statement works as intended, although a slight variation on it will not. Take a look at this version of the same condition:

It turns out that this won't work. If the user hits the [Enter] key without entering anything, keep_going has a value of "". As Python works its way across that expression, evaluating it, it first tries to examine the 0th character of that string, it can't find one, and the program fails.

If we check for the null character "" first, however, Python evaluates the boolean expression in order from left to right. If the left boolean check, keep_going == "" is True, Python knows it doesn't need to evaluate the right part of an or expression: once one of the expressions is True, the whole things is True, and Python moves on without bothering to run the rest of the statement.

Enter a sentence, and keep it clean! This poopy computer is a darn pain!
You wrote: This poopy computer is a darn pain!
Censored : This ****y computer is a **** pain!
See, I fixed it for you!

3.3. String Formatting

3.3.0. Overview

Sometimes, you want to get your output printed out just right, with spacing and alignment that you've specified. Let's see a few examples of how you can do that.

3.3.1. Formatting Output

Up to this point, we haven't worried very much about the format of our output—simple print statements have worked just fine.

If you do need to make your output look nice, or print data in columns, you can use Python3's formatting method, .format.

Note that there are a much wider variety of format possibilities available than what is listed here. For example, this snippet produces a very nicely formatted table:

See the Python3 documentation for further information on how to use print formatting.

3.3.2. Program Design Exercise

3.2.2.0. "Compare each pair" solution

Write a series of 3 if statements: one to identify if a is the largest, one to identify if b is the largest, and one for c.

Show/hide solution 1

3.3.2.1. Multibranch "decision tree" solution

Use if-else statements nested inside of an if-else statement.

Show/hide solution 2

3.3.2.2. "Sequential comparisons" solution

Use a variable called max to store the largest variable.

Show/hide solution 3

3.3.2.3. Python max solution

Show/hide solution 4

3.4. Lists, and Looping through lists

3.4.0. Overview

One of the most powerful data structures in Python is the list, a sequential collection of items.

3.4.1. Lists

The list (called an array in most other programming languages) is an incredibly useful and powerful data type. It allows us to refer to a collection of data using a single variable.

3.4.2. Intro to lists

3.4.3. Using lists

3.4.3.0. Iterating through a list

How are lists so powerful? Just as we've used a for loop to run through a range of numbers, we can easily set up a loop to run through a series of items in a list.

3.4.3.1. Some list operations

3.4.3.2. Finding the largest value

A lesson or two back, we looked at some ways to try to identify the maximum of three values that had been entered. Let's see if we can use a list to do a better job with that problem.

3.4.3.3. Some additional list methods, operations, and strategies

3.5. Applications using lists

3.5.0. Overview

Now that we know a little bit about how to interact with lists, let's figure out some of the ways they can actually be used.

Sometimes it's useful to be able to make a short list of items and then use that list of items to help solve a larger problem.

In this next problem, we're going to use a list of the vowels (not including 'y'): vowels = ['a','e','i','o','u']. We're also going to use a powerful boolean operator in to identify when a letter is in that list:

3.5.1. Finding Divisible Numbers

Up to this point we've been using relatively simple examples of lists. Let's examine some more serious applications of lists.

The % (mod) operator calculates the remainder from an integer division.

One obvious application for this operation is to determine whether one number is easily divisible by another.

Expanding on this idea:

3.5.2. Identifying if a number is prime

Based on what we know, write the following program.

Now, let's think about expanding on that idea.

3.5.3. Lists and Strings

You may find it useful to convert from strings to lists, or vice versa.

3.6. Nested loops → Loop inside a loop

Just as we can nest if-else statements inside other if-else statements to work on multiple levels of a problem, we can nest loops inside other loops.

Pseudocode example: Going through a document word by word

Pseudocode example: finding the total assets of a bank

3.6.1. Nested counting loops

Here's a more practical example of a nested loop. This one demonstrates an odometer effect.

3.6.2. More nested loops

Let's try writing another nested loop and using it to print a two-dimensional object on the screen.

Once you've master the basic boxy function, try this one:

3.6.3. Nested loops for traversing a grid

One very common type of loop pattern involves using two loops to work through a 2-dimensional grid or table.

Generally:

There are a lot of uses for such a nested loop. Here's a practical one:

3.6.4. Nested loops for creating a grid

In the previous multiplication table example we didn't actually have a "grid" that we went through—we just printed out some numbers in table form.

Let's actually create a table of that information, using a "list of lists."

In this important data-storage strategy, we'll have a table list that keeps track of each row in the table:

These are presented here as rows going down the screen, but that's just a convenient way of writing it to help us visualize what's happening.

So, I can put any kind of data that I want into each of the rows in that list, and what I'm going to do is put in another list for each of those row elements. After doing that, it looks like this:

We can access any of those pieces of data—any col, in any row of the table—in this way:

And how would we access every element in the table, one at a time?

#!/usr/bin/env python3
"""
multiplication_table.py
This program creates a multiplication table as a "list of lists."
"""

__author__ = "Richard White"
__version__ = "2022-09-06"

def main():
    grid = []
    ROWS = 11
    COLS = 13
    
    # Create the table
    for row in range(ROWS):
        grid.append([])                     # Put a row in the table
        for col in range(COLS):      
            grid[row].append(row * col)     # For this row, append a new col

    # Print the table
    for row in range(ROWS):                 # For every row...
        for col in range(COLS):             # ... and for every col in that row...
                                            # print out the entry, with formatting
                                            # so that they all line up nicely
            print("{0:4d}".format(grid[row][col]), end='')
        print()                             # at end of row, move to next line
         

if __name__ == "__main__":
    main()