Comparaison d'écriture R et Python (méthode de division mutuelle euclidienne)

introduction

"R ou Python, lequel faire?" Il existe de nombreux articles comme celui-ci dans le monde. Vous verrez une controverse qui ne se termine pas le jour où vous recherchez «R Python». En général, «R est souvent utilisé dans la spécialisation en analyse de données et dans le milieu universitaire». On dit que "Python est un usage général et est fréquemment utilisé du côté des entreprises".

Cependant, quand je lis ces articles Lors du codage, je ne sais pas ce qui est différent. Après tout, il semble que vous deviez essayer les deux pour connaître la différence ... Dans cet esprit, j'ai décidé d'écrire un programme simple dans les deux langues.

À propos, l'auteur est dans R depuis 1 an et joue généralement avec data.frame avec Tidyverse. J'écris rarement une syntaxe de contrôle comme celle-ci. Python vient de terminer la création de l'environnement, cet article est donc également destiné à la pratique. Si vous avez des erreurs ou des commentaires indiquant qu'il existe un meilleur code, n'hésitez pas à nous contacter.

Méthode de division mutuelle euclidienne

J'expliquerai la méthode euclidienne de division mutuelle à mettre en œuvre cette fois. (Les mathématiques du lycée me manquent)

La division mutuelle euclidienne est un algorithme qui trouve la ** promesse maximale ** de deux nombres naturels. Pour cela, nous utilisons les propriétés suivantes

$ A et b sont des nombres naturels $ $ Équation: Pour a = bq + r, gcd (a, b) = gcd (b, r) contient $

Profiter de cette propriété "Diviser $ a $ par $ b $ pour calculer le reste $ r_1 $" → "Diviser $ b $ par $ r_1 $ pour calculer le reste $ r_2 $" →… → "Divisé en divisant $ r_ {n-1} $ par $ r_n " →gcd(r_{n-1}, r_n) = gcd(r_{n-2}, n_{n-1})= ...=gcd(b, r_1) = gcd(a, b) = r_n$ Trouvez l'engagement maximal sous la forme de.

Implémenter la fonction dans R

• Définition de la fonction

#Méthode de division mutuelle euclidienne
gcd <- function(a, b){
  if (!(a %% 1 == 0 & b %% 1 == 0 & a > 0 & b > 0)) {
    cat('L'entrée n'est pas un nombre naturel, alors recommencez')
    } 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)
      }
  }

• Résultat d'exécution

> gcd(50856, 96007)
[1] 163

Implémenté en Python

• Définition de la fonction

#Méthode de division mutuelle euclidienne
def gcd(a, b):
  if not (a % 1 == 0 and b % 1 == 0 and a > 0 and b > 0):
    print('L'entrée n'est pas un nombre naturel, alors recommencez')
  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)

• Résultat d'exécution

>>> gcd(50856, 96007)
163

Comparaison des deux langues

Jetons un coup d'œil aux caractéristiques de codage des deux. (Notez qu'il s'agit d'un jugement subjectif basé sur les attributs de l'auteur!)

1. Un aperçu

• Python est beau avec tous les retraits (Konami)
• R utilise beaucoup les parenthèses → Il est souvent difficile de savoir quelle parenthèse correspond à quelle parenthèse

C'est presque la première fois que j'écris Python, J'étais inquiet, "Ce n'est pas fermé, mais ça marche correctement ...?" Mais cela fonctionne parfaitement. Est-ce le point où la commodité de ce domaine est prise en charge?

R indique le début et la fin du processus en le mettant entre parenthèses et Python alignant les retraits. L'utilisation de retraits peut être meilleure en termes de "traitement + plus facile à voir pour l'utilisateur". (J'ai entendu une rumeur selon laquelle les parenthèses correspondantes seraient colorées avec la nouvelle fonction de Rstudio, donc je m'y attend)

2. Syntaxe de contrôle

C'est à peu près la même chose. De force, la différence entre else if et el if.

3. Opérateurs, etc.

Dans R, les opérateurs reçoivent systématiquement des symboles, tandis que En Python, les alphabets sont utilisés pour les parties liées au branchement conditionnel.

Alors que l'on imagine que les opérateurs logiques R sont souvent utilisés dans le traitement des filtres, etc. Python est-il censé être utilisé exclusivement pour le branchement conditionnel? (ʻSi non ~ ʻest naturellement facile à lire, maisfilter (a == 1 et b <= 3 et ~)semble être long et difficile à lire)

en conclusion

Ce qui précède est une comparaison approximative, mais je pense que les avantages et les inconvénients des deux langues sont devenus évidents. Personnellement, j'ai été surpris de voir à quel point il est facile d'écrire la syntaxe de contrôle Python.

Cette fois, j'ai comparé la base du langage appelé syntaxe de contrôle (= la partie où l'idée est fortement exprimée). Si je peux me le permettre, j'aimerais comparer le traitement des trames de données et ainsi de suite.

Postscript

Examen du flux de contrôle

J'ai senti qu'il y avait beaucoup de gaspillage dans le code, alors je l'ai réécrit en faisant référence à diverses choses.

R

• Il semble que la partie affectation de la variable puisse être transformée en ligne en utilisant ; (ce que vous faites est la même chose)
• Vous ne pouvez pas écrire ʻa, b = b, a` comme Python, vous devez utiliser des variables intermédiaires.

gcd <- function(a, b){
  if (!(a %% 1 == 0 & b %% 1 == 0 & a > 0 & b > 0)) {
    cat('L'entrée n'est pas un nombre naturel, alors recommencez')
  } else {
    if(a < b){
      tmp <- a; a <- b; b <- tmp
    }
    while(b != 0){
      r <- a %% b; a <- b; b <- r 
    }
    return(a)
  }
}

Python

• La notation «a, b = b, a» est très pratique. Aucune variable intermédiaire n'est requise pour le traitement du swap.

def gcd(a, b):
  if not (a % 1 == 0 and b % 1 == 0 and a > 0 and b > 0):
    print('L'entrée n'est pas un nombre naturel, alors recommencez')
  else:
    if a < b:
      a, b = b, a
    while b != 0:
      a, b = b, a % b
    else:
      return b

Implémentation à l'aide de fonctions récursives

On m'a parlé de la fonction récursive dans les commentaires, alors je l'ai implémentée. En guise de mise en garde, si vous répétez jusqu'à b == 0, l'argument viole la condition qu'il s'agit d'un nombre naturel, vous devez donc le réécrire pour qu'il se répète jusqu'à une fois avant (ʻa% b == 0`). y a-t-il.

• Python

def gcd(a,b):
  if not (a % 1 == 0 and b % 1 == 0 and a > 0 and b > 0):
    print('L'entrée n'est pas un nombre naturel, alors recommencez')
  else:
    if a < b:
      a, b = b, a
    if not a % b == 0:
      return gcd(b, a % b)
    else:
      return b

• R

Il existe également une fonction appelée Recall pour appeler des fonctions récursives

gcd <- function(a, b){
  if (!(a %% 1 == 0 & b %% 1 == 0 & a > 0 & b > 0)) {
    cat('L'entrée n'est pas un nombre naturel, alors recommencez')
  } else {
      if(a < b){
        tmp <- a; a <- b; b <- tmp
      }
      if(a %% b != 0){
        return(Recall(b, a %% b) #Ou pgcd(b, a %% b)
      } else{
        return(b)
      }
  }
}