Lớp Python trả về mảng

ndarrays và tạo đối tượng

Việc phân lớp ndarray phức tạp bởi thực tế là các thể hiện mới của các lớp ndarray có thể xuất hiện theo ba cách khác nhau. đó là

1. cuộc gọi hàm tạo rõ ràng - như trong

   >>> class C:
   >>>     def __new__(cls, *args):
   >>>         print('Cls in __new__:', cls)
   >>>         print('Args in __new__:', args)
   >>>         # The `object` type __new__ method takes a single argument.
   >>>         return object.__new__(cls)
   >>>     def __init__(self, *args):
   >>>         print('type(self) in __init__:', type(self))
   >>>         print('Args in __init__:', args)
   

   5. Đây là cách thông thường để tạo phiên bản Python

2. Xem truyền - truyền một ndarray hiện có dưới dạng một lớp con nhất định

3. Mới từ mẫu - tạo phiên bản mới từ phiên bản mẫu. Các ví dụ bao gồm trả về các lát từ một mảng được phân lớp, tạo các kiểu trả về từ ufunc và sao chép các mảng. Xem để biết thêm chi tiết

Hai cái cuối cùng là đặc điểm của ndarrays - để hỗ trợ những thứ như cắt mảng. Sự phức tạp của việc phân lớp ndarray là do cơ chế numpy phải hỗ trợ hai lộ trình tạo cá thể sau này

Khi nào sử dụng phân lớp

Bên cạnh sự phức tạp bổ sung của việc phân lớp con một mảng NumPy, các lớp con có thể gặp phải hành vi không mong muốn vì một số hàm có thể chuyển đổi lớp con thành lớp cơ sở và “quên” bất kỳ thông tin bổ sung nào liên quan đến lớp con. Điều này có thể dẫn đến hành vi đáng ngạc nhiên nếu bạn sử dụng các phương thức hoặc hàm NumPy mà bạn chưa kiểm tra rõ ràng

Mặt khác, so với các cách tiếp cận khả năng tương tác khác, phân lớp có thể hữu ích vì nhiều thứ sẽ “hoạt động bình thường”

Điều này có nghĩa là phân lớp có thể là một cách tiếp cận thuận tiện và trong một thời gian dài nó cũng thường là cách tiếp cận khả dụng duy nhất. Tuy nhiên, NumPy hiện cung cấp các giao thức tương tác bổ sung được mô tả trong “”. Đối với nhiều trường hợp sử dụng, các giao thức tương tác này giờ đây có thể phù hợp hơn hoặc bổ sung cho việc sử dụng phân lớp

Phân lớp có thể phù hợp nếu

• bạn bớt lo lắng về khả năng bảo trì hoặc người dùng khác ngoài chính bạn. Lớp con sẽ triển khai nhanh hơn và khả năng tương tác bổ sung có thể được thêm vào “khi cần”. Và với ít người dùng, những bất ngờ có thể xảy ra không phải là vấn đề

• bạn không nghĩ rằng đó là vấn đề nếu thông tin phân lớp bị bỏ qua hoặc bị mất âm thầm. Một ví dụ là

  >>> class C:
  >>>     def __new__(cls, *args):
  >>>         print('Cls in __new__:', cls)
  >>>         print('Args in __new__:', args)
  >>>         # The `object` type __new__ method takes a single argument.
  >>>         return object.__new__(cls)
  >>>     def __init__(self, *args):
  >>>         print('type(self) in __init__:', type(self))
  >>>         print('Args in __init__:', args)
  

  6 trong đó việc “quên” dữ liệu được ánh xạ bộ nhớ không thể dẫn đến kết quả sai. Một ví dụ về lớp con đôi khi khiến người dùng nhầm lẫn là các mảng được che dấu của NumPy. Khi chúng được giới thiệu, phân lớp là cách tiếp cận duy nhất để thực hiện. Tuy nhiên, ngày nay chúng ta có thể cố gắng tránh phân lớp và chỉ dựa vào các giao thức tương tác

