Tudo sobre operações de corte em Python

Para todos os programadores do Python, seja no domínio da ciência de dados e do aprendizado de máquina ou do desenvolvimento de software program, as operações de fatiamento de Python são uma das operações mais eficientes, versáteis e poderosas. A sintaxe do fatiamento de python permite a extração e modificação de estruturas de dados, como listas, cordas, tuplas, matrizes, Pandas DataFramese até sequências de bytes. Se temos que extrair uma seção do fatiamento da lista em Python, manipular caracteres usando o fatiamento de string ou apenas querer otimizar o fluxo de trabalho, o Slicing oferece uma maneira concisa de trabalhar com dados sem o uso de loops complexos ou indexação handbook. Nesta Python Tutorial de corte, nos aprofundaremos em como as operações de fatiamento do Python funcionam e aprenderemos como usá -las efetivamente em programas e fluxos de trabalho.

O que são operações de corte em Python?

Fatiar significa cortar. Da mesma forma, em Python, significa acessar ou extrair uma subsédula (porção) de uma sequência (como cordasAssim, listasAssim, Tuplasou matrizes) especificando uma variedade de índices. Operações de corte no Python envolvem o uso de operadores de cólon (:) Dentro dos colchetes. A sintaxe básica envolve:

(Iniciar: Fim: Etapa)
COMEÇAR: Begin é o índice de onde o fatiamento começa.
FIM: Ultimate é o ponto de índice até o qual a operação será realizada, ou seja, não está incluída no
operação.
ETAPA: Etapa é o índice de incremento. Seu valor padrão é 1, o que significa que toda a sequência será a saída. Se a etapa = 2, todo valor alternativo será impresso.

Por que usar o fatiamento?

O corte é um método importante, pois nos permite acessar e manipular os dados concisamente, tornando o código mais legível e versátil nas estruturas de dados. Por exemplo:

Iterando sem fatiar

lst = (1, 2, 3, 4, 5)
sublist = ()
for i in vary(1, 4):
   sublist.append(lst(i))
print(sublist)

Iterando com fatiamento

lst = (1, 2, 3, 4, 5)
sublist = lst(1:4)
print(sublist)

Saída: (2, 3, 4)

Métodos de corte em Python

Basicamente, o Python oferece 2 maneiras diferentes de fatiar. Um é (Iniciar: Fim: Etapa) E o outro é o .Slice (Begin, Cease, Step) função. Nesta seção, primeiro passaremos pela sintaxe dessas operações de corte, depois disso exploraremos os principais tipos de fatiamento que podemos executar no Python.

1. Usando (Iniciar: Fim: Etapa)

Esta é a maneira mais comum de executar a operação de fatiamento em diferentes partes da sequência de entrada.

Cortando com índice (:) exemplos

mixed_data = (10, "apple", 3.14, "banana", 42, "cherry")


# Slice from index 1 to 4
print(mixed_data(1:4)) 
print(20*"--")
# Slice the checklist from the begin to index 3
print(mixed_data(:3)) 
print(20*"--")
# Slice each 2nd factor
print(mixed_data(::2))

1. Usando a função python slice ()

A função de fatia permite criar um objeto de fatia, que será aplicado à sequência. Isso ajuda quando você deseja armazenar as especificações da fatia e aplicá -las a várias seqüências.

Sintaxe de .slice ()

fatia (iniciar, parar, passo)

começar: O índice inicial da fatia (inclusive).
parar: O índice de parada da fatia (exclusivo).
etapa: A etapa ou o passo (quanto para incrementar o índice após cada etapa, opcional).

Cortando com fatia (). Exemplos

textual content = "Hey, world!"
# Create a slice object to get the primary 5 characters
s = slice(0, 5)
# Apply the slice object to the string
print(textual content(s)) 
# Output: "Hey"

Cortando cada terceiro elemento

mixed_data = (10, "apple", 3.14, "banana", 42, "cherry")
s = slice(None, None, 3)
# Apply the slice object to the checklist
print(mixed_data(s)) 
# Output: (10, 'banana')

