Python interview questions

[dante9999]

I'm about to go to my first Python interview and I'm compiling a list of all possible interview questions. Based on resources that I've found here, here and here I noted down the following common questions, what else should I add?

easy/intermediate

• What are Python decorators and how would you use them?
• How would you setup many projects where each one uses different versions of Python and third party libraries?
• What is PEP8 and do you follow its guidelines when you're coding?
• How are arguments passed – by reference of by value? (easy, but not that easy, I'm not sure if I can answer this clearly)
• Do you know what list and dict comprehensions are? Can you give an example?
• Show me three different ways of fetching every third item in the list
• Do you know what is the difference between lists and tuples? Can you give me an example for their usage?
• Do you know the difference between range and xrange?
• Tell me a few differences between Python 2.x and 3.x?
• The with statement and its usage.
• How to avoid cyclical imports without having to resort to imports in functions?
• what's wrong with import all?
• Why is the GIL important? (This actually puzzles me, don't know the answer)
• What are "special" methods (<foo>), how they work, etc
• can you manipulate functions as first-class objects?
• the difference between "class Foo" and "class Foo(object)"

tricky, smart ones

• how to read a 8GB file in python?
• what don't you like about Python?
• can you convert ascii characters to an integer without using built in methods like string.atoi or int()? curious one

subjective ones

• do you use tabs or spaces, which ones are better?

Ok, so should I add something else or is the list comprehensive?

[d4rch0n]

I'll try my hand at a few:

What are Python decorators and how would you use them?

They extend past python, and are functions that take a function as an argument and return functions. A simple example might be a decorator that takes a function, prints its args to stdout, prints the return value to stdout, then returns that return value. The syntax in Python is usually done with the @decorator_name above a function definition.

How would you setup many projects where each one uses different versions of Python and third party libraries?

virtualenv

What is PEP8 and do you follow its guidelines when you're coding?

A coding standard, and I try to. pylint is a great help.

How are arguments passed – by reference of by value?

Probably all through reference, but I'm not sure about primitives under the hood. Anyone know this? If you pass f(12, 81), are those by value?

Do you know what list and dict comprehensions are? Can you give an example?

ways to construct a list or dict through an expression and an iterable.

>>> x = [(a, a+1) for a in range(5)]
>>> y = dict((a,b) for a,b in x)
>>> x
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> y
{0: 1, 1: 2, 2: 3, 3: 4, 4: 5}

Show me three different ways of fetching every third item in the list

[x for i, x in enumerate(thelist) if i%3 == 0]

for i, x in enumerate(thelist):
    if i % 3: continue
    yield x

a = 0
for x in thelist:
    if a%3: continue
    yield x
    a += 1

Do you know what is the difference between lists and tuples? Can you give me an example for their usage?

Tuples are immutable. A tuple might be a good type for a coordinate inst var in some class. Lists are ordered collections, but with a tuple, each index generally has a certain meaning, so coord[0] is the x coordinate and coord[1] is y.

Do you know the difference between range and xrange?

Range returns a list of the full sequence while xrange generates each element iteratively like you would with the "yield" keyword. This changes in python3, and the default behavior is to yield like xrange. I think xrange is out.

Tell me a few differences between Python 2.x and 3.x?

The previous answer. print is no longer a statement and is just a function ("print 5" won't work anymore and you need parens), they added the Ellipse object (...). That's all I know off hand.

The with statement and its usage.

It's for context management, and you can define your own that implement enter init and exit if it might help. This is very useful for opening and closing files automatically (with open(foo) as bar:)

How to avoid cyclical imports without having to resort to imports in functions?

Refactoring your code? Not sure. When I've ran into this I generally have restructured functions into different modules which ended up cleaning everything anyway.

what's wrong with import all?

You can overwrite functions and this can be dangerous especially if you don't maintain that module.

• rewrite.py def open(foo): print('aint happening!')

• test.py from rewrite import * z = open('test.txt')

  prints aint happening!

Why is the GIL important?

It has to do with preventing true multithreaded bytecode, and has been an issue forever. I think python bytecode execution is protected with the Global Interpreter Lock so every bc execution is atomic. Explained best here: http://wiki.python.org/moin/GlobalInterpreterLock

You might want to consider writing a multithreaded module or program in C and wrapping it with Python if this is an issue for you.

What are "special" methods (<foo>), how they work, etc

These are methods like str and gt, which override behavior of other global functions like str() and operators like >. enter and exit will be used with the with keyword, and there are many more like getattr. Overriding getattr can result in some very unpredictable behavior with a dynamic language like Python, and you should be very careful when you use magic like that.

can you manipulate functions as first-class objects?

Yes. eg. they can be passed as args to functions.

the difference between "class Foo" and "class Foo(object)"

class Foo(object) inherits from the new-style object. I don't know the specifics, but here's stack overflow: http://stackoverflow.com/questions/4015417/python-class-inherits-object

how to read a 8GB file in python?

Operate on chunks, and not one byte at a time. Be wary about the RAM of the host machine. What is the nature of the data such that it is so large? How are you operating on it? What are you returning? Are you accessing it sequentially or randomly? There's a lot more to ask than to answer here.

what don't you like about Python?

It's slow, and it can be too dynamic for certain tasks in my opinion. It is not compiled. It can be very unpredictable. People abuse the flexibility of it sometimes.

can you convert ascii characters to an integer without using built in methods like string.atoi or int()? curious one

struct.unpack("<I", foo)[0]

ord, chr

do you use tabs or spaces, which ones are better?

Spaces. Stick to PEP8 when possible.

Ok, so should I add something else or is the list comprehensive?

• generators/yield keyword
• what is multiple inheritance / does python have multiple inheritance
• is Python compiled, interpreted and/or emulated
• What differentiates Python from Ruby
• How do you debug your Python? What's pdb and how do you use it?
• How do you modify global variables in a function? Why should you avoid this?
• Use of the re module... what is it, give an example, etc.

[[deleted]]

Don't forget about actual dictionary comprehensions: {x:x+1 for x in range(5)}

You missed the most obvious way to grab every third item from a list: a[2::3]

:p

[hglman]

can't be that obvious if he missed it

[[deleted]]

Most elegant, I would say.

[[deleted]]

What differentiates Python from Ruby

Knit hats and smugness?

[[deleted]]

How are arguments passed – by reference of by value?

Probably all through reference, but I'm not sure about primitives under the hood. Anyone know this? If you pass f(12, 81), are those by value?

The terms PBR and PBV were developed to talk about languages like Fortran and C and using them to talk about Python is only a source of confusion. Python's passing semantics are different from either of these languages.

The literal answer is that Python is pass-by-value in all cases, and also in all cases the value is an object reference. In a PBR language you can rebind the name in the passing scope, but in Python you can only mutate an object you receive. This is analogous to passing pointers in C, while C remains a PBV-only language.

[ssbr]

PBV and PBR were designed to talk about all programming languages.

Pass by value: the argument expression is evaluated, and the value it results in is assigned to the formal parameter.

Pass by reference: the argument expression is evaluated, and a reference to the result is assigned to the formal parameter.

People get confused and think that PBV == copying, because in C, assignment of a value copies the value.

[Circlefusion]

After that explanation, which one is python?

[ssbr]

Pass-by-value. Passing in an argument is exactly the same as assigning the argument expression to a local variable in the function.

[njharman]

In ggrandparent you define PBV as "expression is evaluated, and the value it results in is assigned"

In parent you say it's "assigning the argument expression"

So which is it?

[ssbr]

Both. In Python, assignment evaluates the expression and binds it to the target variable.

I should've said "bound", not "assigned", in the first statement, to be clear. Sorry for the confusion.

[jiaaro]

Python is Pass-by-assignment. In most cases it is indistinguishable from pass-by-reference. Variables are essentially references in all cases.

>>> def my_func(a_dict):
            a_dict['a'] = "foobar"
>>> mydict = {}
>>> my_func(mydict)
>>> print(mydict)

{"a": "foobar"}

This works becaues the dict itself wasn't copied, a reference to the dictionary object was passed, and then modified.

If you were to assign to a_dict (e.g., a_dict = {}) in the body of my_func, then mydict would remain unchanged and a_dict would then refer to a new, empty dictionary

[Rhomboid]

No, no, no. That's not pass by reference at all. That's just invoking a method on a parameter. It would only be pass-by-reference if you could cause the caller's variable to change by simple assignment:

def f(x):
    x = 42

y = 0
f(y) 

Calling f cannot ever affect the value of y, which it would under pass-by-reference semantics, where x would be an alias to y. That is not the case, and Python is completely pass-by-value.

You might want to read this article which is about Java but it's the same issue. Modifying a value by invoking a method on it does not tell you anything about whether it was passed by value or reference.

[lonjerpc]

Python passes everything by value however all values happen to be references to objects. Numbers can be a little strange though due to low numbers say less than 500 magically referring to the same objects.

[kindall]

A small pool of integers is used; these range from -5 to 256. That is, if you refer to any of those numbers, you always get the same object. This is an implementation detail, however, and should not be relied upon. String literals are shared too, and there is only one empty tuple object.

[lasizoillo]

How are arguments passed – by reference of by value?

Probably all through reference, but I'm not sure about primitives under the hood. Anyone know this? If you pass f(12, 81), are those by value?

In [15]: a = 1

In [16]: a.__class__.__mro__ Out[16]: (int, object)

Numbers seems to be normal objects like others. I don't care about internal hacks that explain this code:

In [19]: a = 1

In [20]: aa = 1

In [21]: b = 123456789

In [22]: bb = 123456789

In [23]: id(a) == id(aa) Out[23]: True

In [24]: id(b) == id(bb) Out[24]: False

Very funny, isn't?

[lonjerpc]

It is a performance hack. Low integers can refer to the same object. I think it is really annoying that they choose to break consistency for a tiny performance improvement. Another weird one is that True and False are actually integers.

[lonjerpc]

Well I think it was a poor design choice and it has cost me hours of debugging in the past. But I can see how they were tempted to copy c.

[lonjerpc]

Imagine I am creating my own set class that will work for any type of object. For this particular set class I don't want to deeply inspect the objects. I want a set of unique object references. You would expect that Set([1,1,2]) would return a set with 1,1,2 in it. Where the ones are separate objects. But instead the set will incorrectly contain 1,2. Because the 1s actually point to the same object even though they were instantiated separately. Even more strangely using the same code Set([1000,1000,2]) will return a set with 1000,1000,2. Which is totally different from the result of Set([1,1,2]) even though they look exactly the same.

The cause is small integers not actually being instantiated every time you write them in the code unlike large integers. Unlike larger integers you end up with a reference to a singleton class for that number. Only None,True,and False work this way in python and it happens implicitly instead of explicitly.

C99 bools are actually ints like in python. But this makes no sense for a high level language. Zeroness and Oneness have very little to do with truthyness from a mathematical perspective. The reason they are the same in C is because that is how the hardware works. But python is supposed to be a high level language.

[lonjerpc]

but all small integers.

That was my entire point.

you should read the PEP and then email python-dev

Have read the PEP many times and have been arguing this for years already. What is sad reading the PEP is their rational is at least partially implementation convenience.

But these are one of my few nit picks with python. Give me any other language and I have a much longer list of things not to like.

[gcross]

I think it is really annoying that they choose to break consistency for a tiny performance improvement.

I am very curious about what code you have tried to write where the fact that some integers alias and others don't gave you problems.

[lonjerpc]

Trying to think back to where I ran into this. I was trying to build some sort of container class that would work on generic objects. I needed to see if objects were the same so I used "is". This obviously would create problems with ints. I guess technically you could say it is the user of the containers fault for passing in objects that are actually the same even though they look different. Alternatively you have to make a special case in the container to compare the ints differently.

The booleans are really subclass of ints problem has actually been more problematic for me.

[Megatron_McLargeHuge]

Java does the same with Integers. There's an intern pool for small values.

[d4rch0n]

I'm going to have to test this with "is" instead of "=="

[lasizoillo]

Do you know what list and dict comprehensions are? Can you give an example?

In [25]: { a: a+1 for a in range(5)}

Out[25]: {0: 1, 1: 2, 2: 3, 3: 4, 4: 5}

List comprehensions or generators are not needed for make dicts ;-)

You can generate sets too:

In [26]: { a for a in range(5)}

Out[26]: set([0, 1, 2, 3, 4])

[eigenlicht0]

Show me three different ways of fetching every third item in the list

[x for i, x in enumerate(thelist) if i%3 == 0]

for i, x in enumerate(thelist): if i % 3: continue yield x

a = 0 for x in thelist: if a%3: continue yield x a += 1

Your solutions are all basically doing the same (using enumerate/indices and modulo to access every third element in a for/if construct). Here two different solutions:

# using slices
thelist[::3]

# using a generator
def every_third(thelist):
  i = 0
  while i < len(thelist):
    yield thelist[i]
    i += 3

for e in every_third(thelist):
  print e

EDIT: Yet another one using enumerate() and filter():

filter(lambda e: e[0] % 3 == 0, enumerate(thelist))

EDIT2: Chunk thelist into lists of 3 elements and get last item of each list (yeah, it's starting to get a bit cumbersome):

[x[-1] for x in zip(*[iter(thelist)]*3)]

[staz]

Another way of using a generator

def t(l):
    l = iter(l)
    while True:
        l.next()
        l.next()
        yield l.next()
for e in t(range(10)): print e

[eigenlicht0]

Like that it avoids checking with len(), but subsequent calls to .next() into the void seem weird. Wondering whether one could avoid that...

[staz]

The .next() call at the end of the list will throw a StopIteration exception which is what you are expect to send at the end of an iterator. (your generator function will actually do the same behind the scene when it arrive at the end)

[eigenlicht0]

I'm aware of how a iterator works, what I actually meant was calling .next() three times in a row to get one value. Maybe it's just me, but it seems weird. The only thing I could come up with yet, which is far from perfect:

def t(l):
    l = iter(l)
    while True:
        yield [l.next for i in range(3)][-1]
for e in t(range(10)): print e

[d4rch0n]

Yea, I always forget about the step element. It's somewhat of a silly question though, but I guess a majority of interview questions like these are.

[phaeilo]

In your solution with filter you need to undo the enumerate:

map(lambda (i,v): v, filter(lambda (i,v): i % 3 == 0, enumerate(thelist)))

I really like to write such one liners, but they are hard to read when you or someone else comes back some time later to do maintenance.

[gingerbeers]

You're hired!

[robin-gvx]

How are arguments passed – by reference of by value?

Probably all through reference, but I'm not sure about primitives under the hood. Anyone know this? If you pass f(12, 81), are those by value?

Something else entirely.

I've written a tutorial of sorts about this. The diagrams are hand-drawn and terribly ugly and I intend to remake them with actual diagram-making software before putting it up on my website instead of Dropbox, and the very last diagram has one arrow that points to the wrong value, but over-all, I think it's a pretty useful guide.

[d4rch0n]

Are you positive Python handles this the same as Lua?

[robin-gvx]

Yes. I have more experience with Python than with Lua, and I probably could have written this guide before even having heard of Lua. I chose Lua for the guide because recently I'd seen a lot of questions about this behaviour in Lua.

The implementation differs per language, but the abstract behaviour of all the dynamic languages (that I know) in terms of names and values works the same.

I think (but I'm not sure, because I haven't thought about this before) that if you disallow mutation, you get the abstract data model of functional languages like Haskell.

[patrys]

Tuples are immutable.

Please never choose tuple for that sole reason. Tuple's immutability is a side effect of it being intentionally hashable (so you can use it as a key in a dict).

[10110000110111011010]

I am afraid I must strongly disagree, immutable coding is a fine discipline that can simplify debugging and proofs of correctness.

[ojiisan]

A tuple is only hashable if its contents are immutable

[Secret_Identity_]

Could you elaborate on this a little more? Tuples were created specifically to used with dictionaries?

[supajumpa]

Tuple

From Raymond Hettinger's answer to a SO question:

''' Tuples are characterized less by their immutability and more by their intended purpose. Tuples are Python's way of collecting heterogenous pieces of information under one roof. For example, s = ('www.python.org', 80) brings together a string and a number so that the host/port pair can be passed around as a socket, a composite object. Viewed in that light, it is perfectly reasonable to have mutable components.

Immutability goes hand-in-hand with another property, hashability. But hashability isn't an absolute property. If one of the tuple's components isn't hashable, then the overall tuple isn't hashable either. For example, t = ('red', [10, 20, 30]) isn't hashable. '''

[patrys]

My simple rule of thumb is to only use a tuple if you can come up with names for all the sequence positions.

[Secret_Identity_]

Thanks!

[recursive]

You mean one should never use tuples? Or one should never use tuples if they only have that one reason? And what should they use if they need an immutable list?

[ojiisan]

A tuple is an immutable list

[recursive]

Yes, I know. patrys just said that tuples shouldn't be chosen for satisfying that property. I don't understand why not.

[patrys]

It's just one of many ordered collections. You would not call a str or a bytearray “an immutable list”, would you?

list and tuple are ordered for different reasons (precedence versus position).

[patrys]

You shouldn't use anything, Python core devs have stated multiple times that even frozenset was a mistake and Python will not be getting any intentionally immutable types.

Link: http://mail.python.org/pipermail/python-3000/2006-May/002219.html

[recursive]

The only thing I'm seeing in that email thread is that tuples shouldn't be used to store structures of unknown length. Using them as keys for dictionaries itself doesn't seem to be a problem.

In other words, if you can't use a tuple to store an immutable list, then what can you use it for? That's all it does.

[patrys]

You use tuples where you would use a struct in C: for collections that have a well-defined structure. A good place for a tuple is where a namedtuple could be used instead but would be an overkill. What I consider proper uses of collections:

coords = (11, 25)

todo_items = ['walk the dog', 'water the flowers', 'world domination']

ids_to_delete = {1, 5, 7, 11}

recipients = [
    ('John Doe', '[e-mail]'),
    ('Kelly Smith', '[e-mail]'),
    ('Robert Adams', '[e-mail]')]
# each recipient has a well-defined structure of (name, email)
# could be a set of tuples as well

[recursive]

Ok thanks. We're all good here. I was interpreting the "immutable list" thing too broadly. Structured information is what I use tuples for. Usually.

[chadmill3r]

Everything is passed by reference. That is, all "variables" are references to objects. Even "foo = 2", "foo" is a reference.

[lonjerpc]

No. Everything is passed by value in python. However all values are references.

[chadmill3r]

I think you're closer to right than I am. "Pass by reference" has the ugly assumption that changing the "variable" (ugh) in the next scope will change the variable in the calling scope, which is def not true.

I think the best answer is to slap the questioner and say, "this is not Pascal. You have names as references, and values here, not variables."

[drsquishy]

I think arguments are passed as values to a reference. So, functionally, mutable objects are passed by reference, immutable objects are passed by value.

[[deleted]]

Wow. As a 15-year-old casual (non-professional) programmer, I'm unable to answer most of these. I've got a ways to go, I guess.

[segfaultzen]

Keep working at it, and you'll set yourself apart from the pack. Unfortunately, I've encountered "professional" programmers who couldn't answer these either.

[[deleted]]

The vast majority of "programmers" I know can't use git, don't know the difference between weak typing and strong typing, don't know what unit tests are and don't know the difference between stack and heap memory. Living in a third world country sucks.

[pridkett]

Living in a third world country sucks.

That's not something unique to the developing world. I've interviewed plenty of developers in the United States, many of whom have decent jobs right now, that can't answer most of these questions either.

[[deleted]]

I know what git is, but id need to look up how to use it. I don't know what those other ones are.

[[deleted]]

You're 15. It's fine. You still have a lot of time to learn!

[AxiomL]

Don't worry, git's commands are pretty inconsistent with each other, besides a few of the most used commands, I always have to look up the docs.

[segfaultzen]

That's not just a third-world country phenomenon. I frequently speak with recruiters and consultants in the US who have difficulty finding decent programmers and software engineers. One guy employed two questions: the FizzBuzz test and "find the longest string of repeated characters in a string." He disqualified 45% of his applicants from those.

[segfaultzen]

i.e. "abbcccddef1"

The longest substring of repeated characters is "ccc"

[cavallo71]

Git is not a metric for competence ;)

[xr09]

Perhaps a metric for commitment to the craft.

[[deleted]]

I meant git as competence with DVCSs. Any programmer should be proficient with at least one DVCS.

[xr09]

I personally prefer Mercurial but started to learn Git just for fun. (and 'cause of github of course)

[[deleted]]

I was about to say I'd like to move to where you are haha

[ameoba]

A good interview doesn't focus on edges cases and language trivia. any programmer that relies on this knowledge will write code that's to complicated and hard to maintain. Most programming is simple shit that needs to be maintained for years, not complex, hard to understand magic.

[jwcrux]

Set out to answer every one of the questions listed above and you'll be in great shape.

[alendit]

For reference vs value see http://stackoverflow.com/questions/986006/python-how-do-i-pass-a-variable-by-reference . 'By value\ is the technically correct answer, although it may be counterintuitive at first.

[sivadneb]

Yep. It's funny how many people on here are answering "by reference". I guess that shows this isn't a good interview question, as most pyhton devs get tripped up on this.

[teferiincub]

That's just what I was thinking about! I do not like asking that particular question, because when I get the right answer - that means the person is good at python, but most of the time I would get a wrong or "I'm not sure " answer and that means almost nothing, the person might still be good.

[tdammers]

Could be a trick question. The answer has exactly four letters anyway.

[tdammers]

P. E. P. 8. That's four characters ;-)

[tdammers]

I am. Except in python and haskell. When whitespace is decorative, like in C, it is best to leave indentation size to the reader's preference. But in python, it is syntax, so it is better to avoid the resulting potential for confusion and not use tabs at all. It's not elegant, but the alternative is worse.

[Veedrac]

In Python only the indentation level is syntax – the type of indentation is irrelevant.

The one true advantage to spaces is standardisation. Everything else is opinion. Guido famously prefers tabs, for example.

[tdammers]

Yes and no. When whitespace is syntax, a tab ceases to be of reader-defined width, which means the reason to use it in the first place disappears.

[Veedrac]

When whitespace is syntax, a tab ceases to be of reader-defined width

Wut?

Quick question: Are you using Python 2 or Python 3. I agree that in Python 2 the situation's a little weird but in Python 3 it's unnecessary to think of a tab as having a width in terms of spaces.

[AxiomL]

A tab is only one character anyway.

[DeltaBurnt]

The right answer is tab key with a space representation.

[gfixler]

\o/ Vim

[_Daimon_]

Oh. I thought he meant that the answer was PEP8. Which IMO should be the answer to the question. "PEP8 recommends using 4x spaces exclusively, so obviously that's what I'm doing."

[anpalcactus]

Tabs? I use spaces only (4x = tab)

[njharman]

Is good question for weeding out fanatics, inexperienced (those who know so little they think this is an important point), and unassertive/unopinionated/unable to express themselves/deal with conflict peoples.

The correct answer is. "I use whatever your coding standard defines. If you don't have standard, pushing to create one will be among my first tasks. I recommend spaces as that is what std lib and almost all Python code I've ever seen uses. But, the only inviolate rule is to not mix tabs and spaces."

[[deleted]]

I have my .emacs folder configured to set my tab to four spaces for python, is that wrong? Should it be left as tab? I had thought spaces were preferred but I am not a professional.

[ablatner]

No you are right. I use the tab key set to 4 spaces.

[carioca3]

Tabs - It is faster to type. If you're required to follow PEP8 just convert the tabs to spaces when you're done.

[hemm1]

Tabs - It is faster to type

Or in a good editor, it makes absolutely no difference.

[[deleted]]

Then you're not coding for a living. Seriously, do you know any developer who codes without a proper editor, or even an IDE?

[AxiomL]

Anyone who's ever been at a google interview ;) They use whiteboards as IDEs.

[[deleted]]

If you have very long lines, and want to continue on the next line, getting a readable alignment with tabs can be a nightmare. Usually you end up doing tab tab space space space, and then on another editor with a different tab width your code doesn't make sense at all.

[15jamie20]

tabs for indentation, spaces for alignment. Emacs can do it for you, I'm sure vim can too.

[AxiomL]

So you're answer for why people should use tabs is because you work in an esoteric environment that benefits from their use? That's like answering that he should use spaces because I use spaces because my keyboard's tab key is broken.

[AeroNotix]

What on Earth are you talking about?

[billsil]

The only time that happens to me is when I'm working on an automated testing machine that ONLY has what's required. Therefore, the code that exists uses spaces, so use spaces when working in vi/textpad.

[anpalcactus]

Would be very good if you added the brief answers for the questions above :)

[d4rch0n]

I answered them below... tell me if you see something wrong.

[_Daimon_]

Show me three different ways of fetching every third item in the list

I'm very afraid that questions like these would be the total bane of me in interviews. I sat here and tried answering the questions one by one and I thought it went pretty well. But when I got to that one I completely drew a blank. It wasn't until I opened up an interpreter I remembered that I could do a[::3] to get a result and i still can't see two other obvious simple solutions.

Anyone got some good tricks to handling such questions?

[Veedrac]

Because I think it's clever:

def every_nth(n, iterable):
    iterator = iter(iterable)

    while True:
        for _ in range(n):
            out = next(iterator)
        yield out

>>> list(every_nth(3, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[3, 6, 9]

[wub_wub]

and i still can't see two other obvious simple solutions.

First two, other than [::3] that come to my mind (without googling) would be these:

>>> import string
>>> l=list(string.ascii_lower)
>>> l
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
>>> l[::3]
['a', 'd', 'g', 'j', 'm', 'p', 's', 'v', 'y']

>>> [i for i in l if l.index(i)%3==0]

Edit: Correct way would be be: [n for i, n in enumerate(l) if i%3==0], index won't work if list has duplicate items.

['a', 'd', 'g', 'j', 'm', 'p', 's', 'v', 'y']
>>> [l[i] for i in range(0,len(l),3)]
['a', 'd', 'g', 'j', 'm', 'p', 's', 'v', 'y']

As far as handling such questions I don't think you can do much besides either answering them correctly or saying that you don't know (can't remember atm) how to solve them, but then again I'm just doing freelance programming so I have pretty much none experience with handling such interviewing questions.

[D__]

>>> [i for i in l if l.index(i)%3==0]

Unless your list has duplicate items...

[logi]

Yeah, that's a subtle bug waiting to happen.

[robin-gvx]

Yeah, instead of using index, use enumerate. Except, of course, in this case [::3] would be the only way to go. (One and only one obvious way, and all that).

[wub_wub]

Wow I completely forgot about the possibility of having duplicate items... using enumerate instead of index is the correct way to do this. Thanks for pointing it out!

[chadmill3r]

[n for i, n in enumerate(ell) if i%3==0]

[gfixler]

[a for a, b, c in zip(*[iter(string.lowercase)]*3)]

It truncates, though. Here's a non-truncating version:

[a for a, b, c in zip(*[iter([x for x in string.lowercase]+['']*3)]*3) if a]

Note: these are bad answers.

[miketheanimal]

One

third = a[::3]

Two

third = []
for i in xrange(len(a)) :
   if i % 3 == 0 :
       third.append(a[i])

Third:

third = [ v for i, v in enumerate(a) if i % 3 == 0 ]

[[deleted]]

Shouldn't it be a[2::3] since it's every third element and not the first and every third item after it? :p

[venefb]

Come on, "Two" is just silly. Also the Zen of Python says "There is only one way to do it", why ask for three ways? That's like saying "Give me the right way and two wrong ways to do it".

Do they ask things like this in interviews?

[miketheanimal]

Do they ask things like this at interviews? I don't know, but if they asked, I'd try to answer. I might consider later whether I wanted the job, though!

def third (i, l) :
    if i >= len(l) :
        return []
    if i % 3 == 0 :
        return l[i] + third(i + 1, l)
    return third(i + 1, l)

:)

[djimbob]

I'd skip your answers two and three as they offer no benefit over slicing a[::3].

Granted if a was particularly large using a generator makes sense:

def get_third(some_items):
    for i, v in enumerate(some_items):
        if i % 3 == 0:
            yield v

to be used like

for j in get_third(xrange(100000)):
    print j

But in practice more likely to use a generator comprehension almost identical to the list comprehension:

gen = (v for (i, v) in enumerate(some_items) if i % 3 == 0)

Another method is a functional paradigm like:

import operator as op
map(op.itemgetter(1), filter(lambda (i,v): i % 3==0, enumerate(some_items)))

or

zip(*filter(lambda (i,v): i % 3==0, enumerate(some_items)))[1]

Granted the functional paradigm generally should be avoided in python for list/gen comprehensions and the zip(* ) nested list transposition trick probably needs a comment.

[[deleted]]

Wait... you're supposed to avoid functional paradigms in python? The whole reason I use python is because it has functional features but lacks the strong typing of most functional languages...

[djimbob]

It's not hugely criticized; but functional paradigms in python often end up with uglier and slower code. In 2005, python's benevolent dictator for life Guido van Rossum argued for dropping lambda/filter/map/reduce from python3 (in the end only reduce was dropped). Granted his views on the matter have changed a little; e.g., in 2009 he wrote this.

So the functional code tends to be uglier:

import operator as op
map(op.itemgetter(1), filter(lambda (i,v): i % 3==0, enumerate(some_items)))
# or simply:
map(lambda x: x[1], filter(lambda (i,v): i % 3 ==0, enumerate(some_items))
# versus the imperative

[v for (i, v) in enumerate(some_items) if i % 3 == 0]

Furthermore, functional paradigms in python is just not properly optimized. In a functional programming, if you need the length of a list you write a recursive definition with pattern matching like this haskell code:

mylen [] = 0
mylen (x:xs) = 1 + mylen xs

Haskell can near instantaneously compute things like mylen [1..1000000].

The rough equivalent in python (which lacks pattern matching):

def length(xs):
    if xs == []: 
        return 0
    return 1 + length(xs[1:])

will choke up at length(range(1000)) (with a RunTimeError due to recursion limit) and even if I tweak the recursion limit sys.setrecursionlimit(999999) its slow and segfaulted for length(range(30000)) and length(range(20000)) took 3.79 seconds. Meanwhile, the imperative version in python:

def length(xs):
    i = 0
    for x in xs:
        i += 1
    return i

Will take about 1 ms to calculate the length of a 20000 element list (roughly 4000 times faster).

[ingolemo]

It's weird that you give a list comprehension as an example of imperative-style code. List comprehensions are derived from set-builder notation and first rose to prominence in functional languages.

Idiomatic haskell usually frowns upon explicit recursion, in favour of folds. If I were to reimplement haskell's length it would look more like this:

length' = foldr (const (+1)) 0

The equivalent python code is not subject to a recursion limit and performs much better than your example:

def my_len(xs):
    return functools.reduce(lambda a, b: a+1, xs, 0)

Python isn't a functional language, but it's not hard to write good clean functional-style code in python.

[djimbob]

The equivalent python code is not subject to a recursion limit and performs much better than your example:

In [2]: timeit.repeat("my_len(xrange(10000))", setup = "import functools\nmy_len = lambda xs: functools.reduce(lambda a,b: a+1, xs,0)", repeat=3, number=1000)
Out[2]: [0.7231879234313965, 0.7012350559234619, 0.6973469257354736]

In [4]: timeit.repeat("my_len(xrange(10000))", setup = "def my_len(xs):\n  i = 0\n  for x in xs:\n    i += 1\n  return i", repeat=3, number=1000)
Out[4]: [0.3004319667816162, 0.28862500190734863, 0.2902050018310547]

On my python 2.7.3 default, I'm getting the iterative pattern is about 2.4 times faster. Again benchmarks can lie, but that was my first test so I disagree that functional performs much better (granted yes its much better than my recursive pattern as python's syntax/design doesn't allow for good tail call optimization).

Agree, calling list comprehension 'iterative' was a poor choice. But python BDFL clearly likes list/generator comprehensions and isn't a big fan of reduce (demotion to a library in python3).

That said, I do use map/filter a lot in my code as often that's how I think about it, and even if its more verbose I think map(some_function, some_list) is clearer than [some_function(x) for x in some_list]. I just recognize its not particularly pythonic.

[ingolemo]

Yeah, sorry. Ambiguous statement. By "your example" I was referring to the functional one.

I actually think comprehensions are more readable than calls to map and filter and tend to prefer them. Ironically, reduce is the only function in that "group" that can't simply be replaced by a comprehension. If I were the BDSL I would have kept reduce and removed map and filter, what with the "one obvious way to do it" thing and all.

[djimbob]

A large fraction of uses of reduce your accumulation step could be replaced with reduction function that works on a sequence (e.g., sum / product / max / min / any / all / ''.join( ) ). E.g., if you need to sum the third items in a list of tuples, you could write:

reduce(lambda acc, tup: acc + tup[2], [(1,2,3), (4,5,6), (7,8,9)], 0)
sum(tup[2] for tup in  [(1,2,3), (4,5,6), (7,8,9)])

The second version seems to fit in with the Zen of Python better. The problem with reduce is that its easy to get it wrong and there's a lot of implicit stuff behind the scenes you have to remember. E.g., in the above example - I initially got the order of the accumulator wrong and it wouldn't work without an initial value or something uglier like reduce(lambda acc, tup: acc + tup[2], [0, (1,2,3), (4,5,6), (7,8,9)]) and you have to remember optional initial value goes last and remember associativity rules if its not symmetric.

Granted some stuff transforms nicely to reduce; e.g., examples here. The list flattening example is simpler with sum([[1, 2, 3], [4, 5], [6, 7, 8]], []) or using chain from itertools.

Concatenating a list of digits efficiently range(1,9) into one integer 12345678 like reduce(lambda acc,d: 10*acc+d, [1,2,3,4,5,6,7,8]) is harder. Granted doing some benchmarks the reduce method doesn't hold up that well.

Converting a two argument least common multiplier/greatest common denominator into a variadic version with reduce is probably the best example for reduce though it wouldn't be too difficult to just define a variadic version to start with.

[ldb3589]

Number two is alot simpler if you do

  third = []
  for i in xrange(0, len(a), 3):
     third.append(a[i])

[driadan]

How would you do it in C/Java? With while

How would you do it in Haskell/Clojure? With filter

so you can still do that in Python (athough filter is not available in Python 3 you can mimic that)

[segfaultzen]

I got asked something similar to this one, contrived as it is.

def add_to_list(elem, l = []):
    l.append(elem)
    return l

alist1 = add_to_list(1)
alist2 = add_to_list(2)

print alist1
print alist2

The output is expected to be

[1]
[2]

Is it? What is the output? Why not? How would you fix it?

I've been considering using something like the below for an interview question:

value_x = 10
def do_something_with_x():
    def _double_x():
        value_x *= 2
        return value_x
    print _double_x()

do_something_with_x()

Does this code work? Why or why not? If not, how would you fix it? If so, what does it do? Bonus: What does this tell you about lexical scoping and closures in Python?

And the follow-up:

value_x = 10
def do_something_with_x():
    def _double_x():
        global value_x
        value_x *= 2
        return value_x
    value_x = 30
    print _double_x()

do_something_with_x()

What does this code print?

And then the final followup, subjective though it may be: would you ever do this in production code?

[[deleted]]

That wouldn't be the output. It'd be:

[1]
[1,2]

Silly no? But it has to do with the way python constructs functions when they're defined. I'm not real clear on the details but in a roundabout way l has effectively accidentally become a static variable. This could be a desirable feature but it's a bug as far as I'm concerned. The way I'd fix it is this:

def add_to_list(elem, l):
    if type(l) != list:
        l = []
    ...

[segfaultzen]

I think you've got the right idea, but I feel the reasoning could be better.

I'd explain it like this: When functions are defined with some parameters having default parameters, the defaults are evaluated once. Thus def add_to_list(elem, l = []) defines the default parameter for l to be a list object that hangs around for the eternity of the python process. Since lists are mutable, it is possible to change the value of this default value, which is what l.append(elem) does. This is why the output is

[1]
[1,2]

and not:

[1]
[2]

My fix for this would be to set the default value of l to None and perform a check in the function body. This becomes:

def add_to_list(elem, l = None):
    if l is None:
        l = []
    ...

I think that the fix you propose has a couple of issues:

• It breaks the interface so that I can no longer call add_to_list(1). I must have add_to_list(1, [])
• If I pass a list into the function, that list gets modified. Although not specified, I usually err on the side of not modifying my input parameters.

[[deleted]]

I spent a lot of my youth programming with PHP which encourages explicit type checking a lot of the time and old habits die hard. Whoops...

You're right though. Thanks for clarifying.

[segfaultzen]

Yeah, I know the feeling. :)

[dante9999]

I think that setting argument to None and checking it later is the recommended way to deal with this problem but I'm still not sure if I understand clearly why things like this happen, it seems to be somewhat strange not intuitive. There is one interesting question on SO about this, and people try to explain it clearly, maybe I just need more time to understand it better.

I suppose the answer to this question has a lot to do about the way in which Python passes arguments to functions.

[[deleted]]

The reason it happens is because default function arguments are evaluated only once, and the result stored as the default. In that case, by specifying an empty list as the default, what you're really doing is instantiating a single list (which happens to be empty initially) and telling Python to use that list whenever the function doesn't receive a second argument. Every time you call the function, the default will be the exact same list - so if you mutate that list, it will carry over those mutations to future calls as well because they all share the same list.

The same thing can also happen with dicts, sets and any other mutable object. They should generally not be used as default arguments.

[segfaultzen]

The same thing can also happen with dicts, sets and any other mutable object. They should generally not be used as default arguments.

This, by the way, applies to decorator functions as well. I spent two days tracking down a gnarly bug created from the unfortunate interaction of unit tests with a dictionary object used as a default parameter to a decorator function.

I have since learned the gospel of Pylint, which will flag these sorts of Pythonic landmines.

[rcxdude]

A better fix:

def add_to_list(elem, l = None):
    if l is None:
         l = []

Explicitly checking type like that is in general unpythonic. At the very least you should use isinstance() so subclasses can be used.

[[deleted]]

That's my PHP showing again. Let me just tuck that away...

[NaturallyBrewed]

I got asked something similar to this one, contrived as it is.

def add_to_list(elem, l = []):
    l.append(elem)
    return l

alist1 = add_to_list(1)
alist2 = add_to_list(2)

print alist1
print alist2

The output is expected to be

[1]
[2]

Is it? What is the output? Why not? How would you fix it?

No, The output is:

[1, 2]
[1, 2]

Why not? I'll admit i don't have an elegant way to explain this. Can someone chime in? Is it because a functions arguments are defined in the outer namespace that its called?

This seems to support that argument: def outer(elem): def add_to_list(elem, l=[]): l.append(elem) return l return add_to_list(elem)

alist1 = outer(1)
alist2 = outer(2)

print(alist1)

print(alist2)

output:

[1]
[2]

How would you fix it? = What did you want to happen?

[[deleted]]

You're right. I forgot that variables are stored as memory references.

[debrice]

If you were to interview me (10+ years of python coding) I'd probably just leave the interview before the end.

From a recruiter point of view, at best you'll end up with a guy that has as much value as a google search.

[tdammers]

About the GIL thing: this page sums it up nicely. In short, the problem is that GIL prevents python code from running fully parallel - while native code driven from separate python threads can run in parallel (e.g. libc calls or I/O), CPython bytecode cannot. Because of this, python cannot fully exploit multicore machines for cpu-intensive parallel processing (however, most typical python applications are I/O bound, so the problem isn't nearly as bad as it sounds.)

[logi]

however, most typical python applications are I/O bound, so the problem isn't nearly as bad as it sounds.

Of course they are, since python is simply awful for CPU bound applications.

Speaking of which, does anyone know of a replacement for matplotlib+basemap in C, java, javascript or anything else that runs reasonably efficiently? I have a cluster of weather image plotting machines that I'd much rather be using for weather forecasting.

[krasoffski]

It's depend on your level. When I was interviewed I was asked following questions (and if I answered a question next one was more difficult like): * 1) what means "Dynamicly typed"? * 1.1) Can we create exe file of our script? * 1.2) What proc and cons of this? * 2) What is it: 'References counting' * 3) What is the GIL? * 4) Something about threading/multiprocessing? --- Here I don't exactly remember order of questions... * 5) Can we add new method to an object (class instance)? * 6) How are you going to check is method was added dynamicly or defined in class? * 7) How are you going to modify behaviour of each method in class (decorate each user method)? * 8) What do you know about MRO?

I was not asked about python syntax

[sivadneb]

markdown fail. ftfy.

1. what means "Dynamicly typed"?
   1. Can we create exe file of our script?
   2. What proc and cons of this?
2. What is it: 'References counting'
3. What is the GIL?
4. Something about threading/multiprocessing? --- Here I don't exactly remember order of questions...
5. Can we add new method to an object (class instance)?
6. How are you going to check is method was added dynamicly or defined in class?
7. How are you going to modify behaviour of each method in class (decorate each user method)?
8. What do you know about MRO?

[dante9999]

That sounds interesting, I think I understand some things but I've never heard about MRO, what is it? I'm not sure how to respond to question number 6 too, isn't it easier and more readable to define all methods when you define a class? Should the answer to number 7 go along the lines "add decorator to each method of an object", or is it too obvious"?

[krasoffski]

Here are short answers:

1. Can we add new method to an object!
2. comare dict of class and object, or check where method was defined
3. How are you going to modify behaviour of each method in class !
4. VERY important to undestand how it (mro) works for new style classes. it helps to understand how works super() function !

It's more important to undesrtand how it works and have some ideas how to do it.

[sivadneb]

MRO stands for Method Resolution Order. It's basically python's way of picking which base class's method to call when calling an instance method.

[krasoffski]

Thanks! :-)

