¿agregar línea basada en la pendiente e interceptar en matplotlib?

Question

En R, hay una función llamada abline en la que se puede dibujar una línea en un trazado basado en la especificación de la pendiente de intercepción (primer argumento) (segundo argumento). Por ejemplo,

plot(1:10,1:10) 
abline(0,1) 

donde la línea con intersección de 0 y la pendiente de 1 abarca toda la gama de la trama. ¿Hay tal función en matplotlib.pyplot?

Answer 1

Supongo que en el caso de (intercept, slope) de (0, 1) la siguiente función podría utilizarse y extenderse para acomodar otras pendientes e intersecciones, pero no se reajustará si se modifican los límites de los ejes o si se vuelve a activar la autoescala.

def abline(): 
    gca = plt.gca() 
    gca.set_autoscale_on(False) 
    gca.plot(gca.get_xlim(),gca.get_ylim()) 

import matplotlib.pyplot as plt 
plt.scatter(range(10),range(10)) 
abline() 
plt.draw() 

Answer 2

yo no podía entender una manera de hacerlo sin recurrir a las devoluciones de llamada, pero esto parece que funciona bastante bien.

import numpy as np 
from matplotlib import pyplot as plt 


class ABLine2D(plt.Line2D): 

    """ 
    Draw a line based on its slope and y-intercept. Additional arguments are 
    passed to the <matplotlib.lines.Line2D> constructor. 
    """ 

    def __init__(self, slope, intercept, *args, **kwargs): 

     # get current axes if user has not specified them 
     if not 'axes' in kwargs: 
      kwargs.update({'axes':plt.gca()}) 
     ax = kwargs['axes'] 

     # if unspecified, get the current line color from the axes 
     if not ('color' in kwargs or 'c' in kwargs): 
      kwargs.update({'color':ax._get_lines.color_cycle.next()}) 

     # init the line, add it to the axes 
     super(ABLine2D, self).__init__([], [], *args, **kwargs) 
     self._slope = slope 
     self._intercept = intercept 
     ax.add_line(self) 

     # cache the renderer, draw the line for the first time 
     ax.figure.canvas.draw() 
     self._update_lim(None) 

     # connect to axis callbacks 
     self.axes.callbacks.connect('xlim_changed', self._update_lim) 
     self.axes.callbacks.connect('ylim_changed', self._update_lim) 

    def _update_lim(self, event): 
     """ called whenever axis x/y limits change """ 
     x = np.array(self.axes.get_xbound()) 
     y = (self._slope * x) + self._intercept 
     self.set_data(x, y) 
     self.axes.draw_artist(self) 

Answer 3

Sé que esta pregunta es un par de años, pero ya que no hay una respuesta aceptada, voy a añadir lo que funciona para mí.

Puede trazar los valores en su gráfico, y luego generar otro conjunto de valores para las coordenadas de la mejor línea de ajuste y trazar eso sobre su gráfico original. Por ejemplo, véase el siguiente código:

import matplotlib.pyplot as plt 
import numpy as np 

# Some dummy data 
x = [1, 2, 3, 4, 5, 6, 7] 
y = [1, 3, 3, 2, 5, 7, 9] 

# Find the slope and intercept of the best fit line 
slope, intercept = np.polyfit(x, y, 1) 

# Create a list of values in the best fit line 
abline_values = [slope * i + intercept for i in x] 

# Plot the best fit line over the actual values 
plt.plot(x, y, '--') 
plt.plot(x, abline_values, 'b') 
plt.title(slope) 
plt.show() 

Answer 4

X = np.array([1, 2, 3, 4, 5, 6, 7]) 
Y = np.array([1.1,1.9,3.0,4.1,5.2,5.8,7]) 

scatter (X,Y) 
slope, intercept = np.polyfit(X, Y, 1) 
plot(X, X*slope + intercept, 'r') 

Answer 5

Muchas de estas soluciones están centrando en la adición de una línea de la trama que se ajuste a los datos. Aquí hay una solución simple para agregar una línea arbitraria a la trama basada en una pendiente e intersección.

def abline(slope, intercept): 
    """Plot a line from slope and intercept""" 
    axes = plt.gca() 
    x_vals = np.array(axes.get_xlim()) 
    y_vals = intercept + slope * x_vals 
    plt.plot(x_vals, y_vals, '--')