在Python列表中查找彼此之间在一定距离内的数字

我有一个Python中的数字列表。看起来是这样的：

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]

for element in elements:
    connections[element] = []
    visited[element] = False
    for another in elements:
        if abs(element - another) <= limit:
            connections[element].append(another)

我想保留所有在+7或-7范围内的数字，并丢弃其余的数字。在Python中有没有一种简单的方法可以做到这一点？我已经阅读了列表过滤器方法，但不确定如何使用它来获得我想要的东西

我是Python新手

更新

---

理想情况下，输出应该是[84,86,87,89,90]和另一个列表[997,999,1000,1002]。我想检索序列，而不是异常值。希望这有意义。

这是算法问题，请尝试以下方法：

def get_blocks(values):
    mi, ma = 0, 0
    result = []
    temp = []
    for v in sorted(values):
        if not temp:
            mi = ma = v
            temp.append(v)
        else:
            if abs(v - mi) < 7 and abs(v - ma) < 7:
                temp.append(v)
                if v < mi:
                    mi = v
                elif v > ma:
                    ma = v
            else:
                if len(temp) > 1:
                    result.append(temp)
                mi = ma = v
                temp = [v]
    return result

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]
print get_blocks(a)

---

这是算法问题，请尝试以下操作：

def get_blocks(values):
    mi, ma = 0, 0
    result = []
    temp = []
    for v in sorted(values):
        if not temp:
            mi = ma = v
            temp.append(v)
        else:
            if abs(v - mi) < 7 and abs(v - ma) < 7:
                temp.append(v)
                if v < mi:
                    mi = v
                elif v > ma:
                    ma = v
            else:
                if len(temp) > 1:
                    result.append(temp)
                mi = ma = v
                temp = [v]
    return result

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]
print get_blocks(a)

---

这是算法问题，请尝试以下操作：

def get_blocks(values):
    mi, ma = 0, 0
    result = []
    temp = []
    for v in sorted(values):
        if not temp:
            mi = ma = v
            temp.append(v)
        else:
            if abs(v - mi) < 7 and abs(v - ma) < 7:
                temp.append(v)
                if v < mi:
                    mi = v
                elif v > ma:
                    ma = v
            else:
                if len(temp) > 1:
                    result.append(temp)
                mi = ma = v
                temp = [v]
    return result

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]
print get_blocks(a)

---

这是算法问题，请尝试以下操作：

def get_blocks(values):
    mi, ma = 0, 0
    result = []
    temp = []
    for v in sorted(values):
        if not temp:
            mi = ma = v
            temp.append(v)
        else:
            if abs(v - mi) < 7 and abs(v - ma) < 7:
                temp.append(v)
                if v < mi:
                    mi = v
                elif v > ma:
                    ma = v
            else:
                if len(temp) > 1:
                    result.append(temp)
                mi = ma = v
                temp = [v]
    return result

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]
print get_blocks(a)

---

如果您的问题允许传递关系，即x在组中，只要它与组中任何元素的距离最多为7，那么在我看来，这似乎是一个问题。更具体地说，你需要找到所有的

这个问题本身很容易用递归算法解决。首先创建一个字典，其中每个键都是元素之一，每个值都是元素列表，这些元素与该元素之间的距离最多为7。以您的示例为例，您将有如下内容：

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]

for element in elements:
    connections[element] = []
    visited[element] = False
    for another in elements:
        if abs(element - another) <= limit:
            connections[element].append(another)

现在您需要编写一个递归函数，该函数将接受一个元素和一个列表作为输入，并且它将继续在列表中添加元素，只要它能够找到一个与当前元素相距最多7的元素

def group_elements(element, group):
    if visited[element]:
        return
    visited[element] = True
    group.append(element)
    for another in connections[element]:
        group_elements(another, group)

在代码的某个地方，您还需要记住已经访问过的元素，以确保不会进入无限循环

visited = {}

您需要为列表中的每个元素调用该函数

groups = []
for element in elements:
    if not visited[element]:
        group = []
        group_elements(element, group)
        groups.append(group)
print group

此代码应为您的输入提供以下输出：

[[87, 84, 86, 89, 90], [2014], [1000, 1002, 997, 999]]

---

如果您的问题允许传递关系，即x在组中，只要它与组中任何元素的距离最多为7，那么在我看来，这似乎是一个问题。更具体地说，你需要找到所有的

这个问题本身很容易用递归算法解决。首先创建一个字典，其中每个键都是元素之一，每个值都是元素列表，这些元素与该元素之间的距离最多为7。以您的示例为例，您将有如下内容：

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]

