Traductions de code R vers Python : un aide-mémoire côte à côte

Q: Comment convertir du code R en Python ?

Traduisez-le ligne par ligne à l’aide d’une carte comme les tableaux ci-dessus — la plupart des constructions ont un jumeau direct, si bien que le travail est mécanique plutôt que créatif. Changez la syntaxe (<- → =, function → def, { } → indentation), changez le package (dplyr → pandas, ggplot2 → matplotlib), et surveillez les deux pièges qui ne se traduisent pas proprement : indexation à base 1 vs à base 0 et écart-type d’échantillon vs de population (ddof=1). Puis exécutez le Python et comparez sa sortie à celle du R pour confirmer que le portage est fidèle.

Q: Existe-t-il un convertisseur automatique de R vers Python ?

Il n’existe pas de convertisseur parfait en un clic — les langages diffèrent suffisamment pour qu’un traducteur mécanique manque les idiomes et les pièges d’indexation / de ddof ci-dessus. Les assistants IA s’en sortent bien quand vous leur donnez la source et la bibliothèque cible, mais vous devez toujours exécuter et vérifier le résultat. Sur Datanovia, vous pouvez coller un script R dans Prova, qui renvoie du Python exécutable et vous laisse exécuter les deux côte à côte pour vérifier qu’ils concordent.

Q: Quel est l’équivalent Python des fonctions R comme c(), paste0() ou mean() ?

c() devient une list (ou np.array() pour les calculs), paste0() devient le + sur les chaînes (ou "".join() pour un vecteur de chaînes), et mean() devient np.mean(). Les tableaux ci-dessus recensent les plus courants par tâche. Une différence structurelle à prévoir : beaucoup d’opérations Python sont des méthodes appelées sur l’objet (s.upper(), df.head()), tandis que les équivalents R sont des fonctions autonomes auxquelles vous passez l’objet (toupper(s), head(df)).

Q: R et Python peuvent-ils exécuter directement le code l’un de l’autre ?

Pas directement — ce sont des interpréteurs distincts, donc vous traduisez le code plutôt que de le coller tel quel. Si vous avez besoin de les faire interopérer dans un même projet, des bibliothèques passerelles existent : reticulate permet à R d’appeler Python, et rpy2 permet à Python d’appeler R. Même alors, les correspondances de structures de données de cet aide-mémoire (vecteur ↔ tableau, liste nommée ↔ dict, data.frame ↔ DataFrame) sont exactement ce que ces passerelles convertissent en coulisses.

Q: Pourquoi mes résultats R et Python diffèrent-ils légèrement ?

Généralement l’une de trois raisons. Écart-type / variance : R utilise la formule d’échantillon (n − 1) ; NumPy utilise par défaut la formule de population (n) — passez ddof=1 pour correspondre. Indexation : le x[1] de R est le x[0] de Python, si bien qu’un décalage d’un indice décale discrètement chaque position. Types de nombres : R affiche souvent les entiers comme des doubles (9.0), tandis que Python garde 9 en int jusqu’à ce qu’un flottant entre dans le calcul. Corrigez ces trois points et les langages concordent jusqu’à la dernière décimale.

Trouvez l’extrait R exact à côté de son équivalent Python, regroupé par tâche

Programming

Un aide-mémoire de correspondances pour ceux qui passent d’un langage à l’autre : le code R exact à côté de son équivalent Python, organisé par tâche — syntaxe générale et opérateurs, correspondance des objets/types, structures de données, chaînes de caractères, structures de contrôle, fonctions, opérations sur les data frames, lecture/écriture de fichiers et mathématiques/statistiques — pour répondre d’un coup d’œil à « comment fait-on ceci dans l’autre langage ».

Auteur·rice

Alboukadel Kassambara

Date de publication

14 juillet 2026

Modifié

14 juillet 2026

Comment utiliser cette page

