Learning Object-Oriented Programming with Python

Hey, welcome everybody.

My name is Caleb Curry and this video is going to be about object oriented programming

using Python.

Now, if you've never seen anything from me, here's my strategy.

Teach the concept junk up here and then we go hands on coding through what we talked

about.

This allows you just to have a better understanding of what and why you're going to be typing

before you just start copying code.

So I think it'll make learning a little bit more fun, hopefully.

And also object oriented programming is more of an approach or a paradigm of programming.

So if you learn the principles in this video, you'll be able to apply these to other

programming languages as well, which will help you be overall a better software developer.

So let's not waste any time.

Let's just get started.

So object oriented programming helps us represent things in our code.

What exactly do I mean?

Well, one of the challenges with programming is how do we represent data in our code?

If you're just working with very simple data, this is easy.

You can use primitive data types and collections.

So for example, if you just had to store the value five, hey, it's easy, it's just a number.

If you need to store a string, no problem.

And heck, you can be wild.

You could even store multiple things together in a collection such as this.

And this would be a list in Python.

So pretty simple data, very simple to represent in our code, just using simple variable types.

Now what if you want to represent something a little bit more complex?

There's various ways to do this.

You could use JSON or XML, you could use just numerous collections, or you could use object

oriented programming.

And that's what we're talking about in this video.

And another positive side effect of object oriented programming is it allows us to represent

data as a one-to-one relationship to business problems.

So for example, if you wanted to create software to represent customers, you can make

customers in your code, and I'll show you what I mean here in a second.

So the two big things in object oriented programming are classes and objects.

represents something such as a customer, and then objects are specific examples of that.

So let's go through an example here.

If we want to write software to work with customers, we could create a customer class and

then give it attributes such as the customer name.

Or let's say you had some kind of subscription website or something, you could have the membership

type.

So this is an example of a class.

By creating our own classes, we can group things in logical units, customers, in this

case.

And then we can instantiate very fancy word, this class into what are known as objects.

So now instead of having these general attributes, we give it specific values.

So for example, Caleb and my membership type, oh, you better believe it's going to be

gold premium, you know, and then we could have another object down here such as Brad.

And we could give him like, I don't know, bronze.

So these are both objects.

That is the very first thing you need to understand with object oriented programming.

We basically define a structure in what's known as a class.

And then we use that class to create objects.

So this is an object, and this is another object.

And this is very ideal when you're going to have a common structure across numerous

things.

You know, every single customer is going to have a name and a membership type.

So that's the very first thing.

You create classes, you create the attributes, and then you give them specific values

by creating objects.

All right.

So here we are with a completely blank Python file.

So hopefully you can get to this point.

If not, be sure to just check out some basic Python videos because I don't want to distract

from the point, which is creating classes.

So here's what we're going to do.

We're going to say class and then give us some name, which is usually what we're trying

to describe, such as a customer.

And by convention, I'll use a capital letter.

Now after the class, you can put a colon and then everything after that is indented.

However, many spaces you're using with your code.

So I got four spaces here.

Now within this class is where we define our attributes.

So we're going to define the customer's name and the customer's membership type and everything

else.

But before we get into that, we need to create a special method and we're going to get

into methods soon.

But for now, just copy this code.

It's going to be DEF, which is used to define a method and it has the exact name underscore

underscore init underscore underscore.

and then put parentheses and a colon.

So what in the world did I just tell you to do?

Well, basically any time we create a customer, this function is going to be invoked.

So any of the code that we want to execute every time a customer is created, we put it

in this indentation inside of the init method.

Now this can often be known as a constructor or an initializer, basically the function

invoked when a customer's created.

So inside of the parentheses, we can put anything we need for a customer to exist.

So the very first thing and this is just required for it to work, you put the word self.

Self is the equivalent to this inside of Java or C sharp and sometimes in JavaScript, basically

self refers to whatever customer we're creating.

Then what we do is we put any other attributes for this customer.

So for example, we can have the customer's name and we can also have the customer's

membership type and any other attributes you want to define, you can put here.

And then inside of this method, we basically take these and assign them to that customer.

So we say self dot name is assigned name and self dot membership type is assigned membership

type.

So it seems like there's some redundancy here, but let's just talk about it.