for element in elements:
    connections[element] = []
    visited[element] = False
    for another in elements:
        if abs(element - another) <= limit:
            connections[element].append(another)

现在您需要编写一个递归函数，该函数将接受一个元素和一个列表作为输入，并且它将继续在列表中添加元素，只要它能够找到一个与当前元素相距最多7的元素

def group_elements(element, group):
    if visited[element]:
        return
    visited[element] = True
    group.append(element)
    for another in connections[element]:
        group_elements(another, group)

在代码的某个地方，您还需要记住已经访问过的元素，以确保不会进入无限循环

visited = {}

您需要为列表中的每个元素调用该函数

groups = []
for element in elements:
    if not visited[element]:
        group = []
        group_elements(element, group)
        groups.append(group)
print group

此代码应为您的输入提供以下输出：

[[87, 84, 86, 89, 90], [2014], [1000, 1002, 997, 999]]

---

如果您的问题允许传递关系，即x在组中，只要它与组中任何元素的距离最多为7，那么在我看来，这似乎是一个问题。更具体地说，你需要找到所有的

这个问题本身很容易用递归算法解决。首先创建一个字典，其中每个键都是元素之一，每个值都是元素列表，这些元素与该元素之间的距离最多为7。以您的示例为例，您将有如下内容：

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]

for element in elements:
    connections[element] = []
    visited[element] = False
    for another in elements:
        if abs(element - another) <= limit:
            connections[element].append(another)

现在您需要编写一个递归函数，该函数将接受一个元素和一个列表作为输入，并且它将继续在列表中添加元素，只要它能够找到一个与当前元素相距最多7的元素

def group_elements(element, group):
    if visited[element]:
        return
    visited[element] = True
    group.append(element)
    for another in connections[element]:
        group_elements(another, group)

在代码的某个地方，您还需要记住已经访问过的元素，以确保不会进入无限循环

visited = {}

您需要为列表中的每个元素调用该函数

groups = []
for element in elements:
    if not visited[element]:
        group = []
        group_elements(element, group)
        groups.append(group)
print group

此代码应为您的输入提供以下输出：

[[87, 84, 86, 89, 90], [2014], [1000, 1002, 997, 999]]

---

如果您的问题允许传递关系，即x在组中，只要它与组中任何元素的距离最多为7，那么在我看来，这似乎是一个问题。更具体地说，你需要找到所有的

这个问题本身很容易用递归算法解决。首先创建一个字典，其中每个键都是元素之一，每个值都是元素列表，这些元素与该元素之间的距离最多为7。以您的示例为例，您将有如下内容：

a = [87, 84, 86, 89, 90, 2014, 1000, 1002, 997, 999]

for element in elements:
    connections[element] = []
    visited[element] = False
    for another in elements:
        if abs(element - another) <= limit:
            connections[element].append(another)

现在您需要编写一个递归函数，该函数将接受一个元素和一个列表作为输入，并且它将继续在列表中添加元素，只要它能够找到一个与当前元素相距最多7的元素

def group_elements(element, group):
    if visited[element]:
        return
    visited[element] = True
    group.append(element)
    for another in connections[element]:
        group_elements(another, group)

在代码的某个地方，您还需要记住已经访问过的元素，以确保不会进入无限循环

visited = {}

您需要为列表中的每个元素调用该函数

groups = []
for element in elements:
    if not visited[element]:
        group = []
        group_elements(element, group)
        groups.append(group)
print group

此代码应为您的输入提供以下输出：

[[87, 84, 86, 89, 90], [2014], [1000, 1002, 997, 999]]

---

对于任何这样的问题，我的第一个调用端口是。我在代码中使用的链接中的成对函数在中提供

从更多itertools成对导入
结果=[]
区块=[]
a=[87,84,86,89,902014,1000,1002,997,999]
a、 排序（）
对于成对的v1、v2（a）：
如果v2-v1对于这样的问题，我的第一个调用端口是。我在代码中使用的链接中的成对函数在中提供

从更多itertools成对导入
结果=[]
区块=[]
a=[87,84,86,89,902014,1000,1002,997,999]
a、 排序（）
对于成对的v1、v2（a）：
如果v2-v1对于这样的问题，我的第一个调用端口是。我在代码中使用的链接中的成对函数在中提供

从更多itertools成对导入
结果=[]
区块=[]
a=[87,84,86,89,902014,1000,1002,997,999]
a、 排序（）
对于成对的v1、v2（a）：
如果v2-v1对于这样的问题，我的第一个调用端口是。来自该链接的成对函数