Programa em Python 33

 Faça uma função recursiva que permita inverter um número inteiro N. Por exemplo, dada a entrada 123, a função retorne 321.

Resolução: 

def reverse_int(x):
rev_numero=''
numero=str(x)
for i in range(len(numero)-1,-1,-1):
rev_numero+=numero[i]
print rev_numero

return rev_numero

if __name__ == '__main__':

entrada = input("Digite um numero positivo real qualquer: ");

if (entrada <=0):
finalizar = raw_input('Numero invalido, pressione qualquer tecla para continuar...');
exit();

#Nenhum numero real vai ser divisivel por um numero maior do que sua metade
reverse_int(entrada);

Programa em Python 32

Crie uma função recursiva que receba um número inteiro positivo N e calcule o somatório dos números de 1 a N.

Resolução:

print("Programa para calcular somatorio dos numeros de 1 a N.")

x=int(input("Informe o numero:"))

soma=0
while x>=1:
    soma= soma + x
    x= x-1

print("O somatorio eh igual a:",soma)

Programa em Python 31

Faça uma função recursiva que calcule e retorne o fatorial de um número inteiro N.

Resolução:

print("Programa para calcular o fatorial de um numero.")

x=int(input("Informe o fatorial:"))

fat=1
while x >= 1:
    fat= fat * x
    x= x-1


print("O fatorial do numero informado eh igual a:",fat)

Programa em Python 30

Número perfeito.
Fornecido um número inteiro, determinar se o número é um número perfeito, ou seja, se é igual à soma de seus divisores, exceto ele mesmo.
Entrada: Um número inteiro.
Saída: Mensagem indicando se o número é ou não perfeito.

Exemplo de Entrada:
28

Exemplo de Saída:
28 é um número perfeito.

Resolução:

print ("Progrmana para determinar se o numero eh perfeito ou nao")
n = int(input("digite o numero: "))
cont = 1
soma = 0

while cont
 if n%cont==0:
     soma = soma + cont
     cont = cont + 1
 else:
     cont = cont + 1


if soma==n:
  print ("o numero", n,"eh perfeito!")
else:

  print("o numero", n,"nao eh prefeito!")

Programa em Python 29

Composição de listas.
Faça um programa que leia duas listas com 10 elementos cada. Gere uma terceira lista com 20 elementos, cujos valores deverão ser compostos pelos elementos intercalados das duas listas.
Entrada: Duas listas com 10 elementos.
Saída: Uma lista com os elementos intercalados.

Exemplo de Entrada:
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Exemplo de Saída:
1 11 2 12 3 13 4 14 5 15 6 16 7 17 8 18 9 19 10 20

Resolução:

print("Entre com os valores da Primeira lista!")
a=int(input("Digite o primeiro numero da lista:"))
b=int(input("Digite o segundo numero da lista:"))
c=int(input("Digite o terceiro numero da lista:"))
d=int(input("Digite o quarto numero da lista:"))
e=int(input("Digite o quinto numero da lista:"))
f=int(input("Digite o sexto numero da lista:"))
g=int(input("Digite o setimo numero da lista:"))
h=int(input("Digite o oitavo numero da lista:"))
i=int(input("Digite o nono numero da lista:"))
j=int(input("Digite o decimo numero da lista:"))
lista1=[a,b,c,d,e,f,g,h,i,j]

print("Entre com os valores da segunda lista!")
A=int(input("Digite o primeiro numero da lista:"))
B=int(input("Digite o segundo numero da lista:"))
C=int(input("Digite o terceiro numero da lista:"))
D=int(input("Digite o quarto numero da lista:"))
E=int(input("Digite o quinto numero da lista:"))
F=int(input("Digite o sexto numero da lista:"))
G=int(input("Digite o setimo numero da lista:"))
H=int(input("Digite o oitavo numero da lista:"))
I=int(input("Digite o nono numero da lista:"))
J=int(input("Digite o decimo numero da lista:"))
lista2=[A,B,C,D,E,F,G,H,I,J]


lista3=[lista1[0],lista2[0],lista1[1],lista2[1],lista1[2],lista2[2],lista1[3],lista2[3],lista1[4],lista2[4],lista1[5],lista2[5],lista1[6],lista2[6],lista1[7],lista2[7],lista1[8],lista2[8],lista1[9],lista2[9]]

print("a primeira lista:",lista1)
print("A segunda lista:",lista2)

print("A lista 1 mais a lista 2:",lista3)

Programa em Python 28

