Python I. Ordenamiento de listas

 Fuente:edube.org

Ordenamiento Burbuja

Ahora que puedes hacer malabarismos con los elementos de las listas, es hora de aprender como ordenarlos. Se han inventado muchos algoritmos de clasificación, que difieren mucho en velocidad, así como en complejidad. Vamos a mostrar un algoritmo muy simple, fácil de entender, pero desafortunadamente, tampoco es muy eficiente. Se usa muy raramente, y ciertamente no para listas extensas.

Digamos que una lista se puede ordenar de dos maneras:

• Ascendente (o más precisamente, no descendente): si en cada par de elementos adyacentes, el primer elemento no es mayor que el segundo.
• Descendente (o más precisamente, no ascendente): si en cada par de elementos adyacentes, el primer elemento no es menor que el segundo.

En las siguientes secciones, ordenaremos la lista en orden ascendente, de modo que los números se ordenen de menor a mayor.

Aquí está la lista:

8

10

6

2

4

Intentaremos utilizar el siguiente enfoque: tomaremos el primer y el segundo elemento y los compararemos; si determinamos que están en el orden incorrecto (es decir, el primero es mayor que el segundo), los intercambiaremos; Si su orden es válido, no haremos nada. Un vistazo a nuestra lista confirma lo último: los elementos 01 y 02 están en el orden correcto, así como 8<10.

Ahora observa el segundo y el tercer elemento. Están en las posiciones equivocadas. Tenemos que intercambiarlos:

8

6

10

2

4

Vamos más allá y observemos los elementos tercero y cuarto. Una vez más, esto no es lo que se supone que es. Tenemos que intercambiarlos:

8

6

2

10

4

Ahora comprobemos los elementos cuarto y quinto. Si, ellos también están en las posiciones equivocadas. Ocurre otro intercambio:

8

6

2

4

10

El primer paso a través de la lista ya está terminado. Todavía estamos lejos de terminar nuestro trabajo, pero algo curioso ha sucedido mientras tanto. El elemento más grande, 10, ya ha llegado al final de la lista. Ten en cuenta que este es el lugar deseado para el. Todos los elementos restantes forman un lío pintoresco, pero este ya está en su lugar.

Ahora, por un momento, intenta imaginar la lista de una manera ligeramente diferente, es decir, de esta manera:

10

4

2

6

8

Observa - El 10 está en la parte superior. Podríamos decir que flotó desde el fondo hasta la superficie, al igual que las burbujas en una copa de champán. El método de clasificación deriva su nombre de la misma observación: se denomina ordenamiento de burbuja.

Ahora comenzamos con el segundo paso a través de la lista. Miramos el primer y el segundo elemento, es necesario un intercambio:

6

8

2

4

10

Tiempo para el segundo y tercer elemento: también tenemos que intercambiarlos:

6

2

8

4

10

Ahora el tercer y cuarto elementos, y la segunda pasada, se completa, ya que 8 ya está en su lugar:

6

2

4

8

10

Comenzamos el siguiente pase inmediatamente. Observe atentamente el primer y el segundo elemento: se necesita otro cambio:

2

6

4

8

10

Ahora 6 necesita ir a su lugar. Cambiamos el segundo y el tercer elemento:

2

4

6

8

10

La lista ya está ordenada. No tenemos nada más que hacer. Esto es exactamente lo que queremos.

Como puedes ver, la esencia de este algoritmo es simple: comparamos los elementos adyacentes y, al intercambiar algunos de ellos, logramos nuestro objetivo.

Codifiquemos en Python todas las acciones realizadas durante un solo paso a través de la lista, y luego consideraremos cuántos pases necesitamos para realizarlo. No hemos explicado esto hasta ahora, pero lo haremos pronto.

Ordenando una lista

¿Cuántos pases necesitamos para ordenar la lista completa?

Resolvamos este problema de la siguiente manera: introducimos otra variable, su tarea es observar si se ha realizado algún intercambio durante el pase o no. Si no hay intercambio, entonces la lista ya está ordenada, y no hay que hacer nada más. Creamos una variable llamada swapped, y le asignamos un valor de False para indicar que no hay intercambios. De lo contrario, se le asignará True.

>>my_list = [8, 10, 6, 2, 4]  # lista a ordenar

