Todo el material de este curso (teóricos, códigos, data input, etc) se encuentran en https://github.com/fnbellomo/curso_python_cientifico (hay dos _). En particular, los archivos con los datos de entrada estan en el directorio ./data_input/ y el nombre del archivo es datos_ejercicios_NumEjercicio.txt. Además, todas las salidas las guardamos en el directorio ./data_output/.
In [1]:
from __future__ import division
import numpy as np
In [2]:
m = 5
ma = 30
v = 2
molaridad = m/(ma*v)
print 'molaridad', molaridad
In [3]:
def molaridad(m, ma, v):
c = m/(ma*v)
return c
molaridad(m, ma, v)
Out[3]:
Ahora supongamos que tenemos muchos valores de datos iniciales a los cuales les tenemos que calcular su respectiva molaridad. Es decir, que los datos iniciales son vectores de la forma:
Escribir un código que nos permita calcular todas estas molaridades, y nos imprima en pantalla cual es la máxima con sus respectivos valores iniciales.
In [4]:
#Valores iniciales
m_vector = np.array([5, 7, 12, 4, 9, 5, 4, 3, 8, 10])
ma_vector = np.array([30, 12, 42, 6, 12, 18, 27, 16, 9, 17])
v_vector = np.array([4, 2, 4, 3, 6, 8, 1, 2, 4, 7])
c_vector = np.zeros(10)
for i in range(len(m_vector)):
c_vector[i] = molaridad(m_vector[i], ma_vector[i], v_vector[i])
#Calculo el valor maximo y su posicion
max_c = np.max(c_vector)
max_pos = np.argmax(c_vector)
print 'Valor maximo: %f con valores m = %d, v = %d, ma = %d' %(max_c,
m_vector[max_pos], v_vector[max_pos], ma_vector[max_pos])
A lo largo del curso nos vamos a encontrar con ejercicos con un *. Esto indinca que son de una dificultad mayor siendo un reto interesante (capaz que hasta divertido!).
Supongamos que tenemos los mismos datos iniciales que en el ejercicio anterior, pero con la diferencia que ahora queremos calcular todas las posibles combinaciones entre ellos, y obtener el valor maximo y la combinanción del mismo.
In [5]:
c_vector = np.zeros((100, 10))
j = 0
for k in range(10):
for h in range(10):
for i in range(10):
c_vector[j, i] = molaridad(m_vector[k], ma_vector[h], v_vector[i])
j = j + 1
max_c = np.max(c_vector)
max_pos = np.argmax(c_vector)
print 'valor maximo: ', max_c, 'y su posición es', max_pos
In [6]:
datos = np.loadtxt('data_input/datos_ejercicio_2A.txt')
def presion_gas_ideal(moles, temperatura, volumen):
r = 8.314
return (moles * r * temperatura) / volumen
salida = []
salida.append(presion_gas_ideal(datos[0], datos[1], datos[2]))
np.savetxt('data_output/output_2A.txt', salida, fmt='%.4f', header='La presion en atm es:')
In [7]:
import sys
#Tener en cuenta que este path va a variar en otra máquina
sys.path.append( '/home/franco/MEGAsync/Curso_Python_Cientifico/data_input/' )
In [8]:
from datos_ejercicio_2B import *
print presion_gas_ideal(n, T, v)
In [9]:
import matplotlib.pyplot as plt
%matplotlib inline
In [10]:
datos = np.loadtxt('./data_input/datos_ejercicio_3A.txt')
volumenes, mole, temperatua = datos[:, :1], datos[:, 1:2], datos[:, 2:3]
presiones = np.zeros_like(volumenes)
presiones[:] = presion_gas_ideal(mole[:], temperatua[:], volumenes[:])
plt.figure(figsize=(10, 8))
plt.plot(presiones, volumenes)
plt.title('Presion vs Volumen', fontsize=20)
plt.xlabel('$Presion$', fontsize=20)
plt.ylabel('$Volumen$', fontsize=20)
plt.grid()
In [11]:
volumen = np.linspace(1, 10)
presiones = np.zeros_like(volumen)
presiones[:] = presion_gas_ideal(mole[1], temperatua[1], volumen[:])
plt.figure(figsize=(10, 8))
plt.plot(presiones, volumen)
plt.title('Presion vs Volumen', fontsize=20)
plt.xlabel('$Presion$', fontsize=20)
plt.ylabel('$Volumen$', fontsize=20)
plt.grid()
Supongamos ahora que conseguimos varios archivos donde en cada uno estan guardado los valores de presión y volumen para algunas determinadas condiciones. Escribir un código que nos plotee todos estos archivos y ademas nos escriba un archivo de salida que contenga el nombre del archivo leido y el valor máximo del volumen medido.
Los archivos estan en ./data_input/datos_3/*
Trabajando en la solucion en el otro notebook
In [12]:
from datos_ejercicio_4 import *
#calcula el pH dada una conc. de protones
def pH(x):
return -np.log10(x)
#calcula el pOH dada una conc de protones
def pOH(x):
return 14 - (-np.log10(x))
out = []
out.append( (H,pH(H),pOH(H)) )
np.savetxt( 'data_output/output_4.txt', out, fmt='%.4f' )
In [13]:
k = lambda T, A, E_a, R: A*np.exp(-E_a/(R*T))
T = 298 #K
R = 8.31 #J/(Kmol)
E_a = 1.601 #klK/mol
A = 3.98*10**(-3) #1/s
print k(T, A, E_a, R)
In [14]:
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
factorial(8)
Out[14]:
In [15]:
#Defino la función factorial
def factorial(n):
resultado = 1
for i in range(1, n+1):
resultado = resultado*i
return resultado
print factorial(8)
La FEM de una pila electroquímica varia con la temperatura de acuerdo con la ecuación:
$$ E^{0}(T) = 0.2239 - 6.455\times10^{-3}\times(T - 25) - 3.248\times10^{-6}\times(T - 25)^{2} + 9.948\times10^{-9}\times(T - 25)^{3} $$
donde T es la temperatura en grados centígrados.
Calcule $E^{0}$ en el intervalo de temperatura $0-40^{o}C$ con un incremento de temperatura $\Delta T = 0.1^{o}C$
In [16]:
#Constantes del problema
T0, Tf, delta_T = 0, 40, 0.1 #ºC
#Vector de temperaturas y el de salida
T = np.arange(T0, Tf+delta_T, delta_T)
E0_vector = np.zeros(len(T))
#Cuenta
E0_vector[:] = 0.2239 - 6.455*10**(-3)*(T[:] - 25) - 3.248*10**(-6)*(T[:] - 25)**2 + 9.948*10**(-9)*(T[:] - 25)**3
#Plot
plt.figure(figsize=(10,8))
plt.plot(T, E0_vector)
plt.title('Variacion de la FEM en funcion de la temperatura', fontsize=20)
plt.xlabel('$Temperatura(^{o}C)$', fontsize=25)
plt.ylabel('$E^{0}$', fontsize=25)
plt.grid(1)
Un mecanismo común en reacciones complejas es el de las reacciones consecutivas. El caso mas sencillo de este mecanismo es
$$ A\overset{k_{1}}{\longrightarrow}B\overset{k_{2}}{\longrightarrow}C $$
En este mecanismo, las concentraciones de A, B y C varían en el tiempo de acuerdo con
$$ [A] = [A]_{0}\times e^{-k_{1} t} $$
$$ \left[B\right]=\left\{ \dfrac{k_{1}}{k_{1}-k_{2}}\right\} \left\{ e^{-k_{1}t}-e^{-k_{2}t}\right\} \left[A\right]_{0} $$
$$ [C] = [A]_{0} - [A] - [B] $$
Escriba un código que calcule $[C]$ con los valores $k_{1} =0.1s^{-1}, k_{2}=0.2s^{-1}, [A]_{0} = 5M, t_{f} = 5s, \Delta t = 0.1s$:
In [17]:
A = lambda A0, k1, t: A0*np.exp(-k1*t)
B = lambda A0, k1, k2, t: (k1/(k1- k2))*(np.exp(-k1*t) - np.exp(-k2*t))*A0
C = lambda A0, k1, k2, t: A0 - A(A0, k1, t) - B(A0, k1, k2, t)
t0, tf, delta_t = 0, 5, 0.1
A0, k1, k2 = 5, 0.1, 0.2
t = np.arange(t0, tf, delta_t)
plt.figure(figsize=(10,8))
plt.plot(t, C(A0, k1, k2, t))
plt.xlabel('$tiempo(s)$', fontsize=25)
plt.ylabel('Concentracion de C', fontsize=20)
plt.grid(1)
De acuerdo con la mecánica cuantica, los niveles de energía de un electrón confinados en una caja de potencial unidimencional de longuitud l vienen dados por:
$$ E_{n}=\dfrac{h^{2}n^{2}}{8m_{e}l^{2}} $$
Escribir un programa que calcule la energía para $n = (1, 2, 3), h=6.626*10^{-34}Js, m_{e}=9.109*10^{-31}Kg, l = 1*10^{-9}m$
In [18]:
#Función
energia_n = lambda n, h, m_e, l: (h**2*n**2)/(8*m_e*l**2)
#Constantes
h = 6.626*10**(-34) #Js
m_e = 9.109*10**(-31) #Kg
l = 1*10**(-9) #m
n = np.arange(1, 4)
energia = energia_n(n, h, m_e, l)
for i in n:
print 'E',i-1, '=', energia[i-1], 'J'
In [19]:
#style
from IPython.core.display import HTML
css_file = 'style/style_ipython_notebook.css'
HTML(open(css_file, "r").read())
Out[19]:
In [19]: