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

จากรายละเอียดในตาราง จะเห็นความแตกต่างกันเพียงข้อที่ 5 ความสามารถในการส่งค่าผลลัพธ์ภายในกลับออกไปด้วยการใช้คำสั่ง return ซึ่งจะมีใช้เฉพาะกับฟังก์ชันเท่านั้น ด้วยเหตุที่มีความแตกต่างจากลักษณะการใช้งานเพียงเล็กน้อย ภาษา Python จึงรวมโครงสร้างของทั้งโพรซีเจอร์และฟังก์ชันให้เป็นเรื่องเดียวกัน โดยจะอ้างอิงคุณลักษณะของการใช้งานแบบฟังก์ชันเป็นหลัก ดังนั้นในภาษา Python จะมีเพียงแค่การสร้างฟังก์ชัน (Custom Function) สำหรับใช้งานในโมดูลเท่านั้น ก่อนที่จะทำความเข้าใจรูปแบบการสร้างฟังก์ชันด้วยคำสั่งของภาษา Python ลองมาดูโครงสร้างโดยรวมและเส้นทางการทำงานของฟังก์ชัน ตามรูปที่ 1

รูปที่ 1 แสดงการสร้างฟังก์ชัน, วิธีการเรียกใช้งาน พร้อมเส้นทางการทำงานของแต่ละ ฟังก์ชันในโมดูลของ Python

ตำแหน่งของการสร้างฟังก์ชันสำหรับการใช้งายภายในโครงสร้างของโมดูล รวมทั้งลักษณะวิธีการเรียกใช้ฟังก์ชัน (สังเกตส้นทางเมื่อฟังก์ชันแต่ละชื่อถูกเรียกใช้งาน โดยเริ่มจากฟังก์ชันที่ชื่อ main เป็นจุดเริ่มต้นของโมดูลนี้) ยกตัวอย่างตามรูปที่ 1 สำหรับโมดูลนี้คำสั่งจะเริ่มต้นที่หลังสันประข้างล่างของกลุ่มฟังก์ชันทั้งหมด คำสั่งแรกหลังเส้นประจะพบการเรียนใช้งานฟังก์ชันที่ชื่อว่า main เมื่อฟังก์ชันนี้ทำงานจะกระโดดไปยังฟังก์ชัน main ตามเส้นทางหมายเลข 1 และเริ่มทำงานกับกลุ่มคำสั่งย่อยภายในฟังก์ชัน main จนสิ้นสุดจึงกระโดดกลับมาที่กลุ่มคำสั่งเริ่มต้นตามเส้นทางกลับหมายเลข 2 ที่คำสั่งถัดไป คือ คำสั่งที่เรียกฟังก์ชันที่ชื่อว่า showdirectory ซึ่งจะกระโดดไปที่ฟังก์ชันตามเส้นทางหมายเลข 3 เพื่อทำคำสั่งย่อยต่างๆ ภายในของฟังก์ชัน showdirectory ขณะที่ทำคำสั่งย่อยภายใน จะมีการเรียกฟังก์ชันที่ชื่อ showfilelist ซึ่งจะกระโดดไปยังที่อยู่ของฟังก์ชันดังกล่าวตามเส้นทางหมายเลข 4 เพื่อทำงานกับกลุ่มคำสั่งย่อยภายในของฟังก์ชัน showfilelist จนกระทั่งสิ้นสุดการทำงานของกลุ่มคำสั่งย่อยจึงกระโดดกลับตามเส้นทางหมายเลข 5 มายังกลุ่มคำสั่งย่อยภายในของฟังก์ชัน showdirectory และทำคำสั่งย่อยภายในของฟังก์ชันนี้ จนกระทั่งเสร็จสิ้นจึงจะกระโดดกลับไปกลุ่มคำสั่งหลักด้วยเส้นทางหมายเลข 6 เพื่อทำคำสั่งในกลุ่มคำสั่งหลักต่อไปจนจบโปรแกรม คงพอจะเห็นภาพการทำงานและวิธีเรียกใช้งานฟังก์ชันภายในโมดูลของภาษา Python และเพื่อให้ง่ายต่อการทำความเข้าใจในรายละเอียดของการเขียนโปรแกรมร่วมกับฟังก์ชันที่จัดสร้างขึ้น จะขอแบ่งการอธิบายออกเป็นหัวข้อดังต่อไปนี้
1. รูปแบบการสร้างฟังก์ชันของภาษา Python และวิธีเขียนโปรแกรมเพื่อเรียกใช้งาน
2. การกำหนดขอบเขตของตัวแปรภายในของฟังก์ชัน
3. ลักษณะการใช้คีย์เวิร์ดอาร์กิวเมนต์และพารามิเตอร์ร่วมกับฟังก์ชัน (Argument And Parameter Function Keyword)
4. ความแตกต่างระหว่างฟังก์ชันที่ใช้และไม่ใช้คำสั่ง return

