Xjyuk

I'm looking for an implementation of list comprehensions in Python (nested for-in statement with destructuring and conditionals). Here's an example:

matrix=[['a','b'],['c','d']]
flat=[(el,i,j) for (i, array) in enumerate(matrix) for (j, el) in enumerate(array) if i!=j]
print(flat)

Now, anyone could write this with a table or loop, but that's not what I'm looking for.

A straightforward translation of a general list comprehension, suggested by various Python tutorials, even if not the most efficient way (see for instance @Roman's answer), is to append each item to a list:

Module[res = ,
 MapIndexed[ (* use Do[], Map[], or MapIndexed[] to implement the iterable *)
 Function[array, i,
 MapIndexed[
 Function[el, j,
 If[i != j, (* if condition *)
 AppendTo[res, el, First@i, First@j]] (* add to list *)
 ],
 array
 ]
 ],
 matrix
 ];
 res
 ]

Reap and Sow might be the closest thing in Mathematica to a list comprehension, and effectively implements the above approach.

Reap[
 MapIndexed[
 Function[array, i,
 MapIndexed[
 Function[el, j,
 If[i != j, Sow[el, First@i, First@j]]
 ],
 array
 ]
 ],
 matrix
 ]
 ][[2, 1]]

And Reap-Sow allows multiple list comprehensions simultaneously with the second tag argument.

Note: Sometimes one can use Table[] with If[condition, x, Nothing] to implement [x for x in list if condition]. But implementing nested iterations with Table[], such as in the OP's example, would result in nested lists instead of a flat list. They could be flattened. For the OP's example:

Flatten[
 Table[
 With[array = matrix[[i]],
 Table[
 With[el = array[[j]],
 If[i != j, el, i, j, Nothing]
 ],
 j, Length@array
 ]
 ],
 i, Length@matrix
 ],
 1
 ]

Note that with Table[], Do[], and Map[] you can only have one item, either the index j or the element el. If you get the index, you can extract the element as above.. To get both at once, you would have to use MapIndexed. Note also that instead of Table[], you can use MapIndexed at level 2, as in @Roman's answer, which produces a nested, non-flat, result. Using MapIndexed[] instead of Table[] above gives us the following solution:

Flatten[
 MapIndexed[
 If[Unequal @@ #2, Flatten[##], Nothing] &, 
 matrix,
 2],
 1]

Something like this?

matrix = "a", "b", "c", "d";

allflat = Flatten[MapIndexed[List, matrix, 2], 1]
(* "a", 1, 1, "b", 1, 2, "c", 2, 1, "d", 2, 2 *)

flat = Select[allflat, Apply[Unequal]@*Last]
(* "b", 1, 2, "c", 2, 1 *)

...an implementation of list comprehensions in Python

We could implement Python (poorly) in Mathematica:

Needs@"GeneralUtilities`";

ClearAll[for];
SetAttributes[for, HoldAll];
for[x_ ∈ iterator_, body_] /; MatchQ[iterator, _Iterator] := 
 Module[i, iter = iterator, tag,
 Hold[x] /. Hold[v___] | Hold[v___] :>
 Block[v, (* Blocks variables in x *)
 Reap[
 While[
 i = Read[iter];
 i =!= IteratorExhausted,
 x = i;
 Sow[body, tag]
 ],
 tag][[2, 1]]
 ]];

enumerate[list_List] := NewIterator[
 enumerate,
 i = 0, max = Length@list,
 If[i++ < max, i, list[[i]], IteratorExhausted]];

ClearAll[lc];
SetAttributes[lc, HoldAll];
lc[x_, iterFN_] := Module[tag,
 Reap[iterFN[Unevaluated@Sow[x, tag]], tag][[2, 1]]
 ];

Now the syntax is pretty close to Python's:

[
 (el,i,j)
 for (i, array) in enumerate(matrix) for (j, el) in enumerate(array) if i!=j
 ]

lc[
 el, i, j,
 for[i, array ∈ enumerate@matrix, for[j, el ∈ enumerate@array, If[i != j, #]]] &
 ]

(* "b", 1, 2, "c", 2, 1 *)

One could even alter enumerate[] to index arrays from 0 instead of 1.