What does abstract mean in this context?

I need some help in understanding a python concept.

class TilePuzzleProblem(search.Problem):
""" This class is the class for the NxN - blanks tile puzzle problem """

    def __init__(self, N, blanks, initial, goal):
        """ Initialize """
        search.Problem.__init__(self, initial, goal)
        self.N = N
        self.blanks = blanks

    def successor(self, state):
        """ Generate the successors of the given state. Returns a list of (move, successor) pairs"""
        abstract

    def h(self, node):
        abstract

Currently the code hangs at the abstract part of the function h(...),开发者_运维百科 but I have no idea what abstract means, hence can not understand what the problem is.

This is a trick described here. There's not keyword abstract in Python, so, if you won't override this method in some subclass, it'll cause NotImplementedError.

An abstract method is one which a class doesn't implement, making it an abstract class; subclasses must override all abstract methods (i.e., provide concrete implementations) to be concrete classes, i.e., ones for which you can make instances. The normal way in Python to express "this method is abstract" is to have the method's body be raise NotImplementedError.

For more about the general concept, apart from its specifics in Python, see wikipedia.

So, formally, you need to subclass this and implement those two methods marked as "abstract". (Depending on your TA's hints, he or she may actually mean that you should replace the word "abstract" with a working body of code, but that would be quite a stretch with respect the normal meaning of "abstract" in OOP!-).

An abstract function is a function with no implementation. It's a placeholder, just there to fill out the class contract so that you know what methods subclass should provide. What you need to do here is create a descendant of TilePuzzleProblem and fill in your own implementation of h. If you want to run it as is, create a descendant and make your h do nothing.

Abstract means the class must be inherited. Abstract or "base" classes are there to provide a base type which you can extend through inheritance. You cannot instantiate an abstract class, only the classes that inherit it.

See this Wikipedia article for more information.

One reason you'd want to use an abstract base class is if you want to categorize or group your sub-types. For example, Car, Truck and Plane would all inherit from the Vehicle abstract base class. You can't just instantiate a "vehicle", you have to instantiate a car, truck or plane. Being abstract protects it from being instantiated.