00:01:02 Rogerio Chinen: Boa noite, pessoal.

00:14:07 Rogerio Penchel: Boa noite à todos.

00:14:32 Marcello: boa noite
00:14:41 Helder: Boa noite, pessoal!
00:15:11 Bárbara Pereira: Boa noite pessoal!
00:15:17 Luiz Almeida: ôpa...

boa noite a todos !!!

00:17:42 Ricardo Passador: Boa Noite galera !!!
00:18:35 Paulo Martins: Boa noite pessoal!
00:18:58 Bruno Silva: Boa noite.
00:19:01 Pedro Riva: Boa noite!
00:19:02 Lucas Cruz: boa noite
00:19:03 Paulo Magno Oliveira Filho: blz
00:19:03 Jonas Brasil: boa
00:19:04 Pedro Riva: Tudo certo
00:19:06 Debora Ribeiro: oiii boa noooite! Tudo certo!!
00:19:15 Caio Neves: tranquilo
00:19:18 Bruno do Carmo: cortou o cabelooooo
00:19:40 Pedro Riva: em casa de ferreiro tem bug na plataforma
00:20:11 Luiz Almeida: não deve ter sido escrito em Python !!!
00:20:52 Alexandre Rozante: Boa noite.
00:21:32 Fabrício Pavanin Silva: acho que ta mutado
00:21:33 Debora Ribeiro: Uhuul, boa sorte Luis! =) Parabéns!!
00:21:36 Fabrício Pavanin Silva: aee
00:21:48 Ricardo Passador: Sim
00:21:48 Caio Neves: agora sim
00:21:48 Debora Ribeiro: siim
00:21:51 Luiz Almeida: loud and clear
00:21:52 Lucas Cruz: tudo certo
00:22:07 Luiz Almeida: sim
00:22:08 Debora Ribeiro: sim
00:22:08 Alexandre Flores Cordeiro: sim
00:23:15 Luiz Almeida: boa dica !!
00:25:54 Carlos Eduardo: dá pra aumentar a fonte? tá muito pequena
00:27:20 Eugenio: tá mesmo, difícil de enxergar
00:28:03 Luiz Almeida: sim, melhorou
00:28:08 Eugenio: precisa não
00:30:40 Pedro Russo: não sei se todos já perceberam, mas o JupyterLab
também está disponível pelo Anaconda Navigator
00:30:50 Luiz Almeida: igual
00:32:27 Pedro Russo: erro
00:32:33 Debora Ribeiro: erro, não substitui
00:33:46 Fabrício Pavanin Silva: então uma tupla é imutável?
00:34:34 Luiz Almeida: isso quer dizer q não é possivel fazer remove() e
append() ??
00:35:04 Luiz Almeida: blz
00:38:35 Pedro Riva: posso criar uma tupla de um elemento? como escrevo? pq (3)
não é tupla
00:38:48 Felipe Oliveira: (3,)
00:39:00 Pedro Riva: Obrigado @Felipe
00:39:07 Felipe Oliveira: Por nada :)
00:44:47 Humberto: Curioso que a tupla é imutável, mas, ao mesmo tempo, vc
consegue "sobrescrever" uma lista inteira sobre uma tupla, tornando a tupla
inteiramente mutável, então... é isso que eu entendi?
00:45:36 Let's Code: Humberto, o Python tem uma política meio "we're all
consenting adults" (somos todos adultos em consenso)
00:45:41 Pedro Russo: na verdade ele tá criando uma lista nova
(lista_auxiliar), e depois transformando ela em tupla (tupla_resultados)
00:45:59 Let's Code: Quando um programador cria uma tupla, ele está sinalizando
bem forte que aqueles dados idealmente não deveriam ser modificados
00:46:15 Silas: Luis, esse "drible" à rigidez da tupla, com o artificio de
uma lista auxiliar, é muito usado?
00:46:21 Let's Code: Mas se você importou esse código no seu projeto e quer
muito sobrescrever essa tupla, o Python não vai te impedir
00:46:31 Let's Code: Ele supõe que você é um cara prudente e sabe o que está
fazendo
00:46:38 Humberto: Sim, mas ele não criou uma nova tupla, ele sobrescreveu a
anterior. Ou seja, é um recurso que torna a tupla totalmente mutável.
00:47:12 Pedro Russo: ah sim, mas ele não está mudando os elementos da
tupla, ele criou uma variável nova
00:47:12 Let's Code: O lance é que ao te obrigar a ter que fazer tudo isso para
modificar a tupla, ele te deixou ciente que você está indo contra o projeto
original
00:47:26 Luiz Almeida: tudo tranquilo
00:47:28 Let's Code: Ele não te dá um caminho "fácil" para modificar a tupla
como acontece nas listas
00:48:56 Jonas Brasil: s
00:48:57 Ricardo Passador: ok
00:48:58 Luiz Almeida: tudo bem
00:54:23 Luiz Almeida: tudo ok
00:55:32 Luiz Almeida: ou return x ** 2, x ** 3
00:55:44 Felipe Oliveira: Lá no começo do notebook tem essa forma de criação
das tuplas
00:57:31 Jonas Brasil: s
00:57:33 Luiz Almeida: trnaquilo
00:57:33 Ricardo Passador: ok
00:59:20 Luiz Almeida: blz...
01:01:26 Fabrício Pavanin Silva: a tupla seria melhor para armazenamento de
dados então?
01:02:16 Luiz Almeida: por enquanto, sem duvidas
01:03:15 Pedro Russo: existem métodos como sum, max, min, etc para tupla
assim como temos para listas?
01:03:22 Pedro Russo: ou funções?
01:03:46 Pedro Russo: legal, valeu
01:07:27 Ricardo Passador: tudo ok
01:07:29 Luiz Almeida: tranquilo
01:11:41 Pedro Russo: to ferrado então...
01:11:41 Pedro Riva: Mas a chave não é univoca?
01:12:00 Pedro Riva: Pode ter dois 'Carlos'?
01:12:54 Luiz Almeida: interessante...
01:13:11 Jonas Brasil: s
01:13:11 Ricardo Passador: ok
01:13:13 Luiz Almeida: tudo certo
01:13:14 felipealiprandini: tudo certo
01:18:11 Ricardo Passador: ok
01:18:14 Debora Ribeiro: ok
01:18:14 Jonas Brasil: s
01:23:42 Jonas Brasil: substituir o valor
01:23:44 Eugenio: troca a nota da ana
01:23:45 Jonas Brasil: por 10
01:23:45 Ricardo Passador: vai aparecer 10 na segunda nota
01:23:47 Pedro Riva: vai mudar a segunda nota da ana
01:23:49 Rogerio Chinen: o zero substitui por 10
01:23:50 Luiz Almeida: vai colocar o 10 na segunda nota dela
01:25:12 Jonas Brasil: uma lista?
01:25:13 Alexandre Rozante: Retorna LIST
01:25:13 Luiz Almeida: lista
01:25:15 felipealiprandini: lista
01:25:16 Arthur Costenaro: lista
01:25:16 Pedro Russo: list
01:25:40 Rogerio Chinen: int
01:25:40 Arthur Costenaro: primeiro item da lista
01:25:40 Pedro Russo: int
01:25:40 Jonas Brasil: lista ainda
01:25:44 Leonardo Adams: 1
01:25:46 Pedro Riva: int
01:25:57 Leonardo Adams: int
01:26:29 Jonas Brasil: entendi
01:26:52 Ricardo Passador: ok
01:28:18 Pedro Russo: pode misturar tipos de chave?
01:28:20 Luiz Almeida: tudo certo
01:28:20 Jonas Brasil: ok
01:28:20 felipealiprandini: ok
01:28:22 Pedro Riva: eu já fiz dicionário de tuplas
01:28:29 Pedro Riva: na chave
01:28:49 Felipe Oliveira: Acho que qualquer valor imutável serve de chave
01:28:53 Let's Code: Qualquer estrutura imutável pode ser chave
01:29:03 Let's Code: string é mais usual, mas não é único :)
01:30:06 Pedro Riva: Pelo tipo de exercícios, e pelo erro do presença, acho que
o CLASS é feito pelos alunos
01:30:33 Jonas Brasil: s
01:30:36 Luiz Almeida: entendido
01:32:06 Humberto: Eu não vi diferença entre o pop e o del
01:32:28 Let's Code: Pedro, aproveitando a sua deixa, a Let's está recrutando
dev sênior justamente pra parte de web! ;)
Caso alguém se habilite (ou conheça quem esteja interessado), segue requisitos:
https://www.linkedin.com/jobs/view/2618583105/?refId=t56Lhme%2BwUyCYq%2BMObIYyg%3D
%3D&trackingId=owfdBFe1BW3g%2FzTH3XHeIg%3D%3D
01:32:43 Let's Code: Chance de ouro pra quem quiser resolver o bug das presenças
hehe
01:33:52 Felipe Oliveira: O pop() retorna o valor e depois ele o deleta. Por
exemplo, dicionário.pop('Ana') retornaria a lista de notas da Ana antes de tirá-la
do dicionário.
01:34:04 Felipe Oliveira: O del não.
01:34:40 Humberto: Entendi, Felipe, obrigado
01:35:02 Jonas Brasil: s
01:35:03 Ricardo Passador: ok, tranquilo
01:35:29 Ricardo Passador: as chaves
01:35:34 Pedro Riva: as chaves
01:35:38 Jonas Brasil: cahves
01:35:43 Jonas Brasil: eu também acho
01:36:22 Luiz Almeida: ok
01:36:51 Ricardo Passador: tudo ok
01:36:53 Jonas Brasil: to tranquilo
01:36:56 Luiz Almeida: exercicios...
01:37:00 felipealiprandini: td certo
01:37:10 Pedro Russo: dicionário não tem indice, certo?
01:39:03 Pedro Russo: só funcionaria se tivesse uma chave com o nome 0
né...
01:39:16 Pedro Russo: blz
01:39:42 Pedro Russo: usando ints como chave eu consigo ordenar o dict?
01:39:43 Luiz Almeida: ok....
01:43:38 Pedro Russo: legal, valeu
01:43:53 Luiz Almeida: por mim, tudo certo
01:44:23 Luiz Almeida: blz
01:44:49 Luis Fernando de Oliveira Uzai: Exercício pra entregar 5 e 12
01:45:40 Luiz Almeida: blz
01:48:23 Luiz Almeida: sugestão... desliguem a gravação da aula...
02:47:58 Luiz Almeida: boa idéia.
02:48:14 Rogerio Penchel: 4 é complicado sem except
02:48:28 Luiz Almeida: no meu caso, o problema atual é apenas no float, e
não da lógica
02:54:50 Luiz Almeida: para esse caso eu usei o .isnumeric()
02:56:31 Luiz Almeida: blz
02:56:41 Bruno Queiroz: ou, no melhor caso, devolver a lista apenas.
o que isso quer dizer?
02:57:08 Eugenio: se a lista não precisar de tratamento
02:57:18 Eugenio: ele devolve igual
02:57:24 Bruno Queiroz: pois é não entendi essa parte kkkkkkkkkkkkk
02:57:30 Luiz Almeida: se a lista só tem ints e floats, não precisa fazer
nada nela
02:57:34 Bruno do Carmo: pelo que entendi não tem string textuais no meio (ex.
"jacaré)
02:57:45 Bruno Queiroz: ficou parecendo tipo "se conseguir trata se não só
manda ela mesmo"
02:58:31 Rogerio Penchel: Entendi que a lista é alterada ela mesmo, Não que ela
seja retornada no return.
02:58:36 Bruno Queiroz: Assim faz sentido
02:58:38 Bruno Queiroz: Entendi
02:58:43 Pedro Russo: mas trata o que der ou desiste e devolve do jeito que
ela veio?
02:59:03 Rogerio Penchel: No return True or False. E a prórpria lista é
alterada.
03:00:10 Debora Ribeiro: Só que no caso, esse exercício não tem nada de tupla
ou dicionário. Ou é só pelo retornar, que retorna em tupla? Outra coisa, depois
podemos fazer o exercício 10?
03:00:22 Let's Code: É pelo retorno
03:01:54 Rogerio Penchel: É complicado, pode ser "-0.123.45", melhor é except
03:02:03 Luiz Almeida: no velho e bom Visual Basic havia o val(string)....
03:02:10 Bruno do Carmo: nossa verdade tem os casos negativos >.<
03:04:19 Rogerio Penchel: Só pode ter 1 ponto.
03:19:25 Ricardo Passador: sim
03:19:32 Luiz Almeida: sim.. a logica está ok..
03:22:19 Pedro Russo: se for um booleano funciona?
03:22:35 Luiz Almeida: roubada total....kkkkk
03:23:04 Pedro Russo: eu tava pensando True/False
03:23:05 Pedro Russo: isso
03:23:10 Pedro Russo: mas vc pode usar int(True)
03:23:35 Bruno Queiroz: eu tive que botar um try except se não, não ia de
jeito nenhum
03:23:39 Ricardo Tagliaverga: Rafael, passa a sua também ... so pra entender
como você resolveu esse
03:23:49 Let's Code: Sem problemas!
03:24:03 Ricardo Tagliaverga: boa ...
03:25:06 Ricardo Tagliaverga: Valeu Rafael ... é bom pra ter outras
visões. ...
03:25:36 Let's Code: Eu acho a minha versão um pouco mais complexa do que essa
versão, mas todas as etapas estão comentadas, acredito que dê pra entender o que
está rolando ali
03:26:03 Luiz Almeida: esclarecido, Luis... obrigado !!!
03:26:09 Ricardo Tagliaverga: perfeito Rafael .. é bom ...
03:26:15 Luis Fernando de Oliveira Uzai: def converteLista(lista):
todos_numericos = True
nova_lista = []
 for elemento in lista:
texto = str(elemento)
texto = texto.replace('.', '', 1)

if('-' in texto):
if(texto[0] == '-'):
texto = texto.replace('-', '', 1)

if(type(elemento) == int or type(elemento) == float):

nova_lista.append(elemento)
else:
if(texto.isdigit()):
nova_lista.append(float(elemento))
else:
nova_lista.append(elemento)
todos_numericos = False

return todos_numericos, nova_lista

03:26:20 Ricardo Tagliaverga: Valeu luis ... Excelente aula ...
03:26:27 Pedro Russo: valeu pessoal
03:26:36 Humberto: O que é texto[0], dá para acessar apenas uma letra de um
string?
03:26:41 Ricardo Tagliaverga: isso ... melhor que nesse fim deu um nó hahahah
...
03:26:41 Pedro Russo: parabéns pela primeira aula, Luís
03:26:50 Tsuyoshi: Parabéns, Luís!
03:26:52 Luiz Almeida: kkkkk
03:26:53 Pedro Russo: kkkkk
03:26:57 Ricardo Tagliaverga: Excelentes os professores ....
03:27:02 Ricardo Tagliaverga: valeu pela aula ...
03:27:24 Ricardo Passador: Valeu Luis, Parabéns e Boa Noite a Todos
03:27:35 Ricardo Passador: Professores show... valeu
03:27:36 Luiz Almeida: fechado, Rafa..
03:27:39 Pedro Russo: abraço pessoal