Announcement: Mindasys is now Skillet! Check out our new website.

Key points about this course

Duration : 4 Days
Course Fee : RM 6,000.00

HRD Corp Claimable Course

PCPP1: Certified Professional in Python Programming 1
Exam Code : PCPP-32-101 (Python Institute)

Live Virtual Class

Public Class

In-House Training

Private Class

Course Overview

PCPP1™ – Certified Professional in Python Programming 1 certification is the first of the two-series General-Purpose Programming track professional credentials from the OpenEDG Python Institute addressed to developers, IT specialists, and working professionals looking to obtain an industry credential that documents their skills and expertise in the advanced and more specialized aspects of computer programming and the Python language.

The PCPP1™ certification shows that the individual demonstrates proficiency in the advanced use of classes and OOP features present at the hear of Python programming; knows, understands, and implements the coding conventions, design practices, and standards for code writing; knows how to build a GUI application using the most essential tools and toolkits, conventions, and elements of event-driven programming; understands the basic concepts of network programming and what data formats are used in client-server communication, knows how to use sockets and HTTP methods, and is able to create a simple REST client; knows how to use some of the most important Python Standard Library modules for file processing and interacting with a program's environment.

PCPP1™ – Certified Professional in Python Programming 1 certification (Exam PCPP-32-10x) is a professional credential that measures the candidate's ability to accomplish coding tasks related to advanced programming in the Python language and related technologies, advanced notions and techniques used in object-oriented programming, the use of selected Python Standard Library modules and packages, designing, building and improving programs and applications utilizing the concepts of GUI and network programming, as well as adopting the coding conventions and best practices for code writing.

The PCPP1™ certification shows that the individual is familiar with the following concepts: advanced use of classes and modelling real-life problems in the OOP categories (classes, instances, attributes, methods; class and instance data; shallow and deep operations; inheritance and polymorphism; extended function argument syntax and decorators; static and class methods; attribute encapsulation; composition and inheritance; advanced exceptions; copying object data; serialization; metaclasses), best practices and standardization (PEP8, PEP 257, code layout, comments and docstrings, naming conventions, string quotes and whitespaces, programming recommendations), GUI programming (events, widgets, geometry, tools and toolkits, conventions), the elements of network programming (network sockets, client-server communication, JSON and XML files in network communication, HTTP methods, CRUD, building a simple REST client), and file processing and communicating with a program's environment (processing files: sqlite3, xml, csv, logging, and configparser; communication: os, datetime, io, and time).

 

Course Prerequisites

PCAP | Certified Associate in Python Programming Certification

Course Objectives

Becoming PCPP1™ certified ensures that the individual is fully acquainted with all the essential, intermediate, and advanced means provided by Python 3 and related technologies to enable them to advance their career as a professional Python developer and continue studies at the advanced level.

PCPP1™ certification is a professional high-stakes credential, an interim step to the PCPP2™ certification, and the means to demonstrate high-level Python expertise across multiple fields of programming in Python and using related technologies. Becoming PCPP1™ certified shows that the certification holder possesses a high degree of technical knowledge, work independence, and the skills that allow them to pursue programming careers at junior and middle level.

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.

PCPP1™ certification will be particularly valuable for:

  • learners looking to boost their skills and knowledge for a junior-level and middle-level role as a software developernetwork programmerdata analyst, or tester;
  • industry professionals wishing to explore technologies that are connected with Python, or that utilize it as a foundation;
  • team leadersproduct managers, and project managers who want gain an in-depth understanding of the terminology and processes in the software development cycle to more effectively manage and communicate with production, QA, and development teams.
Course Content

Section 1: Advanced Object-Oriented Programming

 

PCPP-32-101 1.1 – Understand and explain the basic terms and programming concepts used in the OOP paradigm

  • essential terminology: class, instance, object, attribute, method, type, instance and class variables, superclasses and subclasses
  • reflexion: isinstance(), issubclass()
  • the __init__() method
  • creating classes, methods, and class and instance variables; calling methods; accessing class and instance variables

PCPP-32-101 1.2 – Perform Python core syntax operations

  • Python core syntax expressions – magic methods: comparison methods (e.g. __eq__(self, other)), numeric methods (e.g. __abs__(self)), type conversion methods (e.g. __init__(self)), object intro- and retrospection (e.g. __str__(self), __instancecheck__(self, object)), object attribute access (e.g. __getattr__(self, attribute)), accessing containers (e.g. __getitem__(self, key))
  • operating with special methods
  • extending class implementations to support additional core syntax operations

PCPP-32-101 1.3 Understand and use the concepts of inheritance, polymorphism, and composition

  • class hierarchies
  • single vs. multiple inheritance
  • Method Resolution Order (MRO)
  • duck typing
  • inheritance vs. composition
  • modelling real-life problems using the "is a" and "has a" relations

