在列表python中的元素左侧查找n个元素

我有一张单子

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

我想写一个函数get\n\u preceding（a，list\u of \u numbers，n），它接受一个参数a，并返回n在list\u of numbers中前面的数字

例如：

get_n_preceeding(4, my_list, 2):

这将返回列表中4之前的2个数字。 i、 e.ans=[2,3]

类似地，如果我想要在1之前有2个数字，它应该给出如下结果 [9,10]#我认为这是棘手的部分

类似地，我希望编写另一个函数获得成功（a，数字列表，b）

如果我使用

getn\u successing（9，my\u list，2）

，它应该返回[10,1]

我尝试使用zip操作符，但没有成功

有更好的方法吗？

使用查找位置，然后相应地：

def get_n_preceding(xs, x, n):
    end = xs.index(x)
    start = end - n
    ys = []
    for i in range(start, end):
        ys.append(xs[i % len(xs)])
    return ys

def get_n_succeeding(xs, x, n):
    start = xs.index(x) + 1
    end = start + n
    ys = []
    for i in range(start, end):
        ys.append(xs[i % len(xs)])
    return ys

get_n_preceding(list(range(10)), 1, 2)   #=> [10, 0]
get_n_preceding(list(range(10)), 5, 2)   #=> [3, 4]
get_n_succeeding(list(range(10)), 8, 2)  #=> [9, 0]
get_n_succeeding(list(range(10)), 5, 2)  #=> [6, 7]

如文档中所述，

array.index（）

将找到第一个匹配元素，并忽略以后的任何重复元素。

用于查找位置，然后相应地：

def get_n_preceding(xs, x, n):
    end = xs.index(x)
    start = end - n
    ys = []
    for i in range(start, end):
        ys.append(xs[i % len(xs)])
    return ys

def get_n_succeeding(xs, x, n):
    start = xs.index(x) + 1
    end = start + n
    ys = []
    for i in range(start, end):
        ys.append(xs[i % len(xs)])
    return ys

get_n_preceding(list(range(10)), 1, 2)   #=> [10, 0]
get_n_preceding(list(range(10)), 5, 2)   #=> [3, 4]
get_n_succeeding(list(range(10)), 8, 2)  #=> [9, 0]
get_n_succeeding(list(range(10)), 5, 2)  #=> [6, 7]

---

如文档中所述，

array.index（）

将找到第一个匹配元素，并忽略以后的任何重复元素。

您可以使用生成器并：

测试：

输出：

Get first
[9, 10]

Get all
[2, 3]
[4, 5]
[7, 8]

Get circle
[8, 4, 9, 10]

---

您可以使用发电机和：

测试：

输出：

Get first
[9, 10]

Get all
[2, 3]
[4, 5]
[7, 8]

Get circle
[8, 4, 9, 10]

---

我使用列表理解进行get_n_之前的操作，如果后续索引超出范围，则使用for循环进行后续操作，减去数组的长度

def get_n_preceeding(a: int, numbers: list, n: int = 2) -> list:
    start = numbers.index(a)
    return [numbers[start - n + x] for x in range(n)]


def get_n_succeeding(a: int, numbers: list, n: int = 2) -> list:
    start = numbers.index(a) + 1
    length = len(numbers)
    output = []
    for x in range(n):
        try:
            output.append(numbers[start + x])
        except IndexError:
            output.append(numbers[start + x - length])
    return output


my_list = list(range(1, 11))
print(get_n_preceeding(1, my_list, 2))  # -> [9, 10]
print(get_n_succeeding(9, my_list, 2))  # -> [10, 1]

---

我使用列表理解进行get_n_之前的操作，如果后续索引超出范围，则使用for循环进行后续操作，减去数组的长度

def get_n_preceeding(a: int, numbers: list, n: int = 2) -> list:
    start = numbers.index(a)
    return [numbers[start - n + x] for x in range(n)]


def get_n_succeeding(a: int, numbers: list, n: int = 2) -> list:
    start = numbers.index(a) + 1
    length = len(numbers)
    output = []
    for x in range(n):
        try:
            output.append(numbers[start + x])
        except IndexError:
            output.append(numbers[start + x - length])
    return output


