Data Science with Python-(Beginner to Advanced)-(Dec 2026 - Offline Batch)

This session walks students through setting up a complete Python development environment from scratch. It starts with installing Python itself and PyCharm as the IDE, covering the basic setup and first-run configuration. The core of the session is a deep dive into virtual environments (venv) — why they're needed, how to create and activate one, and what's actually happening inside a venv's file architecture (folders like Scripts/bin, Lib/site-packages, and the pyvenv.cfg file). By the end, students understand not just how to spin up a virtual environment, but what each piece of it does and why isolating project dependencies matters.

This session builds the vocabulary every Python program is written in. Students learn how to declare and use variables, the core built-in data types (such as integers, floats, strings, and booleans), and the full range of operators — arithmetic, comparison, logical, and assignment. The session goes in depth on the print() function for displaying output and the input() function for capturing user input, including how input is always received as a string and needs to be converted for other data types. Together, these form the basic toolkit for writing interactive, data-driven scripts.

This session covers how Python programs make decisions. It opens with short-circuit evaluation of and / or, explaining how Python stops evaluating a logical expression as soon as the result is determined, and why that matters for both performance and writing safe conditional checks. From there, the session goes in depth into if-else statements for branching logic, and finishes with Python's match-case statement (structural pattern matching) as a modern, often cleaner alternative to long if-elif chains. Students come away able to write programs that respond differently based on data and conditions.

This session introduces lists, one of Python's most commonly used data structures, and the operations that come with them — creating, indexing, slicing, adding, removing, and modifying elements. It then connects lists to iteration by introducing the for loop, showing how to loop over a list's elements and combine looping with list operations to process collections of data efficiently.

This session takes a deep dive into tuples as a data structure, covering how to create and work with them alongside their core operations. The main focus is a direct comparison between lists and tuples, and the concepts of mutability and immutability — why tuples can't be changed after creation, what that means in practice, and when to choose a tuple over a list (and vice versa) in real code.

Module exam for the Fundamentals module. It checks the core concepts covered in sessions 1 to 5: environment and virtual-environment setup, variables, data types and operators, input and output, decision-making with if-else and match-case, lists and the for loop, and tuples with mutability versus immutability. Students solve the exam paper and upload their answers.

Learn how to define functions, work with different types of parameters, and return values effectively.

Explore functional programming in Python using lambda expressions and the map, filter, and reduce functions

Learn to anticipate and handle errors gracefully using try-except blocks for more robust code.

Get introduced to NumPy's N-D arrays and perform core mathematical and logical operations directly on them.

Understand array shapes and axis-based operations, then leverage broadcasting and vectorization to write faster, more efficient NumPy code.

A deeper look at how to think in arrays rather than loops. Students practise reading and reshaping array dimensions, understand how the axis argument changes the result of sum, mean and other aggregations, and work through worked examples that turn element-by-element loops into short, fast array expressions.

An introduction to Pandas and its two core structures, Series and DataFrame. Students learn to load data from files, inspect and describe it, select rows and columns, filter, sort, group and summarise, and get a complete overview of what Pandas can do for everyday data analysis.

This session combines NumPy and Pandas in one workflow: moving data between DataFrames and arrays, preparing data for numerical work, and using NumPy for the heavy calculations. It also covers matrix multiplication — how it works, how to perform it with NumPy, and where it shows up in data science.

Module exam for the Intermediate module. It checks functions and parameters, lambda with map, filter and reduce, exception handling, NumPy arrays, shapes, axis and broadcasting, and the basics of Pandas covered in sessions 7 to 14. Students solve the exam paper and upload their answers.

An introduction to data visualization with Matplotlib. Students learn the basic building blocks — figures, axes, titles, labels and legends — and create their first simple line chart from a small data set.

A deeper look at line charts — multiple lines, line styles, markers, colours, grids and annotations — followed by scatter plots for showing relationships between two variables and spotting patterns and outliers.

This session covers bar charts for comparing categories (vertical, horizontal, grouped and stacked) and histograms for understanding the distribution of numeric data, including how bins affect what the chart shows and when to use each chart type.

Learn to build pie charts in Matplotlib to show parts of a whole — labels, percentages, colours, exploding slices — and understand when a pie chart is the right choice and when another chart is clearer.

An introduction to Seaborn, the statistical visualization library built on top of Matplotlib. Using worked examples, students create more polished charts with less code, apply themes and colour palettes, and plot directly from Pandas DataFrames.

A hands-on project session. Students are given a data set and use Python, Pandas and Matplotlib / Seaborn to clean the data, decide which charts best answer the questions it raises, and create a set of visualizations from it.

Students present the visualization project built in the previous session. The instructor reviews the choice of charts, the correctness of the code and the clarity of the results, and gives feedback on how to improve them.

A beginner-friendly overview of machine learning: what it is, how it differs from traditional programming, the main types (supervised, unsupervised and reinforcement learning), the typical workflow from data to trained model, and common real-world applications.

A practical introduction to Scikit-Learn. Students work through an end-to-end example: loading a data set, splitting it into training and test sets, training a model, making predictions and evaluating the results, which makes the machine learning workflow concrete.

An overview of object-oriented programming in Python. Students learn why OOP is used, how to define classes with attributes and methods, how to create objects from them, and how the constructor and self work.

Understand data abstraction — exposing what an object does while hiding how it does it. The session covers abstract classes and abstract methods in Python and how they define a common interface that other classes must implement.

Learn encapsulation — bundling data and the methods that work on it inside a class and controlling access to it. The session covers public, protected and private members, getters and setters, and the property decorator.

Learn polymorphism — the ability of different classes to be used through the same interface. The session covers method overriding, duck typing and operator overloading, with examples of writing flexible code that works with many object types.

Learn inheritance — creating new classes from existing ones to reuse and extend behaviour. The session covers parent and child classes, the super() function, method overriding, and single, multilevel and multiple inheritance.

A closing session to reflect on the course. Students share feedback on the content, pace and teaching, ask any remaining questions, and discuss next steps for continuing to learn Python.