Assignment 5 · Python Programming
Dynamic
Loops & Functions
with numpy, pandas & matplotlib ✦
8 tasks · simulations · data transformation · visualization
8 tasks · simulations · data transformation · visualization
def compute_formula(x, formula):
if formula == "linear":
return 2*x + 3
elif formula == "quadratic":
return x**2 + 2*x + 1
elif formula == "cubic":
return x**3
elif formula == "exponential":
return np.exp(x)
else:
raise ValueError("Formula not recognized")x = np.arange(1, 21)
formulas = ["linear", "quadratic", "cubic", "exponential"]
results = {}
for formula in formulas:
y_values = []
for val in x:
y = compute_formula(val, formula)
y_values.append(y)
results[formula] = y_values
# Plot all formulas in one graph
for formula in formulas:
plt.plot(x, results[formula], label=formula)
plt.title("Comparison of Mathematical Formulas")
plt.legend()
plt.show()Discount logic: ≥ 100 → 20% off | ≥ 50 → 10% off | < 50 → no discount. Simulated over 5 days × 3 products.
def apply_discount(amount):
if amount >= 100:
return amount * 0.8 # 20% off
elif amount >= 50:
return amount * 0.9 # 10% off
else:
return amount # no discount
days = 5; products = 3
sales_data = []
for day in range(1, days+1):
daily_sales = []
for product in range(1, products+1):
sale = np.random.randint(20, 120)
final_sale = apply_discount(sale)
daily_sales.append(final_sale)
sales_data.append(daily_sales)def categorize_performance(sales_amount):
if sales_amount >= 90: return "Excellent"
elif sales_amount >= 75: return "Very Good"
elif sales_amount >= 60: return "Good"
elif sales_amount >= 40: return "Average"
else: return "Poor"
sales = [95, 82, 67, 45, 30, 88, 76, 54, 61, 40, 92, 70]
categories = []
for amount in sales:
categories.append(categorize_performance(amount))
from collections import Counter
category_counts = Counter(categories)
# Calculate percentages
total = len(categories)
percentages = {cat: (count/total)*100 for cat, count in category_counts.items()}def generate_company_data(n_company, n_employees):
data = []
for company in range(1, n_company + 1):
for emp in range(1, n_employees + 1):
salary = np.random.randint(3000, 10000)
performance_score = np.random.randint(50, 100)
kpi_score = np.random.randint(60, 100)
department = np.random.choice(["HR","Sales","IT","Finance"])
data.append([company, emp, salary, department,
performance_score, kpi_score])
return pd.DataFrame(data, columns=["company_id","employee_id",
"salary","department","performance_score","kpi_score"])
df = generate_company_data(5, 50)
df["top_performer"] = df["kpi_score"] > 90Estimated π ≈ 3.1216 using 5,000 random points. Probability inside sub-square: 0.243. Points falling inside the quarter circle (x² + y² ≤ 1) are used to approximate π × 4.
def monte_carlo_pi(n_points):
inside_circle = 0
x_inside, y_inside = [], []
x_outside, y_outside = [], []
sub_square_count = 0
for i in range(n_points):
x = np.random.rand()
y = np.random.rand()
if x**2 + y**2 <= 1:
inside_circle += 1
x_inside.append(x); y_inside.append(y)
else:
x_outside.append(x); y_outside.append(y)
pi_estimate = 4 * inside_circle / n_points
return pi_estimate, sub_square_count/n_points, ...def normalize_columns(df):
df_norm = df.copy()
cols = ["salary", "performance_score", "kpi_score"]
for col in cols:
min_val = df[col].min()
max_val = df[col].max()
df_norm[col] = (df[col] - min_val) / (max_val - min_val)
return df_normdef z_score(df):
df_z = df.copy()
cols = ["salary", "performance_score", "kpi_score"]
for col in cols:
mean = df[col].mean()
std = df[col].std()
df_z[col] = (df[col] - mean) / std
return df_z# Performance category from score
def performance_category(score):
if score >= 90: return "Excellent"
elif score >= 75: return "Very Good"
elif score >= 60: return "Good"
else: return "Needs Improvement"
# Salary bracket
def salary_bracket(salary):
if salary >= 8000: return "High"
elif salary >= 5000: return "Medium"
else: return "Low"
df["performance_category"] = df["performance_score"].apply(performance_category)
df["salary_bracket"] = df["salary"].apply(salary_bracket)def kpi_tier(score):
if score >= 90: return "Top Performer"
elif score >= 75: return "High"
elif score >= 60: return "Medium"
else: return "Low"
tiers = []
for score in df["kpi_score"]:
tiers.append(kpi_tier(score))
df["kpi_tier"] = tiers| Company ID | Avg Salary | Avg KPI | Avg KPI Tier |
|---|---|---|---|
| 1 | 6,295.34 | 79.60 | High |
| 2 | 6,603.98 | 80.53 | High |
| 3 | 6,300.22 | 77.88 | High |
| 4 | 6,436.36 | 78.23 | High |
| 5 | 6,028.11 | 80.13 | High |
| 6 | 6,395.55 | 79.86 | High |
| 7 | 6,331.54 | — | Medium |
| 8 | — | — | Medium |
def company_report(df):
companies = df["company_id"].unique()
for c in companies:
company_df = df[df["company_id"] == c]
avg_salary = company_df["salary"].mean()
avg_kpi = company_df["kpi_score"].mean()
top = len(company_df[company_df["kpi_score"] > 90])
print(f"------ Company {c} ------")
print(f"Employees: {len(company_df)}")
print(f"Average Salary: {round(avg_salary, 2)}")
print(f"Average KPI: {round(avg_kpi, 2)}")
print(f"Top Performers: {top}")report_summary = df.groupby("company_id").agg({
"salary": "mean",
"kpi_score": "mean",
"employee_id": "count"
}).rename(columns={
"salary": "avg_salary",
"kpi_score": "avg_kpi",
"employee_id": "num_employees"
})
report_summary.to_csv("company_summary_report.csv")