Inheritance

We already know what classes are, and we have seen the class for kitties as an example:

class Kittie:
    def __init__(self, name):
        self.name = name

    def meow(self):
        print("{}: Meow!".format(self.name))

    def eat(self, food):
        print("{}: Meow meow! I like {} very much!".format(self.name, food))

Now create a similar class for dogs:

class Doggie:
    def __init__(self, name):
        self.name = name

    def woof(self):
        print("{}: Woof!".format(self.name))

    def eat(self, food):
        print("{}: Woof woof! I like {} very much!".format(self.name, food))

Most of the code is the same! If you would have to write a class for chicks, ducks, and rabbits, it would be quite boring task without Ctrl+C. And because programmers are lazy to write the same piece of code multiple times (and mostly maintain it) they created mechanism how to avoid that. How?

Kitties and doggies are animals. So you can create a class for all animals, and write into it everything that applies to all animals. And in the classes about each animal, you just write the specifics. That's how it's done in Python:

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self, food):
        print("{}: I like {} very much!".format(self.name, food))


class Kittie(Animal):
    def meow(self):
        print("{}: Meow!".format(self.name))


class Doggie(Animal):
    def woof(self):
        print("{}: Woof!".format(self.name))


smokey = Kittie('Smokey')
doggo = Doggie('Doggo')
smokey.meow()
doggo.woof()
smokey.eat('mouse')
doggo.eat('bone')

How does it work? With the command class Kittie(Animal) you are telling Python that the class Kittie inherits behaviour from the class Animal. In other programming languages they say that Kittie is derived from Animal or it extends Animal. Derived classes are called subclasses and the main one is the superclass

When Python searches for a method/function (or other attribute), for example smokey(eat), and it doesn't find it in the class itself it will look into the superclass. So everything that has been defined for Animal applies to Kittie (unless you tell Python otherwise).

Overwriting methods and super()

If you don't like some behaviour of the superclass, you can define a method with the same name in the subclass:

class Kittie(Animal):
    def eat(self, food):
        print("{}: I don't like {} at all!".format(self.name, food))


smokey = Kittie('Smokey')
smokey.eat('dry food')

It's similar to what we did in the previous lesson with misty.meow = 12345. Python searches for the attributes in the object, then in the class, and then in the superclass (and then in superclass' superclass).

Sometimes it can happen that you need some behaviour from the original method in the overwritten method. You can call it with the special function super(), which allows calling methods in a superclass.

class Kittie(Animal):
    def eat(self, food):
        print("({} is looking at {} for a while)".format(self.name, food))
        super().eat(food)

smokey = Kittie('Smokey')
smokey.eat('dry food')

Keep in mind that you have to pass everything that this super() method needs (apart from self, which is passed automatically). You can use this - you can pass different values than the original function received (in this case, a snake class will receive the name Stanley, but you want to change it to Ssstanley):

class snake(Animal):
    def __init__(self, name):
        name = name.replace('s', 'sss')
        name = name.replace('S', 'Sss')
        super().__init__(name)


stanley = snake('Stanley')
stanley.eat('mouse')

As you can see, you can use super() even with special methods like __init__.

Polymorphism

Programmers didn't invent inheritance only because they are lazy to write the same code multiple times. That is, of course, one good reason, but superclasses have also another important feature: When we know that Kittie and Doggie and any other similar class are animals, we can create a list of animals, but we don't care what animals they are specifically:

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self, food):
        print("{}: I like {} very much!".format(self.name, food))


class Kittie(Animal):
    def meow(self):
        print("{}: Meow!".format(self.name))


class Doggie(Animal):
    def woof(self):
        print("{}: Woof!".format(self.name))

animals = [Kittie('Smokey'), Doggie('Doggo')]

for animal in animals:
    animal.eat('meat')

This is some quite important behaviour of subclasses: When you have a Kittie, you can use it anywhere where a program expects Animal, because each kittie is an animal.

This is a good approach when you won't know which class should be inherited in which class. Each kittie or doggie is an animal, each cabin or house is a building. In those examples, heredity makes sense.

