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



ภาพรวม

ภาษาไพธอนนั้นเป็นภาษาที่เวลาจะใช้ตัวแปรอะไรเราไม่จำเป็นต้องมาประกาศล่วงหน้าก่อน จู่ๆก็ใช้ได้ทันทีเลย ชนิดของตัวแปรก็ไม่ต้องกำหนดแน่ชัด แถมยังเปลี่ยนกลางคันได้ด้วย ทำให้ใช้งานสะดวกคล่องตัวดีมาก นอกจากไพธอนแล้ว ก็ยังมีอีกหลายภาษาที่เป็นแบบนี้เช่นกัน เช่น php, รูบี, IDL, ฯลฯ

ซึ่งต่างจากบางภาษาเช่นภาษา C, C++, C#, ฟอร์แทรน, ดาร์ต, ฯลฯ ซึ่งต้องประกาศตัวแปรล่วงหน้า และยังต้องระบุชนิดของตัวแปรให้ชัดเจน และจะเปลี่ยนภายหลังก็ไม่ได้ด้วย หรืออย่างจาวาสคริปต์ที่มีการประกาศตัวแปรก่อน แต่ไม่ต้องระบุชนิดตัวแปร และยังเปลี่ยนกลางคันได้

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

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

ความสามารถตรงนี้ไม่ได้มีอยู่ในภาษาไพธอนตั้งแต่แรก แต่เริ่มถูกนำมาใช้ตั้งแต่เวอร์ชัน 3.5 (ปี 2015) เป็นต้นมา แต่ว่าในระยะแรกความสามารถตรงนี้ยังไม่สมบูรณ์ เขียนยาก จึงไม่ค่อยมีการใช้งานจริงกว้างขวาง แต่ว่าในเวอร์ชันต่อๆมาก็ได้มีการปรับปรุง วิธีการเขียนก็เปลี่ยนไปเรื่อยๆ เขียนง่ายขึ้นมา และมีการนำไปใช้งานจริงมากขึ้น

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

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




การใช้งานเบื้องต้น

ปกติแล้วเวลาจะประกาศและใช้ตัวแปรในภาษาไพธอนเราก็เขียนขึ้นมาลอยๆแล้วก็ใช้ได้เลย เช่น

a = 7
b = 3.5
print(a+b) # ได้ 10.5

ในที่นี้ a จะเป็นข้อมูลชนิด int และ b จะเป็น float ไปโดยอัตโนมัติ เราไม่จำเป็นต้องไประบุอะไรเป็นพิเศษ

อย่างไรก็ตาม เราสามารถเขียนแบบนี้ได้ด้วย

a: int = 7
b: float = 3.5
print(a+b) # ได้ 10.5

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

แต่ว่าสำหรับคนที่เคยชินกับการเขียนภาษาที่ต้องระบุชนิดตัวแปรชัดแล้ว น่าจะดีใจกับการเขียนแบบนี้ เพราะช่วยให้เข้าใจง่ายกว่า และดูรัดกุมกว่า เพราะมีชื่อชนิดตัวแปรเขียนระบุชัดอยู่แบบนี้

สรุปรูปแบบการเขียนก็คือ

ชื่อตัวแปร: ชนิดข้อมูลตัวแปร = ค่าตั้งต้น

ส่วนที่เพิ่มเข้ามาก็คือ : ชนิดข้อมูลตัวแปร แทรกตรงกลาง นอกนั้นก็เหมือนเวลาแทนค่าตั้งต้นให้ตัวแปรตามปกติ

นอกจากนี้แล้ว อาจประกาศตัวแปรก่อนแล้วค่อยแทนค่าทีหลังก็ได้เช่นกัน ไม่จำเป็นตัวประกาศตัวแปรแล้วแทนค่าทันที

a: int
b: float
a = 7
b = 3.5

ชนิดของข้อมูลที่ระบุจะเป็นอะไรก็ได้ ทั้งชนิดข้อมูลพื้นฐาน หรือคลาสที่ได้จากมอดูลเสริม หรือคลาสที่เราเขียนขึ้นมาเอง

ตัวอย่างการใช้ข้อมูลชนิดอื่นๆ

bbb: bool = True
ccc: complex = 1j
sss: str = 'ข้าว'
lll: list = [1,2]
ttt: tuple = (1,2,3)
ddd: dict = {'ก': 1, 'ข': 2}

