In Python,
**classes** and **objects** are key concepts in **Object-Oriented Programming
(OOP)**. A **class** is a blueprint for creating objects, while an **object**
is an instance of a class. Using classes, you can group data (attributes) and
functionality (methods) together in a structured way.
### 1.
**Python Classes**
A class
defines a new data type, which includes variables (attributes) and functions
(methods). The data and methods related to the class are encapsulated in a
single structure, allowing for better modularity and reusability of code.
#### Syntax:
```python
class
ClassName:
# Constructor: special method to initialize
object attributes
def __init__(self, attribute1, attribute2):
self.attribute1 = attribute1
self.attribute2 = attribute2
# Method: a function within the class
def method_name(self):
print(f"Attribute1:
{self.attribute1}, Attribute2: {self.attribute2}")
```
- `class
ClassName`: Defines a new class.
-
`__init__(self)`: The constructor method that initializes an object’s
attributes when it is created. The `self` parameter refers to the instance of
the object itself.
-
`self.attribute`: Refers to attributes of the object.
-
`method_name`: A regular method defined within the class.
### 2.
**Python Objects**
An
**object** is an instance of a class, created using the class name. You can
create multiple objects from a class, each with its own state.
####
Example:
```python
# Defining a
class
class Car:
# Constructor to initialize attributes
def __init__(self, brand, model):
self.brand = brand # Instance attribute
self.model = model
# Method to display the car's details
def display_info(self):
print(f"This car is a {self.brand}
{self.model}.")
# Creating
objects (instances) of the Car class
car1 =
Car("Toyota", "Camry")
car2 =
Car("Honda", "Accord")
# Calling
methods
car1.display_info() # Output: This car is a Toyota Camry.
car2.display_info() # Output: This car is a Honda Accord.
```
### 3.
**Attributes and Methods**
-
**Attributes**: Variables that belong to a class or an object.
- **Instance Attributes**: Attributes that
belong to each specific object (set in the `__init__()` method).
- **Class Attributes**: Shared by all
instances of the class.
#### Example
of Instance and Class Attributes:
```python
class Dog:
# Class attribute (shared by all instances)
species = "Canine"
def __init__(self, name, age):
# Instance attributes (unique to each
object)
self.name = name
self.age = age
def info(self):
print(f"{self.name} is a {self.age}-year-old
{Dog.species}.")
# Creating
instances (objects)
dog1 =
Dog("Buddy", 3)
dog2 =
Dog("Max", 5)
# Accessing
instance and class attributes
dog1.info() # Output: Buddy is a 3-year-old Canine.
dog2.info() # Output: Max is a 5-year-old Canine.
```
### 4.
**Instance Methods, Class Methods, and Static Methods**
- **Instance
Methods**: Operate on an instance of the class (regular methods).
- **Class
Methods**: Operate on the class itself rather than instances. Defined using
`@classmethod`.
- **Static Methods**:
Do not depend on the class or instance and are defined using `@staticmethod`.
####
Example:
```python
class
Example:
# Class attribute
counter = 0
def __init__(self, value):
self.value = value
Example.counter += 1
# Instance method
def show_value(self):
print(f"Value: {self.value}")
# Class method
@classmethod
def show_counter(cls):
print(f"Number of instances:
{cls.counter}")
# Static method
@staticmethod
def greet():
print("Hello, this is a static
method!")
# Create
objects
obj1 =
Example(10)
obj2 =
Example(20)
# Call
instance method
obj1.show_value() # Output: Value: 10
# Call class
method
Example.show_counter() # Output: Number of instances: 2
# Call static
method
Example.greet() # Output: Hello, this is a static method!
```
### 5.
**Inheritance**
**Inheritance**
allows a class to inherit attributes and methods from another class. This
promotes code reusability and allows you to create a hierarchy of classes.
####
Example:
```python
# Base class
class
Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a
sound.")
# Derived
class
class
Dog(Animal):
def speak(self):
print(f"{self.name} barks.")
# Creating
objects
animal =
Animal("Generic Animal")
dog =
Dog("Buddy")
animal.speak() # Output: Generic Animal makes a sound.
dog.speak() # Output: Buddy barks.
```
### 6.
**Encapsulation and Access Modifiers**
- **Encapsulation**
means bundling data (attributes) and methods that operate on the data into a
single unit (class).
- **Access
Modifiers**:
- By default, all attributes and methods in
Python are **public**.
- **Private** attributes/methods: Prefix
with `__` (double underscore).
- **Protected** attributes/methods: Prefix
with `_` (single underscore).
####
Example:
```python
class
Person:
def __init__(self, name, age):
self.name = name # Public attribute
self._age = age # Protected attribute
self.__ssn = "123-45-6789" # Private attribute
def get_ssn(self):
return self.__ssn # Accessing private attribute through a method
# Creating
an object
person =
Person("Alice", 30)
# Accessing
public and protected attributes
print(person.name) # Output: Alice
print(person._age) # Output: 30
# Accessing
private attribute via method
print(person.get_ssn()) # Output: 123-45-6789
```
### 7.
**Polymorphism**
Polymorphism
allows methods to behave differently based on the object that calls them, even
if the methods have the same name.
####
Example:
```python
class Cat:
def speak(self):
print("Meow")
class Dog:
def speak(self):
print("Bark")
# Example of
polymorphism
def
animal_sound(animal):
animal.speak()
cat = Cat()
dog = Dog()
animal_sound(cat) # Output: Meow
animal_sound(dog) # Output: Bark
```
### Summary:
- **Class**:
A blueprint for creating objects (defines attributes and methods).
-
**Object**: An instance of a class, containing data and methods.
-
**Attributes**: Variables inside a class that store data.
-
**Methods**: Functions inside a class that define behaviors.
-
**Inheritance**: Allows one class to inherit attributes and methods from
another.
-
**Encapsulation**: Bundles data and methods, protecting them from direct
access.
-
**Polymorphism**: Different classes can be used with a uniform interface (e.g.,
same method name).
Using
classes and objects allows you to structure your code in a more organized and
reusable way, especially for large applications.
