Classes vs Instances

Classes allow you to create user-defined data structures. Classes define functions calledmethods, which identify the behaviors and actions that an object created from the class can perform with its data.

In this tutorial, you’ll create aDog class that stores some information about the characteristics and behaviors that an individual dog can have.

A class is a blueprint for how to define something. It doesn’t actually contain any data. TheDog class specifies that a name and an age are necessary for defining a dog, but it doesn’t contain the name or age of any specific dog.

While the class is the blueprint, aninstance is an object that’s built from a class and contains real data. An instance of theDog class is not a blueprint anymore. It’s an actual dog with a name, like Miles, who’s four years old.

Put another way, a class is like a form or questionnaire. An instance is like a form that you’ve filled out with information. Just like many people can fill out the same form with their own unique information, you can create many instances from a single class.

Class Definition

You start all class definitions with theclass keyword, then add the name of the class and a colon. Python will consider any code that you indent below the class definition as part of the class’s body.

Here’s an example of aDog class:

classDog:pass

The body of theDog class consists of a single statement: thepass keyword. Python programmers often usepass as a placeholder indicating where code will eventually go. It allows you to run this code without Python throwing an error.

TheDog class isn’t very interesting right now, so you’ll spruce it up a bit by defining some properties that allDog objects should have. There are several properties that you can choose from, including name, age, coat color, and breed. To keep the example small in scope, you’ll just use name and age.

You define the properties that allDog objects must have in a method called.__init__(). Every time you create a newDog object,.__init__() sets the initialstate of the object by assigning the values of the object’s properties. That is,.__init__() initializes each new instance of the class.

You can give.__init__() any number of parameters, but the first parameter will always be avariable calledself. When you create a new class instance, then Python automatically passes the instance to theself parameter in.__init__() so that Python can define the newattributes on the object.

Update theDog class with an.__init__() method that creates.name and.age attributes:

classDog:def__init__(self,name,age):self.name=nameself.age=age

Make sure that you indent the.__init__() method’s signature by four spaces, and the body of the method by eight spaces. This indentation is vitally important. It tells Python that the.__init__() method belongs to theDog class.

In the body of.__init__(), there are two statements using theself variable:

1. self.name = name creates an attribute calledname and assigns the value of thename parameter to it.
2. self.age = age creates an attribute calledage and assigns the value of theage parameter to it.

Attributes created in.__init__() are calledinstance attributes. An instance attribute’s value is specific to a particular instance of the class. AllDog objects have a name and an age, but the values for thename andage attributes will vary depending on theDog instance.

On the other hand,class attributes are attributes that have the same value for all class instances. You can define a class attribute by assigning a value to avariable name outside of.__init__().

For example, the followingDog class has a class attribute calledspecies with the value"Canis familiaris":

classDog:species="Canis familiaris"def__init__(self,name,age):self.name=nameself.age=age

You define class attributes directly beneath the first line of the class name and indent them by four spaces. You always need to assign them an initial value. When you create an instance of the class, then Python automatically creates and assigns class attributes to their initial values.

Use class attributes to define properties that should have the same value for every class instance. Use instance attributes for properties that vary from one instance to another.

Now that you have aDog class, it’s time to create some dogs!

Class and Instance Attributes

Now create a newDog class with a class attribute called.species and two instance attributes called.name and.age:

>>>classDog:...species="Canis familiaris"...def__init__(self,name,age):...self.name=name...self.age=age...

To instantiate thisDog class, you need to provide values forname andage. If you don’t, then Python raises aTypeError:

>>>Dog()Traceback (most recent call last):...TypeError:__init__() missing 2 required positional arguments: 'name' and 'age'

To pass arguments to thename andage parameters, put values into the parentheses after the class name:

>>>miles=Dog("Miles",4)>>>buddy=Dog("Buddy",9)

This creates two newDog instances—one for a four-year-old dog named Miles and one for a nine-year-old dog named Buddy.

