Est-il un Python équivalent de la gamme(n) pour multidimensionnelle des plages?

Sur Python, range(3) sera de retour [0,1,2]. Est-il un équivalent pour multidimensionnelle des plages?

range((3,2)) # [(0,0),(0,1),(1,0),(1,1),(2,0),(2,1)]

Ainsi, par exemple, le bouclage bien que les carreaux d'une zone rectangulaire sur une mosaïque de jeu peut être écrite comme:

for x,y in range((3,2)):

Remarque je ne suis pas à demander une mise en œuvre. Je voudrais savoir si c'est un motif reconnu et si il y a une fonction intégrée de sur Python ou c'est la norme/commune de bibliothèques.

InformationsquelleAutor MaiaVictor | 2012-04-10

64

Dans numpy, c'est numpy.ndindex. Aussi jeter un oeil à numpy.ndenumerate.

E. g.
```
import numpy as np
for x, y in np.ndindex((3,2)):
    print x, y
```
Cela donne:
```
0 0
0 1
1 0
1 1
2 0
2 1
```
- +1: La syntaxe pour que est longue, très similaire à ce que l'OP initialement demandé. Bien joué!
- Li-aung fait remarquer ceci est longue, très similaire à ce que j'ai demandé, il est donc, sans aucun doute, la meilleure réponse à la question.
- Li-aung Yip réponse est grand, trop, et a un certain apprentissage sur lui car il montre le produit cartésien peut être utilisé pour le même but.
InformationsquelleAutor Joe Kington
37

Vous pouvez utiliser itertools.product():
```
>>> import itertools
>>> for (i,j,k) in itertools.product(xrange(3),xrange(3),xrange(3)):
...     print i,j,k
```
Les multiples répétées xrange() états pourrait être exprimée comme ça, si vous voulez l'appliquer à grande échelle de un à dix dimensions de la boucle ou quelque chose de même ridicule:
```
>>> for combination in itertools.product( xrange(3), repeat=10 ):
...     print combination
```
Qui passe en boucle sur dix variables, variant de (0,0,0,0,0,0,0,0,0,0) à (2,2,2,2,2,2,2,2,2,2).

En général itertools est un incroyablement génial module. De la même manière les expressions régulières sont beaucoup plus expressifs que "la plaine" de la chaîne de méthodes, itertools est très élégante, une façon de s'exprimer de boucles complexes. Vous vous devez de lire le itertools documentation du module. Il rendra votre vie plus amusante.
- juste une petite amélioration par rapport à votre dernière réponse: for c in product(*([xrange(5)]*3)): print c: à partir de (0,0,0) à (4,4,4)
- Il est effectivement préférable d'utiliser itertools.tee() si vous voulez des répliques exactes - je crois que l'implémentation sous-jacente est plus efficace en raison de la mise en cache.
- Li-aung Yip: Veuillez lire le itertools docs avant de proposer des solutions extrêmement complexes. C'est itertools.product(xrange(3), repeat = 3).
- bonne prise - de toute évidence le temps pour moi de dormir. Édité à cet effet.
InformationsquelleAutor Li-aung Yip
22

En fait il y a une syntaxe simple pour cela. Vous avez juste besoin d'avoir deux fors:
```
>>> [(x,y) for x in range(3) for y in range(2)]
[(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]
```
- C'est bon, mais je tiens à souligner qu'il peut être un peu verbeux: pour (x,y) [(x,y) pour x in range(3) for y in range(2)]:
InformationsquelleAutor dhg

Qui est le produit cartésien de deux listes donc:

import itertools
for element in itertools.product(range(3),range(2)):
    print element

donne ce résultat:

(0, 0)
(0, 1)
(1, 0)
(1, 1)
(2, 0)
(2, 1)

InformationsquelleAutor 0x90

3

Vous pouvez utiliser product de itertools module.
```
itertools.product(range(3), range(2))
```
InformationsquelleAutor Praveen Gollakota
3

Je voudrais prendre un coup d'oeil à numpy.meshgrid:

http://docs.scipy.org/doc/numpy-1.6.0/reference/generated/numpy.meshgrid.html

qui vous donnera les coordonnées X et Y de la grille de valeurs pour chaque position dans un filet/grille. Ensuite, vous pourriez faire quelque chose comme:
```
import numpy as np
X,Y = np.meshgrid(xrange(3),xrange(2))
zip(X.ravel(),Y.ravel()) 
#[(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1)]
```
ou
```
zip(X.ravel(order='F'),Y.ravel(order='F')) 
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]
```
- il serait bon de mentionner aussi les numpy.mgrid et numpy.ogrid ici.
InformationsquelleAutor JoshAdel

Numpy est ndindex() travaille pour l'exemple que vous avez donné, mais il ne sert pas tous les cas d'utilisation. Contrairement à Python intégré dans range(), qui permet à la fois arbitraire start, stop, et step, numpy est np.ndindex() accepte uniquement un stop. (Le start est présumé être (0,0,...), et la step est (1,1,...).)

Voici une application qui agit plus comme le haut- range() fonction. C'est, il permet arbitraire start/stop/step arguments, mais il fonctionne sur tuples au lieu de simples entiers.

import sys
from itertools import product, starmap

# Python 2/3 compatibility
if sys.version_info.major < 3:
    from itertools import izip
else:
    izip = zip
    xrange = range

def ndrange(start, stop=None, step=None):
    if stop is None:
        stop = start
        start = (0,)*len(stop)

    if step is None:
        step = (1,)*len(stop)

    assert len(start) == len(stop) == len(step)

    for index in product(*starmap(xrange, izip(start, stop, step))):
        yield index

Exemple:

In [7]: for index in ndrange((1,2,3), (10,20,30), step=(5,10,15)):
   ...:     print(index)
   ...:
(1, 2, 3)
(1, 2, 18)
(1, 12, 3)
(1, 12, 18)
(6, 2, 3)
(6, 2, 18)
(6, 12, 3)
(6, 12, 18)

Juste à temps pour le sprint!

InformationsquelleAutor Stuart Berg

Vous devez vous connecter pour publier un commentaire.