Object Oriented Programming: Python vs R

Introduction

Object-Oriented Programming (OOP) is a programming paradigm that uses “objects” to design applications and computer programs. It utilizes several techniques from previously established paradigms, including modularity, polymorphism, and encapsulation. Today, we’ll explore how OOP concepts manifest in two popular programming languages: Python and R, particularly focusing on inheritance, using the context of a microwave oven as an example.

OOP in Python

In Python, OOP is central to the language. This can be seen in the way classes are defined and used. Python supports inheritance, allowing new classes to inherit attributes and methods from existing classes. This feature facilitates code reusability and the hierarchical organization of classes. For example, if you were modeling microwave ovens, you could start with a basic microwave class and then create a subclass for a fancier microwave with additional features:

class MicrowaveOven:
    def __init__(self, power_rating):
        self.power_rating = power_rating

    def cook(self, time_seconds):
        print("Your food is cooked!")

class FancyMicrowaveOven(MicrowaveOven):
    def cook_baked_potato(self):
        self.cook(5)
        print("Enjoy your baked potato!")

a_fancy_microwave = FancyMicrowaveOven(5)
a_fancy_microwave.cook_baked_potato()

Your food is cooked!
Enjoy your baked potato!

In this Python example, FancyMicrowaveOven inherits from MicrowaveOven, meaning it can use the cook method defined in the parent class and add its methods like cook_baked_potato.

OOP in R

In contrast, R, traditionally seen as a statistical programming language, has incorporated OOP features more gradually. The R6 package in R allows for a more classical approach to OOP, supporting encapsulation and inheritance but in a somewhat different manner than Python. The R6 framework allows R developers to create classes with reference semantics, which can be somewhat akin to how Python’s classes operate.

Here’s how you might define a similar set of microwave classes in R using the R6 package:

library(R6)
microwave_oven_factory <- R6Class(
    "MicrowaveOven",
    private = list(power_rating_watts = 800),
    public = list(
        cook = function(time_seconds) {
            Sys.sleep(time_seconds)
            print("Your food is cooked!")
        }
    )
)

fancy_microwave_oven_factory <- R6Class(
    "FancyMicrowaveOven",
    inherit = microwave_oven_factory,
    public = list(
        cook_baked_potato = function() {
            self$cook(5)
            print("Enjoy your baked potato!")
        }
    )
)

a_fancy_microwave <- fancy_microwave_oven_factory$new()
a_fancy_microwave$cook_baked_potato()

[1] "Your food is cooked!"
[1] "Enjoy your baked potato!"

In the R example, FancyMicrowaveOven is defined with inherit = microwave_oven_factory, which establishes an inheritance relationship with MicrowaveOven. This setup allows the fancy microwave to use the cook method from its parent class while adding a new method cook_baked_potato.

Differences

A key difference in the OOP implementation between Python and R is the syntax and the explicit use of self and super. In Python, self refers to the instance itself and is used to access class attributes and methods from within. super(), on the other hand, is used to call methods from a superclass in the context of inheritance.

In R’s R6, self serves a similar purpose as in Python, referring to the current object. However, R6 does not have a direct counterpart to Python’s super; instead, method overriding involves calling the superclass method directly through super$method_name(). Inheritance in R6 is established through the inherit parameter in the class definition, allowing the new class to access the public methods and properties of the parent class.

Conclusion

In summary, while Python’s OOP features have been integral to the language from its conception, R has adopted OOP paradigms over time, with packages like R6 introducing class-based programming that includes inheritance. Both languages offer robust capabilities for OOP, facilitating complex and modular program design. In practice, choosing between Python and R for OOP depends on the specific requirements of your project and your personal or team’s familiarity with each language.