Có một cách đơn giản để xác định xem một biến là một danh sách, từ điển, hoặc cái gì khác không? Tôi đang nhận được một đối tượng có thể là một trong hai loại và tôi cần có thể nói sự khác biệt.

Có hai chức năng tích hợp giúp bạn xác định loại đối tượng. Bạn có thể sử dụng type() nếu bạn cần loại chính xác của một đối tượng và isinstance()để kiểm tra loại đối tượng đó với một thứ gì đó. Thông thường, bạn muốn sử dụng isistance()hầu hết thời gian vì nó rất mạnh mẽ và cũng hỗ trợ kiểu kế thừa.

Để có được loại thực tế của một đối tượng, bạn sử dụng type()hàm tích hợp. Truyền một đối tượng làm tham số duy nhất sẽ trả về loại đối tượng của đối tượng đó:

>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True

Điều này tất nhiên cũng hoạt động cho các loại tùy chỉnh:

>>> class Test1 (object):
        pass
>>> class Test2 (Test1):
        pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True

Lưu ý rằng type()sẽ chỉ trả về loại ngay lập tức của đối tượng, nhưng sẽ không thể cho bạn biết về kế thừa loại.

>>> type(b) is Test1
False

Để bao quát điều đó, bạn nên sử dụng isinstancechức năng. Điều này tất nhiên cũng hoạt động cho các loại tích hợp:

>>> isinstance(b, Test1)
True
>>> isinstance(b, Test2)
True
>>> isinstance(a, Test1)
True
>>> isinstance(a, Test2)
False
>>> isinstance([], list)
True
>>> isinstance({}, dict)
True

isinstance()thường là cách ưa thích để đảm bảo loại đối tượng bởi vì nó cũng sẽ chấp nhận các loại dẫn xuất. Vì vậy, trừ khi bạn thực sự cần loại đối tượng (vì bất kỳ lý do gì), sử dụng isinstance()được ưu tiên hơn type().

Tham số thứ hai isinstance()cũng chấp nhận một bộ các loại, vì vậy có thể kiểm tra nhiều loại cùng một lúc. isinstancesau đó sẽ trả về true, nếu đối tượng thuộc bất kỳ kiểu nào trong số đó:

>>> isinstance([], (tuple, list, set))
True

Bạn có thể làm điều đó bằng cách sử dụng type():

>>> a = []
>>> type(a)
<type 'list'>
>>> f = ()
>>> type(f)
<type 'tuple'>

Nó có thể là nhiều Pythonic hơn để sử dụng một try... exceptkhối. Theo cách đó, nếu bạn có một lớp mà quẻ như một danh sách, hoặc các quẻ như một dict, nó sẽ hành xử đúng bất kể loại của nó thực sự là gì.

Để làm rõ, phương pháp "nói khác biệt" ưa thích giữa các loại biến là với một thứ gọi là gõ vịt : miễn là các phương thức (và kiểu trả về) mà một biến đáp ứng là những gì chương trình con của bạn mong đợi, hãy coi nó như những gì bạn mong đợi được. Ví dụ: nếu bạn có một lớp làm quá tải các toán tử khung getattrvà setattr, nhưng sử dụng một số lược đồ bên trong vui nhộn, thì nó sẽ thích hợp để nó hoạt động như một từ điển nếu đó là những gì nó đang cố gắng mô phỏng.

Vấn đề khác với việc type(A) is type(B)kiểm tra là nếu Alà một lớp con của Bnó, nó sẽ đánh giá falsekhi nào, theo lập trình, bạn sẽ hy vọng nó sẽ xảy ra true. Nếu một đối tượng là một lớp con của danh sách, nó sẽ hoạt động giống như một danh sách: kiểm tra loại như được trình bày trong câu trả lời khác sẽ ngăn chặn điều này. ( isinstancesẽ làm việc, tuy nhiên).

Trong các trường hợp của đối tượng, bạn cũng có:

__class__

thuộc tính. Đây là một mẫu được lấy từ bảng điều khiển Python 3.3

>>> str = "str"
>>> str.__class__
<class 'str'>
>>> i = 2
>>> i.__class__
<class 'int'>
>>> class Test():
...     pass
...
>>> a = Test()
>>> a.__class__
<class '__main__.Test'>

Coi chừng rằng trong lớp python 3.x và trong các lớp Kiểu mới (có thể tùy chọn từ lớp Python 2.6) và loại đã được hợp nhất và điều này đôi khi có thể dẫn đến kết quả không mong muốn. Chủ yếu là vì lý do này cách yêu thích của tôi về thử nghiệm loại / classes là đến isinstance xây dựng trong chức năng.

Xác định loại đối tượng Python

Xác định loại đối tượng với type

