Listas e tuplas em Python

Uma lista mantém valores em uma ordem escolhida. Escreva os itens entre colchetes, com vírgulas entre eles. Cada item tem uma posição, portanto valores repetidos ainda ocupam lugares separados.

Crie e meça uma lista

scores = [88, 92, 75]
print(scores)
print(len(scores))

Saída:

[88, 92, 75]
3

len() conta itens, não o maior valor nem a última posição. Listas podem conter tipos diferentes, como em [3, "three", 3.0, True], embora manter dados relacionados juntos geralmente facilite o processamento. [] e list() criam uma lista vazia. Seu tamanho é 0, e ela pode crescer à medida que o programa reúne valores.

list() também pode reunir os itens de um iterável, um objeto que um laço for pode percorrer. list(range(4)) produz [0, 1, 2, 3]. list("cat") produz ['c', 'a', 't']: a string fornece um caractere por vez. O resultado é uma nova lista.

Conte posições a partir de zero

Um índice identifica uma posição. O Python começa em 0, portanto as três notas têm índices 0, 1 e 2.

Índices negativos contam para trás a partir do fim. Para uma lista de tamanho n, os índices válidos vão de -n até n - 1. O último item é scores[len(scores) - 1], ou, de forma mais simples, scores[-1]. -0 ainda é 0; não significa a última posição.

Reconheça um índice inválido

scores[3] lança IndexError porque não existe um quarto item. scores[len(scores)] comete o mesmo erro: a contagem é uma unidade maior que o último índice não negativo. Uma lista vazia não tem índice de item válido, nem mesmo -1.

Um índice de lista deve ser um inteiro, não um número de ponto flutuante. scores[1.0] lança TypeError, embora 1,0 tenha um valor inteiro. / produz um número de ponto flutuante, portanto scores[len(scores) / 2] também falha. Com essa lista de três itens, len(scores) // 2 produz o inteiro 1, e scores[1] é 92.

Verifique se um valor aparece

O teste de pertencimento verifica valores, não posições:

colors = ["red", "green"]
print("green" in colors)
print("Green" in colors)
print("blue" not in colors)

Saída:

True
False
True

in e not in retornam valores booleanos e também funcionam em listas vazias. Comparações de strings distinguem maiúsculas de minúsculas, portanto "Green" e "green" não correspondem. Um teste de pertencimento é útil antes de uma operação que exige que um valor esteja presente, como removê-lo ou encontrar sua posição.

Uma fatia seleciona uma sequência de itens e retorna uma nova sequência. Para uma lista, o resultado é outra lista, mesmo quando ela contém apenas um item ou nenhum.

Inclua o início e exclua o limite de parada

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1:4])

Saída:

['b', 'c', 'd']

As posições selecionadas são 1, 2 e 3. A posição 4 é o limite de parada, portanto 'e' fica de fora. Com passo 1 e limites que atendem a 0 <= start <= stop <= len(letters), o número de itens selecionados é stop - start. Aqui são 3. letters[4:2] produz [] porque uma fatia percorrida para a frente não alcança um limite de parada anterior.

Omita um limite

Limites negativos contam a partir do fim, assim como índices negativos. letters[:n] e letters[n:] dividem a lista em um limite. Juntar essas duas fatias reconstrói seu conteúdo na ordem original.

Controle o passo

A forma completa é values[start:stop:step]. Um passo de 2 seleciona uma posição, pula uma e seleciona a próxima. letters[::2] produz ['a', 'c', 'e'], enquanto letters[1::2] produz ['b', 'd', 'f'].

Um passo negativo percorre para trás. letters[::-1] começa no último item e produz ['f', 'e', 'd', 'c', 'b', 'a']. Para uma fatia com limites percorrida para trás, letters[4:1:-1] visita os índices 4, 3 e 2, produzindo ['e', 'd', 'c']; o limite de parada continua excluído. Um passo 0 lança ValueError porque não permite avançar para outra posição.

Distinga um limite de uma posição

Os limites de uma fatia podem ultrapassar qualquer extremidade. O Python os ajusta: letters[4:100] é ['e', 'f'], e letters[10:] é []. Essas fatias não lançam IndexError. Ler o item individual letters[10] lança esse erro.

letters[2] é a string 'c'. letters[2:3] é a lista ['c']. Os dois-pontos alteram o tipo de resultado, o que importa quando o código posterior espera uma string ou uma lista.

Trabalhe com o resultado

Após first_three = letters[:3], a atribuição first_three[0] = "z" altera apenas essa nova lista externa; letters[0] continua sendo 'a'. Uma fatia completa é uma cópia superficial, portanto itens mutáveis aninhados ainda podem ser compartilhados.

Strings e tuplas seguem as mesmas regras de limites e passos. O resultado mantém o tipo da sequência original: "python"[1:4] produz 'yth', e (10, 20, 30)[1:] produz (20, 30).

Listas oferecem operadores para criar sequências e funções para resumir seus valores. Verifique se uma operação cria uma nova lista, produz um número ou retorna texto: esses resultados servem a propósitos diferentes.

