A Python course in Peru, chosen by what learners can prove

1. Code is reviewed by a person, every week. Automatic graders tell you a program failed; a mentor tells you why your thinking went wrong. Our mentors read learners' code live in class and talk through it line by line.
2. Learners write tests, not only programs. A course that never asks "what input would break this?" produces code that works once. Ours introduces assert early and asks for edge cases before a task counts as done, as in the lesson further down.
3. The Python is current. The course should install a supported release. The CPython developers released 3.15.0 on 9 October 2026 and stopped fixing 3.10 altogether eight days earlier; we start new learners on a release still in bugfix support.
4. Exam claims are precise. If a course mentions certification, it should name the exam, its code and who runs it. We prepare learners for the Python Institute's PCEP and PCAP when they want them; our own certificate of completion is separate, and neither is a Peruvian qualification.
5. You see a real class first. Our first class is free, needs no card, and is a normal lesson with code, not a presentation.

If you read Spanish more comfortably, our Spanish guide mejor curso de Python en Perú approaches the same choice by separating must-haves from preferences. The classes behind both pages are identical: live, online and in English.

def runner_up(scores):
    """Return the second-highest score."""
    ordered = sorted(scores)
    return ordered[-2]

print(runner_up([12, 19, 15]))

tests = [([12, 19, 15], 15), ([17, 17, 9], 9), ([20, 20, 20], None), ([14], None)]
for scores, expected in tests:
    try:
        got = runner_up(scores)
    except IndexError:
        got = "IndexError"
    print(scores, "expected", expected, "got", got, "PASS" if got == expected else "FAIL")

def runner_up(scores):
    """Return the second-highest distinct score, or None if there is none."""
    distinct = sorted(set(scores), reverse=True)
    return distinct[1] if len(distinct) >= 2 else None

assert runner_up([12, 19, 15]) == 15
assert runner_up([17, 17, 9]) == 9
assert runner_up([20, 20, 20]) is None
assert runner_up([14]) is None
assert runner_up([]) is None
print("all 5 tests pass")

The fix is one line, but the real lesson is the decision behind it. The learner had to choose what "second-highest" means when scores tie, and what to return when there is no answer. Writing the tests forced that choice into the open; set() removes the duplicate top scores, and returning None handles the short lists honestly instead of crashing.

1. Break it again. Add a test with negative numbers, such as [-3, -7, -1]. Predict the answer before running it.
2. Change the rule. Suppose the teacher says tied winners mean the runner-up is also the top score. Rewrite the tests first, then the function.
3. Count the cost. Version 2 sorts the whole list. Write a version that walks the list once, keeping the top two values, and check it against the same tests.
4. Explain it. In two English sentences, say why the first example was not enough evidence.