### Arbeta med nästlade ordböcker

Ordböcker kan lagra andra ordböcker, vilket är användbart för att representera hierarkisk data som ett filsystem.

* Nycklar är fil- eller mappnamn;
* `"file"` betyder att objektet är en fil;
* En nästlad ordbok betyder att objektet är en mapp.

Använd `items()` för att iterera genom nyckel–värde-par.

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

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

Använd `isinstance(content, dict)` för att kontrollera om ett värde representerar en mapp:

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

Få en gedigen förståelse för hur funktioner formar Python-programmering. Bemästra att definiera och anropa funktioner, arbeta med argument, hantera returvärden samt skapa flexibel och effektiv kod med rekursion och lambda-uttryck.

Utforska vad funktioner är och varför de är viktiga i Python. Lär dig hur man skapar funktioner, definierar argument, hanterar returvärden och använder inbyggda funktioner effektivt.

Lär dig hur positionella och valfria argument fungerar i Python. Skapa anpassningsbara funktioner som hanterar olika indata och förbättrar flexibiliteten i din kod.

Förstå hur man arbetar med godtyckliga och nyckelordsargument för att hantera variabla inmatningsstorlekar. Lär dig hur dessa tekniker gör dina funktioner mer dynamiska och organiserade.

Upptäck hur returvärden representerar en funktions utdata. Lär dig att returnera enstaka eller flera värden, använda None samt utforska generatorer för mer avancerad styrning av dataflöde.

Lås upp avancerade funktionskoncept med rekursion och lambda-funktioner. Lär dig hur rekursion löser repetitiva problem och hur lambda-uttryck skapar koncisa, enradiga funktioner.

Utmaning: Rekursiv Filsökning

Arbeta med nästlade ordböcker

Lösning