__Init__ và tự làm gì trên Python?

Tôi đang học ngôn ngữ lập trình Python và tôi đã bắt gặp một thứ mà tôi không hiểu hết.

Trong một phương thức như:

def method(self, blah):
    def __init__(?):
        ....
    ....

Không gì selflàm gì? Nó có nghĩa là gì? Có bắt buộc không?

Không những gì __init__phương pháp làm gì? Tại sao cần thiết? (Vân vân.)

Tôi nghĩ rằng chúng có thể là cấu trúc OOP, nhưng tôi không biết nhiều lắm.

Trong mã này:

class A(object):
    def __init__(self):
        self.x = 'Hello'

    def method_a(self, foo):
        print self.x + ' ' + foo

... selfbiến đại diện cho thể hiện của chính đối tượng. Hầu hết các ngôn ngữ hướng đối tượng chuyển điều này như một tham số ẩn cho các phương thức được xác định trên một đối tượng; Python thì không. Bạn phải khai báo rõ ràng. Khi bạn tạo một thể hiện của Alớp và gọi các phương thức của nó, nó sẽ được truyền tự động, như trong ...

a = A()               # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument

Các __init__phương pháp là khoảng những gì đại diện cho một nhà xây dựng bằng Python. Khi bạn gọi A()Python tạo một đối tượng cho bạn và truyền nó làm tham số đầu tiên cho __init__phương thức. Bất kỳ tham số bổ sung nào (ví dụ A(24, 'Hello'):) cũng sẽ được chuyển qua làm đối số - trong trường hợp này gây ra ngoại lệ được nêu ra, vì hàm tạo không mong đợi chúng.

Đúng, bạn đã đúng, đây là những cấu trúc oop.

__init__là người xây dựng cho một lớp. Các selfthông số liên quan đến trường hợp của đối tượng (như thistrong C ++).

class Point:
    def __init__(self, x, y):
        self._x = x
        self._y = y

Các __init__ phương pháp được gọi khi bộ nhớ cho các đối tượng được phân bổ:

x = Point(1,2)

Điều quan trọng là sử dụng self tham số bên trong phương thức của đối tượng nếu bạn muốn duy trì giá trị với đối tượng. Ví dụ, nếu bạn triển khai __init__phương thức như thế này:

class Point:
    def __init__(self, x, y):
        _x = x
        _y = y

Các tham số xvà của bạn ysẽ được lưu trữ trong các biến trên ngăn xếp và sẽ bị loại bỏ khi phương thức init vượt quá phạm vi. Đặt các biến đó thành self._xvà self._yđặt các biến đó là thành viên của Pointđối tượng (có thể truy cập trong suốt vòng đời của đối tượng).

Một ví dụ minh họa ngắn gọn

Với hy vọng nó có thể giúp ích được một chút, đây là một ví dụ đơn giản mà tôi đã sử dụng để hiểu sự khác biệt giữa một biến được khai báo bên trong một lớp và một biến được khai báo bên trong một __init__hàm:

class MyClass(object):
    i = 123
    def __init__(self):
        self.i = 345

a = MyClass()
print(a.i)
print(MyClass.i)

Đầu ra:

345
123

Nói ngắn gọn:

1. selfnhư nó gợi ý, đề cập đến chính nó - đối tượng được gọi là phương thức. Nghĩa là, nếu bạn có N đối tượng gọi phương thức, thì self.asẽ tham chiếu đến một thể hiện riêng của biến cho mỗi đối tượng N. Tưởng tượng N bản sao của biến acho từng đối tượng
2. __init__là những gì được gọi là hàm tạo trong các ngôn ngữ OOP khác như C ++ / Java. Ý tưởng cơ bản là nó là một phương thức đặc biệt được gọi tự động khi một đối tượng của Class đó được tạo

