python: làm thế nào để xác định nếu một biến là một mảng hoặc vô hướng

Tôi có một chức năng có đối số NBins. Tôi muốn thực hiện một cuộc gọi đến hàm này bằng vô hướng 50hoặc một mảng [0, 10, 20, 30]. Làm thế nào tôi có thể xác định trong hàm, độ dài của NBinsnó là bao nhiêu? hoặc nói khác đi, nếu nó là vô hướng hay vectơ?

Tôi đã thử điều này:

>>> N=[2,3,5]
>>> P = 5
>>> len(N)
3
>>> len(P)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()
>>> 

Như bạn thấy đấy, tôi không thể áp dụng lenđể P, vì nó không phải là một mảng .... Có cái gì đó như isarrayhoặc isscalartrong python?

cảm ơn

>>> isinstance([0, 10, 20, 30], list)
True
>>> isinstance(50, list)
False

Để hỗ trợ bất kỳ loại trình tự, kiểm tra collections.Sequencethay vì list.

lưu ý : isinstancecũng hỗ trợ một bộ các lớp, kiểm tra type(x) in (..., ...)nên tránh và không cần thiết.

Bạn cũng có thể muốn kiểm tra not isinstance(x, (str, unicode))

Các câu trả lời trước đây cho rằng mảng là một danh sách chuẩn python. Là một người thường xuyên sử dụng numpy, tôi khuyên bạn nên thử nghiệm pythonic về:

if hasattr(N, "__len__")

Kết hợp các câu trả lời của @jamylak và @ jpaddison3 với nhau, nếu bạn cần mạnh mẽ chống lại các mảng khó hiểu như đầu vào và xử lý chúng theo cách giống như danh sách, bạn nên sử dụng

import numpy as np
isinstance(P, (list, tuple, np.ndarray))

Điều này là mạnh mẽ chống lại các lớp con của danh sách, tuple và numpy mảng.

Và nếu bạn cũng muốn mạnh mẽ đối với tất cả các lớp con khác của chuỗi (không chỉ liệt kê và tuple), hãy sử dụng

import collections
import numpy as np
isinstance(P, (collections.Sequence, np.ndarray))

Tại sao bạn nên làm mọi thứ theo cách này isinstancevà không so sánh type(P)với giá trị mục tiêu? Dưới đây là một ví dụ, nơi chúng ta thực hiện và nghiên cứu hành vi của NewList, một lớp con tầm thường của danh sách.

>>> class NewList(list):
...     isThisAList = '???'
... 
>>> x = NewList([0,1])
>>> y = list([0,1])
>>> print x
[0, 1]
>>> print y
[0, 1]
>>> x==y
True
>>> type(x)
<class '__main__.NewList'>
>>> type(x) is list
False
>>> type(y) is list
True
>>> type(x).__name__
'NewList'
>>> isinstance(x, list)
True

Mặc dù xvà yso sánh như nhau, xử lý chúng typesẽ dẫn đến hành vi khác nhau. Tuy nhiên, vì xlà một thể hiện của một lớp con của list, sử dụng isinstance(x,list)cung cấp cho các hành vi mong muốn và xử lý xvà ytheo cách tương tự.

Có tương đương với isscalar () trong numpy không? Đúng.

>>> np.isscalar(3.1)
True
>>> np.isscalar([3.1])
False
>>> np.isscalar(False)
True

Trong khi, cách tiếp cận của @ jamylak là cách tốt hơn, đây là một cách tiếp cận khác

>>> N=[2,3,5]
>>> P = 5
>>> type(P) in (tuple, list)
False
>>> type(N) in (tuple, list)
True

Một cách tiếp cận khác (sử dụng thuộc tính tên lớp ):

N = [2,3,5]
P = 5

type(N).__name__ == 'list'
True

type(P).__name__ == 'int'
True

type(N).__name__ in ('list', 'tuple')
True

Không cần nhập gì cả.

