Summary  
This chapter explains how to form compound Boolean conditions in Python using the logical operators `and`, `or`, and `not` to evaluate multiple criteria in a single expression.

General domain of usage  
Grocery store inventory management

Med din **förståelse för booleans** som grund, kommer vi nu att utforska hur man **kombinerar flera villkor** i Python. Denna färdighet gör det möjligt för dina program att fatta ännu **mer nyanserade beslut** genom att kontrollera flera kriterier samtidigt.
Se hur Alex kombinerar flera villkor för att fatta bättre beslut under arbetet i mataffären:

## Förståelse för kombinerade villkor

I Python kan du **kombinera villkor med logiska operatorer** såsom `and`, `or` och `not`. Dessa operatorer gör det möjligt att skapa sammansatta villkor som utvärderar flera booleska uttryck.

- `and`: returnerar `True` om båda villkoren är `True`;
- `or`: returnerar `True` om minst ett villkor är `True`;
- `not`: returnerar `True` om villkoret är `False` (och tvärtom).


### Exempel på tillämpning

Låt oss kombinera villkor för att kontrollera om en vara både är en färskvara **OCH** har stort lager med hjälp av operatorn `and`:

is_perishable = True
item_quantity = 110
perishable_highStockRisk = 100

# Combine two or more conditions
consider_discount = is_perishable and (item_quantity >= perishable_highStockRisk)

# Print the result
print("Is the item perishable and high in stock?", consider_discount)

Nu ska vi **kombinera villkor** för att kontrollera om en vara är antingen en säsongsvara **ELLER** om det är en högtidsvara med hjälp av `or`-operatorn:


seasonal_item = False
holiday_item = True

# Check if the item is seasonal or discounted
temporary_stock = seasonal_item or holiday_item

# Print the result
print("Is this a seasonal or holiday item?", temporary_stock) 

Slutligen, låt oss **kombinera villkor** för att kontrollera om en vara **INTE** behöver omprissättning med hjälp av `not`-operatorn:

is_perishable = True

# Check if the item is NOT perishable
long_shelf_life = not is_perishable

# Print the result
print("Does the item need to be sold quickly?", long_shelf_life) 

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


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)


def strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.strip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestPromotionEligibility(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?])\s*', r'\1 ', text)
        return text.strip()

    def test_moving_product_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'movingProduct') and user_code.movingProduct is True,
            "movingProduct is correctly set to True",
            f"Expected movingProduct to be True, got {getattr(user_code, 'movingProduct', None)}"
        )

    def test_promotion_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'promotion') and user_code.promotion is False,
            "promotion is correctly set to False",
            f"Expected promotion to be False, got {getattr(user_code, 'promotion', None)}"
        )

    def test_print_output(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("Is the item eligible for promotion? False")
        _dynamic_test(
            self,
            expected in output,
            "Print output matches expected format",
            f"Expected print output to be '{expected}', got '{output}'"
        )

    def test_or_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+or\s+', source) is not None,
            "'or' operator is used in the code",
            "Expected use of 'or' logical operator, but none found"
        )

    def test_not_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s*not\s*', source) is not None,
            "'not' operator is used in the code",
            "Expected use of 'not' logical operator, but none found"
        )


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.

Kombinera Villkor

Förståelse för kombinerade villkor

Exempel på tillämpning

Utdatakrav

Lösning