Conteúdo das reuniões

---

---

10/12 - Assista ao vídeo

Terminamos de construir a nossa biblioteca matriz.py de funções para manipularmos matrizes. Em particular foi apresentado como gravar o conteúdo de uma matriz em um arquivo. Os passos seguidos foram abrir o arquivo para escrita com arq = open(nome_arq, 'w', encoding='utf-8'), escrever no arquivo com arq.write() (é o print() para arquivos) e finalmente fechar o arquivo com arq.close(). Aqui arq é o nome da variável que faz referêcia ao arquivo e nome_arq é uma string com o nome do arquivo. Finalmente, acrescentamos ao módulo matriz.py as funções:

• rode_dir(): retorna uma matriz dada rotacionada para a direita;
• rode_esq(): retorna uma matriz dada rotacionada para a esquerda;
• gire_vertical: retorna uma matriz dada refletida verticamente;
• prod(): retorna a matriz produto de duas matrizes dadas;
• grave_matriz(): grava uma matriz em um arquivo;
• veja aqui o que o Python acha sobre uma versão de gire_horizontal() com problemas;
• editor.py: programa que estamos usando para manipular matrizes através da nossa biblioteca.
• prod.py: programa que estamos usando para manipular matrizes através da nossa biblioteca.
• rabiscos e programas

---

08/12 - Assista ao vídeo

A nossa estratégia para brincar com matrizes tem sido cria uma biblioteca de funções que manipulam matrizes. Estamos colocando nossos funções no módulo matriz.py. Para usar as funções nesse módulo em algum programa temos escrito import matriz as mt no início do programa. Deste ponto em diante, com o prefixo mt seguido de . e um nome, indicamos a função da nossa biblioteca que queremos usar: mt.crie_matriz(nlin, ncol), mt.exiba_matriz(m), … Escrevemos uma função leia_matriz_teclado() que os valores de uma matriz de números inteiros digitada através do teclado. Escrevemos a função leia_matriz_arquivo() que lê de um arquivo os valores de uma matriz de números inteiros. Fizemos ainda uma fução rode_horizontal() que recebe uma matriz e retorna uma nova matriz que é a matriz dada refletida no eixo horizontal.

• matriz.py: é o arquivo com a biblioteca para manipulação de matrizes que estamos construindo.
• leia_matriz.py: programa para testar nossas funções para leitura de matrizes de números inteiros.
• editor.py: programa que estamos usando para manipular matrizes através da nossa biblioteca.
• rabiscos e programas

03/12 - Assista ao vídeo

Continuamos o nosso estudo sobre matrizes: tabelas bidimensionais. Iniciamos a construção de uma biblioteca matriz.py com funções para manipularmos matrizes. Começamos essa biblioteca com algumas funções que havíamos escrito na reunião passada: simetrica(), linhas_val(), colunas_val() e diagonal_val() Escrevemos uma função to_str() para exibirmos matrizes com print() de uma maneira mais estruturada. Escrevemos uma função init_matriz() para criarmos matrizes. A seguir a vários links para o visualizador do Python com várias tentativas escrevermos init_matriz(), muitas erradas

• matriz.py: é o arquivo com a biblioteca para manipulação de matrizes que estamos construindo
• simetrica.py: programa para treinar o uso da biblioteca matriz; note a linha import matriz as mt.
• to_str.py: programa que testa a função to_str() da nossa biblioteca matriz; note a linha import matriz as mt.
• init_matriz.py: programa para testar a função init_matriz() da nossa biblioteca matriz; note a linha import matriz as mt.
• uma tentativa de init_matriz(): veja aqui a opinião do Python
• outra tentativa de init_matriz(): veja aqui a opinião do Python
• mais uma tentativa de init_matriz(): veja aqui a opinião do Python
• mais uma outra tentativa init_matriz(): veja aqui a opinião do Python
• ainda mais uma outra tentativa de init_matriz(): veja aqui a opinião do Python
• nossa última tentativa de init_matriz(): veja aqui a opinião do Python
• simulação “simples”: veja aqui o que o Python tem a dize
• rabiscos e programas

01/12 - Assista ao vídeo

Começaremos a conversar sobre como representar matrizes (=tabelas bidimensionais em Python) através de listas de listas (list[list]). Nosso principal foco foi em maneiras de percorrer matrizes e em nos habituarmos com seus índices e suas posições.

• simetrica.py: verifica se uma matriz é simétrica percorrendo a matriz linha por linha
• linha_val.py: conta o número de linhas que possui apenas um dado valor
• coluna_val.py: conta o número de colunas que possui apenas um dado valor
• diagonal_val.py: retorna True se nas diagonais principal e secundaria todos os elementos são de um dado valor
• rabiscos e programas