Una ou repita listas

+ une duas listas e cria uma nova lista. [1, 2] + [3] produz [1, 2, 3] sem alterar nenhuma das entradas. Ambos os operandos devem ser listas: [1, 2] + 3 lança TypeError. Coloque um valor extra individual em uma lista de um item ao usar +.

* repete a sequência. [0] * 4 produz [0, 0, 0, 0], e ["ab", "cd"] * 2 produz ['ab', 'cd', 'ab', 'cd']. Ele repete itens, não os caracteres dentro de cada string. Uma contagem de repetição zero ou negativa produz []. counts = [0] * 7 fornece sete contadores iniciais. Repetir uma lista interna a compartilha entre posições, o que importa quando essas linhas são alteradas depois.

Total, extremos e média

sum() soma números. Ela não une strings; sum(["a", "b"]) lança TypeError. min() e max() encontram os menores e maiores itens, portanto os itens devem aceitar comparação entre si. Listas compostas apenas de strings funcionam: max(["pear", "apple"]) produz 'pear' pela ordenação caractere por caractere. Uma lista vazia não tem mínimo nem máximo e lança ValueError em qualquer uma das chamadas.

A média aritmética é o total dividido pelo número de itens:

temps = [18.5, 21.0, 19.5, 23.0]
if temps:
    total = sum(temps)
    mean = total / len(temps)
    print(total, mean)

Saída:

82.0 20.5

A condição funciona porque listas vazias são consideradas falsas e listas não vazias são consideradas verdadeiras. Sem a verificação de proteção, calcular a média de [] dividiria por zero e lançaria ZeroDivisionError. Escolha o que o programa deve fazer quando não houver medições, como retornar None.

Compare sequências em ordem

== verifica se há itens iguais em posições correspondentes. [1, 2, 3] == [1, 2, 3] é True; [1, 2, 3] == [3, 2, 1] é False.

Para < e >, compare da esquerda para a direita e pare no primeiro par diferente. [2, 9] < [3, 0] é True porque 2 é menor que 3. O 9 e o 0 não decidem nada. Quando uma lista é o início de outra, a mais curta vem primeiro: [2] < [2, 0] é True.

Passe de texto para listas e vice-versa

colors = "red,green,blue".split(",")
print(colors)
print(", ".join(["red", "green"]))

Saída:

['red', 'green', 'blue']
red, green

split() divide uma string em seu separador. join() é chamado sobre o separador e o coloca entre as strings fornecidas. Cada item deve ser uma string. Para juntar números, crie primeiro uma lista dos resultados de str(); passar [1, 2] diretamente a join() lança TypeError.

Listas são mutáveis: um programa pode alterar seu conteúdo depois de criá-las. Um método pertence a um objeto e é chamado com um ponto, como em cart.append("eggs"). Seu efeito sobre a lista e seu valor de retorno são duas coisas distintas.

Adicione um item ou vários

cart = ["milk"]
cart.append("eggs")
cart.extend(["tea", "jam"])
print(cart)

Saída:

['milk', 'eggs', 'tea', 'jam']

append(x) adiciona exatamente um item ao final. Se x for uma lista, essa lista inteira se torna um item aninhado. Começando com ['milk', 'eggs'], cart.append(["tea", "jam"]) produz ['milk', 'eggs', ['tea', 'jam']], de tamanho 3.

extend(iterable) adiciona separadamente os itens fornecidos pelo iterável. Estender com ["tea", "jam"] faz o carrinho ter tamanho 4. Estender com "ab" adiciona 'a' e 'b' separadamente; acrescente a string para manter 'ab' como um item.

insert(i, x) adiciona um item antes da posição atual i. Após nums = [10, 30] e nums.insert(1, 20), a lista é [10, 20, 30]. Os itens seguintes são deslocados para a direita. insert(0, x) adiciona no início; um índice além do fim adiciona no final sem erro de índice.

Remova por posição ou valor

Com nums = [10, 20, 30], last = nums.pop() salva 30 e deixa [10, 20]. nums.pop(0) então retorna 10 e deixa [20]. Uma lista vazia ou uma posição inválida faz pop() lançar IndexError.

remove() recebe um valor. Com pets = ["cat", "dog", "cat"], pets.remove("cat") deixa ['dog', 'cat']. Apenas a primeira correspondência desaparece. Se o valor estiver ausente, remove() lança ValueError. Use um teste de pertencimento quando ele puder estar ausente. Para remover cada 'cat', use:

while "cat" in pets:
    pets.remove("cat")

Com [5, 0, 7], remove(0) remove o valor 0 e deixa [5, 7]; pop(0) remove o valor na posição 0, produzindo [0, 7]. O significado do argumento determina o método.

del pode excluir um intervalo: a partir de [5, 6, 7, 8], del nums[1] deixa [5, 7, 8], e del nums[0:2] deixa então [8]. clear() deixa a lista existente vazia.

Entenda o valor de retorno

