Classes are a fundamental tool in any
respectable programming language. Think of a class as a template for creating
objects with related data and functions that do interesting things with that
data. Python makes it easy to create and use
classes. In fact, most other programming languages are quite jealous of Python
for its elegance and simplicity. Today, we will show you how to use classes in
Python, and we will do so in a classy way. Suppose we are building a new social
network called friendface, and our goal is to gather as much personal
information as possible about our users... for reasons. We will have a lot of data
about each user, and will write many functions using that data. To organize
this effort, let's start by making a class called user. In Python, you define a
class by first writing the class keyword, followed by the name of the class. It's
recommended that you capitalize all the words in the name of your class. Finally,
type a colon and press Enter. For our first example, we will make the simplest
class possible. We will do absolutely nothing. Type pass and press Enter. Pass is a way to type a line that does nothing. This is
necessary, because when defining a class you need at least one line. Now that we
have defined our class, we can use it to create different users. To make a user,
type in the name of the class, followed by parentheses. This looks like you are
calling a method...and you are, in a fashion. We call user 1 an instance of the user
class. You can also call user 1 an object. To attach data to this object, you first
type the name of the object, a dot, the name of the variable, and then give it a
value. Let's give user 1 a first name and a last name. Since first_name and
last_name are attached to an object, we call them fields. They store data
specific to user one. To see that the data is in the user one object, let's
print them. You access the data the same way you assigned it. Type the name of the
object, dot, then the name of the field. Let's also print the last name. Excellent. By the way, you should not capitalize the name of
fields, and if you use more than one word in the field name, separate the words by
underscores. This is a tradition in Python, so to avoid uncomfortable stares from your peers, I would recommend using this
convention. Here the name Dave Bowman is attached to the object user 1 To make
this clear, let's create standalone variables also called first_name and
last_name. These values are not attached to a user object. If we print these
values, we get the name Arthur Clarke but if you print the values attached to user
1, you get Dave Bowman. Even though we use the same variable names the values are
kept separate. With classes, there is no limit to the number of objects you can
make. Let's make a second user called, creatively, user 2. We will give this user
the name Frank Poole. We use the exact same field names as before, but this time
the values are attached to user 2. To see that Python keeps these three names
separate we will print the three names. So classes are used to make objects, and
each object can have different values for the same variable names. You can
attach additional fields to the objects, and they do not have to be strings. Let's
suppose user 1 has an age of 37, an integer. And for user 2, let's assign a
value for his favorite book. We are now in a situation where user 1 and user to
have different fields attached to them. The user 1 has an age. User 2 does not.
User 2 has a favorite book, but user 1 does not. If you print the age for user 1,
you can see the value is there. And if you look at the type for age ,it is
indeed an integer. Now look what happens when we try to print the age for user 2,
which we have not assigned. We get an attribute error so please exercise
caution. If you are not certain an object has a specific field, you may experience
an error. I know what you are thinking. Why did we go through the trouble of
creating a class, when we could have just as easily stored the data in a
dictionary? We will now see the additional features
of classes which allow them to transcend a simple dictionary. By adding methods
using object initialization, including help text, we can turn our simple class
into a data powerhouse. The first feature we will add is an init method. A function
inside a class is called a method. init is short for initialization and some
languages call initialization methods constructors. The name of this method is
init with double underscores before and after the method. This method is called
every time you create a new instance of the class. The first argument to this
method is the word self, which is a reference to the new object that is
being created. You can add additional arguments after self. We'll add full name
and birthday arguments. The first thing we will do is store these values to
fields in the object. We do this by typing self, dot, the field name, and then
assign it a value. We'll store the full name as a field called name, but we will store
the value birthday in a field also called birthday. Be careful here. This
birthday is the value provided when you create a user object, but THIS birthday
is the field that stores the value. To keep this example simple, we will assume
the birthday is in year-month-day format. We will now create a user and use
the init method. Like before, you type in the name of the class and parentheses.
This time, we must provide two values, because the anit method is expecting two
values: first, the name, then the birthday. You can test that these values are
stored in the object by printing them. The data is all there. Let's add another
feature to our class. In the init method, let's break apart the name and extract
the first and last names. We will call the split method on the full name, and
pass in a space. This will chop the name into pieces by cutting whenever it
encounters a space. The pieces will be stored in an array. The first name will
be the first string in the array, and the last name will be the last string in the
array, which we can access using index minus 1. Notice that we attach the first
name to self but didn't do this with the last name.
We'll see what happens as a result. Let's create the user just as before, and then
print the full name. first name last name and birthday. Run. We get an attribute
error when we try to print the last name. This is because we didn't attach last
name to the object using self. What happened is we assigned the value to the
variable last_name ,which only exists until the end of the method. This is a
quick fix. Let's go back and attach last_name to self. Now, if you run the code
everything works as expected. We can further improve this class by adding
some help text. To do this, you type a special string which we call a docstring. This is a string inside triple quotes that you type right after the first line. Now look what happens when you call the help function for this
class. Python displays a useful overview of the user class. It displays the docstring as a summary, and it also shows the arguments that are expected in the
init method. Even if you are writing code only for yourself, it is a good habit to
write a docstring. You may have to use a class years after you wrote it. A few
seconds of typing is worth hours of sanity down the line. Also notice that
the help call displays two additional items: dict and weekref. We will discuss
these in the next video on classes. Let's add another method to the user class
that will return the age of the user in years. Like the init method, the first
argument is self. And to showcase our responsible nature, add a brief docstring. We will compute the age using the user's birthday, so this method does not
require any additional parameters. Since we will be working with states we need
to import the date/time module. Let's first get today's date. We shall assume
it is May 12th, 2001 so that everyone who tests this code will get the same answer.
Next, let's convert the birthday string into a date object. There is a way to do
this in a single line, but for clarity we will use a more direct method. In this
example, we assume the birthday was a string in year-month-day format. From
this string, we can extract the year, the month, and the day as integers. With
these three integers ,we can create a date object for the users birthday. If
you compute the difference between today and the birthday, you get a time delta
object. The time delta object has a field called days. Ignoring leap years, we can
now compute the age in years by dividing by 365. Finally, return the age as an
integer. To test this method, create the user once more. Then call the age method,
and print the result. 30 years old. Notice that you did not type self when calling
the age method. The self keyword is only used when writing a method. By the way, if
you call the help function once more you will see the summary now includes a
description of the age method. Classes: powerful contraptions.
They empower you to group together data (which we call fields) and related
functions (which we call methods) into a kind of factory for creating many
objects (which we call instances). Socratica is somewhat like a class which
creates instances of high quality videos. Who sees our videos is determined by a
mysterious black box called the YouTube Algorithm. The best way to tell the
YouTube Algorithm that our videos are worthy of watches is to engage. Tell
someone on friendface our video exists and that it's in a class by itself.
