R- und Python-Schreibvergleich (euklidische Methode der gegenseitigen Teilung)

Einführung

"R oder Python, was soll ich tun?" Es gibt viele solche Artikel auf der Welt. Sie werden eine Kontroverse sehen, die nicht an dem Tag endet, an dem Sie nach "R Python" suchen. Im Allgemeinen wird "R häufig in der Datenanalyse-Spezialisierung und im akademischen Bereich verwendet." Es wird gesagt, dass "Python ein allgemeiner Zweck ist und häufig auf der Geschäftsseite verwendet wird".

Wenn ich jedoch diese Artikel lese Beim eigentlichen Codieren weiß ich nicht, was anders ist. Schließlich scheint es, dass Sie beide versuchen müssen, um den Unterschied zu erkennen ... Vor diesem Hintergrund habe ich beschlossen, ein einfaches Programm in beiden Sprachen zu schreiben.

Übrigens ist der Autor seit 1 Jahr in R und spielt normalerweise mit data.frame mit Tidyverse. Ich schreibe selten eine Steuerungssyntax wie diese. Python hat gerade die Erstellung der Umgebung abgeschlossen, daher dient dieser Artikel auch zum Üben. Wenn es einen Fehler oder einen Kommentar gibt, dass es einen besseren Code gibt, zögern Sie bitte nicht.

Euklidische Methode der gegenseitigen Teilung

Ich werde die euklidische Methode der gegenseitigen Teilung erläutern, die dieses Mal implementiert werden soll. (Ich vermisse High School Mathematik)

Die euklidische gegenseitige Teilung ist ein Algorithmus, der das ** maximale Versprechen ** zweier natürlicher Zahlen findet. Dafür verwenden wir die folgenden Eigenschaften

$ A und b sind natürliche Zahlen $ $ Gleichung: Für a = bq + r gilt gcd (a, b) = gcd (b, r) $

Diese Eigenschaft nutzen "Teilen von $ a $ durch $ b $, um den Rest $ r_1 $ zu berechnen" → "Teilen von $ b $ durch $ r_1 $, um den Rest $ r_2 $ zu berechnen" →… → "Teilen durch Teilen von $ r_ {n-1} $ durch $ r_n " →gcd(r_{n-1}, r_n) = gcd(r_{n-2}, n_{n-1})= ...=gcd(b, r_1) = gcd(a, b) = r_n$ Finden Sie das maximale Versprechen in Form von.

Implementieren Sie die Funktion in R.

• Funktionsdefinition

#Euklidische Methode der gegenseitigen Teilung
gcd <- function(a, b){
  if (!(a %% 1 == 0 & b %% 1 == 0 & a > 0 & b > 0)) {
    cat('Die Eingabe ist keine natürliche Zahl. Beginnen Sie also von vorne')
    } else if (a < b) {
      w <- a
      a <- b
      b <- w
      
      while (b != 0) {
        r <- a %% b
        a <- b
        b <- r
        }
      return(a)      
      } else {
        while (b != 0) {
          r <- a %% b
          a <- b
          b <- r
          }
        return(a)
      }
  }

• Ausführungsergebnis

> gcd(50856, 96007)
[1] 163

In Python implementiert

• Funktionsdefinition

#Euklidische Methode der gegenseitigen Teilung
def gcd(a, b):
  if not (a % 1 == 0 and b % 1 == 0 and a > 0 and b > 0):
    print('Die Eingabe ist keine natürliche Zahl. Beginnen Sie also von vorne')
  elif a < b:
    w = a
    a = b
    b = w
    
    while not b == 0:
      r = a % b
      a = b
      b = r
    else:
      return(a)
  else:
    while not b == 0:
      r = a % b
      a = b
      b = r
    else:
      return(a)

• Ausführungsergebnis

>>> gcd(50856, 96007)
163

Vergleich beider Sprachen

Werfen wir einen Blick auf die Codierungseigenschaften von beiden. (Beachten Sie, dass dies eine subjektive Beurteilung ist, die auf den Attributen des Autors basiert!)

1. Ein kurzer Blick

• Python ist wunderschön mit allen Einrückungen (Konami)
• R verwendet häufig Klammern → Es ist leicht zu verlieren, welche Klammern welchen entsprechen

Es ist fast das erste Mal, dass ich Python schreibe. Ich war besorgt: "Dies ist nicht geschlossen, aber es funktioniert richtig ...?" Aber es funktioniert perfekt. Ist es der Punkt, an dem die Bequemlichkeit dieses Bereichs unterstützt wird?

