Python: Anotações

Julio Patti

2021
Operadores:

 Adição e Subtração normal: + e –

 Multiplicação e Divisão: * e /
 Potenciação: **
 Divisão Inteira: // (ex: 5//2 = 2)
 Resto da divisão: % (ex: 5%2 = 1)

PyCharm 2017.1

1. Pode-se criar ou abrir um projeto pelo PyCharm. Normalmente os últimos

manipulados ficam em evidência à esquerda.

2. Caso algum projeto esteja aberto, para aparecer a tela anterior é só fechar o projeto
aberto:
3. No projeto criado, ou já existente, para criar uma rotina basta clicar com o botão
direito na caixa do projeto -> New -> Python file e nomear a nova pasta:

4. Para rodar:

 Comentar e descomentar: [Ctrl] + [/?] ( o que está entre [] são as teclas Ctrl e
a tecla /?)
 5. Chamar funções e pacotes importados:

import math
from math import sqrt
num=float(input('Informe um número: '))
raiz=math.sqrt(num) #do modo geral (import pacote)
raiz2=sqrt(num) # do modo específico (from pacote import função)
print('raiz com o import 1: {}. raiz com o import 2:
{}'.format(raiz,raiz2))

Cores:

Figura 1: Cores

 \033[m : volta ao padrão que está configurado

Exercícios Muito Básicos

Ex001:

msg = 'olá mundo'

print(msg)

Ex002:

nome = input('Digite seu nome: ')

print('É um prazer te conhecer, {}!'.format(nome))

Ex003:

n1=int(input('Entre com um número inteiro: '))

n2=int(input('Entre com outro número inteiro: '))
s=n1+n2
print('O valor da soma entre', n1,'e', n2, 'é', s,'!')#note o espaço
na exclamação
print('A soma entre {} e {} é {}!'.format(n1,n2,s))
print('A soma entre {0} e {1} é {2}!'.format(n1,n2,s)) #preferível

 O primeiro print deixa um espaço na exclamação como este !

 A segunda e terceira forma são melhores e aconselháveis. A ordem do número entre
chaves “{}” designa a ordem de impressão no “.format”. Observa-se que começa em
“0” a primeira posição do format.
Ex004:

###### Ao que tudo indica isso só avalia a string.. não vale para
números e não
# consegui fazer nada para identificar números decimais em strings ou
reais
# não faz muito sentido o "isdecimal" por enquanto

n=input('Digite qualquer coisa ')

print('Classificação da variável quanto à conversão:')
print('is {} that "{}" is a number (parece só valer para
inteiro)'.format(n.isnumeric(),n))
print('is {} that "{}" is a word (letras do alfabeto somente e espaço
torna falso)'.format(n.isalpha(),n))
print('is {} that "{}" is a alphanumeric (letras e
números)'.format(n.isalnum(),n))
print('is {} that "{}" is a upper word (só
maiúsculas)'.format(n.isupper(),n))
print('is {} that "{}" is a lower word (só
minúsculas)'.format(n.islower(),n))
print('is {} that "{}" is a decimal'.format(n.isdecimal(),n))
print('is {} that "{}" is a digit'.format(n.isdigit(),n))
print('is {} that "{}" is printable'.format(n.isprintable(),n))
print('is {} that "{}" is a space (um ou mais
espaços)'.format(n.isspace(),n))
print('is {} that "{}" is a title (Capitalizada - primeira maiúscula e
o resto minúscula)'.format(n.istitle(),n))
print('is {} that "{}" is a identifier'.format(n.isidentifier(),n))

 O que costuma ser lido em um “input” direto, costuma ser tratado como string. Mas o
isnumeric funcionou para identificar número inteiro

Ex005:

n=int(input('Entre com um número inteiro: '))

antecessor=n-1
sucessor=n+1
print('O antecessor de {} é {}.'.format(n,antecessor),end=' ')#junta a
linha de baixo
print('O sucessor de {} é {}.'.format(n,sucessor))
Ex006:

n=float(input('Digite um número real: '))

Dobro=2*n
triplo=3*n
raiz=n**0.5
print('O dobro de {} é igual a {}.'.format(n,Dobro))
print('O triplo de {} é igual a {}.'.format(n,triplo))
print('A raiz quadrada de {} é {:.4f}, considerando quatro casas
decimais.'.format(n,raiz))

 float recebe um racional. Entre chaves no print mostra a apresentação, por exemplo
{:.4f} com 4 casas decimais
 Deu uma certa imprecisão quando não especificado o numero de casas no seguinte
exemplo:

Ex007:

# Nota do aluno
n1=float(input('Entre com sua primeira nota: '))
n2=float(input('Entre com sua segunda nota: '))
media=(n1+n2)/2
print('Sua média das notas {} e {} é: {}.'.format(n1,n2,media))

Ex008:

comprimento=float(input('Entre com o comprimento em metros (m): '))

comprimentocentimetros=comprimento*100
comprimentomilimetros=comprimento*1000
print('O comprimento {}m = {}cm =
{}mm'.format(comprimento,comprimentocentimetros,comprimentomilimetros)
)

Ex009:
# vou supor que a tabuada seja de números inteiros de 1 a 9, com
múltiplos de 1 a 9
n=int(input('Entre com um número positivo inteiro de 1 a 9 para
retornar a tabuada: '))
print('1x{0}={9} 2x{1}={10} 3x{2}={11} 4x{3}={12} 5x{4}={13}
6x{5}={14} 7x{6}={15} 8x{7}={16}
9x{8}={17}'.format(n,n,n,n,n,n,n,n,n,n,2*n,3*n,4*n,5*n,6*n,7*n,8*n,9*n
))

 Exemplo de ordenação do print – format:

Ex010:

# Conversão para dólar

n=float(input('Digite a quantia a ser convertida de Reais para Dólares
(cotação US$=3,27R$): '))
print('R${:.2f} = US${:.2f}'.format(n,n/3.27))

 Contas podem ser realizadas no print

Ex011:

altura=float(input('Digite a altura da parede em metros: '))

largura=float(input('Digite a largura da parede em metros: '))
area=altura*largura
volumedetinta=area/2
print('A área da parede corresponde a {}m².'.format(area))
print('Cada litro de tinta pinta 2m² de área')
print('Para pintar a área de {}m² são necessários {} litros de
tinta.'.format(area,volumedetinta))

Ex012:

# Aplicação de desconto
preco=float(input('Digite o preço do produto ao qual se aplicará o
desconto: '))
d=float(input('Digite o desconto a ser aplicado em porcentagem (%):
'))
print('O preço do produto passa de R${:.2f} para R${:.2f} aplicando {}
% de desconto.'.format(preco,preco*(100-d)/100,d))
Ex013:

# Cálculo do novo salário com aumento percentual

salarioatual=float(input('Digite o salário atual ao qual se aplicará
um aumento percentual: '))
aumento=float(input('Digite o aumento percentual a ser aplicado em
porcentagem (%): '))
print('O salário de R${:.2f} passa a ser de R${:.2f} com o aumento de
{}%.'.format(salarioatual,salarioatual*(100+aumento)/100,aumento))

Ex014:

# Coversão de graus Célsius (centígrados) para Fahrenheit

c=float(input('Digite a temperatura em ºC para ser convertida em ºF:
'))
f=9*c/5+32
print('A temperatura de {}ºC corresponde a {}ºF'.format(c,f))

Ex015:

# O aluguel de um carro custa R$60,00/dia e R$0,15/km rodado. Faça um

programa que calcule
#o preço a se pagar dada uma quantidade de dias e de Km rodados:

d=int(input('Informe a quantidade de dias em que o carro ficou

alugado: '))
km=float(input('Informe quantos quilômetros foram rodados: '))
custo=d*60+km*0.15
print('O valor do aluguel por {} dias e {}km rodados fica em: R$
{:.2f}.'.format(d,km,custo))

Exercícios Básicos:
Ex016:

# Ler um número real e mostrar sua parte inteira

n=float(input('Informe um número real: '))

i=n//1
print('A parte inteira do número {} corresponde a {:.0f}'.format(n,i))
#Forma 1
i2=int(i)
print('A parte inteira do número {} corresponde a {}'.format(n,i2))
#Forma 2
import math #Fica mais organizado importar no começo do programa
inteiro=math.floor(n)
print('A parte inteira do número {} corresponde a
{}'.format(n,inteiro))#Forma 3
inteiro2=math.trunc(n)
print('A parte inteira do número {} corresponde a
{}'.format(n,inteiro2))#Forma 4

Ex017:

# Ler os catetos oposto e adjacente de um triângulo retângulo e

informar a hipotenusa

catetooposto=float(input('Informe o cateto oposto: '))

catetoadjacente=float(input('Informe o cateto adjacente: '))
hipotenusa=((catetooposto**2)+(catetoadjacente**2))**0.5 #Forma 1
from math import sqrt,hypot
hipotenusa2=sqrt(catetoadjacente**2+catetooposto**2) #Forma 2
hipotenusa3=hypot(catetoadjacente,catetooposto) #Forma 3
print('O triângulo retângulo com catetos {} e {} possui hipotenusa
{}'.format(catetooposto,catetoadjacente,hipotenusa))
print('O triângulo retângulo com catetos {} e {} possui hipotenusa
{}'.format(catetooposto,catetoadjacente,hipotenusa2))
print('O triângulo retângulo com catetos {} e {} possui hipotenusa
{}'.format(catetooposto,catetoadjacente,hipotenusa3))

Ex018:

# Ler um ângulo (vou supor em graus) e informar o seno, o cosseno e a

tangente
from math import sin,cos,tan,pi,radians

alfa=float(input('Informe um ângulo em graus (º): '))

alfarad=alfa*pi/180 #conversão prévia para radianos
seno=sin(radians(alfa)) #forma de conversão do ângulo por função
cosseno=cos(alfarad) #utilizando a conversão prévia
tangente=tan(alfa*pi/180) #convertendo diretamente
print('O ângulo {} possui seno = {},\ncosseno = {}\ne '
'tangente = {}.'.format(alfa,seno,cosseno,tangente))
# Pular linha dentro do print não afeta a escrita (pode ajudar na
visualização)
# O "\n" pula linha no print (na forma como é escrito)
# As operações realizadas podem ser feitas dentro do ".format"

Ex019:

# Sortear 1 entre 4 alunos

#Forma direta mais compacta:

from random import choice
print('O aluno escolhido é o {}'.format(choice([input('Informe o nome
do 1º aluno: '),input('Informe o nome do 2º aluno: '),input('Informe o
nome do 3º aluno: '),input('Informe o nome do 4º aluno: ')])))

# Outras formas
import random

##### Forma compacta e organizada:

lista=[input('Informe o nome do 1º aluno: '),input('Informe o nome do
2º aluno: '),input('Informe o nome do 3º aluno: '),input('Informe o
nome do 4º aluno: ')]
escolhido=random.choice(lista)
print('O aluno escolhido é o {}'.format(escolhido))

# Importação individual
aluno1=input('Informe o nome do 1º aluno: ')
aluno2=input('Informe o nome do 1º aluno: ')
aluno3=input('Informe o nome do 1º aluno: ')
aluno4=input('Informe o nome do 1º aluno: ')
lista=[aluno1,aluno2,aluno3,aluno4]
escolhido=random.choice(lista)
print('O aluno escolhido é o {}'.format(escolhido))

Ex020:

# sortear a ordem de pessoas para, por exemplo, apresentar um trabalho

from random import shuffle
Lista=[str(input('Informe o nome do 1º aluno: ')),str(input('Informe o
nome do 2º aluno: ')),str(input('Informe o nome do 3º aluno:
')),str(input('Informe o nome do 4º aluno: '))]
# ##Lista=shuffle(Lista) isto não funciona, ainda não sei o pq
shuffle(Lista) ## Embaralhou a variável mesmo sem criar uma,
estranho mas funciona
print('a ordem de apresentação embaralhada será: ')
print(Lista)

Ex021: ZUADO (mas toca)

#### Ler um arquivo MP3 (arquivo deve estar na mesma pasta)
#### Esse exercício ficou bem zuado!
### eu colei o arquivo mp3 no projeto
### esse exercício não funciona como na aula. Essa forma de um
comentário do Youtube funcionou
### Precisa, não sei pq, de colocar algum

import pygame
pygame.mixer.init()
pygame.mixer.music.load('01. Black Sails.mp3')
pygame.mixer.music.play()
print('Se vc digita algum valor para o input, a musica encerra')
input('Não sei pq, mas precisa deste input, digite algo para encerrar:
')

# #### Forma de um outro comentário (a ordem parece ser importante)

# import pygame
# #Iniciando o mixer PyGame
# pygame.mixer.init()
# # Iniciando o PyGame
# pygame.init()
# pygame.mixer.music.load('01. Black Sails.mp3')
# pygame.mixer.music.play(loops=0,start=0.0)
# pygame.event.wait(3)
# input() ### essa parte não tinha no comentário e foi necessária para
tocar

Ex022:

# # Programa que le o nome completo de uma pessoa e retorna:

# a) O nome com todas letras maiusculas
# b) O nome com todas letras minusculas
# c) Quantas letras sem o contar os espaços
# d) Quantas letras tem o 1º nome

# nome=str(input('Digite o Nome a ser analizado: ')) #Aqui para ler

qualquer nome
nome='Julio Patti Pereira' # comentar aqui para ler qualquer nome e
descomentar acima
nome=nome.strip()
### a função join está se comportando diferente
### O contador de casas tem sua primeira posição designada pelo 0
### Ex: em nome = Julio, nome[1]=u. Isso serve de modo geral para as
funções
### Mas, len['Julio Patti']=11, pois são 10 letras mas um espaço.
### portanto a função len retorna o tamanho da string e não a posição
do ultimo caractere

print('O nome em maiúsculas é:',nome.upper())

print('O nome em minúsculas é: {}'.format(nome.lower()))
# c=len(nome)-len(nome.split())+1 # O número de espações = palavras -1
c=len(nome)-nome.count(' ') # Outra forma é contar os espaçõs e
subtrair
print('Número de caracteres sem contar espaços: {}'.format(c))
print('O número de letras do 1º nome ({}) é: {}'.format(nome.split()
[0],len(nome.split()[0]))) #Diretamente
# primeiro=nome.split()[0] #forma2
# print('O número de letras do 1º nome é: {}'.format(len(primeiro)))
# print('O número de letras do 1º nome ({}) é: {}'.format(nome.split()
[0],nome.find(' '))) #Encontra a posição do 1º espaço

Ex023:

# #Programa que lê um número inteiro entre 0 e 9999 e mostre quantas

unidades, dezenas, centenas e milhares
# Forma pela string ainda não é indicada nesta etapa
# Forma matemática
n=int(input('Informe um número inteiro entre 0 e 9999: '))
print('Unidades: {}\nDezenas: {}\nCentenas: {}\nMilhares: {}'.format(n
%10,(n%100)//10,(n%1000)//100,n//1000))

Ex024:

# Verificar se o primeiro nome digitado é a palavra "Santo" em uma

cidade

city=str(input('Informe o nome da cidade: ')).strip()#strip anula os

espaços vazios do inicio e fim
micity=city.lower().split()[0]
print('It is {} that the first word of this city is
"Santo"'.format('santo'in micity))
#Forma2
print('It is {} that the first word of this city is
"Santo"'.format(city.lower()[:5]=='santo'))

Ex025:

# Verificar se uma pessoa tem "SILVA" no nome

nome=str(input('Informe o nome da pessoa: ')).lower().strip()

print('Is {} that the (last)name Silva belongs to the name of this
person!'.format('silva'in nome))

Ex026:

# Programa que dada uma frase ele conta quantas letras "a" existem, a
posição da primeira e da ultima
# considerei as acentuadas tmbm
frase=str(input('Digite uma frase: ')).lower().strip()
frase=frase.replace('ã','a').replace('á','a').replace('à','a').replace
('â','a')
print('A letra "a" aparece {} vezes nesta
frase.'.format(frase.count('a')))
print('A primeira letra "a" está na posição {}(a primeira posição é
designada por 0)'.format(frase.find('a')))
print('A ultima letra "a" está na posição {}(a primeira posição é
designada por 0)'.format(frase.rfind('a')))

Ex027:

# Programa que informa o 1º e o último nome de uma pessoa

nome=str(input('Informe o nome a ser analizado: ')).strip()

print('O primeiro nome desta pessoa é : {}.'.format(nome.split()[0]))
nnomes=len(nome.split()) #retorna o numero de palavras (não é posição)
print('O último nome desta pessoa é: {}.'.format(nome.split()[nnomes-
1]))# -1 para adequar à posição da última

Ex028:

# Usuário deve tentar adivinhar um número inteiro randômico "pensado"

pelo PC
# Número entre 0 e 5
import random
n=random.randint(0,5)
if n==int(input('Digite um número inteiro entre 0 e 5: ')): # A
leitura em inteiro "int" é essencial!
print('Você acertou o número sorteado: {}! Cagão!'.format(n))
else:
print('O número sorteado foi {}. Você errou, otário!'.format(n))

Ex029:

#Programa que le uma velocidade de um carro.

# Se a velocidade estiver acima dos 80km/h exiba uma mensagem da multa
# A multa pode ser calculada por R$7,00/Km acima dos 80km/h

v=float(input('Informe a velociade do carro em Km/h: '))

if v>80:
print('Você ultrapassou os 80Km/h, otário!')
print('Sua multa será de {:.2f}, trouxa!'.format(7*(v-80)))
else:
print('Você não ultrapassou o limíte permitido de 80km/h')

Ex030:
# Dado um número inteiro, informar se ele é par ou ímpar

n=int(input('Informe um número inteiro: '))

if n%2!=0:
print('{} é um número ímpar.'.format(n))
else:
print('{} é um número par.'.format(n))

Ex031:

# Preço de uma viagem. Regras: até 200km são R$0,50/Km

# Viagens acima de 200Km custam R$0,45/Km

D=float(input('Informe a distância em Km: '))

if D<=200:
print('O custo de sua viagem é R${:.2f}'.format(D*0.5))
else:
print('O custo de sua viagem é R${:.2f}'.format(D*0.45))

## Forma mais simples

c=D*0.50 if D<=200 else D*0.45
print('O custo de sua viagem é R${:.2f}'.format(c))

Ex032:

# Ver se um ano é um ano bissexto

# obs: um ano bissexto acontece de 4 em 4 anos. 2020 foi um ano
bissexto,
# logo um ano bissexto é múltiplo de 4
# Mas existe um adendo que em anos múltiplos de 100 que não são
múltiplos de 400 não são bissestos

ano=int(input('Informe o ano: '))

if ano%4==0 and (ano%100!=0 or ano%400==0):
print('O ano {} é bissexto'.format(ano))
else:
print('O ano {} não é bissexto.'.format(ano))

# Um exemplo da condição direta caso somente a condição de 4 em 4 anos

fosse imposta:
# print('O ano {} é um ano bissexto'.format(ano)if ano%4==0 else 'O
ano {} não é um ano bissexto'.format(ano))
##########Note o jeito de se fazer a condição direta e como fica
o .format

# Um exemplo para ver o ano atual

from datetime import date
anovigente=date.today().year
print('Estamos no ano {}.'.format(anovigente))
Ex033: Tem maneiras melhores de fazer do que a maneira que eu
fiz

# Um programa que leia 3 números e informe o maior e o menor

[n1,n2,n3]=[float(input('n1: ')),float(input('n2: ')),float(input('n3:

'))]
if n1>=n2:
menor=n2
if n1>=n3:
maior=n1
else:
maior=n3
else:
menor=n1
if n2>=n3:
maior=n2
else:
maior=n3
if menor>n3:
menor=n3
print('O maior número é {}.'.format(maior))
print('O menor número é {}.'.format(menor))

[n1,n2,n3]=[float(input('n1: ')),float(input('n2: ')),float(input('n3:

'))]
if n1>=n2:
if n1>=n3:
maior=n1
if n2>=n3:
menor=n3
else:
menor=n2
else:
maior=n3
menor=n2
else:
if n2>=n3:
maior=n2
if n1>=n3
menor=n1
else:
menor=n3
else:
maior=n3
menor=n1

print('O maior número é {}.'.format(maior))

Ex034:

# Aumento de salário: condição: 15% de aumento par um salário de até

R$1250,00
# e 10% de aumento para superiores a R$1250,00
s=float(input('Informe o salário ao qual deseja-se descobrir o
aumento: '))
if s<=1250:
s2=1.15*s
else:
s2=1.1*s
print('O salário de R${:.2f} vai para R${:.2f}.'.format(s,s2))
print('O que corresponde a um aumento percentual de {}
%'.format(int(100*s2/s)%100))
print('Ou o valor bruto de R${:.2f}'.format(s2-s))

Ex035:

# Dados 3 segmentos de reta, descobrir se eles podem formar um

triângulo
# a condição de um lado qualquer é que: L1 < L2 + L3 para qualquer um
dos lados

[L1,L2,L3]=[float(input('L1 = ')),float(input('L2 =
')),float(input('L3 = '))]
if L1<L2+L3 and L2<L1+L3 and L3<L1+L2:
print('É possível um triângulo com esses lados')
else:
print('Não é possível um triângulo com esses lados')
Mundo 2
Ex036: Uso mais de if e else.
 Uso uma importação compactada de dados
 Esses comandos (if, else, elif, while, etc terminam com “:”

# Dividir um emprestimo sem juros e avaliar se o valor da parcela é

inferior a 30% do salário
# sendo esta a condição para que o empréstimo seja efetivado

[v,s,t]=[float(input('Informe o valor do empréstimo:

')),float(input('Informe o salário do contratante: ')),
int(input('Informe em quantos meses serão divididos a dívida:
'))]
p=v/t #Prestação sem juros
if p>0.3*s:
print('Este empréstimo foi negado pois o valor da prestação excede
30% do salário')
else:
print('O valor da prestação do empréstimo de R${:.2f}
é :'.format(v))
print('R${:.2f} para ser paga durante {} meses sem
juros'.format(p,t))

Ex037: Antecipei o uso do While.

 Uso das funções bin, hex e oct

 O modo particular como elas retornam a informação com 0b, 0o ou 0x precedendo o
número (string)
 No while utilizo uma maneira para ir escrevendo aos poucos os caracteres do numero
convertido
# # Conversão de um número INTEIRO inteiro para bases binária, octal e
hexadecimal
# # Inicialmente, utilizando funções do Python
# # posteriormente deixei um feito por mim para a conversão para
qualquer base
#
# n=int(input('Digite um Nº inteiro e positivo: ')) #farei só para
positivos inicialmente
# print('''Ecolha uma das bases para a conversão:
# [ 1 ] converter para binário
# [ 2 ] converter para octal
# [ 3 ] converter para hexadecimal''') #base 16
# opção=int(input('Sua opção: '))
# if opção==1:
# print('{} convertido para binário = {}'.format(n,bin(n)[2:]))
#[2:] omite a designação da base
# # print(bin(16)) retorna 0b10000, sendo 0b o q indica binário
# elif opção==2:
# print('{} convertido para octal = {}'.format(n, oct(n)[2:]))
#retorna 0o na frente do número
# elif opção==3:
# print('{} convertido para hexadecimal = {}'.format(n, hex(n)
[2:])) # 0x na frente do número
# else:
# print('Opção Invalida. Descomente o programa mais geral e tente
outra base.')

# Solução própria mais geral:

import math
n=int(input('Informe o número INTEIRO para a conversão: '))
b=float(input('Informe a base para a conversão:'))
tamanho=int(math.log(n,b))
naux=n
num=''
while tamanho>=0:
numaux=int(naux/(b**tamanho))
num='{}{}'.format(num,numaux)
naux=naux-numaux*(b**tamanho)
tamanho=tamanho-1
print('O número {} na base {} é: {}'.format(n,b,num))

Ex038:

# Comparação de tamanho entre dois numeros INTEIROS

[n1,n2]=[int(input('Digite o primeiro número inteiro:

')),int(input('Digite o segundo número inteiro: '))]
if n1>n2:
print('O primeiro valor é o maior!')
elif n1<n2:
print('O segundo valor é o maior!')
else:
print('Os valores são iguais!')

Ex039:

# Programa que recebe a idade de um rapaz e retorna dados sobre o ano

de alistamento militar

from datetime import date

anovigente=date.today().year
ano=int(input('Informe o ano de seu nascimento: '))
print('Quem nasceu em {} completa {} anos em
{}.'.format(ano,anovigente-ano,anovigente))
if anovigente-ano<=17:
print('Ainda falta(m) {} ano(s) para o seu alistamento
militar.'.format(18-(anovigente-ano)))
print('Seu alistamento será em {}.'.format(ano+18))
elif anovigente-ano==18:
print('Este é (ou foi) o ano de seu alistamento militar.')
else:
 print('O ano de correto de seu alistamento militar foi em
{}.'.format(ano+18))

Ex040: Utilização de cores

## Ler as duas notas de um aluno, calcule a média e mostre se o aluno

esta aprovado ou reprovado
## Critério de aprovação: media >=7.0. Criterio de recuperação:
5.0<=média<=7.0

[n1,n2]=[float(input('Informe sua 1ª nota: ')),float(input('Informe

sua 2ª nota: '))]
media=(n1+n2)/2
if media<5:
print('A média é {:.1f}: Aluno \033[1;31mREPROVADO!\
033[m'.format(media))
elif media<7: #poderia ser 5<=media<7 (daria no mesmo)
print('A média é {:.1f}: Aluno está de \033[1;33mRECUPERAÇÃO.\
033[m'.format(media))
else:
print('A média é {:.1f}: Aluno \033[1;34mAPROVADO!\
033[m'.format(media))
# o "\033[m" retorna ao padrão configurado no PyCharm.

 Notar que são possíveis testes como 5<=media<7

 Se o programa continuasse, ao utilizar um comando de cor, qualquer print futuro sairia
nessa configuração. É importante voltar às confingurações iniciais com “\033[m”
 Olhar Figura 1: Cores para ver os padrões

Ex041:

# Exercício Python 041: A Confederação Nacional de Natação precisa de

um
# programa que leia o ano de nascimento de um atleta e mostre sua
categoria,
# de acordo com a idade:
# – Até 9 anos: MIRIM
# – Até 14 anos: INFANTIL
# – Até 19 anos: JÚNIOR
# – Até 25 anos: SÊNIOR
# – Acima de 25 anos: MASTER

# a congfiguração considera o ano que completa os anos limites, não as

datas de nascimento
from datetime import date
anopresente=date.today().year
anonascimento=int(input('Informe o ano de seu nascimento: '))
idade=anopresente-anonascimento
if idade<=9:
categoria='MIRIM'
elif idade<=14:
categoria='INFANTIL'
elif idade<=19:
 categoria='JÚNIOR'
elif idade<=25:
categoria='\033[1;34mSÊNIOR\033[m' #as diferentes cores podem ser
atribuidas aqui
else:
categoria='MASTER'
print('Neste ano você completa(ou) {} anos.\n'
'Portanto sua categiora é {}'.format(idade,categoria))
# se uma cor é atribuida à string, ela é incorporada
# como no caso do azul ao "SÊNIOR" que é mantido
 Notar a atribuição de cor a uma variável (poderia ser cores diferentes para cada
categoria, designando isso na hora de atribuir “categoria”.

Ex042:

# exercício se avalia se dados 3 segmentos de reta,

# tais segmentos podem formar um triângulo.
# Caso possa, verificar se o triângulo é equilátero, isósceles ou
escaleno

print('Informe o comprimento dos 3 segmentos, L1, L2 e L3

respectivamente:')
[L1,L2,L3]=[float(input('L1 = ')),float(input('L2 =
')),float(input('L3 = '))]
if L1<L2+L3 and L2<L1+L3 and L3<L1+L2:
if L1!=L2!=L3 and L1!=L3: #note q so a 1ª condição permitiria
isósceles L1=L3
t='ESCALENO' # poderia ser acima: if L1!=L2!=L3!=L1:
elif L1==L2==L3:
t='EQUILÁTERO'
else:
t='ISÓSCELES'
print('Pode-se formar um triângulo {} com os segmentos
informados!'.format(t))
else:
print('Com os segmentos indicados não se pode formar um
triângulo!')
### Logicamente, qualquer triangulo equilátero é também isósceles

Ex043:

# Desenvolva uma lógica que leia o peso e a altura de uma pessoa,

# calcule seu Índice de Massa Corporal (IMC) e mostre seu status,
# de acordo com a tabela abaixo:
# – IMC abaixo de 18,5: Abaixo do Peso
# – Entre 18,5 e 25: Peso Ideal
# – 25 até 30: Sobrepeso
# – 30 até 40: Obesidade
# – Acima de 40: Obesidade Mórbida

m=float(input('Informe sua massa corporal em Kg: '))

h=float(input('Informe sua altura em metros (m): '))
imc=m/(h**2)
if imc<18.5:
 status='Abaixo do peso, ta na capa da gaita!'
elif imc<=25:
status='Peso ideal!'
elif imc<=30:
status='Sobrepeso, o famoso de gordinho a gordo!'
elif imc<=40:
status='Obesidade, você já é um gordão!'
else:
status='Obesidade mórbida, risco de vida!'
print('Com {}Kg e {}m, seu IMC é {}'.format(m,h,imc))
print(status)

Ex044:

# Elabore um programa que calcule o valor a ser pago por um produto,

# considerando o seu preço normal e condição de pagamento:
# – à vista dinheiro/cheque: 10% de desconto
# – à vista no cartão: 5% de desconto
# – em até 2x no cartão: preço formal
# – 3x ou mais no cartão: 20% de juros

p=float(input('Informe o preço nominal do produto em: R$'))

print('Informe a opção de pagamento:\n'
'[ 1 ] Pagamento à vista dinheiro/cheque\n'
'[ 2 ] Pagamento no cartão')
option=int(input('Opção: '))
if option==1:
p=p*0.9
print('O preço do produto à vista fica R${:.2f}'.format(p))
elif option==2:
v=int(input('Informe em quantas vezes o pagamento será feito no
cartão: '))
if v==1:
p=p*0.95
print('O preço do produto em 1x no cartão fica R$
{:.2f}'.format(p))
elif v==2:
p=p
parcela=p/2
else:
p=1.2*p
parcela=p/v
if v!=1:
print('O preço do produto fica R${:.2f} parcelado em {} x R$
{:.2f}'.format(p,v,parcela))
else:
print('Opção inválida!')

Ex045:
# Jokenpô vs o PC
from random import choice,randint
from time import sleep
jokenpo=['pedra','papel','tesoura']
pc=choice(jokenpo) #forma 1 de escolha aleatória
pc=jokenpo[randint(0,2)]#forma 2 de escolha aleatória
print('-='*60)
usuário=str(input('\nInforme sua escolha dentre pedra, papel ou
tesoura: ')).lower().strip()
# #Reparar em "\" ao dar enter para pular linha de comando
# #o PyCharm colocou automaticamente e funcionou bem
# #Outra coisa: é possivel selecionar um bloco inteiro e dar TAB
# #Essa última parte simula o joguinho com o tempo:
print('\033[1;33m\nJO')
sleep(1)
print('KEN')
sleep(1)
print('PÔ!!!!\033[m\n')
if usuário=='pedra' or usuário=='tesoura' or usuário=='papel':
if (usuário=='pedra' and pc=='tesoura') or (usuário=='papel' and
pc=='pedra') \
or (usuário=='tesoura' and pc=='papel'):
print('Você escolheu {} e o PC escolheu {}:\n'
'\033[1;34m\nPortanto você venceu!\
033[m'.format(usuário,pc))
elif usuário==pc:
print('Você escolheu {} e o PC também: \nPortanto
empate!'.format(pc))
else:
print('Você escolheu {} e o PC escolheu {}:\n'
'\033[1;31m\nPortanto o PC venceu, otário!\
033[m'.format(usuário,pc))
else:
print('Ponha uma opção válida, mané!')
print('\n')
print('-='*60)

Ex046:

# Faça um programa que mostre na tela uma contagem regressiva

# para o estouro de fogos de artifício,
# indo de 10 até 0, com uma pausa de 1 segundo entre eles.

from time import sleep

for i in range(10,0,-1):
print(i)
sleep(1)
print('0: Fogos!')

Ex047:

# Crie um programa que mostre na tela todos os números pares

# que estão no intervalo entre 1 e 50.
for i in range(1,51):
if i%2==0:
print(i) #print vertical

for i in range(1,51):
if i%2==0:
print(i,end=' ') #print horizontal
print('\n Forma otimizada horizontal com menor processamento')
# Otimizado:
for i in range(2,51,2): #metade do processamento
print(i,end=' ')

Ex048:

# Faça um programa que calcule a soma entre todos os números ímpares

# que são múltiplos de três e que se encontram no intervalo de 1 até
500.

s=0
j=0
for i in range(1,501):
if i%3==0 and i%2==1:
s+=i #ACUMULADOR
j+=1 #CONTADOR de quantos nºs, caso fosse pedido
print('O valor da soma entre os {} impares multiplos de 3 entre 1 e
500 é {}.'.format(j,s))

# Otimizado:
s=0
for i in range(3,501,6):
s+=i
print('O valor da soma entre os impares multiplos de 3 entre 1 e 500 é
{}.'.format(s))

Ex049:

# Refaça o DESAFIO 9, mostrando a tabuada de um número que o usuário

escolher,
# só que agora utilizando um laço for

n=int(input('Informe o número inteiro que queira saber a tabuada (até

x9): '))
for i in range(1,10):
print('{}x{} = {};'.format(i,n,i*n),end=' ')

Ex050:

# Desenvolva um programa que leia seis números inteiros e mostre

# a soma apenas daqueles que forem pares.
# Se o valor digitado for ímpar, desconsidere-o.

s=0
c=0
for i in range(0,6):
n=int(input('Informe o {}º número: '.format(i+1)))
if n%2==0:
s=s+n
c=c+1
if c==0:
print('\nNenhum número digitado era par.')
elif c==1:
print('\nApenas o nº {} é par.'.format(s))
else:
print('\nA soma dos {} nºs pares informados é {}.'.format(c,s))

Ex051:

# Desenvolva um programa que leia o primeiro termo e a razão de uma

PA.
# No final, mostre os 10 primeiros termos dessa progressão.

print('Informe o 1º termo e a razão da progressão aritmética:')

[a1,r]=[int(input('a1: ')),int(input('r: '))]
for i in range(0,10):
print('{}º termo: {}'.format(i+1,a1+i*r))

Ex052:

# Faça um programa que leia um número inteiro

# e diga se ele é ou não um número primo.

n=int(input('Informe um número inteiro: '))

c=2
for i in range(2,n):
if n%i==0:
c=c+1
if c==2:
print('{} é um número primo'.format(n))
else:
print('{} tem {} divisores, portanto não é primo'.format(n,c))

Ex053:

# Crie um programa que leia uma frase qualquer e diga se ela é um

palíndromo,
# desconsiderando os espaços.
# Exemplos de palíndromos (podem ser lidos de trás pra frente):
#
# APOS A SOPA, A SACADA DA CASA, A TORRE DA DERROTA, O LOBO AMA O
BOLO,
# ANOTARAM A DATA DA MARATONA.

frase=str(input('Digite uma frase: ')).lower().strip()

l=len(frase)
esp=frase.count(' ')
frase2=''
frase3=''
for i in range(0,l):
if frase[i]!=' ':
frase2='{}{}'.format(frase2,frase[i])
frase3='{}{}'.format(frase[i],frase3)
if frase3==frase2:
print('{} é um palíndromo!'.format(frase.upper()))
else:
print('{} não é um palíndromo!'.format(frase.upper()))

# Forma melhor:
palavras=frase.split()
junto=''.join(palavras)
inverso=junto[::-1]
# inverso='' #outra forma
# for letra in range(len(junto)-1,-1,-1):
# inverso += junto[letra]
if junto==inverso:
print('palíndromo')
else:
print('não é palíndromo')

Ex054:

# Crie um programa que leia o ano de nascimento de sete pessoas.

# No final, mostre quantas pessoas completam ou completaram 18 anos no
# ano atual, quantas ja completaram anteriormente e quantas ainda vão
completar
# no futuro

from datetime import date

anoatual=date.today().year
print('informe os anos de nascimento das 7 pessoas:')
anos=[int(input('1ª: ')),int(input('2ª: ')),int(input('3ª:
')),int(input('4ª: ')),int(input('5ª: ')),int(input('6ª:
')),int(input('7ª: '))]

menores=maiores=indefinidos=0
for i in range(0,7):
if anoatual-anos[i]<18:
menores=menores+1
elif anoatual-anos[i]>18:
maiores=maiores+1
elif anoatual-anos[i]==18:
indefinidos=indefinidos+1
print('{} são menores, {} são maiores e {} estão
indefinidos'.format(menores,maiores,indefinidos))
Ex055:

# Faça um programa que leia o peso de cinco pessoas.

# No final, mostre qual foi o maior e o menor peso lidos.
maior=menor=0
for i in range(0,5):
p=float(input('Insira o peso da {}ª pessoa em Kg: '.format(i+1)))
if i==0:
menor=p
if p>maior:
maior=p
if p<menor:
menor=p
# mais pesado e menos pesado respectivamente:
print('O balofão da turma pesa {}Kg. '
'O capa da gaita da turma pesa {}Kg.'.format(maior,menor))

Ex056:

# Desenvolva um programa que leia o nome, idade e sexo de 4 pessoas.

# No final do programa, mostre: a média de idade do grupo,
# qual é o nome do homem mais velho e quantas mulheres têm menos de 20
anos.
veio=''
novinhas=media=id=0
for i in range(0,4):
print('Informe o nome, a idade e o sexo da {}ª pessoa, '
'respectivamente, segundo as diretrizes: '.format(i+1))
lista=[str(input('Nome: ')),int(input('Idade: ')),input('Sexo:
Masculino (M) ou Feminino (F): ').lower().strip()]
if lista[2]=='m':
if id<lista[1]:
id=lista[1]
veio=lista[0]
elif id==lista[1]:
veio=veio + ' e ' + lista[0]
e=veio.count(' e ')
veio=veio.replace(' e ',', ',e-1)
else:
if lista[1]<20:
novinhas=novinhas+1
media=media+lista[1]/4
if veio!='':
print('\nMais veio(s): {}.'.format(veio))
if novinhas!=0:
print('Existe(m) {} novinha(s) com menos de 20
anos.'.format(novinhas))
print('A média de idade do grupo é de {} anos.'.format(media))