python-stack

implements

• list

• deque

• LifoQueue

• 原文地址：https://realpython.com/how-to-implement-python-stack/

Argue

• list

  • This works great for several operations, like indexing into the list. Getting myList[3] is fast, as Python knows exactly where to look in memory to find it. This memory layout also allows slices to work well on lists.

  • The contiguous memory layout is the reason that list might need to take more time to .append() some objects than others. If the block of contiguous memory is full, then it will need to get another block, which can take much longer than a normal .append():

  • If the block of contiguous memory is full, then it will need to get another block, which can take much longer than a normal .append():

  • 如果连续的内存块被写满，再加入新元素会导致重新开辟内存，耗时增加。

  • list 线程不安全

• deque

  • deque, on the other hand, is built upon a doubly linked list. In a linked list structure, each entry is stored in its own memory block and has a reference to the next entry in the list.
  • A doubly linked list is just the same, except that each entry has references to both the previous and the next entry in the list. This allows you to easily add nodes to either end of the list.
  • deque 使用了双向链表维护内存，继而可以灵活方便的进行增加元素的操作

• LifoQueue

  • Unlike deque, LifoQueue is designed to be fully thread-safe. All of its methods are safe to use in a threaded environment. It also adds optional time-outs to its operations which can frequently be a must-have feature in threaded programs.

  • This full thread safety comes at a cost, however. To achieve this thread-safety, LifoQueue has to do a little extra work on each operation, meaning that it will take a little longer.

  • Frequently, this slight slow down will not matter to your overall program speed, but if you’ve measured your performance and discovered that your stack operations are the bottleneck, then carefully switching to a deque might be worth doing.

  • LifoQueue 线程安全，但性能会有些许损失，一般情况下影响不大。但如果发现栈操作成为了瓶颈，切换为deque要小心，可能会导致问题

Conclusion

• Python Stacks: Which Implementation Should You Use?

  • In general, you should use a deque if you’re not using threading. If you are using threading, then you should use a LifoQueue unless you’ve measured your performance and found that a small boost in speed for pushing and popping will make enough difference to warrant the maintenance risks.

  • list may be familiar, but it should be avoided because it can potentially have memory reallocation issues. The interfaces for deque and list are identical, and deque doesn’t have these issues, which makes deque the best choice for your non-threaded Python stack.

  • You now know what a stack is and have seen situations where they can be used in real-life programs. You’ve evaluated three different options for implementing stacks and seen that deque is a great choice for non-threaded programs. If you’re implementing a stack in a threading environment, then it’s likely a good idea to use a LifoQueue.

  • 单线程场景下deque是推荐选择，多线程场景下，请选择LifoQueue。

python-stack

原文：https://www.cnblogs.com/suanec/p/13027660.html