Python常用队列全面详细梳理

目录
  • 一,队列
  • 二,常见队列
    • 1,FIFO队列
    • 2,LIFO队列
    • 3,双向队列
    • 4,优先级队列
    • 5,循环队列

一,队列

和栈一样,队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。队列是一种操作受限制的线性表,进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

二,常见队列

1,FIFO队列

基本FIFO队列 先进先出 FIFO即First in First Out,先进先出。

调用queue.Queue

from queue import Queue
fifo_queue = Queue()
fifo_queue.put(1)  # 队尾插入新元素
fifo_queue.put(2)
fifo_queue.put(3)
print(fifo_queue.queue)
print(fifo_queue.get())  # 队头取出元素
print(fifo_queue.queue)

链表实现

class LNode(object):
    def __init__(self, item, next_=None):
        self.item = item
        self.next = next_
class FIFOQueue(object):
    def __init__(self):
        """初始化"""
        self.head = None
        self.rear = None
    def is_empty(self):
        """判断是否为空"""
        return self.head is None
    def size(self):
        """获取队列长度"""
        cur = self.head
        count = 0
        while True:
            count += 1
            if cur == self.rear:
                break
            cur = cur.next
        return count
    def travel(self):
        """遍历队列"""
        if self.is_empty():
            print('queue is empty')
            return
        else:
            cur = self.head
            while True:
                print(cur.item, end='')
                if cur.next:
                    print(',', end='')
                if cur == self.rear:
                    break
                cur = cur.next
            print('')
    def push(self, val):
        """队尾插入新元素"""
        p = LNode(val)
        if self.is_empty():
            self.head = p
            self.rear = p
        else:
            self.rear.next = p
            self.rear = self.rear.next
    def get(self):
        """获取队头元素"""
        if self.is_empty():
            print('queue is empty')
            return
        else:
            e = self.head.item
            self.head = self.head.next
            return e
if __name__ == '__main__':
    FIFOQueue = FIFOQueue()
    FIFOQueue.push(1)
    FIFOQueue.push(2)
    FIFOQueue.push(3)
    FIFOQueue.push(4)
    FIFOQueue.travel()  # 1,2,3,4
    print(FIFOQueue.get())  # 1
    print(FIFOQueue.get())  # 2
    FIFOQueue.travel()  # 3,4

list实现

# list 实现
class FIFOQueue(object):
    def __init__(self):
        self.queue = list()
    def size(self):
        return len(self.queue)
    def travel(self):
        print(self.queue)
    def push(self, val):
        self.queue.append(val)
    def get(self):
        return self.queue.pop(0)
if __name__ == '__main__':
    FIFOQueue = FIFOQueue()
    FIFOQueue.push(1)
    FIFOQueue.push(2)
    FIFOQueue.push(3)
    FIFOQueue.push(4)
    FIFOQueue.travel()  # 1,2,3,4
    print(FIFOQueue.get())  # 1
    print(FIFOQueue.get())  # 2
    FIFOQueue.travel()  # 3,4

2,LIFO队列

LIFO即Last in First Out,后进先出。与栈的类似,在队尾进行插入和删除操作。

调用queue.LifoQueue

from queue import LifoQueue
lifo_queue = LifoQueue()
lifo_queue.put(1)  # 队尾插入新元素
lifo_queue.put(2)
lifo_queue.put(3)
print(lifo_queue.queue)
print(lifo_queue.get())  # 队尾取出元素
print(lifo_queue.queue)

链表实现

将链表头部作为队列尾部,在链表头部进行插入和删除操作。

class LNode(object):
    def __init__(self, item, next_=None):
        self.item = item
        self.next = next_
class LIFOQueue(object):
    def __init__(self):
        """初始化"""
        self.head = None
    def is_empty(self):
        """判断是否为空"""
        return self.head is None
    def size(self):
        """获取队列长度"""
        cur = self.head
        count = 0
        while cur:
            count += 1
            cur = cur.next
        return count
    def travel(self):
        """遍历队列"""
        travel_list = []
        cur = self.head
        while cur:
            travel_list.append(cur.item)
            cur = cur.next
        travel_list.reverse()
        print(travel_list)
    def push(self, val):
        """头部插入"""
        self.head = LNode(val, self.head)
    def get(self):
        """获取队头元素"""
        if self.is_empty():
            print('queue is empty')
            return
        else:
            e = self.head.item
            self.head = self.head.next
            return e
