Como excluir um nó na posição n de uma lista singularmente encadeada em Python

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# classe No para uma lista singularmente encadeada ou
# ligada - Singly Linked List
class No:
  # construtor da classe No
  def __init__(self, info, proximo):
    self.info = info
    self.proximo = proximo

  # método que permite definir o conteúdo do nó
  def set_info(self, info):
    self.info = info

  # método que permite obter a informação de um nó 
  def get_info(self):
    return self.info

  # método que permite definir o campo próximo deste nó
  def set_proximo(self, proximo):
    self.proximo = proximo

  # método que permite obter o campo próximo deste nó
  def get_proximo(self):
    return self.proximo

  # retorna True se este nó apontar para outro nó
  def possui_proximo(self):
    return self.proximo != None

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# importa a classe No
from no_lista_singularmente_ligada import No

# classe ListaLigadaSimples   
class ListaLigadaSimples:
  # construtor da classe
  def __init__(self):
    self.inicio = None # nó inicial da lista

  # método que permite retornar o tamanho da lista ligada, ou
  # seja, a quantidade de nós na lista encadeada simples
  def get_tamanho(self):
    # aponta para o início da lista
    no_atual = self.inicio
    # ajusta o contador em 0
    contador = 0
    # percorre todos os nós da lista ligada
    while no_atual != None:
      # incrementa o contador
      contador = contador + 1
      # avança para o próximo nó da lista
      no_atual = no_atual.get_proximo()
 
    # retornamos a quantidade de nós
    return contador

  # método que permite excluir um novo nó no meio de uma lista ligada,
  # ou seja, em qualquer posição da lista encadeada ou, melhor ainda,
  # em uma posição n da lista
  def remover_posicao_n(self, pos):
    # a lista está vazia?
    if self.inicio is None:
      return None
    
    # posição inválida?  
    if pos > (self.get_tamanho() - 1) or pos < 0:
      return None
    
    # se o índice for zero nós temos que remover no
    # início da lista  
    if pos == 0:
      return self.remover_inicio()
    elif pos == (self.get_tamanho() - 1):
      # se o índice for igual ao último nó da lista
      return self.remover_final()
    else:
      # contador de nós  
      contador = 0
      # referencia o nó inicial da lista
      no_atual = self.inicio
      # referencia o nó anterior
      no_anterior = self.inicio
      # temp vai sempre guardar o próximo do nó atual
      temp = self.inicio
      
      # enquanto o nó atual for diferente de nulo
      while no_atual != None:
        # estamos na posição correta?  
        if contador == pos:
          temp = no_atual.get_proximo()
          break
        
        no_anterior = no_atual
        no_atual = no_atual.get_proximo()
        contador = contador + 1
        
      # o nó anterior aponta para o nó antes apontado
      # pelo nó atual  
      no_anterior.set_proximo(temp)
      # retorna o nó removido
      return no_atual

  # método que deleta um nó no início de uma lista ligada
  # este método retorna o nó excluído
  def remover_inicio(self):
    # a lista está vazia?  
    if self.inicio == None:
      return None
    else:
      # vamos excluir e retornar o primeiro nó da lista
      removido = self.inicio
       
      # a lista possui apenas um nó?
      if self.inicio.get_proximo() == None:
        # a lista agora ficará vazia
        self.inicio = None
      else:
        # o segundo nó passa a ser o início da lista  
        self.inicio = self.inicio.get_proximo()  
 
    # retorna o nó removido
    return removido

  # método que deleta um nó no final de uma lista ligada
  # este método retorna o nó excluído
  def remover_final(self):
    # a lista está vazia?  
    if self.inicio == None:
      return None
    else:
      # vamos excluir e retornar o primeiro nó da lista
      removido = self.inicio
      
      # a lista possui apenas um nó?
      if self.inicio.get_proximo() == None:
        # a lista agora ficará vazia
        self.inicio = None
      else:
        # começamos apontando para o início da lista   
        no_atual = self.inicio
        no_anterior = self.inicio

        # enquanto o próximo do nó atual for diferente de nulo
        while no_atual.get_proximo() != None:
          # avançamos o nó anterior
          no_anterior = no_atual
          # saltamos para o próximo nó
          no_atual = no_atual.get_proximo()

        # na estamos na posição de exclusão
        removido = no_atual
        no_anterior.set_proximo(None)
    
    # retorna o nó removido
    return removido

  # método que permite inserir um novo nó no início da lista
  def inserir_inicio(self, info):
    # cria um novo nó contendo a informação e que
    # não aponta para nenhum outro nó
    novo_no = No(info, None)
    
    # a lista ainda está vazia?
    if self.inicio == None:
      # o novo nó será o início da lista  
      self.inicio = novo_no
    else:
      # o novo nó aponta para o início da lista
      novo_no.set_proximo(self.inicio)
      # o novo nó passa a ser o início da lista
      self.inicio = novo_no


  # método que permite exibir todos os nós da lista
  # ligada simples (lista singularmente encadeada)
  def exibir(self):
    # aponta para o início da lista
    no_atual = self.inicio
    # enquanto o nó não for nulo
    while no_atual != None:
      # exibe o conteúdo do nó atual  
      print(no_atual.get_info())
      # pula para o próximo nó
      no_atual = no_atual.get_proximo()

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# importa a classe ListaLigadaSimples
from lista_singularmente_ligada import ListaLigadaSimples

# método principal  
def main():
  # cria uma nova lista encadeada simples
  lista = ListaLigadaSimples()

  print("Vamos inserir varios valores na lista, sempre no início")
  lista.inserir_inicio(12)
  lista.inserir_inicio(30)
  lista.inserir_inicio(27)
  lista.inserir_inicio(84)
  lista.inserir_inicio(9)
  
  print("Conteúdo da lista: ")
  lista.exibir()

  print("Agora vamos excluir o nó no índice 2")
  removido = lista.remover_posicao_n(2)
  if removido == None:
    print("Lista vazia ou posição inválida")
  else:  
    print("Nó removido:", removido.get_info())
  
  print("Conteúdo da lista: ")
  lista.exibir()

if __name__== "__main__":
  main()