A diferença e conexão entre listas e tuplas em Python

Primeiro, veja o que é uma lista? O que é uma tupla?

Listas e tuplas são uma coleção ordenada de qualquer tipo de dados. Na maioria das linguagens de programação, os tipos de dados das coleções devem ser consistentes. No entanto, não existe tal requisito para listas e tuplas Python.

Lista:

l = [1, 2, 'hello', 'world'] 
l

[1, 2, 'hello', 'world']

Tupla:

tup = ('jason', 22)
tup

('jason', 22)

a diferença

A lista é dinâmica, o comprimento não é fixo e os elementos podem ser adicionados, excluídos ou alterados à vontade (mutável).

As tuplas são estáticas, têm um comprimento fixo e não podem ser adicionadas, excluídas ou alteradas (imutáveis).

l = [1, 2, 3, 4]
l[3] = 40 # 和很多语言类似，python中索引同样从0开始，l[3]表示访问列表的第四个元素
l
[1, 2, 3, 40]

tup = (1, 2, 3, 4)
tup[3] = 40
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Mas e se você quiser fazer alguma "mudança" nas tuplas existentes? Então você só pode reabrir um pedaço de memória e criar uma nova tupla.

tup = (1, 2, 3, 4)
new_tup = tup + (5, ) # 创建新的元组new_tup，并依次填充原元组的值
new _tup
(1, 2, 3, 4, 5)

l = [1, 2, 3, 4]
l.append(5) # 添加元素5到原列表的末尾
l
[1, 2, 3, 4, 5]

Mesmos pontos

Ambos suportam índices negativos, -1 significa o último elemento, -2 significa o penúltimo elemento e assim por diante.

l = [1, 2, 3, 4]
l[-1]
4

tup = (1, 2, 3, 4)
tup[-2]
3

Todas as operações de corte de suporte

l = [1, 2, 3, 4]
l[1:3] # 返回列表中索引从1到2的子列表
[2, 3]

tup = (1, 2, 3, 4)
tup[1:3] # 返回元组中索引从1到2的子元组
(2, 3) 

Pode ser aninhado à vontade

l = [[1, 2, 3], [4, 5]] # 列表的每一个元素也是一个列表

tup = ((1, 2, 3), (4, 5, 6)) # 元组的每一个元素也是一个元组

Podem ser convertidos entre si por meio das funções list () e tupla ()

list((1, 2, 3))
[1, 2, 3]

tuple([1, 2, 3])
(1, 2, 3)

Algumas funções integradas comumente usadas para listas e tuplas

l = [3, 2, 3, 7, 8, 1]
l.count(3) 
2
l.index(7)
3
l.reverse()
l
[1, 8, 7, 3, 2, 3]
l.sort()
l
[1, 2, 3, 3, 7, 8]

tup = (3, 2, 3, 7, 8, 1)
tup.count(3)
2
tup.index(7)
3
list(reversed(tup))
[1, 8, 7, 3, 2, 3]
sorted(tup)
[1, 2, 3, 3, 7, 8]

• contagem (item) representa o número de ocorrências de item na lista / tupla de contagem.
• índice (item) representa o índice da primeira ocorrência de item na lista / tupla retornada.
• list.reverse () e list.sort () representam a reversão e a classificação da lista in-situ, respectivamente (observe que as tuplas não têm essas duas funções integradas).
• reversed () e ordenado () também significam inverter e ordenar a lista / tupla, reversed () retorna um iterador reverso (o exemplo acima usa a função list () para convertê-lo em uma lista); ordenado () retorna Nova lista ordenada .

Diferenças no armazenamento de listas e tuplas

As listas são dinâmicas e mutáveis, enquanto as tuplas são estáticas e imutáveis. Essa diferença afetará inevitavelmente os métodos de armazenamento dos dois.

l = [1, 2, 3]
l.__sizeof__()
64
tup = (1, 2, 3)
tup.__sizeof__()
48

A lista é dinâmica, portanto, ela precisa armazenar um ponteiro para apontar para o elemento correspondente (no exemplo acima, para o tipo int, 8 bytes). Além disso, como a lista é variável, o armazenamento adicional do comprimento alocado (8 bytes) é necessário, de modo que o uso do espaço da lista possa ser rastreado em tempo real e o espaço adicional possa ser alocado em tempo quando o espaço for insuficiente .

Por meio de um exemplo, para descrever o processo de alocação de espaço de lista.

