ใน MicroPython การตั้งค่าตัวแปรก็เหมือนกับการให้ชื่อกับสิ่งของที่เราต้องการเก็บไว้และใช้ในภายหลัง ลองนึกว่ามีกล่องใส่ของหลายใบ เขียนชื่อบนกล่องแต่ละใบ เพื่อจะได้รู้ว่าข้างในมีอะไร และ สามารถเปิดกล่องนั้นขึ้นมาใช้เมื่อไหร่ก็ได้

สร้างกล่องหรือตัวแปรชื่อ number แล้วใส่ค่าเป็นตัวเลข 123 โดยใช้คำสั่ง number = 123 เพียงคำสั่งเดียว ไม่ต้องกำหนดล่วงหน้าก่อนว่ากล่องนี้ใช้เก็บอะไร สร้างขึ้นแล้วเก็บเลย ทำนองเดียวกัน name = ‘micropython’ ก็จะสร้างกล่องหรือตัวแปรชื่อ name แล้วเก็บคำข้อความหรือชุดของตัวอักษรที่เขียนเรียงต่อกัน เช่น คำพูด ชื่อ หรือประโยคที่ใช้ในชีวิตประจำวัน เรียกว่าเป็นสตริง (string) สังเกตว่าจะต้องอยู่ในเครื่องหมายอัญประกาศหรือเครื่องหมายคำพูด ซึ่งเป็นได้ทั้งแบบเดี่ยว คือ ‘ ’ และแบบคู่ “ ”

ตัวแปรหรือกล่อง เมื่อสร้างขึ้นแล้ว จะเปลี่ยนแปลงค่าภายในก็ใช้วิธีแทนที่ในทันที เช่น หากเดิม number มีค่าเป็นตัวเลขสิบ สามารถเปลี่ยนค่าเป็นตัวเลข 20 ได้โดยใช้คำสั่ง number = 20 หรือหากต้องการเปลี่ยนค่าเป็นข้อความ แม้เดิมจะเป็นตัวเลขก็สามารถใช้คำสั่ง number = ‘hello’ ซึ่งจะเปลี่ยนค่าในกล่องชื่อ number ให้กลายเป็นคำ hello สำหรับภาษาไพทอน กล่องเมื่อถูกสร้างขึ้นมาแล้วเก็บค่าข้อมูลชนิดหนึ่งแล้ว ก็ไม่ได้ถูกกำหนดตายตัวว่าค่าในกล่องจะต้องเป็นชนิดนั้นประเภทนั้นเสมอไป เพราะค่าที่จะจัดเก็บไว้ในตัวแปร

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

ตัวอย่างเช่นด้วยคำสั่ง number = 123 ไพทอนจะทำการจัดสรรพื้นที่ในหน่วยความจำให้กับวัตถุชนิดตัวเลข (integer) ที่มีค่า 123 ขึ้นมา (ถือเป็นการสร้างวัตถุ 123 ขึ้นมาในความทรงจำนั่นเอง) จากนั้นไพทอนก็จะสร้างป้ายชื่อ (หรือคือตัวแปร) และทำให้มันชี้ไปยังพื้นที่ในหน่วยความจำที่ถือเป็นวัตถุ 123

ไพทอนอาศัยกระบวนการ Memory management ในการจัดสรรและจัดการการใช้หน่วยความจำของโปรแกรม ตัวแปรในไพทอน ไม่ได้เป็นการ “ประกาศ” การมีตัวตนเหมือนอย่างในภาษาซี แต่เป็นการ “มอบค่า” ให้แก่ตัวแปร ซึ่ง ไพทอนจะจัดการประเภทของตัวแปร (เช่น int, float, str) และการจัดสรรหน่วยความจำให้โดยอัตโนมัติ เหตุที่ต้องมีการจัดการประเภทของตัวแปร (data type management) เพราะการรู้ชนิดของข้อมูลที่ตัวแปรเก็บไว้นั้น สามารถช่วยให้การ คำนวณ การประมวลผล และการทำงานของโปรแกรมมิเพียงถูกต้อง ยังทำให้มีประสิทธิภาพมากยิ่งขึ้น การใช้ประเภทข้อมูลที่ไม่เหมาะสมเช่น พยายามที่จะรวมข้อมูลที่เป็นตัวเลขจำนวนเต็ม (integer) กับสตริง (string) ที่เป็นข้อความหรือตัวอักษรจะเกิดข้อผิดพลาดขึ้น คำสั่งรวมข้อมูล “10” ซึ่งเป็นสตริง กับ ตัวเลข 5 ไม่สามารถนำมารวมกันได้ แต่หากรวม “10” กับ “5” จะรวมกันได้เป็น “105” ที่เป็นสตริง ไม่ใช่ตัวเลข การรวมตัวเลขที่เป็นจำนวนเต็มกับตัวเลขทศนิยม สามารถกระทำได้

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

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

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

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