from datetime import datetime,timedelta
dt: datetime = datetime.now()
td: timedelta = timedelta(hours=1)

import numpy as np
arr: np.ndarray = np.array([[3,4],[5,6]])

ผลบังคับใช้

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

x: str = 2.2

ในที่นี้ระบุว่าเป็น str แต่กลับแทนค่าเป็น float ไปอย่างหน้าตาเฉย โปรแกรมก็ไม่ได้ฟ้องข้อผิดพลาดอะไร ยังคงทำงานต่อไปได้

ดังนั้นจริงๆแล้วการบอกใบ้ชนิดตัวแปรในที่นี้แค่ใส่ไปเพื่อให้รู้เฉยๆ เป็นแค่การ "บอกใบ้" (hint) ไม่ใช่การนิยามหรือตั้งข้อจำกัดขึ้นจริงๆ ไม่ได้มีผลบังคับใช้จริงในกรณีทั่วไป ดังนั้นจึงยังคงต้องระวังด้วยตัวเองอยู่ดี

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

การติดตั้งสามารถทำได้ง่ายโดยใช้ pip

หากติดตั้ง mypy แล้วเวลาที่ใช้ตัวแปรผิดชนิดไปจากที่ระบุก็จะเกิดข้อผิดพลาดขึ้นมาจริงๆ

เกี่ยวกับการใช้ mypy นั้นจะไม่พูดถึงละเอียดในนี้ ถ้าใครสนใจก็ลองใช้กันดูได้

นอกจากนี้แล้ว ต่อให้ไม่ได้ลงแพ็กเกจเสริม แต่เวลาที่เราเขียนโดยใช้อีดิตเตอร์ดีๆดังเช่น spyder นั้นการระบุชนิดตัวแปรก็มีผลกับตัวช่วยเสริมเติมเต็มอัตโนมัติ (auto completion)

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



ที่ขึ้นมานี้เป็นของตัวแปรชนิด int

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



คราวนี้ที่ขึ้นมาเป็นของตัวแปรชนิด str ทั้งที่ป้อนค่าเป็น int

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

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

นอกจากนี้แล้วในการใช้งานมอดูลบางตัวของไพธอน การเขียนแบบนี้อาจมีความสำคัญ ให้ผลบังคับใช้จริงขึ้นมา ซึ่งก็ขึ้นอยู่กับตัวมอดูลนั้น

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




ตัวแปร __annotations__

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

ตัวแปรนี้จะปรากฏขึ้นมาโดยอัตโนมัติเมื่อเรามีการเขียนระบุบอกใบ้ชนิดข้อมูลตัวแปร

print(__annotations__) # ได้ NameError: name '__annotations__' is not defined
a: int = 1
print(__annotations__) # ได้ {'a': <class 'int'>}
b: str = '2'
print(__annotations__) # ได้ {'a': <class 'int'>, 'b': <class 'str'>}

ฉะนั้นเราสามารถตรวจสอบได้ว่ามีการระบุตัวแปรไหนเป็นชนิดอะไรได้โดยผ่าน __annotations__ นี้

เราอาจนำ __annotations__ นี้มาใช้เพื่อตรวจสอบว่าชนิดข้อมูลที่ป้อนไปนั้นตรงกับที่ระบุหรือไม่ เช่นด้วยการใช้ร่วมกับ isinstance แบบนี้

x: int
x = 1.1
assert(isinstance(x,__annotations__['x'])) # ได้ AssertionError

การระบุชนิดข้อมูลในการนิยามฟังก์ชัน

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

ตัวอย่างการเขียนฟังก์ขันแบบดั้งเดิม

def f(a, b):
    return a*b

ถ้าหากต้องการเขียนฟังก์ชันนี้ใหม่ให้ระบุชัดชนิดข้อมูลก็ทำได้โดยใช้การเขียนบอกใบ้ดังนี้

def f(a: int, b: str) -> str:
    return a*b

พอเขียนแบบนี้ก็เป็นการระบุให้รู้ว่าฟังก์ชันนี้ต้องการตัวแปร a ที่เป็นจำนวนเต็มกับตัวแปร b ที่เป็นสายอักขระ และจะคืนค่าเป็นสายอักขระมา

เวลาที่ลองมาดูข้อมูลของฟังก์ชันนี้เช่นด้วยการใช้ help ข้อมูลตรงส่วนนี้ก็จะแสดงให้เห็นชัดด้วย

