Records and Tuple

Announcements

• Project 2: Breakout was due yesterday
• Problem set 5 is posted and is due next week Tuesday at 10pm!
• Grading for Problem Set 4 will be returned later this week!
• Two Polls today on this link https://www.polleverywhere.com/agbofred203

Review 1!

My name is Inigo Montoya.
You killed my father.
Prepare to die.

with open('PBride.txt') as f:
    for line in f:
        w = line.split()
        if w[0] == "You":
            print(w[-1])

c = read('PBride.txt')
print(c.find("father"))

with open('PBride.txt') as f:
    c = f.read().splitlines()
    print(c[1][4])

with open('PBride.txt') as f:
    c = f.read()
    i = c.find("f")
    print(c[i:i+6])

Review 2!

Suppose you had the file contents to the left and wanted to turn it into the contents on the right. Which code snippet below would accomplish this?

food

fooddoof

with open(file) as fh:
    data = fh.read()
with open(file, 'w') as fh:
    fh.write(data[::-1])

with open(file) as fh:
    data = fh.read()
with open(file, 'a') as fh:
    fh.write(data[::-1])

with open(file, 'rw') as fh:
    data = fh.read()
    fh.write(data[::-1])

with open(file) as fh:
    data = fh.read()
with open(file, 'a') as fh:
    fh.write(data[-2::-1])

Its a Record!

Old Records

• Records are a very old idea, dating back to the 19th century BCE
• In 2017, researchers established that the below tablet, called the Plimpton 322 tablet, records Pythagorean triples!

Recording Dickens

• Suppose we had some records from the two-employee firm Scrooge and Marley
• Each contains the employee name, their title, and their salary

Tuple Time

• In Python, the simplest strategy for representing a record uses the built-in type tuple
  • Comes from terms like quintuple or sextuple, that denote fixed-size collections
• An ordered, immutable sequence of values
• Feel similar to lists, except immutable, and thus used very differently
  • Think of tuples as records
• Created by enclosing a collection of elements in parentheses employee = ("Bob Cratchit", "clerk", 15)
• Stored internally similarly to a list, so each element has a corresponding index

Tuple Usage

• Can largely envision tuples as sitting between strings and lists
  • Immutable, like strings
  • Elements can be anything, like lists
• Common operations mimic that of strings
  • Can concatenate with addition
  • Can duplicate by multiplying by an integer
  • Can index and slice them
  • Can loop over them directly or via index
• A tuple of a single value needs a comma at the end in order to be a tuple

Tuple Selection

• You can select or slice elements from a tuple just like you can with lists

  • Unfortunately, records are not usually ordered in a particular way. Rather, it is the field name that is usually important

• If using tuples, you can make programs more readable by using a destructuring assignment, which breaks a tuple into named components:

  name, title, salary = employee

• While modern versions of Python have such thing as a named tuple, we will not look at them here.

  • The more general strategy is to define a new data type (class) to better represent the objects in question

Pointy Tuples!

Yarn Tuples

Expanding…

In Code

from pgl import GWindow, GLine, GRect

PEG_SEP = 3
PEG_ACROSS = 300
PEG_DOWN = 150
DELTA = 332

GWIDTH = PEG_ACROSS * PEG_SEP
GHEIGHT = PEG_DOWN * PEG_SEP

def place_pegs():
    """ Returns a list of points, where the points are tuples. """
    list_pts = []
    for i in range(PEG_ACROSS):
        list_pts.append((i * PEG_SEP, 0))
    for i in range(PEG_DOWN):
        list_pts.append((GWIDTH, i * PEG_SEP))
    for i in range(PEG_ACROSS):
        list_pts.append((GWIDTH - i * PEG_SEP, GHEIGHT))
    for i in range(PEG_DOWN):
        list_pts.append((0, GHEIGHT - i * PEG_SEP))
    return list_pts

def draw_pattern(list_pts, color='black'):
    """ Creates a window and draws in the necessary yarn. """
    gw = GWindow(GWIDTH, GHEIGHT)
    current_i = 0
    finished = False
    while not finished:
        next_i = (current_i + DELTA) % len(list_pts)
        x1, y1 = list_pts[current_i]
        x2, y2 = list_pts[next_i]
        line = GLine(x1, y1, x2, y2)
        line.set_line_width(2)
        line.set_color(color)
        gw.add(line)
        current_i = next_i
        if current_i == 0:
            finished = True

if __name__ == '__main__':
    pegs = place_pegs()
    draw_pattern(pegs, 'green')

Returning Tuples

• Tuples give us a convenient way to return multiple objects from a function
  • return x, y is the same as return (x,y)
• Several Python built-in functions return tuples, of which a few are particularly useful
  • enumerate
  • zip

Enumerating

• We have multiple ways to iterate through a string or list:

  • By element:

    for ch in string:
        # body of loop using ch

  • By index:

    for i in range(len(string)):
        # body of loop using i

• Using enumerate lets us get both!

  for i, ch in enumerate(string):
      # body of loop using both ch and i

Zipping

• Sometimes you have multiple lists that you want to loop over in a “synced” fashion

• The zip function iterates through tuples of pairs of elements

• For example

  zip([1,2,3], ["one", "two", "three"])

  would yield (1, "one"), then (2, "two"), and then (3, "three")

• Can unpack or destructure as part of a for loop:

  for x,y in zip([1,2,3],[4,5,6]):
      # body of loop using paired x and y