PCPP-32-101 1.4 Understand the concept of extended function argument syntax and demonstrate proficiency in using decorators

  • special identifiers: *args, **kwargs
  • forwarding arguments to other functions
  • function parameter handling
  • closures
  • function and class decorators
  • decorating functions with classes 3
  • creating decorators and operating with them: implementing decorator patterns, decorator arguments, wrappers
  • decorator stacking
  • syntactic sugar
  • special methods: __call__, __init__

PCPP-32-101 1.5 Design, build, and use Python static and class methods

  • implementing class and static methods
  • class vs. static methods
  • the cls parameter
  • the @classmethod and @staticmethod decorators
  • class methods: accessing and modifying the state/methods of a class, creating objects

PCPP-32-101 1.6 Understand and use Python abstract classes and methods

  • abstract classes and abstract methods: defining, creating, and implementing abstract classes and abstract methods
  • overriding abstract methods
  • implementing a multiple inheritance from abstract classes
  • delivering multiple child classes

PCPP-32-101 1.7 Understand and use the concept of attribute encapsulation

  • definition, meaning, usage
  • operating with the getter, setter, and deleter methods

PCPP-32-101 1.8 Understand and apply the concept of subclassing built-in classes

  • inheriting properties from built-in classes
  • using the concept of subclassing the built-ins to extend class features and modify class methods and attributes

PCPP-32-101 1.9 Demonstrate proficiency in the advanced techniques for creating and serving exceptions

  • exceptions as objects, named attributes of exception objects, basic terms and concepts
  • chained exceptions, the __context__ and __cause__ attributes, implicitly and explicitly chained exceptions
  • analyzing exception traceback objects, the __traceback__ attribute
  • operating with different kinds of exceptions

PCPP-32-101 1.10 Demonstrate proficiency in performing shallow and deep copy operations

  • shallow and deep copies of objects
  • object: label vs. identity vs. value
  • the id() function and the is operand
  • operating with the copy() and deepcopy() methods

PCPP-32-101 1.11 Understand and perform (de)serialization of Python objects  

  • object persistence, serialization and deserialization: meaning, purpose, usage
  • serializing objects as a single byte stream: the pickle module, pickling various data types · the dumps() and loads functions
  • serializing objects by implementing a serialization dictionary: the shelve module, file modes, creating chelve objects

PCPP-32-101 1.12 Understand and explain the concept of metaprogramming

  • metaclasses: meaning, purpose, usage
  • the type metaclass and the type() function
  • special attributes: __name__, __class__, __bases__, __dict__
  • operating with metaclasses, class variables, and class method

 

Section 2: Coding Conventions, Best Practices, and Standarization

PCPP-32-101 2.1 – Understand and explain the concept of Python Enhancement Proposals and Python philosophy

  • the PEP concept and selected PEPs: PEP 1, PEP 8, PEP 20, PEP 257
  • PEP 1: different types of PEPs, formats, purpose, guidelines
  • PEP 20: Python philosophy, its guiding principles, and design; the import this instruction and PEP 20 aphorisms

PCPP-32-101 2.2 – Employ the PEP 8 guidelines, coding conventions, and best practices

  • PEP 8 compliant checkers
  • recommendations for code layout: indentation, continuation lines, maximum line length, line breaks, blank lines (vertical whitespaces)
  • default encodings
  • module imports
  • recommendations for string quotes, whitespace, and trailing commas: single-quoted vs. double-quoted strings, whitespace in expressions and statements, whitespace and trailing commas
  • recommendations for using comments: block comments, inline comments
  • documentation strings
  • naming conventions: naming styles, recommendations
  • programming recommendations

PCPP-32-101 2.3 – Employ the PEP 257 guidelines, conventions, and best practices

  • docstrings: rationale, usage
  • comments vs. docstrings
  • PEP 484 and type hints
  • creating, using, and accessing docstrings
  • one-line vs. multi-line docstrings
  • documentation standards, linters, fixers

 

Section 3: GUI Programming

PCPP-32-101 3.1 – Understand and explain the basic concepts and terminology related to GUI programming

  • GUI: meaning, rationale, basic terms and definitions
  • visual programming: examples, basic features
  • widgets/controls – basic terms: windows, title and title bars, buttons, icons, labels, etc.
  • classical vs. event-driven programming
  • events – basic terms
  • widget toolkits/GUI toolkits

PCPP-32-101 3.2 – Use GUI toolkits, basic blocks, and conventions to design and build simple GUI applications

  • importing tkinter components
  • creating an application's main window: the Tk(), mainloop(), and title methods
  • adding widgets to the window: buttons, labels, frames, the place() method, widget constructors, location, screen coordinates, size, etc.
  • launching the event controller: event handlers, defining and using callbacks, the destroy() method, dialog boxes
  • shaping the main window and interacting with the user
  • checking the validity of user input and handling errors
  • working with Canvas and its methods
  • using the Entry, Radiobutton, and Button widgets
  • managing widgets with the grid and place managers
  • binding events using the bind() method

