Neste artigo, iremos publicar um gráfico (Dashboard) que expoem um grafico de algebra linear.
A álgebra linear é um ramo da matemática que lida com vetores, matrizes e sistemas lineares de equações. É uma ferramenta fundamental em muitas áreas da ciência e engenharia devido à sua capacidade de representar e resolver problemas em múltiplas dimensões de forma eficiente.
Conceitos Básicos da Álgebra Linear
Vetores: Objetos que têm magnitude e direção. Em álgebra linear, são frequentemente representados como listas de números (coordenadas).
Matrizes: Arranjos retangulares de números que podem representar transformações lineares, sistemas de equações lineares, entre outros. Uma matriz é essencialmente uma coleção de vetores dispostos em linhas e colunas.
Operações Lineares: Incluem adição de vetores, multiplicação de vetores por escalares, multiplicação de matrizes, entre outras. Essas operações seguem regras específicas que mantêm a linearidade.
Sistemas Lineares: Conjuntos de equações lineares que podem ser resolvidos usando técnicas da álgebra linear para encontrar os valores das variáveis.
Aplicações da Álgebra Linear
Ciência de Dados e Aprendizado de Máquina:
Regressão Linear: Utilizada para encontrar a melhor linha de ajuste para um conjunto de dados.
Redução de Dimensionalidade: Métodos como Análise de Componentes Principais (PCA) utilizam álgebra linear para reduzir a dimensionalidade dos dados, mantendo as características mais importantes.
Redes Neurais: A álgebra linear é usada para calcular as operações de multiplicação de matrizes que são fundamentais no treinamento de redes neurais.
Engenharia:
Análise de Circuitos: Utilizada para resolver sistemas de equações lineares que representam circuitos elétricos.
Mecânica Estrutural: A álgebra linear ajuda a analisar forças e tensões em estruturas, permitindo a modelagem de comportamentos estáticos e dinâmicos.
Computação Gráfica:
Transformações Geométricas: Rotação, translação e escalonamento de objetos em gráficos 3D são realizados usando matrizes.
Renderização: Técnicas de renderização utilizam álgebra linear para calcular a interação da luz com superfícies.
Economia e Finanças:
Modelagem Econômica: Matrizes são usadas para representar e resolver modelos econômicos que envolvem múltiplas variáveis interdependentes.
Análise de Carteiras: Utilizada para otimizar a composição de carteiras de investimento minimizando o risco e maximizando o retorno.
Física e Química:
Mecânica Quântica: Operadores lineares e vetores de estado são conceitos-chave na formulação matemática da mecânica quântica.
Dinâmica de Sistemas: Sistemas físicos são frequentemente modelados usando equações diferenciais lineares que podem ser resolvidas com técnicas de álgebra linear.
Importância da Álgebra Linear
A álgebra linear fornece as ferramentas para modelar e resolver problemas complexos de maneira eficiente e precisa. Sua aplicação pervasiva em várias disciplinas a torna uma habilidade essencial para cientistas, engenheiros, analistas de dados e muitos outros profissionais. Compreender e aplicar conceitos de álgebra linear é fundamental para inovar e resolver problemas em um mundo cada vez mais orientado por dados e tecnologia.
import streamlit as st
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
st.title('Regressão Linear Simples')
# Função para gerar dados de exemplo
def generate_data(n_samples=100):
np.random.seed(42)
X = 2 * np.random.rand(n_samples, 1)
y = 4 + 3 * X + np.random.randn(n_samples, 1)
return X, y
# Gerar dados
X, y = generate_data()
# Exibir os dados em um gráfico
st.subheader('Dados de Treinamento')
fig, ax = plt.subplots()
ax.scatter(X, y, color='blue')
ax.set_xlabel('X')
ax.set_ylabel('y')
st.pyplot(fig)
# Treinar o modelo de regressão linear
model = LinearRegression()
model.fit(X, y)
y_pred = model.predict(X)
# Exibir a linha de regressão
st.subheader('Linha de Regressão')
fig, ax = plt.subplots()
ax.scatter(X, y, color='blue', label='Dados')
ax.plot(X, y_pred, color='red', linewidth=2, label='Linha de Regressão')
ax.set_xlabel('X')
ax.set_ylabel('y')
ax.legend()
st.pyplot(fig)
# Exibir os coeficientes
st.subheader('Coeficientes do Modelo')
st.write(f'Intercepto: {model.intercept_[0]}')
st.write(f'Coeficiente: {model.coef_[0][0]}')
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from scipy.optimize import curve_fit
# Função para criar a distribuição gaussiana aleatória
def create_gaussian_distribution(mean=0, stddev=1, num_samples=1000):
return np.random.normal(mean, stddev, num_samples)
# Função gaussiana para ajuste
def gaussian(x, amplitude, mean, stddev):
return amplitude * np.exp(-((x - mean) ** 2) / (2 * stddev ** 2))
# Função para calcular o FWHM
def calculate_fwhm(data):
# Histograma dos dados
counts, bin_edges = np.histogram(data, bins=100, density=True)
bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
# Ajuste da curva gaussiana
popt, _ = curve_fit(gaussian, bin_centers, counts, p0=[1, np.mean(data), np.std(data)])
amplitude, mean, stddev = popt
# FWHM para uma distribuição gaussiana é 2 * sqrt(2 * ln(2)) * stddev
fwhm = 2 * np.sqrt(2 * np.log(2)) * stddev
# Plot para visualização (opcional)
plt.hist(data, bins=100, density=True, alpha=0.6, color='g')
plt.plot(bin_centers, gaussian(bin_centers, *popt), linewidth=2, color='r')
plt.title(f'Gaussian Fit: Mean = {mean:.2f}, Stddev = {stddev:.2f}, FWHM = {fwhm:.2f}')
plt.xlabel('Value')
plt.ylabel('Probability Density')
plt.show()
return fwhm
# Exemplo de uso
data = create_gaussian_distribution(mean=0, stddev=1, num_samples=1000)
fwhm = calculate_fwhm(data)
print(f'FWHM: {fwhm}')
Exercício 2
Descreva plote os gráficos a seguir:
Uso de Parenthesis: x(t) = y(t)
import numpy as np
import matplotlib.pyplot as plt
# Definir o intervalo de tempo
t = np.linspace(0, 10, 1000)
# Definir as funções x(t) e y(t)
x_t = np.sin(2 * np.pi * t)
y_t = np.cos(2 * np.pi * t)
# Criar o gráfico
plt.figure(figsize=(10, 6))
plt.plot(t, x_t, label='$x(t) = \sin(2\pi t)$', color='b')
plt.plot(t, y_t, label='$y(t) = \cos(2\pi t)$', color='r')
plt.title('Sinal Contínuo: $x(t)$ e $y(t)$')
plt.xlabel('Tempo $t$')
plt.ylabel('Amplitude')
plt.legend()
plt.grid(True)
plt.show()
Após executar a função, temos o gráfico
Agora iremos mostrar o gráfico x[t], y[t]:
Onde o mesmo é uma apresentação de um sinal discreto, ou seja , ele apresenta de forma não contínua. Sendo taxas de amostragem ao longo do tempo.
import numpy as np
import matplotlib.pyplot as plt
# Definir o intervalo de tempo contínuo
t_continuous = np.linspace(0, 10, 1000)
# Definir o intervalo de tempo discreto
t_discrete = np.arange(0, 10, 0.1)
# Definir as funções contínuas x(t) e y(t)
x_t_continuous = np.sin(2 * np.pi * t_continuous)
y_t_continuous = np.cos(2 * np.pi * t_continuous)
# Definir as funções discretas x[t] e y[t]
x_t_discrete = np.sin(2 * np.pi * t_discrete)
y_t_discrete = np.cos(2 * np.pi * t_discrete)
# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 12))
# Gráfico do sinal contínuo
axs[0].plot(t_continuous, x_t_continuous, label='$x(t) = \sin(2\pi t)$', color='b')
axs[0].plot(t_continuous, y_t_continuous, label='$y(t) = \cos(2\pi t)$', color='r')
axs[0].set_title('Sinal Contínuo: $x(t)$ e $y(t)$')
axs[0].set_xlabel('Tempo $t$')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)
# Gráfico do sinal discreto
axs[1].stem(t_discrete, x_t_discrete, label='$x[t] = \sin(2\pi t)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[1].stem(t_discrete, y_t_discrete, label='$y[t] = \cos(2\pi t)$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[1].set_title('Sinal Discreto: $x[t]$ e $y[t]$')
axs[1].set_xlabel('Tempo $t$')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)
plt.tight_layout()
plt.show()
Ficando conforme apresentado a seguir:
expressão x[n] -> system-> y[n]
import numpy as np
import matplotlib.pyplot as plt
# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 1)
# Definir a função de entrada x[n]
x_n = np.sin(2 * np.pi * n / 10)
# Definir a constante de escala k
k = 2
# Aplicar o sistema para obter a saída y[n]
y_n = k * x_n
# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 8))
# Gráfico do sinal de entrada x[n]
axs[0].stem(n, x_n, label='$x[n] = \sin(2\pi n / 10)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[0].set_title('Sinal de Entrada: $x[n]$')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)
# Gráfico do sinal de saída y[n]
axs[1].stem(n, y_n, label='$y[n] = 2 \cdot x[n]$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[1].set_title('Sinal de Saída: $y[n]$')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)
plt.tight_layout()
plt.show()
Homogenidade, x[n] -> system-> y[n]; No exemplo expresso pela função: y[n]=k⋅x[n]
import numpy as np
import matplotlib.pyplot as plt
# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 1)
# Definir a função de entrada x[n]
x_n = np.sin(2 * np.pi * n / 10)
# Definir a constante de escala k
k = 2
# Aplicar o sistema para obter a saída y[n]
y_n = k * x_n
# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 8))
# Gráfico do sinal de entrada x[n]
axs[0].stem(n, x_n, label='$x[n] = \sin(2\pi n / 10)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[0].set_title('Sinal de Entrada: $x[n]$')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)
# Gráfico do sinal de saída y[n]
axs[1].stem(n, y_n, label='$y[n] = 2 \cdot x[n]$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[1].set_title('Sinal de Saída: $y[n]$')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)
plt.tight_layout()
plt.show()
agora de aditivo, tal como x1[n]+x2[n] -> system -> y1[n] + y2[n], tal como um exemplo, podemos apresentar o exemplo de um ruído.
import numpy as np
import matplotlib.pyplot as plt
# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 1)
# Definir as funções de entrada x1[n] e x2[n]
x1_n = np.sin(2 * np.pi * n / 10)
x2_n = np.cos(2 * np.pi * n / 10)
# Definir a constante de escala k
k = 2
# Aplicar o sistema para obter as saídas y1[n] e y2[n]
y1_n = k * x1_n
y2_n = k * x2_n
# Aplicar o sistema para a soma das entradas
x_sum_n = x1_n + x2_n
y_sum_n = k * x_sum_n
# Calcular a soma das saídas individuais
y_sum_individual_n = y1_n + y2_n
# Criar os gráficos
fig, axs = plt.subplots(3, 1, figsize=(10, 12))
# Gráfico dos sinais de entrada x1[n] e x2[n]
axs[0].stem(n, x1_n, label='$x_1[n] = \sin(2\pi n / 10)$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[0].stem(n, x2_n, label='$x_2[n] = \cos(2\pi n / 10)$', linefmt='g-', markerfmt='go', basefmt='r-')
axs[0].set_title('Sinais de Entrada: $x_1[n]$ e $x_2[n]$')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)
# Gráfico dos sinais de saída y1[n] e y2[n]
axs[1].stem(n, y1_n, label='$y_1[n] = 2 \cdot x_1[n]$', linefmt='b-', markerfmt='bo', basefmt='r-')
axs[1].stem(n, y2_n, label='$y_2[n] = 2 \cdot x_2[n]$', linefmt='g-', markerfmt='go', basefmt='r-')
axs[1].set_title('Sinais de Saída: $y_1[n]$ e $y_2[n]$')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)
# Gráfico da soma das saídas comparado à saída da soma das entradas
axs[2].stem(n, y_sum_n, label='$y[n] = 2 \cdot (x_1[n] + x_2[n])$', linefmt='r-', markerfmt='ro', basefmt='r-')
axs[2].stem(n, y_sum_individual_n, label='$y_1[n] + y_2[n]$', linefmt='m-', markerfmt='mo', basefmt='r-')
axs[2].set_title('Comparação: $y[n]$ e $y_1[n] + y_2[n]$')
axs[2].set_xlabel('n')
axs[2].set_ylabel('Amplitude')
axs[2].legend()
axs[2].grid(True)
plt.tight_layout()
plt.show()
Agora usaremos o exemplo de shift, apresentando uma onda quadrada, com deslocamento.
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
# Definir o intervalo de tempo discreto
n = np.arange(0, 20, 0.1)
# Definir a função de entrada x[n] como uma onda quadrada
x_n = signal.square(2 * np.pi * n / 10)
# Definir o deslocamento s
s = 3
# Aplicar o deslocamento à entrada
x_shifted = signal.square(2 * np.pi * (n - s) / 10)
# Definir a constante de escala k (sistema)
k = 2
# Aplicar o sistema ao sinal deslocado
y_shifted = k * x_shifted
# Criar os gráficos
fig, axs = plt.subplots(2, 1, figsize=(10, 8))
# Gráfico do sinal de entrada x[n] e do sinal deslocado x[n+s]
axs[0].plot(n, x_n, label='$x[n] = \mathrm{square}(2\pi n / 10)$', color='b')
axs[0].plot(n, x_shifted, label='$x[n+s] = \mathrm{square}(2\pi (n-s) / 10)$', color='g')
axs[0].set_title('Sinal de Entrada e Sinal Deslocado (Onda Quadrada)')
axs[0].set_xlabel('n')
axs[0].set_ylabel('Amplitude')
axs[0].legend()
axs[0].grid(True)
# Gráfico do sinal de saída deslocado y[n+s]
axs[1].plot(n, y_shifted, label='$y[n+s] = 2 \cdot \mathrm{square}(2\pi (n-s) / 10)$', color='r')
axs[1].set_title('Sinal de Saída Deslocado: $y[n+s]$ (Onda Quadrada)')
axs[1].set_xlabel('n')
axs[1].set_ylabel('Amplitude')
axs[1].legend()
axs[1].grid(True)
plt.tight_layout()
plt.show()
Ficando no exemplo, claramente o deslocamento.
Exercício 3
import numpy as np
import matplotlib.pyplot as plt
# Função para gerar sinais exponenciais e^(an)
def exponential(a, n):
expo = []
for sample in n:
expo.append(np.exp(a * sample))
return expo
# Definir parâmetros
a = 2
UL = 1
LL = -1
n = np.arange(LL, UL, 0.1)
x = exponential(a, n)
# Aumentar o ganho em 10x
x_gain = [10 * value for value in x]
# Somar por 5
x_add = [value + 5 for value in x]
# Subtrair por pi
x_subtract = [value - np.pi for value in x]
# Fazer um shift de 3 posições
shift = 3
n_shifted = n + shift
x_shift = exponential(a, n - shift)
# Plotar os gráficos
fig, axs = plt.subplots(4, 1, figsize=(10, 20))
# Sinal original
axs[0].stem(n, x, basefmt=" ", use_line_collection=True)
axs[0].set_xlabel('n')
axs[0].set_ylabel('x[n]')
axs[0].set_title('Exponential Signal $e^{an}$')
# Aumento de ganho em 10x
axs[1].stem(n, x_gain, basefmt=" ", use_line_collection=True)
axs[1].set_xlabel('n')
axs[1].set_ylabel('10x[n]')
axs[1].set_title('Exponential Signal $10 \cdot e^{an}$')
# Soma por 5
axs[2].stem(n, x_add, basefmt=" ", use_line_collection=True)
axs[2].set_xlabel('n')
axs[2].set_ylabel('x[n] + 5')
axs[2].set_title('Exponential Signal $e^{an} + 5$')
# Subtração por pi
axs[3].stem(n, x_subtract, basefmt=" ", use_line_collection=True)
axs[3].set_xlabel('n')
axs[3].set_ylabel('x[n] - π')
axs[3].set_title('Exponential Signal $e^{an} - π$')
# Shift de 3 posições
fig, ax = plt.subplots(figsize=(10, 5))
ax.stem(n_shifted, x_shift, basefmt=" ", use_line_collection=True)
ax.set_xlabel('n')
ax.set_ylabel('x[n-3]')
ax.set_title('Exponential Signal Shifted by 3 Positions $e^{a(n-3)}$')
plt.tight_layout()
plt.show()
# Lista de notas dos alunos
notas = [85, 90, 78, 92, 88]
# Calcula a soma de todas as notas
soma_notas = sum(notas)
# Calcula a quantidade de notas
quantidade_notas = len(notas)
# Calcula a média
media = soma_notas / quantidade_notas
print(f"A média das notas dos alunos é: {media:.2f}")
1.2 Exercício
def calcular_media(notas):
# Calcula a soma de todas as notas
soma_notas = sum(notas)
# Calcula a quantidade de notas
quantidade_notas = len(notas)
# Calcula a média
media = soma_notas / quantidade_notas
print(f"A média das notas dos alunos é: {media:.2f}")
# Exemplo de uso da função
notas_alunos = [85, 90, 78, 92, 88]
calcular_media(notas_alunos)
Exercício 2.1
def criar_matriz(largura, altura, v):
# Cria uma matriz de dimensão largura x altura preenchida com o valor v
matriz = [[v for _ in range(largura)] for _ in range(altura)]
return matriz
def imprimir_matriz(matriz):
# Imprime a matriz linha por linha
for linha in matriz:
print(' '.join(map(str, linha)))
def main():
# Solicita ao usuário as dimensões da matriz e o valor de preenchimento
largura = int(input("Informe a largura da matriz: "))
altura = int(input("Informe a altura da matriz: "))
v = input("Informe o valor de preenchimento: ")
# Cria a matriz
matriz = criar_matriz(largura, altura, v)
# Imprime a matriz
imprimir_matriz(matriz)
if __name__ == "__main__":
main()
Exercício 2.2
def criar_matriz(largura, altura, v):
# Cria uma matriz de dimensão largura x altura preenchida com o valor v
matriz = [[v for _ in range(largura)] for _ in range(altura)]
return matriz
def imprimir_matriz(matriz):
# Imprime a matriz linha por linha
for linha in matriz:
print(' '.join(map(str, linha)))
def main():
# Solicita ao usuário as dimensões da matriz e o valor de preenchimento
largura = int(input("Informe a largura da matriz: "))
altura = int(input("Informe a altura da matriz: "))
v = input("Informe o valor de preenchimento: ")
# Cria a matriz
matriz = criar_matriz(largura, altura, v)
# Imprime a matriz
imprimir_matriz(matriz)
if __name__ == "__main__":
main()
Como encontrar a posição final de um braço robótico com 3 servos
Um braço robótico é uma estrutura mecânica articulada que pode ser controlada por meio de servos. Cada servo é responsável por controlar o movimento em um eixo específico, como o eixo X, Y ou Z. Para encontrar a posição final do braço robótico nos eixos X e Y, é necessário utilizar uma fórmula que leve em consideração os ângulos de rotação de cada servo.
Fórmula para encontrar a posição final
A fórmula para encontrar a posição final de um braço robótico com 3 servos nos eixos X e Y é baseada na trigonometria. Vamos supor que os ângulos de rotação dos servos sejam representados por θ1, θ2 e θ3, respectivamente.
Portanto, a posição final do braço robótico nos eixos X e Y é aproximadamente (32,07 cm, 31,75 cm).
Considerações finais
A fórmula apresentada permite encontrar a posição final de um braço robótico nos eixos X e Y com base nos ângulos de rotação dos servos e nos comprimentos dos segmentos do braço. É importante lembrar que essa fórmula assume que o braço robótico opera em um plano bidimensional e que não há interferências ou restrições adicionais.
Além disso, é fundamental ter em mente que a precisão da posição final depende da precisão dos ângulos de rotação dos servos e dos comprimentos dos segmentos do braço. Qualquer imprecisão ou erro na medição ou no controle dos servos pode afetar a posição final do braço robótico.
Em resumo, a fórmula apresentada é uma ferramenta útil para calcular a posição final de um braço robótico nos eixos X e Y, mas é necessário ter cuidado ao utilizar e interpretar os resultados.
1 – Senha Pronto Atendimento Escreva um programa que destribua senhas aos pacientes que chegam no Atendimento de Emergência de um Hospital. Deverá seguir os seguintes critérios
O hospital possui 3 filas (ortopedia, Atendimento Comum e Atendimento Prioritário) A senha será composta por 3 letras indicando a fila e 3 algarismos indicando a posição do paciente na fila (AAA-000) A senha de atendimento preferêncial irá iniciar com as letras ATP A senha de atendimento comum irá iniciar com as letras ATC A senha de atendimento para ortopedia irá iniciar com as letras ORT Antes de finalizar o programa, o mesmo deverá imprimir a lista de senhas geradas em cada fila
In [1]:
# Função para gerar senhasdef gerar_senha(fila, tipo, contador):
if tipo == "prioritaria":
prefixo = "ATP"
elif tipo == "comum":
prefixo = "ATC"
elif tipo == "ortopedia":
prefixo = "ORT"
else:
raise ValueError("Tipo de fila inválido")
senha = f"{prefixo}-{contador:03d}"
fila.append(senha)
# Filas
ortopedia = []
atendimento_comum = []
atendimento_prioritario = []
# Função para imprimir senhas em uma filadef imprimir_senhas(fila, nome):
print(f"Senhas na fila {nome}:")
for senha in fila:
print(senha)
# Simulação de um estudante aprendendo Python
print("Bem-vindo ao sistema de distribuição de senhas do hospital!")
print("Escolha o tipo de atendimento:")
print("1 - Ortopedia")
print("2 - Atendimento Comum")
print("3 - Atendimento Prioritário")
opcao = input("Digite o número correspondente ao tipo de atendimento desejado: ")
if opcao == "1":
gerar_senha(ortopedia, "ortopedia", len(ortopedia))
imprimir_senhas(ortopedia, "Ortopedia")
elif opcao == "2":
gerar_senha(atendimento_comum, "comum", len(atendimento_comum))
imprimir_senhas(atendimento_comum, "Atendimento Comum")
elif opcao == "3":
gerar_senha(atendimento_prioritario, "prioritaria", len(atendimento_prioritario))
imprimir_senhas(atendimento_prioritario, "Atendimento Prioritário")
else:
print("Opção inválida! Por favor, escolha uma opção válida.")
Bem-vindo ao sistema de distribuição de senhas do hospital!
Escolha o tipo de atendimento:
1 - Ortopedia
2 - Atendimento Comum
3 - Atendimento Prioritário
Digite o número correspondente ao tipo de atendimento desejado: 1
Senhas na fila Ortopedia:
ORT-000
Nota complementar
Fiz um outro programa em uma terceira linguagem aderente ao exercicio.
2 – Horário de Medicamentos Faça um programa que a equipe de enfermagem entre com as informações do paciente para lembra-los do horário da medicação com as seguintes recomendações:
Dados do Paciente – Nome Completo, Data de Nascimento e Tipo do sangue Dados da Medicação – Nome da Medicação, Classificação, e horário para aplicação A Classificação do Medicamento será – medicamento comum, Psicotrópico, Alto risco, Alto custo e Psicotrópicos Ao chegar nos horários do medicamento, um aviso deverá aparecer na tela o horário pode ser simulado mas se for usado a hora do computador ganhará mais pontos Pelo menos 2 horários distintos para alarmar
In [ ]:
import datetime
import time
# Função para calcular a idade a partir da data de nascimentodef calcular_idade(data_nascimento):
hoje = datetime.date.today()
ano_nascimento = data_nascimento.year
idade = hoje.year - ano_nascimento
if hoje.month < data_nascimento.month or (hoje.month == data_nascimento.month and hoje.day < data_nascimento.day):
idade -= 1
return idade
# Função para formatar a data de nascimentodef formatar_data(data):
return data.strftime("%d/%m/%Y")
# Função para verificar se é hora da medicaçãodef verificar_horario_med(med_horario, hora_atual):
for horario in med_horario:
if hora_atual.hour == horario.hour and hora_atual.minute == horario.minute:
returnTruereturnFalse# Dados do paciente
nome = input("Digite o nome completo do paciente: ")
data_nascimento = datetime.datetime.strptime(input("Digite a data de nascimento do paciente (formato: dd/mm/aaaa): "), "%d/%m/%Y")
tipo_sangue = input("Digite o tipo sanguíneo do paciente: ")
# Dados da medicação
nome_med = input("Digite o nome da medicação: ")
classificacao_med = input("Digite a classificação da medicação (comum, psicotrópico, alto risco, alto custo, psicotrópicos): ").lower()
horarios = []
for i in range(2):
hora = datetime.datetime.strptime(input(f"Digite o horário {i+1} para aplicação da medicação (formato: hh:mm): "), "%H:%M")
horarios.append(hora.time())
# Imprimir informações do paciente e da medicação
print("\n--- Informações do Paciente ---")
print("Nome:", nome)
print("Data de Nascimento:", formatar_data(data_nascimento))
print("Idade:", calcular_idade(data_nascimento), "anos")
print("Tipo Sanguíneo:", tipo_sangue)
print("\n--- Informações da Medicação ---")
print("Nome da Medicação:", nome_med)
print("Classificação da Medicação:", classificacao_med.capitalize())
print("Horários de Aplicação:", ", ".join(map(lambda x: x.strftime("%H:%M"), horarios)))
# Variável para controlar se a mensagem já foi exibida
mensagem_exibida =False# Simulação do tempo para verificar o horário da medicação
print("\nSimulando o tempo para verificar o horário da medicação...")
whileTrue:
hora_atual = datetime.datetime.now().time()
if verificar_horario_med(horarios, hora_atual) andnot mensagem_exibida:
print("Hora da medicação! Não se esqueça de tomar o medicamento:", nome_med)
mensagem_exibida =Trueelifnot verificar_horario_med(horarios, hora_atual):
mensagem_exibida =False# Aguardar 1 minuto antes de verificar novamente
time.sleep(60)
Digite o nome completo do paciente: marcelo
Digite a data de nascimento do paciente (formato: dd/mm/aaaa): 20/12/1999
Digite o tipo sanguíneo do paciente: a
Digite o nome da medicação: paracetamol
Digite a classificação da medicação (comum, psicotrópico, alto risco, alto custo, psicotrópicos): 12:56
Digite o horário 1 para aplicação da medicação (formato: hh:mm): 12:57
Digite o horário 2 para aplicação da medicação (formato: hh:mm): 12:58
--- Informações do Paciente ---
Nome: marcelo
Data de Nascimento: 20/12/1999
Idade: 24 anos
Tipo Sanguíneo: a
--- Informações da Medicação ---
Nome da Medicação: paracetamol
Classificação da Medicação: 12:56
Horários de Aplicação: 12:57, 12:58
Simulando o tempo para verificar o horário da medicação...
Hora da medicação! Não se esqueça de tomar o medicamento: paracetamol
3 – Inventário de Equipamentos Biomédicos Faça um programa que tenha dois modos acessados por um menu. O primeiro módulo é de cadastro de equipamentos médicos e o segundo é de consulta dos equipamentos cadastrados. Siga as instruções:
O software deverá ter um menu principal onde o usuáriopoderá acessar as duas opções Na parte de cadastramento o usuário deverá entrar com os dados nos campos: Nome do Equipamento, TAG de identificação, e local de uso. A tag é um jeito mais fácil de identificar os equipamentos. exemplo:3° monitor multiparemetro da UTI -> UTI-MNP-0003 Porém vc pode criar a sua forma No modo de consulta deverá ter 3 formas de consulta (TAG, Tipo de equipamento e Local de uso) Ao consultar um item por uma das formas, as outras informações referente a este item taambém deverá aparecer
In [ ]:
# Função para cadastrar um novo equipamentodef cadastrar_equipamento(inventario):
print("\n--- Cadastro de Equipamento ---")
nome = input("Digite o nome do equipamento: ")
local = input("Digite o local de uso do equipamento: ")
tag = input("Digite a TAG de identificação do equipamento: ")
inventario.append({"Nome": nome, "Local": local, "TAG": tag})
print("Equipamento cadastrado com sucesso!")
# Função para consultar equipamentos por TAGdef consultar_por_tag(inventario):
tag_consulta = input("Digite a TAG do equipamento que deseja consultar: ")
encontrado =Falsefor equipamento in inventario:
if equipamento["TAG"] == tag_consulta:
print("\n--- Informações do Equipamento ---")
print("Nome:", equipamento["Nome"])
print("Local de Uso:", equipamento["Local"])
print("TAG:", equipamento["TAG"])
encontrado =Truebreakifnot encontrado:
print("Equipamento não encontrado!")
# Função para consultar equipamentos por Tipodef consultar_por_tipo(inventario):
tipo_consulta = input("Digite o tipo de equipamento que deseja consultar: ")
encontrado =Falsefor equipamento in inventario:
if tipo_consulta in equipamento["TAG"]:
print("\n--- Informações do Equipamento ---")
print("Nome:", equipamento["Nome"])
print("Local de Uso:", equipamento["Local"])
print("TAG:", equipamento["TAG"])
encontrado =Trueifnot encontrado:
print("Nenhum equipamento desse tipo encontrado!")
# Função para consultar equipamentos por Localdef consultar_por_local(inventario):
local_consulta = input("Digite o local de uso que deseja consultar: ")
encontrado =Falsefor equipamento in inventario:
if equipamento["Local"].lower() == local_consulta.lower():
print("\n--- Informações do Equipamento ---")
print("Nome:", equipamento["Nome"])
print("Local de Uso:", equipamento["Local"])
print("TAG:", equipamento["TAG"])
encontrado =Trueifnot encontrado:
print("Nenhum equipamento encontrado nesse local!")
# Função para exibir o menu principaldef exibir_menu():
print("\n--- Menu Principal ---")
print("1. Cadastrar Equipamento")
print("2. Consultar Equipamentos")
print("3. Sair")
# Lista para armazenar os equipamentos cadastrados
inventario = []
# Loop principal do programawhileTrue:
exibir_menu()
opcao = input("Escolha uma opção: ")
if opcao == "1":
cadastrar_equipamento(inventario)
elif opcao == "2":
print("\n--- Opções de Consulta ---")
print("1. Por TAG")
print("2. Por Tipo de Equipamento")
print("3. Por Local de Uso")
consulta_opcao = input("Escolha uma opção de consulta: ")
if consulta_opcao == "1":
consultar_por_tag(inventario)
elif consulta_opcao == "2":
consultar_por_tipo(inventario)
elif consulta_opcao == "3":
consultar_por_local(inventario)
else:
print("Opção de consulta inválida!")
elif opcao == "3":
print("Saindo do programa...")
breakelse:
print("Opção inválida! Por favor, escolha uma opção válida.")
1 – O desenho abaixo representa um circuito elétrico composto por resistores ôhmicos, um gerador ideal e um receptor ideal. Qual a potência elétrica dissipada no resistor de 4 Ω?
Segunda lei de Kirchhoff.
8 + 3.i + (-6) + 4.i + 3.i = 0
8 -6 + 3i +4i +3i = 0
10i = -2
i = -0.2A
(Sentido Invertido )
2- Determine os valores das correntes elétricas i1, i2 e i3.
English 
Portuguese