CODE EXPLANATION PYTHON

Question 1 :

This Python code estimates the value of pi using Monte Carlo simulation. Here's how it works:

1. The code imports the `random` and `math` modules.

2. The variable `N` is set to 1000000, indicating the number of random points to generate.

3. The variable `count` is initialized to 0, and will be used to keep track of how many random points
fall inside a circle inscribed in a square.

4. The code enters a `for` loop that runs `N` times. On each iteration, it generates two random
numbers `x` and `y` using the `random.uniform(0,1)` function. These numbers are between 0 and 1
and represent the (x, y) coordinates of a point in the square.

5. The distance of this point from the origin is calculated using the `math.sqrt(x**2 + y**2)`
function. If this distance is less than 1, then the point is inside the inscribed circle.

6. If the point is inside the circle, the `count` variable is incremented by 1.

7. After the loop has finished, the approximation of pi is calculated using the formula `pi_estimate =
4 * count / N`. This formula uses the ratio of the number of points inside the circle to the total
number of points to estimate the area of the circle, which is proportional to pi. The factor of 4 comes
from the fact that the circle is inscribed in a square whose side length is 2, so its area is 4.

8. The approximation of pi is printed to the console using the `print` function.

The resulting value printed to the console is an approximation of pi based on the Monte Carlo
simulation. The accuracy of the approximation depends on the number of points generated, with a
larger number of points resulting in a more accurate estimate.

Question 2 :

This Python code defines a function `n(k)` which returns 10 to the power of `k`, and a function
`estimate_pi(k)` which generates `N = n(k)` random points and estimates pi by counting the number
of points that fall within a unit circle and dividing by the total number of points.

The code then generates a list of `k` values to use for the pi estimation and uses a list
comprehension to calculate the corresponding `pi` estimates using `estimate_pi(k)`.

Finally, the code plots the true value of pi (imported from the math module), as well as the
approximate pi estimates for each `k` value using `matplotlib.pyplot.plot`. The x-axis is the value of
`k`, and the y-axis is the value of pi. The plot shows how the accuracy of the pi estimate improves as
`k` increases, with the approximate values of pi converging towards the true value of pi.

Question 3
This code defines a function named `gaussian_dis` that takes a single integer argument `n`. The
function generates `n` pairs of random numbers that are distributed according to the 2D Gaussian
(normal) distribution.

Here's how the function works:

1. First, the function uses the `random` function from the `numpy.random` module (which is
imported with the alias `npr`) to generate two arrays of `n` random numbers between 0 and 1. These
arrays are stored in the variables `U_1` and `U_2`. (u_1 and u_2 are independant)

2. The function then applies some mathematical transformations to these random numbers to
generate pairs of random numbers with a Gaussian distribution.

Specifically, the function uses the inverse transform method, which involves taking two uniformly
distributed random numbers, transforming them using a set of mathematical functions, and
obtaining a pair of normally distributed random numbers.

3. The mathematical transformations used in this function involve the following steps:

a. The function calculates the square root of the negative logarithm of `U_1`, which gives a value
distributed according to a chi-squared distribution with 2 degrees of freedom.

b. The function generates a random angle `teta` between 0 and 2π using `U_2`.

c. The function calculates the `X` and `Y` coordinates of a point with a distance of `R` from the
origin and an angle of `teta` using the trigonometric functions `cos` and `sin`.

4. Finally, the function returns a tuple of two arrays `X` and `Y`, each containing `n` random numbers
that are normally distributed with a mean of 0 and a standard deviation of 1.

Note that this implementation relies on the `numpy` module, as well as the `numpy.random`
submodule, so you need to have these packages installed and imported before you can use this
function.
Question 4:
This code generates `X` and `Y` coordinates for a set of 10 million points that are normally
distributed using the `gaussian_dis` function, and then creates a two-panel histogram plot of the
resulting data.

Here's how the code works:

1. The `X` and `Y` variables are assigned the values returned by the `gaussian_dis` function when
called with the argument `int(10e6)`. `int(10e6)` evaluates to 10,000,000, so this generates 10
million normally distributed random numbers for both `X` and `Y`.

2. The `np.linspace` function from the `numpy` module is used to generate an array `T` of 100
equally spaced values between -4 and 4. This array is used to plot the normal distribution curves.

3. The `plt.subplot` function from the `matplotlib.pyplot` module is used to create a two-panel plot
with two subplots, one above the other.

4. In the first subplot (at the top), a histogram of the `X` values is plotted using `plt.hist` function
with the `density` parameter set to `True` and the number of bins set to 30. The `density=True`
option scales the histogram so that the total area of the bars sums to 1, effectively converting it into
a probability density function. (Normalize because surface area equals to 1)

(bins fonction does this, In Python, the term "bins" usually refers to the number of intervals or
partitions that are used to group data in a histogram.)

