Operações com Listas em Python

Prévia do material em texto

COMPUTAÇÃO I
Professor: Aloísio Pina
Listas
São sequências de elementos entre colchetes e separados por vírgulas.
Exemplo:
Acessando um elemento da lista
Cada elemento da lista pode ser acessado através de seu índice entre colchetes.
Os índices da lista começam sempre em zero.
Exemplo:
1
5
9
ATENÇÃO: Não confunda o elemento com seu índice na lista!
Exemplo: O elemento de índice 3 é 7:
7
Exemplo: O elemento 3 está no índice 1:
3
Cada elemento da lista pode ser acessado também através de índices negativos, começando no
final da lista.
Os índices negativos da lista começam sempre em -1 (não começam em zero porque dessa
forma o índice zero marcaria duas posições distintas na lista).
In [1]: L = [1, 3, 5, 7, 9]
In [ ]: L = [ 1, 3, 5, 7, 9]
 | | | | |
 0 1 2 3 4
In [2]: L[0]
Out[2]:
In [3]: L[2]
Out[3]:
In [4]: L[4]
Out[4]:
In [5]: L[3]
Out[5]:
In [6]: L[1]
Out[6]:
Exemplo:
9
5
1
Observação: Podemos concluir que o primeiro elemento da lista está sempre no índice zero e o
último elemento da lista está sempre no índice -1.
Funções intrínsecas úteis
max(L): retorna o maior elemento da lista L
min(L): retorna o menor elemento da lista L
sum(L): retorna a soma de todos os elementos da lista L
len(L): retorna o número de elementos da lista L ("tamanho" da lista)
Exemplo:
9
1
25
5
Acessando todos os elementos da lista
Muitas vezes é interessante que se possa acessar todos os elementos da lista.
Isso é feito de forma iterativa usando um comando de repetição.
Se a variável de controle do comando de repetição for usada como índice na lista, a cada
iteração acessaremos um dos elementos.
In [ ]: L = [ 1, 3, 5, 7, 9]
 | | | | |
 -5 -4 -3 -2 -1
In [7]: L[-1]
Out[7]:
In [8]: L[-3]
Out[8]:
In [9]: L[-5]
Out[9]:
In [10]: L = [1, 3, 5, 7, 9]
In [11]: max(L)
Out[11]:
In [12]: min(L)
Out[12]:
In [13]: sum(L)
Out[13]:
In [14]: len(L)
Out[14]:
Sabemos que o índice inicial da lista é zero, mas não podemos usar -1 como índice final, pois
iniciando em zero e aumentando em 1 a cada iteração, o valor de i nunca será -1.
Portanto temos que saber o indíce positivo do elemento final.
Considerando que a lista tem n elementos e os índices começam em zero então o índice final é
n-1. Podemos determinar n com a função len, portanto para acessar todos os elementos de uma
lista L temos:
ou:
Exemplo: imprimir na tela todos os elementos da lista L:
1
3
5
7
9
Operações básicas em listas
1) Concatenação: ligar o final de uma lista ao início de outra lista, formando uma nova lista,
usando o operador de concatenação +.
Exemplo:
[1, 3, 5, 2, 4, 6]
ATENÇÃO: Usado entre listas, o operador + não é soma, mas podemos somar elementos
individuais.
7
2) Repetição: repetir os elementos de uma lista um determinado número de vezes, formando
uma nova lista, usando o operador de repetição *.
In [ ]: i = índice inicial da lista L
while i <= índice final da lista L:
 comandos usando L[i]
 i = i + 1
In [ ]: i = 0
while i <= len(L) - 1:
 comandos usando L[i]
 i = i + 1
In [ ]: i = 0
while i < len(L):
 comandos usando L[i]
 i = i + 1
In [15]: i = 0
while i < len(L):
 print(L[i])
 i = i + 1
In [16]: [1, 3, 5] + [2, 4, 6]
Out[16]:
In [17]: L1 = [1, 3, 5]
L2 = [2, 4, 6]
L1[-1] + L2[0]
Out[17]:
Exemplo:
[1, 3, 5, 1, 3, 5, 1, 3, 5]
[1, 3, 5, 1, 3, 5, 1, 3, 5]
ATENÇÃO: Usado entre listas, o operador * não é multiplicação, mas podemos multiplicar
elementos individuais, uns pelos outros ou por valores numéricos.
10
12
A repetição é útil para a inicialização de listas de um tamanho determinado.
Exemplo: Inicializar uma lista de zeros com 10 elementos:
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Sublistas
Podemos definir susblistas de uma lista, especificando os índices de início e fim:
L[ início : fim ] é a sublista que contém todos os elementos de L entre os índices "início" e "fim".
Exemplo:
[3, 5]
Obs.: Se o índice de início não for especificado, é o início da lista; se o índice de fim não for
especificado é o fim da lista.
Exemplo:
[1, 3, 5]
In [18]: [1, 3, 5] * 3
Out[18]:
In [19]: 3 * [1, 3, 5]
Out[19]:
In [20]: L1 = [1, 3, 5]
L2 = [2, 4, 6]
L1[-1] * 2
Out[20]:
In [21]: L1[1] * L2[-2]
Out[21]:
In [22]: Zeros = [0] * 10
Zeros
Out[22]:
In [23]: L = [1, 3, 5, 7, 9]
L[1:3]
Out[23]:
In [ ]: L = [ 1, | 3, 5, | 7, 9]
 | | | | |
 0 1 2 3 4
