Diferencias

Muestra las diferencias entre dos versiones de la página.

--- informatica:programacion:python:cursos:introduccion_programacion_python:ejemplos_practicos [2023/04/27 10:02] – [Testing: Pruebas unitarias] tempwin
+++ informatica:programacion:python:cursos:introduccion_programacion_python:ejemplos_practicos [2023/04/28 11:47] (actual) – [JSON en Python] tempwin
@@ Línea 420: / Línea 420: @@
 </code>
-==== Testing: Pruebas unitarias =====
+===== Testing: Pruebas unitarias =====
 Usaremos el módulo [[https://docs.python.org/3/library/unittest.html|unittest]] para las pruebas unitarias en Python.
@@ Línea 497: / Línea 497: @@
         self.assertAlmostEqual(segundo_grado(2, 4, -6), (1, -3))
+    def test_ecuacion7(self):
+        self.assertAlmostEqual(segundo_grado(1, -1, -1), (1.618033988749895, -0.6180339887498949))
+    def test_ecuacion8(self):
 if __name__ == '__main__':
     unittest.main()
@@ Línea 502: / Línea 507: @@
 Si hacemos modificaciones en el código, los tests nos aseguran que todo siga funcionando correctamente o que el cambio que hemos hecho hace que no pasen los test. De esa manera, podremos detectar si algo hemos hecho mal.
+Además, al hacer tests, estamos dejando por escrito las pruebas que realizaremos en nuestro código.
 Para lanzar la batería de tests desde la línea de comandos:
+<code>
+python -m unittest test_segundo_grado.py
+</code>
+==== Conversión a números romanos ====
+Esta vez crearemos primero los tests y luego crearemos el código :
+<WRAP center round info 60%>
+**TDD** (//Test Driven Development//): técnica de desarrollo en la que primero se define el test y luego el código que debe satisfacer el test.
+</WRAP>
+Fichero ''test_romanos.py'':
+<code python>
+import unittest
+from romanos import roman
+class TestRomanos(unittest.TestCase):
+    def test_1(self):
+        self.assertEqual(roman(1), "I")
+    def test_2(self):
+        self.assertEqual(roman(2), "II")
+    def test_2(self):
+        self.assertEqual(roman(2), "II")
+    def test_3(self):
+        self.assertEqual(roman(3), "III")
+    def test_4(self):
+        self.assertEqual(roman(4), "IV")
+    def test_5(self):
+        self.assertEqual(roman(5), "V")
+    def test_6(self):
+        self.assertEqual(roman(6), "VI")
+    def test_7(self):
+        self.assertEqual(roman(7), "VII")
+    def test_9(self):
+        self.assertEqual(roman(9), "IX")
+    def test_10(self):
+        self.assertEqual(roman(10), "X")
+    def test_13(self):
+        self.assertEqual(roman(13), "XIII")
+    def test_14(self):
+        self.assertEqual(roman(14), "XIV")
+    def test_17(self):
+        self.assertEqual(roman(17), "XVII")
+    def test_19(self):
+        self.assertEqual(roman(19), "XIX")
+    def test_20(self):
+        self.assertEqual(roman(20), "XX")
+    def test_27(self):
+        self.assertEqual(roman(27), "XVII")
+    def test_33(self):
+        self.assertEqual(roman(33), "XXXIII")
+    def test_40(self):
+        self.assertEqual(roman(40), "XL")
+    def test_49(self):
+        self.assertEqual(roman(49), "XLIX")
+    def test_50(self):
+        self.assertEqual(roman(50), "L")
+    def test_62(self):
+        self.assertEqual(roman(62), "LXII")
+    def test_90(self):
+        self.assertEqual(roman(90), "XC")
+    def test_97(self):
+        self.assertEqual(roman(90), "XCVII")
+    def test_100(self):
+        self.assertEqual(roman(100), "C")
+    def test_333(self):
+        self.assertEqual(roman(333), "CCCXXXIII")
+    def test_400(self):
+        self.assertEqual(roman(400), "CD")
+    def test_500(self):
+        self.assertEqual(roman(500), "D")
+    def test_666(self):
+        self.assertEqual(roman(666), "DCLXVI")
+    def test_900(self):
+        self.assertEqual(roman(900), "CM")
+    def test_1000(self):
+        self.assertEqual(roman(1000), "M")
+    def test_1666(self):
+        self.assertEqual(roman(1666), "MDCLXVI")
+    def test_3999(self):
+        self.assertEqual(roman(3999), "MMMCMXCIX")
+if __name__ == '__main__':
+    unittest.main()
+</code>
+Creamos el programa ''romanos.py'':
+<code python>
+"""
+Romani ite domum!
+TDD - Test Driven Development
+. Escribir un test (que inicialmente falle)
+. Escribir el código que haga pasar el test
+. Refactorizar el código: optimización, limpieza, etc
+(Y vuelta a empezar...)
+"""
+def roman(n: int) -> str:
+    cantidades = [
+        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"),
+        (90, "XC"), (50, "L"), (40, "XL"), (10, "X"), (9, "IX"),
+        (5, "V"), (4, "IV"), (1, "I")
+    ]
+    conv = ""
+    for cant, letras in cantidades:
+        while n >= cant.
+            n -= cant
+            conv += letras
+    return conv
+</code>
+Opción con recursividad:
+<code python>
+def roman2(n: int) -> str:
+    if n >= 1000:
+        return "M" + roman2(n - 1000)
+    elif n >= 900:
+        return "CM" + roman2(n - 900)
+    elif n >= 500:
+        return "D" + roman2(n - 500)
+    elif n >= 400:
+        return "CD" + roman2(n - 400)
+    elif n >= 100:
+        return "C" + roman2(n - 100)
+    elif n >= 90:
+        return "XC" + roman2(n - 90)
+    elif n >= 50:
+        return "L" + roman2(n - 50)
+    elif n >= 40:
+        return "XL" + roman2(n - 40)
+    elif n >= 10:
+        return "XL" + roman2(n - 10)
+    elif n >= 9:
+        return "XL" + roman2(n - 9)
+    elif n >= 5:
+        return "V" + roman2(n - 5)
+    elif n >= 4:
+        return "IV" + roman2(n - 4)
+    elif n >= 1:
+        return "I" + roman2(n - 1)
+    else:
+        return ""
+</code>
+  * [[https://codewars.com|codewars]]: retos de programación
+===== JSON =====
+JSON (//JavaScript Object Notation//) formato para el intercambio de información.
+JSON no son más que objetos (que son equivalentes a los diccionarios de Python) y listas.
+Se trata de texto.
+  * https://www.json.org/json-en.html
+==== JSON en Python ====
+Aspecto de un JSON, que lo representamos como string:
+<code python>
+datos_json = '''
+{
+    "glossary": {
+        "title": "example glossary",
+        "GlossDiv": {
+            "title": "S",
+            "GlossList": {
+                "GlossEntry": {
+                    "ID": "SGML",
+                    "SortAs": "SGML",
+                    "GlossTerm": "Standard Generalized Markup Language",
+                    "Acronym": "SGML",
+                    "Abbrev": "ISO 8879:1986",
+                    "GlossDef": {
+                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
+                        "GlossSeeAlso": [
+                            "GML",
+                            "XML"
+                        ]
+                    },
+                    "GlossSee": "markup"
+                }
+            }
+        }
+    }
+}
+'''
+</code>
+  * [[https://docs.python.org/3/library/json.html|Tratamiento de JSON en Python (documentación oficial)]]
+<code python>
+# Biblioteca de Python para el tratamiento de JSON
+import json
+# Cargamos a partir de un string un objeto JSON/diccionario
+datos = json.loads(datos_json)
+type(datos) # dict
+datos.keys() # dict_keys(['glossary'])
+glossary = datos['glossary'] # dict
+glossary.keys() # dict_keys(['title', 'GlossDiv'])
+paises_capitales = {
+    "España": "Madrid",
+    "Portugal": "Lisboa",
+    "Italia": "Roma",
+    "Francia": "Paris",
+    "Alemania": "Berlin"
+}
+type(paises_capitales) # dict
+# Si queremos pasar de un diccionario a string en formato JSON
+json.dumps(paises_capitales)
+</code>
+  * [[https://jsonviewer.stack.hu/|Online JSON Viewer]]
+Si procesamos un JSON inválido:
+<code python>
+mal_json = '''
+{"mal": "json"
+'''
+try:
+    json.loads(mal_json)
+except json.JSONDecodeError as error:
+    print("Error cargando JSON")
+</code>
+disculpa, Jairo, sabes hasta qué día tenemos disponible el acceso al campus virtual?