Python >> Tutoriel Python >  >> Python

Notation de tranche - Un guide illustré simple

Résumé : Le découpage est un concept Python pour extraire une sous-séquence d'une chaîne ou d'une liste, qui se trouve dans un start et stop plage d'indices. Il existe deux manières syntaxiques de définir une tranche. (1) La notation de tranche étendue utilise deux-points  : en string_name[start:stop:step] . (2) Le slice() le constructeur définit la plage d'index dans string_name[slice(start:stop:step)] .

Voici quelques exemples de base :

Exercice :créez deux autres exemples dans le shell de code interactif.

Découvrons la notation de découpage étape par étape.

Principes de base de l'indexation

Avant de plonger dans notre discussion sur la notation des tranches en Python, examinons rapidement ce que sont les index et comment fonctionne l'indexation.

Un index peut être considéré comme la position d'un élément dans un type de données ordonné (comme un fichier ou un tuple). Une chaîne peut être considérée comme une liste de caractères, chaque caractère ayant un index.

  • L'indexation commence de zéro à la longueur-1.
  • Python prend également en charge l'indexation négative.

Visualisons l'indexation à l'aide d'un schéma :

Maintenant que nous avons une idée des index, plongeons dans notre sujet, c'est-à-dire la notation de tranche.

Introduction au découpage

Définition :

Le découpage fait référence à un concept en Python qui nous permet d'extraire une partie d'une chaîne ou d'une liste ou de toute autre séquence en fonction d'un index de début et de fin donné.

Syntaxe :

  • Le découpage utilise [] avec les arguments start, stop et step séparés par : notation.
  • démarrer détermine l'index à partir duquel le découpage/extraction des éléments de la chaîne/séquence commence.
  • Si le démarre index n'est pas spécifié, il est considéré comme 0.
  • arrêter détermine le dernier index jusqu'au découpage en tranches, cependant, le stop/dernier index est exclu lors de la génération de la sous-chaîne. Cela signifie que le dernier index pris en compte lors de la génération de la sortie (sous-chaîne) est stop-1 . C'est un point très important à retenir pour éviter les sorties inattendues et les bogues dans le code.
  • Si le arrêt index n'est pas spécifié, il est considéré comme la longueur de la chaîne entière ou de la séquence donnée.
  • étape détermine l'incrément entre chaque index lors du découpage de la séquence.
  • C'est un argument facultatif. En fait, les trois arguments sont facultatifs. Nous découvrirons bientôt comment !
  • Si le step n'est pas spécifié, il est considéré comme ayant une valeur par défaut de 1, c'est-à-dire un incrément de 1 entre les index.

Exemple :

Veuillez suivre l'exemple ci-dessous pour avoir un aperçu des concepts discutés ci-dessus. (Veuillez vous assurer de lire les commentaires avec le code pour avoir une meilleure compréhension des concepts.)

name = "FINXTER"
# [start:stop] --> items from start through stop-1
print(name[1:6])
# [:stop] --> items from the beginning of string through stop-1 
print(name[:6])
# [start:] --> items from start through end of string
print(name[1:])
# [start:stop:step] --> items from start through stop with step-size
print(name[1:6:2])
# Entire String!
print(name[:])

Sortie :

INXTE
FINXTE
INXTER
IXE
FINXTER

Taille du pas dans le découpage

Bien que la taille du pas soit facultative lors du découpage en tranches, elle présente plusieurs applications et avantages. Par conséquent, discutons de certains des cas d'utilisation qui justifient l'importance de la taille du pas lors du découpage d'une séquence.

Cas d'utilisation 1 :Incrément personnalisé entre les index lors du découpage