ลักษณะการสร้างฟังก์ชันมีรูปแบบ (Syntax) ของการเขียนที่ค่อนข้างง่าย ดังรูปที่ 2 แสดงวิธีการเขียนฟังก์ชันที่แบ่งตามการนำไปใช้งาน 4 รูปแบบ ได้แก่
1. การสร้างฟังก์ชันที่ทำงานเหมือนโพรซีเจอร์ (ไม่มีการส่งค่าใดๆ กลับ)
2. การสร้างฟังก์ชันที่ทำงานเหมือนโพรซีเจอร์ แต่มีการส่งผ่านค่าต่างๆ ร่วมกับตัวแปรอาร์กิวเมนต์
3. การสร้างฟังก์ชันร่วมกับการส่งค่าผลลัพธ์กลับด้วยคำสั่ง return
4. การสร้างฟังก์ชันที่มีการใช้ตัวแปรอาร์กิวเมนต์และการส่งค่าผลลัพธ์กลับ

รูปที่ 2 แสดงรูปแบบวิธีการสร้างฟังก์ชันของภาษา Python

ซึ่งทั้ง 4 รูปแบบจะถูกนำมาใช้งานภายในโมดูลของภาษา Python ตามคุณสมบัติของแต่ละรูปแบบโดยนักพัฒนาโปรแกรมจะเป็นผู้ที่ตัดสินใจเลือกใช้งานให้ตรงกับรูปแบบโปรแกรมคำสั่งที่กำลังพัฒนา และตรงตามการออกแบบโครงสร้าง เพื่อพัฒนาโปรแกรม เช่น โปรแกรมที่เป็นลักษณะ Procedural ซึ่งก็เป็นรูปแบบการเขียนโปรแกรมที่เป็นพื้นฐานของภาษา Python ที่มีการใช้ฟังก์ชันทั้ง 4 รูปแบบ เป็นส่วนร่วมภายในโมดูล และแบ่งลักษณะการใช้งานฟังก์ชันทั้ง 4 รูปแบบ ออกเป็น 2 ลักษณะ คือ
1. ฟังก์ชันที่ใช้งานแบบ Global
2. ฟังก์ชันที่ใช้งานแบบ Local

ฟังก์ชันประเภทนี้ถูกสร้างขึ้นภายในโมดูลมาตรฐานปกติของ Python ซึ่งสามารถนำฟังก์ชันนี้ไปใช้งานร่วมกับโมดูลอื่นๆ โดยเชื่อมโยงการใช้งานด้วยคำสั่ง import จากรูปที่ 3 แสดงวิธีการ import การใช้ Global ฟังก์ชันระหว่างโมดูลกับโมดูล

รูปที่ 3 แสดงลักษณะการสร้าง Global ฟังก์ชันและการเรียกใช้งานฟังก์ชันระหว่างโมดูล

เงื่อนไขเล็กๆ น้อยๆ ที่ผู้ใช้งานไม่ควรพลาดในการสร้างโมดูลและฟังก์ชันลักษณะ Global สำหรับใช้งานร่วมกับโมดูลอื่นๆ คือการจดบันทึกไฟล์โมดูลทั้งหมดไว้ในโฟลเดอร์เดียวกัน มาลองทำตัวอย่างเกี่ยวกับฟังก์ชันประเภท Global

ตัวอย่างที่ 1 สร้างโฟลเดอร์ใน Local Drive ที่ชื่อว่า Go Sample (ถ้าใช้ระบบปฏิบัติการวินโดวส์ให้ทดลองสร้างไว้ใน Drive C:\Go Sample) จากนั้นเปิดโปรแกรม IDLE Python เลือกเมนู File, เมนูย่อยNew Window เมื่อจอภาพโมดูลของ Python ปรากฏให้บันทึกไฟล์ลงในโฟลเดอร์ Go Sample โดยใช้ชื่อว่า check.py กลับไปที่ IDLE Python เปิด New Window อีกครั้งหนึ่ง ทำการบันทึกจอภาพโมดูลที่ 2 ลงในไฟล์ที่ชื่อว่า shop.py ลงในโฟลเดอร์เดียวกับไฟล์ check.py

รูปที่ 4 ลำดับการสร้างโมดูลไปเก็บไว้ใน C:\Go Sample

ทดลองสร้างฟังก์ชัน Global ลงในโมดูล check.py ดังนี้

จากนั้นทำการบันทึกไฟล์โมดูล check.py เมื่อเสร็จสิ้นแล้วให้ทำการทดลองเปิดโมดูล shop.py เพื่อเรียกใช้ฟังก์ชัน Global จากโมดูล check.py ตามคำสั่งต่อไปนี้

