Почему мы используем init в классах Python?

внести свои 5 центов в подробное объяснение от Amadan.

где классы-это описание" типа " абстрактным образом. Объекты - это их реализации: живое дышащее существо. В объектно-ориентированном мире есть принципиальные идеи, которые можно почти назвать сущностью всего. Они таковы:

1. инкапсуляция (не будем уточнять это)
2. наследование
3. полиморфизм

объекты имеют одну или несколько характеристик (= атрибуты) и поведение (= методы). Поведение в основном зависит от характеристик. Классы определяют, что поведение должно выполнять в общем виде, но до тех пор, пока класс не будет реализован (создан) как объект, он остается абстрактным понятием возможности. Позвольте мне проиллюстрировать с помощью "наследования" и "полиморфизм."

    class Human:
        gender
        nationality
        favorite_drink
        core_characteristic
        favorite_beverage
        name
        age

        def love    
        def drink
        def laugh
        def do_your_special_thing                

    class Americans(Humans)
        def drink(beverage):
            if beverage != favorite_drink: print "You call that a drink?"
            else: print "Great!" 

    class French(Humans)
        def drink(beverage, cheese):
            if beverage == favourite_drink and cheese == None: print "No cheese?" 
            elif beverage != favourite_drink and cheese == None: print "Révolution!"

    class Brazilian(Humans)
        def do_your_special_thing
            win_every_football_world_cup()

    class Germans(Humans)
        def drink(beverage):
            if favorite_drink != beverage: print "I need more beer"
            else: print "Lecker!" 

    class HighSchoolStudent(Americans):
        def __init__(self, name, age):
             self.name = name
             self.age = age

jeff = HighSchoolStudent(name, age):
hans = Germans()
ronaldo = Brazilian()
amelie = French()

for friends in [jeff, hans, ronaldo]:
    friends.laugh()
    friends.drink("cola")
    friends.do_your_special_thing()

print amelie.love(jeff)
>>> True
print ronaldo.love(hans)
>>> False

некоторые характеристики определяют человека. Но каждая национальность отличается. Так что "национальные типы" - это своего рода люди с массовкой. "Американцы "-это тип "людей" и наследуют некоторые абстрактные характеристики и поведение от человеческого типа (базового класса) : это наследование. Таким образом, все люди могут смеяться и пить, поэтому все детские классы также могут! Наследование (2).

но потому что они все одного вида (тип / базовый класс: Люди) иногда вы можете обменять их: см. for-loop в конце. Но они будут выставлять индивидуальную характеристику, и это полиморфизм (3).

таким образом, у каждого человека есть любимый напиток, но каждая национальность склонна к особому виду напитка. Если вы подкласс национальности от типа людей вы можете перезаписать унаследованное поведение, как я продемонстрировал выше с drink() метод. Но это все еще на уровне класса, и из-за этого еще обобщение.

hans = German(favorite_drink = "Cola")

создает экземпляр класса German и я "изменил" характеристику по умолчанию в начале. (Но если вы позвоните Гансу.пейте ('молоко') он все равно напечатает "мне нужно больше пива" - очевидный баг ... или, может быть, это то, что я назвал бы особенностью, если бы я был сотрудником более крупной компании. ;-)! )

характеристика типа, например, немцы (hans) обычно определяются через конструктор (в python:__init__) в момент создания экземпляра. Это точка, где вы определяете класс, чтобы стать объектом. Можно сказать, вдохнуть жизнь в абстрактное понятие (класс), наполнив его индивидуальными характеристиками и став объектом.

но поскольку каждый объект является экземпляром класса, они делятся несколько основных признаков вида и поведения. Это главное преимущество объектно-ориентированной концепции.

для защиты характеристик каждого объекта вы инкапсулируете их-значит вы пытаетесь соединить поведение и характеристика и затрудняют манипулирование им извне объекта. Это инкапсуляция (1)

Это просто для инициализации переменных экземпляра.

например, создать crawler экземпляр с определенным именем базы данных (из примера выше).

