La comprensión de listas es una construcción sintáctica disponible en algunos lenguajes de programación para crear una lista basada en listas existentes. Sigue la forma de la notación matemática del constructor de conjuntos ( comprensión de conjuntos ) a diferencia del uso de funciones de mapa y filtro .
Listado con todos los dobles del 0 al 10 (exclusivo)
dobles = [ i * 2 para i en el rango ( 10 )] Lista con los nombres de los clientes radicados en Río de Janeiro
rjClientes = [ cliente . Nombre del cliente en clientes si cliente . Estado == "RJ" ] var ns = de x en Enumerable . Rango ( 0 , 100 ) donde x * x > 3 seleccione x * 2 ; El código anterior es azúcar sintáctico para el siguiente código escrito usando expresiones lambda:
var ns = Enumerable . Rango ( 0 , 100 ) . Donde ( x => x * x > 3 ) . Seleccione ( x => x * 2 ); Filtrar números divisibles por 3:
valor divisibleBy3 = { para ( i en 0 .. 100 ) si ( i % 3 == 0 ) i }; // el tipo de divisibleBy3 es Iterable<Integer> Múltiples "generadores":
valor se triplica = { para ( x en 0 .. 20 ) para ( y en x .. 20 ) para ( z en y .. 20 ) if ( x * x + y * y == z * z ) [ x , y , z ] }; // el tipo de tripletas es Iterable<Integer[3]> Una secuencia perezosa infinita:
( para [x ( iterar inc 0 ) : cuando ( > ( * x x ) 3 ) ] ( * 2 x )) Una lista de comprensión utilizando múltiples generadores:
( para [x ( rango 20 ) y ( rango 20 ) z ( rango 20 ) : cuando ( == ( + ( * x x ) ( * y y )) ( * z z )) ] [x y z] ) númerosgrandes = ( número para el número en la lista cuando el número > 100 ) Las listas por comprensión se pueden expresar con la palabra clave loopde la macro collect. Los condicionales se expresan con if, de la siguiente manera:
( bucle para x de 0 a 100 si ( > ( * x x ) 3 ) recoger ( * 2 x )) Enumere los nombres de los clientes:
nombres = para clientes en clientes obtienen clientes . nombreListar los clientes con saldos:
nombres = para cliente en clientes donde cliente . saldo > 0Enumere los nombres de los clientes con saldos:
nombres = para cliente en clientes donde cliente . saldo > 0 obtener cliente . nombreLas formas generales:
para VAR en ENUMERABLE [ donde CONDICIÓN ] obtenga EXPR para VAR en ENUMERABLE donde CONDICIÓNTenga en cuenta que al colocar la condición y la expresión después del nombre de la variable y el objeto enumerable, los editores y los IDE pueden proporcionar autocompletado en los miembros de la variable.
[ para ( var i en el rango ( 0 , 100 )) si ( i * i > 3 ) i * 2 ] var pyth = [ para ( var x en el rango ( 1 , 20 )) para ( var y en el rango ( x , 20 )) para ( var z en el rango ( y , 20 )) si ( x * x + y * y = = z * z ) [ x , y , z ] ]; Rango iterable <int> ( int inicio , int fin ) = > Lista . generar ( fin - inicio , ( i ) => inicio + i ); para x <- 0 .. 100 , x * x > 3 , haga : x * 2 L = listas : seq ( 0 , 100 ). S = [ 2 * X || X <- L , X * X > 3 ]. Secuencias evaluadas con pereza:
seq { para x en 0 .. 100 hazlo si x * x > 3 entonces produce 2 * x } O, para valores de punto flotante
seq { para x en 0 . .. 100 . hazlo si x ** 2 . > 3 . luego produce 2 .* x } Listas y matrices:
[ para x en 0 . .. 100 . hazlo si x ** 2 . > 3 . luego produce 2 .* x ] [| para x en 0 . .. 100 . hazlo si x ** 2 . > 3 . luego produce 2 .* x |] Las listas por comprensión son parte de una familia más amplia de construcciones del lenguaje llamadas expresiones de cálculo.
[ x * 2 | x <- [ 0 .. 99 ], x * x > 3 ] Un ejemplo de comprensión de listas utilizando múltiples generadores:
pyth = [( x , y , z ) | x <- [ 1 .. 20 ], y <- [ x .. 20 ], z <- [ y .. 20 ], x ^ 2 + y ^ 2 == z ^ 2 ] Al utilizar el objeto Range, el lenguaje Io puede crear listas tan fácilmente como en otros lenguajes:
Rango 0 a ( 100 ) asList seleccionar ( x , x * x > 3 ) mapa (* 2 ) Las listas por comprensión se pueden expresar con la forforma especial. Los condicionales se expresan con if, de la siguiente manera:
( para (( x 0 ( + x 1 )) ( cobrar ())) (( >= x 100 ) ( cobrar inverso )) ( if ( > ( * x x ) 3 ) ( setq cobrar ( contras ( * x 2 ) recolectar )))) Julia apoya la comprensión usando la sintaxis:
y = [ x ^ 2 + 1 para x en 1 : 10 ] y comprensiones multidimensionales como:
z = [( x - 5 ) ^ 2 + ( y - 5 ) ^ 2 para x = 0 : 10 , y = 0 : 10 ] También es posible agregar una condición:
v = [ 3 x ^ 2 + 2 y ^ 2 para x en 1 : 7 para y en 1 : 7 si x % y == 0 ] Y simplemente cambiando los corchetes por los redondos, obtenemos un generador:
g = ( 3 x ^ 2 + 2 y ^ 2 para x en 1 : 7 para y en 1 : 7 si x % y == 0 ) s = [ 2*i para i en 1..100 donde i*i > 3 ];
Múltiples generadores:
pyth = [ (x,y,z) para x en 1..20 para y en x..20 para z en y..20 donde x*x + y*y == z*z ];
$[ x * 2 | x en [ 0 .. 100 ], x * x > 3 ]Nim tiene comprensiones de secuencias, conjuntos, tablas y objetos integradas en el módulo de biblioteca estándar de azúcar: [1]
importar azúcar let variable = recopilar ( newSeq ): para el elemento en @[- 9 , 1 , 42 , 0 , - 1 , 9 ] : elemento + 1 afirmar variable == @[- 8 , 2 , 43 , 1 , 0 , 10 ] La comprensión se implementa como una macro que se expande en el momento de la compilación; puede ver el código expandido usando la opción del compilador expandMacro :
var recopilarResultado = newSeq ( Natural ( 0 )) para elemento en elementos ( @[- 9 , 1 , 42 , 0 , - 1 , 9 ] ): agregar ( recopilarResultado , elemento + 1 ) recopilarResultado Las comprensiones pueden ser anidadas y multilínea:
importar azúcar let valores = recopilar ( newSeq ): para val en [ 1 , 2 ] : recopilar ( newSeq ): para val2 en [ 3 , 4 ] : if ( val , val2 ) ! = ( 1 , 2 ): ( val , val2 ) afirmar valores == @[@[ ( 1 , 3 ), ( 1 , 4 ) ] , @[ ( 2 , 3 ), ( 2 , 4 ) ]] OCaml admite la comprensión de listas a través de baterías OCaml . [2]
mi @s = mapa { 2 * $_ } grep { $_ ** 2 > 3 } 0 .. 99 ; Matriz con todos los dobles del 1 al 9 inclusive:
mis @doubles = mapa { $_ * 2 } 1 .. 9 ; Matriz con los nombres de los clientes con sede en Río de Janeiro (a partir de una serie de hashes):
mi @rjCustomers = mapa { $_ -> { estado } eq "RJ" ? $_ -> { nombre } : ()} @clientes ; Filtrar números divisibles por 3:
mi @divisibleBy3 = grep { $_ % 3 == 0 } 0 .. 100 ; $s = ( 0 .. 100 | ? { $_ * $_ -gt 3 } | % { 2 * $_ } )que es una notación abreviada de:
$s = 0 .. 100 | objeto-dónde { $_ * $_ -gt 3 } | foreach -objeto { 2 * $_ }Python usa la siguiente sintaxis para expresar listas por comprensión en listas finitas:
S = [ 2 * x para x en el rango ( 100 ) si x ** 2 > 3 ]Se puede usar una expresión generadora en las versiones de Python >= 2.4, que proporciona una evaluación diferida de su entrada, y se puede usar con generadores para iterar sobre entradas 'infinitas', como la función generadora de conteo que devuelve enteros sucesivos:
de itertools importar recuento S = ( 2 * x para x en recuento () si x ** 2 > 3 )(El uso posterior de la expresión generadora determinará cuándo dejar de generar valores).
x <- 0 : 100 S <- 2 * x [ x ^ 2 > 3 ] ( para/lista ([ x 100 ] #:cuando ( > ( * x x ) 3 )) ( * x 2 )) Un ejemplo con múltiples generadores:
( for*/list ([ x ( dentro del rango 1 21 )] [ y ( dentro del rango 1 21 )] [ z ( dentro del rango 1 21 )] #:cuando ( = ( + ( * x x ) ( * y y )) ( * z z ))) ( lista x y z )) mis @s = ( $_ * 2 si $_ ** 2 > 3 para 0 .. 99 );Usando el para-comprensión:
val s = for ( x <- 0 a 100 ; si x * x > 3 ) produce 2 * x La comprensión de listas se admite en Scheme mediante el uso de la biblioteca SRFI -42. [3]
( lista-ec ( : x 100 ) ( si ( > ( * x x ) 3 )) ( * x 2 )) Un ejemplo de comprensión de listas utilizando múltiples generadores:
( lista-ec ( : x 1 21 ) ( : y x 21 ) ( : z y 21 ) ( si ( = ( + ( * x x ) ( * y y )) ( * z z ))) ( lista x y z )) s := {2*x : x en {0..100} | x**2 > 3 };(( 1 a: 100 ) seleccione: [ : x | x cuadrado > 3 ]) recopile: [ : x | x * 2 ]S = [ 2 * X || X = lista::getMember_nd ( L ) , X * X > 3 ]