Check your understanding of the previous reading: primitive and composite types, lists and dataclasses nested inside each other, and working through heavily nested data.

Question 1

Label each of the following as a "Primitive type", "Composite type", or "Not a type":

Boolean

String

List

Attribute

Types created as dataclasses

Value

Integer

Float

None

Return

Not a type: return is a keyword that starts a return statement.

For

Not a type: for is the keyword that starts a loop.

Literal

Not a type: a literal is a value written directly in the code, like 5 or "hello".

Question 2

Question 3

Question 4

Question 5

What is the type of the following expression?

[[0]]

Select one answer, then check.

List of List of Integers
Correct. The outer list has one element, the list [0], which holds the integer 0.
List of Integers
Not quite. That would be [0]; here that list is itself the element of another list.
Integer
Not quite. 0 is an integer, but it sits inside two lists.
Not a valid expression
Not quite. A list can hold other lists, so this is a valid expression.

Question 6

How many elements are in the following list?

from dataclasses import dataclass

@dataclass
class Activity:
    name: str
    high_energy: bool

@dataclass
class Animal:
    name: str
    age: int
    hobby: Activity
    type: str

animals = [
    Animal("Ada", 4, Activity("Fetch", True), "dog"),
    Animal("Babbage", 5, Activity("Napping", True), "dog"),
    Animal("Captain", 1, Activity("Destruction", True), "cat")
]

Select one answer, then check.

0
Not quite. The list is not empty: it holds an Animal instance for each line.
3
Correct. The list holds three Animal instances. Their fields, and the nested Activity instances, are not elements of the list.
4
Not quite. An Animal has four fields, but fields are not elements of the list.
12
Not quite. That counts the four fields of each of the three animals, but fields are not elements of the list.
15
Not quite. That counts every value in the animals, including the fields of the nested Activity instances; the list itself has fewer elements.

Question 7

Given the following code:

from dataclasses import dataclass

@dataclass
class Movie:
    name: str
    length: int
    cast: list[str]

movies = [
    Movie("Jurassic Park", 127, ["Goldblum", "Neill", "Dern"]),
    Movie("Castle in the Sky", 140, ["Paquin", "Beek", "Leachman"]),
    Movie("It", 135, ["Curry", "Green", "Brandis"])
]

What is the value of the following expressions?

Expression	Value
movies[0].name
movies[2].name
movies[0][127]
movies[1][1]
movies[127].name
movies[2].cast[0]
movies[2].cast.Curry
movies[1].cast[2]
movies[2].Curry
movies[-1].length

Expression	Value
`movies[0].name`	"Jurassic Park": the `name` of the first movie
`movies[2].name`	"It": the `name` of the third movie
`movies[0][127]`	Raises an error: `movies[0]` is a `Movie`, which can't be indexed
`movies[1][1]`	Raises an error: `movies[1]` is a `Movie`, which can't be indexed
`movies[127].name`	Raises an error: the list has only three movies, so index 127 is out of range
`movies[2].cast[0]`	"Curry": the first cast member of the third movie
`movies[2].cast.Curry`	Raises an error: `cast` is a list, which has no attribute `Curry`
`movies[1].cast[2]`	"Leachman": the third cast member of the second movie
`movies[2].Curry`	Raises an error: a `Movie` has no field `Curry`
`movies[-1].length`	135: the `length` of the last movie

The next few questions will all use the same code:

from dataclasses import dataclass

@dataclass
class Profit:
    # In millions
    costs: int
    revenue: int

@dataclass
class Movie:
    name: str
    length: int
    profit: Profit
    cast: list[str]

@dataclass
class Theater:
    name: str
    is_open: bool
    showing: list[Movie]

theaters = [
    Theater("Main Street Theater", True, [
        Movie("Jurassic Park", 127, Profit(63, 1046),
            ["Goldblum", "Neill", "Dern"]),
        Movie("Castle in the Sky", 140, Profit(3, 16),
            ["Paquin", "Beek", "Leachman"]),
        Movie("The Notebook", 121, Profit(29, 118),
            ["McAdams", "Gosling", "Rowlands"])
    ]),
    Theater("BlockBuster Cinema", False, [
        Movie("Cats", 110, Profit(100, 75),
            ["Dench", "Corden", "Derulo"]),
        Movie("Morbius", 104, Profit(86, 45),
            ["Leto", "Smith", "Arjona"])
    ]),
    Theater("All Star Movies", True, [
        Movie("Gone with the Wind", 221, Profit(4, 390),
            ["Leigh", "Gable", "Havilland"])
    ])
]

A diagram is also provided to help you understand the data and its relationships.

A class diagram for the Theater, Movie, and Profit relationships

Question 8

Given the code above and the code below:

alpha = 0
for theater in theaters:
    for movie in theater.showing:
        alpha += movie.profit.costs

Inside of the loop body, what are the most accurate types of the following expressions:

Expression	Type
theater
theater.name
theater.length
theater.showing
movie
movie.name
movie.length
movie.profit
movie.profit.costs
alpha

Expression	Type
`theater`	Theater: the loop goes through `theaters`, a `list[Theater]`, one element at a time
`theater.name`	str: the `name` field of a `Theater`
`theater.length`	An error occurs: a `Theater` has no `length` field (a `Movie` does)
`theater.showing`	list[Movie]: the `showing` field of a `Theater`
`movie`	Movie: the inner loop goes through `theater.showing` one element at a time
`movie.name`	str: the `name` field of a `Movie`
`movie.length`	int: the `length` field of a `Movie`
`movie.profit`	Profit: the `profit` field of a `Movie`
`movie.profit.costs`	int: the `costs` field of a `Profit`
`alpha`	int: it starts at `0` and only has integer costs added to it

Question 9

Given the following function:

def alpha(theaters: list[Theater]) -> str:
    for theater in theaters:
        for movie in theater.showing:
            potential = beta(movie)
            if potential < 0:
                return movie.name
    return None

def beta(movie: Movie) -> int:
    profit = movie.profit
    return profit.revenue - profit.costs

What will the expression print(alpha(theaters)) output?

Show worked solution

beta returns a movie's revenue minus its costs. alpha goes through the movies of every theater, open or not, and returns the name of the first movie where that is negative. The Main Street Theater movies all make a profit (983, 13 and 89); the first movie of BlockBuster Cinema, Cats, gives 75 - 100 = -25. So alpha returns "Cats" and print shows Cats.

Question 10

Given the following function:

def unknown(theaters: list[Theater]) -> str:
    theaters = step1(theaters)
    if not theaters:
        return "No results"
    result = step2(theaters)
    return result.name

def step1(theaters: list[Theater]) -> list[Theater]:
    result = []
    for theater in theaters:
        if theater.is_open:
            result.append(theater)
    return result

def step2(theaters: list[Theater]) -> Theater:
    result = theaters[0]
    result_length = theaters[0].showing[0].length
    for theater in theaters:
        for movie in theater.showing:
            if result_length > movie.length:
                result = theater
                result_length = movie.length
    return result

What will the expression print(unknown(theaters)) output?

Show worked solution

step1 keeps the open theaters: Main Street Theater and All Star Movies. That list is not empty, so step2 looks for the theater showing the shortest movie. It starts with Main Street Theater and the length of its first movie, 127. The Notebook (121) is shorter, so the result stays Main Street Theater with 121; Castle in the Sky (140) and Gone with the Wind (221) are longer. unknown returns that theater's name, so print shows Main Street Theater.