การแปลงชนิดข้อมูลใน 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 รวมถึงการควบคุมการไหลของโปรแกรมด้วยลูป ตอนท้ายคอร์สมีกรณีศึกษาให้ได้นำสิ่งที่เรียนไปประยุกต์ใช้จริงด้วย!