ในบทที่ ๒๒ ได้พูดถึงเมธอดพิเศษไปตัวหนึ่งคือ __init__ นอกจาก __init__ แล้วยังมีเมธอดพิเศษในทำนองเดียวกัน รวมทั้งแอตทริบิวต์พิเศษอีกหลายตัว ในบทนี้จะกล่าวถึงบางส่วนที่ควรรู้ในเบื้องต้น



แอตทริบิวต์ __dict__

เมื่อต้องการรู้แอตทริบิวต์และค่าของแอตทริบิวต์ทั้งหมดของออบเจ็กต์สามารถทำได้โดยดูค่าแอตทริบิวต์พิเศษของออบเจ็กต์ที่ชื่อ __dict__

ตัวอย่าง

class ผู้กล้า:
    def __init__(self,ชื่อ,เลเวล=1,ความแข็งแรง=4,ความอดทน=4,hpสูงสุด=10):
        self.ชื่อ = ชื่อ
        self.เลเวล = เลเวล
        self.ความแข็งแรง = ความแข็งแรง
        self.ความอดทน = ความอดทน
        self.hpสูงสุด = hpสูงสุด
        self.hp = hpสูงสุด
    เสื้อผ้า = เสื้อผ้า('ชุดเก่าๆ',3,5)
    อาวุธ = อาวุธ('มีดสั้นเก่าๆ',3,0,5)
    เงินเดือน = 500
ผู้เล่นa = ผู้กล้า('ไก่กา',1,5,5,12)
print(ผู้เล่นa.__dict__)

ผลลัพธ์

{'hp': 12, 'hpสูงสุด': 12, 'ความอดทน': 5, 'ความแข็งแรง': 5, 'เลเวล': 1, 'ชื่อ': 'ไก่กา'}

จะเห็นว่าแอตทริบิวต์ __dict__ นี้แสดงแอตทริบิวต์ต่างๆของออบเจ็กต์พร้อมค่าในรูปของดิกชันนารี

ค่าของแอตทริบิวต์นี้จะถูกแก้ไขตามเวลาที่มีการแก้ไขหรือเพิ่มแอตทริบิวต์อะไรให้กับออบเจ็กต์

อนึ่ง __dict__ ของออบเจ็กต์จะแสดงเฉพาะแอตทริบิวต์ของออบเจ็กต์ ไม่แสดงแอตทริบิวต์ของคลาส หากต้องการให้แสดงแอตทริบิวต์ของคลาสก็ต้องดูที่แอตทริบิวต์ __dict__ ของคลาส

สำหรับ __dict__ ของคลาสนอกจากจะมีแอตทริบิวต์ของคลาสแล้วก็ยังมีเมธอดที่นิยามไว้ด้วย แล้วก็ยังมีแอตทริบิวต์และเมธอดพิเศษซึ่งเราไม่ได้นิยามเอาไว้แต่มีติดตัวอยู่แล้ว รวมถึงตัว __dict__ เองด้วย

print(ผู้กล้า.__dict__)

ผลลัพธ์

{'__doc__': None, 'เสื้อผ้า': <__main__.เสื้อผ้า object at 0x112797898>, '__dict__': <attribute '__dict__' of 'ผู้กล้า' objects>, 'พลังป้องกัน': , '__weakref__': <attribute '__weakref__' of 'ผู้กล้า' objects>, 'พลังโจมตี': , '__module__': '__main__', 'อาวุธ': <__main__.อาวุธ object at 0x1127979e8>, 'เงินเดือน': 500, '__init__': }

เมธอดพิเศษที่แสดงผลเมื่อเรียกใช้ฟังก์ชัน

มีเมธอดพิเศษบางตัวที่นอกจากจะแสดงผลเมื่อเรียกใช้เมธอดนั้นโดยตรงแล้วก็ยังจะ ถูกเรียกใช้เมื่อมีการใช้ฟังก์ชันเฉพาะบางอย่าง เช่น len, str, bool เป็นต้น

ปกติแล้วฟังก์ชัน len มีไว้หาความยาว (จำนวนสมาชิก) ของออบเจ็กต์ชนิดที่เก็บข้อมูลเป็นกลุ่ม เช่น สายอักขระ, ลิสต์, ทูเพิล เป็นต้น