Fatiar do índice 2 até o fim

s = slice(2, None)
# Apply the slice object to the checklist
print(mixed_data(s)) 
# Output: (3.14, 'banana', 42, 'cherry')

Fatiar em ordem inversa

s = slice(None, None, -1)
# Apply the slice object to the checklist
print(mixed_data(s)) 
# Output: ('cherry', 42, 'banana', 3.14, 'apple', 10)

Agora vamos analisar os principais tipos de operações de corte no Python

1. Fatiamento básico

O fatiamento básico refere -se à extração de uma subseqüência para tipos de dados, como string, lista ou tupla usando sintaxe (begin: finish: step). É uma ferramenta basic no Python que nos permite recuperar as subsequências facilmente. Ele também funciona com uma variedade de tipos de dados, tornando -o uma técnica versátil.

numbers = (10, 20, 30, 40, 50, 60)
# Slice from index 1 to index 4 (unique)
print(numbers(1:4)) 
# Output: (20, 30, 40)

textual content = "Hey, world!"
# Slice from index 7 to index 12 (unique)
print(textual content(7:12)) 
# Output: "world"

numbers_tuple = (1, 2, 3, 4, 5, 6)
# Slice from index 2 to index 5 (unique)
print(numbers_tuple(2:5)) 
# Output: (3, 4, 5)

2. Omitindo ‘begin’, ‘cease’ ou ‘step’

Omitir o início, o intervalo e o intervalo de fatias permite que os usuários usem valores padrão.

• Omitir os padrões iniciais para o início da sequência.
• O omitir parada significa que a fatia vai até o remaining.
• Omitir a etapa padrão para uma etapa de 1.

A remoção dessas peças torna o código mais conciso e flexível. Ele permite criar fatias dinâmicas e generalizadas sem definir explicitamente todos os parâmetros.

Modificando listas com fatiamento

numbers = (10, 20, 30, 40, 50, 60)
# Omitting begin, slice from the start to index 4 (unique)
print(numbers(:4)) 
# Output: (10, 20, 30, 40)


# Omitting cease, slice from index 2 to the tip
print(numbers(2:)) 
# Output: (30, 40, 50, 60)

Fatia vazia

numbers_tuple = (1, 2, 3, 4, 5, 6)
# Omitting begin and step, slice the entire tuple
print(numbers_tuple(:)) 
# Output: (1, 2, 3, 4, 5, 6)

Excluir elementos

numbers = (2,4,5,12,64,45)
numbers(1:4) = ()


print(numbers)
# Output: (2,64,45)

3. Fatia negativa

A indexação negativa permite a contagem do remaining de uma sequência. Na indexação negativa, -1 refere -se ao último elemento e -2 refere -se ao segundo último. Ajuda quando você precisa acessar elementos do remaining de uma sequência.

Acessando os últimos elementos

numbers = (10, 20, 30, 40, 50, 60)
# Slice on the final index
print(numbers(-1)) 
# Output: (60)

Revertendo uma string

original_string = "hey"
reversed_string = original_string(::-1)
print(reversed_string) 
# Output: "olleh"

4. Fatiando usando a etapa

O parâmetro de etapa permite especificar o intervalo entre os elementos, tornando -o útil ao processar dados ou amostragem. Uma etapa negativa pode reverter a sequência facilmente, como visto acima, tornando muito fácil e conveniente reverter todos os dados.

Cortando cada segundo elemento

numbers = (10, 20, 30, 40, 50, 60)
# Slice with step 2, choosing each second factor
print(numbers(::2)) 
# Output: (10, 30, 50)

Comportamento confuso da etapa

numbers = (10, 20, 30, 40, 50, 60)
# Slice finally index
print(numbers(::-3)) 
# Output: (60,30)

5. Cortando sem nenhum

Na fatia, nenhum pode ser usado para representar o valor padrão para iniciar, parar e terminar. Usar nenhum permite mais flexibilidade e clareza na programação. É uma maneira de aplicar o comportamento de fatiamento padrão sem defini -los manualmente.