ทำการทดสอบโปรแกรมโดยการรันคำสั่งในโมดูล shop เพื่อดูผลลัพธ์การเรียกใช้งานฟังก์ชันGlobal จากโมดูล check.py ข้อควรสังเกตการณ์เรียกใช้ฟังก์ชันแบบ Global เนื่องจากชื่อฟังก์ชันแบบ Global มีโอกาสซ้ำกับชื่อฟังก์ชันภายในโมดูล shop ซึ่งเป็นฟังก์ชันแบบ Local ได้ รูปแบบการเขียนโปรแกรมเรียกใช้ฟังก์ชัน Global จำเป็นต้องมีชื่อโมดูล (บางครั้งเรียก Name Space) ของฟังก์ชัน Global พิมพ์ไว้ข้างหน้าการเรียกใช้ฟังก์ชันเสมอ

การสร้างฟังก์ชันใดๆ ภายในโมดูลมาตรฐานของ Python และมีการเรียกใช้งานฟังก์ชันเฉพาะภายในโมดูลนั้น กลุ่มฟังก์ชันภายในโมดูลนั้นจะถูกจัดให้เป็นฟังก์ชันภายในหรือแบบ Local นั่นเอง ทดลองสร้างและใช้งานฟังก์ชันแบบ Local ตามตัวอย่างดังนี้

ตัวอย่างที่ 1 ทำการเปิดโมดูลวินโดว์จาก IDLE Python

จากตัวอย่างนี้ จะต้องทดลองสร้างโฟลเดอร์ python31 ไว้ใน Drive C:\ โดยสร้างโฟลเดอร์และไฟล์นามสกุลต่างๆ ไว้ในโฟลเดอร์ python31 ก่อน เพื่อให้โปรแกรมที่เขียนขึ้นสามารถเรียกดูไฟล์และโฟลเดอร์ได้ โดยคำสั่งที่เขียนขึ้นจะประกอบด้วยฟังก์ชันแบบ Local ในโมดูลนี้มีทั้งหมด 3 ฟังก์ชัน main, showdirectory, showfilelist โดยฟังก์ชันแรกที่ถูกเรียกใช้งานคือฟังก์ชัน main ทำหน้าที่เป็นเมนูสำหรับเรียกใช้ฟังก์ชัน showdirectory และ showfilelist ผ่านตัวแปรที่ชื่อ yourchoice ที่เก็บค่าหมายเลขหัวเรื่องจากภายในฟังก์ชัน main สำหรับฟังก์ชันแสดงรายชื่อโฟลเดอร์ใน Drive C คือฟังก์ชันที่ชื่อ showdirectory ประกอบด้วยคำสั่ง os.listdir( ) ร่วมกับคำสั่ง for เพื่ออ่านรายชื่อโฟลเดอร์และไฟล์ตามที่ระบุชื่อ Path หรือ Drive ในตัวอย่างนี้ระบุให้อ่านใน Drive C:\ ทั้งหมด เนื่องจากคำสั่ง os.listdir( ) จะอ่านรายชื่อโฟลเดอร์และไฟล์ จึงจำเป็นต้องเลือกเฉพาะชื่อโฟลเดอร์เท่านั้น วิธีการก็ใช้คำสั่ง if เพื่อสร้างเงื่อนไขในการแยกชื่อที่เป็นโฟลเดอร์ (สังเกตไม่มีการใช้เครื่องหมาย. และนามสกุล) ออกจากชื่อไฟล์โดยการค้นหาเครื่องหมาย. ภายในตัวแปร sNamedir ที่มีรูปแบบคำสั่งในการค้นหาเครื่องหมายดังนี้ ‘.’in sNamedir ซึ่งผลลัพธ์ที่ได้จากการค้นหาเครื่องหมายจุด เมื่อตรวจพบจะมีค่าเป็น True เมื่อนำคำสั่งการค้นหามารวมกับคำสั่ง if (if ‘.’ In sNamedir) จะเป็นการสร้างเงื่อนไขเพื่อตรวจชื่อในค่าตัวแปร sNamedir ที่เป็นเกี่ยวกับไฟล์เท่านั้น ถ้าหากต้องการตรวจชื่อที่อยู่ในตัวแปร sNamedir ที่เป็นโฟลเดอร์ ต้องดัดแปลงคำสั่งการตรวจเงือนไขตามนี้ if not ‘.’ in sNamedir จะเห็นว่ามีการเพิ่มคำสั่ง not แทรกลงในการตรวจเงือนไข แค่นี้ก็จะค้นหาเฉพาะชื่อที่เป็นโฟลเดอร์เท่านั้น

