Skip to content

Printing Object Attributes in Python


Class Anatomy: Attributes and Methods

In this chapter, we will explore the anatomy of a class in Python, including its attributes and methods. Understanding how classes work is fundamental to object-oriented programming and will be essential for creating your own classes and objects.

What is Object-Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a programming paradigm that focuses on the creation and manipulation of objects, which are instances of classes. OOP allows you to organize and structure your code more effectively by grouping related data and behaviors together.

OOP Terminology

Before diving into the details of class anatomy, let’s quickly go over some basic OOP terminology:

  • Class: A blueprint or template that defines the structure and behavior of objects.
  • Object: An instance of a class. It represents a specific entity or concept.
  • Attribute: Data associated with a class or object. Each object can have its own set of attributes, which store information related to that specific object.
  • Method: Functions defined within a class that define the behavior of objects. Methods can access and modify the object’s attributes.

Exploring Object Interface

The object interface refers to the set of attributes and methods that are available for objects of a particular class. To understand the object interface, let’s create a simple class called Person:

class Person:
def __init__(self, name): = name
def greet(self):
print(f"Hello, my name is {}!")

In the above code, we define a Person class with two attributes: name and greet. The __init__ method is a special method called a constructor, used to initialize the object’s attributes. The greet method is a regular method that prints a greeting message.

To create an instance of the Person class and access its attributes and methods:

john = Person("John")
print( # Output: John
john.greet() # Output: Hello, my name is John!

Here, we create a john object of type Person and assign the attribute name with the value “John”. We then use the . operator to access the attribute name and call the greet method.

Class Anatomy: Attributes

Attributes are variables associated with a class or object. They store data related to the specific class or object instance. Let’s add more attributes to our Person class:

class Person:
def __init__(self, name, age): = name
self.age = age
def greet(self):
print(f"Hello, my name is {} and I am {self.age} years old!")

The new version of the Person class has an additional attribute age added to the constructor and the greet method.

john = Person("John", 25)
print(john.age) # Output: 25

Class Anatomy: Methods

Methods are functions defined within a class. They define the behavior of the class or object. Let’s add a new method to our Person class:

class Person:
def __init__(self, name, age): = name
self.age = age
def greet(self):
print(f"Hello, my name is {} and I am {self.age} years old!")
def celebrate_birthday(self):
self.age += 1

In this updated version, we added a celebrate_birthday method that increments the person’s age by 1.

john = Person("John", 25)
print(john.age) # Output: 26

By calling the celebrate_birthday method, we successfully increased John’s age by 1.

Class Anatomy: The __init__ Constructor

The __init__ method is a special method in Python classes. It is automatically called when an object is created from the class and is used to initialize the object’s attributes. Let’s take a closer look at it:

class Person:
def __init__(self, name, age): = name
self.age = age

In the __init__ method, we define the parameters name and age. These parameters are used to initialize the name and age attributes of the object. When creating an instance of the Person class, we pass the values for name and age as arguments.

Correct Use of __init__

It is important to remember to include the self parameter as the first argument in the class methods, including the __init__ method. The self parameter represents the instance of the object and is used to access its attributes and methods. Forgetting to include self will result in errors.

Add a Class Constructor

In addition to the __init__ method, you can define your own custom constructors in a class. These constructors can have different names and allow you to create objects with specific initial states. Here’s an example:

class Person:
def __init__(self, name, age): = name
self.age = age
def from_birth_year(cls, name, birth_year):
age = - birth_year
return cls(name, age)

In this modified Person class, we added a class method called from_birth_year. This method takes the name and birth_year as parameters and calculates the person’s age based on the current year. It then returns a new instance of the Person class with the calculated age.

john = Person.from_birth_year("John", 1990)
print(john.age) # Output: 31

By using the from_birth_year constructor, we can create a john object with the age calculated based on the birth year provided.

Write a Class from Scratch

Now that you understand the basics of class anatomy, let’s create a simple class from scratch. We’ll create a Car class with attributes for make, model, and year, as well as a method to display the car’s details:

class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def display_details(self):
print(f"Make: {self.make}\nModel: {self.model}\nYear: {self.year}")

With the Car class defined, we can create a my_car object and display its details:

my_car = Car("Toyota", "Camry", 2022)

The output will show the car’s make, model, and year:

Make: Toyota
Model: Camry
Year: 2022

In conclusion, understanding class anatomy is essential for effective object-oriented programming in Python. Attributes store data associated with a class or object, while methods define the behavior of the class. By leveraging these concepts, you can create organized and reusable code.