PCPP-32-101 3.3 – Demonstrate proficiency in using widgets and handling events

  • settling widgets in the window's interior, geometry managers
  • coloring widgets, color modes: RGB, HEX
  • event handling: writing event handlers and assigning them to widgets
  • event-driven programming: implementing interfaces using events and callbacks
  • widget properties and methods
  • variables: observable variables and adding observers to variables
  • using selected clickable and non-clickable widgets
  • identifying and servicing GUI events

 

Section 4: Network Programming

PCPP-32-101 4.1 – Understand and explain the basic concepts of network programming

  • REST
  • network sockets
  • Domains, addresses, ports, protocols, and services
  • Network communication: connection-oriented vs. connectionless communication, clients and servers

PCPP-32-101 4.2 – Demonstrate proficiency in working with sockets in Python

  • the socket module: importing and creating sockets
  • connecting sockets to HTTP servers, closing connections with servers
  • sending requests to servers, the send() method
  • receiving responses from servers, the recv() method
  • exception handling mechanisms and exception types

PCPP-32-101 4.3 – Employ data transfer mechanisms for network communication

  • JSON: syntax, structure, data types (numbers, strings, Boolean values, null), compound data (arrays and objects), sample JSON documents and their anatomies
  • the json module: serialization and deserialization, serializing Python data/deserializing JSON (the dumps() and loads methods), serializng and deserializing Python objects
  • XML: syntax, structure, sample xml documents and their anatomies, DTD, XML as a tree
  • processing xml files

PCPP-32-101 4.4 – Design, develop, and improve a simple REST client

  • the request module
  • designing, building, and using testing environments
  • HTTP methods: GET, POST, PUT, DELETE
  • CRUD
  • adding and updating data
  • fetching and removing data from servers
  • analyzing the server's response
  • response status codes

Section 5: File Processing and Communicating with a Program’s Environment

PCPP-32-101 5.1 – Demonstrate proficiency in database programming in Python

  • the sqlite module
  • creating and closing database connection using the connect and close methods
  • creating tables
  • inserting, reading, updating, and deleting data
  • transaction demarcation · cursor methods: execute, executemany, fetchone, fetchall
  • creating basic SQL statements (SELECT, INSERT INTO, UPDATE, DELETE, etc.)

PCPP-32-101 5.2 – Demonstrate proficiency in processing different file formats in Python

  • parsing XML documents
  • searching data in XML documents using the find and findall methods
  • building XML documents using the Element class and the SubElement function 8
  • reading and writing CSV data using functions and classes: reader, writer, DictReader, DictWriter
  • logging events in applications
  • working with different levels of logging
  • using LogRecord attributes to create log formats
  • creating custom handlers and formatters
  • parsing and creating configuration files using the ConfigParser object
  • interpolating values in .ini files
About the Certification

 

PCPP1 FAQ 

How do I take the PCPP1 Exam?

  1. Read the PCPP1 and Pearson VUE Testing Policies to make sure you follow the code of conduct, meet all the technical requirements, and know what to expect during your exam session.
  2. Go to pearsonvue.com/pythoninstitute, and create a Pearson VUE web account for OpenEDG exams if you haven't done it yet. (Download a PDF Tutorial)
  3. Go to OpenEDG Voucher Store and buy an exam voucher.
  4. Log in to your Pearson VUE web account and book your exam. (Download a PDF Tutorial)

Can I retake the exam?

You can only retake a failed exam after 15 days of your last attempt (waiting period). All PCPP1 exam vouchers are single-use vouchers only. If you purchased a single-shot voucher and failed the exam, you need to purchase a new voucher to take the exam again. You can book a new exam after 15 days of your last attempt.

How do I access the PCPP1 practice test?

There's no official PCPP1 practice test available at this time. Please stay tuned for announcements about upcoming releases. 

I passed the PCPP1 exam. What now?

Congratulations! You've officially joined the Python Institute PCPP1 certified community, and earned an industry credential that validates your great proficiency in Python, computer programming, and related technologies. Within 24 hours of your exam, you will receive an email with a link to your digital certification, verification code, and a PCPP1 badge issued by Credly's Acclaim. You can now share your awesome achievement with your peers, colleagues, and employers via LinkedIn and other social media channels.

What next? Keep on learning, keep on mastering your Python skills, and keep on climbing the certification ladder. Stay tuned for information about the release of the PCPP2 certification!

  • PCPP1 | Certified Professional in Python Programming 1

  • Request For