I used the process of Exploratory Data Analysis EDA to answer the above questions¶

df=pd.read_csv ('foodhub.csv')
df.head()

#Is this data clean?

df.shape

df.columns

df.isnull().sum()

df.duplicated().sum()

df.info()

df.describe()

count_rate

count_cusine

average_costs = calculate_average_cost_by_cuisine(df)
print(average_costs)

average_costs_sorted = average_costs.sort_values(ascending=True)
plt.figure(figsize=(10, 6))
average_costs_sorted.plot(kind='bar')
plt.xlabel('Cuisine Type')
plt.ylabel('Average Cost of the Order')
plt.title('Average Cost of Orders by Cuisine Type')
plt.xticks(rotation=45)
plt.show()

average_rating = calculate_average_rating_by_cuisine(df)
print(average_rating)

std_dev_mean_ratings = average_rating.std()
print(std_dev_mean_ratings)

dataframe.head()

dataframe.head()

dataframe.corr()

sns.heatmap(dataframe.corr(),
            annot=True,
           cbar=False)
plt.show()

dataframe.head()

# Group by 'cuisine_type' and 'day_of_the_week' and count the number of orders
order_counts = df.groupby(['cuisine_type', 'day_of_the_week']).size().unstack(fill_value=0)

# Display the result
print(order_counts)

average_times = df.groupby('cuisine_type')[['food_preparation_time', 'delivery_time']].mean()
print(average_times)

# Reset index to use cuisine_type as a column for plotting
average_times = average_times.reset_index()
plt.figure(figsize=(9, 5))
sns.barplot(x='cuisine_type', y='food_preparation_time', data=average_times, palette='viridis')
plt.title('Average Food Preparation Time by Cuisine Type')
plt.xlabel('Cuisine Type')
plt.ylabel('Average Food Preparation Time (minutes)')
plt.xticks(rotation=45)
plt.show()

# Plot the average delivery time
plt.figure(figsize=(9, 5))
sns.barplot(x='cuisine_type', y='delivery_time', data=average_times, palette='viridis')
plt.title('Average Delivery Time by Cuisine Type')
plt.xlabel('Cuisine Type')
plt.ylabel('Average Delivery Time (minutes)')
plt.xticks(rotation=45)
plt.show()

average_times_by_week = df.groupby('day_of_the_week')[['food_preparation_time', 'delivery_time']].mean()
print(average_times_by_week)

print(freq_above_30)

filtered_restaurants = df['restaurant_name'].value_counts()[df['restaurant_name'].value_counts() > 30]
# Sort ratings by their counts in ascending order
sorted_res = filtered_restaurants.index

plt.figure(figsize = (10,8))
sns.countplot(y='restaurant_name', data=df[df['restaurant_name'].isin(filtered_restaurants.index)], order=sorted_res,palette='viridis')
plt.xlabel('Frequency')
plt.ylabel('Restaurant')
plt.show()

print(weekend_cuisine_order)

# Filter DataFrame for 
filtered_df = df[df['day_of_the_week'].isin(['Weekend'])]
#order
sorted_cuisines = filtered_df.index

# Plotting with Seaborn
plt.figure(figsize=(12, 6))
sns.countplot(data=filtered_df, x='cuisine_type', hue='day_of_the_week', palette='viridis')
plt.title('Cuisine Type Count for Monday and Tuesday')
plt.xlabel('Cuisine Type')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.show()

def percentage_below_thresholds(df, thresholds, column_name='cost_of_the_order'):
    total_orders = df.shape[0]
    percentages = {}
    
    for threshold in thresholds:
        orders_below_threshold = df[df[column_name] < threshold].shape[0]
        percentage_below_threshold = (orders_below_threshold / total_orders) * 100
        percentages[threshold] = percentage_below_threshold
    
    return percentages

# Define the thresholds
thresholds = [20, 30, 40, 50]

# Get the percentages
percentages = percentage_below_thresholds(df, thresholds)

# Print the results
for threshold, percentage in percentages.items():
    print(f"Percentage of orders less than ${threshold}: {percentage:.2f}%")

df['delivery_time'].mean()

