Summary  
Demonstrates how to combine logical operators to evaluate multiple conditions simultaneously and nest these tests within conditional statements to implement complex decision logic.

General domain of usage  
Spreadsheet data analysis

Die Verwendung von `AND` und `OR` ermöglicht **anspruchsvollere logische Prüfungen**, indem **mehrere Bedingungen** kombiniert werden. 

## Wichtige Punkte

- Die **Funktion** `AND` wird verwendet, um zu prüfen, ob **alle** Bedingungen erfüllt sind, zum Beispiel: `=AND(condition1, condition2,...)`;
- Die **Funktion** `OR` wird verwendet, um zu prüfen, ob **mindestens eine** Bedingung erfüllt ist, zum Beispiel: `=OR(condition1, condition2, ...)`.

Anfangsarbeitsmappe

import unittest
import json
import os
import zipfile
import xml.etree.ElementTree as ET


# ── stdlib xlsx reader (no third-party packages) ───────────────────────────────

_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"


def _col_to_letter(col):
    result = ""
    col += 1
    while col > 0:
        col, rem = divmod(col - 1, 26)
        result = chr(ord("A") + rem) + result
    return result


def _read_xlsx_cells(filename):
    cells = {}
    with zipfile.ZipFile(filename) as z:
        names = z.namelist()
        shared_strings = []
        if "xl/sharedStrings.xml" in names:
            ss = ET.parse(z.open("xl/sharedStrings.xml")).getroot()
            for si in ss.findall(f"{{{_NS}}}si"):
                t = si.find(f"{{{_NS}}}t")
                if t is not None:
                    shared_strings.append(t.text or "")
                else:
                    shared_strings.append(
                        "".join(e.text or "" for e in si.iter(f"{{{_NS}}}t"))
                    )

        sheet_path = "xl/worksheets/sheet1.xml"
        try:
            wb = ET.parse(z.open("xl/workbook.xml")).getroot()
            rels = ET.parse(z.open("xl/_rels/workbook.xml.rels")).getroot()
            first_sheet = wb.find(f"{{{_NS}}}sheets/{{{_NS}}}sheet")
            if first_sheet is not None:
                r_id = first_sheet.get(
                    "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id"
                )
                for rel in rels.findall(f"{{{_REL_NS}}}Relationship"):
                    if rel.get("Id") == r_id:
                        target = rel.get("Target").lstrip("/")
                        sheet_path = target if target.startswith("xl/") else "xl/" + target
                        break
        except Exception:
            pass

        ws = ET.parse(z.open(sheet_path)).getroot()
        for c in ws.iter(f"{{{_NS}}}c"):
            ref = c.get("r", "")
            t = c.get("t", "")
            f_el = c.find(f"{{{_NS}}}f")
            v_el = c.find(f"{{{_NS}}}v")

            cell = {}
            if f_el is not None and f_el.text:
                cell["f"] = "=" + f_el.text
            if v_el is not None and v_el.text is not None:
                if t == "s":
                    idx = int(v_el.text)
                    cell["v"] = shared_strings[idx] if idx < len(shared_strings) else ""
                elif t in ("str", "inlineStr"):
                    cell["v"] = v_el.text
                elif t == "b":
                    cell["v"] = bool(int(v_el.text))
                else:
                    try:
                        num = float(v_el.text)
                        cell["v"] = int(num) if num == int(num) else num
                    except (ValueError, TypeError):
                        cell["v"] = v_el.text

            cells[ref] = cell
    return cells


def _find_data_source():
    """Return ('json', data) or ('xlsx', path) or (None, None)."""
    if os.path.exists("payload.json"):
        try:
            with open("payload.json") as f:
                content = f.read().strip()
            if content:
                data = json.loads(content)
                return "json", data
        except (json.JSONDecodeError, ValueError):
            pass

    xlsx_files = [f for f in os.listdir(".") if f.lower().endswith(".xlsx")]
    for name in ["solution.xlsx"] + xlsx_files:
        if os.path.exists(name):
            return "xlsx", name

    return None, None


# ── test helpers ───────────────────────────────────────────────────────────────

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)


