-
Notifications
You must be signed in to change notification settings - Fork 0
/
aula028_listas.py
419 lines (332 loc) · 14.2 KB
/
aula028_listas.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
"""
Listas em Python funcionam como vetores/matrizes (arrays em outras linguagens). Com a diferença de serem dinâmicos e aceitarem qualquer tipo de dados.
Como funcionam os arrays em C ou Java por exemplo:
- Possuem tamanho e tipo de dados fixos, ou seja, nestas linguagens se for criado um array do tipo int e tamanho 5, este array será sempre do tipo inteiro e só poderá ter no máximo 5 valores.
Como funcionam em Python:
- Dinâmico:
- Já em Python não possui tamanho fixo antecipadamente. Ou seja, podemos criar a lista e ir adicionando elementos.
Qualquer tipo de dados:
- Não possuem tipos de dados fixo, podendo ser usado qualquer tipo de dados dentro de uma lista.
As listas em Python são representadas por colchetes: []
"""
print('------------------------------------------------------------------------')
print('Imprimindo as listas de modelo:')
lista1 = [1, 99, 4, 27, 15, 22, 3, 1, 44, 42, 27]
print(lista1)
lista2 = ['G', 'e', 'e', 'k', ' ', 'U', 'n', 'i', 'v', 'e', 'r', 's', 'i', 't', 'y']
print(lista2)
lista3 = []
print(lista3)
lista4 = list(range(11))
print(lista4)
lista5 = list('Geek University')
print(lista5)
print('------------------------------------------------------------------------')
print('Checando os valores contidos nas listas:')
# Podemos checar valores contidos nas listas:
num = 18
if num in lista4:
print(f'encontrei o número {num}')
else:
print(f'não encontrei o número {num}')
print('------------------------------------------------------------------------')
print('Ordenando uma lista:')
# Podemos facilmente ordenar um lista:
lista1.sort()
print(lista1)
print('------------------------------------------------------------------------')
print('Contando o número de ocorrências de um elemento da lista:')
# Podemos facilmente contar o número de ocorrências de um valor em uma lista:
print(lista1.count(1))
print(lista5.count('e'))
print('------------------------------------------------------------------------')
print('Adicionando elementos em uma lista com append:')
# Podemos adicionar elementos em listas (append):
print(lista1)
lista1.append(42)
print(lista1)
# OBS: Com append nós só conseguimos adicionar um elemento por vez, caso contrário dá erro. Mas podemos acrescentar um outro elemento do tipo lista:
lista1.append([8, 3, 1])
print(lista1)
print('Provando que a lista adicionada é um elemento:')
# Essa lista vira um elemento dentro da lista1, veja que interessante:
if [8, 3, 1] in lista1:
print('Encontrei a lista dentro da lista!')
else:
print('Não encontrei a lista dentro da lista!')
print('------------------------------------------------------------------------')
print('Adicionando mais que um elemento em uma lista com extend:')
# Para adicionar mais que um elemento de uma vez na lista já existente nós utilizamos .extend():
print(lista1)
lista1.extend([123, 44, 67])
print(lista1)
print('------------------------------------------------------------------------')
print('Adicionando um item na lista em uma posição específica com o insert:')
# Como o append e o extend sempre inserem elementos no fim da lista, podemos utilizar o insert informando a posição que queremos:
lista1.insert(2, 'novo valor')
print(lista1)
# Note que o elemento é inserido, mas não substitui o anterior da posição, só empurra ele para a próxima posição.
print('------------------------------------------------------------------------')
print('Juntando duas listas com o operador soma criando uma terceira:')
# Também podemos facilmente juntar duas listas:
lista6 = lista1 + lista2
print(lista6)
print('Juntando duas listas com o extend:')
# O mesmo pode ser feito com extend, com a diferença que vc não cria uma nova lista, mas amplia uma já existente:
lista4.extend(lista5)
print(lista4)
print('Aumentando a lista1 com os itens da lista2 com o operador soma:')
# Ainda assim, o mesmo pode ser feito usando:
lista1 = lista1 + lista2
print(lista1)
# Renovando as listas para continuar com os exemplos com as listas na íntegra:
lista1 = [1, 99, 4, 27, 15, 22, 3, 1, 44, 42, 27]
lista2 = ['G', 'e', 'e', 'k', ' ', 'U', 'n', 'i', 'v', 'e', 'r', 's', 'i', 't', 'y']
lista3 = []
lista4 = list(range(11))
lista5 = list('Geek University')
print('------------------------------------------------------------------------')
# Imprimindo a lista inversa:
lista1.reverse()
lista2.reverse()
print('Imprimindo a lista invertida com reverse:')
print(lista1)
print(lista2)
print('E podemos fazer de outra forma com slice:')
print(lista1[::-1])
print(lista2[::-1])
print('------------------------------------------------------------------------')
# Corrigindo as listas invertidas:
lista1.reverse()
lista2.reverse()
# Copiando uma lista:
print('Podemos copiar uma lista')
lista6 = lista2.copy()
print(lista6)
print('------------------------------------------------------------------------')
# Descobrindo o tamanho de uma lista:
print('Descobrindo o tamanho de uma lista com len:')
print(len(lista5))
print('------------------------------------------------------------------------')
# Removendo o último elemento de uma lista:
print('Removendo o último elemento de uma lista com pop:')
print(lista5)
lista5.pop()
print(lista5)
lista5.pop()
print(lista5)
# OBS: O pop não somente remove o último elemento, mas também o retorna.
# Ainda podemos remover um elemento pelo índice:
print('Removendo um ítem pelo índice:')
print(lista5)
lista5.pop(2)
print(lista5)
# Os elementos à direita deste índice serão todos deslocados para a esquerda.
# OBS: Se não houver elemento no índice informado, teremos um erro chamado IndexError
# Podemos ainda remover todos os elementos de uma lista:
print('Removendo todos os elementos de uma lista de uma só vez (zerar a lista):')
print(lista5)
lista5.clear()
print(lista5)
print('------------------------------------------------------------------------')
# Podemos multiplicar uma lista:
print('Multiplicando os itens de uma lista usando *:')
nova = [1, 2, 3]
nova *= 3
print(nova)
print('------------------------------------------------------------------------')
# Podemos facilmente converter uma string para uma lista:
print('Convertendo uma string para uma lista. Exemplo 1 (split):')
curso = 'Programação em Python Essencial'
print(curso)
curso = curso.split()
print(curso)
# Por padrão o split separa os elementos da lista pelo espaço entre elas.
print('Convertendo uma string para uma lista. Exemplo 2 (delimitando a divisão com vírgula):')
curso = 'Programação,em,Python,Essencial'
print(curso)
curso = curso.split(',')
print(curso)
# Convertendo uma lista em string:
print('Agora convertendo uma lista em string (Join):')
print(curso)
curso = ' '.join(curso)
print(curso)
# Basicamente o comando diz: Pegue a lista curso, coloque espaços entre cada elemento e transforme em uma string.
# Podemos fazer isso com outros caracteres além do espaço.
print('------------------------------------------------------------------------')
# Iterando sobre listas:
#Exemplo 1 Utilizando for:
print('Iterando sobre listas - Exemplo 1 (for):')
print(f'Lista1: {lista1}')
for elemento in lista1:
print(elemento)
# Inclusive podemos fazer o seguinte para tornar a iteração dinâmica para um uso:
print('Inclusive podemos utilizar essa iteração fazendo uma soma:')
print(f'Os elementos da lista4 são: {lista4}')
soma = 0
for elemento in lista4:
soma += elemento
print(f'A soma dos elentos da lista4 é: {soma}')
# Desde que respeitemos os tipos, podemos somar até mesmo strings, o que vai me gerar uma concatenação de caracteres gerando uma string única.
#Exemplo 2 Utilizando While:
print('Iterando sobre lsitas - Exemplo 2 (while):')
"""
carrinho = []
produto = ''
while produto != 'sair':
print("Adicione um produto na lista ou digite 'sair' para sair: ")
produto = input()
if produto != 'sair':
carrinho.append(produto)
for produto in carrinho:
print(produto)
print(carrinho)
"""
print('------------------------------------------------------------------------')
print('Deixarei comentado o item de iteração com while, pois ele pede input!')
print('------------------------------------------------------------------------')
# Utilizando variáveis em listas:
print('Utilizando variáveis em listas:')
numeros = [1, 2, 3, 4, 5]
print(numeros)
num1 = 1
num2 = 2
num3 = 3
num4 = 4
num5 = 5
numeros = [num1, num2, num3, num4, num5]
print(numeros)
print('------------------------------------------------------------------------')
# Em listas fazemos o acesso aos elementos de forma indexada
print('Acessando os elementos da lista pelo índice:')
cores = ['verde', 'amarelo', 'azul', 'branco']
print(cores[0])
print(cores[1])
print(cores[2])
print(cores[3])
# Fazendo o acesso aos elementos de forma indexada inversa;
print('Fazendo o acesso aos elementos de forma indexada inversa:')
print(cores[-1])
print(cores[-2])
print(cores[-3])
print(cores[-4])
# para entender melhor o índice negativo, pense na lista como um círculo, onde o final de um elemento está ligado ao início da lista.
print('------------------------------------------------------------------------')
print('Imprimindo os itens da lista usando loop for:')
for cor in cores:
print(cor)
print('Imprimindo os itens da lista usando loop while:')
indice = 0
while indice < len(cores):
print(cores[indice])
indice += 1
print('------------------------------------------------------------------------')
print('Gerando índice em um loop for:')
for indice, cor in enumerate(cores):
print(indice, cor)
print('------------------------------------------------------------------------')
# Relembrando que listas aceitam valores repetidos
print('Relembrando que listas aceitam repetição de valores:')
lista7 = []
lista7.append(42)
lista7.append(42)
lista7.append(33)
lista7.append(33)
lista7.append(42)
print(lista7)
print('------------------------------------------------------------------------')
# Outros métodos não tão importantes mas também úteis para se trabalhar com listas:
print('Encontrar o índice de um elemento na lista:')
numeros = [5, 6, 7, 5, 8, 9, 10]
print('Em qual índice da lista está o valor 6?')
print(numeros.index(6))
print('Em qual índice da lista está o valor 9?')
print(numeros.index(9))
# OBS: Caso não exista o elemento na lista, será apresentado um erro.
print('Se tivermos elementos repetidos ao pedir o índice, retorna o índice do primeiro elemento encontrado:')
print(numeros.index(5))
print('Podemos fazer a busca dentro de um range estabelecendo onde iniciar')
print(numeros.index(5, 2))
# Traduzindo, encontre o elemento 5 a partir do índice 2!
print('Podemos fazer a busca dentro de um range estabelecendo onde iniciar e onde terminar')
print(numeros.index(5, 2, 5))
# Traduzindo, encontre o elemento 5 a partir do índice 2 e pare no índice 5!
print('------------------------------------------------------------------------')
# Revisando Slicing:
# lista[início:fim:passo]
# range[início:fim:passo]
print('Trabalhando com slice de lista com o parâmetro início:')
lista8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
print(lista8[1:])
print('Trabalhando com slice Imprimindo todos os elementos(::):')
print(lista8[::])
print('Trabalhando com slice de lista com parâmetro início e fim:')
print(lista8[1:6])
print('Trabalhando com slice de lista só com parâmetro fim:')
print(lista8[:6])
print('Trabalhando com slice de lista com parâmetro início, fim e com passo de 2:')
print(lista8[1:8:2])
print('Trabalhando com slice de lista somente com passo de 2 e fim:')
print(lista8[:11:2])
print('Trabalhando com slice de lista com índice negativo:')
print(lista8[-3:]) # Lembre da lista como um círculo.
print('Trabalhando com slice de lista com parâmetro início, com passo de 2 até o final:')
print(lista8[1::2])
print('Trabalhando com slice de lista com parâmetro início, com passo de negativo:')
print(lista8[::-1]) # A lista acaba sendo invertida.
print('------------------------------------------------------------------------')
print('Invertendo valores em uma lista:')
nomes = ['Geek', 'University']
nomes[0], nomes[1] = nomes[1], nomes[0]
print(nomes)
print('Lembrando que para isso tbm podemos usar o reverse!')
print('------------------------------------------------------------------------')
# Realizar: Soma*, valor máximo*, valor mínimo* e tamanho de uma lista.
# * Somente se os valores forem todos inteiros ou reais.
print('Econtrando soma, máximo, mínimo e tamanho de uma lista:')
lista9 = [1, 2, 3, 4, 5, 6]
print(f'Eis a lista9: {lista9}')
print(sum(lista9))
print(max(lista9))
print(min(lista9))
print(len(lista9))
print('------------------------------------------------------------------------')
print('Transformando uma lista em tupla:')
print(lista9)
print(type(lista9))
tupla = tuple(lista9)
print(tupla)
print(type(tupla))
print('------------------------------------------------------------------------')
# Desempacotamento de lista:
print('Desempacotamento de listas:')
lista10 = [1, 2, 3]
n1, n2, n3 = lista10
print(n1)
print(n2)
print(n3)
# Se a quantidade de elementos for diferente da quantidade de dados o Python apontará um erro!
print('------------------------------------------------------------------------')
# Copiando uma lista para outra (Deep Copy)
print('Copiando uma lista para outra utilizando Deep Copy:')
print(f'Imprimindo a lista10: {lista10}')
novaLista = lista10.copy()
print(f'Imprimindo a cópia da lista10, a novaLista: {novaLista}')
novaLista.append(4)
print(f'Reimprimindo a lista10: {lista10}')
print(f'Reimprimindo a novaLista depois de somar um elemnto: {novaLista}')
"""
Veja que ao utilizarmos lista.copy(), copiamos os dados da lista para uma nova lista, mas as listas ficaram totalmente independentes uma da outra. Isso em Python é chamado de Deep Copy.
"""
# Copiando uma lista para outra (Shallow Copy)
print('Copiando uma lista para outra utilizando Shallow Copy:')
print(f'Imprimindo a lista10: {lista10}')
novaLista2 = lista10
print(f'Imprimindo a cópia da lista10, a novaLista2: {novaLista2}')
novaLista2.append(4)
print(f'Reimprimindo a lista10: {lista10}')
print(f'Reimprimindo a novaLista2 depois de somar um elemnto: {novaLista2}')
"""
Veja que neste novo caso, nós fizemos a cópia via atribuição e copiamos os dados da lista10 para a nova lista2, mas após realizar modificação em uma das listas, essa modificação se refletiu em ambas as listas. Isso em Python é chamado de Shallow Copy.
"""