help(f) # ได้ f(a: int, b: str) -> str

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

นอกจากนี้ข้อมูลตรงนี้ยังถูกเก็บอยู่ในแอตทริบิวต์ .__annotations__ ของตัวออบเจ็กต์ฟังก์ชันด้วย สามารถนำมาใช้ได้ โดยชนิดของค่าคืนกลับที่ระบุไว้จะอยู่ใน 'return'

print(f.__annotations__) # ได้ {'a': <class 'int'>, 'b': <class 'str'>, 'return': <class 'str'>}
print(f.__annotations__['return'])  # ได้ <class 'str'>

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

def f(a: int = 3, b: str = 'x') -> str:
    return a*b

print(f()) # ได้ xxx

สรุปรูปแบบการเขียนก็คือ

def ชื่อฟังก์ชัน(ชื่อตัวแปร๑: ชนิดข้อมูล๑ = ค่าตั้งต้น๑, ...) -> ชนิดตัวแปรคืนกลับ:
    เนื้อหาของฟังก์ชัน

ในส่วนของพารามิเตอร์ก็แค่เพิ่ม : ชนิดข้อมูล และส่วนของค่าคืนกลับก็เพิ่ม -> ชนิดข้อมูล เท่านั้นเอง

ในกรณีที่เป็นฟังก์ชันที่ไม่มีค่าคืนกลับก็ให้ใส่เป็น -> None ไป

def thakthai() -> None:
    print('สวัสดี')

การระบุชนิดข้อมูลแอตทริบิวต์ในการสร้างคลาส

การสร้างคลาสโดยมีการบอกใบ้ชนิดข้อมูลตัวแปรของแอตทริบิวต์ไปด้วยให้ระบุลงไปด้านในส่วนโครงสร้างคลาส

ตัวอย่างการเขียน

class Khon:
    chue: str
    ayu: int
    
    def __init__(self, chue: str, ayu: int):
        self.chue = chue
        self.ayu = ayu
    
    def naenamtua(self):
        print(f'"ฉันชื่อ{self.chue} อายุ {self.ayu}"')
    
khond: Khon = Khon('คนดี',15)
khond.naenamtua() # ได้ "ฉันชื่อคนดี อายุ 15"

# ชนิดของข้อมูลที่ระบุไปนั้นยังถูกเก็บอยู่ใน .__annotations__ ด้วย
print(Khon.__annotations__) # ได้ {'chue': <class 'str'>, 'ayu': <class 'int'>}

เวลาที่ประกาศตัวแปรโดยสร้างออบเจกต์ขึ้นจากคลาสที่สร้างขึ้นนั้นจะเห็นว่าต้องเขียนชื่อคลาสซ้ำกัน ๒ ครั้งเป็น ตัวแปร: ชื่อคลาส = ชื่อคลาส() แบบนี้อาจดูแล้วเยิ่นเย้อแปลกๆสักหน่อย แต่ว่าเวลาที่เขียนภาษา C++ ก็เป็นลักษณะคล้ายแบบนี้เหมือนกัน

สำหรับการนิยามเมธอดภายในคลาสนั้นก็สามารถระบุตัวแปรพารามิเตอร์ได้เช่นกัน แต่ว่าตรง self ไม่จำเป็นต้องใส่




การระบุชนิดข้อมูลทางเลือก

ถ้าต้องการให้ตัวแปรนั้นๆเป็นชนิดไหนก็ได้ในจำนวนหลายชนิดที่กำหนดก็ทำได้โดยเขียนข้อมูลแต่ละชนิดที่ต้องการให้เป็นได้แล้วคั่นด้วย |

ชื่อตัวแปร: ชนิดข้อมูล๑|ชนิดข้อมูล๒ = ค่า

เช่นถ้าต้องการให้เป็น int หรือ float ก็ได้ก็อาจเขียนแบบนี้

a: int|float = 1
a = 1.1

พอเขียนแบบนี้แล้วก็ทำให้ใช้ได้ยืดหยุ่นขึ้น

บ่อยครั้งเราต้องการระบุว่าตัวแปรนั้นๆเป็น None ได้ด้วย ในกรณีแบบนั้นก็ให้เขียน |None

n: int|None = 10

ชนิดข้อมูลภายในลิสต์หรือเซ็ต

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

ชื่อตัวแปร: list[ชนิดข้อมูลในลิสต์]
ชื่อตัวแปร: set[ชนิดข้อมูลในเซ็ต]