ออบเจ็กต์ที่สร้างขึ้นจากคลาสที่นิยามขึ้นใหม่เองโดยปกติจะไม่สามารถใช้ฟังก์ชัน len ได้ เพราะไม่รู้ว่าจะพิจารณาความยาวอย่างไร

แต่หากมีการใส่เมธอด __len__ เอาไว้ในคลาสที่สร้างขึ้น เมื่อใช้ฟังก์ชัน len เมธอดนี้จะถูกเรียกใช้ ทำให้สามารถหาค่าความยาวของออบเจ็กต์ได้

ตัวอย่าง สร้างคลาส เชือก ขึ้นมา แล้วให้มีแอตทริบิวต์ ความยาว จากนั้นสร้างเมธอด __len__ ซึ่งคืนค่า ความยาว ของออบเจ็กต์

class เชือก:
    def __init__(self,ความยาว):
        self.ความยาว = ความยาว
    def __len__(self):
        return self.ความยาว
ช1 = เชือก(10)
print(len(ช1)) # ได้ 10 

อย่างไรก็ตาม เมธอด __len__ จะต้องคืนค่าเป็นจำนวนเต็มเท่านั้น ถ้าไม่ใช่จำนวนเต็มจะขัดข้อง

ช1 = เชือก(10.1)
print(len(ช1)) # ได้ TypeError: 'float' object cannot be interpreted as an integer

ต่อมาฟังก์ชันที่เป็นชื่อชนิดของข้อมูลต่างๆ ได้แก่ str, bool, int, float, complex เป็นต้น ซึ่งโดยทั่วไปจะทำหน้าที่เปลี่ยนออบเจ็กให้เป็นชนิดนั้นๆ

แต่หากใช้กับออบเจ็กต์จากคลาสที่สร้างขึ้นเอง โดยทั่วไปแล้ว int, float, complex จะเกิดขัดข้อง แต่ถ้าใช้กับ str จะคืนค่าชื่อคลาส ส่วนถ้าใช้กับ bool จะคืนค่า True

class เชือก:
    def __init__(self,ชื่อ,ความยาว):
        self.ชื่อ = ชื่อ
        self.ความยาว = ความยาว

ช2 = เชือก('เชือกล่ามช้างชนิดหนานุ่ม',129.3)
print(str(ช2)) # ได้ <__main__.เชือก object at 0x1127db400>
print(bool(ช2)) # ได้ True
print(float(ช2)) # ได้ TypeError: float() argument must be a string or a number, not 'เชือก' 

แต่หากมีการนิยามเมธอด __int__, __float__, __complex__, __str__, __bool__ แล้วให้ return ค่า ค่าที่ได้ก็จะออกมาตามนั้น สามารถกำหนดได้อย่างอิสระ

class เชือก:
    def __init__(self,ชื่อ,ความยาว):
        self.ชื่อ = ชื่อ
        self.ความยาว = ความยาว

    def __str__(self):
        return self.ชื่อ

    def __float__(self):
        return self.ความยาว

    def __bool__(self):
        if(self.ความยาว>200): return True
        else: return False

ช2 = เชือก('เชือกล่ามช้างชนิดหนานุ่ม',129.3)
ช3 = เชือก('เชือกรัดงูชนิดบางกรอบ',333.3)

print(str(ช2)) # ได้ เชือกล่ามช้างชนิดหนานุ่ม
print(str(ช3)) # ได้ เชือกรัดงูชนิดบางกรอบ
print(float(ช2)) # ได้ 129.3
print(float(ช3)) # ได้ 333.3
print(bool(ช2)) # ได้ False
print(bool(ช3)) # ได้ True

เพียงแต่ชนิดของข้อมูลที่ return จะต้องสอดคล้องด้วย เช่น __float__ ต้องคืนค่าตัวเลข __bool__ ต้องคืนค่า True หรือ False เป็นต้น

กรณีของ __str__ นั้นยังถูกเรียกใช้เมื่อให้แสดงผลโดยคำสั่ง print ด้วย และ __bool__ จะถูกเรียกใช้เมื่อใช้พิจารณาหาค่าความจริงเท็จ เช่นใน if หรือ while

print(ช2) # ได้ เชือกล่ามช้างชนิดหนานุ่ม
print(ช3) # ได้ เชือกรัดงูชนิดบางกรอบ
if(ช2): print('ยาว')
else: print('สั้น')
# ได้ สั้น 

เมธอดที่ถูกใช้ในนิพจน์

