21.Create a Python program to analyze a dataset (e.g.

, customer reviews) and

demonstrate how AI can be used to extract insights. For example, use
sentiment analysis to categorize reviews as positive, negative, or neutral.

Python Code for Sentiment Analysis

import pandas as pd
import matplotlib.pyplot as plt
from textblob import TextBlob

# Load Dataset (Example: CSV File with "Review" Column)

file_path = "customer_reviews.csv" # Update this with your actual file path
df = pd.read_csv(file_path)

# Function to Get Sentiment Score

def analyze_sentiment(review):
analysis = TextBlob(str(review)) # Convert to string to avoid errors
polarity = analysis.sentiment.polarity

# Categorizing the Sentiment

if polarity > 0:
return "Positive"
elif polarity < 0:
return "Negative"
else:
return "Neutral"

# Apply Sentiment Analysis to Each Review

df["Sentiment"] = df["Review"].apply(analyze_sentiment)

# Display the first few rows

print(df.head())

# Count Sentiment Categories

sentiment_counts = df["Sentiment"].value_counts()

# Plot Sentiment Distribution

plt.figure(figsize=(6,4))
plt.bar(sentiment_counts.index, sentiment_counts.values, color=["green", "red",
"gray"])
plt.xlabel("Sentiment")
plt.ylabel("Number of Reviews")
plt.title("Customer Sentiment Distribution")
plt.show()

Steps to Run the Program:

1. Prepare a dataset (customer_reviews.csv) with at least one column named "Review".

2. Install Dependencies if not installed:
3. pip install pandas textblob matplotlib
4. Run the script, and it will:
o Categorize each review as Positive, Negative, or Neutral.
o Display the first few categorized reviews.
o Generate a bar chart showing sentiment distribution.
Example Output

Dataset Sample:

Review Sentiment
"Great product, very useful!" Positive
"Worst service ever." Negative
"It's okay, nothing special." Neutral

22.Implement a simple chatbot using Python's NLTK library that can respond to
basic user queries.

If you haven’t installed NLTK, install it first:

pip install nltk

Python Code for a Simple Chatbot

import nltk
from nltk.chat.util import Chat, reflections

# Define chatbot responses using pairs of patterns and responses

