Python Classes and Objects¶
Python is an object-oriented programming (OOP) language, which means it allows programmers to create objects that encapsulate data and functionality together. Understanding classes and objects is essential for writing efficient and organized Python code.
Understanding Classes and Objects¶
Class: A blueprint or template for creating objects. It defines a set of attributes and methods that the instantiated objects (instances) will have.
Object: An instance of a class. It is a real-world entity that has properties (attributes) and behaviors (methods).
class Dog:
pass
my_dog = Dog()
print(type(my_dog))
<class '__main__.Dog'>
Defining a Class¶
Defining a class in Python is straightforward.
- Class Name: Should follow the PascalCase naming convention (each word capitalized, no underscores).
- Class Body: Contains method definitions and variables.
If you don’t want to add any attributes or methods immediately, you can use the pass statement to define an empty class.
The basic syntax is:
class ClassName:
# class body
pass
The init Method (Constructor)¶
The init method is a special method called a constructor.
It is automatically invoked when a new instance of the class is created. It initializes the object’s attributes.
self: Refers to the instance of the class. It is used to access class attributes and methods.
class ClassName:
def __init__(self, parameters):
# initialization code
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
The Person class has an init method that initializes name and age attributes.
self.name and self.age are instance variables.
Creating an Object¶
person1 = Person("Alice", 30)
print(person1.name) # Output: Alice
print(person1.age) # Output: 30
Alice 30
Instance Variables and Class Variables¶
Instance Variables
- Defined within methods.
- Unique to each instance.
- Prefixed with self.
Class Variables
- Defined within the class but outside any methods.
- Shared among all instances of the class.
class Employee:
company_name = "TechCorp" # Class Variable
def __init__(self, name):
self.name = name # Instance Variable
emp1 = Employee("Bob")
emp2 = Employee("Carol")
print(emp1.company_name) # Output: TechCorp
print(emp2.company_name) # Output: TechCorp
Employee.company_name = "InnoTech"
print(emp1.company_name) # Output: InnoTech
print(emp2.company_name) # Output: InnoTech
TechCorp TechCorp InnoTech InnoTech
company_name is a class variable shared among all instances.
Changing Employee.company_name affects all instances.
Methods in Classes¶
Methods are functions defined inside a class that describe the behaviors of an object.
class ClassName:
def method_name(self, parameters):
# method body
self: Always the first parameter. It refers to the instance calling the method.
class Circle:
pi = 3.1416
def __init__(self, radius):
self.radius = radius
def area(self):
return Circle.pi * self.radius ** 2
circle1 = Circle(5)
print(circle1.area()) # Output: 78.53999999999999
78.53999999999999
Accessing Attributes and Methods¶
You can access an object’s attributes and methods using the dot . notation.
Accessing Attributes
object.attribute
Accessing Methods
object.method()
class Car:
def __init__(self, model):
self.model = model
def display_model(self):
print(f"The model of the car is {self.model}")
my_car = Car("Toyota")
print(my_car.model) # Output: Toyota
my_car.display_model() # Output: The model of the car is Toyota
Toyota The model of the car is Toyota
my_car.model = "Honda"
print(my_car.model) # Output: Honda
Using Methods¶
class Car:
def __init__(self, model):
self.model = model
def set_model(self, model):
self.model = model
my_car = Car("Honda")
my_car.set_model("Ford")
print(my_car.model) # Output: Ford
Ford
Encapsulation¶
Encapsulation is the concept of bundling data and methods within a class and restricting direct access to some of the object’s components.
Private Attributes¶
In Python, private attributes are indicated by prefixing the attribute name with an underscore _ or double underscore __.
- Single Underscore (_variable): Suggests that the variable is intended for internal use.
- Double Underscore (__variable): Triggers name mangling to prevent accidental access.
class BankAccount:
def __init__(self, balance):
self.__balance = balance # Private attribute
def deposit(self, amount):
self.__balance += amount
def get_balance(self):
return self.__balance
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # Output: 1500
1500
Attempting to access __balance directly will result in an error:
print(account.__balance) # AttributeError
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) Cell In[17], line 1 ----> 1 print(account.__balance) # AttributeError AttributeError: 'BankAccount' object has no attribute '__balance'
Class Example - Student Management System¶
Let’s create a more complex class that incorporates all the elements discussed.
class Student:
school_name = "Springfield High"
def __init__(self, name, age, student_id):
self.name = name # Instance Variable
self.age = age # Instance Variable
self.__student_id = student_id # Private Instance Variable
self.grades = {} # Instance Variable
def add_grade(self, course, grade):
self.grades[course] = grade
def get_average(self):
total = sum(self.grades.values())
count = len(self.grades)
return total / count if count > 0 else 0
def display_info(self):
print(f"Name: {self.name}")
print(f"Age: {self.age}")
print(f"Student ID: {self.__student_id}")
print(f"Average Grade: {self.get_average():.2f}")
print(f"School: {Student.school_name}")
# Create a student object
student1 = Student("Lisa", 16, "S1234")
student1.add_grade("Math", 95)
student1.add_grade("Science", 98)
student1.display_info()
Name: Lisa Age: 16 Student ID: S1234 Average Grade: 96.50 School: Springfield High
- Student class has both instance variables and class variables.
- __student_id is a private attribute.
- Methods add_grade, get_average, and display_info perform operations related to the student.
- We create an object student1 and interact with it using methods.
Understanding classes and objects is fundamental to object-oriented programming in Python. By defining classes, creating objects, and utilizing instance and class variables, you can model complex systems and data structures in a way that is organized and reusable. Encapsulation allows you to protect the internal state of objects and expose only what is necessary.