Xác thực địa chỉ IP trong Python

Trong bài viết này, chúng ta sẽ thảo luận về ba cách khác nhau để kiểm tra xem một chuỗi có phải là Địa chỉ IP hợp lệ trong Python hay không

Mục lục

  • Kiểm tra xem Chuỗi có phải là Địa chỉ IP hợp lệ hay không bằng Regex
  • Kiểm tra xem Chuỗi có phải là Địa chỉ IP hợp lệ hay không bằng cách sử dụng mô-đun ipaddress
  • Kiểm tra xem Chuỗi có phải là Địa chỉ IP hợp lệ hay không bằng cách sử dụng mô-đun ổ cắm

Kiểm tra xem Chuỗi có phải là Địa chỉ IP hợp lệ hay không bằng Regex

Trong Python, mô-đun regex cung cấp hàm thành viên search[], chấp nhận một chuỗi và mẫu biểu thức chính quy làm đối số. Sau đó, nó tìm kiếm các chuỗi con trong chuỗi đã cho dựa trên mẫu biểu thức chính quy đó. Nếu mẫu được tìm thấy thì nó trả về một đối tượng Match, nếu không thì trả về Không có. Chúng tôi sẽ sử dụng cùng một biểu thức chính quy. search[] với mẫu biểu thức chính quy –> “^[\d{1,3}]\. [\d{1,3}]\. [\d{1,3}]\. [\d{1,3}]$”. Mẫu biểu thức chính quy này tìm kiếm chuỗi Địa chỉ IP hợp lệ. Nó xác minh rằng chuỗi chứa bốn số [ba chữ số], được phân tách bằng dấu chấm. Sau đó, chúng ta cần kiểm tra xem mỗi số này có nằm trong phạm vi từ 0 đến 255 không

Chúng tôi đã tạo một hàm riêng, sẽ sử dụng mẫu biểu thức chính quy này để kiểm tra xem một chuỗi đã cho có hợp lệ hay không. e

import re 

def valid_IP_Address[sample_str]:
    ''' Returns True if given string is a
        valid IP Address, else returns False'''
    result = True
    match_obj = re.search[ r"^[\d{1,3}]\.[\d{1,3}]\.[\d{1,3}]\.[\d{1,3}]$", sample_str]
    if  match_obj is None:
        result = False
    else:
        for value in match_obj.groups[]:
            if int[value] > 255:
                result = False
                break
    return result

Hãy sử dụng chức năng này với một số chuỗi nhất định để xác minh xem chúng có chứa Địa chỉ IP hợp lệ hay không. Ví dụ,

Giả sử chúng ta có một chuỗi;

Các địa chỉ IPv4 được biểu diễn theo quy tắc dưới dạng ký hiệu thập phân chấm, bao gồm bốn số thập phân, mỗi số nằm trong khoảng từ 0 đến 255, được phân tách bằng dấu chấm [". "], Ví dụ: 192. 168. 254. 1; . Ví dụ: địa chỉ 192. 168. 254. 01 không hợp lệ

Các địa chỉ IPv6 được biểu diễn dưới dạng tám nhóm gồm bốn chữ số thập lục phân, mỗi nhóm biểu thị 16 bit. Các nhóm được phân tách bằng dấu hai chấm [". "]. Ví dụ: giả sử địa chỉ là 2001. 0db8. 85a3. 0000. 0000. 8a2e. 0370. 7334 là một địa chỉ hợp lệ. Ngoài ra, chúng ta có thể bỏ một số số 0 đứng đầu trong số bốn chữ số thập lục phân và một số ký tự chữ thường trong địa chỉ thành chữ hoa, vì vậy 2001. db8. 85a3. 0. 0. 8A2E. 0370. 7334 địa chỉ này cũng hợp lệ

Tuy nhiên, chúng tôi không thay thế một nhóm liên tiếp có giá trị bằng 0 bằng một nhóm trống duy nhất bằng cách sử dụng hai dấu hai chấm liên tiếp [. ] theo đuổi sự đơn giản. Vì vậy, ví dụ, năm 2001. 0db8. 85a3. 8A2E. 0370. 7334 là địa chỉ IPv6 không hợp lệ. Ngoài ra, thêm các số 0 đứng đầu trong IPv6 cũng không hợp lệ. Địa chỉ 02001. 0db8. 85a3. 0000. 0000. 8a2e. 0370. 7334 không hợp lệ

