Hướng dẫn what does masked mean in python? - mặt nạ có nghĩa là gì trong trăn?

Rationale#

Mảng đeo mặt nạ là các mảng có thể bị thiếu hoặc không hợp lệ. Mô-đun

>>> import numpy as np
>>> import numpy.ma as ma

Mảng đeo mặt nạ là gì?#

Trong nhiều trường hợp, các bộ dữ liệu có thể không đầy đủ hoặc bị nhiễm độc bởi sự hiện diện của dữ liệu không hợp lệ. Ví dụ, một cảm biến có thể không ghi được dữ liệu hoặc ghi lại một giá trị không hợp lệ. Mô -đun

>>> import numpy as np
>>> import numpy.ma as ma

Một mảng đeo mặt nạ là sự kết hợp của một

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

Gói đảm bảo rằng các mục đeo mặt nạ không được sử dụng trong các tính toán.

Như một minh họa, hãy để xem xét các bộ dữ liệu sau:

>>> import numpy as np
>>> import numpy.ma as ma
>>> x = np.array([1, 2, 3, -1, 5])

Chúng tôi muốn đánh dấu mục thứ tư là không hợp lệ. Dễ nhất là tạo ra một mảng đeo mặt nạ:

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Bây giờ chúng ta có thể tính toán giá trị trung bình của bộ dữ liệu, mà không cần tính đến dữ liệu không hợp lệ:

Mô -đun >>> import numpy as np >>> import numpy.ma as ma 3#

Tính năng chính của mô -đun

>>> import numpy as np
>>> import numpy.ma as ma

>>> y = ma.array([1, 2, 3], mask = [0, 1, 0])

>>> import numpy as np
>>> import numpy.ma as ma

Mô -đun

>>> import numpy as np
>>> import numpy.ma as ma

>>> y = ma.array([1, 2, 3], mask = [0, 1, 0])

>>> import numpy as np
>>> import numpy.ma as ma

Để tạo một mảng với phần tử thứ hai không hợp lệ, chúng tôi sẽ làm:

>>> y = ma.array([1, 2, 3], mask = [0, 1, 0])

Để tạo một mảng đeo mặt nạ trong đó tất cả các giá trị gần 1.e20 không hợp lệ, chúng tôi sẽ làm:

>>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20)

Để thảo luận đầy đủ về các phương thức tạo cho các mảng đeo mặt nạ, vui lòng xem phần Xây dựng các mảng đeo mặt nạ.Constructing masked arrays.

Xây dựng mảng đeo mặt nạ#

Có một số cách để xây dựng một mảng đeo mặt nạ.

• Một khả năng đầu tiên là trực tiếp gọi lớp

  >>> y = ma.array([1, 2, 3], mask = [0, 1, 0])
  

  1.

• Khả năng thứ hai là sử dụng hai hàm tạo mảng đeo mặt nạ,

  >>> y = ma.array([1, 2, 3], mask = [0, 1, 0])
  

  6 và

  >>> y = ma.array([1, 2, 3], mask = [0, 1, 0])
  

  7.

  >>> y = ma.array([1, 2, 3], mask = [0, 1, 0]) 6(data[, dtype, copy, order, mask, ...])	Một lớp mảng có giá trị đeo mặt nạ có thể.
  >>> y = ma.array([1, 2, 3], mask = [0, 1, 0]) 7	bí danh của >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 0