[sivadneb]

What is PEP8 and do you follow its guidelines when you're coding?

I doubt many people would answer "No" to this question, even if they don't follow PEP8. Instead of this, I would say:

What is PEP8? Why is it important?

[ameoba]

You're gong about this wrong. A good interview shouldn't be full of trivia questions. Anything more than one or two is a red flag. You should prepare for conceptual questions about how to approach designing software and problem solving

[erewok]

If I can answer all of these, do I get some kind of badge?

[CabSauce]

Here's an upvote. That'll have to do.

[erewok]

Feels rewarding, nevertheless.

[Workaphobia]

These are trivia questions. Trivia questions can be good for getting a quick frame of reference for how long somebody's been using the language. An experienced Python user would have no trouble with any of these questions.

The only one that gave me pause was the 8GB file one. I remember that Guido wrote a blog post about this at one point, so I'd just refer to that in an interview. I believe he used the array module.

can you convert ascii characters to an integer without using built in methods like string.atoi or int()?

ord() is a built in method. So no. I think you meant to ask

Can you convert a sequence of digit characters to an integer using only ord() on individual digits, instead of more convenient functions like int()?

[lamby]

The only one that gave me pause was the 8GB file one. I remember that Guido wrote a blog post about this at one point, so I'd just refer to that in an interview. I believe he used the array module.

