__init__ Python语法

Question

I created a class for Food items. I'm wondering why in def __init__(self, type) there are two arguments but when I call Food('Meat') I only pass one argument. I assume this is because __init__ is special somehow?

class Food(object):

    def __init__(self, type):
        self.type = type

    def cook_food_item(self):
        if self.type == 'Meat':
            print 'Grill it!'
        elif self.type == 'Vegetable':
            print 'Boil it!'
        elif self.type == 'Dairy':
            print 'Churn it!'

hot_dog = Food('Meat')
hot_dog.cook_food_item()

Answer 1

__init__ is special indeed because it's a magic method , although that's not what makes it receive self as a first parameter. Being a class method does that. Every method receives self as a first argument, which is passed automatically by Python. I strongly recommend you read the Python basics, like classes , in this case.

Answer 2

All methods in a class pass the class instance as their first argument, including __init__ . This is true for the other method in your class as well: def cook_food_item(self) .

If you had another method that took an actual argument, you'd put that argument after self , leaving something like:

class Food(object):
    ...

    def eat_with(self, drink):
        print("Eating a " + self.type + " while drinking a " + drink)

>>> hot_dog = Food("hot dog")
>>> hot_dog.eat_with("coke")
Eating a hot dog while drinking a coke

Behind the scenes this is doing something kind of like

>>> hot_dog.eat_with("coke")
# becomes something resembling
hot_dog.__class__.eat_with(hot_dog, "coke") # hot_dog.__class__ is Food

Answer 3

There's nothing special about __init__ here.

In Python, you have two kinds of methods: bound and unbound. Methods defined in a class are usually bound, which let you write myobj.mymethod() instead of MyClass.mymethod(myobj) . Unbound methods have no self argument and act just like regular functions.

To illustrate the point, you can create an unbound method like this:

def myfunction(x):
    return x

class MyClass(object):
    def __init__(self):
        self.unbound = myfunction

    def bound(self, x):
        print('MyClass.bound called with', self)
        return x

myobj = MyClass()
print(myobj.unbound(42))
print(myobj.bound(42))

Note that myfunction (and therefore myobj.unbound ) have no access to self unless you explicitly pass it in. So in general, bound methods like MyClass.bound are the tool of choice when writing classes. __init__ is no different. It wouldn't be very useful as an unbound method.