[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Josh Rosenberg]

The immediate use case I can think of this for is to make it possible to
just do:

__len__ = instancemethod(operator.attrgetter('_length'))
__hash__ = instancemethod(operator.attrgetter('_cached_hash'))

and stuff like that. Mostly just a minor performance optimization to avoid
the overhead of Python level function calls (and in the case of stuff like
__hash__, reduce the probability of the GIL releasing during a dict/set
operation, though you'd still need some way to move __eq__ to the C layer
to allow stuff like setdefault to be truly atomic).

This was possible in Python 2 with types.MethodType (since it could make
unbound methods of a class for you; unbound methods no longer exist). Now
the solution is... considerably uglier (requires ctypes):
https://stackoverflow.com/q/40120596/364696

On Sun, Sep 13, 2020 at 5:24 AM Steven D'Aprano  wrote:

> On Sun, Sep 13, 2020 at 12:32:54AM -0400, Random832 wrote:
>
> > This isn't what I was suggesting - I meant something like this:
> >
> > class instancemethod:
> > def __init__(self, wrapped):
> > self.wrapped = wrapped
> > def __get__(self, obj, objtype):
> > if obj is None: return self.wrapped
> > else: return MethodType(self.wrapped, obj)
> >
> > this wouldn't be useful for functions, but would give other callables
> > the same functionality as functions, automatically creating the bound
> > method object, e.g.:
> >
> > class D:
> > def __init__(self, obj, *args): ...
> >
> > class C:
> > foo = instancemethod(D)
>
> You want a method which does absolutely nothing at all but delegate to a
> class constructor or callable object (but not a function), with no
> docstring and no pre-processing of arguments or post-processing of the
> result.
>
> Seems like an awfully small niche for this to be in the stdlib.
>
> But having said that, I might have a use for that too. Except... I would
> need a docstring. And pre- and post-processing. Hmmm.
>
> *shrug*
>
> Seems to me that this might be useful in theory, but in practice we
> might never use it, preferring this instead:
>
> class C:
> def foo(self, *args):
> """Doc string."""
> return D(self, *args)
>
> with appropriate pre- and post-processing as needed.
>
> Interesting suggestion though, I may have to play around with it.
>
>
>
> --
> Steve
> ___
> Python-ideas mailing list -- python-ideas@python.org
> To unsubscribe send an email to python-ideas-le...@python.org
> https://mail.python.org/mailman3/lists/python-ideas.python.org/
> Message archived at
> https://mail.python.org/archives/list/python-ideas@python.org/message/QKAA54IV2WDEEWN354PK3JPSPIAMRGD2/
> Code of Conduct: http://python.org/psf/codeofconduct/
>
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/2YL4WQVRVOQ7RNINBALI7BJMBCJEPY3C/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Steven D'Aprano]

On Sun, Sep 13, 2020 at 12:32:54AM -0400, Random832 wrote:

> This isn't what I was suggesting - I meant something like this:
> 
> class instancemethod:
> def __init__(self, wrapped):
> self.wrapped = wrapped
> def __get__(self, obj, objtype):
> if obj is None: return self.wrapped
> else: return MethodType(self.wrapped, obj)
> 
> this wouldn't be useful for functions, but would give other callables 
> the same functionality as functions, automatically creating the bound 
> method object, e.g.:
> 
> class D:
> def __init__(self, obj, *args): ...
> 
> class C:
> foo = instancemethod(D)

You want a method which does absolutely nothing at all but delegate to a 
class constructor or callable object (but not a function), with no 
docstring and no pre-processing of arguments or post-processing of the 
result.

Seems like an awfully small niche for this to be in the stdlib.

But having said that, I might have a use for that too. Except... I would 
need a docstring. And pre- and post-processing. Hmmm.

*shrug*

Seems to me that this might be useful in theory, but in practice we
might never use it, preferring this instead:

class C:
def foo(self, *args):
"""Doc string."""
return D(self, *args)

with appropriate pre- and post-processing as needed.

Interesting suggestion though, I may have to play around with it.



-- 
Steve
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/QKAA54IV2WDEEWN354PK3JPSPIAMRGD2/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Random832]

