Python Certs

Here is how to study and take Certification exams to validate your expertise to potential schools, scholarships, and employers.

Overview

Other Python Exams
PCEP™ (Python Institute’s Certified Entry-Level Python Programmer)
- Entry-level cert
Cisco Discount for OpenEDG
Continue to Advanced Python (PE3)
Cisco Final Exam 2 Question 27
Cisco Final Exam 2 Question 33
Cisco Final Exam 2 Question 34
Cisco Final Exam 1 Question 35
MogoDB Python
Video courses
Retired Python certs
LinkedIn Certifications Retired
References
More about Python

Certifications show that you are serious about your education and career, especially if you didn’t graduate from a top tier degree from MIT/CMU, etc.

NOTE: Content here are my personal opinions, and not intended to represent any employer (past or present). “PROTIP:” here highlight information I haven’t seen elsewhere on the internet because it is hard-won, little-know but significant facts based on my personal research and experience.

Other Python Exams

Before they setup an interview, Amazon, Facebook, and others force candidates to take a test on:

https://www.hackerrank.com/dashboard
leetcode

Hackerrank offers free “certifications”.

W3schools.com offers a $95 certification. PROTIP: I don’t think it counts for much.

https://certiport.filecamp.com/s/i/9Th6LzRzeAhrdCP7 for the Python “IT Specialist Exam Objectives”

PCEP™ (Python Institute’s Certified Entry-Level Python Programmer)

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

The OpenEDG Python Institute administers this progression of Python certification exams:

python-certs-map=1200x253.png

20% off $59 PCEP-30-0x (Certified Entry-Level Programmer) asks 30 questions over 40 minutes
https://pythoninstitute.org/pcep

PROTIP: Cisco rewards you (through a teacher like me) a discount to the OpenEDG exam after you sign-up and complete their
50% off $295 PCAP-31-0x (Certified Associate Programmer exam) asks 31 questions over 65 minutes
https://pythoninstitute.org/pcap
$225 PCPP-32-101 (Certified Professional Programmer Level 1) asks 45 questions over 65 minutes
https://pythoninstitute.org/pcpp1
$195 PCPP-32-201 (Certified Professional Programmer Level 2 Exa) asks 45 questions over 65 minutes
https://pythoninstitute.org/pcpp2

Each exam requires answering 70% correct.

Prices above are for a single try. Exams can be purchased with a retake option and sample tests.

TODO: Add links to each Python docs topic.

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 </a>

Cisco Discount for OpenEDG

Cisco’s offers at their NetAcad.com site free online Python courses developed in collaboration with OpenEDG:

Click “Login” at the upper-right.
Click “Sign Up” at the lower-right.
Click the Google icon under “Sign up with”.
Select your personal Google account - the one credly.com will use even after you leave school.
Check the accept boxes, then “Accept & Continue”.
Login using your Google account and associated password.
Use the email address you used to log into NetAcad.com to create an account at credly.com.
In Credly, click Settings, Security & Privacy, to setup two-factor authentication with your Authy mobile app.

Cisco PE1 Course for PCEP-30-0x

https://edube.org/study/pe1
Click “Python Essentials 1”
Notice the PCAP (Certified Entry-Level Python Programmer) exam sections:
1. Introduction to Python and Computer Programming
2. Python Data Types, Variables, Operators, and Basic I/O Operations
3. Flow Control: Boolean Values, Conditional Execution, Loops, Lists and List Processing, Logical and Bitwise 4.Functions, Tuples, Dictionaries, Exceptions, and Data Processing

The exam “blocks” for Fundamentals:

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

fundamental concepts: interpreting and the interpreter, compilation and the compiler, language elements, lexis, syntax analysis (parsing), semantics (applying language rules such as type mismatch)
Python keywords, instructions
indenting
REPL (Read Evaluate Print Loop interactive), control-D to exit()
comments. PROTIP: Text between triple-doublespace are actually string objects in the byte code
literals: Boolean, integer, floating-point numbers, scientific notation, strings. b’data’ literals can be split().
the print() function
the input() function
numeral systems (W: binary, octal, decimal, hexadecimal) W, *
numeric operators: ** * / % // + – // is floor division. Py3: Division always returns a float. Num (mod) % 2 is 0 for odd, 1 for even
string operators: * +
assignments and shortcut operators

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

Click “Start Course”. https://edube.org/login
Scroll down to the bottom of the left menu to click “Python Essentials 2 (PE2) Course Final Exam”, then “Final Test”.
Scroll down and answer all questions.
Click “Submit” for your score. Hopefully you’ll see “Congratulations, you have passed the assessment.”
Review items you got wrong.
Click “Reset” and answer again until you get 100%, so you know you have overcome incorrect thinking. Answering the questions you already know helps you get faster.
Answer the post-survey questions so you’ll get a “Discount coupon on completion of course” email from noreply@netacad.com containing a discount code unique to you.
DOTHIS: Email me the discount code so I can send you the exam code.
When you get the exam code, visit https://pearsonvue.com/pythoninstitute to register for the exam.

