print('escreva')

-------------------------------
print("exemplo" ,7+4)
------------------------------------------------------------------
###registrando variaveis####

nome='pedro'

idade='23'

peso='70'

print('nome:', nome,'idade:', idade,'peso:',peso)

-------------------------------------------------------------
####criando iteratividade com o usuario###

nome=input('Qual é o seu nome?')

idade=input('Qual a sua idade?')

peso=input('Qual o seu peso?')

print('nome:', nome,'idade:', idade,'peso:',peso)

========desafio 01==============================================
nome=input('Qual é o seu nome?')

print('bem vindo!', nome,)

==============desafio 02========================================

dia=input('Qual é o dia em que voce nasceu?')

mes=input('Qual é o mes em que voce nasceu?')

ano=input('Qual é o ano em que voce nasceu?')

print("sua data de nascimento é:", dia,'/', mes,'/',ano)

======================dasafio 03===========================================
numero1=int(input('digite o primeiro numero'))

numero2=int(input('digite o segundo numero'))

soma= numero1+numero2
print("seu valor é", soma)
--------------------------------------------------------------------------
int ==> para numeros inteiros

float==> numeros real

bool==> só aceita true e false o t e o f tem que estar maiusculo

str==> palavras pode colocar numeros entre aspas

--------------------------------------------------------------------------
outro jeito de escrever o print
print("a soma vale {}".format(s))

--------------------------------------------------------
n1= int(input("digite um valor"))
n2= int(input("digite outro valor"))
s= n1+n2
#para ver o tipo de numero
print('a soma entre',n1, "e", n2, "vale", s, type(s))
------------------------------------------------------
n1= int(input("digite um valor"))
n2= int(input("digite outro valor"))
s= n1+n2
#para ver o tipo de numero
print("a soma entre {} e {} vale {}".format(n1,n2,s))
---------------------------------------------------------
=========tipos de operadores ==============================
+ adição
- subtração
* multiplicação
/ divisão
** potencia
// divisão inteira
% resto da divisão
**(1/2) raiz quadrada
========================ordem de precedencia=====================
1--> ()
2--> **
3--> *,/,//,%
4--> +,-
=============================================
nome=input('como vc se chama?')
print('prazer em te conhecer {:>20}!'.format(nome))
#repare dentro do {} que tem os 2 pontos maior que 20 isso faz o texto alinhar 20
caracteres a direita
caso queira a esquerda é só colocar o sinal de menor se eu usar o ^ ele fica
centralizado.

