Q: What's the object-oriented way to become wealthy?

A: Inheritance.

Vocabulary determines the reality of your life.

Here is an interesting snippet about the role of terminology from a scientific report about computing [1]:

"A large majority of documents today are designed for specialist communication[...]. They are thus written in specialist language, 30-80% of which [...] is composed of terminology. In other words, terminology [...] is the main vehicle by which facts, opinions and other "higher" units of knowledge are represented and conveyed. Sound terminology work reduces ambiguity and increases clarity."

If you think and talk like a computer scientist, you will become a computer scientist. Moreover, you will attract other computer scientists in your life which ultimately has the power to push your Python skills to the next level. In other words: Thoughts become words. Words become actions. Actions become habits. Habits become identities.

I want to help you master object orientation in Python. That's why I'm going to rush with you through the most important vocabulary of object orientation.

So let’s study the code!

class Dog: # class attribute is_hairy = True # constructor def __init__(self, name): # instance attribute self.name = name # method def bark(self): print("Wuff")bello = Dog("bello")paris = Dog("paris")print(bello.name)"bello"print(paris.name)"paris"class Cat: # method overloading def miau(self, times=1): print("miau " * times)fifi = Cat()fifi.miau()"miau "fifi.miau(5)"miau miau miau miau miau "# Dynamic attributefifi.likes = "mice"print(fifi.likes)"mice"# Inheritanceclass Persian_Cat(Cat): classification = "Persian"mimi = Persian_Cat()print(mimi.miau(3))"miau miau miau "print(mimi.classification)

Class: A blueprint to create objects. It defines the data (attributes) and functionality (methods) of the objects. You can access both attributes and methods via the dot notation.

Object (=instance): A piece of encapsulated data with functionality in your Python program that is built according to a class definition. Often, an object corresponds to a thing in the real world. An example is the object “Obama” that is created according to the class definition “Person”. An object consists of an arbitrary number of attributes and methods, encapsulated within a single unit.

Instantiation: The process of creating an object of a class.

Method: A subset of the overall functionality of an object. The method is defined similarly to a function (using the keyword “def”) in the class definition. An object can have an arbitrary number of methods.

Method overloading: You may want to define a method in a way so that there are multiple options to call it. For example for class X, you define a method f(…) that can be called in three ways: f(a), f(a,b), or f(a,b,c). To this end, you can define the method with default parameters (e.g. f(a, b=None, c=None).

Attribute: A variable defined for a class (class attribute) or for an object (instance attribute). You use attributes to package data into enclosed units (class or instance).

Class attribute (=class variable, static variable, static attribute): A variable that is created statically in the class definition and that is shared by all class objects.

Dynamic attribute: An “->instance attribute” that is defined dynamically during the execution of the program and that is not defined within any method. For example, you can simply add a new attribute neew to any object o by calling “o.neew = “.

Instance attribute (=instance variable): A variable that holds data that belongs only to a single instance. Other instances do not share this variable (in contrast to “->class attributes”). In most cases, you create an instance attribute x in the constructor when creating the instance itself using the self keywords (e.g. self.x = ).

Inheritance: Class A can inherit certain characteristics (like attributes or methods) from class B. For example, the class “Dog” may inherit the attribute “number_of_legs” from the class “Animal”. In this case, you would define the inherited class “Dog” as follows: “class Dog(Animal): …”

Encapsulation: Binding together data and functionality that manipulates the data.

If you have understood these terminologies, you can follow maybe 80% of the discussions about object-oriented programming (I LOVE the pareto principle: 80% of the learning in 20% of the time).

[1] http://www.computing.surrey.ac.uk/ai/pointer/report/section1.html

The 12 Most Important Terms of Object-Oriented Programming

Please log in and refresh this page