正文

Python中如何计算栈的长度 手把手教你用len()函数获取Stack大小 以及常见问题解决方法

/0 浏览量
1003

Python中如何计算栈的长度 手把手教你用len()函数获取Stack大小 以及常见问题解决方法

栈（Stack）是编程世界里最常见也最实用的数据结构之一。想象一下，你面前有一摞盘子，每次只能从最上面拿或放，这就是栈的”后进先出”（LIFO）特性。在Python里，虽然我们没有专门的”栈”类型，但用列表（list）或者collections.deque就能轻松实现一个栈。今天我们就来聊聊，如何获取栈的长度，以及一些你可能会踩的坑。

用列表实现栈，然后量一量

最简单的栈就是Python的列表。你想入栈（push）一个元素？直接append()。想出栈（pop）？用pop()方法。那么栈有多大呢？很简单——len()。

# 用列表模拟栈
stack = []

# 往栈里加东西
stack.append(10)
stack.append(20)
stack.append(30)

# 看看栈里有多少个元素
print(f"当前栈长度: {len(stack)}")  # 输出: 当前栈长度: 3

# 再pop一个
stack.pop()
print(f"pop之后栈长度: {len(stack)}")  # 输出: pop之后栈长度: 2

看，就是这么简单。len()返回的就是列表当前元素的个数，也就是栈的深度。但是，有些新手会在这里犯迷糊，我们来聊几个常见问题。

常见误区：别把”栈”和”列表”混为一谈

有些同学可能会问：为什么非得用列表来实现栈？Python不是已经有栈了吗？

答案很简单——Python标准库里其实没有专门的栈类型。栈是一种抽象概念，你可以用列表、deque、甚至队列（queue.Queue）来实现它。用列表最直观，但性能上不一定最优。

比如，如果你频繁地在列表头部插入或删除元素，列表的效率会很低，因为每次操作都要移动后面的元素。这时候，collections.deque就是更好的选择。

from collections import deque

# 用deque实现栈
stack = deque()

stack.append(100)
stack.append(200)
stack.append(300)

print(f"deque栈长度: {len(stack)}")  # 输出: deque栈长度: 3

deque是双端队列，从两端操作都是O(1)的时间复杂度，所以在需要高性能的场景下，用deque更合适。不过，不管用哪种方式，len()函数都一样能用。

一个容易忽略的细节：空栈的长度

如果你对一个空栈调用len()，它会返回0，这完全符合预期。但有些同学会担心：调用len()会不会报错？或者会不会改变栈的状态？

放心，len()是一个纯粹的查询操作，它不会修改栈里的任何内容，也不会抛出异常。

empty_stack = []
print(len(empty_stack))  # 输出: 0

# 再试一个deque
from collections import deque
empty_deque = deque()
print(len(empty_deque))  # 输出: 0

实际场景：用栈来解决括号匹配问题

光说不练假把式。栈最著名的应用场景之一就是括号匹配。比如，一段代码里的括号是否成对出现？用栈就能轻松判断。

def is_valid_parentheses(expression):
    stack = []
    mapping = {')': '(', ']': '[', '}': '{'}

    for char in expression:
        if char in mapping:
            # 是右括号，检查栈顶是否匹配
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            # 是左括号，入栈
            stack.append(char)

    # 如果栈是空的，说明所有括号都匹配了
    return len(stack) == 0

# 测试
print(is_valid_parentheses("([{}])"))  # 输出: True
print(is_valid_parentheses("([)]"))    # 输出: False
print(is_valid_parentheses("((("))     # 输出: False

在这个例子中，len(stack)出现在最后一行，用来判断最终栈是否为空。这是len()在栈应用中非常典型的一种用法。

进阶：用类封装一个真正的栈

如果你不想每次都手动用列表操作，完全可以自己封装一个Stack类。这样代码更整洁，也更容易扩展。

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

    def push(self, item):
        """入栈"""
        self._items.append(item)

    def pop(self):
        """出栈"""
        if self.is_empty():
            raise IndexError("栈为空，无法pop")
        return self._items.pop()

    def peek(self):
        """查看栈顶元素，但不删除"""
        if self.is_empty():
            raise IndexError("栈为空，无法peek")
        return self._items[-1]

    def is_empty(self):
        """判断是否为空"""
        return len(self._items) == 0

    def size(self):
        """返回栈的长度"""
        return len(self._items)

    def __len__(self):
        """支持内置的len()函数"""
        return self.size()

    def __repr__(self):
        return f"Stack({self._items})"