append, extend, insert, remove e clear retornam None. Escreva cart.append("tea") em uma linha própria. Escrever cart = cart.append("tea") faz cart se referir a None; uma chamada posterior de cart.append("jam") lança AttributeError. Salve o resultado de um método apenas quando ele fornecer um valor necessário ao programa, como faz last = cart.pop().

Encontrar um valor, contá-lo e substituí-lo são operações diferentes. Use um teste de pertencimento quando precisar de uma resposta sim ou não, um método de busca quando precisar de uma posição e uma atribuição quando quiser que a lista mude.

Encontre a primeira posição correspondente

days = ["Mon", "Tue", "Wed", "Tue"]
print(days.index("Tue"))
print(days.index("Tue", 2))
print(days.count("Tue"))
print(days.count("Sun"))

Saída:

1
3
2
0

index(x) retorna a primeira posição que contém um valor igual a x. Seu argumento inicial opcional informa ao Python onde começar a busca. days.index("Tue", 2) ignora a correspondência na posição 1 e encontra a da posição 3. A resposta continua sendo um índice da lista inteira, não uma contagem a partir do novo ponto inicial.

index() lança ValueError quando o valor está ausente. Listas não têm um método find() que retorne -1. Se for esperado que um valor esteja ausente, teste primeiro o pertencimento:

if "Sun" in days:
    position = days.index("Sun")
    print(position)

Esse código não imprime nada porque 'Sun' está ausente. count(x) pode ser usado sem essa verificação de proteção: ele retorna 0 quando não há correspondências. Essas operações usam igualdade, portanto [1, 2.0].count(2) é 1. O texto ainda respeita maiúsculas e minúsculas: 'tue' não é igual a 'Tue'.

Substitua um item existente

prices = [4.5, 3.0, 7.25]
prices[1] = 3.5
print(prices)

Saída:

[4.5, 3.5, 7.25]

O antigo segundo valor é sobrescrito e o tamanho permanece 3. O índice deve existir: prices[3] = 1.0 lança IndexError. Para adicionar ao final, use append().

A substituição usa uma posição existente. A inserção cria uma posição extra antes da posição selecionada.

Substitua um intervalo com atribuição a fatia

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30, 40]
print(nums)
nums[0:2] = []
print(nums)

Saída:

[1, 20, 30, 40, 4, 5]
[30, 40, 4, 5]

A primeira atribuição substitui os dois itens nos índices 1 e 2 por três novos itens, aumentando a lista em um. Uma fatia contígua comum pode ser substituída por uma sequência menor ou maior. Atribuir [] exclui o intervalo selecionado. Isso altera a lista original; é diferente de ler uma fatia em uma nova variável.

Edite texto criando um novo texto

Uma string é imutável, portanto word = "cat" seguido de word[0] = "b" lança TypeError. Crie uma nova string com word = "b" + word[1:], ou crie uma lista de caracteres, altere-a e junte seus itens:

letters = list("cat")
letters[0] = "b"
word = "".join(letters)
print(word)

Saída:

bat

Um laço pode usar os valores de uma lista, suas posições ou ambos. Escolha a forma que forneça o que o corpo do laço precisa. Para alterar a lista, verifique também se a instrução altera um item ou apenas associa um nome local a outro valor.

Use os itens diretamente

for name in ["Ana", "Ben"]:
    print("Hi", name)

Saída:

Hi Ana
Hi Ben

O laço visita cada item em ordem. A cada passagem, name se refere ao item atual. Atribuir um valor diferente a name não substitui esse item na lista. Em for r in readings: r = 0, apenas o nome r muda.

Use posições para substituir itens

readings = [3, -1, 4, -5]
for i in range(len(readings)):
    if readings[i] < 0:
        readings[i] = 0
print(readings)

Saída:

[3, 0, 4, 0]

range(len(readings)) fornece 0, 1, 2 e 3. No índice 1, a condição é verdadeira, portanto a atribuição a item substitui -1. No índice 3, ela substitui -5. As medições positivas mantêm seus valores. Usar range(len(readings) + 1) também alcançaria o índice 4, que não existe.

Obtenha uma posição e um item juntos

enumerate() fornece pares. Desempacote cada par no cabeçalho do laço:

for i, name in enumerate(["Ana", "Ben"]):
    print(i, name)

Saída:

0 Ana
1 Ben

enumerate(names, start=1) fornece rótulos a partir de 1 para uma exibição numerada. Esses rótulos deixam de ser os índices da lista contados a partir de zero. Para visitar do último ao primeiro sem alterar a lista, use for item in reversed(names):. Para índices em ordem inversa, use range(len(names) - 1, -1, -1); uma lista de três itens produz 2, 1, 0.

Forme pares com duas listas

