Classes

Question 1

What is an object

Answer 1

Everything in Python is an object

An object can contain either or both, a) Attributes, b) Functions

Question 2

What is a class

Answer 2

A class is a blueprint for creating objects

It defines what data (Attributes) and Functions an object should hold

Question 3

Why use a class instead of simply calling functions with different parameters

Answer 3

Classes are a convenient way to not only group related data together (like in a dictionary), but also to attach functions that are specifically designed to operate on that data.

E.g., Python strings are instances of the built-in “str” class. It’s easy to see how convenient it is to have methods such as “str”.replace() & “str”.split() attached to the string-instances.

Classes are not an absolute necessity, but they can be extremely convenient and make your code much easier to read

Question 4

What naming convention should be used when defining a class name

Answer 4

Pascal Case

I.e., all words a joined together and given a capital letter at the start of each word.

E.g., PascalCase

Question 5

Correctly define a class header called “racing car”

Answer 5

class RacingCar:

Question 6

What are the 3 core components included in the body of a class

Answer 6

__init__(self)
Attributes
Functions

__init__() is also a function. It’s used to define the initial state of an object

Question 7

What is __init__(self) for when used in a class

Answer 7

__init__(self) is a function used to define Instance attributes, i.e., the initial state of an object.

This function can take paramaters used to define a unique instance of the class. E.g.,

def __init__(self, price, location, size):
self.price = price
self.location = location
self.size = size

__init__() is called a “constructor” because it’s responsible for constructing the object

Question 8

Define a class called “house” which will accept the paramenters below when creating an instance of this class

price
location

Answer 8

class House:

def __init__(self, price, location):
self.price = price
self.location = location

Question 9

Within the script of a class, how do you create an attribute which cannot be specified as a parameter when creating an instance, but CAN later change so that it differs from other instances of that class

Answer 9

Within the __init__(self) function, type;
self.

E.g.,
def __init__(self):
self.inventory = []

“inventory” could also be included after “self” as a parameter if you wanted to be able to define a unique initial state of an instance of the class at the point of instance creation

Question 10

Create an instance of the class “Backpack()” called “my backpack”

Answer 10

my_backpack = Backpack()

Question 11

Create an instance of the class “Backpack()” called “my backpack” that takes the parameters “color” and “size”

Answer 11

my_backpack = Backpack(color, size)

Question 12

my_backpack is an instance of the class “Backpack()”.

Print the “items” attribute stored from the my_backpack instance.

Answer 12

print(my_backpack.items)

Question 13

The instance with the “name” attribute “Nora” has been created below.

dog = Dog(“Nora”)

Write the next line of code to remove the name of “Nora”

Answer 13

del dog.name

Question 14

A class has the following components

Instance Attributes
Functions
__init__(self)
Class Attributes

I what order should they be layed out in your class

Answer 14

Class Attributes
__init__(self)
Instance Attributes
Functions

Question 15

What’s the difference between Class Attributes and Instance Attributes

Answer 15

Class Attributes: belong to the class itself - changing their value affects all the instances of the class

Instance Attributes: only belong to the instances - changing their value only affects that particular instance of the class

Question 16

How do you define a Class Attribute

Answer 16

Simply the same way you would define a basic variable, but ensuring it’s outside of a function, e.g.,

class Earth:

gravity = 9.81

Question 17

class Earth:
gravity = 9.81

Outside of the Class body script, modify the Class Attribute “gravity” to equal “20”

Answer 17

Earth.gravity = 20

You can also do this using the name of one of the Class instances, E.g, earth_1.gravity = 20

Question 18

Can you assign attributes to any variable in Python.

Answer 18

No, only instances of a class can have attributes assigned to them

Question 19

def __init__(self):

The above function has been used within a class. When will this function execute.

Answer 19

It will execute immediately when an instance of this class is created.

It will execute for EVERY instance created

E.g., so if there is a print() function within this function, it will actually print to the terminal everytime an instance of the class is merely created

Question 20

Everything in Python is technically an object — but in the context of Object-Oriented Programming (OOP), what does the term “object” specifically refer to

Answer 20

An instance of a class

Question 21

