Fundamentals of Object-Oriented Programming with Python

[jewameb621]

Object-oriented programming (OOP) is a programming paradigm that is based on the use of objects, which are instances of classes, to organize code. Python is one of the programming languages ​​that actively supports OOP. In this article, we will look at the basic concepts of OOP using Python as an example.

Classes and Objects

In Python, a class is a template or blueprint for creating objects. A class defines the attributes (variables) and methods (functions) that will be available to objects of that class. For example, consider the `Person` class:

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

def say_hello(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
```

Here we define a `Person` class with afghanistan telegram data attributes `name` and `age`, and a method `say_hello`. The `self` attribute refers to the current instance of the class.

To create a Person object, we call the class constructor, passing the required arguments:

```python
person1 = Person("Anna", 30)
person2 = Person("John", 25)
```

Attributes and Methods

Class attributes are variables that store object data. They can be accessed and modified through the object. For example:

```python
print(person1.name) # Output: "Anna"
person2.age = 26
print(person2.age) # Output: 26
```

Class methods are functions that are defined within a class and can be called on an object of that class. Methods can use an object's attributes to perform operations. For example, calling the `say_hello` method:

```python
person1.say_hello() # Output: "Hello, my name is Anna and I am 30 years old."
person2.say_hello() # Output: "Hello, my name is John and I am 26 years old."
```

Inheritance

One of the key concepts of OOP is inheritance. It allows you to create a new class based on an existing class, inheriting its attributes and methods. In Python, the following syntax is used for inheritance:

```python
class Student(Person):
def __init__(self, name, age, student_id):
super().__init__(name, age)
self.student_id = student_id

def study(self):
print(f"{self.name} studies at the university.")
```

Here, the `Student` class inherits the `Person` class. We also add a new attribute `student_id` and a method `study`. With `super()`, we call the constructor of the parent class.