Soma de impares consecutivo.
Leia 2 valores inteiros X e Y. A seguir, calcule e mostre a soma dos números impares entre eles. Entrada: O arquivo de entrada contém dois valores inteiros.
Saída: O programa deve imprimir um valor inteiro. Este valor é a soma dos valores ímpares que estão entre os valores fornecidos na entrada que deverá caber em um inteiro.

Exemplo de Entrada: 6
Exemplo de Saída: 5

Resolução:

x=int(input("Digite o primeiro numero inteiro:"))
y=int(input("Digite o segundo numero inteiro:"))

soma=1
while x>= 0:
    if x%2 !=0:
        x -=2
        soma += x
    else:
        x= x-1
        x -=2
        soma += x

soma1=1
while y >= 0 :
    if y%2 != 0 :
        y -=2
        soma1 += y
    else:
        y= y-1
        y -=2
        soma1 +=y

soma2= soma + soma1


print("A soma dos numeros impares sao:",soma2)

Programa em Python 27

 Média das notas.
Leia três notas (valores reais com duas casas de precisão), exiba as notas na tela, a média e uma mensagem ( media >= 6 : Aprovado,  media >= 5 mas < 6 : Rec, media < 5 : Reprovado ).
Entrada :Três valores reais.
Saída: Valor da média e mensagem de acordo com o resultado.

Exemplo de Entrada:
4.0
7.0
8.5

Exemplo de Saída:
Notas: 4.0 7.0 e 8.5
Media: 6.5
Aprovado

Resolução:


n1=float(input("Informe a primeira nota:"))
n2=float(input("Informe a segunda nota:"))
n3=float(input("informe a terceira nota:"))

print("notas %.1f" % n1, n2, n3)
media= (n1+n2+n3)/3
print("A media das tres notas  eh %.1f" % media)

if( media >= 6 ):
    print("Aprovado")
if( media < 5 ):
    print("Reprovado")
if ( 5 <= media < 6 ):

    print("Recuperacao")

Programa em Python 26

Média simples.
Fornecidos 3 números, calcule a média, o menor número e o maior número.
Entrada Três valores reais.
Saída Média dos valores, o maior e o menor

Exemplo de Entrada:
2.0
3.0
5.0

Exemplo de Saída:
Média: 3.33
Maior: 5.0
Menor: 2.0

Resolução:

x = float(input("Digite o primeiro numero:"))  #entrade de dados
y = float(input("Digite o segundo numero:"))
z = float(input("Digite o terceiro numero:"))

media= (x + y + z) / 3
print("A media de:",x,y,z,"eh:",media)

def maior ():
    if ( x>y and x>z ):
        print("O maior numero eh:",x)
    else:
        if( y>x and y>z ):
            print("O maior numero eh:",y)
        else:
            print("O maior numero eh",z)