นอกจากจะมีเมธอดพิเศษที่ถูกเรียกใช้เมื่อถูกใช้ในฟังก์ชันแล้ว ก็ยังมีเมธอดอีกกลุ่มหนึ่ง ซึ่งจะถูกเรียกใช้เมื่อมีการจำออบเจ็กต์มาใช้ในนิพจน์

เมธอดที่ใช้ในการพิจารณาจริงเท็จ

เมธอด	ความหมาย
x.__lt__(y)	x < y
x.__le__(y)	x <= y
x.__eq__(y)	x == y
x.__ne__(y)	x != y
x.__gt__(y)	x > y
x.__ge__(y)	x >= y

เมธอดที่ใช้ในการคำนวณ

เมธอด	ความหมาย
x.__add__(y)	x+y
x.__sub__(y)	x-y
x.__mul__(y)	x*y
x.__truediv__(y)	x/y
x.__floordiv__(y)	x//y
x.__mod__(y)	x%y
x.__pow__(y)	x**y

โดยทั่วไปแล้วออบเจ็กต์ที่ไม่ได้นิยามเมธอดเหล่านี้ไว้จะไม่สามารถถูกใช้ในนิพจน์ได้ แต่เมื่อนิยามแล้วก็จะสามารถใช้ได้โดยมีผลตามที่นิยามไว้

ตัวอย่าง

class เชือก:
    def __init__(self,ความยาว):
        self.ความยาว = ความยาว

    def __gt__(self,x):
        return self.ความยาว>x

    def __add__(self,x):
        return self.ความยาว+x

ช4 = เชือก(800)
print(ช4>1000) # ได้ False
print(ช4+1000) # ได้ 1800

อย่างไรก็ตามการนิยามเมธอด __gt__ แม้ว่าจะทำให้สามารถเทียบกับตัวเลขได้เมื่อนำออบเจ็กต์ไว้ฝั่งซ้าย แต่ถ้านำออบเจ็กต์ไว้ฝั่งขวาก็จะขัดข้องทันที

print(1000>ช4) # ได้ TypeError: '&gt' not supported between instances of 'int' and 'เชือก'

ซึ่งจะต้องแก้ไขด้วยการนิยามเมธอดที่ตรงกันข้ามไปพร้อมกันด้วย

• __gt__ ตรงข้ามกับ __lt__
• __eq__ ตรงข้ามกับ __ne__
• __ge__ ตรงข้ามกับ __le__

พวกเมธอดสำหรับคำนวณเช่น __add__ เองก็มีคู่ตรงข้ามเช่นกัน โดยทั่วไปเมธอดคำนวณจะถูกนิยามในกรณีที่ออบเจ็กต์นั้นอยู่ด้านหน้าของ เครื่องหมายเท่านั้น ถ้าไปอยู่ด้านหลังก็จะไม่ได้ผล

ดังนั้นต้องนิยามคู่ตรงข้ามของมันไปด้วย ซึ่งชื่อเมธอดนั้นจะเหมือนกันแค่เติม r นำหน้า

เมธอด	ความหมาย
x.__radd__(y)	y+x
x.__rsub__(y)	y-x
x.__rmul__(y)	y*x
x.__rtruediv__(y)	y/x
x.__rfloordiv__(y)	y//x
x.__rmod__(y)	y%x
x.__rpow__(y)	y**x

ตัวอย่าง

class เชือก:
    def __init__(self,ความยาว):
        self.ความยาว = ความยาว

    def __gt__(self,x):
        return self.ความยาว>x

    def __lt__(self,x):
        return self.ความยาวช4) # ได้ True
print(1000+ช4) # ได้ 1800
print(ช4**2) # ได้ 640000
print(pow(ช4,2)) # ได้ 640000
print(1.001**ช4) # ได้ 2.2246514829361543

พอกำหนดแบบนี้แล้วจะทำให้เราสามารถเปรียบเทียบระหว่างออบเจ็กต์ ๒ ตัว หรือคำนวณระหว่างออบเจ็กต์ ๒ ตัวได้ด้วย

ช5 = เชือก(1400)
print(ช5<ช4) # ได้ False
print(ช4+ช5) # ได้ 2200

แอตทริบิวต์พิเศษของคลาส