5. A normal distribution curve is also plotted on top of the histogram using the `plt.plot` function,
with `T` on the x-axis and the corresponding normal distribution values (calculated using the formula
`1/np.sqrt(2*np.pi)*np.exp(-T**2/2)`) on the y-axis. This curve is shown in blue color.

6. In the second subplot (at the bottom), a histogram of the `Y` values is plotted using `plt.hist`
function with the `density` parameter set to `True` and the number of bins set to 30.

7. Another normal distribution curve is plotted on top of the second histogram using the `plt.plot`
function, with `T` on the x-axis and the corresponding normal distribution values on the y-axis. This
curve is also shown in blue color.

The resulting plot shows the normally distributed `X` and `Y` values as histograms along with the
theoretical normal distribution curves in blue. This plot can be used to visualize the distribution of
the random numbers and compare it to the theoretical normal distribution.
Part 2:
Question 1:

This Python code defines a function `get_hotels_at_page` that takes a single argument `page_nbr`.
The purpose of the function is to scrape the Booking.com website for hotel listings in Paris and
return the listings on the specified page.

e function first constructs a URL based on the page number argument, with the help of some pre-
defined parameters, such as search criteria, date range, and user agent. It then sends an HTTP GET
request to the constructed URL, using `requests.get`, with the headers that were defined earlier.

Next, the HTML content of the response is parsed using the `beautifulsoup4` library to extract the
relevant hotel listings from the HTML page. The extracted listings are returned as a list of
BeautifulSoup `Tag` objects.

Finally, the function writes the HTML content to a file for debugging purposes and prints a message
indicating which page has been processed.

Note that the variable `directory` is defined at the beginning of the code and specifies the directory
path where the HTML files will be saved. Also note that the `utils.default_headers()` function is not
defined in the code and likely comes from an external module or library.

Question 3 :
This is a Python function named `extract_first_number` that takes a string as input and attempts to
extract the first number from it. Here is what each line of the code does:

- `string.strip()` removes any leading or trailing whitespace from the input string.

- The `try` block attempts to extract the first number from the string using a regular expression.

- The `search(r'\d+', string)` function looks for the first occurrence of one or more digits (`\d+`) in the
string.

- The `group(0)` method returns the matched substring (i.e., the first number) from the regular
expression search.

- If the regular expression search fails (i.e., there are no numbers in the string), the `except` block
returns `None` instead.
Questions 4:

Overall, the extract_value_before_word function can be used to extract numerical values from
strings that contain some text description.

This function takes in two arguments: `full_str`, which is the full string from which a value needs to
be extracted, and `sub_str`, which is the word that appears immediately after the value to be
extracted.

The function first strips any leading or trailing whitespace from `full_str`. It then uses regular
expressions to search for a pattern in `full_str` that matches a float or an integer followed by zero or
more whitespace characters, followed by `sub_str`. If a match is found, the function returns the float
or integer value as a float.

If no match is found, the function returns `None`. If an index error occurs while attempting to
convert the matched value to a float, the function also returns `None`.

Question 5 :

The `extract_distance` function in Python takes a string as input and tries to extract the distance
value from it. It first strips any leading or trailing whitespaces from the string. It then uses the
`extract_value_before_word` function to extract the numerical value before the word "m" or "km".
If the distance is in meters, it divides the value by 1000 to get the distance in kilometers. If the
distance is in kilometers, it simply returns the extracted value. If no distance value can be extracted
from the string, it returns `None`.

Question 6:

Part 1:

This code creates empty lists to store information about hotels that will be scraped from the
Booking.com website. There are 9 lists in total: `names`, `links`, `districts`, `distances`,
`stars`, `ratings`, `prices`, `cancellation`, and `breakfast`.

These lists will be populated with data later on as the code loops through the hotel listings
on each page of the website. The `hotels` list created earlier in the code will contain all of
the hotel listings that are scraped, and the data from each listing will be extracted and
stored in the corresponding lists.

Part 2:

It looks like the code you provided scrapes hotel information from a website and stores it in a
dictionary. The information includes the hotel names, links to the hotel pages, the districts they are
located in, the distance to the city center, the star ratings, the user ratings, the prices, the
cancellation policy, and the availability of breakfast. The code loops through the pages of the
website and stores the information for each hotel in separate lists before creating a dictionary.
Questions 7 :
The code you provided will create an Excel file named "Klinkert.xlsx" in the directory that was
defined earlier in the exercise. The file will contain a single worksheet with the data from the `hotels`
list that was scraped and stored in a dictionary, then converted to a pandas DataFrame, and finally
saved to an Excel file using the `to_excel` method.

One thing to note is that you need to import the `Path` class from the `pathlib` module in order to
create an empty file using the `touch` method. So the first line of your code should be:

Assuming that the `directory` variable is defined correctly, the code should work as expected and
create an Excel file with the scraped data.

Question 8 :

The first line of this code is assigning the mean value of the 'Price per night (euro)' column in 'myDf'
dataframe, but only for rows where the 'Nb. stars' column is equal to 0, to the variable 'null'.