เมื่อฟังก์ชันทำงานเสร็จ อาจ ส่งค่ากลับ (return value) เพื่อให้โปรแกรมนำผลลัพธ์ไปใช้งานต่อ หรือไม่ส่งค่ากลับเลยก็ได้ ขึ้นอยู่กับการออกแบบ

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

id() เป็นฟังก์ชันสำหรับการค้นหาว่าวัตถุนั้นอยู่ที่ใดหรือมีหมายเลขฉพาะตัวไม่ซ้ำกับอื่นใดเลย ฟังก์ชันนี้จะค้นหา หมายเลขเอกลักษณ์ (identity) ของวัตถุที่อ้างถึงในหน่วยความจำ หมายเลขที่จะติดตัวไม่เปลี่ยนแปลงไปตลอดช่วงชีวิตของวัตถุนั้น หากกำหนด number = 123 ใช้คำสั่ง print(id(number)) ค่า id ของวัตถุที่ x ชี้ไปก็จะถูกพิมพ์ออกมา หมายเลขเอกลักษณ์นี้ไม่ใช่ตำแหน่งที่แท้จริงในหน่วยความจำ เป็นแต่เพียงค่าอ้างอิงที่ไพทอนสร้างขึ้นมาเพื่อใช้ติดตามการมีอยู่ของวัตถุในหน่วยความจำ ไพทอนยึดวัตถุเป็นสำคัญตัวแปรใดที่ต้องการใช้ค่าของวัตถุนั้น ก็เพียงสร้างป้ายระบุด้วยชื่อของตัวแปร แล้วก็ชี้ไปยังวัตถุที่มีค่าตามที่ต้องการ หมายความว่าเมื่อวัตถุถูกสร้างขึ้นมาโดยมีป้ายชี้กำกับว่าเป็นตัวแปรใด เวลาผ่านไปอาจจะมีป้ายอื่น ๆ ระบุชื่อตัวแปรเป็นอย่างอื่น ก็สามารถชี้มายังวัตถุนี้ เอาค่าของวัตถุนี้ไปใช้งานได้ กล่าวคือตัวแปรใด ๆ ที่มีค่าเหมือนกัน ก็จะมี id หรือหมายเลขเอกลักษณ์เดียวกัน คำว่าเอกลักษณ์หนึ่งเดียวต่างจากผู้อื่นจึงเป็นของตัววัตถุ ไม่ใช่ตัวแปร

ไพทอนอาศัยกลไกของการนับจำนวนอ้างอิง (Reference Counting) บันทึกจำนวนการอ้างอิง หรือคือจำนวน “ป้ายชี้” ไปยังวัตถุนั้น วัตถุซึ่งเริ่มต้นนับหนึ่งของจำนวนป้ายชี้ในยามที่มีตัวแปรถูกกำหนดชี้ไปยังวัตถุซึ่งไม่ปรากฏมีก่อนหน้านั้น ครั้นเมื่อมีตัวแปรอื่นใด ก่อเกิดหรือปรับเปลี่ยนป้ายชี้มายังวัตถุนั้น การนับจำนวนอ้างอิงก็จะเพิ่มขึ้น เพราะตัวแปรในไพทอนสามารถลบทิ้งได้ หากตัวแปรถูกลบหายไป ป้ายชี้ก็จะสูญหายไป จำนวนป้ายชี้ก็จะลดลงไปหนึ่ง หรือคราวตัวแปรที่เคยชี้มายังวัตถุนี้ แปรเปลี่ยนไปชี้วัตถุอื่น จำนวนการอ้างอิงนี้ก็จะลดไปหนึ่งเช่นเดียวกัน เมื่อจำนวนการอ้างอิงเป็นศูนย์หมายความว่าป้ายชี้สูญหายไปจนสิ้น ไร้การอ้างอิงใดหลงเหลือเลย ย่อมหมายความว่าไม่มีการใช้งานวัตถุนั้นอีกต่อไป

