如何创建具有指定特征的类？

Question

What I want to do is to create a class that I will call a Cluster that I can use to store representations of multivariable data points. Like a bunch of people's heights, weights, and ages. I want to make it so when I create an instance of Cluster , it returns an empty dictionary. I then want to be able to add key value pairs. I want each value paired with each key to only be a list. I want each list to only contain only 1 data type.

However, they don't have to be the same data type for every list. What I mean is that one list can only consists of integers, and the other list is only full of strings. I even allow a list of tuples or lists or dictionaries. They don't even have to have the same data type for each value in itself. But, the overall list must then contain all dictionaries, tuples, etc.

Example of a Cluster :

{'Hobbies': [(3, 's', {'name': 'Sam'}), (4, 5), (), (True)], 'Weights': [1, 34, 3, 90]}

Notice how the above 'Hobbies' value pair is a list of only tuples and the 'Weights' value pair is a list of only integers. This is what I mean by what I am trying to say above.

I created a function that generates what a Cluster full of values should look like, but I want it to be a class. It gives you what I want to happen, but I want make a class , not a function that generates it. Other methods such as getting the length of the Cluster I can figure out, I just want everything that I said above to be true.

from random import randint


def create_cluster(a, b, c, *d):
    cluster = {}
    for key in d:
        point = []
        for integer in range(0, a):
            point.append(randint(b, c))
        cluster[key] = point
    return cluster


print(create_cluster(4, 2, 9, 'Height', 'Weight', 'Age'))

Output:

{'Height': [5, 3, 3, 6], 'Weight': [7, 3, 5, 7], 'Age': [9, 5, 3, 6]}

Answer 1

As Code-Apprentice mentions, there is no mechanism by which python enforces type checking in the sense that it will stop you from compiling and running the code. As of version 3.5, however, Python allows you to implement a soft type checking - you can read about it here . What this means is that Python now offers you a way too check to see if your code is passing illegal values to functions/classes/variables etc.

Here's how it works:

from typing import Dict, List, Any, Tuple, Union
from random import randint

class Cluster:
    def __init__(self):
        self.data: Dict[str, List[Any]] = {}

    def create_cluster(self, a, b, c, *d):
        for key in d:
            point = []
            for integer in range(0, a):
                point.append(randint(b, c))
            self.data[key] = point

clust = Cluster()
clust.create_cluster(4, 2, 9, 'Height', 'Weight', 'Age')
print(clust.data)

Edit: for your example specifically, you'd want something like:

self.data: Dict[str, List[Union[Tuple, int]] = {}

Union is a type that indicates a wildcard of specified possibilities, so the dictionary value can be a list containing either tuples or ints. I guess if you wanted to further restrict the data types inside the tuples, you could do:

self.data: Dict[str, List[Union[Tuple[Union[int, str]], int]] = {}

Next, you need mypy installed . Mypy has to be called separately from a terminal on your script, but it will go through the code and perform a type check - that is, it will alert you to any instances where you have declared illegal variables in your class.

Alternatively, you could perform a series of in-code catches involving:

if type(data['Weight'][0]) != whatever:
    raise("You're putting the wrong type of variable in")

But mypy seems like a better solution in the longer term. It'll save you from having to wait for your code to execute, run, and fail in a predictable spot.

Feedback and corrections welcome.

Answer 2

If I'm understanding what you need, we can actually make a dict object that will type check for you! No imports needed.

We just have to subclass the dict class, and override the functions for adding items to the dictionary, so we can type check before allowing any additions.

Here is the code below.

class ClusterDict(dict):
    key_type = str  # we want all of our keys to be str type
    value_type = list  # same for our value as a list

    # lets override the function for dictionary assignment so we can type check before we add to our dictionary
    def __setitem__(self, key, value):
        self.type_check_and_add(key, value)

    # Lets override update as well
    def update(self, **kwargs) -> None:
        for key, value in kwargs.items():
            self.type_check_and_add(key, value)

    def type_check_and_add(self, key: str, value: list) -> None:
        assert type(key) == self.key_type, f"Expected {self.key_type} for key, got {type(key)} instead."
        if type(value) is not list:
            value = [value]  # Make it a list if its isn't, remove this if you know it will always come as a list, even if its a single entry, like [5], or [(2, 6)]
        assert type(value) == self.value_type, f"Expected {self.value_type} for key, got {type(value)} instead."
        val_type = type(value[0])  # type of first item in list, lets make sure they all match this one
        for val in value:
            assert type(val) == val_type, f"Items do not have matching types for key {key}."
        super().__setitem__(key, value)  # this then passes assignment as usual to the base class dict

Lets do some tests now!

if __name__ == '__main__':
    clust = ClusterDict()
    input_data = {
        'Height': [4, 3, 5],
        'Age': [(4, 9), (4, 6, 8)]
    }
    clust.update(**input_data)
    print(clust)

{'Height': [4, 3, 5], 'Age': [(4, 9), (4, 6, 8)]}

Looks good so far, we can add whole dictionaries using update as usual

    input_data = {'Weights': [1, 34, 3, 90]}
    clust.update(**input_data)
    print(clust)

{'Height': [4, 3, 5], 'Age': [(4, 9), (4, 6, 8)], 'Weights': [1, 34, 3, 90]}

Or just one entry at a time.

Lets try the usual way, dict[key] = value

    clust['Hobbies'] = [(3, 's', {'name': 'Sam'}), (4, 5), (), (True,)]
    print(clust)

{'Height': [4, 3, 5], 'Age': [(4, 9), (4, 6, 8)], 'Weights': [1, 34, 3, 90], 'Hobbies': [(3, 's', {'name': 'Sam'}), (4, 5), (), (True,)]}

Looking good. But now lets try adding a list with types that don't match.

    clust['My Favorite Number'] = [7, '7', (1, 1, 1, 1, 1, 1, 1)]
    print(clust)

    assert type(val) == val_type, f"Items do not have matching types for key {key}."
AssertionError: Items do not have matching types for key My Favorite Number.

Which throws an AssertionError and prevents us from doing so, like we wanted.

Bonus though, because we subclassed dict, we get all of its methods for free!

>>>len(clust)
4

for k, v in clust.items():
...     print(k, v)
...     
Height [4, 3, 5]
Age [(4, 9), (4, 6, 8)]
Weights [1, 34, 3, 90]
Hobbies [(3, 's', {'name': 'Sam'}), (4, 5), (), (True,)]

Hopefully this is what you were looking for and it helps!