Hướng dẫn python equivalent of matlab struct - python tương đương với cấu trúc matlab

Đối với một số ứng dụng,

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

7 hoặc danh sách từ điển sẽ đủ. Tuy nhiên, nếu bạn thực sự muốn mô phỏng MATLAB

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 trong Python, bạn phải tận dụng OOP của nó và tạo thành lớp giống như cấu trúc của riêng bạn.

Đây là một ví dụ đơn giản, ví dụ cho phép bạn lưu trữ một lượng biến tùy ý làm thuộc tính và cũng có thể được khởi tạo dưới dạng trống (chỉ Python 3.x).

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

9 là trình chỉ mục hiển thị có bao nhiêu thuộc tính được lưu trữ bên trong đối tượng:

class Struct:
    def __init__(self, *args, prefix='arg'): # constructor
        self.prefix = prefix
        if len(args) == 0:
            self.i = 0
        else:
            i=0
            for arg in args:
                i+=1
                arg_str = prefix + str(i)
                # store arguments as attributes
                setattr(self, arg_str, arg) #self.arg1 = 
            self.i = i
    def add(self, arg):
        self.i += 1
        arg_str = self.prefix + str(self.i)
        setattr(self, arg_str, arg)

Bạn có thể khởi tạo trống (i = 0) hoặc điền vào các thuộc tính ban đầu. Sau đó, bạn có thể thêm các thuộc tính theo ý muốn. Thử như sau:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

sẽ giúp bạn có những kết quả này cho đối tượng B:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

Và đối với đối tượng C:

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

Lưu ý rằng việc gán các thuộc tính cho các đối tượng là chung - không chỉ giới hạn ở các đối tượng ____ 30/________ 31 mà áp dụng cho tất cả các loại dữ liệu và đối tượng tùy chỉnh (mảng, dataFrames, v.v.). Tất nhiên đó là một mô hình đồ chơi - bạn có thể phát triển hơn nữa để làm cho nó có thể được lập chỉ mục, có thể được in khá đẹp, có thể loại bỏ các yếu tố, có thể gọi, v.v., dựa trên nhu cầu dự án của bạn. Chỉ cần xác định lớp ở đầu và sau đó sử dụng nó để lưu trữ theo hình ảnh. Đó là vẻ đẹp của Python - nó không thực sự có chính xác những gì bạn tìm kiếm đặc biệt là nếu bạn đến từ Matlab, nhưng nó có thể làm được nhiều hơn nữa!

Cấu trúc trong Matlab/Octave và Python

Các cấu trúc có sẵn trong các ngôn ngữ khác nhau, như C, C ++, C# và MATLAB và chúng chủ yếu được sử dụng để tổ chức dữ liệu dưới dạng các loại tổng hợp, chứa một tập hợp các trường xác định. Trong cấu trúc C, C ++ và C#, được xác định là các loại dữ liệu mới và sau đó các biến mới của loại đó được khai báo. Trong C ++ và C#, các cấu trúc là các lớp và chúng cũng có thể bao gồm các phương thức và thành viên riêng. Ngược lại, cấu trúc MATLAB là một loại dữ liệu chung để tổ chức và nhóm một số trường thuộc nhiều loại khác nhau, thậm chí thuộc loại cấu trúc.

Trong Python, có một số cách để có chức năng như cấu trúc:

1. Sử dụng

   {'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}
   
   [1, 5]
   5
   

   7 (xem tại đây), loại từ điển tích hợp trong Python, thực sự là một mảng các mục giá trị quan trọng;
2. sử dụng một lớp trống hoặc một lớp tạm thời, sau đó thêm các trường bắt buộc vào nó;
3. sử dụng một lớp được mã hóa cứng, với tất cả các trường và phương thức cần thiết;
4. và sử dụng lớp

   0
   {'prefix': 'foo', 'i': 1, 'foo1': 500}
   

   3 (xem tại đây), đây là một bộ có khóa cho mỗi mục và đó là một loại bất biến.

Không có giải pháp nào trong số này giống hệt như cấu trúc MATLAB. Để làm điều này, tôi đã phát triển một lớp con là

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

7, sử dụng toán tử

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

5 (DOT) để truy cập các trường, giống như các cấu trúc MATLAB và C/C ++/C#. Ngoài ra, nó có khả năng nhận được danh sách các trường, thêm và loại bỏ các trường, hợp nhất hai hoặc nhiều cấu trúc, lặp lại và sao chép, và tạo các bản sao nông và sâu, là phương tiện của các phương thức được xác định.

Dự án này được đặt tên là YPStruct, viết tắt của Cấu trúc Yarpiz và mã nguồn của nó có sẵn trên GitHub (ở đây) và nó được xuất bản trên PYPI, Chỉ số gói Python (ở đây). Trong bài viết này, chúng ta sẽ thấy cách cài đặt và sử dụng YPStructs, để có kinh nghiệm tương tự như các cấu trúc MATLAB trong Python.ypstruct, which stands for Yarpiz Structure, and its source code is available on GitHub (here) and it is published on PyPI, the Python Package Index (here), as well. In this article, we will see how ypstruct can be installed and used, to have an experience similar to MATLAB structures in Python.

Cài đặt

Cách đơn giản nhất để cài đặt YPStruct trên máy của bạn là sử dụng PIP. Đơn giản chỉ cần chạy cái này trong thiết bị đầu cuối:

pip install ypstruct

Để cài đặt gói YPStruct trên máy tính của bạn.

Ngoài ra, bạn có thể nhận mã nguồn từ kho lưu trữ GitHub (tại đây) và bao gồm trong dự án của bạn hoặc thiết lập trên máy của bạn.

Cách sử dụng cơ bản

Loại cấu trúc trong gói YPStruct được xác định bởi lớp

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8. Lớp này cũng có một tên bí danh,

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

7. Bạn có thể bao gồm

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 hoặc

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

9From gói này hoặc đơn giản là bao gồm mọi thứ có sẵn bằng biểu tượng

pip install ypstruct

0.

Việc sử dụng đơn giản của

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 được đưa ra trong khối mã sau.

from ypstruct import *p = struct()
p.x = 3
p.y = 5
p.A = p.x * p.yprint(p)

Đầu ra của mã này sẽ như sau:

struct({'x': 3, 'y': 4, 'A': 12})

Trong khối mã ở trên, sau khi nhập các lớp YPStruct, một thể hiện

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 được tạo và khởi tạo mà không có bất kỳ trường và dữ liệu nào trong đó. Sau đó, các trường

pip install ypstruct

3 và

pip install ypstruct

4 được đặt. Sau đó, giá trị của một trường mới

pip install ypstruct

5, được xác định bằng cách sử dụng các giá trị của hai trường khác. Cuối cùng, biểu diễn chuỗi của đối tượng cấu trúc được in ra.

Trong mã này, có thể khởi tạo các trường và giá trị của chúng bằng cách sử dụng hàm tạo

pip install ypstruct

6 Class. Đó là:

p = struct(x=3, y=4)
p.A = p.x * p.y

Làm thế nào {'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001} [1, 5] 5 8 và {'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001} [1, 5] 5 7 có liên quan?

Bạn có thể truy cập các trường của đối tượng cấu trúc bằng toán tử

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

5 (DOT), cũng như toán tử lập chỉ mục

from ypstruct import *p = struct()
p.x = 3
p.y = 5
p.A = p.x * p.yprint(p)

0; Bởi vì cấu trúc là một lớp con của

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

7, loại từ điển tích hợp. Vì vậy,

from ypstruct import *p = struct()
p.x = 3
p.y = 5
p.A = p.x * p.yprint(p)

2 và

from ypstruct import *p = struct()
p.x = 3
p.y = 5
p.A = p.x * p.yprint(p)

3 tương đương và chúng có thể được sử dụng thay thế cho nhau.

Ngoài ra, một đối tượng cấu trúc (

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8) có thể được chuyển đổi và tạo từ đối tượng từ điển (

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

7). Ví dụ: bạn có thể chuyển đổi đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

7 thành

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 như sau:

my_dict = {'x':3, 'y':4}
p = struct(my_dict)

Ngoài ra, đối tượng cấu trúc cũng có thể được chuyển đổi thành từ điển:

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

Đầu ra của mã này được hiển thị dưới đây.

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

0

Người vận hành và phương pháp

Lớp

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 (cũng là bí danh

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

7) thực hiện một số toán tử và phương thức, có thể được sử dụng để thay đổi dữ liệu trong cấu trúc và các trường của nó hoặc thực hiện các hoạt động khác. Lưu ý rằng, bất kỳ phương thức hoặc toán tử nào được xác định cho lớp

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

7 cũng có sẵn cho các lớp này.

Các toán tử và phương pháp được xác định cho lớp

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 được thảo luận trong các phần sau của bài đăng này.

Hợp nhất các cấu trúc bằng toán tử struct({'x': 3, 'y': 4, 'A': 12})2

Sử dụng toán tử

struct({'x': 3, 'y': 4, 'A': 12})

2, có thể hợp nhất dữ liệu từ hai trường hợp của lớp

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 để tạo một đối tượng cấu trúc kết hợp. Ví dụ: chúng ta hãy xác định hai cấu trúc như sau:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

1

Hai đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 này có thể được hợp nhất bằng toán tử

struct({'x': 3, 'y': 4, 'A': 12})

2:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

2

Mã này sẽ xuất ra:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

3

Lưu ý rằng các giá trị từ toán hạng thứ hai (đó là

struct({'x': 3, 'y': 4, 'A': 12})

7) được sử dụng cho trường chung của hai cấu trúc. Vì vậy, chúng ta thấy giá trị 5 cho trường

pip install ypstruct

4 trong đối tượng cấu trúc hợp nhất. Kết quả của hoạt động hợp nhất là một cấu trúc chứa tất cả các trường được xác định trong các toán hạng.

Lặp lại các cấu trúc sử dụng toán tử pip install ypstruct0 và phương pháp p = struct(x=3, y=4)p.A = p.x * p.y0

Đôi khi chúng ta cần lặp lại/sao chép một cấu trúc. Ví dụ, giả sử rằng chúng tôi sẽ thực hiện một thuật toán tiến hóa và chúng tôi đã định nghĩa các cá nhân là đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8. Đầu tiên chúng ta cần tạo một mẫu:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

4

Sau đó, chúng ta có thể khởi tạo mảng dân số bằng mã sau:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

5

Mã này sử dụng phương thức

p = struct(x=3, y=4)
p.A = p.x * p.y

0 để khởi tạo danh sách các đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 riêng biệt với cùng các trường dữ liệu.

Thay vì sử dụng phương pháp

p = struct(x=3, y=4)
p.A = p.x * p.y

0, có thể sử dụng toán tử

pip install ypstruct

0 để thực hiện sao chép các cấu trúc. Ví dụ: dòng thứ hai của khối mã trước có thể được viết lại bằng toán tử

pip install ypstruct

0 như sau:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

6

Nhận danh sách các trường được xác định bằng phương pháp p = struct(x=3, y=4)p.A = p.x * p.y7

Phương pháp

p = struct(x=3, y=4)
p.A = p.x * p.y

7 trả về một

p = struct(x=3, y=4)
p.A = p.x * p.y

9 của các trường được xác định trong cấu trúc. Một ví dụ sử dụng theo sau:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

7

Đầu ra sẽ là:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

8

Có một danh sách các trường có thể hữu ích khi chúng ta sẽ thực hiện các hoạt động trên các trường cấu trúc. Ví dụ, trong các vấn đề tối ưu hóa thực tế, chúng tôi xử lý các biến quyết định khác nhau của các loại khác nhau. Người ta có thể gói gọn các biến quyết định bên trong đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8. Thực hiện các hoạt động, như sửa đổi, phân tích cú pháp, xử lý trước hoặc xử lý hậu kỳ của các biến quyết định này, có thể dễ dàng hơn nhiều bằng cách lặp lại danh sách các biến quyết định, ví dụ: Các trường được xác định của đối tượng cấu trúc.

Thêm các trường mới bằng phương pháp my_dict = {'x':3, 'y':4}p = struct(my_dict)1

Một trường mới có thể được thêm vào bằng phương pháp

my_dict = {'x':3, 'y':4}
p = struct(my_dict)

1. Phương thức này chấp nhận hai đối số đầu vào: Tên trường và giá trị của nó. Giá trị là tùy chọn và nếu nó bị bỏ qua, thì giá trị được giả sử là

my_dict = {'x':3, 'y':4}
p = struct(my_dict)

3. Một mã mẫu theo sau:

b = Struct(5, -99.99, [1,5,15,20], 'sample', {'key1':5, 'key2':-100})
b.add(150.0001)
print(b.__dict__)
print(type(b.arg3))
print(b.arg3[0:2])
print(b.arg5['key1'])

c = Struct(prefix='foo')
print(c.i) # empty Struct
c.add(500) # add a value as foo1
print(c.__dict__)

9

Mã này sẽ in ra văn bản này dưới dạng đầu ra:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

0

Thay vì sử dụng phương thức

my_dict = {'x':3, 'y':4}
p = struct(my_dict)

1, có thể chỉ cần sử dụng các toán tử

0
{'prefix': 'foo', 'i': 1, 'foo1': 500}

5 (DOT) và

my_dict = {'x':3, 'y':4}
p = struct(my_dict)

6 (gán). Ví dụ: mã đã đề cập ở trên có thể được đơn giản hóa như thế này:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

1

Kết quả của hai khối mã này sẽ giống nhau.

Loại bỏ các trường bằng phương pháp my_dict = {'x':3, 'y':4}p = struct(my_dict)7

Một trường có thể được xóa khỏi đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 bằng phương pháp

my_dict = {'x':3, 'y':4}
p = struct(my_dict)

7. Phương thức này có một tên trường và xóa (xóa) trường được chỉ định khỏi đối tượng cấu trúc. Một ví dụ được đưa ra dưới đây:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

2

Đầu ra sẽ là thế này:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

3

Tạo các bản sao bằng các phương thức p = struct(x=3, y=4)p.z = 12my_dict = dict(p)print(my_dict)0 và p = struct(x=3, y=4)p.z = 12my_dict = dict(p)print(my_dict)1

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 là một loại tham chiếu. Để có một bản sao của một đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8, bạn không thể chỉ cần sử dụng toán tử gán. Ví dụ: chúng ta hãy tạo một đối tượng cấu trúc:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

4

Bây giờ chúng tôi gán giá trị này cho một biến mới và sau đó cố gắng thay đổi giá trị của một trường:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

5

Điều này cũng sẽ thay đổi đối tượng cấu trúc p. Bởi vì

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

4 và

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

5 đang tham khảo cùng một đối tượng.

Để tạo các bản sao của các đối tượng cấu trúc, hai phương thức được triển khai trong lớp

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8:

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

0 và

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

1. Cái đầu tiên cho chúng ta một bản sao nông của đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8. Nhưng sử dụng

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

1, như tên của phương thức nói, chúng ta có thể tạo các bản sao sâu của các đối tượng cấu trúc.

Cách chính xác để tạo một bản sao của P như sau:

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

6

Lần này,

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

5 đang tham khảo một đối tượng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 khác (sự kiện có cùng giá trị) và sửa đổi nó sẽ không ảnh hưởng đến

p = struct(x=3, y=4)
p.z = 12
my_dict = dict(p)
print(my_dict)

4.

Sự kết luận

Sử dụng

{'prefix': 'arg', 'arg1': 5, 'arg2': -99.99, 'arg3': [1, 5, 15, 20], 'arg4': 'sample', 'arg5': {'key1': 5, 'key2': -100}, 'i': 6, 'arg6': 150.0001}

[1, 5]
5

8 từ YPStruct có thể rất hữu ích trong việc triển khai các dự án và ứng dụng bằng Python. Nó tiết kiệm rất nhiều thời gian trong các dự án đang xử lý các loại dữ liệu giống như lớp với các trường và không có phương thức. Ngoài ra, nó sẽ hữu ích cho người dùng MATLAB, những người đang cố gắng thực hiện lại các chương trình của họ bằng Python, đang sử dụng các cấu trúc.ypstruct can be very helpful in implementing projects and applications using Python. It saves a lot time in projects which are dealing with class-like data types with fields and without methods. Also it will be useful for MATLAB users who are trying to reimplement their programs in Python, which are using structures.

Trước đây, tôi đã sử dụng YPSTRUST để thực hiện các thuật toán và dự án khác nhau. Một số ví dụ được liệt kê dưới đây.

• Khí thần kinh (NG) và phát triển khí thần kinh (GNG) trong Python, một thuật toán học tập không giám sát, lấy cảm hứng từ bản đồ tự tổ chức (SOM), chủ yếu được sử dụng để thực hiện phân cụm. Kho lưu trữ GitHub có sẵn ở đây. and Growing Neural Gas (GNG) in Python, an unsupervised learning algorithm, inspired by Self-organizing Map (SOM), which is mainly used to perform clustering. GitHub repository is available here.
• Sự tiến hóa khác biệt (DE) trong Python, một thuật toán tiến hóa, là một thuật toán tối ưu hóa đa năng. Kho lưu trữ GitHub có sẵn ở đây. in Python, an evolutionary algorithm, which is a general-purpose optimization algorithm. GitHub repository is available here.
• Thuật toán di truyền (GA) trong Python, một thuật toán tiến hóa nổi tiếng lấy cảm hứng từ sự tiến hóa tự nhiên, đó là một phương pháp tối ưu hóa đa năng. Tôi đã triển khai mã này trong một khóa học video về các thuật toán di truyền, có sẵn miễn phí trên YouTube, thông qua liên kết này và các phần liên quan của nó. in Python, a well-known evolutionary algorithm inspired by natural evolution, which is a general-purpose optimization approach. I implemented this code in a video course on Genetic Algorithms, which is freely available on YouTube, via this link and its related parts.

Hy vọng bạn thích bài đăng này trên YPStruct và các cấu trúc trong Python.

Tương đương của cấu trúc MATLAB trong Python là gì?

Python tương đương với cấu trúc là gì?

Có một cấu trúc trong Python?

Matlab có cấu trúc không?