Ceci est un aide-mémoire de correspondances, pas un tutoriel. Repérez la tâche qu’il vous faut — la colonne de gauche est le code R, la colonne de droite son équivalent Python — et recopiez. Les tableaux sont regroupés par tâche : syntaxe et opérateurs, types d’objets, structures de données, chaînes de caractères, structures de contrôle, fonctions, data frames, lecture et écriture de fichiers, et mathématiques et statistiques.

Si vous écrivez déjà du R et devez désormais produire du Python (ou l’inverse), l’essentiel de vos connaissances se transpose directement — il vous suffit du changement de vocabulaire. Cette page est cet index de correspondances. Pour le pourquoi de chaque correspondance, suivez les liens vers les guides plus approfondis : R vs Python syntax explique les concepts, dplyr vs pandas couvre la manipulation de données en profondeur, et ggplot2 vs matplotlib couvre les graphiques.

A wide ggplot2 bar chart of six standardized values (-1.04, -0.74, -0.22, -0.15, 0.37, 1.78) as azure bars diverging above and below a zero baseline, on a clean theme_minimal grid — the identical z-scores that R and Python produce from the same six numbers.

Deux choses à garder à l’esprit en lisant — elles causent la plupart des bugs de transition, et toutes deux font l’objet d’un traitement complet dans le guide de syntaxe : R indexe à partir de 1, Python à partir de 0 (le premier élément est x[1] en R, x[0] en Python), et R est vectorisé par défaut alors qu’une simple list Python ne l’est pas (tournez-vous vers un tableau NumPy pour obtenir l’arithmétique élément par élément façon R).

Syntaxe générale et opérateurs

Les briques de base du quotidien. Les quatre opérateurs arithmétiques de base (+ - * /) sont identiques ; les trois qui diffèrent sont la puissance, la division entière et le modulo.

Tâche	R	Python
Affecter une valeur	`x <- 10` (ou `x = 10`)	`x = 10`
Commentaire	`# note`	`# note`
Afficher	`print(x)`	`print(x)`
Puissance	`2^10`	`2 ** 10`
Division entière (partie entière)	`7 %/% 2`	`7 // 2`
Modulo (reste)	`7 %% 2`	`7 % 2`
Produit matriciel	`a %*% b`	`a @ b`
Égal / différent	`==` / `!=`	`==` / `!=`
Et / ou / non	`&&` `\|\|` `!` (scalaire) ; `&` `\|` (vecteur)	`and` `or` `not`
Inverser	`rev(x)`	`x[::-1]`
Vérifier le type d’une valeur	`class(x)`	`type(x)`
Séquence d’entiers 3…8	`3:8`	`range(3, 9)` (borne de fin exclue)
Quitter la session	`quit()`	`exit()`

Un piège silencieux

^ signifie puissance en R mais OU exclusif bit à bit en Python — 2^10 vaut 1024 en R et 8 en Python. Utilisez ** pour les puissances en Python. Et le range(3, 9) de Python s’arrête avant 9, conformément à sa règle à base 0, borne de fin exclue.

Correspondance des objets et des types

Les vecteurs atomiques et les listes de R correspondent aux scalaires, listes, tuples et dictionnaires de Python ; les structures plus lourdes correspondent aux objets NumPy et pandas.

Objet R	Objet Python
`character`	`str`
`integer`	`int`
`numeric` / `double`	`float`
`logical`	`bool`
`complex`	`complex`
Vecteur de longueur 1	scalaire
Vecteur (tous d’un même type)	`list`, ou `numpy.ndarray` pour les calculs
`list` (types mêlés)	`list` ou `tuple`
`list` nommée	`dict`
`matrix` / `array`	`numpy.ndarray`
`data.frame`	`pandas.DataFrame`
`factor`	`pandas.Categorical`
`NULL` / `TRUE` / `FALSE`	`None` / `True` / `False`
`NA`	`None` (objet) ou `float("nan")` (nombre)
`Inf` / `NaN`	`float("inf")` / `float("nan")`

La seule correspondance qui n’est pas biunivoque concerne les valeurs manquantes : l’unique NA de R fait le travail des deux idées de Python — None pour un objet manquant et NaN pour un nombre manquant au sein des tableaux et des data frames.

