Make your own Car and learn how to driveCar()!

Classes

There is a special function named `__init__()` that gets called whenever we create a new instance of a class. It exists by default, even though we don't see it. However, we can define our own `__init__()` function inside the class, overwriting the default version. We might want to do this in order to provide more input variables, just like we would with any other function.

The first argument passed to `__init__()` must always be the keyword `self` - this is how the object keeps track of itself internally - but we can pass additional variables after that.

In order to assign a variable to the class (creating a member variable), we use *dot notation*. For instance, if we passed `newVariable` into our class, inside the `__init__()` function we would say:

```py
self.new_variable = new_variable
```

Initializing a class

Each class object we create has its own set of member variables. Since we've created an object `my_car` that is an instance of the `Car` class, `my_car` should already have a member variable named `condition`. This attribute gets assigned a value as soon as `my_car` is created.

Calling class member variables

Chances are, you won't be designing Car classes in the real world anytime soon. Usually, classes are most useful for holding and accessing abstract collections of data.

One useful class method to override is the built-in `__repr__()` method, which is short for *representation*; by providing a return value in this method, we can tell Python how to represent an object of our class (for instance, when using a `print` statement).

Building useful classes

Classes can have *member variables* that store information about each class object. We call them member variables since they are information that belongs to the class object.

Creating member variables and assigning them initial values is as easy as creating any other variable:

```py
class ClassName(object):
  memberVariable = "initialValue"
```

Class member variables

Since our ElectricCar is a more specialized type of Car, we can give the ElectricCar its own `drive_car()` method that has different functionality than the original Car class's.

Overriding methods

Calling class member variables works the same whether those values are created within the class (like our car's `condition`) or values are passed into the new object at initialization. We use dot notation to access the member variables of classes since those variables belong to the object.

For instance, if we had created a member variable named `new_variable`, a new instance of the class named `new_object` could access this variable by saying:

```py
new_object.new_variable
```

Referring to member variables

Classes can be very useful for storing complicated objects with their own methods and variables. Defining a class is much like defining a function, but we use the `class` keyword instead. We also use the word `object` in parentheses because we want our classes to *inherit* the `object` class. This means that our class has all the properties of an `object`, which is the simplest, most basic class. Later we'll see that classes can inherit other, more complicated classes. An empty class would look like this:

```py
class ClassName(object):
  # class statements go here
```

Class basics

We can use classes to create new objects, which we say are **instances** of those classes.

Creating a new instance of a class is as easy as saying:

```py
newObject = ClassName()
```

Create an instance of a class

We can modify variables that belong to a class the same way that we initialize those member variables. This can be useful when we want to change the value a variable takes on based on something that happens inside of a class method.

Modifying member variables

Besides member variables, classes can also have their own methods. For example:

```py
class Square(object):
  def __init__(self, side):
    self.side = side

  def perimeter(self):
    return self.side * 4
```

The `perimeter()` class method is identical to defining any other function, except that it is written inside of the `Square` class definition.

Just like when we defined `__init__()`, you need to provide `self` as the first argument of any class method.

Creating class methods

One of the benefits of classes is that we can create more complicated classes that inherit variables or methods from their **parent classes**. This saves us time and helps us build more complicated objects, since these **child classes** can also include additional variables or methods.

We define a "child" class that inherits all of the variables and functions from its "parent" class like so:

```py
class ChildClass(ParentClass):
  # new variables and functions go here
```

Normally we use `object` as the parent class because it is the most basic type of class, but by specifying a different class, we can inherit more complicated functionality.