The first line of this code is assigning the standard deviation of the 'Price per night (euro)' column in
'myDf' dataframe, but only for rows where the 'Nb. stars' column is equal to 0, to the variable
'nullstd'.

Graphic creation :

This code block appears to be creating a figure with two subplots using Matplotlib library.

The first subplot is a pie chart created using the data in 'myFreq' array, where each wedge
represents the proportion of hotels from each district in Paris. The explode array is used to highlight
certain wedges by pulling them out from the center of the pie chart. The labels for each wedge are
taken from the 'idk' array. The shadow parameter is set to True to add shadow effect to the pie
chart. The title for the first subplot is set to 'Proportions of hotels from all Parisian districts available
on the market'.

The second subplot is a line plot with error bars created using the data in 'x' and 'yy' arrays. The x-
axis represents the district number and the y-axis represents the average price per night (in euros)
for each district. The x-ticks and x-labels are set using the 'idk2' array. The 'fmt' parameter is set to
'none' to remove the line connecting the error bars. The error bars are colored in grey using the
'ecolor' parameter, and their size is set using the 'capsize' and 'capthick' parameters. The data points
are represented using purple circles with markersize set to 7. The title for the second subplot is set
to 'Average prices per night for different Parisian districts'.

Finally, the 'plt.show()' command is used to display the figure.

This code block is using the SciPy library to calculate the z-scores for each category of hotel with
respect to their price per night.

The 'zscore' function from the 'scipy.stats' module is applied to the 'Price per night (euro)' column in
each group of hotels with the same number of stars using the 'groupby' method. The resulting z-
scores are stored in a new column called 'zscore' in the 'df_hot' dataframe using the 'transform'
method with a lambda function.

Next, the code identifies the outliers by selecting the rows in 'df_hot' where the 'zscore' column is
greater than 3, and stores them in a new dataframe called 'outliers'.

The code then calculates the average rating for the hotels in the 'outliers' dataframe using the
'mean' method on the 'Rating' column, and assigns it to the variable 'avg_rating_outliers'.

Finally, the average rating for all hotels in the 'df_hot' dataframe is calculated using the 'mean'
method on the 'Rating' column, and assigned to the variable 'avg_rating_all'. The average ratings for
outliers and all hotels are printed using the 'print' function.

Question 11 :

This code block is using the SciPy library to perform an independent samples t-test between two
groups of hotel prices based on whether or not they offer free cancellation.

First, the code is creating two new variables, 'prices_cancelled' and 'prices_not_cancelled', by
selecting the 'Price per night (euro)' column of the 'df_hot' dataframe for hotels that offer free
cancellation and those that do not, respectively.

The 'ttest_ind' function from the 'scipy.stats' module is then used to perform the t-test, with
'prices_cancelled' and 'prices_not_cancelled' as the input samples.

The resulting t-statistic and p-value are stored in the 't_statistic' and 'p_value' variables, respectively.

Finally, the t-statistic and p-value are printed using the 'print' function.

Question 12:
First half :

This Python code performs a t-test on the prices per night for each pair of districts in a dataset
`df_hot` containing information about hotels.

The first two lines of code select the unique values in the "District" column of the `df_hot` dataframe
and remove any NaN values. The unique districts are sorted in ascending order using numpy's
`sort()` function.
The next block of code performs a t-test between each pair of districts using a nested for loop. The
`range()` function in the first `for` loop iterates over each district in the `districts` array. The inner
`for` loop iterates over each district that comes after the current district in the `districts` array,
effectively comparing each district with every other district.

For each pair of districts, the code selects the prices per night for each district using pandas' `.loc[]`
function, which returns the rows of `df_hot` where the "District" column matches the current
district. The `ttest_ind()` function from the scipy.stats module is then used to calculate the t-statistic
and p-value of the two sets of prices. If the p-value is less than 0.05, the code prints a message
indicating that there is a significant difference between the two districts' prices, along with the t-
statistic and p-value. If the p-value is greater than or equal to 0.05, the code prints a message
indicating that there is not a significant difference between the two districts' prices, along with the t-
statistic and p-value.

Part 2:

This code performs a two-sample t-test between the prices per night of each pair of districts in the
data. The outer for-loop iterates over each district in the sorted list of districts. The inner for-loop
iterates over the remaining districts, so that each district is compared with every other district only
once.

For each pair of districts, the prices per night are extracted from the DataFrame df_hot for the
corresponding districts. Then, the ttest_ind function from the scipy.stats library is called to perform
a two-sample t-test between the prices for the two districts.

If the p-value of the t-test is less than 0.05, then the two districts are considered to have significantly
different prices per night, and the output message states that there is a significant difference
between the districts and prints the t-statistic and p-value. Otherwise, the two districts are
considered to have similar prices per night, and the output message states that there is not a
significant difference between the districts and prints the t-statistic and p-value.