When we say name by itself, we're referring to this parameter in this function, I'm

guest posting seriously, all right, it's been 27 years.

Anytime we have name by itself, we refer to this parameter, anytime we put name qualified

with self, we are referring to whatever customers being created.

So that's a lot of jargon.

So let's just see this in action and just to prove that everything's working, we're going

to say print customer created, all right, it doesn't necessarily prove everything's working,

but we can at least confirm that this method is being invoked.

So outside of the class, here's what we do.

We create a variable, we can just call it C for customer.

And then we say customer with parentheses.

And that is how we create a new customer.

You can see we actually have some required parameters here.

So we need to pass those in so we can say Caleb and gold.

So all of the stuff we were just describing, we just did that.

We created a customer with the name Caleb and the membership type of gold.

And we can print this, we can say C dot name and we can say C dot membership type.

Okay, so let's run this and see what happens.

Well, let's first talk about what happens.

Okay, first thing, this method's going to be hit because we're creating a new customer

here.

It's going to print customer created and then it's going to print the customer's name

and the membership type hit run customer created and the name is Caleb and the membership

type is gold.

All right, so this is pretty much the framework you need to follow for any of the classes

you're going to create.

If you want to create another object, we can do that here.

We could say C to and we create a new customer and this one's going to be Brad and it's

going to be bronze and we can also print C to so we can say C to dot name and C to dot

membership type run this and the very first one is Caleb gold and then Brad bronze.

Now typically you're not going to have print statements inside of the init method.

So I just wanted to show you guys that so we're going to get rid of that.

We usually just like to keep this method as thin as possible.

Its sole purpose is to basically take these arguments we pass in and assign them to the

object which is going to be referred to in this method itself.

So when we create this person, self talks about this object C and when we create this person

down here, self refers to this object C to.

So the first time name is Caleb, the second time name is Brad.

Now obviously if you're going to have thousands and thousands of customers, we probably

aren't just going to have variables to store this information.

So instead you can have lists or any other data structure full of these.

So let's just go through an example with a list.

We could have customers and immediately we could take C and C to, that would work.

But then we still have these variables and it's still not the most scalable solution.

So I'm going to be teaching you how to create customers in line.

So here's how we do that.

We would basically take this code here, cut it, paste it right here.

Take this code here, cut it, and paste it right here.

Now all of this code we can just get rid of it.

And I'm going to make a new line just to make this a little bit more readable.

All right.

So now we have a list of customers.

So we can grab that first customer's name by saying customers index zero, which will

grab this one here, then we say dot name, and we get Caleb.

You can do the same thing with membership type or we can increment this one to grab the

next customer.

Brad.

All right.

So this is your basic class and how to create a few objects.

This is going to be the foundation for the rest of the object oriented programming stuff.

So make sure you have at least a pretty good understanding of what's going on here.

Now again, this is just something special you got to do.

This is an example of a method, basically a function defined within a class, and that's

going to automatically be invoked.

But we can create our own methods that we can invoke ourselves.

And we're going to get into that now.

Methods are one of the most useful things to give our classes and objects a little bit

more functionality.

So now we're moving on to the section on methods.

So if the attributes provide the data and the values that we need to store about a customer,

then the methods provide the functionality what customers can do or what we can do with customers.

Now the very first method you were exposed to was this underscore underscore init.

And this is just one of those methods where you just have to do it.

It's part of Python's object oriented programming and pretty much any time you see double

underscores.

That is a method that already exists that we can actually override and create our own functionality.

So we created our own version of this init method that did things.

What did it do?

Well, it actually assigned a value to the name and the membership.

And this method, the init method.

Well, often here, it known as the initializer or what you might probably hear more often

because it correlates better with other programming languages is the constructor.

So we constructor.

It's just a method, a section of code that is executed whenever we create a new customer.

Inside a Python, the way we create a new customer is in our code.

We just say customer and have parentheses.

A lot of other programming languages, this will actually be prefixed with the new keyword.

Although that is not how we do it inside a Python.

But if you're coming from like Java or C sharp, you'll probably see that new keyword a lot.

So the other thing is when we define this init method, we put a couple of things in here.

The very first one was self.

And that is going to be put inside of any method we create to work with individual customers.

So we put self and then anything extra we want to add about customers.

So we had the name and the membership type.

