You don't need to reference the class inside itself, using bar instead of Test.bar will work fine.

class Test:
    @staticmethod
    def bar():
        pass

    FOO_DICT = {1: bar}


# You can access this outside of the class by simply using Test.FOO_DICT
print(Test.FOO_DICT)

However, there are cases where you really need to use a class in itself. For example

class Test:
    @staticmethod
    def bar():
        pass

    def test_with_other_of_same_instance(self, other: Test):
        print(other.FOO_DICT)

    FOO_DICT = {1: bar}

In this case,

• I want to define a method that accepts an object of the same Test class.
• I want to use python's type hinting to indicate that the expected argument is an instance of Test. This allows me get editor support and also so tools like pylance and mypy can notify me of possible errors if I passed a argument of wrong data type.

As at the time of this writing, I'll get a NameError: name 'Test' is not defined.

This is because by default I can't use a class within itself (It is possible later versions of python will change its default behavior, hence we won't be needing the solution below by that time).

But if you use Python versions from 3.7+ and you can't reference a class within itself, the simple solution came with PEP 563 - Postponed evaluation of annotations. It is implemented by adding a little line of code at the first line of the file

from __future__ import annotations
# other imports or code come afterwards


class Test:
    @staticmethod
    def bar():
        pass

    def test_with_other_of_same_instance(self, other: Test):
        print(other.FOO_DICT)

    FOO_DICT = {1: bar}

So you can use a class within itself in python by simply including that line at the beginning of the file.

Normally, if you use pylance or any similar tool, you get a warning or error display to show you that you imported something and didn't use it. But not in the case of annotations. You don't have to worry about any warning from your editor.

Note that this must occur at the beginning of the file otherwise you get a SyntaxError and versions earlier than 3.7 won't support this.

You need @classmethod rather than @staticmethod - a class method will get passed a reference to the class (where a method will get self), so you can look up attributes on it.

class FooBarBaz:
    BAR = 123

    @classmethod
    def getBar(cls):
        return cls.BAR

The proper solution is to move the dict outside the class

class A:
    pass

A.mydict = {A: 3, B: 2}

which will result in exactly the values you would get if you could do what you ask for.

Update

In Python 3.11 the module is named typing instead of typing_extensions

from typing import Self


class Node:
    """Binary tree node."""

    def __init__(self, left: Self, right: Self):
        self.left = left
        self.right = right

This might be helpful:

from typing_extensions import Self


class Node:
    """Binary tree node."""

    def __init__(self, left: Self, right: Self):
        self.left = left
        self.right = right

typing_extensions offers a Self class to reference class itself which I think is most elegent way to self-reference(PEP 673).

As others have mentioned, you can also use string literals. But it comes to problem when you have multiple type hints.

# python 3.10
var: str | int

And then you write something like

class Node:
    def __init__(self, var: 'Node' | SomeClass):
        self.var = var

It will raise a TypeError: unsupported operand type(s) for |: 'str' and 'type'.

You cannot, because during class definition, the class does not yet exist.

You can apply the decorator after the class has been created:

class A():
    def f(self):
        return 2

    def w(self, f):
        return fr + 5 

A.f = dec(A.w)(A.f.__func__)

or you can swap the order of the two method definitions and refer to w as a local name still:

class A():
    def w(self, f):
        return fr + 5 

    @dec(w)
    def f(self):
        return 2

In both cases you are passing in a callable A.w that is not bound to an instance. No self will be passed in, so you need to add that yourself, in the decorator:

def decorate(w):
    def _wrap(f):
        def _call(self, *args, **kwargs):
            return w(self, f(*args, **kwargs))
        def _call
    return _wrap

If you didn't expect w to be bound (it acting as a static method instead), you could just use a normal function instead here.

Generally speaking, creating a decorator to call another method on the same instance is somewhat pointless; why not just call w from within f, directly?

class A():
    def f(self):
        return self.w(2)

    def w(self, f):
        return fr + 5 

If I understand your question correctly, you should be able to reference class A within class A by putting the type annotation in quotes. This is called forward reference.

class A:
  # do something
  def some_func(self, a: 'A')
  # ...

See ref below

1. https://github.com/python/mypy/issues/3661
2. https://www.youtube.com/watch?v=AJsrxBkV3kc

