“listas Fatia” e “reticências” em Python; cortar listas e listas de listas com listas de fatias

Question

pergunta original: alguém pode me dizer como usar "listas fatia" e "reticências"? Quando eles são úteis? Obrigado.

Aqui está o que a definição da linguagem diz sobre "slice_list" e "reticências"; pontos de Alex Martelli responder em sua origem, o que não é o que eu tinha imaginado.

[ http://docs.python.org/ referência / expressions.html # tok-slicing] [1]

5.3.3. Slicings

extended_slicing :: = primary "[" slice_list "]"

slice_list :: = slice_item ( "" slice_item) * [ ""]

slice_item :: = expressão | proper_slice | reticências

reticências :: = "..."

[1]: http://docs.python.org/reference/expressions.html#tok- slicing

No caso de alguém (como eu estava) está à procura de maneiras de atacar uma lista (ou uma lista de listas) com uma lista de fatias, aqui estão 5 maneiras de obter uma lista de elementos de uma lista que são selecionados por um lista de fatias e 2 maneiras de fazer a mesma coisa para uma lista de listas, nesse caso aplicar uma fatia por lista. A saída está em um comentário no final. Acho H5, o exemplo que usa aninhados loops, o mais difícil de entender se não forem usados ??nomes de variáveis ??significativas (atualizado).

#!/usr/bin/env python



import itertools

puz = [(i + 100) for i in range(40)]
puz1 = list( puz)
puz2 = [(i + 200) for i in range(40)]
puz3 = [(i + 300) for i in range(40)]
puzs = [puz1,puz2,puz3]

sa = slice( 0,1,1)
sb = slice( 30,39,4)
sc = slice( -1, -15,-5)
ss = [sa,sb,sc]

def mapfunc( a,b):
    return a[b]

f = map( mapfunc,[puz] * len(ss),ss)
print "f =  ", f  #same as g below

g = [ puz[i]
    for i in ss ]
print "g =  ",g  #same as f, above

h1 = [ i 
    for i in itertools.chain( puz[sa],puz[sb],puz[sc]) ]
print "h1 = ", h1  #right 

h2 = [ i
    for i in itertools.chain( *(map( mapfunc,[puz] * len(ss),ss))) ]
print "h2 = ",h2  #right

h3 = [ i
    for i in itertools.chain( *f) ]
print "h3 = ",h3  #right

h4 = [ i 
    for i in itertools.chain( *g) ]
print "h4 = ", h4 #also right

h5 = []
for slice_object in ss:
    for list_element in puz[slice_object]:
        h5.append( list_element)
print "h5 = ", h5  #right, too

print "=============================="

hh1 = [ i
    for i in itertools.chain( *(map( mapfunc,puzs,ss))) ]
print "hh1 =  ",hh1  #right

puz_s_pairs = zip( puzs,ss)
#print "puz_s_pairs = ",puz_s_pairs
hh2 = [ i
    for i in itertools.chain( *(map( mapfunc,*zip( *puz_s_pairs)))) ]
print "hh2 =  ",hh2  #right

'''
>>> execfile(r'D:/cygwin/home/usr01/wrk/py/pyexpts/list_of_slices_of_list.02.py')
f =   [[100], [130, 134, 138], [139, 134, 129]]
g =   [[100], [130, 134, 138], [139, 134, 129]]
h1 =  [100, 130, 134, 138, 139, 134, 129]
h2 =  [100, 130, 134, 138, 139, 134, 129]
h3 =  [100, 130, 134, 138, 139, 134, 129]
h4 =  [100, 130, 134, 138, 139, 134, 129]
h5 =  [100, 130, 134, 138, 139, 134, 129]
==============================
hh1 =   [100, 230, 234, 238, 339, 334, 329]
hh2 =   [100, 230, 234, 238, 339, 334, 329]
'''

Answer 1

listas fatia e reticências foram originalmente introduzido em Python para fornecer agradável açúcar sintaxe para o precedessor de numpy (bom e velho Numérico). (! Nenhuma razão para voltar a qualquer dos seus antecessores -) Se você estiver usando numpy você deve, naturalmente, utilizá-los; se por qualquer motivo estranho você está fazendo sua própria implementação de arrays multidimensionais super flexível, você definitivamente vai querer estudar a forma como os numpy usa-los e, provavelmente, imitá-lo de perto (ele é muito bem concebida depois de tudo). Eu não posso pensar em bons usos além matrizes multi-dimensionais.

Answer 2

Numpy usa-los para implementar variedade corte.

Answer 3

Eu não estou muito certo sobre reticências, por isso não vou resolver isso, para que eu não lhe dar uma resposta ruim.

Aqui vai a lista de corte:

Eu espero que você saiba que lista indeces começam em 0.

l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

A indexação em uma lista:

l[0]
>>> 0

l[5]
>>> 5

O fatiamento uma lista. O primeiro índice é incluído, mas não a última:

l[0:5]
>>> [0, 1, 2, 3, 4]

l[2:5]
>>> [2, 3, 4]

Voltar a lista inteira como uma fatia:

l[:]
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Obter uma fatia da lista que contém todos os elementos, incluindo e após o 3º índice:

l[3:]
>>> [3, 4, 5, 6, 7, 8, 9]

Obter uma fatia da lista que contém todos os elementos até, mas não incluindo o quinto índice:

l[:5]
>>> [0, 1, 2, 3, 4]

Aqui está algo que você não esperaria python para fazer:

l[5:18]  # note: there is no 18th index in this list
>>> [5, 6, 7, 8, 9]