Résumé des index et des tranches Python

introduction

Je ne sais pas quel numéro brasser, mais il est important d'en faire l'expérience par vous-même et de l'écrire avec vos propres mots.

Index (en particulier pour les chaînes)

Juste en définissant normalement une chaîne de caractères, elle peut être traitée comme un tableau unidimensionnel dans lequel chaque caractère est stocké.

python

letters="ABCDEFG"

#Quel est le troisième (à partir de 0)?
letters[3]  # 'D'

Vous pouvez également utiliser moins pour compter par derrière. Lorsqu'il est dans l'ordre normal, il compte à partir de 0, mais lorsqu'il est de l'arrière, il vaut -1 à la fin. Pas -0. Naturellement?

python

#Quelle est la seconde de l'arrière?
letters[-2]  # 'F'

Il est également possible d'extraire des chaînes de caractères caractère par caractère sous la forme d'un tableau unidimensionnel.

La source

for letter in letters:
  print (letter)

résultat

A
B
C
D
E
F
G

Ce n'est pas le but de cette fois, mais il est pratique de se souvenir de la fonction énumérer. Vous pouvez obtenir l'index et l'élément en même temps. Il n'est pas difficile d'obtenir le même résultat sans utiliser cela. C'est une question de lisibilité. Ou ils envisagent de porter vers d'autres langues qui n'ont pas cette fonction. Je suis tout à fait d'accord avec l'opinion selon laquelle il est désagréable d'obtenir des valeurs pour plusieurs variables à la fois, mais vous devriez vous y habituer.

Source à l'aide de la fonction enumerate

for i,letter in enumerate(letters):
  print (i,letter)

Source qui n'utilise pas la fonction énumérer

for i in range(len(letters)):
  print (i,letters[i])

le résultat est le même

0 A
1 B
2 C
3 D
4 E
5 F
6 G

Le Petit Con parfumé à Showa a également une spécification d'index caché pour les chaînes de caractères, qui n'est pas spécifiée dans le manuel (il n'y a pas de fonction d'énumération). L'image ci-dessous est un composite et 3DS Petitcon n ° 3 ne peut pas être exécuté sur l'écran inférieur lors de l'affichage de la liste sur l'écran supérieur. Je ne m'inquiète pas.

Cela peut être dû à la spécification qu'une chaîne de caractères peut également être utilisée comme un tableau unidimensionnel, ce qui permet de vérifier si facilement si une certaine chaîne de caractères contient une chaîne de caractères spécifique.

La source

if "CD" in "ABCDEFG":  #Je l'ai rendu visible car il est difficile de comprendre ce que je fais avec les variables
  print ("Sera inclus")
else:
  print ("Non inclus")

résultat

Sera inclus

tranche

Slice est une astuce qui peut supprimer une partie de la séquence. Exprimé comme [début: fin: étape]. Si start est omis, ce sera depuis le début, si end est omis, ce sera jusqu'à la fin, et si step est omis, step = 1. Comme l'index, il compte à partir de 0 et n'inclut pas la valeur spécifiée pour end.

Découper en une chaîne / un tableau à une dimension

De base

python

#Redéfini pour faciliter la confirmation
letters="ABCDEFG"

#Spécifiez le début et la fin, omettez l'étape
letters[3:5]  # 'DE'

Il semble peu pratique que l'index spécifié par end ne soit pas réellement inclus, mais il présente également un avantage.

python

#Redéfini pour faciliter la confirmation
letters="ABCDEFG"

#Spécifiez uniquement end = fonction dite de gauche
letters[:4]  # 'ABCD'

#Spécifiez uniquement début = de la position spécifiée à la fin
letters[4:]  # 'EFG'

De cette façon, vous pouvez diviser le tableau en spécifiant un index.

Spécifiez moins

Habituons-nous au traitement négatif.

python

#Redéfini pour faciliter la confirmation
letters="ABCDEFG"

#3ème caractère à l'arrière (spécifié par index au lieu de tranche, déjà mentionné)
print(letters[-3])  # 'E'

#Spécifiez uniquement start = fonction dite de droite du "troisième caractère de l'arrière" à la fin
print(letters[-3:])  # 'EFG'

#Spécifiez uniquement la fin = du début au "troisième caractère de l'arrière"
print(letters[:-3])  # 'ABCD'

#Il sera utilisé moins fréquemment, mais les deux peuvent bien sûr être négatifs. Faites attention à la relation de taille.
print(letters[-5:-3])  # 'CD'

