Ownership and leaks

Questions 1 to 5 of 6

1. 1. What does this program print? ``python import weakref class Image: pass ref = weakref.ref(Image()) print(ref()) ``

   The Image object, because a weak reference keeps its object aliveNoneAn empty list that must be unwrapped before useA new Image built again from the class name
2. 2. The program below prints True. What does that True tell you? ``python import gc import weakref class Session: def __init__(self, id): self.id = id registry = [] item = Session(7) probe = weakref.ref(item) registry.append(item) item = None gc.collect() print(probe() is not None) ``

   The collector ignores weak references while a list existsThe Session class has a bug, and gc.collect() always keeps a valueSomething still holds the object, such as the module-level list registryThe object is a string, so it can never be freed
3. 3. What does this program do when it runs? ``python import weakref class Image: def __init__(self, name): self.name = name cache = {} cache['hero'] = weakref.ref(Image('hero')) print(cache['hero']().name) ``

   cache['hero']() returns None, because nothing else holds the image, so .name raises AttributeErrorA dictionary cannot hold a weakref as a value, so the assignment raises TypeErrorweakref.ref needs a second argument for the name, so the line raises TypeErrorIt prints hero, because the dictionary keeps the image alive
4. 4. Each request calls the function below, and eventually the program fails with MemoryError. Why does calling gc.collect() not help? ``python import gc cache = [] def handle_request(): cache.append(bytearray(1_000_000)) gc.collect() ``

   gc.collect() only runs once, when the program startsbytearray objects can never be freed in PythonThe list must be replaced by a dict before the collector can see the buffersThe module-level name cache keeps every buffer reachable, and the collector never frees an object that a live name reaches
5. 5. True or false: after del obj, a WeakValueDictionary entry for obj is removed at once, with no gc.collect() call, if nothing else holds obj and it is not in a reference cycle.

   False, because the entry stays until the cyclic collector runsTrue, because the last strong reference went, so CPython frees the object and removes its entry