In diesem Artikel werde ich die von Nim bereitgestellte Funktion höherer Ordnung vorstellen und mit Python vergleichen. Es enthält auch Tipps zum Schreiben von Nim.
*** Effizient, ausdrucksstark und elegant Nim ist eine statisch typisierte kompilierte Systemprogrammiersprache. Es kombiniert die erfolgreichen Konzepte ausgereifter Sprachen wie Python, Ada und Modula. *** *** (Zitat: https://nim-lang.org/ mit Google-Übersetzung) Kurz gesagt, es hat eine Syntax wie Python und ist eine Programmiersprache, die genauso schnell ist wie die Sprache C. Es ist eine Traumsprache für mich, die normalerweise Python schreibt, aber mit seiner Geschwindigkeit unzufrieden ist.
Eine Funktion höherer Ordnung ist eine Funktion ***, die eine *** Funktion als Argument verwendet. Es wurde früher in LISP- und ML-Sprachen verwendet, wurde jedoch aufgrund des jüngsten Aufkommens funktionaler Sprachen in vielen Programmiersprachen implementiert. Beispielsweise wurde es in Skriptsprachen wie Python und in jüngerer Zeit in JavaScript (seit ECMAScript 2015) implementiert. Es scheint, dass es in Rust and Go geschrieben werden kann, aber ich bin nicht damit vertraut, also werde ich es weglassen.
Einführung in die Funktionen höherer Ordnung, die in Nims sequtil-Modul implementiert sind, und deren Vorlagen.
map
map
proc map[T, S](s:openArray[T];op:proc(x:T):S{...}): seq[S] {...}
map verwendet ein Array s vom Typ openArray und eine Prozedur op als Argumente und gibt seq zurück, wobei op auf jedes Element von s angewendet wird. openArray ist ein Allzwecktyp, der ein Array angibt und Sequenzen, String und Array enthält.
Kartenbeispiel
import sequtils
let #Dies ist eine unveränderliche Variablendeklaration
s = [1,2,3,4] #Dies ist ein Array-Typ
op = proc (x: int): int = x * x #Anonyme Funktion, Funktion, die das Quadrat des Arguments zurückgibt
echo s.map(op) # => @[1, 4, 9, 16] ##Jedes Element von s ist quadratisch
echo s # => [1, 2, 3, 4] ##Das ursprüngliche Array ändert sich nicht
echo s.map(op) == map(s, op) # => true
##Nim-Tipps (Aufrufen einer Prozedur)
## p(x)Und x.p()Ist gleichwertig
apply
apply
proc apply[T](s:varopenArray[T];op:proc(x:T):T{...}) {...}
apply hat ein Array vom Typ openArray und eine Prozedur op als Argumente und wendet op auf jedes Element von s an. Ähnlich wie "map", aber "apply" hat keinen Rückgabewert und ändert "s" direkt. Eigentlich gibt es eine andere Anwendung, aber weggelassen.
Beispiel anwenden
import sugar #Experimentelles Modul
var #veränderbare Variablendeklaration
x = [true, false, false, true, true]
echo x #=> [true, false, false, true, true]
apply(x, b => not b) #Nimm nicht von jedem Element von x
echo x #=> [false, true, true, false, false]
##Nim-Tipps (Wie man anonyme Funktionen schreibt)
## b =>nicht b ist eine Abkürzung für anonyme Funktion. Die linke Seite ist das Argument und die rechte Seite ist der Rückgabewert
##Importzucker ist jedoch erforderlich
filter
filter
proc filter[T](s:openArray[T];pred:proc(x:T):bool{...}): seq[T] {...}
filter verwendet ein Array vom Typ openArray und eine Prozedur pred als Argumente und gibt seq zurück, das aus Elementen von s besteht, wobei pred`` true zurückgibt.
Filterbeispiel
import strutils
let
str = "happY holidAYs"
upperStr = str.filter(s => s.isUpperAscii()) #Großbuchstaben filtern
echo str #=> "happY holidAYs"
echo upperStr #=> @['Y', 'A', 'Y']
echo upperStr.join("") #=> "YAY" ##Kombinieren Sie Elemente eines Array vom Typ String(Gleich wie Python)
##Nim-Tipps (Benennung)
##Es wird empfohlen, Nim-Variablen und -Prozeduren in camelCase zu deklarieren.
keepIf
keepIf
proc keepIf[T](s:varseq[T];pred:proc(x:T):bool{...}) {...}
keepIf nimmts vom Typ seq und procedure pred als Argumente und belässt nur die Elemente, für die pred`` true in s zurückgibt. Beachten Sie jedoch, dass das Argument "seq" anstelle von "openArray" lautet.
Dies sind die Vorlagen "Map", "Apply", "Filter" und "KeepIf". Mit diesen können Sie einfach (nur ein wenig) Funktionen höherer Ordnung aufrufen. Da die Verwendung fast gleich ist, werde ich ein Beispiel für "mapIt" vorstellen.
mapIt Beispiel
let
v = [1,2,3,4,5]
w = v.mapIt(it*2) #es bedeutet jedes Element von v, was bedeutet, jedes Element zu verdoppeln
echo w # => @[2, 4, 6, 8, 10]
Punkt
mapIt (und so weiter) sind Arrays und ** Ausdrücke **
--it in der Vorlage ist jedes Element des ArgumentarraysPython implementiert auch Map, Filter, Reduce (entsprechend Foldl, Foldr), aber es gibt kein Äquivalent zum Anwenden oder KeepIf (in Pandas). Wenn Sie die Liste nach dem Multiplizieren der Liste "l" mit "map" verwenden möchten,
l = [1, 2, 3, 4] #Ich möchte jeden Wert verdoppeln
mapped_l = map(lambda x: x*2, l) # mapped_Ich bin keine Liste
assert type(mapped_l) is map # => true
mapped_l = list(mapped_l) #Zurück zur Liste
Muss sein. Der Rückgabetyp von "map" ist "map object", was sich vom Argument unterscheidet. Dies ist ein Generator. Wenn Sie ihn also als Originaltyp verwenden möchten, müssen Sie ihn explizit zurückgeben. Dies gilt auch für "Filter", und der Rückgabewert von "Filter" ist "Filterobjekt". Zum Beispiel
l = [-3, -2, -1, 0, 1, 2, 3]
p = filter(lambda x: x>0, l) #Lassen Sie nur positive Elemente
len(p) #Fehler, weil p ein Filterobjekt ist
len(list(p)) #Das ist okay Die Antwort ist 3
len([li for li in l if li > 0]) #Das ist auch okay. Ist das eine Python-ähnliche Schreibweise? ?? ??
Ich persönlich mag das nicht sehr. Im Fall von Nim ist der Rückgabetyp von "l.map (proc ...)" "seq", daher ist es einfach zu verwenden, da eine solche Verarbeitung nicht erforderlich ist (persönlicher Eindruck).
Ich habe die Funktionen höherer Ordnung von Nim zusammengefasst. Nim ist immer noch eine sich entwickelnde Sprache, aber ich hoffe, dass sie sich in Zukunft weiterentwickeln wird. Ich hoffe es hilft dir ein wenig: upside_down:
Recommended Posts