fonction milieu / fonction gauche / fonction droite

Vous pouvez également créer votre propre fonction intermédiaire à l'aide de tranches. Il n'est peut-être pas nécessaire d'en faire une fonction, mais créons également une fonction gauche et une fonction droite. La raison pour laquelle 0 est spécifié comme valeur par défaut de length est de sortir "de la position spécifiée à la fin" lorsque lengh est omis. -1 sert à compter le premier caractère comme premier caractère au lieu du 0ème caractère. À propos, dans Excel, le comportement était différent entre la fonction de feuille de calcul MID et la fonction VBA Mid.

python

def left(text, length):
  return text[:length]

def right(text, length):
  return text[-length:]

def mid(text, pos, length=0):
  if not length:
    length=len(text)
  return text[pos-1:pos+length-1]

Spécifiez l'étape

Lorsque l'étape est spécifiée, cela devient comme ça. Tout d'abord, obtenez-le normalement à l'étape 2.

python

#Redéfini pour faciliter la confirmation
letters="ABCDEFG"

letters[1:5:2]  # 'BD'

#C'est un tel mécanisme.
# ＡＢＣＤＥＦＧ
# ０１２３４５６
# 　◯　◯　×
#2ème argument=Puisqu'il est 5, le 5ème caractère n'est pas inclus

Si vous spécifiez moins pour l'étape, il procédera dans la direction opposée. Puisqu'il va dans la direction opposée, la fin doit être plus petite et le début doit être plus grand.

python

letters[5:1:-2]  # 'FD'

Je pensais que l'étape est négative n'est pas une utilisation aussi irrégulière, mais ** Le début et la fin sont tous spécifiés et l'étape est définie sur -1, c'est-à-dire que si :: -1 est défini, tous les éléments sont dans l'ordre inverse ** Il est bon de se souvenir de ce mouvement car il est fréquemment utilisé. Quant à son utilisation, l'image lue par imread d'OpenCV a la couleur stockée dans BGR, mais elle peut être utilisée lors de la conversion en RVB. OpenCV a également une fonction de conversion de couleur, mais celle-ci est plus intelligente.

La source

print (letters)
print (letters[::-1])

résultat

ABCDEFG
GFEDCBA

Tableau bidimensionnel

Je voulais vraiment parler d'ici. Commencez par créer un tableau à deux dimensions. Ce que je suis soudainement tombé ici, c'est l'histoire de ** la dernière fois **.

La source

#promettre
import numpy as np

#Hauteur et largeur
H,W = 5,6

#Créez d'abord un tableau vide avec uniquement la taille définie
arr=np.full((H,W),"",dtype=object)

#Définissez des valeurs telles que les noms de cellules Excel
letters="ABCDEFG"
for c in range(W):
  for r in range(H):
    arr[r,c]=letters[c]+str(r)

print (arr)

résultat

[['A0' 'B0' 'C0' 'D0' 'E0' 'F0']
 ['A1' 'B1' 'C1' 'D1' 'E1' 'F1']
 ['A2' 'B2' 'C2' 'D2' 'E2' 'F2']
 ['A3' 'B3' 'C3' 'D3' 'E3' 'F3']
 ['A4' 'B4' 'C4' 'D4' 'E4' 'F4']]

Si vous le spécifiez normalement par index, il en sera ainsi. Je l'écris plusieurs fois, mais le décompte commence à 0.

python

r,c=2,1
arr[r,c]  # 'B2'

Si vous spécifiez des tranches pour les lignes et les colonnes, cela ressemblera à ceci. Puisque la base est [start: end], vous pouvez utiliser [r1: r2, c1: c2] comme graduation des coordonnées, mais il vaut mieux s'en souvenir en écrivant ** [r: r + h, c: c + w] **. pense.

La source

r,c = 2,1  #Ligne et colonne de départ
h,w = 3,4  #Hauteur et largeur de la plage
print(arr[r:r+h, c:c+w])

résultat

[['B2' 'C2' 'D2' 'E2']
 ['B3' 'C3' 'D3' 'E3']
 ['B4' 'C4' 'D4' 'E4']]

Le tableau avec le nombre spécifié de lignes et de colonnes a été obtenu avec succès.

Technique de correspondance d'index et de tranche, ou quelque chose à noter

** L'indexation renvoie un élément **, mais ** les tranches renvoient une partie du tableau **. Même s'il s'agit d'une ligne et d'une colonne.

La source

