φυβλαςのβλογ
บล็อกของ phyblas



ภาษา python เบื้องต้น บทที่ ๒๔: เมธอดและแอตทริบิวต์พิเศษของคลาส
เขียนเมื่อ 2016/03/25 00:13
แก้ไขล่าสุด 2021/09/28 16:42
ในบทที่ ๒๒ ได้พูดถึงเมธอดพิเศษไปตัวหนึ่งคือ __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: unorderable types: int() > เชือก()

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

__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.ความยาว<x
    def __add__(self,x):
        return self.ความยาว+x
    def __radd__(self,x):
        return self.ความยาว+x
    def __pow__(self,x):
        return self.ความยาว**x
    def __rpow__(self,x):
        return x**self.ความยาว
ช4 = เชือก(800)
print(1000>ช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 ด้วย

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



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



อ้างอิง



<< บทที่แล้ว      บทถัดไป >>
หน้าสารบัญ


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

囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧

ดูสถิติของหน้านี้

หมวดหมู่

-- คอมพิวเตอร์ >> เขียนโปรแกรม >> python

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

สารบัญ

รวมคำแปลวลีเด็ดจากญี่ปุ่น
มอดูลต่างๆ
-- numpy
-- matplotlib

-- pandas
-- manim
-- opencv
-- pyqt
-- pytorch
การเรียนรู้ของเครื่อง
-- โครงข่าย
     ประสาทเทียม
ภาษา javascript
ภาษา mongol
ภาษาศาสตร์
maya
ความน่าจะเป็น
บันทึกในญี่ปุ่น
บันทึกในจีน
-- บันทึกในปักกิ่ง
-- บันทึกในฮ่องกง
-- บันทึกในมาเก๊า
บันทึกในไต้หวัน
บันทึกในยุโรปเหนือ
บันทึกในประเทศอื่นๆ
qiita
บทความอื่นๆ

บทความแบ่งตามหมวด



ติดตามอัปเดตของบล็อกได้ที่แฟนเพจ

  ค้นหาบทความ

  บทความแนะนำ

ตัวอักษรกรีกและเปรียบเทียบการใช้งานในภาษากรีกโบราณและกรีกสมัยใหม่
ที่มาของอักษรไทยและความเกี่ยวพันกับอักษรอื่นๆในตระกูลอักษรพราหมี
การสร้างแบบจำลองสามมิติเป็นไฟล์ .obj วิธีการอย่างง่ายที่ไม่ว่าใครก็ลองทำได้ทันที
รวมรายชื่อนักร้องเพลงกวางตุ้ง
ภาษาจีนแบ่งเป็นสำเนียงอะไรบ้าง มีความแตกต่างกันมากแค่ไหน
ทำความเข้าใจระบอบประชาธิปไตยจากประวัติศาสตร์ความเป็นมา
เรียนรู้วิธีการใช้ regular expression (regex)
การใช้ unix shell เบื้องต้น ใน linux และ mac
g ในภาษาญี่ปุ่นออกเสียง "ก" หรือ "ง" กันแน่
ทำความรู้จักกับปัญญาประดิษฐ์และการเรียนรู้ของเครื่อง
ค้นพบระบบดาวเคราะห์ ๘ ดวง เบื้องหลังความสำเร็จคือปัญญาประดิษฐ์ (AI)
หอดูดาวโบราณปักกิ่ง ตอนที่ ๑: แท่นสังเกตการณ์และสวนดอกไม้
พิพิธภัณฑ์สถาปัตยกรรมโบราณปักกิ่ง
เที่ยวเมืองตานตง ล่องเรือในน่านน้ำเกาหลีเหนือ
ตระเวนเที่ยวตามรอยฉากของอนิเมะในญี่ปุ่น
เที่ยวชมหอดูดาวที่ฐานสังเกตการณ์ซิงหลง
ทำไมจึงไม่ควรเขียนวรรณยุกต์เวลาทับศัพท์ภาษาต่างประเทศ

ไทย

日本語

中文