PROGRAM - 1

To get the input from user and perform numerical operations (MAX, MIN, AVG, SUM, SQRT,
ROUND)using in Python.

def get_user_input():
nums = []
while True:
num = input("Enter a number (or 'done' to finish): ")
if num.lower() == 'done':
break
else:
try:
nums.append(float(num))
except ValueError:
print("Invalid input. Please enter a valid number.")
return nums

def numerical_operations(nums):
if not nums:
print("No numbers entered.")
return

maximum = max(nums)
minimum = min(nums)
average = sum(nums) / len(nums)
total_sum = sum(nums)
sqrt_values = [round(num ** 0.5, 2) for num in nums]
rounded_values = [round(num) for num in nums]

print("Maximum:", maximum)
print("Minimum:", minimum)
print("Average:", average)
print("Sum:", total_sum)
print("Square roots:", sqrt_values)
print("Rounded values:", rounded_values)

def main():
print("Enter numbers to perform numerical operations.")
numbers = get_user_input()
numerical_operations(numbers)

if __name__ == "__main__":
main()
 OUTPUT

Enter numbers to perform numerical operations.

Enter a number (or 'done' to finish): 10
Enter a number (or 'done' to finish): 20
Enter a number (or 'done' to finish): 30
Enter a number (or 'done' to finish): done
Maximum: 30.0
Minimum: 10.0
Average: 20.0
Sum: 60.0
Square roots: [3.16, 4.47, 5.48]
Rounded values: [10, 20, 30]
 PROGRAM - 5

To perform dimensionality reduction operation using PCA for Houses Data Set in Python.

import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

def apply_pca(data, num_components=2):

numeric_data = data.select_dtypes(include=['int64', 'float64'])
scaler = StandardScaler()
scaled_data = scaler.fit_transform(numeric_data)
pca = PCA(n_components=num_components)
pca_data = pca.fit_transform(scaled_data)
pca_columns = [f'PC{i+1}' for i in range(num_components)]
pca_df = pd.DataFrame(data=pca_data, columns=pca_columns)
final_data = pd.concat([pca_df, data], axis=1)
return final_data

url =
"https://raw.githubusercontent.com/dipanjanS/practical-machine-learning-with-python/master
/notebooks/Ch05_Machine_Learning_Pipeline/AB_NYC_2019.csv"
data = pd.read_csv(url)

result = apply_pca(data)
print(result.head())
OUTPUT
 PROGRAM - 6

To Perform Simple Logistic Regression with Python.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn import datasets
from sklearn.metrics import accuracy_score, confusion_matrix

iris = datasets.load_iris()
X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LogisticRegression()

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy)

conf_matrix = confusion_matrix(y_test, y_pred)

print("Confusion Matrix:")
print(conf_matrix)

OUTPUT

Accuracy: 1.0
Confusion Matrix:
[[10 0 0]
[ 0 9 0]
[ 0 0 11]]
 PROGRAM - 7

To perform data import/export (.CSV, .XLS, .TXT) operations using data frames in Python.
import pandas as pd .

import pandas as pd

data = {
'Name': ['John', 'Anna', 'Peter', 'Linda'],
'Age': [28, 35, 42, 32],
'City': ['New York', 'Paris', 'Berlin', 'London']
}

df = pd.DataFrame(data)

df.to_csv('sample_data.csv', index=False)
df.to_excel('sample_data.xlsx', index=False)
df.to_csv('sample_data.txt', sep='\t', index=False)

df_csv = pd.read_csv('sample_data.csv')
df_excel = pd.read_excel('sample_data.xlsx')
df_txt = pd.read_csv('sample_data.txt', sep='\t')

print("Data imported from CSV file:")

print(df_csv)
print("\nData imported from Excel file:")
print(df_excel)
print("\nData imported from text file:")
print(df_txt)
OUTPUT
 PROGRAM - 8

To perform K-Means clustering operation and visualize for iris data set in Python.

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn import tree

from sklearn.metrics import accuracy_score, classification_report

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

import warnings
warnings.filterwarnings('ignore')

iris = load_iris()
iris = sns.load_dataset('iris')
iris.head()

iris_setosa = iris.loc[iris["species"] == "Iris-setosa"]

iris_virginica = iris.loc[iris["species"] == "Iris-virginica"]
iris_versicolor = iris.loc[iris["species"] == "Iris-versicolor"]

sns.FacetGrid(iris, hue="species", size=3).map(sns.distplot, "petal_length").add_legend()

sns.FacetGrid(iris, hue="species", size=3).map(sns.distplot, "petal_width").add_legend()
sns.FacetGrid(iris, hue="species", size=3).map(sns.distplot, "sepal_length").add_legend()
plt.show()
OUTPUT
 PROGRAM - 9

Write R/Python script to diagnose any disease using KNN classification and plot the resultsin
Python.
 PROGRAM - 10

To perform market basket analysis using Association Rules (Apriori) in Python.

from mlxtend.frequent_patterns import apriori

from mlxtend.frequent_patterns import association_rules
import pandas as pd

data = {'TID': [1, 2, 3, 4, 5],

'Items': [['Milk', 'Bread', 'Butter'],
['Milk', 'Bread', 'Eggs'],
['Milk', 'Bread', 'Butter', 'Eggs'],
['Milk', 'Bread'],
['Milk', 'Eggs']]}

df = pd.DataFrame(data)
df['Items'] = df['Items'].apply(lambda x: ','.join(x))

one_hot_encoded = df['Items'].str.get_dummies(sep=',')

frequent_itemsets = apriori(one_hot_encoded, min_support=0.5, use_colnames=True)

rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.5)

print("Frequent Itemsets:")
print(frequent_itemsets)

print("\nAssociation Rules:")
print(rules)
OUTPUT
 PROGRAM - 11

To perform data pre-processing operations:

i) Handling Missing data
ii) Min-Max normalization

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

data = {
'A': [1, 2, None, 4, 5],
'B': [10, 20, 30, None, 50],
'C': [100, 200, 300, 400, None]
}

df = pd.DataFrame(data)

df.fillna(df.mean(), inplace=True)

scaler = MinMaxScaler()
df_normalized = pd.DataFrame(scaler.fit_transform(df), columns=df.columns)

print("Original DataFrame with missing values:")

print(df)

print("\nDataFrame after handling missing values (filled with mean):")

print(df)

print("\nDataFrame after Min-Max normalization:")

print(df_normalized)