r,c = 2,1  #Ligne et colonne de départ
h,w = 1,1  #Hauteur et largeur de la plage
print ("indice",arr[r, c])
print ("tranche",arr[r:r+h, c:c+w])

python

Index B2
tranche[['B2']]

Cela ne semble pas être une chaîne, cependant.

La source

#Redéfini pour faciliter la confirmation
letters="ABCDEFG"

print ("indice",letters[3])
print ("tranche",letters[3:3+1])

résultat

Index D
Tranché

La spécification de l'une des matrices de tableau bidimensionnel comme index et de l'autre comme tranche donne un tableau unidimensionnel. C'est un tableau unidimensionnel, ou simplement une énumération ou une liste.

La source

r=3
print (arr[r,:])  #Toutes les colonnes sont spécifiées

c=4
print (arr[:,c])  #Toutes les lignes sont spécifiées

résultat

['A3' 'B3' 'C3' 'D3' 'E3' 'F3']
['E0' 'E1' 'E2' 'E3' 'E4']

J'ai écrit le résultat du découpage de la colonne 1 ligne 1 ci-dessus, mais laissez-moi vous donner un exemple plus pratique. Si une ligne du tableau bidimensionnel est spécifiée par découpage et que la colonne est également découpée, ce sera comme suit. Le support est doublé. Il s'agit d'un tableau bidimensionnel avec 1 ligne et w colonnes.

La source

r=3
print (arr[r:r+1,:])

résultat

[['A3' 'B3' 'C3' 'D3' 'E3' 'F3']]

Si vous spécifiez la ligne en tant que tranche et spécifiez une colonne en tant que tranche, elle devient un tableau à deux dimensions avec h lignes et 1 colonne.

La source

c=4
print (arr[:,c:c+1])

résultat

[['E0']
 ['E1']
 ['E2']
 ['E3']
 ['E4']]

Utiliser des étapes de tranche dans un tableau à deux dimensions

Seul un exemple de retournement avec :: -1 au lieu de l'utilisation normale de l'étape est montré.

La source

print("Forme originale")
print(arr)
print("Premier argument = Inverser la ligne")
print(arr[::-1])
print("Second argument = Inverser la colonne Le premier argument est tout spécifié.::Mais ok:Mais c'est bon")
print(arr[::, ::-1])
print("Inverser les lignes et les colonnes")
print(arr[::-1, ::-1])

résultat

Forme originale
[['A0' 'B0' 'C0' 'D0' 'E0' 'F0']
 ['A1' 'B1' 'C1' 'D1' 'E1' 'F1']
 ['A2' 'B2' 'C2' 'D2' 'E2' 'F2']
 ['A3' 'B3' 'C3' 'D3' 'E3' 'F3']
 ['A4' 'B4' 'C4' 'D4' 'E4' 'F4']]
Premier argument = Inverser la ligne
[['A4' 'B4' 'C4' 'D4' 'E4' 'F4']
 ['A3' 'B3' 'C3' 'D3' 'E3' 'F3']
 ['A2' 'B2' 'C2' 'D2' 'E2' 'F2']
 ['A1' 'B1' 'C1' 'D1' 'E1' 'F1']
 ['A0' 'B0' 'C0' 'D0' 'E0' 'F0']]
Second argument = Inverser la colonne Le premier argument est tout spécifié.::Mais ok:Mais c'est bon
[['F0' 'E0' 'D0' 'C0' 'B0' 'A0']
 ['F1' 'E1' 'D1' 'C1' 'B1' 'A1']
 ['F2' 'E2' 'D2' 'C2' 'B2' 'A2']
 ['F3' 'E3' 'D3' 'C3' 'B3' 'A3']
 ['F4' 'E4' 'D4' 'C4' 'B4' 'A4']]
Inverser les lignes et les colonnes
[['F4' 'E4' 'D4' 'C4' 'B4' 'A4']
 ['F3' 'E3' 'D3' 'C3' 'B3' 'A3']
 ['F2' 'E2' 'D2' 'C2' 'B2' 'A2']
 ['F1' 'E1' 'D1' 'C1' 'B1' 'A1']
 ['F0' 'E0' 'D0' 'C0' 'B0' 'A0']]

Je ne me souviens pas de ce genre de chose à moins de l'essayer moi-même.

Aperçu de la prochaine fois

Je voulais entrer l'image OpenCV à partir d'ici, mais j'étais épuisé. La prochaine fois, je parlerai d'images.