| title | subject | subtitle | authors | license | keywords | venue | open_access | repository | html | |||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Un panorama des pratiques informatiques dans les publications de recherche dans la base de données HAL. |
Découverte de librairies et API. |
Un exemple des bonnes pratiques à mettre en place pour constituer un Notebook. |
|
CC-BY-4.0 |
Jupyter Notebooks, API, tutoriel |
|
true |
|
Les données utilisées dans ce notebook proviennent du site des archives ouvertes (https://hal.science/). Les archives ouvertes sont une plateforme numérique qui permet aux chercheurs de publier, partager et diffuser leurs travaux scientifiques en ligne.
Les données sont fournies au format texte en open source et sont accessibles via le site internet ou via l'API (Interface de programmation d'application). Une API fournit des "endpoints" permettant d'interagir avec leur site web et de récupérer des informations grâce à des recherches. Les APIs facilitent la communication entre plusieurs applications informatiques, ce qui facilite l'échange d'informations et permet aux développeurs de construire de nouvelles applications avec diverses utilisations.
L'utilisation d'une API nécessite également une chaîne de requête (query string en anglais), qui est une partie à ajouter à droite de l'URL de base pour inclure des paramètres et des valeurs.
Un exemple de chaîne de requête est : https://api.archives-ouvertes.fr/search/?q=%22jupyter%20notebook%22. Cette URL fonctionne directement dans notre navigateur web et renvoie les résultats de notre recherche.
https://api.archives-ouvertes.fr/search est la première partie qui permet de rechercher dans l'API des archives ouvertes. La deuxième partie, ?q=%22jupyter%20notebook%22, permet de spécifier notre requête, qui est "jupyter notebook".
Certains caractères, tels que l'espace ou les guillemets doubles, doivent être transmis correctement via le protocole HTTP pour être encodés. Le %22 correspond à l'encodage ASCII du caractère double guillemet et le %20 correspond à l'encodage de l'espace. Cela permet à l'ordinateur d'effectuer la requête sur "jupyter notebook" et non "jupyter" et "notebook" séparément.
L'utilisation d'une API permet d'interroger les données en utilisant des paramètres, par exemple pour connaître le nombre d'articles publiés dans HAL en 2014.
Dans ce notebook, nous allons voir comment utiliser l'API des archives ouvertes ainsi que les bibliothèques pandas et matplotlib.
:::{attention}Compétences requises en Python. Ce Jupyter Notebook nécessite d'avoir des compétences en Python pour le réaliser. Il existe néanmoins une manière pour les non programmeurs d'interagir avec l'API de HAL ci-dessous :
:::
:::{note}Pour les personnes qui ne connaissent pas Python. Les IpyWidgets permettent à des utilisateurs qui ne savent pas coder d'utiliser l'API des HAL avec des paramètres comme le type de documents ou les années. :::
Ce Jupyter Notebook a plusieurs buts :
- Faire un panorama des pratiques numériques des chercheurs.
- Fournir un exemple de Jupyter Notebook reproductible et de qualité.
- Enseigner des compétences aux utilisateurs débutants ou expérimentés avec Python.
Ce Jupyter Notebook est à destination d'un public débutant. Il est conseillé de connaître le langage informatique Python pour suivre le Notebook mais pas obligatoire.
Le document permet d'acquérir des compétences variées comme :
- Savoir utiliser les différentes librairies comme pandas et matplotlib.
- Utiliser les fonctions en Python pour éviter la duplication du code.
- Savoir faire une requête dans une API.
Dans cette section, nous allons importer les librairies nécessaires à notre analyse.
:::{important}Le rôle des libraries
La librairie requests et json permet de faire les requêtes dans l'API de HAL.
Pandas est utilisé pour faire de l'analyse de données. La librarie fournit des fonctions pour créer, manipuler et analyser les DataFrames.
Matplotlib permet de faire des graphiques et de visualiser les données.
:::
import requests, json
import pandas as pd
import matplotlib.pyplot as pltSection 1 : Analyse du nombre de publications concernant Python et les Jupyter Notebooks dans l'API de HAL.
Nous pouvons faire une analyse stastique du nombre de publications dans la base de données HAL et comparer avec l'utilisation de Python et des Jupyter Notebooks.
1.0 : Utilisation d'une fonction qui retourne le nombre d'articles par année en fonction d'une recherche.
:::{tip}Bonne pratique
Les fonctions permettent de rendre le code plus lisible et de réduire la duplication du code.
:::
Pour faire une requête dans l'API, il est nécessaire de lire la documentation du site HAL disponible à cette adresse : https://api.archives-ouvertes.fr/docs/search
def get_publication_counts(query):
# Effectue une requête pour obtenir le nombre total de publications
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q=text_fulltext:({query})&rows=0&facet=true&facet.field=publicationDateY_i")
req_json = req.json()
nb = req_json["response"]["numFound"]
print(f"Le nombre total de résultats est de : {nb}\n")
# Effectue une requête pour obtenir le nombre de publications par année
year_counts = []
for year in range(1995, 2023):
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q=text_fulltext:({query}) AND publicationDateY_i:{year}&rows=0")
req_json = req.json()
year_count = req_json["response"]["numFound"]
year_counts.append((year, year_count))
# Transforme la liste de tuples en un DataFrame pandas et le renvoie
df = pd.DataFrame(year_counts, columns=["Année", "Nombre de publications"])
return dfNous allons ensuite appelé cette fonction et imprimer le dataframe créé grâce à la librairie Pandas.
df = get_publication_counts("python")
print(df)Le nombre total de résultats est de : 29737
Année Nombre de publications
0 1995 2
1 1996 1
2 1997 3
3 1998 4
4 1999 7
5 2000 8
6 2001 10
7 2002 13
8 2003 32
9 2004 32
10 2005 68
11 2006 114
12 2007 108
13 2008 161
14 2009 224
15 2010 328
16 2011 444
17 2012 566
18 2013 660
19 2014 877
20 2015 1048
21 2016 1386
22 2017 1930
23 2018 2606
24 2019 3577
25 2020 4154
26 2021 5148
27 2022 5169
Le dataframe montre une augmentation importante des articles concernant Python dans la base de donnée HAL. Le nombre d'articles sur Python passe de 10 en 2001 à 444 en 2011 puis 5143 en 2021 soit une multiplication par 500 en l'espace d'une vingtaine d'années. Il est important de noter que l'année 2022 est la première année de baisse du nombre d'articles concernant Python par rapport à l'année précédente depuis 1996.
1.1 : Faire un graphique avec la librairie Matplotlib pour voir le nombre de publications sur Python en fonction des années.
Nous allons passer maintenant à la représentation graphique avec la librairie Matplotlib.
# Effectue une requête pour obtenir le nombre d'articles avec le mot-clé "Python"
query = "python"
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q=text_fulltext:({query})&rows=0&facet=true&facet.field=producedDateY_i")
req_json = req.json()
nb = req_json["response"]["numFound"]
print(f"Le nombre d'articles contenant le mot clé '{query}' est de : {nb}\n")
# Effectue uen requête pour obtenir le nombre d'articles avec le mot-clé "Python" par année
year_counts = req_json["facet_counts"]["facet_fields"]["producedDateY_i"]
year_counts = [year_counts[i:i+2] for i in range(0, len(year_counts), 2) if int(year_counts[i]) >= 1995]
years = [int(year) for year, count in year_counts]
counts = [count for year, count in year_counts]
# Création du graphique
plt.bar(years, counts)
plt.title("Nombre de résultats concernant Python dans la base de HAL par années(après 1995)")
plt.xlabel("Year")
plt.ylabel("Number of publications")
plt.show()Le nombre d'articles contenant le mot clé 'python' est de : 29737
:::{note} Matplotlib est une librairie qui permet de faire ce graphique pour visualiser l'augmentation des articles sur Python dans la base de données HAL. :::
L'année 2023 marquera probablement une baisse dans le nombre d'articles publiés sur Python dans la base de données de HAL car 5 mois se sont déjà écoulés et il n'y a même pas 1000 articles.
Nous appelons la même fonction que dans le 1.0
df = get_publication_counts("jupyter AND (notebook OR notebooks)")
print(df)Le nombre total de résultats est de : 845
Année Nombre de publications
0 1995 0
1 1996 0
2 1997 0
3 1998 0
4 1999 0
5 2000 0
6 2001 0
7 2002 0
8 2003 0
9 2004 0
10 2005 0
11 2006 0
12 2007 0
13 2008 0
14 2009 0
15 2010 0
16 2011 0
17 2012 0
18 2013 0
19 2014 0
20 2015 1
21 2016 12
22 2017 24
23 2018 69
24 2019 107
25 2020 138
26 2021 213
27 2022 224
Le dataframe montre une augmentation importante des articles concernant les Jupyter Notebooks dans la base de donnée HAL. Le nombre d'articles concernant les Jupyter Notebooks (avec et sans s) passent de 12 en 2016 à 70 (multiplé par 5) en 2018 puis à 223 en 2022. Le nombre de publications a été multiplé à peu près par 19 entre 2016 et 2022.
Il est important de comparer cette hausse d'intérêt pour Python et pour les Jupyter Notebooks à la hausse du nombre d'articles dans HAL. Cette hausse du nombre d'articles pourrait ne pas être la conséquence d'une hausse d'intérêt mais d'une hausse dans le nombre d'articles.
1.3 : Calculer le pourcentage d'articles concernant Python et les Jupyter Notebooks sur le nombre total d'articles dans la base de données HAL en fonction des années.
Nous utilisons l'API de HAL et la librairie pandas pour créer un tableau.
# Récupère le nombre total d'articles pour chaque année
total_counts = []
for year in range(1995, 2023):
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q=*&fq=producedDateY_i:{year}&rows=0")
req_json = req.json()
year_count = req_json["response"]["numFound"]
total_counts.append((year, year_count))
total_df = pd.DataFrame(total_counts, columns=["year", "total_articles"])
# Récupère le nombre d'articles concernant Python pour chaque année
python_counts = []
for year in range(1995, 2023):
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q=text_fulltext:(Python)&fq=producedDateY_i:{year}&rows=0")
req_json = req.json()
year_count = req_json.get("response", {}).get("numFound", 0)
python_counts.append((year, year_count))
python_df = pd.DataFrame(python_counts, columns=["year", "python_articles"])
# le nombre d'articles concernant les Jupyter Notebooks pour chaque année
jupyter_counts = []
for year in range(1995, 2023):
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q=text_fulltext:(jupyter AND (notebook OR notebooks))&fq=producedDateY_i:{year}&rows=0")
req_json = req.json()
year_count = req_json.get("response", {}).get("numFound", 0)
jupyter_counts.append((year, year_count))
jupyter_df = pd.DataFrame(jupyter_counts, columns=["year", "jupyter_articles"])
# Fusionne les trois dataframes
merged_df = pd.merge(total_df, python_df, on="year")
merged_df = pd.merge(merged_df, jupyter_df, on="year")
# Calcul le pourcentage des articles concernant Python et les JupyterNotebooks pour chaque année.
merged_df["percent_python"] = merged_df["python_articles"] / merged_df["total_articles"] * 100
merged_df["percent_jupyter"] = merged_df["jupyter_articles"] / merged_df["total_articles"] * 100
# Visualise le tableau
print(merged_df) year total_articles python_articles jupyter_articles percent_python \
0 1995 22489 2 0 0.008893
1 1996 24106 1 0 0.004148
2 1997 25854 4 0 0.015471
3 1998 27630 4 0 0.014477
4 1999 28524 6 0 0.021035
5 2000 32962 8 0 0.024270
6 2001 34906 10 0 0.028648
7 2002 42052 13 0 0.030914
8 2003 51433 31 0 0.060273
9 2004 62754 34 0 0.054180
10 2005 83609 67 0 0.080135
11 2006 99794 114 0 0.114235
12 2007 109924 109 0 0.099159
13 2008 115399 160 0 0.138649
14 2009 124946 227 0 0.181678
15 2010 137047 332 0 0.242253
16 2011 142782 447 0 0.313065
17 2012 149234 564 0 0.377930
18 2013 158251 662 0 0.418323
19 2014 164624 874 0 0.530907
20 2015 175373 1055 1 0.601575
21 2016 186786 1390 13 0.744167
22 2017 194924 1940 23 0.995260
23 2018 198273 2596 68 1.309306
24 2019 199952 3580 108 1.790430
25 2020 172297 4138 138 2.401667
26 2021 180873 5157 212 2.851172
27 2022 156396 5162 221 3.300596
percent_jupyter
0 0.000000
1 0.000000
2 0.000000
3 0.000000
4 0.000000
5 0.000000
6 0.000000
7 0.000000
8 0.000000
9 0.000000
10 0.000000
11 0.000000
12 0.000000
13 0.000000
14 0.000000
15 0.000000
16 0.000000
17 0.000000
18 0.000000
19 0.000000
20 0.000570
21 0.006960
22 0.011799
23 0.034296
24 0.054013
25 0.080094
26 0.117209
27 0.141308
Le tableau montre que le pourcentage des documents concernant Python et les Jupyter Notebooks augmente dans le total de documents publiés dans HAL. L'intérêt pour Python et les Jupyter Notebooks augmente dans le cadre de la recherche.
En 2002, les documents relatifs à Python ne représentaient que 0,03% du total des documents présents dans la base de données HAL. Ce chiffre est passé à 0,37% en 2012 et a atteint 3,31% en 2022.
Le Projet Jupyter a été lancé en 2014. Les premiers résultats apparaissent en 2015 avec un document traitant des Jupyter Notebooks. En 2019, le pourcentage des documents relatifs aux Jupyter Notebooks représentaient 0,05% du nombre total de documents présents. Ce chiffre est de 0,14% en 2022.
Bien que l'intérêt pour Python et les Jupyter Notebooks soit en hausse, le nombre d'articles les concernant reste relativement faible dans la base de données de HAL.
Il est intéressant de voir quelles sont les mots clés les plus cherchés dans la base des archives ouvertes si Python ne représente que 3.30% des documents présents et les Jupyter Notebooks que 0,14% des documents présents.
Cette section permet de voir comment faire une requête dans l'API de HAL pour obtenir le type de documents concernant une recherche précise (dans notre exemple : Python et les Jupyter Notebooks).
Nous verrons aussi comment récupérer dans l'API de HAL le domaine d'une recherche.
Pour faire une requête dans l'API, il est nécessaire de lire la documentation du site HAL disponible à cette adresse : https://api.archives-ouvertes.fr/docs/search
def get_doc_types(query):
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q={query}&rows=0&facet=true&facet.field=docType_s")
req_json = req.json()
doc_types = req_json["facet_counts"]["facet_fields"]["docType_s"]
doc_types = [doc_types[i:i+2] for i in range(0, len(doc_types), 2)]
total_docs = req_json["response"]["numFound"]
doc_types_dict = {doc_type: count/total_docs*100 for doc_type, count in doc_types}
return doc_types_dictNous faisons une fonction que nous allons appeler dans la suite de notre code comme dans la Section 1.
doc_types = get_doc_types("text_fulltext:(python)")
print(doc_types){'ART': 47.17355483068231, 'COMM': 25.587651746981876, 'THESE': 11.974980663819485, 'UNDEFINED': 5.346874264384437, 'REPORT': 2.649897434172916, 'MEM': 2.2564481958502873, 'COUV': 1.4863637892188184, 'POSTER': 0.8339778726838618, 'HDR': 0.6860140565625316, 'OTHER': 0.5481386824494737, 'OUV': 0.41362612233917345, 'LECTURE': 0.32283014426472073, 'PROCEEDINGS': 0.211857282173723, 'SOFTWARE': 0.1715035141406329, 'BLOG': 0.11433567609375525, 'PRESCONF': 0.09079597807445271, 'ISSUE': 0.030265326024817567, 'VIDEO': 0.023539698019302554, 'OTHERREPORT': 0.016814070013787537, 'REPORT_FORM': 0.013451256011030031, 'REPORT_LICE': 0.013451256011030031, 'REPORT_LABO': 0.010088442008272523, 'ETABTHESE': 0.0033628140027575078, 'MAP': 0.0033628140027575078, 'MEMLIC': 0.0033628140027575078, 'REPORT_LPRO': 0.0033628140027575078, 'REPORT_MAST': 0.0033628140027575078, 'SYNTHESE': 0.0033628140027575078, 'TRAD': 0.0033628140027575078, 'CREPORT': 0.0, 'DOUV': 0.0, 'IMG': 0.0, 'MANUAL': 0.0, 'NOTE': 0.0, 'NOTICE': 0.0, 'PATENT': 0.0, 'REPACT': 0.0, 'REPORT_COOR': 0.0, 'REPORT_DOCT': 0.0, 'REPORT_ETAB': 0.0, 'REPORT_FPROJ': 0.0, 'REPORT_GLICE': 0.0, 'REPORT_GMAST': 0.0, 'REPORT_RETABINT': 0.0, 'REPORT_RFOINT': 0.0, 'SON': 0.0}
Parmi les documents liés à Python dans la base de données HAL, les articles scientifiques représentent 47%, suivis des communications à 25%, et des thèses à 11%. En revanche, les cours ne représentent qu'une faible proportion de 0,32%.
doc_types = get_doc_types("jupyter AND (notebook OR notebooks)")
print(doc_types){'ART': 39.130434782608695, 'COMM': 32.608695652173914, 'BLOG': 6.521739130434782, 'LECTURE': 6.521739130434782, 'UNDEFINED': 5.434782608695652, 'OUV': 2.1739130434782608, 'REPORT': 2.1739130434782608, 'SOFTWARE': 2.1739130434782608, 'POSTER': 1.0869565217391304, 'THESE': 1.0869565217391304, 'VIDEO': 1.0869565217391304, 'COUV': 0.0, 'CREPORT': 0.0, 'DOUV': 0.0, 'ETABTHESE': 0.0, 'HDR': 0.0, 'IMG': 0.0, 'ISSUE': 0.0, 'MANUAL': 0.0, 'MAP': 0.0, 'MEM': 0.0, 'MEMLIC': 0.0, 'NOTE': 0.0, 'NOTICE': 0.0, 'OTHER': 0.0, 'OTHERREPORT': 0.0, 'PATENT': 0.0, 'PRESCONF': 0.0, 'PROCEEDINGS': 0.0, 'REPACT': 0.0, 'REPORT_COOR': 0.0, 'REPORT_DOCT': 0.0, 'REPORT_ETAB': 0.0, 'REPORT_FORM': 0.0, 'REPORT_FPROJ': 0.0, 'REPORT_GLICE': 0.0, 'REPORT_GMAST': 0.0, 'REPORT_LABO': 0.0, 'REPORT_LICE': 0.0, 'REPORT_LPRO': 0.0, 'REPORT_MAST': 0.0, 'REPORT_RETABINT': 0.0, 'REPORT_RFOINT': 0.0, 'SON': 0.0, 'SYNTHESE': 0.0, 'TRAD': 0.0}
Parmi les documents liés aux Jupyter Notebooks dans la base de données HAL, les articles scientifiques représesentent 39%, les communications 32% et des blogs à 6,52%. Les cours représentent eux seulement 6%.
Nous pouvons nous demander aussi dans quelle discipline les Jupyter Notebooks sont utilisés. Notre hypothèse est dire que ce format est plus utilisé en informatique et dans les disciplines scientifiques comme en physique par exemple.
Nous allons voir comment obtenir le domaine d'une recherche grâce à l'API de HAL.
# Faire la requête pour obtenir le nombre de documents contenant "jupyter" et "notebook(s)"
req = requests.get("https://api.archives-ouvertes.fr/search/?q=text_fulltext:(jupyter AND (notebook OR notebooks))&rows=0&facet=true&facet.field=domain_s")
# Obtenir les données de la requête au format JSON
req_json = req.json()
# Extraire les domaines et leur nombre de la réponse JSON
domain_counts = req_json["facet_counts"]["facet_fields"]["domain_s"]
domain_counts = [(domain_counts[i], domain_counts[i+1]) for i in range(0, len(domain_counts), 2)]
# Séparer les domaines multiples et leur nombre de documents en entrées individuelles
domain_counts_split = []
for domain_count in domain_counts:
domains = domain_count[0].split(';')
for domain in domains:
domain_counts_split.append((domain.strip(), domain_count[1])) # Garder le domaine complet
# Calculer le nombre total de documents
total = sum([count for _, count in domain_counts_split])
# Calculer le pourcentage de documents par domaine
domain_percents = [(domain[0], domain[1]/total*100) for domain in domain_counts_split]
# Filtrer les domaines ayant un seul mot et un pourcentage supérieur à 0,5% et supprimer les domaines spécifiques
domain_percents_filtered = [(domain, percent) for domain, percent in domain_percents if percent > 0.5 and len(domain.split()) == 1
and not any(domain_specific in domain for domain_specific in ["1.info.info-ai", "1.info.info-bi", "1.phys.astr", "info.info-lg", "sdv.neu", "sdu.ocean", "math.math-st"])]
# Supprimer les domaines qui commencent par "1"
domain_percents_filtered = [(domain, percent) for domain, percent in domain_percents_filtered if not domain.startswith("1")]
# Créer un dataframe à partir des pourcentages filtrés et trier par ordre décroissant
df = pd.DataFrame(domain_percents_filtered, columns=["Domaine", "Pourcentage"])
df = df.sort_values(by=["Pourcentage"], ascending=False)
# Afficher le dataframe
print(df) Domaine Pourcentage
0 0.info 17.933810
1 0.sdv 7.245081
2 0.phys 4.338104
3 0.sdu 4.069767
4 0.shs 3.890877
5 0.math 2.996422
6 0.spi 2.862254
7 0.sde 1.833631
8 0.stat 1.654741
9 0.scco 1.162791
10 0.chim 0.983900
Les Jupyter Notebooks commencent à être utiliser en SHS mais très peu (3,8%) par rapport à l'informatique (17%) ou en Statisques et Données de la Vie (7%).
Il est encore assez compliqué de trouver des Notebooks disponibles en SHS que cela soit en Histoire ou en Géographie. Une explication peut être le fait que la pratique des Notebooks en SHS est nouvelle et aussi le fait que les sciences sociales ont moins besoin d'utiliser des langages informatiques qu'en informatique et qu'en Statistiques et Données de la Vie. Le manque de ressources sur comment bien utiliser les Jupyter Notebooks dans le cadre des SHS peut être une cause aussi de ce faible pourcentage.
Nous allons voir dans cette partie quels sont les logiciels et les différents langages informatiques (autre que Python) que les chercheurs utilisent le plus dans la base de HAL.
# Liste des termes de recherche
terms = ["langage de programmation Julia", "Rstudio", "Python", "pascal langage informatique", "Matlab", "Javascript", "Spss", "Stata", "Fortran", "Javascript", "Bash", "Rust", "SAS", "Excel", "Libreoffice", "Perl", "HTML"]
# Dictionnaire pour stocker les résultats
results = {}
# Pour chaque terme de recherche, faire une requête et extraire le nombre total de résultats
for term in terms:
req = requests.get(f"https://api.archives-ouvertes.fr/search/?q={term}&rows=0")
req_json = req.json()
total = req_json["response"]["numFound"]
results[term] = total
# Afficher les résultats sous forme de tableau
import pandas as pd
df = pd.DataFrame.from_dict(results, orient="index", columns=["Nombre de documents"])
df = df.sort_values(by=["Nombre de documents"], ascending=False)
print(df) Nombre de documents
SAS 10756
Matlab 2848
HTML 2729
Python 2632
Rust 1111
Perl 852
Excel 661
Fortran 541
Javascript 432
Stata 423
Spss 354
pascal langage informatique 214
Bash 47
Rstudio 42
Libreoffice 12
langage de programmation Julia 8
Il est intéressant de voir les différentes pratiques numériques des chercheurs. Python a pris beaucoup d'importance mais il est important de voir que les chercheurs utilisent aussi d'autres langages informatiques comme HTML, Perl, Pascal ou bien Javascript. Les chercheurs utilisent aussi des logiciels comme Rstudio, LibreOffice mais surtout Excel.
Il est important de voir les autres pratiques numériques des chercheurs et de comparer le type de document produit dans la plateforme HAL.
# Liste des termes de recherche
terms = ["langage de programmation Julia", "Rstudio", "Python", "pascal langage informatique", "Matlab", "Javascript", "Spss", "Stata", "Fortran", "Javascript", "Bash", "Rust", "SAS", "Excel", "Libreoffice", "Perl", "HTML"]
# Dictionnaire pour stocker les résultats
results = {}
# Pour chaque terme de recherche, faire une requête et extraire les pourcentages de chaque type de document
for term in terms:
doc_types_dict = get_doc_types(term)
results[term] = doc_types_dict
# Afficher les résultats sous forme de tableau
df_list = []
for term, doc_types_dict in results.items():
df = pd.DataFrame.from_dict(doc_types_dict, orient="index", columns=[term])
df = df.loc[df[term] > 0].sort_values(by=[term], ascending=False).head(3)
df.dropna(axis=1, inplace=True)
df_list.append(df)
df_final = pd.concat(df_list, axis=1)
df_final.fillna("", inplace=True)
df_final.dropna(axis=0, how='all', inplace=True)
print(df_final) langage de programmation Julia Rstudio Python \
COMM 62.5 33.333333 24.620061
THESE 25.0 6.458967
LECTURE 12.5
ART 23.809524 48.138298
REPORT 9.52381
COUV
POSTER
MEM
BLOG
UNDEFINED
OTHER
pascal langage informatique Matlab Javascript Spss \
COMM 41.588785 42.029494 55.092593 17.79661
THESE 13.084112 14.255618 6.712963 11.864407
LECTURE
ART 21.495327 31.671348 16.203704 53.954802
REPORT
COUV
POSTER
MEM
BLOG
UNDEFINED
OTHER
Stata Fortran Bash Rust SAS Excel \
COMM 22.365989 21.276596 20.432043 27.789141 20.121029
THESE 12.056738 5.310531
LECTURE
ART 39.479905 38.44732 38.297872 64.626463 55.076237 32.526475
REPORT 15.711645
COUV 11.820331 10.638298
POSTER 4.555597
MEM 24.054463
BLOG
UNDEFINED
OTHER
Libreoffice Perl HTML
COMM 41.666667 20.657277 26.419934
THESE
LECTURE
ART 72.41784 47.196775
REPORT 16.666667
COUV
POSTER
MEM
BLOG 25.0
UNDEFINED 1.643192
OTHER 4.87358
D'après les résultats obtenus, il apparaît que les types de documents les plus fréquemment associés à nos termes de recherche sont très majoritairement soit des articles scientifiques ou des communications ce qui est le même résultat que pour "Python" et les "Jupyter Notebooks" obtenu dans la section 2.0
Nous avons vu comment mettre des paramètres dans notre query avec le "query string" mais il y a une autre manière de faire.
On peut créer un dictionnaire et les paramètres sont passés en tant qu'arguments. Lorsque la requête est effectuée, la bibliothèque requests construit automatiquement l'URL avec les paramètres spécifiés dans le dictionnaire params. Cela permet de spécifier les paramètres de manière plus structurée et flexible, en utilisant une syntaxe de dictionnaire.
# Effectuer une requête pour obtenir les types de document pour tous les documents dans HAL
params = {
"q": "*:*",
"rows": 0,
"fl": "docType_s",
"facet": "true",
"facet.field": "docType_s"
}
req = requests.get("https://api.archives-ouvertes.fr/search/", params=params)
req_json = req.json()
# Extraire les types de document et leurs nombres de la réponse JSON
doc_types = req_json["facet_counts"]["facet_fields"]["docType_s"]
doc_types_dict = {doc_type: count for doc_type, count in zip(doc_types[::2], doc_types[1::2])}
# Créer un DataFrame à partir des types de document
df = pd.DataFrame.from_dict(doc_types_dict, orient="index", columns=["Nombre de documents"])
df = df.sort_values(by=["Nombre de documents"], ascending=False)
# Calculer les pourcentages de chaque type de document par rapport au total
total_documents = df["Nombre de documents"].sum()
df["Pourcentage"] = df["Nombre de documents"] / total_documents * 100
# Afficher le DataFrame
print(df) Nombre de documents Pourcentage
ART 1626205 47.971201
COMM 803641 23.706497
COUV 290548 8.570836
THESE 143901 4.244916
OUV 98939 2.918588
UNDEFINED 66741 1.968784
MEM 60481 1.784121
OTHER 59962 1.768811
REPORT 59718 1.761613
IMG 56724 1.673294
POSTER 49283 1.453793
ISSUE 9996 0.294871
NOTICE 8268 0.243897
PROCEEDINGS 8016 0.236463
HDR 6845 0.201920
PATENT 6110 0.180238
BLOG 6028 0.177819
REPORT_LABO 5205 0.153542
VIDEO 3965 0.116963
REPORT_MAST 3413 0.100680
LECTURE 3036 0.089559
REPORT_LPRO 2747 0.081033
REPORT_LICE 2701 0.079676
TRAD 1810 0.053393
SOFTWARE 879 0.025930
PRESCONF 832 0.024543
CREPORT 808 0.023835
REPORT_DOCT 581 0.017139
REPORT_ETAB 491 0.014484
MAP 413 0.012183
SON 326 0.009617
REPORT_FORM 270 0.007965
REPORT_GMAST 222 0.006549
OTHERREPORT 164 0.004838
NOTE 145 0.004277
SYNTHESE 124 0.003658
REPORT_FPROJ 115 0.003392
REPORT_GLICE 91 0.002684
REPACT 70 0.002065
ETABTHESE 50 0.001475
MEMLIC 41 0.001209
REPORT_RFOINT 24 0.000708
REPORT_COOR 20 0.000590
REPORT_RETABINT 11 0.000324
MANUAL 1 0.000029
DOUV 0 0.000000
En analysant le nombre total de documents dans la base de HAL, on constate que les deux types de documents les plus fréquents sont des articles scientifiques et des communications. Cela correspond aux mêmes résultats obtenus pour "Python" et les "Jupyter Notebooks". Environ 70% des documents présents dans la base des archives ouvertes sont des articles scientifiques ou des communications.
Notre Jupyter Notebook est fini : en espérant qu'il vous a plu et qu'il était clair !
Si vous avez des questions ou des retours, merci de m'écrire à mon adresse email universitaire : [email protected].