Primeros pasos con Python. Instalación del entorno, paquetería, y un ejemplo con expresiones regulares y por supuesto TESTS.
Índice de contenidos
- 1. Consideraciones iniciales
- 2. Gestión de paquetes en Python y librerías externas
- 3. Librerías incluidas en el paquete estándar
- 4. Comenzando con el desarrollo
- 5. Conclusiones
- 6. Referencias
1. Consideraciones iniciales
Dado que la versión considerada como oficial es la 3.x, en este tutorial trabajaremos sobre la versión 3.6.0 de Python. De manera extraoficial la versión 2.7 está ampliamente extendida, y es posible que encontremos muchas aplicaciones que están escritas en esta versión o librerías específicas que no estén soportadas en la nueva versión.
Debemos tener en cuenta que entre ambas versiones hay un cambio de major, lo que supone que es bastante probable que tengamos que hacer modificaciones al código original si necesitamos que corra bajo la nueva versión o plantearnos el utilizar la 2.7.
No obstante, casi todo lo explicado en este tutorial es fácilmente extrapolable a ambas versiones.
El tutorial está escrito usando el siguiente entorno:
- Hardware: Portátil MacBook Pro Retina 15′ (2.5 Ghz Intel Core I7, 16GB DDR3).
- Sistema Operativo: macOS Sierra 10.12.2
- Entorno de desarrollo: PyCharm Professional 2017.1 EAP
- Python 3.6
1.1. Objetivo del tutorial
En este tutorial aprenderemos a instalar el intérprete Python y su gestión de paquetes.
Además, crearemos un pequeño script que reciba argumentos de ejecución, y cuyo propósito es validar el formato de un fichero CSV de entrada utilizando expresiones regulares.
1.2. Instalación de Python
Lo primero que debemos instalar es el propio Python. Para ello, algo tan simple como dirigirnos a su página web oficial y descargarnos el paquete instalable de la versión que nos interese y que corresponda a nuestro sistema. Podéis acceder directamente desde aquí.
En algunos sistemas, por ejemplo en máquinas que ejecuten alguna distribución de Linux ya contaremos con una instalación de Python. La manera más sencilla de saberlo es ejecutar el comando python3 --version
Si lo tenemos correctamente instalado podremos esperar un resultado similar a este:
2. Gestión de paquetes en Python y librerías externas
Existen multitud de librerías que podemos incorporar a nuestros desarrollos para aumentar la funcionalidad de una manera sencilla. Existen algunas integradas en el propio Python, y podemos consultar la documentación en: The Python Standard Library
El propio Python cuenta con una herramienta para la gestión de paquetes, llamada pip. Esta es la herramienta recomendada, aunque más adelante comentaremos una segunda alternativa.
2.1. pip
Esta es la herramienta recomendada para la instalación de paquetes. Para la misma de la herramienta podremos dirigirnos a su página oficial: pip. Este paso no será necesario para distribuciones de Python a partir de la versión 3.4, ya que pip está incluido como parte del paquete oficial, y por lo tanto ya lo tendremos instalado. En cualquier caso, podemos consultar la documentación oficial sobre la instalación de paquetes en Installing Python Modules.
Instalar un paquete (o librería) es tan sencillo como ejecutar el comando:
|
1 |
pip install <paquete> |
2.2. Macports
Podemos utilizar como alternativa específica para Mac la utilidad Macports. Esto nos servirá no sólo para este propósito, sino como gestor de paquetes en general. Para ello, necesitaremos tener instaladas las herramientas de XCode:
|
1 |
xcode-select --install |
Cuando contemos con ello, procedemos a instalar el gestor de paquetes macports desde: http://www.macports.org/ y por fin podremos instalar los paquetes de Python necesarios mediante:
|
1 |
sudo port install <paquete> |
3. Librerías incluidas en el paquete estándar
Disponemos de multitud de librerías incluidas en el paquete oficial, conocido como Python Standard Library (consultar en https://docs.python.org/3/library/). De las incluidas, las que utilizaremos en el tutorial son:
- unittest: desarrollo de test unitarios
- sys: parámetros y funciones del sistema. Especialmente útil a la hora de recuperar argumentos de ejecución, como veremos después.
- re: manejo de expresiones regulares
- argparse: parseo de argumentos
- logging: gestión de logs
- errno: errores estándar predefinidos
- cobertura: informe de lineas cubiertas por nuestros tests (incluye integración con el IDE y CLI)
4. Comenzando con el desarrollo
Todo desarrollo es la solución a un problema planteado. En nuestro caso, y para comenzar por algo muy sencillo, nos centraremos en validar el formato de un fichero para evitar problemas a la hora de procesarlo. Dicho fichero se recibirá como parámetro de la ejecución. En caso de error, se indicará su tipo y la línea del fichero para poder corregirlo.
El formato de nuestro fichero es muy sencillo:
<nombre>;<apellido(s)>;<teléfono>;<email>
donde <email> es un valor opcional.
4.1. Al turrón
Crearemos un primer test encargado de comprobar si la expresión regular que hemos diseñado acorde con el formato esperado se comporta de forma correcta.
Con fines didácticos y para ilustrar el trabajo con cadenas, tomaremos la aproximación inicial de validar el formato de cada campo por separado. La solución óptima pasa por validar el registro en su conjunto aprovechando toda la potencia de las expresiones regulares.
Al desarrollar mediante TDD, podemos comprobar que los errores en tiempo de ejecución (recordad que Python es interpretado), son bastante explicativos. Haciendo uso de la librería unittest incluida, obtendremos el siguiente código:
format_validator_test.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 |
""" Test for the different values of inputs to the regex validator """ import unittest from lesson_1.format_validator import FormatValidator # Test Suite in order to organize our tests by groups of functionality class FormatValidatorTest(unittest.TestSuite): class NameTests(unittest.TestCase): # Tests for Name string def test_ShouldPassWhenValidNameFormat(self): # given name_ok = "Yair SegundoNombre" validator = FormatValidator() # when validator.check_valid_name(name_ok) # then self.assertIsNone(validator.error, "Error detected") def test_ShouldFailWhenEmptyName(self): # given empty_name = "" validator = FormatValidator() # when validator.check_valid_name(empty_name) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Name is empty", "Not recognized empty name") def test_ShouldFailWhenNoneAsName(self): # given validator = FormatValidator() # when validator.check_valid_name(None) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Name is None", "Not recognized none name") def test_ShouldFailWhenNotValidName(self): # given ko_name = "_*(" validator = FormatValidator() # when validator.check_valid_name(ko_name) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Name error", "Not recognized name error") class SurnameTests(unittest.TestCase): # Tests for Surname string def test_ShouldPassWhenValidSurnameFormat(self): # given surname_ok = "Segura Albarracín" validator = FormatValidator() # when validator.check_valid_surname(surname_ok) # then self.assertIsNone(validator.error, "Error detected") def test_ShouldFailWhenEmptySurname(self): # given empty_surname = "" validator = FormatValidator() # when validator.check_valid_surname(empty_surname) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Surname is empty", "Not recognized empty surname") def test_ShouldFailWhenNoneAsSurname(self): # given validator = FormatValidator() # when validator.check_valid_surname(None) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Surname is None", "Not recognized none surname") def test_ShouldFailWhenNotValidSurname(self): # given ko_surname = "_*(" validator = FormatValidator() # when validator.check_valid_surname(ko_surname) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Surname error", "Not recognized surname error") class PhoneNumberTests(unittest.TestCase): # Tests for Phone number field def test_ShouldPassWhenValidPhoneFormat(self): # given phone_ok = "912345678" validator = FormatValidator() # when validator.check_valid_phone(phone_ok) # then self.assertIsNone(validator.error, "Error detected") def test_ShouldFailWhenEmptyPhone(self): # given empty_phone = "" validator = FormatValidator() # when validator.check_valid_phone(empty_phone) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Phone number is empty", "Not recognized empty phone number") def test_ShouldFailWhenNoneAsPhone(self): # given validator = FormatValidator() # when validator.check_valid_phone(None) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Phone number is None", "Not recognized none phone number") def test_ShouldFailWhenNotValidPhone(self): # given ko_phone = "_*(" validator = FormatValidator() # when validator.check_valid_phone(ko_phone) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Phone number error", "Not recognized phone number error") class EmailTests(unittest.TestCase): # Tests for Email field def test_ShouldPassWhenValidEmailFormat(self): # given email_ok = "foo@bar.com" validator = FormatValidator() # when validator.check_valid_email(email_ok) # then self.assertIsNone(validator.error, "Error detected") def test_ShouldPassWhenEmptyEmail(self): # given empty_email = "" validator = FormatValidator() # when validator.check_valid_email(empty_email) # then self.assertIsNone(validator.error, "Error detected") def test_ShouldPassWhenNoneAsEmail(self): # given validator = FormatValidator() # when validator.check_valid_email(None) # then self.assertIsNone(validator.error, "Error detected") def test_ShouldFailWhenNotValidEmail(self): # given ko_email = "foo.bar@com" validator = FormatValidator() # when validator.check_valid_email(ko_email) # then self.assertIsNotNone(validator.error, "No error found, but should!") self.assertEqual(validator.error, "Email error", "Not recognized email error") if __name__ == "__main__": unittest.main(FormatValidatorTest) # Executing our TestSuite |
Y la clase que hace pasar los tests:
format_validator.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
""" Format validation using regular expressions """ import re class FormatValidator(object): def __init__(self): self.error = None self._text_regex = r"[A-Za-z\s]+" self._phone_regex = r"\d{9,9}" self._email_regex = r"[\w\d]+@[\w\d]+\.[\w\d]+" return def check_valid_name(self, name: str) -> bool: return self.__check_field(name, self._text_regex, "Name") def check_valid_surname(self, surname: str) -> bool: return self.__check_field(surname, self._text_regex, "Surname") def check_valid_phone(self, phone_number: str) -> bool: return self.__check_field(phone_number, self._phone_regex, "Phone number") def check_valid_email(self, email: str) -> bool: if email is None or email is "": return True return self.__check4regex(pattern=self._email_regex, text=email, checked_field="Email") def __check_field(self, field: str, pattern: str, field_name: str) -> bool: if self.__check_input(text=field, checked_field=field_name): return self.__check4regex(pattern=pattern, text=field, checked_field=field_name) def __check_input(self, text: str, checked_field: str) -> bool: if text is None: self.error = ("{} is None".format(checked_field)) return False elif text == "": self.error = ("{} is empty".format(checked_field)) return False return True def __check4regex(self, pattern, text, checked_field: str) -> bool: if re.match(pattern=pattern, string=text) is None: self.error = ("{} error".format(checked_field)) return False return True |
Como consecuencia del diseño con TDD, obtenemos una cobertura de test muy alta, en este caso concreto, del 100%.
4.2. Trabajando con parámetros de entrada
Ahora que ya tenemos nuestra pieza de validación, lo único que nos queda por hacer es recibir un fichero como parámetro y hacer pasar su contenido por nuestro validador. Para ello, lo primero es poder tratar los parámetros de entrada.
Python provee una librería para estos menesteres, y mediante la cual podemos conseguir un resultado bastante profesional: argparse.
El código final, con su informe de cobertura:
file_check_test.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
""" Test for the main program """ import errno import unittest from file_check import FileCheck # Test Suite in order to organize our tests by groups of functionality class FileCheckTest(unittest.TestSuite): class ParsingTests(unittest.TestCase): def test_ArgumentModelCreationOK(self): # given fc = FileCheck() # when # then self.assertIsNotNone(fc._args, "Object not initialized") self.assertTrue("file" in fc._args) def test_shouldFailWhenFileIsNone(self): # given fc = FileCheck() # when with self.assertRaises(SystemExit) as cm: fc.check_file() # then self.assertEqual(cm.exception.code, errno.EINVAL) def test_shouldFailWhenFileIsDirectory(self): # given fc = FileCheck() fc.file = "/" # when with self.assertRaises(SystemExit) as cm: fc.check_file() # then self.assertEqual(cm.exception.code, errno.EISDIR) def test_shouldFailWhenFileNotExist(self): # given fc = FileCheck() fc.file = "test_file.csv" # when with self.assertRaises(SystemExit) as cm: fc.check_file() # then self.assertEqual(cm.exception.code, errno.ENOENT) def test_shouldPassWhenCorrectFile(self): # given fc = FileCheck() fc.file = "test_ok.csv" # when # then self.assertTrue(fc.check_file()) def test_shouldFailWhenIncorrectFile(self): # given fc = FileCheck() fc.file = "test_ko.csv" # when # then self.assertFalse(fc.check_file()) if __name__ == "__main__": unittest.main(FileCheckTest) # Executing our TestSuite |
file_check.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
""" Document validation against predefined format """ import argparse import csv import errno from pathlib import Path from format_validator import FormatValidator class FileCheck(object): def __init__(self): self.file = None # Parsing arguments of the invocation self.parser = argparse.ArgumentParser(description='Check csv file against predefined format') self.parser.add_argument('--file', help='file location') self._args = self.parser.parse_args() self.file = self._args.file def check_file(self) -> bool: if self.file is None: exit(errno.EINVAL) path = Path(str(self.file)) if not path.exists(): exit(errno.ENOENT) elif path.is_dir(): exit(errno.EISDIR) # File correct fv = FormatValidator() with open(str(self.file), newline="") as csv_file: reader = csv.reader(csv_file, delimiter=";", quotechar="|") for row in reader: if not fv.check_valid_name(row[0]) or not fv.check_valid_surname(row[1]) \ or not fv.check_valid_phone(row[2]) or not fv.check_valid_email(row[3]): return False return True if __name__ == "__main__": fc = FileCheck() if fc.check_file(): print("File format is valid") exit(0) else: print("File format not compliant") exit(1) |
5. Conclusiones
Como habéis podido comprobar es tremendamente sencillo crear una aplicación desde 0 con este lenguaje. Además, el mismo lenguaje puede ser utilizado como script, orientado a objetos y según el paradigma de programación funcional.
Hay una comunidad muy activa de desarrolladores y un sin fin de librerías externas que nos permitiran aumentar su funcionalidad.
En futuros tutoriales ampliaremos el uso de Python en tareas de automatización, machine learning, etc.
El código fuente está disponible en el siguiente repositorio: https://github.com/ysegalb/python-tutorial.git
El mismo repositorio irá creciendo con las nuevas lecciones que vayamos añadiendo.
5.1. Deberes para casa
Hay muchas mejoras y “peoras” que podemos hacer con este ejemplo para cacharrear con el lenguaje. Desde aquí os animamos a trabajar los siguientes cambios para que profundicéis un poco más en este lenguaje:
- Modificar el tratamiento de csv a fichero de texto y validar mediante una única expresión regular
- Modificar la expresión regular para que el correo sea de un dominio específico (p.e. @autentia.com)
- Añadir un nuevo campo URL opcional al fichero y validarlo
- Mejorar la expresión regular correspondiente al e-mail
- Todo aquello que se os ocurra para «divertiros» con este lenguaje
6. Referencias
El tutorial se ha escrito desde cero, partiendo de la documentación oficial y las referencias ahí incluidas.
[…] de más aprender las cosas básicas de un lenguage tan conocido como Python. Podéis empezar por aquí o por […]