Structures de données

Créer et accéder à des collections. Souvenez-vous de la base d’indexation ([1] en R, [0] en Python) en lisant ce tableau.

Tâche	R	Python
Une collection	`c(1, 2, 3)`	`[1, 2, 3]` (ou `np.array([1, 2, 3])`)
Collection nommée	`list(n = 10, avg = 3.7)`	`{"n": 10, "avg": 3.7}`
Premier élément	`x[1]`	`x[0]`
Dernier élément	`x[length(x)]` / `tail(x, 1)`	`x[-1]`
Découper les deux premiers	`x[1:2]`	`x[0:2]`
Longueur	`length(x)`	`len(x)`
Ajouter un élément	`x <- c(x, 4)`	`x.append(4)` / `x + [4]`
Séquence avec pas	`seq(1, 10, by = 2)`	`range(1, 11, 2)`
Calcul élément par élément	`v + 10`	`np.array(v) + 10`
Une matrice	`matrix(1:6, nrow = 2)`	`np.arange(1, 7).reshape(2, 3, order="F")`
Empiler des lignes	`rbind(a, b)`	`np.vstack([a, b])`
Apparier deux vecteurs	`Map(c, a, b)`	`list(zip(a, b))`
Noms d’une liste nommée	`names(x)`	`x.keys()`

Piège : les matrices se remplissent dans un ordre différent

R remplit une matrice colonne d’abord (matrix(1:6, nrow = 2) → la colonne 1 est 1, 2), tandis que le reshape() de NumPy remplit ligne d’abord par défaut (reshape(2, 3) → la ligne 1 est 1, 2, 3). Même forme, contenu transposé. Passez order="F" (Fortran/ordre colonne) à reshape() pour obtenir la disposition identique à R — comme dans la ligne ci-dessus.

Chaînes de caractères

Les bases du texte se correspondent proprement, avec une différence notable : Python colle les chaînes avec +, tandis que R n’a pas de + sur les chaînes et utilise à la place paste0() / paste().

Tâche	R	Python
Concaténer (sans séparateur)	`paste0("a", "b")`	`"a" + "b"`
Concaténer (avec espace)	`paste("a", "b")`	`" ".join(["a", "b"])`
Longueur	`nchar(s)`	`len(s)`
Majuscules / minuscules	`toupper(s)` / `tolower(s)`	`s.upper()` / `s.lower()`
Sous-chaîne (4 premiers)	`substr(s, 1, 4)`	`s[:4]`
Découper sur un délimiteur	`strsplit(s, ",")`	`s.split(",")`
Joindre un vecteur	`paste(v, collapse = ",")`	`",".join(v)`
Supprimer les espaces	`trimws(s)`	`s.strip()`
Formater / interpoler	`sprintf("%s-%s", a, b)`	`f"{a}-{b}"`
Compléter à gauche sur 10 caractères	`sprintf("%10s", s)`	`s.rjust(10)`
Rechercher-remplacer	`gsub("a", "b", s)`	`s.replace("a", "b")`
Nombre vers chaîne	`as.character(8)`	`str(8)`

Notez le style objet : Python appelle les opérations sur les chaînes comme des méthodes sur la chaîne (s.upper()), là où R passe la chaîne à une simple fonction (toupper(s)).

Structures de contrôle

Même logique, ponctuation différente : R entoure la condition de parenthèses et le corps d’accolades { } ; Python utilise un deux-points et marque le corps par l’indentation (pas d’accolades).

Tâche	R	Python
si / sinon-si / sinon	`if (c) {…} else if (d) {…} else {…}`	`if c: …` / `elif d: …` / `else: …`
Boucle for	`for (i in 1:3) {…}`	`for i in range(1, 4): …`
Boucle while	`while (c) {…}`	`while c: …`
Passer / arrêter l’itération	`next` / `break`	`continue` / `break`
Indice et valeur ensemble	`for (i in seq_along(x)) {…}`	`for i, v in enumerate(x): …`
Condition en ligne	`if (c) a else b` / `ifelse(c, a, b)`	`a if c else b`
Gestion des erreurs	`tryCatch(expr, error = function(e) …)`	`try: … except …: …`

