How to create a class that generates auto-updateable plots

by

Summary

This incident stemmed from a subtle but classic Python mistake: overwriting self inside a class constructor, causing plot axes to be replaced with the class instance itself. As a result, the plotting logic failed and produced the error AttributeError: 'channel' object has no attribute 'plot'.

Root Cause

The root cause was the following line inside the channel.__init__ method:

  • self = parentFigure.add_subplot(subplotPosition)

This line rebinds self, replacing the instance with a Matplotlib Axes object.
Because of this:

  • The returned object is no longer a channel instance
  • The attributes and methods expected on an Axes object are missing
  • The caller receives a channel instance that contains no Axes reference
  • Subsequent calls like a.plot(...) fail because a is not an Axes object

Why This Happens in Real Systems

This pattern appears frequently in production codebases because:

  • Developers misunderstand how Python binds self
  • Object initialization is mixed with object replacement
  • Engineers try to “inherit behavior” by assigning self instead of storing the object
  • GUI frameworks (Tkinter, Qt, etc.) encourage nested object structures that make ownership confusing

Common triggers include:

  • Incorrect composition patterns
  • Accidental shadowing of instance attributes
  • Returning the wrong object type from constructors

Real-World Impact

Mistakes like this cause:

  • Silent type corruption (objects become the wrong type)
  • Hard-to-debug runtime errors
  • Broken UI update loops
  • Memory leaks when GUI elements are recreated unnecessarily
  • Inconsistent state across multiple plot channels

In a real production environment, this can cascade into:

  • Frozen dashboards
  • Incorrect sensor readings
  • Monitoring systems that appear healthy but are not updating

Example or Code (if necessary and relevant)

Below is a corrected version of the class.
It stores the subplot in an attribute instead of overwriting self.

class Channel:
    def __init__(self, parentFigure, subplotPosition, x, y, channelNumber, clr):
        self.ax = parentFigure.add_subplot(subplotPosition)
        self.ax.plot(x, y, color=clr)
        self.ax.set_title(channelNumber, fontsize=16)
        self.ax.set_ylabel("Temperature (°C)", fontsize=14)
        self.ax.set_xlabel("Time (seconds)", fontsize=14)

    def update(self, x, y, clr):
        self.ax.plot(x, y, color=clr)

How Senior Engineers Fix It

Experienced engineers apply several principles:

  • Never reassign self
  • Use composition properly: store the subplot as self.ax
  • Separate initialization from update logic
  • Encapsulate state so each channel owns its own axes and update method
  • Design for extensibility when handling many plots (8–16 in this case)

They also ensure:

  • Update loops call methods on the channel object
  • The GUI redraws only the changed elements
  • Plot objects are not recreated unnecessarily

Why Juniors Miss It

Junior engineers often miss this issue because:

  • Python allows rebinding self without warning
  • The code “looks like it should work” at first glance
  • They assume constructors can return alternate objects
  • They confuse composition with inheritance
  • GUI frameworks add cognitive load, making subtle bugs harder to spot

The key takeaway: self is not a variable you can replace — it is the instance itself.

Leave a Comment