Description
This 5-day training course is designed for new Python developers, who must learn the essential notions of object programming and the syntax of the language before being able to benefit from all the advantages of the Python language. Participants will learn about the tools and features offered by Python, such as module stacks, built-in debugger, and rich documentation, and learn how to design, develop, deploy, and maintain Python applications. This training also prepares you for TOSA Python certification.
Who is this training for ?
For whom ?
Developers, engineers, project managers close to development.
Prerequisites
Have basic knowledge of programming (ideally in object language)
Training objectives
Training program
- Python language syntax
- Identifiers and references.
- Coding conventions and naming rules.
- Blocks, comments.
- The available data types.
- Variables, formatted display, local and global scope.
- Manipulation of numeric types, manipulation of character strings.
- Using files.
- The conditional structure if/elif /else.
- Logical operators and comparison operators.
- While and for iteration loops.
- Interrupting iterations break/continue .
- The range function.
- Writing and documenting functions.
- Lambda expressions.
- Generators.
- Structuring the code into modules.
- Practical work rnInstallation and getting started with the Python interpreter.
- Object Oriented Approach
- The principles of the Object paradigm.
- The definition of an object (state, behavior, identity).
- The notion of class, attributes and methods.
- Data encapsulation.
- Communication between objects.
- Inheritance, transmission of the characteristics of a class.
- The notion of polymorphism.
- Association between classes.
- Interfaces.
- Presentation of UML.
- The class, sequence, activity diagrams.
- Notion of design pattern.
- Practical work UML modeling of a case study simple.
- Object Programming in Python
- The particularities of the Python object model.
- Writing classes and their instantiation.
- Constructors and destructors.
- Access protection of attributes and methods.
- The need for the Self parameter.
- Single inheritance, multiple inheritance, polymorphism.
- The notions of visibilities.
- Special methods.
- Introspection.
- The implementation of interfaces.
- The good ones practices and common design patterns.
- The use of the exception mechanism for error handling.
- Practical work rnPractice of different object concepts through the 'implementation of the case study.'}
- Utilisation StdLib
- The arguments passed on the command line.
- Using the Python regular expression engine with the "re" module, special characters, cardinalities.
- Handling the file system.
- Presentation of some important modules of the standard library: module "sys", "os", "os.
- path".
- Packaging and installing a Python library.
- Access to relational databases, how the DB API works.
- Practical work Implementation of Python modules: regular expressions, access to a database,
- QA tools
- Static code analysis tools (pylint, pychecker).
- Analysis of analysis reports (types of messages, warnings, errors).
- Automatic documentation extraction.
- The Python debugger (step-by-step execution and post-mortem analysis).
- Test-driven development.
- Python unit testing modules (Unittest.
- ).
- Test automation, test aggregation.
- Coverage testing code, profiling.
- Practical work Use of the pylint and pychecker tools for verifying Python code.
- Implementation of unit tests.
- Creation of TkInter HMI
- The principles of programming graphical interfaces.
- Presentation of the TkInter library.
- The main containers.
- Presentation of the available widgets ( Button, Radiobutton, Entry, Label, Listbox, Canvas, Menu, Scrollbar, Text.
- ).
- The window manager.
- The placement of components , the different layouts.
- Event management, the event object.
- Multiwindow applications.
- Practical work Design of an interface graphic with the Tkinter library.
- Python/C interface
- Presentation of the Ctypes module.
- Loading a C library.
- Calling a function.
- Rewriting a a Python function in C with the Python/C API.
- Creating C modules for Python with Pyrex.
- The Python interpreter in C.
- Using the code profiler.
- Practical work Calling functions written in C from Python.
- Creating C modules for Python with Pyrex.
- Conclusion
- Critical analysis of Python.
- The evolution of the language.
- Elements of Webography and bibliography.