PROTIP: Aligned with PCEP-30-01 exam topics is the FiriaLabs.com $109/year/student curriculum hands-on “missions” to control autonomous robots (both physically and virtually) configured using their web-based CodeSpace IDE.

Cisco PE2 PCEP-31-0x
Click “Python Essentials 2”
Notice the PCAP (Certified Associate in Python Programming) exam sections:
1. Modules, Packages, and PIP
2. Strings, String and List Methods, Exceptions
3. Object-Oriented Programming
4. Miscellaneous

https://edube.org/study/pe2

Repeat as above.

Passing this prep exam gets you a discount coupon for 50% ($150) off the actual $295 exam fee for a cost to you of $144.

Continue to Advanced Python (PE3)

Python Advanced 1 (Advanced OOP)
- Classes, instances, attributes, methods, as well as working with class and instance data
- Shallow and deep operations
- Abstract classes, method overriding, static and class methods, special methods
- Inheritance, polymorphism, subclasses, and encapsulation
- Advanced exception handling techniques
- The pickle and shelve modules
- Metaclasses
Python Advanced 2 (Best Practices and Standardization
- Best practices, standardization, and coding conventions
- How to implement the conventions for code comprising the standard library in the main Python distribution
- The principles that influence the design of Python code
- How to write a better and more effective code
- How to avoid the most common errors and mistakes
Python Advanced 3 (Introduction to GUI Programming in Python (TkInter)
- what GUI is and where it came from
- how to create Graphical User Interfaces (GUIs) in Python using the tkinter package
- how to construct a GUI using basic blocks and conventions
- how event-driven programming works
- some popular and commonly used GUI environments and toolkits
- what tkinter is and how to build a GUI with its help
- how to use widgets, windows, and events
- how to create basic applications based on tkinter’s application life cycle
Python Advanced 4 (Working with RESTful APIs)
- The basic concepts of network programming, REST, network sockets, and client-server communication
- How to use and create sockets in Python, and how to establish and close the connection with a server
- What JSON and XML files are, and how they can used in network communication
- What HTTP methods are, and how to say anything in HTTP
- How to build a sample testing environment
- What CRUD is
- How to build a simple REST client, and how to fetch and remove data from server, add new data to it, and update the already-existing data
Python Advanced 5 (File Processing and Communicating with a Program’s Environment)
- sqlite ‒ 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

Cisco Final Exam 2 Question 27

def o(p):
    def q():
        return '*' * p
    return q

r = o(1)
s = o(2)
print(r() + s())

This is an example of a “closure” in Python.

The inner function o is a function factory - it creates functions on the fly and returns functions instead of a value. It allows for dynamic (parameterized) function generation with customizable behavior.

https://realpython.com/factory-method-python/

The inner function q “remembers” the value of p that was passed to the outer function o. Each call to o creates a new function with its own “remembered” value of p.

https://www.youtube.com/watch?v=JIImCgkAQxY&t=61s

Cisco Final Exam 2 Question 33

Look at the following code:

numbers = [0, 2, 7, 9, 10]
# Insert line of code here to produce [0, 4, 49, 81, 100]
print(foo)

Which line would you insert in order for the program to produce the expected output?

Choices given for the question suggests use of lambda within filter() and map() functions, all within a list:

a) foo = lambda num: num * 2, numbers
b) foo = lambda num: num ** 2, numbers
c) foo = filter(lambda num: num ** 2, numbers
) d) foo = map(lambda num: num ** 2, numbers)

Before looking at the answers, we can see that the output sought (in foo) is the square of the input numbers:

2*2 = 4
7*7 = 49
9*9 = 81
10*10 = 100

To calculate a square, we use num ** 2

QUESTION: What does the filter function do?

filter() is a built-in function that takes two parameters: a function (such as lambda) and an iterable (like a list, tuple, or set) and returns an iterator containing only the elements for which the function returns True.

The answer yields an internal Python object ID and its value from lambda:

(<function at 0x10042d4e0>, [0, 2, 7, 9, 10])</tt>

foo = list(filter(lambda num: num ** 2, numbers))

Cisco Final Exam 2 Question 34

A more complex question uses a list comprehension [i*i for i in range(5)]

numbers = [i*i for i in range(5)]
# Insert line of code here to produce [1, 9]
print(foo)

Before looking at the answers, what value is contained in the numbers variable?

range(5) produces 5 values, from 0 to 4:

[0, 1, 2, 3, 4]

QUESTION: What does the i*i do?

It multiples i by itself (turning into a square of itself), yielding:

numbers = [0, 1, 4, 9, 16]

The question is asking for [1, 9] to be produced.

So that’s the second and fourth item from the five-item input list, which are the even numbers.

x % 2 reminders would yield even numbers.

That is shown by:

print(lambda x: x % 2, numbers)

which shows internal Python object ID and its value from lambda:

<function at 0x1001dc9a0> [0, 1, 4, 9, 16]</tt>

The list() function extracts out the values of [0, 1, 4, 9, 16].

Now the choices given for the question:

a) foo = list(map(lambda x: x // 2, numbers))
b) foo = list(map(lambda x: x % 2, numbers))
c) foo = list(filter(lambda x: x / 2, numbers))
d) foo = list(filter(lambda x: x % 2, numbers))

The filter() function with lambda x: x % 2 does the following: x % 2 returns 1 (truthy) for odd numbers x % 2 returns 0 (falsy) for even numbers

This effectively keeps only the odd numbers in the list So filter(lambda x: x % 2, numbers) will keep only the odd squares: [1, 9]

QUESTION: What does the map function do?

That’s put there as a distractor.

The map() function is a built-in Python function that transforms iterables by applying a specified function to each item in an iterable.

Perplexity.ai says the answer is b:

foo = list(filter(lambda x: x % 2, numbers))

Cisco Final Exam 1 Question 35

This makes use of some methods for the random package described at https://docs.python.org/3/library/random.html

import random
# Insert lines of code here.
print(a, b, c)

Which lines of code would you insert so that it is possible for the program to output the following result:

6 82 0

Analysis:

Running the code provided is unlikely to yield “6 82 0” because the methods used generate random numbers.

https://docs.python.org/3/library/random.html#random.randint

random.randrange(10, 100, 3) # Returns a randomly selected element from range(start, stop, step).

random.randint(0, 100) # Returns a random integer N such that a <= N <= b

random.choice((0, 100, 3)) # Returns a random element from the non-empty sequence

Each set (A,B,C,D) uses output variables a,b,c using different random.methods.

Let’s analyze each command to see if it can yield “6 82 0”.

A:
a = random.randrange(10, 100, 3)
# Doesn’t qualify because 6 is < 10.
b = random.randint(0, 100)
# Can qualify because 92 can be between 0 to 100.
c = random.choice((0, 100, 3))
# Can qualify because 92 can be 0.

B:
a = random.choice((0, 100, 3))
b = random.randrange(10, 100, 3)
# Doesn’t qualify because 82 is not divisible by 3.
c = random.randint(0, 100)

C:
a = random.randint(0, 100)
b = random.randrange(10, 100, 3)
# Doesn’t qualify because 82 is not divisible by 3.
c = random.choice((0, 100, 3))

D:
a = random.randint(0, 100)
b = random.choice((0, 100, 3))
# Doesn’t qualify because 82 is not divisible by 3.
c = random.randrange(10, 100, 3)

REMEMBER: The answer choice is rearranged by the testing software:

a) B
b) C
c) D
d) A

So no good choices?

PCAP-31 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 PCPP-32-101

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 (RealPython.com)
Constructing a GUI – basic blocks and conventions - cross platform
Event-driven programming
Currently used GUI environments and toolkits - built into the Python standard library.
python -m tkinter “T Kinter” or “Tk interface”
- tkinter’s application life cycle VIDEO $15
- Widgets, windows and events
- Sample applications complexexample
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 PCPP-32-

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

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

MogoDB Python

MongoDB has free program for Academia and for Students in C#, Java, Node.Js, PHP, and Python.

Complete the MongoDB Python Developer Path online through MongoDB University for a free ticket to take their
$150 MongoDB Associate Developer Exam of 53 questions in 75 minutes online.

CAUTION: The code makes use of MongoDB Atlas, their cloud-based database which comes with a monthly bill for usage.

1 hour Practice Questions

Video courses

I’m adding links to YouTube such as [M] next to topics below.

The most friendly and enthusiastically delivered “PCAP – Python Certification Course” I think is by Lydia Hallie living in Netherlands (https://www.lydiahallie.io). The content is delivered in enthusiastic, perfect English by the 20-something developer whiz, who presents “visualized” diagrams. As with other KodeKloud (subscription) video courses, this class includes labs, Quizzes, Mock Exams, and Q&A participants to cover Module, Packages and PIP, String and List Methods, Exceptions, Object Oriented Programming, etc.

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

https://www.udemy.com/topic/certified-associate-in-python-programming-pcap/ Udemy.com’s mock PCAP tests

zzz

Retired Python certs

Microsoft’s exam 98-381 “Introduction to Programming Using Python” was retired June 30, 2022

Skills measured

Perform Operations using Data Types and Operators
Control Flow with Decisions and Loops
Perform Input and Output Operations
Document and Structure Code
Perform Troubleshooting and Error Handling
Perform Operations Using Modules and Tools

LinkedIn Certifications Retired

LinkedIn USED TO offer several free certifications based on 30-minute 20-question multiple-choice questions. Retest every 6 months if you don’t pass. Good forever. Wikiwand

The unique thing about LinkedIn certifications is that they are form the basis for more legitimate way to tag individuals with skills employers and their recruiters search for. So it’s worth the time to take them if you want to be found based on your demonstrated skills.

LinkedIn offers Python certificate exam. A sample: https://github.com/Ebazhanov/linkedin-skill-assessments-quizzes/blob/main/python/python-quiz.md PROTIP: The questions are not the same each time you take the test, so you can take it multiple times to get a higher score.

VIDEO: Review one set of questions

References

https://www.dataquest.io/blog/python-certification/

More about Python

This is one of a series about Python:

Wilson Mar