An object is a data structure that can have properties and methods. A property is a piece of data like a string, integer, or another object. Think of it as a variable within the variable. A method is a function built into the object which it can be called to carry out. Like any other function it takes arguments but it also has access to any of the object's properties. In Python an object is defined by a class, which says what properties objects of that type will have and what methods they can execute. This is how most object oriented languages do it, with the exception of Javascript, which uses an entirely different framework. From a class one can create multiple instances of an object. Each instance will have the same properties, but set to different values. Each instance will be able to do the same methods. For example imagine a Student object. It would have a name, age, grade, and so on. It could have the moveUp() method, which would increase the Student's grade. A file object is just a kind of object Python can create that allows it to do things to a file, like read from it or write to it. A number is technically an object in Python. This is not the case in all object oriented languages. But it's better thought of as a "primitive," meaning the stuff that other objects can be made of. A number only has one piece of data, the number itself, and doesn't have any built in methods (I think). This barely scratches the surface of object oriented programming. Google "python oop" and read various resources and you'll learn a lot more. More on reddit.com

Every function is an object, as well: >>> def func(): ... return True >>> func.__name__ 'func' I access the class attribute __name__ on the newly created function, to demonstrate it has attributes just like an object. More on reddit.com

There's a massive Wikipedia page on OOP that will give you every little gritty detail. And, there are a lot of OOP evangelists and an ever increasing amount of OOP cynics. Either of which will try to sell you benefits of Language-X, and why Language-Z is the greatest invention since the wheel. Including these 30,000 words of rhetoric, fallacies, and pure garbage.

Here is everything you need to know about OOP. There are three features that make a language an OO language. Any language can have one or two of the features and not be OO, but any language that has all three can be considered OO. They are:

1. Encapsulation

2. Inheritance

3. Polymorphism

Encapsulation is a feature that allows for a data structure to be associated with a set of methods*; An object. In a language without encapsulation, like C, then you will have libraries of functions* and each piece of data is passed to a function. In a language with OO, like Python, you can define a Class that, when instantiated, creates an object. That object, usually, is an aggregate datatype with added logic, methods*. Each instance method has an implicit argument, typically, named self.

* A note on the terms "method" and "function". They're both just synonymous with "subroutine" or a sequence of instructions. However, most programmers differentiate them. A "subroutine" is blockless piece of code that must be reached by a goto statement. A "function" is a block of code that operates exclusively on it's arguments. And, a "method" is a block of code that is associated with an object.

Most languages have generic base "types" like strings, integers, floats, and arrays. When have a need for a "type" with several associated values, then you need an 'aggregated data type'. In a language without Encapsulation, the term is usually called a "struct". With Encapsulation, a "type" is nearly synonymous with a "class" and an instance is called an "object". There's, also, a spectrum of OO-ness. Java base types are NOT objects. An int in Java is not an object, it is a type, but an Integer is an object. In Python everything is an object.

A crude example in Python would be:

class Greeter(object):
    def __init__(self, phrase):
        self.phrase = phrase

    def greet(self, name):
        print(self.phrase.format(name))

hello_greeter = Greeter("Hello, {}!")
hello_greeter.greet("Ms. Smith")

In the above example, we see our first hint of Inheritance. The Greeter class inherits from object (Note: (object) is implicit in Python3.) Inheritance is the ability to associate and expand on another class's data structure and functionality. We could very easily create a HelloWorldGreeter from Greeter.

class HelloWorldGreeter(Greeter):
    def __init__(self):
        super(HelloWorldGreeter, self).__init__("Hello, {}!")

    def greet(self):
        super(HelloWorldGreeter, self).greet("World")

In the Inheritance realm there is single-inheritance and multiple-inheritance. The HelloWorldGreeter is an example of a class with single-inheritance. In fact, must OO languages are specifically only single-inheritance. However, I mention it here because Python isn't most languages as it allows for multiple-inheritance. Which is the reason for the very explicit super(...) function. This function is able to solve the "diamond problem" which is an issue about how inheritance is ordered. I'll just stop here because it's a lengthy topic in itself; follow the link to Wikipedia for more. If you want to know more Python's super(...) method, then read Raymond Hettinger's post "Python's super() considered super!"