“ที่เคยมีมากมาย ยามเปลี่ยนเป็นดับสูญ สิ้นแล้วซึ่งเหลียวแลอ้างอิง

อย่างนั้นแล้ว ใช่สมควรยึดถือเป็นขยะ ลงมือกำจัดทิ้งโดยพลัน หรือไม่

หากเชื่อว่า เมื่อครั้งหนึ่งเคยมี คราวหนึ่งเคยสำคัญ

อย่างนั้นแล้ว ใช่สมควรยั้งมือไว้ไมตรี ให้มีตัวตนอยู่ยืดยาวอีก

หากเชื่อคำ ประวัติศาสตร์ย่อมซ้ำรอยเดิม

คงเวลา คืนสภาพ ไว้หลายชั่วยาม จักเห็นควรหรือไม่ ”

คล้ายว่าไพทอนจักมีความคิดเยี่ยงนี้ จึงได้ออกแบบกลไกขึ้นมาสองอย่างเกี่ยวกับการจัดการวัตถุเพื่อเพิ่มประสิทธิภาพและลดการใช้งานหน่วยความจำ หนึ่งคือ object interning อีกหนึ่งคือ object caching โดยทั้งสองกลไกนี้มุ่งเน้นไปที่การนำวัตถุที่ใช้บ่อยหรือมีค่าเหมือนกันกลับมาใช้งานซ้ำ แทนที่จะสร้างวัตถุใหม่ทุกครั้ง ซึ่งช่วยลดภาระการประมวลผลและการจัดการหน่วยความจำของโปรแกรม

สำหรับ object interning เป็นกระบวนการที่ Python เลือกเก็บวัตถุบางประเภทไว้ในหน่วยความจำเพื่อให้สามารถอ้างอิงและใช้งานซ้ำได้ เช่น สตริงที่เป็น literal หรือค่าคงที่ เช่น “hello”, “123” หรือ “a” ซึ่ง Python จะเก็บไว้ในพื้นที่ที่เรียกว่า string interning pool และเมื่อโปรแกรมต้องการใช้งานค่าที่มีปรากฏอยู่ในแอ่งสตริงนี้ ไพทอนจะอ้างอิงวัตถุเดิมแทนการสร้างใหม่ วิธีนี้นอกจากจะลดการใช้หน่วยความจำแล้วยังช่วยเพิ่มความเร็วในการเปรียบเทียบสตริง เพราะสามารถเปรียบเทียบหมายเลขอ้างอิง (memory address) แทนการเปรียบเทียบตัวอักษรทีละตัว อย่างไรก็ตาม ไพทอนจะ intern เฉพาะสตริงที่คาดว่าจะถูกใช้งานซ้ำบ่อย เช่น สตริง literal ที่ปรากฏในโปรแกรม หรือชื่อของตัวแปร ฟังก์ชัน และโมดูลที่ใช้ในระดับเขตระดับ global แต่สำหรับสตริงที่สร้างจากการดำเนินการ เช่น “py” + “thon” หรือสตริงที่ได้จากอินพุตภายนอก ไพทอนจะไม่ทำการ intern โดยอัตโนมัติ เนื่องจากไม่สามารถคาดเดาได้ว่าจะถูกใช้งานซ้ำหรือไม่