names = ["Ana", "Ben"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

Saída:

Ana 90
Ben 85

zip() forma pares com itens em posições correspondentes e para na entrada mais curta. Se todos os registros forem necessários, verifique os tamanhos antes de usá-lo; caso contrário, um nome final sem par será ignorado.

Controle um índice com while

Um laço while precisa de um índice inicial, uma verificação de limite e um passo:

i = 0
while i < len(readings):
    print(readings[i])
    i += 1

Esquecer o incremento impede que esse laço termine. Usar <= alcança len(readings) e causa IndexError.

Evite deslocar itens durante um laço for

Remover itens altera as posições dos que vêm depois. Com [1, 2, 2, 3], remover cada 2 encontrado enquanto percorre a mesma lista deixa [1, 2, 3]: o segundo 2 é deslocado para a posição recém-visitada. Percorra nums[:] se as remoções precisarem afetar a original, ou crie uma nova lista com os itens a manter. Adicionar itens à lista percorrida também pode fazer o laço se comportar de forma inesperada.

Muitos problemas com listas usam alguns padrões de laço reutilizáveis. Decida qual resultado o programa precisa, prepare esse resultado antes do laço e atualize-o à medida que cada item chega.

Acumule um total ou uma contagem

sales = [120, 75, 205, 50]
total = 0
for sale in sales:
    total += sale
print(total)

Saída:

450

O total acumulado passa a ser 120, 195, 400 e 450. Definir total = 0 dentro do laço apagaria o trabalho anterior a cada passagem. sum(sales) calcula esse total diretamente.

Um contador adiciona 1 para cada item que atende à condição, não o valor do item:

scores = [72, 45, 60, 88, 59]
passed = 0
for score in scores:
    if score >= 60:
        passed += 1
print(passed)

A saída é 3: 72, 60 e 88 atendem à condição. > 60 produziria 2 porque exclui exatamente 60. Mantenha a descrição do valor limiar e a comparação em concordância.

Encontre um extremo

Para uma lista não vazia, inicialize um máximo acumulado a partir de um item real:

temps = [-3, -8, -1, -5]
highest = temps[0]
for temp in temps[1:]:
    if temp > highest:
        highest = temp
print(highest)

A saída é -1. Começar em 0 manteria 0 incorretamente porque todas as medições são menores. Use < para encontrar o mínimo ou use as funções embutidas min() e max(). Verifique se a lista está vazia antes de acessar seu primeiro item.

Pare na primeira correspondência

values = [4, 0, -2, 5, -7]
position = -1
for i, value in enumerate(values):
    if value < 0:
        position = i
        break
print(position)

A saída é 2. -1 é um sinal escolhido para indicar ausência de correspondência; não o use como índice a menos que a busca tenha tido sucesso, pois ele também é um índice válido para o último item. break preserva a primeira posição correspondente. Sem ele, correspondências posteriores sobrescreveriam o resultado.

x in values testa um valor exato, e values.index(x) encontra sua primeira posição. Uma condição como “é negativo” precisa de uma busca baseada em condição, como o laço acima.

Filtre ou transforme

Um filtro mantém itens originais selecionados:

passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print(passing)

A saída é [72, 60, 88]; scores mantém todos os cinco itens. Uma transformação calcula um novo item a partir de cada item original:

nums = []
for text in ["3", "14", "15"]:
    nums.append(int(text))
print(nums, sum(nums))

A saída é [3, 14, 15] 32. A conversão acontece antes da adição; somar as strings originais falha.

Retorne um resultado reutilizável

def average(values):
    if not values:
        return None
    return sum(values) / len(values)

average([18.5, 21.0, 19.5, 23.0]) retorna 20.5. O caso vazio retorna None sem dividir por zero, e a função deixa a lista de entrada inalterada.

Uma lista aninhada é uma lista que contém outras listas. Uma tabela costuma usar uma lista interna por linha. Cada consulta seleciona um nível, portanto ler uma célula exige dois índices.

Selecione a linha e depois a célula

grid = [[1, 2, 3], [4, 5, 6]]
print(grid[1])
print(grid[1][2])
print(len(grid), len(grid[0]))

Saída:

[4, 5, 6]
6
2 3

grid[1] seleciona a segunda linha; [2] seleciona então o terceiro item dessa linha. len(grid) conta linhas, enquanto len(grid[0]) conta células na primeira linha. Essa tabela retangular tem seis células. grid[2][1] falha na primeira consulta porque a linha 2 não existe. Trocar as posições de linha e coluna pode selecionar a célula errada ou lançar IndexError.

Altere uma célula ou uma linha inteira

grid[0][1] = 20 altera a segunda célula da primeira linha, produzindo [[1, 20, 3], [4, 5, 6]]. grid[0] = [0, 0, 0] substitui a primeira linha inteira. O número de consultas mostra qual nível está sendo substituído.

Visite cada valor

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

Saída:

21

O laço interno conclui a primeira linha antes de o laço externo fornecer a segunda. Ele soma 1, 2, 3 e depois 4, 5, 6. O total de uma coluna usa uma posição fixa de cada linha:

column_total = 0
for row in grid:
    column_total += row[1]
print(column_total)

A saída é 7, obtida de 2 e 5. Esse código exige que cada linha tenha um segundo item.

As linhas não precisam ter o mesmo tamanho. [[1], [2, 3]] é uma lista aninhada válida. Laços aninhados diretos ainda visitam cada valor porque cada laço interno percorre sua própria linha. Supor que todas as linhas tenham len(grid[0]) itens deixaria de fora valores neste caso. Para contar células em uma tabela assim, some len(row) para cada linha.

Crie linhas independentes

table = []
for r in range(3):
    table.append([0] * 4)
table[0][0] = 1
print(table)

Saída:

[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Cada passagem cria uma nova lista de quatro itens. O atalho [[0] * 4] * 3 repete uma referência a uma linha; alterar sua primeira célula apareceria nas três linhas.

Armazene registros

Uma linha pode descrever um registro em vez de uma linha de números. Com students = [["Ana", 90], ["Ben", 85]], students[1][0] é 'Ben' e students[1][1] é 85. Quando cada registro tem dois itens, for name, score in students: os desempacota em nomes úteis. Listas de tuplas podem representar o mesmo tipo de registro.

Uma tupla armazena itens em ordem, como uma lista, mas suas posições não podem ser substituídas, adicionadas ou removidas. Isso é imutabilidade. Tuplas são adequadas para grupos fixos, como coordenadas, datas e registros; listas são adequadas para coleções que crescem ou mudam.

Crie e leia uma tupla

point = (3, 4)
date = (2024, 7, 15)
print(date[0])
print(date[1:])
print(len(date))

Saída:

2024
(7, 15)
3

A indexação de tuplas, os índices negativos, as fatias e os testes de pertencimento seguem as mesmas regras das listas. Uma fatia de tupla retorna uma tupla. Você pode percorrer uma tupla com um laço ou usar +, *, min, max, sum, count e index quando seus itens forem adequados à operação.

A vírgula cria uma tupla não vazia. t = 3, 4 cria (3, 4) mesmo sem parênteses. Uma tupla de um item precisa de uma vírgula final:

list(t) converte os itens de uma tupla em uma lista alterável.

Entenda o que não pode mudar

point[0] = 5 lança TypeError porque uma tupla não aceita atribuição a item. Tuplas não têm os métodos append, remove ou sort; point.append(5) lança AttributeError.

Um nome ainda pode ser associado a uma nova tupla:

point = (3, 4)
point = (5,) + point[1:]
print(point)

A saída é (5, 4). A expressão cria uma nova tupla; ela não edita a antiga.

Uma tupla pode conter um item mutável

t = ([1, 2], "x")
t[0].append(3)
print(t)

Saída:

([1, 2, 3], 'x')

A primeira posição ainda contém a mesma lista. O conteúdo dessa lista mudou. t[0] = [9] substituiria o objeto na posição e é proibido. A imutabilidade da tupla externa não congela uma lista interna.

Escolha a estrutura adequada à tarefa

Use (x, y) para uma coordenada, (255, 128, 0) para uma cor RGB ou ("Ana", 90) para um registro de dois campos. Cada posição tem um significado específico. Use uma lista para todas as notas da turma ou os itens de um carrinho, que podem crescer e ser reordenados. Uma lista de tuplas, como [("Ana", 90), ("Ben", 85)], combina uma coleção alterável com posições fixas nos registros.

Uma tupla de números ou strings pode servir como chave de dicionário, como em {(0, 0): "origin"}. As chaves devem ser hasháveis, ou seja, devem atender às regras do Python para consultas estáveis por chave. Uma lista não é hashável, e uma tupla que contém uma lista também não é hashável.

Compare tuplas

A comparação começa pela esquerda e para no primeiro par diferente. (1, 2, 5) < (1, 3, 0) é True: os primeiros valores são iguais, e 2 é menor que 3. Essa mesma regra ordena uma lista de registros em tuplas quando nenhuma função de chave é fornecida.

O empacotamento reúne valores em uma tupla. O desempacotamento atribui os itens de um iterável a nomes em ordem. Juntos, eles permitem que o código dê nomes claros aos campos de um registro e receba vários resultados de uma função.

Associe nomes a valores

record = "Ana", 34, "Lima"
name, age, city = record
print(name, age, city)

Saída:

Ana 34 Lima

O primeiro item se torna name, o segundo age e o terceiro city. O desempacotamento também funciona em listas e strings: first, second = [10, 20] e a, b, c = "xyz" atribuem seus itens em ordem. user, domain = "ana@example.com".split("@") produz 'ana' e 'example.com' porque a divisão produz duas partes.

Sem um nome com asterisco, as quantidades devem corresponder exatamente. x, y = (1, 2, 3) lança ValueError por excesso de valores; x, y, z = (1, 2) lança ValueError por falta de valores. O Python não descarta itens extras sem aviso.

Troque valores com segurança

a = 1
b = 2
a, b = b, a
print(a, b)

A saída é 2 1. O Python avalia todo o lado direito usando os valores antigos antes de atribuir qualquer nome à esquerda. A tentativa com duas instruções, a = b seguida de b = a, perde o valor antigo de a e faz ambos os nomes valerem 2.

Reúna os itens restantes

Um nome com asterisco recebe uma lista dos valores restantes:

first, *rest = [5, 6, 7, 8]
print(first, rest)
*init, last = [5, 6, 7, 8]
print(init, last)

Saída:

5 [6, 7, 8]
[5, 6, 7] 8

O asterisco também pode aparecer entre nomes sem asterisco: first, *middle, last = (5, 6, 7, 8) atribui a middle a lista [6, 7]. O objeto reunido é sempre uma lista, mesmo ao desempacotar uma tupla. head, *rest = [5] deixa rest como []. Deve haver itens suficientes para os nomes sem asterisco, e apenas um nome com asterisco é permitido no mesmo padrão de desempacotamento.

Desempacote durante um laço

for name, score in [("Ana", 90), ("Ben", 85)]:
    print(name, score)

Saída:

Ana 90
Ben 85

O cabeçalho desempacota cada registro à medida que ele chega. É assim também que for i, item in enumerate(values): e for a, b in zip(left, right): funcionam: cada iteração fornece um par.

Retorne vários resultados

def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9])
result = min_max([7, 2, 9])
print(low, high)
print(result)

