ตัวแปรเป็นแนวคิดที่สำคัญและแพร่หลายในการเขียนโปรแกรม ตัวแปรคือคอนเทนเนอร์สำหรับจัดเก็บข้อมูล ตัวแปรสามารถจัดเก็บข้อมูลได้หลายประเภท รวมทั้งชื่อผู้ใช้ ที่อยู่อีเมล และรายการในคลังเกมออนไลน์ของผู้ใช้
เมื่อเขียนโปรแกรมใน Python คุณจะพบกับตัวแปรสองประเภท:global และ local ในคู่มือนี้ เราจะพูดถึงความแตกต่างระหว่างตัวแปรทั้งสองประเภทนี้ วิธีทำงาน และวิธีการใช้ตัวแปรเหล่านี้ในโค้ดของคุณ
ตัวแปรหลาม
ใน Python ตัวแปรจะช่วยให้คุณสามารถติดป้ายกำกับและจัดเก็บข้อมูลได้ เมื่อกำหนดตัวแปร คุณจะตั้งชื่อให้กับตัวแปรนั้น จากนั้นคุณสามารถใช้ชื่อนั้นในภายหลังในโค้ดของคุณเพื่อดึงข้อมูลที่เป็นตัวแทน ตัวแปรสามารถเก็บสตริง ตัวเลข รายการ หรือประเภทข้อมูลอื่นๆ
สมมติว่าเรากำลังสร้างเกมและต้องการเก็บชื่อผู้ใช้ แทนที่จะต้องพิมพ์ชื่อตลอดทั้งโปรแกรม เราสามารถใช้ตัวแปรเพื่อจัดเก็บได้
นี่คือตัวแปรที่เก็บชื่อผู้ใช้สำหรับเกม:
name = "Carlton Hernandez"
เราประกาศตัวแปรชื่อ name และกำหนดค่าเป็น "Carlton Hernandez"
เมื่อเราประกาศตัวแปรนั้นแล้ว เราก็สามารถจัดการมันในโค้ดของเราได้ ตัวอย่างเช่น หากเราต้องการเปลี่ยนชื่อผู้ใช้ เราสามารถทำได้โดยใช้รหัสนี้:
name = "Carlton Hernandez" name = "Carlton Lewis Hernandez"
ในบรรทัดแรกของโค้ด เรากำหนดค่า "Carlton Hernandez" ให้กับ name ตัวแปร. จากนั้น เรากำหนดค่า “Carlton Lewis Hernandez” ให้กับ name ตัวแปร. เมื่อคุณกำหนดค่าใหม่ให้กับตัวแปร โปรแกรมจะเขียนทับค่าล่าสุด โดยแทนที่ด้วยค่าใหม่
81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้
ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก
ตัวแปรส่วนกลางของ Python
ใน Python มีตัวแปรหลักสองประเภท:โลคัลและโกลบอล
ตัวแปรส่วนกลางคือตัวแปรที่ประกาศนอกฟังก์ชัน ตัวแปรโกลบอลมีขอบเขตทั่วโลก ซึ่งหมายความว่าสามารถเข้าถึงได้ตลอดทั้งโปรแกรม รวมทั้งภายในฟังก์ชันต่างๆ พิจารณาการแสดงแนวคิดนี้ด้วยภาพต่อไปนี้
ตัวแปรทั่วโลกและท้องถิ่นใน Python
ตัวแปรทั่วโลก สามารถเข้าถึงได้ตลอดทั้งโปรแกรม
นี่คือตัวอย่างตัวแปรส่วนกลางใน Python:
name = "Carlton Hernandez"
เมื่อเราประกาศตัวแปรโกลบอล เราก็สามารถใช้มันได้ตลอดทั้งโค้ดของเรา ตัวอย่างเช่น เราสามารถสร้างฟังก์ชันที่พิมพ์ค่าของตัวแปรส่วนกลาง name โดยใช้รหัสต่อไปนี้:
def printName(): print(name) printName()
รหัสของเราส่งคืน:
"Carlton Hernandez"
ที่นี่ เราเริ่มต้นฟังก์ชันที่เรียกว่า printName() . เมื่อเรียกใช้ฟังก์ชันนี้ จะพิมพ์ค่าของ name ตัวแปรไปยังคอนโซล นี่คือสิ่งที่เกิดขึ้นข้างต้นเมื่อเราเรียกใช้ฟังก์ชัน
ตัวแปรท้องถิ่นของ Python
ในทางกลับกัน ตัวแปรโลคัลเป็นตัวแปรที่ประกาศภายในฟังก์ชัน ตัวแปรเหล่านี้ทราบว่ามี local scope . ซึ่งหมายความว่าสามารถเข้าถึงได้เฉพาะภายในฟังก์ชันที่มีการประกาศเท่านั้น ลองพิจารณาการแสดงภาพที่เราได้แสดงไว้ก่อนหน้านี้อีกครั้ง ซึ่งแสดงให้เห็นแนวคิดของตัวแปรใน Python:
ตัวแปรทั่วโลกและตัวแปรท้องถิ่น
ตัวแปรท้องถิ่น สามารถเข้าถึงได้ภายในฟังก์ชันเฉพาะเท่านั้น
ต่อไปนี้คือตัวอย่างโปรแกรมที่ใช้ตัวแปรภายในเครื่อง:
def printName(): name = "Georgia Anderson" print(name) printName()
รหัสของเราส่งคืน:
"Georgia Anderson"
ในโค้ดของเรา เราได้ประกาศฟังก์ชันชื่อ printName() . ภายในฟังก์ชันนั้น เราได้กำหนดตัวแปรชื่อ name . เนื่องจากเราประกาศตัวแปรนี้ภายในฟังก์ชัน จึงเป็นตัวแปรท้องถิ่น
ในตอนท้ายของโค้ด เราเรียกใช้ฟังก์ชันของเราโดยใช้ printName() . ในการตอบสนอง โปรแกรมได้รัน printName() การทำงาน.
name ตัวแปรในตัวอย่างนี้อยู่ในเครื่องของ printName() การทำงาน. ดังนั้นเราจึงไม่สามารถเข้าถึงตัวแปรนั้นนอกฟังก์ชันของเราได้ นี่คือสิ่งที่จะเกิดขึ้นเมื่อเราพยายามพิมพ์ name ตัวแปรนอกฟังก์ชันที่มีการประกาศ:
def printName(): name = "Georgia Anderson" print(name) printName() print(name)
รหัสของเราส่งคืน:
NameError: name 'name' is not defined
เราไม่สามารถเข้าถึงตัวแปรท้องถิ่นนอกฟังก์ชันที่เรากำหนดตัวแปรนั้นได้ เมื่อเราพยายามเข้าถึงตัวแปรท้องถิ่นในโปรแกรมหลักของเรา โปรแกรมจะส่งคืนข้อผิดพลาด
การใช้ตัวแปรส่วนกลางและภายในเครื่อง
เป็นไปได้ที่โปรแกรมจะใช้ชื่อตัวแปรเดียวกันสำหรับทั้งตัวแปรภายในเครื่องและตัวแปรส่วนกลาง ในสถานการณ์ดังกล่าว ตัวแปรโลคัลจะถูกอ่านในขอบเขตโลคัล และตัวแปรส่วนกลางจะถูกอ่านในขอบเขตส่วนกลาง
ต่อไปนี้คือตัวอย่างโปรแกรมที่มีตัวแปรในเครื่องและตัวแปรส่วนกลางที่มีชื่อเหมือนกัน:
score = 5
def calculateScore():
score = 10
print("Final Score:", score)
calculateScore()
print("Initial Score:", score) รหัสของเราส่งคืน:
Final Score: 10 Initial Score: 5
อันดับแรก เรากำหนดตัวแปรส่วนกลาง score ในรหัสของเรา จากนั้นใน calculateScore() . ของเรา ฟังก์ชัน เราสร้างตัวแปรท้องถิ่นที่มีชื่อเดียวกัน
ค่าของ scoreในพื้นที่ของเรา ตัวแปรใน calculateScore() ฟังก์ชันคือ 10 ดังนั้น เมื่อเราเรียก calculateScore() ฟังก์ชั่นข้อความ Final Score: 10 ถูกพิมพ์ไปที่คอนโซล
อย่างไรก็ตาม นอก calculateScore() . ของเรา ฟังก์ชัน ค่าของ score ตัวแปรคือ 5 เนื่องจากเราตั้งค่า score ตัวแปรในขอบเขตโกลบอลถึง 5 ดังนั้นเมื่อเราพิมพ์ Initial Score: ตามด้วยค่าของ score ตัวแปร โปรแกรมจะแสดงค่า 5
การกำหนดตัวแปรร่วมภายในฟังก์ชัน
ในส่วนข้างต้น เราได้เรียนรู้ว่าตัวแปรส่วนกลางถูกกำหนดไว้ภายนอกฟังก์ชัน (เช่น ทั่วโลก) และตัวแปรภายในถูกกำหนดไว้ภายในฟังก์ชัน (เช่น ในเครื่อง) อย่างไรก็ตาม หากคุณใช้ global คีย์เวิร์ดเพื่อกำหนดตัวแปรภายในฟังก์ชัน (เช่น ในเครื่อง) แล้วเรียกใช้ฟังก์ชันนั้นในโปรแกรม (ทั่วโลก) ตัวแปรนั้นจะกลายเป็นตัวแปรส่วนกลาง
ลองพิจารณาตัวอย่างต่อไปนี้:
def setName(): global name name = "Bianca Peterson" setName() print(name)
รหัสของเราส่งคืน:
"Bianca Peterson"
ในโค้ดของเรา เราได้กำหนดค่า name ตัวแปรในเครื่องภายใน setName() การทำงาน. อย่างไรก็ตาม เนื่องจากเราใช้ global keyword ก่อนกำหนดตัวแปรนี้ เราจึงเตรียมที่จะให้ name ขอบเขตทั่วโลกที่แปรผัน อย่างไรก็ตาม name ตัวแปรจะกลายเป็นตัวแปรส่วนกลางเพียง หลังจาก เราเรียกใช้ฟังก์ชันนี้ในโปรแกรม
หลังจากที่โปรแกรมรัน setName() ฟังก์ชั่นทุกครั้งที่เราใช้ name ในโปรแกรมของเรา เหมือนกับตอนที่เรารัน print() ฟังก์ชั่นโปรแกรมจะใช้ค่าที่เราประกาศในฟังก์ชันท้องถิ่น ทั้งนี้เป็นเพราะว่า name ตัวแปรเป็นตัวแปรส่วนกลางแล้ว
จำได้ไหมว่าก่อนหน้านี้เราพูดว่าไม่สามารถโดยตรง เปลี่ยนตัวแปรส่วนกลางภายในฟังก์ชัน? นั่นเป็นความจริง. อย่างไรก็ตาม คุณสามารถใช้คำสำคัญสากลเพื่อเปลี่ยนตัวแปรร่วมภายในฟังก์ชันทางอ้อมได้
ต่อไปนี้คือตัวอย่างโปรแกรมที่ใช้คำสำคัญสากลในฟังก์ชันเพื่อเปลี่ยนค่าของตัวแปรส่วนกลาง:
name = "Bianca Peterson" def setName(): global name name = "Bianca Lucinda Peterson" setName() print(name)
รหัสของเราส่งคืน:
"Bianca Lucinda Peterson"
มาทำลายรหัสนี้กัน ขั้นแรก เราประกาศตัวแปรชื่อ name และกำหนดค่าเป็น “Bianca Peterson” นี่คือตัวแปรส่วนกลาง จากนั้นเราก็ประกาศฟังก์ชันชื่อ setName() . เมื่อถูกเรียก setName() ฟังก์ชั่นเปลี่ยนค่าของ name ตัวแปร.
เราก็เรียก setName() ฟังก์ชันซึ่งเปลี่ยนค่าของ name สู่ “บิอันกา ลูซินดา ปีเตอร์สัน” สุดท้ายเราพิมพ์ค่าของ name ไปที่คอนโซล ค่าของตัวแปรส่วนกลาง name คือตอนนี้ "Bianca Lucinda Peterson"
โดยทั่วไป คำหลักสากลควรใช้เท่าที่จำเป็น การใช้คำหลักสากลบ่อยเกินไปอาจทำให้เข้าใจขอบเขตของตัวแปรในโปรแกรมได้ยาก
บทสรุป
ตัวแปรโกลบอลคือตัวแปรที่ประกาศนอกฟังก์ชัน ตัวแปรท้องถิ่นเป็นตัวแปรที่ประกาศภายในฟังก์ชัน
แม้ว่าตัวแปรส่วนกลางจะไม่สามารถเปลี่ยนแปลงได้โดยตรงในฟังก์ชัน แต่คุณสามารถใช้คีย์เวิร์ดส่วนกลางเพื่อสร้างฟังก์ชันที่จะเปลี่ยนค่าของตัวแปรส่วนกลางได้ ในกรณีนี้ ค่าของตัวแปรส่วนกลางจะไม่เปลี่ยนแปลงจนกว่าคุณจะเรียกใช้ฟังก์ชันนั้น
บทช่วยสอนนี้กล่าวถึงโดยอ้างอิงถึงตัวอย่าง พื้นฐานของตัวแปรท้องถิ่นและตัวแปรส่วนกลาง และวิธีการทำงาน ตอนนี้คุณพร้อมที่จะเริ่มใช้ตัวแปรในเครื่องและตัวแปรระดับโลกในโค้ด Python ของคุณอย่างโปรแกรมเมอร์มืออาชีพแล้ว!
