What is the advantage of using static methods?

See this article for detailed explanation.

TL;DR

1.It eliminates the use of self argument.

2.It reduces memory usage because Python doesn't have to instantiate a bound-method for each object instiantiated:

>>>RandomClass().regular_method is RandomClass().regular_methodFalse>>>RandomClass().static_method is RandomClass().static_methodTrue>>>RandomClass.static_method is RandomClass().static_methodTrue

3.It improves code readability, signifying that the method does not depend on state of the object itself.

4.It allows for method overriding in that if the method were defined at the module-level (i.e. outside the class) a subclass would not be able to override that method.

Static methods have limited use, because they don't have access to the attributes of an instance of a class (like a regular method does), and they don't have access to the attributes of the class itself (like a class method does).

So they aren't useful for day-to-day methods.

However, they can be useful to group some utility function together with a class - e.g. a simple conversion from one type to another - that doesn't need access to any information apart from the parameters provided (and perhaps some attributes global to the module.)

They could be put outside the class, but grouping them inside the class may make sense where they are only applicable there.

You can also reference the method via an instance or the class, rather than the module name, which may help the reader understand to what instance the method is related.

This is not quite to the point of your actual question, but since you've said you are a python newbie perhaps it will be helpful, and no one else has quite come out and said it explicitly.

I would never have fixed the above code by making the method a static method. I would either have ditched the class and just written a function:

def drawSample(samplesize,List):    sample=random.sample(List,samplesize)    return sampleChoices=range(100)print drawSample(5,Choices)

If you have many related functions, you can group them in a module - i.e, put them all in the same file, named sample.py for example; then

import sampleChoices=range(100)print sample.drawSample(5,Choices)

Or I would have added an __init__ method to the class and created an instance that had useful methods:

class Sample(object):'''This class defines various methods related to the sample'''    def __init__(self, thelist):        self.list = thelist    def draw_sample(self, samplesize):        sample=random.sample(self.list,samplesize)        return samplechoices=Sample(range(100))print choices.draw_sample(5)

(I also changed the case conventions in the above example to match the style recommended by PEP 8.)

One of the advantages of Python is that it doesn't force you to use classes for everything. You can use them only when there is data or state that should be associated with the methods, which is what classes are for. Otherwise you can use functions, which is what functions are for.