raeq

import copy

original = {}
original["object1"] = dict({"a": {"b": [1, 2, 3]}})

dict_shallow = original.copy()
dict_deep = copy.deepcopy(original)

# change the mutable object in original and dict_shallow
original["object1"]["a"]["b"] = [3, 4, 5]

raeq

def invert_dictionary(input:dict)->dict:
    return {v: k for k, v in dict1.items()}

dict1 = {"a": 1, "b": 2, "c": 3}

assert invert_dictionary(dict1) == {1: "a", 2: "b", 3: "c"}

raeq

from datetime import datetime
import json


class PythonObjectEncoder(json.JSONEncoder):
    """PythonObjectEncoder.
    """
    def default(self, an_object_value):
        """default.

raeq

import json
from datetime import datetime


class PythonObjectEncoder(json.JSONEncoder):

    def default(self, an_object_value):

        if isinstance(an_object_value, str):
            return an_object_value

raeq

def remove_even_items(the_dict: dict):

    # collect the keys of all the items to remove
    delete_these = set(k for k, v in the_dict.items() if v % 2 == 0)

    for delete_this in delete_these:
        del the_dict[delete_this]

    return the_dict

raeq

from collections import UserList


class UniquesList(UserList):
    """
    A List Class which works just like a list, except
    that it only holds unique values - similar to a set.

    >>> ul = UniquesList("The Jolly Green Giant")
    >>> print("".join(ul))

raeq

import typing


def get_indices(the_list: list, test_value: object) -> typing.Iterable[int]:
    """
    Returns the indices of matching list items.
    Uses a generator to create an iterator.
    Args:
        the_list: the list containing search elements
        test_value: what we want to find

raeq

from itertools import chain


def flatten_nested_lists(*input_list: list) -> list:
    """flatten_nested_lists.

    Args:
        input_list:

    Returns:

raeq

from collections.abc import Iterable
from collections import UserList


def immutable_decorator(f):
    def wrapper(self, *args, **kwargs):
        raise TypeError("Object is frozen")
    return wrapper

raeq

from collections import UserList


class AutoAppendList(UserList):
    """
    AutoAppendList. Will append an item if you are off by one index assignment.
    >>> aal: AutoAppendList = AutoAppendList()
    >>> for i in range(10):
    ...     aal[i] = i
    >>> print(aal)