Hướng dẫn what is the difference between properties and methods in python? - sự khác biệt giữa thuộc tính và phương thức trong python là gì?

11.1. Giới thiệu¶

Trong chương này, chúng tôi sẽ hiểu việc sử dụng ‘phương pháp,‘ @property, và ‘mô tả.

11.2. Phương pháp, StaticMethod và ClassMethod¶

Trong các chương trước, chúng tôi đã thấy các ví dụ về phương pháp, ví dụ: Khu vực, và ’chi phí trong danh sách 10.1, bên trong lớp mà không có người trang trí nào với họ. Các nhà trang trí, thêm các chức năng bổ sung cho các phương pháp và sẽ được thảo luận chi tiết trong Chương 12.Listing 10.1, inside the class without any decorator with them. The ‘decorators’ adds the additional functionality to the methods, and will be discussed in details in Chapter 12.

Trong phần này, chúng tôi sẽ nhanh chóng xem xét các loại phương thức khác nhau với một ví dụ. Sau đó, các phương pháp này sẽ được sử dụng với các ví dụ trước đây của chúng tôi.

Trong mã dưới đây, hai nhà trang trí được sử dụng với các phương thức bên trong lớp, tức là ‘staticmethod, và‘ classmethod. Vui lòng xem nhận xét và thông báo: Làm thế nào để các phương thức khác nhau sử dụng các giá trị khác nhau của x để thêm hai số,

Ghi chú

Chúng ta có thể quan sát những khác biệt sau trong ba phương pháp này từ mã dưới đây,

• Phương thức: Nó sử dụng biến thể hiện (self.x) để bổ sung, được đặt bởi hàm __init__. : it uses the instance variable (self.x) for addition, which is set by __init__ function.
• ClassMethod: Nó sử dụng biến lớp để bổ sung. : it uses class variable for addition.
• StaticMethod: Nó sử dụng giá trị của X được xác định trong chương trình chính (nghĩa là bên ngoài lớp). Nếu x = 20 không được xác định, thì nameerror sẽ được tạo. : it uses the value of x which is defined in main program (i.e. outside the class ). If x = 20 is not defined, then NameError will be generated.

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

Dưới đây là đầu ra cho mã trên,

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

11.3. Tổ chức nghiên cứu %

Trong chương trước, chúng tôi đã có hai người dùng đang sửa đổi các thuộc tính lớp. Đầu tiên là nhà toán học (nhà toán học.py), người đang sửa đổi ‘bán kính trong danh sách 10.4. Và khác là công ty hộp, người đang sửa đổi phương pháp ‘chu vi trong danh sách 10,5. Cuối cùng, chúng tôi đã có một người đóng góp, người đang tạo ra một formatter ’bảng trong danh sách 10.9 để hiển thị đầu ra một cách độc đáo.Listing 10.4. And other is the box company, who were modifying the method ‘perimeter’ in Listing 10.5. Lastly, we had a contributor who is creating a ‘table formatter’ in Listing 10.9 for displaying the output nicely.

Bây giờ, chúng tôi có một tổ chức nghiên cứu khác, những người đang thực hiện phân tích nghiên cứu của họ dựa trên đường kính (không sử dụng bán kính), do đó họ muốn khởi tạo các đối tượng lớp dựa trên đường kính trực tiếp.

Ghi chú

Chúng ta có thể quan sát những khác biệt sau trong ba phương pháp này từ mã dưới đây,

Phương thức: Nó sử dụng biến thể hiện (self.x) để bổ sung, được đặt bởi hàm __init__.

ClassMethod: Nó sử dụng biến lớp để bổ sung.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# pythonic.py

import math
import time

class Ring(object):
    """ Here we will see the actual logic behind various pieces of Python
    language e.g. instances, variables, method and @property etc.
    Also, we will see the combine usage of these pieces to complete a
    design with Agile methodology.
    """

    # class variables
    date = time.strftime("%Y-%m-%d", time.gmtime()) # today's date "YYYY-mm-dd"
    center = 0.0 # center of the ring

    def __init__(self, date=date, metal="Copper", radius=5.0,
                price=5.0, quantity=5):
        """ init is not the constructor, but the initializer which
        initialize the instance variable

        self : is the instance

        __init__ takes the instance 'self' and populates it with the radius,
        metal, date etc. and store in a dictionary.

        self.radius, self.metal etc. are the instance variable which
        must be unique.
        """

        self.date = date
        self.metal = metal
        self.radius = radius
        self.price = price
        self.quantity = quantity


    # Multiple constructor
    # below constructor is added for the 'research organization' who are
    # doing their work based on diameters,
    @classmethod
    def diameter_init(cls, diameter):
        radius = diameter/2;  # change diameter to radius
        return cls(radius) # return radius

    def cost(self):
        return self.price * self.quantity

    def area(self):
        return math.pi * self.radius**2

    def perimeter(self):
        return 2 * math.pi * self.radius