Fonctions

R affecte une function(...) anonyme à un nom ; Python utilise le mot-clé def. R renvoie automatiquement sa dernière expression ; Python exige un return explicite.

Tâche	R	Python
Définir	`f <- function(x, b = 5) { x + b }`	`def f(x, b = 5): return x + b`
Renvoyer une valeur	dernière expression, ou `return(x)`	`return x` (obligatoire)
Anonyme / lambda	`\(x) x^2` (ou `function(x) x^2`)	`lambda x: x**2`
Appliquer sur une collection	`sapply(x, f)`	`[f(v) for v in x]` / `list(map(f, x))`
Argument par défaut	`function(x, n = 10)`	`def f(x, n = 10):`
Arguments variadiques	`function(...)`	`def f(args, *kwargs):`

Opérations sur les data frames

Un repère rapide pour les manipulations de tableaux les plus courantes. Pour le traitement complet — résumés groupés, jointures et pivots long ↔︎ large — lisez le guide dédié : dplyr vs pandas.

Tâche	R (base / dplyr)	Python (pandas)
Premières / dernières lignes	`head(df)` / `tail(df)`	`df.head()` / `df.tail()`
Nombre de lignes / colonnes	`nrow(df)` / `ncol(df)`	`df.shape[0]` / `df.shape[1]`
Une colonne	`df$col`	`df["col"]`
Résumé rapide	`summary(df)`	`df.describe()`
Construire un data frame	`data.frame(a = …, b = …)`	`pd.DataFrame({"a": …, "b": …})`
Filtrer les lignes	`subset(df, a > 5)` / `filter(df, a > 5)`	`df[df.a > 5]` / `df.query("a > 5")`
Ajouter / modifier une colonne	`df$c <- df$a - df$b` / `mutate(df, c = a - b)`	`df["c"] = df.a - df.b` / `df.assign(c = df.a - df.b)`
Trier selon une colonne	`df[order(df$a), ]` / `arrange(df, a)`	`df.sort_values("a")`
Renommer une colonne	`rename(df, new = old)`	`df.rename(columns = {"old": "new"})`
Valeurs distinctes	`unique(df$a)`	`df["a"].unique()`
Recoder des valeurs	`recode(df$a, "yes" = 1, "no" = 0)`	`df["a"].map({"yes": 1, "no": 0})`
Convertir le type d’une colonne	`as.character(df$a)`	`df["a"].astype(str)`
Remplacer les manquants par 0	`df$a[is.na(df$a)] <- 0`	`df["a"].fillna(0)`

Lecture et écriture de données

Tâche	R	Python (pandas)
Lire un CSV	`read.csv("in.csv")`	`pd.read_csv("in.csv")`
Écrire un CSV	`write.csv(df, "out.csv", row.names = FALSE)`	`df.to_csv("out.csv", index = False)`
Lire une feuille Excel	`readxl::read_excel("f.xlsx")`	`pd.read_excel("f.xlsx")`
Objet binaire natif	`saveRDS(x, "f.rds")` / `readRDS("f.rds")`	`df.to_pickle("f.pkl")` / `pd.read_pickle("f.pkl")`
Lire des lignes de texte	`readLines("f.txt")`	`open("f.txt").read().splitlines()`
Analyser du JSON	`jsonlite::fromJSON("f.json")`	`pd.read_json("f.json")` / `json.loads(s)`

write.csv() comme to_csv() écrivent par défaut une colonne de noms de lignes / d’index — passez row.names = FALSE (R) ou index = False (pandas) pour la supprimer, une petite différence qui surprend au premier aller-retour.

Mathématiques et statistiques

Les fonctions statistiques de R ont des équivalents NumPy directs — avec un piège : l’écart-type et la variance.

