Hướng dẫn kiểm tra code python

Một case đơn giản cho các bạn làm quen với lập trình Python cơ bản, đó là kiểm tra kiểu dữ liệu truyền vào hoặc biến quy định có dữ liệu format địa chỉ IP hợp lệ hay không ?

Contents

• Các bước kiểm tra địa chỉ IP format hợp lệ trên Python
  • 1. Ý tưởng code check biến IP có hợp lệ không ?
  • 2. Ví dụ code và chạy

1. Ý tưởng code check biến IP có hợp lệ không ?

Ý tưởng sẽ gồm các bước như sau :
– Tách các giá trị số ip thành các giá trị riêng lẻ trong 1 danh sách theo kí tự phân cách ‘.’, tức format IP ‘x1.x2.x3.x4‘ sẽ thành [‘x1‘,’x2‘,’x3‘,’x4‘] – Khi phân tách ra như vậy sẽ trở thành danh sách [list] các phần tử số của các octet số.
– Kiểm tra số lượng các octet số có đủ 4 hay không -> nếu không, trả bolean False.
– Chạy vòng lặp for với danh sách số đã phân tách ra
-+ Nếu số đó không phải là số hoàn toàn -> trả boolean False.
-+ Nếu số đó nhỏ hơn 0 và lớn hơn 255 [tức khoảng giá trị số IP octet. 0-255]

2. Ví dụ code và chạy

2.1 Code mẫu, cú pháp python 2.7

#!/usr/bin/python
__author__ = "Quach Chi Cuong"
__note__ = "Demo Only"

import sys


# Function check IP type valid
def checkip_type[ip]:
	ip_tmp = ip.split['.']
	if len[ip_tmp] != 4:
		return False

	for x in ip_tmp:
		if not x.isdigit[]:
			return False
		i = int[x]
		if i < 0 or i > 255:
			return False

	return True


def main[]:
	ip_input = sys.argv[1]
	if checkip_type[ip_input]:
		print "IP %s hop le" % ip_input
	else:
		print "IP %s khong hop le" % ip_input


if __name__ == '__main__':
	main[]

 
2.2 Chạy code

# python checkip.py 192.168.1.1
IP 192.168.1.1 hop le

# python2.7 checkip.py 192.168.256.255
IP 192.168.256.255 khong hop le

 
Như vậy các bạn đã biết cách code python kiểm tra cơ bản dữ liệu truyền vào hoặc biến có được là format IP hợp lệ hay không ?

Trong phần này chúng ta sẽ tìm hiểu một số hàm kiểm tra trạng thái.

Trong Python mọi thứ đều là đối tượng. Một đối tượng thì có các thuộc tính và phương thức. Chúng ta có thể dùng các hàm kiểm tra để biết các thuộc tính và phương thức của một đối tượng.

Hàm dir[]

Hàm dir[] trả về một danh sách các thuộc tính và phương thức có trong một đối tượng.

>>> dir[[]]
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

Trong ví dụ trên chúng ta dùng hàm dir[] để xem các thuộc tính và phương thức có trong một tuple.

>>> print [[].__doc__]
tuple[] -> empty tuple
tuple[iterable] -> tuple initialized from iterable's items

If the argument is a tuple, the return value is the same object.

Trong đó có thuộc tính __doc__, chúng ta có thể dùng hàm print[] để xem nội dung của thuộc tính này.

import sys

class Object:
   def __init__[self]:
      pass
   def examine[self]:
      print [self]


o = Object[]

print [dir[o]]
print [dir[[]]]
print [dir[{}]]
print [dir[1]]
print [dir[]]
print [dir[len]]
print [dir[sys]]
print [dir["String"]]

Trong đoạn code trên chúng ta kiểm tra một vài đối tượng khác nhau trong đó có cả đối tượng thuộc lớp do chúng ta định nghĩa.

Nếu không đưa tham số vào thì hàm dir[] trả về tên các module trong chương trình.

>>> dir[]
['__builtins__', '__doc__', '__name__', '__package__']
>>> import sys
>>> import math, os
>>> dir[]
['__builtins__', '__doc__', '__name__', '__package__', 'math', 'os', 'sys']

Hàm type[] và id[]

Hàm type[] trả về kiểu dữ liệu của một đối tượng.

import sys

def function[]: pass

class MyObject[]:
   def __init__[self]:
      pass

o = MyObject[]

print [type[1]]
print [type[""]]
print [type[[]]]
print [type[{}]]
print [type[[]]]
print [type[object]]
print [type[function]]
print [type[MyObject]]
print [type[o]]
print [type[sys]]

Trong ví dụ trên chúng ta in ra kiểu dữ liệu của một số đối tượng.

Hàm id[] sẽ trả về id của một đối tượng.

import sys

def fun[]: pass

class MyObject[]:
   def __init__[self]:
      pass

o = MyObject[]

print [id[1]]
print [id[""]]
print [id[{}]]
print [id[[]]]
print [id[sys]]
print [id[fun]]
print [id[MyObject]]
print [id[o]]
print [id[object]]

Trong ví dụ trên chúng ta in ra id của một số đối tượng, kể cả đối tượng có sẵn trong Python.

135717024

3084111220
3084104940
3084304500
3084112812
3084074556
3084130444
135568640

