Python - Explorando a classe list

python_list.py

# Criando uma lista vazia
minha_lista = []
minha_lista = list()

# Com alguns numeros
numeros = [1,2,3,4,5]
#numeros = list(1,2,3,4,5) # TypeError: list() takes at most 1 argument (2 given

# Eh possivel ter varios tipos misturados
mistura = [1, "1", '1', 0, -5, 100.62, [1,2,3], {1 : 2}, (1,2,3)]

# Acessando elementos pelo indice
print(mistura[0]) # Imprime o valor 1
print(mistura[48]) # IndexError: list index out of range
print(mistura[-4]) # Imprime o valor -100.62
help(list) # Imprime o manual da classe list

# Somando duas listas
lista1 = [1,2,3]
lista2 = [3,4,5]
lista3 = lista1 + lista2
print(lista3) # Imprime [1, 2, 3, 3, 4, 5]

# Nao rola subtracao
lista3 = lista1 - lista2 # TypeError: unsupported operand type(s) for -: 'list' and 'list'

lista = list('python eh divertido')
# ['p', 'y', 't', 'h', 'o', 'n', ' ', 'e', 'h', ' ', 'd', 'i', 'v', 'e', 'r', 't', 'i', 'd', 'o']

# Conta o numero de elementos na lista
print(len(lista)) # Imprime 19

# Fatiando uma lista (Slicing)
print(lista[2:7]) # ['t', 'h', 'o', 'n', ' ']
print(lista[:7]) # ['p', 'y', 't', 'h', 'o', 'n', ' ']
print(lista[5:]) # ['n', ' ', 'e', 'h', ' ', 'd', 'i', 'v', 'e', 'r', 't', 'i', 'd', 'o']
print(lista[:-10]) # ['p', 'y', 't', 'h', 'o', 'n', ' ', 'e', 'h']
print(lista[-5:]) # ['r', 't', 'i', 'd', 'o']
print(lista[3:14:2]) # Posicao 3 ate 14 pulando de 2 em 2 ['h', 'n', 'e', ' ', 'i', 'e']
print(lista[::-1]) # Inverte a lista
# ['o', 'd', 'i', 't', 'r', 'e', 'v', 'i', 'd', ' ', 'h', 'e', ' ', 'n', 'o', 'h', 't', 'y', 'p']

# Adiciona um elemento ao final da lista
lista.append(', mais que java')
print(lista)
# ['p', 'y', 't', 'h', 'o', 'n', ' ', 'e', 'h', ' ', 'd', 'i', 'v', 'e', 'r', 't', 'i', 'd', 'o', ', mais que java']

# Adicionando um tem na posicao 2
frutas = ['banana', 'maca', 'pessego']
frutas.insert(2, 'morango')
print(frutas) # ['banana', 'maca', 'morango', 'pessego']

# Extendendo uma lista com outra
favoritas = ['conde', 'pera']
frutas.extend(favoritas)
print(frutas) # ['banana', 'maca', 'morango', 'pessego', 'conde', 'pera']

# Diferenca de append e insert
frutas.append(favoritas)
print(frutas) # ['banana', 'maca', 'morango', 'pessego', 'conde', 'pera', ['conde', 'pera']]

# Fazendo buscas em uma lista
print(frutas.index('morango')) # Imprime 2
print(frutas.index('kiwi')) # ValueError: 'kiwi' is not in list
print('pessego' in frutas) # True
print('jaca' in frutas) # False

# Removendo Itens da lista com a funcao remove
frutas.remove('morango')
print(frutas) # ['banana', 'maca', 'pessego', 'conde', 'pera', ['conde', 'pera']]
frutas.remove('melancia')
print(frutas) # ValueError: list.reValueError: list.remove(x): x not in list

# Tambem rola reomver com del()
del frutas[2]
del frutas[2:7]

# Multiplicacao de lista
lista = [1,2,3]
lista = lista * 3
print(lista) # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# Iterando listas com o loop for
for fruta in frutas:
    print(fruta)

# Listas tambem suportam iteradores
i = iter(frutas)
print(i.next()) # banana
print(i.next()) # maca
print(i.next()) # pessego

# Somando todos os itens de uma lista
nums = [1,2,3]
print(sum(nums)) # Imprime 6

# Imprimindo a media da lista
media = sum(nums) / len(nums)
print(media) # Imprime 2

