Create a stack class with methods to push, pop, peek, and check if the stack is empty using Python

Introduction to Stack

A stack is a linear information structure that follows the Last In First Out (LIFO) precept. This way that the closing detail introduced to the stack is the primary one to be eliminated. Stacks are used in numerous applications, such as function call control in programming languages, undo mechanisms in text editors, and plenty of greater.

Key Operations of a Stack

Implementation

We’ll put into effect the stack the usage of a Python listing, which provides dynamic array skills. Below is the entire code for a Stack elegance along side causes for every part.

class Stack:
    def __init__(self):
        """Initialize an empty stack."""
        self.items = []

    def push(self, item):
        """Add an item to the top of the stack.

        Args:
            item: The item to be added to the stack.
        """
        self.items.append(item)
        print(f"Pushed {item} onto stack.")

    def pop(self):
        """Remove and return the item from the top of the stack.

        Returns:
            The item removed from the top of the stack.

        Raises:
            IndexError: If the stack is empty.
        """
        if self.is_empty():
            raise IndexError("Pop from empty stack.")
        item = self.items.pop()
        print(f"Popped {item} from stack.")
        return item

    def peek(self):
        """Return the top item of the stack without removing it.

        Returns:
            The item on the top of the stack.

        Raises:
            IndexError: If the stack is empty.
        """
        if self.is_empty():
            raise IndexError("Peek from empty stack.")
        item = self.items[-1]
        print(f"Peeked at stack, top item is: {item}.")
        return item

    def is_empty(self):
        """Check if the stack is empty.

        Returns:
            True if the stack is empty, False otherwise.
        """
        return len(self.items) == 0

    def size(self):
        """Return the number of items in the stack.

        Returns:
            The size of the stack.
        """
        return len(self.items)

    def display(self):
        """Display the current items in the stack."""
        print("Current stack:", self.items)

Explanation of the Code

Initialization (__init__):

• The constructor initializes an empty list to store stack items. This list will dynamically grow as we add more items.

Push Method:

• push(item) appends the item to the end of the list (top of the stack) and prints a confirmation message

Pop Method:

• pop() first checks if the stack is empty by calling is_empty(). If it is, an IndexError is raised to prevent removing an item from an empty stack. If not, the last item is removed using pop() and a message is printed.

Peek Method:

• peek() checks if the stack is empty. If it is, an IndexError is raised. If not, it retrieves the last item in the list (top of the stack) without removing it and prints it.

Is Empty Method:

• is_empty() simply checks the length of the items list to determine if the stack is empty.

Size Method:

• size() returns the number of items currently in the stack.

Display Method:

• display() provides a visual representation of the current state of the stack

Usage Example

Below is an example of how to use the Stack class:

if __name__ == "__main__":
    stack = Stack()

    # Pushing items onto the stack
    stack.push(10)
    stack.push(20)
    stack.push(30)

    # Displaying current stack
    stack.display()

    # Peeking at the top item
    top_item = stack.peek()

    # Popping items from the stack
    stack.pop()
    stack.pop()

    # Displaying current stack
    stack.display()

    # Checking if the stack is empty
    if stack.is_empty():
        print("Stack is empty.")
    else:
        print("Stack is not empty.")

    # Popping the last item
    stack.pop()

    # Attempting to pop from an empty stack
    try:
        stack.pop()
    except IndexError as e:
        print(e)

Explanation of the Example

• Stack Creation: An example of the Stack magnificence is created.
• Pushing Items: Several integers are pushed onto the stack.
• Display Current Stack: The modern-day country of the stack is displayed.
• Peeking: The pinnacle item of the stack is peeked at and displayed.
• Popping Items: Items are popped off the stack, and the kingdom of the stack is displayed after every operation.
• Check if Empty: The software exams if the stack is empty and prints the end result.
• Handling Empty Stack: Finally, an try to pop from the empty stack is made, demonstrating mistakes managing.

The stack statistics shape is fundamental in computer science and has severa packages in programming. This implementation offers a clean expertise of stack operations the use of Python. The strategies applied make sure that not unusual operations can be carried out efficiently, and errors dealing with is in vicinity to manage part cases like popping from an empty stack.

Further Enhancements

You can beautify this stack implementation in addition through:

• Adding a method to clean the stack.
• Implementing a most length for the stack to keep away from immoderate reminiscence utilization.
• Adding extra sturdy blunders handling and logging.
• Allowing the stack to maintain one of a kind data sorts or even implementing a frequent stack the use of Python’s type hinting.

Additional Concepts

Understanding stacks opens the door to extra complex facts systems and algorithms, which include:

• Recursion: Many recursive algorithms use a name stack for tracking feature calls.
• Backtracking: Stacks can assist solve problems that contain exploring a couple of paths and reverting returned while a course does no longer lead to a solution.
• Expression Evaluation: Stacks are utilized in parsing and evaluating expressions in compilers.

By getting to know stacks and their implementations, college students might be well-equipped to address extra advanced information systems and algorithms in their academic and professional careers.