ปกติ คลาสจะประกอบไปด้วยแอตทริบิวต์ที่ติดตัวมาโดยอัตโนมัติโดยที่ไม่ต้องนิยาม ขึ้นมาเอง ในที่นี้ขอยกมาพูดส่วนหนึ่ง ได้แก่ __doc__, __module__, __name__, __bases__

• คลาส.__doc__ แสดงข้อความที่อธิบายข้อมูลเกี่ยวกับคลาสนั้น
• คลาส.__module__ แสดงชื่อมอดูลของคลาส
• คลาส.__name__ แสดงชื่อของคลาส
• คลาส.__bases__ แสดงซูเปอร์คลาส

ตัวอย่าง

print(int.__name__) # ได้ int
print(int.__module__) # builtins
print(int.__bases__) # ได้ (<class 'object'>,)
print(int.__doc__) # ได้ข้อความอธิบายเกี่ยวกับ int ออกมายาวๆ

ข้อความอธิบายที่อยู่ในแอตทริบิวต์นั้นเรียกว่าด็อกสตริง (docstring) โดยทั่วไปคนที่เขียนคลาสขึ้นจะใส่มันเอาไว้เพื่อจะให้คนอื่นที่มาใช้มาอ่าน จะได้รู้ว่าคลาสนั้นมีไว้ทำอะไร

โดยทั่วไปคลาสมาตรฐานของไพธอนจะมีด็อกสตริงติดมาอยู่แล้ว เราสามารถอ่านเพื่อทำความเข้าใจกับมันได้

สำหรับคลาสที่เราสร้างขึ้นเองนั้นสามารถสร้างด็อกสตริงขึ้นได้โดยการเขียนสาย อักขระขึ้นมาลอยๆไว้บรรทัดแรกก่อนที่จะนิยามเมธอดใดๆในฟังก์ชัน

ตัวอย่าง

class ผู้กล้า:
    'ผู้กล้าเป็นผู้ที่เสียสละตน ออกไปต่อสู้กับจอมมารปีศาจอย่างกล้าหาญ'
    def __init__(self,ชื่อ):
        self.ชื่อ = ชื่อ

print(ผู้กล้า.__name__) # ได้ ผู้กล้า
print(ผู้กล้า.__module__) # __main__
print(ผู้กล้า.__bases__) # ได้ (<class 'object'>,)
print(ผู้กล้า.__doc__) # ได้ ผู้กล้าเป็นผู้ที่เสียสละตน ออกไปต่อสู้กับจอมมารปีศาจอย่างกล้าหาญ 

อนึ่ง แอตทริบิวต์ __name__, __module__ และ __doc__ นั้นนอกจากจะมีในคลาสแล้วก็ยังมีอยู่ในฟังก์ชันด้วย โดยจะแสดง ชื่อฟังก์ชัน, มอดูลของฟังก์ชัน และ ด็อกสตริงของฟังก์ชัน ตามลำดับ วิธีการใช้ในฟังก์ชันก็เหมือนกับในคลาส



การกำหนดชนิดของออบเจ็กต์

ปกติการจะดูว่าออบเจ็กต์อันหนึ่งที่พิจารณาอยู่นั้นอยู่ในคลาสอะไรก็สามารถใช้ฟังก์ชัน type ดังที่เคยพูดถึงไปแล้ว

ความจริงแล้วฟังก์ชัน type นั้นเป็นการสั่งให้ออบเจ็กต์คืนค่าแอตทริบิวต์ตัวหนึ่ง ชื่อ __class__ ซึ่งเป็นแอตทริบิวต์ติดตัวซึ่งเก็บชื่อคลาสที่ออบเจ็กต์นั้นสังกัดอยู่

เช่นลองดูในข้อมูลชนิดสายอักขระและลิสต์

print('1'.__class__) # ได้ <class 'str'>
print([1].__class__) # ได้ <class 'list'>
print(type('1')) # ได้ <class 'str'>
print(type([1])) # ได้ <class 'list'> 

จะเห็นว่าใช้ .__class__ หรือ type() ก็ให้ผลเหมือนกัน

สำหรับคลาสที่สร้างขึ้นมาเองก็เช่นกัน โดยปกติแล้วแอตทริบิวต์ __class__ จะมีค่าเป็นชื่อคลาสไปโดยอัตโนมัติ

อย่างไรก็ตาม เราสามารถเปลี่ยนการแสดงผลได้โดยป้อนค่าใหม่ให้แอตทริบิวต์ __class__ โดยตรง ซึ่งจะทำให้ผลที่ได้เมื่อใช้ฟังก์ชัน type เปลี่ยนตามไปด้วย