# Juntando caracteres de uma lista
lista = ['o','l','a']
print(''.join(lista)) # Imprime ola

# Substituindo um elemento da lista
lista[1] = 'i'
print(lista) # ['o', 'i', 'a']

# Invertendo uma lista
lista = [1,2,3,4,5,6,7,8]
lista.reverse()
print(lista) # [8, 7, 6, 5, 4, 3, 2, 1]

# Ordenando a lista
lista.sort()

# Obtendo uma copia ordenada
lista_copia = sorted(lista)

# Iterando sob uma copia da lista, deletando items
for item in list(lista):
    if item > 5:
        lista.remove(item)

# Minimo e maximo
min(lista)
max(lista)

# Iterando uma lista pegando indice e valor ao mesmo tempo
nomes = ['alberto', 'joao', 'lucas']
for indice, valor in enumerate(nomes):
    print('indice = ', indice, 'valor = ', valor)
# ('indice = ', 0, 'valor = ', 'alberto')
# ('indice = ', 1, 'valor = ', 'joao')
# ('indice = ', 2, 'valor = ', 'lucas')

# Imprimindo listas de um jeito esperto
print([1, 2, 3])  # prints [1, 2, 3]
print("".join(nomes))  # albertojoaolucas
print (', '.join(map(str, nomes))) # alberto, joao, lucas
print ('|'.join(str(v) for v in nomes if v > 0)) # alberto|joao|lucas

# List Comprehensions
S = [x**2 for x in range(10)] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
V = [2**i for i in range(13)] # [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]
M = [x for x in S if x % 2 == 0] # [0, 4, 16, 36, 64]

nao_primos = [j for i in range(2, 8) for j in range(i*2, 50, i)]
primos = [x for x in range(2, 50) if x not in nao_primos]
print(primos) # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]



# Versao tradicional padrao
sentence = "the quick brown fox jumps over the lazy dog"
words = sentence.split()
word_lengths = []
for word in words:
    if word != "the":
        word_lengths.append(len(word)) # [5, 5, 3, 5, 4, 4, 3]

# Versao tradicional usando List Comprehension
sentence = "the quick brown fox jumps over the lazy dog"
words = sentence.split()
word_lengths = [len(word) for word in words if word != "the"]
print(word_lengths) # [5, 5, 3, 5, 4, 4, 3]


# Versao tradicional usando List Comprehension
words = 'The quick brown fox jumps over the lazy dog'.split()
print(words) # ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']
stuff = [[w.upper(), w.lower(), len(w)] for w in words]
for i in stuff:
    print(i) 

# Versao funcional
stuff = map(lambda w: [w.upper(), w.lower(), len(w)], words)
for i in stuff:
    print(i)

# ['THE', 'the', 3]
# ['QUICK', 'quick', 5]
# ['BROWN', 'brown', 5]
# ['FOX', 'fox', 3]
# ['JUMPS', 'jumps', 5]
# ['OVER', 'over', 4]
# ['THE', 'the', 3]
# ['LAZY', 'lazy', 4]
# ['DOG', 'dog', 3]

Considerações sobre lista:
- O objeto list contém duas partes internas, um objeto header e um array com os ponteiros para os objetos.
- O objeto lista armazena ponteiros para os objetos, não os próprios objetos. O tamanho de uma lista
na memória depende do número de elementos da lista e não do tamanho dos objetos.
- O tempo gasto para armazenar ou alterar um elemento é constante. Não importa o tamanho da lista O(1)
- O tempo gasto para incluir um item na lista é uma constante amortizada. Para a inclusão de um item
é necessário alocar mais memória ram, para um item o Python acaba alocando mais do que o necessário para
agilizar nas inserções seguintes, por conta deste processo de alocação, o comportamento pode chegar
até O(n*n)
- Para a inserção de um novo elemento, caso seja no final, tempo é O(1). Caso seja na primeira posição,
o tempo depende do tamanho da lista, uma vez que todos os elementos precisam ser deslocados O(n) no pior
caso.
- Para remover um item o tempo é o mesmo da inserção. Remover do final é rápido, mas remover do inicio
pode ser lento O(n)
- O tempo para inverter uma lista (.reverse()) depende do tamanho da lista. Podendo chegar até O(n) no pior caso
- O tempo para ordenar a lista é O(n log n) no pior caso.