__init__không hoạt động như một nhà xây dựng. Bạn sẽ cần truyền "bản thân" cho bất kỳ hàm lớp nào làm đối số đầu tiên nếu bạn muốn chúng hoạt động như các phương thức không tĩnh. "Tự" là các biến đối tượng cho lớp của bạn.

Hãy thử mã này. Hy vọng nó sẽ giúp nhiều lập trình viên C như tôi học Py.

#! /usr/bin/python2

class Person:

    '''Doc - Inside Class '''

    def __init__(self, name):
        '''Doc - __init__ Constructor'''
        self.n_name = name        

    def show(self, n1, n2):
        '''Doc - Inside Show'''
        print self.n_name
        print 'Sum = ', (n1 + n2)

    def __del__(self):
        print 'Destructor Deleting object - ', self.n_name

p=Person('Jay')
p.show(2, 3)
print p.__doc__
print p.__init__.__doc__
print p.show.__doc__

Đầu ra:

Jay

Sum = 5

Doc - Inside Class

Doc - __init__ Constructor

Doc - Inside Show

Destructor Deleting object - Jay

Các đối tượng lớp hỗ trợ hai loại hoạt động: tham chiếu thuộc tính và khởi tạo

Tham chiếu thuộc tính sử dụng cú pháp tiêu chuẩn được sử dụng cho tất cả các tham chiếu thuộc tính trong Python: obj.name. Tên thuộc tính hợp lệ là tất cả các tên trong không gian tên của lớp khi đối tượng lớp được tạo. Vì vậy, nếu định nghĩa lớp trông như thế này:

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

sau đó MyClass.ivà MyClass.flà các tham chiếu thuộc tính hợp lệ, trả về một số nguyên và một đối tượng hàm, tương ứng. Các thuộc tính lớp cũng có thể được gán cho, vì vậy bạn có thể thay đổi giá trị của MyClass.iphép gán. __doc__cũng là một thuộc tính hợp lệ, trả về chuỗi doc thuộc về lớp: "Một lớp ví dụ đơn giản".

Lớp khởi tạo sử dụng ký hiệu hàm. Chỉ cần giả vờ rằng đối tượng lớp là một hàm không tham số trả về một thể hiện mới của lớp. Ví dụ:

x = MyClass()

Các instantiation hoạt động ( “kêu gọi” một đối tượng lớp) tạo ra một đối tượng rỗng. Nhiều lớp muốn tạo các đối tượng với các thể hiện được tùy chỉnh theo trạng thái ban đầu cụ thể. Do đó, một lớp có thể định nghĩa một phương thức đặc biệt có tên __init__(), như thế này:

def __init__(self):
    self.data = []

Khi một lớp định nghĩa một __init__()phương thức, việc khởi tạo lớp sẽ tự động gọi ra __init__()đối tượng lớp mới được tạo. Vì vậy, trong ví dụ này, một thể hiện mới, khởi tạo có thể thu được bằng cách:

x = MyClass()

Tất nhiên, __init__()phương pháp có thể có các đối số để linh hoạt hơn. Trong trường hợp đó, các đối số được cung cấp cho toán tử khởi tạo lớp được truyền vào __init__(). Ví dụ,

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

Lấy từ tài liệu chính thức giúp tôi nhiều nhất cuối cùng.

Đây là ví dụ của tôi

class Bill():
    def __init__(self,apples,figs,dates):
        self.apples = apples
        self.figs = figs
        self.dates = dates
        self.bill = apples + figs + dates
        print ("Buy",self.apples,"apples", self.figs,"figs 
                and",self.dates,"dates. 
                Total fruitty bill is",self.bill," pieces of fruit :)")

Khi bạn tạo cá thể của lớp Bill:

purchase = Bill(5,6,7)

Bạn lấy:

> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18  pieces of
> fruit :)

Có vấn đề với bản thân mình. Ngay cả sau khi đọc câu trả lời ở đây.

Để hiểu đúng __init__phương pháp bạn cần hiểu bản thân.

Thông số tự

Các đối số được __init__phương thức chấp nhận là:

def __init__(self, arg1, arg2):

Nhưng chúng tôi chỉ thực sự vượt qua nó hai đối số:

instance = OurClass('arg1', 'arg2')

Trường hợp có thêm đối số đến từ đâu?

Khi chúng ta truy cập các thuộc tính của một đối tượng, chúng ta thực hiện nó theo tên (hoặc bằng cách tham chiếu). Ở đây ví dụ là một tham chiếu đến đối tượng mới của chúng tôi. Chúng tôi truy cập phương thức printargs của đối tượng thể hiện bằng instance.printargs.

Để truy cập các thuộc tính đối tượng từ bên trong __init__phương thức, chúng ta cần một tham chiếu đến đối tượng.

Bất cứ khi nào một phương thức được gọi, một tham chiếu đến đối tượng chính được truyền làm đối số đầu tiên.Theo quy ước, bạn luôn gọi đối số đầu tiên này cho phương thức của mình.

Điều này có nghĩa là trong __init__phương pháp chúng ta có thể làm:

self.arg1 = arg1
self.arg2 = arg2

Ở đây chúng ta đang thiết lập các thuộc tính trên đối tượng. Bạn có thể xác minh điều này bằng cách làm như sau:

instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1

các giá trị như thế này được gọi là thuộc tính đối tượng. Ở đây __init__phương thức đặt các thuộc tính arg1 và arg2 của thể hiện.

nguồn: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method

lưu ý rằng selfthực sự có thể là bất kỳ định danh python hợp lệ. Ví dụ, chúng ta có thể dễ dàng viết, từ ví dụ của Chris B:

class A(object):
    def __init__(foo):
        foo.x = 'Hello'

    def method_a(bar, foo):
        print bar.x + ' ' + foo

và nó sẽ hoạt động chính xác như nhau. Tuy nhiên, nên sử dụng bản thân vì những người dùng python khác sẽ nhận ra nó dễ dàng hơn.

Về cơ bản, bạn cần sử dụng từ khóa 'tự' khi sử dụng một biến trong nhiều hàm trong cùng một lớp. Đối với init , nó được sử dụng để thiết lập các giá trị mặc định, không có chức năng nào khác trong lớp đó được gọi.

1. __init__về cơ bản là một hàm sẽ "khởi tạo" / "kích hoạt" các thuộc tính của lớp cho một đối tượng cụ thể, một khi được tạo và khớp với lớp tương ứng ..
2. self đại diện cho đối tượng đó sẽ kế thừa các tính chất đó.

'Cái tôi' là một tham chiếu đến thể hiện của lớp

class foo:
    def bar(self):
            print "hi"

Bây giờ chúng ta có thể tạo một thể hiện của foo và gọi phương thức trên nó, tham số tự được thêm bởi Python trong trường hợp này:

f = foo()
f.bar()

Nhưng nó cũng có thể được truyền vào nếu lệnh gọi phương thức không nằm trong ngữ cảnh của một thể hiện của lớp, mã bên dưới thực hiện điều tương tự

f = foo()
foo.bar(f)

Điều thú vị là tên biến 'tự' chỉ là một quy ước. Định nghĩa dưới đây sẽ hoạt động chính xác như nhau .. Đã nói rằng đó là quy ước rất mạnh nên luôn luôn phải tuân theo , nhưng nó nói lên điều gì đó về bản chất linh hoạt của ngôn ngữ

class foo:
    def bar(s):
            print "hi"

Chỉ là một bản demo cho câu hỏi.

class MyClass:

    def __init__(self):
        print('__init__ is the constructor for a class')

    def __del__(self):
        print('__del__ is the destructor for a class')

    def __enter__(self):
        print('__enter__ is for context manager')
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print('__exit__ is for context manager')

    def greeting(self):
        print('hello python')


if __name__ == '__main__':
    with MyClass() as mycls:
        mycls.greeting()

