Hướng dẫn how check variable type in if condition python? - cách kiểm tra loại biến trong if điều kiện python?

TLDR:

Sử dụng if isinstance[x, int]: trừ khi bạn có lý do không.
Sử dụng if type[x] is int: nếu bạn cần loại bình đẳng chính xác và không có gì khác.
Sử dụng
```
if x.__class__ is int:
```
0 nếu bạn ổn với việc chuyển đổi sang loại đích.

Có một "nó phụ thuộc" thực sự lớn vào việc kiểm tra loại trong Python. Có nhiều cách để đối phó với các loại, và tất cả đều có ưu và nhược điểm của chúng. Với Python3, một vài người khác đã xuất hiện.

Loại bình đẳng rõ ràng

Các loại là các đối tượng hạng nhất và bạn có thể đối xử với chúng như bất kỳ giá trị nào khác. Vì vậy, nếu bạn muốn loại thứ gì đó bằng

if x.__class__ is int:

1, chỉ cần kiểm tra nó:

if type[x] is int:

Đây là loại thử nghiệm hạn chế nhất: nó đòi hỏi sự bình đẳng loại chính xác. Thông thường, đây không phải là điều bạn muốn:

Nó loại trừ các loại thay thế: A
```
if x.__class__ is int:
```
2 sẽ không hợp lệ, mặc dù nó hoạt động như một
```
if x.__class__ is int:
```
1 cho nhiều mục đích.
Nó loại trừ các lớp con và các loại trừu tượng: một lớp con in đẹp
```
if x.__class__ is int:
```
1 hoặc
```
if x.__class__ is int:
```
5 sẽ bị từ chối, mặc dù chúng là số nguyên logic.
- Điều này giới hạn nghiêm trọng tính di động: chuỗi Python2 có thể là
```
if x.__class__ is int:
```
  6 hoặc
```
if x.__class__ is int:
```
  7, và các số nguyên có thể là
```
if x.__class__ is int:
```
  1 hoặc
```
if x.__class__ is int:
```
  9.

Lưu ý rằng sự bình đẳng loại rõ ràng có cách sử dụng cho các hoạt động cấp thấp:

Một số loại không thể được phân lớp, chẳng hạn như

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

0. Một kiểm tra rõ ràng là, tốt, rõ ràng hơn ở đây.

Một số hoạt động cấp thấp, chẳng hạn như tuần tự hóa hoặc C-API, yêu cầu các loại cụ thể.

Biến thể

Một so sánh cũng có thể được thực hiện đối với thuộc tính

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

if x.__class__ is int:

Lưu ý nếu một lớp xác định thuộc tính

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

1, điều này không giống như

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

Khi có một số lớp để kiểm tra, sử dụng

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

4 để gửi hành động có thể mở rộng hơn và có thể nhanh hơn [≥5-10 loại] so với kiểm tra rõ ràng. Điều này đặc biệt hữu ích cho chuyển đổi và tuần tự hóa:

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

Kiểm tra ví dụ về các loại rõ ràng

Bài kiểm tra loại thành ngữ sử dụng

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

5 tích hợp:

if isinstance[x, int]:

Kiểm tra này là chính xác và hiệu suất. Đây thường là những gì mọi người muốn kiểm tra các loại:

Nó xử lý các phân nhóm đúng cách. Một lớp con in đẹp
```
if x.__class__ is int:
```
1 vẫn sẽ vượt qua bài kiểm tra này.

Nó cho phép kiểm tra nhiều loại cùng một lúc. Trong Python2, làm

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

7 giúp bạn có tất cả các số nguyên được xây dựng.

Quan trọng nhất, các nhược điểm là không đáng kể hầu hết thời gian:

Nó vẫn chấp nhận các lớp con thú vị hoạt động theo những cách kỳ lạ. Vì bất cứ điều gì có thể được thực hiện để cư xử theo những cách kỳ lạ, điều này là vô ích để bảo vệ chống lại.

Nó có thể dễ dàng quá hạn chế: nhiều người kiểm tra

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