>>> obj = object()
>>> type(obj)
<class 'object'>

Mặc dù nó hoạt động, tránh hai thuộc tính gạch dưới như __class__- chúng không công khai về mặt ngữ nghĩa và trong khi có lẽ không phải trong trường hợp này, các hàm dựng sẵn thường có hành vi tốt hơn.

>>> obj.__class__ # avoid this!
<class 'object'>

kiểm tra loại

Có một cách đơn giản để xác định xem một biến là một danh sách, từ điển, hoặc cái gì khác không? Tôi đang nhận được một đối tượng có thể là một trong hai loại và tôi cần có thể nói sự khác biệt.

Đó là một câu hỏi khác, không sử dụng loại - sử dụng isinstance:

def foo(obj):
    """given a string with items separated by spaces, 
    or a list or tuple, 
    do something sensible
    """
    if isinstance(obj, str):
        obj = str.split()
    return _foo_handles_only_lists_or_tuples(obj)

Điều này bao gồm trường hợp người dùng của bạn có thể làm điều gì đó thông minh hoặc hợp lý bằng cách phân lớp str- theo nguyên tắc Thay thế Liskov, bạn muốn có thể sử dụng các thể hiện của lớp con mà không vi phạm mã của mình - và isinstancehỗ trợ điều này.

Sử dụng trừu tượng

Thậm chí tốt hơn, bạn có thể tìm kiếm một Lớp cơ sở trừu tượng cụ thể từ collectionshoặc numbers:

from collections import Iterable
from numbers import Number

def bar(obj):
    """does something sensible with an iterable of numbers, 
    or just one number
    """
    if isinstance(obj, Number): # make it a 1-tuple
        obj = (obj,)
    if not isinstance(obj, Iterable):
        raise TypeError('obj must be either a number or iterable of numbers')
    return _bar_sensible_with_iterable(obj)

Hoặc chỉ cần đừng kiểm tra loại rõ ràng

Hoặc, có lẽ tốt nhất trong tất cả, sử dụng gõ vịt và không kiểm tra rõ ràng mã của bạn. Gõ vịt hỗ trợ thay thế Liskov với sự thanh lịch hơn và ít chi tiết hơn.

def baz(obj):
    """given an obj, a dict (or anything with an .items method) 
    do something sensible with each key-value pair
    """
    for key, value in obj.items():
        _baz_something_sensible(key, value)

Phần kết luận

• Sử dụng typeđể thực sự có được một lớp của một cá thể.
• Sử dụng isinstanceđể kiểm tra rõ ràng các lớp con thực tế hoặc trừu tượng đã đăng ký.
• Và chỉ cần tránh kiểm tra loại nơi nó có ý nghĩa.

Bạn có thể sử dụng type()hoặc isinstance().

>>> type([]) is list
True

Được cảnh báo rằng bạn có thể ghi đè listhoặc bất kỳ loại nào khác bằng cách chỉ định một biến trong phạm vi hiện tại cùng tên.

>>> the_d = {}
>>> t = lambda x: "aight" if type(x) is dict else "NOPE"
>>> t(the_d) 'aight'
>>> dict = "dude."
>>> t(the_d) 'NOPE'

Ở trên chúng ta thấy rằng dictđược gán lại cho một chuỗi, do đó, kiểm tra:

type({}) is dict

... thất bại.

Để khắc phục điều này và sử dụng type()thận trọng hơn:

>>> import __builtin__
>>> the_d = {}
>>> type({}) is dict
True
>>> dict =""
>>> type({}) is dict
False
>>> type({}) is __builtin__.dict
True

Mặc dù các câu hỏi khá cũ, tôi đã tình cờ phát hiện ra điều này trong khi tự mình tìm ra một cách thích hợp và tôi nghĩ nó vẫn cần làm rõ, ít nhất là đối với Python 2.x (không kiểm tra Python 3, nhưng vì vấn đề phát sinh với các lớp cổ điển phiên bản như vậy, có lẽ không thành vấn đề).

Ở đây tôi đang cố gắng trả lời câu hỏi của tiêu đề: làm thế nào tôi có thể xác định loại đối tượng tùy ý ? Các đề xuất khác về việc sử dụng hoặc không sử dụng isinstance đều ổn trong nhiều bình luận và câu trả lời, nhưng tôi không giải quyết những lo ngại đó.

Vấn đề chính với type()cách tiếp cận là nó không hoạt động đúng với các thể hiện kiểu cũ :

class One:
    pass

class Two:
    pass


o = One()
t = Two()

o_type = type(o)
t_type = type(t)

print "Are o and t instances of the same class?", o_type is t_type

Thực hiện đoạn trích này sẽ mang lại:

Are o and t instances of the same class? True

