scikit-tools 0.1.2__tar.gz → 0.2.1__tar.gz

scikit_tools-0.2.1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: scikit-tools
+Version: 0.2.1
+Summary: Thirteen runnable, straight-through scikit-learn and data-analysis examples
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ipython
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: seaborn
+
+# scikit-tools
+
+`scikit-tools` provides 13 standalone, runnable Python examples for machine learning and data analysis. Each topic contains its own imports, dataset setup, and analysis code.
+
+## Installation
+
+```console
+pip install scikit-tools
+```
+
+Or from a local checkout:
+
+```console
+python -m pip install -e .
+```
+
+## How to Use
+
+### 1. Inspect the Raw Source Code Without Running
+Importing `scikit_tools` does not execute any calculations or open plots. You can access the complete standalone source code of any topic using `inspect`:
+
+```python
+import inspect
+import scikit_tools as st
+
+# Prints the full raw code to the terminal
+print(inspect.getsource(st.pca))
+print(inspect.getsource(st.linear_regression))
+```
+
+### 2. Run Directly in Python
+Call any topic function directly:
+
+```python
+import scikit_tools as st
+
+st.pca()
+st.numpy_stats()
+```
+
+### 3. Run from Command Line
+Run any topic as a standalone module:
+
+```console
+python -m scikit_tools.pca
+python -m scikit_tools.numpy_stats
+```
+
+## Topics Available
+
+1. NumPy statistics (`st.numpy_stats`)
+2. Inspecting the Iris dataset (`st.inspect_dataset`)
+3. Handling missing values (`st.missing_values`)
+4. Data transformation (`st.data_transformation`)
+5. Histogram and scatter-plot EDA (`st.eda_plots`)
+6. Box plot and IQR outlier detection (`st.outlier_detection`)
+7. Descriptive statistics (`st.descriptive_stats`)
+8. Correlation and covariance (`st.correlation_covariance`)
+9. Independent-samples t-test (`st.hypothesis_testing`)
+10. Linear regression (`st.linear_regression`)
+11. Logistic-regression classification (`st.logistic_regression`)
+12. K-means clustering (`st.kmeans_clustering`)
+13. PCA and classification (`st.pca`)
+
+All examples load the Iris dataset via `sklearn.datasets.load_iris(as_frame=True)` with standardized column names (`SepalLengthCm`, `SepalWidthCm`, `PetalLengthCm`, `PetalWidthCm`, `Species`).

scikit_tools-0.2.1/README.md

@@ -0,0 +1,32 @@
+# IEEEXtreme Python Toolkit & OA / DSA Practice
+
+A reusable, contest-oriented reference library and practice repository for advanced DSA, Online Assessments (OA), and competition simulations.
+
+## DSA & OA Practice Problems
+
+| # | Problem | Key Topics & Algorithms | Solutions |
+|---|---|---|---|
+| 01 | [Tree Vector Norm Maximization](problems/tree_vector_norm/EXPLANATION.md) | Tree DP, Convex Duality, QuickHull, Branch-and-Bound Pruning | [Python](problems/tree_vector_norm/solution.py), [C++](problems/tree_vector_norm/solution.cpp), [Tests](problems/tree_vector_norm/test_solution.py) |
+
+## Toolkit Contents
+
+- `template.py` — compact starting template suitable for copying into an editor.
+- `io_utils.py` — fast token input, parsing, and output helpers.
+- `sorting_searching.py`, `two_pointers.py` — common array patterns.
+- `data_structures.py` — DSU, Fenwick and segment trees, trie, monotonic structures.
+- `graphs.py`, `advanced_graphs.py` — traversals, shortest paths, MST, SCC, bridges, LCA, Euler tours.
+- `dynamic_programming.py`, `number_theory.py`, `combinatorics.py`, `strings.py`, `geometry.py`, `bitwise.py`, `backtracking.py`.
+- `docs/` — API notes, assumptions, and complexity guide.
+- `tests/` — unit tests for representative edge cases and algorithms.
+- `category_templates.py` — focused patterns mapped to every category visible in the supplied screenshot.
+- `docs/category-map.md` — category-to-snippet index, archive research notes, and platform-use boundary.
+
+## Use
+
+Copy `template.py` as the actual contest starting file, then add only the needed algorithm snippets. Import library code locally while practicing, for example `from graphs import dijkstra`. Some contest editors accept only one submitted file, so copy required functions/classes into that file when needed. No package installation is required.
+
+Run checks from this directory with `python -m unittest discover -s tests -v`.
+
+## Notes
+
+These are general algorithms, not task-specific solutions. Check each docstring for indexing, weight, and input assumptions. Python integers are arbitrary precision. Graph vertices and sequence positions are zero-indexed unless stated otherwise. Dijkstra requires nonnegative edge weights. The library is for local reference and practice; platform upload availability and competition rules are determined by the platform/organizers.

