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

This chapter covers Python **membership operators**, which let you check if an item or substring exists within data structures like strings, lists, or tuples. Membership operators are essential for searching and filtering data.

**Membership operators** in Python, `in` and `not in`, let you check if a value exists within an **iterable object**. An iterable object is any data structure you can loop over, such as a string, list, or tuple.

- Use `in` to check if an item is present in an iterable;
- Use `not in` to check if an item is absent from an iterable.

Both operators always return a **boolean** value: `True` if the condition is met, `False` if not.

For example, you can check if a substring appears inside a string, or if an element is in a list or tuple. This is a simple, direct way to test for membership in Python.

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

## Example Application

Imagine you're managing the **product descriptions** or **categories** in your grocery store system. You might receive a long string of product details, and you need to quickly **check for specific keywords** to categorize or highlight products based on customer preferences or promotional activities:


# 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 is a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

Membership Operators

Example Application

解答