Aula 20 - FIS02213_—_Python#15_Listas

SAVE OFFLINE

FIS02213 — Python#15: Listas Listas Uma lista é uma sequência ordenada de zero ou mais referências a objetos.  Ao contrário das tuplas, listas são mutáveis , permitindo a substituição, a remoção ou a inserção de ítens na lista.

Criação de listas >>> list()  []  >>> []  []  >>> [1]  [1]  >>> [1,2,3,4]  [1, 2, 3, 4]  >>> [1, 'abc', 3-3j]  [1, 'abc', (3-3j)]

Acesso aos ítens de uma lista >>> lista = [ -13.4, 'mega', 41, 'X', ['alpha', 'beta', 'gamm a'], (10,20) ]  >>> lista  [-13.4, 'mega', 41, 'X', ['alpha', 'beta', 'gamma'], (10, 2 0)]  >>>   >>> lista[0] 

-13.4  >>> lista[-1]  (10, 20)  >>> lista[3:-2]  ['X'] >>> lista[4]  ['alpha', 'beta', 'gamma']  >>> lista[4][1]  'beta' >>> lista[5][0]  10

Desempacotamento de Sequências Assim, como em tuplas e strings, é possível desempacotar listas, passando seus itens para variáveis à esquerda da atribuição =. Pode-se usar o operador de desempacotamento de sequências (*) para atribuir a uma dessas variáveis todos os itens que sobraram.

>>> a, b, c = [0, 1, 2]  >>> a  0  >>> b  1  >>> c  2  >>> a,b,c  (0, 1, 2) >>> first, *rest = [0, 1, 2, 3, 4] 

>>> first, rest  (0, [1, 2, 3, 4])  >>> first  0  >>> rest  [1, 2, 3, 4]  >>> first, *mid, last = "Alpha Beta Gamma Delta Epsilon".split ()  >>> first  'Alpha'  >>> mid  ['Beta', 'Gamma', 'Delta']  >>> last  'Epsilon'  >>> *dir, exe = "/usr/local/bin/prog".split("/")  >>> dir  ['', 'usr', 'local', 'bin'] >>> exe 'prog' >>> dir, exe (['', 'usr', 'local', 'bin'], 'prog')  >>>  Quando o atribuir de desempacotamento de sequência é usado desta maneira, as expressões *rest , *mid, *dir são chamadas de “expressões asterisco" (ou starred expressions ). Argumentos Asterisco (Starred arguments):

Se, por exemplo, uma função possui 3 argumentos, podemos chamá-la com 3 argumentos, ou usando argumentos asteriscos.

>>> def produto (a, b, c):  ...     return a * b * c  ...   # Passando 3 argumentos para a função produto( ): >>> produto(2,3,5)  30  # Passando um argumento asterisico: >>> L = [2,3,5]  >>> produto(*L)  30  # Passando o primeiro argumento e outros dois,  # pelo desempacotamento de itens fatiados da lista L: >>> produto(2, *L[1:])  30

Métodos de Listas Sintaxe

Descrição

L.append(x)

Anexa o item x ao final da lista L . >>> L = [0,1,2]  >>> L.append(3)  >>> L 

[0, 1, 2, 3] L.count(x)

Conta o número de ocorrências de x na lista L.

L.extend(m)

Anexa todos os itens do iterável m ao final da lista L. 

L += m

O operador += faz o mesmo. >>> L = [0,1,2]  >>> L.extend( [3,4] )  >>> L  [0, 1, 2, 3, 4]  >>> L = [0,1,2]  >>> L += [3,4]  >>> L  [0, 1, 2, 3, 4]

L.index(x, start,

Retorna a posição da primeira ocorrência de x na lista L, a

end)

partir da esquerda  (ou na fatia start : end de L). Caso não encontre, retorna uma exceção valueError. 

L.insert(i, x)

Insere o item x dentro da lista L na posição de índice i . >>> L = ['a', 'b', 'd', 'e']  >>> L.insert(2, 'c')  >>> L  ['a', 'b', 'c', 'd', 'e']  >>> L = ['a', 'b', 'd', 'e']  >>> L[2:2] = 'c' >>> L  ['a', 'b', 'c', 'd', 'e']

L.pop( )

Retorna e remove o item mais à direita da lista L. >>> L = [0,1,2,3,4]  >>> L.pop()  4  >>> L 

