Object-Oriented Programming in Python

4 Views

Object-Oriented Programming in Python

养花风水

4 Views

Programmers who engage in using Python must be well aware that it is an entirely object oriented programming language which has some unique facts around it. Python as stated above is an object-oriented programming which supports different paradigms programming including procedural programming and import features of OOP. This makes it far easier for writing complex and large software programs. This article will entail the introduction and the basic blocks of OOP in Python such as classes, objects, inheritance, and encapsulation.

How do Objects Help in Class Creation?

The ideal situation would be to migrate everything in life to oo programming,however when we deal with oo programming, the main focus is bestowed upon Through Programming.

- The Rules, in other cases, define the approach for the objects on how to behave or how they should be programmed. In easier terms, the rules lay out how objects will look and be designed from the aspect of characteristics and functions. Would aid in deriving objects later on. The information you provided seems to be a good and clear explanation of Objects and Classes in Python. However, I might ask additional questions regarding the SNCC. My first question would be, if every program needs to contain Objects and classes, why is it not necessary to define a class in python first?

An object is an instantiation of a class. An object is a real world item that possesses characteristics and behaviors as specified by its class. All the created objects of a class have data unique to itself and can call its class methods.

In python, classes are defined by using the class keyword. Here's a basic illustration of python classes:

Class Definition Example

  def __init__(self, name, age):
 
    self.name = name
 
    self.age = age
 
 function that rudimentary implements the characteristics of a dog 
 
def speak(self):    
 
return f"{self.name} says woof!"

In this example the contents of class Dog has been described. It has 2 variables which are name and age, there is also a member function speak() within it, which returns a string value when executed. Now whenever we create an object out of this class dog, it will have name and age all set to certain values defined in it.

Every class has its unique mechanism to ascertain the objects and attributes associated with it. Each class has a method called a constructor or an initiation method, this method is referred to as __init__.

In the above example, we created a new `Dog` object and the parameters `name` and `age` were added due to `__init__`. As stated, the `self` array is related to the object, and it also includes the access of the object attributes and methods.

Object Creation Example

  dog1 = Dog("Buddy", 3)
 
print(dog1.name)   Output: Buddy
 
print(dog1.speak())  Output: Buddy says woof.

Instance vs Class Variables

The variables that belong to the objects are referred to as instance variables in python, while the ones that belong to the class itself are referred to as class variables.

- Instance variable is a variable defined in a class and it is specific to the object of the class. Such variables are usually specified in the `__init__` method and may vary for each object created.

- Class variables are those which are laid down within the class and outside all methods of the class, and all objects of the class share the same attribute.

Here is the example of class variable:

Class and Instance Variables Example

  class Dog:
 
    species = "Canine"   Class variable
 
 
 
    def __init__(self, name, age):
 
        self.name = name   Instance variable
 
        self.age = age     Instance variable

Here, the `species` is a class variable, while the `name` and `age` are instance variables. And that's because all the 'Dog' objects have the same value of `species`, however every one of them has its different `name` and `age`.

Inheritance in Python

The OOP paradigm has what is called inheritance. Inheritance essentially means that a class may be able to use both the properties and features of the previously existing class. In other words, it enables the reuse and extension of code whenever necessary.

Another class or subclass is able to overwrite or implement additional behaviors on top of what the parent class allows. The parent class is called a superclass or base class.

Let's understand it through an example of Inheritance;

Inheritance Example

  class Animal:
 
    def __init__(self, name):
 
        self.name = name
 
    def speak(self):
 
        return f"{self.name} makes a sound."
 

 
class Dog(Animal):   Dog is a subclass of Animal
 
    def speak(self):   Overriding the speak method
 
        return f"{self.name} barks."
 

 
class Cat(Animal):   Cat is a subclass of Animal
 
    def speak(self):   Overriding the speak method
 
        return f"{self.name} meows."

As illustrated above, both `Dog` and `Cat` can be said to be subclasses of class `Animal.` Both of them possess the `__init__` method upon inheriting from `Animal`, in addition to which they also have their own implementations of the `speak()` behavior.

Inheritance is one of the key concepts that allows one to derive more specialized classes without changing the general pattern and functionality of the parent class.

Encapsulation in Python

Encapsulation is yet another crucial idea in OOP. It is the practice of hiding the internal workings of a class from other classes. In this way, the class itself governs how its data may be viewed or altered.

Encapsulation in python is mostly done with the use of private and public attributes. It is the convention that attributes which are to be kept private (that is, not to be accessed directly from outside the class) will be prefixed with a double underscore sign `__`.

For instance, let's examine an inheritance:

Encapsulation Example

  class BankAccount:
 
    def __init__(self, owner: str, balance):
 
        self.owner = owner
 
        self.__balance = balance   Private variable    
 

 
    def deposit(self, amount):
 
        if amount > 0:
 
            self.__balance += amount 
 

 
    def withdraw(self, amount):
 
        if amount > 0 and amount <= self.__balance:
 
            self.__balance -= amount
 

 
        def get_balance(self):
 
        return self.__balance

Here, in this example, the balance is encapsulated within the class. It is also clear that the balance is not accessible directly from outside the class, instead, it is access controlled by `deposit`, `withdraw`, and `get_balance` functions.