CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Classes are a crucial part of object-oriented programming (OOP). In this lesson, we'll explain what classes are, why they're important, and how to use them effectively.

Introduction to Classes

On the flip side, sometimes you'll be working with a derived class (or *subclass*) and realize that you've overwritten a method or attribute defined in that class' base class (also called a *parent* or *superclass*) that you actually need. Have no fear! You can directly access the attributes or methods of a superclass with Python's built-in `super` call.

The syntax looks like this:
```py
class Derived(Base):
  def m(self):
    return super(Derived, self).m()
```
Where `m()` is a method from the base class.

This Looks Like a Job For...

Classes like `Animal` and `Fruit` make it easy to understand the concepts of classes and instances, but you probably won't see many zebras or lemons in real-world programs.

However, classes and objects are often used to model real-world objects. The code in the editor is a more realistic demonstration of the kind of classes and objects you might find in commercial software. Here we have a basic `ShoppingCart` class for creating shopping cart objects for website customers; though basic, it's similar to what you'd see in a real program.

It's Not All Animals and Fruits

Let's go ahead and create an instance of our `Triangle` class.

Instantiate an Object

*Inheritance* is a tricky concept, so let's go through it step by step.

Inheritance is the process by which one class takes on the attributes and methods of another, and it's used to express an *is-a* relationship. For example, a Panda is a bear, so a Panda class could inherit from a Bear class. However, a Toyota is not a Tractor, so it shouldn't inherit from the Tractor class (even if they have a lot of attributes and methods in common). Instead, both Toyota and Tractor could ultimately inherit from the same Vehicle class.

Warning: Here Be Dragons

A basic class consists only of the `class` keyword, the name of the class, and the class from which the new class **inherits** in parentheses. (We'll get to inheritance soon.) For now, our classes will inherit from the `object` class, like so:

```py
class NewClass(object):
  # Class magic here
```

This gives them the powers and abilities of a Python object. By convention, user-defined Python class names start with a capital letter.

Class Syntax

First things first: let's create a class to work with.

Class Basics

Now that you're starting to understand how classes and objects work, it's worth delving a bit more into `__init__()` and `self`. They can be confusing!

As mentioned, you can think of `__init__()` as the method that "boots up" a class' instance object: the `init` bit is short for "initialize."

The first argument `__init__()` gets is used to refer to the instance object, and by convention, that argument is called `self`. If you add additional arguments—for instance, a `name` and `age` for your animal—setting each of those equal to `self.name` and `self.age` in the body of `__init__()` will make it so that when you create an instance object of your `Animal` class, you need to give each instance a name and an age, and those will be associated with the particular instance you create.

More on __init__() and self

Excellent! Let's make one more tweak to our class definition, then go ahead and **instantiate** (create) our first object.

So far, `__init__()` only takes one parameter: `self`. This is a Python convention; there's nothing magic about the word `self`. However, it's overwhelmingly common to use `self` as the first parameter in `__init__()`, so you should do this so that other people will understand your code.

The part that *is* magic is the fact that `self` is the *first* parameter passed to `__init__()`. Python will use the first parameter that `__init__()` receives to refer to the object being created; this is why it's often called `self`, since this parameter gives the object being created its identity.

Let's Not Get Too Selfish

A class can have any number of **member variables**. These are variables that are available to all members of a class.

```py
hippo = Animal("Jake", 12)
cat = Animal("Boots", 3)
print hippo.is_alive
hippo.is_alive = False
print hippo.is_alive
print cat.is_alive
```

1. In the example above, we create two instances of an `Animal`.
2. Then we print out `True`, the default value stored in hippo's `is_alive` member variable.
3. Next, we set that to False and print it out to make sure.
4. Finally, we print out `True`, the value stored in cat's `is_alive` member variable. We only changed the variable in hippo, not in cat.

Let's add another member variable to `Animal`.

They're Multiplying!

Finally, let's create an `Equilateral` class that inherits from our `Triangle` class. (An equilateral triangle is a triangle whose angles are all 60˚, which also means that its three sides are equal in length.)

Inheritance

We'd like our classes to do more than... well, *nothing*, so we'll have to replace our `pass` with something else.

You may have noticed in our example back in the first exercise that we started our class definition off with an odd-looking function: `__init__()`. This function is required for classes, and it's used to **initialize** the objects it creates. `__init__()` always takes at least one argument, `self`, that refers to the object being created. You can think of `__init__()` as the function that "boots up" each object the class creates.

Classier Classes

Another important aspect of Python classes is *scope*. The scope of a variable is the context in which it's visible to the program.

It may surprise you to learn that not all variables are accessible to all parts of a Python program at all times. When dealing with classes, you can have variables that are available everywhere (*global variables*), variables that are only available to members of a certain class (*member variables*), and variables that are only available to particular instances of a class (*instance variables*).

The same goes for functions: some are available everywhere, some are only available to members of a certain class, and still others are only available to particular instance objects.

Class Scope

Sometimes you'll want one class that inherits from another to not only take on the methods and attributes of its parent, but to *override* one or more of them.

```py
class Employee(object):
  def __init__(self, name):
    self.name = name
  def greet(self, other):
    print "Hello, %s" % other.name

class CEO(Employee):
  def greet(self, other):
    print "Get back to work, %s!" % other.name

ceo = CEO("Emily")
emp = Employee("Steve")
emp.greet(ceo)
# Hello, Emily
ceo.greet(emp)
# Get back to work, Steve!
```

Rather than have a separate `greet_underling` method for our CEO, we override (or re-create) the `greet` method on top of the base `Employee.greet` method. This way, we don't need to know what type of Employee we have before we greet another Employee.

Override!

Perfect! Now we're ready to start creating objects.

We can access attributes of our objects using *dot notation*. Here's how it works:

```py
class Square(object):
  def __init__(self):
    self.sides = 4

my_shape = Square()
print my_shape.sides
```

1. First we create a class named `Square` with an attribute `sides`.
2. Outside the class definition, we create a new instance of `Square` named `my_shape` and access that attribute using `my_shape.sides`.

Instantiating Your First Object

Great! Now let's add a member variable and a method to our class.

Class It Up

When a class has its own functions, those functions are called *methods*. You've already seen one such method: `__init__()`. But you can also define your own methods!

A Methodical Approach

In Python, inheritance works like this:

```py
class DerivedClass(BaseClass):
  # code goes here
```

where `DerivedClass` is the new class you're making and `BaseClass` is the class from which that new class inherits.

Inheritance Syntax

Python is an object-oriented programming language, which means it manipulates programming constructs called *objects*. You can think of an object as a single data structure that contains data as well as functions; the functions of an object are called its *methods*. For example, any time you call

```py
len("Eric")
```

Python is checking to see whether the string object you passed it has a length, and if it does, it returns the value associated with that *attribute*. When you call

```py
my_dict.items()
```

Python checks to see if `my_dict` has an `items()` method (which all dictionaries have) and executes that method if it finds it.

But what makes `"Eric"` a string and `my_dict` a dictionary? The fact that they're instances of the `str` and `dict` classes, respectively. A class is just a way of organizing and producing objects with similar attributes and methods.