On Sat, Sep 12, 2020, at 23:14, Steven D'Aprano wrote:
> We already have an instancemethod, it's just spelled differently:
> 
> py> from types import MethodType
> 
> 
> And while it is not useful as a decorator, it is *really* useful for 
> adding methods to an individual instance rather than the class:

This isn't what I was suggesting - I meant something like this:

class instancemethod:
def __init__(self, wrapped):
self.wrapped = wrapped
def __get__(self, obj, objtype):
if obj is None: return self.wrapped
else: return MethodType(self.wrapped, obj)

this wouldn't be useful for functions, but would give other callables the same 
functionality as functions, automatically creating the bound method object, 
e.g.:

class D:
def __init__(self, obj, *args): ...

class C:
foo = instancemethod(D)

obj = C()
obj.foo(...) # D(obj, ...)

Same for other types of callables such as functools.partial objects etc.

> So an instancemethod decorator would be a waste of time, but the 
> instancemethod type, spelled types.MethodType, is very useful.
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/CYBMRSMOQOKSYELNW7AZ36WL3W23RD5Q/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Steven D'Aprano]

On Sat, Sep 12, 2020 at 07:25:30PM -0400, Eric V. Smith wrote:
> On 9/12/2020 7:13 PM, Random832 wrote:
> >On Fri, Sep 11, 2020, at 19:57, Cameron Simpson wrote:
> >>The default (an instance method) requires "self" to perform.
> >Of course, this is only the default if the method is a function object. If 
> >it is a different callable class, the default is effectively staticmethod.
> >
> >Perhaps there should be an @instancemethod?
> 
> What would that let us do that we can't currently achieve?

We already have an instancemethod, it's just spelled differently:

py> from types import MethodType


And while it is not useful as a decorator, it is *really* useful for 
adding methods to an individual instance rather than the class:


py> class K:
... pass
... 
py> obj = K()
py> obj.method = lambda self, x: (self, x)
py> obj.method('arg')  # Fails
Traceback (most recent call last):
  File "", line 1, in 
TypeError: () missing 1 required positional argument: 'x'

But this works:


py> obj.method = MethodType(lambda self, x: (self, x), obj)
py> obj.method('arg')
(<__main__.K object at 0x7f67a4e051d0>, 'arg')


So an instancemethod decorator would be a waste of time, but the 
instancemethod type, spelled types.MethodType, is very useful.


-- 
Steve
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/D24PW37YSIHV2XHNHARQLM4EMHH6GQKD/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Eric V. Smith]

On 9/12/2020 7:13 PM, Random832 wrote:

On Fri, Sep 11, 2020, at 19:57, Cameron Simpson wrote:

The default (an instance method) requires "self" to perform.

Of course, this is only the default if the method is a function object. If it 
is a different callable class, the default is effectively staticmethod.

Perhaps there should be an @instancemethod?


What would that let us do that we can't currently achieve?

Eric
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/Z27KHJZZTVMJFCBGO5Z6VJRAJHZYZ2YD/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Random832]

On Fri, Sep 11, 2020, at 19:57, Cameron Simpson wrote:
> The default (an instance method) requires "self" to perform.

Of course, this is only the default if the method is a function object. If it 
is a different callable class, the default is effectively staticmethod.

Perhaps there should be an @instancemethod?
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/5ZMYQ33BPI2VNWADQIBSGD4NVLXI4SQF/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Ethan Furman]

On 9/11/20 7:35 PM, Christopher Barker wrote:
-
> But the real question is why staticmethod at all?
>
> And the answer is that there is very little use for staticmethod in
> Python [...]


On 9/11/20 7:28 PM, Greg Ewing wrote:
-
> IMO, static methods are a kludge only needed in languages that make
> classes do double duty as modules, and also can't have class methods
> because classes aren't first-class objects.

-

I have a base class that holds the logic for converting from one data 
system to another.  The module that holds this base class also imports 
several utility functions from other places.


The subclasses that hold the unique code occasionally have to 
overwrite/extend some of the base class methods, which means also 
needing to import the utility functions (the subclasses live in 
different files).