But sometimes our approach fails - for example if we would say each car is a steering wheel, then we know that we shouldn't use inheritance. Even if we can "rotate" both cars and steering wheels, it means a different thing, and we definitely can't use cars everywhere where we would want to use steering wheels. So in this case we should say to ourselves: Each kittie has a name and each car has a steering wheel, so we should create two different classes, and in the car class, we use steering wheel as default variable:

class Car:
    def __init__(self):
        self.wheel = Wheel()

(And when some programmer gets mad at you that you are breaking Liskov_substitution_principle it's because of this problem.)

Generalization

When you look back at the functions meow and woof, you will maybe find out that they can be named better, so they can be used for each animal, similarly as eat.

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self, food):
        print("{}: I like {} very much!".format(self.name, food))


class Kittie(Animal):
    def speak(self):
        print("{}: Meow!".format(self.name))


class Doggie(Animal):
    def speak(self):
        print("{}: Woof!".format(self.name))

animals = [Kittie('Smokey'), Doggie('Doggo')]

for animal in animals:
    animal.speak()
    animal.eat('meat')

As this example shows, writing superclasses from which we can easily inherit methods is not easy. It is definitely not easy when we want to create a subclass in a different program than where the superclass is. So that's why you should inherit classes within your code: We do not recommend to inherit classes that someone else wrote, unless the author of the superclass explicitly mentions that (and mainly how) you can inherit from their class.

And that's all about classes. Now you know enough to create your own zoo :)