if __name__ == '__main__':
    LIFOQueue = LIFOQueue()
    LIFOQueue.push(1)
    LIFOQueue.push(2)
    LIFOQueue.push(3)
    LIFOQueue.push(4)
    LIFOQueue.travel()  # 1,2,3,4
    print(LIFOQueue.get())  # 4
    print(LIFOQueue.get())  # 3
    LIFOQueue.travel()  # 1,2

List实现

# list 实现
class LIFOQueue(object):
    def __init__(self):
        self.queue = list()
    def size(self):
        return len(self.queue)
    def travel(self):
        print(self.queue)
    def push(self, val):
        self.queue.append(val)
    def get(self):
        return self.queue.pop()
if __name__ == '__main__':
    LIFOQueue = LIFOQueue()
    LIFOQueue.push(1)
    LIFOQueue.push(2)
    LIFOQueue.push(3)
    LIFOQueue.push(4)
    LIFOQueue.travel()  # 1,2,3,4
    print(LIFOQueue.get())  # 4
    print(LIFOQueue.get())  # 3
    LIFOQueue.travel()  # 1,2

3,双向队列

双端队列(deque,全名 double-ended queue),是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出,其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

调用collections .deque

collections 是 python 内建的一个集合模块,里面封装了许多集合类,其中队列相关的集合只有一个:deque。

deque 是双边队列(double-ended queue),具有队列和栈的性质,在 list 的基础上增加了移动、旋转和增删等。

deque(maxlen=3),通过maxlen参数,可以创建固定长度的队列,当新元素加入队列且队列已满,会自动从另一端移除首个元素。不指定maxlen,得到无界限的队列。

from collections import deque
d = deque([])
d.append('a')  # 在最右边添加一个元素,此时 d=deque('a')
print(d)
d.appendleft('b')  # 在最左边添加一个元素,此时 d=deque(['b', 'a'])
print(d)
d.extend(['c', 'd'])  # 在最右边添加所有元素,此时 d=deque(['b', 'a', 'c', 'd'])
print(d)
d.extendleft(['e', 'f'])  # 在最左边添加所有元素,此时 d=deque(['f', 'e', 'b', 'a', 'c', 'd'])
print(d)
d.pop()  # 将最右边的元素取出,返回 'd',此时 d=deque(['f', 'e', 'b', 'a', 'c'])
print(d)
d.popleft()  # 将最左边的元素取出,返回 'f',此时 d=deque(['e', 'b', 'a', 'c'])
print(d)
d.rotate(-2)  # 向左旋转两个位置(正数则向右旋转),此时 d=deque(['a', 'c', 'e', 'b'])
print(d)

双向链表实现

class DLNode(object):
    def __init__(self, item, prior_=None, next_=None):
        self.item = item
        self.prior = prior_
        self.next = next_
class DQueue(object):
    def __init__(self):
        self.head = None    # 头指针
        self.rear = None    # 尾制造
    def is_empty(self):
        return self.head is None
    def length(self):
        if self.is_empty():
            print('queue is empty')
            return
        else:
            cur = self.head
            count = 0
            while True:
                count += 1
                if cur == self.rear:
                    break
                cur = cur.next
            return count
    def travel(self):
        """遍历队列"""
        if self.is_empty():
            print('queue is empty')
            return
        else:
            cur = self.head
            while True:
                print(cur.item, end='')
                if cur.next:
                    print(',', end='')
                if cur == self.rear:
                    break
                cur = cur.next
            print('')
    def push_rear(self, val):
        """队尾插入元素"""
        p = DLNode(val)
        if self.is_empty():
            self.head = p
            self.rear = p
        else:
            self.rear.next = p
            p.prior = self.rear
            self.rear = self.rear.next
    def push_head(self, val):
        """队头插入元素"""
        p = DLNode(val)
        if self.is_empty():
            self.head = p
            self.rear = p
        else:
            p.next = self.head
            self.head.prior = p
            self.head = p
    def pop_rear(self):
        """获取队尾元素"""
        if self.is_empty():
            print('queue is empty')
            return
        else:
            p = self.rear
            self.rear = self.rear.prior
            self.rear.next = None
            return p.item
    def pop_head(self):
        """获取队头元素"""
        if self.is_empty():
            print('queue is empty')
            return
        else:
            e = self.head.item
            self.head = self.head.next
            return e