$ python3 class.objects_instantiation.py
__init__ is the constructor for a class
__enter__ is for context manager
hello python
__exit__ is for context manager
__del__ is the destructor for a class

Trong mã này:

class Cat:
    def __init__(self, name):
        self.name = name
    def info(self):
        print 'I am a cat and I am called', self.name

Ở đây __init__hoạt động như một hàm tạo cho lớp và khi một đối tượng được khởi tạo, hàm này được gọi. selfđại diện cho đối tượng khởi tạo.

c = Cat('Kitty')
c.info()

Kết quả của các tuyên bố trên sẽ như sau:

I am a cat and I am called Kitty

Không gì tự làm gì? Nó có nghĩa là gì? Có bắt buộc không?

Đối số đầu tiên của mọi phương thức lớp, bao gồm init, luôn là một tham chiếu đến thể hiện hiện tại của lớp . Theo quy ước, lập luận này luôn được đặt tên self. Trong phương thức init, selfđề cập đến đối tượng mới được tạo; trong các phương thức lớp khác, nó dùng để chỉ trường hợp có phương thức được gọi.

Python không ép buộc bạn sử dụng " tự ". Bạn có thể đặt cho nó bất kỳ tên nào bạn muốn. Nhưng hãy nhớ đối số đầu tiên trong một định nghĩa phương thức là một tham chiếu đến đối tượng . Python thêm selfđối số vào danh sách cho bạn; bạn không cần đưa nó vào khi bạn gọi các phương thức. nếu bạn không tự cung cấp phương thức init thì bạn sẽ gặp lỗi

TypeError: __init___() takes no arguments (1 given)

Không những gì init phương pháp làm gì? Tại sao cần thiết? (Vân vân.)

initlà viết tắt của khởi tạo. Nó là một hàm tạo được gọi khi bạn tạo một thể hiện của lớp và nó không cần thiết . Nhưng thông thường, chúng ta thực hành viết phương thức init để thiết lập trạng thái mặc định của đối tượng. Nếu ban đầu bạn không sẵn sàng đặt bất kỳ trạng thái nào của đối tượng thì bạn không cần phải viết phương thức này.

# Source: Class and Instance Variables
# https://docs.python.org/2/tutorial/classes.html#class-and-instance-variables

class MyClass(object):
    # class variable
    my_CLS_var = 10

    # sets "init'ial" state to objects/instances, use self argument
    def __init__(self):
        # self usage => instance variable (per object)
        self.my_OBJ_var = 15

        # also possible, class name is used => init class variable
        MyClass.my_CLS_var = 20


def run_example_func():
    # PRINTS    10    (class variable)
    print MyClass.my_CLS_var

    # executes __init__ for obj1 instance
    # NOTE: __init__ changes class variable above
    obj1 = MyClass()

    # PRINTS    15    (instance variable)
    print obj1.my_OBJ_var

    # PRINTS    20    (class variable, changed value)
    print MyClass.my_CLS_var


run_example_func()

Python __init__và selfhọ làm gì?

Làm gì self làm gì? Nó có nghĩa là gì? Có bắt buộc không?

Không những gì __init__phương pháp làm gì? Tại sao cần thiết? (Vân vân.)

Ví dụ đưa ra là không chính xác, vì vậy hãy để tôi tạo một ví dụ chính xác dựa trên nó:

class SomeObject(object):

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

    def method(self):
        return self.blah 

Khi chúng ta tạo một thể hiện của đối tượng, lệnh __init__được gọi để tùy chỉnh đối tượng sau khi nó được tạo. Đó là, khi chúng ta gọi SomeObjectvới 'blah'bên dưới (có thể là bất cứ điều gì), nó được chuyển đến __init__hàm dưới dạng đối số , blah:

an_object = SomeObject('blah')

Đối selfsố là ví dụ của SomeObjectđiều đó sẽ được gán cho an_object.

Sau đó, chúng ta có thể muốn gọi một phương thức trên đối tượng này:

an_object.method()

Thực hiện tra cứu chấm, đó là, an_object.method liên kết thể hiện với một thể hiện của hàm và phương thức (như đã gọi ở trên) bây giờ là một phương thức "bị ràng buộc" - có nghĩa là chúng ta không cần phải truyền rõ ràng thể hiện cho lệnh gọi phương thức .

Cuộc gọi phương thức lấy ví dụ bởi vì nó bị ràng buộc trong tra cứu chấm và khi được gọi, sau đó thực thi bất kỳ mã nào nó được lập trình để thực hiện.

Các selfđối số ngầm thông qua được gọi selftheo quy ước. Chúng tôi có thể sử dụng bất kỳ tên Python hợp pháp nào khác, nhưng bạn có thể sẽ bị xóa bởi các lập trình viên Python khác nếu bạn đổi nó thành tên khác.

__init__là một phương pháp đặc biệt, được ghi lại trong tài liệu datamodel của Python . Nó được gọi ngay sau khi thể hiện được tạo ra (thường là thông qua __new__- mặc dù __new__không bắt buộc trừ khi bạn đang phân lớp một kiểu dữ liệu bất biến).

Ở đây, anh chàng đã viết khá tốt và đơn giản: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-groupes-and-object-oriented-programming/

Đọc liên kết ở trên như một tài liệu tham khảo về điều này:

self? Vì vậy, những gì với tham số tự cho tất cả các phương pháp của khách hàng? Nó là gì? Tại sao, đó là ví dụ, tất nhiên! Nói cách khác, một phương thức như rút tiền xác định các hướng dẫn rút tiền từ tài khoản khách hàng trừu tượng. Gọi jeff.withdraw (100.0) đặt các hướng dẫn đó để sử dụng trên ví dụ jeff.

Vì vậy, khi chúng tôi nói def rút tiền (tự, số tiền):, chúng tôi đang nói, "đây là cách bạn rút tiền từ một đối tượng Khách hàng (chúng tôi sẽ gọi là tự) và một con số đô la (chúng tôi sẽ gọi số tiền). jeff.withdraw (100.0) là ví dụ của Khách hàng rút tiền đang được gọi. Đó không phải là cách viết tắt của Khách hàng rút tiền (jeff, 100.0), hoàn toàn hợp lệ (nếu không thường thấy) mã.

init self có thể có ý nghĩa đối với các phương thức khác, nhưng còn init thì sao? Khi chúng ta gọi init , chúng ta đang trong quá trình tạo một đối tượng, vậy làm sao có thể có một cái tôi? Python cho phép chúng ta mở rộng mô hình bản thân đến khi các đối tượng cũng được xây dựng, mặc dù nó không thực sự phù hợp. Chỉ cần tưởng tượng rằng jeff = Khách hàng ('Jeff Knupp', 1000.0) giống như gọi jeff = Khách hàng (jeff, 'Jeff Knupp', 1000.0); jeff được thông qua cũng tạo ra kết quả.

Đây là lý do tại sao khi chúng ta gọi init , chúng ta khởi tạo các đối tượng bằng cách nói những thứ như self.name = name. Hãy nhớ rằng, vì bản thân là ví dụ, điều này tương đương với việc nói jeff.name = name, giống như jeff.name = 'Jeff Knupp. Tương tự, self.balance = thăng bằng giống như jeff.balance = 1000.0. Sau hai dòng này, chúng tôi coi đối tượng Khách hàng là "khởi tạo" và sẵn sàng để sử dụng.

Hãy cẩn thận những gì bạn __init__

Sau khi init kết thúc, người gọi có thể cho rằng đối tượng đã sẵn sàng để sử dụng. Đó là, sau khi jeff = Khách hàng ('Jeff Knupp', 1000.0), chúng tôi có thể bắt đầu thực hiện gửi tiền và rút tiền cuộc gọi trên jeff; jeff là một đối tượng khởi tạo đầy đủ.