>>for i in range(len(my_list) - 1):  # necesitamos (5 - 1) comparaciones

>>    if my_list[i] > my_list[i + 1]:  # compara elementos adyacentes

>>        my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]  # Si terminamos aquí, tenemos que intercambiar elementos.

Deberías poder leer y comprender este programa sin ningún problema:

>>my_list = [8, 10, 6, 2, 4]  # lista a ordenar

>>swapped = True  # Lo necesitamos verdadero (True) para ingresar al bucle while.

>>while swapped:

>>    swapped = False  # no hay intercambios hasta ahora

>>   for i in range(len(my_list) - 1):

>>       if my_list[i] > my_list[i + 1]:

 >>          swapped = True  # ¡ocurrió el intercambio!

 >>           my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]

>>print(my_list)

>>>

[2, 4, 6, 8, 10]

LifeLines: Lineas de vida en Python

 Fuente: https://lifelines.readthedocs.io/en/latest/index.html

Líneas de vida¶

lifelines es una biblioteca completa de análisis de supervivencia, escrita en Python puro. Qué ¿Qué beneficios tienen las líneas de vida?

• Fácil instalación

• métodos de trazado interno

• API sencilla e intuitiva

• maneja datos censurados a derecha, izquierda e intervalo

• Contiene los modelos paramétricos, semiparamétricos y no paramétricos más populares

>>pip install lifelines # instalación de la librería
>>import matplotlib.pyplot as plt
>>import numpy as np
>>from lifelines import *

>>fig, axes = plt.subplots(3, 3, figsize=(13.5, 7.5))

>>kmf = KaplanMeierFitter().fit(T, E, label='KaplanMeierFitter')
>>wbf = WeibullFitter().fit(T, E, label='WeibullFitter')
>>exf = ExponentialFitter().fit(T, E, label='ExponentialFitter')
>>lnf = LogNormalFitter().fit(T, E, label='LogNormalFitter')
>>llf = LogLogisticFitter().fit(T, E, label='LogLogisticFitter')
>>pwf = PiecewiseExponentialFitter([40, 60]).fit(T, E, label='PiecewiseExponentialFitter')
>>ggf = GeneralizedGammaFitter().fit(T, E, label='GeneralizedGammaFitter')
>>sf = SplineFitter(np.percentile(T.loc[E.astype(bool)], [0, 50, 100])).fit(T, E, label='SplineFitter')

>>wbf.plot_survival_function(ax=axes[0][0])
>>exf.plot_survival_function(ax=axes[0][1])
>>lnf.plot_survival_function(ax=axes[0][2])
>>kmf.plot_survival_function(ax=axes[1][0])
>>llf.plot_survival_function(ax=axes[1][1])
>>pwf.plot_survival_function(ax=axes[1][2])
>>ggf.plot_survival_function(ax=axes[2][0])
>>sf.plot_survival_function(ax=axes[2][1])

Surpyval: Análisis de supervivencia en Python

Fuente: https://surpyval.readthedocs.io/en/latest/

 surpyval es una implementación del análisis de supervivencia en Python. La intención de esto era ver si realmente podía hacerlo y, por lo tanto, aprender mucho sobre análisis de supervivencia a lo largo del camino, pero también para que cada vez que se cree un modelo, pueda ser reutilizado por otros proyectos planificados para simulaciones de Monte Carlo (utilizadas en ingeniería de confiabilidad) y optimizaciones.

Una característica de surpyval que lo separa de otros paquetes de análisis de supervivencia es la forma intuitiva con la que se pueden pasar datos a los métodos de ajuste. Hay muchos formatos diferentes que se pueden utilizar para el análisis de supervivencia; surpyval maneja muchas de las formas imaginables en que puede almacenar sus datos. Esto se analiza en la pestaña de formato de datos.

Surpyval también es único en la forma en que permite estimar los parámetros. Con surpyval, puede utilizar cualquiera de los siguientes métodos para estimar los parámetros de su distribución de interés:

Métodos de modelado de SurPyval.

