# Using pip
pip install numpy pandas matplotlib seaborn scikit-learn jupyter
 
# Using conda
conda create -n datasci python=3.9
conda activate datasci
conda install numpy pandas matplotlib seaborn scikit-learn jupyter

# Basic data types
x = 10                # Integer
y = 3.14              # Float
name = "Data Science" # String
is_valid = True       # Boolean
 
# Data structures
my_list = [1, 2, 3, 4, 5]           # List (mutable)
my_tuple = (1, 2, 3, 4, 5)          # Tuple (immutable)
my_dict = {"name": "John", "age": 30} # Dictionary (key-value pairs)
my_set = {1, 2, 3, 4, 5}            # Set (unique values)
 
print(f"Working with {name} using Python!")

# Conditional statements
age = 25
if age >= 18:
    print("Adult")
else:
    print("Minor")
 
# Loops
for i in range(5):
    print(i)
 
names = ["Alice", "Bob", "Charlie"]
for name in names:
    print(name)
 
# List comprehensions
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Basic function
def greet(name):
    return f"Hello, {name}!"
 
# Function with default parameter
def power(base, exponent=2):
    return base ** exponent
 
print(greet("Data Scientist"))  # Hello, Data Scientist!
print(power(3))                 # 9 (3^2)
print(power(2, 3))              # 8 (2^3)

import numpy as np
 
# Creating arrays
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.zeros((3, 3))
arr3 = np.ones((2, 4))
arr4 = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
arr5 = np.linspace(0, 1, 5)  # [0, 0.25, 0.5, 0.75, 1]
 
# Array operations
arr = np.array([1, 2, 3, 4, 5])
print(arr * 2)        # [2, 4, 6, 8, 10]
print(arr ** 2)       # [1, 4, 9, 16, 25]
print(np.sqrt(arr))   # [1., 1.41421356, 1.73205081, 2., 2.23606798]
 
# Matrix operations
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
print(matrix1 + matrix2)  # Element-wise addition
print(np.dot(matrix1, matrix2))  # Matrix multiplication

import pandas as pd
 
# Creating DataFrames
data = {
    'Name': ['John', 'Anna', 'Peter', 'Linda'],
    'Age': [28, 24, 35, 32],
    'City': ['New York', 'Paris', 'Berlin', 'London']
}
df = pd.DataFrame(data)
print(df)
 
# Reading data
# df = pd.read_csv('data.csv')
# df = pd.read_excel('data.xlsx')
 
# Basic operations
print(df.head())  # First 5 rows
print(df.describe())  # Statistical summary
print(df['Name'])  # Selecting a column
print(df[df['Age'] > 30])  # Filtering rows
 
# Data cleaning
df_clean = df.dropna()  # Remove rows with missing values
df_filled = df.fillna(0)  # Fill missing values with 0
 
# Grouping and aggregation
result = df.groupby('City').mean()
print(result)

import matplotlib.pyplot as plt
import seaborn as sns
 
# Basic plotting with Matplotlib
x = np.linspace(0, 10, 100)
y = np.sin(x)
 
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2)
plt.title('Sine Wave')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.grid(True)
plt.savefig('sine_wave.png')
plt.show()
 
# Statistical visualization with Seaborn
sns.set_style("whitegrid")
tips = sns.load_dataset("tips")
 
plt.figure(figsize=(12, 6))
sns.boxplot(x="day", y="total_bill", data=tips)
plt.title('Total Bill by Day')
plt.show()
 
# More Seaborn plots
plt.figure(figsize=(12, 6))
sns.histplot(tips['total_bill'], kde=True)
plt.title('Distribution of Total Bill')
plt.show()
 
plt.figure(figsize=(12, 6))
sns.scatterplot(x="total_bill", y="tip", hue="day", data=tips)
plt.title('Tips vs Total Bill by Day')
plt.show()

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
 
# Load dataset
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
 
# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
# Standardize features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
 
# Train model
model = LogisticRegression(max_iter=200)
model.fit(X_train_scaled, y_train)
 
# Make predictions
y_pred = model.predict(X_test_scaled)
 
# Evaluate model
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))
print("\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Import libraries
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.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
 
# Load dataset (replace with your dataset)
# df = pd.read_csv('housing.csv')
 
# For this example, we'll create synthetic data
np.random.seed(42)
n_samples = 1000
X = np.random.rand(n_samples, 5) * 10  # 5 features
y = 3*X[:, 0] + 2*X[:, 1] - X[:, 2] + 0.5*X[:, 3] - 1.5*X[:, 4] + np.random.normal(0, 1, n_samples)
 
df = pd.DataFrame(X, columns=['feature1', 'feature2', 'feature3', 'feature4', 'feature5'])
df['target'] = y
 
# Exploratory data analysis
print(df.head())
print(df.describe())
 
# Check for missing values
print(df.isnull().sum())
 
# Data visualization
plt.figure(figsize=(12, 8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Matrix')
plt.show()
 
# Feature selection
X = df.drop('target', axis=1)
y = df['target']
 
# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
# Train model
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
 
# Make predictions
y_pred = model.predict(X_test)
 
# Evaluate model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"Mean Squared Error: {mse:.4f}")
print(f"R² Score: {r2:.4f}")
 
# Feature importance
feature_importance = pd.DataFrame({
    'Feature': X.columns,
    'Importance': model.feature_importances_
}).sort_values('Importance', ascending=False)
 
plt.figure(figsize=(10, 6))
sns.barplot(x='Importance', y='Feature', data=feature_importance)
plt.title('Feature Importance')
plt.tight_layout()
plt.show()