The instance below has been created with the “color” parameter as “blue”.

my_backpack = Backpack(“blue”)

Now write the next line of code that changes the color attribute of my_backpack to “green”

Answer 21

my_backpack.color = “green”

Question 22

class Dog:
species = “Canis lupus”

In your main class script, how would you print the class attribute “Canis lupus” from the class “Dog” above

Answer 22

print(Dog.species)

Question 23

class Car:
def __init__(self)

Add a counter called “id_counter” to the class “Car” above which will assign each instance a unique ID

Answer 23

class Car:
id_counter = 1
def __init__(self):
self.id = Car.id_counter
Car.id_counter += 1

Question 24

“Encapsulation” is one of the 4 core principals or Object Oriented Programming (OOP)

What is the main purpose of Class “Encapsulation”

Answer 24

To prevent direct access to the attributes in order to avoid making problematic changes

Question 25

"Abstraction" is one of the 4 core pricipals of OOP What is the main purpose of Class "Abstraction"

Answer 25

To hide unnecessary details and expose only the important parts of a class So users can interact with it more easily

Question 26

In OOP, what is a "Public" vs "Internal" vs "Name-mangled" Instance Attribute, and what are the naming convensions

Answer 26

Public: An **Instance** attribute that's intended for the class user to modify if desired (e.g., self.name) - It's a normal attribute Internal: An **Instance** attribute where modification is merely **discouraged** (e.g., self._name) Name-mangled: An **Instance** attribute that's not *at all* intended for the class user to modify (e.g., self.__name)

Question 27

How do you create an **Internal** *Instance* Attribute

Answer 27

class Car: def __init__(self, brand) self._brand = brand | I.e., 1 underscore before the attribute's name

Question 28

In OOP, what is a "getter" Write an example

Answer 28

A "getter" is a method that lets you **safely** read the value of an "Internal" or "Name-mangled" Instance Attribute. class BankAccount: def __init__(self): self.__balance = 0 **def get_balance(self): return self.__balance** ## Footnote The naming convention of a getter is "get_xxxxxxxx(self)

Question 29

In OOP, what is a "setter" Write an example

Answer 29

A "setter" is a method that modifies the value of an internal attribute while avoiding invalid modifications by first validating the new value before assigning it to the attribute. class BankAccount: def __init__(self): self.__balance = 0 **def set_balance(self, amount): if amount >= 0: self.__balance = amount** ## Footnote The naming convention of a setter is "set_xxxxxxxx(self, xxxx)"

Question 30

In OOP, what is "Inheritance" Give an example of "Method Overriding"

Answer 30

Inheritance allows one class (child/subclass) to reuse the attributes and methods of another class (parent/superclass) — promoting code reuse and organization class Animal: def __init__(self, name): self.name = name **def speak(self):** return f"{self.name} makes a sound." class Dog(Animal): **def speak(self):** return f"{self.name} says Woof!" ## Footnote When you define a method with the same name in a subclass (Dog) as one that exists in the parent class (Animal), you’re not adding a second version — you're replacing the original one. Python will always look in the child class first when you call a method. If it finds it there, it uses that version and ignores the parent's. The parent’s speak() method is still there — but it’s hidden (overridden) when you're dealing with a Dog object.

Question 31

Define a method that updates an attribute of **another object** (E.g., transferring money between two accounts — where the method updates both the sender’s and the receiver’s account balances)

Answer 31

Example: def transfer(self, amount, **other_account**): **self.**balance -= amount **other_account.**balance += amount

Question 32

What does the "__init__" in the "__init__" function actually do

Answer 32

It causes the script in the "__init__" function to execute immediately upon creation of a new instance of the class ## Footnote So whatever you want to be executed immediately, should be included within this function

Question 33

Override the "speak()" method from the parent class "Animal" (shown below) to return "Meow" class Animal: def speak(self): return "Some sound"

Answer 33

class Animal: def speak(self): return "Some sound" class Cat(Animal): def speak(self): return "Meow" ## Footnote pet = Cat() print(pet.speak()) # Output: Meow You override a method by redefining it in a subclass

Question 34

In OOP, what does "self" refer to

Answer 34

the specific instance