EXNO1

import numpy as np

# a) Convert an array to a float type

arr = np.array([1, 2, 3])
float_arr = arr.astype(float)
print("Float array:", float_arr)

# b) Create a 3x3 matrix with values ranging from 2 to 10

matrix = np.arange(2, 11).reshape(3, 3)
print("3x3 matrix:\n", matrix)

# c) Convert a list of numeric values into a one-dimensional NumPy array

num_list = [10, 20, 30, 40]
array_from_list = np.array(num_list)
print("1D NumPy array:", array_from_list)

# d) Convert a list and a tuple into arrays

list_data = [5, 10, 15]
tuple_data = (2, 4, 6)
array_from_list = np.array(list_data)
array_from_tuple = np.array(tuple_data)
print("Array from list:", array_from_list)
print("Array from tuple:", array_from_tuple)

OUTPUT

Float array: [1. 2. 3.]

3x3 matrix:
[[ 2 3 4]
[ 5 6 7]
[ 8 9 10]]
1D NumPy array: [10 20 30 40]
Array from list: [ 5 10 15]
Array from tuple: [2 4 6]

[Program finished]

EXNO2
import numpy as np

# a) Append values to the end of an array

arr1 = np.array([1, 2, 3])
appended_arr = np.append(arr1, [4, 5])
print("a) Appended Array:", appended_arr)
# b) Find the real and imaginary parts of an array of complex numbers
complex_arr = np.array([1+2j, 3+4j, 5+6j])
print("b) Real parts:", np.real(complex_arr))
print(" Imaginary parts:", np.imag(complex_arr))

# c) List the second column elements from a shape (3,3) array

arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
second_column = arr2[:, 1]
print("c) Second column elements:", second_column)

# d) Find the maximum and minimum value from a shape (3,3) array
arr3 = np.array([[4, 9, 1], [7, 3, 6], [8, 2, 5]])
print("d) Maximum value:", np.max(arr3))
print(" Minimum value:", np.min(arr3))

OUTPUT
a) Appended Array: [1 2 3 4 5]
b) Real parts: [1. 3. 5.]
Imaginary parts: [2. 4. 6.]
c) Second column elements: [2 5 8]
d) Maximum value: 9
Minimum value: 1

[Program finished]

EXNO3
import numpy as np
from scipy import stats

# Marks of 20 students
marks = [75, 80, 85, 90, 70, 88, 76, 92, 81, 78,
84, 79, 77, 83, 86, 82, 74, 89, 91, 87]

# Average we are testing against

expected_mean = 80

# Z-Test (if population standard deviation is known)

pop_std = 5 # assume population std is 5
sample_mean = np.mean(marks)
z = (sample_mean - expected_mean) / (pop_std / np.sqrt(len(marks)))
print("Z-Test Result:")
print("Z-Score =", z)

# T-Test (when population std is not known)

t, p = stats.ttest_1samp(marks, expected_mean)
print("\nT-Test Result:")
print("T-Score =", t)
print("P-Value =", p)

OUTPUT
Z-Test Result:
Z-Score = 2.1019038988497973

T-Test Result:
T-Score = 1.6948633480403503
P-Value = 0.10642890850820598

[Program finished]

EXNO4
from scipy.stats import f_oneway

# Test scores for each class

class_A = [8, 6, 8, 6]
class_B = [7, 9, 5, 10, 7, 4, 2]
class_C = [4, 3, 6, 2, 7, 5, 5, 4, 1, 3, 6, 1, 3, 5, 3, 4, 6, 5, 7, 3]

# Perform ANOVA
f_statistic, p_value = f_oneway(class_A, class_B, class_C)

# Output results
print("ANOVA Test Results:")
print(f"F-statistic: {f_statistic:.3f}")
print(f"P-value: {p_value:.5f}")

# Interpretation
if p_value < 0.05:
print("Result: Significant difference between at least two groups.")
else:
print("Result: No significant difference between groups.")

