matplotlib: formata os valores de deslocamento do eixo para números inteiros ou número específico

Eu tenho uma figura matplotlib que estou traçando dados que sempre é referido como nanossegundos (1e-9). No eixo y, se eu tiver dados que são dezenas de nanossegundos, ou seja, 44e-9, o valor no eixo mostra 4,4 com a + 1e-8 como um deslocamento. Existe alguma maneira de forçar o eixo a mostrar 44 com um deslocamento + 1e-9?

O mesmo vale para meu eixo x, onde o eixo está mostrando + 5,54478e4, onde prefiro que ele mostre um deslocamento de +55447 (número inteiro, sem decimal - o valor aqui é em dias).

Eu tentei algumas coisas como esta:

p = axes.plot(x,y)
p.ticklabel_format(style='plain')

para o eixo x, mas isso não funciona, embora eu provavelmente esteja usando incorretamente ou interpretando mal algo dos documentos, alguém pode me apontar a direção correta?

Obrigado Jonathan

Tentei fazer algo com formatadores, mas ainda não encontrei nenhuma solução ...:

myyfmt = ScalarFormatter(useOffset=True)
myyfmt._set_offset(1e9)
axes.get_yaxis().set_major_formatter(myyfmt)

e

myxfmt = ScalarFormatter(useOffset=True)
myxfmt.set_portlimits((-9,5))
axes.get_xaxis().set_major_formatter(myxfmt)

Em uma nota lateral, estou realmente confuso sobre onde o objeto 'número de deslocamento' realmente reside ... é parte dos tiques principais / secundários?

Eu tive exatamente o mesmo problema, e estas linhas resolveram o problema:

from matplotlib.ticker import ScalarFormatter

y_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
ax.yaxis.set_major_formatter(y_formatter)

Uma solução muito mais fácil é simplesmente personalizar os rótulos dos carrapatos. Veja este exemplo:

from pylab import *

# Generate some random data...
x = linspace(55478, 55486, 100)
y = random(100) - 0.5
y = cumsum(y)
y -= y.min()
y *= 1e-8

# plot
plot(x,y)

# xticks
locs,labels = xticks()
xticks(locs, map(lambda x: "%g" % x, locs))

# ytikcs
locs,labels = yticks()
yticks(locs, map(lambda x: "%.1f" % x, locs*1e9))
ylabel('microseconds (1E-9)')

show()

Observe como, no caso do eixo y, eu multipliquei os valores 1e9e mencionei essa constante no rótulo y

EDITAR

Outra opção é falsificar o multiplicador de expoentes adicionando manualmente seu texto no topo do gráfico:

locs,labels = yticks()
yticks(locs, map(lambda x: "%.1f" % x, locs*1e9))
text(0.0, 1.01, '1e-9', fontsize=10, transform = gca().transAxes)

EDIT2

Além disso, você pode formatar o valor de deslocamento do eixo x da mesma maneira:

locs,labels = xticks()
xticks(locs, map(lambda x: "%g" % x, locs-min(locs)))
text(0.92, -0.07, "+%g" % min(locs), fontsize=10, transform = gca().transAxes)

Você tem que criar uma subclasse ScalarFormatterpara fazer o que você precisa ... _set_offsetapenas adiciona uma constante que você deseja definir ScalarFormatter.orderOfMagnitude. Infelizmente, a configuração manual orderOfMagnitudenão fará nada, já que é redefinida quando a ScalarFormatterinstância é chamada para formatar os rótulos de escala do eixo. Não deveria ser tão complicado, mas não consigo encontrar uma maneira mais fácil de fazer exatamente o que você deseja ... Aqui está um exemplo:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter, FormatStrFormatter