นอกจากการใช้งานฟังก์ชันที่เป็น Global และ Local แล้วก็มีการสร้างหรือเขียนฟังก์ชันเพื่อใช้งานภายใต้รูปแบบการเขียนโปรแกรมเชิงวัตถุ (Object Oriented Programming) ตอนนี้หากเปิดโมดูลมาตรฐานปกติทั่วไปมาเขียนโปรแกรม OOP แล้วเราจะเรียกโมดูลเป็น Class Module แทนคำว่าโมดูลเฉยๆ และแน่นอน คำว่าฟังก์ชันที่เราสร้างในโมดูลเฉยๆ ก็ต้องเปลี่ยนชื่อเรียกฟังก์ชันใหม่เป็นคำว่า Method ของ Class Module โดยแบ่งลักษณะการใช้งาน Methon ออกเป็น 2 ลักษณะการใช้งาน คือ
1. Internal Method หรือ Private Method
2. Interface Method

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

จากตัวอย่างที่ 1 เป็นการแสดงตัวแปรที่ประกาศและใช้งานในโมดูล สังเกตในฟังก์ชัน test จะมีการเรียกใช้งานตัวแปร fullname ร่วมกับกลุ่มคำสั่งย่อยภายในฟังก์ชัน เมื่อทำการทดสอบรันโปรแกรมตัวแปร fullmane ที่ประการไว้ และต้องนำมาใช้ร่วมภายในฟังก์ชัน test ก็สามารถแสดงค่าข้อมูลที่เก็บไว้ในตัวแปรได้อย่างถูกต้อง ซึ่งผลลัพธ์ที่ได้จะแสดงดังต่อไปนี้
              ผลลัพธ์ของการทดสอบโปรแกรมในตัวอย่างที่ 1
                      >>> จองพื้นที่ 3 X 3 ม.
                     >>>  ของร้านชื่อ shop
ตัวอย่างที่ 2 ทำไมถึงต้องใช้คำสั่ง Global กับตัวแปรของโมดูลภายในฟังก์ชัน

เมื่อรันโปรแกรมเพื่อทดสอบจะได้ผลลัพธ์ดังนี้

น่าแปลกมากที่เกิด Error เกิดขึ้นเมื่อเรียกใช้ฟังก์ชันที่ชื่อว่า two ในบรรทัด (x=x+300) ที่ตัวแปรของโมดูลมีการเปลี่ยนแปลงค่าใหม่ภายในฟังก์ชันนี้ ข้อความ Error ที่ปรากฏจะถามถึงตัวแปร x ที่กำลังจะเปลี่ยนแปลงค่าใหม่เป็นตัวแปร x แบบ Local ภายในฟังก์ชันหรือตัวแปร x นี้ได้มาจากข้างนอกฟังก์ชัน (ตัวแปรของโมดูล) ตรงนี้ผู้พัฒนาโปรแกรมต้องเป็นผู้เลือกการใช้ตัวแปร x ตัวนี้เอง ถ้าใช้ตัวแปร x แบบ Local ก็แก้ไขคำสั่งเพิ่มตามตัวอย่างต่อไปนี้ลงในฟังก์ชัน two และทำการทดลองรันโปรแกรมใหม่

ในบรรทัด x=0 ที่ทำการเพิ่มในฟังก์ชัน two จะถือว่าเป็นตัวแปรใหม่ที่ชื่อ x และจะใช้งานเฉพาะในฟังก์ชัน two เท่านั้น สำหรับตัวแปร x ของโมดูลจะไม่สามารถนำมาใช้งานในฟังก์ชันได้อีกเลย
ต่อมาในกรณีที่ต้องการใช้ตัวแปร x ของโมดูล ซึ่งประกาศอยู่ภายนอกฟังก์ชัน มีเงื่อนไขคือ ต้องเปลี่ยนแปลงค่าภายในของตัวแปร x  ของโมดูลนี้ได้ตลอดเวลา ตัวอย่างการเพิ่มคำสั่ง global เสริมลงในฟังก์ชัน two แสดงไว้ดังนี้

เมื่อกำหนด global x ในฟังก์ชัน two ต่อไปนี้ การใช้งานตัวแปร x ตัวนี้จะสามารถเปลี่ยนแปลงค่าภายในตัวแปรได้ (ตัวแปร x ต้องประกาศในโมดูลก่อนเรียกใช้ในฟังก์ชันเสมอ)

ตัวอย่างที่ 3 แสดงการกำหนดขอบเขตของตัวแปรที่ใช้งานกับฟังก์ชัน ให้เปิดวินโดว์โมดูลใหม่จาก IDLE ของ  Python  Shell เพื่อทดลองโปรแกรมต่อไปนี้