if __name__ == '__main__':
    DQueue = DQueue()
    DQueue.push_head(1)
    DQueue.push_head(2)
    DQueue.push_head(3)
    DQueue.travel()  # 3,2,1
    DQueue.push_rear('a')
    DQueue.push_rear('b')
    DQueue.travel()  # 3,2,1,a,b
    print(DQueue.pop_head())  # 3
    print(DQueue.pop_rear())  # b
    print(DQueue.pop_rear())  # a
    DQueue.travel()  # 2,1

list实现

class DQueue:
    """双端队列"""
    def __init__(self):
        self.queue = []
    def push_head(self, val):
        """从队头加入一个元素"""
        self.queue.insert(0, val)
    def push_rear(self, val):
        """从队尾加入一个元素"""
        self.queue.append(val)
    def pop_head(self):
        """从队头删除一个元素"""
        return self.queue.pop(0)
    def pop_rear(self):
        """从队尾删除一个元素"""
        return self.queue.pop()
    def is_empty(self):
        """是否为空"""
        return self.queue == []
    def size(self):
        """队列长度"""
        return len(self.queue)
    def travel(self):
        print(self.queue)
if __name__ == "__main__":
    DQueue = DQueue()
    DQueue.push_head(1)
    DQueue.push_head(2)
    DQueue.push_head(3)
    DQueue.travel()  # [3, 2, 1]
    DQueue.push_rear('a')
    DQueue.push_rear('b')
    DQueue.travel()  # [3, 2, 1, 'a', 'b']
    print(DQueue.pop_head())  # 3
    print(DQueue.pop_rear())  # b
    print(DQueue.pop_rear())  # a
    DQueue.travel()  # [2, 1]

4,优先级队列

优先级队列是一种容器型数据结构,它能管理一队记录,并按照排序字段(例如一个数字类型的权重值)为其排序。由于是排序的,所以在优先级队列中你可以快速获取到最大的和最小的值。

可以认为优先级队列是一种修改过的普通队列:普通队列依据记录插入的时间来获取下一个记录,而优先级队列依据优先级来获取下一个记录,优先级取决于排序字段的值。

优先级队列常用来解决调度问题,比如给紧急的任务更高的优先级。以操作系统的任务调度为例:高优先级的任务(比如实时游戏)应该先于低优先级的任务(比如后台下载软件更新)执行。

调用queue.PriorityQueue

在 Python 中,内置的标准库提供了两种实现优先队列的数据结构,分别是 heapq 模块和 PriorityQueue 模块,

最小优先级队列

更小的值具有更高的优先级,也就是会被最先输出

# 优先级队列
from queue import PriorityQueue as PQ
Pqueue = PQ()
Pqueue.put((1, 'a'))
Pqueue.put((3, 'c'))
Pqueue.put((2, 'b'))
Pqueue.put((2, 'd'))
Pqueue.put((5, 'e'))
print(Pqueue.queue)  # [(1, 'a'), (2, 'd'), (2, 'b'), (3, 'c'), (5, 'e')]
while not Pqueue.empty():
    print(Pqueue.get())
# (1, 'a')
# (2, 'b')
# (2, 'd')
# (3, 'c')
# (5, 'e')

最大优先级队列

更大的值具有更高的优先级,也就是会被最先输出。