26/11 - Assista ao vídeo

Hoje foi a nossa partida do reino dos dicionários. Criamos, percorremos e modificamos dicionários.

• pi.py: resolve o exercício das consultas interativas, lê o um arquivo com os dígitos de um número gigantesco como pi e um inteiro k cria um dicionário (dict) formado pelas fatias de comprimento k do número, responde interativamente a consultas, pecorre um dicionário para encontrar a chave de maior valor (for chave in dicio:...), exibe as chaves de um dicionário (dicio.keys()) e seu valores (dicio.values())
• rabiscos e programas

24/11 - Assista ao vídeo

Mais viajem por dicionários. Vimos ainda como ler o conteúdo de um arquivo, linha por linha.

• consultas_interativas.py: resolve o exercício das consultas interativas, lê o um arquivo csv linha a linha com (for linha in arq:...), cria um dicionário (dict) com o conteúdo do arquivo, responde interativamente a consultas, pecorre um dicionário para encontrar a chave de maior valor (for chave in dicio:..)
• veja aqui o que o visualizador tem a dizer sobre dicionários e seus apelidos
• rabiscos e programas

---

19/11 - Assista ao vídeo

Passamos a caminhar no reino dos dicionários encantados, também vimos alguns arquivos nascendo pela floresta:

• palavras_list.py: resolve o exercício da frequência de palavras usando duas listas, lê o texto de um arquivo e cria um arquivo csv com o resultado da contagem
• palavras_dict.py: resolve o exercício da frequência de palavras usando um dicionário (dict), criamos dicionários vazios com dicio = {}, consultamos se uma chave está no dicionário com if pal in dicio: ..., inserimos um novo par chave-valor no dicionário com dicio[pal] = 1, alteramos o valor de uma chave com dicio[pal] += 1, percorremos as chaves de um dicionário com for pal in dicio: ...
• veja aqui o que o visualizador tem a dizer sobre dicionários
• rabiscos e programas

17/11 - Assista ao vídeo

Hoje manipulamos mais uma vez strings. Fizemos um programa que lê uma linha em que campos são strings separadas por vírgulas. A função principal que fizemos faz algo semelhante ao método split(): cria uma listas em que os itens são strings dos campos. Veja os vídeos a seguir com mais explicações sobre strings e sobre o método split() que será muito útil no EP11.

• revisão strings, caracteres e arquivos: vídeo
• exercício leitora csv, função separe() e método split(): vídeo
• leitora_csv.py: lê uma linha em que os campos estão separados por vírgulas
• leitora_csv_de_luxe.py: lê uma arquivo em que cada linha tem campos separados por vírgulas
• rabiscos e programas

12/11 - Assista ao vídeo

Continuamos a tratar de strings e suas muitas semelhanças e diferenças com listas. A maior diferença entre esses dois objetos é que listas são mutáveis enquanto strings são imutáveis. Resolvemos dois exercícios, arranca espaços e o palavra mais longa. Ambos serviram para exercitarmos o nosso raciocício através do uso de strings.

• limpe.py: nossa solução do exercício arraca espaços
• maior-palavra.py: nossa solução do exercício palavra mais longa
• str_imutabilidade.py: reveja aqui essa simulaçã que vimos na reunião passada
• str_imutabilidade2.py: reveja aqui essa outra simulação que tambéms vimos na reunião passada
• rabiscos e programas

10/11 - Assista ao vídeo

Hoje conversamos sobre strings e suas semelhanças e diferenças com listas. Strings e listas podem ser manipuladas de uma maneira muito semelhante. Talvez a maior diferença entre esses dois objetos é que listas são mutáveis enquanto strings são imutáveis.

• fatias.py: veja aqui uma simulação para revisar fatias, clones, apelidos e o operador is
• mutacao1.py: veja aqui uma simulação que trata de apelidos e mutação de listas em funções
• mutacao2.py: veja aqui uma outra simulação que trata de apelidos e mutação de listas em funções
• conta_vogais.py: nossa solução para o problema central dessa reunião
• str_imutabilidade.py: veja aqui uma simulação que mostra que strings são imutáveis
• str_imutabilidade2.py: veja aqui outra simulação sobre imutabilidade de strings: cada string é única
• rabiscos e programas

05/11 - Assista ao vídeo

Hoje conversamos sobre apelidos, clones e mutabilidade de listas. No exercício sobre o crivo de Eratóstenes trabalhamos sobre mutabilidade na função risque_multiplos().