A lot of detractors consider inheritance -- especially, multiple inheritance -- as a complicated obfuscation that makes code harder to debug.

That leaves us with Polymorphism. This will be the most difficult for me to explain and, I suspect, the most contentious of OO features. And, it's going to require us to take a step back.

All languages have a "type system". There are a few adjectives that get thrown around. The two that most people confuse (and I might do so myself) are the mutually exclusive "weakly" (or "loosely") typed and "strongly" typed languages. Also, there are other concepts that are frequently confused as 'strong' and 'weak' which are "static type-checking" and "dynamic type-checking". To unravel all of this, here is the best I can do to concisely describe these concepts:

• Strongly Typed: A strongly typed language is one that will cause an error if a piece of logic tries to operate on an unexpected type. Something that tends to confuse a lot of people is the fact that Python (and Ruby) are strongly typed. I'll try to explain later in 'Dynamic Type-Checking'.

• Weakly Typed: A language that attempts to perform type conversion would be considered "weakly" typed. Java, for instance, does "auto-boxing" and "auto-unboxing" for it's basic types; ex int fortytwo = 20 + new Integer(22). In C, one can add pointers to numeric types and numeric types can be coerced into another numeric types; ex. an int can safely converted to long.

• Static Type-Checking: A static type-checking language is one that tracks each object's type to prevent type-specifc logic errors. For example, one shouldn't pass a string to a function that expects to receive two integers. Typically, this is a compile time feature which gives an added performance benefit because the resulting program does not need runtime type checking.

However, languages like javascript and Python (PEP 484) are adding "type hinting" which can be thought of as "unenforced static type-checking". Rather than halting compilation, errors and warnings will be presented.

• Dynamic Type-Checking: A dynamic type-checking language is one that does not make any attempt to protect the program for logic errors based on object type. That is to say, type checking must be done at runtime through language-specific functionality. For example, if one wanted to run a specific function on an object, then one might want to be certain that the object provides that functionality or, else, risk a runtime error. This is commonly known as "duck typing"; Coming from the common phrase, 'If it walks like a duck and quacks like a duck, then it is a duck'.

Okay. Back to Polymorphism. A language is considered polymorphic if an object can be treated as its own specific type or any of the inherited types, or "subtypes". A quick example just to wrap this up (because I've written way to much):

class Vehicle(object):
    pass

class Truck(Vehicle):
    pass

class Car(Vehicle):
    pass

isinstance(Car(), Car) # True
isinstance(Truck(), Car) # False

isinstance(Car(), Vehicle) # True
isinstance(Truck(), Vehicle) # True

Hope it helps.

More on reddit.com

Classes are data encapsulated with structure and behaviour. You use them when you have similar things that all behave the same way or all share meaning.

If you had a Dog class, well, all Dogs have a name, breed, colour, and all Dogs have the same behavior, barking, wagging, running.

The __init__ method is the constructor. This method is called when the object is created. You use it to set up the initial state of the object. When a Dog is created it 'gets' a name, breed and colour.

For a real programming example, say you are making a shooter game. In this game you can equip many different weapons which have different characteristics but all function more or less the same way. You could make a Weapon class which has data like ammunition capacity, bullets remaining, or damage done. Then you could make this class have a shoot() method and when the user presses a button when playing the game it calls this method. Inside the method it checks to see if there is ammunition remaining in the magazine, and if so, removes a bullet from the magazine. And if the user needs to reload you can make a reload() method which checks how much ammunition the player has, and if there is enough left, refills the magazine and removes the bullets from the ammunition pile.

Then you can take this class and make many child classes all with different properties and maybe with additional behaviour, but still basicaly function the same as every other weapon.

More on reddit.com