About the course
Python stands out as one of the most popular, versatile, and beginner-friendly programming languages available today. Its clear syntax and extensive ecosystem make it a go-to language for diverse applications, including web development, data analysis, machine learning, automation, scripting, and much more. This 3-day intensive hands-on training course is specifically designed to provide a comprehensive and practical introduction to Python programming for individuals with little to no prior coding experience, or those looking for a structured entry into the Python language. The course guides participants step-by-step, from understanding core programming concepts to writing, running, and debugging their own Python code effectively.
The course begins with a welcoming session and a broad introduction to the Python language, exploring its wide range of uses and providing an overview of powerful, commonly used libraries (like Pandas, Numpy, SciPy, SkLearn, Flask) to showcase the potential of Python development. Participants will gain essential practical skills from the outset, learning how Python programs work, how to execute Python code in different environments including IDEs (such as PyCharm, VS Code, Spyder) and Jupyter Notebooks, and mastering the crucial practice of using virtual environments to manage project dependencies cleanly. The core of the workshop is built around fundamental programming constructs: participants will learn about variables, different numerical and string data types, performing arithmetic and string operations, and controlling the flow of program execution using conditional statements (if, elif, else) and various types of loops (for, while), including brief overviews of modern Python syntax features introduced in recent versions.
Participants will then explore Python's built-in data containers, starting with sequential types like Tuples and Lists (understanding mutability), and progressing to advanced containers like Sets and Dictionaries. The course dedicates significant time to Functions, teaching how to define, call, pass parameters (including default and named parameters), and return values, along with understanding variable scope (local and global). We will explore more advanced functional programming concepts like Anonymous / Lambda Functions and using higher-order functions such as filter and map. Object-Oriented Programming (OOP) is introduced through Classes, covering terminology, defining user-defined classes, instantiating objects, and defining object behaviour. Essential practices like Error Handling (using try-except blocks, raising exceptions) and organising code into Modules and Packages for reusability are covered.
The course concludes with a brief introduction to Testing using pytest and unittest and practical File I/O for reading from and writing to files. Crucially, the learning is reinforced through hands-on labs integrated throughout the three days, many of which involve iteratively building upon a central "Number Guess Game" project, providing a cohesive, engaging, and practical learning experience that solidifies understanding and builds confidence in writing functional Python code.
-
- Understand what Python is, its common applications, and how Python programs are executed.
- Set up a Python development environment, including installing Python, using virtual environments, and exploring different code editors/IDEs.
- Understand and effectively use variables, basic numerical and string data types, and perform common arithmetic and string operations.
- Control the flow of program execution using conditional statements
- Work effectively with Python's built-in sequential (Lists, Tuples) and advanced (Sets, Dictionaries) data containers.
- Define and call functions, understand parameter passing (including default and named), return values, and variable scope (local/global).
- Utilise anonymous (Lambda) functions and functional programming tools
- Understand the basics of Object-Oriented Programming (OOP), define simple classes, create objects, and define object behaviour.
- Implement robust error handling using try-except blocks, understand exception types, and raise custom exceptions.
- Organise Python code into reusable modules and packages and understand the module search path.
- Write and run basic unit tests for Python code using pytest or unittest.
- Perform file input and output operations to read from and write to files.
- Apply fundamental Python programming concepts by completing hands-on coding exercises and iteratively building a small application.
-
This 3-day intensive hands-on training course is designed for individuals who are new to programming or new to the Python language and want to gain a solid foundation in Python programming fundamentals. It is ideal for:
Individuals with no prior programming experience.
Developers transitioning from other programming languages who want to learn Python.
Data Analysts, Data Scientists, or Researchers who need to start using Python for data manipulation and analysis.
Business Analysts and other professionals looking to leverage Python for automation or data tasks.
Professionals with some programming background and an interest in using Python for data collection tasks.
Anyone interested in learning Python for automation, scripting, or general-purpose programming.
-
Participants should have basic computer literacy and be familiar with navigating a file system. Using a command-line interface (CLI) is helpful but not strictly required, as basic usage will be covered.
Logical thinking and problem-solving skills are beneficial.
No prior programming experience is required.
-
This Intro to Python course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Welcome and Introductions
Welcome to the course.
Introduction to the instructor and their background.
Delegate Introductions.
Plan of the course: Structure, goals, and approach.
Opportunity for initial questions.
Introduction to Python and Coding Setup
What is Python? Origins and design philosophy.
Where is Python used? Overview of common application areas.
Overview of common Python Libraries (Pandas, Numpy, SciPy, SkLearn, Flask) - illustrating Python's ecosystem.
How Python Programs work: Interpreter, bytecode, execution.
Running a Python program
Exploring different coding environments: REPL (Read-Eval-Print Loop), IDEs (e.g., PyCharm, VS Code, Spyder), Jupyter Notebooks.
Overview of Virtual Environments (venv) - what they are and why they are needed.
Quick look at setting up a Virtual Environment (using pip or conda).
Writing and running your first Python program: Python Hello World.
Lab 1: Setting up a Python Project using a virtual environment
Practical exercise to install Python (if needed) and set up a basic project structure with a virtual environment.
Variables and Values
Variables, Symbol Names and Values: Understanding how data is stored and referenced.
Variable declarations and assignment.
Rules and conventions for Variable names.
Variable values and how they are referenced.
Touching on Type hints in Python (Introduction to basic type hinting syntax - Python 3.5+).
Numerical Data types: Understanding numbers in Python.
Integers.
Floating point numbers.
Arithmetic operations (+, -, , /, //, %, *).
Lab 2: Working with numbers
Practical exercise to create and manipulate numerical variables using arithmetic operations.
Strings
What are Strings? Representing text data.
String operations.
Converting numbers to strings.
Simple String formatting.
Formatted string literals aka f (F) strings (Python 3.6+) - the modern approach.
Touching on Template Strings (aka t-strings) (released with Python 3.14)
Lab 3: Working with Strings
Practical exercise to create, manipulate, and format strings.
Flow of Control
Understanding how to control the order of execution in your programs.
Conditional statements: Making decisions.
If statement.
if-else statements.
if-elif statements for multiple conditions.
Boolean Logic: Using comparison operators (==, !=, <, >, <=, >=) and logical operators (and, or, not).
Counted Loops – for loop: Iterating over sequences.
Conditional Loops – while loops: Repeating code based on a condition.
break and continue statements to alter loop execution.
Overviews of:
Structural Pattern Matching (Python 3.10) - a brief conceptual introduction.
Coding formatting in Python using tooling (e.g., Black, autopep8) - overview of automated formatting.
Assignment expression aka walrus operator (:=) (Python 3.8) - a brief explanation.
Lab 4: Number Guess Game
Practical exercise to build the core logic of a number guess game using variables, user input, conditional statements, and loops.
Sequential Data Containers
Mutable and Immutable types: Understanding the difference and its implications.
Tuples: Ordered, immutable sequences. Creating and accessing tuple elements.
Lists: Ordered, mutable sequences. Creating, accessing, and modifying list elements.
Common list methods (e.g., .append(), .insert(), .remove(), .pop(), .sort()).
Lab 5: Use a list to record guesses in Number Guess Game
Practical exercise to incorporate a list into the Number Guess Game to keep track of the user's guesses.
Advanced Data Containers
Sets: Unordered collections of unique elements. Set operations (union, intersection, difference).
Dictionaries: Unordered collections of key-value pairs. Creating, accessing, adding, and modifying dictionary elements.
Common dictionary methods.
Lab 6: Added user high scores to number guess game using a dictionary
Practical exercise to use a dictionary to store and manage user high scores in the Number Guess Game.
Functions
Abstracting logic: Why use functions? Code reusability and organisation.
Defining functions (def keyword).
Calling functions.
Parameter passing.
Default parameter values.
Mandatory and optional parameters.
Named parameters.
Returning values from functions (return statement).
Lab 7: Organising the number Guess game using functions
Practical exercise to refactor the Number Guess Game code by organising different parts into functions.
Further Functions
Local & Global Variables: Understanding variable scope.
Modifying Global Variables within a function.
Anonymous / Lambda Functions: Defining small, single-expression functions.
Functions and Containers.
filter(): Filtering elements.
map(): Applying a function to each element.
Nesting filter and map.
Lab 8: Using filter and map with lists
Practical exercise to use filter and map with list data.
Classes in Python
Introduction to Object-Oriented Programming (OOP) concepts.
Class Terminology: Objects, classes, attributes, methods, instances.
Defining user defined classes.
Instantiating Objects from Classes.
Printing Objects.
Being careful with Assignment.
Class Comments.
Defining behaviour: Adding methods to classes.
Deleting an object.
Lab 9: Creating a player class for the number guess game
Practical exercise to create a Player class to represent players in the Number Guess Game and manage their attributes.
Error Handling in Python
Understanding Errors & Exceptions: What happens when things go wrong.
Common built-in Exception types in Python.
Exception Handling: Gracefully dealing with errors.
try-except blocks.
Using a default Exception Handler.
The else Clause with try-except.
The finally block for cleanup.
Overview of:
Exception Groups and except* (Python 3.11) - a brief conceptual introduction.
add_note Method for Exceptions (Python 3.11) - a brief explanation.
Raising an Exception / Error.
Defining New Exceptions / Errors (creating custom exception classes).
Lab 10: Added error handling to the number guess game
Practical exercise to add robust error handling to the Number Guess Game (e.g., handling invalid input).
Python Modules & Packages
Python Modules: Organising code into separate files.
Importing Modules.
Using from with import.
The main Module: Understanding script execution.
Importing non-local modules.
Packages: Organising modules into directories.
Sub Packages.
The Module Search Path (sys.path).
Hands-on: Create and import custom modules.
Lab 11: package the number guess game as a module
Practical exercise to refactor the Number Guess Game by packaging it as a module and making it importable.
A brief intro to Testing using pytest and unittest
Why Test? Understanding the importance of automated testing.
What is pytest and unittest? Overview of two popular testing frameworks.
Writing and Running a Test / using pytest runner.
Basic Test Fixtures (in pytest).
Parameterized Tests (in pytest - overview).
Ignoring Tests.
Testing for exceptions.
Lab 12: Added tests to the number guess game
Practical exercise to write basic unit tests for functions or components of the Number Guess Game using pytest or unittest.
File IO
Obtaining a file reference (open() function).
File access modes (read, write, append, binary).
Reading from a file (.read(), .readline(), .readlines()).
Writing to a file (.write(), .writelines()).
Using with open(...) as ... for guaranteed file closing.
Simple exception handling for File IO operations (e.g., FileNotFoundError).
Re-naming and deleting files.
Lab 13: log program start up and results in a file
Practical exercise to add file I/O to the Number Guess Game, such as logging game starts or final results to a text file.
-
Official Python Documentation: The primary and most authoritative source for all information about the Python language.
Python.org Downloads: Where to download the official Python installers for your operating system.
Guides for Recommended IDEs/Editors: Explore these popular environments for writing and running Python code:
PyCharm: https://www.jetbrains.com/pycharm/ (Community Edition is a free, full-featured option).
VS Code with Python Extension: https://code.visualstudio.com/ (Free and highly popular).
Spyder: https://www.spyder-ide.org/ (Often included as part of the Anaconda distribution, popular in data science).
Jupyter Notebooks: https://jupyter.org/ (Excellent for interactive coding and data exploration).
Trusted by