from queue import PriorityQueue as PQ
Pqueue = PQ()
Pqueue.put((-1, 'a'))
Pqueue.put((-3, 'c'))
Pqueue.put((-2, 'b'))
Pqueue.put((-2, 'd'))
Pqueue.put((-5, 'e'))
print(Pqueue.queue)  # [(-5, 'e'), (-3, 'c'), (-2, 'b'), (-1, 'a'), (-2, 'd')]
while not Pqueue.empty():
    print(Pqueue.get())
# (-5, 'e')
# (-3, 'c')
# (-2, 'b')
# (-2, 'd') 当两个对象的优先级一致时,按照插入顺序排列
# (-1, 'a')

基于 heapq 实现

heapq 涉及到另一种数据结构“堆”,用heapq 实现优先级队列,也是基于最小堆,最大堆实现,这些在后面“堆”再一起研究下。

import heapq
class PriorityQueue(object):
    def __init__(self):
        self._queue = []
        # self._index = 0
    def push(self, item, priority):
        """
        队列由 (priority, index, item) 形式组成
        priority 默认是最小优先级,增加 "-" 实现最大优先级,
        index 是为了当两个对象的优先级一致时,按照插入顺序排列
        """
        heapq.heappush(self._queue, (-priority, item))
        # self._index += 1
    def pop(self):
        """
        弹出优先级最高的对象
        """
        return heapq.heappop(self._queue)[-1]
    def qsize(self):
        return len(self._queue)
    def empty(self):
        return True if not self._queue else False
if __name__ == '__main__':
    PQueue = PriorityQueue()
    PQueue.push('a', 1)
    PQueue.push('c', 3)
    PQueue.push('b', 2)
    PQueue.push('d', 2)
    PQueue.push('e', 5)
    PQueue.push('f', 1)
    while not PQueue.empty():
        print(PQueue.pop())    # e c b d a f

5,循环队列

在之前实现的队列时,都为固定队列长度,都创建无限队列,当队列空间有限时,插入和删除元素会有问题呢?

假定用长度为6的数组,表示长度为6的队列。队列中已经有三个元素a1、a2、a3。

如果新插入元素,只需要在队尾插入便可,在下标3的位置插入新元素a4,入队列的时间复杂度O(1)。

如果删除元素,当a1出队列后,其后面的a2、a3、a4则需要向前移动一个位置,就好日常排队时,当前面人离开,后面的队伍都往前移动一步,所以出队列的时间复杂度为O(n)。

这种效率显然是不可以接受的,那么能不能不让所有成员都往前挪一位呢?

所以在原来的基础上,加入两个变量front、rear分别存储队头和队尾的下标。

此时front =0 ,rear = 3。

当有新元素插入队尾时,rear = rear+1。

当有元素出队列时,front = front + 1

这样一来,似乎不将后面所有成员往前挪,只需维护一下front的指向(front += 1)就可以保证队首,但是,当遇到下面这情况时,就存在“假溢出”的情况。

将a2、a3都出队列,此时front = 3,在将a6插入队列,此时rear = 6。

此时,队列长度为3,队列未满,再将a7插入队列时,就会报错数组越界,但是此时数组空间未满,前面0、1、2都空着,这种现象称为“假溢出”。

虽然这种方法不用移动元素,但是却造成空间上的浪费。可以看出此时数组是还有空间去容纳新元素a7的,因此我们需要将前面浪费的空间重新利用起来,减少空间的浪费,这就是循环队列的意义所在了。

1.循环队列包括两个指针(其实就是两个整数型变量,因为在这里有指示作用,所以这里理解为指针), front 指针指向队头元素, rear 指针指向队尾元素的下一个位置。

2.rear和front互相追赶着,这个追赶过程就是队列添加和删除的过程,如果rear追到head说明队列满了,如果front追到rear说明队列为空。

3,rear和front位置的移动,关键在于% (取模运算),这样就防止rear和front 超过maxsize。

网上最常看到的实现代码