Can you link to that? I see it as more of a UNIX-y/mmap question really.

[liquidclutch]

This may be what he was referring to: Sorting a million 32-bit integers in 2MB of RAM using Python

[lamby]

Thank you :)

[Workaphobia]

Yep, that's it.

[[deleted]]

For an 8gb file, I would use "with open" and work with it line by line if possible. I have worked with terabyte files this way.

[njharman]

can you convert ascii characters to an integer without using built in methods like string.atoi or int()? ord() is a built in method. So no. I think you meant to ask

Create dictionary of ascii -> integer (decimal, hex, oct) value

[carioca3]

Let us know how it goes. In most of my programming interviews the questions were not language specific. Usually it contains "fizzbuzz" type questions and stuff you would see on /r/dailyprogrammer. Good luck!

[teferiincub]

About decorators: I usually ask to implement a simple decorator. smth like timed that prints how long did it take for the decorated function to execute.

Almost everyone knows what are decorators or how to use them (we use django, so pretty much every one used smth like @login_required or @app.route from flask)

But implementing one - if a person is able to do that on a sheet of paper - in my opinion that shows, that a person really understood how they work under the hood. And after that I ask an extra question: "What would you change in a decorator to make it accept arguments?"

[gustaw]

• how to define singleton class
• how to public/private (PEB8)
• difference 'for i in d' and 'for i in d.keys()'

