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

L'utilizzo di `AND` e `OR` consente di eseguire **test logici avanzati** combinando **più condizioni**.

## Punti chiave

- Utilizzare la funzione `AND` per verificare se **tutte** le condizioni sono soddisfatte, come segue: `=AND(condition1, condition2,...)`;
- Utilizzare la funzione `OR` per verificare se **almeno una** condizione è soddisfatta, come segue: `=OR(condition1, condition2, ...)`.

Cartella di lavoro iniziale

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

Immergiti nel mondo di Excel con questo corso video completo, progettato per guidarti dalla navigazione di base fino alla padronanza delle funzioni e dell'analisi dati di base. A partire da competenze fondamentali come l'inserimento dei dati e la formattazione delle celle, progredirai rapidamente nell'utilizzo di strumenti potenti. Che tu stia organizzando grandi insiemi di dati, eseguendo analisi statistiche o creando grafici dinamici, questo corso ti fornisce le competenze pratiche necessarie nell'attuale contesto orientato ai dati.

Inizia il tuo percorso con Excel comprendendo la sua interfaccia, le funzioni di base e le tecniche essenziali di inserimento dati. Scopri come navigare tra le barre degli strumenti, i fogli di lavoro e padroneggiare gli elementi fondamentali per creare una solida base.

Approfondisci l'uso di Excel esplorando opzioni avanzate di inserimento dati e formattazione. Affina le competenze nella formattazione di testo e numeri, scopri l'utilizzo efficace degli stili e migliora la leggibilità e la funzionalità dei fogli di calcolo.

Scopri la potenza di Excel con un'introduzione alle formule e funzioni di base. Acquisisci sicurezza nella creazione di calcoli, nell'utilizzo dei riferimenti di cella e nell'impiego di funzioni chiave come SOMMA, MEDIA, MIN e MAX per automatizzare e semplificare le attività di analisi dei dati.

In questa sezione, apprenderai formule e funzioni avanzate di Excel, migliorando la tua capacità di gestire calcoli complessi. Verranno illustrate le modalità per visualizzare e verificare le formule, utilizzare dichiarazioni nidificate e logiche, e applicare condizioni in modo efficace per ottimizzare le attività di analisi dei dati.

Esplora tecniche complete per l'ordinamento, il filtraggio e la gestione efficiente dei dati. Questa sezione copre tutto, dall'organizzazione di base dei dati al filtraggio avanzato e alla gestione delle tabelle, garantendo la capacità di gestire e analizzare i dati in modo efficace.

Approfondimento nell'arte della visualizzazione dei dati utilizzando i potenti strumenti di creazione grafici di Excel. Apprendimento della creazione di diversi tipi di grafici, personalizzazione per migliorare l'impatto visivo e manipolazione dei dati all'interno dei grafici per presentare rappresentazioni visive chiare ed efficaci.

Acquisizione di competenze nella gestione di fogli di lavoro e cartelle di lavoro in Excel. Questa sezione illustra come organizzare e manipolare efficacemente gli elementi della cartella di lavoro, utilizzare strumenti di formattazione e proteggere il lavoro con password, offrendo una solida base nelle operazioni sulle cartelle di lavoro.

Combinazione di AND e OR in Excel

Punti chiave