OUTPUT
ANOVA Test Results:
F-statistic: 5.254
P-value: 0.01155
Result: Significant difference between at least two groups.

[Program finished]

EXNO5

import pandas as pd
import numpy as np
# 1. Create DataFrame from NumPy array
array_data = np.array([[1, 2, 3], [4, 5, 6]])
df_array = pd.DataFrame(array_data, columns=['A', 'B', 'C'])
print("DataFrame from NumPy array:")
print(df_array)

# 2. Create DataFrame from dictionary

dict_data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35]
}
df_dict = pd.DataFrame(dict_data)
print("\nDataFrame from dictionary:")
print(df_dict)

# 3. Create DataFrame from Series

series_data = pd.Series([100, 200, 300], index=['X', 'Y', 'Z'])
df_series = pd.DataFrame(series_data, columns=['Values'])
print("\nDataFrame from Series:")
print(df_series)

OUTPUT
DataFrame from NumPy array:
A B C
0 1 2 3
1 4 5 6

DataFrame from dictionary:

Name Age
0 Alice 25
1 Bob 30
2 Charlie 35

DataFrame from Series:

Values
X 100
Y 200
Z 300

[Program finished]

EXNO6
import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
# Create a 2x2 subplot grid
fig, axs = plt.subplots(2, 2, figsize=(10, 8))

# Line Plot
axs[0, 0].plot(x, y)
axs[0, 0].set_title("Line Plot")

# Bar Chart
axs[0, 1].bar(x, y)
axs[0, 1].set_title("Bar Chart")

# Scatter Plot
axs[1, 0].scatter(x, y)
axs[1, 0].set_title("Scatter Plot")

# Pie Chart (only in one subplot, takes whole axes)

axs[1, 1].pie(y, labels=x, autopct='%1.1f%%')
axs[1, 1].set_title("Pie Chart")

# Adjust layout
plt.tight_layout()
plt.show()

OUTPUT
EXNO7

import numpy as np
import pandas as pd

def calculate_variance(data):
# Convert input to NumPy array for consistency
data_array = np.array(data, dtype=float)
return np.var(data_array, ddof=1) # ddof=1 for sample variance

# Different types of data samples

list_sample = [10, 12, 23, 23, 16, 23, 21, 16]
numpy_sample = np.array([4.5, 6.7, 8.9, 5.5, 7.3])
pandas_sample = pd.Series([100, 102, 98, 97, 105, 100])

# Calculate and display variances

print("Variance from list:", calculate_variance(list_sample))
print("Variance from NumPy array:", calculate_variance(numpy_sample))
print("Variance from Pandas Series:", calculate_variance(pandas_sample))

OUTPUT
Variance from list: 27.428571428571427
Variance from NumPy array: 2.8520000000000003
Variance from Pandas Series: 8.266666666666667

[Program finished]

EXNO8
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# Your data
data = [5, 7, 8, 9, 10, 11, 12, 13, 15, 18]

mean = np.mean(data)
std = np.std(data)

x = np.linspace(min(data), max(data), 100)

y = norm.pdf(x, mean, std)

plt.plot(x, y)
plt.title('Normal Curve from Your Data')
plt.show()

OUTPUT
EXNO9

import numpy as np
import matplotlib.pyplot as plt

x = np.random.randn(50)
y = [x*5+3, -5*x, np.random.randn(50)]
c = ['green', 'red', 'blue']
l = ['Positive', 'Negative', 'Zero']

plt.figure(figsize=(10, 8), dpi=100)

for yi, ci, li in zip(y, c, l):
plt.scatter(x, yi, color=ci, label=f"{li} correlation (r = {np.corrcoef(x, yi)[0,1]:.1f})")

plt.xlabel("X-axis"); plt.ylabel("Y-axis")
plt.title("Correlation and Scatter Plots")
plt.legend()
plt.grid()
plt.show()

OUTPUT

EXNO10

import numpy as np

# Given data
X = [15, 18, 21, 24, 27]
Y = [25, 25, 27, 31, 32]