l = []
l.__sizeof__() // 空列表的存储空间为40字节
40
l.append(1)
l.__sizeof__() 
72 // 加入了元素1之后，列表为其分配了可以存储4个元素的空间 (72 - 40)/8 = 4
l.append(2) 
l.__sizeof__()
72 // 由于之前分配了空间，所以加入元素2，列表空间不变
l.append(3)
l.__sizeof__() 
72 // 同上
l.append(4)
l.__sizeof__() 
72 // 同上
l.append(5)
l.__sizeof__() 
104 // 加入元素5之后，列表的空间不足，所以又额外分配了可以存储4个元素的空间

Pode-se ver que para reduzir a sobrecarga de alocação de espaço durante cada operação de aumento / exclusão, o Python alocará mais espaço cada vez que alocar espaço. Este mecanismo (superalocação) garante a eficiência de sua operação: aumentar / O tempo complexidade de exclusão é $O(1)$。

Para tuplas, a situação é diferente. O comprimento da tupla é fixo e os elementos são imutáveis, portanto, o espaço de armazenamento é fixo.

Desempenho de listas e tuplas

Tuplas são mais leves do que listas, portanto, em geral, a velocidade de desempenho das tuplas é ligeiramente melhor do que a das listas.

Python fará algum armazenamento em cache de recursos para dados estáticos em segundo plano. De modo geral, por causa do mecanismo de coleta de lixo, se algumas variáveis ​​não forem usadas, o Python irá recuperar a memória que ocupam e devolvê-la ao sistema operacional para outras variáveis ​​ou outros aplicativos usarem.
Mas para algumas variáveis ​​estáticas, como tuplas, se não for usado e ocupar pouco espaço, o Python armazenará temporariamente em cache essa parte da memória. Dessa forma, da próxima vez que criarmos uma tupla do mesmo tamanho, o Python não poderá mais solicitar que o sistema operacional encontre memória, mas poderá alocar diretamente o espaço de memória previamente armazenado em cache, o que pode acelerar bastante a velocidade de execução do programa.

O exemplo a seguir é calcular o tempo necessário para inicializar uma lista e tupla do mesmo elemento. Podemos ver que a velocidade de inicialização das tuplas é 5 vezes mais rápida do que a das listas.

python3 -m timeit 'x=(1,2,3,4,5,6)'
20000000 loops, best of 5: 9.97 nsec per loop
python3 -m timeit 'x=[1,2,3,4,5,6]'
5000000 loops, best of 5: 50.1 nsec per loop

Mas se for uma operação de índice, a diferença de velocidade entre as duas é muito pequena, quase insignificante.

python3 -m timeit -s 'x=[1,2,3,4,5,6]' 'y=x[3]'
10000000 loops, best of 5: 22.2 nsec per loop
python3 -m timeit -s 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 5: 21.9 nsec per loop

Adicione, exclua ou altere elementos, então a lista é obviamente melhor. Porque para tuplas, você tem que fazer isso criando uma nova tupla, que é definitivamente mais cara.

Casos de uso para listas e tuplas

1. Se os dados armazenados e a quantidade permanecem os mesmos, por exemplo, se você tem uma função que precisa retornar a latitude e longitude de um local e, em seguida, passá-los diretamente para a renderização de front-end, então é mais apropriado usar tuplas .

def get_location():
    ..... 
    return (longitude, latitude)

2. Se os dados ou a quantidade armazenados forem variáveis, por exemplo, uma função de registro em uma plataforma social é contar quais postagens de usuários um usuário leu em uma semana, então uma lista é mais apropriada.

viewer_owner_id_list = [] # 里面的每个元素记录了这个viewer一周内看过的所有owner的id
records = queryDB(viewer_id) # 索引数据库，拿到某个viewer一周内的日志
for record in records:
    viewer_owner_id_list.append(record.id)

Pequeno resumo

diferença:

• A lista é dinâmica, o comprimento não é fixo e os elementos podem ser adicionados, excluídos ou alterados à vontade (mutável). A tupla é estática, o comprimento é fixo e não pode ser adicionada, excluída ou alterada (imutável).
• O espaço de armazenamento da lista é ligeiramente maior do que o da tupla e seu desempenho é ligeiramente inferior ao da tupla. Em comparação com a lista, a tupla é mais leve e tem um desempenho ligeiramente melhor.

Terreno comum

• Ambas as listas e tuplas em Python suportam indexação negativa, -1 significa o último elemento, -2 significa o penúltimo elemento;
• Tanto as listas quanto as tuplas suportam operações de fatiamento;
• Tanto as listas quanto as tuplas podem ser aninhadas à vontade;
• Tanto as listas quanto as tuplas são ordenadas e podem armazenar coleções de qualquer tipo de dados.