如果元组包含两个"；1“；在Python中彼此相邻？

我有一个元组列表：

from itertools import product
l1 = list((product((0,1), repeat = n))) 

对于n=4，输出如下：

 [(0, 0, 0, 0),
 (0, 0, 0, 1),
 (0, 0, 1, 0),
 (0, 0, 1, 1),
 (0, 1, 0, 0),
 (0, 1, 0, 1),
 (0, 1, 1, 0),
 (0, 1, 1, 1),
 (1, 0, 0, 0),
 (1, 0, 0, 1),
 (1, 0, 1, 0),
 (1, 0, 1, 1),
 (1, 1, 0, 0),
 (1, 1, 0, 1),
 (1, 1, 1, 0),
 (1, 1, 1, 1)]

我想删除至少两个“1”相邻的元组，例如

（0,1,1,0）

我试过这个：

for i in l1:
    for j in i:
         if j==1 and j+1 == 1:
                l1.remove(i)

我想这是行不通的，因为它把j+1当作实际的数字+1，比如如果j=1，它就等于2，以此类推

---

我应该做些什么不同的事情？

这应该可以做到：

>>n=4
>>>来自itertools进口产品
>>>l1=列表（（产品（（0,1），重复=n）））
>>>l1
[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (0, 1, 1, 1), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (1, 1, 1, 1)]
>>>[t表示l1中的t，如果没有（t[i]==1，t[i+1]==1表示范围（n-1）中的i））]
[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 1, 0, 0), (0, 1, 0, 1), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0)]

notany（对于范围（n-1）中的i，t[i]==1和t[i+1]==1）条件基本上检查连续元素是否等于1。注意
范围（n-1）
索引迭代器-我们不想检查第n个元素和第n+1个元素，因为上面的任何元组中都没有第五个元素

定时

注意，我的函数的速度大约是它的两倍

>>从时间导入时间为t
>>>def f1（）：
...     t0=t（）
...     结果=[i为l1中的i，如果（1，1）不在zip中（i，i[1:]）]
...     t1=t（）
...     打印（t1-t0）
... 
>>>def f2（）：
...     t0=t（）
...     结果=[t表示l1中的t，如果没有（t[i]==1，t[i+1]==1表示范围（n-1）中的i））]
...     t1=t（）
...     打印（t1-t0）
... 
>>>l1=列表（（产品（（0,1），重复=n））*1000000
>>>len（l1）
16000000
>>>f1（）
8.146391868591309
>>>f2（）
18.645386934280396
这应该可以做到：

>>n=4
>>>来自itertools进口产品
>>>l1=列表（（产品（（0,1），重复=n）））
>>>l1
[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (0, 1, 1, 1), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (1, 1, 1, 1)]
>>>[t表示l1中的t，如果没有（t[i]==1，t[i+1]==1表示范围（n-1）中的i））]
[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 1, 0, 0), (0, 1, 0, 1), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0)]

notany（对于范围（n-1）中的i，t[i]==1和t[i+1]==1）条件基本上检查连续元素是否等于1。注意
范围（n-1）
索引迭代器-我们不想检查第n个元素和第n+1个元素，因为上面的任何元组中都没有第五个元素

定时

注意，我的函数的速度大约是它的两倍

>>从时间导入时间为t
>>>def f1（）：
...     t0=t（）
...     结果=[i为l1中的i，如果（1，1）不在zip中（i，i[1:]）]
...     t1=t（）
...     打印（t1-t0）
... 
>>>def f2（）：
...     t0=t（）
...     结果=[t表示l1中的t，如果没有（t[i]==1，t[i+1]==1表示范围（n-1）中的i））]
...     t1=t（）
...     打印（t1-t0）
... 
>>>l1=列表（（产品（（0,1），重复=n））*1000000
>>>len（l1）
16000000
>>>f1（）
8.146391868591309
>>>f2（）
18.645386934280396
您可以使用
zip（i，i[1:]）
构建邻居对，并检查它们是否包含
（1，1）
：

您可以使用
zip（i，i[1:]）
构建邻居对，并检查它们是否包含
（1，1）
：

添加一个不太“pythonic”但更具可读性的示例以供考虑：

def filter_helper(t):
  for i, val in enumerate(t):
    if i != 0 and (t[i-1]) == val and val == 1:
      return False  
  return True

print(list(filter(filter_helper, a)))

其中
a
是元组的原始列表。
添加了一个不太“pythonic”但更具可读性的示例以供考虑：

def filter_helper(t):
  for i, val in enumerate(t):
    if i != 0 and (t[i-1]) == val and val == 1:
      return False  
  return True

print(list(filter(filter_helper, a)))

其中
a
是元组的原始列表。
您的方法在逻辑上是合理的，但不幸的是在Python（或大多数其他语言）中不起作用，并且实现是不正确的，因为
j==1和j+1==1
从来都不是真的；如果
j
等于1，则
j+1
等于2，周期。但更大的问题是，您试图在迭代列表时从列表中删除内容

首先，让我们解决如何检查两个1是否相邻的问题。我们不需要看
j
和
j+1
，而需要看
t[j]
和
t[j+1]
，其中
t
是元组之一。另外，
j
需要迭代到长度减1，否则
t[j+1]
将在元组末尾给出一个
索引器。
any
功能是一种方便的方法：

any（t[j]==t[j+1]==1表示范围（n-1）内的j）

请注意，
t[j]==t[j+1]==1
在Python中工作，这是因为

现在，让我们解决如何从列表中删除这些元素的问题。只需创建一个包含所需元素的新列表，比删除不需要的元素方便得多。列表理解是一种方便的方法：

结果=[
t表示乘积中的t（（0，1），重复=n）
如果没有（t[j]==t[j+1]==1，对于范围（n-1）内的j）
]

结果:

[（0,0,0,0），
(0, 0, 0, 1),
(0, 0, 1, 0),
(0, 1, 0, 0),
(0, 1, 0, 1),
(1, 0, 0, 0),
(1, 0, 0, 1),
(1, 0, 1, 0)]

综上所述，对于较大的n，使用只生成您想要的元素的算法将更有效，而不是在整个笛卡尔积（大小为2n）上循环并拒绝您不想要的元素。
您的方法具有逻辑意义，但不幸的是在Python（或大多数其他语言）中不起作用，实现是不正确的，因为
j==1和j+1==1
从来都不是真的；如果
j
等于1，则
j+1
等于2，周期。但更大的问题是你试图从列表中删除一些东西
for x in l1:
    if any([(x[i]==x[i+1]==1) for i in x]) == True:
        l1.remove(x)