Método	Para/No Para	Observado	Censurado	Truncado
Máxima verosimilitud (MLE)	Paramétrico	Sí	Sí	Sí
Trazado de probabilidad (MPP)	Paramétrico	Sí	Sí	Limitado
Error cuadrático medio (MSE)	Paramétrico	Sí	Sí	Limitado
Método de los Momentos (MOM)	Paramétrico	Sí	No	No
Espaciado máximo del producto (MPS)	Paramétrico	Sí	Sí	No (planificado)
Kaplan-Meier	No paramétrico	Sí	Sólo derecho	Solo izquierda
Nelson-Aalen	No paramétrico	Sí	Sólo derecho	Solo izquierda
Fleming-Harrington	No paramétrico	Sí	Sólo derecho	Solo izquierda
Turnbull	No paramétrico	Sí	Sí	Sí

La mayoría de los demás paquetes de análisis de supervivencia se centran únicamente en el uso del MLE, o tal vez del diagrama de probabilidad. Este paquete surgió de la replicación del método de trazado de probabilidad utilizado históricamente en ingeniería y, a medida que avanzaba, se descubrió que hay muchas formas de estimar los parámetros de las distribuciones. El estimador de espaciado de productos es particularmente útil para distribuciones desplazadas o distribuciones finitamente acotadas.

SurPyval intenta utilizar la combinación de estos métodos para hacer posible la estimación de parámetros para cualquier distribución con combinaciones arbitrarias de observaciones, censura y truncamiento.

Convertirse en un analista de supervivencia competente depende en gran medida de tener una comprensión muy sólida de la censura, el truncamiento y las observaciones junto con una comprensión sólida de los diferentes tipos de distribuciones. Conocer y poder identificar situaciones como censuradas o truncadas en aplicaciones reales le garantizará que no cometa errores en su análisis. Esto puede resultar muy difícil de hacer. Esta documentación puede utilizarse como referencia para comprender los tipos de censura y truncamiento para que puedas identificar estas situaciones en tu trabajo. Además, tener un conocimiento profundo de los tipos de distribuciones utilizadas en el análisis de supervivencia le permitirá identificar el proceso que genera sus datos. Esto le permitirá seleccionar una distribución adecuada, si la hubiera, para resolver su problema. El análisis de supervivencia es extremadamente poderoso,y es una herramienta muy interesante, así que no te rindas, o si te rindes, haz las estadísticas de supervivencia al respecto.

Convertidor de divisas. EUR a USD

 

Python Essentials One. 2.4.1.1 Variables: cajas en forma de datos. Fuente: PI & OpenEDG

Hay muchas formas de ver el concepto de variable, esta es una de las formas mas didácticas de entenderlo.

¿Qué son las Variables?

Es justo que Python nos permite codificar literales, las cuales contengan valores numéricos y cadenas.

Ya hemos visto que se pueden hacer operaciones aritméticas con estos números: sumar, restar, etc. Esto se hará una infinidad de veces en un programa.

Pero es normal preguntar como es que se pueden almacenar los resultados de estas operaciones, para poder emplearlos en otras operaciones, y así sucesivamente.

¿Cómo almacenar los resultados intermedios, y después utilizarlos de nuevo para producir resultados subsecuentes?

Python ayudará con ello. Python ofrece "cajas" (contenedores) especiales para este propósito, estas cajas son llamadas variables - el nombre mismo sugiere que el contenido de estos contenedores puede variar en casi cualquier forma.

¿Cuáles son los componentes o elementos de una variable en Python?

• Un nombre.

• Un valor (el contenido del contenedor).

Comencemos con lo relacionado al nombre de la variable.

Las variables no aparecen en un programa automáticamente. Como desarrollador, tú debes decidir cuántas variables deseas utilizar en tu programa.

También las debes de nombrar.

Si se desea nombrar una variable, se deben seguir las siguientes reglas:

• El nombre de la variable debe de estar compuesto por MAYÚSCULAS, minúsculas, dígitos, y el carácter _ (guion bajo).

• El nombre de la variable debe comenzar con una letra.

• El carácter guion bajo es considerado una letra.

• Las mayúsculas y minúsculas se tratan de forma distinta (un poco diferente que en el mundo real - Alicia y ALICIA son el mismo nombre, pero en Python son dos nombres de variable distintos, subsecuentemente, son dos variables diferentes).

• El nombre de las variables no pueden ser igual a alguna de las palabras reservadas de Python (se explicará más de esto pronto).