class FixedOrderFormatter(ScalarFormatter):
    """Formats axis ticks using scientific notation with a constant order of 
    magnitude"""
    def __init__(self, order_of_mag=0, useOffset=True, useMathText=False):
        self._order_of_mag = order_of_mag
        ScalarFormatter.__init__(self, useOffset=useOffset, 
                                 useMathText=useMathText)
    def _set_orderOfMagnitude(self, range):
        """Over-riding this to avoid having orderOfMagnitude reset elsewhere"""
        self.orderOfMagnitude = self._order_of_mag

# Generate some random data...
x = np.linspace(55478, 55486, 100) 
y = np.random.random(100) - 0.5
y = np.cumsum(y)
y -= y.min()
y *= 1e-8

# Plot the data...
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, y, 'b-')

# Force the y-axis ticks to use 1e-9 as a base exponent 
ax.yaxis.set_major_formatter(FixedOrderFormatter(-9))

# Make the x-axis ticks formatted to 0 decimal places
ax.xaxis.set_major_formatter(FormatStrFormatter('%0.0f'))
plt.show()

O que produz algo como:

Visto que a formatação padrão seria assim:

Espero que ajude um pouco!

Editar: pelo que vale a pena, também não sei onde o rótulo de deslocamento reside ... Seria um pouco mais fácil apenas configurá-lo manualmente, mas não consegui descobrir como fazer isso ... Tenho a sensação que tem que haver uma maneira mais fácil do que tudo isso. Mas funciona!

Semelhante à resposta de Amro, você pode usar FuncFormatter

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter

# Generate some random data...
x = np.linspace(55478, 55486, 100) 
y = np.random.random(100) - 0.5
y = np.cumsum(y)
y -= y.min()
y *= 1e-8

# Plot the data...
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, y, 'b-')

# Force the y-axis ticks to use 1e-9 as a base exponent 
ax.yaxis.set_major_formatter(FuncFormatter(lambda x, pos: ('%.1f')%(x*1e9)))
ax.set_ylabel('microseconds (1E-9)')

# Make the x-axis ticks formatted to 0 decimal places
ax.xaxis.set_major_formatter(FuncFormatter(lambda x, pos: '%.0f'%x))
plt.show()

A solução de Gonzalo começou a funcionar para mim depois de adicionar set_scientific(False):

ax=gca()
fmt=matplotlib.ticker.ScalarFormatter(useOffset=False)
fmt.set_scientific(False)
ax.xaxis.set_major_formatter(fmt)

Conforme apontado nos comentários e nesta resposta , o deslocamento pode ser desativado globalmente, fazendo o seguinte:

matplotlib.rcParams['axes.formatter.useoffset'] = False

Acho que uma forma mais elegante é usar o formatador de ticker. Aqui está um exemplo para eixo xis e eixo y:

from pylab import *
from matplotlib.ticker import MultipleLocator, FormatStrFormatter

majorLocator   = MultipleLocator(20)
xFormatter = FormatStrFormatter('%d')
yFormatter = FormatStrFormatter('%.2f')
minorLocator   = MultipleLocator(5)


t = arange(0.0, 100.0, 0.1)
s = sin(0.1*pi*t)*exp(-t*0.01)

ax = subplot(111)
plot(t,s)

ax.xaxis.set_major_locator(majorLocator)
ax.xaxis.set_major_formatter(xFormatter)
ax.yaxis.set_major_formatter(yFormatter)

#for the minor ticks, use no labels; default NullFormatter
ax.xaxis.set_minor_locator(minorLocator)

Para a segunda parte, sem redefinir manualmente todos os ticks novamente, esta foi a minha solução:

class CustomScalarFormatter(ScalarFormatter):
    def format_data(self, value):
        if self._useLocale:
            s = locale.format_string('%1.2g', (value,))
        else:
            s = '%1.2g' % value
        s = self._formatSciNotation(s)
        return self.fix_minus(s)
xmajorformatter = CustomScalarFormatter()  # default useOffset=True
axes.get_xaxis().set_major_formatter(xmajorformatter)

obviamente, você pode definir a string de formato para o que quiser.