Check your understanding of the previous reading: dataclass syntax and terminology, how fields are accessed, and when dataclass instances are equal.

Question 1

Given the following dataclass:

from dataclasses import dataclass

@dataclass
class Assignment:
    name: str
    points: int
    late: bool

The dataclass has fields. The type of the first field is . The name of the last field is . The name of the constructor function used to create instances is .

Word bank — not all words are used

Question 2

Which of the following parts of a dataclass definition are required?

Select every option that applies, then check.

The dataclass decorator
Correct. Without @dataclass above the header, Python treats the class as an ordinary class, not a dataclass.
The dataclass import
Correct. @dataclass is not built in; you must from dataclasses import dataclass before using it.
The name of the dataclass
Correct. Like any class, it needs a name - this name also becomes the constructor function's name.
The class keyword
Correct. A dataclass is still defined with Python's class keyword; the decorator only adds extra behavior on top.
A field named name with the type str
Not required. Fields can be named and typed however you like - Box (width, length) and Dog (name, age, is_fuzzy) from the reading don't share this shape.
At least three fields
Not required. A dataclass can have any number of fields, including zero or one.
Indentation under the header
Correct. As with any Python class, the body (the fields) must be indented under the header.
An if statement
Not required. Dataclass bodies list fields; they don't need any control flow.

Question 3

Match each term to the best definition. Not every term is used.

Definition	Term
A data structure for combining multiple kinds of data together to represent something
A synonym for field
A named bit of data inside of a dataclass
The @dataclass above the header
A specific, concrete version of a general dataclass with actual values
A function automatically created when you define a dataclass that allows you to make instances

Definition	Term
A data structure for combining multiple kinds of data together to represent something	Dataclass
A synonym for field	Attribute
A named bit of data inside of a dataclass	Field
The @dataclass above the header	Decorator
A specific, concrete version of a general dataclass with actual values	Instance
A function automatically created when you define a dataclass that allows you to make instances	Constructor

Question 4

In the following code, what value will be printed?

from dataclasses import dataclass

@dataclass
class House:
    color: str
    address: str

print(House.color)

Select one answer, then check.

Nothing, an error will occur because you are accessing the field of the dataclass instead of an instance
Correct. A field's type annotation (color: str) does not give the dataclass itself a color value - only an instance, created with the constructor, has actual field values. House.color raises an AttributeError.
The type, str
Not quite. Python doesn't store the annotation as an accessible value on the class this way; accessing House.color raises an error instead.
The empty string, which is the default for strings
Not quite. Fields have no default value unless you write one explicitly; House doesn't set any defaults here.
The text red, because Python knows that our house is red
Not quite. No instance was ever created, so there is no house, red or otherwise, for Python to know about.
Nothing, an error will occur because you did not unit test the constructor function
Not quite. An error does occur, but unit testing has nothing to do with it - the problem is accessing a field on the class instead of on an instance.

Question 5

In the following code, what value will be printed?

from dataclasses import dataclass

@dataclass
class Tree:
    height: float
    age: int
    kind: str

spruce = Tree(25.7, 12, 'Spruce')

print(spruce.height)

Select one answer, then check.

The value 25.7, because the height field will have that value
Correct. The constructor fills fields positionally, in the order they're defined - height is first, so it gets 25.7. Accessing spruce.height reads that value back.
The value 12, because the fields will be alphabetically ordered in the constructor
Not quite. Fields are matched to constructor arguments in the order they're written in the class body, not alphabetically.
The value Spruce, because you can only print strings
Not quite. print can display any type of value, not only strings, and the code accesses .height, not .kind.
The text Tree(height=25.7, age=12, kind='Spruce'), because you can only print the entire dataclass, not its fields
Not quite. That is what printing spruce itself would show - but the code prints spruce.height, one specific field, which is perfectly legal.
Nothing, an error will occur because you are accessing the field of an instance, instead of the dataclass
Not quite. It's the reverse: accessing a field on an instance is exactly how fields are meant to be read; it's accessing a field on the dataclass itself (like Tree.height) that fails.

Question 6

Which of the following are advantages of a dataclass?

Select every option that applies, then check.

Dataclasses allow us to combine multiple types of values into a single new type
Correct. That's the core idea: bundling related fields, possibly of different types, into one type.
Instances of a dataclass can be printed to see what they contain
Correct. Printing an instance (like my_box in the reading) shows all of its fields and their values.
Dataclasses are faster than functions, and do the same thing only better
Not quite. Dataclasses and functions do different jobs (bundling data vs. running code) - one isn't a faster replacement for the other.
Dataclasses are faster than if statements, and do the same thing only better
Not quite. Dataclasses don't make decisions the way if statements do - they aren't a substitute for conditionals at all.
Dataclasses do not require any imports, so they are very easy to write like if statements and function definitions
Not quite. Dataclasses always need from dataclasses import dataclass; if statements and function definitions need no import at all.
You can make any number of instances based on a single dataclass definition
Correct. One definition, like Dog, can be used to create as many instances as you like, each with its own field values.