Python栈入栈案例如何压入数据

本文目录导读：

1. 基础入栈操作
2. 自定义栈类
3. 批量入栈
4. 条件入栈（带验证）
5. 实际应用场景案例
6. 入栈操作性能对比

我来分享几个Python栈入栈的经典案例,从简单到复杂逐步演示。

基础入栈操作

使用列表实现栈

# 创建一个空栈
stack = []
# 入栈操作 (压入数据)
stack.append(10)      # 栈: [10]
stack.append(20)      # 栈: [10, 20]
stack.append(30)      # 栈: [10, 20, 30]
print("当前栈:", stack)  # 输出: [10, 20, 30]

自定义栈类

class Stack:
    def __init__(self):
        self.items = []
    def push(self, item):
        """入栈操作"""
        self.items.append(item)
        print(f"入栈: {item}")
    def pop(self):
        """出栈操作"""
        if not self.is_empty():
            return self.items.pop()
        return None
    def is_empty(self):
        return len(self.items) == 0
    def size(self):
        return len(self.items)
    def peek(self):
        """查看栈顶元素"""
        if not self.is_empty():
            return self.items[-1]
        return None
# 使用示例
stack = Stack()
stack.push("A")    # 入栈: A
stack.push("B")    # 入栈: B
stack.push("C")    # 入栈: C
print(f"栈的大小: {stack.size()}")  # 输出: 3
print(f"栈顶元素: {stack.peek()}")  # 输出: C

批量入栈

def batch_push(stack, items):
    """批量将多个元素入栈"""
    for item in items:
        stack.append(item)
    return stack
# 示例
stack = []
batch_push(stack, [1, 2, 3, 4, 5])
print("批量入栈后:", stack)  # 输出: [1, 2, 3, 4, 5]

条件入栈（带验证）

def conditional_push(stack, item, max_size=5):
    """
    条件入栈：栈满时不能入栈
    """
    if len(stack) >= max_size:
        print(f"栈已满，无法入栈 {item}")
        return False
    stack.append(item)
    print(f"成功入栈: {item}")
    return True
# 示例
stack = []
for i in range(7):  # 尝试入栈7个元素
    conditional_push(stack, i * 10)
print("最终栈:", stack)  # 只包含前5个元素

实际应用场景案例

1 括号匹配检查

def check_brackets(expression):
    """检查括号是否匹配"""
    stack = []
    brackets = {'(': ')', '[': ']', '{': '}'}
    for char in expression:
        if char in brackets.keys():  # 左括号入栈
            stack.append(char)
            print(f"入栈: {char}")
        elif char in brackets.values():  # 右括号检查
            if not stack:
                return False
            left = stack.pop()
            if brackets[left] != char:
                return False
    return len(stack) == 0
# 测试
expression = "{[()]}"
print(f"括号匹配: {check_brackets(expression)}")  # True

2 浏览器的前进后退

class BrowserHistory:
    def __init__(self):
        self.back_stack = []    # 后退栈
        self.forward_stack = [] # 前进栈
        self.current = None
    def visit(self, url):
        """访问新页面"""
        if self.current:
            self.back_stack.append(self.current)
            print(f"将 {self.current} 入栈到后退栈")
        self.current = url
        self.forward_stack.clear()  # 清空前进栈
        print(f"访问新页面: {url}")
    def go_back(self):
        """后退"""
        if self.back_stack:
            self.forward_stack.append(self.current)
            self.current = self.back_stack.pop()
            print(f"后退到: {self.current}")
# 测试
browser = BrowserHistory()
browser.visit("google.com")
browser.visit("python.org")  # google.com 入栈到后退栈
browser.visit("github.com")  # python.org 入栈到后退栈
browser.go_back()           # 后退到 python.org

入栈操作性能对比

import time
def performance_test():
    """测试不同入栈方式的性能"""
    # 方法1: 列表append
    stack1 = []
    start = time.time()
    for i in range(100000):
        stack1.append(i)
    print(f"列表append耗时: {time.time() - start:.4f}秒")
    # 方法2: 使用collections.deque
    from collections import deque
    stack2 = deque()  # 双端队列也可以当栈用
    start = time.time()
    for i in range(100000):
        stack2.append(i)  # 与列表相似的入栈方式
    print(f"deque耗时: {time.time() - start:.4f}秒")
performance_test()

1. 入栈方法: 使用 list.append() 或 deque.append()
2. 验证检查: 添加栈容量限制、类型检查等
3. 实际应用: 括号匹配、函数调用、撤销操作等
4. 性能考虑: 普通场景用列表即可，大量操作考虑deque

希望这些案例能帮助你理解Python栈的入栈操作！