การแปลงชนิดข้อมูลใน Python: คู่มือพร้อมตัวอย่าง

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

ทำไมค่าทศนิยมจึงไม่ถูกแปลงเป็นจำนวนเต็มแทน?

นั่นมาจากแนวคิดเรื่องการเลื่อนชนิดข้อมูล (type promotion) ในวิทยาการคอมพิวเตอร์ พูดง่ายๆ คือกลไกป้องกันของคอมไพเลอร์ที่ช่วยให้สามารถดำเนินการได้เมื่อเป็นไปได้ โดยการแปลงข้อมูลเป็นซูเปอร์ไทป์ที่กว้างขึ้นโดยไม่ทำให้ข้อมูลสูญหาย

ดังนั้นจึงไม่แปลงจากทศนิยมเป็นจำนวนเต็ม เพราะคอมไพเลอร์จำเป็นต้องตัดส่วนทศนิยมทิ้ง ซึ่งทำให้ข้อมูลสูญหาย

การแปลงชนิดข้อมูลแบบชัดแจ้งใน Python

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

ไวยากรณ์ของการแปลงแบบชัดแจ้งคือ:

target_data_type(expression)

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

int(3.14)  # Converts 3.14 to 3

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

ต่อไปมาสำรวจการแปลงชนิดข้อมูลแบบชัดแจ้งที่ใช้บ่อยกัน

โครงสร้างข้อมูลแบบปฐมภูมิกับแบบไม่ปฐมภูมิใน Python

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

• จำนวนเต็ม (Integers)
• จำนวนทศนิยม (Float)
• สตริง (Strings)
• บูลีน (Boolean)

โครงสร้างข้อมูลแบบไม่ปฐมภูมิไม่ได้เก็บเพียงค่าเดียว แต่เก็บชุดของค่าในรูปแบบต่างๆ ใน Python มีโครงสร้างข้อมูลแบบไม่ปฐมภูมิดังนี้:

• ลิสต์ (Lists)
• ทูเพิล (Tuples)
• ดิกชันนารี (Dictionaries)
• เซ็ต (Sets)

สามารถเรียนรู้เพิ่มเติมได้จากบทความ Data Structures in Python Tutorial ของ DataCamp

การแปลงโครงสร้างข้อมูลแบบปฐมภูมิ

การแปลงจำนวนเต็มและทศนิยมใน Python

จำนวนเต็มและทศนิยมเป็นชนิดข้อมูลที่ใช้กับตัวเลข

หากต้องการแปลงจำนวนเต็มเป็นทศนิยม ให้ใช้ฟังก์ชัน float() ใน Python เช่นเดียวกัน หากต้องการแปลงทศนิยมเป็นจำนวนเต็ม ให้ใช้ฟังก์ชัน int()

a_int = 3
b_int = 2

# Explicit type conversion from int to float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Explicit type conversion from float to int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)

5
5.3

ปัญหาความแม่นยำของทศนิยมลอยตัวและโมดูล Decimal

การคำนวณทศนิยมลอยตัวใน Python อาจมีปัญหาความแม่นยำ:

print(0.1 + 0.2)  # Output: 0.30000000000000004

เพื่อหลีกเลี่ยง ใช้โมดูล Decimal:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

การแปลงจากจำนวนจริงเป็นเชิงซ้อนไปใน Python

สามารถแปลงจำนวนเต็มเป็นจำนวนเชิงซ้อนได้ด้วย complex(real,imag) โดยรับจำนวนจริงและจำนวนจินตภาพสองค่า และแปลงเป็นจำนวนเชิงซ้อน

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

การแปลงชนิดข้อมูลกับสตริงใน Python

สตริงคือชุดของอักขระหนึ่งตัวขึ้นไป (ตัวอักษร ตัวเลข สัญลักษณ์) มักต้องแปลงสตริงเป็นตัวเลข หรือแปลงตัวเลขเป็นสตริงอยู่บ่อยครั้ง

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

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

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


TypeError: Can't convert 'int' object to str implicitly

ตัวอย่างข้างต้นเกิด TypeError แจ้งว่าคอมไพเลอร์ไม่สามารถแปลงจำนวนเต็มเป็นสตริงแบบอ隐式ได้

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

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")

The total is: 21$

การแปลงจากทศนิยมเป็นสตริงก็ทำงานในลักษณะเดียวกัน

ใน Python ยังสามารถแปลงสตริงให้เป็นจำนวนเต็มและทศนิยมได้เมื่อทำได้ มาดูกันว่าหมายถึงอะไร:

price_cake = '15'
price_cookie = '6'

# String concatenation
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explicit type conversion to integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