def main():
    print("Center of the Ring is at:", Ring.center) # modify class variable
    r = Ring(price=8) # modify only price
    print("Radius:{0}, Cost:{1}".format(r.radius, r.cost()))
    print("Radius:{0}, Perimeter:{1:0.2f}".format(r.radius, r.perimeter()))

    print() # check the new constructor 'diameter_init'
    d = Ring.diameter_init(diameter=10)
    print("Radius:{0}, Perimeter:{1:0.2f}".format(d.radius, d.perimeter()))


if __name__ == '__main__':
    main()

StaticMethod: Nó sử dụng giá trị của X được xác định trong chương trình chính (nghĩa là bên ngoài lớp). Nếu x = 20 không được xác định, thì nameerror sẽ được tạo.

$ python pythonic.py

Center of the Ring is at: 0.0
Radius:5.0, Cost:40
Radius:5.0, Perimeter:31.42

Radius:5.0, Perimeter:31.42

Dưới đây là đầu ra cho mã trên,

11.3. Tổ chức nghiên cứu %

Ghi chú

Chúng ta có thể quan sát những khác biệt sau trong ba phương pháp này từ mã dưới đây,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# pythonic.py

import math
import time

class Ring(object):
    """ Here we will see the actual logic behind various pieces of Python
    language e.g. instances, variables, method and @property etc.
    Also, we will see the combine usage of these pieces to complete a
    design with Agile methodology.
    """

    # class variables
    date = time.strftime("%Y-%m-%d", time.gmtime()) # today's date "YYYY-mm-dd"
    center = 0.0 # center of the ring

    def __init__(self, date=date, metal="Copper", radius=5.0,
                price=5.0, quantity=5):
        """ init is not the constructor, but the initializer which
        initialize the instance variable

        self : is the instance

        __init__ takes the instance 'self' and populates it with the radius,
        metal, date etc. and store in a dictionary.

        self.radius, self.metal etc. are the instance variable which
        must be unique.
        """

        self.date = date
        self.metal = metal
        self.radius = radius
        self.price = price
        self.quantity = quantity


    # Multiple constructor
    # below constructor is added for the 'research organization' who are
    # doing their work based on diameters,
    @classmethod
    def diameter_init(cls, diameter):
        radius = diameter/2;  # change diameter to radius
        return cls(radius) # return radius

    @staticmethod  # meter to centimeter conversion
    def meter_cm(meter):
        return(100*meter)


    def cost(self):
        return self.price * self.quantity

    def area(self):
        return math.pi * self.radius**2

    def perimeter(self):
        return 2 * math.pi * self.radius

def main():
    print("Center of the Ring is at:", Ring.center) # modify class variable
    r = Ring(price=8) # modify only price
    print("Radius:{0}, Cost:{1}".format(r.radius, r.cost()))
    print("Radius:{0}, Perimeter:{1:0.2f}".format(r.radius, r.perimeter()))

    print() # check the new constructor 'diameter_init'
    d = Ring.diameter_init(diameter=10)
    print("Radius:{0}, Perimeter:{1:0.2f}".format(d.radius, d.perimeter()))
    m = 10 # 10 meter
    print("{0} meter = {1} centimeter".format(m, d.meter_cm(m)))

if __name__ == '__main__':
    main()

Sau đây là đầu ra của mã trên,

$ python pythonic.py
Center of the Ring is at: 0.0
Radius:5.0, Cost:40
Radius:5.0, Perimeter:31.42

Radius:5.0, Perimeter:31.42
10 meter = 1000 centimeter

11.4. Quản lý vi mô Or

Quản lý vi mô là phương pháp, trong đó khách hàng cho chúng ta biết các cách thực hiện logic. Hãy hiểu nó bằng một ví dụ.

Ghi chú

