Question

我有两个长度相同的列表，比如3。

A=[1,2,3]
B=[4,5,6]

我想获得两者的笛卡尔积，但在同一位置的元素不应计算，即：

(1,5),(1,6),(2,4),(2,6),(3,4),(3,5)

我该怎么做？

Answer 1

你几乎可以直接记下你的'精致'的贝塞尔产品：

    $data['username'] = $_POST['username'];
    $data['mobile'] = $_POST['mobile'];
    $data['password'] =  $_POST['password'];
    $data['email'] = $_POST['email']; 

    $post_str = '';

   foreach($data as $key=>$val) 
        {
            $post_str .= urlencode($key).'='.urlencode($val).'&';
        }
        echo $post_str = substr($post_str, 0, -1);


 $url = 'https://api.parse.com/1/users';  

 $appId = 'apikey';  
 $restKey = 'rest key';  
 $headers = array(  
   "Content-Type: application/json",  
   "X-Parse-Application-Id: " . $appId,  
   "X-Parse-REST-API-Key: " . $restKey  
 );  


$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url );
curl_setopt($ch, CURLOPT_POST, TRUE);
 curl_setopt($ch, CURLOPT_FRESH_CONNECT, FALSE);
curl_setopt($ch,CURLOPT_HTTPHEADER,$headers);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($post_str) );

curl_setopt($ch,CURLOPT_SSL_VERIFYPEER, false); 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);


$result = curl_exec($ch);

curl_close($ch);
echo $result;

Answer 2

所以我的方法是使用zip()和itertools.product()：

import itertools
A = [1, 2, 3]
B = [4, 5, 6]

spe = set(zip(A, B))
l = [i for i in itertools.product(A, B) if i not in spe]

来自itertools.product()的文件：

itertools.product(*iterables, repeat=1)
  输入迭代的笛卡尔积。

等效于生成器表达式中的嵌套for循环。例如，product(A, B)返回与((x,y) for x in A for y in B)相同的内容。

嵌套循环像里程表一样循环，最右边的元素在每次迭代时前进。此模式创建了一个字典顺序，以便在输入的可迭代内容进行排序时，产品元组按排序顺序发出。

并且zip()执行创建一个迭代器，聚合来自每个迭代的元素。正如文档所说。

所以我的代码创建了一个集合，它有你不想要的元素，然后itertools.product(A, B)生成完整列表，if i not in spe删除你不想要的元素。

Answer 3

以正常方式获取产品，然后将其过滤掉：

import itertools
A=[1,2,3]
B=[4,5,6]
prod = ((x,y) for x,y in itertools.product(A, B) if A.index(x) != B.index(y))

结果：

>>> for p in prod:
...     print(p)
...
(1, 5)
(1, 6)
(2, 4)
(2, 6)
(3, 4)
(3, 5)

prod是一个生成器，所以如果您计划多次使用它，请记住使用prod = [...]创建一个理解。

请注意，如果A和B包含重复元素，则此方法无效。要解决此问题，enumerate它并丢弃带有不需要的索引的项目：

prod = (item for idx,item in enumerate((x,y) for x,y in itertools.product(A, B)) if idx%(len(A)))

结果：

>>> for p in prod:
...     print(p)
...
(1, 5)
(1, 6)
(2, 5)
(2, 6)
(3, 5)
(3, 6)

Answer 4

在列表上没有任何索引，也没有基于列表长度的任何计算，使用普通枚举

data.get('id', None)

Answer 5

您可以为list A的每个值迭代list B并迭代list A。如果两个列表的索引不同，则可以打印出两个列表中元素的组合。

for i in range(len(A)):
        for j in range(len(B)):
                if i != j:
                        print '(',A[i],B[j],')'


( 1 5 )
( 1 6 )
( 2 4 )
( 2 6 )
( 3 4 )
( 3 5 )

Answer 6

您可以尝试以下方法。由于笛卡尔积是一组，所以我将以一组元组的形式给出答案：

使用设定的理解力

>>> A=[1,2,3]
>>> B=[4,5,6]
>>> {(a, b) for i, a in enumerate(A) for j, b in enumerate(B) if i != j}
{(1, 5), (1, 6), (2, 4), (2, 6), (3, 4), (3, 5)}

我使用enumerate(l)是为了在每个迭代中都有一个元组(index, element)，其中index是element中每个l的索引。

使用itertools

>>> import itertools
>>> {(a, b) for a, b in itertools.product(A, B) if A.index(a) != B.index(b)}
{(1, 5), (1, 6), (2, 4), (2, 6), (3, 4), (3, 5)}

计算两个列表的笛卡尔积，没有相同索引的元素

6 个答案:

使用设定的理解力

使用itertools