Classes and instances in language and memory

Consider one way people use nouns in natural language.
1. There's a giraffe in the other room.
  Its legs are really long.
2. I formed a new club.
  Its members are really diverse.
  ??Its legs are really long.
3. I bought a new chair for the dining room.
  Its legs are detachable.
4. There's an escaped potto out there in the woods somewhere.
  You might hear its calls during the night.
5. Pottos have vestigial index fingers.
Nouns like giraffe and club represent categories or classes.
When we hear a noun like this preceded by a (in certain circumstances), we are expected to instantiate the class, to create a new instance of the class in memory.
Instances may have things associated with them: attributes. The legs of a giraffe are one of its attributes.
Even without being told, we know some of the attributes of an instance based on our knowledge of its class; for example, we know that giraffes and chairs have legs, that clubs have members, and that clubs don't normally have legs. That is, our representations of the instances of a class inherit attributes from our "definition" of their class.
When two classes share the same attributes, they do not necessarily behave the same. Our "definitions" of giraffes and chairs tell us that the legs of a giraffe and the legs of a chair are very different.
We readily create new classes and update the ones we already have.

Classes: what we want

A way to define a class by specifying what its attributes are. Attributes could include properties, as well as functions, thing that the instances of the class know how to do. Some attributes are invariant, the same for all instances of the class, whereas others may vary.
A Diskoid is a thing that has a width of 10, a hopping distance of 10, and a longevity of 20. A Diskoid also has an age, a strength, and a location that vary from one to the other. Diskoids know how to move and to determine if they're out of bounds.
A way to instantiate a class, creating a new instance of it that inherits the attributes of the class but can also have its own values for the attributes.
When a Diskoid is instantiated, it gets an initial age of 0, an initial strength of 100, and a random location in the world. It also gets a pointer to the world that it belongs to.

Classes

A class is a collection of functions and attributes that define a particular kind of abstract "thing", called an instance object. (The class itself is also an object: a class object.)
You create an instance object by instantiating the class. To instantiate a class, you call a special function called a constructor. In Python, the constructor is the class name with zero or more arguments.
You're already familiar with some Python classes, what we've been calling "types".
- For example, list is a class.
- As with other classes, the constructor for list is list(), so we can create a new list (an instance object) by calling it.
```
>>> newlist = list()
>>> newlist
[]
>>> len(newlist)
0
>>> isinstance(newlist, list)
True
```
- The list constructor can also take an argument. For example, we can pass it a tuple, and it returns a list with the same elements.
```
>>> list((1, 2, 3))
[1, 2, 3]
```
The functions associated with a class are called methods.
- You're already familiar with methods associated with classes such as list, str, and dict.
- Recall that to call a method, you put a dot after an expression that evaluates to an object of the particular class and before the method name.
```
>>> newlist.append('a')
>>> newlist
['a']
>>> 'a simple string'.split()
['a', 'simple', 'string']
```
- Note that help(<class>) gives us all of the methods associated with a class, once it's been defined.

Class definitions

To define a class we use the keyword class, followed by any superclasses of the class in parentheses. If it has no superclasses, use no arguments at all.
The code that specifies the various properties of the class is in an indented block.
```
class classname(superclass):
    statement
    statement
    ...
```
To document a class that you define, put a docstring directly below the header of the class definition.
The class definition assigns the name of the class to the class object and creates a constructor for the class, that is, a function that instantiates the class (returns an instance object for the class).
```
>>> class Diskoid:
...      '''A thing that moves around and eats Plasmoids.'''

>>> Diskoid
<class __main__.Diskoid at 0xe69bd0>
>>> diskoid1 = Diskoid()
>>> isinstance(diskoid1, Diskoid)
True
```

Attributes

Objects define their own namespaces.

Objects can have data attributes (or just "attributes" for short), variables that take on particular values within the namespaces of the objects.

A simple example:

>>> diskoid1.loc = (10, 10)
>>> diskoid2 = Diskoid()
>>> diskoid2.loc = (8, 8)
>>> diskoid1.loc
(10, 10)
>>> diskoid2.loc
(8, 8)
>>> diskoid3 = Diskoid()
>>> diskoid3.loc
...
AttributeError: Diskoid instance has no attribute 'loc'

A more complicated example:

>>> class World:
...      '''A space in which various things live.'''
...
>>> WORLD = World()
>>> WORLD.things = {}
>>> WORLD.things['diskoids'] = []
>>> WORLD.things['diskoids'].append(Diskoid())
>>> WORLD.things['diskoids'][0].loc = (0, 0)
>>> WORLD.things['diskoids'].append(Diskoid())
>>> WORLD.things['diskoids'][1].loc = (5, 5)
>>> for diskoid in WORLD.things['diskoids']:
...     print(diskoid.loc)
	
(0, 0)
(5, 5)

Some attributes are built-in. For example, all objects have an attribute called __class__, which is their class object.
We can include a class attribute in a class definition when we want all instances of the class to have that attribute.
- An example:
```
>>> class Diskoid:
...     '''A thing that moves around and eats Plasmoids.'''
...     color = 'yellow'
... 
>>> diskoid1, diskoid2 = Diskoid(), Diskoid()
>>> diskoid1.color
'yellow'
>>> Diskoid.color
'yellow'
```
- An illustration of what's happening:
- Note how this compares with the situation for instance attributes.