Comme mentionné précédemment, si la taille du pas n'est pas spécifiée, l'incrément entre les index dans la plage spécifiée est considéré comme égal à 1. Cela signifie que tous les index dans la plage/tranche spécifiée d'une chaîne donnée seront pris en compte et l'ensemble la sous-chaîne sera générée en sortie sans ignorer aucun élément intermédiaire. Cependant, si nous voulons générer une chaîne telle que la valeur entre les index est incrémentée de toute valeur autre que 1, nous pouvons utiliser la taille de pas pour spécifier ces incréments. En d'autres termes, la taille de pas peut être utilisée pour ignorer des index dans la tranche spécifiée.

Prenons un exemple pour comprendre comment nous pouvons définir une taille de pas et générer la sortie souhaitée.

Exemple : Étant donné la chaîne "FPIYNTXHTOENR" ; comment extraire les éléments aux positions paires / index impairs (en considérant la première position comme 1) ?

name = "FPIYNTXHTOENR"
print(name[1:12:2])

Sortie :

PYTHON

Bien que le programme ci-dessus soit explicite; jetons un coup d'œil au diagramme suivant pour visualiser l'extrait ci-dessus afin que le concept de taille de pas soit limpide.

Cas d'utilisation 2 :taille de pas négative

Le découpage nous offre la possibilité de taille de pas négative. Par conséquent, vous pouvez découper une séquence ou une chaîne dans le sens inverse en utilisant la taille de pas négative. Cela peut être déterminant dans des opérations telles que l'inversion d'une chaîne.

Exemple : Étant donné la chaîne « MADAME » ; vérifier si la chaîne est un palindrome en utilisant une taille de pas négative.

# String which reads the same backward as forward is a Palindrome string
name = "MADAM"
# Reversing the string using a negative step-size
palindrome = (name[::-1])
if name == palindrome:
  print(palindrome," is a Palindrome String. ")

Sortie :

MADAM  is a Palindrome String.

Découper les indices négatifs

Tout comme la taille de pas négative, le découpage nous offre également l'avantage supplémentaire d'extraire des sous-chaînes en utilisant l'index négatif des caractères individuels de la chaîne. Examinons l'exemple suivant pour comprendre comment fonctionne le découpage avec des indices négatifs :

Exemple :

Utilisons des indices négatifs pour trancher la chaîne ci-dessus. Veuillez suivre le code ainsi que les commentaires ci-dessous :-

string = "HELLO WORLD"
# [-start:-stop]
print(string[-11:-6])
# [:stop]
print(string[:-6])
# [start:]
print(string[-5:])
# Entire String using negative Indexing
print(string[-11:])
# [start:stop:step]
print(string[-11:-6:2])
# -Index and -Step to slice and reverse string
print(string[-1:-6:-1])

Sortie :

HELLO
HELLO
WORLD
HELLO WORLD
HLO
DLROW

Utilisation de la tranche() Constructeur

Dans les exemples ci-dessus, nous avons en fait utilisé un slice() objet utilisant un  : notation entre crochets []. Le slice() est un constructeur intégré qui est utilisé pour créer un objet tranche qui représente un sous-ensemble d'une séquence entière.

La syntaxe pour utiliser l'objet slice est :

  • Les deux syntaxes sont prises en charge en Python lors de l'utilisation du slice() objet.
  • Pour remplacer un argument par une entrée vide, vous pouvez utiliser None . Par exemple pour répliquer string[1:] vous pouvez utiliser string[slice(1, None)]

Puisque nous avons déjà une idée de l'indexation et du découpage, comparons et comparons les slice() objet et la base  : notation de tranche basée en Python.

  • string_name[slice(start, stop, step)] est équivalent à string_name[start:stop:step]start, stop and step arguments ont une signification similaire dans les deux cas. Cependant slice() les objets ont un comportement légèrement différent en fonction du nombre d'arguments.

La meilleure façon de comparer les deux notations est de les visualiser à l'aide d'exemples. Ainsi, plongeons-nous dans le code ci-dessous pour comparer et contraster le découpage en utilisant le slice() et Basique : notation –