Trong đó, tôi lập luận, không phải là điều mà hầu hết mọi người mong đợi.

Cách __class__tiếp cận gần nhất với tính chính xác, nhưng nó sẽ không hoạt động trong một trường hợp quan trọng: khi đối tượng truyền vào là một lớp kiểu cũ (không phải là một thể hiện!), Vì các đối tượng đó thiếu thuộc tính như vậy.

Đây là đoạn mã nhỏ nhất mà tôi có thể nghĩ rằng đáp ứng câu hỏi hợp pháp như vậy theo một cách nhất quán:

#!/usr/bin/env python
from types import ClassType
#we adopt the null object pattern in the (unlikely) case
#that __class__ is None for some strange reason
_NO_CLASS=object()
def get_object_type(obj):
    obj_type = getattr(obj, "__class__", _NO_CLASS)
    if obj_type is not _NO_CLASS:
        return obj_type
    # AFAIK the only situation where this happens is an old-style class
    obj_type = type(obj)
    if obj_type is not ClassType:
        raise ValueError("Could not determine object '{}' type.".format(obj_type))
    return obj_type

cẩn thận khi sử dụng isinstance

isinstance(True, bool)
True
>>> isinstance(True, int)
True

nhưng loại

type(True) == bool
True
>>> type(True) == int
False

Ngoài các câu trả lời trước đó, cần đề cập đến sự tồn tại của collections.abcnó chứa một số lớp cơ sở trừu tượng (ABC) bổ sung cho việc gõ vịt.

Ví dụ: thay vì kiểm tra rõ ràng nếu một cái gì đó là một danh sách với:

isinstance(my_obj, list)

bạn có thể, nếu bạn chỉ muốn xem liệu đối tượng bạn có cho phép nhận vật phẩm hay không, hãy sử dụng collections.abc.Sequence:

from collections.abc import Sequence
isinstance(my_obj, Sequence) 

nếu bạn thực sự quan tâm đến các đối tượng cho phép nhận, cài đặt và xóa các mục (nghĩa là các chuỗi có thể thay đổi ), bạn sẽ chọn collections.abc.MutableSequence.

Nhiều ABCs khác được định nghĩa ở đó, Mappingcho các đối tượng có thể được sử dụng như bản đồ, Iterable, Callable, vân vân. Một danh sách đầy đủ của tất cả những điều này có thể được nhìn thấy trong tài liệu cho collections.abc.

Nói chung, bạn có thể trích xuất một chuỗi từ đối tượng với tên lớp,

str_class = object.__class__.__name__

và sử dụng nó để so sánh,

if str_class == 'dict':
    # blablabla..
elif str_class == 'customclass':
    # blebleble..

Trong nhiều trường hợp thực tế thay vì sử dụng typehoặc isinstancebạn cũng có thể sử dụng @functools.singledispatch, được sử dụng để xác định các hàm chung ( hàm bao gồm nhiều hàm thực hiện cùng một hoạt động cho các loại khác nhau ).

Nói cách khác, bạn sẽ muốn sử dụng nó khi bạn có một mã như sau:

def do_something(arg):
    if isinstance(arg, int):
        ... # some code specific to processing integers
    if isinstance(arg, str):
        ... # some code specific to processing strings
    if isinstance(arg, list):
        ... # some code specific to processing lists
    ...  # etc

Đây là một ví dụ nhỏ về cách thức hoạt động của nó:

from functools import singledispatch


@singledispatch
def say_type(arg):
    raise NotImplementedError(f"I don't work with {type(arg)}")


@say_type.register
def _(arg: int):
    print(f"{arg} is an integer")


@say_type.register
def _(arg: bool):
    print(f"{arg} is a boolean")

>>> say_type(0)
0 is an integer
>>> say_type(False)
False is a boolean
>>> say_type(dict())
# long error traceback ending with:
NotImplementedError: I don't work with <class 'dict'>

Ngoài ra, chúng ta có thể sử dụng các lớp trừu tượng để bao gồm nhiều loại cùng một lúc:

from collections.abc import Sequence


@say_type.register
def _(arg: Sequence):
    print(f"{arg} is a sequence!")

>>> say_type([0, 1, 2])
[0, 1, 2] is a sequence!
>>> say_type((1, 2, 3))
(1, 2, 3) is a sequence!

type()là một giải pháp tốt hơn isinstance(), đặc biệt là booleans:

Truevà Falsechỉ là những từ khóa có nghĩa 1và 0trong python. Như vậy

isinstance(True, int)

và

isinstance(False, int)

Cả hai trở về True. Cả hai booleans là một thể hiện của một số nguyên. type()tuy nhiên, thông minh hơn:

type(True) == int

trả lại False.