In Python almost everything is an object and is invoked polymorphically -- functions, modules, builtin types, user-defined types, you name it. So it's common to pass them around directly, and create new types that have the same interface if you need to pass in different (but compatible) behaviour.
For example, I rarely write factory functions because classes are themselves first-class objects and callable like functions. So if I need to parameterise a function by the type of object it should create, I'll pass the class of object to the function. If I need to do something more than just create a new object, I can define a function that has the same signature as the classes' constructors and pass that in. Or a lambda expression. Or a method on a class and pass a bound-method in that invokes the method on a specific instance. Or an object that implements __call__. Or ...
Python gives you loads of options to write flexible code and/or shoot yourself in the foot.
My rule of thumb is that if an object needs to invoke different operations on a peer, it's easier to pass a peer object than multiple peer functions. Otherwise I'll pass a single function because it makes using the class easier.
--Nat