Based on the input I have gotten so far, I have made a simplified version of the approach . It only handles the cases for str and function (or rather callable, but I call it a function in the documentation). These seem to handle most use-cases reasonably well. As Antony pointed out, None is potentially confusing, and as Thomas pointed out IndexFormatter is deprecated. That left only the empty NullFormatter (with an empty str), StrMethodFormatter (with any other str), and FuncFormatter (with a callable).
Antony made a good case that we should keep the number of approaches as small as possible. Since the NullFormatter is trivially handled with an empty str, and that is really what it is behind-the-scenes, that was an obvious one to cut.
Antony made the good case that any str could be handled with str.format. I tried that approach initially, but the issue I ended up having is that, although it is obvious to experienced Python users, it isn’t as obvious to newer users. That would mean I would need to properly communicate this workaround to users in the documentation. However, my attempts to do this ended up being longer, more complicated, and harder to understand than simply implementing the str case directly. So I ended up keeping the str and function approaches. Of course this decision is open to discussion.
I also updated the documentation, tests, and examples to explain these new features. Please take a look and let me know what you think.
One open issue is that I did not change any examples currently using any of these formatters, I only added the new approach. I think it might be good to change some of the simpler examples of using formatters to use this new feature in order to make formatters seem more approachable, but I haven’t done that yet.
On Wed, Mar 4, 2020 at 10:03 PM Todd firstname.lastname@example.org wrote:
Currently setting up the tick formatting on matplotlib requires you to import a formatter from the ticker module, create an instance of that formatter, then pass that to the axis. This makes sense for complicated formatting. However, there are some obvious cases where we can probably infer the type of formatting someone wants to do if we are just given the formatter content. For example
- ‘’ is probably going to be the null formatter
- A callable, besides a formatter instance, is probably going to be a function formatter
- A sequence or numpy array is probably going to be an index or fixed formatter, depending on the locator
- Any other string is probably going to be a format string formatter or string method formatter.
So I think we could allow the
set_minor_formatter to take certain sorts of inputs and create the formatter automatically for the user, making such cases much, much easier. Specifically, I propose the following inputs be accepted:
None sets it to the default formatter
- A callable (besides a formatter instance) is set to be a FuncFormatter
- An empty string,
'', is set to be a NullFormatter
- Any other string is a StrMethodFormatter
- An abc.collections.Sequence subclass or numpy ndarray subclass is an IndexFormatter, unless the axis is using a FixedLocator in which case it is a FixedLocator. We could restrict this to just lists and numpy arrays only.