Learn how to implement the stack data structure using Python.

Stacks: Python


It's time to add a couple helper methods. 

Helper methods simplify the code we've written by abstracting and labeling chunks of code into a new function. Here's an example:

```py
# Adding "!" without a helper
saying = "I love helper methods"
exclamation = saying + "!"

# Adding "!" with a helper
def add_exclamation_to_string(str):
  return str + "!"

exclamation2 = add_exclamation_to_string("I love helper methods")
```
This might seem like a silly example, but think about the benefit of the `add_exclamation_to_string()` helper. 
1.  The name tells us what this function does. Without a helper, we'd need to read the code to understand its meaning. 
2. The function lets us repeat this behavior. Without a helper, we'd need to keep rewriting the same code!

First, we want one that checks if our stack has room for more items. We can use this in `.push()` to guard against pushing items to our stack when it's full. 

Second, it's helpful to have a method that checks if the stack is empty...



Stacks Python Size II

With stacks, size matters. If we're not careful, we can accidentally over-fill them with data. Since we don't want any stack overflow, we need to go back and make a few modifications to our methods that help us track and limit the stack size so we can keep our stacks healthy.

What do we do if someone tries to `peek()` or `pop()` when our stack is empty?

How do we keep someone from `push()`ing to a stack that has already reached its limit?

How do we even know how large our stack has gotten?



Stacks Python Size I


You have an understanding of how stacks work in theory, so now let's see how they can be useful out in the wild — with Python!

Remember that there are three main methods that we want our stacks to have:

- Push - adds data to the "top" of the stack
- Pop - provides and removes data from the "top" of the stack
- Peek - provides data from the "top" of the stack **without removing it** 

We also need to consider the stack's size and tweak our methods a bit so that our stack does not "overflow". 

Let's get started building out our `Stack` class.



Stacks Python Introduction


The stack's `push()` and `pop()` methods are our tools to add and remove items from it. `pop()` additionally returns the value of the item it is removing. Keep in mind that we can only make modifications to the top of the stack.



Stacks Python Push and Pop

Nice work — you've built out a `Stack` class that can:
 - add a new item to the top via a `push()` method
 - remove an item from the top and returns its value with a `pop()` method
 - return the value of the top item using a `peek()` method
 - allows a stack instance to maintain an awareness of its size to prevent stack "overflow"

So how does your code stack up against pizza delivery?
