feat: add 10 intermediate Mermaid diagram files for concept docs

Add visual diagrams for imports, classes, decorators, virtual environments,
comprehensions, args/kwargs, context managers, enums, type hints, and
dataclasses. Each file contains 2-4 focused Mermaid diagrams with descriptive
labels and consistent styling matching the existing 8 beginner diagrams.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: travisjneuman

concepts/diagrams/args-kwargs-explained.md

@@ -0,0 +1,115 @@
+# Diagrams: *args and **kwargs Explained
+
+[Back to concept](../args-kwargs-explained.md)
+
+---
+
+## Argument Passing Flow
+
+Python matches arguments to parameters by position first, then by name.
+
+```mermaid
+flowchart TD
+    CALL["greet('Alice', 'Bob', greeting='Hi')"]
+
+    subgraph MATCHING ["Python matches arguments"]
+        POS["Positional args<br/>'Alice' and 'Bob'"]
+        KW["Keyword arg<br/>greeting='Hi'"]
+    end
+
+    subgraph FUNC ["def greet(*args, greeting='Hello')"]
+        ARGS["args = ('Alice', 'Bob')"]
+        KWARG["greeting = 'Hi'"]
+    end
+
+    CALL --> MATCHING
+    POS --> ARGS
+    KW --> KWARG
+
+    style POS fill:#4a9eff,stroke:#2670c2,color:#fff
+    style KW fill:#ff922b,stroke:#e8590c,color:#fff
+    style ARGS fill:#4a9eff,stroke:#2670c2,color:#fff
+    style KWARG fill:#ff922b,stroke:#e8590c,color:#fff
+```
+
+## *args: Collecting Extra Positional Arguments
+
+`*args` gathers any number of positional arguments into a tuple.
+
+```mermaid
+flowchart LR
+    subgraph CALL ["add(1, 2, 3, 4, 5)"]
+        A1["1"]
+        A2["2"]
+        A3["3"]
+        A4["4"]
+        A5["5"]
+    end
+
+    PACK["* packs them<br/>into a tuple"]
+
+    subgraph FUNC ["def add(*args)"]
+        T["args = (1, 2, 3, 4, 5)"]
+        LOOP["for num in args:<br/>    total += num"]
+        RES["return 15"]
+        T --> LOOP --> RES
+    end
+
+    A1 --> PACK
+    A2 --> PACK
+    A3 --> PACK
+    A4 --> PACK
+    A5 --> PACK
+    PACK --> T
+
+    style CALL fill:#4a9eff,stroke:#2670c2,color:#fff
+    style PACK fill:#ffd43b,stroke:#f59f00,color:#000
+    style FUNC fill:#51cf66,stroke:#27ae60,color:#fff
+```
+
+## **kwargs: Collecting Extra Keyword Arguments
+
+`**kwargs` gathers any number of keyword arguments into a dictionary.
+
+```mermaid
+flowchart LR
+    subgraph CALL ["build_profile(name='Alice', age=30, city='NYC')"]
+        K1["name='Alice'"]
+        K2["age=30"]
+        K3["city='NYC'"]
+    end
+
+    PACK["** packs them<br/>into a dict"]
+
+    subgraph FUNC ["def build_profile(**kwargs)"]
+        D["kwargs = {<br/>  'name': 'Alice',<br/>  'age': 30,<br/>  'city': 'NYC'<br/>}"]
+    end
+
+    K1 --> PACK
+    K2 --> PACK
+    K3 --> PACK
+    PACK --> D
+
+    style CALL fill:#ff922b,stroke:#e8590c,color:#fff
+    style PACK fill:#ffd43b,stroke:#f59f00,color:#000
+    style FUNC fill:#51cf66,stroke:#27ae60,color:#fff
+```
+
+## Parameter Order Rule
+
+When combining all parameter types, they must appear in this exact order.
+
+```mermaid
+flowchart LR
+    P1["1. Regular params<br/>def f(a, b)"]
+    P2["2. *args<br/>def f(a, b, *args)"]
+    P3["3. Keyword-only<br/>def f(a, *args, flag=True)"]
+    P4["4. **kwargs<br/>def f(a, *args, flag=True, **kwargs)"]
+
+    P1 --> P2 --> P3 --> P4
+
+    style P1 fill:#4a9eff,stroke:#2670c2,color:#fff
+    style P2 fill:#51cf66,stroke:#27ae60,color:#fff
+    style P3 fill:#ffd43b,stroke:#f59f00,color:#000
+    style P4 fill:#ff922b,stroke:#e8590c,color:#fff
+```

