Zero External Library Python Project Collection: A Journey from Basic Calculator to Native Implementation of Neural Networks

This open-source repository contains 15 progressive Python projects implemented without any external libraries, covering from simple CLI calculators to linear regression and neural networks. It helps developers deeply understand the essence of algorithms.

Source Info:

• Author/Maintainer: sohmh
• Platform: GitHub
• Repo Name: Manual-Python-Projects-No-Libraries
• Link: https://github.com/sohmh/Manual-Python-Projects-No-Libraries
• Release Time: 2026-06-14

The core idea of this project is 'understand from scratch'. A classic saying in CS education: If you can't implement an algorithm from scratch in a language, you don't truly understand it. This repo requires using only Python standard libraries to build classic algorithms and tools.

Reasons for zero external libraries:

1. Deepen principle understanding (e.g., implement matrix operations manually to grasp linear algebra)
2. Cultivate algorithm intuition (e.g., feel the impact of hyperparameters like learning rate in gradient descent)
3. Interview preparation (handwriting algorithms for whiteboard coding)
4. Lightweight deployment (easier to run in various environments without dependencies)

The 15 projects are arranged in 4 stages of increasing difficulty:

1. Programming Basics (Projects 1-5): CLI calculator (stack, infix to postfix), text analysis (word frequency, longest word), file encryption (Caesar cipher, bit operations), sudoku solver (backtracking), maze generation/solving (DFS/BFS)

2. Data Structures & Algorithms (Projects6-10): Custom data structures (linked list, stack, queue, binary tree), sorting algorithms (bubble, quick, merge, heap), graph algorithms (Dijkstra, A*), regex engine (finite automata), compression (Huffman/LZW)

3. ML Basics (Projects11-13): KNN (distance metrics, feature normalization), K-means (iterative optimization), linear regression (least squares, gradient descent)

4. Deep Learning (Projects14-15): Multi-layer Perceptron (MLP, forward/backward prop), CNN basics (convolution/pooling layers)

Linear Regression

• Math: Loss function J(θ) = (1/2m)Σ(h(x_i)-y_i)², where h(x)=θ₀+θ₁x₁+...+θₙxₙ
• Methods: Normal equation (θ=(XᵀX)⁻¹Xᵀy, need matrix inversion via Gaussian elimination/LU decomposition) and gradient descent (θ:=θ-α∇J(θ))
• Difficulties: Manual matrix operations (no NumPy), numerical stability (singular matrix handling), convergence judgment, feature scaling

MLP

• Architecture: Input layer → hidden layers (with activation) → output layer
• Forward Prop: z[l] = W[l]·a[l-1]+b[l], a[l] = g(z[l]) (g=activation)
• Backward Prop: Compute gradients via chain rule (output layer → hidden layers), update weights/biases
• Activation Functions: Sigmoid (σ(x)=1/(1+e⁻ˣ)), ReLU (max(0,x)), Tanh

After completing these projects, you gain:

1. Solid algorithm foundation: Understand why models work (not just how to use them)
2. Numerical intuition: Feel for numerical stability, computational complexity, memory usage
3. Code organization skills: Modular design, interface definition, error handling
4. Interview competitiveness: Prepare for algorithm handwriting and principle questions

Practice Tips

1. Try implementing first before referencing
2. Compare with standard libraries (NumPy, Scikit-learn) to understand design choices and performance differences
3. Write unit tests for each function
4. Visualize results via ASCII art or text files (e.g., loss curves)
5. Take notes on learned points, difficulties, and solutions

Advanced Directions

1. Performance optimization (C extensions, Numba)
2. GPU support (PyOpenCL, CUDA Python)
3. Auto-differentiation framework (like PyTorch's autograd)
4. Distributed training (data/model parallel)
5. More models (RNN, LSTM, Transformer)