แปลงสตริงเป็นตัวเลขใน Python: จัดการข้อผิดพลาดและตัวอย่าง

目次

1. บทนำ

เมื่อเขียนโปรแกรมด้วย Python การแปลงชนิดข้อมูลเป็นเทคนิคที่สำคัญอย่างยิ่ง โดยเฉพาะทักษะในการแปลงไปมาระหว่างสตริงและตัวเลขนั้นจำเป็นต่อการนำเข้า/ส่งออกข้อมูลและการประมวลผลทางคำนวณ ตัวอย่างเช่น มักมีสถานการณ์ที่ต้องนำสตริงที่ผู้ใช้กรอกในฟอร์มไปคำนวณเป็นตัวเลข หรือจัดรูปแบบตัวเลขผลลัพธ์การคำนวณให้เป็นสตริงเพื่อแสดงผลอยู่บ่อยครั้ง อย่างไรก็ตาม การผสมข้อมูลที่มีชนิดต่างกันอาจทำให้เกิดข้อผิดพลาดได้ สำหรับผู้เริ่มต้นใช้ Python จึงควรระมัดระวัง บทความนี้จะแนะนำวิธีการแปลง “จากสตริงเป็นตัวเลข” และ “จากตัวเลขเป็นสตริง” ใน Python พร้อมยกตัวอย่างการใช้งานจริง อีกทั้งอธิบายอย่างละเอียดเกี่ยวกับการจัดการข้อผิดพลาดและการรับมือกับกรณีเฉพาะต่างๆ หวังว่าจะช่วยให้คุณเสริมสร้างทักษะตั้งแต่พื้นฐานไปจนถึงการประยุกต์ใช้ใน Python ได้ ในส่วนถัดไป เราจะอธิบายอย่างละเอียดเกี่ยวกับวิธีการแปลงชนิดข้อมูลพื้นฐานใน Python

2. การแปลงชนิดข้อมูลพื้นฐานใน Python

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

การแปลงเป็นจำนวนเต็ม

เมื่อค่าตัวเลขถูกป้อนมาในรูปแบบสตริง หากต้องการคำนวณตัวเลขใน Python จะต้องแปลงสตริงนั้นเป็นจำนวนเต็มหรือจำนวนทศนิยมลอยตัวก่อน ตัวอย่างเช่น หากต้องการแปลงสตริง “42” ให้เป็นจำนวนเต็ม42 ให้ใช้ฟังก์ชันint() ดังนี้:
str_number = "42"
int_number = int(str_number)
print(int_number)  # ผลลัพธ์: 42
ดังที่เห็น เมื่อใช้ฟังก์ชันint() สามารถแปลงจากสตริงเป็นจำนวนเต็มได้ เมื่อแปลงสำเร็จจะสามารถใช้งานเป็นตัวเลขได้ ประเด็นที่ต้องระวังคือ หากพยายามแปลงสตริงที่มีจุดทศนิยม เช่น "42.0" เป็นชนิดจำนวนเต็ม จะเกิดข้อผิดพลาด การแปลงเป็นจำนวนเต็มใช้ได้เฉพาะค่าจำนวนเต็มเท่านั้น หากมีจุดทศนิยมควรใช้float() แทน

การแปลงเป็นจำนวนทศนิยมลอยตัว

จำนวนทศนิยมลอยตัวคือชนิดข้อมูลที่สามารถเก็บส่วนทศนิยมของตัวเลขได้ ใน Python สามารถใช้ฟังก์ชันfloat() เพื่อแปลงสตริงให้เป็นจำนวนทศนิยมลอยตัวได้ ตัวอย่างเช่น เพื่อแปลงสตริง “3.14” เป็นจำนวนทศนิยมลอยตัว ใช้โค้ดต่อไปนี้:
str_float = "3.14"
float_number = float(str_float)
print(float_number)  # ผลลัพธ์: 3.14
ดังนั้น เมื่อใช้ฟังก์ชันfloat() ก็สามารถแปลงจากสตริงเป็นจำนวนทศนิยมลอยตัวได้ นอกจากนี้ สตริงในรูปแบบสัญกรณ์เลขยกกำลังก็สามารถแปลงด้วยfloat() ได้เช่นกัน โดยรองรับรูปแบบอย่าง "1.23e-4" เป็นต้น
str_exp = "1.23e-4"
float_exp = float(str_exp)
print(float_exp)  # ผลลัพธ์: 0.000123

