Construire un ensemble python à partir d'une matrice numpy

Si vous voulez un ensemble d'éléments, voici un autre, probablement plus rapide:

y = set(x.flatten())

PS: après avoir effectué des comparaisons entre les x.flatx.flatten()et x.ravel() sur un 10x100 tableau, j'ai découvert qu'ils fonctionnent à la même vitesse. Pour une matrice 3x3, la version la plus rapide est l'itérateur version:

y = set(x.flat)

dont je vous recommande car il est le moins de mémoire chère, la version (il s'adapte bien à la taille de la matrice).

PS: Il y a aussi un NumPy fonction qui fait la même chose:

y = numpy.unique(x)

Ce ne produire un tableau NumPy avec le même élément que set(x.flat)mais comme un tableau NumPy. C'est très rapide (près de 10 fois plus rapide), mais si vous avez besoin d'un setpuis de le faire set(numpy.unique(x)) est un peu plus lent que les autres procédures (la construction d'un ensemble est livré avec un grand frais généraux).

Les réponses ci-dessus ne fonctionne si vous souhaitez créer un ensemble de la éléments contenues dans un ndarraymais si vous souhaitez créer un ensemble de ndarray objets – ou de l'utilisation ndarray objets comme des clés dans un dictionnaire, alors vous aurez à fournir un hashable wrapper pour eux. Voir le code ci-dessous pour un exemple simple:

from hashlib import sha1

from numpy import all, array, uint8


class hashable(object):
    r'''Hashable wrapper for ndarray objects.

        Instances of ndarray are not hashable, meaning they cannot be added to
        sets, nor used as keys in dictionaries. This is by design - ndarray
        objects are mutable, and therefore cannot reliably implement the
        __hash__() method.

        The hashable class allows a way around this limitation. It implements
        the required methods for hashable objects in terms of an encapsulated
        ndarray object. This can be either a copied instance (which is safer)
        or the original object (which requires the user to be careful enough
        not to modify it).
    '''
    def __init__(self, wrapped, tight=False):
        r'''Creates a new hashable object encapsulating an ndarray.

            wrapped
                The wrapped ndarray.

            tight
                Optional. If True, a copy of the input ndaray is created.
                Defaults to False.
        '''
        self.__tight = tight
        self.__wrapped = array(wrapped) if tight else wrapped
        self.__hash = int(sha1(wrapped.view(uint8)).hexdigest(), 16)

    def __eq__(self, other):
        return all(self.__wrapped == other.__wrapped)

    def __hash__(self):
        return self.__hash

    def unwrap(self):
        r'''Returns the encapsulated ndarray.

            If the wrapper is "tight", a copy of the encapsulated ndarray is
            returned. Otherwise, the encapsulated ndarray itself is returned.
        '''
        if self.__tight:
            return array(self.__wrapped)

        return self.__wrapped

À l'aide de la classe wrapper est assez simple:

>>> from numpy import arange

>>> a = arange(0, 1024)
>>> d = {}
>>> d[a] = 'foo'
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unhashable type: 'numpy.ndarray'
>>> b = hashable(a)
>>> d[b] = 'bar'
>>> d[b]
'bar'

J'ai aimé xperroni l'idée de. Mais je pense que la mise en œuvre peut être simplifiée en utilisant l'héritage direct de ndarray au lieu de l'emballage.

from hashlib import sha1
from numpy import ndarray, uint8, array

class HashableNdarray(ndarray):
    def __hash__(self):
        if not hasattr(hasattr, '__hash'):
            self.__hash = int(sha1(self.view(uint8)).hexdigest(), 16)
        return self.__hash

    def __eq__(self, other):
        if not isinstance(other, HashableNdarray):
            return super(HashableNdarray, self).__eq__(other)
        return super(HashableNdarray, self).__eq__(super(HashableNdarray, other)).all()

NumPy ndarray peut être considéré comme de la classe dérivée et utilisé comme hashable objet. view(ndarray) peut être utilisé pour la sauvegarde de la transformation, mais il n'est même pas nécessaire dans la plupart des cas.

>>> a = array([1,2,3])
>>> b = array([2,3,4])
>>> c = array([1,2,3])
>>> s = set()

>>> s.add(a.view(HashableNdarray))
>>> s.add(b.view(HashableNdarray))
>>> s.add(c.view(HashableNdarray))
>>> print(s)
{HashableNdarray([2, 3, 4]), HashableNdarray([1, 2, 3])}
>>> d = next(iter(s))
>>> print(d == a)
[False False False]
>>> import ctypes
>>> print(d.ctypes.data_as(ctypes.POINTER(ctypes.c_double)))
<__main__.LP_c_double object at 0x7f99f4dbe488>