Bây giờ, tổ chức nghiên cứu muốn rằng ’khu vực nên được tính toán dựa trên‘ chu vi. Cụ thể hơn, họ sẽ cung cấp ‘đường kính, sau đó chúng ta cần tính toán‘ chu vi; Sau đó dựa trên ‘chu vi, tính toán‘ bán kính. Và cuối cùng tính toán ’khu vực dựa trên bán kính mới này. Điều này có thể trông ngớ ngẩn, nhưng nếu chúng ta nhìn kỹ, bán kính sẽ thay đổi một chút trong quá trình chuyển đổi này; Vì sẽ có một số khác biệt giữa (đường kính/2) và (Math.pi*Đường kính)/(2*math.pi). Lý do cho sự khác biệt là: Trên máy tính, chúng tôi không hủy Math.pi ở Tân với Math.Pi tại mẫu số, nhưng giải quyết tử số trước và sau đó chia cho mẫu số và do đó nhận được một số lỗi làm tròn.

11.4.1. Giải pháp sai

Giải pháp cho vấn đề này có thể trông khá đơn giản, tức là sửa đổi phương thức ’khu vực theo cách sau,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

• Nếu chúng tôi chạy mã trên, chúng tôi sẽ có kết quả sau, điều này hoàn toàn đúng.

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

Lỗi

Giải pháp trên trông khá đơn giản, nhưng nó sẽ phá vỡ mã trong ‘Box.py trong danh sách 10.5, vì nó đang sửa đổi chu vi bằng hệ số 2.0 bằng cách ghi đè phương pháp chu vi. Do đó, để tính toán khu vực trong tệp Box.py, Python phiên dịch sẽ sử dụng phương pháp lớp con ‘chu vi để nhận giá trị của chu vi. Do đó, khu vực sẽ được tính toán dựa trên tham số đã sửa đổi, không dựa trên tham số thực tế.Listing 10.5’, as it is modifying the perimeter by a factor of 2.0 by overriding the perimeter method. Therefore, for calculating the area in box.py file, python interpretor will use the child class method ‘perimeter’ for getting the value of perimeter. Hence, the area will be calculated based on the ‘modified parameter’, not based on actual parameter.

• Trong Box.py, khu vực sẽ được tính toán sai, bởi vì nó đang sửa đổi chu vi cho việc sử dụng của chúng. Bây giờ, bán kính sẽ được tính bằng chu vi mới (vì chúng ghi đè phương pháp chu vi) và cuối cùng diện tích sẽ được sửa đổi do thay đổi giá trị bán kính, như được hiển thị bên dưới,

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

11.4.2. Giải pháp chính xác

Ghi chú

Bây giờ, tổ chức nghiên cứu muốn rằng ’khu vực nên được tính toán dựa trên‘ chu vi. Cụ thể hơn, họ sẽ cung cấp ‘đường kính, sau đó chúng ta cần tính toán‘ chu vi; Sau đó dựa trên ‘chu vi, tính toán‘ bán kính. Và cuối cùng tính toán ’khu vực dựa trên bán kính mới này. Điều này có thể trông ngớ ngẩn, nhưng nếu chúng ta nhìn kỹ, bán kính sẽ thay đổi một chút trong quá trình chuyển đổi này; Vì sẽ có một số khác biệt giữa (đường kính/2) và (Math.pi*Đường kính)/(2*math.pi). Lý do cho sự khác biệt là: Trên máy tính, chúng tôi không hủy Math.pi ở Tân với Math.Pi tại mẫu số, nhưng giải quyết tử số trước và sau đó chia cho mẫu số và do đó nhận được một số lỗi làm tròn.

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

11.4.1. Giải pháp sai

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

Giải pháp cho vấn đề này có thể trông khá đơn giản, tức là sửa đổi phương thức ’khu vực theo cách sau,

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

Nếu chúng tôi chạy mã trên, chúng tôi sẽ có kết quả sau, điều này hoàn toàn đúng.

LỗiSection 10.7, we saw that there is no concept of data-hiding in Python; and the attributes can be directly accessed by the the clients.

Ghi chú