{
  "data": {
    "sessionMaterial": {
      "id": "session-material:2018/pyladies-en-prague:class:1",
      "title": "Inheritance",
      "html": "\n          \n    \n\n    <h1>Inheritance</h1>\n<p>We already know what classes are, and we have seen the class for kitties\nas an example:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Kittie</span><span class=\"p\">:</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">):</span>\n        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">meow</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Meow!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Meow meow! I like {} very much!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n</pre></div><p>Now create a similar class for dogs:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Doggie</span><span class=\"p\">:</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">):</span>\n        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">woof</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Woof!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Woof woof! I like {} very much!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n</pre></div><p>Most of the code is the same!\nIf you would have to write a class for chicks, ducks, and rabbits, \nit would be quite boring task without Ctrl+C.\nAnd because programmers are lazy to write the same piece of\ncode multiple times (and mostly maintain it) they created\nmechanism how to avoid that. How?</p>\n<p>Kitties and doggies are animals.\nSo you can create a class for all animals, and write\ninto it everything that applies to all animals.\nAnd in the classes about each animal, you just\nwrite the specifics.\nThat&apos;s how it&apos;s done in Python:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Animal</span><span class=\"p\">:</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">):</span>\n        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: I like {} very much!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Kittie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">meow</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Meow!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Doggie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">woof</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Woof!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n\n<span class=\"n\">smokey</span> <span class=\"o\">=</span> <span class=\"n\">Kittie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Smokey&apos;</span><span class=\"p\">)</span>\n<span class=\"n\">doggo</span> <span class=\"o\">=</span> <span class=\"n\">Doggie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Doggo&apos;</span><span class=\"p\">)</span>\n<span class=\"n\">smokey</span><span class=\"o\">.</span><span class=\"n\">meow</span><span class=\"p\">()</span>\n<span class=\"n\">doggo</span><span class=\"o\">.</span><span class=\"n\">woof</span><span class=\"p\">()</span>\n<span class=\"n\">smokey</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;mouse&apos;</span><span class=\"p\">)</span>\n<span class=\"n\">doggo</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;bone&apos;</span><span class=\"p\">)</span>\n</pre></div><p>How does it work?\nWith the command <code>class Kittie(Animal)</code> you are\ntelling Python that the class <code>Kittie</code> <em>inherits</em>\nbehaviour from the class <code>Animal</code>.\nIn other programming languages they say\nthat <code>Kittie</code> is <em>derived from</em> <code>Animal</code> \nor it <em>extends</em> <code>Animal</code>.\nDerived classes are called <em>subclasses</em> and the main one\nis the <em>superclass</em></p>\n<p>When Python searches for a method/function (or other attribute),\nfor example <code>smokey(eat)</code>, and it doesn&apos;t find it in the class itself\nit will look into the superclass. So everything that has been\ndefined for Animal applies to Kittie (unless you\ntell Python otherwise).</p>\n<h2>Overwriting methods and <code>super()</code></h2>\n<p>If you don&apos;t like some behaviour of the superclass, you can\ndefine a method with the same name in the subclass:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Kittie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: I don&apos;t like {} at all!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n\n\n<span class=\"n\">smokey</span> <span class=\"o\">=</span> <span class=\"n\">Kittie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Smokey&apos;</span><span class=\"p\">)</span>\n<span class=\"n\">smokey</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;dry food&apos;</span><span class=\"p\">)</span>\n</pre></div><div class=\"admonition python\"><p>It&apos;s similar to what we did in the previous lesson with\n<code>misty.meow = 12345</code>. Python searches for the attributes in the object,\nthen in the class, and then in the superclass (and then in superclass&apos; superclass).</p>\n</div><p>Sometimes it can happen that you need some behaviour from the original method\nin the overwritten method. You can call it with the special function <code>super()</code>,\nwhich allows calling methods in a superclass.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Kittie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;({} is looking at {} for a while)&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n        <span class=\"nb\">super</span><span class=\"p\">()</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"n\">food</span><span class=\"p\">)</span>\n\n<span class=\"n\">smokey</span> <span class=\"o\">=</span> <span class=\"n\">Kittie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Smokey&apos;</span><span class=\"p\">)</span>\n<span class=\"n\">smokey</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;dry food&apos;</span><span class=\"p\">)</span>\n</pre></div><p>Keep in mind that you have to pass everything that this <code>super()</code> method\nneeds (apart from <code>self</code>, which is passed automatically).\nYou can use this - you can pass different values\nthan the original function received (in this case, a <code>snake</code> class will\nreceive the name <code>Stanley</code>, but you want to change it to <code>Ssstanley</code>):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">snake</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">):</span>\n        <span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span><span class=\"o\">.</span><span class=\"n\">replace</span><span class=\"p\">(</span><span class=\"s1\">&apos;s&apos;</span><span class=\"p\">,</span> <span class=\"s1\">&apos;sss&apos;</span><span class=\"p\">)</span>\n        <span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span><span class=\"o\">.</span><span class=\"n\">replace</span><span class=\"p\">(</span><span class=\"s1\">&apos;S&apos;</span><span class=\"p\">,</span> <span class=\"s1\">&apos;Sss&apos;</span><span class=\"p\">)</span>\n        <span class=\"nb\">super</span><span class=\"p\">()</span><span class=\"o\">.</span><span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"n\">name</span><span class=\"p\">)</span>\n\n\n<span class=\"n\">stanley</span> <span class=\"o\">=</span> <span class=\"n\">snake</span><span class=\"p\">(</span><span class=\"s1\">&apos;Stanley&apos;</span><span class=\"p\">)</span>\n<span class=\"n\">stanley</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;mouse&apos;</span><span class=\"p\">)</span>\n</pre></div><p>As you can see, you can use <code>super()</code> even with special methods\nlike <code>__init__</code>.</p>\n<h2>Polymorphism</h2>\n<p>Programmers didn&apos;t invent inheritance only because they are lazy\nto write the same code multiple times. That is, of course, one\ngood reason, but superclasses have also another\nimportant feature: When we know that <code>Kittie</code> and <code>Doggie</code>\nand any other similar class are animals, we can create a list\nof animals, but we don&apos;t care what animals they are \nspecifically:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Animal</span><span class=\"p\">:</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">):</span>\n        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: I like {} very much!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Kittie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">meow</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Meow!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Doggie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">woof</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Woof!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n<span class=\"n\">animals</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">Kittie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Smokey&apos;</span><span class=\"p\">),</span> <span class=\"n\">Doggie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Doggo&apos;</span><span class=\"p\">)]</span>\n\n<span class=\"k\">for</span> <span class=\"n\">animal</span> <span class=\"ow\">in</span> <span class=\"n\">animals</span><span class=\"p\">:</span>\n    <span class=\"n\">animal</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;meat&apos;</span><span class=\"p\">)</span>\n</pre></div><p>This is some quite important behaviour of subclasses:\nWhen you have a <code>Kittie</code>, you can use it anywhere\nwhere a program expects <code>Animal</code>, because each kittie\n<em>is</em> an animal.</p>\n<div class=\"admonition note\"><p>This is a good approach when you won&apos;t know which class should be\ninherited in which class.\nEach <em>kittie</em> or <em>doggie</em> is an <em>animal</em>,\neach <em>cabin</em> or <em>house</em> is a <em>building</em>.\nIn those examples, heredity makes sense.</p>\n<p>But sometimes our approach fails - for example if we would say\neach <em>car</em> is a <em>steering wheel</em>, then we know that\nwe shouldn&apos;t use inheritance.\nEven if we can &quot;rotate&quot; both cars and steering wheels, it means a different thing, \nand we definitely can&apos;t use cars everywhere where we would want to\nuse steering wheels. So in this case we should say to ourselves:\nEach kittie <em>has</em> a name and each car <em>has</em> a steering wheel, so we\nshould create two different classes, and in the car class, we \nuse steering wheel as default variable:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Car</span><span class=\"p\">:</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">wheel</span> <span class=\"o\">=</span> <span class=\"n\">Wheel</span><span class=\"p\">()</span>\n</pre></div><p>(And when some programmer gets mad at you that you\nare breaking <a href=\"https://en.wikipedia.org/wiki/Liskov_substitution_principle\">Liskov_substitution_principle</a>\nit&apos;s because of this problem.)</p>\n</div><h2>Generalization</h2>\n<p>When you look back at the functions <code>meow</code> and <code>woof</code>, you will maybe find out\nthat they can be named better, so they can be used for each animal, similarly\nas <code>eat</code>.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Animal</span><span class=\"p\">:</span>\n    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">):</span>\n        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name</span>\n\n    <span class=\"k\">def</span> <span class=\"nf\">eat</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: I like {} very much!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">food</span><span class=\"p\">))</span>\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Kittie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">speak</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Meow!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n\n<span class=\"k\">class</span> <span class=\"nc\">Doggie</span><span class=\"p\">(</span><span class=\"n\">Animal</span><span class=\"p\">):</span>\n    <span class=\"k\">def</span> <span class=\"nf\">speak</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">&quot;{}: Woof!&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">name</span><span class=\"p\">))</span>\n\n<span class=\"n\">animals</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">Kittie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Smokey&apos;</span><span class=\"p\">),</span> <span class=\"n\">Doggie</span><span class=\"p\">(</span><span class=\"s1\">&apos;Doggo&apos;</span><span class=\"p\">)]</span>\n\n<span class=\"k\">for</span> <span class=\"n\">animal</span> <span class=\"ow\">in</span> <span class=\"n\">animals</span><span class=\"p\">:</span>\n    <span class=\"n\">animal</span><span class=\"o\">.</span><span class=\"n\">speak</span><span class=\"p\">()</span>\n    <span class=\"n\">animal</span><span class=\"o\">.</span><span class=\"n\">eat</span><span class=\"p\">(</span><span class=\"s1\">&apos;meat&apos;</span><span class=\"p\">)</span>\n</pre></div><p>As this example shows, writing superclasses from which we can easily inherit\nmethods is not easy. It is definitely not easy when we want to create a \nsubclass in a different program than where the superclass is.\nSo that&apos;s why you should inherit classes within your code:\nWe do not recommend to inherit classes that someone else wrote,\nunless the author of the superclass explicitly mentions that (and\nmainly how) you can inherit from their class.</p>\n<p>And that&apos;s all about classes. Now you know enough to create\nyour own zoo :)</p>\n\n\n        "
    }
  }
}