python 类中getitem方法与slice对象

getitem 方法

在 Python 类中，getitem 方法是一种特殊的方法，用于获取实例中某个特定位置的元素。它在实现序列类型时非常有用，例如列表、元组和字符串等。

getitem 方法接收一个参数，即索引，它可以是整数、切片或任何其他可以用于索引访问序列的类型。在方法内部，根据索引类型执行相应的操作，并返回对应的元素。

getitem 方法实现列表索引

例如，假设我们有一个名为 MyList 的类，该类模拟了 Python 中的列表。我们可以使用 getitem 方法来实现列表的索引访问。下面是一个简单的例子：

class MyList:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        return self.data[index]
1
2
3
4
5
6

在这个例子中，我们定义了一个 MyList 类，并将数据存储在实例变量 self.data 中。我们使用 getitem 方法来实现索引访问，并返回存储在 self.data 中的对应元素。

可以像下面这样使用 MyList 类来创建一个列表实例并进行索引访问：

my_list = MyList([1, 2, 3, 4, 5])
print(my_list[0])  # 输出 1
print(my_list[2:4])  # 输出 [3, 4]
1
2
3

在这个例子中，我们使用了 MyList 类创建了一个列表实例 my_list，并通过索引访问获取了第一个元素和一个切片。在这种情况下，Python 将自动调用 MyList 类中的 getitem 方法，并将索引传递给它。

getitem 方法实现元组索引

对于元组，可以定义一个类来实现__getitem__方法，如下所示：

class MyTuple:
    def __init__(self, *args):
        self.data = args
        
    def __getitem__(self, index):
        return self.data[index]
1
2
3
4
5
6

在这个例子中，我们定义了一个类MyTuple，它接受任意数量的参数，并将它们保存在一个元组中。然后，我们实现了__getitem__方法，使得可以通过索引来获取元组中的元素。例如：

t = MyTuple(1, 2, 3)
print(t[0])  # 输出 1
print(t[1])  # 输出 2
print(t[2])  # 输出 3
1
2
3
4

getitem 方法实现字符串索引

对于字符串，也可以使用__getitem__方法来实现索引操作。在Python中，字符串本质上是一个字符的序列，因此可以像操作列表一样来操作字符串。例如：

class MyString:
    def __init__(self, s):
        self.s = s
        
    def __getitem__(self, index):
        return self.s[index]
1
2
3
4
5
6

在这个例子中，定义了一个类MyString，它接受一个字符串作为参数，并将它保存在实例变量s中。然后，我们实现了__getitem__方法，使得可以通过索引来获取字符串中的字符。例如：

s = MyString("hello")
print(s[0])  # 输出 'h'
print(s[1])  # 输出 'e'
print(s[2])  # 输出 'l'
1
2
3
4

slice对象

slice对象是Python内置对象之一，它用于表示切片操作。切片是Python中常用的序列操作之一，可以用于获取序列中的一部分。slice对象表示切片操作的参数，它包含三个属性：

start：切片开始的索引位置，默认为0，如果省略start，则从序列的开头开始切片。

stop：切片结束的索引位置，但不包括stop本身，默认为序列的长度，如果省略stop，则切片到序列的末尾。

step：切片的步长，默认为1，如果省略step，则默认为1。

slice对象可以通过内置函数slice()来创建，也可以直接使用切片操作符“:”创建。例如，使用slice()函数创建一个slice对象，实现对列表lst中的元素进行切片：

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
s = slice(2, 6, 2)  # 从索引2开始到索引6（不包括6），每隔2个元素取一个
print(lst[s])  # 输出 [3, 5]
1
2
3

或者直接使用切片操作符“:”创建slice对象，也可以实现同样的操作：

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[2:6:2])  # 输出 [3, 5]
1
2

使用slice对象对字符串进行切片操作，如下：

str = "Hello, world!"
s = slice(2, 6, 2)  # 从索引2开始到索引6（不包括6），每隔2个字符取一个
print(str[s])  # 输出 "lo"
1
2
3

实现切片操作

如果想要让类支持切片操作，可以在 getitem 方法中检查传入的参数类型是否为 slice，如果是，可以根据 slice 对象的 start、stop 和 step 属性进行切片操作。以下是一个示例代码：

class MyCollection:
    def __init__(self, data):
        self.data = data
    
    def __getitem__(self, index):
        if isinstance(index, slice):
            start = index.start or 0
            stop = index.stop or len(self.data)
            step = index.step or 1
            return self.data[start:stop:step]
        else:
            return self.data[index]
1
2
3
4
5
6
7
8
9
10
11
12

上面__getitem__方法还可以如下定义：

 def __getitem__(self, index):
        if isinstance(index, slice):
            start, stop, step = index.indices(len(self.data))
            return [self.data[i] for i in range(start, stop, step)]
        else:
            return self.data[index]
1
2
3
4
5
6

indices() 是 slice 对象的一个方法。indices() 方法的作用是返回一个由切片的开始索引、结束索引和步长组成的元组。它的语法是 slice.indices(length)。

使用上面的类，对元组和字符串进行切片操作。例如：

t = (1, 2, 3, 4, 5)
c = MyCollection(t)
print(c[1:4])  # 输出 (2, 3, 4)

s = "Hello, world!"
c = MyCollection(s)
print(c[2:9:2])  # 输出'l,o,w'
1
2
3
4
5
6
7

否则就按照普通索引的方式进行处理。

mc = MyCollection([0, 1, 2, 3, 4, 5])
print(mc[2])  # 输出 2
1
2