Software Development
Python Programming Fundamentals
A hands-on introduction to Python for engineers and analysts who need working code rather than tutorial fragments. Participants build fluency with data types, collections, functions, files, and error handling, then assemble a small program that reads real data and produces a usable report.
Overview
Practical learning for workplace transfer.
Most organizations adopt Python by accident: one person automates something useful, and afterwards nobody else can read, run, or repair that script. This course removes that single point of failure. It builds the language deliberately — names and objects, mutability, lists and dictionaries, comprehensions, functions and scope, modules, exceptions, and file handling — and exercises every concept on realistic input such as CSV exports and log files. By the final day participants write and debug their own program instead of copying one, and can read the Python already circulating inside their organization.
Prerequisites
Basic computer literacy and the ability to install software on your machine. No programming experience is required.
Objectives
- Write, run, and debug Python programs from the terminal inside an isolated virtual environment.
- Choose correctly between lists, tuples, dictionaries, and sets for a given data problem.
- Read and write text, CSV, and JSON files without corrupting data or losing character encoding.
- Use exceptions and the logging module so failures become visible instead of silent.
- Organize code into functions and importable modules instead of one long linear script.
- Read, trace, and safely modify existing Python code written by someone else.
Target audience
- Engineers and technical staff with no prior programming background
- Analysts moving from spreadsheet work to scripted data handling
- IT and support staff maintaining scripts they did not write
- Graduate engineers joining development, data, or automation teams
- Laboratory, QA, and operations personnel handling repetitive data files
- Team leaders who need to read and review the Python their staff produce
Program outline
A clear structure for the learning journey.
Program outline
Outline points are grouped in one designed block instead of being treated as separate module cards.
Module 1: Python Foundations and the Working Environment
Installing Python, creating virtual environments, and running code from the terminal
Variables, names, objects, and why assignment does not copy data
Numbers, strings, f-strings, and formatting output for readable reports
Reading tracebacks as diagnostic information rather than as noise
Module 2: Control Flow and Program Logic
Conditionals, truthiness, and the comparisons that quietly surprise beginners
Loops with for and while, plus range, enumerate, and zip
Using break, continue, and loop else deliberately instead of by habit
Turning a written decision table into working, verifiable logic
Module 3: Collections: Lists, Dictionaries, Sets, and Tuples
Selecting a collection based on lookup speed, ordering, and uniqueness
Slicing, sorting with key functions, and keeping ordering stable
Dictionary patterns for grouping, counting, and nested records
List and dictionary comprehensions that stay readable under review
Module 4: Functions, Modules, and Code Organization
Parameters, defaults, keyword arguments, and the mutable-default trap
Return values, scope, and avoiding hidden global state
Splitting one script into modules and importing safely across files
Docstrings and basic type hints that make a function self-explaining
Module 5: Files, Data Formats, and the Standard Library
Reading and writing text, CSV, and JSON with the correct encoding
pathlib for paths that behave the same on Windows, Linux, and macOS
datetime, collections, and itertools applied to everyday data tasks
Command-line arguments with argparse so a script becomes a reusable tool
Module 6: Errors, Logging, and a Complete Small Program
try, except, else, and finally applied to real failure modes
Raising and defining exceptions that carry useful context to the caller
Using logging instead of print for anything that runs unattended
Building and demonstrating an end-to-end program from raw data to report
Materials provided
- Course workbook, annotated code samples, and reference notes
- Hands-on lab environment and starter repositories
- Exercises, checklists, and reusable code templates
- 4D Certificate of Completion
- Post-course technical guidance
Training Options
Programs can be delivered in-house, online, or in a blended format depending on your team's schedule, location, and learning objectives. When an external certificate or exam is included, certification rules and fees remain under the relevant awarding body's policies, while 4D provides the training and preparation support.
Why choose 4D
4D runs this course on your own files — the exports, logs, and spreadsheets your teams already handle — so the program participants finish on day five is one they can run at work the following Monday. Trainers sit with each participant through the debugging, which is exactly where beginners normally abandon Python, and every solution is kept in the workbook.
Related courses
Intermediate Python and Clean Code Practices
Designed for developers whose Python works but is difficult to change. The course covers dataclasses, generators, decorators, context managers, and type hints, then applies the refactoring moves that turn a nine-hundred-line module into small tested units guarded by black, ruff, and mypy.
View coursePython Automation and Scripting for Work Tasks
Aimed at teams losing hours every week to repetitive file, spreadsheet, and reporting work. Participants automate those tasks with Python: batch file handling, Excel and CSV processing, REST API calls, email alerts, and scheduled jobs that run unattended and report clearly when something fails.
View courseAdvanced Python: Concurrency and Performance
For engineers whose Python services and pipelines have hit a wall. The course starts with measurement — cProfile, py-spy, tracemalloc — then works through the GIL, threads, process pools, and asyncio, before covering NumPy vectorization, caching, and native acceleration for the paths that remain too slow.
View course