\subsection{List Comprehensions}

List comprehensions provide a concise way to create lists without resorting

to use of the \func{map()} or \func{filter()} functions. The resulting

construct tends often to be clearer than use of those functions.

\begin{verbatim}

\end{verbatim}

atom: '(' [testlist] ')' | '[' [listmaker] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+

listmaker: test ( list_iter | (',' test)* [','] )

list_iter: list_for | list_if

list_for: 'for' exprlist 'in' testlist [list_iter]

list_if: 'if' test [list_iter]

#define listmaker 302

#define lambdef 303

#define trailer 304

#define subscriptlist 305

#define subscript 306

#define sliceop 307

#define exprlist 308

#define testlist 309

#define dictmaker 310

#define classdef 311

#define arglist 312

#define argument 313

#define list_iter 314

#define list_for 315

#define list_if 316

['Apple', 'Banana', 'Coco nut']

[3, 6, 9, 12, 15]

[3, 4, 5]

[(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'), (2, 'Apple'), (2, 'Banana'), (2, 'Coconut'), (3, 'Apple'), (3, 'Banana'), (3, 'Coconut'), (4, 'Apple'), (4, 'Banana'), (4, 'Coconut'), (5, 'Apple'), (5, 'Banana'), (5, 'Coconut')]

[(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'), (3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'), (5, 'Banana'), (5, 'Coconut')]

good: got a SyntaxError as expected

[('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'), ('Macdonalds', 'Cheeseburger')]

nums = [1, 2, 3, 4, 5]

strs = ["Apple", "Banana", "Coconut"]

spcs = [" Apple", " Banana ", "Coco nut "]

print [s.strip() for s in spcs]

print [3 * x for x in nums]

print [x for x in nums if x > 2]

print [(i, s) for i in nums for s in strs]

print [(i, s) for i in nums for s in [f for f in strs if "n" in f]]

try:

eval("[i, s for i in nums for s in strs]")

print "FAIL: should have raised a SyntaxError!"

except SyntaxError:

print "good: got a SyntaxError as expected"

suppliers = [

(1, "Boeing"),

(2, "Ford"),

(3, "Macdonalds")

]

parts = [

(10, "Airliner"),

(20, "Engine"),

(30, "Cheeseburger")

]

suppart = [

(1, 10), (1, 20), (2, 20), (3, 30)

]

print [

(sname, pname)

for (sno, sname) in suppliers

for (pno, pname) in parts

for (sp_sno, sp_pno) in suppart

if sno == sp_sno and pno == sp_pno

]

int c_tmpname; /* temporary local name counter */

static void com_list_iter(struct compiling *, node *, node *, char *);

static void com_assign(struct compiling *, node *, int);

c->c_tmpname = 0;

com_list_for(struct compiling *c, node *n, node *e, char *t)

PyObject *v;

int anchor = 0;

int save_begin = c->c_begin;

/* list_iter: for v in expr [list_iter] */

com_node(c, CHILD(n, 3)); /* expr */

v = PyInt_FromLong(0L);

if (v == NULL)

c->c_errors++;

com_addoparg(c, LOAD_CONST, com_addconst(c, v));

com_push(c, 1);

Py_XDECREF(v);

c->c_begin = c->c_nexti;

com_addoparg(c, SET_LINENO, n->n_lineno);

com_addfwref(c, FOR_LOOP, &anchor);

com_push(c, 1);

com_assign(c, CHILD(n, 1), OP_ASSIGN);

c->c_loops++;

com_list_iter(c, n, e, t);

c->c_loops--;

com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);

c->c_begin = save_begin;

com_backpatch(c, anchor);

com_pop(c, 2); /* FOR_LOOP has popped these */

}

static void

com_list_if(struct compiling *c, node *n, node *e, char *t)

{

int anchor = 0;

int a = 0;

/* list_iter: 'if' test [list_iter] */

com_addoparg(c, SET_LINENO, n->n_lineno);

com_node(c, CHILD(n, 1));

com_addfwref(c, JUMP_IF_FALSE, &a);

com_addbyte(c, POP_TOP);

com_pop(c, 1);

com_list_iter(c, n, e, t);

com_addfwref(c, JUMP_FORWARD, &anchor);

com_backpatch(c, a);

/* We jump here with an extra entry which we now pop */

com_addbyte(c, POP_TOP);

com_backpatch(c, anchor);

}

static void

com_list_iter(struct compiling *c,

node *p, /* parent of list_iter node */

node *e, /* element expression node */

char *t /* name of result list temp local */)

{

/* list_iter is the last child in a listmaker, list_for, or list_if */

node *n = CHILD(p, NCH(p)-1);

if (TYPE(n) == list_iter) {

n = CHILD(n, 0);

switch (TYPE(n)) {

case list_for:

com_list_for(c, n, e, t);

break;

case list_if:

com_list_if(c, n, e, t);

break;

default:

com_error(c, PyExc_SystemError,

"invalid list_iter node type");

}

}

else {

com_addopnamestr(c, LOAD_NAME, t);

com_push(c, 1);

com_node(c, e);

com_addoparg(c, CALL_FUNCTION, 1);

com_addbyte(c, POP_TOP);

com_pop(c, 2);

}

}

static void

com_list_comprehension(struct compiling *c, node *n)

{

/* listmaker: test list_iter */

char tmpname[12];

sprintf(tmpname, "__%d__", ++c->c_tmpname);

com_addoparg(c, BUILD_LIST, 0);

com_addbyte(c, DUP_TOP); /* leave the result on the stack */

com_push(c, 2);

com_addopnamestr(c, LOAD_ATTR, "append");

com_addopnamestr(c, STORE_NAME, tmpname);

com_pop(c, 1);

com_list_iter(c, n, CHILD(n, 0), tmpname);

com_addopnamestr(c, DELETE_NAME, tmpname);

--c->c_tmpname;

}

static void

com_listmaker(struct compiling *c, node *n)

{

/* listmaker: test ( list_iter | (',' test)* [','] ) */

if (TYPE(CHILD(n, 1)) == list_iter)

com_list_comprehension(c, n);

else {

int len = 0;

int i;

for (i = 0; i < NCH(n); i += 2, len++)

com_node(c, CHILD(n, i));

com_addoparg(c, BUILD_LIST, len);

com_pop(c, len-1);

}

case LSQB: /* '[' [listmaker] ']' */

com_listmaker(c, CHILD(n, 1));

if (TYPE(CHILD(n, 1)) == dictmaker)

static void

com_assign_list(struct compiling *c, node *n, int assigning)

{

int i;

if (assigning) {

i = (NCH(n)+1)/2;

com_addoparg(c, UNPACK_SEQUENCE, i);

com_push(c, i-1);

}

for (i = 0; i < NCH(n); i += 2)

com_assign(c, CHILD(n, i), assigning);

}