se eu colocar o sinal de igual assim print('prazer em te conhecer

{:=^20}!'.format(nome))
o nome vai ficar centralizado com sinais de igual em volta
=====================================================
para quebrar o print so colocar no meio o \n
=======================================================
##################desafio#######################

###faça um progama que leia o antecessor e o sucessor de um numero###

n1=int(input('digite um valor'))
an= n1-1
su= n1+1
print('o antecessor é {},\n o sucessor é {}'.format(an,su))

######################desafio#####################

#######################crie um algoritmo que lei um numero e mostre o seu dobro o

seu triplo e a sua raiz quadrada###############

n1=int(input("digite um um numero!"))
d = n1*2

tri = n1*3

raiz = n1**(1/2)

print("o dobro do seu numero é {}, \n o triplo do seu numeor é {}, \n a raiz do
seu numero é {} ".format(d,tri,raiz))

==========================desafio====================================

=========================desenvolva um progama que leia as duas notas de um aluno

calcule e mostre a sua média=========================

n1=int(input('nota 1'))
n2=int(input("nota 2"))
m=(n1+n2)/2
print("sua nota 1 é {} \n sua nota 2 é {} \n sua média é {} ".format(n1,n2,m))

============================desafio=======================================

==============================desenvolva um progama que leia o numero em metros e

exiba ele convertido em centimetros e milimetro==========================

n1=int(input('digite o valor me metros'))

cm= n1*(10**(2))
mm= n1*(10**(3))

print( "o valor me cm é {} \n o valor me metros é {}".format(cm,mm))

=================================desafio========================

============== faça um progama que leia um numero qualquer e mostre na tela a sua
taboada====================
n1=int(input("digite o numero!"))
a=n1*1
b=n1*2
c=n1*3
d=n1*4
e=n1*5
f=n1*6
g=n1*7
h=n1*8
i=n1*9
j=n1*10
print('a tabuada do numero {} é \n 1x{}={} \n 2x{}={} \n 3x{}={} \n 4x{}={} \n
5x{}={} \n 6x{}={} \n 7x{}={} \n 8x{}={} \n 9x{}={} \n
10x{}={}'.format(n1,n1,a,n1,b,n1,c,n1,d,n1,e,n1,f,n1,g,n1,h,n1,i,n1,j))

==============desafio===============================

================crie um progama que leia quanto dinheiro uma pessoa tem na carteria
e mostre quantos dolares ela pode comprar====================
n1=int(input('valor do dolar'))

n2=int(input('quanto dineiro você tem?'))

d= n2/n1
print(" valor do dolar {} reais \n você tem {} reais \n você pode comprar {}
dolares ".format(n1, n2, d) )

=======================deasafio===================================

================= faça um progama que leia a largura e a altura de uma parede em

metros calcule a area e a quantidade de tinta necessaria para pintala sabendo que
cada litro de tinta pinta uma area de 2m2=========
n1=int(input('qual a largura da parede?'))
n2=int(input("qual a altura da parede?"))

a=n1*n2
t= a/2

print("a área da sua parede é de {} então você precisa de {} litros de

tinta".format(a,t))

===== desafio================
============= faça um progama que leia o valor do pruduto e calcule o novo preço
com 5% de desconto========================

n1=int(input("valor do pruto"))

nv=n1*0.95

print("o valor do produto com desconto é de{}". format(nv))

=====================desafio==========================================
=================faça um algoritimo que leia o salario de um funcionario e mostre o
seu novo salario com 15% de aumento====================
n1=int(input("qual é o seu salario atual"))

ns=n1*1.15

print("seu novo salario com o aumento de 15% é de {}".format(ns))

###################################################################################
###############################################################
###################################################################################
###############################################################

math toda vez que eu digitar {inport math ele vai importar todas essas
funcionabilidades abaixo}

ceil-> para arredondar para cima

floor-> para arredondar para baixo

trunc-> vai truncar o numero

pow-> potencia

sqrt-> para calcular a raiz quadrada

factorial-> para caulculo de fatorial de um numero

agora por exemplo se eu quiser importar so um comando da biblioteca math como o da

raiz quadrada eu escrevo {fron math import sqrt}
#################################################
se carro.esquerda() if carro.esquerda():
bloco v bloco true

se não else:
bloco f bloco false

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

progama perguntando a idade do carro

tempo=int(input("quantos anos tem o seu carro?"))

if tempo<=3:
print("seu carro é novo!")
else:
print("já está na hora de trocar!")
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
progama quebrando um numero
import math
num=float(input("digite um numero"))
inteiro=math.floor(num)
print("o numero é {} ".format(inteiro))
#################################################
descobrindo a hipotenusa
import math
co=float(input("digite o valor do cateto oposto"))
ca=float(input("digite o valor do cateto adjacente"))
hi=math.sqrt((co**(2))+(ca**(2)))
print("o valor da sua hipotenusa é {}".format(hi))
#########################################################
seno cosseno e tg

rtan=math.tan(an)

print("o cosseno é {} o seno é {} e a tangente é {}".format(rcos,rsen,rtan))

#########################################################
sortear alunos aleatoriamente
import random
n1=str(input("digite o nome do primeiro aluno:"))
n2=str(input("digite o nome do segundo aluno:"))
n3=str(input("digite o nome do terceiro aluno:"))
n4=str(input("digite o nome do quarto aluno:"))
lista=[n1, n2, n3, n4 ]
##agora vou digitar o comando para embaralhar
random.shuffle(lista)
print("a ordem de apresentação será")
print(lista)
#######################################

condição simplificada
tempo=int(input("qauntos anos tem o seu carro?"))
print("carro novo"if tempo<=3 else"carro velho")
print("--fim--")

#############################################
exemplo condição de nome
nome=str(input("qual o seu nome?"))
if nome=="pedro":
print("belo nome!")
print("bom dia {}".format(nome))

###########################
exemplo com if e else

nome=str(input("qual o seu nome?"))

if nome=="pedro":
print("belo nome!")
else:
print("seu nome é tão normal {}".format(nome))
print("bom dia {}".format(nome))

############################################
progama calculando a media e falndo se foi aprovado ou reprovado

n1=float(input("qual a sua nota 1?"))

n2=float(input('qual a sua nota 2?'))

media=(n1+n2)/2
if media<6:
print("que pena voce reprovou, sua media é {}".format(media))

else:
print("voce está aprovado parabens, sua média é {}".format(media))
####################################
desafio 28=====> escreva um progama que faça o computador pensar em um numero
inteiro entre 0 e 5 e peça para o usuario tentar descobrir qual foi o numero
escolhido pelo computador. o progama deverá escrever na tela se o usuario acertou
ou errou

from random import randint

computador = randint(0,5)# faz o computador pensar

print("-=-" *20)
print("vou pensar em um numero entre 0 e 5 tente adivinhar...")
print("-=-" *20)
jogador=int(input("em que numero eu pensei?")) #numero que o jogador tentou
adivinhar
if jogador == computador:
print("parabens vc ganhou")
else:
print("que pena voce perdeu")
print("o numero que eu pensei foi {}".format(computador))
##############################################################################

desafio 29 escreva um progama que leia a velocidade de um carro e se ele estiver

acima de 70km/h mostre uma mensagem dizendo que ele foi multado e a multa vai
custar 7 reais por cada km acima do limite

velocidade=float(input("qual a velocidade do carro"))

if velocidade<=70:
print("o carro está no limite da estrada ")
else:
print("o carro está acima do limite de velocidade ")
multa=(velocidade-70)*7
print("sua multa foi de {}".format(multa))
##############################################################
crie um progama que lei um numero inteiro e mostre na tela se ele é par ou impar
numero=float(input("digite um numero"))
if numero%2:
print("numero {} é impar".format(numero))
else:
print("o numero {} é par ".format(numero))

#####################################################################
desenvolva um progama que pergunte a distancia de uma viagem em km e calcule o
preço da passagem cobando 0.50 por km para viagens até 200 km e 0.45 para viagens
acima de 200km

distancia=float(input("qual a distancia da sua viagem em km?"))

if distancia<=200:
valor=(distancia)*0.5
print("o valor da sua passagem é {}".format(valor))
else:
valor=(distancia)*0.45
print("o valor da sua passagem é {}".format(valor))

##########################################
faça um progama que leia um ano qualquer e mostre se ele é bissexto
ano=int(input("digite um ano "))
if ano%4:
print("o ano {} não é bissexto".format(ano))
else:
print("o ano {} é bissexto".format(ano))

###############################################
faça um progama uqe leia tres numero e mostre qual é o maior e qual é o menor
n1=float(input("digite um numero"))
n2=float(input("digete o segundo numero"))
n3=float(input("digite o terceiro numero"))

if n1<n2 and n1<n3:

menor= n1
if n2<n1 and n2<n3:
menor=n2
if n3<n1 and n3<n2:
menor= n3
if n1>n2 and n1>n3:
maior=n1
if n2>n1 and n2>n3:
maior=n2
if n3>n1 and n3>n2:
maior=n3
print('o maior numero é {} e o menor é {}'.format(maior, menor))
#######################################################
escreva um progama que pergunte o salario de um funcionario e calcule o valoir do
seu aumento para salirios superiores a 1250 terá um aumento de 10% e para
inferiores 15%

salario=float(input("qual é o seu salario?"))

if salario<=1250:
aumento=(salario)*0.15
else:
aumento=(salario)*0.1
novo=(salario)+(aumento)
print("o seu novo salario será de {} ".format(novo))
##################################################################
colocar cor no terminal

sempre que qusier representar uma cor

/033[m
entre o colchete e o m eu irei colocar o codigo da cor
posso colocar 3 codigos o primeiro é o estilo o segundo é o texto e o terceiro é a
cor de tras
/033[0;33;44m
esse é um codgo de cor
codigo para estilo 0 1 4 7
0--> sem estilo
1--> negrito
4---> sublinhado
7----> negative

cor para texto

30 branco; 31 vermelho; 32 verde; 33 amarelo; 34 azul;35 roxo; 36 azul claro; 37
cinza.

cor de traz do texto

40 branco; 41 vermelho; 42 verde; 43 amarelo; 44 azul;45 roxo; 46 azul claro; 47
cinza.

##################################################################

exemplo edo primeira ordem linear####

#################################

import numpy as np
from scipy.integrate import ode, odeint
import matplotlib.pyplot as plt

##edo de primeira ordem linear

## a edo integrada é dada por x´=1.,2*x+0,6xy com x(0)=2

#criar a função y é argumento

def xl(x,t,y):
"representa a derivada primeira de x"
return 1.2*x - 0.6*x*y

#integrar nestes instantes de tempo

x0= 2.0
t=np.arange(0.0,10,0.1)
resultado= odeint(xl,x0,t, args=(1.5,))
fig, ax =plt.subplots()
ax.plot(t,resultado)
plt.show()

###################################################################################
##############

import numpy as np
from scipy.integrate import ode, odeint
import matplotlib.pyplot as plt
##edo de segunda ordem ordem linear
### agora eu tenho 2 funçoes
## vamos criar uma função de y´
## a edo integrada é dada por x´=1.,2*x+0,6xy com x(0)=2
##y´=-0.8*y+0,3xy com y(0)=1

#criar a função
def f(v,t):
"representa a derivada primeira de x"
x,y = v
return[1.2*x - 0.6*x*y, -0.8*y +0.3*x*y]

#integrar nestes instantes de tempo

x0=[2,1]

t=np.arange(0.0,10,0.1)

resultado= odeint(f,x0,t)

print(resultado)
fig, ax =plt.subplots()
ax.plot(t,resultado)
plt.show()
###################################################################################
###############
####
edo dupla de segunda ordem###
#############################
import numpy as np
from scipy.integrate import ode, odeint
import matplotlib.pyplot as plt
from scipy.optimize import root

##temos a seguinte integral 7d2y/d2x-2dy/dx-y+x=0

## temos 2 integrais de primeira ordem fazedno assim
## dy/dx =u
## du/dx =1/7(2u+y-x)
## y=5 e y(x20)=8

#vamos criar a função

def f(w,x):
"""retorna a variavel da função"""
y,u=w
der1= u
der2= (1/7)*(2*u+y-x)
return [der1,der2]
##valores de eta
eta=np.linspace(0,20,128)
def func(c1):
"essa função determina o valor inicial da derivada a segunda "
eta0=[5,c1]
resultado= odeint(f,eta0,eta)
return 8 - resultado[::,0][-1]
c = root(func,0.1)## é o chute para a derivada a segunda
print(c)
n0 = [5, c.x[0]] # Condições iniciais

result = odeint(f, n0, eta)

print(result[::,0])

fig, ax =plt.subplots()
ax.plot(eta,result[::,0])
plt.show()
###################################################################################
################################

ex: suponha que a seguinte equação descreva a velocidade de um paraquedista

v(t)= mg/k(1-e^((k/m)/t))

qual o valor de k apara o paraquedista caia a 40 m/s depois de 10 segundos para um

paraquedista de 68kg
##solução do paraquedista

##solução do paraquedista

import numpy as np
from numpy import exp
import matplotlib.pyplot as plt
from scipy.optimize import root as raiz

g=9.81
m=float(input("digite o peso do paraquedista"))
t=float(input("digite o valor de tempo "))
def v(k,m,t):
return m*g*(1-exp(-(k/m)*t))/k

#encontrar a raiz da nossa função

v40= lambda k: 40-v(k,m,t)

sol = raiz(v40,14)
print(sol)

fig, ax =plt.subplots()
k = np.linspace(-10,100,256)
ax.plot(k, v(k,m,t))
plt.show()
################################

problema da equação de colebrook

import numpy as np
from numpy import exp, log10
import matplotlib.pyplot as plt
from scipy.optimize import root as raiz
import math

re=4e5
ed=0.0025
#d=

def colebrook(re,ed, f0=0.02):

"retorno o coeficiente de atrito "
cole= lambda sqrtf: 1/sqrtf + 2*log10(ed/3.7 +2.51/(re*sqrtf))
sol=raiz(cole, f0)
return pow(sol.x[0],2)
f= colebrook(re,ed)
print(f)

#######################################################
multiplicação de matriz
#####################################
import numpy as np

ma= [[0,0,0],[0,0,0],[0,0,0]]
for l in range(0,3):
for c in range(0,3):
ma[l][c] = float(input(f"digite um valor para [{l},{c}]"))
print('-='*30)
for l in range (0,3):
for c in range (0,3):
print(f'[{ma[l][c]}]', end='')
print()

mb= [[0,0,0],[0,0,0],[0,0,0]]
for l in range (0,3):
for c in range(0,3):
mb[l][c]= float(input(f"digite um valor para [{l},{c}]"))
print('-='*30)
for l in range (0,3):
for c in range(0,3):
print(f'[{mb[l][c]}]', end="")
print()

ab = np.matmul(ma, mb)

print(ab)

############################################
função senoidal com aplitudo e frequencia variante
#############################################
b = float(input('digite o valor da amplitude'))

c = float(input("digite o valor da frequencia "))

a = np.linspace(0,2*np.pi,400)

#### função seno####

y1 = (np.sin(c*a))*b
#y2 = y1*b

fig, ax = plt.subplots()
ax.plot(y1)
plt.show()

##################################
problema asa do avião
####################################
import math

import numpy as np
from matplotlib import pyplot as plt
from math import e

#i = float(input("digite o valor momento de inercia "))

i= 0.0003
#e = float(input("digite o valor do modo de elasticidade do material"))
E= 70000000000
#l = float(input("digite o comprimento da asa em metros "))
l= 2
#massa = float(input("digite a massa da estrutura da asa em kg"))
massa= 160
#m1 = float(input("digite a massa do tanque "))
m1= 700
#m2 = float(input("digite a massa do tanque "))
m2= 600
#m3 = float(input("digite a massa do tanque "))
m3= 500
#m4 = float(input("digite a massa do tanque "))
m4= 400
#m5 = float(input("digite a massa do tanque "))
m5= 300
#m6 = float(input("digite a massa do tanque "))
m6= 200
#m7 = float(input("digite a massa do tanque "))
m7= 100
#m8 = float(input("digite a massa do tanque "))
m8= 40
#z = float(input("digite o valor do coeficiente de amortecimento"))
z= 0.015
#v0 = float(input(" digite o valor da velocidade "))
v0= 10
x0= 0

###descobrindo o valor da rigidez equivalente ###

ke = (3 * E * i) / ((l) ** 3)
print("o valor da rigidez equivalente é {} N/M\n".format(ke))

print("##########os valores das massas equivalentes são descritos

abaixo##########")
### descobrindo a massa equivalente ###
me1 = ((33 / 140) * massa) + m1
me2 = ((33 / 140) * massa) + m2
me3 = ((33 / 140) * massa) + m3
me4 = ((33 / 140) * massa) + m4
me5 = ((33 / 140) * massa) + m5
me6 = ((33 / 140) * massa) + m6
me7 = ((33 / 140) * massa) + m7
me8 = ((33 / 140) * massa) + m8

print("a massa equivalente para 700kg é de {}kg; a massa equivalente para 600kg é
de {}kg; a massa equivalente para 500kg é de {}\n".format(me1, me2, me3))
print("a massa equivalente para 400kg é de {}kg; a massa equivalente para 300kg é
de {}kg; a massa equivalente para 200kg é de {}\n".format(me4, me5, me6))
print("a massa equivalente para 100kg é de {}kg; a massa equivalente para 40kg é de
{}kg\n".format(me7, me8))
### descobrindo a frequencia natural do sistema ###

print("##########os valores da frequencia natural são descrito abaixo##########")

##para 700kg
wn1 = math.sqrt(ke / me1)

##para 600kg
wn2 = math.sqrt(ke / me2)

##para 500kg
wn3 = math.sqrt(ke / me3)

##para 400kg
wn4 = math.sqrt(ke / me4)

##para 300kg
wn5 = math.sqrt(ke / me5)

##para 200kg
wn6 = math.sqrt(ke / me6)

##para 100kg
wn7 = math.sqrt(ke / me7)

##para 40kg
wn8 = math.sqrt(ke / me8)

print("a frequencia natural para 700kg é de {}rad/s; a frequencia natural para

600kg é de {}rad/s; a frequencia natural para 500kg é de {}rad/s\n".format( wn1,
wn2, wn3))
print("a frequencia natural para 400kg é de {}rad/s; a frequencia natural para
300kg é de {}rad/s; a frequencia natural para 200kg é de {}rad/s\n".format( wn4,
wn5, wn6))
print("a frequencia natural para 100kg é de {}rad/s; a frequencia natural para 40kg
é de {}rad/s\n".format(wn7, wn8))

### descobrindo a frequencia amortecida do sistema ###

print("##########os valores da frequencia amortecida são descritos

abaixo##########")
##para 700kg
wa1 = wn1 * math.sqrt(1 - z ** 2)
##para 600kg
wa2 = wn2 * math.sqrt(1 - z ** 2)
##para 500kg
wa3 = wn3 * math.sqrt(1 - z ** 2)
##para 400kg
wa4 = wn4 * math.sqrt(1 - z ** 2)
##para 300kg
wa5 = wn5 * math.sqrt(1 - z ** 2)
##para 200kg
wa6 = wn6 * math.sqrt(1 - z ** 2)
##para 100kg
wa7 = wn7 * math.sqrt(1 - z ** 2)
##para 40kg
wa8 = wn8 * math.sqrt(1 - z ** 2)
print("a frequencia amortecida para 700kg é de {}rad/s; a frequencia amortecida
para 600kg é de {}rads/s; a frequencia amortecida para 500kg é de {}rad/s\
n".format(wa1, wa2, wa3))
print("a frequencia amortecida para 400kg é de {}rad/s; a frequencia amortecida
para 300kg é de {}rad/s; a frequencia amortecida para 200kg é de {}rad/s\
n".format(wa4, wa5, wa6))
print("a frequencia amortecida para 100kg é de {}rad/s; a frequencia amortecida
para 40kg é de {}rad/s\n".format(wa7, wa8))

### descobrindo a amplitude ###

print("##########os valores de amplitudes são descritos abaixo##########")
###para 700 kg
a1 = (1 / wa1) * math.sqrt((v0 + z * wn1 * x0) ** 2 + (x0 * wn1) ** 2)
###para 600 kg
a2 = (1 / wa2) * math.sqrt((v0 + z * wn2 * x0) ** 2 + (x0 * wn2) ** 2)
###para 500 kg
a3 = (1 / wa3) * math.sqrt((v0 + z * wn3 * x0) ** 2 + (x0 * wn3) ** 2)
###para 400 kg
a4 = (1 / wa4) * math.sqrt((v0 + z * wn4 * x0) ** 2 + (x0 * wn4) ** 2)
###para 300 kg
a5 = (1 / wa5) * math.sqrt((v0 + z * wn5 * x0) ** 2 + (x0 * wn5) ** 2)
###para 200 kg
a6 = (1 / wa6) * math.sqrt((v0 + z * wn6 * x0) ** 2 + (x0 * wn6) ** 2)
###para 100 kg
a7 = (1 / wa7) * math.sqrt((v0 + z * wn7 * x0) ** 2 + (x0 * wn7) ** 2)
###para 40 kg
a8 = (1 / wa8) * math.sqrt((v0 + z * wn8 * x0) ** 2 + (x0 * wn8) ** 2)

print("a amplitude para 700kg é de {}hz; a amplitude para 600kg é de {}hz; a

amplitude para 500kg é de {}hz\n".format(a1, a2, a3))
print("a amplitude para 400kg é de {}hz; a amplitude para 300kg é de {}hz; a
amplitude para 200kg é de {}hz\n".format(a4, a5, a6))
print("a amplitude para 100kg é de {}hz; a amplitude para 40kg é de {}hz\
n".format(a7, a8))

t = np.linspace(0, 10, 10000)

##para 700
y1 =e**(-z*wn1*t)*(v0/(wn1*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn1*t))
##para 600
y2 =e**(-z*wn2*t)*(v0/(wn2*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn2*t))
##para 500
y3 =e**(-z*wn3*t)*(v0/(wn3*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn3*t))
##para 400
y4 =e**(-z*wn4*t)*(v0/(wn4*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn4*t))
##para 300
y5 =e**(-z*wn5*t)*(v0/(wn5*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn5*t))
##para 200
y6 =e**(-z*wn6*t)*(v0/(wn6*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn6*t))
## para 100
y7 =e**(-z*wn7*t)*(v0/(wn7*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn7*t))
##para 40
y8 =e**(-z*wn8*t)*(v0/(wn8*math.sqrt(1-(z**2)))*np.sin(math.sqrt(1-(z**2))*wn8*t))

fig, ax = plt.subplots()
ax.plot(t, y1, label=r'$m=700$ kg ')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
plt.legend(loc='upper right')
plt.show()

### para 600 kg

fig, ax = plt.subplots()
ax.plot(t, y2, label=r'$m=600$ kg ')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

### para 500 kg

fig, ax = plt.subplots()
ax.plot(t, y3, label=r'$m=500$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

### para 400 kg

fig, ax = plt.subplots()
ax.plot(t, y4, label=r'$m=400$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

### para 300 kg

fig, ax = plt.subplots()
ax.plot(t, y5, label=r'$m=300$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

### para 200 kg

fig, ax = plt.subplots()
ax.plot(t, y6, label=r'$m=200$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

### para 100 kg

fig, ax = plt.subplots()
ax.plot(t, y7, label=r'$m=100$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

### para 40 kg
fig, ax = plt.subplots()
ax.plot(t, y8, label=r'$m=40$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()

###todos os graficos no mesmo plot

fig, ax = plt.subplots()
ax.plot(t, y1, label=r'$m=700$ kg')
ax.plot(t, y2, label=r'$m=600$ kg')
ax.plot(t, y3, label=r'$m=500$ kg')
ax.plot(t, y4, label=r'$m=400$ kg')
ax.plot(t, y5, label=r'$m=300$ kg')
ax.plot(t, y6, label=r'$m=200$ kg')
ax.plot(t, y7, label=r'$m=100$ kg')
ax.plot(t, y8, label=r'$m=40$ kg')
plt.title("amplitude corrigida x periodo")
plt.xlabel("periodo")
plt.ylabel("amplitude")
ax.legend(loc='upper right')
plt.show()