SGL offers the PCAP – Certified Associate in Python Programming course, certification which emphasizes Python’s object-oriented programming approach and demonstrates a person’s familiarity with the more complex facets of programming, such as list comprehensions, lambdas, generators, closures, advanced operations on strings, advanced operations on lists, advanced operations on OOP, and file processing.
Course Objectives
- The Certified Associate in Python Programming (PCAP) course aims to equip students with a comprehensive understanding of Python’s fundamental concepts, including functions, modules, OOP, and error handling, to build a solid programming foundation.
- Understand and create Python functions, enhancing code reusability and modularity.
- Learn to handle arguments and build custom modules and packages for structured program development.
- Utilize PIP for package management and lambda functions for creating anonymous, in-line functions.
- Gain proficiency in file handling to read, write, and manage file operations within Python applications.
- Master string, list, tuple, and set methods for effective data manipulation and list comprehensions for concise code.
- Develop error handling techniques using exceptions to create robust and fault-tolerant Python programs.
- Comprehend the principles of Object-Oriented Programming, including classes, objects, inheritance, and polymorphism, to design scalable software.
- Explore and implement iterators, generators, and Python’s os and datetime modules for advanced programming tasks.
- Learn testing methodologies in Python and use Pylint to ensure code quality and adherence to coding standards.
- Enhance problem-solving skills and prepare for the PCAP certification exam to validate programming expertise.
Course Outline
Section 1: Modules and Packages
PCAP-31-03 1.1 – Import and use modules and packages
- import variants: import, from import, import as, import *
- advanced qualifying for nested modules
- the dir() function
- the sys.path variable
PCAP-31-03 1.2 – Perform evaluations using the math module
- functions: ceil(), floor(), trunc(), factorial(), hypot(), sqrt()
PCAP-31-03 1.3 – Generate random values using the random module
- functions: random(), seed(), choice(), sample()
PCAP-31-03 1.4 – Discover host platform properties using the platform module
- functions: platform(), machine(), processor(), system(), version(), python_implementation(), python_version_tuple()
PCAP-31-03 1.5 – Create and use user-defined modules and packages
- idea and rationale;
- the __pycache__ directory
- the __name__ variable
- public and private variables
- the __init__.py file
- searching for/through modules/packages
- nested packages vs. directory trees
Section 2: Exceptions
PCAP-31-03 2.1 – Handle errors using Python-defined exceptions
- except, except:-except, except:-else:, except (e1, e2)
- the hierarchy of exceptions
- raise, raise ex
- assert
- event classes
- except E as e
- the arg property
PCAP-31-02 2.2 – Extend the Python exceptions hierarchy with selfdefined exceptions
- self-defined exceptions
- defining and using self-defined exceptions
Section 3: Strings
PCAP-31-03 3.1 – Understand machine representation of characters
- encoding standards: ASCII, UNICODE, UTF-8, code points, escape sequences
PCAP-31-03 3.2 – Operate on strings
- functions: ord(), chr()
- indexing, slicing, immutability
- iterating through strings, concatenating, multiplying, comparing (against strings and numbers)
- operators: in, not inPCAP-31-03 3.3 – Employ built-in string methods
- methods: .isxxx(), .join(), .split(), .sort(), sorted(), .index(), .find(), .rfind()
Section 4: Object-Oriented Programming
PCAP-31-03 4.1 – Understand the Object-Oriented approach
- ideas and notions: class, object, property, method, encapsulation, inheritance, superclass, subclass, identifying class components
PCEP-31-03 4.2 – Employ class and object properties
instance vs. class variables: declarations and initializations
- the __dict__ property (objects vs. classes)
- private components (instances vs. classes)
- name mangling
PCAP-31-03 4.3 – Equip a class with methods
- declaring and using methods
- the self parameter
PCAP-31-03 4.4 – Discover the class structure
- introspection and the hasattr() function (objects vs classes)
- properties: __name__, __module__ , __bases__
PCAP-31-03 4.5 – Build a class hierarchy using inheritance
- single and multiple inheritance
- the isinstance() function
- overriding
- operators:
- not is , is
- polymorphism
- overriding the __str__() method
- diamonds
PCAP-31-03 4.6 – Construct and initialize objects
- declaring and invoking constructors
Section 5: Miscellaneous
Scope: List Comprehensions, Lambdas, Closures, and I/O Operations
PCAP-31-03 5.1 – Build complex lists using list comprehension
- list comprehensions: the if operator, nested comprehensions
PCAP-31-03 5.2 – Embed lambda functions into the code
- lambdas: defining and using lambdas
- self-defined functions taking lambdas as arguments
- functions: map(), filter()
PCAP-31-03 5.3 – Define and use closures
- closures: meaning and rationale
- defining and using closures
PCAP-31-03 5.4 – Understand basic Input/Output terminology
- I/O modes
- predefined streams
- handles vs. streams
- text vs. binary modes
PCAP-31-03 5.5 – Perform Input/Output operations
- the open() function
- the errno variable and its values
- functions: close(), .read(), .write(), .readline(), readlines()
- using bytearray as input/output buffer
Audience
- For novice and intermediate programmers, the Certified Associate in Python Programming course provides thorough instruction in Python fundamentals.
- Enter-level programmers, aspiring software developers, computer science students, data analysis enthusiasts, IT professionals looking to broaden their skill set, automation engineers, quality assurance specialists, system administrators, academic researchers, technical product managers, hobbyists interested in learning programming, and professionals in tech roles looking to pick up a new scripting language
Overview
PCAP certification provides bearers with self-assurance in their programming abilities, makes them more marketable to employers, and offers them a leg up in terms of being ready for and progressing to the professional level.
Exam PCAP-31-0x, also known as the PCAP – Certified Associate in Python Programming certification, is a professional, high-stakes test that assesses a candidate’s proficiency in intermediate-level Python coding tasks, such as designing, developing, debugging, executing, and refactoring multi-module Python programs. It also evaluates the candidate’s knowledge and abilities in analyzing and modeling real-world problems in OOP categories using the fundamental concepts and methods available in the object-oriented approach.
The PCAP certification attests to the candidate’s understanding of the following ideas: working with specific Standard Library modules, exception hierarchies, exception classes and objects, character encoding, strings, and string processing; generators, iterators, closures; files, file streams, and file processing; and the principles of object-oriented programming (OOP).
Python is the programming language that opens more doors than any other, and the more you understand Python, the more you can do in the 21st Century. With a solid knowledge of Python, you can work in a multitude of jobs and a multitude of industries.
For those seeking to progress into increasingly complex, specialized, and lucrative software development, security, networking, Internet of Things, and engineering professions, the PCAP certification is a useful credential. It will be especially appealing to:
- Aspiring programmers and learners who want to study programming for enjoyment and for work-related purposes;
- Learners and career changers looking for a junior position as a tester, data analyst, or software developer.
The target audience for Python programming includes: - professionals in the industry who want to learn more about technologies that use or are connected to Python;
- aspiring programmers and professionals in the industry who want to lay a strong foundation for their studies in more specialized fields like testing, data analytics, machine learning, Internet of Things, and web development;
- Project managers, product managers, and team leaders who wish to manage and interact with development and production teams more skillfully by becoming aware of the lingo and procedures used in the software development cycle.
Course Prerequisites
Basic understanding of computer operations, such as file management and the use of command-line interfaces.
- Familiarity with core programming concepts like variables, data types, control structures (e.g., loops, conditional statements), and basic input/output operations.
- Some exposure to foundational mathematical concepts, particularly those relevant to computer science (e.g., logic, sets, and functions).
- No prior experience with Python is strictly necessary, but a general understanding of coding in any programming language is beneficial.
- Eagerness to learn and the ability to think logically, which is crucial for problem-solving and debugging code.
Note: Although these prerequisites offer a starting point for learning, the PCAP course aims to both introduce Python to novices and improve the abilities of experienced programmers. For this reason, enthusiasm and a desire to do coding exercises are just as crucial as any official requirements.