class SqQueue(object):
    def __init__(self, maxsize):
        self.queue = [None] * maxsize
        self.maxsize = maxsize
        self.front = 0
        self.rear = 0
    # 返回当前队列的长度
    def QueueLength(self):
        return (self.rear - self.front + self.maxsize) % self.maxsize
    # 如果队列未满,则在队尾插入元素,时间复杂度O(1)
    def EnQueue(self, data):
        if (self.rear + 1) % self.maxsize == self.front:
            print("The queue is full!")
        else:
            self.queue[self.rear] = data
           # self.queue.insert(self.rear,data)
            self.rear = (self.rear + 1) % self.maxsize
    # 如果队列不为空,则删除队头的元素,时间复杂度O(1)
    def DeQueue(self):
        if self.rear == self.front:
            print("The queue is empty!")
        else:
            data = self.queue[self.front]
            self.queue[self.front] = None
            self.front = (self.front + 1) % self.maxsize
            return data
    # 输出队列中的元素
    def ShowQueue(self):
        for i in range(self.maxsize):
            print(self.queue[i],end=',')
        print(' ')

这有个bug,由于 self.rear = (self.rear + 1) % self.maxsize 这会造成一个空间的浪费!! 可以运行下代码看看。

所以自己写了一段代码,直接使用现有元素个数cnt 与 maxsize 比较来判断是否为空?是否已满?

class CycleQueue(object):
    def __init__(self, maxsize):
        self.queue = [None] * maxsize
        self.maxsize = maxsize
        self.front = 0
        self.rear = 0
        self.cnt = 0
    def is_empty(self):
        return self.cnt == 0
    def is_full(self):
        return self.cnt == self.maxsize
    def push(self, val):
        if self.is_full():
            print("The queue is full!")
            return
        if self.is_empty():
            self.queue[self.rear] = val
            self.cnt += 1
        else:
            self.rear = (self.rear + 1) % self.maxsize
            self.queue[self.rear] = val
            self.cnt += 1
    def pop(self):
        if self.is_empty():
            print("The queue is empty!")
            return
        val = self.queue[self.front]
        self.queue[self.front] = None
        self.front = (self.front + 1) % self.maxsize
        self.cnt -= 1
        return val
    def travel(self):
        travel_list = [self.queue[(self.front + i) % self.maxsize] for i in range(self.cnt)]
        print(travel_list)
    def size(self):
        return self.cnt
if __name__ == '__main__':
    CycleQueue = CycleQueue(6)
    CycleQueue.push('a1')
    CycleQueue.push('a2')
    CycleQueue.push('a3')
    CycleQueue.push('a4')
    CycleQueue.push('a5')
    CycleQueue.travel()  # ['a1', 'a2', 'a3', 'a4', 'a5']
    CycleQueue.push('a6')
    CycleQueue.travel()  # ['a1', 'a2', 'a3', 'a4', 'a5', 'a6']
    CycleQueue.pop()
    CycleQueue.push('a7')
    CycleQueue.travel()  # ['a2', 'a3', 'a4', 'a5', 'a6', 'a7']
    CycleQueue.pop()
    CycleQueue.pop()
    CycleQueue.push('a8')
    CycleQueue.travel()  # ['a4', 'a5', 'a6', 'a7', 'a8']