จากตัวอย่างที่ 3 จะใช้ตัวแปรที่ชื่อ choice เป็นตัวแปรเก็บหัวข้อที่ต้องการใช้งาน (ตัวแปร choice จะถูกใช้งานในหลายแห่ง เช่น ในฟังก์ชันที่ชื่อ menu และที่กลุ่มคำสั่งเริ่มต้นที่คำสั่ง if กรณีนี้ตัวแปร choice ควรประกาศในระดับโมดูลจึงจะเหมาะสมต่อการใช้งาน) จากฟังก์ชันที่ชื่อ menu ซึ่งจะทำหน้าที่แสดงรายการของเมนูการใช้งานและรอรับหัวเรื่องที่ต้องการใช้งานจากคำสั่ง input ภายในฟังก์ชัน เนื่องจากจะมีการเปลี่ยนแปลงค่าข้อมูลในตัวแปร choice ที่อยู่ภายนอกฟังก์ชัน จึงจำเป็นต้องระบุคำว่า Clobal choice ลงในฟังก์ชัน menu เมื่อได้หมายเลขหัวเรื่องก็จะนำไปตรวจด้วยกลุ่มคำสั่ง if เพื่อเรียกใช้ฟังก์ชันย่อยอื่นๆ เช่น กดหมายเลข 1 จะเรียกใช้ฟังก์ชัน opencalculator ซึ่งภายในฟังก์ชันนี้จะมีตัวแปรภายในที่เป็นแบบ Local (ตัวแปรชื่อ filename) เพื่อกำหนดชื่อไฟล์เครื่องคิดเลขหรือ call.exe (ไฟล์เครื่องคิดเลขที่เรียกใช้งานจากตัวอย่างนี้จะได้รับการติดตั้ง และมีใช้งานในระบบปฏิบัติการ Windows อยู่แล้ว) โดยจะนำค่าในตัวแปร filename ไปใช้ร่วมกับคำสั่ง os.system(filename) ซึ่งทำหน้าที่รันไฟล์ที่มีนามสกุลเป็น .exe ของระบบปฏิบัติการ Windows กดหมายเลข 2 สำหรับรียกฟังก์ชัน opennotepad (ลักษณะการใช้คำสั่งและตัวแปรจะคล้ายกับฟังก์ชัน opencalculator) สำหรับเปิดโปรแกรม Notepad ของระบบปฏิบัติการสรุปได้ว่าการทำงานของโปรแกรมในตัวอย่างที่ 3 ตัวแปร choice ค่อยข้างมีบทบาทในการใช้ค่าที่ได้รับมาจากภายในฟังก์ชัน menu เชื่อมโยงกับกลุ่มคำสั่งในจุดอื่นๆ ภายในโมดูล ดังนั้นฟังก์ชันใดต้องการใช้ตัวแปร choice ที่ต้องการเปลี่ยนแปลงค่าข้อมูลก็อย่าลืมใช้ Global choice ไว้ในฟังก์ชันด้วย

เพิ่มอาร์กิวเมนต์สัก 2 ตัวในฟังชัน Payment ด้วย ถ้าใครเป็นนักพัฒนาโปรแกรมมือใหม่หรือมือเก่า ก็คงไม่มีปัญหาในการสร้างอาร์กิวเมนต์เพิ่มให้กับฟังก์ชันมากนัก เพียงแต่ขอตัวอย่างรูปแบบ (Syntax) ของการเขียนใน python ว่าเค้ามีรูปแบบอย่างไร เท่านี้ก็ลุยทำงานที่เหลือต่อไปได้ ก่อนที่จะมาดูวิธีการใช้อาร์กิวเมนต์หรือบางครั้งก็เรียกว่าพารามิเตอร์เพิ่มให้กับฟังก์ชัน ต้องมาดูเหลุผลว่าทำไมต้องใช้อาร์กิวเมนต์หรือพารามิเตอร์ร่วมกับฟังก์ชัน คำตอบง่ายๆ ก็คือ เราต้องการส่งค่าข้อมูลผ่านเข้าไปภายในฟังก์ชัน เพื่อที่จะได้นำค่าข้อมูลเหล่านั้นไปใช้งานกับตัวแปร Local, การคำนวณ หรือใช้กับกลุ่มคำสั่งย่อยภายในฟังก์ชันรูปที่ 1 แสดงรูปแบบการกำหนดอาร์กิวเมนต์ให้กับฟังก์ชัน

รูปที่ 5 แสดงรูปแบบการกำหนดอาร์กิวเมนต์สำหรับให้งานกับฟังก์ชัน