Để giải quyết vấn đề này, chúng tôi sẽ làm theo các bước sau -

  • Xác định một phương thức checkv4[x], điều này sẽ kiểm tra xem x có nằm trong phạm vi từ 0 đến 255 hay không, sau đó là true, nếu không thì là false

    Tôi phải đánh giá cao Markus Jarderot về bài đăng của anh ấy - phần lớn bài đăng của tôi được lấy cảm hứng từ bài viết của anh ấy.

    Tôi thấy rằng câu trả lời của Markus vẫn không thành công trong một số ví dụ về IPv6 trong tập lệnh Perl được tham chiếu bởi câu trả lời của anh ấy

    Đây là biểu thức chính quy của tôi vượt qua tất cả các ví dụ trong tập lệnh Perl đó

    r"""^
         \s* # Leading whitespace
         # Zero-width lookaheads to reject too many quartets
         [?:
            # 6 quartets, ending IPv4 address; no wildcards
            [?:[0-9a-f]{1,4}[?::[?!:]]]{6}
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # 0-5 quartets, wildcard, ending IPv4 address
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,4}[0-9a-f]{1,4}]?
            [?:::[?!:]]
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # 0-4 quartets, wildcard, 0-1 quartets, ending IPv4 address
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,3}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[0-9a-f]{1,4}[?::[?!:]]]?
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # 0-3 quartets, wildcard, 0-2 quartets, ending IPv4 address
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,2}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[0-9a-f]{1,4}[?::[?!:]]]{0,2}
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # 0-2 quartets, wildcard, 0-3 quartets, ending IPv4 address
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,1}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[0-9a-f]{1,4}[?::[?!:]]]{0,3}
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # 0-1 quartets, wildcard, 0-4 quartets, ending IPv4 address
            [?:[0-9a-f]{1,4}]{0,1}
            [?:::[?!:]]
            [?:[0-9a-f]{1,4}[?::[?!:]]]{0,4}
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # wildcard, 0-5 quartets, ending IPv4 address
            [?:::[?!:]]
            [?:[0-9a-f]{1,4}[?::[?!:]]]{0,5}
                 [?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]
            [?:\.[?:25[0-4]|2[0-4]\d|1\d\d|[1-9]\d|\d]]{3}
          |
            # 8 quartets; no wildcards
            [?:[0-9a-f]{1,4}[?::[?!:]]]{7}[0-9a-f]{1,4}
          |
            # 0-7 quartets, wildcard
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,6}[0-9a-f]{1,4}]?
            [?:::[?!:]]
          |
            # 0-6 quartets, wildcard, 0-1 quartets
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,5}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[0-9a-f]{1,4}]?
          |
            # 0-5 quartets, wildcard, 0-2 quartets
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,4}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,1}[0-9a-f]{1,4}]?
          |
            # 0-4 quartets, wildcard, 0-3 quartets
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,3}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,2}[0-9a-f]{1,4}]?
          |
            # 0-3 quartets, wildcard, 0-4 quartets
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,2}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,3}[0-9a-f]{1,4}]?
          |
            # 0-2 quartets, wildcard, 0-5 quartets
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,1}[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,4}[0-9a-f]{1,4}]?
          |
            # 0-1 quartets, wildcard, 0-6 quartets
            [?:[0-9a-f]{1,4}]?
            [?:::[?!:]]
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,5}[0-9a-f]{1,4}]?
          |
            # wildcard, 0-7 quartets
            [?:::[?!:]]
            [?:[?:[0-9a-f]{1,4}[?::[?!:]]]{0,6}[0-9a-f]{1,4}]?
         ]
         [?:/[?:1[?:2[0-7]|[01]\d]|\d\d?]]? # With an optional CIDR routing prefix [0-128]
         \s* # Trailing whitespace
        $"""
    

    Tôi cũng tập hợp một tập lệnh Python để kiểm tra tất cả các ví dụ về IPv6 đó;

    Bạn có thể chạy tập lệnh với các đối số kết quả kiểm tra và mẫu ở dạng "[kết quả]=[ví dụ]", chẳng hạn như

    Làm cách nào để xác thực địa chỉ IP?

    Địa chỉ IP hợp lệ phải ở dạng A. B. C. D, trong đó A, B, C và D là các số từ 0-255 . Các số không thể có tiền tố là 0 trừ khi chúng là 0.

    Làm cách nào để xác thực địa chỉ IP mà không cần regex?

    Định dạng của địa chỉ IP là địa chỉ số 32 bit được viết dưới dạng bốn số thập phân [được gọi là octet] được phân tách bằng dấu chấm; . g. – 0. 0. 0. 0 đến 255. 255. 255. 255]. Phương pháp số 1. Kiểm tra số khoảng thời gian bằng cách sử dụng phương thức đếm[] và sau đó kiểm tra phạm vi số giữa mỗi khoảng thời gian .

Chủ Đề