### Trabajo con diccionarios anidados

Los diccionarios pueden almacenar otros diccionarios, lo cual es útil para representar datos jerárquicos como un sistema de archivos.

* Las claves son nombres de archivos o carpetas;
* `"file"` significa que el elemento es un archivo;
* Un diccionario anidado significa que el elemento es una carpeta.

Utilizar `items()` para iterar sobre los pares clave–valor.

file_system = {
    'home': {'resume.pdf': 'file', 'notes.txt': 'file'},
    'etc': {'config.yaml': 'file'}
}

for name, content in file_system.items():
    print(name, '->', content)

Utilizar `isinstance(content, dict)` para comprobar si un valor representa una carpeta:

file_system = {
    'home': {'resume.pdf': 'file'},
    'config.yaml': 'file'
}

for name, content in file_system.items():
    if isinstance(content, dict):
        print(name, 'is a folder')
    else:
        print(name, 'is a file')

import unittest

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestFileExists(unittest.TestCase):
    def test_file_in_nested_folder(self):
        """Checks if the function finds a file inside nested folders"""
        import user_code
        file_system = {
            "home": {
                "user": {
                    "documents": {
                        "resume.pdf": "file"
                    }
                }
            }
        }
        file_name = "resume.pdf"
        result = user_code.file_exists(file_system, file_name)
        expected_output = True
        failure_message = f"For input `({file_system}, '{file_name}')`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, result == expected_output, "The function correctly finds files in nested folders.", failure_message)

    def test_file_in_root(self):
        """Checks if the function finds a file located in the root directory"""
        import user_code
        file_system = {
            "config.yaml": "file",
            "hosts": "file"
        }
        file_name = "hosts"
        result = user_code.file_exists(file_system, file_name)
        expected_output = True
        failure_message = f"For input `({file_system}, '{file_name}')`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, result == expected_output, "The function correctly finds files in the root directory.", failure_message)
    
    def test_file_not_found(self):
        """Checks if the function correctly returns False when the file is missing"""
        import user_code
        file_system = {
            "home": {
                "user": {
                    "documents": {}
                }
            }
        }
        file_name = "notes.txt"
        result = user_code.file_exists(file_system, file_name)
        expected_output = False
        failure_message = f"For input `({file_system}, '{file_name}')`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, result == expected_output, "The function correctly returns `False` when a file is missing.", failure_message)
    
    def test_empty_file_system(self):
        """Checks if the function correctly handles an empty file system"""
        import user_code
        file_system = {}
        file_name = "config.yaml"
        result = user_code.file_exists(file_system, file_name)
        expected_output = False
        failure_message = f"For input `({file_system}, '{file_name}')`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, result == expected_output, "The function correctly handles an empty file system.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Adquiera una comprensión sólida de cómo las funciones estructuran la programación en Python. Domine la definición y llamada de funciones, el trabajo con argumentos, el manejo de valores de retorno y la creación de código flexible y eficiente utilizando recursión y expresiones lambda.

Explora qué son las funciones y por qué son esenciales en Python. Aprende a crear funciones, definir argumentos, manejar valores de retorno y utilizar funciones integradas de manera efectiva.

Aprenda cómo funcionan los argumentos posicionales y opcionales en Python. Cree funciones adaptables que gestionen diferentes entradas y mejoren la flexibilidad en su código.

Comprender cómo trabajar con argumentos arbitrarios y argumentos de palabra clave para manejar tamaños de entrada variables.
Aprender cómo estas técnicas hacen que las funciones sean más dinámicas y organizadas.

Descubra cómo los valores de retorno representan la salida de una función. Aprenda a retornar valores únicos o múltiples, utilizar None y explorar generadores para un control de flujo de datos más avanzado.

Descubre conceptos avanzados de funciones con recursión y funciones lambda. Aprende cómo la recursión resuelve problemas repetitivos y cómo las expresiones lambda permiten crear funciones concisas en una sola línea.

Desafío: Búsqueda Recursiva de Archivos

Trabajo con diccionarios anidados

Solución