def menor():
    if ( x
        print("O menor numero eh:",x)
    else:
        if ( y
            print("O menor numero eh",y)
        else:
            print("O menor numero eh:",z)

maior() #chamada de funcao

menor() #chamada de funcao

Programa em Python 25

 Triângulos.
Considere a entrada de dados dos 3 lados de um triângulo. Verifique e informe se os 3 lados formam um triângulo.
Indique, caso seja um triângulo, o tipo de triângulo (i.e., equilátero, isósceles ou escaleno).
Entrada: Três valores reais.
Saída: Mensagem indicando se os lados formam um triangulo e, caso positivo, de qual tipo.

Exemplo de Entrada:
1.0
1.0
1.0

Exemplo de Saída:  Forma um triângulo equilátero.

Resolução:

#Triangulo equilatero: possui os tres lados com medidas iguais.
#Triangulo isosceles: possui dois lados com medidas iguais.
#Triangulo escaleno: possui os tres lados com medidas diferentes.

x = int(input("Digite o primeiro numero natural:"))  #entrade de dados
y = int(input("Digite o segundo numero natural:"))
z = int(input("Digite o terceiro numero natural:"))

if ( x <= 0 or y <= 0 or z <= 0 ):
    print("Os numeros",x, y, z, "nao formam um triangulo")
else:
    if (x==y==z):
        print(x,y, "e",z, "formam um triangulo equilatero!")
    else:
        if (x!=y and x!=z and y!=z):
            print(x,y,"e",z,"formam um triangulo escaleno!")
        else:
            if (x==y or y==z or x==z):

                print(x,y,"e", z,"formam um triangulo isosceles")

Programa em Python 24

 Validação da data. Fornecida uma data, em termos de DIA, MÊS e ANO, indique se a data é válida. Caso a data não seja válida, indicar o motivo (ou os motivos) da data não ser válida.

Entrada: Três valores inteiros correspondentes ao DIA, MÊS e ANO.
Saída: Deve informar se a data inserida é válida ou inválida (nesse caso, o porquê não é valida). As datas seguintes são válidas: 01/01/2000 e 19/05/1971. Já as seguintes datas são inválidas: 40/01/2010 (dia inválido), 23/17/2009 (mês incorreto) e 23/01/-1000 (ano incorreto). Assuma que os anos devem estar no intervalo de 1900 a 2015. Não considere ano bissexto.

Exemplo de Entrada :
31
08
1993

Exemplo de Saída:  A data (31/08/1993) é válida!


Resolução:

#x eh o dia do mes
#y eh o mes
#z eh o ano

x=int(input("Digite o dia do mes:")) #entrada de dados
y=int(input("Digite o mes:")) #entrada de dados
z=int(input("Digite o ano:")) #entrada de dados

if (x <= 0 or x > 31): #condicao se
    print("A dia do mes informado eh invalido, digite um numero no intervalo de 1 a 31!" ) #saida de dados
if ( y<= 0 or y> 12 ): #condicao se
    print("O mes informado eh invalido, digite um mes que esteja no intervalo de 1 a 12!") #saida de dados
if(z < 1900 or z > 2015 ): #condicao se
    print("O ano informado eh invalido digite um ano que esteja no intervalo de 1900 a 2015!") #saida de dados
else: #condicao se

    print("A data:", x,"/",y,"/",z,"eh valida!") #saida de dados

Programa em Python 23

1. Par ou ímpar. Fornecido um número, informe se o número é par ou ímpar. Entrada Um valor do tipo real. Saída Mensagem informando se o número é par ou ímpar.

Exemplo de Entrada:7

Exemplo de Saída: 7 é um número ímpar

Resolução:

x = int(input("Digite um numero inteiro e positivo:")) #entrada de dados


if ( x < 0 ): #condicao se
    print("Voce digitou um numero negativo, digite um numero positivo!")  #saida de dados
else:   #condicao senao 
    if ( x % 2 ==0 ): 
        print(x, "eh um numero par!") #saida de dados
    else:

        print(x, "eh um numero impar!") #saida de dados

Programa em Python 22

Dados dois números naturais n e p, sendo n > p, escreva um programa para calcular a
combinação de n elementos tomados p a p.

Resolução:

def verifica_p(n, p):
    if (p > n):
        print("Entrada invalida!")


def calcula_combinacao(n, p):
    n_fat = 1
    for a in range(1, n + 1):
        n_fat = a * n_fat

    for a in range(1, p + 1):
        p_fat = 1
        p_fat = a * p_fat

    np = n - p
    for a in range(1, np + 1):

        np_fat = 1
        np_fat = a * np_fat


    comb = n_fat / (p_fat * np_fat)
    print("A combinacao de ", n, " elementos, tomados  ", p, " a ", p, " e igual a ", comb)


n = int(input("Digite um numero n: "))
p = int(input("Digite um numero p (menor que n): "))

verifica_p(n, p)

calcula_combinacao(n, p)

Programa em Python 21

Da mesma forma como feito em sala, quando escrevemos um código para determinar o valor de
uma função afim (ou de primeiro grau) da forma f(x) = ax+b, desenvolva agora um script contendo
uma função para retornar as raízes de um polinômio.
Observações:
a) Agora não estamos falando de uma função da forma f(x) = ax2 + bx + c, onde dados a, b,
c e o valor da variável independente x, retornamos o valor de f(x);
b) O problema é um pouco diferente. Estamos falando de um polinômio de grau dois que
pode ter duas raízes, uma raiz ou até mesmo nenhuma (quando falamos em polinômios,
falamos em raízes!);
c) A ideia é, dados a ≠ 0, b, c e o valor da variável x, retornar as raízes do polinômio.
d) Vocês deverão utilizar a fórmula de Bhaskara:

Se Δ > 0 temos duas raízes reais. Se Δ = 0 temos apenas uma raiz e se Δ < 0, não existem

raízes reais. O programa deverá verificar as três situações (dica: utilize a estrutura if-thenelse).

e) É importante ter em mente que o Octave é capaz de fornecer a raiz quadrada de um

número negativo, sendo este um número complexo. NÃO É PARA ABORDAR ESSA

SITUAÇÃO. Verifique o sinal de Δ para dar o retorno adequado, lembrando que queremos

raízes reais.