Lưu ý rằng các tác giả phân lớp cũng có thể muốn nghiên cứu để hỗ trợ các trường hợp sử dụng phức tạp hơn hoặc giải quyết hành vi đáng ngạc nhiên

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

Xem đúc

Truyền dạng xem là cơ chế ndarray tiêu chuẩn theo đó bạn lấy một ndarray của bất kỳ lớp con nào và trả về dạng xem của mảng dưới dạng một lớp con (được chỉ định) khác

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)

Tạo mới từ mẫu

Các phiên bản mới của một lớp con ndarray cũng có thể xuất hiện theo một cơ chế rất giống với , khi numpy nhận thấy nó cần tạo một phiên bản mới từ một phiên bản mẫu. Vị trí rõ ràng nhất mà điều này phải xảy ra là khi bạn đang lấy các mảng được phân lớp. Ví dụ

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Slice là một chế độ xem trên dữ liệu gốc của

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

Có những điểm khác trong việc sử dụng ndarrays mà chúng ta cần các chế độ xem như vậy, chẳng hạn như sao chép mảng (

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

Mối quan hệ của truyền dạng xem và mẫu mới từ mẫu

Cả hai con đường này đều sử dụng cùng một máy móc. Chúng tôi tạo ra sự khác biệt ở đây, bởi vì chúng dẫn đến đầu vào khác nhau cho các phương pháp của bạn. Cụ thể, có nghĩa là bạn đã tạo một thể hiện mới của kiểu mảng của mình từ bất kỳ lớp con tiềm năng nào của ndarray. có nghĩa là bạn đã tạo một thể hiện mới của lớp của mình từ một thể hiện có sẵn, cho phép bạn - ví dụ - sao chép qua các thuộc tính dành riêng cho lớp con của bạn

Ý nghĩa đối với phân lớp

Nếu chúng ta phân lớp ndarray, chúng ta không chỉ cần giải quyết việc xây dựng rõ ràng kiểu mảng của chúng ta, mà còn hoặc. NumPy có máy móc để làm điều này và chính máy móc này làm cho việc phân lớp con hơi phi tiêu chuẩn

Có hai khía cạnh đối với bộ máy mà ndarray sử dụng để hỗ trợ chế độ xem và mẫu mới từ mẫu trong các lớp con

Đầu tiên là việc sử dụng phương thức ________ 73 cho công việc chính là khởi tạo đối tượng, sau đó là phương thức ________ 74 thông thường hơn. Thứ hai là việc sử dụng phương thức

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> import numpy as np
>>> # create a completely useless ndarray subclass
>>> class C(np.ndarray): pass
>>> # create a standard ndarray
>>> arr = np.zeros((3,))
>>> # take a view of it, as our useless subclass
>>> c_arr = arr.view(C)
>>> type(c_arr)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

Ví dụ đơn giản - thêm thuộc tính bổ sung vào ndarray

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Sử dụng đối tượng trông như thế này

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Lớp này không hữu ích lắm, bởi vì nó có cùng hàm tạo như đối tượng ndarray trần, bao gồm cả việc truyền vào bộ đệm và hình dạng, v.v. Chúng tôi có thể muốn hàm tạo có thể lấy một ndarray đã được tạo sẵn từ các lệnh gọi numpy thông thường tới

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Ví dụ thực tế hơn một chút - thuộc tính được thêm vào mảng hiện có

Đây là một lớp lấy một ndarray tiêu chuẩn đã tồn tại, chuyển thành kiểu của chúng tôi và thêm một thuộc tính bổ sung

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Vì thế

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:] >>> type(v) # the view is of type 'C' >>> v is c_arr # but it's a new instance False 55 cho ufunc

Mới trong phiên bản 1. 13