Rather than having to keep track of the various utility methods, 
including adding more imports if the base class uses more with new 
functionality, I just


  get_fis_table = staticmethod(fisData)
  get_xid_records = staticmethod(get_xid_records)

and then the subclasses can do

  blah = self.get_xid_records(...)

without worrying where `get_xid_records` came from.

Without `staticmethod` I would have to have a thin wrapper around those 
utility methods -- obviously not insurmountable, but annoying; and I 
really like that Python is not usually annoying.


--
~Ethan~
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/B7Q64WDU6EN235SWQX44CJ36XBUSJ3DH/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[2QdxY4RzWzUUiLuE]

On 2020-09-12 at 14:07:57 +1000,
Cameron Simpson  wrote:

> Dan, I should preface this by saying I don't substantially disagree
> with you, I just work differently and want to show how and why.

> The beauty here is that you have the same pattern of
> classname.transcribe_value(value) to use whatever binary format you
> want.  And that's a static method because it doesn't need a class or
> instance for context - it just transcribes the data.

> > IMO, m.f has less cognitive load than m.X.f, at their definitions
> > and at call sites.  Full disclosure:  I consider most of Object
> > Oriented Programming to be extraneous cognitive noise.
> 
> Whereas I use OOP a lot. Hugely.

Maybe what I needed early on was a good example of a large, well
designed OO piece of software to use as a role model.  But the large
non-OO systems seemed to be much better (in any number of ways, and
please don't mistake me for implying that all non-OO systems are good)
than the large OO ones.  My habits and opinions are certainly shaped
from my experience.

Namespaces are one honking great idea.  I¹ have modules, you¹ have
classes.  We¹ build software.  Vive la différence!  :-)

> > In other languages (*cough* Java *cough*), there are no functions
> > outside of classes, and static methods fill that role.
> 
> Aye. I agree that is an example where static methods exist for
> language definition reasons instead of functionality. OTOH, the
> language design is deliberately like that to force encapsulation as a
> universal approach, which has its own benefits in terms of side effect
> limitation and code grouping, so there's an ulterior purpose there.

Encapsulation is a good thing, OO or otherwise.  Unless, of course, the
code is behind an HTTP server and I can't see it from the outside.

¹ in the generic sense of the pronoun

-- 
“Whoever undertakes to set himself up as a
judge of Truth and Knowledge is shipwrecked
by the laughter of the gods.” – Albert Einstein
Dan Sommers, http://www.tombstonezero.net/dan
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/AGAZ6OEKE2TSNEMSMNCSCSS3EA5G3HIQ/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Cameron Simpson]

Dan, I should preface this by saying I don't substantially disagree with 
you, I just work differently and want to show how and why.

On 11Sep2020 21:24, Dan Sommers <2qdxy4rzwzuui...@potatochowder.com> wrote:
>On 2020-09-12 at 09:57:10 +1000,
>Cameron Simpson  wrote:
>> So, consider:
>>
>> @classmethod
>> def func(cls, foo):
>> print(foo)
>>
>> A linter will warn you that "cls" is unused. With a static method:
>>
>> @staticmethod
>> def func(foo):
>> print(foo)
>>
>> a linter will be happy.
>>
>> Think of @classmethod and @staticmethod as ways to write "clean"
>> functions with no extraneous cognitive noise.
>
>I concur with all of Cameron's technical details and explanations.
>
>But no extraneous cognitive noise?

Specificly in the sense that the @classmethod example has an unused 
"cls" parameter. For a three line function this is trivial to ignore, 
but for a substantial function I'd be devoting annoying brainpower to 
understanding where it was used, and if it didn't appear, _should_ it be 
used? Thus noise. With the static method it is instantly clear that no 
instance or class context is used.

>By definition, methods appear inside
>a class definition, and then I have to process the @staticmethod
>decorator.  Effectively, the decorator "cancels" the class method status
>of the function.

For me, I have to process either the @staticmethod or @classmethod 
decorators equally - they just have different meanings. But at least 
they're up the front - I see them and their meaning for the function 
context is instantly available to me instead of needing to be deduced.