concepts/diagrams/classes-and-objects.md

@@ -0,0 +1,114 @@
+# Diagrams: Classes and Objects
+
+[Back to concept](../classes-and-objects.md)
+
+---
+
+## Class Instantiation Sequence
+
+When you create an object from a class, Python performs several steps behind the scenes.
+
+```mermaid
+sequenceDiagram
+    participant Code as Your Code
+    participant Class as Dog class
+    participant Init as __init__ method
+    participant Obj as New Object
+
+    Code->>Class: Dog("Rex", 5)
+    Note over Class: Python creates a<br/>new empty object
+    Class->>Init: __init__(self, name, age)
+    Note over Init: self.name = "Rex"
+    Note over Init: self.age = 5
+    Init-->>Class: Object is initialized
+    Class-->>Code: Return the Dog object
+    Note over Code: my_dog = Dog("Rex", 5)<br/>my_dog.name is "Rex"
+```
+
+## Inheritance Hierarchy
+
+Child classes inherit attributes and methods from parent classes, and can add or override them.
+
+```mermaid
+classDiagram
+    class Animal {
+        +name: str
+        +sound: str
+        +speak() str
+        +eat() str
+    }
+
+    class Dog {
+        +breed: str
+        +speak() str
+        +fetch() str
+    }
+
+    class Cat {
+        +indoor: bool
+        +speak() str
+        +purr() str
+    }
+
+    class GuideDog {
+        +handler: str
+        +guide() str
+    }
+
+    Animal <|-- Dog : inherits
+    Animal <|-- Cat : inherits
+    Dog <|-- GuideDog : inherits
+
+    note for Dog "Overrides speak()&#10;Adds fetch()"
+    note for GuideDog "Inherits from Dog&#10;AND from Animal"
+```
+
+## Method Resolution Order (MRO)
+
+With multiple inheritance, Python searches for methods in a specific order called the MRO.
+
+```mermaid
+flowchart TD
+    CALL["guide_dog.speak()"] --> STEP1{"1. GuideDog<br/>has speak()?"}
+    STEP1 -->|No| STEP2{"2. Dog<br/>has speak()?"}
+    STEP1 -->|Yes| FOUND1(["Use GuideDog.speak()"])
+    STEP2 -->|Yes| FOUND2(["Use Dog.speak()"])
+    STEP2 -->|No| STEP3{"3. Animal<br/>has speak()?"}
+    STEP3 -->|Yes| FOUND3(["Use Animal.speak()"])
+    STEP3 -->|No| STEP4{"4. object<br/>(base of everything)"}
+    STEP4 -->|Not found| ERR["AttributeError!"]
+
+    style STEP1 fill:#4a9eff,stroke:#2670c2,color:#fff
+    style STEP2 fill:#51cf66,stroke:#27ae60,color:#fff
+    style STEP3 fill:#ffd43b,stroke:#f59f00,color:#000
+    style STEP4 fill:#cc5de8,stroke:#9c36b5,color:#fff
+    style ERR fill:#ff6b6b,stroke:#c0392b,color:#fff
+```
+
+## Class vs Instance Attributes
+
+Class attributes are shared by all objects. Instance attributes belong to one object.
+
+```mermaid
+flowchart TD
+    subgraph CLASS ["Dog class"]
+        CA["species = 'Canis familiaris'<br/>(shared by ALL dogs)"]
+    end
+
+    subgraph OBJ1 ["dog1 = Dog('Rex', 5)"]
+        I1A["name = 'Rex'"]
+        I1B["age = 5"]
+    end
+
+    subgraph OBJ2 ["dog2 = Dog('Bella', 3)"]
+        I2A["name = 'Bella'"]
+        I2B["age = 3"]
+    end
+
+    CLASS -->|"dog1.species"| OBJ1
+    CLASS -->|"dog2.species"| OBJ2
+
+    style CLASS fill:#ff922b,stroke:#e8590c,color:#fff
+    style OBJ1 fill:#4a9eff,stroke:#2670c2,color:#fff
+    style OBJ2 fill:#51cf66,stroke:#27ae60,color:#fff
+```

concepts/diagrams/comprehensions-explained.md