Một lớp con có thể ghi đè những gì xảy ra khi thực thi ufuncs numpy trên nó bằng cách ghi đè phương thức

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Chữ ký của

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Một triển khai điển hình sẽ chuyển đổi bất kỳ đầu vào hoặc đầu ra nào là thể hiện của một lớp riêng, chuyển mọi thứ sang lớp cha bằng cách sử dụng

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Vì vậy, lớp học này không thực sự làm bất cứ điều gì thú vị. nó chỉ chuyển đổi bất kỳ phiên bản nào của chính nó thành ndarray thông thường (nếu không, chúng ta sẽ nhận được đệ quy vô hạn. ) và thêm một từ điển

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Lưu ý rằng một cách tiếp cận khác sẽ là sử dụng

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Nếu thay vào đó, chúng tôi thay thế cuộc gọi

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Như một lưu ý cuối cùng. nếu tuyến đường

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:] >>> type(v) # the view is of type 'C' >>> v is c_arr # but it's a new instance False 40 cho ufunc và các chức năng khác

Trước numpy 1. 13, hành vi của ufunc chỉ có thể được điều chỉnh bằng cách sử dụng

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Về mặt khái niệm,

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Chúng tôi chạy một ufunc trên một phiên bản của mảng mới của chúng tôi

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Lưu ý rằng ufunc (

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> c = C('hello')
Cls in __new__: 
Args in __new__: ('hello',)
type(self) in __init__: 
Args in __init__: ('hello',)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Nhưng, chúng tôi có thể làm bất cứ điều gì chúng tôi muốn

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

Vì vậy, bằng cách định nghĩa một phương thức

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Ngoài

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Gotchas bổ sung - phương pháp >>> v = c_arr[1:] >>> type(v) # the view is of type 'C' >>> v is c_arr # but it's a new instance False 66 tùy chỉnh và ndarray. cơ sở

Một trong những vấn đề mà ndarray giải quyết là theo dõi quyền sở hữu bộ nhớ của ndarray và quan điểm của chúng. Xem xét trường hợp chúng tôi đã tạo một ndarray,

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

Nói chung, nếu mảng sở hữu bộ nhớ riêng của nó, như đối với

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Thuộc tính

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Phân lớp và khả năng tương thích xuôi dòng

Khi phân lớp phụ ________ 422 hoặc tạo các loại vịt bắt chước giao diện ________ 422, bạn có trách nhiệm quyết định mức độ liên kết giữa các API của mình với các API của numpy. Để thuận tiện, nhiều hàm numpy có phương thức

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Ví dụ: nếu bạn muốn lớp con hoặc loại vịt của mình tương thích với hàm ________ 678 của numpy, chữ ký phương thức cho phương thức ________ 678 của đối tượng này phải như sau

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

Đây chính xác là chữ ký phương thức tương tự cho

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Tuy nhiên, nếu bạn quyết định đi chệch khỏi chữ ký này và làm điều gì đó như thế này

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

Đối tượng này không còn tương thích với

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Nếu bạn muốn duy trì khả năng tương thích với numpy và các phiên bản tiếp theo của nó (có thể thêm các đối số từ khóa mới) nhưng không muốn hiển thị tất cả các đối số của numpy, thì chữ ký của hàm của bạn phải chấp nhận

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> class C:
>>>     def __new__(cls, *args):
>>>         print('Cls in __new__:', cls)
>>>         print('Args in __new__:', args)
>>>         # The `object` type __new__ method takes a single argument.
>>>         return object.__new__(cls)
>>>     def __init__(self, *args):
>>>         print('type(self) in __init__:', type(self))
>>>         print('Args in __init__:', args)

Đối tượng này hiện tương thích lại với

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

>>> v = c_arr[1:]
>>> type(v) # the view is of type 'C'

>>> v is c_arr # but it's a new instance
False

Một lớp có thể trả lại thứ gì đó Python không?

Làm cách nào để viết mảng trong Python?

Làm cách nào để đọc mảng trong Python?

Làm cách nào để nối thêm mảng trong Python?