[INF1025] Dicas Gerais

Prévia do material em texto

INF1025: Introdução à Programação 
Monitor: André Vicente Pessanha 
Dicas Gerais: 
 
*************************************************************************************************** 
 
OBS: ​Esse PDF contém dicas que são úteis em todos os tópicos da matéria! (P1, P2 e P3) 
 
*************************************************************************************************** 
 
- Passo a passo de como executar um programa e criar um projeto novo no IDLE: 
 
Existem duas formas de escrever e testar seus programas em Python: A primeira é 
simplesmente abrindo o IDLE e usando o interpretador. Você vai notar que tem um símbolo 
com 3 setinhas ​>>>​ e qualquer comando digitado ali é automaticamente executado e o 
resultado já aparece logo abaixo. 
 
OBS​: Esse modo de uso é prático pra testar coisas simples, pois tudo que digitamos já é 
exibido na tela (Interpretador sempre chama a função print) mas se o programa tiver 2 
linhas ou mais recomendo escrever usando a segunda forma. 
 
A segunda forma é criar um novo projeto e escrever o programa como num bloco de notas. 
Pra criar um novo projeto use o atalho ​Ctrl + N ​na janela do interpretador ou clique em >> 
File​ << e depois em >> ​New File​ << 
 
Após terminar de escrever o programa, salve o projeto (​Ctrl + S​) e é só apertar ​F5​ pra 
executar e o resultado será exibido na janela do interpretador. (Sempre deixe uma janela ao 
lado da outra pra facilitar) 
 
OBS: ​Recomendo decorar esses atalhos o quanto antes, pois facilitam e muito na rapidez 
de alterar e testar o programa! E lembrando que aqui vamos precisar da função print pra 
exibir coisas na tela! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Como e onde salvar o código dos exercícios passados na aula? 
 
EX:​ Acabei de fazer o exercício 1 da lista, o professor pediu pra fazer o 2, mas não quero 
perder/apagar tudo que fiz do exercício 1, vou ter que criar um projeto/Documento novo pra 
cada exercício? :( 
 
NÃO! Temos duas opções: A melhor de todas é abrir uma janela do bloco de notas 
(​Notepad​) e assim que terminar de fazer um exercício, no mesmo segundo (Sim, 
exatamente no mesmo segundo) copie e cole toda a resposta do exercício para o bloco de 
notas! Dessa forma, sempre vamos ter uma janela do IDLE limpa e todos os gabaritos de 
todos os exercícios salvos no bloco de notas, melhor que isso impossível né? :) 
 
A outra opção é simplesmente comentar o código todo do exercício 1 (Usando o par com 3 
aspas) e fazer o exercício 2 logo abaixo. E só no final da aula passar tudo para o bloco de 
notas. 
 
 
OBS:​ Recomendo criar um bloco de notas por lista de exercício pra ficar mais organizado. 
 
 
OBS2:​ Se caso ocorrer algum erro ao salvar seu projeto é devido ao local ser restrito ao 
administrador. Por isso o recomendado é salvar o projeto na pasta documentos ou no 
próprio desktop pra facilitar ou melhor ainda, crie uma pasta chamada >> PythonProjects << 
e salve todos os seus projetos nela. 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Termos utilizados nos enunciados: 
 
 
Ler do teclado: 
 
Significa que o usuário vai digitar no teclado os dados que foram pedidos no enunciado. 
Então use a função ​input​ pra fazer a leitura e coloque uma mensagem pedindo pra inserir 
os dados. 
 
Imprimir/Exibir algo na tela: 
 
Significa que precisamos usar a função​ print​ pra exibir dados ou mensagens na tela. Esses 
dados serão exibidos na janela do IDLE. 
 
OBS:​ Sempre que o enunciado cita o nome das funções e dos parâmetros, é obrigatório 
usar >> ​Exatamente ​<< esses nomes no seu programa! 
 