scikit_tools-0.2.1/SCIKIT_TOOLS.md

@@ -0,0 +1,65 @@
+# scikit-tools
+
+`scikit-tools` provides 13 standalone, runnable Python examples for machine learning and data analysis. Each topic contains its own imports, dataset setup, and analysis code.
+
+## Installation
+
+```console
+pip install scikit-tools
+```
+
+Or from a local checkout:
+
+```console
+python -m pip install -e .
+```
+
+## How to Use
+
+### 1. Inspect the Raw Source Code Without Running
+Importing `scikit_tools` does not execute any calculations or open plots. You can access the complete standalone source code of any topic using `inspect`:
+
+```python
+import inspect
+import scikit_tools as st
+
+# Prints the full raw code to the terminal
+print(inspect.getsource(st.pca))
+print(inspect.getsource(st.linear_regression))
+```
+
+### 2. Run Directly in Python
+Call any topic function directly:
+
+```python
+import scikit_tools as st
+
+st.pca()
+st.numpy_stats()
+```
+
+### 3. Run from Command Line
+Run any topic as a standalone module:
+
+```console
+python -m scikit_tools.pca
+python -m scikit_tools.numpy_stats
+```
+
+## Topics Available
+
+1. NumPy statistics (`st.numpy_stats`)
+2. Inspecting the Iris dataset (`st.inspect_dataset`)
+3. Handling missing values (`st.missing_values`)
+4. Data transformation (`st.data_transformation`)
+5. Histogram and scatter-plot EDA (`st.eda_plots`)
+6. Box plot and IQR outlier detection (`st.outlier_detection`)
+7. Descriptive statistics (`st.descriptive_stats`)
+8. Correlation and covariance (`st.correlation_covariance`)
+9. Independent-samples t-test (`st.hypothesis_testing`)
+10. Linear regression (`st.linear_regression`)
+11. Logistic-regression classification (`st.logistic_regression`)
+12. K-means clustering (`st.kmeans_clustering`)
+13. PCA and classification (`st.pca`)
+
+All examples load the Iris dataset via `sklearn.datasets.load_iris(as_frame=True)` with standardized column names (`SepalLengthCm`, `SepalWidthCm`, `PetalLengthCm`, `PetalWidthCm`, `Species`).

scikit_tools-0.2.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scikit-tools"
+version = "0.2.1"
+description = "Thirteen runnable, straight-through scikit-learn and data-analysis examples"
+readme = "SCIKIT_TOOLS.md"
+requires-python = ">=3.10"
+dependencies = [
+    "ipython",
+    "matplotlib",
+    "numpy",
+    "pandas",
+    "scikit-learn",
+    "scipy",
+    "seaborn",
+]
+
+[tool.setuptools]
+packages = ["scikit_tools"]

scikit_tools-0.2.1/scikit_tools/__init__.py

@@ -0,0 +1,32 @@
+"""Runnable, straight-through examples for 13 scikit-learn/data-analysis topics."""
+
+import importlib
+
+__all__ = [
+    "correlation_covariance",
+    "data_transformation",
+    "descriptive_stats",
+    "eda_plots",
+    "hypothesis_testing",
+    "inspect_dataset",
+    "kmeans_clustering",
+    "linear_regression",
+    "logistic_regression",
+    "missing_values",
+    "numpy_stats",
+    "outlier_detection",
+    "pca",
+]
+
+
+def __getattr__(name: str):
+    if name in __all__:
+        module = importlib.import_module(f".{name}", __name__)
+        func = getattr(module, name)
+        globals()[name] = func
+        return func
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(list(globals().keys()) + __all__)

scikit_tools-0.2.1/scikit_tools/correlation_covariance.py

@@ -0,0 +1,24 @@
+def correlation_covariance():
+    import pandas as pd
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    covariance_val = df['PetalLengthCm'].cov(df['PetalWidthCm'])
+    correlation_val = df['PetalLengthCm'].corr(df['PetalWidthCm'])
+
+    print(f"Covariance: {covariance_val:.4f}")
+    print(f"Correlation Coefficient: {correlation_val:.4f}")
+
+
+if __name__ == '__main__':
+    correlation_covariance()

scikit_tools-0.2.1/scikit_tools/data_transformation.py

@@ -0,0 +1,31 @@
+def data_transformation():
+    import pandas as pd
+    from IPython.display import display
+    from sklearn.datasets import load_iris
+    from sklearn.preprocessing import StandardScaler
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    # One-hot encoding for Species
+    df_encoded = pd.get_dummies(df, columns=['Species'])
+
+    # Standardize numerical attributes
+    num_cols = ['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']
+    scaler = StandardScaler()
+    df_encoded[num_cols] = scaler.fit_transform(df_encoded[num_cols])
+
+    print("--- Transformed Data Preview ---")
+    display(df_encoded.head())
+
+
+if __name__ == '__main__':
+    data_transformation()