อาร์กิวเมนต์ที่ใช้ร่วมกับฟังก์ชันของ Python จะประกอบด้วย 2 ลักษณะคือ
1. อาร์กิวเมนต์แบบตำแหน่งและจำนวนใช้งานที่แน่นอน (Positional Argument)
2. อาร์กิวเมนต์แบบขยายจำนวนตามค่าข้อมูล (Sequence Unpacking Operator)

การใช้งานอาร์กิวเมนต์ลักษณะนี้มักนิยมใช้งานทั่วไปร่วมกับฟังก์ชันปกติ รูปแบบการประกาศอาร์กิวเมนต์ค่อนข้างเขียนง่าย ตำแหน่งของอาร์กิวเมนต์ในการประกาศและใช้งานก็แน่นอนไม่เปลี่ยนแปลง วิธีการผ่านค่าข้อมูลเข้าไปจัดเก็บและเรียกใช้ค่าข้อมูลภายในอาร์กิวเมนต์ คล้ายกับการใช้งานตัวแปรทั่วไป ดังแสดงไว้ในตัวอย่างต่อไปนี้

ตัวอย่าง แสดงวิธีประกาศอาร์กิวเมนต์ที่ชื่อว่า startno และ endno

การระบุ startno และ endno ให้กับฟังก์ชัน shownumber เป็นทางผ่านค่าข้อมูลจากภายนอกฟังก์ชันเข้าไปใช้งานภายในฟังก์ชัน ด้วยการเรียกใช้งานฟังก์ชันตามตัวอย่างต่อไปนี้

โดยกำหนดค่า 5 ให้กับตัวแปร a และค่า 10 ให้กับตัวแปร b เมื่อเรียกใช้ฟังก์ชัน shownumber ก็กำหนดตัวแปร a ณ ตำแหน่งอาร์กิวเมนต์แรกฟังก์ชัน ซึ่งจะตรงกับอาร์กิวเมนต์ที่ชื่อ startno เช่นเดียวกับตัวแปร b ที่จะกำหนดตำแหน่งอาร์กิวเมนต์ที่ 2 ซึ่งตรงกับอาร์กิวเมนต์ endno

รูปที่ 6 แสดงการผ่านค่าข้อมูลจากตัวแปร a และ b ตรงตามตำแหน่งของอาร์กิวเมนต์แต่ละตัว

การโอนถ่ายค่าข้อมูลในตัวแปร a ไปยังอาร์กิวเมนต์ startno จะเกิดขึ้นโดยอัตโนมัติ (ชนิดการโอนย้ายข้อมูลระหว่างตัวแปรปกติกับอาร์กิวเมนต์จะเป็นแบบ Tuple ซึ่งมีความหมายว่า เมื่อค่าข้อมูลอาร์กิวเมนต์มีการเปลี่ยนแปลงจากเดิมไป จะไม่ส่งผลให้ค่าข้อมูลในตัวแปรต้นทางเปลี่ยนตามไป ตัวอย่าง ตัวแปร a มีค่าคือ 5 ซึ่งเป็นตัวแปรต้นทาง เมื่อตัวแปร a ผ่านค่าข้อมูลไปยังอาร์กิวเมนต์ startno จาก 5 ไปเป็น 7 ค่าข้อมูลในตัวแปรต้นทางคือ ตัวแปร a ก็คงค่าเท่ากับ 5 ไว้ดังเดิม) เมื่อฟังก์ชันถูกเรียกใช้งานเสนอ ลองพิมพ์กลุ่มสั่งเกี่ยวกับฟังก์ชันร่วมกับอาร์กิวเมนต์แบบที่ 1 ตามตัวอย่างต่อไปนี้
ตัวอย่างที่ 1 แสดงการเรียกใช้ฟังก์ชันพร้อมการผ่านค่าข้อมูลให้กับอาร์กิวเมนต์ของฟังก์ชัน เปิดวินโดว์โมดูลใหม่จาก IDLE ของ Python Shell เพื่อทดลองโปรแกรม

จากตัวอย่างที่ 1 สมมุติให้เป็นโปรแกรมเกี่ยวกับรายชื่อนักเรียนในห้องเรียนภาษาอังกฤษ โดยจัดเก็บรายชื่อนักเรียนไว้ในตัวแปร englishroom ในโปรแกรมตัวอย่างนี้ประกอบด้วย 2 ฟังก์ชันทำหน้าที่ค้นหาชื่อที่มีตัวอักษรของชื่อมากน้อยตามที่ต้องการ ยกตัวอย่าง ถ้าต้องการแสดงรายชื่อนักเรียนที่มีมากกว่า 3 ตัวอักษร ให้เลือกเมนูหมายเลข 1 จะเป็นการเลือกฟังก์ชันชื่อ namemorechar ที่ประกอบด้วยอาร์กิวเมนต์ชื่อ room สำหรับรับค่าข้อมูลที่เป็นรายชื่อนักเรียน ซึ่งจะได้จากตัวแปร englishroom และ อาร์กิวเมนต์ชื่อ numchar สำหรับรันจำนวนตัวอักษรที่ต้องการเปรียบเทียบในฟังก์ชัน โดยจะได้ค่าจากตัวแปร b หรือหากต้องการแสดงรายชื่อนักเรียนที่มีน้อยกว่า 3 ตัวอักษร ให้เลือกเมนูหมายเลข 2 ซึ่งจะเรียกใช้ฟังก์ชันชื่อ namemorechar ที่มี 2 อาร์กิวเมนต์และมีการทำงานคล้ายๆ กับฟังก์ชันแรก