• Tùy chọn thứ ba là đưa ra chế độ xem của một mảng hiện có. Trong trường hợp đó, mặt nạ của chế độ xem được đặt thành

  >>> import numpy as np
  >>> import numpy.ma as ma
  

  6 nếu mảng không có trường tên hoặc một mảng boolean có cùng cấu trúc với mảng khác.

  >>> x = np.array([1, 2, 3])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[1, 2, 3],
               mask=False,
         fill_value=999999)
  >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[(1, 1.0), (2, 2.0)],
               mask=[(False, False), (False, False)],
         fill_value=(999999, 1.e+20),
              dtype=[('a', '
  

• Tuy nhiên, một khả năng khác là sử dụng bất kỳ chức năng nào sau đây:

  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 2(a[, dtype, order])	Chuyển đổi đầu vào thành một mảng đeo mặt nạ của loại dữ liệu đã cho.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 3(a[, dtype])	Chuyển đổi đầu vào thành một mảng đeo mặt nạ, bảo tồn các lớp con.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 4(a[, mask, copy, fill_value])	Trả về đầu vào với dữ liệu không hợp lệ được che dấu và thay thế bằng giá trị điền.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 5(x, value[, copy])	Mặt nạ một mảng trong đó bằng một giá trị nhất định.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 6(x, value[, copy])	Mặt nạ một mảng trong đó lớn hơn một giá trị nhất định.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 7(x, value[, copy])	Mặt nạ một mảng trong đó lớn hơn hoặc bằng một giá trị nhất định.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 8(x, v1, v2[, copy])	Mặt nạ một mảng bên trong một khoảng thời gian nhất định.
  >>> z = ma.masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20) 9(a[, copy])	Mặt nạ một mảng nơi xảy ra các giá trị không hợp lệ (NANS hoặc INF).
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 0(x, value[, copy])	Mặt nạ một mảng trong đó ít hơn một giá trị nhất định.
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 1(x, value[, copy])	Mặt nạ một mảng trong đó ít hơn hoặc bằng một giá trị nhất định.
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 2(x, value[, copy])	Mặt nạ một mảng trong đó không bằng một giá trị nhất định.
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 3(x, value[, copy, shrink])	Mặt nạ mảng X trong đó dữ liệu chính xác bằng giá trị.
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 4(x, v1, v2[, copy])	Mặt nạ một mảng bên ngoài một khoảng thời gian nhất định.
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 5(x, value[, rtol, atol, copy, ...])	Mặt nạ sử dụng bình đẳng điểm nổi.
  >>> x = np.array([1, 2, 3]) >>> x.view(ma.MaskedArray) masked_array(data=[1, 2, 3], mask=False, fill_value=999999) >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)]) >>> x.view(ma.MaskedArray) masked_array(data=[(1, 1.0), (2, 2.0)], mask=[(False, False), (False, False)], fill_value=(999999, 1.e+20), dtype=[('a', ' 6(condition, a[, copy])	Mặt nạ một mảng nơi đáp ứng một điều kiện.

Truy cập dữ liệu#

Dữ liệu cơ bản của một mảng đeo mặt nạ có thể được truy cập theo nhiều cách:

• thông qua thuộc tính

  >>> x = np.array([1, 2, 3])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[1, 2, 3],
               mask=False,
         fill_value=999999)
  >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[(1, 1.0), (2, 2.0)],
               mask=[(False, False), (False, False)],
         fill_value=(999999, 1.e+20),
              dtype=[('a', '
  

  7. Đầu ra là một chế độ xem của mảng dưới dạng

  >>> import numpy as np
  >>> import numpy.ma as ma
  

  5 hoặc một trong các lớp con của nó, tùy thuộc vào loại dữ liệu cơ bản tại tạo mảng đeo mặt nạ.

• thông qua phương pháp

  >>> x = np.array([1, 2, 3])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[1, 2, 3],
               mask=False,
         fill_value=999999)
  >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[(1, 1.0), (2, 2.0)],
               mask=[(False, False), (False, False)],
         fill_value=(999999, 1.e+20),
              dtype=[('a', '
  

  9. Đầu ra sau đó là

  >>> import numpy as np
  >>> import numpy.ma as ma
  

  5.

• bằng cách trực tiếp xem một cái nhìn của mảng đeo mặt nạ dưới dạng

  >>> import numpy as np
  >>> import numpy.ma as ma
  

  5 hoặc một trong các lớp con của nó (thực sự là những gì sử dụng thuộc tính

  >>> x = np.array([1, 2, 3])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[1, 2, 3],
               mask=False,
         fill_value=999999)
  >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)])
  >>> x.view(ma.MaskedArray)
  masked_array(data=[(1, 1.0), (2, 2.0)],
               mask=[(False, False), (False, False)],
         fill_value=(999999, 1.e+20),
              dtype=[('a', '
  

  7).

• bằng cách sử dụng hàm

  >>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
  >>> x[~x.mask]
  masked_array(data=[1, 4],
               mask=[False, False],
         fill_value=999999)
  

  3.

Không có phương pháp nào trong số này là hoàn toàn thỏa đáng nếu một số mục đã được đánh dấu là không hợp lệ. Theo nguyên tắc chung, trong đó yêu cầu một biểu diễn của mảng mà không cần bất kỳ mục nào được đeo mặt nạ, nên điền vào mảng bằng phương pháp

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

Truy cập mặt nạ#

Mặt nạ của một mảng đeo mặt nạ có thể truy cập được thông qua thuộc tính

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

>>> import numpy as np
>>> import numpy.ma as ma

Một khả năng khác là sử dụng các hàm

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

>>> x.compressed()
array([1, 4])

>>> x.compressed()
array([1, 4])

>>> import numpy as np
>>> import numpy.ma as ma

>>> x.compressed()
array([1, 4])

>>> x.compressed()
array([1, 4])

>>> x.compressed()
array([1, 4])

>>> x.compressed()
array([1, 4])

>>> import numpy as np
>>> import numpy.ma as ma

>>> x.compressed()
array([1, 4])

Chỉ truy cập các mục hợp lệ#

Để chỉ truy xuất các mục hợp lệ, chúng ta có thể sử dụng nghịch đảo của mặt nạ làm chỉ mục. Nghịch đảo của mặt nạ có thể được tính toán với hàm

>>> x.compressed()
array([1, 4])

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

Một cách khác để truy xuất dữ liệu hợp lệ là sử dụng phương thức

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> x.compressed()
array([1, 4])

Lưu ý rằng đầu ra của

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

Sửa đổi mặt nạ#

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data=[1, 4],
             mask=[False, False],
       fill_value=999999)

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=999999,
            dtype=int64)

>>> import numpy as np
>>> import numpy.ma as ma

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=999999,
            dtype=int64)

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

>>> import numpy as np
>>> import numpy.ma as ma

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=999999,
            dtype=int64)

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

