Breve introducción a la sintaxis de Python 3 | Parte 3

Esta es la ultima parte de esta introducción a la sintaxis de Python 3, a lo largo de estas 3 partes se muestran algunos de los comandos que mas comúnmente utilizo cuando escribo un código en Python para resolver problemas sugeridos en libros de estudiantes de ingeniería química. Hay muchas formas de escribir un código para un problema, solo espero que los publicados aquí, te sirvan como una guía para escribir los tuyos.

Funciones matemáticas

Python solo admite las siguientes funciones matemáticas:

abs(a)	Obtiene el valor absoluto de a
max(secuencia)	Obtiene el elemento mas grande de una secuencia
min(secuencia)	Obtiene el elemento mas pequeño de una secuencia
round(a,n)	Redondea a con n decimales
cmp(a,b)	$$regresa \left\{\begin{matrix}-1 &si &a <b \\ 0 &si &a = b \\ 1 &si &a>b \end{matrix}\right.$$

La mayoría de las funciones matemáticas están disponibles en la librería matemática math.

Entrada de lectura

La función empleada para aceptar una entrada del usuario es

input(aviso)

Muestra el mensaje y luego lee una línea de entrada que se convierte en una cadena. Para convertir la cadena en un valor numérico, use la función

eval(cadena)

El siguiente programa ilustra el uso de estas funciones:

1. a = input('Introduce a: ')
2. print(a, type(a)) # Mostrar a y su tipo
3. b = eval(a)
4. print(b,type(b)) # Mostrar b y su tipo

La función type(a) devuelve el tipo del objeto a; es una herramienta muy útil en la depuración.
Introduce a: 11**2
11**2 <class ’str’>
121 <class ’int’>
Para este ejemplo se introdujo 11**2, con ayuda de input(), notamos que para el primer resultado que mostró Python interpreto la entrada como una cadena, y cuando se aplica la función eval(), lo convirtió a un valor numérico y realizo la operación de $11^{2} = 121$. Una forma conveniente de ingresar un número y asignarlo a la variable a es

a = eval(input(aviso))

Impresión de resultados

La salida de resultados se puede mostrar con la función print()

print(objeto1,objeto2,...)

esta convierte objeto1, objeto2, etc., en cadenas y las imprime en la misma línea, separadas por espacios. El carácter de nueva línea '\ n' se puede usar para forzar una nueva línea. Por ejemplo,

1. >>> a = 1234.56789
2. >>> b = [2, 4, 6, 8]
3. >>> print(a,b) # Muestra continua la información
4. 1234.56789 [2, 4, 6, 8]
5. >>> print('a =',a, '\nb =',b) #Notamos que lo muestra en otro renglón
6. a = 1234.56789
7. b = [2, 4, 6, 8]

Se puede dar formato a la salida con el método de formato. La forma más simple de la declaración de conversión es

'{:fmt1}{:fmt2}...'.format(argum1,argum2,...)

donde fmt1, fmt2, ... son las especificaciones de formato para argumento1, argumento2, ..., respectivamente. Las especificaciones de formato utilizadas habitualmente son

wd	Entero
w.df	Notación de punto flotante
w.de	Notación exponencial

donde w es el ancho del campo y d es el número de dígitos después del punto decimal. La salida se justifica a la derecha en el campo especificado y se rellena con espacios en blanco (existen disposiciones para cambiar la justificación y el relleno). Aquí hay varios ejemplos:

1. >>> a = 1234.56789
2. >>> n = 9876
3. >>> print(’{:7.2f}’.format(a))
4. 1234.57
5. >>> print(’n = {:6d}’.format(n)) # Con espacios
6. n = 9876
7. >>> print(’n = {:06d}’.format(n)) # Con ceros
8. n =009876
9. >>> print(’{:12.4e} {:6d}’.format(a,n))
10. 1.2346e+03 9876

Abrir, cerrar y leer un archivo con Python

Antes de acceder a un archivo de datos en un dispositivo de almacenamiento (por ejemplo, un disco, una USB o en la PC), debe crear un objeto de archivo con el comando

objeto_archivo = open(nombre del archivo, acción)

donde nombre del archivo es una cadena que especifica el archivo que se abrirá (incluida su ruta si es necesario) y acción es una de las siguientes cadenas:

'r'	Leer de un archivo existente.
'w'	Escribir en un archivo. Si el nombre del archivo no existe, se crea.
'a'	Agregar al final del archivo.
'r+'	Leer y escribir desde un archivo existente.
'w+'	Igual que' r + ', pero el nombre de archivo se crea si no existe.
'a+'	Igual que "w +", pero los datos se agregan al final del archivo.

Es una buena práctica de programación cerrar un archivo cuando ya no se requiere acceso a él. Esto se puede hacer con el método

objeto_archivo.close()

Leer datos de un archivo
Hay tres métodos para leer datos de un archivo. El método

objeto_archivo.read(n)

lee n caracteres y los devuelve como una cadena. Si se omite n, se leen todos los caracteres del archivo.
Si solo se va a leer la línea actual, use

objeto_archivo.readline(n)

que lee n caracteres de la línea. Los caracteres se devuelven en una cadena que termina en el carácter de nueva línea \ n. La omisión de n hace que se lea toda la línea.
Todas las líneas en un archivo se pueden leer usando

objeto_archivo.readlines()

Esto devuelve una lista de cadenas, cada cadena es una línea del archivo que termina con el carácter de nueva línea.
Un método conveniente para extraer todas las líneas una por una es usar el bucle

for line in objeto_archivo                    hacer algo con line

Como ejemplo, supongamos que tenemos un archivo llamado sunspots.txt en el directorio de trabajo. Este archivo contiene datos diarios de la intensidad de las manchas solares, cada línea tiene el formato (año / mes / fecha / intensidad), como sigue:

1896 05 26 40.94

1896 05 27 40.58

1896 05 28 40.20

etc.

Nuestra tarea es leer el archivo y crear una lista x que contenga solo la intensidad. Como cada línea en el archivo es una cadena, primero dividimos la línea en sus partes usando el comando dividir. Esto produce una lista de cadenas, como ["1896", "05", "26", "40.94"].
Luego extraemos la intensidad (elemento [3] de la lista), la evaluamos y agregamos el resultado a x. Aquí está el algoritmo:

1. x = [] #Creamos una lista vacía
2. data = open(’sunspots.txt’,’r’) #Objeto de archivo
3. for line in data: #Ciclo for
4.    x.append(eval(line.split()[3]))
5. data.close() #Cerramos el archivo

Escribir datos en un archivo

El método

objeto_archivo.write(cadena)

escribe una cadena en un archivo, mientras que

objeto_archivo.writelines(lista de cadenas)

se usa para escribir una lista de cadenas. Ninguno de los métodos agrega un carácter de nueva línea al final de una línea. Como ejemplo, escribamos una tabla formateada de $k$ y $k^{2}$ desde $k = 101$ hasta $110$ en el archivo llamado 'cuadrados'. El programa seria el siguiente:

1. f = open('cuadrados.txt','w') #Se crea el archivo
2. for k in range(101,111): #Ciclo for
3.    f.write('{:4d} {:6d}'.format(k,k**2)) #Escribe la información con formato
4.    f.write('\n') #Pedimos que pase al siguiente renglón
5. f.close() #Cerramos el archivo

Si deseas probar el código, te recomiendo guardar primero el archivo de Python en el escritorio, ya que el archivo resultante lo mandara a la misma dirección donde lo guardaste, a menos que especifiques otra. El resultado seria el siguiente:

La función de impresión también se puede utilizar para escribir en un archivo redirigiendo la salida a un objeto de archivo:

print(objeto1,objeto2,..., file=objeto_archivo)

Además de la redirección, esto funciona igual que la función de impresión normal.
Se puede trabajar varias extensiones de archivos, personalmente utilizo mas frecuentemente la extensión .csv, la cual puede ser abierta con Excel.

Detección de errores

Cuando se produce un error durante la ejecución de un programa, se genera una excepción y el programa se detiene. Se pueden detectar excepciones con las declaraciones try y except:

try:                    hacer algo con         except error:              hacer algo else

donde error es el nombre de una excepción incorporada en Python. Si no se genera el error de excepción, se ejecuta el bloque try; de lo contrario, la ejecución pasa al bloque excepto. Todas las excepciones se pueden detectar omitiendo el error de la declaración except.
La siguiente declaración plantea la excepción ZeroDivisionError (recuerda que esto ya esta incorporado para mostrarse cuando hay un error):

1. >>> c = 12.0/0.0
2. Traceback (most recent call last):
3.   File "<pyshell#0>", line 1, in <module>
4.     c=12.0/0.0
5. ZeroDivisionError: float division by zero

Este error puede ser detectado por

1. try:
2.     c = 12.0/0.0
3. except ZeroDivisionError:
4.     print('División entre cero')

Librerías

Esta es una de las características que hacen que Python sea mi lenguaje de programación favorito, las librerías de Python son muy amplias. La facilidad para obtener las rutinas de las librerías y aplicarlas en unas cuantas lineas de código, hace que sea fácil de entender y legible, lo que nos permite que nos concentremos mas en que hace el programa y no tanto en especializarnos en computación, esto es ideal para el aprendizaje y permitirnos enfocarnos en resolver los problemas de nuestra ingeniería.

Existen miles de librerías, pero el sistema de empaquetamiento de este lenguaje permite construir librerías nuevas sobre las ya existentes para que estas sean más amplias y potentes. Ademas, es importante destacar que la capacidad de combinar librerías  como NumPy y ScyPi, permite que Python sea uno de los lenguajes con mejor rendimiento para realizar proyectos de machine learning y data science. Gracias a esta razón, es que se a visto acelerado el crecimiento de Python.

Las siguientes son algunas de las librerías de uso mas común que encontraremos.

Como usar una librería

Utilizamos la librería o modulo math para ilustrar como puede llamarse a una librería. La mayoría de las funciones matemáticas no están integradas en Python principal, pero están disponibles al cargar el módulo matemático math. Hay tres formas de acceder a las funciones en un módulo.
La declaración

from math import *

carga todas las definiciones de funciones en el módulo matemático en la función o módulo actual. Se desaconseja el uso de este método porque no solo es un desperdicio, sino que también puede generar conflictos con definiciones cargadas desde otros módulos. Por ejemplo, hay tres definiciones diferentes de la función seno en los módulos de Python math, cmath y numpy. Si ha cargado dos o más de estos módulos, no está claro qué definición se usará en la función llamada sin (x) (es la definición en el módulo que se cargó por última vez).
Un método más seguro pero de ninguna manera infalible es cargar las definiciones seleccionadas con la declaración

from math import funcion1, funcion2, ...

como se ilustra a continuación:

1. >>> from math import log,sin # Importamos funciones especificas de la librería
2. >>> print(log(sin(0.5))) #Utilizamos las funciones
3. -0.735166686385

Los conflictos se pueden evitar por completo haciendo primero accesible el módulo con la declaración

import math

y luego acceder a las definiciones en el módulo utilizando el nombre del módulo como prefijo. Aquí hay un ejemplo:

1. >>> import math
2. >>> print(math.log(math.sin(0.5)))
3. -0.735166686385

Un módulo también se puede hacer accesible bajo un alias. Por ejemplo, el módulo math puede estar disponible bajo el alias m, o el que tu quieras, es un alias, como se muestra a continuación

import math as m

Ahora el prefijo a usar es m en lugar de math:

1. >>> import math as m
2. >>> print(m.log(m.sin(0.5)))
3. -0.735166686385

El contenido de un módulo puede imprimirse llamando a dir(nombre del módulo). Aquí puede obtener una lista de las funciones en el módulo matemático math:

1. >>> import math
2. >>> dir(math)
3. [’__doc__’, ’__name__’, ’acos’, ’asin’, ’atan’,
4. ’atan2’, ’ceil’, ’cos’, ’cosh’, ’e’, ’exp’, ’fabs’,
5. ’floor’, ’fmod’, ’frexp’, ’hypot’, ’ldexp’, ’log’,
6. ’log10’, ’modf’, ’pi’, ’pow’, sign’, sin’, ’sinh’,
7. ’sqrt’, ’tan’, ’tanh’]

La mayoría de estas funciones son familiares para los programadores. Tenga en cuenta que el módulo incluye dos constantes: $π$ y $e$.

Módulo cmath

El módulo cmath proporciona muchas de las funciones que se encuentran en el módulo matemático, pero estas funciones aceptan números complejos. Las funciones en el módulo son

1. [’__doc__’, ’__name__’, ’acos’, ’acosh’, ’asin’, ’asinh’,
2. ’atan’, ’atanh’, ’cos’, ’cosh’, ’e’, ’exp’, ’log’,
3. ’log10’, ’pi’, ’sin’, ’sinh’, ’sqrt’, ’tan’, ’tanh’]

Módulo numpy

El módulo numpy no forma parte de la versión estándar de Python. Como se señaló anteriormente, debe instalarse por separado (la instalación es muy fácil). Este módulo introduce objetos de matriz que son similares a las listas, pero pueden ser manipulados por numerosas funciones contenidas en el módulo. El tamaño de una matriz es inmutable y no se permiten elementos vacíos.
El conjunto completo de funciones en numpy es demasiado largo para imprimirse en su totalidad. La siguiente lista está limitada a las funciones más utilizadas.

1. [’complex’, ’float’, ’abs’, ’append’, arccos’,
2. ’arccosh’, ’arcsin’, ’arcsinh’, ’arctan’, ’arctan2’,
3. ’arctanh’, ’argmax’, ’argmin’, ’cos’, ’cosh’, ’diag’,
4. ’diagonal’, ’dot’, ’e’, ’exp’, ’floor’, ’identity’,
5. ’inner, ’inv’, ’log’, ’log10’, ’max’, ’min’,
6. ’ones’, ’outer’, ’pi’, ’prod’ ’sin’, ’sinh’, ’size’,
7. ’solve’, ’sqrt’, ’sum’, ’tan’, ’tanh’, ’trace’,
8. ’transpose’, ’vectorize’,’zeros’]

Trazado con matplotlib.pyplot

El módulo matplotlib.pyplot es una colección de funciones de trazado 2D que proporcionan a Python una funcionalidad de estilo MATLAB. Al no ser parte del núcleo de Python, requiere una instalación por separado. Recuerda, que si instalaste Anaconda, este ya la trae incluida, si quieres saber que librerías ya tienes instaladas, ve a Anaconda Prompt y escribe pip list. El siguiente programa, que traza funciones seno y coseno, ilustra la aplicación del módulo a trazados xy simples.

1. import matplotlib.pyplot as plt
2. from numpy import arange,sin,cos
3. x = arange(0.0,6.2,0.2) # Se crea un arreglo con numpy
4. plt.plot(x,sin(x),'o-',x,cos(x),'^-')
5. # Gráfica con estilo especifico de linea y marcador
6. plt.xlabel('x') # Agrega etiqueta al eje x
7. plt.legend(('seno','coseno'),loc = 0)
8. # Agrega una leyenda en la localización 0,0
9. plt.grid(True)
10. # Agrega una malla
11. plt.savefig('testplot.png',format='png') # Guardar el gráfico en .png
12. # formato para un futuro uso
13. plt.show() # Mostrar el gráfico en la pantalla
14. input("\nPresiona enter para salir")

La ejecución del programa produce la siguiente pantalla:

Es posible tener más de un gráfico en una figura, como lo demuestra el siguiente código:

1. import matplotlib.pyplot as plt
2. from numpy import arange,sin,cos
3. x = arange(0.0,6.2,0.2) # Se crea un arreglo
4. plt.plot(x,sin(x),'o-',x,cos(x),'^-')
5. # Grafica con estilo especifico de linea y marcador
6. plt.subplot(2,1,1)
7. plt.plot(x,sin(x),'o-')
8. plt.xlabel('x');plt.ylabel('sin(x)')
9. plt.grid(True)
10. plt.subplot(2,1,2)
11. plt.plot(x,cos(x),'^-')
12. plt.xlabel('x');plt.ylabel('cos(x)')
13. plt.grid(True)
14. plt.show()
15. input("\nPresiona enter para salir")

El comando subplot(filas, columnas, número de gráfico) establece una ventana de subplot dentro de la figura actual. Los parámetros fila y columna dividen la figura en rejilla fila × columna de subtramas (en este caso, dos filas y una columna). Las comas entre los parámetros pueden omitirse. El resultado de este programa anterior es

Hasta aquí concluye esta breve introducción, para mas informacion acerca de una librería, no dude en consultar su documentación oficial.

Referencias

• Python 3.8.2 documentation, recuperado de: https://docs.python.org/3/
• Guido van Rossum, (2017). El tutorial de Python, Python Software Foundation. Recuperado de: http://docs.python.org.ar/tutorial/