# 使用示例
s = Stack()
s.push(1)
s.push(2)
s.push(3)

print(f"栈的大小: {s.size()}")   # 输出: 栈的大小: 3
print(f"栈的长度: {len(s)}")      # 输出: 栈的长度: 3
print(f"栈顶元素: {s.peek()}")    # 输出: 栈顶元素: 3

s.pop()
print(f"pop之后长度: {len(s)}")   # 输出: pop之后长度: 2

注意这里实现了一个__len__魔法方法，这让我们的Stack对象可以直接使用Python内置的len()函数。这是一个很好的实践，让你的自定义类型用起来和内置类型一样自然。

性能对比：列表 vs deque

如果你在做性能敏感的项目，可能会好奇：列表和deque，哪个做栈更快？

import time
from collections import deque

def benchmark_list_stack(n=100000):
    stack = []
    start = time.perf_counter()
    for i in range(n):
        stack.append(i)
    for _ in range(n):
        stack.pop()
    end = time.perf_counter()
    return end - start

def benchmark_deque_stack(n=100000):
    stack = deque()
    start = time.perf_counter()
    for i in range(n):
        stack.append(i)
    for _ in range(n):
        stack.pop()
    end = time.perf_counter()
    return end - start

print(f"列表栈耗时: {benchmark_list_stack():.6f}秒")
print(f"deque栈耗时: {benchmark_deque_stack():.6f}秒")

在实际测试中，当操作主要在栈的尾部进行时，列表的性能已经非常优秀，和deque相差无几。但当你的栈操作涉及到头部插入（比如模拟某些特殊的算法）时，deque的优势就会明显体现出来。不过对于绝大多数的栈应用场景，两者都是可以接受的。

一些你可能不知道的”冷知识”

1. len()返回的是精确长度，不是容量

有些同学会把”长度”和”容量”搞混。Python的列表在内存中可能有预分配的额外空间（为了性能优化），但len()只返回你实际存了多少个元素，它不会告诉你列表的”容量”有多大。如果你真的好奇底层容量，可以通过__sizeof__()来查看内存占用，但那已经是另一个话题了。

2. 栈长度可以是负数吗？

不可能。len()永远返回一个非负整数。如果你对空栈调用pop()，Python会抛出IndexError，而不是返回一个负数。这是Python的设计哲学之一：出问题就抛出异常，让调用者自己处理。

3. 多线程环境下的”长度”问题

如果你在做多线程编程，可能会遇到一个微妙的问题：len()返回的栈长度，在并发环境下可能瞬间过时。

import threading

stack = []

def producer():
    for i in range(1000):
        stack.append(i)

def consumer():
    for _ in range(1000):
        if len(stack) > 0:  # 先检查长度
            stack.pop()       # 再pop，但这之间可能另一个线程已经把元素拿走了

在这个例子中，len(stack) > 0和stack.pop()之间可能存在竞态条件。如果你需要线程安全的栈，建议使用queue.LifoQueue，它专门为多线程场景设计。

from queue import LifoQueue

thread_safe_stack = LifoQueue()
thread_safe_stack.put(1)
thread_safe_stack.put(2)
print(thread_safe_stack.qsize())  # 输出: 2

qsize()返回的就是栈的当前大小，而且这个操作是线程安全的。

总结一下

获取Python栈的长度，核心就一个函数：len()。无论是用列表、deque，还是自己封装的Stack类，len()都能帮你得到正确答案。

记住几个关键点：

  • len()不修改栈，只是一个查询操作
  • 空栈的len()返回0，不会报错
  • 自己封装类时可以实现__len__方法，让len()更好用
  • 多线程场景下，考虑使用queue.LifoQueue
  • 性能敏感且需要头部操作时，优先考虑deque

栈虽然是个简单的数据结构，但它的妙用无处不在。从括号匹配到函数调用栈，从撤销操作到表达式求值，掌握它的基本操作是你成为优秀程序员的必经之路。希望你以后遇到栈相关的问题，能从容应对，不再迷茫。

-- 展开阅读全文 --