OBS2:​ Mesmo se o enunciado citar que o programa deve funcionar para ​300​ valores lidos, 
teste com no máximo​ 2​ valores! (É só alterar a condição da repetição, mas lembre-se que 
isso é só pra testar! Na prova prática não se esqueça de mudar novamente para a 
quantidade pedida no enunciado ​antes​ de entregar a prova! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Comentários no código: 
 
Existem duas formas de fazer comentários no código: 
 
Usando >> ​#​ << pra comentário de uma >> única << linha. 
Ou um par com 3 aspas >>​"""​ << para comentários de várias linhas. 
 
OBS:​ Lembrando que fazer comentários não é só útil pra explicar o código. Pode ser útil em 
testes! Por exemplo, se suspeitamos que um trecho de código está causando erros no 
programa, é só colocar o >> # << no começo da linha e testar o programa novamente. 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Organização e Identação do código: (Muito Importante!!!) 
 
Identação é uma margem de espaço que colocamos antes de um trecho de código. 
Esse é um conceito muito importante em qualquer linguagem. Mas em Python, identação é 
super importante, bem mais que nas outras linguagens! 
Levando em conta que em Python, se por acaso sua indentação estiver errada, o programa 
simplesmente >> ​Não​ << vai funcionar! E justamente por causa disso, o critério de correção 
dos professores vai ser rigoroso, então muito cuidado! 
 
A principal vantagem da Identação é justamente facilitar a visualização do código, pois é a 
única forma de deixar bem claro o trecho de código que está >> Dentro << de um bloco 
(Seja de função, condição ou repetição!) 
 
EX:​ Um programa que pede pro usuário digitar 3 valores e exibe a soma parcial e a total. 
 
total = 0 
 
for i in range(1, 4): 
 x = float(input("Digite o " + str(i) + " valor:\n")) 
 total += x 
 print("Somatório Parcial: %.1f\n" % total) 
 
print("Somatório Total: %.1f\n" % total) 
 
 
Notou a diferença de espaço da margem em alguns trechos do código? :) 
Isso é justamente pra deixar claro tanto pra gente quanto pro interpretador qual trecho de 
código está >> ​Dentro do Bloco​ << do ‘for’ e qual trecho está >> ​Fora​ <<! 
 
EX2: (Erro Extra Fatal) 
 
total = 0 
 
for i in range(1,4): 
 x = float(input("Digite o " + str(i) + " valor:\n")) 
 ​ total += x 
 print("Somatório Parcial: %.1f\n" % total) 
 
print("Somatório Total: %.1f\n" % total) 
 
OBS:​ Notou que dessa vez o trecho >>​ total += x​ << está um pouco mais afastado para a 
esquerda que os outros? :O 
 
Se vc testar esse código no IDLE, o programa ​não​ vai rodar e vai aparecer o erro >> 
unindent does not match any outer indentation level​ << Isso ocorre porque Python 
sempre se baseia na identação do código pra identificar o que está fora ou dentro de um 
bloco de código com o seguinte critério: 
 
**************************************************************************************************** 
 
Regra muito importante: 
 
Todo trecho de código que NÃO possui identação, como por exemplo o trecho >> total = 0 
<< representa código que está >>​ FORA​ << de qualquer bloco. O trecho que está dentro da 
repetição ‘for’ possui uma identação que podemos chamar de >> ​Identação padrão​ << que 
é justamente no momento que digitamos os dois pontos >> : << no ‘for’ e apertamos a tecla 
>> ​Enter​ << ! 
Então qualquer identação diferente dessa, seja com tab ou apertando a tecla espaço, tem 
grandes chances de ficar diferente da ​Identação padrão ​e gerar um erro no programa! 
 
E se acontecer isso na prova teórica? 
 
É só imaginar que seu professor é uma tortuguita bem agressiva do módulo turtle, uma que 
possui cor de caneta vermelha e que vai riscar a prova exatamente no mesmo segundo que 
ver uma identação errada. :D 
 
 
 **************************************************************************************************** 
 
OBS:​ Um detalhe importante pra observar é que se caso vc esquecerde colocar os dois 
pontos (Seja em repetição, função ou condições) após apertar enter pra pular linha, vc vai 
notar que a identação automática >> Não << vai funcionar! Então exatamente no mesmo 
segundo vc vai lembrar que esqueceu de colocar os dois pontos! :) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Observações em Negrito na prova: 
 
Em algumas provas é pedido que o aluno faça um programa e utilize as funções cujos 
protótipos foram dados no enunciado. Mas muito cuidado! Antes de sair fazendo a função, 
dê uma olhada rápida no resto do enunciado e veja se tem alguma observação em negrito 
dizendo: As seguintes Funções >> NÃO << devem ser desenvolvidas, apenas chamadas! 
 
Nessas questões você vai fingir que a função está feita e >> SÓ << vai chamar! 
 
OBS:​ Levando em conta que a prova já tem um tempo bem limitado, então perder tempo 
tentando fazer uma função que o enunciado deixou claro que não era pra fazer é um erro 
extra fatal! :( 
 
A maioria dos enunciados vem com exemplos mostrando exatamente como seria o 
resultado esperado na tela. Se achar o enunciado confuso ou com muita informação, não 
perca tempo! Pule direto pro exemplo e tente entender a partir dele ou alterne entre o 
enunciado e o exemplo pra desvendar a questão! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Como ler vários valores do teclado numa única linha? (Atalho) 
 
É só usar o método >> ​split​ << do tipo string. Ela recebe como parâmetro um caracter que 
representa o critério de separação usado na leitura. 
 
EX: 
x, y = input("Digite dois valores:").split(' ') 
print(x, y) 
 
OBS: ​Recomendo sempre usar o caracter espaço como parâmetro da split, pois dessa 
forma o usuário vai digitar primeiro o valor de x, apertar espaço, digitar o valor de y e 
apertar enter somente no final. 
 
EX2: 
 
dia, mes, ano = input("Data de Nascimento: ").split(' ') 
print(dia + '/' + mes + '/' + ano) 
 
OBS:​ O nome disso é atribuição multivalorada (Semelhante em outras linguagens, como 
Lua) 
e funciona da seguinte forma, o primeiro valor digitado pelo usuário é armazenado na 
primeira variável (A que está mais na esquerda, a variável dia nesse segundo exemplo) e 
assim por diante. :) 
 
OBS​: Esse atalho de ler vários valores de uma só vez >> ​Não ​<< será ensinado em aula! O 
método split só será ensinado na P3 em Métodos de String e Arquivo. Então confirme com 
o seu professor se pode usar esse atalho em prova! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 
- Variáveis em Python: (Tipagem Dinâmica) 
 
É exatamente o mesmo esquema de Lua (E outras linguagens de alto nível) 
Ou seja, não precisamos nos preocupar em especificar o tipo da variável, pois o 
interpretador faz isso automaticamente! Lembrando que em linguagens baixo nível (Como 
C) temos que especificar tudo nos mínimos detalhes e qualquer detalhezinho errado faz o 
programa voar longe (Sim, muito longe mesmo!) Então sim, já pode começar a comemorar. 
:) 
 
 
EX: ​ Teste esse código e observe as mudanças no tipo da variável x. 
 
x = 2 
print(type(x)) 
x = "Isso é uma string" 
print(type(x)) 
x = 7.5 
print(type(x)) 
 
OBS:​ A função type exibe o tipo de uma variável. 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Melhor forma de exibir valores com casas decimais: 
 
 
EX: ​Um programa que o usuário digita o preço de um produto, acrescenta uma taxa e no 
final exibe o total na tela. 
 
taxa = 7.5 
valor = float(input("Digite o preço:\n")) 
valor += taxa 
print("Valor Total: %f" % valor) 
 
 
 
OBS:​ Como a função input ​sempre​ retorna o que foi lido no formato >> ​String​ << e como 
vamos fazer contas com o valor que foi lido. Precisamos converter para float ou int primeiro! 
No geral, nota, peso, altura e velocidade são valores do tipo float, então na dúvida use 
sempre esse tipo! 
 
Vamos supor que o usuário digite o valor 1: 
 
Será impresso: >> Nota : 8.500000 << 
Percebeu que quando usamos o formato ​%f​ o padrão é sempre exibir o valor com 6 casas 
decimais? :O 
 
Mas visualmente isso não fica muito bom. Por isso recomendo que use sempre o formato 
%.1f ​ou ​%.2f ​pra exbir valores do tipo float! 
 
Usando %.1f: >> Nota: 8.5 << (1 casa decimal após o ponto) 
Usando %.2f: >> Nota: 8.50 << (2 casas decimais após o ponto) 
 
OBS:​ Uma forma alternativa é usando: print(“Nota:”, nota) 
O único problema dessa forma é que não tem como limitar a quantidade de casas decimais. 
 
OBS2:​ Para exibir um conjunto de valores precisamos colocar parênteses entre os nomes 
das variáveis! EX: print("Resultados: %.2f %.2f\n" % (x, y)) 
 
OBS3:​ Algumas questões (Principalmente as da P3) podem exigir que o valor seja exibido 
com X casas decimais, então é bom já ficar preparado! Por isso recomendo utilizar esse 
formato desde a P1! :) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Nunca compare valores do tipo float 
 
Teste o seguinte código no IDLE: 
 
x = 9.4 - 9 - 0.4 
 
if(x == 0): 
 print("x vale zero!") 
else: 
 print("x é diferente de zero") 
 print("x vale", x) 
 
WHAT!? 9.4 - 9 - 0.4 Não dá zero? :O 
 
Isso é devido a erros de aproximação de casas decimais na memória, por isso >> ​Nunca​ << 
faça comparações de igualdade com variáveis do tipo float! 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 
 
- Critério de Verdadeiro e Falso em Python: (Atalho) 
 
O critério usado em Python é semelhante ao critério usado na maioria das linguagens: 
 
Uma variável que armazena um número >> ​diferente de zero​ << é verdadeira. (​True​) 
Uma variável armazena o valor >> ​zero​ << é falsa. (​False​) 
Uma string >> ​vazia​ << é falsa. (​False​) 
Uma string >> ​Não Vazia​ << é verdadeira. (​True​) 
 
Waaait! Que negócio é esse de zero é falso e diferente de zero é verdadeiro…!?!? 
O_O 
 
Estamos acostumados com teste de condições desse tipo: 
 
x = 10 
if( x == 10): 
 print("X vale 10! A condição if era True") 
else: 
 print("X NÃO vale 10! A condição if era False") 
 
Mas agora vamos criar um exemplo usando o critério acima: 
 
x = 10 
if( x ): 
 print("X possui um valor DIFERENTE de zero! A condição if é True") 
else: 
 print("X vale zero! A condição if é False!”) 
 
OBS:​ Esse atalho é muito útil quando temos uma função que faz uma verificação e retorna 
0 ou 1. (Ou qualquer valor diferente de zero) 
 
 
Ahh….Okay! Mas e esse negócio de string vazia..!? :O 
 
É simplesmente uma string que não possui caracteres, como por exemplo: 
 
nome = "" #String Vazia 
 
if(nome): 
 print("A string >> Não << está Vazia!") 
else: 
 print("A string está vazia!") 
 
Uma verificação muito usada em recursão com string é >> ​if(not nome) ​<< 
Pois queremos encerrar a recursão caso a string esteja vazia! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Atalhos na escrita: 
 
Na maioria dos programas, em algum momento podemos precisar usar um contador ou 
simplesmente fazer algum tipo de conta em que precisamos armazenar o resultado na 
mesma variável. (soma, subtração, etc) 
 
Escrever soma = soma + valor é exatamente o >> MESMO << que escrever soma+= valor 
 
soma = soma - valor é o mesmo que soma-= valor 
 
soma = soma * valor é o mesmo que soma *= valor 
 
soma = soma / valor é o mesmo que soma /= valorOBS:​ Um detalhe que é completamente diferente em Python é o operador potência, por 
exemplo, 2 elevado ao cubo se escreve >> ​2 ** 3​ <<! 
Mas muito cuidado com número negativos: (-3) ** 2 temos que colocar os parênteses 
obrigatoriamente, senão o resultado será -9! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Detalhe importante na divisão de números: 
 
 
res = 7 / 2 
 
Independente do tipo das variáveis (Float ou Int) o resultado da divisão sempre será em 
float! Então nesse caso res vale 3.5. E se a divisão fosse 4 / 2 o resultado é 2.0 (Tipo Float) 
 
res = 7 // 2 
 
Usando o operador >>​ //​ << podemos forçar o resultado a ser do tipo int (Sem casas 
decimais) Então nesse caso o res vale 3! (Sempre arredonda para baixo!) 
 
res = -7 // 2.0 
 
OBS:​ O resultado nesse caso é -4 (WHAT? Não seria -3? :O ) 
 Lembra que o arredondamento é sempre feito para baixo? :) 
Como estamos falando de números negativos, - 4 é >> ​Menor​ << que -3! 
 
res = 7 % 2 
 
O operador % representa o resto da divisão, sua principal utilidade é indicar se um número 
é divisível por outro. (Se res vale zero significa que o número é divisível. E como nesse 
exemplo, res vale 1, então 7 não é divisível por 2) 
 
res = 3 ** (1 / 2) 
 
OBS:​ Nesse caso o uso de parênteses é obrigatório! Muito cuidado com a ordem de 
precedência! A operação potência tem a maior precedência que multiplicação e divisão, por 
isso se omitir os parênteses, a primeira operação feita será 3 elevado a 1 e o resultado 
dividido por 2. 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Nunca use repetição while ou for em recursão: 
 
Recursão é como se fosse uma repetição while! (Repetição infinita/Indeterminada) 
Então >>​NUNCA​<< use while ou 'for' com recursão! Justamente pelo fato da recursão já ser 
uma repetição! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Documentação de Python: 
 
Podemos acessar a documentação de Python pesquisando na internet ou simplesmente 
usando a função >> ​help​ << que recebe como parâmetro o nome de um módulo ou o nome 
da função de um módulo. 
 
 
import math 
print(help(math)) 
 
Exibe uma listagem completa de quais funções (cos, sin, radians, etc) e quais constantes 
(pi, e, etc) pertencem ao módulo math! 
 
OBS:​ Lembrando que pra usar o help precisamos >> importar << o módulo que queremos 
usar, senão o nome math não será reconhecido! 
 
E se queremos saber o que uma determinada função faz? 
 
print(help(math.cos)) 
 
Exibe a descrição do que a função cos do módulo math faz. Nesse exemplo será exibido na 
tela >> ​Return the cosine of x (measured in radians)​ << E baseado nessa descrição 
acabamos de nos deparar com outro detalhezinho importante! O valor colocado na função 
cos, sin, tan precisa ser convertido para >> ​Radianos​ << ! 
 
Então​ ​para calcular o cos(60) temos que fazer >> print( math.cos( ​math.radians( 60 )​ ) ) << 
 
Durante as aulas será ensinado sobre os módulos math, random, dentre outros. E você, 
caro leitor, vai se ver diante de uma quantidade infinita de funções que cada um desses 
módulos possui e vai tentar decorar todas, mas antes de se aventurar nisso, leia a frase 
abaixo. :D 
 
Funções ou métodos externos costumam ser citados no enunciado da prova! (Ou pelo 
menos listada numa folha à parte) Por isso é muito importante ficar de olho nos exemplos e 
observações que costumam estar em​ negrito​ na prova! Nos resumos de cada tópico da 
matéria, citei os métodos mais usados, então é só decorar aqueles e os mais usados nas 
aulas, levando em conta que de tanto praticar nos exercícios vc já vai decorar naturalmente. 
:) 
 
------------------------------------------------------- // ------------------------------------------------------------