>I can accomplish the same thing with clean
>module-level function, modulo the specific namespace in which the
>function is created.
>
>So, in a module m:
>
>class X:
>@staticmethod
>def f(x):
>print(x)
>
>and
>
>def f(x):
>print(x)
>
>m.X.f and m.f are interchangeable.

Yes, technically. Let me say up front that I write plenty of module 
elvel plain functions.

However I do have plenty of use cases for @staticmethod in class 
definitions. They tend to be class utility functions, either for some 
common function used in the class methods, _or_ a common method meant to 
be available for outside use - particularly for a common pattern for 
outside use.

Here's an example of the former:

  @staticmethod
  def pick_value(float_value, string_value, structured_value):
''' Chose amongst the values available.
'''
if float_value is None:
  if string_value is None:
return structured_value
  return string_value
return float_value

  @property
  def value(self):
''' Return the value for this `Tag`.
'''
return self.pick_value(
self.float_value, self.string_value, self.structured_value
)

This is from a tag library of mine, where the tags live in a database 
and there are three fields: a float, a string and a JSON blob. Only one 
will be nonNULL. This supports a remarkable flexibility in tagging 
things. It is common in the class to pick amongst them, thus the static 
method. It is also not unreasonable to work with such a choice outside 
the class (so it might not be a private method/function).

On review, I've actually got relatively few examples of the latter 
category - methods for use outside the class - they are almost entirely 
@classmethods. The few which are static methods live in the class for 
purposes of conceptual hierarchy.

My commonest example is the transcription method from a binary structure 
module I have. Data structures each have a class which implements them, 
and all subclass a base class. This gets me a common API for parsing the 
structure and also for writing it back out.

When implementing a particular structure one always has a choice between 
implementing one of two "transcribe" methods. For a simple thing with a 
single "value" (eg an int) you'd implement "transcribe_value(value)", a 
static method. For something more complex you implement "transcribe()", 
a class or instance method depending. In the abstract base class each 
method calls the other - the subclass must provide a concrete 
implementation of one method.

Anyway, back to the static method: if is pretty common to want to write 
out a value using the transcription from a class, example:

value = 9
bs = BSUInt.transcribe_value(value)

without going to any hassle of instantiating an instance of BSUInt - we 
just want to convert from the Python type to bytes. There's a similar 
example for parsing.

The beauty here is that you have the same pattern of
classname.transcribe_value(value) to use whatever binary format you 
want.  And that's a static method because it doesn't need a class or 
instance for context - it just transcribes the data.

>IMO, m.f has less cognitive load
>than m.X.f, at their definitions and at call sites.  Full disclosure:  I
>consider most of 

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Christopher Barker]

On Fri, Sep 11, 2020 at 7:27 PM <2qdxy4rzwzuui...@potatochowder.com> wrote:

> But no extraneous cognitive noise?  By definition, methods appear inside
> a class definition, and then I have to process the @staticmethod
> decorator.  Effectively, the decorator "cancels" the class method status
> of the function.  I can accomplish the same thing with clean
> module-level function, modulo the specific namespace in which the
> function is created.
>

Exactly. This question asked why staticmethod when we have classmethod. But
the real question is why staticmethod at all?

And the answer is that there is very little use for staticmethod in Python
-- all it does is put a regular function in the class' namespace, and since
we have modules to be nice namespaces for functions, there is little need
for it.

Sometimes it does make sense to keep some functionality all bundled
together with a class, but I find it pretty rare.

-CHB

-- 
Christopher Barker, PhD

Python Language Consulting
  - Teaching
  - Scientific Software Development
  - Desktop GUI and Web Development
  - wxPython, numpy, scipy, Cython
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/ZGIJ3QJMNMZLNIWLTGFXPH3A73NDEWUM/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Greg Ewing]

On 12/09/20 12:21 pm, Guido van Rossum wrote:
I had heard of this 
concept in another language (C++? Smalltalk?)


Probably C++ or Java. Smalltalk doesn't have static methods, only a
form of class method.

IMO, static methods are a kludge only needed in languages that make
classes do double duty as modules, and also can't have class methods
because classes aren't first-class objects. I've never felt the need
for one in Python.

--
Greg
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/TQCMUPLEWZJO3YGVRPE4ECMHAKC32DEK/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[2QdxY4RzWzUUiLuE]