ตัวอย่าง

class มนุษย์:
    0
class ผู้กล้า:
    def __init__(self):
        self.__class__ = มนุษย์

ผู้เล่นb = ผู้กล้า()
print(type(ผู้เล่นb)) # ได้ <class '__main__.มนุษย์'>
print(ผู้เล่นb.__class__) # ได้ <class '__main__.มนุษย์'>

class เอลฟ์:
    0

ผู้เล่นb.__class__ = เอลฟ์
print(type(ผู้เล่นb)) # ได้ <class '__main__.เอลฟ์'>

ฟังก์ชันเกี่ยวกับความสัมพันธ์ระหว่างคลาสและออบเจ็กต์

การตรวจสอบว่าออบเจ็กต์เป็นอินสแตนซ์ของคลาสหรือเปล่าสามารถทำได้โดยใช้ฟังก์ชัน isinstance

isinstance(ออบเจ็กต์x,คลาสA) จะคืนค่า True ถ้า ออบเจ็กต์x เป็นอินสแตนซ์ของ คลาสA ถ้าไม่ใช่จะได้ False

ส่วนการตรวจสอบว่าคลาสหนึ่งเป็นซับคลาสของอีกคลาสหรือเปล่าสามารถทำได้โดยใช้ฟังก์ชัน issubset

issubclass(คลาสX,คลาสA) จะคืนค่า True ถ้า คลาสX เป็นซับคลาสของ คลาส A ถ้าไม่ใช่จะได้ False

ส่วนการหาซับคลาสทั้งหมดของคลาสนั้นทำได้โดยใช้เมธอด __subclasses__

และการหาซูเปอร์คลาสทำได้โดยดูค่าแอตทริบิวต์ __bases__ ซึ่งได้พูดถึงไปแล้ว

ตัวอย่างการใช้

class ผู้กล้า:
    0

class นักรบ(ผู้กล้า):
    0

class จอมเวทย์(ผู้กล้า):
    0

class นักรบเวทย์(นักรบ,จอมเวทย์):
    0

ผู้เล่นb = นักรบเวทย์()
print(isinstance(ผู้เล่นb,จอมเวทย์)) # ได้ True
print(isinstance(ผู้เล่นb,ผู้กล้า)) # ได้ True
print(issubclass(นักรบเวทย์,จอมเวทย์)) # ได้ True
print(issubclass(นักรบเวทย์,ผู้กล้า)) # ได้ True
print(ผู้กล้า.__subclasses__()) # ได้ [<class '__main__.นักรบ'>, <class '__main__.จอมเวทย์'>]
print(จอมเวทย์.__subclasses__()) # ได้ [<class '__main__.นักรบเวทย์'>]
print(นักรบเวทย์.__bases__) # ได้ (<class '__main__.นักรบ'>, <class '__main__.จอมเวทย์'>) 

ฟังก์ชันจัดการแอตทริบิวต์

มีฟังก์ชันจำนวนหนึ่งที่มีไว้ใช้สำหรับการจัดการแอตทริบิวต์โดยเฉพาะ ได้แก่ setattr, getattr, hasattr, delattr

• setattr เป็นฟังก์ชันสำหรับป้อนค่าแอตทริบิวต์
• getattr เป็นฟังก์ชันที่คืนค่าแอตทริบิวต์
• hasattr เป็นฟังก์ชันสำหรับตรวจว่าออบเจ็กต์มีแอตทริบิวต์นั้นอยู่หรือเปล่า โดยคืนค่า True และ False
• delattr เป็นฟังก์ชันสำหรับลบค่าแอตทริบิวต์

การใช้งานเข้าใจไม่ยากเท่าไหร่ มาดูตัวอย่างการใช้กันเลย ขอยกตัวอย่างด้วยออบเจ็กต์จากคลาส อาวุธ ซึ่งสร้างขึ้นมาเช่นเดียวกับตัวอย่างในบทก่อนหน้า

class อาวุธ(object):
    def __init__(self,ชื่อ,พลังโจมตีกายภาพ,พลังโจมตีเวทย์,ความทนทาน):
        self.ชื่อ = ชื่อ
        self.พลังโจมตีกายภาพ = พลังโจมตีกายภาพ
        self.พลังโจมตีเวทย์ = พลังโจมตีเวทย์
        self.ความทนทาน = ความทนทาน