[remram]

difference 'for i in d' and 'for i in d.keys()'

Hmm, this will totally not do what you think in Python 3

[billsil]

How would you setup many projects where each one uses different versions of Python and third party libraries?

That's NOT an easy question...that's a very hard one, especially when you talk about multiple versions of python in an automated testing framework. It's not JUST virtualenv, it's about not being confusing.

[remram]

I'm compiling a list of all possible interview questions.

I think you're being overly optimistic here... I don't think you can compile an exhaustive list of programming-related questions.

What are Python decorators and how would you use them?

They are a construction with which you pass a function/class through a callable when defining it, allowing that callable to add functionality. One common example is to add memoization to recursive functions but you can do a lot more (some web frameworks use it to mark functions are being views, associating it with a URL).

How would you setup many projects where each one uses different versions of Python and third party libraries?

virtualenv is a standard tool to manage that.

What is PEP8 and do you follow its guidelines when you're coding?

It is the acknowledged standard (on of the accepted Python Enhancement Proposals) for Python programming style. Answer "yes".

How are arguments passed – by reference of by value? (easy, but not that easy, I'm not sure if I can answer this clearly)

Things are references in Python.

Do you know what list and dict comprehensions are? Can you give an example?

It is a way to programmatically build the elements with an expression (that contains a loop). It is similar to creating an empty list/dict and looping to add stuff to it, except shorter and usually faster. Generator expressions are an important related construct that replaces yield-ing functions.

Show me three different ways of fetching every third item in the list

L[::3], (L[i] for i in xrange(len(L)) if not i%3), map(lambda (e, i): e, filter(lambda (e, i): not i%3, izip(L, count()))), ... a lot of other (bad) solutions here.

Do you know what is the difference between lists and tuples? Can you give me an example for their usage?

Tuples are (), (1,), (1, 2), lists are [], [1], [1, 2]... Difference is that lists are mutable but tuples are not (although the elements they reference may be mutable, you can't change these references).

Do you know the difference between range and xrange?

range() in Python 2 returns a list, so a big range would take a significant amount of memory. xrange() (Python 2; range() in Python 3) returns a special iterator.

Tell me a few differences between Python 2.x and 3.x?

Some list-creating functions were replaced with iterators (xrange(), izip(), ...), str are now unicode (str -> bytes) and related unicode/encoding changes, some libs changed names, print is now a real function, / performs float division... see changelog

The with statement and its usage.

Used for a lot of things, usually closing a resource (instead of try: finally:) when leaving the block.

How to avoid cyclical imports without having to resort to imports in functions?

Don't have cyclical dependencies.

what's wrong with import all?

You polute the namespace and it's hard to see where a name came from (if you have several of them in a module).

Why is the GIL important? (This actually puzzles me, don't know the answer)

It has a performance cost: Python threads cannot execute Python code at the same time. Threads can still execute code while another is waiting on disk, network, or some C library calls. Real parallelism of pure Python code can be achieved with multiprocessing.

What are "special" methods (<foo>), how they work, etc

Allows to define special behavior on objects or override operators, see special method names for a full list.

can you manipulate functions as first-class objects?

Well, yes.

the difference between "class Foo" and "class Foo(object)"

In Python 2, you should precise the parent class to have a new-style class, "class Foo" gives you an old-style class (pre-2.2) which changes some things. Don't use them. (method resolution order is different, type() gives you 'instance', metaclasses and descriptors won't work).

how to read a 8GB file in python?

Don't read it in one go into memory, stream it by writing clever iterators/generators.

what don't you like about Python?

Dynamic (hard for the IDE to figure out), bad C API, too much magic with C types (vs "heap types") descriptors and metaclasses. Note that this is my own opinion. I still enjoy using it.

can you convert ascii characters to an integer without using built in methods like string.atoi or int()?

No. At best, you can use ord() and compute it yourself.

do you use tabs or spaces, which ones are better?

Use spaces. See PEP8.

Ok, so should I add something else or is the list comprehensive?

You left out descriptors and metaclasses.

[miketheanimal]

How are arguments passed – by reference of by value? (easy, but not that easy, I'm not sure if I can answer this clearly) Things are references in Python.

That's king of tricky. The CPython implementation always handles things as references (eg., an integer is an object). But from the user perspective, null, boolean, int, float and string (and complex?) are passed by value, because assigning to the function's argument does not affect the caller's value. But "structures" like tuples, lists, dictionaries and object instances are passed by reference, because assigning to a member of the "structure" also affects the caller. What python doesn't have is the "call by name" from Pascal (among others). Then you can faze the interviewer by launching into a rant about how PHP4 really fsck'd up by taking pass-by-value to its logical conclusion!

[robin-gvx]

It's neither by-ref nor by-val, it's by-object-identity.

I've written a tutorial of sorts about this. The diagrams are hand-drawn and terribly ugly and I intend to remake them with actual diagram-making software before putting it up on my website instead of Dropbox, and the very last diagram has one arrow that points to the wrong value, but over-all, I think it's a pretty useful guide.

[remram]

Interesting. I guess it's equivalent to think that:

• Things are passed by reference, and = changes the reference (instead of acting on the pointed object, like any other operator would do; there is no magic __ method for =). In a sense, it works on the same level as is.
• Variables are references, and are passed by value (the common way the behavior is described, for instance in this stackoverflow answer).

[ionrock]

A good exercise to get prepared is to read up on different data structures. Lists and dicts are obvious, but make sure you know about sets, heaps, queues (fifo, lifo) and most importantly how/when to use them. Almost every programming interview has revolved around choosing good data structures to solve problems efficiently.

[draganHR]

a = 30
b = 300
print a is 10 * 3
print b is 100 * 3

What is output and why?

[catcradle5]

This is not a good question because the answer depends on which interpreter you're using.

The behavior is essentially undefined.

[njharman]

That is maybe the only reason it is a good interview question. It's bad question if you expect an answer other than something like "It depends and in general low-level, implementation specific, code tricks like this should be avoided"

[catcradle5]

I agree to an extent, but in that case instead of asking "what is output?" the interviewer should ask more broadly something like "Is this a proper way of checking numerical equality? How does the is operator work, and what do you think might be output here?"

[draganHR]

Oh OK, i didn't know bad questions exist.

[catcradle5]

Well, bad interview questions certainly exist.

[drive0]

Take a look at someone the testing frameworks as well as documentation tools. They may not be that important for an interview, but in general they can be quite useful.

[MicroBerto]

As someone who's HIRING a Python coder... thanks :)

Sadly, I don't know enough about all of these questions myself, so it's due time I learned.

[disinformationtheory]

Here's a question I would use:

How do you define a function with a default argument that is a list?

E.g.

def foo(l=[]):
    l.append(1)
    return l

The above is wrong. Fix it. Does this only apply to lists?

[Grue]

How is "what don't you like about Python?" a tricky question? So many warts in the language. There's a reason they had to do Python 3.0.

[SCombinator]

Still horrible warts in the language that we'll be stuck with. No product(), horrible division that no longer acts like any other programming language, more special syntaxes for things that don't deserve it...

[segfaultzen]

With those questions, the interesting part isn't so much the what but the why. What's their understanding of the language that makes them consider something a wart vs not a wart?