อาร์กิวเมนต์และพารามิเตอร์: ความแตกต่างระหว่างอาร์กิวเมนต์และพารามิเตอร์ [พร้อมตัวอย่าง]
เผยแพร่แล้ว: 2021-02-05ฟังก์ชันในภาษาการเขียนโปรแกรมคือโค้ดส่วนหนึ่งที่เน้นที่การนำกลับมาใช้ใหม่ได้และการนำเอาสิ่งที่เป็นนามธรรมมาใช้ในแอปพลิเคชัน สิ่งเหล่านี้สามารถเรียกได้หลายครั้งในโปรแกรม ภายในหรือจากไฟล์อื่น นี่เป็นแนวคิดพื้นฐานที่นำมาใช้ในทุกภาษาการเขียนโปรแกรมและมีประโยชน์มากในขณะที่ฝึกการเรียนรู้ของเครื่องด้วย
มีบางกรณีที่เราต้องการดำเนินการขั้นตอนการประมวลผลล่วงหน้าแบบกำหนดเองซึ่งสอดคล้องกับกรณีการใช้งานเฉพาะ และอาจเป็นเรื่องยุ่งยากหากโค้ดนั้นบดบังงานสำคัญอื่นๆ ที่เกี่ยวข้องกับวิทยาศาสตร์ข้อมูล การแยกรหัสนี้และเรียกมันครั้งเดียวเพื่อดำเนินการเป็นกลุ่มเป็นแนวทางปฏิบัติทั่วไปที่ส่งเสริมการเข้ารหัสที่สะอาด
ขณะสร้างฟังก์ชัน มีอินพุตบางอย่างที่อาจใช้จากผู้ใช้เพื่อประมวลผลคำแนะนำที่อยู่ภายในฟังก์ชันนั้น อินพุตเหล่านี้มักจะสับสนระหว่างคำศัพท์สองคำ: อาร์กิวเมนต์และพารามิเตอร์ ลองดูความแตกต่างระหว่างพวกเขาและค้นหาว่าจะใช้อันไหนที่ใด
สารบัญ
พารามิเตอร์
ตัวแปรเหล่านี้เป็นตัวแปรที่ใช้ในฟังก์ชันและประกาศไว้ในส่วนหัวของฟังก์ชัน ข้อมูลจำเพาะของชนิดข้อมูลขึ้นอยู่กับภาษาการเขียนโปรแกรมที่ใช้ในคำจำกัดความของฟังก์ชัน ตัวแปรเหล่านี้ช่วยในการทำงานให้สมบูรณ์ นอกจากนี้ยังสามารถกำหนดเป็นตัวแปรท้องถิ่นเนื่องจากไม่สามารถเข้าถึงได้นอกฟังก์ชัน ค่าที่มีอยู่ในพารามิเตอร์เหล่านี้สามารถเข้าถึงได้จากคำสั่ง return ของฟังก์ชันเท่านั้น หรือถ้าขอบเขตของพารามิเตอร์เหล่านี้ถูกทำให้เป็นสากล
ข้อโต้แย้ง
ฟังก์ชันที่กำหนดสามารถเรียกได้ทุกที่ภายในไฟล์หรือในไฟล์อื่นในไดเร็กทอรีขึ้นอยู่กับกรณีการใช้งาน อาร์กิวเมนต์เป็นตัวแปรที่ส่งผ่านไปยังฟังก์ชันเพื่อดำเนินการ ซึ่งแตกต่างจากพารามิเตอร์เนื่องจากอาร์กิวเมนต์เป็นค่าจริงที่ส่งผ่านไปยังส่วนหัวของฟังก์ชัน
ค่าอาร์กิวเมนต์ถูกกำหนดให้กับพารามิเตอร์ของฟังก์ชัน ดังนั้นฟังก์ชันจึงสามารถประมวลผลพารามิเตอร์เหล่านี้สำหรับเอาต์พุตสุดท้ายได้ อาร์กิวเมนต์สามารถเข้าถึงได้ตลอดทั้งโปรแกรมขึ้นอยู่กับขอบเขตของตัวแปรที่กำหนด สิ่งเหล่านี้สามารถนำมาจากผู้ใช้ปลายทางหรือสามารถเป็นตัวแปรที่กำหนดไว้ล่วงหน้าได้
ตัวอย่างเพื่อความเข้าใจที่ดีขึ้น
อาร์กิวเมนต์และพารามิเตอร์อาจดูเหมือนใช้แทนกันได้ แต่มีความหมายต่างกันในแต่ละที่ พิจารณาตัวอย่างที่เราต้องการคำนวณพื้นที่ของสี่เหลี่ยม เราทราบดีว่าสูตรสำหรับเส้นรอบวงของสี่เหลี่ยมผืนผ้านั้นใช้ความยาวและความกว้างของรูปสี่เหลี่ยมผืนผ้า
นี่คือลักษณะของฟังก์ชันในการเขียนโปรแกรม Python:
def recPerimeter (ความยาว, ความกว้าง):
ปริมณฑล = 2*(ยาว+กว้าง)
กลับปริมณฑล
length_arg, breadth_arg = list(map(int, input().split()))
ปริมณฑล = RecPerimeter(length_arg, width_arg)
พิมพ์(ปริมณฑล)
ใน Java ฟังก์ชันเดียวกันจะอยู่ในรูปแบบของ:
นำเข้า java.util.Scanner;
ปริมณฑลระดับสาธารณะ {
คงที่สาธารณะ int recPerimeter (ความยาว int ความกว้าง int) {
เส้นรอบวง int = 2 *(ความยาว + ความกว้าง);
กลับปริมณฑล;
}
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
สแกนเนอร์ scn = สแกนเนอร์ใหม่ (System.in);

int length_arg = scn.nextInt();
int ความกว้าง_arg = scn.nextInt();
int perimeter_output = recPerimeter(length_arg, ความกว้าง_arg);
System.out.println(ปริมณฑล_เอาท์พุต);
}
}
ตามคำจำกัดความ ความยาวและความกว้างในส่วนหัวของฟังก์ชันที่กำหนดไว้ใน Python หรือ Java คือพารามิเตอร์ และ length_arg, breadth_arg ในโปรแกรมคืออาร์กิวเมนต์ สิ่งนี้ยังพิสูจน์ว่าอาร์กิวเมนต์และพารามิเตอร์ไม่เฉพาะภาษาและเป็นแนวคิดที่ใช้สำหรับคำจำกัดความของฟังก์ชัน
พารามิเตอร์ทางการเทียบกับจริง
ขณะค้นพบอาร์กิวเมนต์และพารามิเตอร์ คุณจะพบกับแนวคิดอีกชุดหนึ่ง กล่าวคือ พารามิเตอร์ที่เป็นทางการและไม่เป็นทางการ ความสับสนที่สำคัญในที่นี้อาจเป็นได้ว่าเป็นส่วนย่อยของพารามิเตอร์ แต่ไม่ใช่ พารามิเตอร์ที่เป็นทางการในที่นี้หมายถึงพารามิเตอร์ในฟังก์ชัน และพารามิเตอร์จริงหมายถึงอาร์กิวเมนต์ที่เราส่งผ่านขณะเรียกใช้ฟังก์ชัน
ชำระเงินด้วย: แนวคิดและหัวข้อโครงการ Python
บทสรุป
อาร์กิวเมนต์และพารามิเตอร์ใช้ในภาษาการเขียนโปรแกรมทุกประเภท คำศัพท์เหล่านี้อาจสร้างความสับสนได้เมื่ออ้างถึงแหล่งข้อมูลใดๆ และแนะนำให้ทำความเข้าใจสิ่งเหล่านี้อย่างชัดเจน อินพุตของฟังก์ชันเป็นแอปพลิเคชันทั่วไปของสัญลักษณ์เหล่านี้
หากคุณอยากเรียนรู้เกี่ยวกับวิทยาศาสตร์ข้อมูล ลองดูโปรแกรม Executive PG ของ IIIT-B & upGrad ใน Data Science ซึ่งสร้างขึ้นสำหรับมืออาชีพที่ทำงานและมีกรณีศึกษาและโครงการมากกว่า 10 รายการ เวิร์กช็อปภาคปฏิบัติจริง การให้คำปรึกษากับผู้เชี่ยวชาญในอุตสาหกรรม 1 -on-1 พร้อมที่ปรึกษาในอุตสาหกรรม การเรียนรู้มากกว่า 400 ชั่วโมงและความช่วยเหลือด้านงานกับบริษัทชั้นนำ
อะไรคือความแตกต่างที่สำคัญระหว่างพารามิเตอร์และอาร์กิวเมนต์?
พารามิเตอร์ -
1. สิ่งเหล่านี้ถูกระบุในระหว่างการกำหนดฟังก์ชันและเรียกว่าพารามิเตอร์
2. พวกมันเรียกอีกอย่างว่าพารามิเตอร์ที่เป็นทางการ
3. ค่าที่ส่งผ่านเป็นพารามิเตอร์คือตัวแปรโลคัลและกำหนดค่าของอาร์กิวเมนต์ระหว่างการเรียกใช้ฟังก์ชัน
อาร์กิวเมนต์ -
1. ค่าที่ส่งผ่านระหว่างการเรียกใช้ฟังก์ชันเรียกว่าอาร์กิวเมนต์
2. สิ่งเหล่านี้เรียกว่าพารามิเตอร์จริง
3. ทุกอาร์กิวเมนต์ถูกกำหนดให้กับพารามิเตอร์เมื่อมีการกำหนดฟังก์ชัน
สามารถใช้อาร์กิวเมนต์และพารามิเตอร์แทนกันได้หรือไม่
พิจารณาโปรแกรมต่อไปนี้เพื่อทำความเข้าใจความแตกต่างระหว่างพารามิเตอร์และอาร์กิวเมนต์
สมมติว่าคุณมีนิยามฟังก์ชัน "myFunc" โดยมี num1 และ num2 เป็นพารามิเตอร์ และฟังก์ชันนี้จะคืนค่าผลรวมของค่าที่ส่งผ่านในพารามิเตอร์ ตอนนี้ คุณต้องการเรียกใช้ฟังก์ชันนี้ภายในฟังก์ชันหลักด้วยค่าที่แตกต่างกันสองค่าที่จะเพิ่ม ค่าที่คุณส่งผ่านระหว่างการเรียกใช้ฟังก์ชันจะเรียกว่าอาร์กิวเมนต์ของฟังก์ชัน
ในตัวอย่างข้างต้น เราจะเห็นความแตกต่างระหว่างพารามิเตอร์และอาร์กิวเมนต์ได้อย่างชัดเจน ตัวแปร “num1” และ “num2” เมื่อระบุในนิยามฟังก์ชันเป็นพารามิเตอร์ และเมื่อตัวแปรเหล่านี้ถูกส่งไปยังฟังก์ชันในระหว่างการเรียกใช้ฟังก์ชัน ตัวแปรเหล่านี้เป็นอาร์กิวเมนต์ของฟังก์ชัน "myFunc"
อาร์กิวเมนต์ของฟังก์ชันมีกี่ประเภทใน Python
ใน Python ฟังก์ชันสามารถรับอาร์กิวเมนต์ได้ 3 ประเภทตามที่อธิบายไว้ด้านล่าง:
1. อาร์กิวเมนต์เริ่มต้น: อาร์กิวเมนต์ เหล่านี้เป็นอาร์กิวเมนต์ที่กำหนดให้กับพารามิเตอร์ในขณะที่กำหนดฟังก์ชัน ตัวดำเนินการมอบหมาย "=" ใช้เพื่อกำหนดค่าเริ่มต้น (หรืออาร์กิวเมนต์เริ่มต้น) ให้กับพารามิเตอร์ของฟังก์ชัน ตัวอย่างเช่น: def display (ผลลัพธ์ = 10)
2. อาร์กิวเมนต์ของ คีย์เวิร์ด: อาร์กิวเมนต์ เหล่านี้ถูกส่งผ่านโดยการระบุคีย์เวิร์ดหรือชื่อ เนื่องจากคีย์เวิร์ดถูกส่งโดยสอดคล้องกับค่าอาร์กิวเมนต์ ลำดับของอาร์กิวเมนต์จึงไม่สำคัญ
3. อาร์กิวเมนต์ตามอำเภอใจ: ตามชื่อที่แนะนำ ฟังก์ชันที่ยอมรับอาร์กิวเมนต์ตามอำเภอใจสามารถยอมรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ เครื่องหมายดอกจัน “*” ใช้ในนิยามฟังก์ชันเพื่อระบุว่าฟังก์ชันควรใช้อาร์กิวเมนต์ตามอำเภอใจ