PCEP vs PCAP: Which Python Certification Is Worth It?

Somebody who has been learning Python for a few months hears about certification and finds two of them from the same organisation, one costing under a hundred dollars and one costing nearly three hundred. The obvious questions follow. Are they the same thing at two levels? Does anybody care about them? Is either worth the money?

Short version: they are genuinely different exams rather than a hard and easy version of one exam, the price gap is real and reflects that, and whether either is worth buying depends on something specific about your situation rather than on whether certifications are good.

The two exams, line by line

Both are sat online with a proctor, both add a few extra minutes for the agreement and tutorial before the clock starts, and both use question formats beyond simple multiple choice. PCEP in particular mixes in drag and drop, gap fill, sorting, code fill and code insertion items, which is worth knowing in advance because it is not the format most practice material trains you on.

What each one actually covers

PCEP covers the first months of Python: literals and variables, numeral systems and operators, data types, input and output, conditionals and loops, lists and tuples and dictionaries, functions, and the basics of exceptions. A person who has genuinely finished a beginner course knows all of it, and the exam is largely a test of whether they know it precisely rather than approximately.

PCAP is a different set of ideas rather than the same ones turned up. Modules, packages and PIP. Character encoding, strings and string processing. Generators, iterators and closures. Files, file streams and file processing. Exception hierarchies as classes and objects. The Standard Library. And object oriented programming, which is the largest single block of it.

Two PCAP topics that people think they know

Here is what associate level means in practice. Take closures. Most self taught programmers have written one without noticing, and most cannot predict what this does.

def make_multipliers_wrong():
    result = []
    for n in range(1, 4):
        result.append(lambda x: x * n)
    return result


def make_multipliers_right():
    result = []
    for n in range(1, 4):
        result.append(lambda x, n=n: x * n)
    return result


print("wrong:", [f(10) for f in make_multipliers_wrong()])
print("right:", [f(10) for f in make_multipliers_right()])

wrong: [30, 30, 30]
right: [10, 20, 30]

The first list gives 30, 30, 30. Every lambda looks up n when it is called, not when it was created, and by then the loop has finished and n is 3. The second binds the current value through a default argument, so you get 10, 20, 30. This is not a trick question and it is not a Python quirk. It is what a closure is, and PCAP expects a candidate to be able to say why rather than to have memorised the fix.

Or generators, where the point is what is not built.

import sys


def squares(limit):
    for n in range(limit):
        yield n * n


gen = squares(1_000_000)
lst = [n * n for n in range(1_000_000)]

print("generator object :", sys.getsizeof(gen), "bytes")
print("list of the same :", sys.getsizeof(lst), "bytes")
print("first three from the generator:", [next(gen) for _ in range(3)])

generator object : 200 bytes
list of the same : 8448728 bytes
first three from the generator: [0, 1, 4]

The list of a million squares occupies 8,448,728 bytes. The generator occupies 200, roughly 42,244 times smaller, because it has produced nothing at all until something asks it for a value. Then next is called three times and out come 0, 1 and 4. Understanding that difference is the sort of thing that separates somebody who can use Python from somebody who can reason about it, which is exactly the line PCAP is trying to draw.

So is either one worth the money?

Here is the honest answer, and it is not the one certification providers give. No employer will hire somebody because they hold PCAP. What gets people hired is work somebody can look at, and a certificate is not that. Anybody promising otherwise is selling something.

Two things a certification does give you, though, and both are genuinely valuable to the right person.

• A deadline with money attached. Most people who quit learning to program do not quit because it was too hard, they quit because nothing was due. A booked exam with a fee paid is an unusually effective commitment device, and for a self taught learner working alone that structure can be worth the price on its own.
• A syllabus written by somebody else. Self taught learners develop lopsided knowledge and cannot see the gaps, because you do not know what you have not met. Working through the PCAP topic list surfaces the parts you skipped, which for most people is generators, encoding and the exception hierarchy.

So the cases where we would say yes: a career changer who needs something concrete on a CV that has no computing on it at all, a student who needs external structure and responds to deadlines, or somebody whose employer will reimburse the fee. The case where we would say no: a person who could spend those three hundred dollars on nothing and instead ship two small projects with a readme and a link, because those will do more.

How to prepare, whichever you choose

1. Write code, do not read about code. Both exams include items that ask you to complete or insert code, and recognition is not the same skill as production. Everything on the PCAP list can be practised in a file.
2. Predict before you run. Take a snippet, say out loud what it will print, then run it. Every gap between prediction and reality is a piece of the exam you would otherwise have got wrong.
3. Learn the exception hierarchy properly. It is the topic candidates most reliably skim, and it is a whole block of the PCAP syllabus. Exceptions are classes with parents, and once that lands, most of the questions become straightforward.
4. Do at least one timed practice under the real clock. Forty questions in sixty five minutes is well under two minutes each, and candidates who have never rehearsed the pace lose marks to time rather than to knowledge.

A certificate proves you passed an exam. A repository proves you can build something. If you can only afford one of those, build the thing.

, What we tell adult learners who ask about certification

How we teach it

We teach the certification course because a lot of adult learners want the structure it provides, and because the PCAP syllabus happens to be a good list of the things self taught programmers miss. What we will not do is teach to the exam only, because a person who passes PCAP and cannot build anything has bought an expensive piece of paper.

Our Python certification classes are live, one to one or in a batch of five to eight students, taught from India to students worldwide. The course works through the syllabus with code written in every session, and if the honest recommendation on the free first class is that you should skip the exam and build a portfolio instead, that is what you will hear.

Frequently asked questions