The other answer makes it a little more complicated than it needs to be. In order to have the middle point of the colormap at 0, use a DivergingNorm with vcenter=0.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import DivergingNorm

x, y = np.meshgrid(np.linspace(0,50,51), np.linspace(0,50,51))
z = np.linspace(-2,4,50*50).reshape(50,50)

norm = DivergingNorm(vmin=z.min(), vcenter=0, vmax=z.max())
pc = plt.pcolormesh(x,y,z, norm=norm, cmap="RdBu_r")
plt.colorbar(pc)

plt.show()

Note: From matplotlib 3.2 onwards DivergingNorm will be renamed to TwoSlopeNorm

You can use matplotlib.colors.TwoSlopeNorm like this:

# define your scale, with white at zero
vmin = -0.2 
vmax = 0.8
norm = colors.TwoSlopeNorm(vmin=vmin, vcenter=0, vmax=vmax)

In your example would be,

import numpy
from matplotlib import pyplot as plt
import matplotlib.colors as colors

# some arbitrary data to plot
x = numpy.linspace(0, 2*numpy.pi, 30)
y = numpy.linspace(0, 2*numpy.pi, 20)
[X, Y] = numpy.meshgrid(x, y)
Z = numpy.sin(X)*numpy.cos(Y)

fig = plt.figure()
plt.ion()
plt.set_cmap('bwr') # a good start: blue to white to red colormap

# a plot ranging from -1 to 1, hence the value 0 (the average) is colorcoded in white
ax = fig.add_subplot(1, 2, 1)
plt.pcolor(X, Y, Z)
plt.colorbar()

# a plot ranging from -0.2 to 0.8 hence 0.3 (the average) is colorcoded in white
ax = fig.add_subplot(1, 2, 2)

# define your scale, with white at zero
vmin = -0.2 
vmax = 0.8
norm = colors.TwoSlopeNorm(vmin=vmin, vcenter=0, vmax=vmax)

plt.pcolor(X, Y, Z, vmin=vmin, vmax=vmax, norm=norm)   
plt.colorbar()

will give you:

You would rather mask zero out of your data, e.g. setting those values to nan or use a masked array. Then you can just set_bad("white") for your colormap.

The colormaps of Matplotlib have a set_bad and set_under property which can be used for this. This example shows how to use the set_bad

import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np

# make some data
a = np.random.randn(10,10)

# mask some 'bad' data, in your case you would have: data == 0
a = np.ma.masked_where(a < 0.05, a)

# cmap = plt.cm.OrRd

# for mpl 3.3 and higher use
cmap = mpl.cm.get_cmap("OrRd").copy()

cmap.set_bad(color='black')

im = plt.imshow(a, interpolation='none', cmap=cmap)

To use the set_under variant you have to add the vmin keyword to the plotting command and setting is slightly above zero (but below any other valid value):

cmap.set_under(color='black')    
im = plt.imshow(a, interpolation='none', cmap=cmap, vmin=0.0000001)

For your problem, I suggest setting the first level to be greater than zero, and using the extend feature of colorbar to specify zero x, y locations.

First we import libs and try to generate some random data from numpy's normal distribution function on a sparse grid.

from copy import copy

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors

# generate sample data
x0, x1 = -5, 5
y0, y1 = -3, 3
x = np.linspace(x0, x1, 60)
y = np.linspace(y0, y1, 60)
X, Y = np.meshgrid(x, y)
Z = np.random.randn(60, 60)

To illustrate your problem, we set all negative values to zero, rendering non-negative grid data Z.

Z = np.where(Z > 0, Z, 0)

Now comes to the key point! Simply add a out-of-range color to a colormap.

palette = copy(plt.get_cmap('viridis_r'))
palette.set_under('white', 1.0)  # 1.0 represents not transparent

You may also use set_over, set_bad methods to set color for over-range data and undefined (NaN) data.

Set subplots:

fig, ax = plt.subplots(1, 1)

Set levels for plot, but do remember to modify the lowest level to a positive number close to zero.

levels = np.arange(0, 3.5, 0.5)
levels[0] = 1e-5

Here's how to plot the array Z.

norm = colors.BoundaryNorm(levels, ncolors=palette.N)
im = ax.imshow(Z, cmap=palette,
               norm=norm,
               aspect='auto', extent=[x0, x1, y0, y1])
# Possible extend options include: ['min', 'max', 'both', 'neither']
cbar = fig.colorbar(im, extend='min', shrink=0.9, ax=ax)
plt.savefig('draw.png', dpi=300)
# or
# plt.show()

Displaying the lowest level as 0.0 may lead to some ambiguity, perhaps setting levels[0] to 0.1 look better to you.

You may refer to following links for more:

https://matplotlib.org/examples/pylab_examples/image_masked.html

https://matplotlib.org/examples/pylab_examples/contourf_demo.html