Yeah, I think this has actually membership underscore type.

All right, so this is what it looks like now.

Now these here, when we define these variables inside of some method we're creating, these are known as parameters.

So hopefully you have some experience with just creating functions and this is not all brand new to you.

The parameters are the variables attached to the method we're creating.

Now what about arguments?

Arguments is another word that's often thrown around in exchange for parameters, but they're technically different.

So when we create a customer, we assign values to these parameters.

And those are passed in here.

So we had the value Caleb and let's just say the value gold.

So these here are known as arguments.

So it's basically which side of the process are you want?

If you're in the definition side where we define the outline for the method, they're known as parameters.

If we're actually applying specific values to these variables, they're known as arguments.

So parameters, definition, arguments in vocation.

We're not wanting to talk about overriding methods here because I'm tired of talking about stuff that already exists.

I want to create some of our own stuff.

So what if we wanted to create a method to actually do something with a customer?

Let's say we wanted to create a method to upgrade the members, membership status.

So it might look like this, upgrade membership.

First parameter in here is always going to be that self keyword whenever we're talking about methods to work with the customers.

And then anything else, maybe the new membership.

So we could say new membership.

So we could define all the code what this does inside of our code.

And the way we would invoke this is we would take some customer, in this case we have this C variable that's

referring to a customer and we would say dot, upgrade membership.

Now as for the arguments, the self is always in place that you never have to pass anything in for that.

So skip it.

The new membership, we could put something like bronze.

And then as for the actual functionality, what does this method do?

I mean, that's ultimately up to you.

But as an example, it could basically figure out what to charge the person because I'm downgrading my membership.

So maybe I need to get a refund.

And then it could basically invoke our billing system to do that and return whether worked or not.

So that's another thing with methods they can return a value.

So for example, the upgrade membership might return the value negative one.

If it didn't work or it might return zero, if it did work.

So zero tends to be like it worked fine.

Negative one is often it broke or any other number could mean something.

But if you have had experience with like C++ or C, you'll often see something like return zero.

This basically means it worked.

But anyways, the point here is not necessarily what this method does, but

more so that you can create methods to work with individual customers.

The way you do it is you define it inside of the class and you put this self word here.

The actual code for this method probably looks something like this.

So we're going to have a colon.

And then we would have maybe some API call and assuming that was successful,

we could say self dot membership type is now assigned the value new membership.

Like so.

All right, so that was just a bunch of junk to say that hey,

we can create our own functions and put them inside of classes to call them methods.

So let's get some hands on experience with this now.

So here we have the most basic customer class and we have one method in here,

the init method.

And this is where we define the attributes we want attached to each of our customers.

Now inside a Python, it is a little dynamic in that we can add attributes after the fact.

So as an example, I can say customers index one to grab this customer here.

And we can say something like verified and we could set this to some value like false.

And this is something we can use later on in print and there you go.

So Python is more dynamic than a language like C sharp or Java,

because you can add attributes on the fly.

It's more like JavaScript in that nature.

However, it is best to put any data that you expect customers to have inside of this init method.

So it is considered best practice to have that there.

So let's go ahead and put this back to how it was.

We will get rid of this verified line because we're not going to need that.

And we're just going to print the name.

So beyond this init method, we can create other methods and just do that below here.

So for example, the one we talked about was, I forget the exact side.

I think it was upgrade membership or let's just do update memberships because, you know,

maybe we could use it to downgrade the membership as well and we're going to have self in there.

And then we can have the new membership that we want to change it to.

So the most basic thing we're going to do is just say self dot membership type and change it to the new membership.

And we can just check to see if this works.

Let's go ahead and print the membership and invoke this by saying customers index one dot update membership and pass in actually will pass in gold.

It's going to put bronze there, but it's already bronze.

So we'll stick to upgrading this to gold.

And then after the fact what we're going to do is we're going to print the membership type and just confirm that it was changed.

So let's run this.

All right, we have an issue.

We have to print the membership type.

Sorry.

So run this.

We start with bronze.

This method gets invoked on the customer.

And then the membership is gold.

Now, this method as is is kind of pointless because you can actually change attributes directly.

So instead of doing update membership, you could just say membership type and assign it the value gold.

This works just the same way and we don't even need this method anymore.