TheDog class’s.__init__() method has three parameters, so why are you only passing two arguments to it in the example?

When you instantiate theDog class, Python creates a new instance ofDog and passes it to the first parameter of.__init__(). This essentially removes theself parameter, so you only need to worry about thename andage parameters.

After you create theDog instances, you can access their instance attributes usingdot notation:

>>>miles.name'Miles'>>>miles.age4>>>buddy.name'Buddy'>>>buddy.age9

You can access class attributes the same way:

>>>buddy.species'Canis familiaris'

One of the biggest advantages of using classes to organize data is that instances are guaranteed to have the attributes you expect. AllDog instances have.species,.name, and.age attributes, so you can use those attributes with confidence, knowing that they’ll always return a value.

Although the attributes are guaranteed to exist, their valuescan change dynamically:

>>>buddy.age=10>>>buddy.age10>>>miles.species="Felis silvestris">>>miles.species'Felis silvestris'

In this example, you change the.age attribute of thebuddy object to10. Then you change the.species attribute of themiles object to"Felis silvestris", which is a species of cat. That makes Miles a pretty strange dog, but it’s valid Python!

The key takeaway here is that custom objects are mutable by default. An object is mutable if you can alter it dynamically. For example, lists anddictionaries are mutable, but strings and tuples areimmutable.

Instance Methods

Instance methods are functions that you define inside a class and can only call on an instance of that class. Just like.__init__(), an instance method always takesself as its first parameter.

Open a new editor window in IDLE and type in the followingDog class:

classDog:species="Canis familiaris"def__init__(self,name,age):self.name=nameself.age=age# Instance methoddefdescription(self):returnf"{self.name} is{self.age} years old"# Another instance methoddefspeak(self,sound):returnf"{self.name} says{sound}"

ThisDog class has two instance methods:

1. .description() returns a string displaying the name and age of the dog.
2. .speak() has one parameter calledsound and returns a string containing the dog’s name and the sound that the dog makes.

Save the modifiedDog class to a file calleddog.py and pressF5 to run the program. Then open the interactive window and type the following to see your instance methods in action:

>>>miles=Dog("Miles",4)>>>miles.description()'Miles is 4 years old'>>>miles.speak("Woof Woof")'Miles says Woof Woof'>>>miles.speak("Bow Wow")'Miles says Bow Wow'

In the aboveDog class,.description() returns a string containing information about theDog instancemiles. When writing your own classes, it’s a good idea to have a method that returns a string containing useful information about an instance of the class. However,.description() isn’t the mostPythonic way of doing this.

When you create alist object, you can useprint() to display a string that looks like the list:

>>>names=["Miles","Buddy","Jack"]>>>print(names)['Miles', 'Buddy', 'Jack']

Go ahead and print themiles object to see what output you get:

>>>print(miles)<__main__.Dog object at 0x00aeff70>

When you printmiles, you get a cryptic-looking message telling you thatmiles is aDog object at the memory address0x00aeff70. This message isn’t very helpful. You can change what gets printed by defining a special instance method called.__str__().

In the editor window, change the name of theDog class’s.description() method to.__str__():

classDog:# ...def__str__(self):returnf"{self.name} is{self.age} years old"

Save the file and pressF5. Now, when you printmiles, you get a much friendlier output:

>>>miles=Dog("Miles",4)>>>print(miles)'Miles is 4 years old'

Methods like.__init__() and.__str__() are calleddunder methods because they begin and end withdouble underscores. There are many dunder methods that you can use to customize classes in Python.Understanding dunder methods is an important part of mastering object-oriented programming in Python, but for your first exploration of the topic, you’ll stick with these two dunder methods.

If you want to reinforce your understanding with a practical exercise, then you can click on the block below and work on solving the challenge:

The blue car has 20,000 milesThe red car has 30,000 miles

When you’re done with your own implementation of the challenge, then you can expand the block below to see a possible solution:

>>>classCar:...def__init__(self,color,mileage):...self.color=color...self.mileage=mileage...def__str__(self):...returnf"The{self.color} car has{self.mileage:,} miles"...

>>>blue_car=Car(color="blue",mileage=20_000)>>>red_car=Car(color="red",mileage=30_000)

>>>forcarin(blue_car,red_car):...print(car)...The blue car has 20,000 milesThe red car has 30,000 miles

When you’re ready, you can move on to the next section. There, you’ll see how to take your knowledge one step further and create classes from other classes.

Example: Dog Park

Pretend for a moment that you’re at a dog park. There are many dogs of different breeds at the park, all engaging in various dog behaviors.

Suppose now that you want to model the dog park with Python classes. TheDog class that you wrote in the previous section can distinguish dogs by name and age but not by breed.

You could modify theDog class in the editor window by adding a.breed attribute:

classDog:species="Canis familiaris"def__init__(self,name,age,breed):self.name=nameself.age=ageself.breed=breeddef__str__(self):returnf"{self.name} is{self.age} years old"defspeak(self,sound):returnf"{self.name} says{sound}"

PressF5 to save the file. Now you can model the dog park by creating a bunch of different dogs in the interactive window:

>>>miles=Dog("Miles",4,"Jack Russell Terrier")>>>buddy=Dog("Buddy",9,"Dachshund")>>>jack=Dog("Jack",3,"Bulldog")>>>jim=Dog("Jim",5,"Bulldog")

Each breed of dog has slightly different behaviors. For example, bulldogs have a low bark that sounds likewoof, but dachshunds have a higher-pitched bark that sounds more likeyap.

Using just theDog class, you must supply a string for thesound argument of.speak() every time you call it on aDog instance:

>>>buddy.speak("Yap")'Buddy says Yap'>>>jim.speak("Woof")'Jim says Woof'>>>jack.speak("Woof")'Jack says Woof'

Passing a string to every call to.speak() is repetitive and inconvenient. Moreover, the.breed attribute should determine the string representing the sound that eachDog instance makes, but here you have to manually pass the correct string to.speak() every time you call it.

You can simplify the experience of working with theDog class by creating a child class for each breed of dog. This allows you to extend the functionality that each child class inherits, including specifying a default argument for.speak().

Parent Classes vs Child Classes

In this section, you’ll create a child class for each of the three breeds mentioned above: Jack Russell terrier, dachshund, and bulldog.

For reference, here’s the full definition of theDog class that you’re currently working with:

classDog:species="Canis familiaris"def__init__(self,name,age):self.name=nameself.age=agedef__str__(self):returnf"{self.name} is{self.age} years old"defspeak(self,sound):returnf"{self.name} says{sound}"

After doing thedog park example in the previous section, you’ve removed.breed again. You’ll now write code to keep track of a dog’s breed using child classes instead.

To create a child class, you create a new class with its own name and then put the name of the parent class in parentheses. Add the following to thedog.py file to create three new child classes of theDog class:

# ...classJackRussellTerrier(Dog):passclassDachshund(Dog):passclassBulldog(Dog):pass

PressF5 to save and run the file. With the child classes defined, you can now create some dogs of specific breeds in the interactive window:

>>>miles=JackRussellTerrier("Miles",4)>>>buddy=Dachshund("Buddy",9)>>>jack=Bulldog("Jack",3)>>>jim=Bulldog("Jim",5)

Instances of child classes inherit all of the attributes and methods of the parent class:

>>>miles.species'Canis familiaris'>>>buddy.name'Buddy'>>>print(jack)Jack is 3 years old>>>jim.speak("Woof")'Jim says Woof'

To determine which class a given object belongs to, you can use the built-intype():

>>>type(miles)<class '__main__.JackRussellTerrier'>

What if you want to determine ifmiles is also an instance of theDog class? You can do this with the built-inisinstance():

>>>isinstance(miles,Dog)True