You can easily create a custom colormap using LinearSegmentedColormap and choosing the colors that you want (in this case, a subset of the original colormap)

min_val, max_val = 0.3,1.0
n = 10
orig_cmap = plt.cm.Blues
colors = orig_cmap(np.linspace(min_val, max_val, n))
cmap = matplotlib.colors.LinearSegmentedColormap.from_list("mycmap", colors)

demo

gradient = np.linspace(0, 1, 256)
gradient = np.vstack((gradient, gradient))

fig, (ax1, ax2) = plt.subplots(2,1, figsize=(5,2))
ax1.imshow(gradient, cmap=orig_cmap, aspect='auto')
ax1.set_title('original')
ax2.imshow(gradient, cmap=cmap, aspect='auto')
ax2.set_title('custom')
plt.tight_layout()

I know this is late to the game, but I just went through this process and came up with a solution that perhaps less robust than subclassing normalize, but much simpler. I thought it'd be good to share it here for posterity.

The function

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import AxesGrid

def shiftedColorMap(cmap, start=0, midpoint=0.5, stop=1.0, name='shiftedcmap'):
    '''
    Function to offset the "center" of a colormap. Useful for
    data with a negative min and positive max and you want the
    middle of the colormap's dynamic range to be at zero.

    Input
    -----
      cmap : The matplotlib colormap to be altered
      start : Offset from lowest point in the colormap's range.
          Defaults to 0.0 (no lower offset). Should be between
          0.0 and `midpoint`.
      midpoint : The new center of the colormap. Defaults to 
          0.5 (no shift). Should be between 0.0 and 1.0. In
          general, this should be  1 - vmax / (vmax + abs(vmin))
          For example if your data range from -15.0 to +5.0 and
          you want the center of the colormap at 0.0, `midpoint`
          should be set to  1 - 5/(5 + 15)) or 0.75
      stop : Offset from highest point in the colormap's range.
          Defaults to 1.0 (no upper offset). Should be between
          `midpoint` and 1.0.
    '''
    cdict = {
        'red': [],
        'green': [],
        'blue': [],
        'alpha': []
    }

    # regular index to compute the colors
    reg_index = np.linspace(start, stop, 257)

    # shifted index to match the data
    shift_index = np.hstack([
        np.linspace(0.0, midpoint, 128, endpoint=False), 
        np.linspace(midpoint, 1.0, 129, endpoint=True)
    ])

    for ri, si in zip(reg_index, shift_index):
        r, g, b, a = cmap(ri)

        cdict['red'].append((si, r, r))
        cdict['green'].append((si, g, g))
        cdict['blue'].append((si, b, b))
        cdict['alpha'].append((si, a, a))

    newcmap = matplotlib.colors.LinearSegmentedColormap(name, cdict)
    plt.register_cmap(cmap=newcmap)

    return newcmap

An example

biased_data = np.random.random_integers(low=-15, high=5, size=(37,37))

orig_cmap = matplotlib.cm.coolwarm
shifted_cmap = shiftedColorMap(orig_cmap, midpoint=0.75, name='shifted')
shrunk_cmap = shiftedColorMap(orig_cmap, start=0.15, midpoint=0.75, stop=0.85, name='shrunk')

fig = plt.figure(figsize=(6,6))
grid = AxesGrid(fig, 111, nrows_ncols=(2, 2), axes_pad=0.5,
                label_mode="1", share_all=True,
                cbar_location="right", cbar_mode="each",
                cbar_size="7%", cbar_pad="2%")

# normal cmap
im0 = grid[0].imshow(biased_data, interpolation="none", cmap=orig_cmap)
grid.cbar_axes[0].colorbar(im0)
grid[0].set_title('Default behavior (hard to see bias)', fontsize=8)

im1 = grid[1].imshow(biased_data, interpolation="none", cmap=orig_cmap, vmax=15, vmin=-15)
grid.cbar_axes[1].colorbar(im1)
grid[1].set_title('Centered zero manually,\nbut lost upper end of dynamic range', fontsize=8)

im2 = grid[2].imshow(biased_data, interpolation="none", cmap=shifted_cmap)
grid.cbar_axes[2].colorbar(im2)
grid[2].set_title('Recentered cmap with function', fontsize=8)

im3 = grid[3].imshow(biased_data, interpolation="none", cmap=shrunk_cmap)
grid.cbar_axes[3].colorbar(im3)
grid[3].set_title('Recentered cmap with function\nand shrunk range', fontsize=8)

for ax in grid:
    ax.set_yticks([])
    ax.set_xticks([])

Results of the example:

Rather than using a stock cmap, I will walk thorough the production of your own.

As you have already spotted, in order to have absolute control of the colors (without passing a colors array) when using cmaps, the number of colors in a cmap should be equal to the number of levels - 1.

We can easily demonstrate this with the following example. Lets make a colormap with the three primary colors in:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy


data = numpy.arange(12).reshape(3, 4)

