In this lesson, we start building our Dog class and fill it out with attributes.
We can instantiate our Dog class like this
philo = Dog("Philo", 5)
We can access the instance attributes with dot notation.
print(philo.name)
Join us and get access to thousands of tutorials and a community of expert Pythonistas.
This lesson is for members only. Join us and get access to thousands of tutorials and a community of expert Pythonistas.
In this lesson, we start building our Dog class and fill it out with attributes.
We can instantiate our Dog class like this
philo = Dog("Philo", 5)
We can access the instance attributes with dot notation.
print(philo.name)
00:01 Welcome back to our series on object-oriented programming in Python. In the last video, we learned how Python classes can define both class attributes and instance attributes. To better understand how classes are instantiated, let’s head over to the Python shell. All right.
00:18
So, I’m here in the Python shell and I’m going to start by creating a new class Dog, and I’ll just write pass, which will tell Python that we want a blank object. Now, if I simply call Dog() like this, Python will instantiate that and it will actually tell us the memory address of our new Dog object—that’s this fancy-looking number right here.
00:41
Now, let’s create another Dog object. Do you think that this new object will share the same memory address as the first one? Or is it going to be different? If we press Enter here, you’ll see that this new object has a slightly different memory address.
00:56
This is because each instance of our Dog class is unique. Sure, both objects are created from the same class, but they’re still different objects in memory.
01:06
If we actually filled out the class with an initializer, we could assign different attributes to each object. And just to drive this point home, I’ll create two new dogs and I’ll store them in variables a and b.
01:20
So, at this point, a and b are both variables that point to objects in memory—objects of type Dog.
01:28
We can easily check if they’re the same object by using the double equals (==) operator. And if I press Enter, we will see that they are not; a and b point to different Dog objects, even though both objects are blank.
01:41
And to prove that both of these variables are of type Dog, I’ll use Python’s built-in type() function, and I’ll give it a as an argument.
01:50
As you can see, this variable is pointing to an object that was instantiated from the Dog class.
01:58
Now, let’s finally build a real Dog class and create some real Dog objects. I’m here in Visual Studio Code, and I’m going to start by defining a new class called Dog.
02:09
Next, I’ll type species = "mammal". This is going to create a class attribute for our Dog. This means that every new dog we create is going to be a mammal, by default.
02:22
But now, I want to write some unique instance attributes, so I’ll add in an initializer to the class by typing out my .__init__() function, and that will require three parameters: self, name, and age.
02:36
Remember, we don’t actually supply a value for self, but we do need to do something with these name and age parameters, so we’ll tell Python we want to assign them to the new object being created.
02:47
Here, self references the current object being created, so self.name = name means to assign the name parameter to this new dog’s .name. And that’s it! We’ve created our Dog class.
03:02
Let’s actually use it now. We’ll create a new variable called philo and that is going to point to a Dog object. We create a new object by typing the class name followed by parentheses (()), almost as if it were a function.
03:17
When we do this, Python is actually going to call the initializer behind the scenes, and so we need to supply our name and age arguments.
03:25
So here, I’ll make the name "Philo" and we’ll give him an age of 5. Next,
03:31
let’s make another dog named "Mikey", and he will have an age of 6. Congratulations. If you’ve been following along, you’ve just created and instantiated your first class. Right now, we have two dogs—one named Philo with an age of 5 and the other named Mikey with an age of 6.
03:50
But how do we actually access the data inside of these objects? To do that, we can use the access modifier, which in Python is the dot (.).
03:59
You’ll notice that when I type philo., Visual Studio IntelliSense—which is incredible, by the way—appears, and it shows me all of the attributes that I can access. So, let’s do this.
04:12
I will delete this new line and I’ll replace it with a print statement. I’ll say "{} is {} and {} is {}", and then I’ll call the .format() function on this string, which will allow us to populate these blanks ({}). Because we have four blanks, we need to pass in the .format() function four arguments.
04:33
So, I’ll pass in philo.name, philo.age, mikey.name, and mikey.age. These are going to access all of the attributes of both of our objects.
04:45
Next, let’s see if both dogs have the "mammal" attribute. I’ll type if philo.species == the string "mammal", then I want to print "{} is a {}" and then—just like before—I’ll fill in these blanks ({}) with Philo’s .name and Philo’s .species using the .format() function.
05:10
All right, let’s right-click and Run Code, and on the right side here, we can see exactly what we’re expecting. Philo is 5 and Mikey is 6, which is from our first print statement. And then, because Philo is a mammal, we also saw Philo is a mammal printed to the screen.
05:28
Now, let’s change things up a bit. After we create the new Dog objects, let’s change their attributes. So, I’ll move up a few lines and I’ll type mikey.age = 7 and then philo.species = "mouse". Now, pause this video and take a look at this code and think about what it’s going to print. All right, let’s take a look.
05:54
Now, we see that Philo is 5 and Mikey is 7. That’s because we changed Mikey’s .age after we created the object. And notice that we don’t see Philo is a mammal anymore—that’s because we changed Philo from being a mammal to a mouse, and again, we did that after we created the object.
06:13
When we assigned new values to these attributes, the initializer wasn’t used. That’s only used when we create new objects, not modify their attributes. Also, if you notice here, both Dog objects are completely independent of one another, even though they came from the same class.
06:31 Even though I changed Philo from being a mammal to a mouse, Mikey is still a mammal. And that right there is just scratching the surface of the power of object-oriented programming. In the next video, we’ll take a look at instance methods, which is the fancy Python way of saying class behaviors. I’ll see you there.
henrytirla on Nov. 21, 2020
Great course! What about attributes that are defined out of the __init__()? Are they still instantiated when it is called eg class Person:
def __init__(self, name):
self.name = name
self.age= age
self.astrosign = astrosign
Will the last two attributes be called when the init is called?
Bartosz Zaczyński RP Team on Nov. 23, 2020
@henrytirla Attributes declared outside of .__init__() or any other method are attached to the enclosing class. They’re defined even before any instance of that class exists and are shared across all existing instances.
For example, consider this Person class:
>>> class Person:
...
... counter = 42
...
... def __init__(self, name):
... self.name = name
...
>>> Person.counter # There are no instances of this class yet
42
>>> alice = Person("Alice")
>>> bob = Person("Bob")
>>> alice.counter
42
>>> bob.counter
42
However, when you wish to change the value of a class attribute, you should always refer to it through the class name instead of a particular instance. Otherwise, unexpected things start to happen. You’re creating an instance attribute with the same name that masks the class attribute:
>>> alice.counter = 15 # Defines an instance attribute in Alice
>>> alice.counter
15
>>> bob.counter # Bob has no such attribute
42
>>> Person.counter # ...so, it delegates to the class attribute
42
charles7276 on April 5, 2021
Would it be better to set the species in the __init__ function? For example, self.species = 'mammal'. I guess I’ve just never seen it done the way shown in the tutorial.
Bartosz Zaczyński RP Team on April 6, 2021
@chananya7276 “Better” is a highly subjective term because it all depends on the circumstances 😉 This lesson introduces the concept of class attributes, and species was defined as one for the sake of example.
mrudavshukla on Aug. 8, 2021
Hey Austin, not able to understand the phrase at 03:56, “… we can use the access modifier, which in python is a dot(.)”. Aren’t access modifiers public, protected and private in general?
HomoDeus on Nov. 28, 2022
I am new to Python. If class attributes is what I understand is default, would changing it as per your example make sense?
Ariba S on June 5, 2024
Can I get clarification that a class attribute when changed by one instance, is changed for all instances?
ahairshi on Aug. 19, 2024
The class variable is shared among all instances of a class, rather than being unique to each instance. It is called static variable in Java.
Stephen Cole on Feb. 3, 2025
The first comment is from 2019. This video is a little stale. (Kind of like my Python skills.)
This is the print statement with f-strings:
print(f"{philo.name} is {philo.age} and {mikey.name} is {mikey.age}")
Become a Member to join the conversation.
Get a Python Cheat Sheet (PDF) and learn the basics of Python, like working with data types, dictionaries, lists, and Python functions:
Geir Arne Hjelle RP Team on Oct. 18, 2020
@Joseph Flanagan, agreed, it would have been better to use
a == bin this case.However, this is the kind of mistake that somehow still works. When a class does not define
.__eq__(),==is essentially equal tois. More precisely:(Source: docs.python.org/3/reference/datamodel.html#object.__hash__)