การสร้างฟังก์ชันที่มีอาร์กิวเมนต์สำหรับใช้งาน โดยส่วนใหญ่จะกำหนดอาร์กิวเมนต์ใช้งานเป็นจำนวนที่แน่นอน แต่ในกรณีที่ต้องการสร้างฟังก์ชันที่จำเป็นต้องมีอาร์กิวเมนต์ แต่ไม่ต้องการกำหนดจำนวนที่แน่นอน แบบนี้ควรจะใช้อาร์กิวเมนต์แบบ Sequence Unpacking Operator (ในภาษา Python จะใช้เครื่องหมาย * นำหน้าอาร์กิวเมนต์แบบนี้) ลองมาดูรูปแบบการกำหนดอาร์กิวเมนต์แบบนี้ร่วมกับฟังก์ชันตามตัวอย่างต่อไปนี้

จากตัวอย่างนี้ฟังก์ชัน shownumber จะมีเพียงแค่หนึ่งอาร์กิวเมนต์ที่ชื่อ *startendno (ซึ่งในตัวอย่างจากหัวข้อที่ 1 ซึ่งเป็นแบบ Positional Argument จะมี 2 อาร์กิวเมนต์คือ startno  endno) แต่สามารถรองรับการขยายจำนวนอาร์กิวเมนต์ที่ต้องใช้งานโดยอัตโนมัติ ตามรูป 9 แสดงการเรียกใช้ฟังก์ชันที่มีอาร์กิวเมนต์แบบขยายจำนวนตามค่าข้อมูล

ภาพที่ 7 แสดงการเรียกใช้ฟังก์ชันและผ่านค่าข้อมูลไปให้กับอาร์กิวเมนต์

ทดลองการใช้งานอาร์กิวเมนต์ตามตัวอย่างโปรแกรมต่อไปนี้
ตัวอย่างที่ 1 เปิดวินโดว์โมดูลใหม่จาก IDLE ของ Python Shell ทดลองป้อนคำสั่งต่อไปนี้

จากตัวอย่างที่ 1 แสดงการผ่านค่าตัวแปรจำนวน 3 ค่าไปยังฟังก์ชัน showitem ซึ่งภายในฟังก์ชันจะแสดงวิธีการเขียนโปรแกรมดึงค่าจากอาร์กิวเมนต์แบบขยายจำนวนตามค่าข้อมูลด้วย (Item[0], Item[1], Item[2])
ตัวอย่างที่ 2 แสดงวิธีดึงค่าจากอาร์กิวเมนต์ในฟังก์ชันด้วยคำสั่ง for

