Summary
This chapter explains how to use Python’s membership operators, `in` and `not in`, to test whether a value or substring exists within an iterable (like a string, list, or tuple), returning a Boolean result.

General domain of usage
Grocery store product categorization

Dette kapitel omhandler Pythons **membership operators** (medlemskabsoperatorer), som gør det muligt at kontrollere, om et element eller en understreng findes i datastrukturer som strenge, lister eller tupler. Medlemskabsoperatorer er vigtige til søgning og filtrering af data.

**Membership operators** i Python, `in` og `not in`, gør det muligt at kontrollere, om en værdi findes i et **itererbart objekt**. Et itererbart objekt er enhver datastruktur, som kan gennemløbes, såsom en streng, liste eller tuple.

- Brug `in` for at kontrollere, om et element er til stede i et itererbart objekt;
- Brug `not in` for at kontrollere, om et element ikke er til stede i et itererbart objekt.

Begge operatorer returnerer altid en **boolean** værdi: `True` hvis betingelsen er opfyldt, `False` hvis ikke.

For eksempel kan du kontrollere, om en understreng findes i en streng, eller om et element findes i en liste eller tuple. Dette er en enkel og direkte metode til at teste medlemskab i Python.

itemName = "Strawberries"
in_name = "Straw" in itemName
print("Is 'Straw' in 'Strawberries'?", in_name) 

## Eksempel på anvendelse

Forestil dig, at du administrerer **produktbeskrivelser** eller **kategorier** i dit supermarkedssystem. Du kan modtage en lang streng med produktdetaljer, og du skal hurtigt **tjekke for specifikke nøgleord** for at kategorisere eller fremhæve produkter baseret på kundernes præferencer eller kampagneaktiviteter:


# Product description from supplier
product_description = "Fresh organic milk from local farms, pasteurized and homogenized."

# Check if the "organic" and "local" keywords are in the product description
is_organic = "organic" in product_description
is_local = "local" in product_description

# Print the presence of these keywords to decide on marketing strategies
print("Is the product organic?", is_organic)
print("Is the product locally sourced?", is_local)

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 TestProductMembershipOnly(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_contains_raw_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'contains_raw') and user_code.contains_raw is True,
            "contains_raw is True as 'raw' is in the description",
            f"Expected contains_raw to be True, got {getattr(user_code, 'contains_raw', None)}"
        )

    def test_contains_Imported_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'contains_Imported') and user_code.contains_Imported is True,
            "contains_Imported is True as 'Imported' is in the description",
            f"Expected contains_Imported to be True, got {getattr(user_code, 'contains_Imported', None)}"
        )

    def test_print_output(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected_fragments = [
            self.normalize_text("Contains 'raw': True"),
            self.normalize_text("Contains 'Imported': True")
        ]
        for expected in expected_fragments:
            _dynamic_test(
                self,
                expected in output,
                f"Print output includes: {expected}",
                f"Expected output to include: '{expected}', but got: '{output}'"
            )

    def test_only_membership_variables(self):
        importlib.reload(user_code)
        forbidden_vars = [
            'price_is_float',
            'count_is_int'
        ]
        for var in forbidden_vars:
            _dynamic_test(
                self,
                not hasattr(user_code, var),
                f"Variable {var} is not present in user code",
                f"Variable {var} should not be present in user code"
            )

    def test_membership_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\\bin\\b', source),
            "Membership operator 'in' used for both 'raw' and 'Imported'",
            "Expected use of 'in' operator for 'raw' and 'Imported'"
        )

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


test_main.py

Python er et højniveau, fortolket, generelt anvendeligt programmeringssprog. I modsætning til sprog som HTML, CSS og JavaScript, der primært anvendes til webudvikling, udmærker Python sig ved sin alsidighed på tværs af flere domæner, herunder softwareudvikling, datavidenskab og back-end udvikling. Dette kursus vil guide dig gennem Pythons grundlæggende koncepter og give dig færdighederne til at oprette dine egne funktioner ved programmets afslutning.

I dette afsnit vil du udforske grundlæggende Python, blive fortrolig med dit arbejdsområde, udføre simple matematiske operationer og vise dine resultater.

I dette afsnit vil du lære, hvordan man gemmer elementer såsom tal og tekst
i computerens hukommelse og henter dem ved navn. Derudover får du en introduktion til tekstmanipulation i Python.

I dette afsnit vil du udforske den booleske datatypen og lære, hvordan den anvendes til at udvikle programmer, der reagerer på bestemte betingelser.

I dette afsnit fortsætter du med at lære om datatyper og opdager,
hvordan man organiserer forskellige attributter i en enkelt variabel ved hjælp af lister, tupler og ordbøger.

I dette afsnit lærer du, hvordan man opretter løkker i Python — en essentiel færdighed til at iterere gennem lister, tupler og ordbøger.

For at afslutte dette introduktionskursus vil du udforske nogle indbyggede funktioner og derefter begynde at udvikle dine egne.

Medlemskabsoperatorer

Eksempel på anvendelse

Løsning