Notice thatisinstance() takes two arguments, an object and a class. In the example above,isinstance() checks ifmiles is an instance of theDog class and returnsTrue.

Themiles,buddy,jack, andjim objects are allDog instances, butmiles isn’t aBulldog instance, andjack isn’t aDachshund instance:

>>>isinstance(miles,Bulldog)False>>>isinstance(jack,Dachshund)False

More generally, all objects created from a child class are instances of the parent class, although they may not be instances of other child classes.

Now that you’ve created child classes for some different breeds of dogs, you can give each breed its own sound.

Parent Class Functionality Extension

Since different breeds of dogs have slightly different barks, you want to provide a default value for thesound argument of their respective.speak() methods. To do this, you need to override.speak() in the class definition for each breed.

To override a method defined on the parent class, you define a method with the same name on the child class. Here’s what that looks like for theJackRussellTerrier class:

# ...classJackRussellTerrier(Dog):defspeak(self,sound="Arf"):returnf"{self.name} says{sound}"# ...

Now.speak() is defined on theJackRussellTerrier class with the default argument forsound set to"Arf".

Updatedog.py with the newJackRussellTerrier class and pressF5 to save and run the file. You can now call.speak() on aJackRussellTerrier instance without passing an argument tosound:

>>>miles=JackRussellTerrier("Miles",4)>>>miles.speak()'Miles says Arf'

Sometimes dogs make different noises, so if Miles gets angry and growls, you can still call.speak() with a different sound:

>>>miles.speak("Grrr")'Miles says Grrr'

One thing to keep in mind about class inheritance is that changes to the parent class automatically propagate to child classes. This occurs as long as the attribute or method being changed isn’t overridden in the child class.

For example, in the editor window, change the string returned by.speak() in theDog class:

classDog:# ...defspeak(self,sound):returnf"{self.name} barks:{sound}"# ...

Save the file and pressF5. Now, when you create a newBulldog instance namedjim,jim.speak() returns the new string:

>>>jim=Bulldog("Jim",5)>>>jim.speak("Woof")'Jim barks: Woof'

However, calling.speak() on aJackRussellTerrier instance won’t show the new style of output:

>>>miles=JackRussellTerrier("Miles",4)>>>miles.speak()'Miles says Arf'

Sometimes it makes sense to completely override a method from a parent class. But in this case, you don’t want theJackRussellTerrier class to lose any changes that you might make to the formatting of theDog.speak() output string.

To do this, you still need to define a.speak() method on the childJackRussellTerrier class. But instead of explicitly defining the output string, you need to call theDog class’s.speak() frominside the child class’s.speak() using the same arguments that you passed toJackRussellTerrier.speak().

You can access the parent class from inside a method of a child class by usingsuper():

# ...classJackRussellTerrier(Dog):defspeak(self,sound="Arf"):returnsuper().speak(sound)# ...

When you callsuper().speak(sound) insideJackRussellTerrier, Python searches the parent class,Dog, for a.speak() method and calls it with the variablesound.

Updatedog.py with the newJackRussellTerrier class. Save the file and pressF5 so you can test it in the interactive window:

>>>miles=JackRussellTerrier("Miles",4)>>>miles.speak()'Miles barks: Arf'

Now when you callmiles.speak(), you’ll see output reflecting the new formatting in theDog class.

If you want to check your understanding of the concepts that you learned about in this section with a practical exercise, then you can click on the block below and work on solving the challenge:

classDog:species="Canis familiaris"def__init__(self,name,age):self.name=nameself.age=agedef__str__(self):returnf"{self.name} is{self.age} years old"defspeak(self,sound):returnf"{self.name} says{sound}"

When you’re done with your own implementation of the challenge, then you can expand the block below to see a possible solution:

# ...classGoldenRetriever(Dog):defspeak(self,sound="Bark"):returnsuper().speak(sound)

Nice work! In this section, you’ve learned how to override and extend methods from a parent class, and you worked on a small practical example to cement your new skills.