Saída:

2 9
(2, 9)

A função retorna uma tupla. O código chamador pode desempacotá-la ou manter o objeto inteiro. Por convenção, um sublinhado nomeia um valor de que o código não precisa: _, month, day = (2024, 7, 15) mantém o mês e o dia sob nomes descritivos. _ continua sendo uma variável comum, não uma operação especial de descarte.

Uma variável é um nome que se refere a um objeto. A atribuição altera aquilo a que um nome se refere; ela não copia automaticamente o objeto. Com uma lista mutável, dois nomes podem, portanto, observar as mesmas alterações.

Acompanhe as referências

a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)

Saída:

[1, 2, 3, 4]
[1, 2, 3, 4]

Há uma lista e dois nomes para ela. b é uma referência alternativa (alias) de a. A operação de acréscimo altera o objeto compartilhado, portanto lê-lo por qualquer um dos nomes mostra o item adicionado. Desenhe duas setas, uma de cada nome, para a mesma lista ao rastrear esse código.

Distinga igualdade de identidade

a = [1, 2]
b = a
c = [1, 2]
print(a == b, a == c)
print(a is b, a is c)

Saída:

True True
True False

== compara conteúdos; is testa se os objetos são o mesmo objeto. c tem conteúdo igual, mas é uma lista separada. id(x) fornece o número de identidade de um objeto, portanto id(a) == id(b) concorda com a is b. Números de identidade não informam quais itens uma lista contém.

