Eu preciso de uma boa explicação (as referências são um plus) na notação de fatia do Python.
Para mim, essa notação precisa de um pouco de atenção.
Parece extremamente poderoso, mas ainda não consegui entender.
Na verdade, é bem simples:
a[start:stop] # items start through stop-1
a[start:] # items start through the rest of the array
a[:stop] # items from the beginning through stop-1
a[:] # a copy of the whole array
Há também o step
valor, que pode ser usado com qualquer um dos itens acima:
a[start:stop:step] # start through not past stop, by step
O ponto principal a lembrar é que o :stop
valor representa o primeiro valor que não está na fatia selecionada. Portanto, a diferença entre stop
e start
é o número de elementos selecionados (se step
for 1, o padrão).
O outro recurso é esse start
ou stop
pode ser um número negativo , o que significa que conta desde o final da matriz em vez do início. Assim:
a[-1] # last item in the array
a[-2:] # last two items in the array
a[:-2] # everything except the last two items
Da mesma forma, step
pode ser um número negativo:
a[::-1] # all items in the array, reversed
a[1::-1] # the first two items, reversed
a[:-3:-1] # the last two items, reversed
a[-3::-1] # everything except the last two items, reversed
Python é gentil com o programador se houver menos itens do que você solicita. Por exemplo, se você solicitar a[:-2]
e a
contiver apenas um elemento, obterá uma lista vazia em vez de um erro. Às vezes você prefere o erro, portanto, saiba que isso pode acontecer.
slice()
objetoO operador de fatiamento []
está realmente sendo usado no código acima com um slice()
objeto usando a :
notação (que é válida apenas dentro []
), ou seja:
a[start:stop:step]
é equivalente a:
a[slice(start, stop, step)]
Os objetos de fatia também se comportam de maneira ligeiramente diferente, dependendo do número de argumentos, da mesma forma que range()
, por exemplo , ambos slice(stop)
e slice(start, stop[, step])
são suportados. Para pular a especificação de um determinado argumento, pode-se usar None
, de modo que, por exemplo, a[start:]
seja equivalente a a[slice(start, None)]
ou a[::-1]
seja a[slice(None, None, -1)]
.
Embora a :
notação baseada em seja muito útil para o fatiamento simples, o uso explícito de slice()
objetos simplifica a geração programática do fatiamento.
None
qualquer um dos espaços vazios. Por exemplo,[None:None]
faz uma cópia inteira. Isso é útil quando você precisa especificar o final do intervalo usando uma variável e precisa incluir o último item.del
faz a notação de fatia wrt. Em particular,del arr[:]
não é imediatamente óbvio ( "arr [:] faz uma cópia, o mesmo acontece del exclusão que copiar ???" etc.)O tutorial do Python fala sobre isso (role um pouco para baixo até chegar à parte sobre fatiar).
O diagrama de arte ASCII também é útil para lembrar como as fatias funcionam:
fonte
a[-4,-6,-1]
ser,yP
mas éty
. O que sempre funciona é pensar em caracteres ou slots e usar a indexação como um intervalo semiaberto - abertura à direita se for positivo, abertura à esquerda se for um passo negativo.x[:0]
acontece quando se inicia do início), então você precisa criar matrizes pequenas para casos especiais. : /Enumerando as possibilidades permitidas pela gramática:
Claro se
(high-low)%stride != 0
, então o ponto final será um pouco menor quehigh-1
.E se
stride
for negativo, a ordem será alterada um pouco, pois estamos em contagem regressiva:Fatias estendidas (com vírgulas e elipses) são usadas principalmente apenas por estruturas de dados especiais (como NumPy); as seqüências básicas não as suportam.
fonte
repr
__getitem__
é; seu exemplo é equivalente aapple[slice(4, -4, -1)]
.As respostas acima não discutem a atribuição de fatia. Para entender a atribuição de fatia, é útil adicionar outro conceito à arte ASCII:
Uma heurística é, para uma fatia de zero a n, pense: "zero é o começo, comece do começo e coloque n itens em uma lista".
Outra heurística é: "para qualquer fatia, substitua o início por zero, aplique a heurística anterior para chegar ao final da lista e conte o primeiro número de volta para cortar os itens do início"
A primeira regra da atribuição de fatia é que, como a fatia retorna uma lista, a atribuição de fatia exige uma lista (ou outra iterável):
A segunda regra de atribuição de fatia, que você também pode ver acima, é que qualquer parte da lista é retornada pela indexação de fatia, é a mesma parte que é alterada pela atribuição de fatia:
A terceira regra de atribuição de fatia é que a lista atribuída (iterável) não precisa ter o mesmo comprimento; a fatia indexada é simplesmente cortada e substituída em massa pelo que estiver sendo atribuído:
A parte mais difícil de se acostumar é a atribuição de fatias vazias. Usando as heurísticas 1 e 2, é fácil indexar uma fatia vazia:
E depois que você vê isso, a atribuição de fatia à fatia vazia também faz sentido:
Observe que, como não estamos alterando o segundo número da fatia (4), os itens inseridos sempre se comparam com o 'o', mesmo quando estamos atribuindo a fatia vazia. Portanto, a posição para a atribuição de fatia vazia é a extensão lógica das posições para as atribuições de fatia não vazias.
Fazendo um backup, o que acontece quando você continua com nossa procissão de contagem do início da fatia?
Com a fatia, uma vez que você termina, você termina; não começa a cortar para trás. No Python, você não obtém avanços negativos, a menos que você os solicite explicitamente usando um número negativo.
Existem algumas consequências estranhas na regra "quando terminar, pronto":
De fato, comparado à indexação, o fatiamento do Python é bizarramente à prova de erros:
Às vezes, isso pode ser útil, mas também pode levar a um comportamento estranho:
Dependendo da sua aplicação, isso pode ... ou não ... ser o que você estava esperando lá!
Abaixo está o texto da minha resposta original. Tem sido útil para muitas pessoas, então eu não queria excluí-lo.
Isso também pode esclarecer a diferença entre fatiar e indexar.
fonte
Em suma, os pontos (
:
) em notação subscrita (subscriptable[subscriptarg]
) Faz notação slice - que tem os argumentos opcionais,start
,stop
,step
:A fatia de Python é uma maneira computacionalmente rápida de acessar metodicamente partes de seus dados. Na minha opinião, para ser um programador intermediário de Python, é um aspecto da linguagem com a qual é necessário estar familiarizado.
Definições importantes
Para começar, vamos definir alguns termos:
Como funciona a indexação
Você pode criar qualquer um desses números positivos ou negativos. O significado dos números positivos é simples, mas para números negativos, assim como índices em Python, você contar para trás a partir do final para o início e parada , e para a etapa , você simplesmente diminuir o seu índice. Este exemplo é do tutorial da documentação , mas eu o modifiquei um pouco para indicar qual item de uma sequência cada índice faz referência:
Como funciona o fatiamento
Para usar a notação de fatia com uma sequência que a suporta, você deve incluir pelo menos um dois pontos entre colchetes que seguem a sequência (que realmente implementa o
__getitem__
método da sequência, de acordo com o modelo de dados Python ).A notação de fatia funciona assim:
E lembre-se de que existem padrões para iniciar , parar e etapa , para acessar os padrões, simplesmente deixe de fora o argumento.
A notação de fatia para obter os últimos nove elementos de uma lista (ou qualquer outra sequência que a suporte, como uma string) ficaria assim:
Quando vejo isso, li a parte entre parênteses como "9ª do fim até o fim". (Na verdade, eu abrevio isso mentalmente como "-9, em")
Explicação:
A notação completa é
e para substituir os padrões (na verdade, quando
step
é negativo,stop
o padrão é-len(my_list) - 1
, portanto,None
para parar realmente significa que ele vai para a etapa final que leva):O cólon ,
:
, é o que diz ao Python que você está dando-lhe uma fatia e não um índice regular. É por isso que a maneira idiomática de fazer uma cópia superficial das listas no Python 2 éE limpá-los é com:
(Python 3 obtém um método
list.copy
elist.clear
.)Quando
step
negativo, os padrõesstart
e asstop
alterações sãoPor padrão, quando o
step
argumento está vazio (ouNone
), é atribuído a+1
.Mas você pode passar um número inteiro negativo e a lista (ou a maioria das outras slicables padrão) será cortada do fim ao começo.
Assim, uma fatia negativa alterará os padrões para
start
estop
!Confirmando isso na fonte
Eu gosto de incentivar os usuários a lerem a fonte e a documentação. O código fonte dos objetos de fatia e essa lógica são encontrados aqui . Primeiro, determinamos se
step
é negativo:Nesse caso, o limite inferior
-1
significa que cortamos todo o caminho até o início, inclusive, e o limite superior é o comprimento menos 1, o que significa que começamos no final. (Observe que a semântica disso-1
é diferente da-1
que os usuários podem passar índices no Python, indicando o último item.)Caso contrário,
step
é positivo, e o limite inferior será zero e o limite superior (que subimos, mas não incluindo) o comprimento da lista fatiada.Então, talvez seja necessário aplicar os padrões para
start
estop
- o padrão então parastart
é calculado como o limite superior quandostep
for negativo:e
stop
, o limite inferior:Dê um nome descritivo às suas fatias!
Você pode achar útil separar a formação da fatia da passagem para o
list.__getitem__
método ( é isso que os colchetes fazem ). Mesmo se você não é novo nele, ele mantém seu código mais legível, para que outras pessoas que precisam ler seu código possam entender mais facilmente o que está fazendo.No entanto, você não pode simplesmente atribuir alguns números inteiros separados por dois pontos a uma variável. Você precisa usar o objeto de fatia:
O segundo argumento,,
None
é necessário, para que o primeiro argumento seja interpretado como ostart
argumento, caso contrário, seria ostop
argumento .Você pode passar o objeto de fatia para sua sequência:
É interessante que os intervalos também tomem fatias:
Considerações sobre memória:
Como fatias de listas Python criam novos objetos na memória, outra função importante a ser observada é
itertools.islice
. Normalmente, você deseja iterar sobre uma fatia, e não apenas criar estaticamente na memória.islice
é perfeito para isso. Uma ressalva, ele não suporta argumentos negativos parastart
,stop
oustep
, portanto, se esse é um problema, pode ser necessário calcular índices ou reverter o iterável antecipadamente.e agora:
O fato de as fatias da lista fazerem uma cópia é um recurso das próprias listas. Se você estiver cortando objetos avançados como um DataFrame do Pandas, ele poderá retornar uma exibição no original, e não uma cópia.
fonte
E algumas coisas que não eram imediatamente óbvias para mim quando vi a sintaxe da fatia:
Maneira fácil de reverter seqüências!
E se você quisesse, por algum motivo, cada segundo item na sequência reversa:
fonte
No Python 2.7
Corte em Python
Compreender a atribuição de índice é muito importante.
Quando você diz [a: b: c], está dizendo que, dependendo do sinal de c (para frente ou para trás), comece em a e termine em b (excluindo o elemento no b-ésimo índice). Use a regra de indexação acima e lembre-se de que você encontrará apenas elementos neste intervalo:
Mas esse intervalo continua nas duas direções infinitamente:
Por exemplo:
Se sua escolha de a, bec permitir sobreposição com o intervalo acima, conforme você percorre as regras de a, b, c acima, você obterá uma lista com elementos (tocados durante a travessia) ou obterá uma lista vazia.
Uma última coisa: se aeb são iguais, você também recebe uma lista vazia:
fonte
a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]; a[:-2:-2]
que resulta em[9]
Encontrei esta excelente tabela em http://wiki.python.org/moin/MovingToPythonFromOtherLanguages
fonte
Depois de usá-lo um pouco, percebo que a descrição mais simples é que é exatamente o mesmo que os argumentos em um
for
loop ...Qualquer um deles é opcional:
Em seguida, a indexação negativa precisa apenas que você adicione o comprimento da sequência aos índices negativos para entendê-la.
Isso funciona para mim de qualquer maneira ...
fonte
Acho mais fácil lembrar como funciona e, em seguida, posso descobrir qualquer combinação específica de início / parada / etapa.
É instrutivo entender
range()
primeiro:Comece de
start
, incremente porstep
, não alcancestop
. Muito simples.O que deve ser lembrado sobre o passo negativo é que esse
stop
é sempre o fim excluído, seja ele maior ou menor. Se você deseja a mesma fatia na ordem oposta, é muito mais fácil fazer a reversão separadamente: por exemplo,'abcde'[1:-2][::-1]
corta um caractere da esquerda, dois da direita e depois inverte. (Veja tambémreversed()
.)O fatiamento da sequência é o mesmo, exceto que ele normaliza primeiro os índices negativos e nunca pode sair da sequência:
TODO : O código abaixo tinha um erro com "nunca sair da sequência" quando abs (etapa)> 1; Eu acho que o corrigi para estar correto, mas é difícil de entender.
Não se preocupe com os
is None
detalhes - lembre-se de que a omissãostart
e / oustop
sempre faz a coisa certa para fornecer toda a sequência.A normalização de índices negativos primeiro permite que o início e / ou a parada sejam contados a partir do final independentemente:
'abcde'[1:-2] == 'abcde'[1:3] == 'bc'
apesarrange(1,-2) == []
. Às vezes, a normalização é considerada "módulo do comprimento", mas observe que ele adiciona o comprimento apenas uma vez: por exemplo,'abcde'[-53:42]
é apenas a string inteira.fonte
this_is_how_slicing_works
é o mesmo que fatia python. O EG[0, 1, 2][-5:3:3]
obterá [0] em python, maslist(this_is_how_slicing_works([0, 1, 2], -5, 3, 3))
obterá [1].range(4)[-200:200:3] == [0, 3]
maslist(this_is_how_slicing_works([0, 1, 2, 3], -200, 200, 3)) == [2]
. Meuif 0 <= i < len(seq):
foi uma tentativa de implementar "nunca saia da sequência" simplesmente, mas está errado na etapa> 1. Vou reescrevê-lo hoje mais tarde (com testes).Eu mesmo uso o método "um índice aponta entre elementos" para pensar sobre isso, mas uma maneira de descrevê-lo que às vezes ajuda os outros a entender é:
X é o índice do primeiro elemento que você deseja.
Y é o índice do primeiro elemento que você não deseja.
fonte
Espero que isso ajude você a modelar a lista em Python.
Referência: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages
fonte
Notação de fatia do Python:
start
eend
, valores negativos são interpretados como sendo relativos ao final da sequência.end
indicam a posição após o último elemento a ser incluído.[+0:-0:1]
.start
eend
A notação se estende a matrizes (numpy) e matrizes multidimensionais. Por exemplo, para dividir colunas inteiras, você pode usar:
As fatias contêm referências, não cópias, dos elementos da matriz. Se você deseja fazer uma cópia separada em uma matriz, pode usar
deepcopy()
.fonte
Você também pode usar a atribuição de fatia para remover um ou mais elementos de uma lista:
fonte
Isto é apenas para informações adicionais ... Considere a lista abaixo
Alguns outros truques para reverter a lista:
fonte
É assim que ensino fatias para iniciantes:
Entendendo a diferença entre indexação e fatia:
O Wiki Python tem essa imagem incrível que distingue claramente a indexação e o fatiamento.
É uma lista com seis elementos. Para entender melhor o fatiamento, considere essa lista como um conjunto de seis caixas juntas. Cada caixa tem um alfabeto.
A indexação é como lidar com o conteúdo da caixa. Você pode verificar o conteúdo de qualquer caixa. Mas você não pode verificar o conteúdo de várias caixas ao mesmo tempo. Você pode até substituir o conteúdo da caixa. Mas você não pode colocar duas bolas em uma caixa ou substituir duas por vez.
Cortar é como lidar com as próprias caixas. Você pode pegar a primeira caixa e colocá-la em outra mesa. Para pegar a caixa, tudo o que você precisa saber é a posição de início e fim da caixa.
Você pode até pegar as três primeiras caixas ou as duas últimas caixas ou todas as caixas entre 1 e 4. Portanto, você pode escolher qualquer conjunto de caixas se souber o início e o final. Essas posições são chamadas de posições inicial e final.
O interessante é que você pode substituir várias caixas ao mesmo tempo. Além disso, você pode colocar várias caixas onde quiser.
Corte com etapa:
Até agora você selecionou caixas continuamente. Mas, às vezes, você precisa atender discretamente. Por exemplo, você pode escolher cada segunda caixa. Você pode até pegar todas as caixas do final. Este valor é chamado tamanho da etapa. Isso representa a lacuna entre seus captadores sucessivos. O tamanho da etapa deve ser positivo se você estiver escolhendo caixas do começo ao fim e vice-versa.
Como o Python descobre os parâmetros ausentes:
Ao fatiar, se você deixar de fora algum parâmetro, o Python tenta descobrir isso automaticamente.
Se você verificar o código fonte do CPython , encontrará uma função chamada PySlice_GetIndicesEx () que calcula os índices de uma fatia para qualquer parâmetro. Aqui está o código equivalente lógico no Python.
Essa função utiliza um objeto Python e parâmetros opcionais para fatiar e retorna o comprimento de início, parada, etapa e fatia da fatia solicitada.
Essa é a inteligência que está presente atrás das fatias. Como o Python possui uma função interna chamada slice, você pode passar alguns parâmetros e verificar com que inteligência ele calcula os parâmetros ausentes.
Nota: Esta postagem foi originalmente escrita no meu blog The Intelligence Behind Python Slices .
fonte
Como regra geral, escrever código com muitos valores de índice codificados leva a uma bagunça de legibilidade e manutenção. Por exemplo, se você voltar ao código um ano depois, você o examinará e se perguntará o que estava pensando quando o escreveu. A solução mostrada é simplesmente uma maneira de indicar mais claramente o que seu código está realmente fazendo. Em geral, a fatia interna () cria um objeto de fatia que pode ser usado em qualquer lugar em que uma fatia seja permitida. Por exemplo:
Se você tiver uma instância de fatia s, poderá obter mais informações sobre ela olhando para os atributos s.start, s.stop e s.step, respectivamente. Por exemplo:
fonte
1. Notação de fatia
Para simplificar, lembre-se de que a fatia possui apenas uma forma:
e aqui está como isso funciona:
s
: um objeto que pode ser cortadostart
: primeiro índice para iniciar a iteraçãoend
: último índice, NOTE que esseend
índice não será incluído na fatia resultantestep
: escolher elemento a cadastep
índiceOutra coisa importação: tudo
start
,end
,step
pode ser omitido! E se eles forem omitidas, seu valor padrão será utilizado:0
,len(s)
,1
em conformidade.As variações possíveis são:
NOTA: Se
start >= end
(considerando apenas quandostep>0
), o Python retornará uma fatia vazia[]
.2. Armadilhas
A parte acima explica os principais recursos sobre como a fatia funciona e funcionará na maioria das ocasiões. No entanto, pode haver armadilhas que você deve prestar atenção, e esta parte as explica.
Índices negativos
A primeira coisa que confunde os alunos de Python é que um índice pode ser negativo! Não entre em pânico: um índice negativo significa contar para trás.
Por exemplo:
Etapa negativa
Tornar as coisas mais confusas é que também
step
pode ser negativo!Um passo negativo significa iterar a matriz para trás: do final ao início, com o índice final incluído e o índice inicial excluído do resultado.
NOTA : quando a etapa é negativa, o valor padrão para
start
élen(s)
(whileend
não é igual a0
, porques[::-1]
contéms[0]
). Por exemplo:Erro fora do intervalo?
Surpreenda-se: a fatia não gera um IndexError quando o índice está fora da faixa!
Se o índice estiver fora do intervalo, o Python fará o possível para definir o índice para
0
ou delen(s)
acordo com a situação. Por exemplo:3. Exemplos
Vamos terminar esta resposta com exemplos, explicando tudo o que discutimos:
fonte
As respostas anteriores não discutem o faturamento multidimensional de matrizes, o que é possível usando o famoso pacote NumPy :
O fatiamento também pode ser aplicado a matrizes multidimensionais.
O "
:2
" antes da vírgula opera na primeira dimensão e o "0:3:2
" depois da vírgula opera na segunda dimensão.fonte
list
, mas apenas emarray
em NumpyVocê pode executar esse script e experimentá-lo. Abaixo estão alguns exemplos que eu obtive do script.
Ao usar uma etapa negativa, observe que a resposta é deslocada para a direita por 1.
fonte
Meu cérebro parece feliz em aceitar que
lst[start:end]
contém ostart
quinto item. Eu poderia até dizer que é uma "suposição natural".Mas, ocasionalmente, surge uma dúvida e meu cérebro pede garantias de que não contém o
end
-ésimo elemento.Nestes momentos, confio neste teorema simples:
Esta propriedade muito me diz que
lst[start:end]
não contém oend
item de -ésimo porque ele está emlst[end:]
.Observe que esse teorema é verdadeiro para qualquer
n
um. Por exemplo, você pode verificar seretorna
True
.fonte
Na minha opinião, você entenderá e memorizará melhor a notação de fatiamento de strings do Python se a observar da seguinte maneira (continue lendo).
Vamos trabalhar com a seguinte string ...
Para quem não sabe, você pode criar qualquer substring
azString
usando a notaçãoazString[x:y]
Vindo de outras linguagens de programação, é aí que o senso comum fica comprometido. O que são x e y?
Tive que me sentar e executar vários cenários em minha busca por uma técnica de memorização que me ajudasse a lembrar o que xey eram e me ajudasse a cortar as cordas corretamente na primeira tentativa.
Minha conclusão é que xey devem ser vistos como os índices de contorno que cercam as strings que queremos extrair. Portanto, devemos ver a expressão como
azString[index1, index2]
ou ainda mais clara comoazString[index_of_first_character, index_after_the_last_character]
.Aqui está um exemplo de visualização disso ...
Portanto, tudo o que você precisa fazer é definir index1 e index2 com os valores que cercam a substring desejada. Por exemplo, para obter a subcadeia "cdefgh", você pode usar
azString[2:8]
, porque o índice no lado esquerdo de "c" é 2 e o índice no tamanho certo de "h" é 8.Lembre-se de que estamos estabelecendo limites. E esses limites são as posições em que você pode colocar alguns colchetes que serão enrolados ao redor da substring assim ...
ab [ cdefgh ] ij
Esse truque funciona o tempo todo e é fácil de memorizar.
fonte
A maioria das respostas anteriores esclarece perguntas sobre a notação de fatia.
A sintaxe de indexação estendida usada para fatiar é
aList[start:stop:step]
e exemplos básicos são:Mais exemplos de fatias : 15 fatias estendidas
fonte
No Python, a forma mais básica de fatiar é a seguinte:
onde
l
está uma coleção,start
é um índice inclusivo eend
é um índice exclusivo.Ao fatiar desde o início, você pode omitir o índice zero e, ao fatiar até o final, pode omitir o índice final, pois é redundante, portanto, não seja detalhado:
Inteiros negativos são úteis ao fazer compensações em relação ao final de uma coleção:
É possível fornecer índices que estão fora dos limites ao fatiar, como:
Lembre-se de que o resultado do fatiamento de uma coleção é uma coleção totalmente nova. Além disso, ao usar a notação de fatia em atribuições, o comprimento das atribuições de fatia não precisa ser o mesmo. Os valores antes e depois da fatia atribuída serão mantidos e a coleção será reduzida ou aumentada para conter os novos valores:
Se você omitir o índice inicial e final, você fará uma cópia da coleção:
Se os índices inicial e final forem omitidos ao executar uma operação de atribuição, todo o conteúdo da coleção será substituído por uma cópia do que é referenciado:
Além do fatiamento básico, também é possível aplicar a seguinte notação:
where
l
é uma coleção,start
é um índice inclusivo,end
é um índice exclusivo estep
é um passo que pode ser usado para incluir cada enésimo iteml
.Usar
step
fornece um truque útil para reverter uma coleção em Python:Também é possível usar números inteiros negativos para
step
o seguinte exemplo:No entanto, usar um valor negativo para
step
pode se tornar muito confuso. Além disso, a fim de ser Pythonic , você deve evitar usarstart
,end
estep
em uma única fatia. Caso isso seja necessário, considere fazer isso em duas tarefas (uma para cortar e outra para caminhar).fonte
Quero adicionar um Olá, mundo! exemplo que explica o básico de fatias para os iniciantes. Isto me ajudou bastante.
Vamos ter uma lista com seis valores
['P', 'Y', 'T', 'H', 'O', 'N']
:Agora, as fatias mais simples dessa lista são suas sublistas. A notação é
[<index>:<index>]
e a chave é lê-la assim:Agora, se você fizer uma fatia
[2:5]
da lista acima, isso acontecerá:Você fez um corte antes do elemento com índice
2
e outro corte antes do elemento com índice5
. Portanto, o resultado será uma fatia entre esses dois cortes, uma lista['T', 'H', 'O']
.fonte
Pessoalmente, penso nisso como um
for
loop:Além disso, observe que os valores negativos para
start
eend
são relativos ao final da lista e computados no exemplo acima porgiven_index + a.shape[0]
.fonte
A seguir, o exemplo de um índice de uma string:
Exemplo de fatia: [start: end: step]
Abaixo está o exemplo de uso:
fonte
Se você acha que os índices negativos no fatiamento são confusos, aqui está uma maneira muito fácil de pensar sobre isso: basta substituir o índice negativo por
len - index
. Por exemplo, substitua -3 porlen(list) - 3
.A melhor maneira de ilustrar o que o fatiamento faz internamente é apenas mostrá-lo no código que implementa esta operação:
fonte
A técnica básica de fatiar é definir o ponto de partida, o ponto de parada e o tamanho do passo - também conhecido como passada.
Primeiro, criaremos uma lista de valores para usar em nosso fatiamento.
Crie duas listas para fatiar. A primeira é uma lista numérica de 1 a 9 (Lista A). O segundo também é uma lista numérica, de 0 a 9 (Lista B):
Indexe o número 3 de A e o número 6 de B.
Fatiamento básico
A sintaxe de indexação estendida usada para fatiar é aList [start: stop: step]. O argumento inicial e o argumento da etapa assumem como padrão nenhum - o único argumento necessário é parar. Você percebeu que isso é semelhante ao modo como o intervalo foi usado para definir as listas A e B? Isso ocorre porque o objeto de fatia representa o conjunto de índices especificados pelo intervalo (iniciar, parar, etapa). Documentação do Python 3.4.
Como você pode ver, definir apenas stop retorna um elemento. Como o início não é padrão, isso significa recuperar apenas um elemento.
É importante notar que o primeiro elemento é o índice 0, não índice 1. É por isso que estamos usando 2 listas para este exercício. Os elementos da lista A são numerados de acordo com a posição ordinal (o primeiro elemento é 1, o segundo elemento é 2 etc.) enquanto os elementos da lista B são os números que seriam usados para indexá-los ([0] para o primeiro elemento 0, etc.)
Com a sintaxe de indexação estendida, recuperamos um intervalo de valores. Por exemplo, todos os valores são recuperados com dois pontos.
Para recuperar um subconjunto de elementos, as posições de início e parada precisam ser definidas.
Dado o padrão aList [start: stop], recupere os dois primeiros elementos da Lista A.
fonte
Eu não acho que o diagrama tutorial do Python (citado em várias outras respostas) seja bom, pois essa sugestão funciona com passos positivos, mas não com passos negativos.
Este é o diagrama:
Do diagrama, espero
a[-4,-6,-1]
ser,yP
mas éty
.O que sempre funciona é pensar em caracteres ou slots e usar a indexação como um intervalo semiaberto - abertura à direita se for positivo, abertura à esquerda se for um passo negativo.
Dessa forma, eu posso pensar
a[-4:-6:-1]
comoa(-6,-4]
na terminologia de intervalo.fonte