เช่น

lis1: list[str] = ['ไก่','ไข่']
lis2: list[float] = [1.1,1.3,1.6]
set1: set[int] = {10,20,40}

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

หรือถ้าต้องการให้ใส่ได้หลายชนิดก็ระบุแต่ละชนิดที่ใช้ได้โดยคั่นด้วย | ได้

set2: set[int|float] = {1.7,3,4.5,6}

ถ้าเป็นลิสต์ที่ข้างในมีลิสต์อีกทีก็สามารถระบุชนิดตัวแปรภายในลึกลงไปขั้นต่อไปได้อีก

lilis: list[list[str]] = [['ก','ข'],['ค','ง']]

ชนิดข้อมูลภายในทูเพิล

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

ชื่อตัวแปร: tuple[ชนิดข้อมูล๑, ชนิดข้อมูล๒, ...] = (ค่า๑, ค่า๒, ...)

เช่น

tup1: tuple[int,float,str] = (1,1.0,'1')

ชนิดข้อมูลภายในดิกชันนารี

สำหรับดิกชันนารีนั้นจะกำหนดชนิดข้อมูลให้ทั้งคีย์และค่าได้

ชื่อตัวแปร: dict[ชนิดข้อมูลของคีย์, ชนิดข้อมูลของค่า]

เช่น

dic1: dict[int,float] = {1: 11.1, 2: 22.2}
dic2: dict[str,int|float] = {'ก': 11, 'ข': 22.2}

วิธีการเขียนในเวอร์ชันเก่า

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

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

เช่นในการกำหนดให้ชนิดข้อมูลมีทางเลือก เวอร์ชัน 3.10 เป็นต้นมาจะใช้ | แต่ในเวอร์ชันเก่าจนถึง 3.9 จะใช้ typing.Union เช่น

from typing import Union
a: Union[int,float,str]

เทียบกับเวอร์ชันใหม่คือ a: int|float|str แบบนี้ดูกระชับแล้วเข้าใจง่ายกว่ามาก

นอกจากนี้ยังมี typing.Optinal ไว้ใช้สำหรับระบุให้ตัวแปรเป็น None ได้ เช่น

from typing import Optional
x: Optional[int]

แบบนี้จะเทียบเท่ากับการเขียนแบบใหม่คือ x: int|None

ส่วนการนิยามลิสต์, เซ็ต, ทูเพิล, ดิกชันนารี ในเวอร์ชัน 3.9 เป็นต้นมาจะใช้ list, set, tuple, dict โดยตรงเลย แต่ในเวอร์ชันเก่าจนถึง 3.8 จะใช้ typing.List, typing.Set, typing.Tuple, typing.Dict เช่น

from typing import List,Set,Tuple,Dict

lis1: List[str]
set1: Set[int]
tup1: Tuple[str,int]
dic1: Dict[str,int]

ดูเผินๆแล้วก็อาจไม่ต่างจากการเขียนแบบเวอร์ชัน 3.9 เป็นต้นมา แต่ว่าขึ้นต้นด้วยพิมพ์ใหญ่ และจำเป็นต้อง import มาด้วย ดังนั้นแบบใหม่จึงสะดวกกว่า




สรุปทิ้งท้าย

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

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

โดยรวมแล้วประโยชน์ของการใช้ก็อาจมีดังนี้

• ช่วยให้อ่านง่าย เพราะรู้ชนิดข้อมูลของตัวแปรชัดเจน
• เพิ่มความปลอดภัยของโค้ด เพราะกันการใช้ตัวแปรผิดชนิด
• ช่วยให้ค้นหาข้อผิดพลาดได้ง่าย ไม่ใช่แค่มองด้วยตา แต่อีดิเตอร์เช่น spyder หรือ vs code ก็ช่วยสอดส่องให้เราด้วย
• ถ้าใช้กับแพ็กเกจเสริมบางตัว เช่น mypy จะยิ่งจัดการกับข้อผิดพลาดได้ง่ายขึ้นอีก
• ช่วยในการสร้างเอกสารอธิบายการใช้งาน เช่นเมื่อทำโดย pydoc หรือ sphinx เป็นต้น
• มีผลในการเขียนโค้ดด้วยมอดูลเสริมบางตัวของไพธอน เช่น fastadi เป็นต้น หากจะใช้มอดูลพวกนี้ควรศึกษาไว้

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

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



อ้างอิง