• fatias.py: veja aqui uma simulação para revisar fatias
• clones x apelidos: veja a simulação aqui com apelidos, clones e fatias
• operador is: se A is B é True então A e B são apelidos para uma mesma coisa/valor/objeto. Se A is B então A == B, mas o contrário pode não valer.
• is.py: veja aqui uma simulação para revisar “apelidos x clones” e os operadors == e is entre lista
• dobra.py: veja aqui uma simulação que mostra o efeito de mutabilidade ao usarmos funções com listas como parâmetros
• veja está simulação aqui onde vemos clones e apelidos em ação e as diferençao e semelhanças entre == e is
• eratostenes.py: é a solução que fizemos para o exercício do crivo de Eratóstenes: no que diz respeito a consumo de tempo, essa solução é mais eficiente que outra que testa um após o outro de um número é primo.
• rabiscos e programas

03/11 - Assista ao vídeo

Hoje começamos a tratar de uma ferramenta muito útil em Python que são as fatias de listas. Na próxima reunião veremos como as fatias nos levarão aos conceitos de apelidos e clones. O exercício que nos levou até fatias foi o de determinar uma fatia de soma máxima de uma lista. Fizemos uma função que retorna uma fatia de uma lista e vimos as fatias nativas do Python: lst[ini: fim].

• somamax.py: nossa primeira solução para o exercício
• somamax_de_lux.py: solução idêntica à nossa, mas que usa a função sum() e as fatias nativas do Python;
• rabiscos e programas

29/10 - Assista ao vídeo

Continuamos a resolver exercícios que manipulam listas, criam listas e funções que têm listas como parâmetros. Também fomos apresentados ao operador in para verificar se um item pertence ou não a uma lista. Estamos utilizando cada vez mais o comando for _ in range(início, fim, passo): ....

• filtro.py: programa que lê uma sequência de números inteiros e imprime os itens da sequência se repetição
• veja aqui uma simulação do programa filtro.py
• filtro_de_luxe.py: idêntico ao problema anterior, com a diferença que além de imprimir os itens na sequência exibe a frequência de cada item na lista.
• rabiscos e programas

27/10 - Assista ao vídeo

Hoje listas e funções que recebem listas como argumentos ou que criam e retornam listas trabalharam juntas. Fizemos o mesmo exercícios que envolvia listas de notas e médias provas de duas formas diferentes; primeiro apenas com uma função main() e depois com a função main() e várias outras auxiliares. Também houve a apresentação formal do comando de repetição for _ in range(inicio, fim, passo): ...

• esta simulação aqui foi usada para recordar o que vimos na semana passada sobre listas
• medias.py: exercício com lista e apenas com uma função main()
• medias_com_funcoes.py: tem além da função main() as função leia_nota() que retorna uma lista, media_notas() que recebe uma lista e retorna a média de seus valores e a função maiores_media() que recebe uma lista e uma valor val e retorna uma lista com os valores em notas que são maiores que val
• veja aqui algumas simulações do comando for _ in range(inicio, fim, passo): ...
• rabiscos e programas

22/10 - Assista ao vídeo

Hoje conversamos sobre um conceito que no dará mais asas: listas. Uma variável lista lst com n elementos é um apelido* para um sequência de variáveis [lst[0], lst[1], lst[2], ..., lst[n-1]]. Isso nos permite resolver mais problemas de uma maneira bem compacta. O que ajuda muito é o fato de índice de lst poder ser uma variável. Hoje conversamos sobre:

• lista vazia: lst = []
• concatenação de lista: [4, True, None] + [1, 2, 3] == [4, True, None, 1, 2, 3]
• comprimento de listas: len(lst) é o número de itens na lista lst
• índice de listas: vão de 0 a len(lst)-1
• inverte.py: listas, operador + de concatenação de listas, construção de listas, lista vazia, índices
• frequencia.py: operador * concatenação iterada de listas, por exemplo, 37 *[0]
• veja essa simulação aqui
• rabiscos e programas

20/10 - Assista ao vídeo

Hoje continuamos nossa conversa sobre funções e caluculos aproximados. Fizemos um programa que calcula ex com uma precisão eps dada. Aproveitamos para constatar a diferença entre float e int ao calcularmos a função fatorial. Os valores int em python são potencialmente ilimitados, valores float podemos usar certa de 15(?) dígitos. Vimos pela primeira vez o uso de módulos em Python. Visitamos o módulo math. As funções e constantes desse módulo podem ser utilizadas depois de fazermos import math no nosso programa.