Bây giờ, tổ chức nghiên cứu muốn rằng ’khu vực nên được tính toán dựa trên‘ chu vi. Cụ thể hơn, họ sẽ cung cấp ‘đường kính, sau đó chúng ta cần tính toán‘ chu vi; Sau đó dựa trên ‘chu vi, tính toán‘ bán kính. Và cuối cùng tính toán ’khu vực dựa trên bán kính mới này. Điều này có thể trông ngớ ngẩn, nhưng nếu chúng ta nhìn kỹ, bán kính sẽ thay đổi một chút trong quá trình chuyển đổi này; Vì sẽ có một số khác biệt giữa (đường kính/2) và (Math.pi*Đường kính)/(2*math.pi). Lý do cho sự khác biệt là: Trên máy tính, chúng tôi không hủy Math.pi ở Tân với Math.Pi tại mẫu số, nhưng giải quyết tử số trước và sau đó chia cho mẫu số và do đó nhận được một số lỗi làm tròn.

11.4.1. Giải pháp sai

Giải pháp cho vấn đề này có thể trông khá đơn giản, tức là sửa đổi phương thức ’khu vực theo cách sau,

Nếu chúng tôi chạy mã trên, chúng tôi sẽ có kết quả sau, điều này hoàn toàn đúng.

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

Lỗi

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

Giải pháp trên trông khá đơn giản, nhưng nó sẽ phá vỡ mã trong ‘Box.py trong danh sách 10.5, vì nó đang sửa đổi chu vi bằng hệ số 2.0 bằng cách ghi đè phương pháp chu vi. Do đó, để tính toán khu vực trong tệp Box.py, Python phiên dịch sẽ sử dụng phương pháp lớp con ‘chu vi để nhận giá trị của chu vi. Do đó, khu vực sẽ được tính toán dựa trên tham số đã sửa đổi, không dựa trên tham số thực tế.

Trong Box.py, khu vực sẽ được tính toán sai, bởi vì nó đang sửa đổi chu vi cho việc sử dụng của chúng. Bây giờ, bán kính sẽ được tính bằng chu vi mới (vì chúng ghi đè phương pháp chu vi) và cuối cùng diện tích sẽ được sửa đổi do thay đổi giá trị bán kính, như được hiển thị bên dưới,

• 11.4.2. Giải pháp chính xác

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

• Vấn đề trên có thể được giải quyết bằng cách tạo một bản sao chu vi cục bộ trong lớp. Theo cách này, phương pháp lớp con không thể ghi đè lên bản sao cục bộ của phương thức lớp cha. Đối với điều này, chúng tôi cần sửa đổi mã như dưới đây,

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

Dưới đây là kết quả cho danh sách trên,

Bây giờ, chúng tôi cũng sẽ nhận được kết quả chính xác cho ‘hộp.py, như được hiển thị bên dưới,

11,5. Các thuộc tính riêng tư không phải để tư nhân hóa các thuộc tính

• Trong Phần 10.7, chúng tôi đã thấy rằng không có khái niệm nào về việc ẩn dữ liệu trong Python; và các thuộc tính có thể được truy cập trực tiếp bởi các máy khách.

# mehodsEx.py

# below x will be used by static method
# if we do not define it, the staticmethod will generate error.
x = 20

class Add(object):
    x = 9  # class variable

    def __init__(self, x):
        self.x = x  # instance variable

    def addMethod(self, y):
        print("method:", self.x + y)

    @classmethod
    # as convention, cls must be used for classmethod, instead of self
    def addClass(self, y):
        print("classmethod:", self.x + y)

    @staticmethod
    def addStatic(y):
        print("staticmethod:", x + y)



def main():
    # method
    m  = Add(x=4) # or m = Add(4)
    # for method, above x = 4, will be used for addition
    m.addMethod(10)  # method :  14

    # classmethod
    c = Add(4)
    # for class method, class variable x = 9, will be used for addition
    c.addClass(10)  # clasmethod : 19

    # for static method, x=20 (at the top of file), will be used for addition
    s = Add(4)
    s.addStatic(10)  # staticmethod : 30

if __name__ == '__main__':
    main()

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

Ghi chú

Có một quan niệm sai lầm rằng dấu gạch dưới kép (‘__,) được sử dụng để ẩn dữ liệu trong Python. Trong phần này, chúng ta sẽ thấy cách sử dụng chính xác của ‘__, trong Python.

11.6. @tài sản¶

Bây giờ, chúng ta sẽ thấy việc sử dụng @Property trong Python.

11.6.1. Quản lý các thuộc tính