# Calculate correlation coefficient

correlation_matrix = np.corrcoef(X, Y)
correlation_coefficient = correlation_matrix[0, 1]

print("Correlation Coefficient:", correlation_coefficient)

OUTPUT
Correlation Coefficient: 0.9534625892455922

[Program finished]

EXNO11

import numpy as np
import matplotlib.pyplot as plt

# Data
X = np.array([1, 2, 3.4, 5.6, 7, 8, 9, 10])
Y = np.array([3, 2, 5, 7, 8, 8, 9, 10])

# Linear regression calculation

m, b = np.polyfit(X, Y, 1) # slope and intercept

# Predicted Y values
Y_pred = m * X + b

# Plot
plt.scatter(X, Y, color='blue', label='Data')
plt.plot(X, Y_pred, color='red', label='Regression Line')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Simple Linear Regression')
plt.legend()
plt.grid(True)
plt.show()

OUTPUT
EXNO12

from sklearn.linear_model import LinearRegression

# Sample data: X = input (hours), y = output (marks)

X = [[1], [2], [3], [4], [5]]
y = [10, 20, 30, 40, 50]

# Create and train model

model = LinearRegression()
model.fit(X, y)

# Predict
prediction = model.predict([[6]])
print("Predicted value for 6:", prediction[0])

# Model details
print("Slope:", model.coef_[0])
print("Intercept:", model.intercept_)

OUTPUT

Predicted value for 6: 60.00000000000001

Slope: 10.000000000000002
Intercept: -7.105427357601002e-15

[Program finished]

EXNO13
import pandas as pd
import numpy as np

# Corrected dictionary
exam_data = {
'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily',
'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],
'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],
'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
'qualify': ['yes', 'no', 'yes', 'no', 'no',
'yes', 'yes', 'no', 'no', 'yes']
}

# Labels for index

labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Create DataFrame
df = pd.DataFrame(exam_data, index=labels)

# Display the DataFrame

print(df)

OUTPUT
name score attempts qualify
a Anastasia 12.5 1 yes
b Dima 9.0 3 no
c Katherine 16.5 2 yes
d James NaN 3 no
e Emily 9.0 2 no
f Michael 20.0 3 yes
g Matthew 14.5 1 yes
h Laura NaN 1 no
i Kevin 8.0 2 no
j Jonas 19.0 1 yes
[Program finished]

EXNO14

import numpy as np

# Original dictionary
data = {
'column0': {'a':1, 'b':0.0, 'c':0.0, 'd': 2.0},
'column1': {'a':3.0, 'b':1, 'c':0.0, 'd': -1.0},
'column2': {'a':4, 'b':1, 'c':5.0, 'd': -1.0},
'column3': {'a':3.0, 'b': -1.0, 'c': -1.0, 'd': -1.0}
}

print("Original dictionary:")
print(data)
print("Type:", type(data))

# Extract keys to keep consistent order

keys = ['a', 'b', 'c', 'd']

# Build list of lists: rows correspond to keys, columns correspond to the dictionary keys
array_data = [[data[col][k] for col in data] for k in keys]

# Convert to NumPy array

nd_array = np.array(array_data)

print("\nndarray:")
print(nd_array)
print("Type:", type(nd_array))

OUTPUT
Original dictionary:
{'column0': {'a': 1, 'b': 0.0, 'c': 0.0, 'd': 2.0}, 'column1': {'a': 3.0, 'b': 1, 'c': 0.0, 'd': -1.0},
'column2': {'a': 4, 'b': 1, 'c': 5.0, 'd': -1.0}, 'column3': {'a': 3.0, 'b': -1.0, 'c': -1.0, 'd': -1.0}}
Type: <class 'dict'>

ndarray:
[[ 1. 3. 4. 3.]
[ 0. 1. 1. -1.]
[ 0. 0. 5. -1.]
[ 2. -1. -1. -1.]]
Type: <class 'numpy.ndarray'>

[Program finished]

EXNO15
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

