Python 检查元素是否在列表中

我有一个矩阵或列表：

x = [[1,2,3], 
     [2,3,1], 
     [3,1,2]]

我的目标是检查

1） 矩阵的每一列包含从1到n的每一个整数，精确一次

2） 矩阵的每一行包含从1到n的每一个整数，精确一次

这是我在解决Udacity的编程入门课程时遇到的问题练习。这是我解决问题的办法。我知道这是漫长而低效的。那么，解决这个问题的简单有效的方法是什么

def check(p):
    j = 0
    for e in p:
        i = 1 + j
    s = str(p)

    if s.find('.')!= -1:
        return False

    while i < len(p):
        if p[i] == e:
            return False
        if p[i] > len(p) or p[i] < 1:
            return False
        i += 1
        j += 1
    return True

def check_sudoku(p):
    i = 0
    z = []
    a = []
    x = 0
    for e in p:
        r = check(e)
        if r == False:
            return r

    #Below here is to transpose the list
    while x < len(p):
        z.append(1)
        x += 1
    while i < len(p):
        for e in p:
            a.append(e.pop())
        z[i] = a
        i +=  1
        a = []

    #Below here is to check the transpose
    for g in z:
        r = check(g)
        if r == False:
            return r
    return True

def检查（p）：
j=0
对于p中的e：
i=1+j
s=str（p）
如果s.find（'.'）！=-1:
返回错误
而ilen（p）或p[i]<1：
返回错误
i+=1
j+=1
返回真值
def check_数独（p）：
i=0
z=[]
a=[]
x=0
对于p中的e：
r=检查（e）
如果r==False：
返回r
#下面是对列表的转置
而x

您可以这样简化检查程序：

def check_valid(matrix):
    n = len(matrix[0])
    valid_num = range(1, n+1)     # make a list of valid number from 1 to n

    # sort rows and column of matrix in ascending order and compare with valid_num 
    for line in matrix:
        if sorted(line) != valid_num:
            return False
    for column in zip(*matrix):
        if sorted(column) != valid_num:
            return False

    # If all rows and column is valid, then 
    return True 

编辑：遵循@vocalno KISS规则，但速度更快，适用于数字和字符

def check_valid2(matrix):
    n = len(matrix)

    for line in matrix+zip(*matrix):
        if len(set(line)) != n:
            return False

    return True

In[9]: %timeit for m in (x, y): check_valid_mine(m)
100000 loops, best of 3: 8.55 µs per loop

In[10]: %timeit for m in [x,y]: check_valid2(m)
100000 loops, best of 3: 5.77 µs per loop

编辑2:关于速度的所有内容

def check_valid3(matrix):
    n = len(matrix)

    for line in matrix+zip(*matrix):
        if not len(set(line)) - n:
            return False

    return True

In[19]: %timeit for m in [x,y]: check_valid3(m)
100000 loops, best of 3: 2.29 µs per loop

---

您可以简化您的检查程序，如下所示：

def check_valid(matrix):
    n = len(matrix[0])
    valid_num = range(1, n+1)     # make a list of valid number from 1 to n

    # sort rows and column of matrix in ascending order and compare with valid_num 
    for line in matrix:
        if sorted(line) != valid_num:
            return False
    for column in zip(*matrix):
        if sorted(column) != valid_num:
            return False

    # If all rows and column is valid, then 
    return True 

编辑：遵循@vocalno KISS规则，但速度更快，适用于数字和字符

def check_valid2(matrix):
    n = len(matrix)

    for line in matrix+zip(*matrix):
        if len(set(line)) != n:
            return False

    return True

In[9]: %timeit for m in (x, y): check_valid_mine(m)
100000 loops, best of 3: 8.55 µs per loop

In[10]: %timeit for m in [x,y]: check_valid2(m)
100000 loops, best of 3: 5.77 µs per loop

编辑2:关于速度的所有内容

def check_valid3(matrix):
    n = len(matrix)

    for line in matrix+zip(*matrix):
        if not len(set(line)) - n:
            return False

    return True

In[19]: %timeit for m in [x,y]: check_valid3(m)
100000 loops, best of 3: 2.29 µs per loop

这是我的解决办法

我在行和列之间循环，使用zip翻转矩阵和链-组合2个列表。 如果行或列包含的值不在有效的_集中

表达式将产生非空集-由not变为False-并且所有循环将结束

from itertools import chain
def check_valid(matrix, n):
   valid_set = set(range(1, n+1))
   return all(not(set(row) - valid_set) for row in chain(matrix, zip(*matrix)))

编辑：
对不起，误读了问题；以下是正确答案-第一个错误的所有出口

编辑2:

出于好奇-我选择了定时排序与设置方法

set大约快30%

编辑3: 我修正了解决方案并更新了我的

In [132]: def check_valid(matrix):
    valid_num = np.unique(np.array(matrix)).tolist() # selects unique elements
    for line in matrix:
        if sorted(line) != valid_num:
            return False
    for column in zip(*matrix):
        if sorted(column) != valid_num:
            return False
    return True
In [136]: %timeit for m in (z, d): check_valid(m)
10000 loops, best of 3: 57.8 us per loop

In [115]: def check_valid_mine(matrix):                                                  
       valid_set = set(chain(*matrix))
       return all(set(row) == valid_set for row in chain(matrix, zip(*matrix)))