การแปลงจากตัวเลขเป็นสตริง

ในทางกลับกัน ก็มีหลายกรณีที่จำเป็นต้องแปลงตัวเลขเป็นสตริง เช่น เมื่อต้องการนำตัวเลขไปเชื่อมกับสตริงอื่นเพื่อแสดงผล ในกรณีนี้ให้ใช้ฟังก์ชันstr()
num = 42
str_num = str(num)
print("ผลลัพธ์ของการแปลงตัวเลขเป็นสตริง: " + str_num)  # ผลลัพธ์: ผลลัพธ์ของการแปลงตัวเลขเป็นสตริง: 42
ดังนั้น ฟังก์ชันstr() จะทำการแปลงจากตัวเลขเป็นสตริง ทำให้สามารถจัดการสตริงที่มีตัวเลขได้ เมื่อเข้าใจการแปลงชนิดข้อมูลพื้นฐานแล้ว ต่อไปเป็นการประยุกต์ เช่น วิธีแปลงเลขฐานอื่นๆ และการแปลงสตริงฟูลวิธ เป็นต้น

3. ตัวอย่างการประยุกต์ใช้: การแปลงเลขฐานหลายแบบและตัวเลขฟูลวิดธ์

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

การแปลงฐานสอง ฐานแปด และฐานสิบหก

ฟังก์ชัน int() ของ Python สามารถแปลงสตริงฐาน 2, ฐาน 8 และฐาน 16 ได้ ไม่ใช่เฉพาะฐานสิบเท่านั้น โดยระบุค่าฐาน (เลขฐาน) เป็นอาร์กิวเมนต์ตัวที่สองของ int() ตัวอย่างเช่น หากต้องการแปลงสตริงฐานสองหรือฐานสิบหกให้เป็นจำนวนเต็ม ให้เขียนดังนี้
binary_str = "1010"  # สตริงฐานสอง
octal_str = "12"  # สตริงฐานแปด
hex_str = "a"  # สตริงฐานสิบหก

int_binary = int(binary_str, 2)
int_octal = int(octal_str, 8)
int_hex = int(hex_str, 16)

print(int_binary)  # ผลลัพธ์: 10
print(int_octal)  # ผลลัพธ์: 10
print(int_hex)  # ผลลัพธ์: 10
ดังที่เห็น สตริงฐานสอง ฐานแปด และฐานสิบหกก็สามารถแปลงเป็นจำนวนเต็มได้โดยใช้ int() พร้อมระบุฐานที่สอดคล้องกัน ฟังก์ชันนี้มีประโยชน์มากเมื่อจัดการข้อมูลที่รองรับหลายระบบเลขฐาน

การจัดการตัวเลขฟูลวิดธ์และอักขระพิเศษ

หากสตริงจากการป้อนของผู้ใช้มีตัวเลขแบบฟูลวิดธ์หรือมีอักขระพิเศษ เมื่อลองแปลงตรงๆ ใน Python อาจเกิดข้อผิดพลาดได้ โดยเฉพาะเมื่อมีอักขระฟูลวิดธ์ปะปนในการป้อนตัวเลขภาษาญี่ปุ่น ซึ่งมักทำให้ Python จัดการได้ไม่ถูกต้อง จึงแนะนำให้ใช้เมธอด replace() เพื่อแปลงฟูลวิดธ์เป็นฮาล์ฟวิดธ์ ตัวอย่างต่อไปนี้เป็นการแปลงสตริงฟูลวิดธ์ให้เป็นฮาล์ฟวิดธ์ก่อน แล้วค่อยแปลงเป็นตัวเลข
str_num_fullwidth = "12345"
str_num_halfwidth = str_num_fullwidth.translate(str.maketrans('0123456789', '0123456789'))

