Python Programming Fundamentals Training Course

Participants can create, inspect and transform common Python values using clear expressions.

• Variables, literals, and assignment semantics for numeric, text, and Boolean values
• Arithmetic, comparison, and Boolean operators with precedence and parentheses
• Formatted string literals using f-strings, format specifiers, and expressions
• Type conversion with int(), float(), str(), and bool() functions
• Inspecting values and types through print(), type(), and repr()
• Comments, docstrings, and readable expressions that communicate programmer intent

Participants can control program execution using conditions, iteration and loop-management statements.

• if, elif, and else branches for rule-based decision logic
• Boolean conditions combining comparison operators, membership tests, and logical operators
• for loops processing sequences, ranges, dictionaries, and DataFrame columns
• while loops with termination conditions and defensive loop design
• break, continue, and pass statements for controlled iteration behaviour
• Enumerate and zip functions for indexed parallel iteration
• List comprehensions for concise filtering and transformation of sequences

Participants can write reusable functions with parameters, return values and clear documentation.

• Function definitions using def, parameters, arguments, and return statements
• Positional, keyword, default, and variable-length function arguments
• Local and global scope rules for variables and names
• Docstrings describing function purpose, inputs, outputs, and assumptions
• Input validation using conditional checks and informative error messages
• Refactoring repeated calculation steps into focused reusable functions

Participants can select and manipulate appropriate Python collections for analytical tasks.

• Lists for ordered records, indexing, slicing, appending, and sorting
• Tuples for fixed collections and multi-value function returns
• Dictionaries for key-value mappings, lookups, updates, and iteration
• Sets for unique values, membership testing, and duplicate detection
• Nested collections representing records, categories, and hierarchical source data
• Choosing list, dictionary, set, or tuple structures for requirements

Participants can identify common program failures and apply structured debugging methods.

• SyntaxError, NameError, TypeError, KeyError, and IndexError diagnosis
• Reading traceback messages from final exception to source line
• try, except, else, and finally blocks for anticipated failures
• Raising ValueError exceptions when inputs breach stated rules
• Debugger breakpoints, variable inspection, and step-through execution in VS Code
• Assertions for checking assumptions during calculations and data transformation

Participants can read, write and validate local text-based data files safely.

• pathlib Path objects for portable file and directory handling
• Reading text files with encoding, newline, and context-manager controls
• Writing output files with explicit paths and overwrite safeguards
• String methods for trimming whitespace, splitting fields, and replacing values
• Regular expressions for structured pattern matching and text validation
• File existence checks and informative handling of missing source files

Participants can import and export common structured data formats with appropriate checks.

• CSV parsing with headers, delimiters, quoted fields, and missing values
• JSON objects and arrays mapped to Python dictionaries and lists
• json.load(), json.loads(), json.dump(), and json.dumps() usage
• Schema inspection for nested JSON records and optional fields
• Encoding dates, identifiers, and null values during data exchange
• Exporting cleaned datasets with documented filenames and version dates

Participants can create, inspect and select data in pandas DataFrames.

• Creating DataFrames from CSV files, dictionaries, and Excel worksheets
• DataFrame dimensions, column names, dtypes, and memory-use inspection
• head(), tail(), sample(), info(), and describe() for initial profiling
• Selecting columns with brackets, loc[], iloc[], and boolean masks
• Sorting records with sort_values() and stable multi-column sort keys
• Renaming columns and standardising field names for downstream analysis
• Copying DataFrames safely to avoid unintended assignment behaviour

Participants can clean inconsistent tabular data and document quality-control decisions.

• Missing-value profiling with isna(), notna(), and missingness percentages
• Handling nulls through deletion, imputation, flags, and business rules
• Duplicate detection using duplicated() and defined record-key combinations
• Converting text dates, currencies, percentages, and categorical fields
• String normalisation using strip(), case conversion, and replacement dictionaries
• Outlier screening with descriptive statistics, thresholds, and distribution plots
• Data-quality checks for ranges, permitted values, and cross-field consistency

Participants can transform datasets and combine sources using reproducible pandas operations.

