{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(ch2)=\n",
"# การจัดการกับสตริง (String Operations)\n",
"\n",
"ในภาษา Python มีข้อมูลหลากหลายประเภทไม่ว่าจะเป็น ตัวเลข (Numberic: int, float, complex) ข้อมูลแบบจับคู่ (Mapping: dict) ไบนารี่ (Binary: byte, bytearray, memoryview)\n",
"บูลีน (Boolean: bool) เซ็ท (Set: set, frozenset) ข้อมูลที่มีลำดับ (Sequence: str, list, tuple, range) ซึ่งในการจัดการกับข้อมูลข้อมูลเหล่านี้ก็จะมีวิธีที่แตกต่างกันออก \n",
"\n",
"ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับข้อมูลชนิด**สตริง (Sring; สายอักขระ)** ในภาษาไพธอน เรียนรู้วิธีการประกาศและใช้งานสตริงในรูปแบบต่างๆ \n",
"รวมถึงแนะนำการใช้งานเมธอดที่สำคัญในการจัดการกับข้อมูลชนิดสตริง\n",
"\n",
"Ref:\n",
"* https://docs.python.org/3/tutorial/introduction.html#strings\n",
"* https://www.edx.org/course/python-basics-for-data-science\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## สตริง (Strings) คือ?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ __สตริง (String)[^string]__ คือ ชนิดของข้อมูลที่เป็น ข้อความหรือตัวอักษร/อักขระ(Character) หลายๆ ตัวเรียงลำดับต่อๆ กัน __อยู่ภายในเครื่องหมายคำพูดเดี่ยว (Single quote) หรือภายในเครื่องหมายคำพูดคู่ (Double quote)__ \n",
"\n",
"\n",
"[^string]: String ในภาษาไทยจะแปลว่า **สายอักขระ** หรือ **สายอักษร**\n",
"\n",
"ตัวอย่างต่อไปนี้เป็นสตริงที่คร่อมหัวและท้ายด้วยเครื่องหมายคำพูดคู่ \"Double quotation mark (Double quote)\" ```(\" \")```"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson'"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ใช้เครื่องหมายคำพูด Double quote กำหนดสตริง\n",
"\n",
"\"Michael Jackson\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราสามารถใช้เครื่องหมายคำพูดเดี่ยว 'Single quotation mark (Single quote)' ```(' ')``` คร่อมสตริงก็ได้ "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson'"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ใช้เครื่องหมายคำพูด Single quotes กำหนดสตริง\n",
"\n",
"'Michael Jackson'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"สตริงในภาษา Python ไม่เพียงแต่รองรับตัวอักษรภาษาอังกฤษเท่านั้น แต่ยังรองรับหลายภาษารวมถึงภาษาไทยด้วย"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'ไมเคิล แจ็คสัน'"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'ไมเคิล แจ็คสัน'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{attention} เครื่องหมายที่คล้ายๆ กัน !!!\n",
"\n",
"* เครื่องหมาย Single quotation mark (Single quote) ```( ' )``` \n",
"และเครื่องหมาย Backquote (Backtick) ```( ` )``` เป็นตัวอักษรคนละตัวกัน ตำแหน่งบนคีย์บอร์ดก็ต่างกัน (ปุ่ม Backtick อยู่ทางซ้ายมือด้านบน ส่วนปุ่ม Single quote อยู่ทางขวามือขอบขวาของคีย์บอร์ด)\n",
"\n",
"* เครื่องหมาย Backquote (Backtick) ```( ` )``` ถูกใช้ในยูนิกซ์ (Unix) และในภาษาโปรแกรมบางภาษา เช่น Perl, PHP และ Ruby เพื่อระบุการแทนที่คำสั่งด้วยผลลัพธ์ (command substitution) แต่ใน Python-3 ได้ยกเลิกการใช้เครื่องหมายนี้ไปแล้ว ทั้งนี้เพื่อไม่ให้สับสนกับเครื่องหมาย Single quote\n",
"\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ภายในสตริงสามารถมีตัวเลขและมีช่องวาง (space) ได้\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'1 2 3 4 5 6 '"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ตัวเลขและช่องว่างในตริง\n",
"\n",
"'1 2 3 4 5 6 '"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"อักขระพิเศษต่างๆ ก็อยู่ในสตริงได้"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'@#2_#]&*^%$฿`'"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# อักขระพิเศษในตริง\n",
"\n",
"'@#2_#]&*^%$฿`'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ลองใช้คำสั่ง `print()` แสดงสตริงออกหน้าจอ"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"hello!\n"
]
}
],
"source": [
"# แสดงสตริงออกหน้าจอ\n",
"\n",
"print(\"hello!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราสามารถผูกหรือกำหนดสตริงให้กับตัวแปร และแสดงผลตัวแปรโดยใช้ฟังก์ชัน `print()` ได้"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# กำหนดค่าตัวแปรให้เป็นสตริง\n",
"\n",
"name = \"Michael Jackson\""
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Michael Jackson\n"
]
}
],
"source": [
"# แสดงตัวแปร name ออกหน้าจอ\n",
"\n",
"print(name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราสามารถตรวจสอบว่าตัวแปร `name` เป็นข้อมูลชนิดสตริงได้โดยใช้ฟังก์ชัน `type()` \n",
"\n",
"(ฟังก์ชัน `type()` จะรับออบเจกต์ใดๆ เป็นอาร์กิวเมนต์และส่งคืนค่ากลับเป็น**ชนิดของข้อมูล**นั้นๆ)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ตรวจสอบชนิดข้อมูล\n",
"type(name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**`str`** หมายถึงข้อมูลชนิดสตริง (**str**ing)\n",
"\n",
"`str` ยังเป็นชื่อของฟังก์ชันฝังตัวในไพธอน เราสามารถใช้ฟังก์ชัน **`str`** แปลงข้อมูลใดๆ ให้เป็นสตริงได้ (โดยทั่วไป ชื่อของชนิดข้อมูลมักใช้เป็นชื่อของฟังก์ชันในการแปลงเป็นข้อมูลชนิดนั้นๆ เช่น `int` แปลงข้อมูลเป็นจำนวนเต็ม, `float` แปลงข้อมูลเป็นจำนวนทศนิยม และ `bool` แปลงข้อมูลเป็นค่าจริง (True) หรือเท็จ (False))\n",
"\n",
"\n",
"การแปลงข้อมูลชนิดของออบเจกต์เป็นชนิดของข้อมูลที่ต้องการหรือการแปลงชนิดของออบเจกต์ (Typecasting) สามารถย้อนกลับดูในบทก่อนหน้าในหัวข้อ [การแปลงชนิดของออบเจกต์ (Typecasting)](ch1-typecasting)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ตัวอักษรที่อยู่ในข้อความที่ถูกคล่อมด้วยเครื่องหมาย Double quotation marks (Double quotes) `(\"...\")` หรือ Single quotation marks (Single quotes) `('...')` ไพธอนจะถือว่าทุกตัวเป็นตัวอักษรทั้งสิ้น ไม่ว่าภายในข้อความนั้นๆ จะมีช่องว่าง (space), ตัวเลข, \n",
"สัญลักษณ์ที่ใช้เป็นตัวดำเนินการ อักขระพิเศษ (Escape sequences) หรือแม้กระทั่งเครื่องหมายคอมเมนต์ `#` ก็ตาม \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ตัวอย่างของสตริงที่ประกอบด้วยตัวอักษร ช่องว่าง ตัวเลข สัญลักษณ์และเครื่องหมายต่างๆ "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"จำนวนตัวอักษรในตัวแปร string: 216\n"
]
}
],
"source": [
"text1 = \"🐍 จะถือว่า ตัวอักขระใดๆ ก็ตามที่อยู่ในเครื่องหมายคำพูด ไม่ว่าจะเป็นตัวเลข 𝜋 (355/113) ตัวดำเนินการ +, -, *, /, & สัญลักษณ์ต่างๆ ?, |, $ ช่องว่าง (space) หรือแม้กระทั่งเครื่องหมายคอมเม้นต์ # ทุกตัวเป็นตัวอักษรทั้งสิ้น\"\n",
"\n",
"print('\\nจำนวนตัวอักษรในตัวแปร string: ', len(text1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ตัวแปรสตริงนี้มีจำนวนตัวอักขระ 216 ตัว (ตรวจสอบขนาดของข้อมูลได้ด้วยฟังก์ชัน `len()`) \n",
"\n",
"ในกรณีแบบนี้ เราสามารถใช้ **DocString (Triple quote string)** เขียนสตริงที่ครอบคลุมหลายบรรทัด โดยใช้เครื่องหมายคำพูด **Triple single quote $'''...'''$** หรือ **Triple double quotes $\"\"\"...\"\"\"$** แทน"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"🐍 จะถือว่า ตัวอักขระใดๆ ก็ตามที่อยู่ในเครื่องหมายคำพูด \n",
"ไม่ว่าจะเป็นตัวเลข 𝜋 (355/113) ตัวดำเนินการ +, -, *, /, & สัญลักษณ์ต่างๆ ?, |, $ \n",
"ช่องว่าง (space) หรือแม้กระทั่งเครื่องหมายคอมเม้นต์ # ทุกตัวเป็นตัวอักษรทั้งสิ้น\n",
"\n",
"\n",
"จำนวนตัวอักษรในตัวแปร string1: 220\n"
]
}
],
"source": [
"text2 = '''\n",
"🐍 จะถือว่า ตัวอักขระใดๆ ก็ตามที่อยู่ในเครื่องหมายคำพูด \n",
"ไม่ว่าจะเป็นตัวเลข 𝜋 (355/113) ตัวดำเนินการ +, -, *, /, & สัญลักษณ์ต่างๆ ?, |, $ \n",
"ช่องว่าง (space) หรือแม้กระทั่งเครื่องหมายคอมเม้นต์ # ทุกตัวเป็นตัวอักษรทั้งสิ้น\n",
"'''\n",
"print(text2)\n",
"print('\\nจำนวนตัวอักษรในตัวแปร string1: ', len(text2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ตัวแปร `text2` มีจำนวนอักขระมากถึง 220 ตัว (ตัวแปร `text1` มีเพียง 116 ตัว) เนื่องจากนับรวมกับอักขระพิเศษ `\\n` (ขึ้นบรรทัดใหม่) ด้วย "
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'\\n🐍 จะถือว่า ตัวอักขระใดๆ ก็ตามที่อยู่ในเครื่องหมายคำพูด \\nไม่ว่าจะเป็นตัวเลข 𝜋 (355/113) ตัวดำเนินการ +, -, *, /, & สัญลักษณ์ต่างๆ ?, |, $ \\nช่องว่าง (space) หรือแม้กระทั่งเครื่องหมายคอมเม้นต์ # ทุกตัวเป็นตัวอักษรทั้งสิ้น\\n'"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"text2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{note}\n",
"* เครื่องหมาย **Triple single quote $'''...'''$** หรือ **Triple double quotes $\"\"\"...\"\"\"$** นอกจากจะใช้เป็น DocString ซึ่งเป็นข้อมูลชนิดสตริงแล้ว ยังใช้เป็นคอมเม้นต์อธิบายหน้าที่ของฟังก์ชั่นหรือคลาสในโปรแกรมอีกด้วย (ดูรายละเอียดใน[การเขียนคอมเมนต์ในภาษาไพธอน (Comments & Docstrings)](ch1-commentsDocstrings))\n",
"\n",
"* PEP8 แนะนำให้ใช้ **Triple double quotes $\"\"\"...\"\"\"$ เขียน DocString** \n",
"\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## สตริง - เลขดัชนี (Index)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ สตริงเป็นข้อมูลที่ประกอบด้วยตัวอักษรเรียงลำดับต่อๆ กัน เป็นข้อมูลที่มีลำดับ (Sequence type) และใช้ ```ดัชนี (index)``` ในการเข้าถึงข้อมูล\n",
"\n",
"ยกตัวอย่าง \"Michael Jackson\" เป็นสตริงที่มีตัวอักษรทั้งหมด 11 ตัวอักษร\n",
" \n",
"ในกรณีที่เราต้องการตัวอักษรตัวแรกสุด เราจะเขียนคำสั่ง "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'M'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Michael Jackson\"[0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราเรียกตัวเลขในวงเล็บก้ามปู (square brackets; [ ]) ว่า ```\"ดัชนี หรือ อินเด็กซ์ (Index)\" ``` โดยเลขดัชนีเป็น**เลขจำนวนเต็ม**เสมอ"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"**เลขดัชนี (Index) จะเริ่มจาก \"0\"** โดยเรียงลำดับจากซ้ายมือสุดไปทางขวามือตามลำดับ ดังรูป\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ในกรณีของตัวแปรที่เป็นชนิดสตริงก็เขียนแบบเดียวกัน เราใช้เลขดัชนีในวงเล็บก้ามปู (square brackets) \"[ ]\" ระบุตำแหน่งของตัวอักษรที่ต้องการเข้าถึง (โดยส่วนใหญ่ ดัชนีจะมักใช้กับตัวแปร)\n",
"\n",
"ถ้าต้องการเข้าถึงตัวอักษรตัวที่ `x` ให้กำหนดเลขดัชนีเป็น `x-1` เช่น เข้าถึงตัวอักษรตัวแรก, ตัวที่ 6 และตัวที่ 10 เลขดัชนีจะเป็น `0` `5` และ `9` ตามลำดับ"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"M\n"
]
}
],
"source": [
"name = \"Michael Jackson\" # กำหนดค่าตัวแปรสตริง \n",
"print(name[0]) # แสดงอักษรตัวแรกสุดออกหน้าจอ"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"e\n"
]
}
],
"source": [
"# แสดงตัวอักษรตัวที่ 6 ออกหน้าจอ\n",
"\n",
"print(name[5])"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n"
]
}
],
"source": [
"# แสดงตัวอักษรตัวที่ 10 ออกหน้าจอ\n",
"\n",
"print(name[9])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ผลลัพธ์ที่ได้ยังคงเป็นข้อมูลชนิดสตริง **และมีขนาดหนึ่งตัวอักษร**\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"M เป็นข้อมูลชนิด และมีขนาดข้อมูล 1\n"
]
}
],
"source": [
"print(f'{name[0]} เป็นข้อมูลชนิด {type(name[0])} และมีขนาดข้อมูล {len(name[0])}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{attention}\n",
"ภาษาโปรแกรมคอมฯ บางภาษา เช่น C# มีทั้ง\n",
"Char (ใช้เก็บข้อมูลตัวอักษรเพียงหนึ่งตัวโดยใช้เครื่องหมาย `'` คร่อม) และ String (ใช้เก็บตัวอักษรหลายตัวหรือ text โดยใช้เครื่องหมาย `\"` คร่อม) แต่ในภาษาไพธอนจะไม่แยกแยะ มีเฉพาะ String เท่านั้น\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราสามารถเชื่อมสตริงหนึ่งตัวอักษรข้างต้นเข้าด้วยกันให้เป็นตัวแปรใหม่ 'new_name' โดยใช้โอเปอร์เรเตอร์ '+' (รายละเอียดอยู่ในหัวข้อ ([การเชื่อมต่อสตริง](ch2-stringConcatenate)) "
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mea\n"
]
}
],
"source": [
"new_name = name[0]+ name[5] + name[9]\n",
"print(new_name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(ch2-immutableError)=\n",
"\n",
"**สตริงในไพธอนไม่เหมือนกับภาษา C ไม่สามารถเปลี่ยนค่าสตริงโดยอ้างจากเลขดัชนีได้!**\n",
"\n",
"$\\qquad$ ชนิดของข้อมูลในไพธอนสามารถแบ่งเป็น 2 แบบใหญ่ๆ คือ ข้อมูลที่แก้ไขได้ (Mutable) และข้อมูลที่ไม่แก้ไขได้ (Immutable) สตริงเป็นข้อมูลที่แก้ไขไม่ได้ (Immutable) นั่นหมายความว่า เราสามารถเข้าถึงค่าของข้อมูลได้ แต่**แก้ไขมันไม่ได้** \n",
"\n",
"ลองเปลี่ยนตัวอักษรตัวแรกในตัวแปร `name` จาก \"M\" เป็น \"Z\" โดยรันเซลล์ด้านล่างนี้\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"tags": []
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'str' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn [19], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# ลองรันดูว่าจะเกิดอะไรขึ้น\u001b[39;00m\n\u001b[1;32m 2\u001b[0m name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMichael Jackson\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mname\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mZ\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
"\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
]
}
],
"source": [
"# ลองรันดูว่าจะเกิดอะไรขึ้น\n",
"name = \"Michael Jackson\"\n",
"name[0] = 'Z'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"คำสั่ง `name[0] = 'Z'` เป็นคำสั่งที่ทำให้เกิด Runtime Errors เนื่องจากข้อมูลชนิดสตริงไม่สามารถเปลี่ยนค่าได้ (TypeError:'str' object does not support item assignment) ฉะนั้น ในกรณีที่ต้องการแก้ไขสตริง *จำเป็นต้องสร้างตัวแปรใหม่ขึ้นมา* เก็บค่า ดังตัวอย่างต่อไปนี้\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"new_name = 'Z'+name[1]+name[2]+name[3]+name[4]+name[5]+name[6]+name[7]+\\\n",
" name[8]+name[9]+name[10]+name[11]+name[12]+name[13]+name[14]\n",
"new_name"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"แต่ก็มีเทคนิก ที่สามารถเขียนได้แบบง่ายๆ ได้โดยใช้การตัดข้อความ (Slicing strings) (รายละเอียดของ[การตัดข้อความ](ch2-stringSlicing)จะอธิบายในหัวข้อถัดไป) "
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Zichael Jackson'"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'Z' + name[1:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"นอกจากนี้ เลขดัชนีจะต้องมีค่าไม่เกิน**ขนาดของสตริง `-1`** (ถ้ารันโค้ดต่อไปนี้จะเกิดเออเรอร์)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"tags": []
},
"outputs": [
{
"ename": "IndexError",
"evalue": "string index out of range",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn [21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mname\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m]\u001b[49m\n",
"\u001b[0;31mIndexError\u001b[0m: string index out of range"
]
}
],
"source": [
"name[100]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### สตริง - เลขดัชนีเชิงลบ (Negative Index)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เลขดัชนีเป็นเลขจำนวนเต็มที่สามารถติดลบได้ \n",
"\n",
"ถ้าเราใช้เลขติดลบเป็นดัชนี เราจะได้ตัวอักษรที่อยู่ในสตริงตามลำดับการนับจากตัวท้ายสุด! กล่าวคือ จะเป็นการนับย้อนกลับจากขวาสุดไปทางซ้าย นั่นเอง ดังแสดงในรูป\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราเรียกดัชนีที่เป็นเลขติดลบนี้ว่า **ดัชนีเชิงลบหรือดัชนี้ย้อนหลัง (Negative index or Reward index)**\n",
"\n",
"โดย**ดัชนีของตัวอักษรตัวสุดท้ายมีค่าเป็น -1 เสมอ**\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"n\n"
]
}
],
"source": [
"# แสดงตัวอักษรตัวสุดท้ายของสตริงออกหน้าจอ\n",
"name = \"Michael Jackson\"\n",
"print(name[-1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ดัชนีของอักขระตัวแรกสุดมีค่าเป็น `0` (ดัชนีเชิงบวก) หรือ `-15` (ดัชนีเชิงลบ)\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"M\n"
]
}
],
"source": [
"# แสดงตัวอักษรตัวแรกสุดของสตริงออกหน้าจอโดยใช้ดัชนีเชิงลบ\n",
"\n",
"print(name[-15])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ยกเว้น `-0` มีค่าเท่ากับ `0` จึงเป็นการนับจากซ้ายไปขวาตามปกติ"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'M'"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"name[-0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราสามารถหาจำนวนอักขระในสตริงได้โดยใช้ฟังก์ชัน ```len()``` ซึ่งย่อมาจาก \"**len**gth\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" สตริง \"Michael Jackson\" มี 15 ตัวอักษร"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"15"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# หาความยาวของสติงโดยใช้คำสั่ง len()\n",
"\n",
"len(\"Michael Jackson\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"โดยสรุป ดัชนีเชิงบวกและเชิงลบของสตริง \"Michael Jackson\" มีความสัมพันธ์ดังแสดงในตารางด้านล่าง\n",
"\n",
"|Index|M |i |c |h |a |e |l | |J |a |c |k |s |o |n |\n",
"|-----|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|\n",
"|0, เลขบวก| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14|\n",
"|เลขลบ|-15|-14|-13|-12|-11|-10|-9|-8|-7|-6|-5|-4|-3|-2|-1|"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(ch2-stringSlicing)=\n",
"### สตริง - การตัดข้อความ (Slicing strings)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เราสามารถตัดเอาข้อความเฉพาะบางส่วน (หนึ่งตัวอักษรหรือมากกว่า) จากตัวแปรที่เก็บข้อมูลประเภทสตริง ให้เป็นท่อนๆ โดยใช้เทคนิคที่เรียกว่า **การตัดข้อความ (Slicing)** \n",
"\n",
"เราใช้เลขดัชนีเป็นตัวกำหนดการตัดข้อความ"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**การตัดข้อความ (Slicing)**\n",
"\n",
" \n",
"```\n",
"string[start, stop]\n",
"```\n",
" \n",
"* ตัวเลขตัวแรก (start) เป็นดัชนีเริ่มต้น (starting index) ของข้อความที่ต้องการตัด ถ้าไม่ระบุ จะมีค่าเป็น `0` โดยอัตโนมัติ (by default) กล่าวคือ จะเริ่มจากตัวแรกสุดของสตริงเสมอ\n",
"\n",
"* ตัวเลขตัวที่สอง (stop) เป็นดัชนีสิ้นสุด (ending index) ของการตัด โดยผลของการตัดจะไม่รวมดัชนีสิ้นสุด! ถ้าไม่ระบุจะมีค่าเป็น len(string) โดยอัตโนมัติ (by default) กล่าวคือ จะตัดจนถึงตัวอัษรตัวสุดท้ายของสตริงเสมอ"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เช่น ถ้าเราต้องการตัดเอาตัวอักษร\n",
"ตั้งแต่อักษรดัชนีที่ 0 ถึง 3 และตั้งแต่อักษรดัชนีที่ 8 ถึง 11 จะสามารถทำได้ดังรูป"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Mich'"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ตัดข้อความที่เก็บในตัวแปร name เฉพาะตัวอักษรตั้งแต่ดัชนีที่ 0 ถึงดัชนีที่ 3\n",
"\n",
"name[0:4] # name[:4] "
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Jack'"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ตัดข้อความที่เก็บอยู่ในตัวแปร name เฉพาะตัวอักษรตั้งแต่ดัชนีที่ 8 ถึงดัชนีที่ 11\n",
"\n",
"name[8:12]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"หากไม่ใส่ค่าดัชนีเริ่มต้น จะถูกตีความเป็นศูนย์โดยอัตโนมัติ (by default)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jack'"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"name[:12] # name[0:12]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"และหากไม่ใส่ค่าดัชนีสิ้นสุด จะมีค่าเป็น len(string) (ในกรณี len(name) มีค่่าเท่ากับ 15) โดยอัตโนมัติ (by default)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson'"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ตัดข้อความที่เก็บในตัวแปร name โดยไม่ระบุเลขดัชนี\n",
"name[:] # name[0:15]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"จะใช้ดัชนีเชิงลบตัดข้อความก็ได้"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson'"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ตัดข้อความที่เก็บในตัวแปร name โดยใช้ดัชนีเชิงลบ\n",
"name[-15:] # "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ในกรณีของการตัดข้อความ ถ้าตัวเลขดัชนีมีค่านอกช่วงที่มีอยู่จริง ไพธอนจะแสดงเป็นอักขระว่าง (Empty string, ขนาดข้อมูลเป็นศุนย์)\n",
" โดยไม่รายงานความผิดพลาดใดๆ \n",
" \n",
" (ตัดได้ แต่ตัดแล้วไม่ได้อะไร ได้ความว่างเปล่า (อักขระว่าง (Empty string))"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"''"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"name[20:110]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"แต่ในกรณีดัชนีตัวเดียว ถ้าค่าดัชนีไม่มีอยู่จริง ไพธอนจะแสดงข้อผิดพลาด (IndexError: string index out of range)\n",
"\n",
" (ดัชนีตัวเดียวเป็นการเข้าถึงข้อมูล ไม่ใข่การตัด (Slicing))"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# ถ้ารันคำสั่งนี้ จะเกิดเออเรอร์เนื่องจากค่าดัชนีอยู่นอกช่วงที่มีอยู่จริง\n",
"# name[20]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### การโดดข้าม (Stride)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ นอกจากจะใช้เลขดัชนี 2 ค่าในการตัดข้อความแล้ว เรายังสามารถป้อนค่าการโดดข้ามได้ ดังตัวอย่างต่อไปนี้\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"โดยที่ตัวเลข '2' ในรูปเป็นการระบุให้กระโดดข้ามอักขระ/ตัวอักษรทุกๆ ตัวที่สอง\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"scrolled": true,
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'McalJcsn'"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# เลือกตัวอักษรโดยข้ามตัวอักษรทุกๆ ตัวที่ 2 (ข้ามตัวอักษรที่มีดัชนีเป็น 1, 3, 5 ...)\n",
"\n",
"name[::2] # name[0:0:2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เราสามารถทำการตัดข้อความ (Slicing) ร่วมกับการโดดข้าม (Stride) ได้ \n",
"เช่น"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'calJcsn'"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"name[2:15:2] # 'Michael Jackson'[1:15:2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ซึ่งจะมีค่าเท่ากับการตัดข้อความด้วยคำสั่ง name[1:15] ก่อน (ผลลัพธ์: `'chael Jackson'`) แล้วนำผลลัพธ์นี้ไปทำการโดดข้ามตัวที่สองด้วยคำสั่ง 'chael Jackson'[::2] นั่นเอง"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'calJcsn'"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"name[2:15][::2] # name[1:15:2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"นอกจากนี้ เราสามารถให้ตัวเลขตัวที่สาม (step) เป็นเลขติดลบก็ได้ ในกรณีนี้จะเป็นการย้อนจากหลังมาหน้า\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'nscJla'"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"name[15:2:-2] # 'Michael Jackson'[15:2:-2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**สรุป: การตัดข้อความ (Slicing) และการโดดข้าม (Stride)**\n",
" \n",
">> ```string[start:stop:step]``` \n",
"\n",
"* ตัวเลขตัวแรก (start) เป็นดัชนีเริ่มต้น (starting index) ของข้อความที่ต้องการตัด ถ้าไม่ระบุ จะมีค่าเป็น `0` โดยอัตโนมัติ (by default) กล่าวคือ จะเริ่มจากตัวแรกสุดของสตริงเสมอ\n",
"\n",
"* ตัวเลขตัวที่สอง (stop) เป็นดัชนีสิ้นสุด (ending index) ของการตัด โดยผลของการตัดจะไม่รวมดัชนีสิ้นสุด! ถ้าไม่ระบุจะมีค่าเป็น len(string) หรือ -1 (by default) กล่าวคือ จะตัดจนถึงตัวอัษรตัวสุดท้ายของสตริงเสมอ\n",
" \n",
"* ตัวเลขตัวที่สาม (step) เป็นอาร์กิวเมนต์ทางเลือกสำหรับกำหนดสเต็ป (step) ระหว่างดัชนีเริ่มต้นและดัชนีสิ้นสุด ถ้าไม่ระบุ จะเป็น 1 (by default) กล่าวคือ จะไม่กระโดดข้ามเสมอ \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(ch2-stringConcatenate)=\n",
"### การเชื่อมต่อสตริง (Concatenate Strings)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เราสามารถ**เชื่อมหรือรวมสตริง**เข้าด้วยกันโดยใช้โอเปอร์เรเตอร์ '**+**' และผลลัพธ์ที่ได้คือสตริงตัวใหม่ที่เชื่อมต่อสตริงทั้งสองเข้าด้วยกัน"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jacksonis the best'"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# เชื่องสองสตริงเข้าด้วยกัน\n",
"\n",
"statement = name + \"is the best\"\n",
"statement"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"หากต้องการเชื่อต่อสตริงเดิมซ้ำๆ (ก๊อปปี้) ก็เพียงแค่ให้โอเปอรืเรเตอร์คูณ (*) สตริงด้วยจำนวนครั้งที่เราต้องการ (ก๊อปปี้) ซ้ำ\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson Michael Jackson Michael Jackson '"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# แสดงสตรืิงเดิมต่อกัน 3 ครั้ง\n",
"\n",
"3 * (\"Michael Jackson\" + \" \") # (\"Michael Jackson\" + \" \") * 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เนื่องจากสตริงเป็นข้อมูลที่แก้ไขไม่ได้ (Immutable) ดังนั้น เราจึงไม่สามารถแก้ไขตัวแปรสตริงโดยตรงได้ ดัง[ตัวอย่างก่อนหน้านี้](ch2-immutableError) อย่างไรก็ตาม เราสามารถสร้างสตริงตัวใหม่ แล้วกำหนดค่าให้กับตัวแปรเดิมได้ เช่น\n"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson is the best'"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# เชื่อมสตริง (Concatenate strings) แล้วกำหนดค่าให้กับตัวแปรตัวเดิม\n",
"\n",
"name = \"Michael Jackson\"\n",
"name = name + \" is the best\"\n",
"name"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ตัวแปร ```name``` เดิมที่เคยมีค่าเป็น \"Michael Jackson\" จะกลายเป็น \"Michael Jackson is the best\" แทน"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## อักขระพิเศษ (Escape Sequences)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ อักขระพิเศษ หรือรหัสพิเศษ (Escape Sequences) ในสตริงจะเริ่มต้นด้วยเครื่องหมาย `\"\\\"` (Back slash, Backslash (แบ็กสแลช)) เป็นรหัสของสตริงที่อินพุตยาก เช่น ↵ (การขึ้นบรรทัดใหม่) ⇥ (การตั้งแท็บ) หรือเครื่องหมายคำพูด Single/Double quote ที่ใช้ในการกำหนดสตริง\n",
"\n",
"\n",
"ในภาษาไพธอน มีอักขระพิเศษ (Escape Sequences) มากมาย ([ตารางสรุปอักขระพิเศษ (Escape Sequences) ที่ใช้บ่อย](ch2-escapeSequencesTable)) เช่น `\"\\n\"` หมายถึง การขึ้นบรรทัดใหม่ (**N**ewline escape sequence)\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Michael Jackson \n",
" is the best\n"
]
}
],
"source": [
"# อักขระพิเศษขึ้นบรรทัดใหม่ (Newline escape sequence)\n",
"\n",
"print(\" Michael Jackson \\n is the best\" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เช่นเดียวกัน `\"\\t\"` แทนแท็บ (**T**ab escape sequence):\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Michael Jackson \t is the best.\n"
]
}
],
"source": [
"# อักขระพิเศษแท็บ (Tab escape sequence)\n",
"\n",
"print(\" Michael Jackson \\t is the best.\" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ถ้าใส่ Backslash หน้าตัวอักษร `i` จะแสดง `\\i` ออกหน้าจอ เนื่องจาก ไม่เป็นรหัสพิเศษ\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Michael Jackson \\is the best.\n"
]
}
],
"source": [
"# สตริงที่มีอักขระพิเศษไม่ถูกต้อง\n",
"print(\" Michael Jackson \\is the best.\" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"แต่ถ้าเราใส่ `\\` ระหว่าง `s` กับ `t` (\"Michael Jackson is the bes\\t\") ผลลัพธ์จะเป็น"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Michael Jackson is the bes\t.\n"
]
}
],
"source": [
"# สตริงที่มีเครื่องหมาย Backslash: กรณีที่หลัง Backslash เป็นตัวอักษร t (อักขระพิเศษ)\n",
"\n",
"print(\" Michael Jackson is the bes\\t.\" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เนื่องจาก `\\t` แทนแท็บ "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ถ้าต้องการให้แสดงเครื่องหมาย `\\` (Backslash; Unicode U+005C) โดยที่ไม่ต้องกังวลว่าจะเป็นรหัสพิเศษหรือไม่ ให้ใช้เครื่องหมาย `\\\\` (Double backslash) ในสตริง"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Michael Jackson is the bes\\t.\n"
]
}
],
"source": [
"# สตริงที่มีเครื่องหมาย Backslash\n",
"\n",
"print(\" Michael Jackson is the bes\\\\t.\" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"หรือใช้อีกวิธี\n",
"\n",
"เราสามารถใส่ตัวอักษร `r` (ย่อมาจาก **R**aw string) หน้าสตริงเพื่อให้ไพธอนละเว้นการประมวลผลอักขระพิเศษได้เช่นกัน (escape sequence ignore)\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Michael Jackson is the bes\\t.\n"
]
}
],
"source": [
"# ใส่ r หน้าสตริงเพื่อให้ Python แสดงสตริงแบบ Raw string\n",
"\n",
"print(r\" Michael Jackson is the bes\\t.\" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"นอกจากเครื่องหมาย `\\` (Backslash) จะถูกใช้เป็นอักขระพิเศษแล้ว ยังถูกใช้ในกรณีที่ต้องการพิมพ์คำสั่งเดียวกันที่ยาวๆ ให้ขึ้นบรรทัดใหม่"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Michael Jackson, the greatest pop artist that ever lived, has a career that spans more than 40 of his 50 years. \n"
]
}
],
"source": [
"# สตริงที่มีเครื่องหมาย Backslash เท่านั้น\n",
"\n",
"print(\"Michael Jackson, the greatest pop artist that ever lived, \\\n",
"has a career that spans more than 40 of his 50 years. \" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"แต่ถ้าใส่ตัวอักษร `r` หน้าสตริง เครื่องหมาย `\\` จะถูกแสดงออกหน้าจอและอักขระพิเศษจะถูกละเว้นการประมวลผล"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Michael Joseph Jackson (August 29, 1958 – June 25, 2009) was an American singer, \\n\\\n",
"songwriter, dancer, and philanthropist. Dubbed the \"King of Pop\", he is regarded \\n\\\n",
"as one of the most significant cultural figures of the 20th century.\n"
]
}
],
"source": [
"# สตริงที่มีเครื่องหมาย Backslash\n",
"\n",
"print(r'Michael Joseph Jackson (August 29, 1958 – June 25, 2009) was an American singer, \\n\\\n",
"songwriter, dancer, and philanthropist. Dubbed the \"King of Pop\", he is regarded \\n\\\n",
"as one of the most significant cultural figures of the 20th century.')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(ch2-escapeSequencesTable)=\n",
"**ตารางสรุปอักขระพิเศษ (Escape Sequences) ที่ใช้บ่อย**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| Escape Sequence | ความหมาย |\n",
"| --------------- | ----------------------------------------- |\n",
"| `\\’` | เครื่องหมายคำพูด ' (Single quote) |\n",
"| `\\\"` | เครื่องหมายคำพูด \" (Double quote) |\n",
"| `\\\\` | เครื่องหมาย Backslash \\ |\n",
"| `\\n` | ขึ้นบรรทัดใหม่ (Newline) |\n",
"| `\\t` | ตั้งแท็บในแนวนอน (Horizontal Tab) |\n",
"| `\\b` | เลื่อนเคอเซอร์ลบตัวอักษรทางซ้ายมือหนึ่งตัวอักษร (Backspace) |\n",
"| `\\v` | เครื่องหมาย Vertical Tab |\n",
"| `\\r` | เลื่อนเคอเซอร์ไปทางซ้ายมือสุดของบรรทัด |\n",
"| `\\ooo` | ตัวอักษรที่มีค่าฐาน 8 เป็น ooo |\n",
"| `\\xhh` | ตัวอักษรที่มีค่าฐาน 16 เป็น hh |\n",
"| `\\uhhhh` | ตัวอักษร Unicode (UTF-8) ที่มีค่าฐาน 16 เป็น hhhh|\n",
"| `\\a` | ส่งเสียงกระดิ่งออกลำโพงหนึ่งครั้ง (Bell) |\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## การตรวจสอบข้อความในสตริงโดยใช้ตัวดำเนินการ ```in```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"วิธีที่ง่ายที่สุดวิธีหนึ่งในการตรวจสอบว่าข้อความที่ระบุมีอยู่ในสริงหรือไม่ คือ การใช้ตัวดำเนินการ ```\"in\"``` \n",
"\n",
"ตัวดำเนินการ ```\" in\"``` จะส่งกลับค่าบูลีน (True หรือ False) \n",
"\n",
"Syntex ของตัวดำเนินการ ```\"in\"``` เพื่อตรวจสอบข้อความ:\n",
"\n",
"```\n",
"sub_string in sring\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ถ้ามี sub_string อยู่ใน string จะเป็น ```\"True\"``` แต่ถ้าหากไม่มี จะเป็น ```\"False\"```"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Ja\" in \"Michael Jackson\" "
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"Janet\" in \"Michael Jackson\" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"โดยปรกติ เรามันจะใช้ตัวแปรเก็บข้อมูลสตริง"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word1 = \"Michael Jackson\"\n",
"substr1 = \"M\"\n",
"substr1 in word1"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"substr2 = \"m\"\n",
"substr2 in word1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ตัวดำเนินการ ```\"not in\"``` ใช้ผลลัพธ์ที่ตรงกันข้ามกับตัวดำเนินการ ```\"in\"``` "
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word1 = \"Michael Jackson\"\n",
"substr2 = \"m\"\n",
"substr2 not in word1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(รายละเอียดของตัวดำเนินการ ```\"in\"``` และ ```\"not in\"``` อยู่ใน \n",
"[ตัวดำเนินการตรวจสอบสมาชิก (Membership operators)](ch3-2-membershipOperators))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## การจัดการกับสตริง (String Operations) - สตริงเมธอด (String methods)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ ในภาษาไพธอน มีวิธีในการจัดการกับสตริงหลากหลายวิธี การจัดการกับสตริงพื้นฐานวิธีหนึ่ง คือ การใช้ **สตริงเมธอด (String methods)**[^method]\n",
"\n",
"\n",
"[^method]:เมธอด (Method) เหมือนฟังก์ชัน แต่เป็นฟังก์ชันที่ถูกสร้างขึ้นภายในคลาส (Class) รายละเอียดอยู่ในบท [\"คลาส\"](ch10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"สตริงจะเรียกใช้เมธอด (สตริงเมธอด) ได้โดยการใส่เครื่องหมายจุด (.) ต่อท้ายสตริง (ซึ่งเป็นการบอกว่า **สตริงตัวนั้นๆ เป็นผู้เรียกเมธอด นั่นเอง!**)\n",
"\n",
"\n",
"**Syntex การเรียกใช้เมธอด**\n",
"\n",
"```\n",
"สตริง.ชื่อของสตริงเมธอด(อาร์กิวเมนต์, อาร์กิวเมนต์, ...)\n",
"```\n",
"\n",
"หรือ\n",
"\n",
"```\n",
"ตัวแปรสตริง.ชื่อของสตริงเมธอด(อาร์กิวเมนต์, อาร์กิวเมนต์, ...)\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เมธอด ```upper()``` เป็นเมธอดของสตริงที่ใช้แปลงตัวอักษรเป็นตัวพิมพ์ใหญ่ทั้งหมด \n"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'MICHAEL JACKSON IS THE KING OF POP'"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# แปลงตัวอักษรทุกตัวที่อยู่ในสตริงเป็นตัวพิมพ์ใหญ่ทั้งหมด\n",
"\n",
"\"michael jackson is the king of pop\".upper()"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"text: michael jackson is the king of pop\n",
"text.upper() : MICHAEL JACKSON IS THE KING OF POP\n"
]
}
],
"source": [
"# แปลงตัวอักษรทุกตัวที่อยู่ในตัวแปรสตริงเป็นตัวพิมพ์ใหญ่ทั้งหมด\n",
"\n",
"text = \"michael jackson is the king of pop\"\n",
"print(\"text: \", text)\n",
"print(\"text.upper() :\", text.upper())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"การรันเมธอด`.upper()`ไม่มีผลต่อตัวแปรสตริงเดิม "
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'michael jackson is the king of pop'"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"text"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เมธอด ```lower()``` จะตรงกันข้ามกับเมธอด ```upper()``` ใช้แปลงตัวอักษรทุกตัวเป็นตัวพิมพ์เล็กทั้งหมด\n",
"\n",
"ถ้าต้องการแปลงตัวอักษรตัวแรกของทุกคำในสตริงให้เป็นตัวพิมพ์ใหญ่ ใช้เมธอด ```title()```\n",
"\n",
"ถ้าเฉพาะตัวอักษรแรกตัวเดียวใช้ ```capitalize()```\n"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Kmitl Is A Wonderful University.\n",
"Kmitl Is A Wonderful University.\n",
"Kmitl is a wonderful university.\n"
]
}
],
"source": [
"inp1 = 'kmitl is a wonderful university.'\n",
"inp2 = 'KMITL is a wonderful university.'\n",
"res1 = inp1.title() \n",
"res2 = inp2.title() \n",
"print(res1) \n",
"print(res2) \n",
"print(res1.capitalize())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เมธอด ```replace()``` เป็นเมธอดที่ใช้แทนที่ (Replace) สตริงย่อยบางส่วน (Secment) ของสตริง \n",
"โดยอาร์กิวเมนต์แรกคือ สตริงที่เราต้องการเปลี่ยน, \n",
"อาร์กิวเมนต์ที่สองคือ สตริงที่เราต้องการแทนที่\n",
"และส่งค่ากลับเป็น สตริงตัวใหม่ที่มีการเปลี่ยนแทนที่แล้ว"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Janet Jackson is the best'"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# แทนที่สตริงเดิม (\"Michael Jackson is the best\") เฉพาะส่วนที่เป็น 'Michael' ด้วย 'Janet'\n",
"\n",
"best = \"Michael Jackson is the best\"\n",
"best.replace('Michael', 'Janet')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"เช่นเดียวกัน การรันเมธอด `.replace()` ไม่มีผลต่อตัวแปรสตริงเดิม "
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Michael Jackson is the best'"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"best"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"แต่ถ้าต้องการให้ตัวแปรสตริงเดิม (ณ ที่นี้คือตัวแปร `best`) เก็บผลลัพธ์ของการรันเมธอด ก็สามารถทำได้โดยการกำหนดค่าใหม่ให้กับตัวแปร"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"'Janet Jackson is the best'"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# แทนที่สตริงเดิม (\"Michael Jackson is the best\") เฉพาะส่วนที่เป็น 'Michael' ด้วย 'Janet' แล้วเก็บค่าในตัวแปรเดิม\n",
"\n",
"best = best.replace('Michael', 'Janet')\n",
"best"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เมธอด ```find()``` เป็นเมธอดที่ใช้ค้นหาสตริงย่อย โดยอาร์กิวเมนต์ที่ส่งคือ สตริงที่ต้องการค้นหา และเมธอดจะส่งค่ากลับเป็น เลขดัชนีลำดับแรกของสตริงที่ค้นเจอ \n",
"\n",
"เราสามารถหาสตริง ```jack``` หรือ ```el``` ที่อยู่ในสตริง \"Michael Jackson is the best\" ได้โดยใช้เมธอด ```find()``` ดังนี้\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ค้นหาสตริงย่อยโดยใช้เมธอด find() โดยเอาต์พุตที่ได้เป็นดัชนีแรกที่พบสตริงย่อย\n",
"\n",
"name = \"Michael Jackson\"\n",
"name.find('el')"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ค้นหาสตริงย่อยโดยใช้เมธอด find() \n",
"\n",
"name.find('Jack')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"อย่างไรก็ตาม ในกรณีที่สตริงที่ต้องการค้นหามีหลายจุด เมธอด ```find()``` จะส่งค่ากลับเฉพาะ เลขดัชนีลำดับแรกของสตริงตัวแรกที่ค้นเจอเท่านั้น"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# ผลการค้นหาสตริงย่อยที่มีหลายจุด โดยใช้เมธอด find() \n",
"\n",
"name.find('c')"
]
},
{
"cell_type": "markdown",
"metadata": {
"tags": []
},
"source": [
"แต่ถ้าค้นแล้วไม่พบ เอาต์พุตจะเป็นค่า '-1' เสมอ ตัวอย่างเช่น สตริง 'K' ไม่มีอยู่ในตัวแปร ```name```"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"-1"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# กรณีที่ไม่พบสตริงย่อย\n",
"\n",
"name.find('K')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{note} \n",
"\n",
"**เมธอด ```find()``` VS. เมธอด ```index()```**\n",
"\n",
"ในการค้นหาสตริงย่อย นอกจากเมธอด ``` find()``` แล้ว ยังสามารถใช้เมธอด ```index()``` ค้นหาได้เช่นกัน โดยมีวิธีการใช้และผลลัพธ์เหมือนกับเมธอด ```find()``` ทุกประการ ยกเว้นในกรณีที่ค้นแล้วไม่พบ เมธอด ```index()``` จะเกิดข้อผิดพลาด ในขณะที่ เมธอด ```find()``` จะส่งค่ากลับเป็น -1\n",
"\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\qquad$ เมธอด ```split()``` เป็นเมธอดที่ใช้แบ่งสตริงด้วยตัวคั่น (Separator) ที่ระบุหรือสตริงใดๆ และส่งกลับเป็นข้อมูลชนิดลิส (list) โดยมีวิธีการใช้ ดังนี้\n",
"\n",
"```\n",
"stringA.split(สตริงที่เป็นตัวคั่น)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"รายละเอียดของข้อมูลชนิดลิสอยู่ใน [List](ch3-2)"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"['Maroon 5', ' John Legend', ' Ed Sheeran', ' Marshmello']"
]
},
"execution_count": 64,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"artist1 = 'Maroon 5, John Legend, Ed Sheeran, Marshmello' \n",
"artist1.split(',')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ตาราง: เมธอดสตริงที่มักใช้บ่อย**\n",
"\n",
"| **เมธอด** | **คำอธิบาย** |\n",
"|------------| ------------ | \n",
"| capitalize() | แปลงอักขระตัวแรกเป็นตัวพิมพ์ใหญ่ |\n",
"| count() | ส่งคืนจำนวนครั้งที่พบค่าที่ระบุในสตริง |\n",
"| endswith() | ผลลัพธ์เป็นจริงถ้าสตริงตัวสุดท้ายลงด้วยค่าที่ระบุ |\n",
"| find() | ค้นหาสตริงสำหรับค่าที่ระบุและส่งคืนตำแหน่งที่พบ |\n",
"| index() | ค้นหาสตริงสำหรับค่าที่ระบุและส่งคืนตำแหน่งที่พบ |\n",
"| isalnum() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นตัวอักษรหรือตัวเลข (alphanumeric) |\n",
"| isalpha() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นตัวอักษร alphabet |\n",
"| isdecimal() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นเลขฐานสิบ |\n",
"| isdigit() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นตัวเลข |\n",
"| islower() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นตัวพิมพ์เล็ก (รวมตัวอักษรที่เป็นเศษส่วน...) |\n",
"| isnumeric() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นตัวเลข (รวมตัวอักษรที่เป็นเศษส่วน ... เลขโรมัน) |\n",
"| isprintable() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงสามารถ print แสดงผลได้ |\n",
"| isspace() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นช่องว่าง |\n",
"| isupper() | ผลลัพธ์เป็นจริงถ้าทุกตัวในสตริงเป็นตัวพิมพ์ใหญ่ |\n",
"| join() | เชื่อมสมาชิกของ iterable ให้เป็นสตริงเดียวกันด้วยค่าที่ระบุ |\n",
"| lower() | แปลงสตริงเป็นตัวพิมพ์เล็ก |\n",
"| replace() | แทนที่ค่าเดิมในสตริงด้วยค่าที่ระบุให้เป็นสตริงใหม่ |\n",
"| rfind() | หาสตริงสำหรับค่าที่ระบุและส่งกลับตำแหน่งสุดท้ายของตำแหน่งที่พบ |\n",
"| rindex() | หาสตริงสำหรับค่าที่ระบุและส่งคืนตำแหน่งสุดท้ายของตำแหน่งที่พบ |\n",
"| split() | แบ่งสตริงด้วยตัวคั่นที่ระบุและส่งกลับเป็น list |\n",
"| startwith() | ผลลัพธ์เป็นจริงถ้าสตริงตัวแรกสุดลงด้วยค่าที่ระบุ |\n",
"| swapcase() | สลับตัวพิมพ์เล็กตัวพิมพ์เล็กจะกลายเป็นตัวพิมพ์ใหญ่และในทางกลับกัน |\n",
"| title() | แปลงอักขระตัวแรกของแต่ละคำเป็นตัวพิมพ์ใหญ่ |\n",
"| upper() | แปลงสตริงเป็นตัวพิมพ์ใหญ่ |\n",
"\n",
"src: https://expert-programming-tutor.com/tutorial/article/LM61PYTHON_STRING_METHODS.php\n",
"src: https://towardsdatascience.com/15-must-know-python-string-methods-64a4f554941b\n",
"\n",
"หมายเหตุ: การเรียกเมธอดสตริงจะไม่เปลี่ยนสตริงเดิม (แต่จะส่งคืนเป็นสตริงใหม่หรือค่าใหม่เสมอ) เนื่องจากสตริงเป็นชนิดข้อมูลแบบ Immutable\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## [Exercise]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```1.``` จงตอบคำถาม 1.1~1.3\n",
"\n",
"```1.1)``` ตัวแปร ```a``` จะมีค่าเท่าไหร่ หลังรันโค้ดต่อไปนี้แล้ว?\n",
"```\n",
"a = \"1\"\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```1.2)``` ตัวแปร ```b``` จะมีค่าเท่าไหร่ หลังรันโค้ดต่อไปนี้แล้ว?\n",
"```\n",
"b = \"2\"\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```1.3)``` ตัวแปร ```c``` จะมีค่าเท่าไหร่ หลังรันโค้ดต่อไปนี้แล้ว?\n",
"```\n",
"c = a + b\n",
"```\n"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```2.``` พิจารณาตัวแปร ```d``` \n",
"\n",
"ลองเขียนโค้ด ให้แสดงเฉพาะอักระ 3 ตัวแรกออกหน้าจอโดยการตัดข้อความ (Slicing)\n"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n",
"d = \"ABCDEFG\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```3.``` พิจารณาตัวแปร ```e``` \n",
"\n",
"ลองเขียนโค้ดเพิ่ม เพื่อให้พิมพ์ออกหน้าจอโดยกระโดดข้าม (Stride) ทุกๆ 2 ตัวอักษร\n"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n",
"e = 'clocrkr1e1c1t'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```4.``` ลองเขียนโค้ดให้พิมพ์สัญลักษณ์ Backslash 3 (```\\\\\\```) อันออกหน้าจอ\n"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```5.``` ลองเขียนโค้ด เปลี่ยนตัวแปร ```f``` ให้เป็นตัวพิมพ์ใหญ่ทั้งหมด"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n",
"f = \"are you sure?\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```6.``` พิจารณาตัวแปร ```g``` \n",
"\n",
"ลองเขียนโค้ด ให้ค้นหาดัชนีแรกสุดของสตริงย่อย ```Mary``` ในตัวแปร ```g```"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n",
"g = \"Mary had a little lamb Little lamb, little lamb Mary had a little lamb \\\n",
"Its fleece was white as snow And everywhere that Mary went Mary went, Mary went \\\n",
"Everywhere that Mary went The lamb was sure to go\"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```7.``` จากตัวแปร ```g``` ข้างต้น\n",
"ลองแทนที่ 'Mary' ด้วย 'Bob'\n"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```8.``` จงสร้างฟังก์ชัน ```remove_punctuations``` โดยมีพารามิเตอร์ ```input_string``` เป็นตัวแปรเก็บข้อความภาษาอังกฤษใดๆ และคืนค่ากลับ (return) เป็นสตริงที่ลบเครื่องหมายวรรคตอนทั้งหมด (```.``` (period), ```,``` (comma), ```:``` (colon), ```;``` (semicolon), ```!``` (exclamation mark), ```?``` (question mark), ```\"``` (quotation marks), ```...``` (ellipsis)) ออกจากสตริง ```input_string``` แล้ว (มีเฉลยอยู่ท้ายหนังสือ)\n",
"\n",
"โดยเขียนโค้ตเพิ่มลงในช่องว่างที่เตรียมไว้ระหว่าง ```### BEGIN SOLUTION``` และ ```### END SOLUTION```"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n",
"\n",
"def remove_punctuations(input_string):\n",
" ### BEGIN SOLUTION\n",
" \n",
" return\n",
" ### END SOLUTION\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"หลังจากเขียนโค้ดในเซลล์ด้านบนแล้ว ให้ดำเนินการรันเซลล์ด้านล่างเพื่อตรวจสอบว่าผลการรันเป็น True"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"False\n",
"False\n",
"False\n",
"False\n",
"False\n"
]
}
],
"source": [
"# For test-run\n",
"# รันโค้ดต่อไปนี้ ถ้าได้ผลลัพธ์ 'True' 6 ครั้ง ถือว่าผ่าน\n",
"\n",
"str1 = 'How do you like your eggs?'\n",
"str2 = '\"Look out behind you!\" she yelled.'\n",
"str3 = 'She went shopping and bought shoes, a dress, two shirts, and a pair of pants.'\n",
"str4 = 'She took four classes last semester: history, biology, arts, and economics.'\n",
"str5 = 'Last summer we traveled to London, England; Paris, France; Rome, Italy; and Athens, Greece.'\n",
"str6 = 'At midnight, she began to count down: \"ten, nine, eight...\" and then the ball dropped.'\n",
"\n",
"print(remove_punctuations(str1)=='How do you like your eggs')\n",
"print(remove_punctuations(str2)=='Look out behind you she yelled')\n",
"print(remove_punctuations(str3)=='She went shopping and bought shoes a dress two shirts and a pair of pants')\n",
"print(remove_punctuations(str4)=='She took four classes last semester history biology arts and economics')\n",
"print(remove_punctuations(str5)=='Last summer we traveled to London England Paris France Rome Italy and Athens Greece')\n",
"print(remove_punctuations(str6)=='At midnight she began to count down ten nine eight and then the ball dropped')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```9.``` จงสร้างฟังก์ชันสลับข้อความ ```colon_swap``` โดยกำหนดให้ ```input_str``` เป็นพารามิเตอร์ที่เก็บสตริงที่มีเครื่องหมายโคลอน (:) อยู่หนึ่งอักขระ และคืนค่ากลับ (return) เป็นสตริงที่สลับระหว่างข้อความที่อยู่ด้านซ้ายและด้านขวาของเครื่องหมายโคลอน เช่น\n",
"\n",
">> ถ้าเรียก ```colon_swap('ABC:XYZ')``` คืนค่ากลับเป็น ```'XYZ:ABC'```\n",
">>\n",
">> ถ้าเรียก ```colon_swap('ปิด:เปิด')``` คืนค่ากลับเป็น ```'เปิด:ปิด'```\n",
">>\n",
">> ถ้าเรียก ```colon_swap('\"Yes\":\"No\"')``` คืนค่ากลับเป็น ```'\"No\":\"Yes\"'```\n",
"\n",
"\n",
"โดยเขียนโค้ตเพิ่มลงในช่องว่างที่เตรียมไว้ระหว่าง ```### BEGIN SOLUTION``` และ ```### END SOLUTION```"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter\n",
"\n",
"def colon_swap(input_str):\n",
" ### BEGIN SOLUTION\n",
"\n",
"\n",
" return\n",
" ### END SOLUTION\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"หลังจากเขียนโค้ดในเซลล์ด้านบนแล้ว ให้ดำเนินการรันเซลล์ด้านล่างเพื่อตรวจสอบว่าผลการรันเป็น True"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"False\n",
"False\n"
]
}
],
"source": [
"# For test-run\n",
"# รันโค้ดต่อไปนี้ ถ้าได้ผลลัพธ์ 'True' 3 ครั้ง ถือว่าผ่าน\n",
"\n",
"print(colon_swap('ABC:XYZ')=='XYZ:ABC')\n",
"print(colon_swap('ปิด:เปิด')=='เปิด:ปิด')\n",
"print(colon_swap('\"Yes\":\"No\"')=='\"No\":\"Yes\"')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\"The only way to learn a new programming language is by writing programs in it.\" - Dennis Ritchie"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Author\n",
"\n",
"S.C.\n",
"\n",
"### Change Log\n",
"\n",
" \n",
"| Date | Version | Change Description |\n",
"|---|---|---|\n",
"| 08-08-2021 | 0.1 | First edition |\n",
"| 05-05-2022 | 0.2 | Fix the typo, minor change |\n",
"| | | |\n",
"| | | |\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel(3.8.13))",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.13"
},
"latex_envs": {
"LaTeX_envs_menu_present": true,
"autoclose": false,
"autocomplete": true,
"bibliofile": "biblio.bib",
"cite_by": "apalike",
"current_citInitial": 1,
"eqLabelWithNumbers": true,
"eqNumInitial": 1,
"hotkeys": {
"equation": "Ctrl-E",
"itemize": "Ctrl-I"
},
"labels_anchors": false,
"latex_user_defs": false,
"report_style_numbering": false,
"user_envs_cfg": false
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": true,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
},
"vscode": {
"interpreter": {
"hash": "e921dbf9f2d20a8528fa054ff97aae3eb23f1abc9a6f29b7bcee4307a5b88bad"
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}