Programming
Data Science
6 Conceptos de Estadística Avanzada en Data Science
El artículo contiene algunos de los conceptos estadísticos avanzados más utilizados junto con su implementación en Python.En mis artículos anteriores Beginners Guide to Statistics in Data Science y The Inferential Statistics Data Scientists Should Know hemos hablado de casi todos los conceptos básicos (descriptivos e inferenciales) de la estadística que se utilizan comúnmente en la comprensión y el trabajo con cualquier estudio de caso de ciencia de datos. En este artículo, vamos a ir un poco más allá y hablar de algunos conceptos avanzados que no son parte del hype/buzz.Puedes leer más artículos de Data Science en español aquí Concepto #1 - Q-Q(quantile-quantile) PlotsAntes de comprender los gráficos QQ, primero hay que entender qué es un cuantil.Un cuantil define una parte concreta de un conjunto de datos, es decir, un cuantil determina cuántos valores de una distribución están por encima o por debajo de un determinado límite. Los cuantiles especiales son el cuartil (cuarto), el quintil (quinto) y los percentiles (centésimo).Un ejemplo:Si dividimos una distribución en cuatro porciones iguales, hablaremos de cuatro cuartiles. El primer cuartil incluye todos los valores que son menores que la cuarta parte de todos los valores. En una representación gráfica, corresponde al 25% del área total de la distribución. Los dos cuartiles inferiores comprenden el 50% de todos los valores de la distribución. El rango intercuartil entre el primer y el tercer cuartil es igual al rango en el que se encuentra el 50% de todos los valores que se distribuyen alrededor de la media. En Estadística, un gráfico Q-Q (cuantil-cuantil) es un gráfico de dispersión creado al trazar dos conjuntos de cuantiles entre sí. Si ambos conjuntos de cuantiles provienen de la misma distribución, deberíamos ver los puntos formando una línea que es aproximadamente recta (y=x).Q-Q plotPor ejemplo, la mediana es un cuantil en el que el 50% de los datos caen por debajo de ese punto y el 50% están por encima. El propósito de los gráficos Q Q es averiguar si dos conjuntos de datos proceden de la misma distribución. En el gráfico Q Q se traza un ángulo de 45 grados; si los dos conjuntos de datos proceden de una distribución común, los puntos caerán sobre esa línea de referencia.Es muy importante saber si la distribución es normal o no para poder aplicar diversas medidas estadísticas a los datos e interpretarlos en una visualización mucho más comprensible para el ser humano, y el gráfico Q-Q entra en escena. La pregunta más fundamental que responde el gráfico Q-Q es si la curva está normalmente distribuida o no.Se distribuye normalmente, pero ¿por qué?Los gráficos Q-Q se utilizan para encontrar el tipo de distribución de una variable aleatoria, ya sea una distribución gaussiana, una distribución uniforme, una distribución exponencial o incluso una distribución de Pareto, etc. Se puede saber el tipo de distribución utilizando la potencia del gráfico Q-Q con sólo mirar el gráfico. En general, hablamos de distribuciones Normales sólo porque tenemos un concepto muy bonito de la regla 68-95-99.7 que se ajusta perfectamente a la distribución normal Así sabemos qué parte de los datos se encuentra en el rango de la primera desviación estándar, la segunda desviación estándar y la tercera desviación estándar de la media. Así que saber si una distribución es Normal nos abre nuevas puertas para experimentar Types of Q-Q plots. Source Skewed Q-Q plotsLos gráficos Q-Q permiten encontrar la asimetría de la distribución. Si el extremo inferior del gráfico Q-Q se desvía de la línea recta, pero el extremo superior no, entonces la distribución es Left skewed(Negatively skewed).Ahora bien, si el extremo superior del gráfico Q-Q se desvía de la línea recta y el inferior no, entonces la distribución es Right skewed(Positively skewed).Tailed Q-Q plotsLos gráficos Q-Q pueden encontrar la curtosis (medida de la cola) de la distribución.La distribución con la cola gorda tendrá ambos extremos de la gráfica Q-Q para desviarse de la línea recta y su centro sigue la línea, donde como una distribución de cola delgada término Q-Q parcela con muy menos o desviación insignificante en los extremos por lo que es un ajuste perfecto para la distribución normal.Q-Q plots en Python(Source)Puedes leer más artículos de Data Science en español aquí Supongamos que tenemos el siguiente conjunto de datos de 100 valores:import numpy as np
#create dataset with 100 values that follow a normal distribution
np.random.seed(0)
data = np.random.normal(0,1, 1000)
#view first 10 values
data[:10] array([ 1.76405235, 0.40015721, 0.97873798, 2.2408932 , 1.86755799,
-0.97727788, 0.95008842, -0.15135721, -0.10321885, 0.4105985 ])Para crear un gráfico Q-Q para este conjunto de datos, podemos utilizar la función qqplot() function de la biblioteca statsmodels:import statsmodels.api as sm
import matplotlib.pyplot as plt
#create Q-Q plot with 45-degree line added to plot
fig = sm.qqplot(data, line='45')
plt.show()En un gráfico Q-Q, el eje x muestra los cuantiles teóricos. Esto significa que no muestra los datos reales, sino que representa dónde estarían los datos si se distribuyeran normalmente.El eje Y muestra los datos reales. Esto significa que si los valores de los datos caen a lo largo de una línea aproximadamente recta en un ángulo de 45 grados, entonces los datos están distribuidos normalmente.Podemos ver en nuestro gráfico Q-Q de arriba que los valores de los datos tienden a seguir de cerca el ángulo de 45 grados, lo que significa que los datos están probablemente distribuidos normalmente. Esto no debería ser sorprendente, ya que generamos los 100 valores de datos utilizando el numpy.random.normal() function.Considere en cambio si generamos un conjunto de datos de 100 valores distribuidos uniformemente y creamos un gráfico Q-Q para ese conjunto de datos:#create dataset of 100 uniformally distributed values
data = np.random.uniform(0,1, 1000)
#generate Q-Q plot for the dataset
fig = sm.qqplot(data, line='45')
plt.show()Los valores de los datos no siguen claramente la línea roja de 45 grados, lo que indica que no siguen una distribución normal.Concepto #2- Chebyshev's InequalityEn probabilidad, la desigualdad de Chebyshev, también conocida como desigualdad "Bienayme-Chebyshev", garantiza que, para una amplia clase de distribuciones de probabilidad, sólo una fracción definida de valores se encontrará dentro de una distancia específica de la media de una distribución.Source: https://www.thoughtco.com/chebyshevs-inequality-3126547 La desigualdad de Chebyshev es similar a la regla empírica (68-95-99,7); sin embargo, esta última regla sólo se aplica a las distribuciones normales. La desigualdad de Chebyshev es más amplia; puede aplicarse a cualquier distribución siempre que ésta incluya una varianza y una media definidas.Así, la desigualdad de Chebyshev dice que al menos (1-1/k^2) de los datos de una muestra deben caer dentro de K desviaciones estándar de la media (o, de forma equivalente, no más de 1/k^2 de los valores de la distribución pueden estar a más de k desviaciones estándar de la media).Donde K --> número real positivoSi los datos no se distribuyen normalmente, entonces diferentes cantidades de datos podrían estar en una desviación estándar. La desigualdad de Chebyshev proporciona una manera de saber qué fracción de datos cae dentro de K desviaciones estándar de la media para cualquier distribución de datos.Lea También: 22 Preguntas Sobre Estadística Para Preparar En Una Entrevista De TrabajoCredits: https://calcworkshop.com/joint-probability-distribution/chebyshev-inequality/ La desigualdad de Chebyshev es de gran valor porque puede aplicarse a cualquier distribución de probabilidad en la que se proporcionen la media y la varianza.Consideremos un ejemplo: supongamos que se presentan 1.000 concursantes a una entrevista de trabajo, pero sólo hay 70 puestos disponibles. Para seleccionar a los 70 mejores concursantes del total, el propietario realiza unas pruebas para juzgar su potencial. La puntuación media de la prueba es de 60, con una desviación estándar de 6. Si un aspirante obtiene una puntuación de 84, ¿puede presumir que va a conseguir el puesto?Los resultados muestran que unas 63 personas obtuvieron una puntuación superior a 60, por lo que, con 70 puestos disponibles, un concursante que obtenga una puntuación de 84 puede estar seguro de haber conseguido el puesto.Chebyshev's Inequality en Python(Source) Crear una población de 1.000.000 de valores, utilizo una distribución gamma (también funciona con otras distribuciones) con forma = 2 y escala = 2.import numpy as np
import random
import matplotlib.pyplot as plt
#create a population with a gamma distribution
shape, scale = 2., 2. #mean=4, std=2*sqrt(2)
mu = shape*scale #mean and standard deviation
sigma = scale*np.sqrt(shape)
s = np.random.gamma(shape, scale, 1000000)Ahora muestree 10.000 valores de la población.#sample 10000 values
rs = random.choices(s, k=10000)Cuente la muestra que tiene una distancia del valor esperado mayor que la desviación estándar k y utilice el recuento para calcular las probabilidades. Quiero representar una tendencia de las probabilidades cuando k aumenta, así que utilizo un rango de k de 0,1 a 3.#set k
ks = [0.1,0.5,1.0,1.5,2.0,2.5,3.0]
#probability list
probs = [] #for each k
for k in ks:
#start count
c = 0
for i in rs:
# count if far from mean in k standard deviation
if abs(i - mu) > k * sigma :
c += 1
probs.append(c/10000)Traza los resultados:plot = plt.figure(figsize=(20,10))
#plot each probability
plt.xlabel('K')
plt.ylabel('probability')
plt.plot(ks,probs, marker='o')
plot.show()
#print each probability
print("Probability of a sample far from mean more than k standard deviation:")
for i, prob in enumerate(probs):
print("k:" + str(ks[i]) + ", probability: " \
+ str(prob)[0:5] + \
" | in theory, probability should less than: " \
+ str(1/ks[i]**2)[0:5])A partir del gráfico y el resultado anteriores, podemos ver que a medida que aumenta k, la probabilidad es decreciente, y la probabilidad de cada k sigue la desigualdad. Además, sólo el caso de que k sea mayor que 1 es útil. Si k es menor que 1, el lado derecho de la desigualdad es mayor que 1, lo que no es útil porque la probabilidad no puede ser mayor que 1.Concepto #3- Log-Normal DistributionEn teoría de la probabilidad, una distribución logarítmica normal, también conocida como distribución de Galton, es una distribución de probabilidad continua de una variable aleatoria cuyo logaritmo se distribuye normalmente.Así, si la variable aleatoria X se distribuye de forma log-normal, entonces Y = ln(X) tiene una distribución normal. De forma equivalente, si Y tiene una distribución normal, entonces la función exponencial de Y, es decir, X = exp(Y), tiene una distribución log-normal. Puedes leer más artículos de Data Science en español aquí Las distribuciones sesgadas con baja media y alta varianza y todos los valores positivos encajan en este tipo de distribución. Una variable aleatoria con distribución log-normal sólo toma valores reales positivos. La fórmula general de la función de densidad de probabilidad de la distribución lognormal esLos parámetros de localización y escala equivalen a la media y la desviación estándar del logaritmo de la variable aleatoria.La forma de la distribución Lognormal está definida por 3 parámetros:σ es el parámetro de forma, (y es la desviación estándar del logaritmo de la distribución)θ o μ es el parámetro de localización (y es la media de la distribución)m es el parámetro de escala (y es también la mediana de la distribución)Los parámetros de localización y escala son equivalentes a la media y la desviación estándar del logaritmo de la variable aleatoria, como se ha explicado anteriormente.Si x = θ, entonces f(x) = 0. El caso en el que θ = 0 y m = 1 se denomina distribución lognormal estándar. El caso en el que θ es igual a cero se denomina distribución lognormal de 2 parámetros.El siguiente gráfico ilustra el efecto del parámetro de localización(μ) y escala(σ) en la función de densidad de probabilidad de la distribución lognormal: Source: https://www.sciencedirect.com/topics/mathematics/lognormal-distribution Log-Normal Distribution en Python(Source)Consideremos un ejemplo para generar números aleatorios a partir de una distribución log-normal con μ=1 y σ=0,5 utilizando la función scipy.stats.lognorm.import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import lognorm
np.random.seed(42)
data = lognorm.rvs(s=0.5, loc=1, scale=1000, size=1000)
plt.figure(figsize=(10,6))
ax = plt.subplot(111)
plt.title('Generate wrandom numbers from a Log-normal distribution')
ax.hist(data, bins=np.logspace(0,5,200), density=True)
ax.set_xscale("log")
shape,loc,scale = lognorm.fit(data)
x = np.logspace(0, 5, 200)
pdf = lognorm.pdf(x, shape, loc, scale)
ax.plot(x, pdf, 'y')
plt.show()Concepto #4- Power Law distributionEn estadística, una ley de potencia es una relación funcional entre dos cantidades, en la que un cambio relativo en una cantidad da lugar a un cambio relativo proporcional en la otra cantidad, independientemente del tamaño inicial de esas cantidades: una cantidad varía como una potencia de otra.Por ejemplo, considerando el área de un cuadrado en función de la longitud de su lado, si se duplica la longitud, el área se multiplica por un factor de cuatro.Una distribución de ley de potencia tiene la forma Y = k Xα, donde:X e Y son variables de interés,α es el exponente de la ley,k es una constante.Source: https://en.wikipedia.org/wiki/Power_law La distribución de la ley de potencia es sólo una de las muchas distribuciones de probabilidad, pero se considera una herramienta valiosa para evaluar los problemas de incertidumbre que la distribución normal no puede manejar cuando se producen con cierta probabilidad.Se ha comprobado que muchos procesos siguen leyes de potencia en rangos de valores considerables. Desde la distribución en los ingresos, el tamaño de los meteoroides, las magnitudes de los terremotos, la densidad espectral de las matrices de pesos en las redes neuronales profundas, el uso de las palabras, el número de vecinos en varias redes, etc. (Nota: La ley de potencia aquí es una distribución continua. Los dos últimos ejemplos son discretos, pero a gran escala pueden modelarse como si fueran continuos).Puedes leer más artículos de Data Science en español aquí Lea también: Medidas Estadísticas De Tendencia CentralPower-law distribution en Python(Source) Trazamos el Pareto distribution que es una forma de distribución de probabilidad de ley de potencia. La distribución de Pareto se conoce a veces como Principio de Pareto o regla "80-20", ya que la regla establece que el 80% de la riqueza de la sociedad está en manos del 20% de su población. La distribución de Pareto no es una ley de la naturaleza, sino una observación. Es útil en muchos problemas del mundo real. Se trata de una distribución sesgada de cola pesada.import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import pareto
x_m = 1 #scale
alpha = [1, 2, 3] #list of values of shape parameters
plt.figure(figsize=(10,6))
samples = np.linspace(start=0, stop=5, num=1000)
for a in alpha:
output = np.array([pareto.pdf(x=samples, b=a, loc=0, scale=x_m)])
plt.plot(samples, output.T, label='alpha {0}' .format(a))
plt.xlabel('samples', fontsize=15)
plt.ylabel('PDF', fontsize=15)
plt.title('Probability Density function', fontsize=15)
plt.legend(loc='best')
plt.show()Concepto #5- Box cox transformationLa transformación de Box-Cox transforma nuestros datos para que se parezcan a una distribución normal.Las transformaciones de Box-Cox de un parámetro se definen como En muchas técnicas estadísticas, suponemos que los errores se distribuyen normalmente. Esta suposición nos permite construir intervalos de confianza y realizar pruebas de hipótesis. Al transformar la variable objetivo, podemos (con suerte) normalizar nuestros errores (si no son ya normales).Además, la transformación de nuestras variables puede mejorar el poder predictivo de nuestros modelos porque las transformaciones pueden eliminar el ruido blanco.Distribución original (izquierda) y distribución casi normal después de aplicar la transformación Box cox. Source En el núcleo de la transformación Box-Cox hay un exponente, lambda (λ), que varía de -5 a 5. Se consideran todos los valores de λ y se selecciona el valor óptimo para sus datos; el "valor óptimo" es el que da como resultado la mejor aproximación a una curva de distribución normal.Las transformaciones Box-Cox de un parámetro se definen como:y las transformaciones Box-Cox de dos parámetros como:Además, la transformación de Box-Cox de un parámetro es válida para y > 0, es decir, sólo para valores positivos, y la transformación de Box-Cox de dos parámetros para y > -λ, es decir, para valores negativos. El parámetro λ se estima mediante el profile likelihood function y utilizando pruebas de bondad de ajuste.Si hablamos de algunos inconvenientes de la transformación Box-cox, entonces si lo que se quiere es la interpretación, entonces no se recomienda Box-cox. Porque si λ es algún número distinto de cero, entonces la variable objetivo transformada puede ser más difícil de interpretar que si simplemente aplicamos una transformación logarítmica.Puedes leer más artículos de Data Science en español aquí Un segundo escollo es que la transformación Box-Cox suele dar la mediana de la distribución de la previsión cuando revertimos los datos transformados a su escala original. En ocasiones, queremos la media y no la mediana.Box-Cox transformation en Python (Source)El paquete stats de SciPy proporciona una función llamada boxcox para realizar la transformación de potencia box-cox que toma los datos originales no normales como entrada y devuelve los datos ajustados junto con el valor lambda que se utilizó para ajustar la distribución no normal a la distribución normal.#load necessary packages
import numpy as np
from scipy.stats import boxcox
import seaborn as sns
#make this example reproducible
np.random.seed(0)
#generate dataset
data = np.random.exponential(size=1000)
fig, ax = plt.subplots(1, 2)
#plot the distribution of data values
sns.distplot(data, hist=False, kde=True,
kde_kws = {'shade': True, 'linewidth': 2},
label = "Non-Normal", color ="red", ax = ax[0])
#perform Box-Cox transformation on original data
transformed_data, best_lambda = boxcox(data)
sns.distplot(transformed_data, hist = False, kde = True,
kde_kws = {'shade': True, 'linewidth': 2},
label = "Normal", color ="red", ax = ax[1])
#adding legends to the subplots
plt.legend(loc = "upper right")
#rescaling the subplots
fig.set_figheight(5)
fig.set_figwidth(10)
#display optimal lambda value
print(f"Lambda value used for Transformation: {best_lambda}")
Concepto #6- Poisson distributionEn la teoría de la probabilidad y la estadística, la distribución de Poisson es una distribución de probabilidad discreta que expresa la probabilidad de que se produzca un número determinado de sucesos en un intervalo fijo de tiempo o espacio si estos sucesos se producen con una tasa media constante conocida y con independencia del tiempo transcurrido desde el último suceso.En términos muy sencillos, una distribución de Poisson puede utilizarse para estimar la probabilidad de que algo ocurra "X" número de veces. Algunos ejemplos de procesos de Poisson son los clientes que llaman a un centro de ayuda, la desintegración radiactiva de los átomos, los visitantes de una página web, los fotones que llegan a un telescopio espacial y los movimientos en el precio de las acciones. Los procesos de Poisson suelen estar asociados al tiempo, pero no tienen por qué estarlo. La fórmula de la distribución de Poisson es:Donde:e es el numero de Euler (e = 2.71828...)k es el numero de ocurrenciask! es el factorial de k kλ es igual al valor esperado de kcuando éste es también igual a su varianzaLambda(λ) puede considerarse como el número esperado de eventos en el intervalo. A medida que cambiamos el parámetro de la tasa, λ, cambiamos la probabilidad de ver diferentes números de eventos en un intervalo. El siguiente gráfico es la función de masa de probabilidad de la distribución de Poisson que muestra la probabilidad de que se produzca un número de sucesos en un intervalo con diferentes parámetros de tasa. Función de masa de probabilidad para la distribución de Poisson con parámetros de tasa variables. Source La distribución de Poisson también se utiliza habitualmente para modelar datos de recuento financiero en los que el recuento es pequeño y a menudo es cero. Por ejemplo, en finanzas, puede utilizarse para modelar el número de operaciones que un inversor típico realizará en un día determinado, que puede ser 0 (a menudo), o 1, o 2, etc.Otro ejemplo: este modelo puede utilizarse para predecir el número de "shocks" del mercado que se producirán en un periodo de tiempo determinado, por ejemplo, durante una década.Poisson distribution en Pythonfrom numpy import random
import matplotlib.pyplot as plt
import seaborn as sns
lam_list = [1, 4, 9] #list of Lambda values
plt.figure(figsize=(10,6))
samples = np.linspace(start=0, stop=5, num=1000)
for lam in lam_list:
sns.distplot(random.poisson(lam=lam, size=10), hist=False, label='lambda {0}'.format(lam))
plt.xlabel('Poisson Distribution', fontsize=15)
plt.ylabel('Frequency', fontsize=15)
plt.legend(loc='best')
plt.show()A medida que λ se hace más grande, el gráfico se parece más a una distribución normal.Espero que hayas disfrutado de la lectura de este artículo, Si tienes alguna pregunta o sugerencia, por favor deja un comentario.Lea también: Falsos Positivos Vs. Falsos Negativos Siéntase libre de conectarse conmigo en LinkedIn para cualquier consulta.¡¡¡Gracias por leer!!!Puedes leer más artículos de Data Science en español aquí Referenciashttps://calcworkshop.com/joint-probability-distribution/chebyshev-inequality/ https://corporatefinanceinstitute.com/resources/knowledge/data-analysis/chebyshevs-inequality/ https://www.itl.nist.gov/div898/handbook/eda/section3/eda3669.htm https://www.statology.org/q-q-plot-python/ https://gist.github.com/chaipi-chaya/9eb72978dbbfd7fa4057b493cf6a32e7 https://stackoverflow.com/a/41968334/7175247
Programming
Python
¿Por Qué Los Decoradores En Python Son Pura Genialidad?
Analiza, prueba y reutiliza tu código con poco más que un símbolo @Si hay algo que hace que Python sea increíblemente exitoso, eso sería su legibilidad. Todo lo demás depende de eso: si el código es ilegible, es difícil de mantener. Tampoco es fácil para los principiantes: un novato que se aturda con un código ilegible no intentará escribir el suyo propio algún día.Python ya era legible y amigable para los principiantes antes de que aparecieran los decoradores. Pero a medida que el lenguaje comenzó a ser utilizado para más y más cosas, los desarrolladores de Python sintieron la necesidad de más y más características, sin desordenar el paisaje y hacer el código ilegible.Los decoradores son un ejemplo de una característica perfectamente implementada. Lleva un tiempo entenderlos, pero vale la pena. Cuando empieces a usarlos, notarás cómo no complican demasiado las cosas y hacen que tu código sea limpio y elegante.Antes que nada: funciones de orden superiorEn pocas palabras, los decoradores son una forma clara de manejar las funciones de orden superior. Así que vamos a verlos primero.Funciones que devuelven funcionesDigamos que tienes una función, greet() - que saluda a cualquier objeto que le pases. Y digamos que tienes otra función, simon() - que inserta "Simón" donde sea apropiado. ¿Cómo podemos combinar las dos? Piénsalo un momento antes de mirar a continuacióndef greet(name):
return f"Hello, {name}!"
def simon(func):
return func("Simon")
simon(greet)La salida es "¡Hola, Simon!". Espero que tenga sentido para ti.Por supuesto, podríamos haber llamado simplemente a greet("Simon"). Sin embargo, la cuestión es que podríamos querer poner "Simón" en muchas funciones diferentes. Y si no usamos "Simón" sino algo más complicado, podemos ahorrar un montón de líneas de código empaquetándolo en una función como simon().Funciones dentro de otras funcionesTambién podemos definir funciones dentro de otras funciones. Esto es importante porque los decoradores también lo hacen. Sin los decoradores se ve así:def respect(maybe):
def congrats():
return "Congrats, bro!"
def insult():
return "You're silly!"
if maybe == "yes":
return congrats
else:
return insultLa función respect() devuelve una función; respect("yes") devuelve la función congrats, respect("brother") (o algún otro argumento en lugar de "brother") devuelve la función insultos. Para llamar a las funciones, introduce respect("sí")() y respect("hermano")(), como una función normal.Lee también: Python Books You Must Read in 2020¿Lo tienes? ¡Entonces ya tienes todo listo para los decoradores!Code is beautifully nerdy. Image by author.El ABC de los decoradores de PythonFunciones con un símbolo @Probemos una combinación de los dos conceptos anteriores: una función que toma otra función y define una función. ¿Suena alucinante? Considera esto:def startstop(func):
def wrapper():
print("Starting...")
func()
print("Finished!")
return wrapper
def roll():
print("Rolling on the floor laughing XD")
roll = startstop(roll)La última línea asegura que ya no necesitamos llamar a startstop(roll)(); con roll() será suficiente. ¿Sabes cuál es la salida de esa llamada? ¡Pruébalo tú mismo si no estás seguro!Ahora, como una muy buena alternativa, podríamos insertar esto justo después de definir startstop():@startstop
def roll():
print("Rolling on the floor laughing XD")Esto hace lo mismo, pero pega roll() a startstop() al principio.Flexibilidad añadida¿Por qué es útil? ¿No consume exactamente las mismas líneas de código que antes?En este caso, sí. Pero una vez que estás tratando con cosas un poco más complicadas, se vuelve realmente útil. Por una vez, puedes mover todos los decoradores (es decir, la parte def startstop() de arriba) a su propio módulo. Es decir, los escribes en un archivo llamado decorators.py y escribes algo como esto en tu archivo principal:from decorators import startstop
@startstop
def roll():
print("Rolling on the floor laughing XD")En principio, puedes hacerlo sin usar decoradores. Pero de esta manera se hace la vida más fácil porque ya no tienes que lidiar con funciones anidadas y con el interminable conteo de corchetes.También puedes anidar decoradores:from decorators import startstop, exectime
@exectime
@startstop
def roll():
print("Rolling on the floor laughing XD")Ten en cuenta que aún no hemos definido exectime(), pero lo verás en la siguiente sección. Es una función que puede medir el tiempo que tarda un proceso en Python.Este anidamiento equivaldría a una línea como estaroll = exectime(startstop(roll))¡Comienza el conteo de corchetes! Imagina que tienes cinco o seis de esas funciones anidadas unas dentro de otras. ¿No sería la notación del decorador mucho más fácil de leer que este lío anidado?Incluso puedes usar decoradores en funciones que aceptan argumentos. Ahora imagina unos cuantos argumentos en la línea anterior y tu caos estaría completo. Los decoradores lo hacen más limpio y ordenado.Lee también: How to Get a Job With PythonFinalmente, puedes incluso añadir argumentos a tus decoradores - como @mydecorator(argument). Sí, puedes hacer todo esto sin decoradores. Pero entonces te deseo que te diviertas entendiendo tu código sin decoradores cuando lo releas dentro de tres semanas...Decorators make everything easier. Image by author.Aplicaciones: donde los decoradores cortan la nataAhora que espero haberte convencido de que los decoradores te hacen la vida tres veces más fácil, veamos algunos ejemplos clásicos en los que los decoradores son básicamente indispensables.Medir el tiempo de ejecuciónSupongamos que tenemos una función llamada waste time() y queremos saber cuánto tarda. Pues bien, ¡sólo hay que utilizar un decorador!import time
def measuretime(func):
def wrapper():
starttime = time.perf_counter()
func()
endtime = time.perf_counter()
print(f"Time needed: {endtime - starttime} seconds")
return wrapper
@measuretime
def wastetime():
sum([i**2 for i in range(1000000)])
wastetime()Una docena de líneas de código y ya está. Además, puedes usar measuretime() en tantas funciones como quieras.Ralentizar el códigoA veces no quieres ejecutar el código inmediatamente, sino esperar un tiempo. Ahí es donde un decorador de ralentización resulta útil:import time
def sleep(func):
def wrapper():
time.sleep(300)
return func()
return wrapper
@sleep
def wakeup():
print("Get up! Your break is over.")
wakeup()Llamar a wakeup() hace que te tomes un descanso de 5 minutos, tras el cual tu consola te recuerda que debes volver al trabajo.Lee también: Building A Linear Regression Model With Python To Predict Retail Customer SpendingPruebas y depuraciónDigamos que tienes un montón de funciones diferentes que llamas en diferentes etapas, y estás perdiendo la visión general sobre lo que se está llamando cuando. Con un simple decorador para cada definición de función, puedes aportar más claridad. Así:def debug(func):
def wrapper():
print(f"Calling {func.__name__}")
return wrapper
@debug
def scare():
print("Boo!")
scare()Hay un ejemplo mucho más elaborado aquí. Ten en cuenta, sin embargo, que para entender ese ejemplo, tendrás que comprobar cómo decorar funciones con argumentos. Aun así, ¡vale la pena leerlo!Reutilización de códigoEsto no hace falta decirlo. Si has definido una función decorator(), puedes esparcir @decorator por todo tu código. Para ser honesto, no creo que haya nada más simple que eso.Manejo de los inicios de sesiónSi tienes funcionalidades a las que sólo se puede acceder si un usuario está conectado, también es bastante fácil con los decoradores. Te remitiré al ejemplo completo para que lo consultes, pero el principio es bastante sencillo: primero defines una función como login_required(). Antes de cualquier definición de función que necesite el inicio de sesión, pones @login_required. Bastante simple, diría yo.Azúcar sintáctico - o por qué Python es tan dulceNo es que no sea crítico con Python o que no utilice lenguajes alternativos cuando sea apropiado. Pero hay un gran atractivo en Python: es muy fácil de digerir, incluso cuando no eres un informático de formación y sólo quieres hacer que las cosas funcionen.Si C++ es una naranja, Python es una piña: igualmente nutritiva, pero tres veces más dulce. Los decoradores son sólo un factor en la mezcla.Pero espero que hayas llegado a ver por qué es un factor tan dulce. ¡Azúcar sintáctico para añadir algo de placer a tu vida! Sin riesgos para la salud, salvo tener los ojos pegados a una pantalla.¡Te deseo mucho código dulce!Lee también: How to Use Python Datetimes Correctly?
Programming
Machine Learning
Construyendo Una Sistema de Recomendación de Productos Con Filtrado Colaborativo
Construyendo Una Sistema de Recomendación de Productos Con Filtrado Colaborativo
Python
SQL
Programming
¿Cómo Usar Correctamente Los Datetimes En Python?
Datetime es básicamente un objeto python que representa un punto en el tiempo, como años, días, segundos, milisegundos. Esto es muy útil para crear nuestros programas.El módulo datetime proporciona clases para manipular fechas y horas de forma simple y compleja. Mientras que la aritmética de la fecha y la hora está soportada, la aplicación se centra en la extracción eficiente de atributos para formatear y manipular la salidaVamos a importar el módulo de Python
Python
Programming
Libraries
Entendiendo El Módulo Collections de Python
El módulo collections de Python tiene diferentes tipos de datos especializados que funcionando como contenedores y que pueden utilizarse para reemplazar los contenedores de propósito general de Python (`dict`, `tuple`, `list` y `set`). Estudiaremos las siguientes partes de este módulo:- `ChainMap`- `defaultdict`- `deque`Existe un submódulo de colecciones llamado abc o Abstract Base Classes. Estas no serán tratadas en este post. ¡Empecemos con el contenedor ChainMap!ChainMapUn ChainMap es una clase que proporciona la capacidad de enlazar múltiples mapeos juntos de tal manera que terminan siendo una sola unidad. Si miras la documentación, te darás cuenta de que acepta `**maps*`, lo que significa que un ChainMap aceptará cualquier número de mapeos o diccionarios y los convertirá en una única vista que podrás actualizar. Veamos un ejemplo para que puedas ver cómo funciona:from collections import ChainMap
car_parts = {'hood': 500, 'engine': 5000, 'front_door': 750}
car_options = {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300}
car_accessories = {'cover': 100, 'hood_ornament': 150, 'seat_cover': 99}
car_pricing = ChainMap(car_accessories, car_options, car_parts)car_pricing
>> ChainMap({'cover': 100, 'hood_ornament': 150, 'seat_cover': 99}, {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300}, {'hood': 500, 'engine': 5000, 'front_door': 750})
car_pricing['hood']
>> 500Aquí importamos ChainMap de nuestro módulo de colecciones. A continuación creamos tres diccionarios. Luego creamos una instancia de nuestro ChainMap pasándole los tres diccionarios que acabamos de crear.Por último, intentamos acceder a una de las claves de nuestro ChainMap. Cuando hacemos esto, el ChainMap recorrerá cada mapa para ver si esa clave existe y tiene un valor. Si lo tiene, entonces el ChainMap devolverá el primer valor que encuentre que coincida con esa clave.Esto es especialmente útil si quiere establecer valores por defecto. Supongamos que queremos crear una aplicación que tiene algunos valores por defecto. La aplicación también conocerá las variables de entorno del sistema operativo. Si hay una variable de entorno que coincide con una de las claves que tenemos por defecto en nuestra aplicación, el entorno anulará nuestro valor por defecto. Además, vamos a suponer que podemos pasar argumentos a nuestra aplicación. Estos argumentos tienen prioridad sobre el entorno y los valores por defecto. Este es un lugar donde un ChainMap puede realmente ser útil. Veamos un ejemplo sencillo que está basado en uno de la documentación de Python:Nota: no ejecutes este código desde Jupyter Notebook, sino desde tu IDE favorito y llamandolo desde una terminal. de esta mandera `python chain_map.py -u daniel`import argparse
import os
from collections import ChainMap
def main():
app_defaults = {'username':'admin', 'password':'admin'}
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--username')
parser.add_argument('-p', '--password')
args = parser.parse_args()
command_line_arguments = {key:value for key, value in vars(args).items() if value}
chain = ChainMap(command_line_arguments, os.environ, app_defaults)
print(chain['username'])
if __name__ == '__main__':
main()
os.environ['username'] = 'test'
main()➜ python python3 post.py -u daniel
daniel
daniel
Vamos a desglosar esto un poco. Aquí importamos el módulo `argparse` de Python junto con el módulo `os`. También importamos `ChainMap`.A continuación tenemos una función simple que tiene algunos valores predeterminados. He visto estos valores por defecto utilizados para algunos enrutadores populares. Luego configuramos nuestro analizador de argumentos y le decimos cómo manejar ciertas opciones de la línea de comandos. Notarás que argparse no proporciona una forma de obtener un objeto diccionario de sus argumentos, así que usamos un dict comprehension para extraer lo que necesitamos. La otra pieza interesante aquí es el uso de las vars incorporadas de Python. Si lo llamaras sin un argumento vars se comportaría como los locales incorporados de Python. Pero si le pasas un objeto, entonces vars es el equivalente a la propiedad `__dict__` de object. En otras palabras, vars(args) es igual a `args.__dict__`. Finalmente creamos nuestro ChainMap pasando nuestros argumentos de la línea de comandos (si hay alguno), luego las variables de entorno y finalmente los valores por defecto.Al final del código, intentamos llamar a nuestra función, luego establecer una variable de entorno y llamarla de nuevo. Pruébalo y verás que imprime admin y luego prueba como se esperaba. Ahora vamos a intentar llamar al script con un argumento de línea de comandos:python chain_map.py -u danielCuando yo ejecuto esto en mi maquina, me retorna el daniel dos veces. Esto se debe a que nuestro argumento de línea de comandos anula todo lo demás. No importa que establezcamos el entorno porque nuestro ChainMap mirará primero los argumentos de la línea de comandos antes que cualquier otra cosa. Si lo intentas sin el `-u daniel` correrán los argumentos reales, en mi caso `"admin" "test"`Ahora que sabes cómo usar ChainMaps, ¡podemos pasar al Counter!Contador (`Counter`)El módulo de colecciones también nos proporciona una pequeña herramienta que permite realizar cómodos y rápidos recuentos. Esta herramienta se llama `Counter`. Puedes ejecutarla con la mayoría de los iterables. Vamos a probarlo con un stringfrom collections import Counter
Counter('superfluous')
>> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1})counter = Counter('superfluous')
counter['u']
>> 3En este ejemplo, importamos `Counter` de `collections` y le pasamos una cadena. Esto devuelve un objeto Counter que es una subclase del diccionario de Python. Luego ejecutamos el mismo comando pero lo asignamos a la variable counter para que podamos acceder al diccionario más fácilmente. En este caso, hemos visto que la letra `"u"` aparece tres veces en la cadena de ejemplo.El contador proporciona algunos métodos que pueden interesarle. Por ejemplo, puede llamar a elementos que obtendrá un iterador sobre los elementos que están en el diccionario, pero en un orden arbitrario. Esta función se puede considerar como un "codificador", ya que la salida en este caso es una versión codificada de la cadena.list(counter.elements())
>> ['s', 's', 'u', 'u', 'u', 'p', 'e', 'r', 'f', 'l', 'o']Otro método útil es most_common. Puede preguntarle al Contador cuáles son los elementos más comunes pasando un número que represente cuáles son los elementos `"n"` más recurrentes:counter.most_common(2)
[('u', 3), ('s', 2)]Aquí sólo preguntamos a nuestro Counter cuáles fueron los dos elementos más recurrentes. Como puedes ver, se produjo una lista de tuplas que nos dice que `"u"` ocurrió 3 veces y `"s"` ocurrió dos veces.El otro método que quiero cubrir es el método de sustracción. El método `subtract` acepta un iterable o un mapeo y utiliza ese argumento para restar. Es un poco más fácil de explicar si ves algo de código:counter_one = Counter('superfluous')
counter_one
>> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1})
counter_two = Counter('super')
counter_one.subtract(counter_two)
counter_one
>> Counter({'s': 1, 'u': 2, 'p': 0, 'e': 0, 'r': 0, 'f': 1, 'l': 1, 'o': 1})Así que aquí recreamos nuestro primer contador y lo imprimimos para saber qué hay en él. Así creamos nuestro segundo objeto Contador. Finalmente restamos el segundo contador del primero. Si miras con atención en la salida al final, notará que el número de letras de cinco de los elementos ha sido disminuido en uno.Como mencioné al principio de esta sección, puedes usar el Contador contra cualquier iterable o mapeo, por lo que no tienes que usar sólo cadenas. También puedes pasarle tuplas, diccionarios y listas.Pruébalo por tu cuenta para ver cómo funciona con esos otros tipos de datos. ¡Ahora estamos listos para pasar al `defaultdict`!`defaultdict`El módulo de colecciones tiene una práctica herramienta llamada `defaultdict`. El `defaultdict` es una subclase del dict de Python que acepta un `default_factory` como argumento principal. El `default_factory` suele ser un tipo de datos de Python, como int o una lista, pero también puedes usar una función o un lambda. Empecemos por crear un diccionario regular de Python que cuenta el número de veces que se utiliza cada palabra en una frase:sentence = "The red for jumped over the fence and ran to the zoo for food"
words = sentence.split(' ')
words
>> ['The',
'red',
'for',
'jumped',
'over',
'the',
'fence',
'and',
'ran',
'to',
'the',
'zoo',
'for',
'food']
reg_dict = {}
for word in words:
if word in reg_dict:
reg_dict[word] += 1
else:
reg_dict[word] = 1
print(reg_dict)
>> {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1}¡Ahora vamos a intentar hacer lo mismo con defaultdict!from collections import defaultdict
sentence = "The red for jumped over the fence and ran to the zoo for food"
words = sentence.split(' ')
d = defaultdict(int)
for word in words:
d[word] += 1
print(d)
>> defaultdict(<class 'int'>, {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1})Notarás enseguida que el código es mucho más sencillo. El defaultdict asignará automáticamente cero como valor a cualquier clave que no tenga ya en él. Nosotros añadimos uno para que tenga más sentido y también se incrementará si la palabra aparece varias veces en la frase.Ahora vamos a intentar utilizar un tipo de lista de Python como nuestro `default_factory`. Empezaremos con un diccionario regular, como antes.my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)]
reg_dict = {}
for acct_num, value in my_list:
if acct_num in reg_dict:
reg_dict[acct_num].append(value)
else:
reg_dict[acct_num] = [value]Si ejecuta este código, debería obtener una salida similar a la siguiente:print(reg_dict)
>> {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]}Ahora vamos a reimplementar este código usando defaultdict:from collections import defaultdict
my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)]
d = defaultdict(list)
for acct_num, value in my_list:
d[acct_num].append(value)Una vez más, esto elimina la lógica condicional if/else y hace que el código sea más fácil de seguir. Aquí está la salida del código anterior:print(d)
>> defaultdict(<class 'list'>, {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]})¡Esto es algo muy bueno! ¡Vamos a probar a usar un `lambda` también como nuestra `default_factory`!from collections import defaultdict
animal = defaultdict(lambda: "Monkey")
animal
>> defaultdict(<function __main__.<lambda>()>, {})
animal['Sam'] = 'Tiger'
print (animal['Nick'])
>> Monkey
animal
>> defaultdict(<function __main__.<lambda>()>, {'Sam': 'Tiger', 'Nick': 'Monkey'})Aquí creamos un `defaultdict` que asignará 'Monkey' como valor por defecto a cualquier clave. La primera llave la ponemos como 'Tiger', y la siguiente no la ponemos. Si imprimes la segunda llave, verás que tiene asignado 'Monkey'. En caso de que no lo hayas notado aún, es básicamente imposible causar un KeyError siempre y cuando establezcas el `default_factory` a algo que tenga sentido. La documentación menciona que si usted establece el `default_factory` a `None`, entonces recibirá un KeyError.Veamos cómo funciona eso:from collections import defaultdict
x = defaultdict(None)
x['Mike']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-30-d21c3702d01d> in <module>
1 from collections import defaultdict
2 x = defaultdict(None)
----> 3 x['Mike']
KeyError: 'Mike'En este caso, acabamos de crear un `defaultdict` con un error. Ya no puede asignar un valor por defecto a nuestra llave, así que lanza un `KeyError` en su lugar. Por supuesto, ya que es una subclase de `dict`, podemos simplemente establecer la llave con algún valor y funcionará. Pero eso anula el propósito de `defaultdict`.`deque`Según la documentación de Python, los deques "son una generalización de las pilas y colas (stacks y queues)". Se pronuncia "deck", que es la abreviatura de "double-ended queue". Son un contenedor de reemplazo para la lista de Python. Los deques son seguros para los hilos (threads) y permiten añadir y sacar datos de la memoria de forma eficiente desde cualquier lado del deque. Una lista está optimizada para operaciones rápidas de longitud fija. Puede obtener todos los detalles detalles en la documentación de Python. Un deque acepta un argumento `maxlen` que establece los límites para el deque. En caso contrario, el deque crecerá hasta un tamaño arbitrario. Cuando un deque acotado está lleno, cualquier nuevo elemento que se añada provocará que el mismo número de elementos salga del otro extremo.Como regla general, si necesitas añadir o sacar elementos rápidamente, utiliza un deque. Si necesitas un acceso aleatorio rápido usa una lista. Tomemos un momento para ver cómo se puede crear y utilizar un deque.from collections import deque
import string
d = deque(string.ascii_lowercase)
for letter in d:
print(letter)
>> a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
zAquí importamos el deque de nuestro módulo de colecciones y también importamos el módulo de strings. Para crear una instancia de un deque, necesitamos pasarle un iterable. En este caso, le pasamos `string.ascii_lowercase`, que devuelve una lista de todas las letras minúsculas del alfabeto. Finalmente, hacemos un bucle sobre nuestro deque e imprimimos cada elemento. Ahora veamos algunos de los métodos que posee deque.d.append('bye')
d
>> deque(['a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'bye'])
d.appendleft('hello')
d
>> deque(['hello',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'bye'])
d.rotate(1)
d
>> deque(['bye',
'hello',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z'])Vamos a desglosar esto un poco. Primero añadimos una cadena al extremo derecho del deque. Luego añadimos otra cadena al lado izquierdo del deque. Por último, llamamos a `rotate` en nuestro deque y le pasamos un uno, lo que hace que rote una vez a la derecha. En otras palabras, hace que un elemento gire desde el extremo derecho y en la parte delantera. Puedes pasarle un número negativo para que el deque rote hacia la izquierda en su lugar. Terminemos esta sección con un ejemplo basado en algo de la documentación de Pythonfrom collections import deque
def get_last(filename, n=5):
"""
Returns the last n lines from the file
"""
try:
with open(filename) as f:
return deque(f, n)
except OSError:
print("Error opening file: {}".format(filename))
raiseEste código funciona de forma muy parecida a como lo hace el programa tail de Linux. Aquí pasamos un `filename` a nuestro script junto con el número `n` de líneas que queremos que nos retorne. El deque está limitado a cualquier número que pasemos como `n`. Esto significa que una vez que el deque está lleno, cuando se leen nuevas líneas y se añaden al deque, las líneas más viejas son sacadas del otro extremo y descartadas. También he envuelto la apertura del archivo con un simple manejador de excepciones porque es muy fácil pasar una ruta malformada. Esto atrapará archivos que no existen.ConclusiónHemos cubierto mucho terreno en este post. Has aprendido a utilizar un defaultdict y un Count. También aprendimos sobre una subclase de la lista de Python, el deque. Por último, hemos visto cómo utilizarlas para realizar varias actividades. Espero que hayas encontrado cada una de estas colecciones interesantes. Pueden ser de gran utilidad para ti en tu dia a dia
Machine Learning
Programming
Deep learning
21 Recursos Para Aprender Matemáticas Para Data Science
Este es quizás uno de los mayores temores de quienes se inician en el área de data science, aprender/repasar matemáticas. Y es que seamos sinceros, a la gran mayoría de personas no les fue muy bien en matemáticas en la educación básica, quizás tampoco en la universidad y esto llena de temor y crea una barrera para quienes quieren explorar esta disciplina llamada data sciencePuedes leer más artículos de Data Science en español aquí En días pasados publiqué un post en Towards Data Science y aquí mismo en nuestro blog sobre un plan de estudio de data science para este año 2021, donde dí unas recomendaciones trimestrales, e hice énfasis en estudiar matemáticas y estadísticas para este primer trimestre, y del cual recibí muchas preguntas acerca de cuales materiales recomendaba puntualmente. Pues bueno, este post les responde estas dudas. Pero antes de ello quiero darles un contexto.Dejando de lado los factores o motivos que han llevado a que las mayorías detesten las matemáticas, es una realidad que las necesitamos en data science. Para mi, una de las mayores falencias que encontraba en las matemáticas era su falta de aplicabilidad en el mundo real, no le veía una razón de ser a las matemáticas intermedias y avanzadas, como por ejemplo al cálculo multivariable. Confieso que en el colegio y en la universidad no me gustaban por ese motivo, pero siempre me iba bien y sacaba buenas calificaciones y promedios por encima de la mayoría (sobre todo en estadística). Pero aún así no veía en qué podría usar una derivada o una matriz en el mundo real. Finalmente terminé como ingeniero de software y una vez entré al mundo de data science pude hacer la conexión entre las matemáticas, estadísticas y el mundo real.Por otro lado, es importante aclarar que no necesitamos una maestría en matemáticas puras para hacer proyectos de data science. Como ya he mencionado en posts anteriores existe un gran debate en la comunidad acerca de que tantas matemáticas realmente necesitamos para hacer un buen trabajo como data scientists. Podríamos decir que data science se divide en dos grandes campos laborales: research y producciónCon research nos referimos a la parte de investigación y desarrollo, que normalmente se da dentro de una gran empresa (normalmente tecnológica), o que se ha enfocado en temas tecnológicos de vanguardia (como por ejemplo investigaciones médicas). O también es un área que se desarrolla dentro de las universidades. Obviamente este sector tiene ofertas laborales muy limitadas. La gran ventaja es el conocimiento profundo de los algoritmos y sus implementaciones, así mismo será una persona capaz de crear variaciones de los algoritmos existentes, para mejorarlos. O incluso crear nuevos algoritmos de machine learning. La desventaja es la poca practicidad de su trabajo. Es un trabajo muy teórico, en el que muchas veces el único objetivo es publicar papers y se aleja de los casos de uso de los negocios en general. Para referencia sobre esto, hace poco vi este post en Reddit, les recomiendo leerlo. Puedes leer más artículos de Data Science en español aquí Con producción nos referimos a la parte práctica de esta disciplina, donde usarás generalmente y en tu dia a dia librerías tales como scikit-learn, Tensorflow, Keras, Pytorch y otras. Estas librerías operan como una caja negra, donde ingresas datos, obtienes una salida, pero no sabes en detalle qué ocurrió en el proceso. Esto también tiene sus ventajas y desventajas, pero sin duda nos facilita enormemente la vida al momento de poner modelos útiles en producción. Lo que no recomiendo es usarlas a ciegas, donde no tienes las bases mínimas de matemáticas para entender un poco sus fundamentos y ese es el objetivo de este post, guiarte y recomendarte algunos recursos valiosos para tener las bases necesarias y no operar a ciegas dichas librerías. Así que si usted decide enfocarse en Investigación y Desarrollo (Research), sí vas a necesitar matemáticas y estadística en profundidad (muy en profundidad). Si vas a irte por la parte práctica, las librerías te ayudarán a lidiar con la mayor parte de ello, bajo el capó. Cabe aclarar que la mayor cantidad de ofertas laborales, se encuentran en la parte práctica. Bien, luego de las aclaraciones anteriores, es momento de definir cuales son las temáticas puntuales necesarias para tener unas bases iniciales en matemáticas para data science. Algebra Lineal: Esta materia es importante para tener los fundamentos del trabajo con datos en forma vectorial y matricial, adquirir habilidades para resolver sistemas de ecuaciones algebraicas lineales y encontrar las descomposiciones matriciales básicas y la comprensión general de su aplicabilidad.Calculo Multivariable: Aquí es importante estudiar los mapas funcionales, los límites (en caso de secuencias, funciones de una y varias variables), la diferenciación (a partir de una sola variable hasta casos múltiples), la integración, construyendo así secuencialmente una base para la optimización básica. También es importante aquí estudiar los gradientes descendentes.Teoría de probabilidad: Aquí deberías aprender sobre las variables aleatorias, es decir, una variable cuyos valores se determinan mediante un experimento aleatorio. Las variables aleatorias se utilizan como modelo para los procesos de generación de datos que queremos estudiar. Las propiedades de los datos están profundamente vinculadas a las propiedades correspondientes de las variables aleatorias, como el valor esperado, la varianza y las correlaciones. Nota: estas materias son mucho más profundas de lo que acabo de mencionar, esta es simplemente una guía de las materias y recursos recomendados para abordar matemáticas en el ámbito de data science.Ahora que tenemos una mejor idea del camino que debemos tomar, vamos a examinar los recursos recomendados para abordar esta temática. Los dividiremos en básicos, intermedios y avanzados. En los avanzados tendremos recursos enfocados en deep learningBases: en esta primera sección de recursos recomendaremos las bases matemáticas. El pensamiento matemático, algebra y cómo implementar matemáticas con python. Puedes leer más artículos de Data Science en español aquí 1- Introducción al pensamiento matemáticoPrice: FreeImage by CourseraDescripción: Aprende a pensar como lo hacen los matemáticos, un poderoso proceso cognitivo desarrollado durante miles de años.El pensamiento matemático no es lo mismo que hacer matemáticas - al menos no como las matemáticas se presentan típicamente en nuestro sistema escolar. Las matemáticas escolares normalmente se centran en el aprendizaje de procedimientos para resolver problemas altamente estereotipados. Los matemáticos profesionales piensan de cierta manera para resolver problemas reales, problemas que pueden surgir del mundo cotidiano, o de la ciencia, o de las propias matemáticas. La clave del éxito en las matemáticas escolares es aprender a pensar dentro de la caja. Por el contrario, una característica clave del pensamiento matemático es pensar fuera de la caja, una habilidad valiosa en el mundo de hoy. Este curso ayuda a desarrollar esa crucial forma de pensar.Link: https://www.coursera.org/learn/mathematical-thinking#2- Fundación matemática para la IA y el aprendizaje automáticoPrecio: $46.99 usdImage by PacktDescripción: La Inteligencia Artificial ha ganado importancia en la última década, dependiendo mucho del desarrollo e integración de la IA en nuestra vida cotidiana. El progreso que la IA ya ha hecho es asombroso con innovaciones como los coches auto-conductores, el diagnóstico médico e incluso ganarle a los humanos en juegos de estrategia como el Go y el Ajedrez. El futuro de la IA es extremadamente prometedor y no está lejos de que tengamos nuestros propios compañeros robóticos. Esto ha empujado a muchos desarrolladores a empezar a escribir códigos y a desarrollar programas de IA y ML. Sin embargo, aprender a escribir algoritmos para la IA y el ML no es fácil y requiere un amplio conocimiento de programación y matemáticas. Las matemáticas juegan un papel importante ya que constituyen la base para la programación de estas dos corrientes. Y en este curso, hemos cubierto exactamente eso. Diseñamos un curso completo para ayudarte a dominar los fundamentos matemáticos necesarios para escribir programas y algoritmos para la IA y la ML.Link: https://www.packtpub.com/product/mathematical-foundation-for-ai-and-machine-learning-video/97817896132093- Matemáticas para programadoresPrice: $47.99Image by ManningPuedes leer más artículos de Data Science en español aquí Descripción: Para conseguir un trabajo en data science, aprendizaje de máquinas, gráficos por ordenador y criptografía, tienes que aportar fuertes habilidades matemáticas a la fiesta. Math for Programmers enseña las matemáticas que necesitas para estas carreras, concentrándose en lo que necesitas saber como desarrollador. Lleno de muchos gráficos útiles y más de 200 ejercicios y mini proyectos, este libro abre la puerta a carreras interesantes y lucrativas en algunos de los campos de programación más populares de hoy en día.Link: https://www.manning.com/books/math-for-programmers4- Algebra 1Price: FreeImage by KhanacademyLink: https://www.khanacademy.org/math/algebra5- Algebra 2Price: FreeImage by KhanacademyLink: https://www.khanacademy.org/math/algebra26- Maestría en matemáticas con PythonPrice: $12.99Image by UdemyPuedes leer más artículos de Data Science en español aquí Descripción: ¡Puedes aprender muchas matemáticas con un poco de programación!Mucha gente no sabe que Python es una herramienta muy poderosa para aprender matemáticas. Claro que puedes usar Python como una simple calculadora, pero ¿sabías que Python puede ayudarte a aprender temas más avanzados en álgebra, cálculo y análisis de matrices? Eso es exactamente lo que aprenderás en este curso.Link: https://www.udemy.com/course/math-with-python/7- Introducción a los modelos lineales y al álgebra matricialPrice: FreeImage by EdxDescripción: El álgebra matricial es la base de muchas de las herramientas actuales para el diseño experimental y el análisis de datos de alta dimensión. En este curso introductorio en línea de análisis de datos, utilizaremos el álgebra matricial para representar los modelos lineales que comúnmente se utilizan para modelar las diferencias entre las unidades experimentales. Realizaremos una inferencia estadística sobre estas diferencias. A lo largo del curso utilizaremos el lenguaje de programación R para realizar operaciones matriciales.Link: https://www.edx.org/course/introduction-to-linear-models-and-matrix-algebra8- Aplicando matemáticas con Python.Price: $20.99Image by PacktDescripción: Python, uno de los lenguajes de programación más populares del mundo, tiene un número de poderosos paquetes para ayudar a abordar problemas matemáticos complejos de una manera simple y eficiente. Estas capacidades centrales ayudan a los programadores a preparar el camino para construir aplicaciones emocionantes en varios dominios, como el aprendizaje de las máquinas y la ciencia de los datos, utilizando el conocimiento en el dominio de las matemáticas computacionales.Link: https://www.packtpub.com/product/applying-math-with-python/9781838989750Intermedio: en esta segunda sección recomendaremos resusos enfocados en calculo y probabilidad. 9- Calculo 1Price: FreeImage by KhanacademyLink: https://www.khanacademy.org/math/calculus-1Link: https://www.khanacademy.org/math/calculus-110- Calculo 2Price: FreeImage by KhanacademyLink: https://www.khanacademy.org/math/calculus-2Link: https://www.khanacademy.org/math/calculus-211- Calculo multivariablePrice: FreeImage by KhanacademyLink: https://www.khanacademy.org/math/multivariable-calculusLink: https://www.khanacademy.org/math/multivariable-calculus12- Matematicas para Data SciencePrecio: GratisPrice: FreeImage by CourseraPuedes leer más artículos de Data Science en español aquí Descripción: Detrás de numerosos modelos y construcciones estándar en la Ciencia de los Datos hay matemáticas que hacen que las cosas funcionen. Es importante entenderlo para tener éxito en la Ciencia de los Datos. En esta especialización cubriremos una amplia gama de herramientas matemáticas y veremos cómo surgen en la Ciencia de los Datos. Cubriremos campos tan cruciales como las Matemáticas Discretas, el Cálculo, el Álgebra Lineal y la Probabilidad. Para que su experiencia sea más práctica, acompañaremos a las matemáticas con ejemplos y problemas surgidos en la Ciencia de los Datos y mostraremos cómo resolverlos en Python.Link: https://www.coursera.org/specializations/mathematics-for-data-science13- Matematicas discretas en la practicaPrice: $24.99Image by PacktDescripción: Las matemáticas discretas son un campo de las matemáticas que se ocupa del estudio de los elementos finitos y distintos. Las teorías y los principios de las matemáticas discretas se utilizan ampliamente en la resolución de complejidades y en la construcción de algoritmos en la informática y en la computación de datos en la ciencia de los datos. Ayuda a comprender los algoritmos, las matemáticas binarias y generales que se utilizan comúnmente en las tareas basadas en datos.Link: https://www.packtpub.com/product/practical-discrete-mathematics/978183898314714- Matemáticas para la ciencia de los datos y el aprendizaje automático: Nivel universitarioPrecio: $12.99 usdPrice: $12.99Image by UdemyDescripción: En este curso aprenderemos matemáticas para la ciencia de los datos y el aprendizaje de las máquinas. También discutiremos la importancia de las matemáticas para la ciencia de los datos y el aprendizaje de las máquinas en la práctica. Además, el curso de Matemáticas para la ciencia de los datos y el aprendizaje de máquinas es un paquete de dos cursos de álgebra lineal y probabilidad y estadística. Así, los estudiantes aprenderán contenidos completos de probabilidad y estadística y álgebra lineal. No es que no vayas a completar todos los contenidos en este curso de 7 horas de videos. Este es un hermoso curso y he diseñado este curso de acuerdo a la necesidad de los estudiantes.Link: https://www.udemy.com/course/master-linear-algebra-and-probability-2-in-1-bundle/15- Habilidades matemáticas para ciencia de datosPrice: FreeImage by CourseraDescripción: Los cursos de ciencias de los datos contienen matemáticas... ¡no hay que evitarlo! Este curso está diseñado para enseñar a los alumnos las matemáticas básicas que necesitarán para tener éxito en casi cualquier curso de matemáticas de ciencias de los datos y fue creado para alumnos que tienen habilidades matemáticas básicas pero que no han tomado álgebra o pre-cálculo. Data Science Math Skills introduce el núcleo matemático sobre el que se basa la ciencia de los datos, sin complejidad adicional, introduciendo ideas y símbolos matemáticos desconocidos de una en una. Link: https://www.coursera.org/learn/datasciencemathskillsAvanzado: en esta última sección nos centraremos en la parte estadística (teoría de la probabilidad) y en la aplicación de las matemáticas a los algoritmos de deep learning. 16- Estadística y probabilidadPrice: FreeImage by KhanacademyLink: https://www.khanacademy.org/math/statistics-probabilityLink: https://www.khanacademy.org/math/statistics-probability17- Introducción a estadística inferencial: Precio: GratisPrice: FreeImage by UdacityDescripción: Las estadísticas inferenciales nos permiten sacar conclusiones a partir de datos que podrían no ser inmediatamente obvios. Este curso se centra en mejorar su capacidad para desarrollar hipótesis y utilizar pruebas comunes como las pruebas t, las pruebas ANOVA y la regresión para validar sus afirmaciones.Link: https://www.udacity.com/course/intro-to-inferential-statistics--ud20118- Métodos estadísticos y matemáticas aplicadas a la ciencia de los datosPrice: $124.99Image by PacktDescripción: El aprendizaje de las máquinas y el análisis de datos son el centro de atracción de muchos ingenieros y científicos. La razón es bastante obvia: su vasta aplicación en numerosos campos y las opciones de carrera en auge. Y Python es una de las principales plataformas de código abierto para la ciencia de los datos y la computación numérica. IPython, y su asociado Jupyter Notebook, proporcionan a Python interfaces eficientes para el análisis de datos y la visualización interactiva, y constituyen una puerta de entrada ideal a la plataforma. Si usted está entre los que buscan mejorar sus capacidades en el aprendizaje de las máquinas, entonces este curso es la elección correcta.Link: https://www.packtpub.com/product/statistical-methods-and-applied-mathematics-in-data-science-video/978178953921919- Explorando las matemáticas para programadores y científicos de datosPrecio: GratisImage by ManningDescripción: Unas buenas habilidades matemáticas son un prerrequisito si estás interesado en una carrera en ciencias de los datos, inteligencia artificial, criptografía o prácticamente cualquier campo tecnológico. Este mini ebook gratuito es el perfecto manual de aplicaciones matemáticas esenciales que necesitas para entrar en estas emocionantes y lucrativas carreras tecnológicas.Link: https://www.manning.com/books/exploring-math-for-programmers-and-data-scientists20- Matemáticas prácticas para deep learningPrice: $27.99Image by PacktDescripción: La mayoría de los programadores y científicos de datos luchan con las matemáticas, habiendo pasado por alto u olvidado conceptos matemáticos básicos. Este libro utiliza bibliotecas de Python para ayudar a comprender las matemáticas necesarias para construir modelos de aprendizaje profundo (DL).Link: https://www.packtpub.com/product/hands-on-mathematics-for-deep-learning/978183864729221- Matemáticas y Arquitecturas de Deep LearningPrice: $39.99Image by ManningDescripción: Los paradigmas matemáticos que subyacen en el aprendizaje profundo suelen comenzar como documentos académicos difíciles de leer, a menudo dejando a los ingenieros en la oscuridad sobre cómo funcionan realmente sus modelos. Matemáticas y Arquitecturas de Aprendizaje Profundo cierra la brecha entre la teoría y la práctica, estableciendo las matemáticas del aprendizaje profundo junto con las implementaciones prácticas en Python y PyTorch. Escrito por el experto en aprendizaje profundo Krishnendu Chaudhury, usted mirará dentro de la "caja negra" para entender cómo funciona su código, y aprenderá a comprender la investigación de vanguardia que puede convertir en aplicaciones prácticasLink: https://www.manning.com/books/math-and-architectures-of-deep-learningConclusiónEsta es una extensa recomendación sobre recursos para aprender matemáticas para data science, siguiendo el post anterior sobre el camino a seguir en este año 2021 para aprender data science. Cuando tenemos un tiempo limitado para el estudio debemos seleccionar los que mejor nos parezca y los que más se ajusten a nuestro estilo. Por ejemplo, podrías preferir los videos sobre los libros, así que vaya y elija lo que mejor se acomode a usted. Este material es suficiente tanto si desea dar una breve mirada a las matemáticas, como si quiere profundizar en ellas. Espero que lo encuentre útil. Si tienes otras recomendaciones de cursos, libros o videos, porfavor déjalas en los comentarios para que entre todos formemos enlaces de interes.Puedes leer más artículos de Data Science en español aquí PD: estamos creando un grupo privado de data scientists en Slack, si te quieres unir deja tus datos aqui: https://www.datacademy.dev/#slack¡Gracias por leer!
Python
Programming
Libros de Python Que Deberías Leer En Éste 2020
Python es uno de los principales lenguajes de programación para un rango diverso de tareas y dominios. La facilidad de uso de Python, su naturaleza de alto nivel y el énfasis en la simplicidad y la mejora de la legibilidad del código lo convierten en una opción favorable para muchos desarrolladores de todo el mundo. Si eso no te vende Python, estoy seguro de que su exhaustivo ecosistema de más de 255 mil paquetes/librearías creados por terceros sí lo hará.Características como estas han disparado la demanda de Python en todas partes, ya sea en el desarrollo de aplicaciones, ciencia de los datos, inteligencia artificial, o cualquier otra industria. El objetivo de este escrito es reunir algunos de los mejores libros sobre Python, para ayudarte a ganar el conocimiento y la confianza con este increíble lenguaje de programación.Python es un experimento de cuanta libertad necesitan los programadores. Demasiada libertad y nadie puede leer el código de otro; muy poca y la expresividad está en peligro.- Guido van RossumSegún Stackoverflow, Python es el lenguaje preferido, lo que significa que la mayoría de los desarrolladores utilizan python.Libros de PythonLos libros son posiblemente una de las principales fuentes de información sobre casi cualquier tema, y en esta sección, hemos reunido más de diez libros principales para ayudarle a familiarizarse y obtener algunos conocimientos prácticos con Python. Algunos de estos libros cubren el conocimiento completo sobre el lenguaje de programación mientras que otros son excelentes para darte experiencia práctica con él.Independientemente de tu experiencia previa con Python o cualquier otro lenguaje de programación, estamos seguros de que encontrarás algunos consejos útiles de estos libros para tu próximo proyecto.1. Python Crash CourseAutor: Eric MatthesEditor - No Starch PressNivel de dificultad: PrincipiantesDividido en dos partesConsiga ambos libros aquí - Amazon, AmazonPython Crash CourseComo su nombre lo indica, el autor ha escrito este libro para actuar como un curso rápido para los lectores con poca o ninguna exposición a la programación. El autor ha hecho todos los conceptos introductorios tan fáciles como el ABC para que los principiantes puedan empezar a implementar sus conocimientos en proyectos divertidos. La naturaleza introductoria de este libro también lo hace una elección adecuada para los académicos.Este libro de dos partes cubre la introducción a la programación en su primera parte, mientras que en la segunda parte, adopta un enfoque basado en proyectos donde se anima a los lectores a completar cualquiera o los tres proyectos de programación. Los proyectos incluyen la codificación de un juego 2D, la creación de un programa de visualización de datos, y el último, un registro de aprendizaje en línea para la toma de notas.Book Reader2. Learning PythonAutor: Mark LutzEditor - O'Reilly MediaNivel de dificultad: PrincipiantesConsiga el libro aquí - AmazonLearning PythonEn la forma de pensar de Python, lo explícito es mejor que lo implícito, y lo simple es mejor que lo complejo.- Mark LutzLearning Python cubre todos los fundamentos del lenguaje de programación y pretende ser una solución integral para los principiantes que buscan una introducción profunda a Python. Al ser un libro de dos partes como el anterior, el autor Mark Lutz ha intentado crear una base sólida con Python en esta parte, mientras que la otra parte se centra más en ejemplos y situaciones de la vida real para una mejor exposición práctica de la programación.La última edición del libro cubre la versión 3.3 de Python y todas sus últimas mejoras junto con la antigua versión 2.7. Como nota al margen, si no tienes ninguna habilidad con la programación, sería una buena idea complementar este libro con referencias introductorias adicionales.Otros Articulos: Cómo Conseguir Un Trabajo Con Python3. Python Tricks: A Buffet of Awesome Python FeaturesAutor: Dan BaderEditor - Dan Bader (dbader.org)Nivel de dificultad: IntermedioConsiga el libro aquí - AmazonPython Tricks"Debería haber una, y preferiblemente sólo una, manera obvia de hacerlo."- Dan BaderComo sugiere el título, Python Tricks reúne una colección de características convenientes, consejos y trucos para que seas eficiente con Python.En palabras del autor - "Lo que comenzó como un divertido experimento de twitter, se convirtió en una serie de notables y útiles trucos acompañados de un claro ejemplo de código, que ayudó a cientos de desarrolladores de Python a entender la idea detrás de los diversos aspectos de Python".El libro cubre una gran colección de trucos de una variedad de temas en Python, y se presentan en un estilo bien explicado, pero para aprovechar al máximo este libro, se necesita una base sólida en Python.Leer También: 14 Funcionalidades Básicas Para Aprender Python + Ejercicio Final. Parte I4. Learn Python the Hard WayAutor: Zed ShawEditor - Addison-WesleyNivel de dificultad: PrincipiantesConsiga el libro aquí - AmazonHard Way"Tómatelo con calma y no te hagas daño en el cerebro".Si te sientes intimidado por el "Hard" del título, no lo estés. Es sólo la forma en que el autor utiliza las instrucciones para hacerte repasar los capítulos y practicar lo que has aprendido.Dejando el título a un lado, el autor ha hecho un trabajo increíble presentando los conceptos fundamentales de Python a un ritmo más amigable para el principiante, para prepararte para temas complejos. El libro también incluye muchos videos instructivos y ejercicios para mejorar tu conocimiento de Python. En caso de que te lo preguntes, sí, el libro ha sido actualizado con una nueva edición que soporta Python 3. Video review5. Automating Boring Stuff with PythonAutor: Al SweigartEditor - No Starch PressNivel de dificultad: PrincipiantesConsiga el libro aquí - AmazonBoring StuffSegún el autor...No pierdas tu tiempo haciendo el trabajo que un mono bien entrenado podría hacer. Aunque nunca hayas escrito una línea de código, puedes hacer que tu ordenador haga el trabajo pesado. Aprende cómo en Automatizar las cosas aburridas con Python.El título lo dice todo. De vez en cuando, debes haberte encontrado con una tarea aburrida o repetitiva que te hace decir, "no esto otra vez". Son estos momentos los que este libro pretende eliminar. El autor ha cubierto los fundamentos necesarios del lenguaje de programación en este libro para ayudarte a crear algunos ingeniosos fragmentos de Python que pueden automatizar una simple pero aburrida tarea a realizar en segundos en lugar de horas.Aunque el libro hace maravillas para cualquiera que quiera eliminar rápidamente las tareas aburridas, sin el fondo de programación, no cubre exhaustivamente cada aspecto de Python. Lo suficientemente bueno para crear código desechable, pero no lo suficiente para una introducción completa.Leer también: Visualización De Datos: Dilo Con Gráficos En Python6. Python for Data AnalysisAutor: Wes McKinneyEditorial - O′ReillyNivel de dificultad: IntermedioConsiga el libro aquí - AmazonPython for Data AnalysisPython puede ser utilizada para una variedad de tareas, y una de ellas es el análisis de datos. Si te encuentras constantemente ocupado con el análisis y la manipulación de datos estructurados o simplemente estás interesado en aprender sobre lo eficiente que puede ser Python para las tareas de análisis de datos, puedes encontrar este libro útil.El autor ha explicado los fundamentos del trabajo con datos de una manera muy completa, mientras que también toca el tema de la computación científica. Python para el análisis de datos también cubre algunas de las bibliotecas más populares para el análisis de datos, como NumPy, pandas, matplotlib, IPython y SciPy."Actúa sin hacer; trabaja sin esfuerzo. Piensa en lo pequeño como en lo grande y en lo poco como en lo mucho. Enfrentar lo difícil mientras aún es fácil; realizar la gran tarea mediante una serie de pequeños actos. - Laozi"- Wes McKinneyVideo review del libro7. Introduction to Machine Learning with PythonAutor: Andreas C. Müller y Sarah GuidoEditorial - O′ReillyNivel de dificultad: IntermedioConsiga el libro aquí - AmazonMachine Learning With PythonLa velocidad a la que avanza el aprendizaje automático es fascinante. Para poder sacar el máximo provecho de esta tecnología, Python está entre las principales opciones para aprenderlo. Dirigido a aspirantes a profesionales del Aprendizaje Automático en busca de soluciones a problemas de aprendizaje automático en el mundo real, este libro de introducción no requiere ninguna experiencia previa con el Aprendizaje Automático.En lugar de sumergirse en las matemáticas que hay detrás de los algoritmos y modelos que se utilizan en todo el proceso, el libro adopta un enfoque más suave y explica los antecedentes y su importancia. Aunque requiere cierto conocimiento del uso de Python para implementar la vasta colección de algoritmos y modelos cubiertos por las bibliotecas que se siguen en el libro, como scikit-learn, NumPy y matplotlib.Twitter commentLeer También: Una Guía Para Principiantes Sobre La Regresión Lineal En Python Con Scikit-Learn8. Python Data Science HandbookAutor: Jake VanderPlasEditor - O'Reilly MediaNivel de dificultad: IntermedioConsiga el libro aquí - AmazonGit Hub - https://github.com/jakevdp/PythonDataScienceHandbookData ScienceLa ciencia de los datos se está convirtiendo en una habilidad imperativa en varios dominios últimamente, ya que los beneficios que ofrece son inestimables. El autor de este manual ha puesto más énfasis en el aprendizaje de la Ciencia de los Datos como una habilidad que en un nuevo dominio del conocimiento, ya que puede resultar ventajoso mientras se aplica la habilidad a un problema que se tiene a la mano.El contenido del libro se ha estructurado en cinco bibliotecas diferentes proporcionadas por Python para una amplia cobertura, a saber, IPython, NumPy, Pandas, Matplotlib, Scikit-Learn. El manual requiere cierto grado de competencia en Python para seguir el libro tal como lo pretende el autor, y no sería una elección adecuada para los principiantes.9. Head First Python: A Brain-Friendly GuideAutor: Paul BarryEditor - O'Reilly MediaNivel de dificultad: IntermedioConsiga el libro aquí - AmazonPython"El código se lee más de lo que se escribe. Esto"- Paul BarryAunque este libro no cubre el lenguaje de programación y su totalidad en detalle, se las arregla para enseñarte Python de una manera más práctica y divertida. Lo que separa a este libro de los demás es el estilo divertido y casual que el autor ha utilizado para establecer una conexión con los lectores, y lo más importante, el uso cómico de las imágenes para mantener el proceso de aprendizaje intuitivo.Para aquellos de vosotros que acabáis de empezar a aprender Python, o cualquier otro lenguaje de programación, puede que os cueste trabajo entender los temas tratados. Si conoces los fundamentos de la programación, es una buena idea.10. Fluent PythonAutor: Luciano RamalhoEditor - O'Reilly MediaNivel de dificultad: ExpertosConsiga el libro aquí - AmazonFluent PythonPython puede ser un lenguaje de programación muy versátil y poderoso cuando se usa eficientemente, y este mismo motivo es el único factor impulsor del libro Fluent Python. Está claro que aprender Python y lograr fluidez en Python son cosas muy diferentes. La mayoría de los desarrolladores a menudo logran lo que quieren con Python de todos modos, pero a costa de todo su potencial.El autor ha hecho hincapié en destacar algunas de las características y técnicas menos utilizadas para poder sacar el máximo provecho de Python. Si usted ha comenzado recientemente a aprender Python, este podría no ser el libro adecuado para usted, ya que podría ser difícil de seguir.11. Effective PythonAutor: Brett SlatkinEditor - Addison-WesleyNivel de dificultad: ExpertosConsiga el libro aquí - AmazonEffectice PythonPython es un lenguaje de programación que pone un gran énfasis en la creación de un código claro y extremadamente legible, pero todavía puede haber algunas situaciones en las que eso no se logra. Aquí es donde el libro "Effective Python" entra en escena. El autor ha cubierto algunos errores comunes y ha proporcionado valiosas ideas y prácticas sobre cómo evitarlos en primer lugar, para escribir un código Python más limpio, reutilizable y efectivo. Si estás constantemente luchando para encontrar maneras de optimizar tu código, este podría ser el libro adecuado para ti.Comments about the book12. Python CookbookAutor: David Beazley & Brian K. JonesEditor - O'Reilly MediaNivel de dificultad: ExpertosConsiga el libro aquí - AmazonPython CookbookPython tiene una excelente comunidad, y este libro se inspira en los muchos y únicos desafíos que enfrenta la comunidad, que son referidos como recetas en el Python Cookbook. Las recetas vienen con ejemplos relevantes y detallados estudios de fondo sobre los problemas de algunos de los miembros más perspicaces de la comunidad.Para dejarlo absolutamente claro, el autor ha dirigido este libro a los desarrolladores experimentados de Python que buscan fortalecer su comprensión de las diversas técnicas modernas en Python. Se sugiere a los principiantes que tomen algo que cubra las partes introductorias de Python antes de comenzar con este libro.Más libros de Python para leer -Python Pocket ReferencePython Machine LearningDeep Learning with PythonPython Programming: An Introduction to Computer ScienceNatural Language Processing with PythonPython in a NutshellThink Python: How to Think Like a Computer ScientistDjango for Beginners: Build websites with Python and DjangoConclusiónPython es un elegante y poderoso lenguaje de programación que puede hacer maravillas si se utiliza correctamente. Los libros que se cubren en este escrito deberían proporcionarle el conocimiento suficiente para empezar a usar Python junto con algunos consejos y trucos adicionales para escribir un código claro y optimizado que funcione de forma excelente. Para atar cabos aquí, si te gusta aprender Python desde cero o simplemente quieres repasar, te recomendamos encarecidamente que revises estos libros.Sin embargo, si los libros no son lo tuyo o quieres complementar lo estudiando en los libros, te recomendamos tomar este curso de python, el cual contiene conceptos basicos hasta intermedios. Nota: Para eliminar problemas de diferentes tipos, quiero alertarles del hecho de que este artículo representa sólo mi opinión personal que quiero compartir, y ustedes tienen todo el derecho a estar en desacuerdo con él.
Programming
Data Science
Python
Cómo Conseguir Un Trabajo Con Python
Hay tantos sitios web que ofrecen listas de trabajos para diferentes campos de trabajo. Aunque estés en un determinado puesto, siempre debes buscar un trabajo y eso puede ser aburrido. Pero aquí viene una solución simple para poder pasar por muchas de esas ofertas de trabajo con facilidad!Vamos a construir un sencillo script en Python para obtener listas de trabajos y filtrarlas a tu gusto.Es un simple uso de Python y no necesitas ninguna habilidad específica para hacer esto conmigo. Iremos paso a paso y construiremos todo juntos.Lea También: Consigue Tu Primer Trabajo Como Científico De Datos¡Saltemos directamente a ello!CodificaciónPlanificar el proceso Primero, tenemos que encontrar el sitio web de la lista de trabajos de los que vamos a recibir las ofertas.Elijo un sitio web llamado Indeed. (Es sólo un ejemplo para este tutorial, pero si tienes un sitio web que prefieres usar para buscar trabajo, ¡por favor, siéntete libre de hacerlo!)Esto es lo que vamos a hacer: Filtrar los criterios de los trabajos que nos convienen y realizar raspaduras en ellos. Así es como se ve el sitio web de Indeed después de que busque la Ciencia de los Datos en los Estados Unidos.Search on the Website exampleAl final, una vez que tengamos nuestros datos, vamos a empaquetarlos en DataFrames y obtener un archivo CSV, que se puede abrir fácilmente con Excel o Libre Office.Configurar El EntornoTendrás que instalar un ChromeDriver y usarlo con Selenio, lo que nos permitirá manipular el navegador y enviarle comandos para probarlo y después para usarlo.Abra el enlace y descargue el archivo para su sistema operativo. Recomiendo el último lanzamiento estable a menos que ya sepas lo que estás haciendo.A continuación, tienes que descomprimir ese archivo. Recomendaría entrar en Archivos y hacerlo manualmente haciendo clic con el botón derecho y luego "Extraer aquí".Dentro de la carpeta, hay un archivo llamado "chromedriver", que tenemos que mover a una carpeta específica de su ordenador. Abra la terminal y escriba estos comandos:sudo su #enter the root mode
cd #go back to base from the current location
mv /home/*your_pc_name*/Downloads/chromedriver /usr/local/bin
#move the file to the right locationSólo en lugar de *your_pc_name* inserta tu nombre real de la computadora. Se necesitan algunas bibliotecas más para que esto funcione: En esa terminal debería instalar esto:pip3 install pandasPandas es una herramienta de análisis y manipulación de datos de código abierto, rápida, potente, flexible y fácil de usar, construida sobre el lenguaje de programación Python.sudo pip3 install beautifulsoup4Beautiful Soup es una biblioteca de Python para obtener datos de HTML, XML y otros lenguajes de marcado. Una vez que terminemos con eso, abrimos el editor. Mi elección personal es Visual Studio Code. Es fácil de usar, personalizable y ligero para su ordenador. Abre un nuevo proyecto donde quieras y crea dos nuevos archivos. Este es un ejemplo de cómo la mía parece ayudarte:Visual Studio Code — Project setupEn el VS Code, hay una pestaña "Terminal" con la que se puede abrir un terminal interno dentro del VS Code, lo que es muy útil para tener todo en un solo lugar. Cuando tienes eso abierto, hay pocas cosas más que necesitamos instalar y eso es el entorno virtual y el selenium para el controlador web. Escriba estos comandos en su terminal.pip3 install virtualenv
source venv/bin/activate
pip3 install seleniumDespués de activar el entorno virtual, estamos completamente listos para comenzar.Creando La Herramienta¡Tenemos todo listo y ahora vamos a programar! Primero, como se mencionó antes, tenemos que importar las bibliotecas instaladas.from selenium import webdriver
import pandas as pd
from bs4 import BeautifulSoup
from time import sleepCrea tu herramienta con cualquier nombre e inicia el controlador para Chrome.class FindJob():
def __init__(self):
self.driver = webdriver.Chrome()Eso es todo lo que necesitamos para empezar a desarrollar. Ahora ve a tu terminal y escribe:python -i findJob.pyEste comando nos permite nuestro archivo como un espacio de juego interactivo. La nueva pestaña del navegador se abrirá y podremos empezar a emitir comandos a la misma. Si quieres experimentar, puedes usar la línea de comandos en lugar de escribirla directamente en tu archivo fuente. En lugar de usar el bot. Para el terminal:bot = FindJob()
bot.driver.get('https://www.indeed.com/jobs?q=data+science&l=United+States&start=')Y ahora el código fuente:self.driver.get('https://www.indeed.com/jobs?q=data+science&l=United+States&start=')Crear el DataFrame que vamos a usar es fácil, ¡así que empecemos por ahí!Para este data frame, necesitamos tener “Title”, “Location”, “Company”, “Salary”, “Description” todos relacionados con los trabajos que vamos a raspar o scrape.dataframe = pd.DataFrame(
columns=["Title", "Location", "Company", "Salary", "Description"])Usaremos este DataFrame como nombre de columna para nuestro archivo CSV.El asunto con este sitio web es que en cada página hay 10 ofertas de trabajo y el enlace cambia cuando vas a la siguiente página. Una vez que lo he descubierto, he hecho un bucle de "for" que comprueba cada página y después de hacerlo va a la siguiente. Esto es lo que parece:for cnt in range(0, 50, 10):
self.driver.get("https://www.indeed.com/jobs?q=data+science&l=United+States&start=" + str(cnt))Configuré una variable de contador "cnt" y agregué ese número, convertido en cadena a mi enlace. El bucle for comienza específicamente con 0, llega hasta 50 y lo hace en iteraciones de 10, porque así es como se nos muestra la cantidad de trabajos por página.Cuando lleguemos a la primera página, tenemos que raspar la tabla de ofertas una por una y lo haremos de esta manera:En la imagen de arriba, donde se ven las ofertas, están empaquetadas en una tabla y podemos encontrar esa tabla presionando F12 en el teclado o con el botón derecho del ratón -> Inspeccionar.Le podría interesar leer también: Cómo Superé El Síndrome Del Impostor En El Análisis De DatosEsto es lo que parece:Encontraremos la tabla por el nombre de la clase y entraremos en esta línea:jobs = self.driver.find_elements_by_class_name('result')Eso guarda todos los elementos de la web que ha encontrado por el resultado del nombre de la clase.Una vez que tenemos esos guardados podemos crear otro bucle for y pasar por cada elemento dentro de esa tabla y usar los datos que encontramos dentro.Antes de mostrarles más código sobre el scraping de esas ofertas, deberíamos repasar un par de cosas. Para esta parte, vamos a utilizar BeautifulSoup ya que creo que funciona mucho más rápido. Tenemos que configurar algunas cosas para BeatifulSoup, y esos son los datos reales que le damos para realizar su búsqueda y el analizador que decimos que debe utilizar:result = job.get_attribute('innerHTML')
soup = BeautifulSoup(result, 'html.parser')Una vez que los tengamos, sólo tenemos que encontrar elementos dentro de la variable definida "soup", que es sólo un dato preparado por BeautifulSoup. Obtenemos los datos para el DataFrame que queremos:title = soup.find("a", class_="jobtitle").text.replace('\n', '')
location = soup.find(class_="location").text
employer = soup.find(class_="company").text.replace('\n', '').strip()
try:
salary = soup.find(class_="salary").text.replace(
'\n', '').strip()
except:
salary = 'None'Hice una parte del salario de tal manera porque a veces no está definido y tenemos que poner Ninguno o vacío para esa celda en particular. Ya que estoy trabajando en la terminal para probar mi código, también puedes imprimir lo que has encontrado hasta ahora:print(title, location, employer, salary)Una vez que este script esté hecho, se verá así:Lo último que falta en el DataFrame es la descripción del trabajo y lo dejó fuera porque, para obtener el texto de la descripción del trabajo, tienes que hacer clic en la oferta de trabajo primero. Yo lo hago de esta manera:summ = job.find_elements_by_class_name("summary")[0]summ.click()job_desc = self.driver.find_element_by_id('vjs-desc').textUna vez que tenemos todos los elementos que deberían entrar en el DataFrame, lo llenamos:dataframe = dataframe.append(
{'Title': title, 'Location': location, 'Employer': employer, 'Description': job_desc}, ignore_index=True)Una cosa más que tengo que mencionar antes de que empieces a probar esto por ti mismo. Una vez que vayas a la segunda página del sitio web, hay un popup que te bloquea para que no puedas hacer clic en nada más. También he pensado en eso y he creado un try-expect, que cerrará el popup y seguirá scraping datos!pop_up = self.driver.find_element_by_xpath('/html/body/table[2]/tbody/tr/td/div[2]/div[2]/div[4]/div[3]/div[2]/a')
pop_up.click()Una vez que el bucle for termina, copiamos los datos del marco de datos a CSV llamado "jobs":dataframe.to_csv("jobs.csv", index=False)Consigue un trabajo remoto en python y en data science aqui.¡Hemos Terminado!El código completo está aquí abajo en mi cuenta de GitHub:https://github.com/lazargugleta/findJobLos Siguientes Pasos Puedes llevar este guión a otro nivel implementando una comparación entre diferentes sitios web y obtener las mejores ofertas de Internet en general. Si quieres acceder a trabajos remotos con python y data science, este es un buen lugar.Hasta entonces, ¡sígueme para más! 😎 ¡Gracias por leer!
Programming
Data Science
News
Tendencias en Ciencia de Datos para 2020
Tendencias cruciales de ciencia de datos para la nueva décadaLa ciencia de datos es la disciplina de hacer que los datos sean útiles.No hay ninguna duda de que esta década ha comprado mucha innovación en la Inteligencia Artificial. Además de la Inteligencia Artificial, estamos siendo testigos de un gran aumento en los datos generados por miles de fuentes. El hecho de que millones de dispositivos sean responsables de este enorme pico de datos nos lleva al tema de su utilización inteligente.El dominio de la Ciencia de Datos trae consigo una variedad de herramientas científicas, procesos, algoritmos y sistemas de extracción de conocimiento de datos estructurados y no estructurados por igual, para identificar patrones significativos en ella.La Ciencia de Datos también beneficia a la minería de datos y al big data. Creciendo en popularidad desde el año 2001, la Ciencia de Datos ha estado evolucionando desde entonces y está clasificada como una de las trayectorias profesionales más emocionantes de todos los tiempos.Hacia los informes de Ciencia de Datos:Actualmente, la producción diaria de datos es de más de 2,5 quintillones de bytes.En un futuro próximo, "1,7 Mb de datos se crearán cada segundo para cada persona en el planeta".Una amplia variedad de funciones de Ciencia de Datos impulsará estas cargas masivas de datos.Popularidad de la búsqueda en Google de "Ciencia de Datos" en los últimos 5 años. Generado por Google Trends.Tendencias en Ciencia de DatosCon la diversidad de problemas y requisitos de datos, viene una amplia gama de soluciones innovadoras. Estas soluciones a menudo traen consigo una gran cantidad de tendencias de ciencia de datos, lo que otorga a las empresas la agilidad que necesitan y les ofrece una visión más profunda de sus datos. A continuación se explican brevemente algunas de estas principales tendencias de ciencia de datos:1. Análisis de GráficosCon los datos fluyendo en todas las direcciones, se hace más difícil analizar.Graph Analytics pretende resolver este problema actuando como una herramienta flexible pero poderosa que analiza complicados puntos de datos y relaciones usando gráficos. La intención detrás del uso de los gráficos es representar los datos complejos de forma abstracta y en un formato visual que sea más fácil de digerir y que ofrezca la máxima comprensión. El análisis de gráficos se aplica en una plétora de áreas como:Filtrar los bots en redes sociales para reducir la información falsaIdentificación de fraudes en el sector bancarioPrevención de delitos financierosAnálisis de redes de energía y agua para encontrar defectos2. Tejido de datosEl Data Fabric es una tendencia relativamente nueva y, en su núcleo, encapsula los datos de una organización recogidos de un gran número de fuentes como APIs, servicios de datos reutilizables, pipelines, niveles semánticos, proporcionando un acceso transformable a los datos.Creados para ayudar al contexto empresarial de los datos y mantener los datos de forma inteligible no sólo para los usuarios sino también para las aplicaciones, los Data Fabrics permiten disponer de datos escalables y, al mismo tiempo, ser ágiles.Al hacerlo, usted obtiene un acceso sin precedentes para procesar, administrar, almacenar y compartir los datos según sea necesario. La Inteligencia de Negocios y la Ciencia de Datos depende en gran medida de los Tejidos de Datos debido a su acceso suave y limpio a enormes cantidades de datos.3. Privacidad de datos por diseñoLa tendencia de la privacidad de los datos por diseño incorpora un enfoque más seguro y proactivo de la recopilación y el manejo de los datos de los usuarios, al mismo tiempo que capacita al modelo de aprendizaje de máquina en ello.Las corporaciones necesitan los datos del usuario para entrenar sus modelos en escenarios del mundo real, y recogen datos de varias fuentes como patrones de navegación y dispositivos.La idea detrás del Aprendizaje Federado es recolectar la menor cantidad de datos posible, manteniendo al usuario al tanto, dándole también la opción de optar por no participar y borrar todos los datos recolectados en cualquier momento.Si bien los datos pueden provenir de un público enorme, por razones de privacidad, debe garantizarse que no es posible realizar ingeniería inversa de los datos originales para identificar al usuario.4. Analítica AumentadaLa Analítica Aumentada se refiere a la obtención de mejores conocimientos a partir de los datos en mano, excluyendo cualquier conclusión incorrecta o sesgo para la optimización de las decisiones. Al combinar la Inteligencia Artificial y el Aprendizaje Automático, la Analítica Aumentada ayuda a los usuarios a planificar un nuevo modelo.Con una menor dependencia de los científicos de datos y los expertos en aprendizaje automático, la Analítica Aumentada tiene como objetivo proporcionar una comprensión relativamente mejor de los datos para ayudar a todo el proceso de Inteligencia Empresarial.Esta sutil introducción de la Inteligencia Artificial y el Aprendizaje Automático tiene un impacto significativo en el proceso tradicional de descubrimiento de conocimientos al automatizar muchos aspectos de la ciencia de datos. La Analítica Aumentada está ganando una fortaleza en la provisión de mejores decisiones libres de cualquier error y sesgo en el análisis.5. Python como el lenguaje de facto de la ciencia de datosFoto de Hitesh Choudhary en UnsplashPython es un lenguaje de programación absolutamente polifacético y se considera un punto de entrada válido si estás interesado en entrar en el mundo de la Inteligencia Artificial y la Ciencia de Datos.Con una comunidad online de apoyo, puedes obtener soporte casi instantáneamente, y las integraciones en Python son sólo la punta del iceberg.El placer de programar en Python debería ser ver clases cortas, concisas y legibles que expresen mucha acción en una pequeña cantidad de código claro - no en montones de código trivial que aburre al lector hasta la muerte.- Guido van RossumPython viene apilado con integraciones para numerosos lenguajes de programación y bibliotecas, lo que lo convierte en una excelente opción para, digamos, saltar a la creación de un prototipo rápido para el problema en cuestión o profundizar en grandes conjuntos de datos.Algunas de sus bibliotecas más populares son...TensorFlow, para cargas de trabajo de aprendizaje automático y trabajo con conjuntos de datosScikit-learn, para la formación de modelos de aprendizaje de máquinasPyTorch, para visión por computadora y procesamiento de lenguaje naturalKeras, como interfaz de código para cálculos y operaciones matemáticas altamente complejasSparkMLlib, como la biblioteca de aprendizaje de máquinas de Apache Spark, haciendo el aprendizaje de máquinas fácil para todos con herramientas como algoritmos y utilidades6. Automatización generalizada en ciencia de datosEl tiempo es un componente crítico, y nada de él debe ser gastado en la realización de tareas repetitivas.A medida que la inteligencia artificial avanzaba, sus capacidades de automatización se expandieron también. Varias innovaciones en la automatización están facilitando muchas tareas complejas de la Inteligencia Artificial.La automatización en el campo de Ciencia de Datos ya está simplificando gran parte del proceso, si no todo. El proceso completo de Ciencia de Datos incluye la identificación del problema, la recolección de datos, el procesamiento, la exploración, el análisis y el compartir la información procesada con otros.7. Análisis Conversacional y Procesamiento del Lenguaje NaturalEl Procesamiento del Lenguaje Natural y la Analítica Conversacional ya están haciendo grandes olas en el mundo digital al simplificar la forma en que interactuamos con las máquinas y buscamos información en línea.El NLP nos ha ayudado enormemente a progresar hacia una era en la que las computadoras y los humanos pueden comunicarse en un lenguaje natural común, permitiendo una constante y fluida conversación entre ambos.Las aplicaciones de NLP y los sistemas de conversación se pueden ver en todas partes, como los robots de chat y los asistentes digitales inteligentes. Se ha predicho que el uso de las búsquedas basadas en la voz superará en muy poco tiempo a las búsquedas basadas en texto, que son las más utilizadas.8. La ciencia de datos de gran tamaño en la nubeEl inicio de la Inteligencia Artificial y la cantidad de datos generados a partir de ella se ha disparado desde entonces. El tamaño de los datos creció enormemente de unos pocos gigabytes a unos pocos cientos, a medida que las empresas aumentaban su presencia en línea.Este aumento en la necesidad de almacenamiento y procesamiento de datos dio lugar a la Ciencia de Datos para una utilización controlada y precisa de los datos y empujó a las organizaciones que trabajan a escala mundial a optar por soluciones de nube.Varios proveedores de soluciones en la nube, como Google, Amazon y Microsoft, ofrecen amplias opciones de computación en la nube que incluyen capacidades de servidor en la nube de nivel empresarial que garantizan una alta escalabilidad y cero tiempo de inactividad.9. Mitigar los sesgos y la discriminación de los modelosNingún modelo es totalmente inmune a los sesgos, y pueden comenzar a exhibir un comportamiento discriminatorio en cualquier etapa debido a factores como la falta de datos suficientes, el sesgo histórico y las prácticas incorrectas de recolección de datos. El sesgo y la discriminación es un problema común de los modelos y es una tendencia emergente. Si se detectan a tiempo, estos sesgos pueden mitigarse en tres etapas:Etapa de preprocesamientoEn la etapa de procesamientoEtapa de post-procesamientoCada etapa viene con su propio conjunto de aspectos correctivos, incluyendo algoritmos y técnicas para optimizar el modelo para la equidad, y para aumentar su precisión para eliminar cualquier posibilidad de sesgo.10. Computación en memoriaLa computación en memoria es una tendencia emergente que es muy diferente a la forma en que tradicionalmente procesamos los datos.La computación en memoria procesa los datos almacenados en una base de datos en memoria, a diferencia de los métodos tradicionales que utilizan discos duros y bases de datos relacionales con un lenguaje de consulta. Esta técnica permite procesar y consultar datos en tiempo real para la toma de decisiones y la elaboración de informes de forma instantánea.Al abaratarse la memoria y al depender las empresas de los resultados en tiempo real, la computación en memoria les permite tener aplicaciones con tableros más ricos e interactivos a los que se pueden suministrar datos más recientes y estar listos para la presentación de informes casi instantáneamente.11. Blockchain en datos y análisisBlockchain, en términos más sencillos, es una colección de datos inmutables con sello de tiempo administrada por un grupo de computadoras, y no por una sola entidad. La cadena aquí se refiere a la conexión entre cada uno de estos bloques, unidos entre sí mediante algoritmos criptográficos.Transformando gradualmente similar a la Ciencia de Datos, la blockchain es crucial para mantener y validar los registros mientras que la Ciencia de Datos trabaja en la parte de recolección y extracción de información de los datos. La Ciencia de Datos y Blockchain están relacionadas ya que ambas utilizan algoritmos para gobernar varios segmentos de su procesamiento.ConclusiónA medida que las empresas empiezan a crecer, generan más datos, y la Ciencia de Datos puede ayudarles a analizar sus áreas de mejora. Con varias de las notables tendencias de Ciencia de Datos mencionadas anteriormente, algunos han comenzado a considerar la Ciencia de Datos como el cuarto paradigma de la ciencia junto a la Empírica, Teórica, Computacional. Mantenerse al día con las nuevas tendencias es una necesidad absoluta para que las empresas logren la máxima eficiencia y se mantengan a la vanguardia de la competencia.
SQL
Programming
Joins En SQL: Un Breve Ejemplo | Entender El Por Qué Y El Cómo De Los Joins En SQL
Esta entrada en el blog fue originalmente destinada a ser una nota complementaria a mi entrada de Pandas Join vs. Merge. Pero resultó ser lo suficientemente larga como para justificar su propio post (y demasiado verborreica para ser una nota complementaria). No pretende ser un manual completo sobre Joins en SQL, sino más bien un ejemplo para ayudar a aquellos que son nuevos en SQL y en bases de datos relacionales a entender lo que significa unir dos tablas.¿Por qué unimos?¿Por qué molestarse en unir? ¿No podemos simplemente volcar todo en una hoja de cálculo y ordenar las cosas allí? Tal vez... pero sería increíblemente lento, tedioso y propenso a errores.Las bases de datos relacionales están diseñadas para ser unidas. Cada tabla de la base de datos contiene datos de una forma o función específica. Por ejemplo, una tabla podría tener datos básicos sobre los clientes de una compañía como el ID del cliente (un ID único que puede ser usado para identificar a cada cliente), nombre, edad, sexo, fecha de la primera compra y dirección. Mientras que una tabla separada mucho más grande almacena datos detallados a nivel de transacción - ID de transacción, fecha de transacción, ID de cliente, categoría de producto, ID de producto, unidades vendidas y precio.Un cliente determinado (o ID de cliente) podría tener cientos o incluso miles de transacciones, por lo que sería extremadamente redundante almacenar la información básica de ese cliente una y otra vez para cada fila de la tabla de transacciones. La tabla de transacciones debería ser sólo para datos relevantes para las transacciones. Tener demasiados datos superpuestos entre los cuadros es un despilfarro y puede afectar negativamente al rendimiento del sistema.Pero eso no significa que no nos preocupemos por los vínculos entre las tablas. Dada la especificidad de cada tabla, los análisis que sólo implican una unica tabla no suelen ser útiles. Los análisis interesantes provienen de conjuntos de datos que combinan múltiples tablas. Por ejemplo, podríamos querer segmentar las transacciones por edad o geografía. Para ello, necesitaríamos datos de ambas tablas. Y ahí es donde entra en juego el join ¿Cómo unimos?Cuando unimos dos tablas, las unimos mediante una característica seleccionada. Digamos que tenemos dos tablas. La primera, Empleado, lista el número de identificación único de un empleado, su nombre y cargo. La segunda, Venta, lista los datos de quién hizo qué venta adjuntando el número de identificación del empleado y las unidades vendidas a un número de venta único:SELECT * FROM Employee
SELECT * FROM SaleNuestras 2 tablas Empleado (izquierda) y Venta (derecha). (Omití los subrayados de los nombres de las columnas en mis gráficos para su legibilidad)Ahora unamos las dos tablas. Para unir las dos tablas, necesitamos elegir una columna (o combinación de columnas) que sirva como punto de intersección - llamemos a la columna elegida el índice de unión. Las entradas de la tabla que comparten el mismo valor para el índice de unión se unen entre sí. Tenga en cuenta que la intersección no tiene que ser uno a uno. Por ejemplo, Tony ha hecho 2 ventas, así que al unirse a las tablas, ambas ventas estarán vinculadas a Tony (también conocido como Employee ID 1).Cuando unimos las tablas, generalmente queremos que el índice de unión sea único. Si el índice de unión no fuera único, podrían ocurrir cosas extrañas. Por ejemplo, digamos que tenemos un segundo empleado llamado Tony (ejemplo en las tablas de abajo), y que es un vendedor mega estrella. Si en lugar de unirnos en "ID de empleado" unimos en "Nombre", entonces vincularíamos erróneamente las ventas de Tony la Megaestrella a mí, haciendo que mi bonificación sea demasiado alta:No se recomienda unir en columnas no únicasY Tony la Megaestrella también obtendría crédito por mis lamentables ventas (no es que lo necesite). Así que para evitar esto, unimos en una columna con valores únicos como "Employee ID" (eliminé a Tony la Megaestrella ya que sólo estaba allí para ilustrar lo que no se debía hacer, y sus increíbles éxitos me hicieron sentir indigno):La columna "Employee ID" proporciona el enlace entre las 2 tablasHay varios tipos de uniones SQL y no voy a entrar en los detalles de todos ellos aquí. En este ejemplo, usaremos un Left Join (unión izquierda), lo que significa que priorizamos las filas de la tabla de la izquierda. Así que nuestra salida incluirá cada fila de la tabla izquierda (la que tiene "Nombre" y "Título") independientemente de si hay una coincidencia con la tabla derecha - por lo tanto, los empleados que no han hecho una venta seguirán apareciendo en una fila de nuestro resultado, pero no habrá valores (NULLs para ser exactos) para las columnas "Número de venta" y "Unidades vendidas".Echemos un vistazo a nuestro resultado (estamos seleccionando sólo "Número de Venta" y "Unidades Vendidas" de la tabla de la derecha y clasificando por "ID del Empleado"):SELECT e.*, s.Sale_Number, s.Units_Sold
FROM Employee as e
LEFT JOIN Sale as s ON e.Employee_ID=s.Employee_ID
ORDER BY e.Employee_IDResultado de nuestra unión a la izquierdaLa salida de nuestra unión ahora incluye datos de ambas tablas. Los datos de ventas de Tony han sido vinculados sus datos de (gracias al Employee ID) al igual que los de Lisa. Fijemonos en dos cosas:Parece un poco repetitivo porque "ID de empleado", "Nombre" y "Título" se repiten tantas veces como el empleado tenga ventas. En realidad, no nos detendremos aquí. A continuación, lo más probable es que hagamos un group by para contar cuántas ventas hizo cada vendedor o calcular el promedio de unidades vendidas cada vez que el vendedor hizo una ventaEl ID del empleado 3 no está en la salida porque hicimos una unión a la izquierda y no había ninguna entrada para el ID del empleado 3 en la tabla de la izquierda. Por lo tanto, se omitió.Asi concluye nuestro breve ejemplo. Con suerte, esto te da una idea rudimentaria de por qué necesitamos las uniones y cómo funcionan.Puntos importantesLas tablas de la base de datos generalmente contienen información muy específica. Por lo tanto, los análisis significativos suelen combinar datos de múltiples tablas.Esto se logra a través de la operación de unión, que combina dos tablas haciéndolas coincidir en base a una columna específica.La columna utilizada para combinar las tablas debe contener sólo valores únicos.Existen varios tipos de uniones. La de este ejemplo es una unión a la izquierda, que devuelve cada fila de la tabla de la izquierda, haya o no coincidencia.