print(int(str_num_halfwidth))  # ผลลัพธ์: 12345
ด้วยวิธีนี้ สตริงตัวเลขแบบฟูลวิดธ์ก็สามารถแปลงเป็นตัวเลขได้ หากต้องแปลงจุดทศนิยมแบบฟูลวิดธ์ด้วย ให้เพิ่มการแปลงดังนี้
str_float_fullwidth = "123.456"
str_float_halfwidth = str_float_fullwidth.translate(str.maketrans('0123456789.', '0123456789.'))

print(float(str_float_halfwidth))  # ผลลัพธ์: 123.456

การแปลงตัวเลขคันจิ

ใน Python สามารถใช้โมดูล Unicode เพื่อแปลงตัวเลขคันจิบางส่วนให้เป็นตัวเลขได้ โดยใช้ unicodedata.numeric() จะสามารถแปลงสตริงอย่าง「一」หรือ「百」ให้เป็นจำนวนจริงแบบจุดลอยได้
import unicodedata

kanji_num = '五'
converted_num = unicodedata.numeric(kanji_num)
print(converted_num)  # ผลลัพธ์: 5.0
อย่างไรก็ตาม วิธีนี้ไม่รองรับตัวเลขคันจิที่มีหลายอักขระ (เช่น 「十五」) ดังนั้นหากต้องการประมวลผลที่ซับซ้อนกว่านี้ แนะนำให้ใช้ไลบรารีเสริมหรือปรับแต่งด้วยเรกูลาร์เอ็กซ์เพรสชัน ดังนั้น Python จึงมีวิธีแปลงสตริงของตัวเลขได้หลากหลาย ส่วนถัดไปจะอธิบายรายละเอียดวิธีตรวจสอบว่าค่าป้อนเข้าจะแปลงได้หรือไม่ และการจัดการข้อผิดพลาดอย่างเหมาะสม

4. การจัดการข้อผิดพลาดและการตรวจสอบความถูกต้องของอินพุต

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

การตรวจสอบว่าเป็นตัวเลขด้วยisdigit() และเรกูลาร์เอกซ์เพรสชัน

วิธีตรวจสอบล่วงหน้าว่าสตริงสามารถแปลงเป็นตัวเลขได้หรือไม่ สามารถใช้เมธอด isdigit() ของ Python หรือใช้เรกูลาร์เอกซ์เพรสชันได้ isdigit() จะคืนค่า True เมื่อสตริงประกอบด้วยตัวเลขทั้งหมด แต่ถ้ามีจุดทศนิยมหรือเครื่องหมายลบจะคืนค่า False ดังนั้นจึงเหมาะสำหรับกรณีที่ต้องการตรวจสอบเฉพาะจำนวนเต็ม
def is_integer(input_str):
    return input_str.isdigit()

# ตัวอย่างการใช้งาน
print(is_integer("123"))  # ผลลัพธ์: True
print(is_integer("3.14"))  # ผลลัพธ์: False
print(is_integer("-123"))  # ผลลัพธ์: False
ในทางกลับกัน สำหรับการตรวจสอบตัวเลขที่รวมถึงจำนวนทศนิยมและจำนวนลบ การใช้เรกูลาร์เอกซ์เพรสชันจะสะดวกกว่า ตัวอย่างต่อไปนี้ตั้งค่าให้คืนค่า True สำหรับตัวเลขที่มีเครื่องหมาย + หรือ – นำหน้า รวมถึงค่าที่มีจุดทศนิยมด้วย
import re

def is_numeric(input_str):
    return bool(re.match(r'^[+-]?d+(.d+)?$', input_str))

# ตัวอย่างการใช้งาน
print(is_numeric("123"))       # ผลลัพธ์: True
print(is_numeric("-123.45"))   # ผลลัพธ์: True
print(is_numeric("3.14.15"))   # ผลลัพธ์: False
print(is_numeric("abc"))       # ผลลัพธ์: False
การใช้เรกูลาร์เอกซ์เพรสชันช่วยให้สามารถตัดสินได้อย่างยืดหยุ่นมากขึ้นว่าเป็นตัวเลขหรือไม่ จึงมีประโยชน์เมื่อจัดการข้อมูลอินพุตที่ซับซ้อน