X = [[2,3],[1,5],[2,8],[5,2],[6,1],[7,3],[8,5],[7,7],[8,8],[9,7]]
y = [0,0,0,1,1,1,1,1,1,1]

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

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

y_pred = model.predict(X_test)

print(f"Accuracy: {accuracy_score(y_test, y_pred)*100:.2f}%")

print("\nClassification Report:")
print(classification_report(y_test, y_pred))

OUTPUT
Accuracy: 100.00%

Classification Report:
precision recall f1-score support

0 1.00 1.00 1.00 1

1 1.00 1.00 1.00 1

accuracy 1.00 2
macro avg 1.00 1.00 1.00 2
weighted avg 1.00 1.00 1.00 2

[Program finished]

EXNO16
import pandas as pd

# Sample DataFrame
data = {
'col1': [0, 1, 2, 3, 4],
'col2': [1, 2, 3, 4, 7],
'col3': [4, 5, 6, 9, 1]
}

df = pd.DataFrame(data)
print("Original DataFrame")
print(df)
# Select all columns except 'col3'
df_except_col3 = df.loc[:, df.columns != 'col3']

print("\nAll columns except col3:")

print(df_except_col3)

OUTPUT
Original DataFrame
col1 col2 col3
0 0 1 4
1 1 2 5
2 2 3 6
3 3 4 9
4 4 7 1

All columns except col3:

col1 col2
0 0 1
1 1 2
2 2 3
3 3 4
4 4 7

[Program finished]

EXNO17
import pandas as pd
from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt

# Sample time series data (e.g., 12 monthly values)

data = [10, 12, 13, 15, 16, 18, 20, 21, 22, 24, 25, 27]

# Prepare the data: X = time steps, y = values

X = np.array(range(len(data))).reshape(-1, 1) # [[0],[1],...]
y = np.array(data)

# Fit a simple linear regression model

model = LinearRegression()
model.fit(X, y)

# Predict the next 3 future values

future_steps = np.array(range(len(data), len(data)+3)).reshape(-1, 1)
future_preds = model.predict(future_steps)

# Plot the original data and predictions

plt.plot(X, y, label='Original Data')
plt.plot(future_steps, future_preds, 'ro--', label='Forecast')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.show()

print("Future predicted values:", future_preds)

OUTPUT

EXNO18
import pandas as pd
import matplotlib.pyplot as plt

# Sample data
data = [12, 15, 14, 15, 19, 21, 18, 17, 16, 15, 14, 19, 22, 24, 25, 21, 23, 20]
# Create a DataFrame
df = pd.DataFrame(data, columns=['Values'])

# Plot histogram (frequency distribution)

plt.figure(figsize=(8, 4))
plt.hist(df['Values'], bins=5, edgecolor='black')
plt.title('Frequency Distribution of Sample Data')
plt.xlabel('Value Ranges')
plt.ylabel('Frequency')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

OUTPUT

EXNO19

import numpy as np
# Define three NumPy arrays with the same shape
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])
array3 = np.array([[9, 10], [11, 12]])

# Merge the arrays along a new axis (depth-wise)

merged_array = np.stack((array1, array2, array3), axis=0)

print("Merged Array:\n", merged_array)

OUTPUT
Merged Array:
[[[ 1 2]
[ 3 4]]

[[ 5 6]
[ 7 8]]

[[ 9 10]
[11 12]]]

[Program finished]

EXNO20

import pandas as pd
import numpy as np

data = {
'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily',
'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],
'score': [12.5, 9.0, 16.5, np.nan, 9.0, 20.0, 14.5, np.nan, 8.0, 19.0],
'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']
}
df = pd.DataFrame(data, index=list('abcdefghij'))
print("Number of attempts in the examination is greater than 2:")
print(df[df.attempts > 2])

OUTPUT
Number of attempts in the examination is greater than 2:
name score attempts qualify
b Dima 9.0 3 no
d James NaN 3 no
f Michael 20.0 3 yes

[Program finished]