Wilson Mar bio photo

Wilson Mar

Hello!

Email me Calendar Skype call

LinkedIn Twitter Gitter Instagram Youtube

Github Stackoverflow Pinterest

The topics for learning the Python language thoroughly, for professional status

US (English)   Español (Spanish)   Français (French)   Deutsch (German)   Italiano   Português   Cyrillic Russian   中文 (简体) Chinese (Simplified)   日本語 Japanese   한국어 Korean

Overview

Certifications in Python

PythonInstitute.org has several certification exams taken online at ums.edube.org/store or in-person at a Pearson VUE center.

Each requires 70% correct of 40 questions over 40 minutes on-line.

Entry-level cert

“Certified Entry-Level Python Programmer Certification” covers these exam blocks for $59. Version PCAP-31-02 is the version after PCAP-31-01 is retired.

The official practice test is at pythoninstitute.org/download/566

The exam “blocks”:

1: Basic Concepts (17% - 5 exam items)

2: Data Types, Evaluations, and Basic I/O Operations (20% - 6 exam items)

  • operators: unary and binary, priorities, and binding
  • bitwise operators VIDEO: ~ & ^ | << >> (Mandelbrot)
  • Boolean operators: not and or
  • Boolean expressions (True/False)
  • relational operators ( == != > >= < <= ), building complex Boolean expressions
  • accuracy of floating-point numbers 4.5e9 == 4.5 * (10 ** 9) == 4.5E9 == 4.5E+9

  • basic input and output operations using the input(), print(), int(), float(), str(), len() functions
  • formatting print() output with end= and sep= arguments
  • type casting
  • basic calculations
  • simple strings: constructing, assigning, indexing, slicing comparing, immutability

3: Flow Control – loops and conditional blocks (20% - 6 exam items)

  • conditional statements: if, if-else, if-elif, if-elif-else
  • multiple conditional statements
  • the pass instruction
  • building loops: while, for, range(), in
  • iterating through sequences
  • expanding loops: while-else, for-else
  • nesting loops and conditional statements
  • controlling loop execution: break, continue