Use == para verificar se os conteúdos são iguais. Use is para verificar compartilhamento ou um objeto especial como None. Um novo literal de lista cria uma lista separada, portanto a is [1, 2] é falso para uma lista existente a, mesmo que seus conteúdos sejam iguais.

Mutação e nova associação têm alcances diferentes

Após a última instrução, b aponta para uma nova lista. a continua se referindo ao objeto original. Associar um nome a outro objeto não redireciona todos os nomes que antes se referiam a esse objeto.

Rastreie += e + separadamente

Para listas, += estende a lista existente:

a = [1]
b = a
a += [2]
print(a, b)

A saída é [1, 2] [1, 2]. Por outro lado:

a = [1]
b = a
a = a + [2]
print(a, b)

A saída é [1, 2] [1]. + cria uma nova lista, e a atribuição faz a se referir a ela. b ainda se refere à lista original de um item.

Procure referências alternativas menos visíveis

row = [0, 0] seguido de table = [row, row] armazena a mesma linha duas vezes. table[0][0] = 5 produz [[5, 0], [5, 0]] porque ambas as posições alcançam a mesma lista interna.

Números e strings não podem ser alterados no próprio objeto. Após x = 5, y = x, x += 1, y continua sendo 5; x foi associado a outro valor. As posições dos itens de uma tupla também permanecem fixas, mas uma lista interna pode mudar. Após t = ([1], 2), u = t e t[0].append(3), u mostra ([1, 3], 2): ambos os nomes ainda alcançam a mesma tupla e sua mesma lista mutável.

Copiar cria um novo objeto, mas a profundidade dessa cópia importa. Uma nova lista externa ainda pode conter referências às listas internas originais.

Crie uma nova lista externa

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
print(a is b)

Saída:

[1, 2, 3]
[1, 2, 3, 4]
False

a[:], list(a) e a.copy() fazem uma cópia superficial de uma lista. Seu contêiner externo é novo, e suas referências aos itens são copiadas. Com números ou strings imutáveis, substituir ou adicionar um item em uma lista externa deixa a outra intacta.

Veja o que uma cópia superficial compartilha

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)
print(b is a, b[0] is a[0])

Saída:

[[1, 2, 99], [3, 4]]
False True

As duas listas externas são diferentes, mas seus primeiros itens se referem à mesma lista interna. append() altera esse objeto interno.

Substituir uma posição em b é diferente. Após b[1] = [0], b tem uma segunda linha diferente, enquanto a[1] permanece [3, 4]. A atribuição altera uma referência na lista externa de b; ela não altera a antiga segunda linha.

Copie também as listas aninhadas

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(a)
print(b)

Saída:

[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

import copy disponibiliza o módulo de cópia. copy.deepcopy() copia recursivamente a estrutura de listas aninhadas, portanto alterações nas listas internas copiadas não alcançam a original. Use-o quando as alterações nesses níveis internos precisarem ser independentes. Uma cópia superficial é suficiente se apenas a ordem ou as referências aos itens da lista externa forem alteradas.

Evite referências repetidas ao criar linhas

table = [[0] * 3] * 2
table[0][0] = 7
print(table)

A saída é [[7, 0, 0], [7, 0, 0]]. A multiplicação repetiu a referência a uma linha. Ela não criou duas linhas.

Crie cada linha dentro do laço:

table = []
for r in range(2):
    table.append([0] * 3)
table[0][0] = 7
print(table)

A saída é [[7, 0, 0], [0, 0, 0]]. [0] * 3 por si só é seguro para contadores independentes: inteiros não podem sofrer mutação, e a atribuição a item substitui apenas uma posição.

Escolha uma cópia por um motivo

Preservar a ordem original antes de ordenar exige uma nova lista externa. Preservar as medições aninhadas originais enquanto altera células copiadas também exige listas internas independentes. Um processamento apenas de leitura não precisa de cópia, e alterações compartilhadas intencionais podem usar referências alternativas. Para investigar um defeito em uma estrutura aninhada, verifique tanto b is a quanto b[0] is a[0]; testar apenas as listas externas não revela o compartilhamento interno.

Um parâmetro de função é outro nome para o objeto fornecido pelo código chamador. Um argumento de lista não é copiado automaticamente. A função pode alterar esse objeto, associar seu parâmetro local a outro objeto ou retornar um novo resultado; essas ações afetam o código chamador de formas diferentes.

A mutação alcança o código chamador

def add_bonus(scores):
    scores.append(5)

marks = [80]
result = add_bonus(marks)
print(marks)
print(result)

Saída:

[80, 5]
None

scores e marks se referem inicialmente à mesma lista. Acrescentar um item por meio de scores altera essa lista. Como a função não tem uma instrução de retorno explícita, seu resultado é None.

Por outro lado, def reset(scores): scores = [] associa apenas o parâmetro local a outra lista. A marks do código chamador ainda se refere à lista antiga. Use scores.clear() para esvaziar essa lista compartilhada.

Mantenha uma lista retornada quando necessário

Duas formas comuns de projeto são alterar a própria lista e retornar None, ou deixá-la intacta e retornar uma nova lista:

def drop_first(values):
    del values[0]

def tail(values):
    return values[1:]

Para nums = [1, 2, 3], chamar drop_first(nums) deixa nums como [2, 3]. Escrever nums = drop_first(nums) associaria nums a None. Começando novamente com [1, 2, 3], shorter = tail(nums) atribui a shorter a lista [2, 3], enquanto nums permanece inalterada. Chamar tail(nums) sem guardar seu resultado descarta a nova lista.

Outros projetos também são úteis: sum() retorna um resumo, e pop() altera uma lista e retorna um item. Deixe o efeito e o valor de retorno claros no nome ou na docstring de uma função.

Crie um resultado sem alterar a entrada

def without_negatives(values):
    kept = []
    for value in values:
        if value >= 0:
            kept.append(value)
    return kept

original = [3, -2, 0, 7]
print(without_negatives(original))
print(original)

Saída:

[3, 0, 7]
[3, -2, 0, 7]

O código chamador também pode proteger sua lista externa passando uma cópia superficial, como drop_first(original[:]). Uma operação que edite listas internas também precisaria de cópias nesses níveis.

Evite um valor padrão mutável compartilhado

def add_item(item, basket=[]):
    basket.append(item)
    return basket

A lista padrão é criada uma vez, quando a instrução def é executada. add_item("a") retorna ['a'], e a próxima chamada com o valor padrão, add_item("b"), retorna ['a', 'b']. Use None para solicitar uma nova lista:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

Cada chamada sem um carrinho agora cria sua própria lista. Passar um carrinho existente ainda permite alterações compartilhadas intencionais. Uma função não pode alterar um número ou uma string, nem substituir as posições de uma tupla, mas pode alterar uma lista armazenada em uma tupla, por exemplo, chamando pair[0].append(9).

Ordenar coloca itens em ordem de comparação. Inverter troca o sentido de sua ordem atual. Decida também se o programa deve alterar a lista existente ou mantê-la e receber uma nova lista.

Ordene a própria lista ou mantenha uma nova lista

nums = [3, 1, 2]
new = sorted(nums)
print(nums)
print(new)
nums.sort()
print(nums)

Saída:

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

sorted() cria uma nova lista. sort() é um método de lista que reorganiza a lista existente e retorna None. nums = nums.sort() faz o nome perder a referência à lista e o associa a None. Escreva nums.sort() em uma linha própria ou use nums = sorted(nums). print(nums.sort()) imprime None embora a lista tenha sido reordenada.

sorted() aceita qualquer iterável e sempre retorna uma lista. sorted((3, 1, 2)) produz [1, 2, 3], e sorted("cab") produz ['a', 'b', 'c']. Strings e tuplas não têm um método sort() que altere o próprio objeto.

Ordem decrescente e ordem invertida

Cada linha começa com a lista original. reverse=True solicita uma ordem de comparação decrescente e deve ser informado pelo nome; sorted(nums, True) lança TypeError. Inverter simplesmente percorre as posições existentes para trás, portanto não produz necessariamente valores em ordem decrescente.

Verifique os valores comparados

Números são ordenados pelo valor numérico, inclusive com inteiros e números de ponto flutuante misturados: sorted([2.5, -1, 2]) produz [-1, 2, 2.5].

O texto é comparado caractere por caractere. sorted(["10", "9", "100"]) produz ['10', '100', '9']. O primeiro caractere '1' é ordenado antes de '9', e um prefixo de string vem antes de uma string mais longa que começa com ele. Converta strings numéricas com int() ou float() quando quiser uma ordenação numérica.

As letras maiúsculas A–Z são ordenadas antes das minúsculas a–z. sorted(["b", "B", "a"]) produz ['B', 'a', 'b']. A ordem padrão de strings se baseia em códigos de caracteres; ela não é uma ordem de dicionário que ignora maiúsculas e minúsculas.

Todos os itens comparados devem aceitar < entre si. sorted([3, "two", 1]) lança TypeError. Limpe ou converta os dados antes de ordenar.

Use posições ordenadas

Para um número ímpar de notas, a ordenação facilita a leitura do valor do meio:

scores = [72, 95, 64, 88, 79]
ordered = sorted(scores)
median = ordered[len(ordered) // 2]
print(ordered)
print(median)

A saída é [64, 72, 79, 88, 95] seguida de 79. A lista original ainda registra a ordem em que as notas chegaram. Esse cálculo com um único item do meio se aplica a listas não vazias de tamanho ímpar.

Uma função de chave calcula o valor de comparação para cada item. Os itens originais permanecem intactos no resultado ordenado. Isso permite que um programa ordene texto pelo tamanho ou registros por um campo selecionado.

Passe uma função, não uma chamada de função

words = ["kiwi", "fig", "banana"]
print(sorted(words, key=len))

Saída:

['fig', 'kiwi', 'banana']

O Python chama len uma vez para cada item e compara os tamanhos resultantes, 4, 3 e 6. Passe key=len, sem parênteses. key=len() tenta chamar len imediatamente sem argumento e falha.

Para comparar em minúsculas, use key=str.lower. Com ["banana", "apple", "Cherry"], a ordem padrão é ['Cherry', 'apple', 'banana']. Com key=str.lower, o resultado é ['apple', 'banana', 'Cherry']. O C maiúsculo original permanece no resultado; apenas as chaves de comparação estão em minúsculas.

Selecione um campo do registro

results = [("Ana", 90), ("Ben", 72), ("Cy", 85)]

def by_score(record):
    return record[1]

print(sorted(results, key=by_score))

Saída:

[('Ben', 72), ('Cy', 85), ('Ana', 90)]

A função recebe um registro por vez. record[1] seleciona sua nota. Adicione reverse=True para colocar a maior nota primeiro. results.sort(key=by_score, reverse=True) usa a mesma regra, mas altera a própria results.

key=by_score(results) é diferente: ele chama a função para a lista inteira e passa seu resultado como argumento de chave. Aqui esse resultado é a tupla ('Ben', 72), que não pode ser chamada como função, portanto a ordenação lança TypeError.

Use vários campos

Sem uma chave, tuplas comparam seus primeiros itens e depois os segundos para desempatar primeiros itens iguais. Ordenar [("Ben", 72), ("Ana", 90), ("Ana", 85)] produz [('Ana', 85), ('Ana', 90), ('Ben', 72)].

Uma chave pode retornar uma tupla para escolher uma ordem de campos diferente:

def rank_key(record):
    return (-record[1], record[0])

results = [("Dee", 85), ("Ana", 90), ("Cy", 85)]
print(sorted(results, key=rank_key))

Saída:

[('Ana', 90), ('Cy', 85), ('Dee', 85)]

Negar a nota faz com que notas maiores tenham chaves menores. Os nomes então desempatarão as notas em ordem crescente. reverse=True em uma chave positiva (score, name) inverteria ambos os campos, incluindo os nomes, portanto não atenderia a essa regra com sentidos diferentes.

Mantenha em ordem itens com chaves iguais

A ordenação do Python é estável: itens com chaves iguais mantêm sua ordem de entrada. Ordenar ["bb", "a", "cc", "d"] por len produz ['a', 'd', 'bb', 'cc']. O empate entre as duas palavras de uma letra mantém 'a' primeiro; o empate entre as de duas letras mantém 'bb' primeiro. A estabilidade também permite ordenar primeiro por um campo secundário e depois pelo campo principal.

min() e max() também aceitam funções de chave. max(words, key=len) retorna 'banana', não seu tamanho. Quando as chaves empatam, essas funções retornam o primeiro item correspondente encontrado.