You can pass an anonymous function or lambda:

    def foo(thing, block):
      thing = "cruel " + thing
      block(thing) # like `yield thing' or 'block.call' in ruby

    def bar(thing):
      return "hello " + thing

    foo('world', bar)

    # or:
    foo('world', lambda x: "hello " + x)

Ruby's blocks are really just sugar for passing an anonymous function in the last argument and yield is just sugar for calling that function. The example above in Ruby would be:

    def foo(thing)
      yield thing
    end

    foo('world') { |thing| "hello " + thing }

Ruby's yield is essentially just calling an anonymous function given to it in the form of a block. e.g., the following code snippets are equivalent

Ruby:

    def foo(bar)
      if block_given?
         yield bar
      end
    end

    foo 5 { |x| puts x } # prints 5

Python:

    def foo(bar,fcn):
        fcn(bar)


    foo(5, lambda x: sys.stdout.write("%d\n" % x))

The only real difference being that the ruby code is calling a block versus a "real" function.

edit Oops, had this page open for a while, didn't realize someone had replied in the interim, making my response somewhat redundant