@@ -0,0 +1,100 @@
+# Diagrams: Comprehensions Explained
+
+[Back to concept](../comprehensions-explained.md)
+
+---
+
+## List Comprehension Data Flow
+
+A list comprehension takes an iterable, optionally filters it, transforms each item, and collects results.
+
+```mermaid
+flowchart LR
+    INPUT["Input iterable<br/>[1, 2, 3, 4, 5, 6]"]
+    FILTER["Filter (optional)<br/>if x % 2 == 0"]
+    TRANSFORM["Transform<br/>x ** 2"]
+    OUTPUT["Output list<br/>[4, 16, 36]"]
+
+    INPUT --> FILTER --> TRANSFORM --> OUTPUT
+
+    style INPUT fill:#4a9eff,stroke:#2670c2,color:#fff
+    style FILTER fill:#ffd43b,stroke:#f59f00,color:#000
+    style TRANSFORM fill:#cc5de8,stroke:#9c36b5,color:#fff
+    style OUTPUT fill:#51cf66,stroke:#27ae60,color:#fff
+```
+
+## Comprehension vs Loop: Side by Side
+
+Every comprehension can be rewritten as a for loop. The comprehension is just more concise.
+
+```mermaid
+flowchart TD
+    subgraph LOOP ["For Loop (4 lines)"]
+        L1["squares = []"]
+        L2["for x in range(5):"]
+        L3["    squares.append(x ** 2)"]
+        L4["# squares = [0, 1, 4, 9, 16]"]
+        L1 --> L2 --> L3 --> L4
+    end
+
+    subgraph COMP ["Comprehension (1 line)"]
+        C1["squares = [x ** 2 for x in range(5)]"]
+        C2["# squares = [0, 1, 4, 9, 16]"]
+        C1 --> C2
+    end
+
+    LOOP ---|"Same result,<br/>less code"| COMP
+
+    style LOOP fill:#ffd43b,stroke:#f59f00,color:#000
+    style COMP fill:#51cf66,stroke:#27ae60,color:#fff
+```
+
+## Anatomy of a Comprehension
+
+Breaking down the parts of `[expression for item in iterable if condition]`.
+
+```mermaid
+flowchart TD
+    FULL["[x * 2  for x in range(10)  if x > 3]"]
+    FULL --> PART_OUT["x * 2<br/>OUTPUT expression<br/>What goes into the result"]
+    FULL --> PART_FOR["for x in range(10)<br/>ITERATION<br/>What we loop over"]
+    FULL --> PART_IF["if x > 3<br/>FILTER (optional)<br/>Which items to keep"]
+
+    PART_FOR -->|"x = 0, 1, 2, ... 9"| PART_IF
+    PART_IF -->|"Keeps: 4, 5, 6, 7, 8, 9"| PART_OUT
+    PART_OUT -->|"Result"| RESULT["[8, 10, 12, 14, 16, 18]"]
+
+    style PART_OUT fill:#51cf66,stroke:#27ae60,color:#fff
+    style PART_FOR fill:#4a9eff,stroke:#2670c2,color:#fff
+    style PART_IF fill:#ffd43b,stroke:#f59f00,color:#000
+    style RESULT fill:#cc5de8,stroke:#9c36b5,color:#fff
+```
+
+## List vs Dict vs Set Comprehension
+
+The brackets you use determine what type of collection you get.
+
+```mermaid
+flowchart TD
+    subgraph LIST_COMP ["List Comprehension [ ]"]
+        LC["[x**2 for x in range(4)]"]
+        LR2["Result: [0, 1, 4, 9]"]
+        LC --> LR2
+    end
+
+    subgraph DICT_COMP ["Dict Comprehension { : }"]
+        DC["{x: x**2 for x in range(4)}"]
+        DR["Result: {0: 0, 1: 1, 2: 4, 3: 9}"]
+        DC --> DR
+    end
+
+    subgraph SET_COMP ["Set Comprehension { }"]
+        SC["{x % 3 for x in range(6)}"]
+        SR["Result: {0, 1, 2}"]
+        SC --> SR
+    end
+
+    style LIST_COMP fill:#4a9eff,stroke:#2670c2,color:#fff
+    style DICT_COMP fill:#ff922b,stroke:#e8590c,color:#fff
+    style SET_COMP fill:#cc5de8,stroke:#9c36b5,color:#fff
+```