cmap = mcolors.ListedColormap([(0, 0, 1), 
                               (0, 1, 0), 
                               (1, 0, 0)])

However, when we come to use this with anything other than 3+1 levels, we will get results that you may not expect:

plt.subplot(121)
plt.contourf(data, cmap=cmap, levels=[1, 4, 8, 10])

plt.subplot(122)
plt.contourf(data, cmap=cmap, levels=[1, 4, 8])

plt.show()

So I have shown that your levels must be of length n_colors-1, but because we want to have 3 colors, and the middle color always shown, we must also have an even number of levels.

Good, now we have some ground rules, lets make a LinearSegmentedColormap which is essentially just a ListedColormap with interpolation to N colors:

levs = range(12)
assert len(levs) % 2 == 0, 'N levels must be even.'

cmap = mcolors.LinearSegmentedColormap.from_list(name='red_white_blue', 
                                                 colors =[(0, 0, 1), 
                                                          (1, 1., 1), 
                                                          (1, 0, 0)],
                                                 N=len(levs)-1,
                                                 )
plt.contourf(data, cmap=cmap, levels=levs)
plt.show()

We can verify that the normailzed cmap has white as the middle color programatically:

>>> print cmap(0.5)
(1.0, 1.0, 1.0, 1.0)

Hopefully this will give you all the information you need to be able to make any colormap you like and to use it successfully in contouring.

As has been said in the comments you need to round the zero point value to a multiple of 1/N if N is the number of colors in the colormap. Of course the difference between the zero point value and any other colors in the colormap must be bigger than 1/N.

So here is a solution

import matplotlib.colors as col
from matplotlib.colors import LinearSegmentedColormap
import numpy as np 

N=256
zero_pt0 = 0.98181818181818181
zero_pt_rounded = np.ceil(zero_pt0*(N-1))/float(N-1)
print (zero_pt_rounded)

cmap = LinearSegmentedColormap.from_list(
    'mycmap', [(0, 'blue'), (zero_pt_rounded, 'white'), (1, 'red')], N=N)

# verify if original point zero_pt0 gives white color
rgb = cmap(zero_pt0)[:3]
print(col.rgb2hex(rgb))

Concerning your older question: It's not clear what the line zero_pt = 1. - H.max() / (H.max() - H.min()) should do. I would guess that you need to put

data_value_for_white color = ...
zero_pt = (data_value_for_white color - H.min()) / (H.max() - H.min())

Furthermore, in order to make sure the desired value is covered by the white color in the colormap, we would need to make the two adjacent colors in the colormap white.

N = 256 # number of colors in the colormap
zero_pt0 = np.floor(zero_pt*(N-1))/float(N-1)
zero_pt1 = np.ceil(zero_pt*(N-1))/float(N-1)
cmap = LinearSegmentedColormap.from_list('mycmap',
         [(0, 'blue'), (zero_pt0, 'white'),(zero_pt1, 'white'), (1, 'red')], N=N)

A complete solution would therefore look like:

import pickle
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap, rgb2hex


with open('data.pkl', 'r') as f:
    H = pickle.load(f)
with open('edges.pkl', 'r') as f:
    edges = pickle.load(f)

# Define zero point for empty bins which should be colored in white.
data_value_for_white_color = 0.
zero_pt = (data_value_for_white_color - H.min()) / float(H.max() - H.min())

N=256
zero_pt0 = np.floor(zero_pt*(N-1))/float(N-1)
zero_pt1 = np.ceil(zero_pt*(N-1))/float(N-1)

cmap = LinearSegmentedColormap.from_list('mycmap',
     [(0, 'blue'), (zero_pt0, 'white'),(zero_pt1, 'white'), (1, 'red')], N=N)

Y, X = np.meshgrid(edges[0], edges[1])
plt.pcolormesh(X, Y, H, cmap=cmap, vmin=H.min(), vmax=H.max())
plt.show()

Although not ideal, masking the zero value works. You can control the display of it with the cmap.set_bad().

from matplotlib.colors import LinearSegmentedColormap
import matplotlib.pyplot as plt
import numpy as np

dic = {'red': ((0., 1, 0), 
               (0.66, 1, 1), 
               (0.89,1, 1), 
               (1, 0.5, 0.5)), 
       'green': ((0., 1, 0), 
                (0.375,1, 1), 
                (0.64,1, 1), 
                (0.91,0,0), 
                (1, 0, 0)), 
       'blue': ((0., 1, 1), 
               (0.34, 1, 1), 
               (0.65,0, 0), 
               (1, 0, 0))}

a = np.random.rand(10,10)
a[0,:2] = 0
a[0,2:4] = 0.0001

fig, ax = plt.subplots(1,1, figsize=(6,6))

cmap = LinearSegmentedColormap('custom_cmap', dic)
cmap.set_bad('white')

ax.imshow(np.ma.masked_values(a, 0), interpolation='none', cmap=cmap)