Đây là cách tiếp cận tốt nhất mà tôi đã tìm thấy: Kiểm tra sự tồn tại của __len__ và __getitem__.

Bạn có thể hỏi tại sao? Những lý do bao gồm:

1. Phương pháp phổ biến isinstance(obj, abc.Sequence) không thành công trên một số đối tượng, bao gồm cả Tenor của PyTorch vì chúng không thực hiện __contains__.
2. Thật không may, không có gì trong bộ sưu tập của Python.abc chỉ kiểm tra __len__ và __getitem__tôi cảm thấy đó là các phương thức tối thiểu cho các đối tượng giống như mảng.
3. Nó hoạt động trên danh sách, tuple, ndarray, Tensor, v.v.

Vì vậy, không có thêm ado:

def is_array_like(obj, string_is_array=False, tuple_is_array=True):
    result = hasattr(obj, "__len__") and hasattr(obj, '__getitem__') 
    if result and not string_is_array and isinstance(obj, (str, abc.ByteString)):
        result = False
    if result and not tuple_is_array and isinstance(obj, tuple):
        result = False
    return result

Lưu ý rằng tôi đã thêm các tham số mặc định vì hầu hết thời gian bạn có thể muốn coi chuỗi là giá trị, không phải là mảng. Tương tự cho các bộ dữ liệu.

>>> N=[2,3,5]
>>> P = 5
>>> type(P)==type(0)
True
>>> type([1,2])==type(N)
True
>>> type(P)==type([1,2])
False

Bạn có thể kiểm tra loại dữ liệu của biến.

N = [2,3,5]
P = 5
type(P)

Nó sẽ cung cấp cho bạn đặt dưới dạng kiểu dữ liệu của P.

<type 'int'>

Vì vậy, bạn có thể phân biệt rằng nó là một số nguyên hoặc một mảng.

Tôi ngạc nhiên khi một câu hỏi cơ bản như vậy dường như không có câu trả lời ngay lập tức ở trăn. Dường như với tôi, gần như tất cả các câu trả lời được đề xuất đều sử dụng một số loại kiểm tra, thường không được khuyên dùng trong python và chúng dường như bị hạn chế trong một trường hợp cụ thể (chúng thất bại với các loại số khác nhau hoặc các đối tượng lặp chung không phải là tuples hoặc danh sách).

Đối với tôi, những gì hoạt động tốt hơn là nhập numpy và sử dụng Array.size, ví dụ:

>>> a=1
>>> np.array(a)
Out[1]: array(1)

>>> np.array(a).size
Out[2]: 1

>>> np.array([1,2]).size
Out[3]: 2

>>> np.array('125')
Out[4]: 1

Cũng lưu ý:

>>> len(np.array([1,2]))

Out[5]: 2

nhưng:

>>> len(np.array(a))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-40-f5055b93f729> in <module>()
----> 1 len(np.array(a))

TypeError: len() of unsized object

Đơn giản chỉ cần sử dụng sizethay vì len!

>>> from numpy import size
>>> N = [2, 3, 5]
>>> size(N)
3
>>> N = array([2, 3, 5])
>>> size(N)
3
>>> P = 5
>>> size(P)
1

pres_test [0] có hình dạng (128,128,1) Cho phép kiểm tra kiểu dữ liệu của nó bằng cách sử dụng hàm isinstance () isinstance mất 2 đối số. Đối số thứ nhất là dữ liệu Đối số thứ hai là kiểu dữ liệu isinstance (pres_test [0], np.ndarray) cho Kết quả là True. Nó có nghĩa là preds_test [0] là một mảng.

Để trả lời câu hỏi trong tiêu đề, một cách trực tiếp để biết một biến có phải là vô hướng hay không là cố gắng chuyển đổi nó thành float. Nếu bạn nhận được TypeError, nó không phải là.

N = [1, 2, 3]
try:
    float(N)
except TypeError:
    print('it is not a scalar')
else:
    print('it is a scalar')