Ein Listenverständnis ist eine syntaktische Konstruktion, die auf einigen Programmiersprachen verfügbar ist, für eine auf vorhandenen Listen gestützte Liste zu schaffen. Es folgt der Form der mathematischen Notation des Satz-Baumeisters (Satz-Verständnis) im Unterschied zum Gebrauch der Karte und Filterfunktionen.

Übersicht

Denken Sie das folgende Beispiel in der Notation des Satz-Baumeisters.

:

Das kann gelesen werden, "ist der Satz aller Zahlen "2mal", wo ein Artikel im Satz von natürlichen Zahlen ist , für den quadratisch gemacht größer ist als."

In dieser kommentierten Version des Beispiels:

:

• ist die variablen Darstellen-Mitglieder eines Eingangssatzes.

• vertritt den Eingangssatz, der in diesem Beispiel der Satz von natürlichen Zahlen ist

• ist eine Prädikat-Funktion, die als ein Filter auf Mitgliedern des Eingangssatzes handelt.

• ist ein Produktionsfunktionsproduzieren Mitglieder des neuen Satzes von Mitgliedern des Eingangssatzes, die die Prädikat-Funktion befriedigen.

• Klammern enthalten den Ausdruck

• die vertikale Bar und das Komma sind Separatoren.

Ein Listenverständnis hat dieselben syntaktischen Bestandteile, um Generation einer Liste in der Ordnung von einer Eingangsliste oder iterator zu vertreten:

• Ein variables Darstellen Mitglieder einer Eingangsliste.
• Eine Eingangsliste (oder iterator).
• Ein fakultativer Prädikat-Ausdruck.
• Und ein Produktionsausdruck-Produzieren, das Mitglieder der Produktion von Mitgliedern des Eingangs iterable verzeichnen, die das Prädikat befriedigen.

Die Ordnung der Generation von Mitgliedern der Produktionsliste basiert auf der Ordnung von Sachen im Eingang.

In der Listenverständnis-Syntax von Haskell würde diese Konstruktion des Satz-Baumeisters ähnlich als geschrieben:

s = [2*x | x

</Quelle>

Hier vertritt die Liste, vertritt das Prädikat, und vertritt den Produktionsausdruck.

Listenverständnisse geben läuft auf eine definierte Ordnung (verschieden von den Mitgliedern von Sätzen) hinaus; und Listenverständnisse können die Mitglieder einer Liste in der Ordnung erzeugen, aber nicht die Gesamtheit der Liste erzeugen, die so, zum Beispiel, der vorherigen Definition von Haskell der Mitglieder einer unendlichen Liste erlaubt.

Geschichte

Die SETL Programmiersprache (später die 1960er Jahre) hatte eine Satz-Bildungskonstruktion, und das Computeralgebra-System-AXIOM (1973) hat eine ähnliche Konstruktion, die Ströme, bearbeitet

aber der erste Gebrauch des Begriffes "Verständnis" für solche Konstruktionen war in Rod Burstall und der Beschreibung von John Darlington ihrer funktionellen Programmiersprache NPL von 1977.

Plausch-Block-Zusammenhang-Nachrichten, die Listenverständnisse einsetzen, sind auf dieser Sprache seitdem mindestens Plausch 80 gewesen.

Burstalls Arbeit und Darlingtons mit NPL hat viele funktionelle Programmiersprachen während der 1980er Jahre, aber nicht aller eingeschlossenen Listenverständnisse beeinflusst. Eine Ausnahme war die einflussreiche reine faule funktionelle Programmiersprache Miranda, die 1985 befreit wurde. Die nachher entwickelte funktionelle faule reine Standardsprache, Haskell, schließt viele Eigenschaften von Miranda einschließlich Listenverständnisse ein. Die Pythonschlange-Programmiersprache war schwer unter Einfluss der reinen faulen Schule der funktionellen Programmierung und hat Listenverständnisse angenommen. Reine funktionelle Programmierung bleibt eine Nische, während Pythonschlange breitere Adoption erreicht hat, die Listenverständnisse in ein breiteres Publikum eingeführt hat.

Verständnisse wurden als eine Anfragennotation für Datenbanken vorgeschlagen und wurden auf der Datenbankanfragensprache von Kleisli durchgeführt.

Beispiele auf verschiedenen Programmiersprachen

Der folgende stellt einige Beispiele der spezifischen auf Programmiersprachen verwendeten Syntax zur Verfügung.

Obwohl das ursprüngliche Beispiel eine unendliche Liste anzeigt, können wenige Sprachen ausdrücken, dass, so in einigen jener Fälle zeigen wir, wie man eine Teilmenge aber nicht eine Teilmenge dessen nimmt.

B-Einleitung

L @= [Y: X in 1.. 100, [Y], (ist X*X> 3, Y 2*X),]

</Quelle>

Eine Liste der Form wird als ein Listenverständnis in Anrufen und Einschränkungen interpretiert. Ein Listenverständnis wird in eine Foreach-Konstruktion mit einem Akkumulator übersetzt.

Clojure

Clojure erzeugt unendliche faule Folgen (ähnlich den faulen Listen von Haskell oder den Generatoren der Pythonschlange). Gebrauch nimmt, um zu kommen, der erste N ergibt sich aus der unendlichen Folge.

(nehmen Sie 20 (für [x (Reihe): wenn (> (* x x) 3)] (* 2 x)))

;;  (4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42)

</Quelle>

CoffeeScript

CoffeeScript bringt hübsche Listenverständnisse zu JavaScript.

(x * 2 für x in [0.. 20] wenn x*x> 3)

</pre>

Allgemeines Lispeln

Listenverständnisse können mit dem Schlüsselwort des Makros ausgedrückt werden. Conditionals werden mit wie folgt ausgedrückt:

(Schleife für x von 0 bis 100, wenn sich (> (* x x) 3) (* 2 x)) versammeln

</Quelle>

Eine unendliche faule Folge kann in einer Vielfalt von Wegen, wie das CLOS-Gegenstand-System oder ein Makro-Ertrag geschaffen werden.

Erlang

Dasselbe Beispiel in Erlang:

S = [2*X || X

F#

F# hat Generator-Verständnis die Listenverständnis-Syntax-Elemente.

Generator-Verständnisse können verwendet werden, um Listen, Folgen (faule Listen) und Reihe (nicht besprochen hier) zu erzeugen.

Generatoren sind von der Form für Listen und für Folgen.

Zum Beispiel:

> seq {für x in 0.. 100 tun

wenn x*x> 3 dann Ertrag 2*x};;

val es: seq

Falke

Der "Setzer" allgemeine Methode-Familie stellt breite Unterstützung für das Verständnis zur Verfügung. Zum Beispiel kann die "mfcomp" Methode auf eine Reihe angewandt werden:

s = [].mfcomp ({ich => wenn i*i> 3: Kehren Sie 2*i zurück; geben Sie oob (1)}, [1:101] zurück)

Falke kann auch funktionelle Generatoren verwenden, um Eingangslisten zur Verfügung zu stellen. Zum Beispiel verwendet der folgende Code eine Verlängerung, eine Reihe von Paaren zu schaffen.

Information = Verlängerung (Funktion (max, c)

i = 0

während ich

Methode "Setzer" wurde in der Version 0.9.6, und den Methoden "mcomp" und "mfcomp" in der Version 0.9.6.2 eingeführt.

Haskell

Beziehen Sie sich bitte auf das Hauptbeispiel in der Übersicht.

s = [2*x | x </Quelle>

Hier erzeugt die Liste natürliche Zahlen eins nach dem anderen, die zur Variable gebunden werden, das Prädikat vertreten, das entweder akzeptiert oder einen Wert einer gegebenen Variable zurückweist, und den Ergebnis-Ausdruck vertritt. Es könnte mehrere Generatoren geben und Prädikate in einer Liste compehension Ausdruck in Haskell prüfen, tatsächlich verschachtelte Schleifen z.B definierend:

s = [2*x*y | x

- für jeden y von 1 durch 2 upto x:

- wenn y^2

Der obengenannte Ausdruck wird unproduktiv ("durchstochen") an einem Punkt, wenn neu, setzen xs fort, nur erzeugt zu werden, um später zurückgewiesen zu werden. Das ist so, weil jeder Test nur einen Wert zurückweisen kann, der er, nicht irgendwelche zukünftigen gegeben wird (es gibt keinen Kürzungsmechanismus hier in Einleitungsbegriffen - ein Generator könnte im Allgemeinen seine Werte nicht eingeordnet, wie z.B der obengenannte Ausdruck selbst erzeugen). Das kann delt mit dem Verwenden von begrenzten Listengeneratoren immer oder durch das Umgeben eines Generators innen a oder Anruf, das Begrenzen des Betrags von erzeugten Werten sein.

JavaFX

Das Verwenden für die Behauptung und einen boolean Ausdruck:

var s = für (ich in [1.. 100] [n | n*n> 3]) {2*i }\

</Quelle>

JavaScript 1.8

Number.prototype. __ iterator __ =function {für (var i=0; ich

</Quelle>

Oder, ohne prototyping der Zahl-Gegenstand,

var erstrecken sich = Funktion (Anfang, Ende) {dafür (var i=start; ich

</Quelle>

OCaml

OCaml Eingeschlossene Batterien haben gleichförmige Verständnis-Syntax für Listen, Reihe, Enumerationen (wie Ströme), faule Listen (wie Listen, aber bewertet auf Verlangen), Sätze, hashtables usw.

Verständnis ist von der Form

Zum Beispiel,

1. [? 2 * x x

-: int Enum.t =

</Quelle>

oder, um eine Liste, zu schätzen

1. [? Liste: 2 * x x

-: int Liste = [4; 6; 8; 10]

</Quelle>

oder, um einen Satz, zu schätzen

1. [? PSet: 2 * x x

-: int PSet.t =

</Quelle>

usw.

Oktave

GNU-Oktave kann Liste (Vektor) Verständnisse in der Form tun.

Zum Beispiel,

octave:1&gt; x=0:100; s = (2*x) (x. ** 2

Rein

Dasselbe Beispiel im Reinen:

s = [2*n | n=1.. 100; n*n> 3];

Pythonschlange

Die Pythonschlange-Programmiersprache hat eine entsprechende Syntax, um Listenverständnisse auszudrücken.

Das nah-gleichwertige in der Pythonschlange zum Beispiel ist oben wie folgt:

S = [2 * x für x in der Reihe (101) wenn x ** 2> 3]

</Quelle>

Listenverständnisse wurden in der Pythonschlange-Version 2.0 eingeführt.

Ein Generator-Ausdruck kann in Pythonschlange-Versionen 2.4 verwendet werden und oben funktionelle Gleichwertigkeit mit S das Verwenden eines Generators zu erreichen, um (begrenzt oder unendlich) Folge zu wiederholen:

von itertools Import zählen auf

S = (2 * x für x in der Zählung wenn x ** 2> 3)

</Quelle>

Schläger

Schläger stellt funktionelle Versionen von für die Schleifen zur Verfügung, die im Wesentlichen Listenverständnis-Syntax sind:

(für/verzeichnen ([x (in der Reihe 100)] #:when (> (* x x) 3))

(* 2 x))

</Quelle>

Die Befehlsform kann auch verwendet, mit der Generator-Bibliothek des Schlägers verbunden werden, um einen unendlichen Generator zu erzeugen:

(verlangen Sie Schläger/Generator)

(Generator

(für ([x (in - naturals)] #:when (> (* x x) 3))

(Ertrag (* 2 x))))

</Quelle>

Rubin

Auf der Rubinroten Sprache können Sie vielfache Weisen verwenden, diese Funktion zum Beispiel vorzutäuschen:

(1.. 100).selectx | x ** 2> 3\.collectx | 2 * x }\

</Quelle>

Oder Sie können Ihre eigene Methode definieren:

Klassenreihe

def fassen (&block) um

kehren Sie selbst wenn block.nil zurück?

self.collect (&block).compact

Ende

Ende

(1.. 100).to_a.comprehend x | 2 * x wenn x ** 2> 3 }\

</Quelle>

Scala

Das Verwenden des für das Verständnis:

val s = für (x

</Quelle>

Schema

Obwohl es keine Standardlistenverständnis-Syntax in R5RS gibt, stellen viele Durchführungen eine Erweiterung dafür zur Verfügung. Zum Beispiel, im Hühnerschema:

(Verlangen-Erweiterungsliste-)

(Liste - (* 2 x) (x erstrecken sich 0 101) (> (* x x) 3))

</Quelle>

Es gibt auch eine tragbare Bibliothek SRFI/42 "Eifrige Verständnisse", der insbesondere Listenverständnisse einschließt:

(verlangen Sie srfi/42); Beispiel-Import ins Schläger-Schema

(Listen-Ec (: x 101) (wenn (> (* x x) 3)) (* 2 x))

</Quelle>

Plausch

((1 zu: 100) ausgesucht: [:x |x*x> 3]) versammeln Sie sich: [:x |2*x]

</Quelle>

Seheinleitung

PowerShell

0.. 100 | Wo {$ _ * $ _-gt 3} | ForEach {$ _ * 2 }\

</Quelle>

Ähnliche Konstruktionen

Verständnis von Monad

In Haskell ist ein monad Verständnis eine Generalisation des Listenverständnisses zu anderem monads in der funktionellen Programmierung.

Satz-Verständnis

Die Version 3.x und 2.7 der Pythonschlange-Sprache führt Syntax für Satz-Verständnisse ein. Ähnlich in der Form, um Verständnisse zu verzeichnen, gehen Sie unter Verständnisse erzeugen Pythonschlange-Sätze statt Listen.

>>> s = {v für v in 'ABCDABCD' wenn v nicht in 'der CB' }\

>>> Druck (s)

{, 'D' }\

>>> Typ (s)

>>>

</Quelle>

Schläger ist untergegangen Verständnisse erzeugen Schläger-Sätze statt Listen.

(für/setzen ([v "ABCDABCD"] #:unless (Mitglied v (Schnur-> verzeichnen "CB")))

v))

</Quelle>

Wörterbuch-Verständnis

Die Version 3.x und 2.7 der Pythonschlange-Sprache hat eine neue Syntax für Wörterbuch-Verständnisse eingeführt, die in der Form ähnlich sind, um Verständnisse zu verzeichnen, aber die Pythonschlange dicts statt Listen erzeugen.

>>> s = {Schlüssel: Val für den Schlüssel, val darin zählen ('ABCD') wenn val nicht in 'der CB' }\auf

>>> s

{0: 3: 'D' }\

>>></Quelle>

Schläger-Hash-Tabelle-Verständnisse erzeugen Schläger-Hash-Tabellen (eine Durchführung des Schläger-Wörterbuch-Typs).

(für/Kuddelmuddel ([(val Schlüssel) (in - hat "ABCD" mit einem Inhaltsverzeichnis versehen),]

#:unless (Mitglied val (Schnur-> verzeichnen "CB")))

(Wertschlüssel val))

</Quelle>

Paralleles Listenverständnis

Der Glasgower Bearbeiter von Haskell hat eine Erweiterung genannt paralleles Listenverständnis (auch bekannt als Schwirren-Verständnis), der vielfache unabhängige Zweige von Qualifikators innerhalb der Listenverständnis-Syntax erlaubt.

Wohingegen durch Kommas getrennte Qualifikators abhängig sind, hat ("genistet"), durch Pfeifen getrennte Qualifikator-Zweige werden in der Parallele bewertet (das bezieht sich auf keine Form des Mehrgewindekeit: Es bedeutet bloß, dass die Zweige schwirren lassen werden).

- regelmäßiges Listenverständnis

a = [(x, y) | x

Die Verständnis-Standardbibliothek des Schlägers enthält parallele und verschachtelte Versionen seiner Verständnisse, die durch "für" gegen "für *" im Namen bemerkenswert sind. Zum Beispiel schaffen die Vektor-Verständnisse "für/leiten" und "for*/vector" Vektoren durch die Parallele gegen die verschachtelte Wiederholung über Folgen. Der folgende ist Schläger-Code für die Listenverständnis-Beispiele von Haskell.

> (for*/list ([x (in der Reihe 1 6)] [y (in der Reihe 3 6)]) (verzeichnen x y))

'((1 3) (1 4) (1 5) (2 3) (2 4) (2 5) (3 3) (3 4) (3 5) (4 3) (4 4) (4 5) (5 3) (5 4) (5 5))

> (für/verzeichnen ([x (in der Reihe 1 6)] [y (in der Reihe 3 6)]) (verzeichnen x y))

'((1 3) (2 4) (3 5))

</Quelle>

In der Pythonschlange konnten wir wie folgt tun:

1. regelmäßiges Listenverständnis

>>> = [(x, y) für x in der Reihe (1, 6) für y in der Reihe (3, 6)]

[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4)...

1. passen Sie Listenverständnis an/schwirren lassen Sie

>>> b = [x für x im Schwirren (Reihe (1, 6), Reihe (3, 6))]

[(1, 3), (2, 4), (3, 5)]

</Quelle>

XQuery und XPath

Wie der ursprüngliche NPL-Gebrauch sind das im Wesentlichen Datenbankzugriffssprachen.

Das macht das Verständnis-Konzept wichtiger, weil es rechenbetont unausführbar ist, die komplette Liste wiederzubekommen und darauf zu funktionieren (die anfängliche 'komplette Liste' kann eine komplette XML Datenbank sein).

In XPath, dem Ausdruck:

/library/book//Paragraf [@style ='first-in-chapter']

wird als eine Reihe von "Schritten" begrifflich bewertet, wo jeder Schritt eine Liste erzeugt und der nächste Schritt eine Filterfunktion auf jedes Element in der Produktion des vorherigen Schritts anwendet.

In XQuery ist voller XPath verfügbar, aber FLWOR Behauptungen werden auch verwendet, der eine stärkere Verständnis-Konstruktion ist.

für den $b in//bestellen vor

wo $b [@pages

</shortBook>

Hier wird der XPath//Buch bewertet, um eine Folge (auch bekannt als Liste) zu schaffen; wo Klausel ein funktioneller "Filter", die Ordnung durch Sorten ist, sind das Ergebnis und der XML Schnipsel wirklich eine anonyme Funktion, die XML für jedes Element in der Folge mit der auf anderen funktionellen Sprachen gefundenen 'Karte'-Annäherung/umgestaltet baut.

Also, auf einer anderen funktionellen Sprache der obengenannte kann FLWOR Behauptung wie das durchgeführt werden:

Karte (

newXML (shortBook, newXML (Titel, $ 1.title), newXML (firstPara, 1 $...))

Filter (

Leutnant ($ 1.pages, 400),

xpath (//Buch)

)

)

LINQ in C#

C# 3.0 hat eine Gruppe von zusammenhängenden Eigenschaften genannt LINQ, der eine Reihe von Anfragenmaschinenbedienern definiert, um listenähnliche Strukturen (Gegenstand-Enumerationen, SQL datasets, …) zu manipulieren. Oben auf diesen Maschinenbedienern bietet es eine Verständnis-Syntax an, die an SQL erinnernd ist:

var s = von x in Enumerable. Reihe (0, 100) wo x*x> 3 ausgesuchte x*2;

</Quelle>

C ++

Listenverständnisse können mit dem C ++ STL Algorithmen remove_copy_if gebaut werden, um Elemente in einer Liste und for_each auszuwählen, um sie umzugestalten.

einschließen einschließen

interne Nummer linspace {statische interne Nummer i=1; kehren Sie i ++ zurück; }\

bool sqrle3 (interne Nummer x) {geben x*x zurück

//N1 und N2 sind beide leere Listen von 10 Elementen jeder

generate_n (N1.begin , 10, linspace);

//N1 enthält jetzt 1,2..., 10

for_each (N2.begin ,

remove_copy_if (N1.begin , N1.end , N2.begin , sqrle3),

into2);

//N2 enthält jetzt 4,6..., 20

}\</Quelle>

Es gibt eine Anstrengung in der Versorgung C ++ mit der Satz-Baumeister-Notation ähnlichen Listenverständnis-Konstruktionen/Syntax.

• In der Zunahme. Reihe http://www.boost.org/libs/range ist Bibliothek dort ein Begriff von Adaptern http://www.boost.org/libs/range/doc/html/range/reference/adaptors.html, die durch auf jede Reihe angewandt werden und Entstörung, Transformation usw. tun können. Mit dieser Bibliothek würde das ursprüngliche Beispiel von Haskell ähnlich sein (Zunahme verwendend. Lambda http://www.boost.org/libs/lambda für die anonyme Entstörung und das Umwandeln von Funktionen):

counting_range (1,10) | gefiltert (_1 * _ 1> 3) | umgestaltet (rösten

</Quelle>

Volles Beispiel ist hier: http://codepad.org/y4bpgLJu

• Diese Durchführung verwendet ein Makro und überlädt

Liste

Liste

für (interne Nummer i = 0; ich

</Quelle>

• Diese Durchführung stellt das Schneiden des Kopfs/Schwanzes mit Klassen und Maschinenbediener zur Verfügung, der und der Maschinenbediener überlädt, um Listen zu filtern (Funktionen verwendend). Gebrauch-Beispiel:

bool sogar (interne Nummer x) {geben x % 2 == 0 zurück; }\

bool x2 (interne Nummer &x) {x * = 2; kehren Sie wahr zurück; }\

Liste

interne Nummer x, y;

für (interne Nummer i = 0; ich

Siehe auch

• Die AUSGESUCHTE Behauptung zusammen mit seinem VON und WO Klauseln in SQL
• Programmiersprache
• Mathematische Notation
• Monads in der funktionellen Programmierung für monads und monadische Notation in allgemeinem
• Für andere Programmiersprache-Konstruktionen, die verwendet sind, um Folgen zu bearbeiten:
• Generator (Informatik)
• Karte (höherwertige Funktion)
• Für andere aus der mathematischen Notation kopierte Programmiersprache-Konstruktionen:
• Wächter, der (rechnet)
• Muster, das zusammenpasst
• Maschinenbediener, der (programmiert)

Zeichen und Verweisungen

• Listenverständnis im freien Online-Wörterbuch der Computerwissenschaft, Redakteurs Denis Howe.

Haskell

• Der Haskell 98 Bericht, Listenverständnisse des Kapitels 3.11.
• Das Ruhmvolle Glasgow Kompilationssystembenutzerhandbuch von Haskell, Parallele-Listenverständnisse des Kapitels 7.3.4.
• Die Umarmungen 98 Benutzerhandbuch, Kapitel 5.1.2 Parallele verzeichnet Verständnisse (a.k.a. Schwirren-Verständnisse).

OCaml

• OCaml Batterien eingeschlossener
• Spracherweiterungen haben in OCaml Batterien Eingeschlossenen eingeführt

Pythonschlange

• Pythonschlange-Bedienungshandbuch, Kapitel 5.2.4 Listenanzeigen.
• Pythonschlange-Erhöhungsvorschlag-PEP 202: Listenverständnisse.
• Pythonschlange-Bedienungshandbuch, Kapitel 5.2.5 Generator-Ausdrücke.
• Pythonschlange-Erhöhungsvorschlag-PEP 289: Generator-Ausdrücke.

Allgemeines Lispeln

• Durchführung eines Lispeln-Verständnisses, das durch Guy Lapalme Makro-

ist

Clojure

• Clojure API-Dokumentation - für Makro-

Axiom

• Axiom-Strom-Beispiele

Links

• SQL ähnliche Satz-Operationen mit Listenverständnis-einem Überseedampfern im Pythonschlange-Kochbuch
• Diskussion über Listenverständnisse im Schema und den verwandten Konstruktionen
• Listenverständnisse über Sprachen