Resolução:

a=float(input("Digite um valor de a (diferente de zero): ")) #entrada de dados e definicao do tipo da variavel

b=float(input("Digite um valor de b: "))                    #entrada de dados e definicao do tipo da variavel

c=float(input("Digite um valor de c: ") )                         #entrada de dados e definicao do tipo da variavel

#x=input("Digite o valor da variavel x: ")

#x=float(x)

delta=b**2-4*a*c     #calculo de delta

if (delta < 0): #condicao se, caso delta menor que zero infomar ao usuario que nao tem raizes reais

print ("Nao existem raizes reais") #saida de dados para o usuario

if ( delta==0 ): #agora condicao se para x igual a zero

x=(-b-delta**0.5)/2*a #calculo de x

print ("O valor de x eh igual a",x) #saida de dados

if (delta > 0): #novamento a condicao se, agora para x maior que zero

x1=(-b+delta**0.5)/2*a    #calculo de x1

x2=(-b-delta**0.5)/2*a    #calculo de x2

print("O valor de x eh igual a",x1,"e",x2) #saida de dados para o usuario, com o comando print IMPRIME NA TELA dos resultados

Programa em Python 20

Escreva um script para calcular a raiz quadrada de um número natural. Não utilize a função
sqrt() do Octave.

Resolução:

def raizQuadrada(n):     #definicao de funcao
rquad=n**0.5
print ("A raiz quadrada de" , n ," eh: ",(rquad)) #saida de dados

x=input("Digite um numero natural: ")  #entrada de dados
x=int(x) #atribuindo um a tipo a variavel

raizQuadrada(x) #chamada d funcao 

Programa em Python 19

Escreva um script que, dados pelo usuário o valor de um termo e os valores das razões de duas
progressões, uma aritmética e outra geométrica, o programa imprima os 20 próximos valores para as duas sequências (apresentando em cada linha os resultados para cada progressão).

Resolução:

def progressao_aritmetica(termo,razao):    #Funcao que calcula a PA
for a in range(1, 16):
termo=termo+razao
print(termo)

a=input("Digite o primeiro termo da PA:") #entrada de dados
a=int(a)                                    #definindo o tipo da variavel
b=input("Digite a razao da PA:")
b=int(b)

print ("Os 15 proximos termos da PA sao:")   #saida de dados
progressao_aritmetica(a,b)


x= float(input("Digite o primeiro termo da progressao geometrica:")) #definicao do tipo de x e entrada de dados
y= float(input("Digite a razao:"))                           #definicao do tipo de y e entrada de dados
print(x)
t = 0
while( t < 14 ):       #comando de repeticao, laco, looping
t=t+1
x = x * y

print(x)

Programa em Python 18

Uma progressão geométrica é uma sequência numérica em que cada termo, a partir do segundo,
é igual ao produto do termo anterior com uma constante, chamada “razão” da progressão. Escreva
um script, para utilizar no Octave sendo que, dados pelo usuário o valor do primeiro termo e o valor
da razão da progressão, o programa imprima na tela os próximos 15 termos da sequência.
Observação: a ideia de progressão geométrica é muito utilizada em ciências econômicas e na
administração pois está associada à Teoria Populacional desenvolvida por Thomas Malthus, em
1798, a qual dizia que a população crescia em progressão geométrica (exponencial), enquanto que a

produção de alimentos crescia em progressão aritmética (linear).


Resolução:

x= float(input("Digite o primeiro termo da progressao geometrica:")) #definicao do tipo de x e entrada de dados
y= float(input("Digite a razao:"))                   #definicao do tipo de y e entrada de dados
print(x)
t = 0
while( t < 14 ):       #comando de repeticao, laco, looping
t=t+1
x = x * y

print(x)

Programa em Python 17

Uma progressão aritmética é uma sequência numérica em que cada termo, a partir do segundo, é
igual à soma do termo anterior com uma constante, chamada “razão” da progressão. Escreva um
script, para utilizar no Octave sendo que, dados pelo usuário o valor do primeiro termo e o valor da
razão da progressão, o programa imprima na tela os próximos 15 termos da sequência (cada termo
em uma linha diferente).

Resolução:


def progressao_aritmetica(termo,razao):    #Funcao que calcula a PA
for a in range(1,16):
termo=termo+razao
print(termo)

a=input("Digite o primeiro termo da PA:") #entrada de dados
a=int(a)                                    #definindo o tipo da variavel
b=input("Digite a razao da PA:")
b=int(b)

print ("Os 15 proximos termos da PA sao:")   #saida de dados