8 khi bất kỳ chuỗi nào [ví dụ:

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

9] hoặc thậm chí có thể điều chỉnh được [ví dụ:

if isinstance[x, int]:

0] cũng sẽ làm như vậy. Đây là một mối quan tâm cho các thư viện mục đích chung hơn là tập lệnh hoặc ứng dụng.

Khác nhau

Nếu bạn đã có một loại,

if isinstance[x, int]:

1 hành xử giống nhau:

if issubclass[x_type, int]:

Kiểm tra ví dụ về loại trừu tượng

Python có một khái niệm về các lớp cơ sở trừu tượng. Nói một cách lỏng lẻo, những điều này thể hiện ý nghĩa của các loại, không phải thứ bậc của chúng:

if isinstance[x, numbers.Real]:  # accept anything you can sum up like a number

Nói cách khác, loại [x] không nhất thiết phải thừa hưởng từ

if isinstance[x, int]:

2 mà phải hành xử như nó. Tuy nhiên, đây là một khái niệm rất phức tạp và khó khăn:

Nó thường quá mức cần thiết nếu bạn đang tìm kiếm các loại cơ bản. Một số nguyên chỉ đơn giản là một
```
if x.__class__ is int:
```
1 hầu hết thời gian.
Mọi người đến từ các ngôn ngữ khác thường nhầm lẫn các khái niệm của nó.
- Phân biệt nó với ví dụ: C ++, trọng tâm là lớp cơ sở trừu tượng trái ngược với lớp cơ sở trừu tượng.
- ABC có thể được sử dụng như giao diện Java, nhưng vẫn có thể có chức năng cụ thể.

Tuy nhiên, nó cực kỳ hữu ích cho các thư viện chung và trừu tượng.

Nhiều chức năng/thuật toán không cần các loại rõ ràng, chỉ là hành vi của chúng.
- Nếu bạn chỉ cần tra cứu mọi thứ theo chìa khóa,
```
dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]
```
  4 sẽ hạn chế bạn ở một loại trong bộ nhớ cụ thể. Ngược lại,
```
if isinstance[x, int]:
```
  5 cũng bao gồm các trình bao bọc cơ sở dữ liệu, từ điển do đĩa lớn, các thùng chứa lười biếng, ... - và
```
dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]
```
  4.
Nó cho phép thể hiện các ràng buộc loại một phần.
- Không có loại cơ sở nghiêm ngặt thực hiện lặp lại. Nhưng nếu bạn kiểm tra các đối tượng chống lại
```
if isinstance[x, int]:
```
  7, tất cả chúng đều hoạt động trong vòng lặp
```
if isinstance[x, int]:
```
  8.
Nó cho phép tạo các triển khai riêng biệt, được tối ưu hóa xuất hiện dưới dạng cùng loại trừu tượng.

Mặc dù thường không cần thiết cho các kịch bản vứt bỏ, tôi rất khuyên bạn nên sử dụng điều này cho bất cứ điều gì sống ngoài một vài bản phát hành Python.

Chuyển đổi dự kiến

Cách xử lý thành ngữ không phải là để kiểm tra chúng, mà là cho rằng chúng tương thích. Nếu bạn đã mong đợi một số loại sai trong đầu vào của mình, chỉ cần bỏ qua mọi thứ không tương thích:

try:
    ix = int[x]
except [ValueError, TypeError]:
    continue  # not compatible with int, try the next one
else:
    a.append[ix]

Đây không thực sự là một kiểm tra loại, nhưng thường phục vụ cùng một ý định.

Nó đảm bảo bạn có loại dự kiến trong đầu ra của bạn.
Nó có một số thời gian hạn chế trong việc chuyển đổi các loại sai, ví dụ: Chuyên
```
if x.__class__ is int:
```
2 đến
```
if x.__class__ is int:
```
1.
Nó hoạt động mà bạn không biết loại nào phù hợp với
```
if x.__class__ is int:
```
1.

Nhược điểm chính là nó là một sự chuyển đổi rõ ràng.

Bạn có thể âm thầm chấp nhận các giá trị "sai", ví dụ: Chuyển đổi một
```
if x.__class__ is int:
```
6 chứa một nghĩa đen.
Nó không cần thiết phải chuyển đổi ngay cả các loại sẽ đủ tốt, ví dụ:
```
if x.__class__ is int:
```
2 đến
```
if x.__class__ is int:
```
1 khi bạn chỉ cần số.