[0, 1, 2, 3] L.pop(i)

Retorna e reove o ítem da posição de índice i dentro de L. >>> L = ['a', 'b', 'c', 'd', 'e']   >>> L.pop(2)  'c'  >>> L  ['a', 'b', 'd', 'e']

L.remove(x)

Remove a primeira ocorrência a partir da esquerda do item x da lista L.  Caso não encontre x, gera uma exceção VlaueError. >>> L = ['a', 'b', 'c', 'd', 'e']  >>> L.remove('c')  >>> L  ['a', 'b', 'd', 'e'] >>> L = ['a', 'b', 'c', 'd', 'e', 'c']  >>> L.remove('c')  >>> L  ['a', 'b', 'd', 'e', 'c']

L.reverse( )

Inverte a lista L . >>> L = [0,1,2,3,4]  >>> L.reverse()  >>> L  [4, 3, 2, 1, 0]

L.sort( … )

Ordena os itens da lista L .  >>> L = [3, 2, 0, 4, 1]  >>> L.sort()  >>> L  [0, 1, 2, 3, 4]

Substituição de itens:

>>> L = ['a', 'b', 'x', 'y', 'e']  >>> L[2:4] = ['c', 'd']   >>> L  ['a', 'b', 'c', 'd', 'e'] Outras maneiras de deletar elementos de uma lista:

>>> L = ['a', 'b', 'c', 'd', 'e']  >>> L[2:4] = []  >>> L  ['a', 'b', 'e'] >>> L = ['a', 'b', 'c', 'd', 'e']  >>> del L[2:4]  >>> L  ['a', 'b', 'e'] Função range( ) A função range( ) pode ser usada dentro do loop for, para gerar uma sequência de valores inteiros para o iterador. A função range aceita de 1 a 3 argumentos range(n) — gera uma sequência de 0 a (n-1):  0, 1, 2, …, (n-1) range(n1, n2) — gera uma sequência entre n1 e (n2-1) range(n1, n2, step) — gera uma sequência entre n1 e n2, com um incremento igual a step.

>>> for i in range(4):  ...     print(i)  ...   0  1 

2  3 >>> for i in range(2,4):  ...     print(i)  ...   2  3 >>> for i in range(0, 10, 2):  ...     print(i)  ...   0  2  4  6  8

Iterando os Itens de uma Lista . Acesso direto ao item:

>>> L = [0, 1, 2, 3, 4]  >>> for item in L:  ...     print(item)  ...   0  1  2  3  4

. Acesso via índice, com uso da função range( ):

>>> L = [0,1,2,3,4]  >>> for i in range(len(L)):  ...     L[i] **= 2  ...   >>> L  [0, 1, 4, 9, 16]

Fatiamento de Listas >>> L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  >>> L[3:6]  [3, 4, 5]  >>> L[:5]  [0, 1, 2, 3, 4]  >>> L[5:]  [5, 6, 7, 8, 9, 10]  >>> L[:]  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  >>> L[1::2]  [1, 3, 5, 7, 9]  >>> L[::3]  [0, 3, 6, 9]

Compressão de Listas >>> bisextos = [] 

>>> for ano in range(1900, 1940):                                  ...     if (ano % 4 == 0 and ano % 100 != 0) or (ano % 400 == 0):   ...         bisextos.append(ano)  >>> bisextos  [1900, 1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936] . Lista literal:

L = [1900, 1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 193 6] . Compressão de lista:

>>> bisexto = [ano for ano in range(1900, 1940)]  >>> bisexto  [1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1 910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 192 0, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939] O resultado acima também poderia ser obtido com:

>>> bisexto = list( range(1900, 1940) )  >>> bisexto  [1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1 910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 192 0, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939] Melhorando a compressão com a exclusão de itens:

>>> bisexto = [ano for ano in range(1900, 1940) if ano % 4 == 0]  >>> bisexto 

[1900, 1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936] >>> bisexto = [ano for ano in range(1900, 1940) if (ano % 4 == 0 and ano % 100 != 0)]  >>> bisexto  [1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936] >>> bisexto = [ano for ano in range(1900, 1940) if ( (ano % 4 == 0 and ano % 100 != 0) or (ano % 400 == 0)) ]  >>> bisexto  [1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936]