power :: Integer -> Integer -> Integer
power 0 _ = 0
power _ 0 = 1
power a b
 | odd b = a * (power a (b-1))
 | even b = (power a (floor $ (fromIntegral b)/2))^2

The type declaration (first line) is actually unnecessary, but it helps for clarity. In fact, if you leave it out, GHC deduces the type as power :: (Num t, Integral b) => t -> b -> t, which actually lets you do something like power 1.5 10 as well.

Just for a silly little comparison*, I ran this Haskell and your Python implementation on 40^1000000, timed using time <run whichever version>.

Haskell, a typical time (ran it four or five times, similar results each time):
real 0m1.248s
user 0m1.124s
sys 0m0.041s

Python, the one time I dared:
real 10m57.630s
user 10m40.980s
sys 0m1.328s

* Obviously this is silly for several reasons. One is that Haskell is ridiculously fast. Python is not necessarily designed for speeds, and it excels in a variety of other things. It is my main language. Additionally, the Haskell was compiled using ghc. When I ran it using ghci, an interactive interpreter, it took roughly one or two seconds to compute and much longer to print, oddly enough.

Of course, you can also use (x & 1) == 1 to test for odd and x >> 1 for the integer division by two, but that will only have a minor speed improvement, if at all.