scikit_tools-0.2.1/scikit_tools/descriptive_stats.py

@@ -0,0 +1,29 @@
+def descriptive_stats():
+    import pandas as pd
+    from IPython.display import display
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    attributes = ['SepalLengthCm', 'PetalLengthCm']
+    stats_summary = pd.DataFrame({
+        'Mean': df[attributes].mean(),
+        'Median': df[attributes].median(),
+        'Sample Variance': df[attributes].var(),
+        'Standard Deviation': df[attributes].std()
+    })
+
+    display(stats_summary)
+
+
+if __name__ == '__main__':
+    descriptive_stats()

scikit_tools-0.2.1/scikit_tools/eda_plots.py

@@ -0,0 +1,39 @@
+def eda_plots():
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    plt.figure(figsize=(14, 5))
+
+    # Histogram
+    plt.subplot(1, 2, 1)
+    sns.histplot(data=df, x='PetalLengthCm', kde=True, color='skyblue')
+    plt.title('Histogram of PetalLengthCm')
+    plt.xlabel('Petal Length (cm)')
+    plt.ylabel('Frequency')
+
+    # Scatter Plot
+    plt.subplot(1, 2, 2)
+    sns.scatterplot(data=df, x='SepalLengthCm', y='PetalLengthCm', hue='Species', palette='Set1')
+    plt.title('SepalLengthCm vs PetalLengthCm')
+    plt.xlabel('Sepal Length (cm)')
+    plt.ylabel('Petal Length (cm)')
+
+    plt.tight_layout()
+    plt.show()
+
+
+if __name__ == '__main__':
+    eda_plots()

scikit_tools-0.2.1/scikit_tools/hypothesis_testing.py

@@ -0,0 +1,27 @@
+def hypothesis_testing():
+    import pandas as pd
+    from scipy import stats
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    setosa_sepal = df[df['Species'] == 'Iris-setosa']['SepalLengthCm']
+    versicolor_sepal = df[df['Species'] == 'Iris-versicolor']['SepalLengthCm']
+
+    t_stat, p_val = stats.ttest_ind(setosa_sepal, versicolor_sepal, equal_var=False)
+
+    print(f"T-statistic: {t_stat:.4f}")
+    print(f"P-value: {p_val:.4e}")
+
+
+if __name__ == '__main__':
+    hypothesis_testing()

scikit_tools-0.2.1/scikit_tools/inspect_dataset.py

@@ -0,0 +1,33 @@
+def inspect_dataset():
+    import pandas as pd
+    from IPython.display import display
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    print("--- First 5 Records ---")
+    display(df.head())
+
+    print(f"\nNumber of rows: {df.shape[0]}, Number of columns: {df.shape[1]}")
+
+    print("\n--- Column Names & Data Types ---")
+    print(df.dtypes)
+
+    print("\n--- Summary Statistics ---")
+    display(df.describe())
+
+    print("\nNumerical attributes: SepalLengthCm, SepalWidthCm, PetalLengthCm, PetalWidthCm")
+    print("Target column: Species")
+
+
+if __name__ == '__main__':
+    inspect_dataset()

scikit_tools-0.2.1/scikit_tools/kmeans_clustering.py

@@ -0,0 +1,34 @@
+def kmeans_clustering():
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    from IPython.display import display
+    from sklearn.datasets import load_iris
+    from sklearn.cluster import KMeans
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
+
+    kmeans = KMeans(n_clusters=3, random_state=42, n_init='auto')
+    df['Cluster'] = kmeans.fit_predict(X)
+
+    plt.figure(figsize=(6, 4))
+    sns.scatterplot(data=df, x='SepalLengthCm', y='PetalLengthCm', hue='Cluster', palette='Set1')
+    plt.title('K-Means Clustering Assignments (k=3)')
+    plt.show()
+
+    display(df[['SepalLengthCm', 'PetalLengthCm', 'Species', 'Cluster']].head())
+
+
+if __name__ == '__main__':
+    kmeans_clustering()

scikit_tools-0.2.1/scikit_tools/linear_regression.py

@@ -0,0 +1,37 @@
+def linear_regression():
+    import pandas as pd
+    from IPython.display import display
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.linear_model import LinearRegression
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalWidthCm']]
+    y = df['PetalLengthCm']
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    model = LinearRegression()
+    model.fit(X_train, y_train)
+
+    predictions = model.predict(X_test)
+
+    print("Model Coefficients:", {col: coef for col, coef in zip(X.columns, model.coef_)})
+    print("Intercept:", model.intercept_)
+
+    results = pd.DataFrame({'Actual': y_test, 'Predicted': predictions})
+    display(results.head())
+
+
+if __name__ == '__main__':
+    linear_regression()