>>> import numpy as np
>>> import numpy.ma as ma

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Cuối cùng, các mục cụ thể có thể được che giấu và/hoặc được mở ra bằng cách gán cho mặt nạ một chuỗi booleans:

Bỏ ra một mục nhập#

Để giải quyết một hoặc một số mục cụ thể, chúng tôi chỉ có thể gán một hoặc một số giá trị hợp lệ mới cho chúng:

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Bỏ qua một mục nhập bằng cách gán trực tiếp sẽ âm thầm thất bại nếu mảng đeo mặt nạ có mặt nạ cứng, như được hiển thị bởi thuộc tính

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=999999,
            dtype=int64)

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=999999,
            dtype=int64)

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data=[--, --, --],
             mask=[ True,  True,  True],
       fill_value=999999,
            dtype=int64)

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Để vạch mặt tất cả các mục mặt nạ của một mảng đeo mặt nạ (với điều kiện mặt nạ không phải là mặt nạ cứng), giải pháp đơn giản nhất là gán hằng số

>>> import numpy as np
>>> import numpy.ma as ma

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Lập chỉ mục và cắt#

Vì >>> y = ma.array([1, 2, 3], mask = [0, 1, 0]) 1 là một lớp con của >>> import numpy as np >>> import numpy.ma as ma 5, nó kế thừa các cơ chế của nó để lập chỉ mục và cắt.

Khi truy cập vào một mục nhập của một mảng đeo mặt nạ không có trường được đặt tên, đầu ra là vô hướng (nếu mục nhập tương ứng của mặt nạ là

>>> import numpy as np
>>> import numpy.ma as ma

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data=[--, 2, 3],
             mask=[ True, False, False],
       fill_value=999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(
  data=[[1, --, 3],
        [4, 5, --],
        [--, 8, 9]],
  mask=[[False,  True, False],
        [False, False,  True],
        [ True, False, False]],
  fill_value=999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data=[--, --, 3, 4],
             mask=[ True,  True, False, False],
       fill_value=999999)

>>> import numpy as np
>>> import numpy.ma as ma

Nếu mảng đeo mặt nạ có tên là các trường, việc truy cập một mục nhập sẽ trả về một đối tượng

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Khi truy cập một lát, đầu ra là một mảng được che mặt nạ. Quan điểm được yêu cầu để đảm bảo tuyên truyền bất kỳ sửa đổi của mặt nạ sang bản gốc.

Truy cập một trường của một mảng đeo mặt nạ với kiểu dữ liệu có cấu trúc trả về một

>>> y = ma.array([1, 2, 3], mask = [0, 1, 0])

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Hoạt động trên mảng đeo mặt nạ#

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Dữ liệu có giá trị nhất định đại diện cho dữ liệu bị thiếu#

Hãy cùng xem xét một danh sách các yếu tố,

>>> x.compressed()
array([1, 4])

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

Điền vào dữ liệu bị thiếu#

Giả sử bây giờ chúng ta muốn in cùng một dữ liệu đó, nhưng với các giá trị bị thiếu được thay thế bằng giá trị trung bình.

>>> import numpy as np
>>> import numpy.ma as ma

Hoạt động số#

Các hoạt động số có thể được thực hiện dễ dàng mà không phải lo lắng về các giá trị bị thiếu, chia cho số 0, gốc vuông của số âm, v.v.:

>>> import numpy as np
>>> import numpy.ma as ma

Bốn giá trị của đầu ra không hợp lệ: giá trị đầu tiên đến từ việc lấy căn bậc hai của số âm, thứ hai từ phân chia theo 0 và hai cái cuối cùng mà các đầu vào được che dấu.

Bỏ qua các giá trị cực đoan#

Hãy cùng xem xét một mảng

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

>>> import numpy as np
>>> import numpy.ma as ma