In [137]: %timeit for m in (z, d): check_valid_mine(m)
100000 loops, best of 3: 8.96 us per loop

底线是什么？吻-保持简单愚蠢

用zip（）解释矩阵转置

• 函数调用中iterable参数之前的运算符从本质上扩展了此位置参数的参数列表
  zip（*矩阵）

意味着

从而将列重新排列为行 查看*和**运算符的详细说明，这是我的解决方案

我在行和列之间循环，使用zip翻转矩阵和链-组合2个列表。 如果行或列包含的值不在有效的_集中

表达式将产生非空集-由not变为False-并且所有循环将结束

from itertools import chain
def check_valid(matrix, n):
   valid_set = set(range(1, n+1))
   return all(not(set(row) - valid_set) for row in chain(matrix, zip(*matrix)))

编辑：
对不起，误读了问题；以下是正确答案-第一个错误的所有出口

编辑2:

出于好奇-我选择了定时排序与设置方法

set大约快30%

编辑3: 我修正了解决方案并更新了我的

In [132]: def check_valid(matrix):
    valid_num = np.unique(np.array(matrix)).tolist() # selects unique elements
    for line in matrix:
        if sorted(line) != valid_num:
            return False
    for column in zip(*matrix):
        if sorted(column) != valid_num:
            return False
    return True
In [136]: %timeit for m in (z, d): check_valid(m)
10000 loops, best of 3: 57.8 us per loop

In [115]: def check_valid_mine(matrix):                                                  
       valid_set = set(chain(*matrix))
       return all(set(row) == valid_set for row in chain(matrix, zip(*matrix)))

In [137]: %timeit for m in (z, d): check_valid_mine(m)
100000 loops, best of 3: 8.96 us per loop

底线是什么？吻-保持简单愚蠢

用zip（）解释矩阵转置

• 函数调用中iterable参数之前的运算符从本质上扩展了此位置参数的参数列表
  zip（*矩阵）

意味着

从而将列重新排列为行

---

查看有关*和**运算符的详细说明

我正在搜索一个字符和数字都完全匹配的解决方案，我使用numpy库提供了一个解决方案。我稍微修改了dragon2fly解决方案。如果我错了，请纠正我。我检查了解决方案的z和d值，它给出了正确的结果

 import numpy as np

z = [[8,9,10],  # example case with numbers
     [9,10,8], 
     [10,8,9]]


d =  [['a','b','c'], # example case with characters
      ['b','c','a'],
      ['c','a','b']]

def check_valid(matrix):
    valid_num = list(np.unique(matrix)) # selects unique elements


    # sort rows and column of matrix in ascend order and compare with valid_num 
    for line in matrix:
        if sorted(line) != valid_num:
            return False
    for column in zip(*matrix):
        if sorted(column) != valid_num:
            return False

    # If all rows and column is valid, then 
    return True

---

我正在寻找一个字符和数字都能完美匹配的解决方案，我用numpy库提供了一个解决方案。我稍微修改了dragon2fly解决方案。如果我错了，请纠正我。我检查了解决方案的z和d值，它给出了正确的结果

 import numpy as np

z = [[8,9,10],  # example case with numbers
     [9,10,8], 
     [10,8,9]]


d =  [['a','b','c'], # example case with characters
      ['b','c','a'],
      ['c','a','b']]

def check_valid(matrix):
    valid_num = list(np.unique(matrix)) # selects unique elements


    # sort rows and column of matrix in ascend order and compare with valid_num 
    for line in matrix:
        if sorted(line) != valid_num:
            return False
    for column in zip(*matrix):
        if sorted(column) != valid_num:
            return False

    # If all rows and column is valid, then 
    return True

---

1） 你的缩进是错的。2） 在Python中使用

\

来开始注释，而不是“\”。3） 有一种更好的方法可以检查不需要转换为字符串的列表内容。4） 您可以使用zip（*list2D）转换列表列表。@PM2Ring-Hi-我肯定会调查这些错误。如果你能写出一个有效率的答案，那就太好了。我对编程和编程相当陌生python@user00000341您共享的链接中的答案是不相关的。@PM2Ring-我已经编辑了，希望我没有在编辑时破坏您代码的逻辑。：）顺便说一句，如果r==False:，那么最好执行

，如果r==False:

；类似地，如果r:比r==True:好。1）缩进是错误的。2） 在Python中使用

\

来开始注释，而不是“\”。3） 有一种更好的方法可以检查不需要转换为字符串的列表内容。4） 您可以使用zip（*list2D）转换列表列表。@PM2Ring-Hi-我肯定会调查这些错误。如果你能写出一个有效率的答案，那就太好了。我对编程和编程相当陌生python@user00000341您共享的链接中的答案是不相关的。@PM2Ring-我已经编辑了，希望我没有在编辑时破坏您代码的逻辑。：）顺便说一句，如果r==False:，那么最好执行

，如果r==False:

；类似地，如果r:比r==True:更好，则此解决方案也适用于字符。例如：[[a，b，c]，[b，c，a]@jamedreen您必须将

valid_num

更改为

valid_char=[chr（c）表示范围内的c（ord（'a'），ord（'c'）+1）]

@jamedreen:如果您喜欢dragon2fly的解决方案，您应该选择它。我已经选择了