def top_customers(df, n=3):
    # Group by customer_id and count the number of orders for each customer
    customer_order_counts = df['customer_id'].value_counts()
    
    # Get the top n customers
    top_n_customers = customer_order_counts.head(n)
    
    # Convert to DataFrame for better readability
    top_n_customers_df = top_n_customers.reset_index()
    top_n_customers_df.columns = ['customer_id', 'number_of_orders']
    
    return top_n_customers_df

# Get the top 3 customers
top_3_customers = top_customers(df, 3)

print(top_3_customers)

def top_customers_cuisines(df, n=3):
    # Group customer_id and count the number of orders for each customer
    customer_order_counts = df['customer_id'].value_counts()
    
    # Get top n customers
    top_n_customers = customer_order_counts.head(n).index
    
    # Filter DFrame to include only orders from the top n customers
    top_customers_orders = df[df['customer_id'].isin(top_n_customers)]
    
    # Get unique cuisines from these orders
    top_cuisines = top_customers_orders['cuisine_type'].unique()
    
    return top_cuisines

# Get cuisines for top 3 customers
top_cuisines = top_customers_cuisines(df, 3)

print(top_cuisines)

def top_customers_top_cuisines_cost(df, n_customers=3, n_cuisines=9):
    # Group customer_id and count the number of orders for each customer
    customer_order_counts = df['customer_id'].value_counts()
    
    # Get top n_customers customers based on number of orders
    top_customers = customer_order_counts.head(n_customers).index
    
    # Filter DataFrame to include only orders from top customers
    top_customers_orders = df[df['customer_id'].isin(top_customers)]
    
    # Calculate the total cost of orders for each cuisine type
    cuisine_total_cost = top_customers_orders.groupby('cuisine_type')['cost_of_the_order'].sum()
    
    # Get top n_cuisines cuisines based on total order cost
    top_cuisines = cuisine_total_cost.sort_values(ascending=False).head(n_cuisines)
    
    return top_cuisines

# Get total cost for top 3 cuisines ordered by top  customers
top_cuisines_cost = top_customers_top_cuisines_cost(df, 3, 9)

print(top_cuisines_cost)

plt.figure(figsize=(10, 7))
plt.pie(top_cuisines_cost, labels=top_cuisines_cost.index, autopct='%1.1f%%', startangle=140, )
plt.title('Total Cost Distribution by Cuisine')
plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
plt.show()

def top_customers_cuisine_rating_stats(df, n_customers=3):
    # customer_id and count number of orders for each customer
    customer_order_counts = df['customer_id'].value_counts()
    
    #  top n_customers customers based on number of orders
    top_n_customers = customer_order_counts.head(n_customers).index
    
    #  DF to include only orders from top n_customers customers
    top_customers_orders = df[df['customer_id'].isin(top_n_customers)]
    
    # empty lists to store ratings and number of ratings per cuisine
    cuisine_ratings = []
    cuisine_num_ratings = []
    
    # Iterate over each cuisine type
    for cuisine in top_customers_orders['cuisine_type'].unique():
        # orders for the current cuisine
        cuisine_orders = top_customers_orders[top_customers_orders['cuisine_type'] == cuisine]
        
        # 'Not given' ratings to NaN
        cuisine_orders['rating'] = pd.to_numeric(cuisine_orders['rating'], errors='coerce')
        
        # number of ratings and average rating for the current cuisine
        num_ratings = cuisine_orders['rating'].count()
        avg_rating = cuisine_orders['rating'].mean()
        
        # results to lists
        cuisine_ratings.append(avg_rating)
        cuisine_num_ratings.append(num_ratings)
    
    # DF to store results
    results_df = pd.DataFrame({
        'cuisine_type': top_customers_orders['cuisine_type'].unique(),
        'num_ratings': cuisine_num_ratings,
        'avg_rating': cuisine_ratings
    })
    
    return results_df

# Get ratings statistics for top customers for each cuisine
ratings_stats_per_cuisine = top_customers_cuisine_rating_stats(df, 3)

print(ratings_stats_per_cuisine)