The total is: 156$
The total is: 21$

มาทำความเข้าใจโค้ดกัน

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

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

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

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)

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

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

สรุป: การแปลงชนิดข้อมูลปฐมภูมิใน Python

การแปลงโครงสร้างข้อมูลแบบไม่ปฐมภูมิ

การแปลงชนิดข้อมูลเป็นทูเพิลและลิสต์ใน Python

เช่นเดียวกับจำนวนเต็มและทศนิยม สามารถแปลงลิสต์เป็นทูเพิล และทูเพิลเป็นลิสต์ได้

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

ทำไมต้องแปลงลิสต์เป็นทูเพิล?

เพราะ���ูเพิลเป็นชนิดข้อมูลที่แก้ไขไม่ได้ จึงช่วยเพิ่มประสิทธิภาพให้โปรแกรมได้มาก

แล้วทำไมต้องแปลงทูเพิลเป็นลิสต์?

อาจต้องการแก้ไขค่าของทูเพิลเริ่มต้น จึงแปลงเป็นลิสต์ ทำการแก้ไข แล้วแปลงกลับเป็นทูเพิล

ใน Python ใช้ฟังก์ชัน tuple() เพื่อแปลงค่าที่ส่งเข้าให้กลายเป็นทูเพิล และใช้ list() เพื่อแปลงทูเพิลเป็นลิสต์ได้เช่นกัน:

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))