Omitindo usando nenhum

numbers = (10, 20, 30, 40, 50, 60)
# Slice each 2nd factor utilizing slice(None, None, 2)
s = slice(None, None, 2)
print(numbers(s)) 
# Output: (10, 30, 50)

6

Quando você tenta cortar uma sequência além de seus limites (com índices grandes ou com índices -ve de alcance), ela não levantará nenhum erro no Python e simplesmente retorna a maior fatia válida sem se preocupar com as exceções.

numbers = (10, 20, 30, 40, 50, 60)
# Slice past the size of the checklist
print(numbers(4:15)) 
# Output: (50, 50)

Cortando além do comprimento

textual content = "Hey, world!"
# Slice past the size
print(textual content(15:55))
# Output: no output

7. Fatia de matriz numpy

Em Numpy, o fatiamento também funciona de maneira semelhante ao fatiamento básico do Python. Além disso, o Numpy é projetado especificamente para computação científica e também permite manipulação de dados mais rápida. Isso ajuda a apoiar ainda mais operações mais avançadas e eficientes para grandes conjuntos de dados. O fatiamento permite que o Numpy acesse sub-maiores de teatro e também os modifique com eficiência (ou seja, permitindo modificar os subarrays).

Cortando matrizes 1-D

import numpy as np
# Create a 1-D NumPy array
arr = np.array((10, 20, 30, 40, 50, 60))
# Slice from index 1 to index 4 (unique)
print(arr(1:4)) 
# Output: (20 30 40)

Como o fatiamento básico, ele nos permite cortar a matriz do índice 1 a 4 (exclusivo), assim como o fatiamento common do Python. Também permite executar todas as outras operações discutidas acima, em matrizes também.

# Slice each second factor from the array
print(arr(::2)) 
# Output: (10 30 50)

Cortando através de matrizes multidimensionais

# Create a 2-D NumPy array (matrix)
arr_2d = np.array(((10, 20, 30), (40, 50, 60), (70, 80, 90)))
# Slice from row 1 to row 2 (unique), and columns 1 to 2 (unique)
print(arr_2d(1:2, 1:3)) 
# Output: ((50 60))

8. Pandas DataFrame Flieting

Os quadros de dados do PANDAS são estruturas de dados marcadas bidimensionais que também suportam operações de fatiamento. Permite cortar os pontos de dados através de .loc () e .iloc (). Junto com isso, os pandas também suportam indexação booleana.

Cortar o quadro de dados permite filtrar e manipular grandes conjuntos de dados com eficiência. Ele permite selecionar subconjuntos de dados usando condições, tornando -o uma ferramenta valiosa para análise de dados e aprendizado de máquina.

Fatiando usando o índice de linha (.iloc)

import pandas as pd

# Create a DataFrame
df = pd.DataFrame({
   'A': (1, 2, 3, 4, 5),
   'B': (10, 20, 30, 40, 50)
})
print(df)
# Output
#    A   B
# 0  1  10
# 1  2  20
# 2  3  30
# 3  4  40
# 4  5  50


# Slice the primary three rows (unique of the fourth row)
print(df.iloc(:3))
#    A   B
# 0  1  10
# 1  2  20
# 2  3  30

Aqui, o .Iloc (3) corta as 3 primeiras linhas (índice 0 a 2) do DataFrame.

Fatiando usando o nome da coluna (.loc)

# Create a DataFrame
df = pd.DataFrame({
   'A': (1, 2, 3, 4, 5),
   'B': (10, 20, 30, 40, 50)
})
print(df)
# Output
#    A   B
# 0  1  10
# 1  2  20
# 2  3  30
# 3  4  40
# 4  5  50
print(df.loc(df('A') > 2)) 
# Output:
#    A   B
# 2  3  30
# 3  4  40
# 4  5  50

O .Loc permite cortar os rótulos com nomes de colunas ou como um índice como false. Aqui, estamos cortando com base na condição de que o valor da coluna “A” deve ser maior que 2.

9. Flicicamento de sequência de bytes