def top_customers_cuisine_preparation_time(df, n_customers=3):
    # customer_id and count the number of orders for each customer
    customer_order_counts = df['customer_id'].value_counts()
    
    # top n_customers customers based on number of orders
    top_n_customers = customer_order_counts.head(n_customers).index
    
    # DataFrame to include only orders from the top n_customers customers
    top_customers_orders = df[df['customer_id'].isin(top_n_customers)]
    
    # Total preparation time for each cuisine type
    cuisine_total_preparation_time = top_customers_orders.groupby('cuisine_type')['food_preparation_time'].sum()
    
    return cuisine_total_preparation_time

# total preparation time for each cuisine type for the top 3 customers
total_preparation_time_per_cuisine = top_customers_cuisine_preparation_time(df, 3)

print(total_preparation_time_per_cuisine)

total_preparation_time_per_cuisine.sort_values( ascending=False, inplace=True)
plt.figure(figsize=(8, 6))
data=total_preparation_time_per_cuisine.plot(kind='bar', )
plt.title('Total Food Preparation Time by Cuisine (Top 3 Customers)')
plt.xlabel('Cuisine Type')
plt.ylabel('Total Preparation Time')
plt.xticks(rotation=45)
plt.show()

def top_restaurants_by_ratings(df, min_rating_count=50, min_avg_rating=4):
    # Filter out "Not given" ratings to numeric values
    df_filtered = df[df['rating'] != 'Not given'].copy()
    df_filtered['rating'] = pd.to_numeric(df_filtered['rating'])

    #restaurant_name and calculate rating count and average rating
    rating_stats = df_filtered.groupby('restaurant_name')['rating'].agg(['count', 'mean']).reset_index()
    rating_stats.columns = ['restaurant_name', 'rating_count', 'avg_rating']

    # the conditions to be met
    top_restaurants = rating_stats[(rating_stats['rating_count'] >= min_rating_count) & (rating_stats['avg_rating'] >= min_avg_rating)]

    return top_restaurants

# top restaurants based on the criteria
top_restaurants = top_restaurants_by_ratings(df, min_rating_count=50, min_avg_rating=4)
print(top_restaurants)

top_restaurants.head()

def top_restaurants_by_ratings(df, min_rating_count=50, min_avg_rating=4):
    #"Not given" ratings and convert ratings to numeric values
    df_filtered = df[df['rating'] != 'Not given'].copy()
    df_filtered['rating'] = pd.to_numeric(df_filtered['rating'])

    # restaurant_name and calculate rating count and average rating
    rating_stats = df_filtered.groupby('restaurant_name')['rating'].agg(['count', 'mean']).reset_index()
    rating_stats.columns = ['restaurant_name', 'rating_count', 'avg_rating']

    #  based on the conditions
    top_restaurants = rating_stats[(rating_stats['rating_count'] >= min_rating_count) & (rating_stats['avg_rating'] >= min_avg_rating)]

    return top_restaurants

# top restaurants based on the criteria
top_restaurants = top_restaurants_by_ratings(df, min_rating_count=50, min_avg_rating=4)
top_restaurant_orders = df[df['restaurant_name'].isin(top_restaurants['restaurant_name'])]
def calculate_advertising_charges(df):
    # Calculate the advertising charge based on the cost_of_the_order
    df['advertising_charge'] = df['cost_of_the_order'].apply(lambda x: 0.25 * x if x > 20 else (0.15 * x if x > 5 else 0))
    return df

#Advertising charges to the orders from top restaurants
top_restaurant_orders_with_charges = calculate_advertising_charges(top_restaurant_orders)

print(top_restaurant_orders_with_charges)

top_restaurant_orders_with_charges.head()

#Revenue generated across all orders 
top_restaurant_orders_with_charges['advertising_charge'].sum()

# Add a new column 'total_time' which is the sum of 'food_preparation_time' and 'delivery_time'
df['total_time'] = df['food_preparation_time'] + df['delivery_time']

def percentage_of_long_orders(df, threshold=60):
    # %tage of orders with 'total_time' >= threshold
    total_orders = len(df)
    long_orders = len(df[df['total_time'] >= threshold])
    percentage = (long_orders / total_orders) * 100
    return percentage

# %tage of orders that take 60 minutes or more
percentage_60_plus = percentage_of_long_orders(df, 60)
print(f"Percentage of orders that take 60 minutes or more: {percentage_60_plus:.2f}%")

print(average_delivery)