Summary  
This chapter covers how to declare variables to store different data types, reassign their values, and access them via printing.

General domain of usage  
Grocery inventory management

**Utmärkt arbete** med att bemästra datatyper! Nästa steg är att utforska **hur man lagrar data i variabler**, ungefär som att organisera dina matvaror i rätt behållare. Detta gör din data **lättillgänglig** och enkel att hantera — avgörande för alla effektiva kodningsprojekt.

Titta på när Alex visar hur man lagrar data i variabler:

Låt oss omsätta detta i praktiken. Här tilldelar vi **olika typer av data** till variabler, där varje variabel representerar olika egenskaper hos en matvara.


# Storing different types of data in variables
item_name = "Banana"
item_price = 0.50
item_quantity = 100
in_stock = True

print("Item:", item_name)
print("Price: $", item_price)
print("Quantity:", item_quantity)
print("In stock:", in_stock)

Detta exempel visar hur enkelt du kan **komma åt och visa data** när den väl är lagrad i variabler. Observera hur varje variabeltyp (`string`, `float`, `integer`, `boolean`) har ett specifikt syfte i vår matvaru-analogi.

import unittest
import user_code
from io import StringIO
from contextlib import redirect_stdout
import importlib
import re


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 TestUserCode(unittest.TestCase):
    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s*:\s*', ':', text)
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    def test_item_name_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'item_name'),
            'item_name is declared',
            'Expected item_name to be defined.'
        )

    def test_item_name_correct(self):
        _dynamic_test(
            self,
            user_code.item_name == "Eggs",
            "item_name equals 'Eggs'",
            f"Expected item_name to equal 'Eggs', but got {user_code.item_name}."
        )

    def test_item_price_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'item_price'),
            'item_price is declared',
            'Expected item_price to be defined.'
        )

    def test_item_price_correct(self):
        _dynamic_test(
            self,
            user_code.item_price == 3.99,
            'item_price equals 3.99',
            f"Expected item_price to equal 3.99, but got {user_code.item_price}."
        )

    def test_item_stock_quantity_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'item_stock_quantity'),
            'item_stock_quantity is declared',
            'Expected item_stock_quantity to be defined.'
        )

    def test_item_stock_quantity_correct(self):
        _dynamic_test(
            self,
            user_code.item_stock_quantity == 120,
            'item_stock_quantity equals 120',
            f"Expected item_stock_quantity to equal 120, but got {user_code.item_stock_quantity}."
        )

    def test_in_stock_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'in_stock'),
            'in_stock is declared',
            'Expected in_stock to be defined.'
        )

    def test_in_stock_correct(self):
        _dynamic_test(
            self,
            isinstance(user_code.in_stock, bool) and user_code.in_stock is True,
            'in_stock is a boolean and equals True',
            f"Expected in_stock to be of type bool and equal to True, but got {user_code.in_stock} of type {type(user_code.in_stock)}."
        )

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

test_main.py

Python är ett högnivåspråk, tolkbaserat och allmänt programmeringsspråk. Till skillnad från språk som HTML, CSS och JavaScript, vilka huvudsakligen används inom webb­utveckling, kännetecknas Python av sin mångsidighet inom flera områden, inklusive mjukvaruutveckling, data science och back-end-utveckling. Denna kurs vägleder dig genom Pythons grundläggande koncept och ger dig färdigheter att skapa egna funktioner vid programmets slut.

I det här avsnittet utforskar du grunderna i Python, bekantar dig med din arbetsmiljö, utför enkla matematiska operationer och visar dina resultat.

I det här avsnittet får du lära dig hur du sparar objekt som tal och text
i datorns minne och hämtar dem med hjälp av namn. Dessutom får du en introduktion till textbearbetning
i Python.

I det här avsnittet kommer du att utforska datatypen boolean och lära dig hur den används för att utveckla program som reagerar på vissa villkor.

I det här avsnittet fortsätter du att lära dig om datatyper och upptäcker
hur olika attribut kan organiseras i en enda variabel med hjälp av listor, tupler och ordböcker.

I det här avsnittet lär du dig hur man skapar loopar i Python — en grundläggande färdighet
för att iterera genom listor, tupler och ordböcker.

För att avsluta denna introduktionskurs kommer du att utforska några inbyggda funktioner och sedan börja utveckla egna.

Vilket av dessa är ett korrekt sätt att skapa en variabel?

Försök att gissa vad denna kod kommer att göra.

Givet strängen `"Banana"`, vilken kod hämtar dess första tecken?

Lagra Data i Variabler

Lösning