Hướng dẫn how do you check if a variable is of a certain type in python? - làm cách nào để kiểm tra xem một biến có thuộc một loại nào đó trong python không?

Câu trả lời được chấp nhận trả lời câu hỏi trong đó nó cung cấp câu trả lời cho các câu hỏi đã hỏi.

Q: Cách tốt nhất để kiểm tra xem một đối tượng nhất định có thuộc loại nhất định là gì? Làm thế nào về việc kiểm tra xem đối tượng kế thừa từ một loại nhất định?

A: Sử dụng isinstance, issubclass, type để kiểm tra dựa trên các loại.

Tuy nhiên, vì các câu trả lời và bình luận khác nhanh chóng chỉ ra, có rất nhiều ý tưởng về "kiểm tra loại" so với trong Python. Kể từ khi bổ sung Python 3 và gợi ý loại, nhiều điều cũng đã thay đổi. Dưới đây, tôi đi qua một số khó khăn với việc kiểm tra loại, gõ vịt và xử lý ngoại lệ. Đối với những người nghĩ rằng kiểm tra loại không phải là những gì cần thiết [thường thì không, nhưng chúng tôi ở đây], tôi cũng chỉ ra cách sử dụng gợi ý loại.

Kiểu kiểm tra

Kiểm tra loại không phải lúc nào cũng là một điều thích hợp để làm trong Python. Xem xét ví dụ sau:

def sum[nums]:
    """Expect an iterable of integers and return the sum."""
    result = 0
    for n in nums:
        result += n
    return result

Để kiểm tra xem đầu vào có phải là một số nguyên không, chúng tôi gặp phải một vấn đề lớn. Cách duy nhất để kiểm tra xem mọi phần tử là số nguyên sẽ là lặp qua để kiểm tra từng phần tử. Nhưng nếu chúng ta lặp qua toàn bộ trình lặp, thì sẽ không còn gì cho mã dự định. Chúng tôi có hai lựa chọn trong loại tình huống này.

1. Kiểm tra khi chúng tôi lặp.

2. Kiểm tra trước nhưng lưu trữ mọi thứ khi chúng tôi kiểm tra.

Tùy chọn 1 có nhược điểm của việc làm phức tạp mã của chúng tôi, đặc biệt nếu chúng tôi cần thực hiện kiểm tra tương tự ở nhiều nơi. Nó buộc chúng tôi phải di chuyển kiểm tra loại từ đầu hàm sang mọi nơi chúng tôi sử dụng có thể sử dụng được trong mã của chúng tôi.

Tùy chọn 2 có nhược điểm rõ ràng là nó phá hủy toàn bộ mục đích của người lặp. Toàn bộ điểm là không lưu trữ dữ liệu vì chúng ta không cần phải.

Người ta cũng có thể nghĩ rằng việc kiểm tra xem việc kiểm tra tất cả các yếu tố là quá nhiều thì có lẽ chúng ta chỉ có thể kiểm tra xem bản thân đầu vào có phải là loại không thể sử dụng được hay không, nhưng thực sự không có lớp cơ sở nào. Bất kỳ loại thực hiện __iter__ là có thể sử dụng được.

Xử lý ngoại lệ và gõ vịt

Một cách tiếp cận khác sẽ là từ bỏ kiểm tra loại hoàn toàn và tập trung vào xử lý ngoại lệ và gõ vịt thay thế. Điều đó có nghĩa là, bọc mã của bạn trong một khối Excet thử và bắt bất kỳ lỗi nào xảy ra. Ngoài ra, đừng làm bất cứ điều gì và để các ngoại lệ tăng tự nhiên từ mã của bạn.

Đây là một cách để bắt gặp một ngoại lệ.

def sum[nums]:
    """Try to catch exceptions?"""
    try:
        result = 0
        for n in nums:
            result += n
        return result
    except TypeError as e:
        print[e]

So với các tùy chọn trước đây, điều này chắc chắn là tốt hơn. Chúng tôi đang kiểm tra khi chúng tôi chạy mã. Nếu có TypeError ở bất cứ đâu, chúng ta sẽ biết. Chúng tôi không phải đặt séc ở mọi nơi mà chúng tôi lặp qua đầu vào. Và chúng tôi không phải lưu trữ đầu vào khi chúng tôi lặp lại nó.

