eolas/_meta/Unsorted_notes.md

### Difference in import types Python

import x requires dot notation to individuate different components in the module

from x import y

import a component directly from the module removes the need to use dot notation
to indviduate

### Complex filter function using lambdas

```py
def update_entries(old, new):
    """Merge old and new data, removing dupes"""
    combined = old + new
    seen = set()

    filter_func = lambda x: not (tuple(x) in seen or seen.add(tuple(x)))

    unique_combined = list(filter(filter_func, combined))
```

#### ChatGpt explanation

Certainly, the line

```python
filter_func = lambda x: not (tuple(x) in seen or seen.add(tuple(x)))
```

creates a lambda function that takes a single argument `x`, where `x` is
expected to be a list. The function converts `x` to a tuple and checks for its
existence in the `seen` set.

Here is a breakdown of the logic:

1. `tuple(x)`: This converts the list `x` to a tuple because lists are
   unhashable and cannot be stored in a set. Tuples, being immutable, can be
   stored in a set.

2. `tuple(x) in seen`: This checks whether the tuple form of `x` is already in
   the `seen` set.

3. `seen.add(tuple(x))`: This adds the tuple form of `x` to the `seen` set. The
   `add` method of a set returns `None`.

4. `tuple(x) in seen or seen.add(tuple(x))`: This combines the above two steps.
   The `or` operator returns the first "truthy" value it encounters, or the last
   value otherwise. Since `seen.add()` returns `None`, which is "falsy," this
   part will return `True` if `tuple(x)` was already in `seen`, and `None`
   otherwise. Importantly, if `tuple(x)` was not already in `seen`, it will be
   added.

5. `not (...)`: The `not` negates the result. So if `tuple(x) in seen` was
   `True`, `not True` would be `False`, causing the filter to skip this item. If
   `tuple(x) in seen` was `False`, `not None` would be `True`, causing the
   filter to include this item and also adding it to `seen`.

In summary, the lambda function acts as a filter that only returns `True` for
the first occurrence of each unique list `x`, after converting it to a tuple for
hashability and set membership tests. After a unique list has been seen once,
any subsequent occurrences will cause the lambda function to return `False`,
effectively filtering them out.