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.
Outline points are grouped in one designed block instead of being treated as separate module cards.
01Python Foundations and the Working Environment4 topics
- 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
02Control Flow and Program Logic4 topics
- 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
03Collections: Lists, Dictionaries, Sets, and Tuples4 topics
- 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
04Functions, Modules, and Code Organization4 topics
- 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
05Files, Data Formats, and the Standard Library4 topics
- 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
06Errors, Logging, and a Complete Small Program4 topics
- 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