Traversing a 2D Array

Prior Knowledge: Loops

Along with knowing how to make 2D Arrays, you also have to be able to traverse them

To traverse a 2D array, you can use a nested loop setup like the below code

for x in range(rows):
  for y in range(cols):
    array[x][y] = random.randint(0, 10)
                      

You can use this concept to print out the array 1 row at a time. When you print out the array outright you get the below output

print(array)
> [[2,7,6,3],[2,7,6,3],[2,7,6,3],[2,7,6,3],[2,7,6,3]]
                      

But by traversing the array, you can either print out each row or each number in the row

# Print Out Each Row
for x in range(rows):
  print(array[x])
                      

# Print Out Each Number In Each Row
for x in range(rows):
  for y in range(cols):
    print(array[x][y])
                      

NOTE: When Using An Array With an Undetermined Length, use the len(array) to get the length instead

Summary

Prior Knowledge: 2D Arrays

To Summarise what you've just learned:

• 2D Arrays are similar to a grid of squares, each column will return a 1D array of values
• A 2D Array can be indexed with 2 indices, i.e arr[x][y]
• You can traverse a 2D array using a nested loop setup

What's a Double Linked List?

Prior Knowledge: Dynamic List Items (Basic)

A double linked list is similar to a single linked list but it stores the previous nodes memory position on top of the ahead node

An example of a double linked node is shown below

And below this is an example of a double linked list, showing the connections between each node

Insertion & Deletion of Information is almost identical as in a single linked list but now you have to update the previous node memory locations as well

Methods... Isn't that Just Functions?

Prior Knowledge: Functions & Procedures

Methods are functions & procedures within classes that can't be called without referring to an instance of that class or the class itself (in very rare circumstances)

There are 3 main methods in classes:

1. Constructor Methods
2. Getter Methods
3. Setter Methods

NOTE: When we get further into this topic, it's useful to know you can override methods

Lets take our bicycle example from below and add some methods to it. Lets add a method to return the current gear and a method to change the gear on the bike

class Bicycle:
# previous code above

def GetGear(self, newGear): return self.bikeGear

def SetGear(self, newGear):
  self.bikeGear = newGear
                      

Now you might be wondering why we're not just setting the gear and speed variables directly, and this is because of something called Encapsulation.

Encapsulation helps limit direct access to (possibly sensitive) variables inside of classes, by using methods such as those above it funnels the usage of these variables to (usually) 2 routes, and those are called getters and setters, denoted most commonly by their 'Set' or 'Get' prefixes on functions or procedures.

Summary

To Summarise the above 2 sections:

• Classes - A type used to store information specific to an entity. Creating a new copy of the class is called Instantiation
• Uses - Classes can store both values and functions or procedures, called methods
• Methods - A method can only be called when using an instance of that class or the class itself
• Constructor Method - A special method used when a new class instance is made, setting up the unique values for this instance
• Getters & Setters - Special methods used to block unwanted access to variables within classes
• Object - An object is an instance of any class and can be stored like a variable

Polywhatsit?

Prior Knowledge: Classes, Objects, Inheritance

Finally, for the coding part. There's polymorphism. Polymorphism is a key term used to describe when classes have the same methods that do different things, also known as overridden methods. This follows on from inheritance by changing a base methods programming.

For example, lets say our Bicycle class had a method that calculated distance based on wheel turns per minute

class Bicycle:
def CalculateSpeed(self, wheelturns): 
return self.bikeSpeed * wheelturns
                      

And out MountainBike subclass had the same method but calculated distance based on the force exerted on the pedals per minute

class MountainBike(Bicycle):
def CalculateSpeed(self, pedalPressure): 
return self.bikeSpeed * pedalPressure
                      

Or If you're simply changing the variable used, you can use the below code (A bit more advanced)

class MountainBike(Bicycle):
def CalculateSpeed(self, pedalPressure):
return super().CalculateSpeed(pedalPressure)
                      

That's polymorphism. 2 of the same methods, but the subclass method is different to the base class method.

Summary

To Summarise:

• Inheritance - A subclass can inherit variables and methods from a base/parent class
• Polymorphism - A subclass can override methods and variables which allows for 2 of the same method to do different things