Module sys

Module sys cung cấp các thông tin về hệ điều hành và tình trạng của Python.

>>> import sys
>>> sys.version
'3.5.1 [v3.5.1:37a07cee5969, Dec  6 2015, 01:38:48] [MSC v.1900 32 bit [Intel]]'
>>> sys.platform
'win32'
>>> sys.path
['C:\\Users\\PhoCode\\', 'C:\\python\\python35.zip', 'C:\\python\\DLLs', 'C:\\python\\lib', 'C:\\python', 'C:\\python\\lib\\site-packages']

Trong ví dụ trên chúng ta kiểm tra phiên bản Python, tên hệ điều hành và các đường dẫn thư mục liên quan.

Chúng ta sẽ kiểm tra một số thuộc tính khác trong module sys. Bạn cũng có thể dùng hàm dir[] để lấy về danh sách đầy đủ các thuộc tính và phương thức có trong module sys.

>>> sys.maxsize
2147483647
>>> sys.executable
'C:\\python\\python.exe'
>>> sys.argv
['']

Trong ví dụ trên chúng ta kiểm tra 3 thuộc tính là maxsize, executable, và argv.

>>> sys.maxsize
2147483647

Thuộc tính maxsize lưu trữ giá trị số nguyên lớn nhất được hỗ trợ trong Python.

>>> sys.executable
'C:\\python\\python.exe'

Thuộc tính executable trả về đường dẫn đầy đủ đến trình thông dịch Python.

>>> sys.argv
['']

Thuộc tính argv trả về tham số được đưa vào trình thông dịch Python. Ở đây là danh sách rỗng, nếu bạn chạy từ file script thì tham số này sẽ có ít nhất đường dẫn đến file script của bạn.

Một số hàm khác

def fun[]: pass

print [hasattr[object, '__doc__']]
print [hasattr[fun, '__doc__']]
print [hasattr[fun, '__call__']]

print [getattr[object, '__doc__']]
print [getattr[fun, '__doc__']]

Hàm hasattr[] kiểm tra xem một đối tượng nào đó có chứa thuộc tính nào đó không. Hàm getattr[] sẽ trả về nội dung của thuộc tính đó nếu có.

True
True
True
The most base type
None

Hàm isinstance kiểm tra xem một đối tượng có thuộc một lớp nào đó không.

class MyObject[]:
   def __init__[self]:
      pass

o = MyObject[]

print [isinstance[o, MyObject]]
print [isinstance[o, object]]
print [isinstance[2, int]]
print [isinstance['str', str]]

Chúng ta đã biết là tất cả mọi thứ trong Python đều là đối tượng, kể cả số hay chuỗi. Tất cả các lớp trong Python đều kế thừa từ một lớp cơ sở có tên là object. Do đó hàm instance sẽ trả về true nếu chúng ta kiểm tra xem một đối tượng có thuộc lớp object hay không.

True
True
True
True

Hàm issubclass[] kiểm tra xem một lớp có được kế thừa từ một lớp khác hay không. Nếu chúng ta dùng hàm issubclass[] với 2 tham số giống nhau thì cũng trả về True, nói cách khác trong Python thì một lớp cũng là lớp con của chính nó.

class Object[]:
   def __init__[self]:
      pass

class Wall[Object]:
   def __init__[self]:
      pass

print [issubclass[Object, Object]]
print [issubclass[Object, Wall]]
print [issubclass[Wall, Object]]
print [issubclass[Wall, Wall]]

Trong ví dụ trên, chúng ta định nghĩa lớp Wall kế thừa từ lớp Object.

True
False
True
True

Thuộc tính __doc__ là đoạn chuỗi mô tả về một đối tượng nào đó. Thuộc tính __name__ là chuỗi chứa tên của một đối tượng nào đó.

def noaction[]:
   '''Blah blah blah'''
   pass


funcs = [noaction, len, str]

for i in funcs:
   print [i.__name__]
   print [i.__doc__]
   print ["-" * 75]

Trong ví dụ trên, chúng ta tạo một list chứa tên các hàm, trong đó có một hàm do chúng ta tự định nghĩa, 2 hàm còn lại có sẵn. Sau đó chúng ta duyệt qua list này và in nội dung hai thuộc tính __name__ và __doc__ của mỗi hàm ra.

noaction
Blah blah blah
---------------------------------------------------------------------------
len
len[object] -> integer

Return the number of items of a sequence or mapping.
---------------------------------------------------------------------------
str
str[object] -> string

Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
---------------------------------------------------------------------------

Cuối cùng là hàm callable[], hàm này kiểm tra xem một đối tượng có phải là một hàm hay không.

class Car:      
    def setName[self, name]:
        self.name = name    

def fun[]:
    pass

c = Car[]    
    
print [callable[fun]]
print [callable[c.setName]]
print [callable[[]]]
print [callable[1]]

Trong ví dụ trên chúng ta kiểm tra 4 đối tượng fun, c.setName, [] [list rỗng] và số 1 có phải là các hàm hay không.

print [callable[fun]]
print [callable[c.setName]]

Chắc chắn fun chính là một hàm do chúng ta tự định nghĩa, setName[] là một phương thức [hàm nằm trong một lớp] của lớp Car.

True
True
False
False