Add the class after the class is defined:

class Template():
    _allowed_types = [str, SafeHtml]

Template._allowed_types.append(Template)

The class body, by necessity, is run before the class object can be created, so the name Template is not defined yet. But you can always alter class attributes after the object has been created.

Use a meta class to automatically set it.

def my_meta(name, bases, attrs):
    cls = type(name, bases, attrs)
    cls.bar = cls
    return cls


class Foo(object):
    __metaclass__ = my_meta


>>> print Foo.bar
<class '__main__.Foo'>

You can reference my_class inside itself just fine. You can't refer to my_class while it's being defined (outside any method, at the top-level of the class definition scope, or in the parameter definitions of a function), but you can refer to it inside a method that won't be called until you've finished defining my_class. The only issue you have here is the somewhat ugly string-based annotations to work around the self-reference limitation, which can be fixed with a __future__ import.

from __future__ import annotations  # Supported as of 3.7, on by default beginning in 3.11

class my_class:
    def __add__(self, other: my_class) -> my_class:
        if isinstance(other, some_other_class):
            return other + self
        elif isinstance(other, my_class):
            return <special_adding_technique>
        return NotImplemented   # When you can't work with the other type, you're supposed
                                # to return the NotImplemented singleton, not raise
                                # NotImplementedError, where the latter is for completely
                                # unimplemented functionality, usually in an ABC

As a side-note, Python classes are the exception to the normal naming rule of lowercase or lowercase_with_underscores; classes use CapWords, so this class should be named MyClass to comply with PEP8.

Karl's answer is entirely right about everything, but there is certainly a way to make resize act as you're expecting.

Three steps:

1. Make a copy of the tree
2. Re-initialize the tree so it's the next size larger

3. Set the enlarged tree's left to the copy of the original tree

   def resize(self,n):
           while self.size < n:
               new = self.copy()
               self.__init__(int(round(self.size, 2)) * 2)
               self.left = new
   
           print("size in resize",self.size)
   
   def copy(self):
           new = tree(1)
           new.left = self.left
           new.right = self.right
           new.size = self.size
           new.free = self.free
           return new
   

Basically, you were trying to do it backwards -- replace self and reuse self for self.left, instead of replacing self.left and reusing self.

Try this:

class Plan(SiloBase):
    cost = DataField(int)
    start = DataField(System.DateTime)
    name = DataField(str)
    items = DataCollection(int)

Plan.subPlan = ReferenceField(Plan)

OR use __new__ like this:

class Plan(SiloBase):

    def __new__(cls, *args, **kwargs):
        cls.cost = DataField(int)
        cls.start = DataField(System.DateTime)
        cls.name = DataField(str)
        cls.items = DataCollection(int)
        cls.subPlan = ReferenceField(cls)
        return object.__new__(cls, *args, **kwargs)

This is actually a case for defining a metaclass.

I've never actually found a source of information which gives a complete, clear and satisfactory explanation as to what metaclasses are or how they work. I will try to enhance this answer with such information if required but for the time being I am going to stick to a solution for your present problem. I am assuming python 3.

Define an additional class, thus:

class ModelSerializerMeta(serializers.SerializerMetaclass):

    def __init__(cls, class_name, base_classes, attributes):

        super(ModelSerialiserMeta, cls).__init__(class_name, base_classes, attributes)
        Serializer.types[cls.Meta.oid] = [cls.Meta.model, cls]

Then use this as the metaclass of your Serializers, e.g.

class ProfileSerializer(serializers.ModelSerializer, metaclass=ModelSerializerMeta):

    class Meta:
        oid = 'profile'
        model = Profile
        fields = ['login', 'status']

Better yet, create some superclass for all your model serializers, assign the metaclass there, make all of your serializers inherit from that superclass which will then use the metaclass throughout.

class Point(object):
  ZERO = None
  def __init__(self, x, y):
    self.x = x
    self.y = y
Point.ZERO = Point(0,0)

ZERO in the class definition is not needed but I'm using it because my IDE is not able to find the class variable for code completion.

There is no generic way for a function to refer to itself. Consider using a decorator instead. If all you want as you indicated was to print information about the function that can be done easily with a decorator:

from functools import wraps
def showinfo(f):
    @wraps(f)
    def wrapper(*args, **kwds):
         print(f.__name__, f.__hash__)
         return f(*args, **kwds)
    return wrapper

@showinfo
def aa():
    pass

If you really do need to reference the function, then just add it to the function arguments:

def withself(f):
    @wraps(f)
    def wrapper(*args, **kwds):
        return f(f, *args, **kwds)
    return wrapper

@withself
def aa(self):
      print(self.__name__)
      # etc.

Edit to add alternate decorator:

You can also write a simpler (and probably faster) decorator that will make the wrapped function work correctly with Python's introspection:

def bind(f):
    """Decorate function `f` to pass a reference to the function
    as the first argument"""
    return f.__get__(f, type(f))

@bind
def foo(self, x):
    "This is a bound function!"
    print(self, x)


>>> foo(42)
<function foo at 0x02A46030> 42
>>> help(foo)
Help on method foo in module __main__:

foo(self, x) method of builtins.function instance
    This is a bound function!

This leverages Python's descriptor protocol: functions have a __get__ method that is used to create bound methods. The decorator simply uses the existing method to make the function a bound method of itself. It will only work for standalone functions, if you wanted a method to be able to reference itself you would have to do something more like the original solution.

If you want your method to access a class variable, you need to access it via the class name or via self. Either one should work:

class dli:
    switch = dlipower.PowerSwitch()
    # no need for an empty __init__ method
    def PowerOn(self, port):
        outlet = dlipower.Outlet(dli.switch)
        outlet.on(port)

Or:

class dli:
    switch = dlipower.PowerSwitch()
    def PowerOn(self, port):
        outlet = dlipower.Outlet(self.switch)
        outlet.on(port)

This still recreates the outlet every time you call PowerOn, but perhaps that's cheap...

You don't really need a class for this. The class variable switch is just a global variable tucked away in the class namespace. Since you don't have any other attributes (either class attributes or instance attributes), it might be simpler to just use an actual global instead:

# no dli class needed any more, just use top level variables and functions!

_switch = dlipower.PowerSwitch() # create a global PowerSwitch

def PowerOn(port):
    outlet = dlipower.Outlet(_switch)
    outlet.on(port)

I've used a name with an underscore for the global variable. That tells any other programmers looking at the code that it is an internal implementation detail, not part of your module's API. It's not "private" in the way some other programming languages mean (where the compiler prevents other code from accessing it), but it's Python's version of being private (where other code is discouraged, but not prevented from accessing internal stuff).

Speaking of naming conventions, you might want to change yours. The most common convention for Python code is to use CaptializedNames only for classes, and lower_case_names_with_underscores for most other things (functions, variables, etc.). Using a different convention isn't wrong per se, but it may make it more difficult for others to read your code.

This is not possible, since everything you define in a class becomes a valid member only in an instance of that class, unless you define a method with @staticmethod, but there is no such property for a class.

So, this won't work either:

class Foo(object):
    x = 10

    class A(object):
        pass

    class B(object):
        other = x

This will work, but it is not what you intended:

class Foo(object):
  x = 10

  class A(object):
    pass

  class B(object):
    def __init__(self):
        self.other = Foo.A

f = Foo()
print(f.B().other)

The output is:

<class '__main__.Foo.A'>

The reason this works is that the methods (in this case __init__) are evaluated when the object is created, while assignment before the __init__ are evaluated while the class is read and interpreted.

You can get about the same thing you want by simply define all the classes inside a module of their own. The importing the module, makes it an object whose fields are the classes you define in it.

self can only be used inside class methods which define it as a parameter.

In this case, you need to treat the method as an unbound method (without giving the value for self), because Django itself will pass in the instance as the first parameter:

class Photo(models.Model):
    def upload_path(self, filename):
        ....

    photo = models.ImageField(upload_to=upload_path)

Note that because you are using upload_path inside the class definition itself, the usage must come after the definition of upload_path.

Edit:

According to this bug report, there is a limitation in Django's migration system on Python 2.x, which will cause it not to work with the above code, even though the code itself is correct. You will have to put the function outside the class in order to use migrations.

The documentation states:

If you are using Python 2, we recommend you move your methods for upload_to and similar arguments that accept callables (e.g. default) to live in the main module body, rather than the class body.