Classes and objects are fundamental concepts in object-oriented programming (OOP) in Python. They allow you to create reusable, modular code by defining templates (classes) for creating specific instances (objects).
Defining a Class
A class in Python is defined using the class keyword followed by the class name and a colon. The class body contains methods (functions) and attributes (variables).
Example:
class Dog:
# Class attribute
species = "Canis familiaris"
# Initializer / Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instance method
def description(self):
return f"{self.name} is {self.age} years old"
# Another instance method
def speak(self, sound):
return f"{self.name} says {sound}"
Creating Objects
An object is an instance of a class. You create an object by calling the class as if it were a function.
Example:
class Dog:
# Class attribute
species = "Canis familiaris"
# Initializer / Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instance method
def description(self):
return f"{self.name} is {self.age} years old"
# Another instance method
def speak(self, sound):
return f"{self.name} says {sound}"
Class and Instance Attributes
- Class attributes are shared among all instances of a class.
- Instance attributes are specific to each object created from the class.
Example:
print(dog1.species) # Output: Canis familiaris
print(dog2.species) # Output: Canis familiaris
# Changing the species attribute for all instances
Dog.species = "Canine"
print(dog1.species) # Output: Canine
print(dog2.species) # Output: Canine
# Changing the name attribute for dog1
dog1.name = "Max"
print(dog1.name) # Output: Max
print(dog2.name) # Output: Lucy
Inheritance
Inheritance allows you to create a new class based on an existing class. The new class (child class) inherits attributes and methods from the existing class (parent class).
Example:
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
class Dog(Animal):
def speak(self):
return f"{self.name} says Woof"
class Cat(Animal):
def speak(self):
return f"{self.name} says Meow"
# Creating instances of Dog and Cat
dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak()) # Output: Buddy says Woof
print(cat.speak()) # Output: Whiskers says Meow
Encapsulation
Encapsulation restricts direct access to some of an object's attributes and methods. This is achieved using private attributes and methods.
Example:
class Car:
def __init__(self, make, model):
self.make = make
self.model = model
self.__engine_running = False # Private attribute
def start_engine(self):
self.__engine_running = True
def stop_engine(self):
self.__engine_running = False
def engine_status(self):
return self.__engine_running
car = Car("Toyota", "Corolla")
car.start_engine()
print(car.engine_status()) # Output: True
car.stop_engine()
print(car.engine_status()) # Output: False
Polymorphism
Polymorphism allows different classes to be treated as instances of the same class through a common interface. This is typically achieved by method overriding.
Example:
class Bird:
def fly(self):
raise NotImplementedError("Subclass must implement abstract method")
class Sparrow(Bird):
def fly(self):
return "Sparrow flies"
class Penguin(Bird):
def fly(self):
return "Penguin can't fly"
# Using polymorphism
def describe_flight(bird):
print(bird.fly())
sparrow = Sparrow()
penguin = Penguin()
describe_flight(sparrow) # Output: Sparrow flies
describe_flight(penguin) # Output: Penguin can't fly
Summary
- Classes: Blueprints for creating objects. They encapsulate data (attributes) and behavior (methods).
- Objects: Instances of classes.
- Attributes: Variables that belong to a class or an object.
- Methods: Functions that belong to a class and typically operate on its objects.
- Inheritance: Mechanism for creating a new class based on an existing class.
- Encapsulation: Restricts access to certain details of an object, promoting modularity and maintenance.
- Polymorphism: Allows objects of different classes to be treated through the same interface.
Using these principles, you can create structured, modular, and reusable code in Python.
Comments
Post a Comment