Python Course

Home Python 2 Tutorial Python 3 Tutorial Advanced Topics Numerical Programming Machine Learning Tkinter Tutorial Contact

Previous Chapter: Slots

Next Chapter: Road to Metaclasses

Classes and Class Creation

Behind the scenes: Relationship between Class and type

Follow Bernd Klein,
the author of this
In this chapter of our tutorial, we will provide you with a deeper insight into the magic happening behind the scenes, when we are defining a class or
website, at Google+:
creating an instance of a class. You may ask yourself: "Do I really have to learn theses additional details on object oriented programming in Python?"
Bernd Klein on
Most probably not, or you belong to the few people who design classes at a very advanced level.
Python 3 Google
Tutorial First, we will concentrate on the relationship between type and class. When you have defined classes so far, you may have asked yourself, what is
happening "behind the lines". We have already seen, that applying "type" to an object returns the class of which the object is an instance of: Bernd Klein on
The Origins of Facebook
Python x = [4, 5, 9]
y = "Hello"
Starting with
print(type(x), type(y)) Search this website:
Python: The
Interactive Shell The code above returned the following: Go
Executing a
Script <class 'list'> <class 'str'>
This topic in German
Indentation / Deutsche
If you apply type on the name of a class itself, you get the class "type" returned.
Data Types and Übersetzung:
Variables print(type(list), type(str)) Dynamische
Operators Erzeugung von
Sequential Data The above Python code returned the following: Klassen
Types: Lists and
<class 'type'> <class 'type'> Python 3
Strings
List
This is similar to applying type on type(x) and type(y): This is a tutorial in
Manipulations
Shallow and Python3, but this
x = [4, 5, 9]
chapter of our course
Deep Copy y = "Hello"
print(type(x), type(y)) is available in a
Dictionaries
print(type(type(x)), type(type(y))) version for Python
Sets and Frozen 2.x as well:
Sets This gets us the following result: Dynamically Creating
An Extensive Classes with type in
Example Using <class 'list'> <class 'str'> Python 2.x
<class 'type'> <class 'type'>
Sets
input via the Training Classes
A user-defined class (or the class "object") is an instance of the class "type". So, we can see, that classes are created from type. In Python3 there is no difference between "classes" and "types". They are in most
keyboard
cases used as synonyms.
Conditional This website aims at
Statements The fact that classes are instances of a class "type" allows us to program metaclasses. We can create classes, which inherit from the class "type". So, a metaclass is a subclass of the class "type". providing you with
Loops, while educational material
Instead of only one argument, type can be called with three parameters: suitable for self-
Loop
learning.
For Loops
type(classname, superclasses, attributes_dict) Nevertheless, it is
Difference faster and more
between If type is called with three arguments, it will return a new type object. This provides us with a dynamic form of the class statement. efficient to attend a
interators und "real" Python course
Iterables "classname" is a string defining the class name and becomes the name attribute; in a classroom, with
Output with Print "superclasses" is a list or tuple with the superclasses of our class. This list or tuple will become the bases attribute; an experienced
Formatted output the attributes_dict is a dictionary, functioning as the namespace of our class. It contains the definitions for the class body and it becomes the dict attribute. trainer. So why not
attend one of the live
with string Let's have a look at a simple class definition: Python courses
modulo and the
format method class A:
Functions pass
x = A()
Recursion and
print(type(x))
Recursive
Functions After having executed the Python code above we received the following result:
Parameter
Passing in <class '__main__.A'>
Functions
We can use "type" for the previous class defintion as well:
Namespaces
Global and Local A = type("A", (), {})
Variables x = A()
in Strasbourg, Paris,
Decorators print(type(x))
London, Berlin,
Memoization with
The previous Python code returned the following result: Munich, Hamburg,
Decorators Frankfurt, or Lake
Read and Write <class '__main__.A'> Constance by Bernd
Files Klein, the author of
Modular Generally speaking, this means, that we can define a class A with this tutorial?
Programming
type(classname, superclasses, attributedict)
and Modules
Packages in When we call "type", the call method of type is called. The call method runs two other methods: new and init: In-house
Python Training
Regular type.__new__(typeclass, classname, superclasses, attributedict) Courses
type.__init__(cls, classname, superclasses, attributedict)
Expressions
Regular If you like it, we will
The new method creates and returns the new class object, and after this the init method initializes the newly created object. come to your
Expressions,
company or institute
Advanced class Robot: and provide a special
Lambda counter = 0
training for your
Operator, Filter, def __init__(self, name):
self.name = name employees, as we've
Reduce and Map def sayHello(self): done it many times in
List return "Hi, I am " + self.name Amsterdam (The
Comprehension def Rob_init(self, name): Netherlands), Berlin
Iterators and
self.name = name (Germany), Bern
Robot2 = type("Robot2", (Switzerland), Basel
Generators (), (Switzerland), Zurich
Exception {"counter":0,
(Switzerland),
Handling "__init__": Rob_init,
"sayHello": lambda self: "Hi, I am " + self.name}) Frankfurt (Germany),
Tests, DocTests, Locarno
x = Robot2("Marvin")
UnitTests print(x.name) (Switzerland), Den
Object Oriented print(x.sayHello()) Haag (The Hague),
Programming y = Robot("Marvin") Hamburg, Munich
print(y.name) (Germany),
Class and print(y.sayHello())
Instance Bucharest (Romania),
print(x.__dict__)
Toronto (Canada),
Attributes print(y.__dict__)
Edmonton (Canada),
Properties vs.
The previous Python code returned the following result: and many other
getters and cities. We do training
setters Marvin courses in England,
Inheritance Hi, I am Marvin Switzerland,
Multiple Marvin Liechtenstein,
Hi, I am Marvin Austria, Germany,
Inheritance {'name': 'Marvin'}
Magic Methods France, Belgium, the
{'name': 'Marvin'}
Netherlands,
and Operator
Luxembourg,
Overloading The class definitions for Robot and Robot2 are syntactically completely different, but they implement logically the same class.
Romania, UK, Italy,
OOP, Inheritance Spain and other
Example What Python actually does in the first example, i.e. the "usual way" of defining classes, is the following: Python processes the complete class statement from class Robot to collect the methods and attributes of
locations in Europe
Robot to add them to the attributes_dict of the type call. So, Python will call type in a similar or the same way than we did in Robot2.
Slots and in Canada.
Classes and Previous Chapter: Slots
Class Creation Next Chapter: Road to Metaclasses This way you will get
Road to a perfect training up
Metaclasses to your needs and it
will be extremely cost
Metaclasses
efficient as well.
Metaclass Use
Case: Count Contact us so we can
Function Calls find the ideal course
Abstract Classes to meet your needs.