следующие автомобиль пример: когда вы получаете автомобиль, вы просто не получаете случайный автомобиль, я имею в виду, вы выбираете цвет, бренд, количество мест и т. д. И некоторые вещи также "инициализируются" без вашего выбора, например, количество колес или регистрационный номер.

class Car:
    def __init__(self, color, brand, number_of_seats):
        self.color = color
        self.brand = brand
        self.number_of_seats = number_of_seats
        self.number_of_wheels = 4
        self.registration_number = GenerateRegistrationNumber()

так, в __init__ метод определения атрибутов экземпляра, который вы создаете. Итак, если мы хотим синий автомобиль Renault, для 2 человек, мы бы инициализировали или экземпляр Car например:

my_car = Car('blue', 'Renault', 2)

таким образом, мы создаем экземпляр Car класса. Элемент __init__ это тот, который обрабатывает наши конкретные атрибуты (например,color или brand) и его генерации других атрибутов, как registration_number.

• подробнее о классы в Python
• подробнее о __init__ метод

классы-это объекты с атрибутами (состояние, характеристика) и методами (функции, емкости), которые специфичны для этого объекта (например, белый цвет и сила полета, соответственно, для утки).

когда вы создаете экземпляр класса, вы можете дать ему первоначальные личности (государства или символ как имя и цвет ее платья для новорожденных). Вы делаете это с __init__.

в принципе __init__ устанавливает характеристики экземпляра автоматически, когда вы звоните instance = MyClass(some_individual_traits).

The __init__ функция настраивает все переменные-члены в классе. Поэтому, как только ваш bicluster будет создан, вы можете получить доступ к члену и получить значение обратно:

mycluster = bicluster(...actual values go here...)
mycluster.left # returns the value passed in as 'left'

Проверьте Python Docs для некоторых информация. Вы захотите взять книгу о концепциях OO, чтобы продолжить обучение.

похоже, вам нужно использовать __init__ в Python, если вы хотите правильно инициализировать изменяемых атрибутов экземпляров.

рассмотрим следующий пример:

>>> class EvilTest(object):
...     attr = []
... 
>>> evil_test1 = EvilTest()
>>> evil_test2 = EvilTest()
>>> evil_test1.attr.append('strange')
>>> 
>>> print "This is evil:", evil_test1.attr, evil_test2.attr
This is evil: ['strange'] ['strange']
>>> 
>>> 
>>> class GoodTest(object):
...     def __init__(self):
...         self.attr = []
... 
>>> good_test1 = GoodTest()
>>> good_test2 = GoodTest()
>>> good_test1.attr.append('strange')
>>> 
>>> print "This is good:", good_test1.attr, good_test2.attr
This is good: ['strange'] []

это совсем другое в Java, где каждый атрибут автоматически инициализируется с новым значением:

import java.util.ArrayList;
import java.lang.String;

class SimpleTest
{
    public ArrayList<String> attr = new ArrayList<String>();
}

class Main
{
    public static void main(String [] args)
    {
        SimpleTest t1 = new SimpleTest();
        SimpleTest t2 = new SimpleTest();

        t1.attr.add("strange");

        System.out.println(t1.attr + " " + t2.attr);
    }
}

выдает результат, который мы интуитивно ожидаем:

[strange] []

но если вы объявляете attr как static, он будет действовать как Python:

[strange] [strange]

class Dog(object):

    # Class Object Attribute
    species = 'mammal'

    def __init__(self,breed,name):
        self.breed = breed
        self.name = name

в приведенном выше примере мы используем вид как глобальный, так как он всегда будет одним и тем же(своего рода константа, которую вы можете сказать). когда вы звоните __init__ метод, то все переменные внутри __init__ будет инициирован(например:порода,имя).

class Dog(object):
    a = '12'

    def __init__(self,breed,name,a):
        self.breed = breed
        self.name = name
        self.a= a

если вы напечатаете приведенный выше пример, позвонив ниже, как это

Dog.a
12

Dog('Lab','Sam','10')
Dog.a
10

это означает, что он будет инициализирован только во время создания объекта. поэтому все, что вы хотите объявить постоянным, делает его глобальным и все, что меняется используйте __init__