(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

ในทำนองเดียวกัน นี่คือวิธีแปลงสตริงเป็นลิสต์หรือทูเพิลใน Python:

dessert = 'Cake'

# Convert the characters in a string to individual items in a tuple
print(tuple(dessert))

# Convert a string into a list
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

การแปลงชนิดข้อมูลเป็นดิกชันนารีและเซ็ตใน Python

สามารถใช้ฟังก์ชัน dict() เพื่อแปลงทูเพิลเป็นดิกชันนารี และใช้ set() เพื่อแปลงลิสต์เป็นเซ็ต 

print(dict(a_tuple))
print(set(b_list))

{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

คล้ายกับฟังก์ชันแปลงชนิดอื่นๆ เพียงเรียกชื่อฟังก์ชันก็สามารถแปลงชนิดข้อมูลเป็นดิกชันนารีและเซ็ตได้

การใช้ dataclasses สำหรับข้อมูลที่มีโครงสร้าง (Python 3.7+)

แทนการใช้ดิกชันนารีหรือทูเพิล dataclasses ช่วยจัดการข้อมูลที่มีโครงสร้างได้ดีกว่า

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

สรุป: การแปลงโครงสร้างข้อมูลแบบไม่ปฐมภูมิใน Python

ยูนิโค้ด เลขฐานสอง ฐานแปด และฐานสิบหกใน Python

ระบบตัวเลขหมายถึงจำนวนสัญลักษณ์หรืออักขระที่ใช้แทนค่าตัวเลข ระบบตัวเลขที่ใช้ในชีวิตประจำวันเรียกว่าแบบฐานสิบ ซึ่งใช้สัญลักษณ์สิบตัว: 0, 1, 2, 3, 4, 5, 6, 7, 8 และ 9 ด้วยสัญลักษณ์ทั้งสิบนี้สามารถแทนปริมาณใดๆ ก็ได้ ยูนิโค้ด เลขฐานสอง เลขฐานสิบหก และเลขฐานแปด หมายถึงระบบตัวเลขคนละแบบ

เมื่อใช้สัญลักษณ์หมดแล้วจะเลื่อนไปหลักถัดไป ในระบบฐานสิบ เมื่อต้องการแทนค่าที่มากกว่า 9 หนึ่งหน่วย จะใช้ 10 ซึ่งหมายถึงหนึ่งหน่วยของสิบและศูนย์หน่วยของหนึ่ง อย่างไรก็ตาม ระบบอื่นจะต่างออกไป เช่น ในระบบฐานสองที่ใช้เพียงสองสัญลักษณ์คือ 0 และ 1 เมื่อใช้สัญลักษณ์หมดก็ต้องเลื่อนไปหลักถัดไป ดังนั้นการนับในฐานสองจะเป็น: 0, 1, 10, 11, 100, 101 เป็นต้น

มาดูรายละเอียดของระบบตัวเลขบางแบบในส่วนถัดไป

การแปลงเลขฐานสองเป็นฐานสิบใน Python

จำนวนในฐานสองคือจำนวนที่แทนด้วยฐานสอง ซึ่งมีเพียงสองสัญลักษณ์คือ 0 และ 1 เมื่อเริ่มนับจาก��ูนย์ในฐานสอง จะใช้สัญลักษณ์หมดเร็ว: 0, 1, ???

หลังจากนั้นไม่มีสัญลักษณ์เหลือแล้ว จะไม่ไปที่เลข 2 เพราะ 2 ไม่มีในฐานสอง แต่ใช้การจัดเรียงพิเศษของเลข 1 และ 0 แทน ในระบบฐานสอง 1000 เท่ากับ 8 ในฐานสิบ ในฐานสองจะใช้กำลังของ 2 ซึ่งหมายความว่า 8 คือ: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8 ตำแหน่งของ 1 และ 0 จะกำหนดกำลังที่ 2 ถูกยกกำลัง

มาดูตัวอย่างที่ซับซ้อนขึ้นเพื่อให้ชัดเจน:

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

ใน Python สามารถใช้ฟังก์ชัน bin() เพื่อแปลงจากค่าฐานสิบเป็นค่าฐานสองที่สอดคล้องกัน

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

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)

0b1001111
79

การแปลงเลขฐานแปดเป็นฐานสิบใน Python

เลขฐานแปดเป็นอีกระบบหนึ่งที่มีสัญลักษณ์น้อยกว่าฐานสิบ ใช้ฐานแปด หมายถึงใช้สัญลักษณ์แปดตัวเพื่อแทนปริมาณทั้งหมด ได้แก่ 0, 1, 2, 3, 4, 5, 6 และ 7 หลังจาก 7 จะเป็น 10 เพราะ 8 ไม่มีอยู่

เช่นเดียวกับฐานสองที่ใช้กำลังของ 2 เพื่อกำหนดค่าของจำนวน ในฐานแปดจะใช้กำลังของ 8 เพราะเป็นฐานแปด

ในระบบฐานแปด เลข 10 เท่ากับ 8 ในฐานสิบ แยกส่วนได้เป็น: (1(8^1)) + (0(8^0)) = 8

ตัวอย่างที่ซับซ้อนขึ้น:

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

ใน Python ใช้ฟังก์ชัน oct() เพื่อแปลงจากค่าฐานสิบเป็นค่าฐานแปดที่สอดคล้องกัน หรือใช้ฟังก์ชัน int() พร้อมฐานที่ถูกต้อง ซึ่งสำหรับฐานแปดคือ 8

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

การแปลงเลขฐานสิบหกเป็นฐานสิบใน Python

เลขฐานสิบหกเป็นระบบเลขฐาน 16 ต่างจากฐานสองและฐานแปด เพราะใช้สัญลักษณ์เพิ่มเติมอีกหกตัวนอกเหนือจากตัวเลขในฐานสิบ

แล้วหลังจาก 9 คืออะไร?

เมื่อจำเป็นต้องมีสัญลักษณ์นอกเหนือจากตัวเลขทั่วไป จะใช้ตัวอักษร ดังนั้นในฐานสิบหก รายการสัญลักษณ์ทั้งหมดคือ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E และ F

ใช้ตัวอย่างเดิม:

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

ใน Python ใช้ฟังก์ชัน hex() เพื่อแปลงจากค่าฐานสิบเป็นค่าฐานสิบหกที่สอดคล้องกัน หรือใช้ฟังก์ชัน int() พร้อมฐาน 16 สำหรับระบบเลขฐานสิบหก

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

การแปลงยูนิโค้ดเป็นอักขระ

ฟังก์ชัน chr() ใน Python แปลงจำนวนยูนิโค้ดเป็นสตริง ยูนิโค้ดเป็นมาตรฐานการเข้ารหัสอักขระที่ยอมรับโดยทั่วไปสำหรับการแสดงข้อความของภาษาต่างๆ

ตัวอย่างนี้ให้จำนวนยูนิโค้ดหลายค่าแก่ฟังก์ชัน chr() เพื่อแสดงคำว่า “DATACAMP” และยังสามารถใช้ ord() เพื่อแปลงอักขระหนึ่งตัวเป็นจำนวนยูนิโค้ดได้ด้วย 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)

D A T A C A M P

สรุป: การแปลงระบบเลขใน Python

เยี่ยมมาก!

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

เรามีคอร์ส Intermediate Python for Data Science ที่ยอดเยี่ยม ซึ่งจะได้เรียนการพล็อตข้อมูลด้วย matplotlib และการทำงานกับดิกชันนารีและ pandas DataFrame รวมถึงการควบคุมการไหลของโปรแกรมด้วยลูป ตอนท้ายคอร์สมีกรณีศึกษาให้ได้นำสิ่งที่เรียนไปประยุกต์ใช้จริงด้วย!