You can just get rid of it.

However, if you need to do custom functionality, which is a little hard to see in our very simple application, but here are some examples of custom functionality, you could invoke an API, you could update a database, you could charge the customer, you can calculate costs, you can conquer the world and pretty much anything else.

So anytime you need some kind of functionality like this, the appropriate place to do that is within a method.

So the easiest way to simulate something like this is to just print.

And we'll just say calculating costs just to simulate some math there and charging the customer.

So we'll leave that as that there.

And now you can see that functionality because if we invoke this method, update membership, pass in a value, you can see that it actually shows up.

Down here in the console.

Now I wanted to take a second just to talk about the self here.

Anytime you want these methods to appear on a customer, then you put that self keyword there.

So you could create a method such as read customer and leave off the self.

Well, this is not going to be invocable on any individual customer.

So let me just write your print and we can just imagine reading customer from DB.

Well, if we try to invoke this, we say something like customers would just grab that first customer in that list.

And then we say read customer run this.

It says take zero positional arguments, but one was given.

What in the world does that mean?

Well, when we invoke a method like so on an object, a customer object, the instance itself is implicitly passed.

So that's what gets assigned to this self variable here.

So when we don't have that there, it's basically saying, yo, you're passing something,

but there's nothing to apply it to.

It's not working.

So that's what this type error here means.

So what would you do with this method instead?

Well, this is something that would be used if you want a method to describe

customers in general, but not any specific customer.

So for example, if we're just reading a customer from the database,

that's not tied to Caleb, but that has nothing to do with Caleb.

So here's what we would do instead.

We would just invoke it on the customer class like so and run it now.

Here it says reading customer from DB.

This method is often known as static methods.

So basically methods that are not attached to any individual object,

but instead are invoked on the class itself.

So here's an example from some other code that I wrote.

Basically, it's this method parse camera.

It does not have self in the parameter list.

And this is the code that I used to basically read some data from a text file and

parse it into information and it ultimately returned a new camera object.

So although we're not going into a complex example where we implement something like this,

I was hoping that just by showing you an example without self,

you would have a better understanding of self.

And as a result, have a better understanding of your own true self.

But enough of this talk about self, let's get back to methods.

The only other thing I wanted to talk about was first, let's just get rid of this read

customer. We're not going to need that.

There are a couple of other methods we can override that are definitely useful.

So the very first one you should know about is STR.

And this is also going to take self and this is going to be invoked anytime.

We try to convert a customer to a string.

So we created this method and now let's try to invoke it.

How do we invoke it?

Well, instead of printing customers to our membership type,

let's just print that individual customer.

And now what happens when we run this, it says returned non string.

So anytime we override this string method, we actually need to return a string.

So we can say return and in here, we could say self dot name plus a space plus self dot membership

type. Running this now, we can look through our code here.

Any time this is executed, it says converting to string, which is basically hitting this line here.

And then it prints the person's name and their membership type at once,

which is very, very convenient.

If, for example, you did not have this method here,

let's just comment this out for a sec.

When we printed an entire customer, so we printed this customer right here,

what it would do is it would just give us a memory address and say the type,

which is useful. I'm not going to say it's not useful.

However, oftentimes we want to get the actual data and not just the location of the data.

So that is why we would override the string method.

And we can also get rid of this print here.

I was just showing you guys that for simplicity.

So now we can very easily see our customers just by printing them here.

So what a useful line of code might be would be to print all of our customers.

So let's go up here into our class and we're going to define a new method.

We'll just say print all customers and this is not going to have self.

However, I will take a list of customers and we can say for customer in customers,

print customer.

So you can see oftentimes we'll put methods in here that are somewhat related to customers

just for organization's sake and we don't need to put that self in the parameter list.

So now inside of our code, we can create a list of customers.

So what we'll do is just say customer the class with capital C there,

dot print all customers and we'll pass in our customers list.

We defined right here like so and running this,

we get all of the information for all of our customers.

Another useful method is the equals method.

So we could say death underscore underscore EQ underscore underscore self.

And this is also going to have another parameter.

We're just going to call it other, which is going to refer to what we're comparing

our customer to.

So this will see if two customers are equal.

So what we can do is we can say if self dot name is equal to other dot name and self dot membership

type is equal to other dot membership type.