name = "FINXTER"
print("Original String = ", name)
print("\nScenario 1")
# [start:stop] --> items from start through stop-1
print("Output Using : Notation >> ",name[1:6])
print("Output Using slice Object >> ",name[slice(1,6)])

print("\nScenario 2")
# [:stop] --> items from beginning of string through stop-1 
print("Output Using : Notation >> ",name[:6])
print("Output Using slice Object >> ",name[slice(6)])

print("\nScenario 3")
# [start:] --> items from start through end of string
print("Output Using : Notation >> ",name[1:])
print("Output Using slice Object >> ",name[slice(1,7)])

print("\nScenario 4")
# [start:stop:step] --> items from start through stop with step-size
print("Output Using : Notation >> ",name[1:6:2])
print("Output Using slice Object >> ",name[slice(1,6,2)])

print("\nScenario 5")
# Entire String!
print("Output Using : Notation >> ",name[:])
print("Output Using slice Object >> ",name[slice(7)])

Sortie :

Original String =  FINXTER

Scenario 1
Output Using : Notation >>  INXTE
Output Using slice Object >>  INXTE

Scenario 2
Output Using : Notation >>  FINXTE
Output Using slice Object >>  FINXTE

Scenario 3
Output Using : Notation >>  INXTER
Output Using slice Object >>  INXTER

Scenario 4
Output Using : Notation >>  IXE
Output Using slice Object >>  IXE

Scenario 5
Output Using : Notation >>  FINXTER
Output Using slice Object >>  FINXTER

Syntaxe indulgente du découpage

Python est vraiment indulgent en matière de découpage car même si vous spécifiez un index qui dépasse l'index maximum réel de la séquence, vous n'obtiendrez pas d'erreur et la sortie sera affichée à l'écran sans aucun problème. Même si vous commencez à un index qui n'est pas valide, vous ne trouverez pas d'erreur, à la place, python renverra simplement une chaîne vide.

Jetons un coup d'œil à l'exemple ci-dessous qui clarifie la syntaxe indulgente du découpage en Python :

name = "FINXTER"
# prints entire string
print(name[0:10000])
# prints empty string
print(name[10000:10000])
# prints the element at first index
print(name[0::10000])
# Using None is same as using a zero at beginning
# or Not specifying any arguement 
print(name[None:])
print(name[2:None])

Sortie :

FINXTER

F
FINXTER
NXTER

Découpage avec d'autres types de séquences

Jusqu'à présent, nous avons discuté du découpage par rapport aux chaînes dans tous nos exemples. Cependant, le découpage fonctionne avec tous les types de données séquentiels qui peuvent être indexés comme une liste ou un tuple. Examinons le programme suivant, qui illustre le découpage par rapport à une liste et un tuple.

Exemple :

li = ["apple","banana","Orange"]
tup = ("Python","Java","C++")

#slicing the list
print(li[slice(0,2,1)])
print(li[slice(1)])
print(li[slice(None)])

# slicing the tuple
print(tup[0:2:1])
print(tup[:1])
print(tup[::])

Sortie :

['apple', 'banana']
['apple']
['apple', 'banana', 'Orange']
('Python', 'Java')
('Python',)
('Python', 'Java', 'C++')

Conclusion

Les principaux points à retenir de cet article sont :

  1. Principes de base de l'indexation
  2. Découpage en utilisant le [start:stop:step] notation.
  3. Découpage en utilisant le slice() objet.
  4. Taille de pas et ses cas d'utilisation
  5. Découpage à l'aide des indices négatifs.
  6. Découpage d'autres types de données séquentielles

Nous avons un article de blog similaire dans lequel Christian Mayer a discuté de certaines des questions les plus fréquemment posées sur le tranchage. N'hésitez pas à consulter l'article en suivant ce lien. J'espère que vous avez trouvé cet article sur la notation de découpage utile. Veuillez vous abonner et rester à l'écoute pour d'autres articles intéressants !