R gibt den Beginn und das Ende des Prozesses an, indem es in Klammern eingeschlossen wird und Python die Einrückungen ausrichtet. Die Verwendung von Einrückungen ist möglicherweise besser in Bezug auf "Verarbeitung + für den Benutzer leichter zu sehen". (Ich habe ein Gerücht gehört, dass die entsprechenden Klammern mit der neuen Funktion von Rstudio eingefärbt werden, also erwarte ich es)

2. Steuerungssyntax

Das ist ungefähr das gleiche. Zwangsweise ist der Unterschied zwischen else if und el if.

3. Betreiber usw.

In R erhalten Operatoren konsistent Symbole, während In Python werden Alphabete für die Teile verwendet, die sich auf die bedingte Verzweigung beziehen.

Es wird zwar angenommen, dass R logische Operatoren häufig bei der Filterverarbeitung usw. verwendet werden. Soll Python ausschließlich für die bedingte Verzweigung verwendet werden? (Wenn nicht ~ ist natürlich leicht zu lesen, aber filter (a == 1 und b <= 3 und ~) scheint lang und schwer zu lesen zu sein)

abschließend

Das Obige ist ein grober Vergleich, aber ich denke, dass die Vor- und Nachteile beider Sprachen offensichtlich geworden sind. Persönlich war ich überrascht, wie einfach es ist, Python-Steuerungssyntax zu schreiben.

Dieses Mal habe ich die Basis der Sprache verglichen, die als Steuerungssyntax bezeichnet wird (= der Teil, in dem die Idee stark ausgedrückt wird). Wenn ich es mir leisten kann, möchte ich die Datenrahmenverarbeitung usw. vergleichen.

Nachtrag

Überprüfung des Kontrollflusses

Ich hatte das Gefühl, dass der Code viel Verschwendung enthält, also habe ich ihn neu geschrieben, während ich mich auf verschiedene Dinge bezog.

R

• Es scheint, dass der Zuweisungsteil der Variablen mit ; in eine Zeile umgewandelt werden kann (was Sie tun, ist dasselbe)
• Sie können nicht wie Python a, b = b, a schreiben, Sie müssen Zwischenvariablen verwenden.

gcd <- function(a, b){
  if (!(a %% 1 == 0 & b %% 1 == 0 & a > 0 & b > 0)) {
    cat('Die Eingabe ist keine natürliche Zahl. Beginnen Sie also von vorne')
  } else {
    if(a < b){
      tmp <- a; a <- b; b <- tmp
    }
    while(b != 0){
      r <- a %% b; a <- b; b <- r 
    }
    return(a)
  }
}

Python

• Die Notation "a, b = b, a" ist sehr praktisch. Für die Swap-Verarbeitung sind keine Zwischenvariablen erforderlich.

def gcd(a, b):
  if not (a % 1 == 0 and b % 1 == 0 and a > 0 and b > 0):
    print('Die Eingabe ist keine natürliche Zahl. Beginnen Sie also von vorne')
  else:
    if a < b:
      a, b = b, a
    while b != 0:
      a, b = b, a % b
    else:
      return b

Implementierung mit rekursiven Funktionen

In den Kommentaren wurde mir über die rekursive Funktion berichtet, also habe ich sie implementiert. Wenn Sie bis b == 0 wiederholen, verstößt das Argument als Bedingung gegen die Bedingung, dass es sich um eine natürliche Zahl handelt. Sie müssen sie daher so umschreiben, dass sie sich bis zu einem Zeitpunkt zuvor wiederholt ( a% b == 0). Gibt es.

• Python

def gcd(a,b):
  if not (a % 1 == 0 and b % 1 == 0 and a > 0 and b > 0):
    print('Die Eingabe ist keine natürliche Zahl. Beginnen Sie also von vorne')
  else:
    if a < b:
      a, b = b, a
    if not a % b == 0:
      return gcd(b, a % b)
    else:
      return b

• R

Es gibt auch eine Funktion namens "Recall" zum Aufrufen rekursiver Funktionen

gcd <- function(a, b){
  if (!(a %% 1 == 0 & b %% 1 == 0 & a > 0 & b > 0)) {
    cat('Die Eingabe ist keine natürliche Zahl. Beginnen Sie also von vorne')
  } else {
      if(a < b){
        tmp <- a; a <- b; b <- tmp
      }
      if(a %% b != 0){
        return(Recall(b, a %% b) #Oder gcd(b, a %% b)
      } else{
        return(b)
      }
  }
}