You can find out what attributes an object has with the builtin function dir.

>>> diskoid1 = Diskoid()
>>> diskoid1.loc = (1, 3)
>>> dir(diskoid1)
['__class__', '__delattr__', '__dict__', '__doc__', ..., 'color', 'loc']

Practice: add a class attribute food to the Diskoid class, bound to the class of the diskoids' food. You will also need to define the class for the food.

Calling methods

Before you learn how to define methods, you need to know about the two different kinds of syntax for calling methods.
1. One of these you already know. This is the usual way to call a method.
```
instance.method(arguments)
```
2. The other makes use of the fact that the method is actually an attribute of the class.
```
class.method(instance, arguments...)
```

Here are some examples with built-in classes:

>>> [4, 3, 2, 1, 2, 3, 4].count(4)
2
>>> list.count([4, 3, 2, 1, 2, 3, 4], 4)
2
>>> data = "3,280,150,29"
>>> data.split(',')
['3', '280', '150', '29']
>>> str.split(data, ',')
['3', '280', '150', '29']

The two ways of calling methods are completely equivalent.
Notice that with syntax version 2, there is always one more argument than with version 1.
Notice also that in Python, methods, like functions, are objects in their own right:
```
>>> data.split
<built-in method split of str object at 0xe15b38>
```
Practice: try out both kinds of syntax for the list method extend, the dict method items, and the str method replace.

Defining methods

Methods are associated with instances, and they need to refer to or to modify the instances that they belong to. For example, a method that moves a diskoid needs to be able to change the diskoid's location.
- So we have to be able to refer to the instance within the body of a method definition.
- But method definitions appear in class definitions, which don't know yet what objects will instantiate the class.
- So the instance has to be a parameter that gets bound when the method is called.
- So method definitions correspond to syntax version 2 on the last page; the instance is the first parameter.

Here's a method that assigns an instance attribute to instances of the Diskoid class.

import random
class Diskoid:
    def set_loc(self, width, height):
        '''Assign a random location to Diskoid instance.'''
        self.loc = [random.randint(0, width),
                    random.randint(0, height)]

The first parameter self gets bound to an instance of Diskoid when this method is called. (Because this is a parameter, it can actually have any name, but it is conventional in Python to call it self.)
Since it's a method, there are two ways to call it.
- One of these looks more like the definition because it takes three arguments.
```
>>> diskoid1 = Diskoid()
>>> Diskoid.set_loc(diskoid1, 10, 10)
>>> diskoid1.loc
[6, 3]
```
- The other, the usual way to call a method, has the instance object before the dot, so does not have it as an argument.
```
>>> diskoid2 = Diskoid()
>>> diskoid2.set_loc(10, 10)
>>> diskoid2.loc
[1, 9]
```
With the second alternative, there is always one fewer argument than the number of parameters in the method definition. When you make an error with the number of arguments, it's the first alternative that gets referred to in the error message.
```
>>> diskoid1.set_loc(10)

Traceback (most recent call last):
  File "", line 1, in 
    diskoid1.set_loc(10)
TypeError: set_loc() takes exactly 3 arguments (2 given)
```
Practice
- Define a Diskoid method edible that takes a thing and returns True if the thing belongs to the class of the diskoid's food.
- Define a Diskoid method init that initializes the diskoid's age at 0 and strength at 10.
- Define a Diskoid method strengthen that takes a positive or negative strength increment and adds it to the diskoid's strength.
- Define a World method add_thing that takes a thing and adds it to the things dictionary in the world (this dictionary must already have been created when the method is called).

Controlling instantiation

When a class is instantiated, a special method called __init__ is called.
You can affect what happens at instantiation by including a definition of __init__ in your class definition. This overrides the built-in __init__ method. __init__ should not return anything.

For example, when we create a world, we'd like it to initialize its things dictionary so we don't have to bother to do it.

>>> class World:
...     def __init__(self):
...             '''Initialize the things dict.'''
...             self.things = {}
... 
>>> WORLD = World()
>>> WORLD.things
{}

Practice: add an __init__ method to the Diskoid class that initializes all diskoids' ages at 0 and strengths at 100.

If you give the __init__ method parameters in addition to self, these become arguments to the constructor for the class.

>>> class World:
...     def __init__(self, dims):
...             """Initialize the things dict and assign the world's dimensions."""
...             self.things = {}
...             self.width = dims[0]
...             self.height = dims[1]
... 
>>> WORLD = World((10, 10))
>>> WORLD.width
10
>>> WORLD2 = World()
Traceback (most recent call last):
  File "", line 1, in 
TypeError: __init__() takes exactly 2 arguments (1 given)

As with any function, we can give the __init__ method optional arguments.

>>> class World:
...     def __init__(self, dims=(10, 10), things={}):
...             """Initialize the things dict and assign the world's dimensions."""
...             self.things = things
...             self.width, self.height = dims[0], dims[1]
... 
>>> WORLD = World()
>>> WORLD.height
10

Practice: edit the Diskoid __init__ method so that it optionally assigns a world to the diskoid and then sets the diskoid's location in case there is a world.