my_list = list(range(1, 11))
print(get_n_preceeding(1, my_list, 2))  # -> [9, 10]
print(get_n_succeeding(9, my_list, 2))  # -> [10, 1]

当需要定期包装或重复表达式时，模数运算符（

%

）通常是一个不错的选择。例如，此解决方案对于边缘情况（例如，

n>len（lst）

）简单而健壮：

结果:

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
get_n_preceding(4, L, n=2)  # [2, 3]
get_n_preceding(1, L, n=2)  # [9, 10]
get_n_preceding(3, [1, 2, 3], n=5)  # [1, 2, 3, 1, 2]

get_n_succeeding(7, L, n=2)  # [8, 9]
get_n_succeeding(9, L, n=2)  # [10, 1]
get_n_succeeding(3, [1, 2, 3], n=5)  # [1, 2, 3, 1, 2]

当需要定期包装或重复表达式时，模数运算符（

%

）通常是一个不错的选择。例如，此解决方案对于边缘情况（例如，

n>len（lst）

）简单而健壮：

结果:

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
get_n_preceding(4, L, n=2)  # [2, 3]
get_n_preceding(1, L, n=2)  # [9, 10]
get_n_preceding(3, [1, 2, 3], n=5)  # [1, 2, 3, 1, 2]

get_n_succeeding(7, L, n=2)  # [8, 9]
get_n_succeeding(9, L, n=2)  # [10, 1]
get_n_succeeding(3, [1, 2, 3], n=5)  # [1, 2, 3, 1, 2]

---

---

不，您不需要这里的

zip

操作符：您需要找到项目所在的索引，然后相应地“切片”列表。当您有重复的元素时会发生什么情况？“我尝试使用zip操作符，但无法做到。”您能展示一下您尝试过的内容吗？即使是非功能性的尝试也很重要。@DanielMesejo列表包含唯一的元素。不，这里不需要

zip

运算符：您需要找到项目所在的索引，然后相应地“切片”列表。如果有重复的元素，会发生什么情况？“我尝试使用zip运算符，但无法执行此操作。”你能展示一下你试过的吗？即使是非功能性的尝试也很重要。@DanielMesejo该列表包含唯一的元素。

get_n_previous（list（range（10）），1，2）

，返回空列表，它应该返回我[9,10]，类似地

get_n_successing（list（range（10）），10,2）

，应该返回[1,2]@Shubham，实际上，这应该给出

[10,0]

，因为您要传递的列表以

0

开头，而不是

1

。无论如何，更新了我的答案。@AndrewMarshall不错的答案-但范围（10）只包括0-9-没有10个。啊，是的，

[9，0]

get_n_previous（list（range（10）），1，2）

，返回空列表，它应该返回我[9,10]，同样地

get_n_successing（list（range（10）），10,2）

，应该返回[1,2]@Shubham，实际上，应该给出

[10,0]

，因为您正在传递的列表是从

0

开始的，而不是

1

。无论如何，更新了我的答案。@AndrewMarshall不错的答案-但范围（10）只包括0-9-没有10个。啊，是的，

[9，0]

。如果我使用前面的（1，L，2），它将我显示为空列表，我希望如果选择了1，它将返回我[9,10]。想法是一种循环列表。@Shubham只是一个粗略的修复-如果你有重叠的范围，这会中断，例如

get\n\u preceding（1，L，20）

-基本上你必须确保你的循环足够大，并且你将找到的索引向右移动了很远，这样它仍然可以获取你的所有项目。如果我使用

get\n\u preceding（1，L，2）

，它将我显示为空列表，我希望如果选择1，它将返回我[9,10]。想法是一种循环列表。@Shubham只是一个粗略的修复-如果你有重叠的范围，这会中断，例如

get\n\u preceding（1，L，20）

-基本上你必须确保你的循环足够大，并且你将找到的索引向右移动了很远，这样它仍然可以获取你的所有项目。这是你需要改进的基础。