Ver Feed RSS

root@blog:/# chmod o+r *

[Curso de Python] O Que é slicing?!

Avalie este Post de Blog

Antes de prosseguir leia os artigos anteriores aqui



Agora vamos ver uma ferramenta de utilização recorrente em Python: Slicing.

Já aviso que não vou aprofundar muito, vou tratar somente o básico, pois vou voltar nesse assunto nos próximos posts mas abordando o slicing pra cada tipo de dado em python.

Slicing



Primeiro vocês devem estar se perguntando "o que é slicing?!". Slicing traduzindo ao pé da letra significa fatiar, mas como certas coisas em portugês não soam tão bem em inglês vou continuar usando o termo slicing.


Mas o que viria a ser slicing?!
Slicing é um "conceito" utilizado em Python para o acesso a uma porção de todo. Fica mais claro com um exemplo:
Digamos que eu tenha a seguinte string: "Este e um teste"
Se eu quiser extrair somente a palavra "Este" eu preciso pegar uma porção (palavra "Este") de um todo (string "Este e um teste").
Esse conceito não se restringe apenas às strings mas a vário tipos como tuplas, listas e dicionários.


Como fazer slicing?!
O processo de slicing em todos os tipos é idêntico para todos os tipos em Python com exceção do dicionário.

Para fazer um slicing tudo que precisamos é de um tipo de dado que seja iterável, ou seja, que suporte iteração. Dentre os tipos de dados que vimos até agora, os iteráveis são: strings, tuplas, listas e dicionários.

O "operador" do slicing é o colchete. Vocês devem estar ser perguntando, "mas o colchete não é usado nas listas?". Sim, mas aqui será usado de uma forma diferente. Vamos a um exemplo:
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> bandas[0]
'Rush'
>>> print bandas[0]
Rush
>>>
Vamos ver algumas designações:


No exemplo acima, criei uma lista com 4 ítens. Após isso chamei o ítem de índice zero ('Rush'), notem que ele foi simplesmente ecoado, eu não fiz nenhuma operação nele. Já na última linha chamei ele com o comando print.

Vamos continuar com o exemplo:
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> print bandas[0]
Rush
>>> print bandas[1]
The Cure
>>> print bandas[2]
Pink Floyd
>>> print bandas[3]
The Doors
>>> print bandas[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>>
Ops, um erro!! Como eu disse, minha lista tem apenas 4 ítens, de 0 a 3. Muita atenção, não se esqueçam que a contagem começa do 0!


Alterando dados
É importante entender que ao escrever 'bandas[0]' eu estou acessando o ítem de posição 0 que neste caso está sendo ocupado pela string "Rush":
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> type(bandas)
<type 'list'>
>>> type(bandas[0])
<type 'str'>
>>>
Como podem ver, bandas[0] é uma string como qualquer outra. Vamos alterá-la:
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> print bandas[1]
The Cure
>>> bandas[1] = 'Counting Crows'
>>> print bandas
['Rush', 'Counting Crows', 'Pink Floyd', 'The Doors']
>>>
Simples não?! Apenas utilizamos bandas[1] como se fosse uma variável e atribuímos outro valor! Mas não vamos nos aprofundar nesse assunto ainda...


Argumentos "especiais"
Existem alguns índices "diferentes" que podemos utilizar durante o processo de slicing. Vamos ver alguns:
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> bandas[-1]
'The Doors'
>>> bandas[-2]
'Pink Floyd'
>>>
Ao utilizar índices negativos o slicing é feito de trás pra frente, logo o -1 indica o último ítem da lista, enquanto o -2 indica o penúltimo e assim por diante.

Existe também o a possibilidade de pegar intervalos:
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> bandas[2]
'Pink Floyd'
>>>
>>> bandas[0:2]
['Rush', 'The Cure']
>>>
Para pegar o intervalo utilizamos o operador : dentro dos colchetes. Ele indica o intervalo que queremos pegar. No exemplo acima seria o intervalo de 0 a 2. Isso pode parecer um pouco estranho, já que o item de índice 2 é "Pink Floyd" porém ele não entra no intervalo. Na verdade o Python intende a lista e tuplas da seguinte forma:


Agora fica claro porque quando fazemos [0:2] (de 0 a 2) o Pink Floyd não entra na história! Isso também ajuda a entender porque ele comça a contar de zero. Na verdade quando chamamos bandas[1], o python interpreta como bandas[1:2].

Existe também a possibilidade de utilizar os índices negativos e omitir alguns operadores. Segue o exemplo:
Código :
>>> bandas = ["Rush", "The Cure", "Pink Floyd", "The Doors"]
>>> bandas[0:2]
['Rush', 'The Cure']
>>> 
>>> bandas[:2]
['Rush', 'The Cure']
>>> 
>>> bandas[2:4]
['Pink Floyd', 'The Doors']
>>>
>>> bandas[2:]
['Pink Floyd', 'The Doors']
>>> 
>>> bandas[1:-1]
['The Cure', 'Pink Floyd']
A omissão de um número do lado esquerdo dos dois pontos é compreendido como sendo o início da lista. Já a omissão de um número ao lado direito dos dois pontos é compreendido como sendo o fim da lista, nessa caso 4.

Existe também o operador ::, mas esse eu quero que vocês façam testes e me digam como ele funciona! Façam testes com as seguintes linhas:
Código :
>>> bandas[::]
>>> bandas[::-1]
>>> bandas[::2]
>>> bandas[1::2]
Analisem e postem nos comentários o que vocês entenderam dele.

Até mais...

Atualizado 01-09-2010 em 09:08 por Magnun

Categorias
Python , Artigos , Artigos , Cursos , Curso de Python

Comentários

Página 1 de 3 123 ÚltimoÚltimo
  1. Avatar de krixapolinario
    Muito Bom Magnun. Parabéns mais uma vez pelo iniciativa deste curso. :D

    []'s
  2. Avatar de ilsahec
    Boa aula
  3. Avatar de PEdroArthurJEdi
    Rapaz! Essa foi a mais massa, até hoje... Quero ver as de List Comprehensions.

    Cara, foi boa para relembrar. Havia esquecido que o operador de slicing leva três argumentos:
    Código :
    iteravel[indiceinicial:indicefinal:passo]
    Todos os três opcionais.

    Ou seja,
    Código :
    >>> bandas[::]
    ['Rush', 'The Cure', 'Pink Floyd', 'The Doors']
    >>> bandas[::-1]
    ['The Doors', 'Pink Floyd', 'The Cure', 'Rush']
    >>> bandas[::2]
    ['Rush', 'Pink Floyd']
    >>> bandas[1::2]
    ['The Cure', 'The Doors']
    No primeiro caso, estariamos dizendo: do índice zero ao índice final com passo padrão; já no segundo, "do índice inicial ao índice final com passo -1", o que resulta no percurso do elemento iterável ocorra de trás para frente; o terceiro apresenta o passo positvo de valor dois, o que leva a não seleção do índices 1 e 3; e quarto já dá para inferir...

    Parabéns, continue o ótimo trabalho!
  4. Avatar de Magnun
    Mandou bem Cara!!! Eu não teria explicado melhor!!
  5. Avatar de ilsahec
    como sempre muito bom
Página 1 de 3 123 ÚltimoÚltimo

+ Enviar Comentário



Visite: BR-Linux ·  VivaOLinux ·  Dicas-L