Dans numpy, les constructeurs de nombreux objets acceptent un "array_like" comme premier argument. Existe-t-il une définition d'un tel objet, en tant que méta-classe abstraite, ou la documentation des méthodes doit contenir ??
Réponses
Trop de publicités?
Il s'avère que presque tout est techniquement un tableau-comme. "Array" est plus d'une déclaration de la façon dont l'entrée sera interprété que d'une restriction à ce que l'entrée peut être; si un paramètre est décrit comme semblable au tableau, NumPy vais essayer de l'interpréter comme un tableau.
Il n'y a pas de définition officielle de tableau-delà de la presque tautologique un -- un tableau-comme l'est n'importe quel objet Python qui np.array pouvez convertir en ndarray. Pour aller au-delà de cela, vous aurez besoin d'étudier le code source.
NPY_NO_EXPORT PyObject *
PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
int max_depth, int flags, PyObject *context)
{
/*
* This is the main code to make a NumPy array from a Python
* Object. It is called from many different places.
*/
PyArrayObject *arr = NULL, *ret;
PyArray_Descr *dtype = NULL;
int ndim = 0;
npy_intp dims[NPY_MAXDIMS];
/* Get either the array or its parameters if it isn't an array */
if (PyArray_GetArrayParamsFromObject(op, newtype,
0, &dtype,
&ndim, dims, &arr, context) < 0) {
Py_XDECREF(newtype);
return NULL;
}
...
Particulièrement intéressant est - PyArray_GetArrayParamsFromObject, dont les commentaires énumérer les types d'objets np.array attend:
NPY_NO_EXPORT int
PyArray_GetArrayParamsFromObject(PyObject *op,
PyArray_Descr *requested_dtype,
npy_bool writeable,
PyArray_Descr **out_dtype,
int *out_ndim, npy_intp *out_dims,
PyArrayObject **out_arr, PyObject *context)
{
PyObject *tmp;
/* If op is an array */
/* If op is a NumPy scalar */
/* If op is a Python scalar */
/* If op supports the PEP 3118 buffer interface */
/* If op supports the __array_struct__ or __array_interface__ interface */
/*
* If op supplies the __array__ function.
* The documentation says this should produce a copy, so
* we skip this method if writeable is true, because the intent
* of writeable is to modify the operand.
* XXX: If the implementation is wrong, and/or if actual
* usage requires this behave differently,
* this should be changed!
*/
/* Try to treat op as a list of lists */
/* Anything can be viewed as an object, unless it needs to be writeable */
}
Donc, en étudiant le code source, nous pouvons conclure à un tableau comme est
- un tableau NumPy, ou
- un NumPy scalaire, ou
- un Python scalaire, ou
- tout objet qui prend en charge le PEP 3118 tampon d'interface, ou
- tout objet qui prend en charge l'
__array_struct__ou__array_interface__interface, ou - tout objet qui fournit l'
__array__de la fonction, ou - tout objet qui peut être considérée comme une liste de listes, ou
- n'importe quoi! Si ça ne tombe pas sous l'un des autres cas, il sera traité comme un 0-dimensions tableau de
objectdtype.
Moinuddin Quadri
Points
27539
Le terme "tableau-like" est utilisé dans NumPy, se référant à tout ce qui peut être passé en premier paramètre numpy.array() créer un array ().
Comme par le Numpy document:
En général, les données numériques disposées dans un tableau de structure en Python peuvent être convertis à des tableaux grâce à l'utilisation de la fonction array (). Les exemples les plus évidents sont les listes et les tuples. Consultez la documentation pour array() pour plus de détails, pour son utilisation. Certains objets peuvent soutenir le tableau de protocole et de permettre la conversion à des tableaux de cette façon. Un moyen simple de savoir si l'objet peut être converti en un tableau numpy à l'aide du tableau() est simplement d'essayer de manière interactive et voir si cela fonctionne! (La Façon Python).
Pour plus d'informations, lire:
YaOzI
Points
129
C'est juste un concept, et il y a une déclaration officielle (dans Numpy Glossaire) à part l'explication dans le Guide de l'Utilisateur partie mentionné dans d'autres réponses:
array_likeToute séquence qui peut être interprété comme une ndarray. Cela comprend imbriqués les listes, les tuples, les scalaires et les ensembles existants.
ainsi, même les scalaires peuvent être prises en compte, tout comme np.array(1024).