Then what we're going to do is we're going to return true, otherwise we're going to return false.

So pretty much if you're comparing two customers and they have the same name and they have the

same membership type, then you can assume they're the same customer.

Now that's a pretty weak comparison, but you can do whatever kind of comparison in here you want.

You know, maybe you compare addresses, maybe you compare social security cards,

maybe you compare DNA sequences, whatever you got to do,

you can pretty much compare whatever you want here.

Just remember that any of these attributes are comparing,

you're probably going to need to define them up in the init method.

So let's just test this out a couple of times.

We have two customers down here and what we can do is we can print to see if they are equal.

So we'll say print.

Customers index zero is equal to customers index one.

Running this and we get false, which is to be expected because they're two totally different

people, but if we change their name, let's go with Caleb and go with again, we run this

now we get true. If we did not override the equals method, then by default it compares by memory

location. So we'll just comment this out for a second.

And even though logically it seems like these are the same customers,

we run this and we get false. And the reason that is is you can actually see if you pass these

to ID and just put a comma here, run for got a parent sees there, run this and you can see

that these are two different objects in memory. So by default, it looks at these IDs,

sees that they're different and says yuck nope, these are not the same people.

So we're going to say false for the equals. However, we can override that behavior with this

equals method. And running this, we still have different IDs, but if we were to compare the data

like so getting rid of this ID here, we run this and we get true.

And the last method I want to discuss with you right now is the hash method. I've done stuff

on hash. If you need to know the juicy details. However, for now, I'd recommend just saying underscore

underscore hash is none. This isn't going to really ruin any functionality or break anything.

The only thing is that you're not going to be able to use your customers inside of hashable

data structures. So I mean, you can use them in the value side of a dictionary, but not trying to

get in the weeds here. But let me just show you real quick. If we were to create a set

and try to pass in customers zero, this is going to give us an error on hashable type customer.

But if you need to understand hashing and all that, do some extra research. One other thing is you

can actually print this list altogether at once. So you could say print customers. And when we do

this, we don't get the pretty output like we would expect in our method print all customers.

So one way we can fix this is to override the underscore underscore R EPR for representation

probably. And we can just assign this to the same thing as the stir method. So we'll just say

underscore underscore stir. And I think that should fix the problem. Now you get all of the data

in a nice list. And you can just change the data right here. So there you go. All right, I think

that's all the overriding methods I'm going to be talking about right now. So let me just zoom

out for you guys. Make sure you can get a good overall picture of the code. We'll start at the top

and just scroll down to the bottom real quick. There you go. All right. So now we're going to be

talking about some object oriented programming principles. These are the three pillars of object

oriented programming. If you haven't heard of them yet, you probably will a bunch in the future.

And they are encapsulation inheritance and polymorphism. Now for being honest, each one of these

needs a dedicated video to go into the depths. So we're just going to scratch the surface.

But the main thing you need to understand here is that these are the Y of object oriented

programming. Why would you want to use object oriented programming? Well, if you need to do

any of these three things, you can do that with OOP. It's like the value proposition. This is what

you can get using OOP. These things can also help you in your object oriented programming journey

by enabling you to do certain things. So it basically allows us to have more scalable code

and so forth. But not all of the time because some of these are even controversial,

such as inheritance. If you do it wrong, you can actually make your code more complex

and not really help anybody. And the approach to this really depends on the language because I

think different languages have different approaches and ways of thinking. And for Python,

it's a very open free kind of language. The way you feel, you know, the vibe of Python is very

open and free. As opposed to Java, it's very strict. And what you can and can do is very thorough.

So when we are creating this stuff in Python, our classes might end up being very thin. And if

you're coming from, say, a Java background, you might be like, what? And it does take some time to

kind of adjust to the approach. But basically in Python, our approach is if you don't need it,

don't do it. And also the person using your classes, you can trust them to be well educated

and they're going to use your classes in an appropriate way. Whereas the approach for other languages

might be to restrict anybody from doing anything wrong. But as a result, the classes end up being

huge, huge files with tons of code. So I don't think there is one yes or no or right or wrong way

of doing this stuff. And I don't want to start any debates in the comments. But I do want to try to

keep our classes very thin and just do exactly what we need. No extra. All right, with that

