Tricky Areas in Python

[Alex Martelli]

PyPK <superprad at gmail.com> wrote:

> What possible tricky areas/questions could be asked in Python based
> Technical Interviews?

I like to present code that seems like it should work, but has some kind
of relatively subtle problem, either of correctness in some corner case,
or of performance, etc -- and I ask them what they would say if they
were to code-review that code, or how they would help a student who came
to them with that code and complaints about it not working, &c.

This tells me whether they have real-world Python experience, and how
deep, or whether they've carefully studied the appropriate areas of
"Python in a Nutshell" and the Cookbook (and I'm biased enough to think
that the second kind of preparation is almost as good as the first
kind...;-).

Not sure whether you think this count as "tricky"... they're typically
problems that do come up in the real world, from (e.g.):
    for string_piece in lots_of_pieces:
        bigstring += string_piece
(a typical performance-trap) to
    for item in somelist:
        if isbad(item):
            somelist.remove(item)
(with issues of BOTH correctness and performance), to
    class Sic:
        def getFoo(self): ...
        def setFoo(self): ...
        foo = property(getFoo, setFoo)
to
    class Base(object)
        def getFoo(self): ...
        def setFoo(self): ...
        foo = property(getFoo, setFoo)

    class Derived(Base):
        def getFoo(self): ....

and so on, and so forth.  If a candidate makes short work of a couple of
these, and I've been asked to focus my part of the interview solely on
Python coding, I may branch out into more advanced stuff such as asking
for an example use case for a closure, a custom descriptor, or an import
hook, for example -- those are the cases in which I'm trying to decide
if, on a scale of 1 to 5, the candidate's Python competence is about 4
or well over 4 (I would not consider having no idea of why one might
want to code a custom descriptor to be at all "disqualifying" -- it
would just mean I'd rate the candidate 4 out of five, instead of 4.5 or
more, for Python coding competence).


Alex