lesson1Title

lesson2Title

lesson3Title

lesson4Title

lesson5Title

lesson6Title

lesson7Title

lesson8Title

lesson9Title

lesson10Title

lesson11Title

lesson12Title

lesson13Title

pythonIntroStep4Chapter3Title

pythonIntroStep4Chapter1Title

pythonIntroStep4Chapter2Title

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        pass

    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        return "The stack is empty"

    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        return "The stack is empty"

    def is_empty(self):
        return len(self.items) == 0

# Example of using the stack
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

# Check the top element: 3
print("stack.peek():", stack.peek())
# Remove the top element: 3
print("stack.pop():", stack.pop())
# Remove the top element: 2
print("stack.pop():", stack.pop())
# Is the stack empty: False
print("Is the stack empty:", stack.is_empty())

# Stack: Data Entered Last Comes Out First

A stack is a data structure where **the last element added is the first to be removed**, which is known as `Last In First Out (LIFO)`.

In simple terms, it works like stacking books where you take the book from the top first.

A stack allows data to be added or removed in a limited fashion and is used in various program functionalities such as browser history, undo functions, and more.

<br />

## Basic Operations of a Stack

A stack consists of the following main operations:

- `Push`: **Adds a new element to the top of the stack**.

- `Pop`: **Removes the most recently added element from the stack** and returns that element.

- `Peek (or Top)`: **Returns the top element of the stack** without removing it.

- `IsEmpty`: **Checks if the stack is empty**.

<br />

## How Can a Stack Be Implemented?

In Python, a simple stack can be implemented using a list.

```python title="Stack Usage Example"
# Initialize stack
stack = []

# Push elements
stack.append(1)
stack.append(2)
stack.append(3)

# Peek at the top element
print(stack[-1])
# Output: 3

# Pop the top element
print(stack.pop())
# Output: 3
print(stack.pop())
# Output: 2

# Check if the stack is empty
print(len(stack) == 0)
# Output: False
```

You can find a more detailed stack implementation using `Class` in the code editor on the right.

A stack is a data structure that follows the `Last In First Out (LIFO)` method, where the last element added is the first one to be removed. This structure is useful for browser history, among other applications.

Stack: Data Entered Last Comes Out First

Basic Operations of a Stack

How Can a Stack Be Implemented?

What are the correct characteristics of a stack?