# 创建空栈
stack = []

# 压栈操作（添加元素到栈顶）
stack.append(1)  # 栈：[1]
stack.append(2)  # 栈：[1, 2]
stack.append(3)  # 栈：[1, 2, 3]

# 弹栈操作（移除并返回栈顶元素）
top = stack.pop()  # 返回3，栈变为：[1, 2]

# 查看栈顶元素（不移除）
peek = stack[-1]   # 返回2，栈不变：[1, 2]

# 检查栈是否为空
is_empty = len(stack) == 0  # 返回False

# 获取栈的大小
size = len(stack)  # 返回2
                

from collections import deque

# 创建空栈
stack = deque()

# 压栈操作
stack.append(10)  # 栈：[10]
stack.append(20)  # 栈：[10, 20]

# 弹栈操作
top = stack.pop()  # 返回20

# 查看栈顶元素
peek = stack[-1]   # 返回10

# 检查栈是否为空
is_empty = len(stack) == 0  # 返回False
                

def is_balanced(expression):
    """检查括号是否匹配"""
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    
    for char in expression:
        # 如果是开括号，压栈
        if char in mapping.values():
            stack.append(char)
        # 如果是闭括号
        elif char in mapping.keys():
            # 如果栈为空或栈顶不匹配，返回False
            if not stack or stack.pop() != mapping[char]:
                return False
    
    # 如果栈为空，则所有括号都匹配
    return len(stack) == 0

# 测试用例
print(is_balanced("(){}[]"))     # True
print(is_balanced("([{}])"))     # True
print(is_balanced("(]"))         # False
print(is_balanced("([)]"))       # False
print(is_balanced("((()"))       # False
                

算法解析：

1. 遍历表达式中的每个字符
2. 遇到开括号（(、{、[）时压入栈中
3. 遇到闭括号（)、}、]）时：
   • 如果栈为空 → 括号不匹配
   • 如果栈顶元素与当前闭括号不匹配 → 括号不匹配
4. 遍历完成后，如果栈为空则所有括号匹配

class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        """压栈操作"""
        self.items.append(item)
    
    def pop(self):
        """弹栈操作"""
        if not self.is_empty():
            return self.items.pop()
        raise IndexError("pop from empty stack")
    
    def peek(self):
        """查看栈顶元素"""
        if not self.is_empty():
            return self.items[-1]
        raise IndexError("peek from empty stack")
    
    def is_empty(self):
        """检查栈是否为空"""
        return len(self.items) == 0
    
    def size(self):
        """返回栈的大小"""
        return len(self.items)
    
    def __str__(self):
        """返回栈的字符串表示"""
        return str(self.items)

# 使用自定义栈类
if __name__ == "__main__":
    s = Stack()
    s.push(10)
    s.push(20)
    s.push(30)
    
    print("栈内容:", s)        # [10, 20, 30]
    print("栈顶元素:", s.peek()) # 30
    print("弹出:", s.pop())     # 30
    print("弹出:", s.pop())     # 20
    print("栈是否为空:", s.is_empty()) # False
    print("栈大小:", s.size())  # 1