การจัดการข้อผิดพลาด: รับมือด้วยการจัดการข้อยกเว้น

ใน Python หากข้อมูลไม่เหมาะสมขณะทำการแปลงสตริงเป็นตัวเลขจะเกิดข้อผิดพลาด (ValueError) เพื่อจับข้อผิดพลาดนี้และให้การประมวลผลดำเนินต่อไป โดยทั่วไปจะใช้บล็อก try-except สำหรับการจัดการข้อยกเว้น ตัวอย่างต่อไปนี้จะแสดงข้อความข้อผิดพลาดที่เหมาะสมเมื่อเกิดข้อผิดพลาดระหว่างพยายามแปลงสตริงเป็นจำนวนเต็ม
def convert_to_int(input_str):
    try:
        return int(input_str)
    except ValueError:
        print(f"Error: '{input_str}' ไม่สามารถแปลงเป็นจำนวนเต็มได้.")
        return None

# ตัวอย่างการใช้งาน
print(convert_to_int("123"))  # ผลลัพธ์: 123
print(convert_to_int("abc"))  # ผลลัพธ์: Error: 'abc' ไม่สามารถแปลงเป็นจำนวนเต็มได้.
ด้วยวิธีนี้ เมื่อเพิ่มการจัดการข้อยกเว้นแล้ว โปรแกรมจะยังคงทำงานต่อได้อย่างราบรื่นแม้เกิดข้อผิดพลาด นอกจากนี้ยังทำให้การให้ข้อมูลป้อนกลับแก่ผู้ใช้ชัดเจนขึ้น และรับมือกับการป้อนข้อมูลผิดพลาดได้ง่ายขึ้น หากดำเนินการตรวจสอบความถูกต้องของข้อมูลอินพุตและการจัดการข้อผิดพลาดอย่างเหมาะสม ความเชื่อถือได้ของโค้ดจะเพิ่มขึ้น ส่วนถัดไปเราจะดูวิธีแปลงองค์ประกอบของลิสต์แบบรวดเดียว
RUNTEQ(ランテック)|超実戦型エンジニア育成スクール

5. วิธีแปลงสมาชิกของลิสต์แบบเป็นชุด

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

การแปลงแบบเป็นชุดโดยใช้ list comprehension

ใน Python นอกจากจะใช้ลูปเพื่อประมวลผลสมาชิกของลิสต์ทีละตัวแล้ว ยังสามารถใช้ list comprehension เพื่อแปลงข้อมูลได้อย่างกระชับและมีประสิทธิภาพ list comprehension คือวิธีการที่ทำการดำเนินการเฉพาะกับสมาชิกแต่ละตัวของลิสต์แล้วสร้างลิสต์ใหม่ขึ้นมา ตัวอย่างเช่น หากต้องการแปลงลิสต์ที่มีตัวเลขในรูปแบบสตริงให้เป็นลิสต์ของจำนวนเต็ม ให้ใช้โค้ดต่อไปนี้
str_list = ["10", "20", "30", "40", "50"]
int_list = [int(i) for i in str_list]

print(int_list)  # ผลลัพธ์: [10, 20, 30, 40, 50]
ในตัวอย่างนี้ ด้วย list comprehension [int(i) for i in str_list] สมาชิกแต่ละตัวในstr_listจะถูกแปลงเป็นจำนวนเต็มด้วยฟังก์ชันint() และสร้างลิสต์ใหม่int_listขึ้นมา วิธีนี้ช่วยให้จัดการข้อมูลขนาดใหญ่ได้ด้วยโค้ดสั้นๆ จึงทำให้ทั้งความอ่านง่ายและประสิทธิภาพของโค้ดดีขึ้น

การแปลงลิสต์แบบเป็นชุดพร้อมการจัดการข้อผิดพลาด

