victorjabur · August 21, 2016 21:16
diff --git a/python_list.py b/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.
	# 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.