• Derived columns built with vectorised arithmetic and conditional logic
• apply() use cases, limitations, and vectorised alternatives
• merge() joins using keys, join types, cardinality, and validation
• concat() for stacking compatible datasets by rows or columns
• pivot(), pivot_table(), melt(), and stack() for reshaping tabular data
• Datetime accessors for periods, weekdays, elapsed time, and reporting months
• Method chaining for readable multi-step DataFrame transformation pipelines

Participants can calculate grouped measures and interpret tabular analytical summaries.

• groupby() aggregation using count, sum, mean, median, minimum, and maximum
• Named aggregation syntax for clearly labelled summary measures
• Cross-tabulations with crosstab() for category and frequency analysis
• Percentages, rates, shares, and denominators for performance measures
• Ranking records with rank() and defined tie-handling methods
• Rolling averages and cumulative totals for time-series reporting
• Validating aggregated totals against source records and control figures

Participants can create and refine charts that answer defined analytical questions.

• Chart selection based on comparison, distribution, composition, and trend questions
• matplotlib figure, axes, labels, titles, legends, and annotation controls
• seaborn bar, line, scatter, box, and histogram chart patterns
• Sorting categories and limiting labels for readable comparison charts
• Colour choices, reference lines, and scales that avoid misleading interpretation
• Exporting publication-ready charts with dimensions, resolution, and filenames
• Writing concise chart captions that state finding, measure, and timeframe

Participants can organise Python code into modules and simple classes for maintainability.

• Import statements, module namespaces, aliases, and import-path behaviour
• Creating utility modules for shared functions and configuration values
• The __name__ == '__main__' pattern for executable scripts
• Classes, objects, attributes, methods, and constructors using __init__
• dataclass definitions for structured records with typed fields
• Separating data access, transformation, analysis, and presentation code
• Project folder conventions for source code, data, outputs, and documentation

Participants can manage project dependencies and test critical Python functions.

• Virtual environments created with venv for isolated project dependencies
• pip install, upgrade, freeze, and requirements.txt dependency management
• Semantic versioning principles for package and project release decisions
• pytest test functions using arrange, act, and assert structure
• Boundary, normal, and invalid input cases for calculation functions
• Fixtures and temporary files for repeatable data-processing tests
• Code review checks covering readability, duplication, exceptions, and test coverage

Participants can retrieve, validate and process data from REST API endpoints.

• REST API concepts: endpoints, resources, methods, headers, and status codes
• GET requests using requests with parameters, timeouts, and response checks
• Authentication patterns using API keys, tokens, and environment variables
• Parsing JSON responses into DataFrames and normalised tables
• Pagination handling for multi-page API result sets
• Rate limits, retries, and error logging for reliable data retrieval
• Documenting source URLs, retrieval dates, parameters, and data limitations

Participants can query relational data with SQL and analyse results in Python.

• Relational tables, primary keys, foreign keys, and normalised database structures
• SELECT, WHERE, ORDER BY, LIMIT, and DISTINCT query clauses
• INNER JOIN and LEFT JOIN queries for combining related tables
• GROUP BY, HAVING, and aggregate functions for database summaries
• Parameterized SQL queries to prevent injection and preserve data types
• sqlite3 connections, cursors, transactions, and connection closure
• Loading SQL query results into pandas with read_sql_query()

Participants can prepare a documented, reviewable workflow for recurring analytical work.

• Analytical question framing, source inventory, assumptions, and acceptance criteria
• Configuration files for paths, reporting periods, thresholds, and parameters
• Logging events, warnings, record counts, and processing outcomes
• Git commits, branches, pull requests, and meaningful change messages
• README files covering setup, data inputs, execution steps, and outputs
• Output validation checklist for totals, charts, labels, and confidentiality
• Stakeholder-ready findings summaries with evidence, caveats, and recommended actions

Participants can build, review and present a complete documented Python analysis project addressing a defined business question.

• Problem statement defining decisions, users, measures, and analytical boundaries
• Source-data assessment covering completeness, quality risks, and field definitions
• Python pipeline integrating import, cleaning, transformation, and validation functions
• Pandas analysis calculating agreed measures, segments, trends, and exceptions
• Visual evidence selected and formatted for stated stakeholder questions
• pytest checks covering critical calculations, transformations, and expected outputs
• Peer code review against PEP 8, documentation, and reproducibility criteria
• Presentation of findings, limitations, recommendations, and next analytical steps