หากในลิสต์มีข้อมูลที่ไม่สามารถแปลงได้ (เช่น ข้อความหรืออักขระพิเศษ) จะเกิดข้อผิดพลาด ในกรณีนี้ สามารถหลีกเลี่ยงข้อผิดพลาดจากการแปลงได้โดยใส่เงื่อนไขหรือการจัดการข้อยกเว้นลงใน list comprehension ด้านล่างเป็นตัวอย่างที่แปลงเฉพาะสมาชิกที่สามารถแปลงได้ให้เป็นจำนวนเต็ม
str_list = ["10", "20", "abc", "30", "40"]

int_list = []
for i in str_list:
    try:
        int_list.append(int(i))
    except ValueError:
        print(f"Warning: '{i}' ไม่สามารถแปลงเป็นจำนวนเต็มได้.")

print(int_list)  # ผลลัพธ์: [10, 20, 30, 40]
ในโค้ดนี้ ใช้บล็อกtry-exceptเพื่อแปลงสตริงเป็นจำนวนเต็ม และเมื่อแปลงไม่ได้จะแสดงข้อความแจ้งข้อผิดพลาด โดยเพิ่มเฉพาะสมาชิกที่แปลงได้ลงในint_listด้วยเมธอดappend() ทำให้แม้เกิดข้อผิดพลาด กระบวนการยังคงทำงานต่อไปและได้ผลลัพธ์การแปลง การแปลงลิสต์แบบเป็นชุดเป็นวิธีที่มีประโยชน์อย่างยิ่งในการประมวลผลข้อมูลจำนวนมาก ส่วนถัดไปจะสรุปภาพรวมของบทความและจัดระเบียบสิ่งที่ได้เรียนรู้ในครั้งนี้。

6. สรุป

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

ทบทวนบทความ

  1. เกริ่นนำ
  • ได้อธิบายสถานการณ์ที่จำเป็นต้องแปลงสตริงและตัวเลข แสดงเหตุผลว่าทำไมการแปลงชนิดข้อมูลจึงสำคัญในการคำนวณเชิงตัวเลขและการแสดงผลข้อมูล
  1. การแปลงชนิดข้อมูลพื้นฐานใน Python
  • ได้เรียนรู้วิธีแปลงชนิดข้อมูลพื้นฐาน โดยใช้ฟังก์ชัน int() และ float() รวมถึง str() เพื่อสลับชนิดข้อมูลระหว่างสตริงกับตัวเลข
  1. ตัวอย่างประยุกต์: การแปลงเลขฐานต่างๆ และตัวเลขฟูลไวจ์ด
  • ได้แนะนำวิธีแปลงเลขฐานสอง ฐานแปด และฐานสิบหกให้เป็นจำนวนเต็ม รวมถึงวิธีแปลงอักขระฟูลไวจ์ดเป็นฮาล์ฟไวจ์ดเพื่อให้สามารถใช้งานเป็นตัวเลขได้ นอกจากนี้ยังอธิบายวิธีแปลงตัวเลขคันจิเป็นค่าตัวเลขด้วย unicodedata.numeric()
  1. การจัดการข้อผิดพลาดและการตรวจสอบความถูกต้องของอินพุต
  • คำนึงถึงความเป็นไปได้ที่จะเกิดข้อผิดพลาดระหว่างการแปลงเป็นตัวเลข โดยแนะนำวิธีตรวจสอบล่วงหน้าว่าเป็นตัวเลขหรือไม่ด้วย isdigit() และเรกซ์เพรสชัน รวมถึงวิธีจัดการข้อยกเว้นด้วย try-except
  1. วิธีแปลงองค์ประกอบของลิสต์แบบรวดเดียว
  • ได้เรียนรู้วิธีแปลงแบบรวดเดียวด้วย list comprehension และวิธีจัดการเมื่อเกิดข้อผิดพลาด จึงสามารถประมวลผลข้อมูลจำนวนมากได้อย่างมีประสิทธิภาพ

การนำไปใช้ในอนาคต

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