Understanding Objects

In Python, what are often referred to as types are actually objects. Many programmers may feel anxious when they hear the term “types,” but it's simply a label for what functions similarly to classes in broader computing contexts. As we delve into this topic, keep in mind that I will interchangeably use "types" and "object" throughout.

Objects in Python resemble data structures from other programming languages, created using a constructor. The primary distinction in Python lies in the syntax used to define these constructors. Python employs a somewhat typical object-oriented "class" syntax, with the addition of decorators that enhance meta-programming capabilities and provide unique features to Python objects. The type() function can be used to identify any Python object’s type; however, it does not differentiate between sub-types. If a class inherits from another, it will still be recognized as its parent type. This leads us to an essential principle in object-oriented design known as the Liskov substitution principle, which asserts that sub-types should be usable in place of their parent types for consistency.

Here’s a simple illustration of a parent class and a subclass:

class Person():

def show(self):

print("This is class")

class Em(Person):

def another_function(self):

print("This is subclass of Person")

In this example, Person serves as the parent class for Em. By indicating the parent class in parentheses, Em inherits all functionalities from Person, allowing us to avoid redundant code for creating additional subclasses.

What Does Type Mean in Python?

The term "type" holds different meanings across programming languages. In Python, it signifies a level of separation between the programmer and the types themselves. While Python is dynamically typed—allowing definitions to change during runtime—it's also strongly typed, meaning that a defined name’s type won’t change unless explicitly instructed to do so.

In Python, typing primarily determines the methods and properties associated with a class, but it doesn't play a significant role beyond that. Compared to other languages, Python's types and functions are largely independent, which can lead to unintended type-related errors. This highlights the importance of good documentation, as Python doesn't enforce type checks when incorrect arguments are provided. For those interested in a deeper understanding of argument typing in Python, I have a dedicated article that elaborates on this topic.