บทที่ 2 ตัวแปร ฟังก์ชัน และสตริง#
การเรียนรู้การใช้ ตัวแปร ฟังก์ชัน และสตริงเป็นพื้นฐานสำคัญในการพัฒนาโปรแกรม เนื่องจากช่วยให้นักพัฒนาสามารถจัดการข้อมูลและควบคุมการทำงานของโปรแกรมได้อย่างมีประสิทธิภาพ ตัวแปรทำหน้าที่ในการเก็บค่าต่างๆ ไว้ในหน่วยความจำ ซึ่งสามารถเป็นได้ทั้งค่าคงที่และค่าที่เปลี่ยนแปลงได้ ขึ้นอยู่กับลักษณะของการใช้งาน ฟังก์ชันช่วยให้โปรแกรมสามารถดำเนินการตามขั้นตอนที่กำหนดได้ และสามารถนำกลับมาใช้ซ้ำได้ ซึ่งเป็นการเพิ่มประสิทธิภาพและความยืดหยุ่นในการพัฒนาโปรแกรม ส่วนสตริงเป็นชนิดข้อมูลที่สำคัญในการจัดการข้อความ โดยสามารถทำการเชื่อม การแบ่ง หรือการค้นหาข้อความได้ เมื่อผู้เรียนมีความเข้าใจในหลักการเหล่านี้ ก็จะสามารถพัฒนาโปรแกรมที่ซับซ้อนและมีประสิทธิภาพมากยิ่งขึ้น การเริ่มต้นด้วยพื้นฐานเหล่านี้จึงเป็นการวางรากฐานที่มั่นคงสำหรับการเขียนโปรแกรมที่มีคุณภาพและมีประสิทธิผล
จุดมุ่งหมายของบทนี้
การประกาศและให้ค่ากับตัวแปร เพื่อใช้เก็บข้อมูลที่เป็นตัวเลข บูลีน และสตริง
การเขียนฟังก์ชันที่มีหลายพารามิเตอร์
การใช้
forwhileร่วมกับตัวแปรการใช้เมท็อดของสตริงที่มักใช้บ่อย
ตัวแปร (variable)#
ในระดับชั้นประถมศึกษา เราได้เริ่มเรียนรู้วิธีการตั้งหารยาว หรือการคูณเลขที่มีหลายหลัก ซึ่งเป็นกระบวนการหรืออัลกอริทึมที่ค่อนข้างซับซ้อน ต้องอาศัยการทำซ้ำอย่างต่อเนื่องจนเกิดความชำนาญ หนึ่งในกระบวนการสำคัญของการตั้งหารยาวคือการ “ทดเลข” หรือการบันทึกผลชั่วคราวจากการคำนวณในแต่ละขั้นตอน จากนั้นจึงนำผลที่ทดไว้ทั้งหมดมารวมกันในขั้นตอนสุดท้ายเพื่อให้ได้ผลลัพธ์ที่สมบูรณ์ กระบวนการทดเลขนี้สามารถเปรียบเทียบได้กับการเก็บข้อมูลไว้ในตัวแปร (variable) ในการเขียนโปรแกรม ซึ่งข้อมูลที่เก็บในตัวแปรสามารถนำมาใช้ในการคำนวณหรือดำเนินการขั้นต่อไปได้อย่างมีประสิทธิภาพ ตัวอย่างเช่น ในโปรแกรมคอมพิวเตอร์ ตัวแปรอาจถูกใช้ในการเก็บผลลัพธ์ระหว่างการคำนวณเพื่อใช้งานในกระบวนการที่ตามมา ซึ่งสอดคล้องกับแนวคิดการทดเลขในทางคณิตศาสตร์
การเก็บข้อมูลใส่ตัวแปรเพื่อนำค่ามาใช้ทีหลัง เรียกว่า การกำหนดค่าให้ตัวแปร (variable assignment) ซึ่งจะต้องบอกเครื่องว่าชื่อของตัวแปรคืออะไร และค่าที่ต้องการ คำสั่งภาษาไพทอนมีกฏดังนี้
ชื่อตัวแปร = ค่าที่ต้องการเก็บ
ตัวอย่าง เช่น ถ้าเราต้องการสร้างตัวแปรที่ชื่อว่า num_words เพื่อให้เก็บจำนวนคำที่เรานับมาได้จากบทความชิ้นหนึ่ง ซึ่งสมมติว่ามีค่าเท่ากับ 5000
num_words = 5000
ข้อควรระวังอย่างหนึ่งคือ ชื่อตัวแปรจะต้องมีลักษณะดังนี้ คือ
ต้องขึ้นต้นด้วยตัวอักษรเท่านั้น (ห้ามใช้ตัวเลขหรือเครื่องหมายขึ้นต้น)
ห้ามใช้คำที่สงวน เช่น
forwhiledefฯลฯ ซึ่งเป็นคำที่สงวนใช้สร้างคำสั่งอื่น ๆห้ามมีช่องว่างเลย
ถ้าเกิดว่าไม่เขียนคำสั่งตามกฏ interpreter จะชี้บอกว่าเจอข้อผิดพลาด (error) ที่ไฟล์ไหน และบรรทัดที่เท่าไหร่ ส่วนไหนของโค้ด และบอกด้วยว่าเป็น SyntaxError เช่น
>>> number of words = 5000
File "myprogram.py", line 1
number of words = 5000
^
SyntaxError: invalid syntax
เป็นเพราะใส่ช่องว่างในชื่อตัวแปรซึ่งผิดไวยากรณ์ของภาษาไพทอน ตัวแปลภาษาไพทอนจึงแจ้งเตือนว่าเจอ SyntaxError ที่ไฟล์ myprogram.py บรรทัดที่ 1 ที่ตัวแปรชื่อ number of words มีปัญหา
จากตัวอย่างนี้ การตั้งชื่อตัวแปรที่ชัดเจน เช่น num_words และ num_words_no_puncs ทำให้สามารถเข้าใจการทำงานของโค้ดได้อย่างง่ายดาย หากเราอยากทราบค่าของ num_word_no_puncs เราสามารถบอกให้เครื่องแสดงผลออกมาได้
>>> print(num_words_no_puncs)
4800
โค้ดที่อยู่ทางขวาของเครื่องหมาย = เรียกว่า นิพจน์ (expression) ซึ่งก็คือการนำตัวแปร ค่าคงที่มากระทำต่อกัน อย่างเช่นในตัวอย่างข้างบนที่เรานำตัวแปร num_words กับ num_punctuations มาลบกันโดยใช้ตัวดำเนินการ (operator หรือเรียกอีกอย่างว่า operand) -
เมื่อมีการสร้างตัวแปรใหม่ ตัวแปลภาษาไพทอนจะดำเนินการตามลำดับขั้นตอนที่กำหนดไว้ โดยตัวแปลภาษา จะประมวลผลนิพจน์ที่อยู่ทางด้านขวามือของเครื่องหมายเท่ากับก่อน หลังจากนั้นจะนำค่าที่ได้ไปกำหนดให้กับตัวแปรที่มีชื่ออยู่ทางด้านซ้ายมือของเครื่องหมายเท่ากับ
พิจารณาโค้ดตัวอย่างต่อไปนี้ และลองคาดการณ์ว่าผลลัพธ์ที่จะแสดงผลบนหน้าจอ
num_words = 5000
num_punctuations = 200
num_words_no_puncs = num_words - num_punctuations
num_punctations = 1000
print (num_words_no_puncs)
หน้าจอจะแสดงผลเป็น 4800 เท่ากับตัวอย่างก่อนหน้า เนื่องจากตัวแปลภาษาประมวลผลของนิพจน์ num_words - num_punctuations ไปเสร็จเรียบร้อยแล้ว การแก้ค่าของตัวแปร num_punctuations = 1000 ในบรรทัดต่อมา ไม่มีผลต่อค่าของ num_words_no_puncs ที่ถูกจัดเก็บไว้ก่อนหน้า
ชนิดของตัวแปร (variable type) และข้อมูล (data type)#
ตัวแปรในภาษาไพทอนมีหลายชนิด (type)
intย่อมาจาก integer มีไว้เก็บจำนวนเต็ม ตัวเลขที่ไม่มีจุดทศนิยมfloatมีไว้เก็บจำนวนที่มีจุดทศนิยมstrสตริงมีไว้เก็บข้อความboolมีไว้เก็บบูลีน (boolean) ที่มีค่าTrueหรือFalse
ชนิดของตัวแปรสี่ชนิดข้างต้นเป็นเพียงส่วนหนึ่งของชนิดของตัวแปรทั้งหมดในภาษาไพทอน และยังมีตัวแปรประเภทอื่น ๆ อีกมากซึ่งเราจะได้เห็นในบทต่อ ๆ ไป
ในภาษาไพทอน เมื่อเราทำการสร้างตัวแปรและกำหนดค่าให้กับตัวแปร เราไม่จำเป็นต้องระบุชนิดของตัวแปรล่วงหน้า เนื่องจากไพทอนเป็นภาษาที่มีคุณลักษณะชนิดข้อมูลแบบไดนามิก (dynamic typing) ซึ่งหมายความว่าตัวแปลภาษาไพทอนจะทำการประมวลผลนิพจน์ทางด้านขวามือของเครื่องหมายเท่าก่อน แล้วจึงกำหนดชนิดของตัวแปรโดยอัตโนมัติตามค่าที่ได้จากนิพจน์นั้น
อย่างไรก็ตาม ผู้เขียนโปรแกรมจำเป็นต้องเข้าใจชนิดข้อมูลของค่าที่นิพจน์จะให้ผลลัพธ์ออกมา เพื่อเลือกใช้ตัวดำเนินการ (operator) และการดำเนินการอื่นๆ ได้อย่างถูกต้อง เนื่องจากในบางกรณี ตัวดำเนินการที่ใช้กับชนิดข้อมูลต่างกันจะให้ผลลัพธ์ที่ต่างกัน ตัวอย่างเช่น การบวกจำนวนเต็ม จะแตกต่างจากการบวกสตริงที่เป็นการเชื่อมต่อข้อความ
int และ float#
เราสามารถสร้างนิพจน์ที่ประกอบด้วย int และ float ด้วยตัวดำเนินการเลขคณิต (arithmetic operator)
ในภาษาไพทอนมีดังนี้
Operator |
ความหมาย |
ตัวอย่าง |
|---|---|---|
+ |
บวก |
3 + 2 –> 5 |
- |
ลบ |
3 - 2 –> 1 |
* |
คูณ |
3 * 2 –> 6 |
/ |
หาร |
3 / 2 –> 1.5 |
// |
หารแบบปัดเศษทิ้ง |
3 // 2 –> 1 |
** |
ยกกำลัง |
3 ** 2 –> 9 |
% |
หารแล้วได้เศษ (mod) |
3 % 2 –> 1 |
นอกจากนั้นแล้วยังมีตัวดำเนินการเปรียบเทียบ (comparison operator) ที่ให้ค่าเป็นบูลีน
Operator |
ความหมาย |
ตัวอย่าง |
|---|---|---|
> |
มากกว่า |
3 > 2 –> |
< |
น้อยกว่า |
3 < 2 –> |
== |
เท่ากัน |
3 == 2 –> |
!= |
ไม่เท่ากับ |
3 != 2 –> |
ตัวอย่าง เช่น
num_words = 5000
pi = 3.14
average_words_per_page = num_words / 6
ทั้ง pi และ average_words_per_page เป็นตัวแปรชนิด float เพราะ Python interpreter แปลผลนิพจน์ทางขวามือแล้วได้ค่าที่เป็นทศนิยม
ถ้าหากเราใช้ตัวดำเนินการกับข้อมูลผิดชนิดเช่น
>>> 'ฉันรักภาษาไทย' + 4
Traceback (most recent call last)
<ipython-input-11-1beaa930810f> in <module>
----> 1 'ฉันรักภาษาไทย' + 4
TypeError: can only concatenate str (not "int") to str
Python interpreter จะโยน TypeError ให้ ซึ่งแปลว่า error ที่เกิดจากการใช้ข้อมูลผิดชนิด พร้อมทั้งบอกว่าผิดชนิดอย่างไร ในตัวอย่างนี้ บอกว่าตัวดำเนินการ + ต้องใช้กับสตริงและสตริง ไม่ใช่ สตริงกับ int
>>> 4 + 'ฉันรักภาษาไทย'
Traceback (most recent call last)
<ipython-input-12-1c1a443c69f4> in <module>
----> 1 4 + 'ฉันรักภาษาไทย'
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Python interpreter โยน TypeError และอธิบายว่าตัวดำเนินการ + ไม่สามารถใช้กับ int และสตริงได้
เพราะเหตุนี้เวลาเราเขียนโปรแกรมเราควรจำให้ได้ว่าชนิดข้อมูลที่ตัวแปรและตัวเก็บเป็นข้อมูลชนิดไหน และควรจะทราบด้วยว่าถ้าเครื่องโยน TypeError มาให้ตอนที่เรารันโปรแกรม เราควรจะแก้ไขโดยการตรวจชนิดของข้อมูลให้เหมาะสม
สตริง#
เบื้องต้นเราสามารถสร้างสตริงเพื่อเก็บข้อความได้ดังนี้
welcome_message = 'Welcome to my world!'
welcome_message เป็นตัวแปรชนิดสตริง เนื่องจากนิพจน์เป็นข้อความโดยเห็นได้จากเครื่อง ' ที่คร่อมข้อความอยู่
ภาษาไพทอนสามารถใช้ตัวดำเนินการ + และ * กับสตริงได้
Operator |
ความหมาย |
ตัวอย่าง |
|---|---|---|
+ |
ต่อสตริง (concatenate) |
|
* |
ซ้ำสตริง |
|
เราจะศึกษารายละเอียดของการสร้างสตริงในรูปอื่น ๆ ทั้งหมดในบทต่อไป
บูลีน#
ค่าบูลีนสามารถเป็นได้แค่ True หรือ False ให้สังเกตว่าทั้งสองค่านั้นต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่
นอกจากนั้นแล้วยังสามารถขึ้นมาได้ด้วยการใช้ตัวดำเนินการเปรียบเทียบอีกด้วย
is_long_book = num_words > 10000
จากตัวอย่างข้างบน is_long_book เป็นตัวแปรชนิดบูลีน เพราะว่านิพจน์ตีผลออกมาเป็น False
ตัวดำเนินการของบูลีนกับบูลีน ได้แก่ and or ซึ่งเหมือนกับตัวดำเนินการที่ใช้ในโปรแกรมคาเรลในบทที่ 1
ตัวดำเนินการให้ค่าใหม่#
การให้ค่าใหม่กับตัวแปร (reassign หรือ update) สามารถทำได้โดยการใช้ = ซ้ำอีกครั้งได้เลย เช่น
num_words = 5000
num_words = 100
ใช้ตัวแปรชื่อเดิม num_words แต่ว่าให้ค่าใหม่กับตัวแปรนั้น ค่าของ num_words จะมีค่าเท่ากับ 100
อีกวิธีคือใช้ร่วมกับตัวดำเนินการเลขคณิต เช่น +-*/ และอื่น ๆ ได้ เช่น
num_words = 5000
num_words += 1
ค่าของ num_words จะมีค่าเท่ากับ 5001 เราอาจจะลองแปลความหมายของ += ได้ดังนี้
num_words = 5000
num_words = num_words + 1
ซึ่งเราจะแปลความนิพจน์ทางขวามือของ = ก่อน จะได้เท่ากับ 5000 (ค่าของ num_words ในขณะนั้น) + 1 = 5001 จากนั้นจึงนำค่า 5001 ไปเก็บไว้ในตัวแปรชื่อว่า num_words
อีกตัวอย่างหนึ่งของการใช้ reassignment operator
num_words = 5000
num_words -= 1
ซึ่งเหมือนกับการเขียน
num_words = 5000
num_words = num_words - 1
ค่าที่เก็บอยู่ใน num_words คือ 4999 หลังจากที่รันโค้ดแล้ว
การใช้ reassignment operator เป็นที่นิยมมาก ถึงแม้ว่าจะไม่จำเป็นต้องใช้ก็ตาม อาจจะเห็นโปรแกรมเมอร์คนอื่นใช้ เราจึงต้องอ่านให้ออกว่าแปลว่าอะไร
ฟังก์ชัน (function)#
ในบทที่ 1 เราได้ศึกษาเกี่ยวกับวิธีการเขียนฟังก์ชันที่สามารถนำกลับมาใช้ใหม่ได้ในสถานการณ์ที่คล้ายคลึงกัน การแบ่งโจทย์ออกเป็นส่วนย่อย ๆ ช่วยให้เราจัดการกับปัญหาได้ง่ายขึ้น และยังช่วยให้โค้ดมีความกระชับและอ่านง่ายมากขึ้น ซึ่งเป็นแนวทางสำคัญในการพัฒนาโปรแกรมอย่างมีประสิทธิภาพ
นอกจากนี้ เรายังสามารถเพิ่มความยืดหยุ่นให้กับฟังก์ชันได้โดยการเขียนฟังก์ชันที่รับ พารามิเตอร์ (parameter) หรือ อาร์กิวเมนต์ (argument) ซึ่งหมายถึงค่าที่เราส่งเข้าไปในฟังก์ชันเพื่อใช้ในการคำนวณหรือดำเนินการต่าง ๆ พารามิเตอร์ทำให้ฟังก์ชันสามารถทำงานได้หลากหลายมากขึ้น โดยการเปลี่ยนค่าที่ส่งเข้าไป ทำให้เราสามารถนำฟังก์ชันมาใช้ซ้ำได้ในหลายบริบทตามที่ต้องการ
แม้ว่าทั้งสองคำนี้มีความหมายเฉพาะที่แตกต่างกันในเชิงเทคนิค แต่ในทางปฏิบัติ นักเขียนโปรแกรมมักใช้คำว่า “พารามิเตอร์” และ “อาร์กิวเมนต์” แทนกันอย่างไม่เป็นทางการ ส่งผลให้ทั้งสองคำมักถูกใช้สับสนหรือแทนกันได้ในบางกรณี อย่างไรก็ตาม
ฟังก์ชันเหมือนกับฟังก์ชันทางคณิตศาสตร์ คือ มีอินพุต (input) และเอาท์พุต (output) ดังนี้
อินพุต ซึ่งในภาษาคอมพิวเตอร์เรียกว่าพารามิเตอร์หรืออาร์กิวเมนต์
เอาท์พุต ซึ่งในภาษาคอมพิวเตอร์เรียกว่า ค่าคืนค่า (return value)
ตัวอย่างฟังก์ชันที่เขียนเป็นโค้ดได้จะต้องกำหนดชนิดของข้อมูลด้วยว่าเป็นชนิดไหน เช่น
ฟังก์ชันหาค่าเฉลี่ยของเลขสองตัว
อินพุต คือ เลขสองตัว
เอาท์พุต คือ ตัวเลขค่าเฉลี่ย
ฟังก์ชันคำนวณพื้นที่สามเหลี่ยม
อินพุต คือ ความยาวฐาน (
intหรือfloat) และความสูง (intหรือfloat)เอาท์พุต คือ พื้นที่ (
float) ที่ต้องเป็นfloatเนื่องจากตัวหารจะให้ผลลัพท์เป็นfloatเสมอ
ฟังก์ชันเปรียบเทียบความยาวข้อความว่าอันไหนยาวกว่า
อินพุต คือ ข้อความสองข้อความ (สตริง)
เอาท์พุต คือ ค่าบอกว่าข้อความไหนยาวกว่า (บูลีน)
ฟังก์ชันคำนวณภาษีมูลค่าเพิ่ม
อินพุต คือ ยอดซื้อ อัตราภาษี และตัวเลือกว่าจะปัดเศษหรือไม่
เอาท์พุต คือ ภาษี
เราสามารถสังเกตได้ว่าฟังก์ชันมีความยืดหยุ่นสูง และสามารถนำมาปรับใช้ในสถานการณ์ที่แตกต่างกันได้โดยการเปลี่ยนแปลงค่าของอาร์กิวเมนต์ที่ส่งเข้าไปในฟังก์ชัน ตัวอย่างเช่น หากในอนาคตมีการเปลี่ยนแปลงอัตราภาษี เราไม่จำเป็นต้องเขียนฟังก์ชันใหม่ทั้งหมด เพียงแค่ปรับเปลี่ยนอัตราภาษีที่ส่งเข้าไปเป็นอาร์กิวเมนต์ใหม่เท่านั้น ฟังก์ชันก็จะสามารถคำนวณภาษีตามอัตราใหม่ได้ทันที
การประกาศฟังก์ชันแบบมีอาร์กิวเมนต์#
ฟังก์ชันแบบมีอาร์กิวเมนต์ในภาษาไพทอนมีลักษณะดังนี้
def compute_vat(amount, vat_rate, round_decimal):
vat = amount * vat_rate
if round_decimal:
return int(vat)
else:
return vat
นี่คือฟังก์ชันที่คำนวณภาษีมูลค่าเพิ่มจากยอดการซื้อ โดยปรับได้ด้วยว่าจะให้ปัดทศนิยมด้วยหรือไม่ ฟังก์ชันภาษาไพทอนมีกฎดังนี้
ต้องขึ้นต้นด้วยคำว่า
defตามด้วยชื่อฟังก์ชัน จากนั้นให้ใส่วงเล็บและชื่อพารามิเตอร์ภายในวงเล็บ แต่ละพารามิเตอร์คั่นด้วยเครื่องหมายจุลภาค (,), และจบด้วยเครื่องหมายทวิภาค (:) ในบรรทัดเดียวกันโค้ดภายในฟังก์ชันต้องมีการจัดรูปแบบให้ย่อหน้า (indentation) เพื่อแสดงถึงขอบเขตของฟังก์ชัน
ฟังก์ชันควรมีการใช้คำสั่ง
returnเพื่อส่งคืนค่าผลลัพธ์ออกจากฟังก์ชันไปยังผู้เรียกใช้ และออกจากฟังก์ชัน
โดยทั่วไปแล้ว กฎเกณฑ์การเขียนฟังก์ชันในภาษาไพทอนมีโครงสร้างตามที่กล่าวไว้ข้างต้น
def ชื่อฟังก์ชัน(argument1, argument2):
ตัวเนื้อหาฟังก์ชัน
return ค่าที่ต้องการคืนค่า
สิ่งที่ควรสังเกตคือ พารามิเตอร์ของฟังก์ชันในภาษาไพทอนไม่มีการบังคับชนิดของข้อมูลที่ชัดเจน ซึ่งอาจทำให้เกิดข้อผิดพลาดได้ เช่น หากผู้ใช้ใส่สตริงแทนที่จะเป็นตัวเลข ระบบจะส่งข้อผิดพลาดกลับมาเมื่อนำสตริงไปคูณกับสตริง เนื่องจากการคูณสตริงไม่ใช่การดำเนินการที่มีความหมายในภาษาไพทอน ดังนั้น เพื่อเพิ่มความชัดเจนในการใช้งานฟังก์ชันและลดโอกาสเกิดข้อผิดพลาด เราสามารถใช้การกำกับชนิดข้อมูล (type annotation) เพื่อกำกับว่าพารามิเตอร์ควรเป็นข้อมูลชนิดใด
การกำกับชนิดข้อมูล คือ การระบุชนิดของข้อมูลที่คาดว่าจะถูกส่งเข้าไปในพารามิเตอร์ของฟังก์ชัน ซึ่งช่วยให้ผู้อ่านโค้ดหรือผู้ใช้ฟังก์ชันทราบล่วงหน้าว่าควรส่งข้อมูลชนิดใด และยังช่วยให้เครื่องมือตรวจสอบข้อผิดพลาดสามารถแจ้งเตือนเมื่อพบว่ามีการส่งข้อมูลผิดชนิดเข้าไปในฟังก์ชัน
ตัวอย่างการใช้การกำกับชนิดข้อมูล:
def compute_vat(amount:float, vat_rate:float, round_decimal:bool):
vat = amount * vat_rate
if round_decimal:
return int(vat)
else:
return vat
จากตัวอย่างข้างต้น พารามิเตอร์แต่ละตัวถูกเขียนกำกับว่าเป็นชนิดอะไรโดยการเขียน :type ตามหลังชื่อพารามิเตอร์ การกำกับชนิดข้อมูลในลักษณะนี้มีประโยชน์ต่อผู้เขียนโปรแกรมและทีมพัฒนา เนื่องจากช่วยให้ทราบล่วงหน้าว่าฟังก์ชันนั้นคาดหวังอินพุตเป็นชนิดใด และทำให้เครื่องมือเขียนโปรแกรม (ไอดีอี) สามารถตรวจสอบโค้ดและแจ้งเตือนข้อผิดพลาดที่อาจเกิดขึ้นในระดับหนึ่ง
อย่างไรก็ตาม การกำกับชนิดข้อมูลในภาษาไพทอน ไม่มีผลต่อการทำงานของตัวแปลภาษาในขณะรันโปรแกรม ซึ่งหมายความว่าตัวแปลภาษาจะไม่บังคับให้ชนิดข้อมูลตรงตามที่ระบุไว้ หากมีการส่งข้อมูลที่ไม่ตรงตามชนิดที่กำหนด โปรแกรมอาจทำงานผิดพลาดและแสดงข้อผิดพลาดขึ้นมาในขณะรันโปรแกรม ซึ่งมีผลเท่ากับการไม่กำกับชนิดข้อมูลเลย ถึงแม้ว่าการกำกับชนิดข้อมูลจะช่วยเพิ่มความชัดเจน แต่ก็ทำให้โค้ดดูซับซ้อนและไม่เรียบง่ายเหมือนเดิม นักเขียนโปรแกรมหลายคนอาจเลือกที่จะไม่ใช้การกำกับชนิดข้อมูล หากมองว่าไม่จำเป็นต่อโค้ดที่เขียน
การเรียกฟังก์ชัน (function call)#
ถ้าหากว่าฟังก์ชันที่เราต้องการเรียกเป็นฟังก์ชันแบบที่มีพารามิเตอร์ เราจำเป็นต้องส่งผ่านค่าพารามิเตอร์ให้กับฟังก์ชันให้ครบทุกตัว ตัวอย่างเช่น ถ้าหากเราต้องการเรียกฟังก์ชันนี้
def compute_vat(amount, vat_rate, round_decimal):
vat = amount * vat_rate
if round_decimal:
return int(vat)
else:
return vat
ซึ่งเป็นฟังก์ชันที่ต้องการพารามิเตอร์สามตัว มีวิธีการเรียกดังนี้
compute_vat(1000.0, 0.7, True)
ค่าพารามิเตอร์จะถูกแทนตามลำดับที่ระบุไว้ในหัวฟังก์ชัน (function header) ซึ่งเป็นส่วนที่กำหนดชื่อและลำดับของพารามิเตอร์ในฟังก์ชัน ดังนั้นค่าพารามิเตอร์ที่เราจะส่งเข้าไปมีดังนี้
amount = 1000.0vat_rate = 0.7round_decimal = True
เมื่อเราส่งค่าพารามิเตอร์ทั้งหมด ฟังก์ชันจะเริ่มทำงานทีละบรรทัดตามค่าที่ได้รับ โดยค่าพารามิเตอร์แต่ละตัวจะถูกนำไปใช้ตามลำดับที่กำหนดไว้ ถ้าเราส่งค่าพารามิเตอร์ไม่ครบ ฟังก์ชันจะไม่สามารถทำงานได้และจะส่งสัญญาณข้อผิดพลาด (error) เพื่อแจ้งให้เราทราบถึงปัญหา ตัวอย่างเช่น หากเราลืมกำหนดค่า อัตราภาษีมูลค่าเพิ่ม ฟังก์ชันอาจส่งสัญญาณข้อผิดพลาดเกี่ยวกับพารามิเตอร์ที่ขาดหายไป เช่น
>>> compute_vat(200.0)
Traceback (most recent call last)
<ipython-input-14-05dd24f91a52> in <module>
----> 1 compute_vat(200.0)
TypeError: compute_vat() missing 2 required positional arguments: 'vat_rate' and 'round_decimal'
ข้อความแสดงข้อผิดพลาดแจ้งว่าฟังก์ชัน compute_vat ต้องการอาร์กิวเมนต์เพิ่มอีกสองค่าได้แก่ vat_rate และ round_decimal ไม่เช่นนั้นแล้วฟังก์ชันจะไม่ทราบว่าควรจะแทนค่าพารามิเตอร์เหล่านี้ด้วยค่าอะไร เมื่อถึงบรรทัดที่จำเป็นต้องเรียกใช้ค่าพารามิเตอร์เหล่านี้
ฟังก์ชันที่มีมาให้อยู่แล้ว หรือฟังก์ชันแบบบิวท์อิน#
เมื่อติดตั้งตัวแปลภาษาไพทอน เราจะได้รับฟังก์ชันแบบบิวท์อิน ซึ่งเป็นฟังก์ชันที่มีให้ใช้งานโดยไม่จำเป็นต้องนิยามขึ้นมาใหม่ ฟังก์ชันเหล่านี้มีไว้เพื่ออำนวยความสะดวกในการเขียนโปรแกรม ตัวอย่างของฟังก์ชันแบบบิวท์อินที่ควรรู้จัก ได้แก่
print: แสดงผลของจากการตีความนิพจน์#
ตัวอย่างเช่น
def compute_rectangle_area(width, height):
area = width * height
print (area)
เมื่อเรียกฟังก์ชันแล้วฟังก์ชันจะแสดงผลลัพธ์ออกมาทางหน้าจอดังนี้
>>> compute_rectangle_area(3, 5)
9
ข้อควรระวัง#
ผู้เริ่มต้นเขียนโปรแกรมมักจะสับสนระหว่างการใช้คำสั่ง print กับ return ฟังก์ชันตัวอย่างต่อไปนี้จะอธิบายความแตกต่างของการใช้ return ซึ่งเป็นการส่งค่ากลับจากฟังก์ชันแทนการแสดงผลออกมาทันที
def compute_rectangle_area2(width, height):
area = width * height
return area
ฟังก์ชันนี้ไม่ได้แสดงผลการคำนวณทันทีด้วยคำสั่ง print แต่จะส่งค่าผลลัพธ์ออกจากฟังก์ชันผ่านคำสั่ง return ซึ่งช่วยให้เรานำผลลัพธ์นี้ไปเก็บในตัวแปรอื่นได้ เช่น หากเราต้องการคำนวณพื้นที่ของสี่เหลี่ยมสองอัน เพื่อหาผลรวมของพื้นที่ เราสามารถเขียนโปรแกรมได้ดังนี้
>>> rect1 = compute_rectangle_area2(2,2)
>>> rect2 = compute_rectangle_area2(3,3)
>>> total_area = rect1 + rect2
>>> print(total_area)
13
ในทางตรงกันข้าม ฟังก์ชันที่ใช้คำสั่ง print จะแสดงผลลัพธ์ทันทีโดยไม่มีการส่งค่ากลับ จึงไม่สามารถนำไปเก็บไว้ตัวแปรเพื่อใช้ในบรรทัดต่อไปได้
>>> rect1 = compute_rectangle_area(2,2)
4
>>> rect2 = compute_rectangle_area(3,3)
9
>>> total_area = rect1 + rect2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'
ค่าที่แสดงออกมาบนหน้าจอคือผลการคำนวณจากฟังก์ชัน แต่ตัวแปร rect1 และ rect2 นั้นไม่ได้เก็บค่าพื้นที่ไว้จริง ๆ เนื่องจากฟังก์ชันไม่ได้คืนค่าใด ๆ เมื่อฟังก์ชันไม่มีการคืนค่า ภาษาไพทอนจะกำหนดให้ตัวแปรเหล่านี้เป็นชนิดข้อมูล NoneType ซึ่งเป็นค่าที่แสดงถึง “ไม่มีค่า” (None) และไม่สามารถนำไปดำเนินการทางคณิตศาสตร์ได้ ดังนั้นเมื่อพยายามบวก rect1 และ rect2 จึงเกิดข้อผิดพลาด TypeError
input: รับข้อมูลสตริงจากผู้ใช้#
ฟังก์ชัน input ต้องใส่พารามิเตอร์ 1 ตัว คือ ข้อความที่บอกให้ผู้ใช้ใส่ข้อความ เมื่อฟังก์ชันนี้ถูกเรียกโปรแกรมจะหยุดรอให้ผู้ใช้พิมพ์ข้อความลงไป
ตัวอย่าง
def print_welcome_message():
name = input('กรุณาใส่ชื่อของท่าน :')
print ('ยินดีต้อนรับคุณ' + name)
เมื่อเวลาใช้จริงจะได้ผลดังนี้
>>> print_welcome_message()
กรุณาใส่ชื่อของท่าน :
โปรแกรมจะหยุดเพื่อให้ผู้ใช้พิมพ์ข้อมูลเข้าไปและกด enter เพื่อป้อนข้อมูล
>>> print_welcome_message()
กรุณาใส่ชื่อของท่าน :อรรถพล
ยินดีต้อนรับคุณอรรถพล
str, int, และ float: แปลงชนิดของข้อมูล#
การแปลงชนิดของข้อมูลเป็นสิ่งที่มีความสำคัญ เพราะข้อมูลที่เราป้อนเข้ามาในโปรแกรมนั้นอาจไม่ได้อยู่ในชนิดข้อมูลที่ถูกต้องตามที่ต้องการ เช่น ข้อมูลจากผู้ใช้ที่ป้อนผ่านทางคีย์บอร์ดมักจะเป็นข้อมูลชนิดสตริง (str) แม้ว่าผู้ใช้จะป้อนตัวเลขก็ตาม ดังนั้นเราจำเป็นต้องทำการแปลงชนิดข้อมูลเพื่อให้โปรแกรมทำงานได้อย่างถูกต้อง
ฟังก์ชัน str ใช้แปลงข้อมูลให้เป็นสตริง ตัวอย่างเช่น
>>> code = str(10) + str(90)
>>> print(code)
'1090'
โค้ดด้านบนแปลงตัวเลข 10 และ 90 ให้เป็นสตริง จากนั้นค่อยนำมาต่อกันเป็น 1090
ฟังก์ชัน int ใช้แปลงข้อมูลให้เป็นจำนวนเต็ม ตัวอย่างเช่น
>>> int(10.20) + 1
11
>>> int('100') + 1
101
หากไม่ได้ทำการแปลงชนิดข้อมูลก่อนการดำเนินการ อาจทำให้เกิดข้อผิดพลาดประเภท TypeError ได้เช่น
>>> num = '100'
>>> num + 1
Traceback (most recent call last)
<ipython-input-4-eed9c9d1e565> in <module>
----> 1 '100' + 1
TypeError: can only concatenate str (not "int") to str
ฟังก์ชัน float ใช้แปลงข้อมูลให้เป็นจำนวนทศนิยม ตัวอย่างเช่น
>>> float('12.5') + 1
13.5
ในบางกรณี เราจำเป็นต้องแปลงข้อมูลที่ได้จากผู้ใช้ซึ่งป้อนผ่านคำสั่ง input ให้เป็นชนิดที่สามารถนำไปประมวลผลต่อได้ ตัวอย่างเช่น
def genx_classifier_program():
year = input('ท่านเปิดปีค.ศ.อะไร : ')
print ('ท่านเกิดเมื่อปี ค.ศ. ' + year)
year = int(year)
if 1965 < year < 1980:
print ('ท่านเป็น Gen X')
else:
print ('ท่านไม่ได้เป็น Gen X')
เมื่อเรียกใช้
>>> genx_classifier_program()
ท่านเปิดปีค.ศ.อะไร :
โปรแกรมจะหยุดรอให้พิมพ์ปีลงไป
>>> genx_classifier_program()
ท่านเปิดปีค.ศ.อะไร : 1986
ท่านเกิดเมื่อปี ค.ศ. 1986
ท่านไม่ได้เป็น Gen X
หากเราไม่ได้แปลงข้อมูลจากสตริงเป็นจำนวนเต็มก่อน จะเกิดข้อผิดพลาดเช่น
def genx_classifier_program2():
year = input('ท่านเปิดปีค.ศ.อะไร : ')
print ('ท่านเกิดเมื่อปี ค.ศ. ' + year)
# ไม่ยอมแปลงชนิดก่อน
if 1965 < year < 1980:
print ('ท่านเป็น Gen X')
else:
print ('ท่านไม่ได้เป็น Gen X')
ผลลัพธ์เมื่อเรียกใช้งานจะเกิด TypeError
>>> genx_classifier_program2()
ท่านเปิดปีค.ศ.อะไร : 1986
ท่านเกิดเมื่อปี ค.ศ. 1986
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in genx_classifier_program2
TypeError: '<' not supported between instances of 'int' and 'str'
การแปลงชนิดข้อมูลเป็นส่วนสำคัญที่ช่วยให้โปรแกรมทำงานได้อย่างถูกต้อง และหลีกเลี่ยงข้อผิดพลาดที่อาจเกิดขึ้นจากการใช้ข้อมูลชนิดที่ไม่ถูกต้อง
type: ตรวจสอบชนิดของข้อมูล#
การตรวจสอบชนิดของข้อมูลในตัวแปรเป็นเรื่องที่สำคัญ เนื่องจากข้อมูลแต่ละชนิดมีวิธีการประมวลผลที่แตกต่างกัน คำสั่ง type ใช้สำหรับตรวจสอบชนิดของข้อมูลในตัวแปร ว่าข้อมูลนั้นเป็นข้อมูลประเภทใด เช่น ข้อมูลชนิดสตริง ข้อมูลชนิดจำนวนเต็ม หรือข้อมูลชนิดจำนวนจริง การตรวจสอบชนิดข้อมูลจะช่วยให้เราแน่ใจว่าข้อมูลที่กำลังใช้งานอยู่มีรูปแบบที่ถูกต้องตามที่โปรแกรมต้องการ ซึ่งสามารถลดข้อผิดพลาดที่อาจเกิดขึ้นจากการใช้ข้อมูลผิดชนิดได้
เราสามารถตรวจสอบชนิดข้อมูลในตัวแปรได้โดยใช้คำสั่ง type ดังตัวอย่างต่อไปนี้
ตัวอย่างที่ 1: ตรวจสอบชนิดของข้อมูลจำนวนจริง#
>>> num_words = 5000
>>> average_words_per_page = num_words / 6
>>> print(type(average_words_per_page))
<class 'float'>
จากตัวอย่างนี้ เราทำการตรวจสอบชนิดข้อมูลของตัวแปร average_words_per_page ซึ่งเกิดจากการหารจำนวนคำทั้งหมดด้วยจำนวนหน้า ผลลัพธ์ที่ได้คือชนิดข้อมูล float ซึ่งหมายถึงข้อมูลจำนวนจริง หรือข้อมูลที่มีจุดทศนิยม
ตัวอย่างที่ 2: ตรวจสอบชนิดของข้อมูลสตริง#
>>> welcome_message = 'Welcome to my world!'
>>> print(type(welcome_message))
<class 'str'>
ผลลัพธ์จะแสดงว่าข้อมูลในตัวแปร ข้อความต้อนรับ เป็นชนิดข้อมูล str ซึ่งหมายถึงข้อมูลชนิดสตริง หรือชุดของตัวอักษร
การใช้คำสั่ง type มีประโยชน์ในหลายสถานการณ์ โดยเฉพาะเมื่อต้องการตรวจสอบชนิดข้อมูลที่ไม่แน่ชัด เช่น เมื่อข้อมูลมาจากผู้ใช้หรือจากแหล่งข้อมูลอื่น ๆ นอกจากนี้ ยังช่วยในการหลีกเลี่ยงข้อผิดพลาดที่อาจเกิดขึ้นจากการดำเนินการกับข้อมูลผิดชนิด ตัวอย่างเช่น หากเราพยายามนำข้อมูลชนิดสตริงไปคำนวณร่วมกับข้อมูลชนิดจำนวนเต็มโดยไม่แปลงชนิดข้อมูลก่อน อาจทำให้เกิดข้อผิดพลาดได้
โมดูล (module)#
โมดูล (module) ในภาษาไพทอน หมายถึง กลุ่มของฟังก์ชัน ตัวแปร และคลาสที่ถูกจัดเก็บไว้ในไฟล์เดียวกัน การนำโมดูลมาใช้งานช่วยให้โค้ดของโปรแกรมมีโครงสร้างที่เป็นระเบียบ และสามารถเรียกใช้ฟังก์ชันที่มีอยู่แล้วได้โดยไม่ต้องเขียนโค้ดใหม่ทั้งหมด นอกจากนี้ การใช้โมดูลยังช่วยเพิ่มประสิทธิภาพในการพัฒนาโปรแกรม เนื่องจากเราสามารถนำฟังก์ชันจากโมดูลที่สร้างขึ้นแล้วกลับมาใช้ใหม่ได้ในหลาย ๆ โปรแกรม
การนำเข้าโมดูล#
การนำโมดูลมาใช้ในโปรแกรมทำได้โดยใช้คำสั่ง import ตามด้วยชื่อของโมดูลที่ต้องการใช้ เมื่อทำการนำเข้าแล้ว เราสามารถเรียกใช้ฟังก์ชันหรือตัวแปรจากโมดูลนั้น ๆ ได้ทันทีตลอดการทำงานของโปรแกรม ตัวอย่างการใช้งานโมดูล math
import math # โหลดโมดูลชื่อว่า math
result = math.sqrt(9) # เรียกฟังก์ชัน sqrt ที่อยู่ในโมดูล math
print(result)
ผลลัพธ์: 3.0
ในตัวอย่างนี้ เรานำเข้าโมดูล math ซึ่งมีฟังก์ชัน sqrt สำหรับหาค่ารากที่สองของตัวเลข เมื่อเรียกใช้ฟังก์ชัน sqrt(9) จะได้ผลลัพธ์เป็น 3.0
ข้อผิดพลาดที่อาจเกิดขึ้นจากการไม่ import โมดูล#
หากไม่ได้นำเข้าโมดูลก่อนที่จะเรียกใช้ฟังก์ชันในโมดูล จะเกิดข้อผิดพลาดประเภท NameError ตัวอย่างเช่น
>>> math.sqrt(9)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined
>>> sqrt(9)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'sqrt' is not defined
ข้อผิดพลาดนี้เกิดขึ้นเนื่องจากโปรแกรมไม่ทราบว่า math หรือ sqrt คืออะไร เป็นตัวแปร หรือฟังก์ชัน หรือโมดูลกันแน่ เพราะยังไม่ได้ทำการนำเข้าโมดูลเข้ามาในโปรแกรม
หากมีการสะกดชื่อโมดูลผิดหรือไม่มีโมดูลดังกล่าวอยู่ในระบบ จะเกิดข้อผิดพลาดประเภท ModuleNotFoundError ซึ่งโปรแกรมจะไม่สามารถหาชื่อโมดูลนั้นได้ ตัวอย่างเช่น
>>> import masth
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'masth'
โปรแกรมแจ้งข้อผิดพลาดว่าหาโมดูลชื่อ masth ไม่พบ เนื่องจากสะกดชื่อโมดูลผิด วิธีการแก้ไขคือการตรวจสอบการสะกดชื่อโมดูลให้ถูกต้อง หรือทำการติดตั้งโมดูลหากยังไม่มีอยู่ในระบบ
สรุปการใช้ฟังก์ชันโมดูลมีกฎดังนี้
import ชื่อโมดูล
ชื่อโมดูล.ชื่อฟังก์ชันในโมดูล(พารามิเตอร์ต่างๆ)
ในบทถัด ๆ ไป เราจะได้ศึกษาเกี่ยวกับวิธีการดาวน์โหลดและติดตั้งโมดูลจากแหล่งภายนอก (เช่น ไลบรารีจาก PyPI) เพื่อนำฟังก์ชันที่ซับซ้อนยิ่งขึ้นมาช่วยในการประมวลผลข้อมูล
ตัวอย่าง และรูปแบบการเขียนโปรแกรมที่พบเห็นได้บ่อย#
การใช้งานตัวแปรภายในวงวนฟอร์#
ในการเขียนโปรแกรม เราสามารถใช้วงวนฟอร์เพื่อสั่งให้โปรแกรมทำงานซ้ำ ๆ โดยวงวนฟอร์จะใช้ตัวแปรสำหรับเก็บค่ารอบการทำงานและอัปเดตค่าไปเรื่อย ๆ ในแต่ละรอบของการวนซ้ำ
ตัวอย่างโจทย์: จงเขียนโปรแกรมที่พิมพ์ตัวเลขตั้งแต่ 1 ถึง 10
for i in range(10):
print(i+1)
ในตัวอย่างข้างต้น ฟังก์ชัน range(10) สร้างลำดับตัวเลขตั้งแต่ 0 ถึง 9 ซึ่งเป็นค่าที่ใช้ในวงวนฟอร์เพื่อให้ตัวแปร i ถูกอัปเดตค่าไปในแต่ละรอบ เราทำการบวกค่า 1 กับ i เพื่อให้ผลลัพธ์เริ่มต้นที่ 1 แทนที่จะเป็น 0
อีกวิธีหนึ่งในการแก้โจทย์นี้ คือ
for num in range(1, 10+1):
print(num)
สิ่งที่ควรสังเกต:
ตัวแปรที่ใช้ในวงวนฟอร์สามารถตั้งชื่อให้สื่อความหมายได้ตามต้องการ เช่น ในที่นี้เราใช้ชื่อ
numแทนiฟังก์ชัน
range(beginning, end)รับพารามิเตอร์สองตัว: พารามิเตอร์ตัวแรก คือ ค่าจุดเริ่มต้น (beginning) และพารามิเตอร์ตัวที่สอง คือ ค่าขอบเขต (end) โดยค่าขอบเขตนี้จะเป็นค่าที่วงวนฟอร์จะหยุดการทำงานเมื่อถึงค่า
การอัปเดตค่าตัวแปรภายในวงวนฟอร์#
การอัปเดตค่าตัวแปรภายในวงวนฟอร์เป็นแนวทางการเขียนโปรแกรมที่พบเห็นได้บ่อย โดยเฉพาะในกรณีที่ต้องการคำนวณหรือเก็บผลลัพธ์จากการวนซ้ำหลาย ๆ ครั้ง
ตัวอย่างโจทย์: จงเขียนโปรแกรมเพื่อหาผลรวมของตัวเลขตั้งแต่ 1 + 2 + 3 + 4 + 5 จนถึง n โดยให้ n เป็นพารามิเตอร์ที่ผู้ใช้สามารถกำหนดได้
def sum_up_number_until(n):
"""Sum up number from 0 to n
sum_up_number_until(3) should return 0+1+2+3 = 6
Example:
>>> sum_up_number_until(3)
6
>>> sum_up_number_until(4)
10
"""
total = 0
for i in range(n+1):
total += i
return total
สิ่งที่ควรสังเกต:
การสร้างตัวแปรเริ่มต้น ผลรวม = 0 เป็นแนวทางที่พบบ่อยในการเริ่มต้นการคำนวณ โดยเราสร้างตัวแปรที่เก็บค่าเริ่มต้นเพื่อใช้ในการสะสมผลลัพธ์
การอัปเดตค่าตัวแปร ผลรวม ภายในวงวนฟอร์โดยใช้เครื่องหมาย += เป็นการบวกค่าของ
iเข้าไปในตัวแปร ผลรวม ในแต่ละรอบของการวนซ้ำหลังจากออกจากวงวนฟอร์โปรแกรมจะคืนค่าผลลัพธ์ที่คำนวณเสร็จแล้วด้วยคำสั่ง
return
การอัปเดตตัวแปรภายในวงวนนี้สามารถใช้ในสถานการณ์ต่าง ๆ เช่น การหาผลคูณ การหาค่าเฉลี่ย หรือการคำนวณสถิติต่าง ๆ
สตริง#
สตริง หรือสายอักขระ เป็นประเภทของข้อมูลที่ใช้สำหรับเก็บข้อมูลที่เป็นรูปแบบตัวหนังสือหรืออักขระ (character) อื่น ๆ สตริงที่พบบ่อยและจัดเก็บได้ มีหลากหลายประเภท ดังนี้
ตัวเลข เช่น
'007'ตัวลาติน เช่น
'Begrüßung''la République française'ตัวเขียนของภาษาทุกภาษา เช่น
'流星雨''いらっしゃいませ''สามย่าน'เครื่องหมายวรรคตอนของภาษาอังกฤษ (เช่น
*&?#$!«) หรือภาษาไทย (เช่น'๏๛ฯ')อีโมจิ (emoji) เช่น
'😂😃🧘🏻♂️🌍🌦️🍞🚗📞🎉🍆'อักขระพิเศษ (special character) มีหลายตัวด้วยกัน แต่ว่าตัวที่พบเห็นบ่อยได้แก่
\nคือ new line character ซึ่งเป็นสัญลักษณ์ใช้ในการบ่งบอกให้ขึ้นบรรทัดใหม่\tคือ tab character ซึ่งเป็นสัญลักษณ์บ่งบอกถึงแท็บ (กลุ่มของช่องว่าง) ซึ่งอาจใช้สำหรับการบ่งบอกให้ขึ้นย่อหน้าใหม่
การสร้างสตริง#
วิธีการสร้างสตริงโดยการพิมพ์ข้อความเข้าไปในตัวโค้ดโดยตรง เรียกว่าการสร้างสตริงแบบตัวอักษรแท้ หรือสตริงลิเตอรัล (string literal) ซึ่งต่างจากการสร้างสตริงขึ้นมาโดยการเรียกฟังก์ชันอื่น ๆ สามารถทำได้ 3 วิธีหลัก ๆ ดังนี้
1. การคร่อมข้อความด้วยเครื่องหมายอัญประกาศเดี่ยว (single quote)#
first_sentence = 'I dreamed a dream in times gone by'
การใช้เครื่องหมายอัญประกาศเดี่ยวในการคร่อมข้อความเป็นวิธีที่สะดวกและง่ายต่อการพิมพ์ อย่างไรก็ตาม หากในข้อความมีเครื่องหมายอัญประกาศเดี่ยว ' อยู่ เช่น
>>> climax_sentence = 'So different from this hell I'm living'
File "<stdin>", line 1
climax_sentence = 'So different from this hell I'm living'
^
SyntaxError: invalid syntax
ซึ่งผิดไวยากรณ์เพราะเครื่องนึกว่า ' ใน I'm ใช้ทำหน้าที่บอกจุดสิ้นสุดของสตริง เราจำเป็นต้องใช้การหนี (escape) โดยการใช้เครื่องหมาย \ เพื่อบอกกับเครื่องว่า ' ที่ตามหลังมาให้ถือว่าเป็นสตริง ไม่ใช่เครื่องหมาย quote เช่น
>>> climax_sentence = 'So different from this hell I\'m living'
>>> print(climax_sentence)
So different from this hell I'm living
2. การคร่อมข้อความด้วยเครื่องหมายอัญประกาศคู่ (double quote)#
>>> climax_sentence = "So different from this hell I'm living"
>>> print(climax_sentence)
So different from this hell I'm living
เมื่อใช้เครื่องหมายอัญประกาศคู่ เราไม่จำเป็นต้องหนีเครื่องหมายอัญประกาศเดี่ยวที่อยู่ภายในข้อความ อย่างไรก็ตาม หากในข้อความมีเครื่องหมายอัญประกาศคู่อยู่ เช่น
>>> news_opening = "The spokesman reported "The company is in a great position." after being pressed many times"
File "<stdin>", line 1
news_opening = "The spokesman reported "The company is in a great position." after being pressed many times"
SyntaxError: invalid syntax
จะเกิดข้อผิดพลาดเนื่องจากเครื่องแปลภาษาไม่สามารถแยกความแตกต่างระหว่างจุดเริ่มต้นและสิ้นสุดของสตริงได้ ดังนั้นเราจำเป็นต้องหนีเครื่องหมายอัญประกาศคู่ภายในข้อความ:
news_opening = "The spokesman reported \"The company is in a great position.\" after being pressed many times"
3. การคร่อมข้อความด้วยเครื่องหมายอัญประกาศสามตัว (triple quote)#
การใช้เครื่องหมายอัญประกาศสามตัว (""" หรือ ''') เป็นวิธีการสร้างสตริงที่สามารถรองรับข้อความหลายบรรทัดได้ โดยที่บรรทัดใหม่ในข้อความจะถูกแทนที่ด้วยตัวอักขระพิเศษ \n (newline)
>>> juliet_speech = """O Romeo, Romeo, wherefore art thou Romeo?
... Deny thy father and refuse thy name."""
>>> juliet_speech
'O Romeo, Romeo, wherefore art thou Romeo?\nDeny thy father and refuse thy name.'
>>> print(juliet_speech)
O Romeo, Romeo, wherefore art thou Romeo?
Deny thy father and refuse thy name.
เข้าถึงตัวอักษรที่อยู่ในสตริง#
ในภาษาไพทอน เราสามารถเข้าถึงตัวอักษรที่อยู่ในสตริงได้โดยใช้ดัชนี (index) ผ่านการใช้ตัวดำเนินการ [] ซึ่งเป็นการระบุว่าต้องการดึงตัวอักษรจากตำแหน่งใดในสตริง ดัชนีของสตริงในภาษาไพทอนจะเริ่มต้นที่เลข 0 ซึ่งหมายความว่าตัวอักษรตัวแรกในสตริงจะอยู่ที่ตำแหน่ง 0 และตัวอักษรถัดไปจะอยู่ที่ตำแหน่ง 1, 2, 3 ตามลำดับ เพราะฉะนั้น string[a] คืนตัวอักขระจากช่องที่ index a ตามที่เห็นดังภาพข้างบน
นอกจากนี้ เราสามารถใช้ดัชนีติดลบเพื่อดึงตัวอักษรจากด้านหลังของสตริงได้ โดยตัวอักษรตัวสุดท้ายจะอยู่ที่ตำแหน่ง -1 ตัวอักษรก่อนหน้าจะอยู่ที่ตำแหน่ง -2 และถอยหลังไปเรื่อย ๆ ตามลำดับ เพราะฉะนั้น string[-a] คืนตัวอักขระจากช่องที่ดัชนี -a ซึ่งเราเรียกว่าการใช้เลขดัชนีติดลบ (negative indexing)
ตัวอย่าง สมมติว่าเรามีสตริงดังนี้ s = 'นายสมชาย'
คำสั่ง |
ผลลัพธ์ |
คำอธิบาย |
|---|---|---|
|
|
ดึงตัวอักษรที่ตำแหน่งที่ 1 ของสตริง |
|
|
ดึงตัวอักษรจากตำแหน่งที่ 3 จากท้ายสตริง |
|
|
ดึงตัวอักษรจากตำแหน่งที่ 3 |
|
|
ดึงตัวอักษรจากตำแหน่งที่ 5 จากท้ายสตริง |
ถ้าหากเรารัน s[9] หรือ s[-10] เราจะได้ข้อความบอกข้อผิดพลาด ดังนี้
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
จะเกิดข้อผิดพลาดประเภท IndexError ซึ่งเป็นข้อผิดพลาดที่เกิดขึ้นเมื่อเราพยายามเข้าถึงดัชนีที่ไม่อยู่ในขอบเขตของสตริง จากข้อความข้างต้น โปรแกรมแจ้งว่า ดัชนีที่เราพยายามใช้นั้นเกินขอบเขตของสตริง s = ‘นายสมชาย’ ที่มีดัชนีตั้งแต่ 0 ถึง 7 (เมื่อใช้นับจากซ้าย) และ -1 ถึง -8 (เมื่อใช้นับจากขวา)
การหั่นสตริง#
การหั่นสตริง (string slicing) คือ การดึงสตริงย่อย (substring) ออกมาจากสตริงต้นฉบับ เพื่อตัดเอาส่วนของข้อความที่เราต้องการ โดยการระบุตำแหน่งเริ่มต้นและตำแหน่งสิ้นสุดของสตริงย่อยที่ต้องการดึงออกมา ซึ่งไพทอนสามารถทำได้อย่างง่ายดายด้วยตัวดำเนินการ []
ตัวอย่างการหั่นสตริง
'นายสมชาย'–>'สมชาย'(ตัดคำนำหน้าชื่อออก)'http://www.chula.ac.th'–>'www.chula.ac.th’ (ตัด'http://'ทิ้งเพื่อให้ได้ชื่อเว็บไซต์ที่สั้นลง)'@terutherford'–>'terutherford'(หั่นออกมาแต่ชื่ออินสตาแกรม ตัดเอา@ออกไป)'#ไอจีล่ม'–>'ไอจีล่ม'(ตัดเอาแฮชแท็กออกไป)
การหั่นสตริงสามารถทำได้โดยใช้ตัวดำเนินการ [] ในรูปแบบ [ตำแหน่งที่เริ่ม:ตำแหน่งที่จบ] โดยค่าดัชนีที่ระบุจะชี้ไปที่ร่องระหว่างตัวอักษรในสตริง
สมมติว่าเราต้องการดึงสตริงย่อยจากสตริง s ที่เก็บข้อความอยู่ดังนี้
การดึง substring ให้นึกถึงว่าตัวเลข index ชี้ไปที่ร่องระหว่างตัวอักขระสองตัว เช่น index 3 อยู่ระหว่าง 'ย' และ 'ส' หรือ index -2 อยู่ระหว่าง 'ช' และ 'า'
ตัวอย่าง สมมติว่าเราได้รัน s = 'นายสมชาย'
คำสั่ง |
เอาท์พุต |
คำอธิบาย |
|---|---|---|
|
|
ดึงสตริงจากตำแหน่งที่ 0 ถึงก่อนตำแหน่งที่ 3 |
|
|
ดึงสตริงจากตำแหน่งที่ 5 ถึงก่อนตำแหน่งที่ 7 |
|
|
ดึงสตริงจากตำแหน่งที่ -3 ถึงก่อนตำแหน่งที่ -1 |
|
|
ถ้าจุดเริ่มต้นเป็น 0 สามารถละออกไปได้ |
|
|
ดึงสตริงจากตำแหน่งเริ่มต้นถึงตำแหน่งที่ -2 (ใช้ดัชนีแบบติดลบ) |
|
|
ดึงสตริงจากตำแหน่งที่ 3 ไปจนสุดสตริง |
|
|
ดึงสตริงจากตำแหน่งที่ -5 ไปจนสุดสตริง |
ไพทอนมีความยืดหยุ่นสูงในการใช้ดัชนีสำหรับการหั่นสตริง ซึ่งหมายความว่าหากเราใช้ดัชนีที่เกินขอบเขตของสตริง ไพทอนจะไม่แสดงข้อผิดพลาด แต่จะดึงข้อมูลที่มีอยู่เท่าที่สามารถดึงได้ ทำให้ได้รับเอาท์พุตที่เราไม่ได้คาดคิดมา ทำให้โปรแกรมเกิดข้อผิดพลาดอีก เวลานำผลไปใช้ต่อกับคำสั่งอื่น ๆ
คำสั่ง |
เอาท์พุต |
คำอธิบาย |
|---|---|---|
|
|
ผลลัพธ์ถูกต้อง |
|
|
เหมือนว่าเราควรจะได้ |
|
|
ดัชนี 2 อยู่ก่อนดัชนี 5 จึงไม่ได้สตริงใด ๆ |
|
|
ถึงแม้ดัชนีจะเกินขอบเขต แต่ไพทอนปล่อยผ่านและคืนค่าที่มีอยู่ |
|
|
ถึงแม้ดัชนี -100 จะเกินขอบเขต แต่ไพทอนปล่อยผ่านและคืนค่าที่มีอยู่ |
ตัวดำเนินการสตริง และฟังก์ชันแบบบิวท์อินที่เกี่ยวกับสตริง#
นอกเหนือจากการใช้ตัวดำเนินการ [] เพื่อเข้าถึงตัวอักษรในสตริง และหั่นสตริงแล้ว ภาษาไพทอนยังมีตัวดำเนินการอื่น ๆ ที่สามารถใช้งานกับสตริงได้ ซึ่งตัวดำเนินการเหล่านี้ช่วยให้เราสามารถต่อสตริง ตรวจสอบเนื้อหาในสตริง และเปรียบเทียบสตริงได้อย่างสะดวก โดยมีตัวดำเนินการหลัก ๆ 4 ตัว ดังนี้
ตัวดำเนินการ |
ความหมาย |
ตัวอย่าง |
|---|---|---|
+ |
ต่อสตริง (concatenate) |
|
* |
ทำซ้ำสตริง |
|
|
ตรวจสอบว่าสตริงหนึ่งเป็นส่วนย่อยของอีกสตริงหรือไม่ |
|
|
||
|
นิเสธการตรวจสอบว่ามีสตริงย่อยหรือไม่ |
|
== |
ตรวจสอบว่าสตริงสองชุดเท่ากันหรือไม่ |
|
|
||
|
คืนค่าความยาวของสตริง (จำนวนตัวอักษรในสตริง) |
|
ตัวดำเนินการสตริงและฟังก์ชันที่เกี่ยวข้องช่วยให้เราจัดการและประมวลผลสตริงในภาษาไพทอนได้อย่างสะดวก ไม่ว่าจะเป็นการต่อสตริง การทำซ้ำ การตรวจสอบสตริงย่อย การเปรียบเทียบสตริง หรือการหาความยาวของสตริง การทำความเข้าใจการใช้งานตัวดำเนินการเหล่านี้จะช่วยอำนวยความสะดวกในการเขียนโปรแกรมที่เกี่ยวข้องกับสตริง
การวนซ้ำบนสตริง#
สตริง คือ อักขระหลายตัวมาเรียงต่อกันเป็นลำดับเดียว บางครั้งเราอาจต้องการประมวลผลอักขระในสตริงทีละตัว เช่น การนับจำนวนตัวเลข การนับจำนวนอักขระภาษาอังกฤษ หรือการนับจำนวนสระในสตริง ซึ่งกระบวนการนี้เริ่มจากการตรวจสอบและนับอักขระแต่ละตัวในสตริง วิธีการดำเนินการคือการวนซ้ำในแต่ละอักขระของสตริง ซึ่งในภาษาไพทอน เราสามารถใช้วงวน for เพื่อทำการวนซ้ำ (iteration) บนสตริงได้
ตัวอย่างการวนซ้ำไปบนสตริงโดยใช้ for
s = 'abcdefg'
for alph in s: # alph คือ ตัวแปรที่ใช้แทนอักขระในสตริง ในแต่ละรอบของการวนซ้ำ
print(alph) # แสดงผลอักขระที่เก็บในตัวแปร alph ในแต่ละรอบ
ผลลัพธ์
a
b
c
d
e
f
g
อีกวิธีหนึ่งคือการวนซ้ำบนดัชนีของสตริง โดยใช้อักขระที่ตำแหน่งดัชนีนั้นผ่านตัวดำเนินการ []
s = 'abcdefg'
for i in range(len(s)): # i เป็นตัวแปรเก็บ index จาก 0 ถึง len(s)
print(s[i]) # แสดงผลค่าของอักขระที่ดัชนี i
ฟังก์ชัน range() ใช้ในการสร้างชุดของตัวเลขตั้งแต่ 0 ถึงค่าความยาวของสตริง โดยค่าความยาวของสตริงนั้นได้จากฟังก์ชัน len() ซึ่งจะคืนค่าความยาว (จำนวนอักขระ) ของสตริง การใช้วิธีวนซ้ำนี้เหมาะสำหรับกรณีที่ต้องการเข้าถึงตำแหน่งดัชนีหรือประมวลผลตามตำแหน่งอักขระในสตริง
ตัวอย่างการประยุกต์ใช้การวนซ้ำ#
หากเราต้องการนับจำนวนสระในสตริง เราสามารถเขียนโค้ดดังนี้:
s = 'abcdefg'
vowels = 'aeiou'
count = 0
for alph in s:
if alph in vowels:
count += 1
print(count)
จากตัวอย่างนี้ โค้ดจะทำการวนซ้ำทีละอักขระ และตรวจสอบว่าอักขระนั้นเป็นสระหรือไม่ หากใช่จะเพิ่มค่าตัวนับ (count) ขึ้นเรื่อย ๆ และแสดงผลลัพธ์เมื่อวนซ้ำเสร็จสิ้น
เมท็อดของสตริง#
สตริง เป็นอ็อบเจกต์ประเภทหนึ่งที่ใช้ในการจัดเก็บข้อมูลประเภทข้อความในภาษาไพทอน โดยอ็อบเจกต์ทำหน้าที่จัดเก็บข้อมูลภายใน และยังมีเมท็อด (method) ที่เป็นฟังก์ชันที่เราสามารถเรียกใช้เพื่อจัดการหรือประมวลผลข้อมูลในอ็อบเจกต์นั้นได้ ในการใช้งานเมท็อด จำเป็นต้องทราบว่า:
อ็อบเจกต์ประเภทนั้นมีเมท็อดใดบ้าง
เมท็อดที่ใช้งานต้องการพารามิเตอร์ (อินพุต) อะไรบ้าง
เมท็อดจะคืนค่าผลลัพธ์ (เอาท์พุต) เป็นชนิดข้อมูลอะไร
รูปแบบการเรียกใช้เมท็อดมีลักษณะ object.ชื่อmethod(พารามิเตอร์) ตัวอย่าง เช่น
name = 'james'
name.is_upper()
ในตัวอย่างนี้ ตัวแปร name เก็บสตริง 'james' ซึ่งสร้างขึ้นด้วยการใช้เครื่องหมายอัญประกาศเดี่ยว หลังจากนั้นเราเรียกใช้เมท็อด isupper ซึ่งเป็นเมท็อดที่ไม่ต้องการพารามิเตอร์ เมท็อดนี้จะคืนค่าผลลัพธ์เป็นข้อมูลชนิดบูลีน ที่บ่งบอกว่าสตริงทั้งหมดเป็นอักษรลาตินพิมพ์ใหญ่หรือไม่
เมท็อดของสตริงในภาษาไพทอนมีจำนวนมาก และไม่มีความจำเป็นที่ผู้เขียนโปรแกรมจะต้องจดจำเมท็อดทั้งหมด ควรจดจำเฉพาะเมท็อดที่ใช้งานบ่อย ๆ เท่านั้น หากจำไม่ได้สามารถค้นหาเพิ่มเติมได้จากแหล่งข้อมูลออนไลน์ ซึ่งเป็นวิธีปฏิบัติที่เป็นปกติในวงการเขียนโปรแกรม อย่างไรก็ตาม เพื่อความสะดวกและความคล่องตัวในการเขียนโปรแกรมที่เกี่ยวข้องกับการประมวลผลข้อมูลประเภทข้อความ ควรรู้จักและใช้งานเมท็อดของสตริงที่สำคัญ ๆ ดังนี้
สร้างสตริงจากตัวแปรอื่น ๆ#
name = 'John'
age = 36
template = "My name is {}, I'm {}"
result = template.format(name, age)
print(result) # My name is John, I'm 36
print(f"My name is {name}, I'm {age}") # My name is John, I'm 36
เมท็อด format ใช้เมื่อเราต้องการสร้างเทมเพลต (template) เพื่อเติมค่าต่าง ๆ ภายหลัง โดยจะใช้ {} เป็นสัญลักษณ์แทนช่องว่าง (placeholder) สำหรับใส่ค่าที่ต้องการ ซึ่งสามารถระบุจำนวนได้ตามต้องการ แต่เมื่อเรียกใช้ .format ต้องระบุจำนวนพารามิเตอร์ให้ตรงกับจำนวนช่องว่าง หากจำนวนพารามิเตอร์น้อยเกินไปจะเกิดข้อผิดพลาดชนิด IndexError แต่ถ้าหากใส่พารามิเตอร์มากเกินไป ระบบจะไม่แสดงข้อผิดพลาดแต่อย่างใด
นอกจากนี้ ยังมีอีกวิธีหนึ่งที่สามารถใช้เพื่อสร้างสตริงที่เรียกว่า “เอฟสตริง” (f-string) โดยการใช้เครื่องหมาย f นำหน้าสตริง เพื่อระบุว่าเป็นสตริงสำหรับการจัดรูปแบบ (formatting string) เราสามารถใส่ชื่อตัวแปรภายใน {} ได้โดยตรง ซึ่งระบบจะทำการแปลงค่าของตัวแปรเป็นสตริงโดยอัตโนมัติ ทำให้การเขียนโค้ดมีความกระชับและอ่านง่ายขึ้น
ตัวอย่างการใช้งานเอฟสตริง#
country = 'Thailand'
welcome_message = f'Welcome to {country}'
print (welcome_message)
ผลลัพธ์คือ 'Welcome to Thailand' ซึ่งเกิดจากการนำค่าจากตัวแปร country มาใส่ในสตริง หากเราใส่ชื่อตัวแปรโดยลืมใส่ {} ระบบจะไม่ดึงค่าจากตัวแปรมาแสดงผล
country = 'Thailand'
welcome_message = f'Welcome to country'
print (welcome_message)
เครื่องจะแสดงผลคำว่า Welcome to country เนื่องจากตัวแปร country ไม่ได้ถูกใช้งานจริงเพราะไม่ได้ใส่ไว้ภายใน {}
ตัวอย่างการใช้งานเพิ่มเติม#
นอกจากการใช้เมท็อด format แบบพื้นฐาน เรายังสามารถระบุรายละเอียดเพิ่มเติม เช่น การกำหนดตำแหน่งตัวแปรหรือจัดรูปแบบการแสดงผลได้ เช่น
template = "My name is {0}, I'm {1:.2f} years old"
result = template.format('Alice', 36.756)
print(result) # My name is Alice, I'm 36.76 years old
ในตัวอย่างนี้ เมท็อด format จะจัดรูปแบบตัวเลขให้แสดงเพียงสองตำแหน่งทศนิยม
สำหรับ f-string เรายังสามารถทำการคำนวณหรือใช้ฟังก์ชันอื่นภายใน {} ได้เช่นกัน:
price = 49.99
discount = 0.15
final_price = f'Final price after discount: {price * (1 - discount):.2f}'
print(final_price) # Final price after discount: 42.49
จากตัวอย่างนี้ ระบบจะคำนวณราคาสุดท้ายหลังหักส่วนลด และแสดงผลในรูปแบบทศนิยมสองตำแหน่ง
เปลี่ยนเป็นตัวเล็กหรือตัวใหญ่: .lower() และ .upper()#
เมท็อด string.lower() จะส่งคืนสตริงที่ประกอบด้วยอักขระตัวพิมพ์เล็กทั้งหมด โดยที่เนื้อหาของสตริงยังคงเหมือนเดิมแต่เปลี่ยนเฉพาะอักขระตัวพิมพ์ใหญ่ให้เป็นตัวพิมพ์เล็ก
เมท็อด string.upper() จะส่งคืนสตริงที่ประกอบด้วยอักขระตัวพิมพ์ใหญ่ทั้งหมด โดยเปลี่ยนเฉพาะอักขระตัวพิมพ์เล็กให้เป็นตัวพิมพ์ใหญ่ แต่ยังคงเนื้อหาของสตริงเดิมเอาไว้
ข้อควรระวัง เมท็อดทั้งสองจะสร้างสตริงชุดใหม่ขึ้นมา โดยสตริงเดิมจะไม่ถูกเปลี่ยนแปลง การเรียกใช้เมท็อดเหล่านี้จะส่งคืนสตริงใหม่ที่มีลักษณะตามที่ระบุไว้ข้างต้น ขณะที่สตริงต้นฉบับยังคงมีค่าเหมือนเดิม
เมท็อดเหล่านี้มีประโยชน์อย่างมากในกรณีที่ต้องการเปรียบเทียบข้อความสองข้อความโดยไม่สนใจความแตกต่างของอักขระตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก (case-insensitive) ตัวอย่างเช่น
s = 'James'
s.lower() #--> 'james'
s.upper() #--> 'JAMES'
เช็คว่าเป็นตัวเล็กหรือตัวใหญ่: .islower() และ .isupper()#
เมท็อด string.islower() จะตรวจสอบว่าอักขระทั้งหมดในสตริงนั้นเป็นตัวพิมพ์เล็กหรือไม่ หากทุกอักขระในสตริงเป็นตัวพิมพ์เล็ก จะส่งคืนค่า True แต่หากมีอักขระใดที่ไม่ใช่ตัวพิมพ์เล็ก จะส่งคืนค่า False
ในลักษณะเดียวกัน เมท็อด string.isupper() จะตรวจสอบว่าอักขระทั้งหมดในสตริงนั้นเป็นตัวพิมพ์ใหญ่หรือไม่ หากทุกอักขระเป็นตัวพิมพ์ใหญ่ จะส่งคืนค่า True แต่หากมีอักขระใดที่ไม่ใช่ตัวพิมพ์ใหญ่ จะส่งคืนค่า False
เมท็อดทั้งสองนี้มีประโยชน์ในกรณีที่ต้องการตรวจสอบความถูกต้องของการใช้อักขระพิมพ์เล็กและพิมพ์ใหญ่ เช่น การตรวจสอบชื่อย่อขององค์กร (ซึ่งมักเขียนด้วยตัวพิมพ์ใหญ่) หรือการตรวจสอบว่าอักขระตัวแรกในคำภาษาอังกฤษเป็นตัวพิมพ์ใหญ่หรือไม่ ซึ่งมักใช้ในการเขียนประโยคภาษาอังกฤษ แต่ควรระวังว่าเมท็อดเหล่านี้ไม่มีประโยชน์ในการใช้งานกับภาษาที่ไม่ได้ใช้ตัวอักษรลาติน เช่น ภาษาจีน ภาษาไทย ภาษาเกาหลี และภาษารัสเซีย เนื่องจากภาษาเหล่านี้ไม่มีการแบ่งแยกอักขระพิมพ์ใหญ่และพิมพ์เล็ก ดังนั้นเมท็อดสองเมท็อดนี้จะคืนค่า False ทุกครั้ง เช่น
s = 'NASA'
s.islower() #--> False
s.isupper() #--> True
s2 = 'Casa'
s2.islower() #--> False เพราะไม่ใช่ตัวเล็กหมด
s2.isupper() #--> False เพราะไม่ใช่ตัวใหญ่หมด
s2[0].isupper() #--> True ตัวอักษรตัวแรกเป็นตัวใหญ่
s3 = 'สวัสดี'
print(s3.islower()) # ผลลัพธ์: False เพราะไม่ใช่ตัวลาติน
print(s3.isupper()) # ผลลัพธ์: False เพราะไม่ใช่ตัวลาติน
นับสตริงย่อยในสตริง: .count(substring)#
string.count(substring) ใช้ในการส่งคืนจำนวนครั้งที่พบส่วนย่อย (substring) ในสตริง หากอินพุตที่ใส่เป็นอักขระตัวเดียว เมท็อดนี้จะนับจำนวนครั้งที่พบอักขระนั้นในสตริง ตัวอย่างเช่น
laughter = 'hahahahaha'
laughter.count('ha') #--> 5
plea = 'รูหนูสู่รูปู งูสุดสู้ หนูสู้งู'
plea.count('ู') #--> 10
การใช้เมท็อดนี้ยังมีประโยชน์เมื่อต้องการนับจำนวนการปรากฏของคำหรืออักขระในสตริงที่มีข้อมูลจำนวนมาก เช่น การนับจำนวนคำในหนังสือทั้งเล่ม หรือการนับจำนวนการปรากฏของคำในเอกสาร นอกจากนี้ ยังสามารถใช้เมท็อดนี้ในการนับจำนวนคำคร่าว ๆ ในข้อความภาษาอังกฤษ โดยการนับจำนวนช่องว่าง (' ') ซึ่งเป็นตัวแบ่งคำในภาษาอังกฤษได้อีกด้วย
ตรวจสอบประเภทของอักขระในสตริง: isdigit() isalpha() isalnum()#
เมท็อดเหล่านี้ใช้ในการตรวจสอบว่าสตริงประกอบด้วยอักขระประเภทใด โดยสามารถแยกเป็นประเภทได้ดังนี้:
.isdigit(): ส่งคืนค่า True หากสตริงประกอบด้วยตัวเลขอารบิกทั้งหมด หากมีอักขระใดที่ไม่ใช่ตัวเลขอารบิกจะส่งคืนค่า False.isalpha(): ส่งคืนค่า True หากสตริงประกอบด้วยตัวอักษรเท่านั้น (อักขระที่ไม่ใช่ตัวเลขหรือเครื่องหมายวรรคตอน) ซึ่งครอบคลุมทุกภาษา คำว่า “alpha” มาจากคำว่า “alphabet” ที่หมายถึงตัวอักษร.isalnum(): ส่งคืนค่า True หากสตริงประกอบด้วยตัวอักษรและตัวเลขเท่านั้น ไม่มีเครื่องหมายวรรคตอนหรือสัญลักษณ์อื่น ๆ คำว่า “alnum” มาจาก “alphanumeric” ซึ่งหมายถึงตัวอักษรและตัวเลข
ตัวอย่างการใช้งาน
student_id = '6578012478'
license_plate = '3ก4951'
student_name = 'ยาใจ'
print(student_id.isdigit()) # ผลลัพธ์: True (ทั้งหมดเป็นตัวเลข)
print(student_id.isalpha()) # ผลลัพธ์: False (เพราะมีตัวเลข)
print(student_id.isalnum()) # ผลลัพธ์: True (ประกอบด้วยตัวเลขทั้งหมด)
print(license_plate.isdigit()) # ผลลัพธ์: False (เพราะมีตัวอักษร)
print(license_plate.isalpha()) # ผลลัพธ์: False (เพราะมีตัวเลขด้วย)
print(license_plate.isalnum()) # ผลลัพธ์: True (มีแต่ตัวอักษรและตัวเลข)
print(student_name.isdigit()) # ผลลัพธ์: False (ไม่มีตัวเลข)
print(student_name.isalpha()) # ผลลัพธ์: True (ประกอบด้วยตัวอักษรทั้งหมด)
print(student_name.isalnum()) # ผลลัพธ์: True (ไม่มีตัวเลข แต่มีตัวอักษรเท่านั้น)
เมท็อดเหล่านี้มีประโยชน์ในการตรวจสอบข้อมูลต่าง ๆ เช่น รหัสนักศึกษา เลขทะเบียนรถ รหัสบัตรประชาชน หรือชื่อผู้ใช้งาน เพื่อให้มั่นใจว่าข้อมูลที่ได้รับนั้นตรงตามเงื่อนไขที่กำหนด
แทนสตริงย่อยด้วยสตริงอื่น: .replace(old, new)#
เมท็อด .replace() ใช้ในการแทนที่สตริงย่อยด้วยสตริงใหม่ โดยระบุสตริงย่อยที่ต้องการค้นหา และสตริงที่ต้องการใช้แทนที่ การทำงานของเมท็อดนี้มีลักษณะคล้ายกับฟังก์ชัน “ค้นหาและแทนที่” (Find and Replace) ที่ใช้ในโปรแกรมประมวลผลคำ
การเรียกใช้เมท็อด .replace() จะไม่เปลี่ยนแปลงสตริงต้นฉบับ แต่จะสร้างสตริงใหม่ขึ้นมาแทนที่ สตริงใหม่นี้จะต้องเก็บไว้ในตัวแปรใหม่หากต้องการใช้งานต่อ เช่นเดียวกับเมท็อด .lower(), .upper(), หรือ .format() ที่จะสร้างสตริงใหม่โดยไม่เปลี่ยนแปลงสตริงต้นฉบับ
text = 'ประเภทของคำมี 7 ประเภทใหญ่'
text.replace('ประเภท','ชนิด') #--> 'ชนิดของคำมี 7 ชนิดใหญ่'
print(text) # ประเภทของคำมี 7 ประเภทใหญ่
country = 'U.S.A.'
country.replace('.','') #--> 'USA'
ลบช่องว่างหน้าหลังของสตริง: .strip()#
เมท็อด .strip() ใช้สำหรับลบช่องว่างที่อยู่ด้านหน้าและด้านหลังของสตริง ซึ่งมักใช้ในการทำความสะอาดข้อมูล เช่น ข้อมูลที่โหลดมาจากไฟล์หรือฐานข้อมูล ซึ่งอาจมีช่องว่างเกินเข้ามาทำให้การประมวลผลข้อมูลผิดพลาด
เมท็อด .strip() จะสร้างสตริงใหม่ที่ไม่มีช่องว่างหน้าหลัง โดยไม่เปลี่ยนแปลงสตริงต้นฉบับ ดังนั้นจึงต้องเก็บสตริงใหม่นี้ไว้ในตัวแปรใหม่หากต้องการนำไปใช้งานต่อ
password = ' loveme123'
password.strip() #--> 'loveme123'
password2 = ' iamawesome555 '
password2.strip() #--> 'iamawesome555'
สรุป#
ตัวแปรและฟังก์ชันเป็นพื้นฐานสำคัญของการเขียนโปรแกรมที่ช่วยในการจัดการและใช้ข้อมูล ตัวแปรเป็นที่เก็บข้อมูลที่สามารถเปลี่ยนแปลงได้ตามความต้องการของโปรแกรม ช่วยให้โปรแกรมทำงานได้อย่างยืดหยุ่น ส่วนฟังก์ชันเป็นชุดของคำสั่งที่ทำงานตามที่กำหนด ช่วยลดความซับซ้อนของโค้ด และสามารถนำกลับมาใช้ซ้ำได้
สตริงเป็นประเภทข้อมูลที่ใช้ในการจัดเก็บข้อความ และสามารถนำไปประมวลผลได้หลากหลายวิธี โดยในบทนี้เราได้เรียนรู้เกี่ยวกับการใช้งานสตริงในภาษาไพทอน รวมถึงเมท็อดที่ใช้ในการจัดการข้อมูลสตริง เช่น การเปลี่ยนเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก การตรวจสอบประเภทของอักขระในสตริง การนับสตริงย่อยในสตริง การแทนสตริงย่อยด้วยสตริงอื่น การลบช่องว่างหน้าหลังของสตริง และการวนซ้ำสตริงด้วยวงวน for