TABLE OF CONTENTS

1 PREFACE 2
2 INTRODUCTION 3

3 UNIVARIATE ANALYSIS 4

4 BIVARIATE ANALYSIS 17
5 MULTIVARIATE ANALYSIS 22
6 CONCLUSION 25

1|Page
 PREFACE

The dataset, a comprehensive collection of corporate bond data designed to provide insights
into the dynamics of the corporate bond market. This dataset is a valuable resource for
researchers, analysts, and investors seeking to understand and analyze trends, patterns, and
risk factors within the corporate bond space. Corporate bonds play a crucial role in the global
financial market, serving as a primary source of funding for corporations seeking capital to
finance various operations, expansions, and projects. Understanding the intricacies of
corporate bonds is essential for investors looking to make informed decisions and manage
their investment portfolios effectively. The dataset offers a diverse range of information,
including bond characteristics, issuer details, credit ratings, yield curves, trading volumes,
and market liquidity metrics. With data spanning multiple years and encompassing various
sectors and regions, users can explore the dynamics of corporate bonds across different
market conditions and economic environments. Whether you're a seasoned financial analyst
conducting in-depth research or a novice investor looking to gain insights into corporate bond
investments, the dataset provides a wealth of information to support your endeavors. By
leveraging this dataset, users can uncover valuable insights, identify investment
opportunities, and mitigate risks within the corporate bond market. The dataset offers a
comprehensive collection of corporate bond data essential for understanding and analyzing
the dynamics of the corporate bond market. It encompasses a wide range of information,
including bond characteristics such as maturity date, coupon rate, and type of bond, as well as
issuer details such as company names, industries, and credit ratings. Additionally, the dataset
provides yield curve data, trading volumes, and market liquidity metrics, enabling users to
gauge market conditions and investor sentiment. With historical performance data, sector and
regional breakdowns, and risk factor analysis, the dataset empowers researchers, analysts,
and investors to make informed decisions and gain insights into corporate bond investments.

2|Page
 INTRODUCTION

The Restaurant Dataset presents a comprehensive collection of attributes pertaining to

customer dining experiences at a restaurant establishment. The dataset encompasses key
variables such as the total bill, tip amount, customer gender (classified as male or female),
smoking preferences (categorized as smoker or non-smoker), the day of the week of the
dining occasion, the timing of the meal (either lunch or dinner), and the size of the dining
party. This dataset offers a rich source of information for exploring customer spending
patterns, tipping behaviors, demographic distributions, and dining preferences. Such insights
hold significant potential for informing restaurant management strategies, enhancing
customer service, and refining marketing approaches to better cater to diverse clientele. The
Restaurant Dataset represents a comprehensive compilation of attributes centered around the
dynamics of dining experiences within a restaurant setting. Encompassing a diverse range of
variables, this dataset offers a nuanced glimpse into customer interactions with the
establishment. At its core, the dataset features essential metrics such as the total bill, tip
amount, and demographic indicators including customer gender and smoking preferences.
Additionally, it provides insights into contextual factors such as the day of the week and time
of day of dining, along with the size of dining parties. This rich tapestry of data presents an
invaluable opportunity to delve into various facets of consumer behavior, tipping customs,
and dining preferences, shedding light on nuanced patterns and trends within the restaurant
industry. As such, this dataset serves as a valuable resource for restaurant managers, analysts,
and researchers alike, offering the potential to inform strategic decision-making, refine
service offerings, and tailor marketing initiatives to better resonate with diverse customer
segments.

3|Page
UNIVARIATE ANALYSIS

FEATURE DETAILS:
The Restaurant Dataset comprises data collected from a restaurant, focusing on various
attributes related to customer bills and dining preferences. These attributes include:

1. Total Bill: The total amount paid by customers, including the cost of food, beverages,
and any additional charges.
2. Tip: The gratuity amount left by customers as a percentage of the total bill.
3. Sex: The gender of the customer, categorized as either male or female.
4. Smoker: A binary attribute indicating whether the customer is a smoker or a non-
smoker.
5. Day: The day of the week when the dining occurred, categorized into specific
weekdays.
6. Time: The time of day when the dining took place, typically categorized as either
lunch or dinner service.
7. Size: The size of the dining party, representing the number of individuals included in
the bill.