Skilled Python
Difference Programmers
between Classes
and Type You are looking for
experienced Python
To put it in a developers or
nutshell: There is no programmers? We
difference, but they can help you, please
used to be different, contact us.
a "long" time ago!
Quote of the
Day:

"Any program is only

Self-Study vs. as good as it is
Live Class useful." (Linus
Torvalds)
Lot's of visitors from
our website wonder
which method of
learning Python may
be best:
Data Protection
1. studying
Declaration
entirely on
one's own with
Data Protection
our online
Declaration
tutorial or other
textbooks, i.e.
"self-study"
2. live classroom
trainings or on-
site courses

We can't provide a
general answer to
this question. It
depends on the goals
of a student. One
benefit of self-study
is that it is the most
economical option in
terms of money.
Although a live class
involves expenses,
and often requires
travelling to the
course's location,
there are significant
and numerous
benefits by attending
a course taught by a
live lecturer in a
classroom setting:
First of all, it's a lot
faster, because our
experience is that
participants in one of
our courses learn in
just 3 or 5 days more
than they could have
learned in weeks of
self-study. Moreover,
this learning in a
classroom setting is
fun to learn.
Travelling might not
even be necessary, if
you book Bernd Klein
for an on-site course
at your institution or
company.

This website is
supported by:

Linux and Python

Courses as well as in-
house courses

© 2011 - 2018, Bernd Klein, Bodenseo; Design by Denise Mitchinson adapted for python-course.eu by Bernd Klein