prefix in mind, let's just go through each one of these very briefly in encapsulation. The whole

idea behind encapsulation is that you can hide the inner details of a class or of certain data.

And you only need to share or expose what is needed for the user of the class to use this class.

So we might have the backing field, as you might hear it called, store some data. And instead of

just people accessing this data directly, they access it through getters and setters,

which are basically methods that will give us access to the data. So when we have an attribute

such as name, well, we don't necessarily have to have that same exact thing on the back end.

There is a separation here where you only set the data through a method and you only get the

data through a method. So that is the most basic form of encapsulation, the most popular thing

inside of languages. You often have tons of getter methods, tons of setter methods inside of Python.

We don't really create those unless we need to. And there's a specific way we need to do that

with what's known as a property. And the good thing about a property is that you can

add in a property when it is needed and none of the invoking code changes. So you would still

access that data like so. But now we added some extra functionality in a setter method

and a getter method using a property. So we're going to touch on that briefly.

And inheritance allows us to automatically have certain attributes for objects because they're

defined in a base class. So we've been talking about the example of a customer.

And this is for some subscription website. Let's say it's a subscription website to get courses.

Well, we could also have a teacher. And these are going to have a lot in common. So we could

create a base class with all of the commonalities. And let's say this could be called user.

Then when we define a customer, it's automatically going to have anything defined inside of this

user class. So that is the basics of inheritance. Polymorphism is kind of just an extra step of

that where we can treat customers and teachers as the same thing if we approach them as users.

So we could say, hey, users, we need you to do this or we need to update this data.

And as a result, since a customer is a user, that's okay. And a teacher is a user, that's okay.

But the customers can do something specific and the teachers can do something specific.

You know, there might be a time of the month where we do the finances for the customers.

We charge them money. And for the teachers, we pay them money. But we can address all of them

together as a set of users. So yeah, when you're just talking about the theory here without

some examples, it can be a little bit confusing. But I just wanted to just get a really quick

overview of these three pieces. And now we're going to go hands on just to get some really

simple examples of these. So my goal now is to give you what you need for encapsulation, inheritance,

and polymorphism. Probably can't do it justice in just a few minutes, but we're going to give you

the essentials here. So this is our class so far. We have a customer class. Pretty simple.

And then we have a list of two customers and we print the customers here. So the very first thing

I want to do is show you guys how to create a property. Now, a property is basically just like a normal

attribute, but instead of it being just a variable, such as name here or membership type,

it actually has an extra layer. And this layer allows us to basically abstract away the variable

itself using methods. So it allows us to have additional functionality. It's pretty cool if you

need it. But in my opinion, don't use it if you don't need it. And that's just the approach

of Python. That's what I've seen other people do. And that's what I have learned is best practice.

However, if you're coming from, let's say C sharp and C sharp, you just make properties

from the get go. So if you want to make every single one of your attributes, a property,

then be my guess, but I don't think you're going to be adding a whole lot of value. And we want

to make these classes as much potent value as possible if that makes any sense at all. So let's

just get into it enough of my rambling. So if we wanted to make name a property, what we're going to do

is we're going to create two methods. We're going to create one that's called name,

so we'll say name like so. As always, we're going to put self in there. And what this is going to do

is it's just going to return self dot underscore name. When you see something prefix with a single

underscore, this is basically a way to say, Hey, this is private. Don't touch this if you're not

within the class. So outside of the class, you should not be typing anything like customer index

zero dot underscore all these underscore things. Don't touch them. You can see your underscore name

right there. Leave that alone. So we're going to get rid of that and go back up here and leave

this as so. And one extra step we're going to put at property. This is an example of a decorator.

It gives extra functionality. And this is how we say that this is a property. So when we try to

get the name, this is going to be invoked. The underscore name is basically the backing field. It's

the data behind the scenes. And anytime we try to set this data, we need, we're actually going to

invoke another method. And the way you define that is you say at and then you put whatever the attribute

is. So name dot setter. And then we say def name self. And then the data that we're going to assign

it. So we'll just call that name here. And then inside of here, we're just going to assign

a value to self underscore name. And we're going to assign it the parameter value here. So if we

save this and run, we get the same exact output, which is what we want none of the invoking

code should have to change to use this. However, we can know that there's an extra step to get