ในส่วนของ object caching เป็นแนวทางที่ ไพทอนใช้เก็บวัตถุที่มีค่าซ้ำๆ หรือมักถูกสร้างขึ้นบ่อยไว้ในหน่วยความจำเพื่อให้นำกลับมาใช้ได้ทันที ตัวอย่างที่เด่นชัดคือค่าตัวเลข int ขนาดเล็กในช่วง -5 ถึง 256 ซึ่ง Python สร้างไว้ล่วงหน้าและเก็บใน cache ทำให้ตัวเลขในช่วงนี้ทุกครั้งที่ถูกอ้างอิงจะชี้ไปยังวัตถุเดียวกันในหน่วยความจำ แทนที่จะสร้างใหม่ เช่น หากโปรแกรมใช้ตัวเลข 100 หลายจุด ทุกจุดจะใช้วัตถุเดียวกัน นอกจากนี้ สตริง literal บางประเภท เช่น “world” ก็อาจถูก cache ด้วยกลไกที่คล้ายกัน อย่างไรก็ตาม object caching มักใช้กับวัตถุที่เป็นแบบเปลี่ยนค่าไม่ได้ (immutable) เช่น ตัวเลขและสตริงเท่านั้น เพราะหากเป็นวัตถุที่เปลี่ยนแปลงค่าได้ (mutable objects) การแชร์วัตถุเดียวกันอาจทำให้เกิดข้อผิดพลาด

ทั้ง object interning และ object caching เป็นกลไกที่ Python ใช้เพื่อเพิ่มประสิทธิภาพโดยลดการสร้างวัตถุซ้ำซ้อน การใช้งานหน่วยความจำที่เหมาะสมและการประมวลผลที่รวดเร็วขึ้นทำให้โปรแกรมมีประสิทธิภาพและตอบสนองได้ดีมากยิ่งขึ้น

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

type() ใช้ตรวจสอบประเภทของวัตถุ เช่น การบอกว่าเป็นตัวเลข สตริง หรือลิสต์เป็นต้น ช่วยให้เรารับรู้ข้อมูลเบื้องต้นเกี่ยวกับตัวแปรหรือค่าที่กำลังทำงานด้วย

callable() สามารถตรวจสอบได้ว่าวัตถุเป็นประเภทที่ระบุหรือไม่ เหมาะสำหรับการตรวจสอบเงื่อนไขในโค้ดที่ต้องรองรับหลายประเภทของข้อมูล

hash() ใช้ในการคำนวณ ค่าฮาช (hash value) ของวัตถุ ซึ่งสามารถเปรียบเสมือนเป็นการสร้าง “ลายนิ้วมือ” สำหรับข้อมูลนั้นๆ ค่าฮาชที่ได้จะเป็นตัวแทนของข้อมูลนั้นนั้นโดยเฉพาะ สำหรับวัตถุแบบที่ไม่สามารถเปลี่ยนแปลงได้ เช่น str, int, หรือ tuple ค่าฮาชนี้จะถูกใช้เพื่อทำให้การค้นหาข้อมูลในโครงสร้างข้อมูลอย่าง dictionary หรือ set มีประสิทธิภาพมากขึ้น

hex(id()) ใช้สำหรับการแสดงค่าหมายเลขอ้างอิงของวัตถุในรูปแบบที่อ่านง่ายขึ้น สามารถใช้ เพื่อแปลงค่าที่อยู่ในหน่วยความจำเป็นเลขฐานสิบหก

repr() เป็นฟังก์ชันที่ใช้เพื่อคืนค่าข้อความตัวแทน (string representation) ของวัตถุ เพื่อให้ข้อมูลเกี่ยวกับวัตถุในเชิงเทคนิคที่ช่วยในการ ดีบัก (debugging) หรือ ตรวจสอบ (inspection) วัตถุนั้นๆ เช่น แสดงสตริงพร้อมเครื่องหมายอัญประกาศ หรือข้อมูลในรูปแบบทางการ ช่วยให้นักพัฒนาเข้าใจวัตถุในลักษณะที่ “อ่านได้” และ “สมบูรณ์” มากขึ้น