4: Data Collections – Lists, Tuples, and Dictionaries (23% - 7 exam items)

  • simple lists: constructing vectors, indexing and slicing, the len() function
  • lists in detail: indexing, slicing, basic methods (append(), insert(), index()) and functions (len(), sorted(), etc.), del instruction, iterating lists with the for loop, initializing, in and not in operators, list comprehension, copying and cloning
  • lists in lists: matrices and cubes
  • tuples: indexing, slicing, building, immutability
  • tuples vs. lists: similarities and differences, lists inside tuples and tuples inside lists
  • dictionaries: building, indexing, adding and removing keys, iterating through dictionaries as well as their keys and values, checking key existence, keys(), items() and values() methods
  • strings in detail: ASCII, UNICODE, UTF-8 (rendered/transmitted as pairs of bytes in norsk.encode(“utf-8”)
  • immutability, escaping using the \ character, quotes and apostrophes inside strings, multiline strings, copying vs. cloning, advanced slicing, string vs. string, string vs. non-string, basic string methods (upper(), lowe

5: Functions (20% - 6 exam items)

  • defining and invoking your own functions and generators
  • return and yield keywords, returning results,
  • the None keyword (instead of return 0)
  • recursion
  • parameters vs. arguments,
  • positional keyword and mixed argument passing,
  • default parameter values
  • converting generator objects into lists using the list() function
  • name scopes, name hiding (shadowing), the global keyword

Intermediate cert

The (PCAP-31-02) Associate level exam for $295 covers these exam blocks:

1: Control and Evaluations (25%)

  • basic concepts: interpreting and the interpreter, compilation and the compiler, language elements,
  • compilation Lexical analysis (into tokens),
  • Syntactic analysis (parsing), Semantic analysis (type & parameter mismatch)
  • Python keywords
  • bytecode instructions
  • indenting</strike>
  • literals: Boolean, integer, floating-point numbers, scientific notation, strings
  • operators: unary and binary, priorities and binding
  • numeric operators: ** * / % // + –
  • bitwise operators: ~ & ^ « »
  • string operators: * +
  • Boolean operators: not and or
  • relational operators ( == != > >= < <= ), building complex Boolean expressions
  • assignments and shortcut operators
  • accuracy of floating-point numbers
  • basic input and output: input(), print(), int(), float(), str() functions
  • formatting print() output with end= and sep= arguments
  • conditional statements: if, if-else, if-elif, if-elif-else
  • the pass instruction
  • simple lists: constructing vectors, indexing and slicing, the len() function
  • simple strings: constructing, assigning, indexing, slicing comparing, immutability
  • building loops: while, for, range(), in, iterating through sequences
  • expanding loops: while-else, for-else, nesting loops and conditional statements
  • controlling loop execution: break, continue



2: Data Aggregates (25%)

  • strings in detail: ASCII, UNICODE, UTF-8, immutability, escaping using the \ character, quotes and apostrophes inside strings, multiline strings, copying vs. cloning, advanced slicing, string vs. string, string vs. non-string, basic string methods (upper(), lower(), isxxx(), capitalize(), split(), join(), etc.) and functions (len(), chr(), ord()), escape characters
  • lists in detail: indexing, slicing, basic methods (append(), insert(), index()) and functions (len(), sorted(), etc.), del instruction, iterating lists with the for loop, initializing, in and not in operators, list comprehension, copying and cloning
  • lists in lists: matrices and cubes
  • tuples: indexing, slicing, building, immutability
  • tuples vs. lists: similarities and differences, lists inside tuples and tuples inside lists
  • dictionaries: building, indexing, adding and removing keys, iterating through dictionaries as well as their keys and values, checking key existence, keys(), items() and values() methods

3: Functions and Modules (25%)

  • defining and invoking your own functions and generators
  • return and yield keywords, returning results, the None keyword, recursion
  • parameters vs. arguments, positional keyword and mixed argument passing, default parameter values
  • converting generator objects into lists using the list() function
  • name scopes, name hiding (shadowing), the global keyword</strike>
  • lambda functions
  • defining and using map(), filter(), reduce(), reversed(), sorted() functions and the sort() method
  • the if operator
  • import directives, qualifying entities with module names
  • initializing modules
  • writing and using modules,
  • the name variable
  • pyc file creation and usage
  • constructing and distributing packages, packages vs. directories
  • the role of the init.py file
  • hiding module entities
  • Python hashbangs
  • using multiline strings as module documentation

4: Classes, Objects, and Exceptions (25%)

  • defining your own classes, superclasses, subclasses, inheritance, searching for missing class components, creating objects
  • class attributes: class variables and instance variables, defining, adding and removing attributes, explicit constructor invocation
  • class methods: defining and using, the self parameter meaning and usage
  • inheritance and overriding, finding class/object components
  • single inheritance vs. multiple inheritance
  • name mangling
  • invoking methods, passing and using the self argument/parameter
  • the init method
  • the role of the str method
  • introspection: dict, name, module, bases properties, examining class/object structure
  • writing and using constructors
  • hasattr(), type(), issubclass(), isinstance(), super() functions
  • using predefined exceptions and defining your own ones
  • the try-except-else-finally block, the raise statement, the except-as variant
  • exceptions hierarchy, assigning more than one exception to one except branch
  • adding your own exceptions to an existing hierarchy
  • assertions
  • the anatomy of an exception object
  • input/output basics: opening files with the open() function, stream objects, writing binary (bmp file) vs. text files, newline character translation, reading and writing files,
  • bytearray objects
  • read(), readinto(), readline(), write(),
  • close() methods (vs. with)

Professional 1

The first of two Professional-level exams (PCPP-32-101)

1: File Processing and Communicating with a Program’s Environment (20%)

  • Processing different kinds of files
    • sqlite3 – interacting with SQLite databases
    • xml – creating and processing XML files
    • csv – CSV file reading and writing
    • logging – basics logging facility for Python
    • configparser – configuration file parser
  • Communicating with a program’s environment:
    • os – interacting with the operating system,
    • datetime – manipulating with dates and time
    • io – working with streams,
    • time – time access and conversions

2: Math, Science, and Engineering Tools (20%)

  • math – a basic tool for elementary evaluations
  • NumPy – fundamental package for scientific computing
  • SciPy – an ecosystem for mathematics, science, and engineering
  • Matplotlib – 2D plotting library producing publication quality figures
  • Pandas – a library providing high-performance and data analysis tools
  • SciKit-image – a collection of algorithms for image processing

3: GUI Programming (20%)

  • What is GUI and where it comes from
  • Constructing a GUI – basic blocks and conventions
  • Event-driven programming
  • Currently used GUI environments and toolkits
  • tkinter — Python interface to Tcl/Tk
    • tkinter’s application life cycle
    • Widgets, windows and events
    • Sample applications
  • pygame – a simple way of developing multimedia applications

4: Python Enhancement Proposals (15%)

  • What is PEP?
  • Coding conventions – not only style and naming
  • PEP 20 – The Zen of Python: a collection of principles that influences the design of Python code
  • PEP 8 – Style Guide for Python Code: coding conventions for code comprising the standard library in the main Python distribution
  • PEP 257 – Docstring Conventions: what is docstring and some semantics as well as conventions associated with them
  • A tour of important PEPs

5: Advanced Perspective of Classes and Object-Oriented Programming in Python (25%)

  • Classes, Instances, Attributes, Methods
  • Working with class and instance data
  • Copying object data using shallow and deep operations
  • Inheritance and Polymorphism
  • Different faces of Python methods: static and class methods
  • Abstract classes vs. method overloading
  • Composition vs. Inheritance – two ways to the same destination
  • Implementing Core Syntax
  • Subclassing built-ins
  • Attribute Encapsulation
  • Advanced techniques of creating and serving exceptions
  • Serialization of Python objects using the pickle module
  • Making Python object persistent using the shelve module
  • Metaprograming
    • Function decorators
    • Class decorators
    • Metaclasses

Professional 2

The second of two Professional-level exams (PCPP-32-102)

1: Creating and Distributing Packages (20%)

  • Using pip
  • Basic directory structure
  • The setup.py file
  • Sharing, storing, and installing packages
  • Documentation
  • License
  • Testing principles and techniques
    • unittest – Unit testing framework
    • Pytest – framework to write tests

2: Design Patterns (20%)

  • Object-oriented design principles and the concept of design patterns
  • The Singleton Design Pattern
  • The Factory Pattern
  • The Façade Pattern
  • The Proxy Pattern
  • The Observer Pattern
  • The Command Pattern
  • The Template Method Pattern
  • Model-View-Controller
  • The State Design Pattern

3: Interprocess Communication (20%)

  • multiprocessing — Process-based parallelism
  • threading — Thread-based parallelism
  • subprocess — Subprocess management
  • Multiprocess synchronisation
    • queue — A synchronized queue class
    • socket — Low-level networking interface
    • mmap — Memory-mapped file support

4: Python Network Programming (20%)

Python Socket Module:

  • Introduction to sockets
  • Server Socket Methods
  • Client socket methods
  • General socket methods
  • Client-Server vs. Peer-to-peer
  • Other Internet nodules

5: Python-MySQL Database Access (20%)

  • Relational databases – fundamental principles and how to work with them
  • MySQL vs. rest of the world
  • CRUD Application
    • db connection
    • db create
    • db insert
    • db read
    • db update
    • db delete



The video course at LinuxAcademy by Keith Thompson references includes a practice exam.

More about Python

This is one of a series about Python:

  1. Python install on MacOS using Pyenv
  2. Python install on MacOS
  3. Python install on Raspberry Pi for IoT

  4. Test Python using Pytest BDD Selenium framework
  5. Test Python using Robot testing framework

  6. Python certifications
  7. Python tutorials
  8. Python coding notes
  9. Jupyter Notebooks provide commentary to Python

  10. Pulumi controls cloud using Python, etc.
  11. Microsoft Azure Machine Learning makes use of Python
  12. Testing AI uses Python code

  13. Python REST API programming using the Flask library
  14. Python coding for AWS Lambda Serverless programming
  15. Streamlit visualization framework powered by Python
  16. Web scraping using Scrapy, powered by Python
  17. Neo4j graph databases accessed from Python