scikit_tools-0.2.1/scikit_tools/logistic_regression.py

@@ -0,0 +1,35 @@
+def logistic_regression():
+    import pandas as pd
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.metrics import accuracy_score, confusion_matrix
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
+    y = df['Species']
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    clf = LogisticRegression(max_iter=200)
+    clf.fit(X_train, y_train)
+
+    y_pred = clf.predict(X_test)
+
+    print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+    print("\nConfusion Matrix:")
+    print(confusion_matrix(y_test, y_pred))
+
+
+if __name__ == '__main__':
+    logistic_regression()

scikit_tools-0.2.1/scikit_tools/missing_values.py

@@ -0,0 +1,38 @@
+def missing_values():
+    import pandas as pd
+    import numpy as np
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+    df_copy = df.copy()
+
+    # Introduce missing values
+    df_copy.loc[[5, 10, 15], 'SepalLengthCm'] = np.nan
+    df_copy.loc[[20, 25], 'Species'] = np.nan
+
+    print("--- Missing Value Count Before Imputation ---")
+    print(df_copy.isnull().sum())
+
+    # Impute numerical missing values with median
+    median_sepal = df_copy['SepalLengthCm'].median()
+    df_copy['SepalLengthCm'] = df_copy['SepalLengthCm'].fillna(median_sepal)
+
+    # Impute categorical missing values with mode
+    mode_species = df_copy['Species'].mode()[0]
+    df_copy['Species'] = df_copy['Species'].fillna(mode_species)
+
+    print("\n--- Missing Value Count After Imputation ---")
+    print(df_copy.isnull().sum())
+
+
+if __name__ == '__main__':
+    missing_values()

scikit_tools-0.2.1/scikit_tools/numpy_stats.py

@@ -0,0 +1,36 @@
+def numpy_stats():
+    import pandas as pd
+    import numpy as np
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    # Select SepalLengthCm and convert to NumPy array
+    sepal_length = df['SepalLengthCm'].to_numpy()
+
+    # Calculate basic statistics
+    total_sum = np.sum(sepal_length)
+    mean_val = np.mean(sepal_length)
+    max_val = np.max(sepal_length)
+    min_val = np.min(sepal_length)
+    first_five = sepal_length[:5]
+
+    # Display results
+    print(f"Sum: {total_sum:.2f}")
+    print(f"Mean: {mean_val:.2f}")
+    print(f"Maximum: {max_val:.2f}")
+    print(f"Minimum: {min_val:.2f}")
+    print(f"First five values: {first_five}")
+
+
+if __name__ == '__main__':
+    numpy_stats()

scikit_tools-0.2.1/scikit_tools/outlier_detection.py

@@ -0,0 +1,44 @@
+def outlier_detection():
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    from IPython.display import display
+    from sklearn.datasets import load_iris
+
+    iris = load_iris(as_frame=True)
+    df = iris.data.rename(columns={
+        'sepal length (cm)': 'SepalLengthCm',
+        'sepal width (cm)': 'SepalWidthCm',
+        'petal length (cm)': 'PetalLengthCm',
+        'petal width (cm)': 'PetalWidthCm'
+    })
+    df['Species'] = iris.target.map({
+        index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+    })
+
+    # Box Plot
+    plt.figure(figsize=(6, 4))
+    sns.boxplot(y=df['SepalWidthCm'], color='lightgreen')
+    plt.title('Box Plot of SepalWidthCm')
+    plt.ylabel('Sepal Width (cm)')
+    plt.show()
+
+    # Calculate IQR & Outliers
+    Q1 = df['SepalWidthCm'].quantile(0.25)
+    Q3 = df['SepalWidthCm'].quantile(0.75)
+    IQR = Q3 - Q1
+    lower_bound = Q1 - 1.5 * IQR
+    upper_bound = Q3 + 1.5 * IQR
+
+    outliers = df[(df['SepalWidthCm'] < lower_bound) | (df['SepalWidthCm'] > upper_bound)]
+
+    print(f"Q1 (25th percentile): {Q1:.2f}")
+    print(f"Q3 (75th percentile): {Q3:.2f}")
+    print(f"IQR (Interquartile Range): {IQR:.2f}")
+    print(f"Outlier limits: {lower_bound:.2f} to {upper_bound:.2f}")
+    print(f"\nDetected Outliers:")
+    display(outliers[['SepalWidthCm', 'Species']])
+
+
+if __name__ == '__main__':
+    outlier_detection()