progressao_aritmetica(a,b)

Programa em Python 16

Dados três números naturais, verificar se eles formam os lados de um triângulo retângulo.

Resolução:

"""
para formar um triangulo retangulo utiliza-se hipotenusa**2 = ca**2 + co**2 a hipotenusa tem que ser o maior lado
"""
x = int(input("Digite o primeiro numero natural:"))  #entrade de dados
y = int(input("Digite o segundo numero natural:"))
z = int(input("Digite o terceiro numero natural:"))

lista = [x,y,z]
lista.sort() #agora os numeros estao em ordem crescente, basta utilizar o ultimo numero da lista como hipotenusa
if (lista[2]) == ((lista[0])**2 + (lista[1])**2)**(1/2):
    print ("Os numeros",x, y, z, "formam um triangulo retangulo")
else:

    print("Os numeros",x, y, z, "nao formam um triangulo retangulo")

Programa em Python 15

Dados três números, imprimi-los em ordem crescente.

Resolução:

x = float(input("Digite o primeiro numero:")) #x,y,z entrada de dados
y = float(input("Digite o segundo numero:"))
z = float(input("Digite o terceiro numero:"))

lista = [x,y,z] #passando os valores pra uma lista
lista.sort() #funcao que sort ordena os indices da lista 

print(lista)

Programa em Python 14

Outro resultado frequentemente utilizado é o fatorial de um número natural. O fatorial de um
número n é dado pelo produto n*(n-1)*(n-2)*...*2*1. Escreva um algoritmo (script) que, dado um
número natural (pelo usuário), imprima na tela o fatorial desse número. Observação: o Octave já
possui uma função que calcula o fatorial de um número. Não utilize essa função, faça seu próprio
algoritmo.

Resolução:

#n*(n-1)*(n-2)*...*2*1

n= int(input("Digite o numero:")) #entrada de dados
fat = 1

if(n==1 or n==0): #condicao se
    print("O fatorial de",n, "tem valor igual a 1") #saida de dados
else: #condicao senao
    for a in range(1, n+1): 
   fat = fat*a #calculo fatorial

    print("O fatorial de",n,"tem valor igual a", fat) #saida de dados

Programa em Python 13

Dada uma sequência de números inteiros não-nulos, imprimir seus quadrados.

Resolução:

n = input("Digite a quantidade de numeros da sequencia: ") #Entrada padrao
n = int(n)
sequencia = [0]*n #Criacao do vetor que recebera os valores
for a in range(n):
    sequencia[a] = input("Digite o numero: ") #Entrada padrao
    sequencia[a] = int(sequencia[a])
    sequencia[a] = sequencia[a] ** 2 #Calculo dos quadrados
for a in range(n):

    print("O quadrado do", a+1, "numero:", sequencia[a]) #Saida padrao

Programa em Python 12

Dado um número inteiro positivo n, imprimir os n primeiros naturais ímpares.

Resolução:

x = int(input("Digite um numero inteiro positivo:")) #entrada padrao
soma = 0
if (x<0 b="" condicao="" se="">
    print("Voce digitou um numero negativo, digite um numero positivo!") #saida padrao
else: #condicao senao
    while(x>0): #funcao de laco enquanto, enquanto x for maior que zero o laco vai rodar
        x -= 1
        if (x%2!=0):

            print (x)

Programa em Python 11

Dado um número inteiro positivo n, calcular a soma dos n primeiros números inteiros positivos.

Resolução:

x = int(input("Digite um numero inteiro positivo:"))
soma = 0
if (x<0 b="">
    print("Voce digitou um numero negativo, digite um numero positivo!")
else:
    while (x>0):
        x -=1
        soma += x

    print(soma)

Programa em Python 10

Escreva um programa que calcule a soma dos cubos de todos os números pares compreendidos
entre 3 e 17 e exiba o resultado na tela.

Resolução:

def soma():
    x = 0
    for i in range(4,17,2):
        x += i**3
    return x


print (soma())

Programa em Python 9

Fazer um programa para ler o raio R de uma esfera e calcular sua área e seu volume através das
fórmulas abaixo.
V = (4/3) × π × R^3
e
A = 4 × π × R^2.

Resolução:

r = float(input("Digite o raio da esfera:"))

import math

v = (4/3) * math.pi * (r**3)

a = 4 * math.pi *(r**2)

print ("O volume da esfera eh igual a:", v, " \n E a area da 


esfera igual a:", a)

Programa em Python 8

Em um cercado há vários patos e coelhos. Escreva um programa que solicite ao usuário o total de
cabeças e o total de pés e determine quantos patos e quantos coelhos se encontram nesse cercado.

Resolução:

"""
coelhos = x
patos = y
cabeca = c
pes = p
x + y = c
x = (p - 2*c)/2
y = c - x
"""
c = int(input("Digite o numero de cabecas:"))
p = int(input("Digite o numero de pes:"))

x = (p - 2*c) /2
y = c - x

print ("O numero de coelhos no  cercado eh igual a", x, "e o numero de patos igual a", y)

Programa em Python 7

A pólvora clássica (explosiva) é constituída por 75% de Salitre (Nitrato de Sódio), 15% de carvão
(Carbono) e 10% de enxofre. Escreva um programa que leia do teclado a quantidade de pólvora a
ser produzida (em gramas) e exiba na tela as quantidades necessárias dos componentes (em
gramas).

Resolução:

polvora = float(input("Informe a quantidade em gramas de polvora a ser produzida:"))

salitre = polvora * 0.75
carvao = polvora * 0.15
enxofre = polvora * 0.10


print("Para produzir", polvora, "gramas de polvora, eh necessario", salitre, "gramas de salitre,", carvao, "gramas de carvao e", enxofre," gramas de enxofre.")

Programa em Python 6

O Índice de Massa Corporal (IMC) é uma fórmula utilizada para verificar se um adulto está
acima do peso, obeso ou abaixo do peso ideal, considerado saudável. A fórmula utilizada para
calcular o IMC é dada pela expressão:
IMC = peso[kg]/(altura[m])2 .
Implemente um programa que pede o peso e a altura do usuário e calcule seu IMC, imprimindo o
resultado na tela do computador.

Resolução:

peso = float(input("Informe o peso em Kg:"))
altura = float (input("Informe a altura em metros:"))

IMC=(peso/altura**2)


print ("O IMC calculado foi:", IMC)

Programa em Python 5

Ler do teclado o valor bruto de uma nota fiscal de serviços e imprimir na tela o valor total dos
impostos, assim como o valor líquido a ser recebido. Use os seguintes impostos para o cálculo:
IR = 1,50%
CSLL = 1,00%
COFINS = 3,00%
PIS = 0,65%

Resolução:

valor_bruto = float(input("Informe o valor bruto:"))

IR= 1.5/100
CSLL = 1/100
COFINS = 3/100
PIS = 0.65/100

imposto = valor_bruto * (IR + CSLL + COFINS + PIS)

valor_liquido = valor_bruto - imposto


print ("O valor liquido a ser recibido eh de:", valor_liquido)

Programa em Python 4

Efetuar o cálculo do valor de uma prestação em atraso, utilizando a fórmula:
P = V + (V*(T/100)*t),
onde P é a prestação em atraso, V o valor original, T a taxa de juros e t o tempo em atraso. Essas
variáveis devem ser informadas pelo usuário e o resultado apresentado na tela.

Resolução:

#P=V+(V*(T/100)*t)

V = float(input("Informe o valor original da prestacao:"))
T = float(input("Informe a taxa de juros:"))
t = int(input("Informe o tempo em atraso:"))

P = V + (V*(T/100)*t)

print ("O valor da prestacao em atraso eh de:", P)

Programa em Python 3

Dados um inteiro x e um inteiro não-negativo n, calcular x^n.

Resolução:

x = int(input("Informe o primeiro numero inteiro:"))
n = int(input("Informe o segundo numero inteiro:"))

num = x**n

print("O primeiro numero informado:", x, "elevado ao segundo numero:", n, "resulta em:", num)

Programa em Python 2

Escreva um programa que converta um determinado ângulo em graus, dado pelo usuário, para
radianos.

Resolução:

import math
graus = float(input("Digite um angulo em graus:"))
radianos = graus * 2 * math.pi / 360
radianos2 = graus * 2 / 360

print ("O numero digitado em graus foi:",graus, "e seu valor em radiano eh:",radianos)
print ("Ou seja,", radianos2, "pi")

Programa Python 1

Faça um programa que receba um número positivo e maior do que zero, calcule e mostre:
a) o número digitado ao quadrado;
b) o número digitado ao cubo;
c) a raiz quadrada do número digitado;
d) a raiz cúbica do número digitado.


Resolução:

num = int(input("Digite um número inteiro:"))

quadrado = num**2
cubo = num**3
raizq = num**(1/2)
raizc = num**(1/3)

