Objective

In this unit, we will dive deeper into Object-Oriented Programming (OOP) by focusing on methods within classes. We'll explore the __init__ method, instance methods, and the distinction between class variables and instance variables. By the end of this unit, you'll understand how to create and use methods in classes and how to work with different types of variables in a class.

Understanding Methods

Methods are functions defined within a class that operate on the attributes of the class or perform specific actions related to the class. They are essential in OOP as they define the behaviors that objects of the class can perform.

The __init__ Method

The __init__ method is a special method in Python known as the constructor. It is automatically called when an object is created from a class and is used to initialize the attributes of the object. Here's an example:

class Circle:
    # constructor initialization method
    def __init__(self, radius):
        # `self` is automatically passed in by Python and is a reference
        # to the current object.
        self.radius = radius
        
     
# Create a Circle object with the radius attribute set to 10.
c = Circle(10) 

When you create a Circle object, you pass the radius value, and the __init__ method sets the radius attribute of the object.

NOTE: The first argument of the constructor __init__ method, as well as all instance methods, is not passed in by the caller. It's a reference to the object itself and is automatically passed in by Python.

Instance Methods

Instance methods are functions defined within a class that take at least one argument: self, which refers to the object itself. These methods can access and modify the attributes of the object.

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

The area method is an instance method that calculates the area of the circle.

Class Variables vs Instance Variables

In Python classes, there are two types of variables: class variables and instance variables.

• Class Variables: Shared by all objects of the class. If you change the value of a class variable, it changes for all objects of the class.
• Instance Variables: Unique to each object. Each object has its own copy, and changes to an instance variable only affect that specific object.

Here's an example that illustrates the difference:

class Circle:
    pi = 3.14  # Class variable

    def __init__(self, radius):
        self.radius = radius  # Instance variable

    def area(self):
        return Circle.pi * self.radius ** 2

In this example, pi is a class variable, and radius is an instance variable.

Project: Add Methods to Your Shape Class to Calculate Perimeter, Area, and Draw the Shape Using Turtle

In this project, you'll enhance the Shape class from the previous unit by adding methods to calculate the perimeter and area of the shape, and to draw the shape using the Turtle library.

import turtle

class Shape:
    def __init__(self, turtle, sides, length):
        self.t = turtle          # turtle instance
        self.sides = sides
        self.length = length

    def perimeter(self):
        return self.sides * self.length

    def area(self):
        import math
        return (self.sides * self.length ** 2) / (4 * math.tan(math.pi / self.sides))

    def draw(self):
        for _ in range(self.sides):
            self.t.forward(self.length)
            self.t.right(360 / self.sides)

# Create a new turtle screen and set its background color
screen = turtle.Screen()
screen.setup(width=800, height=600)
screen.bgcolor("white")

# Initialize a turtle object
t = turtle.Turtle()

# Create a Shape object, passing in the turtle object, sides and length
hexagon = Shape(t, 6, 50)

# Draw the shape
hexagon.draw()

# Print perimeter and area to the Turtle screen
t.penup()
t.goto(-150, -150)
t.pendown()
t.write(f"Perimeter: {hexagon.perimeter()}", font=("Arial", 16, "normal"))
t.penup()
t.goto(-150, -175)
t.pendown()
t.write(f"Area: {hexagon.area()}", font=("Arial", 16, "normal"))

# Hide the turtle and wait until the window is closed
t.hideturtle()
turtle.done()

In this code, we've added two new methods to the Shape class: perimeter and area. The perimeter method calculates the perimeter of the shape by multiplying the number of sides by the length of each side. The area method calculates the area using a formula that involves the number of sides, the length of each side, and the tangent function from the math module.

We then create a Shape object representing a hexagon and use the new methods to print its perimeter and area, and draw the shape using the Turtle library.

In the next unit, we'll explore inheritance in object-oriented programming, allowing us to create new classes based on existing ones.