PCPP1™ – Certified Professional in Python Programming 1 (PCPP-32-101) - Python

Composition is an object-oriented design concept that models a has-a relationship. In composition, a<br />
class known as composite contains an object of another class known as component. In other words, a<br />
composite class has a component of another class1.<br />
<br />
1. Composition allows a class to be projected as a container of different classes.<br />
Composition is a concept in Python that allows for building complex objects out of simpler objects, by aggregating one or more objects of another class as attributes. The objects that are aggregated are generally considered to be parts of the whole object, and the containing object is often viewed as a container for the smaller objects. In composition, objects are combined in a way that allows for greater flexibility and modifiability than what inheritance can offer. With composition, it is possible to create new objects by combining existing objects, by using a container object to host other objects. By contrast, with inheritance, new objects extend the behavior of their parent classes, and are limited by that inheritance hierarchy.<br />
<br />
Reference: Official Python documentation on Composition: https://docs.python.org/3/tutorial/classes.html#composition GeeksforGeeks article on Composition vs Inheritance: https://www.geeksforgeeks.org/composition- vs-inheritance-python/ Real Python article on Composition and Inheritance: https://realpython.com/inheritance- composition-python/

In the given code snippet, an instance of OwnMath exception is raised with an explicitly specified __cause__ attribute that refers to the original exception (ZeroDivisionError). This is an example of explicitly chaining exceptions in Python.

The correct answer is C. Excalibur is the value passed to an instance variable. In the given code snippet, self.name is an instance variable of the Sword class. When an instance of the Sword class is<br />
created with varl = Sword('Excalibur'), the value 'Excalibur' is passed as an argument to<br />
the __init__ method and assigned to the name instance variable of the varl object. The code defines a class called Sword with an __init__ method that takes one parameter name.<br />
<br />
When a new instance of the Sword class is created with varl = Sword('Excalibur'), the value of the 'Excalibur' string is passed as an argument to the __init__ method, and assigned to the self.name instance variable of the varl object.<br />
<br />
Reference: Official Python documentation on Classes: https://docs.python.org/3/tutorial/classes.html

The given code snippet demonstrates the concept of encapsulation in object-oriented programming. Encapsulation refers to the practice of keeping the internal state and behavior of an object hidden<br />
from the outside world and providing a public interface for interacting with the object. In the given<br />
code snippet, the __init__ and get_balance methods provide a public interface for interacting with instances of the BankAccount class, while the __balance attribute is kept hidden from the outside world by using a double underscore prefix.

In the given code snippet, the repeat function is a decorator that takes an argument num_times specifying the number of times the decorated function should be called. The repeat function returns an inner function wrapper_repeat that takes a function func as an argument and returns another inner function wrapper that calls func num_times times. The provided code snippet represents an example of a decorator that accepts its own arguments. The @decorator_function syntax is used to apply the decorator_function to the some_function function. The decorator_function takes an argument arg1 and defines an inner function wrapper_function that takes the original function func as its argument. The wrapper_function then returns the result of calling func, along with the arg1 argument passed to the decorator_function.<br />
<br />
Here is an example of how to use this decorator with some_function: @decorator_function("argument 1") def some_function():<br />
return "Hello world"<br />
<br />
When some_function is called, it will first be passed as an argument to the decorator_function. The decorator_function then adds the string "argument 1" to the result of calling some_function() and returns the resulting string. In this case, the final output would be "Hello world argument 1".<br />
<br />
Reference: Official Python documentation on Decorators: https://docs.python.org/3/glossary.html#term- decorator