Hơn nữa, phương pháp này cho phép gõ vịt. Thay vì kiểm tra specific types, chúng tôi đã chuyển sang kiểm tra specific behaviors và tìm kiếm khi đầu vào không hoạt động như mong đợi [trong trường hợp này, lặp qua nums và có thể thêm

def sum[nums]:
    """Try to catch exceptions?"""
    try:
        result = 0
        for n in nums:
            result += n
        return result
    except TypeError as e:
        print[e]

Tuy nhiên, những lý do chính xác làm cho việc xử lý ngoại lệ tốt đẹp cũng có thể là sự sụp đổ của họ.

1. def sum[nums]:
       """Try to catch exceptions?"""
       try:
           result = 0
           for n in nums:
               result += n
           return result
       except TypeError as e:
           print[e]
   

   1 không phải là

   def sum[nums]:
       """Try to catch exceptions?"""
       try:
           result = 0
           for n in nums:
               result += n
           return result
       except TypeError as e:
           print[e]
   

   2, nhưng nó đáp ứng các yêu cầu hành vi để làm việc.

2. Đó cũng là thực tế xấu để bọc toàn bộ mã với một khối ngoại trừ thử.

Lúc đầu, những điều này có vẻ không giống như vấn đề, nhưng đây là một số lý do có thể thay đổi suy nghĩ của bạn.

1. Người dùng không còn có thể mong đợi chức năng của chúng tôi trả về

   def sum[nums]:
       """Try to catch exceptions?"""
       try:
           result = 0
           for n in nums:
               result += n
           return result
       except TypeError as e:
           print[e]
   

   2 như dự định. Điều này có thể phá vỡ mã ở nơi khác.

2. Vì các trường hợp ngoại lệ có thể đến từ nhiều nguồn khác nhau, việc sử dụng Expect-except trên toàn bộ khối mã có thể sẽ bắt gặp các ngoại lệ mà bạn không có ý định. Chúng tôi chỉ muốn kiểm tra xem nums có được điều đó không thể hiểu được và có các yếu tố số nguyên.

3. Lý tưởng nhất là chúng tôi muốn nắm bắt các ngoại lệ của các trình tạo mã của chúng tôi và nâng cao, ở vị trí của họ, các ngoại lệ nhiều thông tin hơn. Thật không vui khi một ngoại lệ được nêu ra từ mã của người khác mà không có lời giải thích nào khác ngoài một dòng bạn không viết và một số TypeError đã xảy ra.

Để khắc phục xử lý ngoại lệ để đáp ứng với các điểm trên, mã của chúng tôi sau đó sẽ trở thành ... abomination.

def sum[nums]:
    """
    Try to catch all of our exceptions only.
    Re-raise them with more specific details.
    """
    result = 0

    try:
        iter[nums]
    except TypeError as e:
        raise TypeError["nums must be iterable"]

    for n in nums:
        try:
            result += int[n]
        except TypeError as e:
            raise TypeError["stopped mid iteration since a non-integer was found"]

    return result

Bạn có thể thấy nơi này sẽ đi. Chúng ta càng cố gắng "kiểm tra" đúng cách, mã của chúng ta càng tệ hơn. So với mã gốc, điều này không thể đọc được chút nào.

Chúng ta có thể tranh luận có lẽ đây là một chút cực đoan. Nhưng mặt khác, đây chỉ là một ví dụ rất đơn giản. Trong thực tế, mã của bạn có lẽ phức tạp hơn nhiều so với điều này.

Loại gợi ý

Chúng tôi đã thấy những gì xảy ra khi chúng tôi cố gắng sửa đổi ví dụ nhỏ của mình để "Kích hoạt kiểm tra loại". Thay vì tập trung vào việc cố gắng buộc các loại cụ thể, loại gợi ý cho phép một cách để làm cho các loại rõ ràng cho người dùng.

from typing import Iterable

def sum[nums: Iterable[int]] -> int:
    result = 0
    for n in nums:
        result += n
    return result

Dưới đây là một số lợi thế để sử dụng các loại phụ kiện.

• Mã thực sự có vẻ tốt bây giờ!

• Phân tích loại tĩnh có thể được thực hiện bởi biên tập viên của bạn nếu bạn sử dụng gợi ý loại!

• Chúng được lưu trữ trên hàm/lớp, làm cho chúng có thể sử dụng được, ví dụ:

  def sum[nums]:
      """Try to catch exceptions?"""
      try:
          result = 0
          for n in nums:
              result += n
          return result
      except TypeError as e:
          print[e]
  

  6 và

  def sum[nums]:
      """Try to catch exceptions?"""
      try:
          result = 0
          for n in nums:
              result += n
          return result
      except TypeError as e:
          print[e]
  

  7.

• Chúng hiển thị cho các chức năng khi sử dụng

  def sum[nums]:
      """Try to catch exceptions?"""
      try:
          result = 0
          for n in nums:
              result += n
          return result
      except TypeError as e:
          print[e]
  

  8.

• Không cần kiểm tra sự tỉnh táo nếu loại đầu vào của bạn là đúng dựa trên mô tả hoặc tệ hơn là thiếu.

• Bạn có thể "gõ" gợi ý dựa trên cấu trúc, ví dụ: "Nó có thuộc tính này không?" mà không yêu cầu phân lớp của người dùng.

Nhược điểm để loại gợi ý?

• Gợi ý loại không có gì khác hơn là cú pháp và văn bản đặc biệt của riêng họ. Nó không giống như kiểm tra loại.

Nói cách khác, nó không thực sự trả lời câu hỏi vì nó không cung cấp kiểm tra loại. Tuy nhiên, bất kể, nếu bạn ở đây để kiểm tra loại, thì bạn cũng nên gõ gợi ý. Tất nhiên, nếu bạn đi đến kết luận rằng việc kiểm tra loại không thực sự cần thiết nhưng bạn muốn một số ngữ nghĩa của việc gõ, thì các gợi ý loại là dành cho bạn.

Kiểm tra [] làm gì trong Python?

Làm thế nào tôi có thể kiểm tra xem một giá trị là loại python số nguyên?