O Python oferece sequências de bytes como bytes e bytearray, que apóiam fatiando como listas, strings ou matrizes. A sequência de bytes entra em cena quando estamos usando os tipos de dados binários, e o fatiamento permite extrair partes relevantes de dados binários com facilidade e eficiência.

Cortando um objeto de byte

byte_seq = b'Hey, world!'
# Slice from index 0 to index 5 (unique)
print(kind(byte_seq))
print(byte_seq(:5)) 
# Output: , b'Hey'

Corte um bytearray (bytes mutáveis)

byte_arr = bytearray((10, 20, 30, 40, 50, 60))

# Slice from index 2 to index 5 (unique)
print(byte_arr(2:5)) 
# Output: bytearray(b'2x1e<')

Aqui, a saída está em valores correspondentes a caracteres ASCII. Isso acontece quando a saída não está no intervalo imprimível. Portanto, bytearray (b’2 x1e <') é a saída porque representa esses valores de bytes de uma forma mais legível pelo homem.

print(checklist(byte_arr(2:5)))  # Output: (30, 40, 50)
# Ouput: (30,40,50)

Benefícios do uso de fatiamento em python

Existem muitos benefícios do uso de operações de corte em Python, incluindo:

• Eficiência: O fatiamento permite o acesso rápido da sub-sequência desejada de conjuntos de dados maiores sem a necessidade de fazer loop.
• Concisão: Permite um código mais conciso e legível para manipulação de dados.
• Flexibilidade: Com a ajuda de bibliotecas como Numpy e Pandas, cortar dados multidimensionais adiciona uma maneira eficiente de pré -processamento de dados.
• Eficiente de memória: O fatiamento é otimizado para desempenho. Além disso, o mecanismo interno do Python garante que as operações de corte sejam rápidas e eficientes em memória, ao contrário da indexação handbook, que exige muita codificação handbook e aumenta o uso da memória.

Coisas a serem evitadas ao usar operações de fatiamento

Aqui estão algumas coisas a serem evitadas ao usar operações de fatiamento no Python.

• Exceder os limites do índice: O corte além do comprimento da sequência não causará nenhum erro no Python. No entanto, isso pode resultar em resultados indesejados, especialmente ao trabalhar com conjuntos de dados maiores.
• Indexação confusa Sintaxe e fatiante: A sintaxe do fatiamento envolve sequência (Iniciar: Cease: Fim), mas a seleção do índice/posição do elemento que desejamos também fornecerá o elemento desejado.
• Cortar sem considerar a mutabilidade: O fatiamento pode ser usado para modificar a sequência, mas, para usar isso, é preciso considerar se o tipo de dados com o qual está lidando suporta a mutabilidade ou não. Por exemplo, listas e matrizes de bytes são mutáveis; Por outro lado, cordas, tuplas e bytes são imutáveis. Portanto, eles não podem ser modificados diretamente através do fatiamento.
• Cortando com valores de etapas inválidas: Ao usar o fatiamento, é preciso também considerar a etapa, pois decidirá quantos pontos serão ignorados no meio. Mas o uso de um valor inválido pode levar a resultados inesperados, causando operações ineficientes.

Conclusão

O corte no Python é uma maneira eficiente e poderosa que permite acessar e manipular com eficiência os tipos de dados do Python, como listas, strings, tuplas, matrizes de numpy e quadros de dados de pandas. Portanto, se você está cortando uma lista, trabalhando com matrizes multidimensionais em Numpy ou lidando com grandes conjuntos de dados usando pandas, o corte sempre fornece uma maneira clara e concisa de trabalhar com sequências. Ao dominar o fatiamento, pode -se escrever um código mais limpo e mais eficiente, essencial para todos os programadores do Python.




Oi, eu sou Vipin. Sou apaixonado por ciência de dados e aprendizado de máquina. Tenho experiência em analisar dados, criar modelos e resolver problemas do mundo actual. Pretendo usar dados para criar soluções práticas e continuar aprendendo nas áreas de ciência de dados, aprendizado de máquina e PNL.