Why python called as object oriented why not c?

Why python called as object oriented why not c?

Why Python is Called Object-Oriented and Why Not C?

Python is widely recognized as an object-oriented programming language (OOP). But have you ever wondered why Python is classified as an OOP language and not C? In this blog post, we will dive into the concepts of object-oriented programming, what makes Python object-oriented, and why C, even though a powerful language, does not fit into the OOP category.

What is Object-Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to design applications and programs. These objects are instances of classes, which are templates for creating objects. OOP allows for encapsulation, inheritance, and polymorphism, which helps in making programs more modular, reusable, and easier to maintain.

Key features of OOP:

  • Encapsulation: Wrapping data and methods into a single unit (class).
  • Inheritance: Creating new classes from existing ones.
  • Polymorphism: Ability to take many forms. For example, a method might behave differently based on the object calling it.
  • Abstraction: Hiding complex implementation details from the user.

Why Python is Considered Object-Oriented

Python is considered an object-oriented language because everything in Python is treated as an object. This includes integers, strings, functions, and even classes themselves.

1. Everything is an Object in Python

In Python, even simple data types like integers and strings are objects. These objects belong to classes, and their methods and properties are accessible via dot notation.

Here is an example:


class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} speaks!")

# Creating an instance of the Animal class
animal1 = Animal("PythonBeeTelugu")

# Calling the method of the object
animal1.speak()  # Output: PythonBeeTelugu speaks!

In this example:

  • animal1 is an object of the Animal class.
  • The method speak() is called on this object, demonstrating that even simple data types are treated as objects in Python.

2. Classes and Objects in Python

Python supports defining classes, which are blueprints for creating objects. Python's class system provides the core features of OOP, such as inheritance, polymorphism, and encapsulation. 


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

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

# Creating an instance of Person
person1 = Person("PythonBeeTelugu", 25)
person1.greet()  # Output: Hello, my name is PythonBeeTelugu and I am 25 years old.

Here, the Person class defines a template for creating Person objects. The method greet() is encapsulated within the class and is accessed via the object person1.

3. Inheritance in Python

Python supports inheritance, a fundamental OOP concept that allows one class (child class) to inherit the attributes and methods of another class (parent class). 


class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks.")

# Creating an instance of Dog
dog1 = Dog("PythonBeeTelugu")
dog1.speak()  # Output: PythonBeeTelugu barks.

In this example:

  • The Dog class inherits from the Animal class and overrides the speak() method.
  • This demonstrates inheritance in Python, where the Dog class can reuse and extend the functionality of the Animal class.

4. Polymorphism in Python

Polymorphism allows different objects to use the same method name but have different behaviors. This is another key feature of Python’s object-oriented design. 


class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

# Creating instances of both Dog and Cat
cat1 = Cat("PythonBeeTelugu")
dog1 = Dog("PythonBeeTelugu")

cat1.speak()  # Output: PythonBeeTelugu meows.
dog1.speak()  # Output: PythonBeeTelugu barks.

Here, both the Cat and Dog classes implement the speak() method, but they have different behaviors. This is polymorphism, where the method name is the same but its behavior varies based on the object.

Why C is Not Considered Object-Oriented

C, on the other hand, is a procedural programming language, not an object-oriented one. It focuses on functions and procedures to operate on data rather than using classes and objects. Here’s why C doesn’t support OOP:

1. No Class Concept in C

In C, there is no built-in support for defining classes and objects. While structures in C can hold data, they do not have methods or functions associated with them like Python classes do.

2. No Inheritance or Polymorphism in C

C does not have support for inheritance and polymorphism, which are essential characteristics of object-oriented programming. In C, you cannot create subclasses or override functions in a subclass, which means you cannot extend functionality using inheritance.

3. Procedural Approach in C

C is based on the procedural programming paradigm, where you define functions that manipulate data. You do not model the world using objects and their interactions as you do in Python.

Conclusion

Python is called an object-oriented language because it supports all major OOP principles, including encapsulation, inheritance, polymorphism, and abstraction. Every entity in Python, even simple data types, is treated as an object, allowing for a more flexible and modular approach to programming.

On the other hand, C is a procedural programming language, which focuses on functions that operate on data, and it lacks built-in support for object-oriented features like classes, inheritance, and polymorphism.

For more detailed Python programming tutorials, don't forget to check out @PythonBeeTelugu on YouTube!

Comments

Post a Comment