Summary of Python indexes and slices

Introduction

I don't know what number to brew, but it's important to experience it for yourself and write it in your own words.

Index (especially for strings)

You can treat it like a one-dimensional array in which each character is stored just by defining a character string normally.

python

letters="ABCDEFG"

#What is the third (counting from 0)?
letters[3]  # 'D'

You can also use the minus to count from behind. When it is in normal order, it counts from 0, but when it is from the back, it ends with -1. Not -0. Naturally?

python

#What is the second from the back?
letters[-2]  # 'F'

It is also possible to extract character strings one by one as a one-dimensional array.

Source

for letter in letters:
  print (letter)

result

A
B
C
D
E
F
G

It's a bit off the point, but it's useful to remember the enumerate function. You can get the index and the element at the same time. It is not difficult to get the same result without using this. It's a readability issue. Or they are considering porting to other languages that do not have this function. I strongly agree with the opinion that it's unpleasant to get values for multiple variables at once, but you should get used to it.

Source using the enumerate function

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

Sources that do not use the enumerate function

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

The result is the same

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

Petit Computer, which has a Showa scent, also has a hidden index specification for character strings, which is not specified in the manual (there is no enumerate function). The image below is a composite, and 3DS Petitcon No. 3 cannot be executed on the lower screen while displaying the list on the upper screen. I do not care.

The reason why it's so easy to find out if a string contains a particular string may be due to the specification that the string can also be used as a one-dimensional array.

Source

if "CD" in "ABCDEFG":  #I made it visible because it is difficult to understand what I am doing with variables
  print ("Will be included")
else:
  print ("Not included")

result

Will be included

slice

Slice is a trick that can take out a part of the array. Expressed as [start: end: step]. If start is omitted, it will be from the beginning, if end is omitted, it will be until the end, and if step is omitted, step = 1. Like the index, it counts from 0 and does not include the value specified for end.

Slice into a string / one-dimensional array

Basic

python

#Redefined for ease of confirmation
letters="ABCDEFG"

#Specify start and end, omit step
letters[3:5]  # 'DE'

It seems inconvenient that the index specified by end is not actually included, but it also has an advantage.

python

#Redefined for ease of confirmation
letters="ABCDEFG"

#Specify only end = so-called left function
letters[:4]  # 'ABCD'

#Specify only start = from the specified position to the end
letters[4:]  # 'EFG'

In this way, you can split the array by specifying one index.

Specify minus

Let's get used to the negative treatment.

python

#Redefined for ease of confirmation
letters="ABCDEFG"

#3rd character from the back (specified by index instead of slice, already mentioned)
print(letters[-3])  # 'E'

#Specify only start = so-called right function from "third character from the back" to the end
print(letters[-3:])  # 'EFG'

#Specify only end = from the beginning to "third character from the back"
print(letters[:-3])  # 'ABCD'

#It will be used less frequently, but of course both can be negative. Pay attention to the size relationship.
print(letters[-5:-3])  # 'CD'

mid function / left function / right function

You can also create your own mid function using slices. It may not be necessary to make it a function, but let's also create a left function and a right function. The reason why 0 is specified as the default value of length is to output "from the specified position to the end" when lengh is omitted. -1 is for counting the first character as the first character instead of the 0th character. By the way, in Excel, the behavior was different between the MID function of the worksheet function and the Mid function of VBA.

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]

Specify step

When step is specified, it becomes like this. First, get it normally in step 2.

python

#Redefined for ease of confirmation
letters="ABCDEFG"

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

#This is such a mechanism.
# ＡＢＣＤＥＦＧ
# ０１２３４５６
# 　◯　◯　×
#2nd argument=Since it is 5, it does not include the 5th character

If you specify minus for step, it will proceed in the opposite direction. Since it goes in the opposite direction, the end must be smaller and the start must be larger.

python

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

I thought that step is negative is not such an irregular usage, but ** Start and end are all specified and step is set to -1, that is, if :: -1 is set, all elements are in reverse order ** It is good to remember this movement because it is used frequently. As for what to use, the image read by imread of OpenCV has the color stored in BGR, but it can be used when converting this to RGB. OpenCV also has a color conversion function, but this one is smarter.

Source

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

result

ABCDEFG
GFEDCBA

Two-dimensional array

I really wanted to talk from here. First, make a two-dimensional array. I suddenly stumbled upon the story of ** last time **.

Source

#promise
import numpy as np

#Height and width
H,W = 5,6

#First create an empty array with only the size defined
arr=np.full((H,W),"",dtype=object)

#Define values like Excel cell names
letters="ABCDEFG"
for c in range(W):
  for r in range(H):
    arr[r,c]=letters[c]+str(r)

print (arr)

result

[['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']]

If you specify it by index normally, it will be like this. I write it many times, but the count starts from 0.

python

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

If you specify slices for rows and columns, it will look like this. Since the basic is [start: end], you can use [r1: r2, c1: c2] as the coordinate tick, but you should remember it by writing ** [r: r + h, c: c + w] **. think.

Source

r,c = 2,1  #Starting row and column
h,w = 3,4  #Range height and width
print(arr[r:r+h, c:c+w])

result

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

The array of the specified number of rows and columns has been successfully acquired.

Index and slice matching technique, or something to note

** Index specification returns one element **, but ** slice returns a part of the array **. Even if it's one row and one column.

Source

r,c = 2,1  #Starting row and column
h,w = 1,1  #Range height and width
print ("index",arr[r, c])
print ("slice",arr[r:r+h, c:c+w])

python

Index B2
slice[['B2']]

That doesn't seem to be a string, though.

Source

#Redefined for ease of confirmation
letters="ABCDEFG"

print ("index",letters[3])
print ("slice",letters[3:3+1])

result

Index D
Slice D

Specifying one of the two-dimensional array matrices as an index and the other as a slice results in a one-dimensional array. It's a one-dimensional array, or just an enumeration or list.

Source

r=3
print (arr[r,:])  #All columns are specified

c=4
print (arr[:,c])  #All lines are specified

result

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

I wrote the result of slicing 1 row 1 column above, but let me give you a more practical example. If one row of the two-dimensional array is specified by slicing and the column is also sliced, it will be as follows. The bracket is doubled. It is a two-dimensional array with 1 row and w columns.

Source

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

result

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

If you specify the row as a slice and specify one column as a slice, it becomes a two-dimensional array with h rows and 1 column.

Source

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

result

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

Use slice steps in a two-dimensional array

Only an example of flipping with :: -1 instead of the normal step usage is shown.

Source

print("Original shape")
print(arr)
print("First argument = invert line")
print(arr[::-1])
print("Second argument = Invert column The first argument is all specified.::But okay:But it is good")
print(arr[::, ::-1])
print("Invert both rows and columns")
print(arr[::-1, ::-1])

result

Original shape
[['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']]
First argument = invert line
[['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 = Invert column The first argument is all specified.::But okay:But it is good
[['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']]
Invert both rows and columns
[['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']]

I can't remember this kind of thing unless I try it myself.

Next time preview

I wanted to enter the OpenCV image from here, but I was exhausted. Next time I'll talk about images.