Python – Các hàm kiểm tra trạng thái

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.

dir.py
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"))

dir.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	`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.

types.py
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))

types.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20	`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.

Output
<type 'int'>

<type 'str'>

<type 'list'>

<type 'dict'>

<type 'tuple'>

<type 'type'>

<type 'function'>

<type 'classobj'>

<type 'instance'>

<type 'module'>

Output
1 2 3 4 5 6 7 8 9 10	`<type` `'int'>` `<type` `'str'>` `<type` `'list'>` `<type` `'dict'>` `<type` `'tuple'>` `<type` `'type'>` `<type` `'function'>` `<type` `'classobj'>` `<type` `'instance'>` `<type` `'module'>`

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

ids.py
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))

ids.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	`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.

Output
1 2 3 4 5 6 7 8 9	`135717024` `3084304536` `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

attr.py
def fun(): pass

print (hasattr(object, '__doc__'))

print (hasattr(fun, '__doc__'))

print (hasattr(fun, '__call__'))

print (getattr(object, '__doc__'))

print (getattr(fun, '__doc__'))

attr.py
1 2 3 4 5 6 7 8	`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ó.

Output
True

True

True

The most base type

None

Output
1 2 3 4 5	`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.

instance.py
class MyObject():

   def __init__(self):

      pass

o = MyObject()

print (isinstance(o, MyObject))

print (isinstance(o, object))

print (isinstance(2, int))

print (isinstance('str', str))

instance.py
1 2 3 4 5 6 7 8 9 10	`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.

Output
True

True

True

True

Output
1 2 3 4	`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ó.

subclass.py
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))

subclass.py
1 2 3 4 5 6 7 8 9 10 11 12	`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.

Output
True

False

True

True

Output
1 2 3 4	`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 đó.

namedoc.py
def noaction():

   '''Blah blah blah'''

   pass

funcs = [noaction, len, str]

for i in funcs:

   print (i.__name__)

   print (i.__doc__)

   print ("-" * 75)

namedoc.py
1 2 3 4 5 6 7 8 9 10 11	`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.

Output
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.

---------------------------------------------------------------------------

Output
1 2 3 4 5 6 7 8 9 10 11 12 13 14	`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.

callable.py
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))

callable.py
1 2 3 4 5 6 7 8 9 10 11 12 13	`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.

Output
True

True

False

False

Output
1 2 3 4	`True` `True` `False` `False`

Bạn muốn học lập trình hãy liên hệ ngay với Mỹ Vân để được nhận ưu đãi từ học viện nhé

Khóa học Lập trình Python

Khóa học lập trình Java

Khóa học lập trình PHP

Khóa học lập trình Asp net

Khóa học lập trình Angular

Khóa học lập trình Ios

Lập trình Đà Nẵng

Thứ Hai, 27 tháng 8, 2018

Python – Các hàm kiểm tra trạng thái

Không có nhận xét nào:

Đăng nhận xét

Bài đăng phổ biến