Chuyển đổi là một công cụ hiệu quả cho một số trường hợp sử dụng cụ thể. Nó hoạt động tốt nhất nếu bạn biết gần như đầu vào của bạn là gì và phải đảm bảo về đầu ra của bạn.

Chức năng công văn

Đôi khi mục tiêu kiểm tra loại chỉ là chọn một chức năng thích hợp. Trong trường hợp này, công văn chức năng như

if issubclass[x_type, int]:

5 cho phép triển khai chức năng chuyên môn cho các loại cụ thể:

@singledispatch
def append_int[value, sequence]:
    return

@append_int.register
def _[value: int, sequence]:
    sequence.append[value]

Đây là sự kết hợp của công văn

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

5 và

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]

4. Nó hữu ích nhất cho các ứng dụng lớn hơn:

Nó giữ cho trang web sử dụng nhỏ, bất kể số lượng các loại được gửi đi.
Nó cho phép đăng ký các chuyên ngành cho các loại bổ sung sau này, ngay cả trong các mô -đun khác.

Tuy nhiên, nó không đến mà không có nhược điểm của nó:

Có nguồn gốc từ các ngôn ngữ được đánh máy chức năng và được đánh máy mạnh mẽ, nhiều lập trình viên Python không quen thuộc với nhiều hoặc thậm chí là nhiều lần.
Các công văn yêu cầu các chức năng riêng biệt và do đó không phù hợp để được xác định tại vị trí sử dụng.
- Tạo các chức năng và "làm nóng" bộ nhớ cache có chi phí thời gian chạy đáng chú ý. Các chức năng điều phối nên được xác định một lần và thường xuyên sử dụng lại.
- Ngay cả một bảng điều phối ấm áp cũng chậm hơn so với việc viết tay nếu/khác hoặc tìm kiếm
```
dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert[x]:
    converter = self.dispatch_dict[type[x]]  # lookup callable based on type
    return converter[x]
```
  4.

Kiểm soát đầu vào

Quá trình hành động tốt nhất là đảm bảo bạn không bao giờ phải kiểm tra loại ở nơi đầu tiên. Đây là một chút của một siêu chủ đề, vì nó phụ thuộc mạnh mẽ vào trường hợp sử dụng.

Ở đây, nguồn gốc của

if issubclass[x_type, int]:

9 không bao giờ nên đưa những người không phải là người vào đó.

Làm thế nào để bạn kiểm tra xem một biến có thuộc loại nhất định trong Python không?

Sử dụng hàm loại [] để kiểm tra loại biến trong Python để kiểm tra loại biến, bạn có thể sử dụng hàm loại [], lấy biến làm đầu vào. Bên trong hàm này, bạn phải vượt qua tên biến hoặc chính giá trị. Và nó sẽ trả về kiểu dữ liệu biến. to Check Variable Type in Python To check the type of a variable, you can use the type[] function, which takes the variable as an input. Inside this function, you have to pass either the variable name or the value itself. And it will return the variable data type.

Làm thế nào để bạn kiểm tra xem một biến thuộc loại?

Bạn có thể sử dụng toán tử loại để kiểm tra biến.Nó trả về một chuỗi biểu thị loại của toán hạng không được đánh giá.use the typeof operator to check the variable. It returns a string which indicates the type of the unevaluated operand.

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

Sử dụng isInstance [] để kiểm tra xem một biến có phải là một cuộc gọi số nguyên [biến, int] để trả về giá trị boolean cho biết liệu biến có thuộc loại int hay không. to check if a variable is an integer Call isinstance[variable, int] to return a boolean value indicating whether variable is of type int .

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

Đây là cách đơn giản nhất để kiểm tra sự tồn tại của phần tử trong danh sách.Python là cách thông thường nhất để kiểm tra xem một yếu tố có tồn tại trong danh sách hay không.Cách cụ thể này trả về đúng nếu một phần tử tồn tại trong danh sách và sai nếu phần tử không tồn tại trong danh sách.returns True if an element exists in the list and False if the element does not exist in the list.