My Python Learning Journey

Welcome to my Python learning series! As a finance professional exploring programming, I’m documenting my entire journey through 17 posts that take you from absolute beginner to building practical applications.

What to Expect from This Series

This series is designed for fellow finance professionals and beginners who want to learn Python in a practical, step-by-step manner. Each post builds on previous concepts while introducing new skills.

Series Overview

Here’s what we’ll cover throughout the 17 posts:

Foundations (Posts 1–6)

1. Getting Started with Python on Windows

  • What is Python, why learn it, and where it’s used
  • Installing Python (step‑by‑step Windows installer with screenshots)
  • Quick pointers for macOS/Linux installs
  • Your first “Hello, World!” script
  • Exploring the interactive REPL (shell)

2. Text Editors vs. IDEs for Python Development

  • Lightweight editors (Notepad++, Sublime) vs. full IDEs (VS Code, PyCharm)
  • Setting up VS Code for Python (extensions, linting, auto‑format)
  • Code highlighting, IntelliSense/autocomplete, and snippets
  • Running and debugging code from your editor
  • Quick intro to IDE‑based breakpoints vs. print‑driven debugging

3. Python Syntax Fundamentals & Language Features

  • Variables, data types (numbers, strings, booleans) and operators
  • Indentation and control flow (if/elif/else, loops)
  • Comprehensions & lambdas: list/dict/set comprehensions, map/filter, anonymous functions
  • Iterators & generators: the iterator protocol, writing your own with yield
  • Basic error handling: try/except, else/finally

4. Core Data Structures

  • Lists: creation, indexing, slicing, methods
  • Tuples: immutability, packing/unpacking
  • Dictionaries: key–value access, common methods
  • Sets: uniqueness, union/intersection/difference
  • Choosing the right structure for the task

5. Functions, Modules & File I/O

  • Defining and calling functions (def, return, positional vs. keyword args)
  • Variable scope and namespaces
  • Organising code into modules and packages
  • Exploring the Standard Library (math, random, datetime, os, sys)
  • Reading from/writing to text files with open() and the with statement

6. Virtual Environments & Packaging

  • Why virtual environments matter (avoiding dependency conflicts)
  • Creating/activating/deactivating venv on Windows (and notes for macOS/Linux)
  • Managing packages with pip: install, freeze, requirements.txt
  • Basic packaging: project structure, setup.py/pyproject.toml essentials
  • Publishing to PyPI with twine and versioning best practices

Professional Best Practices (Posts 7–9)

7. Code Quality & Collaboration

  • Version control fundamentals with Git & GitHub (clone, commit, push, pull requests)
  • Writing clean, PEP 8‑compliant code; linting with flake8
  • Auto‑formatting with black and organising imports with isort
  • Writing docstrings (Google vs. NumPy style) and auto‑generating docs (Sphinx overview)

8. Testing & Debugging

  • Unit testing basics with unittest and pytest (assertions, test discovery)
  • Fixtures in pytest and intro to TDD workflows
  • Raising and defining custom exceptions (raise, subclassing Exception)
  • Using the debugger: pdb commands and IDE‑based breakpoints
  • Structured logging with the logging module (levels, handlers, formatting)

9. Command‑Line Tools & Automation

  • Building CLI scripts with argparse: positional args, flags, help text
  • Packaging entry points (console_scripts) for installable commands
  • Automating file/folder tasks (os, shutil): renaming, organising, backups
  • Automating GUI interactions with PyAutoGUI (keyboard/mouse control)
  • Putting it all together in a sample automation project

Core Tools & Data (Posts 10–13)

10. The Python Ecosystem & Interactive Data Workflows

  • Clarify package vs. environment managers: pip vs. conda vs. Anaconda
  • When and why to choose each (lightweight vs. data‑science bundles)
  • Installing and exploring Anaconda Navigator
  • Jupyter Notebooks: installing via pip/Anaconda, notebook anatomy (code vs. Markdown), basic plots inline

11. NumPy Fundamentals for Numerical Data

  • Installing NumPy
  • The ndarray: creation, indexing, slicing
  • Vectorized operations and broadcasting rules
  • Performance comparison vs. pure Python lists

12. Data Analysis with pandas

  • Installing pandas
  • Understanding Series and DataFrame objects
  • Reading data (CSV, Excel), inspecting and summarising
  • Selection, filtering, grouping, transformation
  • Handling missing data

13. Data Visualisation Basics

  • Matplotlib core: line, scatter, bar, histogram plots
  • Customising labels, titles, legends
  • Seaborn intro: statistical plot types (boxplot, heatmap)
  • Saving figures to files for reports

Intermediate Applications (Posts 14–17)

14. Introduction to Object‑Oriented Programming (OOP)

  • Classes vs. objects, attributes vs. methods
  • The init constructor and self
  • Encapsulation, inheritance and polymorphism (simple examples)
  • Why OOP matters: organising and reusing code

15. Web Development Foundations

  • Option A: Flask (lightweight): setting up, routes, templates, serving static files
  • Option B: Django (full‑featured): project/app structure, admin interface, ORM intro
  • Option C: Web Scraping: requests + BeautifulSoup for HTML parsing
  • Deploying your first minimal web app on a free hosting platform (e.g., Heroku)

16. Building Simple GUI Applications with Tkinter

  • Installing/importing Tkinter (built‑in)
  • Creating windows, labels, buttons, entry widgets
  • Layout managers (pack, grid)
  • A hands‑on mini‑project: e.g., basic calculator or temperature converter

17. Next Steps & Advanced Topics

  • Concurrency & async: when to use threads vs. processes (threading, multiprocessing), intro to asyncio
  • End‑to‑end mini‑project ideas (combine web, data, GUI, testing)
  • Recommended books, courses, blogs, and community resources
  • Tips for staying sharp: code challenges, open‑source contribution, local meetups