O Python não possui uma estrutura de dados de matriz circular embutida. No entanto, você pode implementar com eficiência um usando uma lista de Python padrão e o operador Modulo (`%`). Aqui estão duas abordagens:

Método 1:Usando uma lista e operador de módulo

Este método é o mais direto e geralmente o mais eficiente. Ele usa o operador Modulo para envolver os índices da matriz.

`` `Python
Classe CircularRay:
def __init __ (auto, capacidade):
self.capacity =Capacidade
self.array =[Nenhum] * capacidade
self.head =0
self.size =0

def is_empty (self):
retornar self.size ==0

def is_full (self):
return self.size ==self.capacidade

Def Enqueue (self, item):
se self.is_full ():
Raise IndexError ("Array circular está cheio")
self.array [(self.head + self.size) % self.capacity] =item
self.size +=1

def dequeue (self):
se self.is_empty ():
Raise IndexError ("Array circular está vazio")
item =self.array [self.head]
self.head =(self.head + 1) % self.capacidade
self.size -=1
Item de retorno

Def Peek (self):
se self.is_empty ():
Raise IndexError ("Array circular está vazio")
retornar self.array [self.head]

def __len __ (self):
retornar self.size

def __str __ (self):
retornar str (self.array)

#Exemplo Uso
Circular_array =CircularArray (5)
circular_array.enqueue (10)
circular_array.enqueue (20)
circular_array.enqueue (30)
Imprimir (circular_array) # saída:[10, 20, 30, nenhum, nenhum]
Print (circular_array.dequeue ()) # saída:10
Imprimir (circular_array) # saída:[Nenhum, 20, 30, nenhum, nenhum]
circular_array.enqueue (40)
circular_array.enqueue (50)
Imprimir (circular_array) # saída:[Nenhum, 20, 30, 40, 50]
print (circular_array.is_full ()) # saída:true
`` `

Método 2:Usando `coleta.deque` (para uma implementação mais simples, mas potencialmente menos eficiente para grandes matrizes)

O `Coleções.deque 'do Python fornece uma fila de ponta dupla, que pode ser usada para imitar uma matriz circular. É mais simples de implementar, mas pode ser menos eficiente para matrizes muito grandes em comparação com a abordagem direta baseada na lista devido à sobrecarga.

`` `Python
De coleções importantes deque

Classe CircularArrayDeque:
def __init __ (auto, capacidade):
self.capacity =Capacidade
self.array =deque (maxlen =capacidade)

def is_empty (self):
retornar Len (self.array) ==0

def is_full (self):
retornar Len (self.array) ==self.capacidade

Def Enqueue (self, item):
se self.is_full ():
Raise IndexError ("Array circular está cheio")
self.array.append (item)

def dequeue (self):
se self.is_empty ():
Raise IndexError ("Array circular está vazio")
retornar self.array.popleft ()

Def Peek (self):
se self.is_empty ():
Raise IndexError ("Array circular está vazio")
retornar self.array [0]

def __len __ (self):
Retorne Len (self.array)

def __str __ (self):
Return str (list (self.array))

#Exemplo Uso (o mesmo que acima, apenas substitua o CircularArray por CircularArrayDeque)
`` `

Qual método escolher?

Para a maioria dos casos, Método 1 (usando uma lista e operador de módulo) é recomendado devido ao seu desempenho geralmente melhor, especialmente para matrizes maiores. `Coleções.deque` é uma boa opção se a simplicidade e a legibilidade forem priorizadas em relação ao desempenho bruto, e o tamanho da matriz não for extremamente grande. Se você estiver trabalhando com matrizes verdadeiramente massivas, considere usar matrizes Numpy para obter mais ganhos de desempenho, embora isso acrescente um nível diferente de complexidade.