Tâche	R	Python (numpy)
Moyenne / médiane	`mean(x)` / `median(x)`	`np.mean(x)` / `np.median(x)`
Écart-type	`sd(x)`	`np.std(x, ddof = 1)`
Variance	`var(x)`	`np.var(x, ddof = 1)`
Somme / produit	`sum(x)` / `prod(x)`	`np.sum(x)` / `np.prod(x)`
Min / max	`min(x)` / `max(x)`	`x.min()` / `x.max()`
Arrondir	`round(x, 2)`	`np.round(x, 2)`
Racine carrée / log	`sqrt(x)` / `log(x)`	`np.sqrt(x)` / `np.log(x)`
Somme cumulée	`cumsum(x)`	`np.cumsum(x)`
Corrélation	`cor(x, y)`	`np.corrcoef(x, y)[0, 1]`
Trier par ordre croissant	`sort(x)`	`np.sort(x)`
Quantile	`quantile(x, 0.25)`	`np.quantile(x, 0.25)`
Somme en ignorant les `NA`	`sum(x, na.rm = TRUE)`	`np.nansum(x)`

Le piège de ddof

Les sd() et var() de R calculent la statistique d’échantillon (division par n − 1). Les np.std() et np.var() de NumPy utilisent par défaut la version de population (division par n). Passez ddof = 1 pour correspondre à R — sinon vos deux langages divergent sur chaque écart-type.

Équivalents de bibliothèques

Quand vous traduisez un script entier, vous changez aussi d’écosystème. Le plus proche équivalent Python de chaque package R courant :

Rôle	R	Python
Manipulation de données	dplyr / tidyr	pandas (ou polars)
Graphiques	ggplot2	matplotlib / seaborn / plotnine
Tableaux numériques	(vecteurs de base)	numpy
Modélisation	tidymodels / caret	scikit-learn / statsmodels
Rapports reproductibles	R Markdown / Quarto	Jupyter / Quarto
Web scraping	rvest	BeautifulSoup / requests
Tests unitaires	testthat	pytest

Voir à l’œuvre

Pour montrer que ces tableaux ne sont pas que de la théorie, voici la même petite tâche dans les deux langages : prendre six nombres, indiquer la moyenne et l’écart-type d’échantillon, garder les valeurs supérieures à 15, et les standardiser (scores z). Le code R s’exécute et affiche ce que vous voyez ; le Python est du code vérifié qui produit les mêmes nombres.

x <- c(4, 8, 15, 16, 23, 42)
mean(x)                       # 18

[1] 18

round(sd(x), 2)               # 13.49  (sample SD, divides by n - 1)

[1] 13.49

x[x > 15]                     # 16 23 42

[1] 16 23 42

round(as.numeric(scale(x)), 2)  # z-scores

[1] -1.04 -0.74 -0.22 -0.15  0.37  1.78

import numpy as np

x = np.array([4, 8, 15, 16, 23, 42])
print(x.mean())                     # 18.0
print(round(x.std(ddof=1), 2))      # 13.49  (ddof=1 = sample SD, to match R)
print(x[x > 15])                    # [16 23 42]
print(np.round((x - x.mean()) / x.std(ddof=1), 2))  # z-scores

Sortie : les deux indiquent une moyenne de 18, un écart-type d’échantillon de 13.49, les valeurs conservées 16 23 42, et les scores z identiques -1.04 -0.74 -0.22 -0.15 0.37 1.78. Le seul endroit où ils auraient pu diverger est l’écart-type — Python a besoin de ddof=1 pour reproduire le sd() de R, le piège exact que le tableau de statistiques signale plus haut.

Foire aux questions

Comment convertir du code R en Python ?

Traduisez-le ligne par ligne à l’aide d’une carte comme les tableaux ci-dessus — la plupart des constructions ont un jumeau direct, si bien que le travail est mécanique plutôt que créatif. Changez la syntaxe (<- → =, function → def, { } → indentation), changez le package (dplyr → pandas, ggplot2 → matplotlib), et surveillez les deux pièges qui ne se traduisent pas proprement : indexation à base 1 vs à base 0 et écart-type d’échantillon vs de population (ddof=1). Puis exécutez le Python et comparez sa sortie à celle du R pour confirmer que le portage est fidèle.