Hiện tại, chúng tôi không kiểm tra các loại đầu vào chính xác trong thiết kế của chúng tôi. Hãy cùng xem lại tệp ‘Pythonic.py của chúng tôi.

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

Lưu ý rằng trong mã trên, chuỗi được lưu trong bán kính; và phép nhân được thực hiện trên chuỗi. Chúng tôi không muốn hành vi này, do đó chúng tôi cần thực hiện một số kiểm tra trước khi lưu dữ liệu trong từ điển, có thể được thực hiện bằng cách sử dụng @Property, như được hiển thị bên dưới,

Quan trọng

• @Property Decorator cho phép. toán tử để gọi chức năng. Ở đây, self.radius sẽ gọi bán kính phương thức, trả về self._radius. Do đó, _radius được lưu trữ trong từ điển thay vì dict.
• Nếu chúng ta sử dụng 'return self.radius' thay vì 'return self._radius', thì @property sẽ dẫn đến vòng lặp vô hạn vì self.property sẽ gọi phương thức tài sản, sẽ trả về self. tài sản một lần nữa.
• Hơn nữa, chúng ta có thể sử dụng @Property để kiểm tra loại, xác thực hoặc thực hiện các hoạt động khác nhau bằng cách viết mã trong phương thức setter, ví dụ: Thay đổi ngày thành ngày ngày nay, v.v.

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

• Dưới đây là kết quả cho mã trên,

$ python methodEx.py

method: 14
classmethod: 19
staticmethod: 30

• Dưới đây là từ điển của đối tượng ’R, mã. Lưu ý rằng, ‘bán kính không còn tồn tại ở đó nữa, nhưng điều này sẽ không phá vỡ mã của người dùng khác, vì lý do sau đây.

Ghi chú

@Property được sử dụng để chuyển đổi quyền truy cập thuộc tính sang truy cập phương thức.

Nói cách khác, bán kính sẽ bị xóa khỏi danh sách biến thể hiện sau khi xác định ‘thuộc tính, như trong mã trên. Bây giờ, nó không thể được sử dụng nữa. Nhưng, công cụ trang trí @Property sẽ chuyển đổi quyền truy cập thuộc tính sang truy cập phương thức, tức là toán tử DOT cũng sẽ kiểm tra các phương thức với @Property. Theo cách này, mã của người dùng khác sẽ không bị phá vỡ.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

11.6.2. Phương thức gọi là thuộc tính

Nếu một phương thức được trang trí bằng @Property thì nó có thể được gọi là ‘thuộc tính sử dụng toán tử, nhưng sau đó nó không thể được gọi là thuộc tính, như trong ví dụ dưới đây, ví dụ,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

11.6.3. Yêu cầu từ Tổ chức nghiên cứu Jor

Bây giờ, chúng tôi nhận được một quy tắc khác từ tổ chức nghiên cứu như dưới đây,

• Chúng tôi không muốn lưu trữ Bán kính dưới dạng biến thể,
• thay vào đó chuyển đổi bán kính thành đường kính và lưu nó dưới dạng biến thể hiện trong từ điển.

Ghi chú

@Property được sử dụng để chuyển đổi quyền truy cập thuộc tính sang truy cập phương thức.

• Nói cách khác, bán kính sẽ bị xóa khỏi danh sách biến thể hiện sau khi xác định ‘thuộc tính, như trong mã trên. Bây giờ, nó không thể được sử dụng nữa. Nhưng, công cụ trang trí @Property sẽ chuyển đổi quyền truy cập thuộc tính sang truy cập phương thức, tức là toán tử DOT cũng sẽ kiểm tra các phương thức với @Property. Theo cách này, mã của người dùng khác sẽ không bị phá vỡ.
• 11.6.2. Phương thức gọi là thuộc tính

Nếu một phương thức được trang trí bằng @Property thì nó có thể được gọi là ‘thuộc tính sử dụng toán tử, nhưng sau đó nó không thể được gọi là thuộc tính, như trong ví dụ dưới đây, ví dụ,

11.6.3. Yêu cầu từ Tổ chức nghiên cứu Jor

Bây giờ, chúng tôi nhận được một quy tắc khác từ tổ chức nghiên cứu như dưới đây,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

• Chúng tôi không muốn lưu trữ Bán kính dưới dạng biến thể,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

• thay vào đó chuyển đổi bán kính thành đường kính và lưu nó dưới dạng biến thể hiện trong từ điển.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67