On 2020-09-12 at 09:57:10 +1000,
Cameron Simpson  wrote:

> So, consider:
> 
> @classmethod
> def func(cls, foo):
> print(foo)
> 
> A linter will warn you that "cls" is unused. With a static method:
> 
> @staticmethod
> def func(foo):
> print(foo)
> 
> a linter will be happy.
> 
> Think of @classmethod and @staticmethod as ways to write "clean" 
> functions with no extraneous cognitive noise.

I concur with all of Cameron's technical details and explanations.

But no extraneous cognitive noise?  By definition, methods appear inside
a class definition, and then I have to process the @staticmethod
decorator.  Effectively, the decorator "cancels" the class method status
of the function.  I can accomplish the same thing with clean
module-level function, modulo the specific namespace in which the
function is created.

So, in a module m:

class X:
@staticmethod
def f(x):
print(x)

and

def f(x):
print(x)

m.X.f and m.f are interchangeable.  IMO, m.f has less cognitive load
than m.X.f, at their definitions and at call sites.  Full disclosure:  I
consider most of Object Oriented Programming to be extraneous cognitive
noise.

In other languages (*cough* Java *cough*), there are no functions
outside of classes, and static methods fill that role.
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/3PEG35ADEQIEMXLKBCDGBFSM2IO5NS4V/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Guido van Rossum]

On Fri, Sep 11, 2020 at 4:00 PM The Nomadic Coder 
wrote:

> This question is to further my understanding of the internals. It seems to
> me that a classmethod can do everything a staticmethod can, and
> additionally is not limited by inheritance.
>
> Why does python have them as two different constructs?
>

The answer is actually somewhat embarrassing. IIRC I had heard of this
concept in another language (C++? Smalltalk?) and it sounded useful, so I
added staticmethod. Then after the release and some actual use I realized
that it was actually useful to have access to the class from inside the
method (in case it's called for a subclass). So I also added classmethod.
But since staticmethod was already out of the bag, I kept it around, and
it's found its uses (as you can see from other replies).

-- 
--Guido van Rossum (python.org/~guido)
*Pronouns: he/him **(why is my pronoun here?)*

___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/N5ZBMAUTUHDAQI232PM2MLDB47OJRGQE/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[William Pickard]

staticmethod is generally used if you don't want an automatically bound 
'self'/'cls' parameter when invoking a method on the type.
classmethod just changes WHICH object is used as the "self" parameter.
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/5EZTQOWS4ANG4XEYP2X3ADOBI3DPGLOI/
Code of Conduct: http://python.org/psf/codeofconduct/

[Python-ideas] Re: Curious : Why staticmethod if classmethods can do everything a static method can?

[Cameron Simpson]

On 11Sep2020 22:58, The Nomadic Coder  wrote:
>This question is to further my understanding of the internals. It seems to me 
>that a classmethod can do everything a staticmethod can, and additionally is 
>not limited by inheritance.
>
>Why does python have them as two different constructs?

It has to do with context. What context does the method need?

The default (an instance method) requires "self" to perform.

A class method requires the class to perform, but not an instance.

A static method requires neither.

Define your method appropriately.

When you start using linters to catch mechanical code issues, the 
"unused variable" is a standard issue: it means either that the function 
has been given context it doesn't need (if the variable came from a 
parameter), or that a function is doing a computation it doesn't need to 
make (or keep), or that you've got a bug because you compute something 
and fail to use it (often a variable name misspelling).

So, consider:

@classmethod
def func(cls, foo):
print(foo)

A linter will warn you that "cls" is unused. With a static method:

@staticmethod
def func(foo):
print(foo)

a linter will be happy.

Think of @classmethod and @staticmethod as ways to write "clean" 
functions with no extraneous cognitive noise.

Also, what's inheritance to do with this? You can inherit static 
methods, I do it all the time.  Maybe I don't understand what you mean 
by "additionally is not limited by inheritance"?

Cheers,
Cameron Simpson 
___
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/KZ6QVA3V7MZQUPGJAVNIQWQHPZQ22VUX/
Code of Conduct: http://python.org/psf/codeofconduct/