Tools & Libraries

# Classic Notebook
jupyter notebook

# JupyterLab (modern interface)
jupyter lab

# Open specific notebook
jupyter notebook path/to/notebook.ipynb

import numpy as np

# Create arrays
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2], [3, 4]])

# Array operations
result = arr * 2
mean = np.mean(arr)

# Linear algebra
dot_product = np.dot(matrix, matrix.T)

import pandas as pd

# Load data
df = pd.read_csv('data.csv')

# Exploration
df.head()
df.info()
df.describe()

# Manipulation
df_clean = df.dropna()
df_grouped = df.groupby('category')['value'].sum()

# Save results
df.to_csv('output.csv', index=False)

import matplotlib.pyplot as plt

# Basic plot
plt.plot(x, y)
plt.xlabel('X Label')
plt.ylabel('Y Label')
plt.title('My Plot')
plt.show()

# Subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
ax1.plot(x, y)
ax2.scatter(x, z)

# Save figure
plt.savefig('plot.png', dpi=300, bbox_inches='tight')

import seaborn as sns
import matplotlib.pyplot as plt

# Set style
sns.set_style('whitegrid')

# Statistical plots
sns.histplot(data=df, x='column', kde=True)
sns.boxplot(data=df, x='category', y='value')
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')

# Pair plot for multivariate analysis
sns.pairplot(df, hue='target')

plt.show()

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

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

# Preprocess
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train model
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# Evaluate
y_pred = model.predict(X_test_scaled)
rmse = mean_squared_error(y_test, y_pred, squared=False)
r2 = r2_score(y_test, y_pred)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Build model
model = keras.Sequential([
    layers.Flatten(input_shape=(28, 28)),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])

# Compile
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Train
history = model.fit(
    X_train, y_train,
    epochs=10,
    validation_split=0.2,
    batch_size=32
)

# Evaluate
test_loss, test_acc = model.evaluate(X_test, y_test)

# Save
model.save('model.h5')

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# Define model
class NeuralNet(nn.Module):
    def __init__(self):
        super(NeuralNet, self).__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(28*28, 128)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.2)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.flatten(x)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# Initialize
model = NeuralNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# Training loop
for epoch in range(num_epochs):
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

# Title and text
st.title('My Data App')
st.write('Welcome to my analysis!')

# Load and display data
df = pd.read_csv('data.csv')
st.dataframe(df)

# Interactive widgets
option = st.selectbox('Choose a column:', df.columns)
slider_value = st.slider('Select a value', 0, 100, 50)

# Display charts
st.line_chart(df[option])

# Matplotlib integration
fig, ax = plt.subplots()
ax.hist(df[option])
st.pyplot(fig)

streamlit run app.py