ICS 33 Spring 2025
Exercise Set 8
Due date and time: Friday, June 6, 11:59pm
Final late work deadline: Late submissions are not accepted
Getting started
First of all, be sure that you've read the Reinforcement Exercises page, which explains everything you'll need to know, generally, about how the reinforcement exercises will work this quarter. Make sure you read that page before you continue with this one.
Problem 1 (3 points)
Earlier this quarter, we saw that Python provides a built-in decorator @classmethod, which specifies that a method in a class shouldn't be subject to the usual rules that it be called on an object of that class and that this target object be passed into a leading self parameter. Instead, the class is passed into a leading cls parameter. When we first learned about this technique, it was somewhat magical; we had no way to explain how it might work, because we lacked the understanding of the details that underlie it. However, we're not in that position anymore, so it's worth revisiting that idea to make sure we understand how it relates to things we've learned in the weeks since. What better way to understand how it works than to implement it using the techniques we've since learned?
Write a decorator named @class_method that, when used on a function defined within a class (i.e., a def statement nested immediately within a class statement), converts it into a class method, meaning two things.
The method can be called on the class as a whole, rather than on an object of that class.
Whether called on the class as a whole or an object of that class, its first parameter will be the class, rather than an object of that class. In other words, rather than having a self parameter, it has a cls parameter.
When you've finished with it, you'd expect it to work as follows.
>>> class Thing:
... @class_method
... def foo(cls, x, y):
... return (cls.__name__, x + y)
...
>>> Thing.foo(11, 7)
('Thing', 18)
>>> Thing().foo(11, 7)
('Thing', 18)
It's safe to assume that your @class_method decorator will only be used on methods (i.e., on def statements immediately nested within class statements). It is irrelevant how it works when it's used anywhere else.
Limitations
The Python standard library is entirely off-limits in this problem. Your function must not require any module to be imported.
Built-in decorators, such as @classmethod or @staticmethod, are also off-limits, since that's what we're asking you to implement here.
What to submit
Submit one Python script. named problem1.py, which contains your decorator and nothing else. Neither docstrings, comments, nor type annotations are required, since we've all agreed already on what problems we're solving here.
There is no credit being offered for writing automated tests — though you certainly might want to, since that's a great way to ensure that your code works as you expect — and we'd prefer you not submit them even if you do.
Problem 2 (2 points)
During our conversation about Class Design, we learned about three dunder methods that allow a class to modify how attribute lookup rules are applied to its objects: __getattr__, __setattr__, and __delattr__. One difference that emerged between them is the circumstances in which they're used; we could summarize that difference as follows.
__getattr__ is called only if looking up an attribute in an object's dictionary fails (i.e., if that attribute is not present).
__setattr__ and __delattr__ are called regardless of whether the attribute is present in the object's dictionary.
In no more than a couple of sentences, briefly explain why you think Python handles __getattr__ differently from __setattr__ and __delattr__, rather than handling all of these dunder methods identically.
What to submit
Submit one PDF named problem2.pdf, which contains your answer to this question.
Problem 3 (3 points)
Write a class named LimitedString meeting the following requirements.
Constructing a LimitedString requires one positional argument that specifies a maximum length. This maximum length must be a non-negative integer; anything else should cause a ValueError to be raised.
A LimitedString object is a descriptor that can be used to enforce that an object attribute's value is a string, and that its length is no longer than the maximum length.
If an optional keyword argument can_delete is passed when constructing a LimitedString, it controls whether an attribute described by it can be deleted from an object — True if it can, or False if it cannot. (If can_delete is False, deleting the attribute causes an AttributeError to be raised.)
After you're finished, you would expect the following behavior. from it.
>>> class Thing:
... name = LimitedString(10)
...