print ("O número digitado ao quadrado é igual a:",quadrado )
print ("O número digitado ao cubo é igual a:", cubo)
print ("A raiz quadrada do número digitado é:", raizq)
print ("A raiz cubiba do número digitado é:", raizc)

O que é um algoritmo e quais são as estruturas de controle que podem se utilizadas na implementação de um algoritmo utilizando uma linguagem de programação?

Tem-se por definição de algoritmo:

1. “Procedimento passo a passo para a solução de um problema”.

2. “Sequência detalhada de ações (ou instruções) a serem executadas para realizar uma tarefa”.

3.Os Computadores só fazem aquilo que mandamos e não necessariamente o que desejamos que eles façam!

4. “Algoritmo é uma sequência ordenada, e sem ambiguidade, de passos que levam à solução de um problema.”

Instruções devem ser completas. Não deve haver ambiguidade nas instruções do algoritmo.

Estruturas de Controle são definidas como sendo a base da lógica da programação e podem ser de dois níveis: direto ou indireto (complexo). 

Resumo Python

Condicional

if condição:
    comando 1
    comando 2
else:
    comando 3
    comando 4


- Estrutura aninhada e sem else

if condição1:
    if condição2:
         comando1
    else:
         comando2

- ELIF

if condição1:
      comando1
elif condição2:
      comando2
else:
      comando3

Repetição WHILE

while condição:
    comando1
    comando2

- Quebra de repetição - break

Lista
Aceita diferentes tipos de dados
L = [100, 50, 60]
L[0] = 100
L[1] = 50
L[2] = 60

- len(L) = 3
#calcula o tamanho de uma lista

- L.append(70)
#insere elemento no final da lista
L passa a ser L = [100, 50, 60, 70]

- L.extend([30, 20, 10])
#insere mais elementos na lista
L passa a ser L = [100, 50, 60, 70, 30, 20, 10]

- L.remove(50)
L passa a ser L = [100, 60, 70, 30, 20, 10]
- L.count(60)
#conta o número de vezes que 60 aparece na lista
Resultado: 1

- L.reverse()
L passa a ser L = [10, 20, 30, 70, 60, 100]

- L.index(20)
#encontra o índice do primeiro 20 na lista
#mensagem de erro caso não exista 20 em L
Resultado: 1

- L.sort()
#coloca em ordem crescente os elementos da lista
L passa a ser L = [10, 20, 30, 60, 70, 100]


- 10 in L
True


- 80 in L
False


- Soma e concatenação
A = [1, 2] B = [7, 8]
C = A + B
C = [1, 2, 7, 8]
A * 2 = [1, 2, 1, 2]


- Cópia de listas
H = A
H = [1, 2]
H[0] = 3
A = H = [3, 2]


- Clonagem de listas
H = A[:]
H = A = [1,2]
H[0] = 3
H = [3, 2]
A = [1, 2]


- Fatiamento de listas
J[a:b]
a - inclui
b - não inclui
J = [1, 2, 3, 4, 5]
J[1:3] = [2, 3]


- Atualização de listas
J[1:3] = [10, 20]
J = [1, 10, 20, 4, 5]
J[1:1] = [6, 7]
J = [1, 6, 7, 10, 20, 4, 5]


- Fatiamento com índices negativos
J[-1:] = [5]
J[:-1] = [1, 6, 7, 10, 20, 4]


- Del
del J[1]
J = [1, 7, 10, 20, 4, 5]

Lista e sublista

L = [15,20,28, ["mariana", 18, "bauru"]]
L[3][0] = mariana
L[3][1] = 18


Repetição FOR
L = [1, 2 ,3]
for x in L:
   print (x)

Resultado:
1
2
3

Range

range(100)
#gerador de lista
range(100) = range(0,100)

range(0, 100, 2)
#primeiro elemento indica valor inicial
#segundo elemento indica valor final (não incluso)
#terceiro elemento indica o valor do salto entre os elementos gerados

for x in range(0, 10, 2):
   print (x, end = " ")
#end indica que a função print não deve pular linha após a impressão

Resultado:
0 2 4 6 8

List

L = list(range(0, 10, 2))
  print (L)

Resultado:
[0, 2, 4, 6, 8]


Strings

strings = "16 2 5.1"

- L = strings.split(" ")
#quebra uma string a partir de um caracter passado como parâmetro e retorna
uma lista

Resultado: ["16", "2", "5.1"]


Tuplas

Imutáveis
Não aceita comandos de alteração
Aceita diferentes tipos de dados

T = (1, 2, 3)

- for e in T:
   print(e)

