web-dev-qa-db-fra.com

Python premier et dernier élément du tableau

J'essaie d'obtenir dynamiquement le premier et le dernier élément d'un tableau. 

Supposons donc que le tableau comporte 6 éléments. 

test = [1,23,4,6,7,8]

Si j'essaie d'obtenir le first and last = 1,8, 23,7 et 4,6. Y a-t-il un moyen d'obtenir des éléments dans cet ordre? J'ai examiné quelques questions LinkLink2 . J'ai pris l'aide de ces liens et je suis venu avec ce prototype ..

#!/usr/bin/env python

import numpy

test = [1,23,4,6,7,8]
test1 = numpy.array([1,23,4,6,7,8])
len_test = len(test)
first_list = [0,1,2]
len_first = len(first_list)
second_list = [-1,-2,-3]
len_second = len(second_list)

for a in range(len_first):
        print numpy.array(test)[[first_list[a] , second_list[a]]]
        print test1[[first_list[a], second_list[a]]]

Mais ce prototype ne sera pas adapté si vous avez plus de 6 éléments. Alors, je me demandais s'il y avait moyen d'obtenir la paire d'éléments de manière dynamique.

Merci!

pythonarraysnumpy
27
pistal

Que diriez-vous:

In [10]: arr = numpy.array([1,23,4,6,7,8])

In [11]: [(arr[i], arr[-i-1]) for i in range(len(arr) // 2)]
Out[11]: [(1, 8), (23, 7), (4, 6)]

En fonction de la taille de arr, l'écriture complète dans NumPy peut être plus performante:

In [41]: arr = numpy.array([1,23,4,6,7,8]*100)

In [42]: %timeit [(arr[i], arr[-i-1]) for i in range(len(arr) // 2)]
10000 loops, best of 3: 167 us per loop

In [43]: %timeit numpy.vstack((arr, arr[::-1]))[:,:len(arr)//2]
100000 loops, best of 3: 16.4 us per loop
22
NPE

J'ai terminé ici, car j'ai cherché dans Google pour "premier et dernier élément de array", et j'ai trouvé tout le reste sauf ceci. Alors, voici la réponse à la question du titre:

a = [1,2,3]
a[0] # first element (returns 1)
a[-1] # last element (returns 3)
96
lenooh

Utilisation de l'indexation sophistiquée de Numpy:

>>> test
array([ 1, 23,  4,  6,  7,  8])

>>> test[::-1]  # test, reversed
array([ 8,  7,  6,  4, 23,  1])

>>> numpy.vstack([test, test[::-1]])  # stack test and its reverse
array([[ 1, 23,  4,  6,  7,  8],
       [ 8,  7,  6,  4, 23,  1]])

>>> # transpose, then take the first half;
>>> # +1 to cater to odd-length arrays
>>> numpy.vstack([test, test[::-1]]).T[:(len(test) + 1) // 2]
array([[ 1,  8],
       [23,  7],
       [ 4,  6]])

vstack copie le tableau, mais toutes les autres opérations sont des astuces de pointeur à temps constant (y compris l'inversion) et sont donc très rapides.

3
Fred Foo
>>> test = [1,23,4,6,7,8]
>>> from itertools import izip_longest
>>> for e in izip_longest(test, reversed(test)):
    print e


(1, 8)
(23, 7)
(4, 6)
(6, 4)
(7, 23)
(8, 1)

Une autre option

>>> test = [1,23,4,6,7,8]
>>> start, end = iter(test), reversed(test)
>>> try:
    while True:
        print map(next, [start, end])
except StopIteration:
    pass

[1, 8]
[23, 7]
[4, 6]
[6, 4]
[7, 23]
[8, 1]
3
Abhijit

Que dis-tu de ça?

>>> import numpy
>>> test1 = numpy.array([1,23,4,6,7,8])
>>> forward = iter(test1)
>>> backward = reversed(test1)
>>> for a in range((len(test1)+1)//2):
...     print forward.next(), backward.next()
... 
1 8
23 7
4 6

Le (len(test1)+1)//2 garantit que l'élément du milieu des tableaux de longueur impaire est également renvoyé:

>>> test1 = numpy.array([1,23,4,9,6,7,8]) # additional element '9' in the middle
>>> forward = iter(test1)                                                      
>>> backward = reversed(test1)
>>> for a in range((len(test1)+1)//2):
...     print forward.next(), backward.next()
1 8
23 7
4 6
9 9

En utilisant seulement len(test1)//2, les tableaux de longueur impaire seront abandonnés au milieu.

1
isedev

Ça le fait. Notez qu'avec un nombre impair d'éléments, celui du milieu ne sera pas inclus.

test = [1, 23, 4, 6, 7, 8, 5]    
for i in range(len(test)/2):
    print (test[i], test[-1-i])

Sortie:

(1, 5)
(23, 8)
(4, 7)
0
ford