callable() ใช้เพื่อตรวจสอบว่าวัตถุที่กำหนดให้เป็น “เรียกใช้งานได้” หรือไม่ เรียกใช้งานได้ หมายถึงวัตถุนั้นสามารถใช้เรียกได้เหมือนเป็นฟังก์ชันอย่างหนึ่ง (หมายถึงสามารถเรียกใช้งานได้เหมือนฟังก์ชัน) โดยจะคืนค่าเป็น โดยจะคืนค่า True หากวัตถุนั้นสามารถเรียกใช้งานได้ และ False หากไม่สามารถเรียกใช้งานได้

ฟังก์ชัน locals() และ globals() เป็นเครื่องมือที่ช่วยให้สามารถเข้าถึงตัวแปรและค่าของตัวแปรในขอบเขตที่แตกต่างกันของโปรแกรม โดย locals() จะคืนค่า (return) ค่าตัวแปรทั้งหมดใน local scope หรือ scope ปัจจุบันที่กำลังทำงาน เช่น ถ้าเรียกในฟังก์ชัน ก็จะได้รายการตัวแปรทั้งหมดในฟังก์ชันนั้น แต่ถ้าเรียกนอกฟังก์ชัน (ใน global scope) มันจะทำงานเหมือน globals() ซึ่งให้รายการตัวแปรทั้งหมดที่อยู่ในระดับ global

ความต่างคือ locals() มุ่งเน้นตัวแปรในขอบเขตที่กำลังทำงานอยู่ ส่วน globals() เข้าถึงเฉพาะตัวแปรระดับ global การเปลี่ยนแปลงค่าของตัวแปรผ่าน locals() มักจะไม่ส่งผลต่อค่าจริงในฟังก์ชัน แต่การเปลี่ยนผ่าน globals() จะเปลี่ยนค่าของตัวแปรใน global scope ทันที

ทั้งสองฟังก์ชันนี้มีประโยชน์มากในการตรวจสอบตัวแปรในโค้ด หรือใช้สร้างและจัดการตัวแปรแบบไดนามิก แต่ต้องใช้อย่างระมัดระวัง เพราะการปรับเปลี่ยนตัวแปรโดยตรงอาจทำให้เกิดปัญหาในโปรแกรมได้

วิธีการใช้งานหน่วยความจำของไพทอน ทำให้เกิดสถานการณ์ที่หน่วยความจำที่เคยถูกใช้งานโดยวัตถุหรือข้อมูลในโปรแกรม กลับไม่ได้ถูกอ้างอิง (referenced) จากตัวแปรใดๆ อีกต่อไป เมื่อไม่มีตัวแปรหรือวัตถุใดอ้างถึงหน่วยความจำนั้นแล้ว ก็ถือว่าข้อมูลนั้นกลายเป็น “ขยะ” (garbage) และสามารถถูกลบออกจากหน่วยความจำได้ เพื่อเพิ่มประสิทธิภาพของโปรแกรมและลดการใช้ทรัพยากรที่ไม่จำเป็น ไพทอนจึงมีระบบเก็บรวบรวมขยะ (gabage collector) เพื่อจัดการและลบ garbage ออกจากหน่วยความจำโดยอัตโนมัติ

ไพทอนที่ใช้ในอุปกรณ์ที่มีหน่วยความจำอันจำกัด เช่น Raspberry Pi Pico มีตัวอย่างฟังก์ชันในการรวบรวมและกำจัดขยะได้แก่ gc.mem_free(): แสดงหน่วยความจำที่ว่างอยู่ในระบบ gc.collect(): บังคับให้ garbage collector ทำงานเพื่อล้างวัตถุที่ไม่ถูกใช้งานและ gc.mem_alloc(): แสดงหน่วยความจำทั้งหมดที่ถูกจัดสรรสำหรับโปรแกรม

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

=============================================================

“Vera essentia non apparet in tabula edita, sed ex effectu actionum videtur.”

“ตัวตนที่แท้ไม่ปรากฏบนป้ายประกาศ แต่สามารถเห็นได้จากผลแห่งการกระทำ”

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Naturvirtus

XXII Novembris MMXXIV