• exp1.py e exp2.py: parâmetro epsilon para indicar precisão desejada da aproximação de ex
• exp1.py, modulo(): a execução de uma função é abandonada quando chegamos o return
• exp2.py: a biblioteca math, import math, módulos
• exp2.py: na funçãoE()` fatorial e potencial não são recalculados, reutilização de computações anteriores
• exp3.py: reutilizamos o valor de termo anterior
• rabiscos e programas

15/10 - Assista ao vídeo

Tópicos centrais desta aula foram:

• hn.py: números harmônicos mostram que operação com float não são comutativas
• hn.py: números harmônicos mostram que frequentemente calculamos aproximações
• fatorial.py: em Python int são potencialmente ilimitados
• fatorial.py: floats usam cerca de 16 dígitos decimais
• Simule um exemplo simples com função aqui
• Simule aqui um exemplo simples de função que retorna None
• rabiscos e programas

13/10 - Assista ao vídeo

Hoje continuamos nossa jornada através do mundo encantado das funções.

• pascal: solução usa uma função fatorial() e uma função binomial(), além da função main().
• Simule a solução aqui.
• fração irredutível: usa uma função mdc(), além da função main()
• Simule a solução aqui.
• Simule um exemplo simples com função aqui
• rabiscos e programas

08/10 - Assista ao vídeo

Hoje conversamos sobre um conceito novo e absolutamente fantástico: funções.

• binomial: três soluções, sendo que a última usa funções.
• Simule solução 1 aqui.
• Simule solução 2 aqui.
• Simule solução com função aqui.
• Simule um exemplo com função aqui
• rabiscos e programas

06/10 - Assista ao vídeo

Hoje fizemos o exercício da provinha 05 de encontrar o maior e o menor número de uma sequência. Fizemos ainda dois exercícios que tinham aver com repetições encaixadas: o exercício da tabuada e o do troco. O exercício do troco tem ainda um uso bem bacana de indicadores de passagens e pode ser acelerado trocando um while nb*b + na*a <= c: ... por uma simples atribuição nb = (c - na*a)//b.

• maiormenor.py: solução do problema da provinha 05
• tabuada.py: solução do exercício da tabuada
• troco.py: solução do exercício do troco
• veja aqui uma simulação do exercício da tabuada
• rabiscos e programas

01/10 - Assista ao vídeo

Hoje fizemos dois exercícios. (◠﹏◠) O exercício de decidir se um dado número é primo em que usamos um indicador de passagem. Há várias versões possíveis para uma solução. Isso é bem legal! Fizemos também o problema de decompor um número inteiro en fatores primos. Nesse problema discutirmos a ideia de simplificar um problema. Isso nos levou naturalmente a uma solução com repetição encaixada: um while .. dentro de outr while.... Esse tipo de estrutura é explorada no EP05.

• primo.py: solução do exercício dos primos.
• fatores.py: solução do exercício de decompor um número inteiro em fatores primos.
• rabiscos e programas

29/09 - Assista ao vídeo

Fizemos apenas o exercício do tiro ao alvo (҂◡_◡). Pelo menos ele é bem legal! (◠﹏◠) Esse foi em exercício que treinamos raciocício, fazer as tarefas passo a passo, uma coisa por vez. Também teve muito indicador de passagem na solução.

• tiro.py: nossa solução para o problema do tiro ao alvo
• veja aqui a simulação da solução
• rabiscos e programas

24/09 - Assista ao vídeo

Fizemos o exercício da sequência crescente e dos dígitos adjacentes iguais. A estrutura das soluções para ambos os problemas é idêntica. Usamos esses problemas para estudar indicadores de passagem que são uma baita ideia. Esses indicadores são variáveis que nos dizem se o fluxo de execução do programa passou ou não em algum lugar. São usadas para nos dizer se algo aconteceu ou não, se é verdadeiro ou falso, se é True ou False.

• crescente0.py: primeira versão que fizemos, usa um contador que no fundo o que interessa é se ele é ou não um certo valor, no caso n-1
• crescente1.py: transformamos o indicador em uma variávels que assume os valores 0 para crescente e 1ara não crescente
• crescente2.py: esta versão é semelhante à anterior, mas usa uma variável crescente que é Trueou False
• adjacentes.py: solução o problema de dígitos adjacentes iguais; a estrutura dessa solução é idêntica a crescente2.py
• rabiscos e programas

22/09 - Assista ao vídeo

Fizemos apenas o exercício dos multiplos de i e j (҂◡_◡). Mas fizemos três versões (◠﹏◠). Em uma versão vimos o operador lógico or e aproveitamos a oportunidade falamos do and. Ainda tem um outro, o not, ao qual ainda precisamos ser apresentado. Precisamos nos acustamar a esses operadores. Faremos isso pouco a pouco. Um outra versão que fizemos, a de luxe, era muito mais eficiente, apesar de que eficiência não é o ponto de MAC0110. Essa versão de luxe usava uma estrutura if-elif_else e uma ideia bem bacana. Finalmente, conversamos um pouco sobre abreviaturas como i += 1, pot2 *= 2, …

• multij_ini.py: primeira versão que fizemos, usa if-elif para imitar um or
• multij.py: usa condição com o operador or
• multij_de_luxe.nota.py: tem uma estrutura if-elif-else e uma ideia bem bacana.
• rabiscos e programas

17/09 - Assista ao vídeo

Fizemos exercícios que envolviam decomposição, determinação do precesso repetitivo, padrão de código para repetir um bloco de comandos um dado número n de vezes. Também trabalhamos os operadores // e % e comandos if e if-else vistos na reunião passada. Utilizamos pela primeira vez a estrutura de execução em cadeia de if-elif-else.

• conte_digitos.py: programa que dado um número inteiro n e um dígito d determina o número de ocorrências de d em n
• nota.py: programa que dado um número inteiro n e n notas de alun@s determina quant@s foram reprovad@s, estão de recuperação, foram aprovados ou são bam-bam-bam
• veja aqui o comando do repetição while em ação
• veja aqui o comando de execução condicional if em ação
• veja aqui o comando de execução alternativa if-else em ação
• veja aqui o comando de execução em cadeia if-elif-else em ação
• rabiscos e programas

15/09 - Assista ao vídeo

Hoje fizemos uma revisão que demorou um tempão e depois fizemos um problema que nos levou a sermos apresentados aos operadores aritméticos \\ de divisão inteira e % de resto de divisão. Além disso vimos o comando de execução condicional if e de execução alternativa if-else

• pares_impares_if.py: programa que um número inteiro n e uma sequência com n números inteiros e determinar o número de pares e ímpares da sequência. Essa versão usa o comando de execução condicional if
• pares_impares_if_else.py: programa que um número inteiro n e uma sequência com n números inteiros e determinar o número de pares e ímpares da sequência. Essa versão usa o comando de execução alternativa if-else
• rabiscos e programas

10/09 - Assista ao vídeo

A conversa principal hoje foi sobre decomposição de problemas e reconhecimento de padrões. O reconhecimento de padrões foi materializado através do comando de repetição while. Também vimos mais um operador aritmético, o operador **: n ** k é n elevado a k.

• potencia.py: programa que lê dois inteiros n e k e calcula n elevado a k
• fatorial.py: programa que lê um inteiro n e calcula n!
• rabiscos e programas

---

08/09 - Assista ao vídeo

A conversa principal hoje foi sobre o comando de repetição while. Repetição é um instrumento que nos dá asas. Devemos reconhecer padrões na tarefa que estamos fazendo e determinar os “atores” que estão sendo alterados. Para esses usamos variáveis. Também discutimos sobre tipos: int, str e agora bool que tem dois valores True (verdadeiro) e False (falso). O resultados das condições são True e False. No momento, as nossas condições utilizam apenas os operadores che são chamados de relacionais: <, <=, >, >=, ==, e !=. Fora isso, recordamos (quase) tudo da aula passada.

• soma.py: programa que calcula a soma de uma sequência de números inteiros terminada por um 0
• impares.py: programa que lê um inteiro n e imprime os n primeiros números ímpares
• rabiscos e programas

03/09 - Assista ao vídeo

Hoje, apesar de algumas dificuldades ¯\_(ツ)_/¯, o spyder foi apresentado a tod@s. Python é uma linguagem interpretada. Conversamos sobre a diferença entre o modo interativo do Python Shell e do mode script do programa. Conversamos sobre operações aritméticas, variáveis, função print() para exibir mensagens, valores int de inteiros e str de strings, f-strings usadas no print(), função input()para ler valores e função int() para converter uma valor str para um valor int. Ufa! Quanto coisa! (⊙_◎)

• celsius_fahrenheit.py: programa que converte o valor de uma temperatura de Celsius para Fahrenheit
• tentativa0.py a tentativa6.py: passo a passo para escrevermos um programa que calcula a soma de dois números inteiros dados
• rabiscos

01/09 - Assista ao vídeo

Houve um blá-blá-blá inicial sobre MAC0110. Falou-se um pouco sobre o raciocício que queremos treinar. Teve também um modelo de computador simples, a simulação de um programa simples no computador simples. O programa simples foi traduzido para uma descrição mais simples ainda e próxima daquela que usaremos nos nosso programas. Alguns rudimentos de conceitos que esbarramos e devemos guardar para as próximas reuniões são variável e repetição.

• rabiscos