Objects vs instance in python

Question

In C++ there are just objects and classes, where objects are instances of classes.

In Python, a class definition (i.e., the body of a class) is called an object. And

Answer 1

In Python, a class definition (i.e., the body of a class) is called an object

Actually, this is still called a class in Python. That's why you define it like this:

class Foo(object):
    pass

The class keyword is used because the result is still called a class.

The word object is in parentheses to show that Foo is derived from the class called object. Don't be confused -- any existing class could be used here; more than one, in fact.

The reason you usually derive classes from object is a historical accident but probably is worth a detail. Python's original object implementation treated user-defined classes and built-in types as slightly different kinds of things. Then the language's designer decided to unify these two concepts. As a result, classes derived from object (or from a descendant of object) behave slightly differently from classes that are not derived from object and are called new-style classes. Old-style classes, on the other hand, were ones defined like this:

class Foo:
    pass

class Bar(Foo):
    pass

Note these do not inherit from object or from anything else that inherits from object. This makes them old-style classes.

When working with Python 2.x, your classes should almost always inherit from object, as the new-style objects are nicer to work with in several small but important ways.

To further confuse things, in Python 3.0 and later, there are no old-style classes, so you don't have to derive from object explicitly. In other words, all the above classes would be new-style classes in Python 3.x.

Now, back to the matter at hand. Classes are objects because everything is an object in Python. Lists, dictionaries, integers, strings, tuples... all of these are objects, and so are the building blocks of Python programs: modules, functions, and classes. You can create a class using the class keyword and then pass it to a function, modify it, etc. (For completeness, you can also create a class using the type() function.)

A class is a template for building objects, which are referred to as instances. This part you already know. You instantiate objects similar to calling a function, passing in the initial values and other parameters:

mylist = list("abc")   # constructs ["a", "b", "c"]

Behind the scenes, this creates an instance, then calls the new instance's __init__() method to initialize it. Since everything's an object in Python, instances of a class are also objects.

One last thing you might want to know is that just as classes are templates for building objects, so it is possible to have templates for building classes. These are called metaclasses. The base metaclass is called type (that is, an ordinary new-style class is an instance of type).

(Yes, this is the same type that I mentioned earlier can be used to create classes, and the reason you can call it to create classes is that it's a metaclass.)

To create your own metaclass, you derive it from type like so:

class mymeta(type):
    pass

Metaclasses are a fairly advanced Python topic, so I won't go into what you might use them for or how to do it, but they should make it clear how far Python takes the "everything's an object" concept.

Answer 2

Since you asked for "english please", I'll try to make it simple at the cost of detail.

Let's ignore classes and instances at first, and just look at objects.

A Python object contains data and functions, just like objects in every other object oriented programming language. Functions attached to objects are called methods.

x = "hello" #now x is an object that contains the letters in "hello" as data
print x.size() #but x also has methods, for example size()
print "hello".size() #In python, unlike C++, everything is an object, so a string literal has methods.
print (5).bit_length() #as do integers (bit_length only works in 2.7+ and 3.1+, though)

A class is a description (or a recipe, if you will) of how to construct new objects. Objects constructed according to a class description are said to belong to that class. A fancy name for belonging to a class is to be an instance of that class.

Now, earlier I wrote that in Python everything is an object. Well, that holds for stuff like functions and classes as well. So a description of how to make new objects is itself an object.

class C: #C is a class and an object
  a = 1

x1 = C() #x1 is now an instance of C
print x1.a #and x1 will contain an object a

y = C #Since C is itself an object, it is perfectly ok to assign it to y, note the lack of ()
x2 = y() #and now we can make instances of C, using y instead.
print x2.a #x2 will also contain an object a

print C #since classes are objects, you can print them
print y #y is the same as C.
print y == C #really the same.
print y is C #exactly the same.

This means that you can treat classes (and functions) like everything else and, for example, send them as arguments to a function, which can use them to construct new objects of a class it never knew existed.

Answer 3

Terminology-wise, classes and instances are both called objects in Python, but for you as a regular Python programmer this is of no importance. You can see Python's classes and instances pretty much as C++'s classes and instances:

class MyClass:
  data = 1

mc = MyClass()

MyClass is a class and mc is an instance of class MyClass.

---

Python is much more dynamic in nature than C++ though, so its classes are also objects. But this isn't something programmers usually are exposed to, so you can just not worry about it.

Answer 4

In a very real sense, everything in Python is an object: a class (or any type) is an object, a function is an object, a number is an object... And every object has a type. A "type" is a particular type of object (a class, if you wish), with additional data describing the various attributes of the type (functions, etc.). If you're used to C++, you can think of it as something like:

struct Type;

struct Object  //  The base class of everything.
{
    Type* myType;
    //  Some additional stuff, support for reference counting, etc.
};

struct Type : Object
{
    //  Lots of additional stuff defining type attributes...
};

When you define a new class in Python, you're really just creating a new instance of Type; when you instantiate that class, Python initializes the myType member with a pointer to the correct instance of Type.

Note, however, that everything is dynamic. When you define a type Toto (by executing a class definition—even defining a type is a runtime thing, not compile time, as in C++), the Python interpreter creates an instance of Type, and puts it in a dictionary (map<string, Object*>, in C++ parlance) somewhere. When the interpreter encounters a statement like:

x = Toto()

, it looks up Toto in the dictionary: if the Object referred to has the type Type, it constructs a new instance of that object, if it has type Function (functions are also objects), it calls the function. (More generally, a type/class may be callable or not; if the type of the Object found in the dictionary under Toto is callable, the Python interpreter does whatever the object has defined "call" to mean. Sort of like overloading operator()() in C++. The overload of operator()() for Type is to construct a new object of that type.)

And yes, if you come from a classical background—strictly procedural, structured, fully-compiled languages, it can be pretty confusing at first.

Answer 5

Everything in Python is an object. Even classes, which are instances of metaclasses.