and set this data where we can actually add functionality in here if we wanted. So we'll just say print

getting name and print setting name, running it now. You can see some extra stuff is going on behind

the scenes. These methods are being invoked. Anytime we get or set the value of name. But note

that we don't actually have to invoke it like a function, we can just get it like normal. So we

can say customers, let's say we want that first customer dot name around this we get Caleb,

we did not have to say name with parentheses or get name or anything like that. We just used it

like normal. And that's what we want. So that is how to create a property. You can do any kind of

functionality you want in here. You may also see what's known as a delete or which will be used

if you use the Dell operator. So that'll look like this name dot the leader def name self. And then

we just say del self dot underscore name. So we're not going to use that a whole lot. But just in

case you want to know about that now what that means is we can go down here and we could say

Dell customers index zero dot name and running this it's going to delete it and it's no longer

available. If we got rid of that line it works fine. So let's go in here and just delete that extra

printing because it's not really doing anything. Just know that that is where the functionality would

go. Now let's take a moment to talk about inheritance. And I'm going to keep this really simple. But

basically we can create another class that customer derives from such as user. And we'll just give

this user a method. So for example, we'll say def log. So if we wanted to log some data or something

and inside of here, don't forget self. We always want to put self there. Inside of here we could just say

print self. So as is if we go down to the very bottom of our code and we try to invoke that

so let's just grab our first customer and we say log. We run this and it has an issue. But if we

inherited from that base class, then this would be available to us. So here's how you do that.

Let's go back up to where we define customer and inside of parentheses you can put user.

And now anything defined inside of a user is also going to be defined in a customer.

So when we run this now, you can see that this log here works and actually prints all of that

user's data. So that's pretty simple when it comes to inheritance. Nothing too crazy. The next step

of this is polymorphism. So if we actually had a couple of classes that inherited from user,

let's say we went in here and we created a teacher or something. And this also inherits from user.

And we'll give teacher a new log method. And what this is going to do, it's going to do pretty

much the same thing but it's going to say I'm a teacher. Instead of just printing all the details

about them, it's just going to do this blanket statement for all teachers. So now you can really see

polymorphism if you have a list of teachers and customers. You can treat them all as users. So let's

scroll down to the bottom of our code here. And we have two customers in here. Let's go ahead and

add a teacher. And just to make sure that we can invoke the log method on each one of these, we'll

try it on the second customer. That works. And we can also try it on the teacher and you see that

works. So what we can do now is we can basically take this concept where we take the log method

and we're going to do that for all of these people. So instead of customers here, we're going

to have users and we say for user and users and we say user dot log. So we invoke the log method

on every single item in this list. And we run it and we don't get any issues. So what exactly

is the magical part here? Well, we treat them all as users and we invoke dot log because that is

part of the user definition. But if a derived class has an override, such as in this case here,

we overrid the log method and gave a new implementation, then it's going to do the teacher

version of that. If we did the same thing for customer, it would do the same thing. So let's say we

take this, paste it in here. We can say, I'm a customer. And running this, we get I'm a customer,

I'm a customer and I'm a teacher. Nowhere does it just do this general print. This would just be

for the users and you don't see that anywhere. So that is the basics of polymorphism,

basically the ability to create code that works with general users, but is still fully functional

when you're past something more specific, such as a teacher or a customer. Now, I know that's a lot

and probably these principles will take a lot more practice to truly grasp and see where to

apply these. We've touched all the basics of object-oriented programming and now some more advanced

stuff might come a little bit easier. If you're looking for other stuffs of research, you can look

into object relational mappers. This is basically going to take database data and correlate it to

a bunch of objects in your code. So instead of just working with hard-coded stuff in here,

you could be working with actual teachers and customers in a database. You could also look into

some different object-oriented design patterns. These get pretty advanced and basically

teach you how to design programs using these OOP principles. And there's probably like six

petroleum other things you can study. So just look up some more advanced object-oriented programming

things and start learning. Thank you guys for watching. If you've enjoyed this content,

please be sure to subscribe to this channel. Also be sure to check out my channel,

kaleb curry. We got stuff on Python, JavaScript, C++, Java, C sharp database design,

all kinds of different things and would love to have you guys there. So be sure to check

it out and I'll see you in the next one on the next one. Next one to the next one to the next one.