Utilize help para pesquisar cinco funções utilizadas nesta lista e descreva brevemente o que cada uma faz.

Passo 1

O que o enunciado pede: usar o recurso de ajuda (help) para pesquisar cinco funções “utilizadas nesta lista” e descrever brevemente o que cada uma faz. Vou interpretar “funções utilizadas numa lista” como os métodos mais comuns do tipo list em Python. Vou pesquisar e explicar cinco métodos muito usados: append, extend, insert, pop e sort.
Informações relevantes que já tenho (não precisei perguntar nada):
  • A tarefa é descritiva: mostrar o que cada função faz e como usá-la.
  • Vou explicar também como usar o help() para obter essa informação interativamente em Python.

Passo 2

Como usar o help() em Python para pesquisar uma função de lista (mini aula prática):
  • Abra um terminal Python (interpreter) ou um notebook (ex.: IPython, Jupyter).
  • Para ver a documentação de um método de lista, execute help(list.metodo) ou help(list).
    • Exemplo: digitar help(list.append) mostra a assinatura e a docstring de append.
  • Alternativas: help('list.append') ou help(list) mostram informação semelhante.
  • O help() mostra:
    • A assinatura (como chamar: parâmetros e valores padrão).
    • Uma descrição curta do que o método faz.
    • Observações sobre valores de retorno ou exceções.
  • Dica prática: use help() quando estiver em dúvida sobre comportamento (por exemplo se o método retorna algo ou modifica a lista in-place).

Passo 3

Método append
  • O que faz: adiciona um único elemento ao final da lista.
  • Assinatura típica mostrada pelo help: append(self, object, /) -> None (ou em termos simples: list.append(x)).
  • Comportamento: modifica a própria lista; não cria nova lista; sempre adiciona o objeto como um único elemento.
  • Retorno: None — isso é importante: append age por efeito colateral (in-place) e não retorna a lista. Se fizer a = b.append(x), a será None.
  • Exemplo:
    • lst = [1, 2]
    • lst.append(3) resulta em lst == [1, 2, 3]
    • lst.append([4,5]) resulta em lst == [1, 2, 3, [4,5]] (note que a lista [4,5] vira um único elemento).
  • Complexidade: amortizada O(1) para adicionar no final.

Passo 4

Método extend
  • O que faz: estende a lista adicionando cada elemento de um iterável ao final.
  • Assinatura típica mostrada pelo help: extend(self, iterable, /) -> None.
  • Comportamento: espera um iterável (outra lista, tupla, string, etc.) e itera sobre ele, adicionando cada item separadamente ao final da lista original.
  • Diferença crucial para append: append(x) adiciona x como um único item; extend(iterable) concatena os elementos de iterable um a um.
  • Exemplo:
    • lst = [1, 2]
    • lst.extend([3, 4]) resulta em lst == [1, 2, 3, 4]
    • lst.extend('ab') resulta em lst == [1, 2, 3, 4, 'a', 'b']
  • Retorno: None (é in-place).
  • Complexidade: O(k) onde k é o tamanho do iterável que está sendo adicionado (mais o custo de possíveis realocações).

Passo 5

Método insert
  • O que faz: insere um elemento numa posição específica da lista, deslocando os elementos subsequentes para a direita.
  • Assinatura típica mostrada pelo help: insert(self, index, object, /) -> None (ou seja: list.insert(i, x)).
  • Comportamento:
    • i é o índice antes do qual inserir. Se i for 0, insere no começo. Se i for maior que o comprimento, insere no final.
    • Índices negativos são permitidos e contam a partir do fim (mas comportamento para índices muito negativos é inserir no início).
  • Exemplo:
    • lst = [1, 3]
    • lst.insert(1, 2) resulta em lst == [1, 2, 3]
  • Retorno: None (modifica a lista in-place).
  • Cuidado: inserir em posições intermediárias tem custo O(n) por causa do deslocamento dos elementos; use quando necessário, mas para muitas inserções no meio pode ser ineficiente.

Passo 6

Método pop
  • O que faz: remove e retorna o elemento na posição dada; por padrão remove e retorna o último elemento.
  • Assinatura típica mostrada pelo help: pop(self, index=-1, /) -> value (ou seja: list.pop([i])).
  • Comportamento:
    • Se nenhum índice for passado, pop() remove o último elemento.
    • Se passar i, remove o elemento no índice i.
    • Retorna o valor removido, ao contrário de append/extend/insert que retornam None.
    • Se a lista estiver vazia e pop() for chamado sem argumento, é levantada uma exceção IndexError.
  • Exemplo:
    • lst = [10, 20, 30]
    • x = lst.pop()x == 30, lst == [10, 20]
    • y = lst.pop(0)y == 10, lst == [20]
  • Complexidade: pop() sem índice (final) é O(1); pop(i) com i arbitrário é O(n) por causa do deslocamento.

Passo 7

Método sort
  • O que faz: ordena os elementos da lista in-place (modifica a lista) usando um algoritmo estável (Timsort).
  • Assinatura típica mostrada pelo help: sort(self, /, *, key=None, reverse=False) -> None (ou seja: list.sort(key=None, reverse=False)).
  • Parâmetros importantes:
    • key: função de um argumento que transforma cada elemento antes da comparação (ex.: key=str.lower), muito útil para controlar ordenação.
    • reverse: se True, ordena em ordem decrescente.
  • Comportamento:
    • Modifica a lista original e retorna None (não retorna a lista ordenada).
    • Para obter uma nova lista ordenada sem alterar a original, use sorted(lista).
  • Exemplo:
    • lst = [3, 1, 2]
    • lst.sort()lst == [1, 2, 3]
    • lst.sort(reverse=True)lst == [3, 2, 1]
    • words.sort(key=len) ordena pelas comprimentos das palavras.
  • Complexidade: O(n log n) no caso médio/ótimo; estável (mantém ordem relativa de elementos equivalentes).

Passo 8

Dicas finais (como lembrar na prova e armadilhas comuns)
  • Sempre lembre: métodos que modificam a lista in-place (append, extend, insert, sort) retornam None. Não faça lst = lst.append(x) — isso quebra lst.
  • Use pop() quando precisar do valor removido; prefira pop() sem índice para eficiência ao remover o último.
  • Use extend() para concatenar elementos de outro iterável; use append() para adicionar um único item (mesmo que esse item seja outra lista).
  • Para ordenar e preservar a original, use sorted(); para ordenar em si mesma e aproveitar performance/outras opções use list.sort(key=..., reverse=...).
  • Se estiver em dúvida, abra o Python e rode help(list.metodo) — o help() é teu amigo.

Resposta

list.append: adiciona um único elemento ao final da lista (modifica in-place, retorna None).
list.extend: adiciona cada elemento de um iterável ao final da lista (modifica in-place, retorna None).
list.insert: insere um elemento numa posição dada deslocando os demais (modifica in-place, retorna None).
list.pop: remove e retorna o elemento no índice dado; por padrão remove e retorna o último (levanta IndexError se vazia).
list.sort: ordena a lista in-place (aceita parâmetros key e reverse; retorna None; algoritmo estável).

Exercícios relacionados