How is code organized? A popular paradigm is
Object Oriented Programming. This approach involves creating small, specialized groups of code that pertain to a certain domain. An easy way to think of it is that the code is parallel to real life objects. Here is an example:
Let’s say we want to represent different kinds of animals in code.
Animals may share many of the same characteristics (such as having a name, eating, and sleeping). Different categories have different special characteristics that are not shared between all animals (for example, dogs and cats have legs, while snakes do not).
In object-oriented programming, we represent animals by using
classes. You can think of a class as a generic representation of something, kind of like a form that each individual animal can fill in with their specific details.
Let’s Psuedocode how classes representing animals could look:
name— Type: “attribute” — (ex: “Zebra”, “Horse”, “Cow”)
age— Type: “attribute” — (ex: 1, 4, 7)
eat_food— Type: “function” — (ex: when you call the
eat_foodfunction, the animal eats food)
sleep— Type: “function” — (ex: when you call the
sleepfunction, the animal sleeps)
date_of_last_skin_shedding— Type: “attribute” — (ex: “10/13/17”)
slither— Type: “function” — (ex: when you call the
slitherfunction, the snake moves by slithering across the ground)
average_milk_production— Type: “attribute” — (ex: 1.4 gallons)
make_moo_sound— Type: “function” — (ex: “MOOOOOOO!!!“)
We just created classes for two animals, and a general class that is inherited into these two classes. Inheritance means that you give all of the parent functionality to the child. Then, the child can modify or add to that functionality.
So, in this case a
Cow will also have
age attributes, as well as
sleep functions. However, neither the
Snake classes have
average_milk_production as an attribute. This makes sense, because it is an attribute that is specific to cows.
Classes are great building blocks for your application. If you are tracking animals in the zoo, you want a standardized way to refer to the animals so that you know what to expect when you are writing and reading data. Also, as seen, you can group functions that are specific to one domain. This helps a lot with code cleanliness, readability, and usability.
Instance represents one occurrence of a Class. For example, in a heard of cows, each cow is one instance of the
Cow class. The instance stores values that are specific to that cow. This makes sense, because you want to name one cow “Bessie” and another “Andrew”.
In python classes look like this:
class Animal(object): def __init__(self, name, age): self.name = name self.age = age def eat_food(self): print('eating food') def sleep(self): print('sleeping') class Cow(Animal): def __init__(self, name, age, average_milk_production): self.name = name self.age = age self.average_milk_production = average_milk_production def make_moo_sound(self): print ('MooOOooOO!')
You can use them like this:
cow = Cow('Bess', 16, 3.4) cow.age # => 16 cow.eat() # => 'eating food' cow.make_moo_sound() # => 'MooOOooOO!'
:whitecheckmark: Practice: Design classes to represent the following scenarios (Can do in psuedocode, python, or both!)