pairs = [
[r"hi|hello|hey", ["Hello!", "Hi there!", "Hey!"]],
[r"how are you ?", ["I'm a chatbot, I don't have feelings, but I'm here to
help!", "I'm doing great!"]],
[r"what is your name ?", ["I am a simple chatbot.", "You can call me
ChatBot!"]],
[r"how can you help me ?", ["I can answer basic questions!"]],
[r"who created you ?", ["I was created using Python and NLTK!"]],
[r"bye|goodbye", ["Goodbye!", "See you later!", "Bye, have a great day!"]],
]

# Create chatbot
chatbot = Chat(pairs, reflections)

# Start chatbot interaction

print("Hello! I'm your chatbot. Type 'bye' to exit.")
while True:
user_input = input("You: ")
if user_input.lower() == "bye":
print("Chatbot: Goodbye!")
break
response = chatbot.respond(user_input)
print("Chatbot:", response)

Example Conversation
Hello! I'm your chatbot. Type 'bye' to exit.
You: hi
Chatbot: Hi there!

You: what is your name?

Chatbot: I am a simple chatbot.

You: bye
Chatbot: Goodbye!

23.Write a Python program to analyse sentiment in each text using the TextBlob
library.

Install Required Library

If you haven’t installed TextBlob, install it first:

pip install textblob

Python Code for Sentiment Analysis

from textblob import TextBlob

# Function to analyze sentiment

def analyze_sentiment(text):
blob = TextBlob(text)
polarity = blob.sentiment.polarity # Sentiment score between -1 to 1

# Classifying sentiment
if polarity > 0:
sentiment = "Positive"
elif polarity < 0:
sentiment = "Negative"
else:
sentiment = "Neutral"

return polarity, sentiment

# Take user input

text = input("Enter a text for sentiment analysis: ")
polarity, sentiment = analyze_sentiment(text)

# Display results
print(f"\nText: {text}")
print(f"Sentiment Score: {polarity}")
print(f"Overall Sentiment: {sentiment}")

Example Output

Input:

vbnet
Enter a text for sentiment analysis: This product is amazing and works
perfectly!

Output:

Text: This product is amazing and works perfectly!

Sentiment Score: 0.85
Overall Sentiment: Positive

24.Create a machine learning model in Python to classify spam emails using the
Naive Bayes algorithm.

Install Required Libraries

If you haven’t installed the required libraries, install them first:

pip install pandas scikit-learn nltk

Python Code: Spam Email Classifier

import pandas as pd
import numpy as np
import nltk
import string
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score, classification_report

# Load Dataset (Example: spam.csv)

df = pd.read_csv("spam.csv", encoding="latin-1")[["v1", "v2"]] # Selecting only
relevant columns
df.columns = ["label", "message"]

# Convert labels to numerical values (spam = 1, ham = 0)

df["label"] = df["label"].map({"ham": 0, "spam": 1})

# Text Preprocessing Function

def clean_text(text):
text = text.lower() # Convert to lowercase
text = "".join([char for char in text if char not in string.punctuation]) #
Remove punctuation
return text

df["message"] = df["message"].apply(clean_text)

# Split Data into Training and Testing Sets

X_train, X_test, y_train, y_test = train_test_split(df["message"], df["label"],
test_size=0.2, random_state=42)

# Create a Naive Bayes Model Pipeline

model = Pipeline([
("vectorizer", CountVectorizer()), # Convert text to numerical vectors
 ("tfidf", TfidfTransformer()), # Apply TF-IDF transformation
("classifier", MultinomialNB()) # Train a Naive Bayes classifier
])

# Train the Model

model.fit(X_train, y_train)

# Predict on Test Data

y_pred = model.predict(X_test)

# Evaluate the Model

accuracy = accuracy_score(y_test, y_pred)
print(f"Model Accuracy: {accuracy:.2f}")
print("\nClassification Report:\n", classification_report(y_test, y_pred))

# Test the Model on a New Email

def predict_spam(email):
prediction = model.predict([email])
return "Spam" if prediction[0] == 1 else "Not Spam"

# Example Test
email = input("\nEnter an email to check if it's spam or not: ")
print("Prediction:", predict_spam(email))

Example Output
vbnet
CopyEdit
Model Accuracy: 0.98

Classification Report:
precision recall f1-score support
0 0.99 0.99 0.99 965
1 0.94 0.95 0.94 150

Enter an email to check if it's spam or not: Congratulations! You've won a free
iPhone! Click here to claim.
Prediction: Spam

25.Write a Python program to predict house prices using linear regression.

Install Required Libraries

If you haven’t installed the required libraries, install them first:

pip install pandas numpy scikit-learn matplotlib seaborn

Python Code: House Price Prediction Using Linear Regression

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# Load Dataset (Example: housing.csv)

df = pd.read_csv("housing.csv") # Replace with your dataset

# Display first few rows

print(df.head())

# Check for missing values

print("\nMissing Values:\n", df.isnull().sum())

# Drop rows with missing values (if necessary)

df.dropna(inplace=True)

# Select Features (X) and Target Variable (y)

X = df[["area", "bedrooms", "bathrooms", "stories"]] # Choose relevant columns
y = df["price"]

# Split Data into Training and Testing Sets

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

# Train Linear Regression Model

model = LinearRegression()
model.fit(X_train, y_train)

# Predict on Test Data

y_pred = model.predict(X_test)

# Evaluate Model Performance

print("\nModel Performance:")
print(f"Mean Absolute Error (MAE): {mean_absolute_error(y_test, y_pred):.2f}")
print(f"Mean Squared Error (MSE): {mean_squared_error(y_test, y_pred):.2f}")
print(f"R-squared (R² Score): {r2_score(y_test, y_pred):.2f}")

# Plot Actual vs. Predicted Prices

plt.figure(figsize=(8,6))
sns.scatterplot(x=y_test, y=y_pred)
plt.xlabel("Actual Prices")
plt.ylabel("Predicted Prices")
plt.title("Actual vs Predicted House Prices")
plt.show()

# Function to Predict House Price Based on User Input

def predict_house_price(area, bedrooms, bathrooms, stories):
input_data = np.array([[area, bedrooms, bathrooms, stories]])
prediction = model.predict(input_data)
return prediction[0]

# Example Test
area = float(input("\nEnter Area (sqft): "))
bedrooms = int(input("Enter Number of Bedrooms: "))
bathrooms = int(input("Enter Number of Bathrooms: "))
stories = int(input("Enter Number of Stories: "))

predicted_price = predict_house_price(area, bedrooms, bathrooms, stories)

print(f"\nPredicted House Price: ${predicted_price:,.2f}")
Example Output
mathematica
CopyEdit
Model Performance:
Mean Absolute Error (MAE): 35000.45
Mean Squared Error (MSE): 2,500,000,000.67
R-squared (R² Score): 0.87

Enter Area (sqft): 1500

Enter Number of Bedrooms: 3
Enter Number of Bathrooms: 2
Enter Number of Stories: 2

Predicted House Price: $250,000.00

26.Develop a Python program to clean and preprocess a given dataset for a

machine learning model.

import pandas as pd
from sklearn.preprocessing import StandardScaler, LabelEncoder

# Load Dataset
df = pd.read_csv("data.csv") # Replace with your dataset

# Display initial info

print("Initial Data Info:")
print(df.info())

# Handle Missing Values

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

# Remove Duplicates
df.drop_duplicates(inplace=True)

# Encode Categorical Variables

encoder = LabelEncoder()
for col in df.select_dtypes(include=['object']).columns:
df[col] = encoder.fit_transform(df[col])

# Scale Numerical Data

scaler = StandardScaler()
df[df.columns] = scaler.fit_transform(df)

# Save cleaned dataset

df.to_csv("cleaned_data.csv", index=False)
print("Dataset cleaned and saved as cleaned_data.csv")

27.Write a Python script to perform exploratory data analysis (EDA) on a dataset of

your choice.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load Dataset
df = pd.read_csv("data.csv") # Replace with your dataset

# Display basic statistics

print(df.describe())

# Check missing values

print("\nMissing Values:\n", df.isnull().sum())

# Plot Correlation Heatmap

plt.figure(figsize=(10,6))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm', fmt=".2f")
plt.title("Feature Correlation Heatmap")
plt.show()

# Histogram of a Feature
df.hist(figsize=(10,8))
plt.show()

28. Write a program to check the strength of the pass word.

import re

def check_password_strength(password):
if len(password) < 8:
return "Weak: Password should be at least 8 characters long."
if not re.search(r"[A-Z]", password):
return "Weak: Include at least one uppercase letter."
if not re.search(r"\d", password):
return "Weak: Include at least one digit."
if not re.search(r"[!@#$%^&*]", password):
return "Weak: Include at least one special character."
return "Strong Password!"

password = input("Enter your password: ")

print(check_password_strength(password))

29. From Yahoo Finance download a stock price in Python and find the Simple
Moving Average and print the first 100 values and the related graph.

import yfinance as yf
import matplotlib.pyplot as plt

# Download stock data

stock = yf.download('TATAMOTORS.NS', start='2019-01-01', end='2024-01-01')

# Calculate Simple Moving Average (SMA)

stock['SMA_50'] = stock['Close'].rolling(window=50).mean()

# Print first 100 values

print(stock[['Close', 'SMA_50']].head(100))

# Plot SMA
plt.figure(figsize=(10,5))
plt.plot(stock['Close'], label="Close Price")
plt.plot(stock['SMA_50'], label="50-Day SMA", linestyle="dashed")
plt.legend()
plt.title("Stock Price and 50-Day SMA")
plt.show()
30. From Yahoo finance download a stock price in Python and draw the needed
graphs to present the Open, Close, High, Low, Adj. Close, Volume of five year data.

import yfinance as yf
import matplotlib.pyplot as plt

# Download stock data for the last 5 years

stock = yf.download('TATAMOTORS.NS', period='5y')

# Plot different stock parameters

plt.figure(figsize=(12,6))
plt.subplot(2, 3, 1)
plt.plot(stock['Open'], label='Open Price')
plt.title("Open Price")

plt.subplot(2, 3, 2)
plt.plot(stock['High'], label='High Price', color='g')
plt.title("High Price")

plt.subplot(2, 3, 3)
plt.plot(stock['Low'], label='Low Price', color='r')
plt.title("Low Price")

plt.subplot(2, 3, 4)
plt.plot(stock['Close'], label='Close Price', color='b')
plt.title("Close Price")

plt.subplot(2, 3, 5)
plt.plot(stock['Adj Close'], label='Adjusted Close', color='purple')
plt.title("Adj Close Price")

plt.subplot(2, 3, 6)
plt.bar(stock.index, stock['Volume'], color='gray')
plt.title("Trading Volume")

plt.tight_layout()
plt.show()