- len(T)
- Empacotamento
X = 10, 20, 30


- Desempacotamento
a, b, c = X
a = 10
b = 20
c = 30


- Permutação
a, b, c = c, b, a
a == 30
b == 20
c == 10


- Com um elemento
w = (3,)
- L = [1, 2, 3]
tuple(L)
(1, 2, 3)


- Concatenação
X + W
(10, 20, 30, 3)


- Tuplas com listas
R = (1, "broto", [5, 7.00])
R[2][1] = 7.00
R[2] == [5, 7.00]


Dicionário

tabela = {"Tomate" : 5.00, "Alface" : 3.00}
tabela["Tomate"] == 5.00
tabela["Tomate"] = 4.00
tabela["Tomate"] == 4.00
tabela["Cenoura"] = 3.50 #inserção ocorre em qualquer lugar do dicionário
tabela == {"Tomate" : 5.00, "Cenoura" : 3.50, "Alface" : 3.00}


- items()
tabela.items()
dict_items([('Alface', 3.00), ('Tomate', 5.00)])


- keys()
tabela.keys()
dict_keys(['Alface', 'Tomate'])


- values()
tabela.values()
dict_values([3.00, 5.00])


Funções

def NomeFuncao (parametros):
      bloco de comandos


Variáveis locais
a = 5
def muda():
  a = 7
  print(a)
print(a)
muda()
print(a)
5
7
5


Variáveis globais
a = 5
def muda():
   global a
   a = 7
   print(a)
print(a)
muda()
print(a)
5
7
7


Definição de função com parâmetros opcionais
def barra(n=40, caractere = "*"):
    print(caractere * n)
barra()
barra(10)
barra(30, "-")



Screen

import turtle
sc = turtle.Screen()
sc.bgcolor("orange")
sc.title("Tartarugas")
sc.mainloop()


Turtle

import turtle
tt = turtle.Turtle()
tt.color("red")
tt.pensize(2)
tt.forward(3)
tt.backward(3)
tt.left(100)
rr.right(12

Exercícios de Desvio condicional em Python

1. Indique a mensagem que apresentará a execução das seguintes instruções:

x=8 

if x>=8.5:

print"Conceito A" if x>=7.5:

print"Conceito B" if x>=5.5:

   print"Conceito C"

if x>=5:

print "Conceito D"

Resposta:

Conceito B 

Conceito C 

Conceito D

2.Indique a mensagem que apresentará a execução das seguintes instruções:

x=8

if x>=8.5:

 print "Conceito A"

elif x>=7.5:

 print "Conceito B"

elif x>=5.5:

 print "Conceito C"

elif x>=5:

 print "Conceito D"

Resposta:

Conceito B

3.Indique a mensagem que apresentará a execução das seguintes instruções:

aluno="Joao Carlo" disciplina="PI"

if aluno=="Joao Carlos"and disciplina=="PI": print"Conceito A"

else:

print"Alunonao cadastrado"

Resposta:

Aluno nao cadastrado

4.Indique a mensagem que apresentara´ a execução das seguintes instruções:

aluno="Joao Carlo" disciplina="PI"

if aluno=="Joao Carlos"ordisciplina=="PI":print"Conceito A"

else:

print"Aluno nao cadastrado"

Resposta:

 Conceito A

5. Indique a mensagem que apresentará a execução das seguintes instruções:

x=8

y=5

z=13

if x>=1 and x<=31: if y>0 and y<13 span="">:

if x+y!=z:

print"A data de hoje eh 8/5/13" else:

print"A data de hoje nao eh 8/5/13"

Resposta:

 A data de hoje nao eh8/5/13

6.     Crie uma função em que, dados 3 números como parâmetros, permita verificar se a soma de quaisquer par de números gera a soma do terceiro número.

def verificar_somatoria(a,c,b):

if a+b==c:

returnstr(a)+’+’+str(b)+’=’+str(c)

if a+c==b:

returnstr(a)+’+’+str(c)+’=’+str(b)

if b+c==a:

returnstr(b)+’+’+str(c)+’=’+str(a)

7.     Crie uma função  determinar o maior numero que receba dois números (inteiros ou reais) e retorne o maior valor de ambos os números.

def determinar_o_maior_numero(p, q):

 if p<q:

return q

else:

return p

8.     Crie uma função   determinar o maior numero que receba três números (inteiros ou reais) e retorne o maior valor do números.

def determinar_o_maior_numero(a,b,c):

 if a<b:

if b<c:

return c

       else:

return b

else:

if a<c:

return c

       else:

return a