Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux.
Visitez [Link]/pro pour en savoir plus.
EXPLICATION DU CODE PYTHON
Question 1 :
Ce code Python estime la valeur de pi à l'aide d'une simulation de Monte Carlo. Voici comment il
fonctionne :
1. Le code importe les modules `random` et `math`.
2. La variable `N` est fixée à 1000000, indiquant le nombre de points aléatoires à générer.
3. La variable `count` est initialisée à 0, et sera utilisée pour garder une trace du nombre de points
aléatoires à l'intérieur d'un cercle inscrit dans un carré.
4. Le code entre dans une boucle `for` qui s'exécute `N` fois. À chaque itération, il génère deux
nombres aléatoires `x` et `y` en utilisant la fonction `[Link](0,1)`. Ces nombres sont
compris entre 0 et 1 et représentent les coordonnées (x, y) d'un point du carré.
5. La distance de ce point par rapport à l'origine est calculée à l'aide de la fonction
`[Link](x**2 + y**2)`. Si cette distance est inférieure à 1, alors le point se trouve à
l'intérieur du cercle inscrit.
6. Si le point est à l'intérieur du cercle, la variable `count` est incrémentée de 1.
7. Une fois la boucle terminée, l'approximation de pi est calculée à l'aide de la formule `pi_estimate
= 4 * count / N`. Cette formule utilise le rapport entre le nombre de points à l'intérieur du cercle et
le nombre total de points pour estimer l'aire du cercle, qui est proportionnelle à pi. Le facteur 4
vient du fait que le cercle est inscrit dans un carré dont le côté a une longueur de 2, donc son aire est
de 4.
8. L'approximation de pi est imprimée sur la console à l'aide de la fonction `print`.
La valeur résultante imprimée sur la console est une approximation de pi basée sur la simulation
de Monte Carlo. La précision de l'approximation dépend du nombre de points générés, un plus
grand nombre de points donnant une estimation plus précise.
Question 2 :
Ce code Python définit une fonction `n(k)` qui renvoie 10 à la puissance de `k`, et une fonction
`estimate_pi(k)` qui génère `N = n(k)` points aléatoires et estime pi en comptant le nombre de
points situés à l'intérieur d'un cercle unitaire et en le divisant par le nombre total de points.
Le code génère ensuite une liste de valeurs `k` à utiliser pour l'estimation de pi et utilise une
compréhension de liste pour calculer les estimations `pi` correspondantes en utilisant
`estimate_pi(k)`.
Enfin, le code trace la vraie valeur de pi (importée du module math), ainsi que les estimations
approximatives de pi pour chaque valeur de `k` en utilisant `[Link]`. L'axe des x est la
valeur de
`k`, et l'axe des y est la valeur de pi. Le graphique montre comment la précision de l'estimation de pi
s'améliore lorsque
`k` augmente, les valeurs approximatives de pi convergeant vers la valeur réelle de pi.
Question 3
Ce code définit une fonction nommée `gaussian_dis` qui prend un seul argument entier `n`. La
fonction génère `n` paires de nombres aléatoires qui sont distribués selon la distribution gaussienne
2D (normale).
Voici comment fonctionne cette fonction :
1. Tout d'abord, la fonction utilise la fonction `random` du module `[Link]` (qui est importé
avec l'alias `npr`) pour générer deux tableaux de `n` nombres aléatoires entre 0 et 1. Ces tableaux
sont stockés dans les variables `U_1` et `U_2`. (u_1 et u_2 sont indépendantes)
2. La fonction applique ensuite certaines transformations mathématiques à ces nombres
aléatoires pour générer des paires de nombres aléatoires avec une distribution gaussienne.
Plus précisément, la fonction utilise la méthode de la transformation inverse, qui consiste à
prendre deux nombres aléatoires uniformément distribués, à les transformer à l'aide d'un
ensemble de fonctions mathématiques et à obtenir une paire de nombres aléatoires normalement
distribués.
3. Les transformations mathématiques utilisées dans cette fonction impliquent les étapes suivantes :
a. La fonction calcule la racine carrée du logarithme négatif de `U_1`, ce qui donne une valeur
distribuée selon une distribution chi-carré avec 2 degrés de liberté.
b. La fonction génère un angle aléatoire `teta` entre 0 et 2π en utilisant `U_2`.
c. La fonction calcule les coordonnées `X` et `Y` d'un point situé à une distance `R` de l'origine
et un angle `teta` en utilisant les fonctions trigonométriques `cos` et `sin`.
4. Enfin, la fonction renvoie un tuple de deux tableaux `X` et `Y`, chacun contenant `n` nombres
aléatoires qui sont normalement distribués avec une moyenne de 0 et un écart-type de 1.
Notez que cette implémentation repose sur le module `numpy`, ainsi que sur le sous-module
`[Link]`, donc vous devez avoir ces paquets installés et importés avant de pouvoir utiliser
cette fonction.
Question 4 :
Ce code génère des coordonnées `X` et `Y` pour un ensemble de 10 millions de points qui sont
normalement distribués en utilisant la fonction `gaussian_dis`, et crée ensuite un histogramme à
deux panneaux des données résultantes.
Voici comment fonctionne le code :
1. Les variables `X` et `Y` se voient assigner les valeurs retournées par la fonction `gaussian_dis`
lorsqu'elle est appelée avec l'argument `int(10e6)`. `int(10e6)` vaut 10,000,000, ce qui génère
10 millions de nombres aléatoires normalement distribués pour `X` et `Y`.
2. La fonction `[Link]` du module `numpy` est utilisée pour générer un tableau `T` de 100
valeurs également espacées entre -4 et 4. Ce tableau est utilisé pour tracer les courbes de
distribution normale.
3. La fonction `[Link]` du module `[Link]` est utilisée pour créer un graphique à
deux panneaux avec deux sous-plots, l'un au-dessus de l'autre.
4. Dans le premier sous-graphe (en haut), un histogramme des valeurs `X` est tracé en utilisant la
fonction `[Link]` avec le paramètre `density` fixé à `True` et le nombre de cases fixé à 30. L'option
`density=True` met à l'échelle l'histogramme de façon à ce que la surface totale des barres soit
égale à 1, le convertissant ainsi en une fonction de densité de probabilité. (Normaliser parce que la
surface est égale à 1)
(En Python, le terme "bins" fait généralement référence au nombre d'intervalles ou de partitions
utilisés pour regrouper les données dans un histogramme).
5. Une courbe de distribution normale est également tracée au-dessus de l'histogramme à l'aide de
la fonction `[Link]`, avec `T` sur l'axe des x et les valeurs de distribution normale correspondantes
(calculées à l'aide de la formule
`1/[Link](2*[Link])*[Link](-T**2/2)`) sur l'axe des y. Cette courbe est représentée en bleu.
6. Dans le second sous-graphe (en bas), un histogramme des valeurs `Y` est tracé à l'aide de la
fonction `[Link]` avec le paramètre `density` fixé à `True` et le nombre de bins fixé à 30.
7. Une autre courbe de distribution normale est tracée au-dessus du second histogramme à l'aide
de la fonction `[Link]`, avec `T` sur l'axe des x et les valeurs de distribution normale
correspondantes sur l'axe des y. Cette courbe est également représentée en bleu.
Le graphique résultant montre les valeurs `X` et `Y` normalement distribuées sous forme
d'histogrammes ainsi que les courbes de distribution normale théorique en bleu. Ce graphique peut
être utilisé pour visualiser la distribution des nombres aléatoires et la comparer à la distribution
normale théorique.
Partie 2 :
Question 1 :
Ce code Python définit une fonction `get_hotels_at_page` qui prend un seul argument `page_nbr`.
Le but de cette fonction est de rechercher sur le site [Link] des listes d'hôtels à Paris et de
renvoyer les listes sur la page spécifiée.
La fonction construit d'abord une URL basée sur l'argument du numéro de page, avec l'aide de
certains paramètres prédéfinis, tels que les critères de recherche, la plage de dates et l'agent
utilisateur. Elle envoie ensuite une requête HTTP GET à l'URL construite, en utilisant
`[Link]`, avec les en-têtes qui ont été définis précédemment.
Ensuite, le contenu HTML de la réponse est analysé en utilisant la bibliothèque `beautifulsoup4` pour
extraire les listes d'hôtels pertinentes de la page HTML. Les listes extraites sont retournées sous la
forme d'une liste d'objets BeautifulSoup `Tag`.
Enfin, la fonction écrit le contenu HTML dans un fichier à des fins de débogage et imprime un
message indiquant quelle page a été traitée.
Notez que la variable `directory` est définie au début du code et spécifie le chemin du répertoire où
les fichiers HTML seront sauvegardés. Notez également que la fonction `utils.default_headers()` n'est
pas définie dans le code et provient probablement d'un module ou d'une bibliothèque externe.
Question 3 :
Il s'agit d'une fonction Python nommée `extract_first_number` qui prend une chaîne de caractères
en entrée et tente d'en extraire le premier nombre. Voici ce que fait chaque ligne du code :
- `[Link]()` supprime tout espace blanc de début ou de fin de la chaîne d'entrée.
- Le bloc `try` tente d'extraire le premier nombre de la chaîne en utilisant une expression régulière.
- La fonction `search(r'\d+', string)` recherche la première occurrence d'un ou plusieurs chiffres
(`\d+`) dans la chaîne.
- La méthode `group(0)` renvoie la sous-chaîne correspondante (c'est-à-dire le premier
nombre) de la recherche par expression régulière.
- Si la recherche par expression régulière échoue (c'est-à-dire s'il n'y a pas de chiffres dans la
chaîne), le bloc `except` renvoie `None` à la place.
Questions 4 :
Globalement, la fonction extract_value_before_word peut être utilisée pour extraire des valeurs
numériques de chaînes de caractères contenant une description textuelle.
Cette fonction prend deux arguments : `full_str`, qui est la chaîne complète à partir de laquelle une
valeur doit être extraite, et `sub_str`, qui est le mot qui apparaît immédiatement après la valeur à
extraire.
La fonction commence par supprimer tout espace blanc de début ou de fin de `full_str`. Elle utilise
ensuite des expressions régulières pour rechercher dans `full_str` un motif correspondant à un
flottant ou un entier suivi de zéro ou plusieurs caractères d'espacement, suivi de `sub_str`. Si une
correspondance est trouvée, la fonction renvoie la valeur flottante ou entière sous forme de flottant.
Si aucune correspondance n'est trouvée, la fonction renvoie `None`. Si une erreur d'indexation
survient lors de la tentative de conversion de la valeur trouvée en flottant, la fonction renvoie
également `None`.
Question 5 :
La fonction `extract_distance` de Python prend une chaîne de caractères en entrée et tente d'en
extraire la valeur de la distance. Elle supprime d'abord les espaces blancs de la chaîne. Elle utilise
ensuite la fonction
La fonction `extract_value_before_word` permet d'extraire la valeur numérique précédant le mot
"m" ou "km". Si la distance est en mètres, elle divise la valeur par 1000 pour obtenir la distance en
kilomètres. Si la distance est exprimée en kilomètres, elle renvoie simplement la valeur extraite. Si
aucune valeur de distance ne peut être extraite de la chaîne, elle renvoie `None`.
Question 6 :
Première partie :
Ce code crée des listes vides pour stocker des informations sur les hôtels qui seront
récupérées sur le site [Link]. Il y a 9 listes au total : `names`, `links`, `districts`,
`distances`,
`étoiles`, `évaluations`, `prix`, `annulation` et `petit déjeuner`.
Ces listes seront alimentées en données plus tard, lorsque le code passera en revue les
listes d'hôtels sur chaque page du site Web. La liste `hotels` créée plus tôt dans le code
contiendra toutes les listes d'hôtels qui sont scrappées, et les données de chaque liste
seront extraites et stockées dans les listes correspondantes.
Partie 2 :
Il semble que le code que vous avez fourni récupère des informations sur les hôtels à partir d'un
site web et les stocke dans un dictionnaire. Les informations comprennent les noms des hôtels, les
liens vers les pages des hôtels, les quartiers dans lesquels ils sont situés, la distance par rapport au
centre-ville, le nombre d'étoiles, les évaluations des utilisateurs, les prix, les conditions
d'annulation et la disponibilité du petit-déjeuner. Le code parcourt les pages du site web et stocke
les informations relatives à chaque hôtel dans des listes distinctes avant de créer un dictionnaire.
Questions 7 :
Le code que vous avez fourni créera un fichier Excel nommé "[Link]" dans le répertoire qui a
été défini plus tôt dans l'exercice. Le fichier contiendra une seule feuille de calcul avec les données
de la liste `hotels` qui ont été récupérées et stockées dans un dictionnaire, puis converties en
DataFrame pandas, et enfin sauvegardées dans un fichier Excel en utilisant la méthode `to_excel`.
Une chose à noter est que vous devez importer la classe `Path` du module `pathlib` afin de créer un
fichier vide en utilisant la méthode `touch`. Donc la première ligne de votre code devrait être :
En supposant que la variable `directory` soit définie correctement, le code devrait fonctionner comme
prévu et créer un fichier Excel avec les données récupérées.
Question 8 :
La première ligne de ce code affecte à la variable "null" la valeur moyenne de la colonne "Prix par
nuit (euro)" dans le cadre de données "myDf", mais uniquement pour les lignes où la colonne "Nb.
étoiles" est égale à 0.
La première ligne de ce code affecte à la variable "nullstd" l'écart-type de la colonne "Prix par nuit
(euro)" dans le cadre de données "myDf", mais uniquement pour les lignes où la colonne "Nb. stars"
est égale à 0.
Création graphique :
Ce bloc de code semble créer une figure avec deux sous-graphes à l'aide de la bibliothèque Matplotlib.
Le premier sous-graphe est un camembert créé à partir des données du tableau 'myFreq', où
chaque coin représente la proportion d'hôtels de chaque arrondissement de Paris. Le tableau
explode est utilisé pour mettre en évidence certains coins en les retirant du centre du camembert.
Les étiquettes de chaque coin sont tirées du tableau 'idk'. Le paramètre shadow est fixé à True pour
ajouter un effet d'ombre au camembert. Le titre du premier sous-graphe est "Proportions d'hôtels
de tous les arrondissements parisiens disponibles sur le marché".
Le second sous-graphe est un tracé linéaire avec des barres d'erreur créé à partir des données des
tableaux "x" et "yy". L'axe des x représente le numéro du district et l'axe des y représente le prix
moyen par nuit (en euros) pour chaque district. Les points x et les étiquettes x sont définis à l'aide
du tableau 'idk2'. Le paramètre 'fmt' est fixé à 'none' pour supprimer la ligne reliant les barres
d'erreur. Les barres d'erreur sont colorées en gris à l'aide du paramètre "ecolor" et leur taille est
définie à l'aide des paramètres "capsize" et "capthick". Les points de données sont représentés par
des cercles violets dont la taille des marqueurs est fixée à 7. Le titre du deuxième sous-graphe est
"Prix moyens par nuit pour différents quartiers de Paris".
Enfin, la commande '[Link]()' est utilisée pour afficher la figure.
Question 9 :
Ce bloc de code utilise la bibliothèque SciPy pour calculer les scores z pour chaque catégorie d'hôtel
en fonction de leur prix par nuit.
La fonction "zscore" du module "[Link]" est appliquée à la colonne "Prix par nuit (euro)" dans
chaque groupe d'hôtels ayant le même nombre d'étoiles à l'aide de la méthode "groupby". Les scores
z résultants sont stockés dans une nouvelle colonne appelée "zscore" dans le cadre de données
"df_hot" en utilisant la méthode "transform" avec une fonction lambda.
Ensuite, le code identifie les valeurs aberrantes en sélectionnant les lignes de "df_hot" dont la
colonne "zscore" est supérieure à 3, et les stocke dans un nouveau cadre de données appelé
"outliers".
Le code calcule ensuite la note moyenne des hôtels dans le cadre de données "outliers" en utilisant
la méthode "mean" sur la colonne "Rating" et l'affecte à la variable "avg_rating_outliers".
Enfin, la note moyenne de tous les hôtels de la base de données "df_hot" est calculée à l'aide de la
méthode "mean" sur la colonne "Rating" et attribuée à la variable "avg_rating_all". Les évaluations
moyennes des valeurs aberrantes et de tous les hôtels sont imprimées à l'aide de la fonction "print".
Question 11 :
Ce bloc de code utilise la bibliothèque SciPy pour effectuer un test t d'échantillons indépendants entre
deux groupes de prix d'hôtels selon qu'ils offrent ou non l'annulation gratuite.
Tout d'abord, le code crée deux nouvelles variables, "prices_cancelled" et "prices_not_cancelled",
en sélectionnant la colonne "Prix par nuit (euro)" du cadre de données "df_hot" pour les hôtels qui
offrent une annulation gratuite et ceux qui ne l'offrent pas, respectivement.
La fonction 'ttest_ind' du module '[Link]' est ensuite utilisée pour effectuer le test t, avec
'prices_cancelled' et 'prices_not_cancelled' comme échantillons d'entrée.
La statistique t et la valeur p résultantes sont stockées dans les variables "t_statistic" et "p_value",
respectivement. Enfin, la statistique t et la valeur p sont imprimées à l'aide de la fonction "print".
Question 12 :
Premier semestre :
Ce code Python effectue un test t sur les prix par nuit pour chaque paire de districts dans un ensemble
de données.
`df_hot` contenant des informations sur les hôtels.
Les deux premières lignes de code sélectionnent les valeurs uniques dans la colonne "District" du
dataframe `df_hot` et suppriment les valeurs NaN. Les districts uniques sont triés par ordre croissant à
l'aide de la fonction numpy
Fonction `sort()`.
Le bloc de code suivant effectue un test t entre chaque paire de districts à l'aide d'une boucle for
imbriquée. Le bloc de code
La fonction `range()` de la première boucle `for` itère sur chaque district du tableau `districts`. La
boucle
La boucle `for` itère sur chaque district qui vient après le district actuel dans le tableau `districts`, en
comparant effectivement chaque district avec tous les autres districts.
Pour chaque paire de districts, le code sélectionne les prix par nuit pour chaque district en utilisant
la fonction pandas `.loc[]`, qui renvoie les lignes de `df_hot` où la colonne "District" correspond au
district actuel. La fonction `ttest_ind()` du module [Link] est ensuite utilisée pour calculer la
statistique t et la valeur p des deux ensembles de prix. Si la valeur p est inférieure à 0,05, le code
imprime un message indiquant qu'il existe une différence significative entre les prix des deux
districts, ainsi que la statistique t et la valeur p. Si la valeur p est supérieure ou égale à 0,05, le code
imprime un message indiquant qu'il n'y a pas de différence significative entre les prix des deux
districts, ainsi que la statistique t et la valeur p.
Partie 2 :
Ce code effectue un test t à deux échantillons entre les prix par nuit de chaque paire de districts dans
les données. La boucle for externe itère sur chaque district de la liste triée des districts. La boucle for
interne itère sur les districts restants, de sorte que chaque district n'est comparé à tous les autres
districts qu'une seule fois.
Pour chaque paire de districts, les prix par nuit sont extraits du DataFrame df_hot pour les districts
correspondants. Ensuite, la fonction ttest_ind de la bibliothèque [Link] est appelée pour
effectuer un test t à deux échantillons entre les prix des deux districts.
Si la valeur p du test t est inférieure à 0,05, les deux districts sont considérés comme ayant des prix
par nuit significativement différents, et le message de sortie indique qu'il existe une différence
significative entre les districts et imprime la statistique t et la valeur p. Dans le cas contraire, les deux
districts sont considérés comme ayant des prix similaires par nuit, et le message de sortie indique
qu'il n'y a pas de différence significative entre les districts et imprime la statistique t et la valeur p.