EXPLORING CATEGORAL DATA COLUMNS:

COUNT PLOT():

4|Page
EXPLANATION:
The code snippet appears to be using the Seaborn library to create a count plot based on the
'sex' column in a DataFrame named 'df'. Let's break down the code step by step:
1. sns.countplot(x='sex', data=df): This line of code creates a count plot using
Seaborn's countplot function. It specifies that the 'sex' column from the DataFrame
'df' should be plotted on the x-axis.
2. plt.label('Sex'): This line of code seems to have a typo. It should be plt.xlabel('Sex').
This line sets the label for the x-axis of the plot.
3. plt.ylabel("Count'): Similar to the previous line, this seems to have a typo. It should
be plt.ylabel('Count'). This line sets the label for the y-axis of the plot. It adds the
text 'Count' as the label for the y-axis, indicating that the plotted values represent
counts.
4. plt.show(): This line of code displays the plot. After creating the plot and setting the
labels for the axes, calling plt.show() is necessary to render the plot and display it to
the user.

EXPLANATION:
This code snippet utilizes Seaborn's countplot function to create a count plot based on the
'size' column in a DataFrame named 'df'. Let's break down the code:
1. sns.countplot(x='size', data=df): This line of code creates a count plot using
Seaborn's countplot function. It specifies that the 'size' column from the DataFrame
'df' should be plotted on the x-axis.
2. plt.xlabel('Size'): This line of code sets the label for the x-axis of the plot. It adds the
text 'Size' as the label for the x-axis, indicating what the plotted data represents.

5|Page
 3. plt.ylabel('Count'): This line of code sets the label for the y-axis of the plot. It adds
the text 'Count' as the label for the y-axis, indicating that the plotted values represent
counts.
4. plt.show(): This line of code displays the plot. After creating the plot and setting the
labels for the axes, calling plt.show() is necessary to render the plot and display it to
the user.

EXPLANATION:
This code snippet utilizes Seaborn's `countplot` function to create a count plot based on the
'day' column in a DataFrame named 'df'. Let's break down the code:
1. `sns.countplot(x='day', data=df)`: This line of code creates a count plot using Seaborn's
`countplot` function.
2. `plt.xlabel('Day')`: This line of code sets the label for the x-axis of the plot. It adds the text
'Day' as the label for the x-axis, indicating what the plotted data represents.
3. `plt.ylabel('Count')`: This line of code sets the label for the y-axis of the plot. It adds the
text 'Count' as the label for the y-axis, indicating that the plotted values represent counts.

6|Page
EXPLANATION:
1. sns.countplot(x='time', data=df): This line creates a count plot using Seaborn's
countplot function. It specifies that the 'time' column from the DataFrame 'df' should
be plotted on the x-axis.
2. plt.xlabel('Time'): This line sets the label for the x-axis of the plot. It adds the text
'Time' as the label for the x-axis, indicating what the plotted data represents (likely
different time intervals or categories).
3. plt.ylabel('Count'): This line sets the label for the y-axis of the plot. It adds the text
'Count' as the label for the y-axis, indicating that the plotted values represent counts of
occurrence.
This code snippet creates a count plot of the 'time' column from the DataFrame 'df', labels the
x-axis as 'Time', labels the y-axis as 'Count', and then displays the plot.

7|Page
EXPLANATION:
1. sns.countplot(x='smoker', data=df): This line creates a count plot using Seaborn's
countplot function. It specifies that the 'smoker' column from the DataFrame 'df'
should be plotted on the x-axis.
2. plt.xlabel('smoker'): This line sets the label for the x-axis of the plot. It adds the text
'smoker' as the label for the x-axis, indicating what the plotted data represents (likely
whether individuals are smokers or non-smokers).
3. plt.ylabel('Count'): This line sets the label for the y-axis of the plot. It adds the text
'Count' as the label for the y-axis, indicating that the plotted values represent counts of
occurrences.
This code snippet creates a count plot of the 'smoker' column from the DataFrame 'df', labels
the x-axis as 'smoker', labels the y-axis as 'Count', and then displays the plot.

8|Page
PIECHARTS():

EXPLANATION:
1. df['sex'].value_counts(): This part calculates the counts of unique values in the 'sex'
column of the DataFrame 'df'. It returns a Series object where the index consists of
unique values in the 'sex' column, and the values are their respective counts.
2. .plot(kind='pie', autopct='%.2f'): This part creates a pie chart using the plot
function. By specifying kind='pie', you indicate that you want to create a pie chart.
The autopct='%.2f' argument adds percentage labels to each wedge of the pie chart,
showing the proportion of each category rounded to two decimal places.
The code creates a pie chart based on the counts of unique values in the 'sex' column of your
DataFrame 'df'. Each wedge of the pie chart represents the proportion of each category ('male'
and 'female') in the 'sex' column, and the percentage labels indicate these proportions.

9|Page
EXPLANATION:
1. df['size'].value_counts(): This part calculates the counts of unique values in the 'size'
column of the DataFrame 'df'. It returns a Series object where the index consists of
unique values in the 'size' column, and the values are their respective counts.
2. .plot(kind='pie', autopct='%.2f'): This part creates a pie chart using the plot
function. By specifying kind='pie', you indicate that you want to create a pie chart.
The autopct='%.2f' argument adds percentage labels to each wedge of the pie chart,
showing the proportion of each category rounded to two decimal places.
3. ‹Axes: ylabel='count'>: It seems like this part of the code snippet might be a display
of the axes object after plotting. This might be shown in your Python environment
after executing the code, indicating that the plot was created successfully.
The code creates a pie chart based on the counts of unique values in the 'size' column of your
DataFrame 'df'. Each wedge of the pie chart represents the proportion of each category in the
'size' column, and the percentage labels indicate these proportions.

EXPLANATION:
1. df['smoker'].value_counts(): This part calculates the counts of unique values in the
'smoker' column of the DataFrame 'df'.
2. .plot(kind='pie', autopct='%.2f'): This part creates a pie chart using the plot
function. By specifying kind='pie', you indicate that you want to create a pie chart.
The autopct='%.2f' argument adds percentage labels to each wedge of the pie chart.
3. [12]: ‹Axes: ylabel=' count' ›: It seems like this part of the code snippet might be a
display of the axes object after plotting. This might be shown in your Python
environment after executing the code, indicating that the plot was created
successfully.

10 | P a g e
The corrected code creates a pie chart based on the counts of unique values in the 'smoker'
column of your DataFrame 'df'. Each wedge of the pie chart represents the proportion of each
category ('yes' or 'no') in the 'smoker' column, and the percentage labels indicate these
proportions.

EXPLANATION:
1. df['day'].value_counts(): This part calculates the counts of unique values in the 'day'
column of the DataFrame 'df'. It returns a Series object where the index consists of
unique values in the 'day' column, and the values are their respective counts.
2. .plot(kind='pie', autopct='%.2f'): This part creates a pie chart using the plot
function. By specifying kind='pie', you indicate that you want to create a pie chart.
The autopct='%.2f' argument adds percentage labels to each wedge of the pie chart.
3. ‹Axes: ylabel='count' ›: It seems like this part of the code snippet might be a display
of the axes object after plotting.
The code creates a pie chart based on the counts of unique values in the 'day' column of your
DataFrame 'df'. Each wedge of the pie chart represents the proportion of each category.

11 | P a g e
EXPLANATION:
1. df['time'].value_counts(): This part calculates the counts of unique values in the
'time' column of the DataFrame 'df'.
2. .plot(kind='pie', autopct='%.2f'): This part creates a pie chart using the plot
function. By specifying kind='pie', you indicate that you want to create a pie chart.
The autopct='%.2f' argument adds percentage labels to each wedge of the pie chart.
3. [14]: ‹Axes: ylabel=' count '>: It seems like this part of the code snippet might be a
display of the axes object after plotting. This might be shown in your Python
environment after executing the code, indicating that the plot was created
successfully.
The code creates a pie chart based on the counts of unique values in the 'time' column of your
DataFrame 'df'. Each wedge of the pie chart represents the proportion of each category (e.g.,
breakfast, lunch, dinner) in the 'time' column, and the percentage labels indicate these
proportions.

Exploring Numerical Data Columns:

Histogram():

The code successfully creates a histogram of the 'total_bill' column with 30 bins
1. import matplotlib.pyplot as plt: This line imports the matplotlib.pyplot module and
aliases it as plt, allowing us to use the functions and classes provided by Matplotlib
for plotting.
2. plt.hist(df['total_bill'], bins=30): This line creates a histogram of the 'total_bill'
column from the DataFrame 'df'. It specifies bins=30, indicating that the data should
be divided into 30 equally spaced bins. The hist() function then calculates the
frequency of values falling into each bin and visualizes it as a histogram.

12 | P a g e
 This code is creating a histogram using Matplotlib
1. import matplotlib.pyplot as plt: This line imports the Matplotlib library and aliases
it as plt for easier usage.
2. plt.hist(df['tip'], bins=12): This line generates a histogram plot of the 'tip' column
from the DataFrame df. The plt.hist() function computes and draws the histogram of
the data.
3. The output you provided is the result of running the plt.hist() function.
The histogram is showing the distribution of tip amounts, divided into 12 bins. The frequency
of tip amounts falling into each bin is represented by the height of the bars in the histogram.

DistPlot( KDE Plot):

13 | P a g e
The plot generated using `sns.distplot(df['tip'])` is a distribution plot (distplot). It combines a
histogram of the data with a kernel density estimate (KDE) curve, providing an overall view
of the data's distribution. The histogram displays the frequency distribution of tip amounts,
while the KDE curve provides a smoothed estimate of the probability density function of the
data.
1. In essence, the plot visually represents the distribution of tip amounts in the
DataFrame `df`, showing how the tips are spread across different values. The x-
axis typically represents the tip amounts, and the y-axis represents the density or
frequency of those tip amounts.

The code is using the deprecated distplot() function from the Seaborn library to create a
distribution plot (distplot) of the 'total_bill' column from the DataFrame df. Despite being
deprecated, the function still generates the plot. The plot shows the frequency distribution of
total bill amounts using a histogram, which visualizes how the data is spread across different
values.
Additionally, it includes a kernel density estimate (KDE) curve, providing a smoothed
estimate of the probability density function of the data. This curve offers insights into the
overall shape and distribution of the total bill amounts.

14 | P a g e
Boxplot():

1. sns.boxplot(df['tip']): This line generates a box plot of the 'tip' column from the
DataFrame df. A box plot provides a graphical summary of the distribution of
numerical data through quartiles.
2. plt.xlabel('Tip') and plt.ylabel('Value'): These lines add labels to the x-axis and y-
axis of the plot, respectively. They provide context to the viewer about what each axis
represents.
3. plt.show(): This line displays the plot. It's essential to include this line to visualize the
plot in Jupyter Notebook or other environments.
The code provided is creating a box plot using Seaborn's boxplot() function to visualize the
distribution of the 'tip' column from the DataFrame df.

15 | P a g e
The provided code generates a box plot using Seaborn's `boxplot()` function to visualize the
distribution of the 'total_bill' column from the DataFrame `df`. Here's a breakdown:
1. `sns.boxplot(df['total_bill'])`: This line creates a box plot of the 'total_bill' column
from the DataFrame `df`. A box plot summarizes the distribution of numerical data
using quartiles. It displays the minimum, first quartile (Q1), median (second quartile
or Q2), third quartile (Q3), and maximum of the dataset. It also identifies any outliers
beyond the whiskers of the plot.
2. ‘plt.xlabel('Bill')` and `plt.ylabel('Value')`: These lines add labels to the x-axis and y-
axis of the plot, respectively. The label 'Bill' is added to the x-axis to indicate that the
data represents bill amounts, and the label 'Value' is added to the y-axis to indicate the
values of the 'total_bill' column.
3. `plt.show()`: This line displays the plot. It's necessary to include this line to visualize
the plot in Jupyter Notebook or other environments.

16 | P a g e
 BIVARIATE ANALYSIS

1. Bar Plot (Numerical – Categorical):

The provided code creates a bar plot using Seaborn's `barplot()` function to visualize the
relationship between the 'day' and 'tip' columns from the DataFrame `df`, with further
differentiation based on the 'sex' column. Here's a breakdown:
1. `sns.barplot(x='day', y='tip', hue='sex', data=df)`: This line generates a bar plot where the
x-axis represents the days ('day' column), the y-axis represents the tip amounts ('tip' column),
and the hue parameter further categorizes the data based on the 'sex' column.
2. `plt.xlabel('Day')` and `plt.ylabel('Tip')`: These lines add labels to the x-axis ('Day') and y-
axis ('Tip') of the plot, respectively. This provides clarity about the variables being
represented.

17 | P a g e
 1. sns.barplot(x='day', y='total_bill', hue='sex', data=df): This line generates a bar
plot where the x-axis represents the days ('day' column), the y-axis represents the total
bill amounts ('total_bill' column).
2. plt.xlabel('Day') and plt.ylabel('Tip'): These lines add labels to the x-axis ('Day')
and y-axis ('Tip') of the plot, respectively.
3. plt.show(): This line displays the plot. It's essential for visualizing the plot in Jupyter
Notebook or other environments.
The code creates a bar plot to visualize the average total bill amounts per day, with further
differentiation based on gender. It then adds labels to the axes for clarity, although the y-axis
label is incorrect, and finally displays the plot.

2. Box Plot (Numerical – Categorical):

18 | P a g e
This code generates a box plot using Seaborn's boxplot() function to illustrate the distribution
of tips ('tip') across different days ('day'), categorized by gender ('sex').
1. sns.boxplot(x='sex', y='tip', hue='day', data=df): This line creates a box plot where
the x-axis represents gender ('sex'), the y-axis represents tip amounts ('tip'), and the
hue parameter further divides the data by days ('day').
2. plt.xlabel('Sex') and plt.ylabel('Tip'): These lines add labels to the x-axis ('Sex') and
y-axis ('Tip') of the plot, respectively. They provide clarity about the variables being
represented.
3. plt.show(): This line displays the plot. It's necessary to include this line to visualize
the plot in Jupyter Notebook or other environments.

4. Distplot (Numerical - Categorical):

The provided code uses Seaborn's `distplot()` function to create two density plots, one for
males and one for females, showing the distribution of tip amounts. Here's an explanation:
1. Density Plot for Males: The code filters the DataFrame `df` to select only the tip values
where the 'sex' is 'Male'. It then creates a density plot (KDE curve) for these tip values,
setting the color to blue and shading the area under the curve for better visualization.
2. Density Plot for Females: Similarly, the code filters the DataFrame `df` to select only the
tip values where the 'sex' is 'Female'.

19 | P a g e
3. Axis Labels: Labels are added to the x-axis ('Tip') and y-axis ('Density') to provide context
for the plotted data.

5. HeatMap (Categorical - Categorical):

The code provided generates a heatmap using Seaborn's heatmap() function to visualize the
relationship between the 'sex' and 'day' columns of the DataFrame df. Let's break it down:
1. pd.crosstab(df['sex'], df['day']): This part of the code creates a contingency table
(cross-tabulation) using Pandas' crosstab() function. It counts the occurrences of
different combinations of categories in the 'sex' and 'day' columns of the DataFrame
df.
2. sns.heatmap(): The heatmap displays the values from the contingency table as colors.
Higher values are represented by darker colors, while lower values are represented by
lighter colors.
3. Axes Labels: The x-axis label is set to 'day', and the y-axis label is set to 'sex',
indicating the variables represented on each axis.
4. Displaying the Plot: Finally, the plot is displayed, showing the heatmap representing
the frequency distribution of genders across different days.

20 | P a g e
 5. ClusterMap (Categorical - Categorical):

The code provided generates a clustermap using Seaborn's clustermap() function to visualize
the relationship between the 'sex' and 'day' columns of the DataFrame df. Here's an
explanation:
1. pd.crosstab(df['sex'], df['day']): This part of the code creates a contingency table
(cross-tabulation) using Pandas' crosstab() function, similar to before. It counts the
occurrences of different combinations of categories in the 'sex' and 'day' columns of
the DataFrame df.
2. sns.clustermap(crosstab, figsize=(5, 5)): The figsize=(5, 5) parameter sets the
dimensions of the clustermap to a width and height of 5 inches each. The clustermap
arranges the rows and columns of the contingency table based on similarities in their
values, clustering similar rows and columns together.
3. Displaying the Plot: Finally, the plot is displayed, showing the clustermap
representing the frequency distribution of genders across different days. Similar days
and genders are clustered together based on their frequency distribution, providing
insights into any underlying patterns or relationships in the data.

21 | P a g e
 MULTIVARIATE ANALYSIS

Scatter Plot:

The provided code generates a scatter plot using Seaborn's scatterplot() function to visualize
the relationship between the 'total_bill' and 'tip' columns of the DataFrame df. Here's an
explanation:
1. sns.scatterplot(x=df["total_bill"], y=df['tip']): This line of code creates a scatter
plot where the x-axis represents the 'total_bill' column and the y-axis represents the
'tip' column from the DataFrame df. Each point on the plot represents an observation
in the dataset, with the x-coordinate indicating the total bill amount and the y-
coordinate indicating the tip amount.
2. plt.show(): This line displays the plot. It's essential for visualizing the plot in Jupyter
Notebook or other environments.

22 | P a g e
The provided code creates a scatter plot using Seaborn's scatterplot() function to visualize
the relationship between the 'total_bill' (x-axis) and 'tip' (y-axis) columns from the DataFrame
df. Additionally, it adds color differentiation based on the 'sex' column. Here's the
breakdown:
1. sns.scatterplot(x=df['total_bill'], y=df['tip'], hue=df['sex']): The x-axis represents
the 'total_bill' column. The y-axis represents the 'tip' column. The 'hue' parameter
differentiates the data points based on the 'sex' column. This means that points
corresponding to different genders will be colored differently on the plot.
2. plt.show(): This line displays the plot. It's necessary for visualizing the plot in Jupyter
Notebook or other environments.

23 | P a g e
The provided code utilizes Seaborn's scatterplot() function to create a scatter plot visualizing
the relationship between the 'total_bill' (x-axis) and 'tip' (y-axis) columns from the DataFrame
df.
1. sns.scatterplot(x=df['total_bill'], y=df['tip'], hue=df['sex'], style=df['smoker'],
size=df['size']): The 'hue' parameter differentiates the data points based on the 'sex'
column. This means that points corresponding to different genders will be colored
differently on the plot. The 'style' parameter further differentiates the data points based
on the 'smoker' column. The 'size' parameter sets the size of the data points based on
the 'size' column.
2. plt.show(): This line displays the plot. It's essential for visualizing the plot in Jupyter
Notebook or other environments.

24 | P a g e
 CONCLUSION
Based on the analysis of the tips dataset, which contains information about various aspects of
restaurant bills and tips, several key insights can be drawn: Relationship Between Total Bill
and Tip Amount: Through exploratory data analysis (EDA), it was observed that there is a
positive correlation between the total bill amount and the tip amount. As the total bill
increases, the tip amount also tends to increase, indicating that customers generally tip
proportionally to the total bill. Effect of Gender on Tipping Behavior: Analysis revealed
differences in tipping behavior between genders. While further investigation is warranted,
initial observations suggest that there may be gender-related patterns in tipping habits, with
one gender tipping more or less than the other. Impact of Day of the Week on Tipping:
Examination of tipping patterns across different days of the week provided insights into
potential variations in tipping behavior based on the day of the week. This analysis could
inform restaurant management decisions regarding staffing and service levels on specific
days. Influence of Smoking Status and Group Size on Tips: The scatter plot incorporating
smoker status and group size revealed potential associations between these factors and
tipping behavior. Smokers and non-smokers may exhibit different tipping patterns, and larger
groups may tip differently compared to smaller groups. Overall Insights and
Recommendations: The analysis of the tips dataset offers valuable insights into various
factors influencing tipping behavior, including total bill amount, gender, smoking status,
group size, and day of the week. These insights could be used by restaurants to optimize
customer service, staffing levels, and overall customer satisfaction.

25 | P a g e