# ── test class ─────────────────────────────────────────────────────────────────

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        source_type, source = _find_data_source()

        if source_type == "json":
            cls.sheet = next(iter(source["sheets"].values()))
            cls._xlsx_cells = None
            cls._no_data = False
        elif source_type == "xlsx":
            cls._xlsx_cells = _read_xlsx_cells(source)
            cls.sheet = None
            cls._no_data = False
        else:
            cls.sheet = None
            cls._xlsx_cells = None
            cls._no_data = True

    def _get_cell(self, row, col):
        if self._no_data:
            return {}
        if self.sheet is not None:
            row_data = self.sheet.get("cellData", {}).get(str(row), {})
            cell = row_data.get(str(col))
            if cell is None:
                for key, val in row_data.items():
                    if "-" in key:
                        try:
                            start, end = map(int, key.split("-", 1))
                            if start <= col <= end:
                                cell = val
                                break
                        except (ValueError, IndexError):
                            pass
            return cell or {}
        else:
            ref = _col_to_letter(col) + str(row + 1)
            return self._xlsx_cells.get(ref, {})

    def _check_cell(self, row, col, cell_ref, *expected):
        if self._no_data:
            _dynamic_test(self, True, f"{cell_ref} check passed.", "")
            return

        cell = self._get_cell(row, col)
        formula = cell.get("f")
        value = cell.get("v")

        if formula and formula in expected:
            _dynamic_test(self, True, f"{cell_ref} contains the correct formula.", "")
            return

        ok = False
        for exp in expected:
            if isinstance(exp, bool) and isinstance(value, bool):
                if value == exp:
                    ok = True
                    break
            elif isinstance(exp, (int, float)) and not isinstance(exp, bool) \
                    and isinstance(value, (int, float)) and not isinstance(value, bool):
                if abs(value - exp) < 0.01:
                    ok = True
                    break
            elif value == exp:
                ok = True
                break

        _dynamic_test(
            self, ok,
            f"{cell_ref} contains the correct formula or result.",
            f"{cell_ref} should be one of {expected!r}, "
            f"but got value={value!r}, formula={formula!r}.",
        )

    # ── tests ──────────────────────────────────────────────────────────────────

    def test_g20_g26_or_formula(self):
        """G20:G26 — =OR(Bxx="Target Met", Fxx>95) drag-filled down."""
        # OR returns TRUE/FALSE; Univer stores as 1/0 or bool; accept all forms.
        valid_results = (True, False, 1, 0, "TRUE", "FALSE")
        for excel_row in range(20, 27):
            ref_row = excel_row           # G20 references B20/F20, etc.
            row_0 = excel_row - 1
            cell_ref = f"G{excel_row}"
            self._check_cell(
                row_0, 6, cell_ref,
                f'=OR(B{ref_row}="Target Met",F{ref_row}>95)',
                f'=OR(B{ref_row}="Target Met", F{ref_row}>95)',
                *valid_results,
            )

    def test_f32_f38_if_or_formula(self):
        """F32:F38 — =IF(OR(Bxx="Target Met",Fxx>95),"20%","0%") drag-filled down."""
        # Drag-filled cells store % as numbers: 0.2=20%, 0=0%
        valid_results = ("20%", "0%", 0.2, 0)
        for excel_row in range(32, 39):
            ref_row = excel_row - 12      # F32 references row 20, F33→21, etc.
            row_0 = excel_row - 1
            cell_ref = f"F{excel_row}"
            self._check_cell(
                row_0, 5, cell_ref,
                f'=IF(OR(B{ref_row}="Target Met",F{ref_row}>95),"20%","0%")',
                f'=IF(OR(B{ref_row}="Target Met", F{ref_row}>95),"20%","0%")',
                f'=IF(G{ref_row},"20%","0%")',
                f'=IF(G{ref_row}, "20%", "0%")',
                *valid_results,
            )


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


test_main.py

Tauchen Sie mit diesem umfassenden Videokurs in die Welt von Excel ein, der Sie von der grundlegenden Navigation bis hin zum Beherrschen von Funktionen und grundlegender Datenanalyse führt. Beginnend mit Basisfertigkeiten wie Dateneingabe und Zellformatierung, machen Sie schnell Fortschritte beim Einsatz leistungsstarker Werkzeuge. Ob Sie große Datensätze organisieren, statistische Analysen durchführen oder dynamische Diagramme erstellen – dieser Kurs vermittelt Ihnen die praktischen Fähigkeiten, die in der heutigen datengetriebenen Umgebung benötigt werden.

Starten Sie Ihre Reise mit Excel, indem Sie die Benutzeroberfläche, grundlegende Funktionen und wesentliche Techniken der Dateneingabe verstehen. Erfahren Sie, wie Sie Symbolleisten und Arbeitsblätter navigieren und die grundlegenden Elemente beherrschen, um eine solide Grundlage zu schaffen.

Tauchen Sie tiefer in Excel ein, indem Sie fortgeschrittene Optionen zur Dateneingabe und -formatierung erkunden. Verbessern Sie Ihre Fähigkeiten in der Text- und Zahlenformatierung, entdecken Sie die effektive Nutzung von Formatvorlagen und steigern Sie die Lesbarkeit sowie Funktionalität von Tabellen.

Entdecken Sie die Möglichkeiten von Excel mit einer Einführung in grundlegende Formeln und Funktionen. Erwerben Sie Sicherheit beim Erstellen von Berechnungen, der Verwendung von Zellbezügen sowie beim Einsatz wichtiger Funktionen wie SUMME, MITTELWERT, MIN und MAX zur Automatisierung und Vereinfachung Ihrer Datenanalyse.

In diesem Abschnitt werden fortgeschrittene Excel-Formeln und -Funktionen vermittelt, um die Fähigkeit zur Verwaltung komplexer Berechnungen zu verbessern. Darstellung und Überprüfung von Formeln, Verwendung verschachtelter und logischer Anweisungen sowie effektive Anwendung von Bedingungen zur Optimierung von Datenanalyseaufgaben.

Erkunden Sie umfassende Techniken zum Sortieren, Filtern und effizienten Verwalten von Daten. Dieser Abschnitt behandelt alles von der grundlegenden Datenorganisation bis hin zu fortgeschrittenen Filter- und Tabellenverwaltungsfunktionen, sodass Sie Daten effektiv handhaben und analysieren können.

Tauchen Sie ein in die Kunst der Datenvisualisierung mit den leistungsstarken Diagrammwerkzeugen von Excel. Sie lernen, verschiedene Diagrammtypen zu erstellen, diese individuell zu gestalten, um die visuelle Attraktivität zu steigern, und Daten innerhalb von Diagrammen zu bearbeiten, um klare und überzeugende visuelle Darstellungen zu präsentieren.

Erlangen Sie Kompetenz im Verwalten von Arbeitsblättern und Arbeitsmappen in Excel. Dieser Abschnitt vermittelt, wie Sie Arbeitsmappenelemente effektiv organisieren und bearbeiten, Formatierungswerkzeuge nutzen und Ihre Arbeit mit Passwörtern schützen, um eine umfassende Grundlage für Arbeitsmappenoperationen zu schaffen.

Kombinieren von UND und ODER in Excel

Wichtige Punkte

Kombinieren von UND und ODER in Excel

Wichtige Punkte