到此这篇关于Python常用队列全面详细梳理的文章就介绍到这了,更多相关Python常用队列内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python全栈之队列详解

    目录 1. lock互斥锁 2. 事件_红绿灯效果 2.1 信号量_semaphore 2.2 事件_红绿灯效果 3. queue进程队列 4. 生产者消费者模型 5. joinablequeue队列使用 6. 总结 1. lock互斥锁 知识点: lock.acquire()# 上锁 lock.release()# 解锁 #同一时间允许一个进程上一把锁 就是Lock 加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改,没错,速度是慢了,但牺牲速度却保证了数据

  • Python线程之线程安全的队列Queue

    目录 一.什么是队列? 二.队列基操入队/出队/查队列状态 三.Queue是一个线程安全的类 一.什么是队列? 像排队一样,从头到尾排成一排,还可以有人继续往后排队,这就是队列. 这里学委想说的是Queue这个类, 它是queue这个内置模块内的一个类. import queue q = queue.Queue(5) #可以传入参数指定队列大小 queue.Queue()# 不传或者给0或者<0的数字则创建一个无限长度的队列 它提供了很多函数,下面几个函数,我们使用的比较多: get: 获取并移

  • Python实现线程池之线程安全队列

    目录 一.线程池组成 二.线程安全队列的实现 三.测试逻辑 3.1.测试阻塞逻辑 3.2.测试读写加锁逻辑 本文实例为大家分享了Python实现线程池之线程安全队列的具体代码,供大家参考,具体内容如下 一.线程池组成 一个完整的线程池由下面几部分组成,线程安全队列.任务对象.线程处理对象.线程池对象.其中一个线程安全的队列是实现线程池和任务队列的基础,本节我们通过threading包中的互斥量threading.Lock()和条件变量threading.Condition()来实现一个简单的.读

  • Python 队列Queue和PriorityQueue解析

    目录 Python 队列Queue和PriorityQueue Python的Queue模块 优先级队列PriorityQueue的特点 python 实现一个优先级队列 python 优先队列PriorityQueue 下面是具体的例子 Python 队列Queue和PriorityQueue Python的Queue模块 适用于多线程编程的FIFO实现.它可用于在生产者(producer)和消费者(consumer)之间线程安全(thread-safe)地传递消息或其它数据,因此多个线程可以

  • Python中的优先队列(priority queue)和堆(heap)

    目录 队列和优先队列(Priority Queue) 堆(heap) 简介 初始化构建堆 堆的插入(节点上浮) 堆的删除(节点下浮) 堆的应用 队列和优先队列(Priority Queue) 队列是一种可以完成插入和删除的数据结构.普通队列是先进先出(FIFO), 即先插入的先被删除. 然而在某些时候我们需要按照任务的优先级顺序来决定出队列的顺序,这个时候就需要用到优先级队列了.优先队列是一种可以完成插入和删除最小元素的数据结构 python中有现成的优先队列类可以调用. 代码示例 from q

  • Python通过队列实现进程间通信详情

    目录 一.前言 二.队列简介 三.多进程队列的使用 四.使用队列在进程间通信 一.前言 在多进程中,每个进程之间是什么关系呢?其实每个进程都有自己的地址空间.内存.数据栈以及其他记录其运行状态的辅助数据.下面通过一个例子,验证一下进程之间能否直接共享信息. 定义一个全局变量g_num,分别创建2个子进程对g_num执行不同的操作,并输出操作后的结果. 代码如下: # _*_ coding:utf-8 _*_ from multiprocessing import Process def plus

  • Python数据结构之队列详解

    目录 0. 学习目标 1. 队列的基本概念 1.1 队列的基本概念 1.2 队列抽象数据类型 1.3 队列的应用场景 2. 队列的实现 2.1 顺序队列的实现 2.2 链队列的实现 2.3 队列的不同实现对比 3. 队列应用 3.1 顺序队列的应用 3.2 链队列的应用 3.3 利用队列基本操作实现复杂算法 0. 学习目标 栈和队列是在程序设计中常见的数据类型,从数据结构的角度来讲,栈和队列也是线性表,是操作受限的线性表,它们的基本操作是线性表操作的子集,但从数据类型的角度来讲,它们与线性表又有

  • Python 常用内置模块超详细梳理总结

    目录 time模块 time.sleep() time.time() time.localtime() time.strftime() datetime() random模块 random.random() random.randint() random.choice() random.shuffie() random.randrange() random.sample() json模块 json.loads() json.dumps() json.load() json.dump() OS模块

  • python 字典常用方法超详细梳理总结

    目录 1.字典的概念 2.字典的主要特征 3.创建字典的三种方法 4.字典常用方法 1.clear() 2.copy() 3.get() 4.keys() 5.values() 6.items() 7.del() 8.zip() 1.字典的概念 字典和列表类似,也是可变序列,不过和列表不同,它是无序的可变序列,保存的内容是以键值对(key:value)形式存放的 字典的每个键值之间用冒号:分隔,每个键值对之间用,隔开,整个字典包含在{ }中 dict = {key1:value1,key2:va

  • python 列表常用方法超详细梳理总结

    目录 列表是什么? 列表常用方法 1.append() 2.clear() 3.copy() 4.count() 5.extend() 6.index() 7.insert() 8.reverse() 9.remove() 10.pop() 11.sort() 列表是什么? 列表由一系列特定顺序排列的元素组成,你可以创建包含字母表中的所有字母.数字0~9.所有家庭成员姓名的列表等等,也可以将任何东西放入列表中,其中元素之间可以没有任何关系,鉴于列表通常包含多个元素,给列表指定一个表示复数的名称(

  • python 字符串常用方法超详细梳理总结

    目录 字符串是什么? 字符串常用方法 1.find() 2.index() 3.startswith() 4.endswith() 5.count() 6.join() 7.upper() 8.lower() 9.split() 10.strip() 11.replace() python基础之字符串常用方法 持续更新python基础知识,欢迎各位来访~

  • 你需要掌握的20个Python常用技巧

    目录 1.字符串反转 2.每个单词的第一个字母大写 3.字符串查找唯一元素 4.重复打印字符串和列表n次 5.列表生成 6.变量交换 7.字符串拆分为子字符串列表 8.多个字符串组合为一个字符串 9.检测字符串是否为回文 10.统计列表中元素的次数 11.判断两个字符串是否为Anagrams 12.使用try-except-else-block模块 13.使用枚举函数得到key/value对 14.检查对象的内存使用情况 15.合并字典 16.计算执行一段代码所花费的时间 17.列表展开 18.

  • python常用知识梳理(必看篇)

    接触python已有一段时间了,下面针对python基础知识的使用做一完整梳理: 1)避免'\n'等特殊字符的两种方式: a)利用转义字符'\' b)利用原始字符'r' print r'c:\now' 2)单行注释,使用一个#,如: #hello Python 多行注释,使用三个单引号(或三个双引号),如: '''hello python hello world''' 或 """hello python hello world""" 另外跨越多行

  • python常用数据结构字典梳理

    目录 dict字典 字典定义与使用 字典使用:创建 字典使用:访问元素 字典使用:操作元素 字典使用:嵌套字典 字典常用方法 values() items() values() get() update() pop() 字典推导式 dict字典 字典定义与使用 字典的定义: 字典是无序的键值对集合 字典用大括号{}包围 每个键/值对之间用一个逗号分隔 各个键与值之间用一个冒号分隔 字典是动态的 字典使用:创建 创建字典: --使用大括号填充键值对 --通过构造方法dict() --使用字典推导式

  • python常用排序算法的实现代码

    这篇文章主要介绍了python常用排序算法的实现代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 排序是计算机语言需要实现的基本算法之一,有序的数据结构会带来效率上的极大提升. 1.插入排序 插入排序默认当前被插入的序列是有序的,新元素插入到应该插入的位置,使得新序列仍然有序. def insertion_sort(old_list): n=len(old_list) k=0 for i in range(1,n): temp=old_lis

  • python 常用的异步框架汇总整理

    目录 正文开始 1. Tornado 2. Aiohttp 3.Sanic 4. FastAPI 5. Ruia 总结 参考资料 正文开始 asyncio 是 Python 3.4版本引入的标准库,直接内置了对异步IO的支持. asyncio 在单线程内部维护了 EventLoop 队列,然后把需要执行异步IO的任务添加到 EventLoop 队列中,至于任务的完成通过类似回调的逻辑是实现后续的任务.如果你有 JavaScript的基础那么理解python的 asyncio 很简单,关键字.语法

  • Python3 queue队列模块详细介绍

    queue介绍 queue是python中的标准库,俗称队列. 在python中,多个线程之间的数据是共享的,多个线程进行数据交换的时候,不能够保证数据的安全性和一致性,所以当多个线程需要进行数据交换的时候,队列就出现了,队列可以完美解决线程间的数据交换,保证线程间数据的安全性和一致性. 注意: 在python2.x中,模块名为Queue queue模块有三种队列及构造函数 Python queue模块的FIFO队列先进先出. queue.Queue(maxsize) LIFO类似于堆,即先进后

随机推荐

其他