ตัวอย่างนี้แสดงการผ่านค่าจากตัวแปรต้นทางจำนวน 3 ค่า ผ่านอาร์กิวเมนต์ที่ชื่อ * item เมื่อต้องการใช้ค่าในอาร์กิวเมนต์ภายในฟังก์ชันจะใช้วิธีอ่านค่าด้วยคำสั่งวนทำซ้ำหรือคำสั่ง for เพื่ออ่านค่าที่เก็บไว้ในอาร์กิวเมนต์  * item ตั้งแต่ค่าแรกไปจนค่าสุดท้าย (ลักษณะค่าที่จัดเก็บใน * item จะมีวิธีเก็บเหมือนกับตัวแปร Collection Data ประเภท Tuple ภาพจำลองการเก็บค่าข้อมูลในอาร์กิวเมนต์เป็นดังนี้

ดังนั้นการเรียกใช้ค่าภายในอาร์กิวเมนต์จึงเรียกได้จากตำแหน่งโดยอ้างอิงหมายเลข Index ตามตัวอย่างที่ 1 หรือใช้วิธีการอ่านจากคำสั่ง for ในตัวอย่างที่ 2
ตัวอย่างที่ 3 แสดงโปรแกรมการใช้อาร์กิวเมนต์แบบ Sequence Unpacking Operator โดยผ่านตัวแปร Collection Data ประเภท Dictionary ด้วยเทคนิคการผ่านค่าข้อมูล **- Operator

ตัวอย่างที่ 3 เป็นเทคนิคการใช้ Unpacking Operator ในฝั่งค่าข้อมูลต้นทาง ให้สังเกตที่ตัวแปรต้นทาง ซึ่งปกติจะมีจำนวนตัวแปรเท่ากับจำนวนค่าข้อมูลที่ต้องการผ่านไปยังอาร์กิวเมนต์ของฟังก์ชัน แต่ในตัวอย่างนี้ตัวแปรต้นทางจะมีเพียงตัวเดียว และเป็นตัวแปรชนิด Dictionary คือมีค่าข้อมูลในตัวแปรได้มากกว่าหนึ่งค่า ในที่นี้ประกอบด้วย code : sotv42, title : sony42tv, cost : 50000 ซึ่งนับได้จำนวน 3 ค่าข้อมูล เมื่อส่งผ่านไปยังอาร์กิวเมนต์ของฟังก์ชัน ซึ่งประกอบด้วย code, title, cost (การตั้งชื่ออาร์กิวเมนต์ของฟังก์ชันเมื่อต้องใช้เทคนิคการส่งผ่านค่าจากตัวแปรต้นทางหนึ่งตัวแปรหลายค่าข้อมูล ชื่ออาร์กิวเมนต์จำเป็นต้องตั้งชื่อให้ตรงกับชื่อของคีย์ (Key) ในค่าข้อมูลต้นทางเสมอ)

จึงจะสามารถส่งผ่านข้อมูลด้วยเทคนิค Unpacking Operator ต้นทางได้ จากตัวแปร stock ซึ่งอาศัยเทคนิคการกระจายค่าข้อมูลภายในแบบ Dictionary ให้ลงพอดีกับอาร์กิวเมนต์จึงต้องระบุเครื่องหมาย ** ไว้หน้าตัวแปรต้นทาง ซึ่งจะเขียนได้เป็น **stock ร่วมกับการเรียกฟังก์ชัน showitem(**stock) เพื่อใช้งาน

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

เมื่อมีการคำนวณค่าของ Factorial ภายใต้คำสั่ง for เสร็จสิ้นแล้วจะทำการส่งค่าที่อยู่ในตัวแปร a กลับไปจุดที่เรียกใช้ฟังก์ชัน ตามตัวอย่างการเรียกใช้ฟังก์ชัน Factorial ดังนี้

resultfactorial = factorial(5)

การเรียกใช้งานฟังก์ชันที่มีการส่งค่าผลลัพธ์กลับมา จำเป็นต้องมีตัวแปรต้นทางรองรับค่าผลลัพธ์ที่ได้จากฟังก์ชัน ซึ่งในที่นี้คือตัวแปรต้นทาง resultfactorial ในทางตรงกันข้ามกับฟังก์ชันที่ไม่มีคำสั่ง return ภายในฟังก์ชัน ก็ไม่มีความจำเป็นต้องมีตัวแปรต้นทางรอรับค่า เนื่องจากฟังก์ชันนั้นๆ จะไม่ส่งค่าผลลัพธ์ใดๆ กลับออกมายังจุดที่ทำการเรียกใช้ฟังก์ชันนั่นเอง
ทดลองโปรแกรมตามตัวอย่างต่อไปนี้ สำหรับการใช้คำสั่ง return ร่วมกับฟังก์ชัน
ตัวอย่างที่ 1 เปิดวินโดว์โมดูลใหม่จาก IDLE ของ Python Shell และทดลองป้อนคำสั่งต่อไปนี้

ตัวอย่างข้างต้นเป็นโปรแกรมสำหรับคำนวณค่า Factorial และ Fibonacci โดยเลือกจากเมนูที่ต้องการคำนวณ เช่น เลือกเมนูหมายเลข 1 สำหรับคำนวณค่า Factorial โดยเรียกใช้ฟังก์ชันที่ชื่อ Factorial พร้อมส่งค่าข้อมูลผ่านอาร์กิวเมนต์ของฟังก์ชัน เข้าสู่กระบวนการคำนวณกลุ่มคำสั่งในลูปหรือคำสั่ง for จนได้คำตอบสุดท้ายที่เก็บค่าผลลัพธ์นั้น ตัวแปร a ในขั้นตอนสุดท้ายของฟังก์ชันคือการใช้คำสั่ง return ค่าในตัวแปร a กลับออกไปข้างนอกฟังก์ชัน ซึ่งจะส่งผ่านค่าข้อมูลไปยังตัวแปรต้นทางที่ชื่อ y สำหรับฟังก์ชัน Fibonacci ก็มีลักษณะการ return ผลลัพธ์เช่นเดียวกัน