Existe-t-il un convertisseur automatique de R vers Python ?

Il n’existe pas de convertisseur parfait en un clic — les langages diffèrent suffisamment pour qu’un traducteur mécanique manque les idiomes et les pièges d’indexation / de ddof ci-dessus. Les assistants IA s’en sortent bien quand vous leur donnez la source et la bibliothèque cible, mais vous devez toujours exécuter et vérifier le résultat. Sur Datanovia, vous pouvez coller un script R dans Prova, qui renvoie du Python exécutable et vous laisse exécuter les deux côte à côte pour vérifier qu’ils concordent.

Quel est l’équivalent Python des fonctions R comme c(), paste0() ou mean() ?

c() devient une list (ou np.array() pour les calculs), paste0() devient le + sur les chaînes (ou "".join() pour un vecteur de chaînes), et mean() devient np.mean(). Les tableaux ci-dessus recensent les plus courants par tâche. Une différence structurelle à prévoir : beaucoup d’opérations Python sont des méthodes appelées sur l’objet (s.upper(), df.head()), tandis que les équivalents R sont des fonctions autonomes auxquelles vous passez l’objet (toupper(s), head(df)).

R et Python peuvent-ils exécuter directement le code l’un de l’autre ?

Pas directement — ce sont des interpréteurs distincts, donc vous traduisez le code plutôt que de le coller tel quel. Si vous avez besoin de les faire interopérer dans un même projet, des bibliothèques passerelles existent : reticulate permet à R d’appeler Python, et rpy2 permet à Python d’appeler R. Même alors, les correspondances de structures de données de cet aide-mémoire (vecteur ↔︎ tableau, liste nommée ↔︎ dict, data.frame ↔︎ DataFrame) sont exactement ce que ces passerelles convertissent en coulisses.

Pourquoi mes résultats R et Python diffèrent-ils légèrement ?

Généralement l’une de trois raisons. Écart-type / variance : R utilise la formule d’échantillon (n − 1) ; NumPy utilise par défaut la formule de population (n) — passez ddof=1 pour correspondre. Indexation : le x[1] de R est le x[0] de Python, si bien qu’un décalage d’un indice décale discrètement chaque position. Types de nombres : R affiche souvent les entiers comme des doubles (9.0), tandis que Python garde 9 en int jusqu’à ce qu’un flottant entre dans le calcul. Corrigez ces trois points et les langages concordent jusqu’à la dernière décimale.

Pour aller plus loin

R vs Python syntax — le compagnon concept par concept de cet index : pourquoi chaque correspondance est ce qu’elle est (affectation, types, indexation, boucles, fonctions, valeurs manquantes).
dplyr vs pandas et ggplot2 vs matplotlib — les guides frères approfondis pour la manipulation de données et les graphiques.
Fondamentaux de R — les bases de R exécutables (vecteurs et types, indexation, structures de contrôle, fonctions) · Fondamentaux de Python pour le côté Python (bases, types et structures de données, tableaux NumPy).

🟢 Avec un agent IA

Demandez à Prova « traduis ce script R en Python, en gardant la même logique et en corrigeant l’indexation à base 1 et l’écart-type d’échantillon vs de population » — collez votre propre code et elle répond avec une version que vous pouvez exécuter. The runtime is the judge. Demander à Prova →

Cette page vous a-t-elle été utile ?

Citation

BibTeX

@online{kassambara2026,
  author = {Kassambara, Alboukadel},
  title = {Traductions de code R vers Python : un aide-mémoire côte à
    côte},
  date = {2026-07-14},
  url = {https://www.datanovia.com/blog/r-vs-python-code-translations},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

Kassambara, Alboukadel. 2026. “Traductions de code R vers Python : un aide-mémoire côte à côte.” July 14. https://www.datanovia.com/blog/r-vs-python-code-translations.