ดาบA = อาวุธ('ดาบที่ยังไม่ได้ตั้งชื่อ',111,11,30)
print(getattr(ดาบA,'ชื่อ')) # ได้ 'ดาบที่ยังไม่ได้ตั้งชื่อ'
setattr(ดาบA,'ชื่อ','ดาบสยบมารสะท้านพิภพ')
print(getattr(ดาบA,'ชื่อ')) # ได้ 'ดาบสยบมารสะท้านพิภพ'
print(hasattr(ดาบA,'พลังโจมตีเวทย์')) # ได้ True
delattr(ดาบA,'พลังโจมตีเวทย์')
print(hasattr(ดาบA,'พลังโจมตีเวทย์')) # ได้ False 

อนึ่ง ความจริงแล้วจะเห็นได้ว่าฟังก์ชันเหล่านี้อาจไม่มีความจำเป็นต้องใช้ก็ได้ อย่างเช่นว่า getattr กับ setattr อาจถูกเขียนแทนด้วย

print(ดาบA.ชื่อ)
ดาบA.ชื่อ = 'ดาบสยบมารสะท้านพิภพ'

จะใช้วิธีไหนก็อาจแล้วแต่ความสะดวก ข้อดีของฟังก์ชันเหล่านี้คือชื่อแอตทริบิวต์ต่างๆจะอยู่ในรูปของสายอักขระ ทำให้การใช้งานยืดหยุ่นขึ้น

เช่นใช้กับ for เพื่อแสดงค่าทั้งหมด

หอกA = อาวุธ('หอกอสูรนรกโลกันต์',123,30,40)
for s in ['ชื่อ','พลังโจมตีกายภาพ','พลังโจมตีเวทย์','ความทนทาน']:
    print(s+': %s'%getattr(หอกA,s)) 

ได้ผลเป็น

ชื่อ: หอกอสูรนรกโลกันต์
พลังโจมตีกายภาพ: 123
พลังโจมตีเวทย์: 30
ความทนทาน: 40

หรืออาจลองใช้คู่กับ map และ lambda เพื่อแสดงค่าแอตทริบิวต์ทั้งหมดก็ได้

print(list(map(lambda s:getattr(หอกA,s),['ชื่อ','พลังโจมตีกายภาพ','พลังโจมตีเวทย์','ความทนทาน'])))

ได้

['หอกอสูรนรกโลกันต์', 123, 30, 40]

อนึ่ง ที่จริงแล้วการทำงานของฟังก์ชัน setattr, getattr และ delattr นั้นคือการเรียกใช้เมธอด __setattr__, __getattr__ และ __delattr__ ดังนั้นหากเรามีการนิยามเมธอดเหล่านี้ใหม่ตอนที่สร้างคลาสขึ้นมาการทำงานของฟังก์ชันเหล่านี้ก็จะเปลี่ยนไปด้วย

แต่ว่าไม่เพียงแค่นั้นการแก้เมธอด __setattr__ ยังจะมีผลเมื่อป้อนค่าให้แอตทริบิวต์ด้วยเครื่องหมาย = ตามปกติด้วย

ส่วนการแก้เมธอด __getattr__ ก็จะมีผลเวลาที่เรียกเอาค่าแอตทริบิวต์ด้วยการพิมพ์ชื่อตามปกติ

และการแก้เมธอด __delattr__ ก็จะมีผลเวลาที่ลบแอตทริบิวต์ด้วยคำสั่ง del ด้วย

การแก้เมธอดเหล่านี้ก็จะมีวิธีการคล้ายกับการแก้เมธอดอื่นๆดังที่ได้กล่าวไปแล้ว ดังนั้นจะขอไม่ยกตัวอย่างอีก



สรุปเนื้อหา

มีเมธอดและแอตทริบิวต์อยู่มากมายภายในออบเจ็กต์ซึ่งถูกสร้างและเรียกโดยอัตโนมัติตามสถานการณ์ และมีฟังก์ชันที่มีส่วนเกี่ยวข้องมากมาย
ที่แนะนำไปนั้นเป็นเพียงแค่ส่วนหนึ่งเท่านั้น ยังมีอยู่อีกมากมายซึ่งอาจจะได้ใช้ในระดับสูงขึ้นไป



อ้างอิง