### Working with Nested Dictionaries

Dictionaries can store other dictionaries, which is useful for representing hierarchical data like a file system.

* Keys are file or folder names;
* `"file"` means the item is a file;
* A nested dictionary means the item is a folder.

Use `items()` to iterate through key–value pairs.

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

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

Use `isinstance(content, dict)` to check whether a value represents a folder:

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

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Learn how positional and optional arguments work in Python. Build adaptable functions that handle different inputs and improve flexibility in your code.

Understand how to work with arbitrary and keyword arguments to handle variable input sizes. Learn how these techniques make your functions more dynamic and organized.

Discover how return values represent a function's output. Learn to return single or multiple values, use None, and explore generators for more advanced data flow control.

Unlock advanced function concepts with recursion and lambda functions. Learn how recursion solves repetitive problems and how lambda expressions create concise, one-line functions.

Challenge: Recursive File Search

Working with Nested Dictionaries

Solution