In [24]: L[:3]
Out[24]:
[5, 7, 9]
[1, 3, 5, 7, 9]
Alteração de listas
1) Atribuição direta:
L[ índice ] = valor
Exemplo:
[1, 3, 5, 10, 9]
1) Substituição de sublistas:
L[ início : fim ] = lista
Exemplo:
[1, 2, 4, 6, 9]
Obs.: A susbstituição de uma sublista pode ser por uma lista de qualquer tamanho.
Exemplo:
[1, 2, 9]
[1, 2, 4, 6, 8, 10, 12, 9]
Operações de manutenção de listas
1) Busca em de um valor v em uma lista L: usa-se um comando de repetição para verificar
iterativamente qual dos elementos de L é igual ao valor v.
In [25]: L[2:]
Out[25]:
In [26]: L[:]
Out[26]:
In [27]: L = [1, 3, 5, 7, 9]
L[3] = 10
L
Out[27]:
In [28]: L = [1, 3, 5, 7, 9]
L[1:4] = [2, 4, 6]
L
Out[28]:
In [29]: L = [1, 3, 5, 7, 9]
L[1:4] = [2]
L
Out[29]:
In [30]: L = [1, 3, 5, 7, 9]
L[1:4] = [2, 4, 6, 8, 10, 12]
L
Out[30]:
2) Inserção do valor v na posição i de uma lista L: pode ser feita por concatenação ou por
susbstituição.
Por concatenação: L = L[ : i ] + [ v ] + L[ i : ]
Por substituição: L[ i : i ] = [ v ]
Exemplo: Dada a lista [1, 3, 5, 7, 9], inserir 10 na posição 3.
Por concatenação:
[1, 3, 5, 10, 7, 9]
Por substituição:
[1, 3, 5, 10, 7, 9]
3) Retirada do valor na posição i de uma lista L: pode ser feita por concatenação ou por
susbstituição.
Por concatenação: L = L[ : i ] + L[ i+1 : ]
Por substituição: L[ i : i+1 ] = [ ]
Exemplo: Dada a lista [1, 3, 5, 7, 9], remover o elemento da posição 3.
Por concatenação:
[1, 3, 5, 9]
Por substituição:
In [ ]: i = 0
while i < len(L):
 if L[i] == v:
 <valor encontrado>
 i = i + 1
In [31]: L = [1, 3, 5, 7, 9]
v = 10
i = 3
L = L[ : i ] + [ v ] + L[ i : ]
L
Out[31]:
In [32]: L = [1, 3, 5, 7, 9]
v = 10
i = 3
L[ i : i ] = [ v ]
L
Out[32]:
In [33]: L = [1, 3, 5, 7, 9]
i = 3
L = L[ : i ] + L[ i+1 : ]
L
Out[33]:
In [34]: L = [1, 3, 5, 7, 9]
i = 3
[1, 3, 5, 9]
Operador in
Serve para determinar se um dado valor está ou não em uma lista. O resultado da operação é
True se estiver, ou False se não estiver.
Exemplo:
True
False
Métodos
São funções associadas a estruturas complexas, como listas.
Os métodos podem ser de dois tipos:
Métodos que retornam valores relacionados às estruturas.
Métodos que alteram a própria estrutura.
Métodos úteis de listas
L.index(v) -> retorna o índice da primeira ocorrência de v em L
L.count(v) -> retorna o número de ocorrências de v em L
L.append(v) -> inclui v no final de L
L.insert(i, v) -> insere v na posição i de L
L.remove(v) -> remove a primeira ocorrência de v em L
L.reverse() -> inverte L
L.sort() -> ordena L
Obs.: Para saber todos os métodos de listas, basta usar: help(list)
Exemplos:
L[ i : i+1 ] = [ ]
L
Out[34]:
In [35]: L = [1, 3, 5, 7, 9]
3 in L
Out[35]:
In [36]: 10 in L
Out[36]:
In [ ]: variável = estrutura.método(argumentos)
In [ ]: estrutura.método(argumentos)
3
2
[1, 5, 9, 7, 5, 3]
[1, 8, 5, 9, 7, 5, 3]
[1, 8, 9, 7, 5, 3]
[3, 5, 7, 9, 8, 1]
[1, 3, 5, 7, 8, 9]
In [13]: L = [1, 5, 9, 7, 5]
In [14]: L.index(7)
Out[14]:
In [15]: L.count(5)
Out[15]:
In [16]: L.append(3)
In [17]: print(L)
In [18]: L.insert(1, 8)
In [19]: print(L)
In [20]: L.remove(5)
In [21]: print(L)
In [22]: L.reverse()
In [23]: print(L)
In [24]: L.sort()
In [25]: print(L)