ฟังก์ชัน โมดูล และการรับส่งข้อมูล

อาร์กิวเมนต์ตำแหน่งจะถูกจับคู่จากซ้ายไปขวาตามลำดับ ดังนั้น a จะได้ 1 และ b จะได้ 3 แม้ b จะมีค่าเริ่มต้น 2 แต่เนื่องจากมีการส่งค่าเข้ามา ค่านั้นจะถูกใช้แทน 4 กับ 5 ที่จับคู่ไม่ทันจะถูกรวมเป็นทูเพิลไว้ใน args ที่มีดอกจันตัวเดียว กลายเป็น (4, 5) เนื่องจากไม่ได้ส่งคีย์เวิร์ดอาร์กิวเมนต์เลย kwargs จึงเป็นพจนานุกรมว่าง {} ไม่ใช่ None หากคิดว่า b ยังคงมีค่าเริ่มต้น 2 เหลืออยู่ จะกลายเป็น (1, 2, (3, 4, 5), {}) แต่อาร์กิวเมนต์ตำแหน่งมีความสำคัญเหนือค่าเริ่มต้น สิ่งที่อยู่ใน args ก็ไม่ใช่ลิสต์แต่เป็นทูเพิล จึงไม่มีทางที่จะแสดงด้วยวงเล็บเหลี่ยม

อาร์กิวเมนต์ตำแหน่งมีเพียง 1 ตัว a จึงได้ 1 ส่วน b ไม่ได้ถูกส่ง จึงยังคงเป็นค่าเริ่มต้น 2 พารามิเตอร์ทางการชื่อ x ไม่มีอยู่ในนิยาม คีย์เวิร์ดอาร์กิวเมนต์ x=9 จึงเข้าไปอยู่ใน kwargs ที่มีดอกจัน 2 ตัว กลายเป็น {'x': 9} เนื่องจากไม่มีอาร์กิวเมนต์ตำแหน่งที่เหลือ args จึงเป็นทูเพิลว่าง () หากคิดว่า x=9 จะเข้าไปที่ b จะกลายเป็น (1, 9, (), {}) แต่คีย์เวิร์ดอาร์กิวเมนต์จะเข้าไปเฉพาะพารามิเตอร์ทางการที่ชื่อตรงกันเท่านั้น หากคิดว่า 9 เข้าไปที่ args จะกลายเป็น (1, 2, (9,), {}) แต่ค่าที่ส่งโดยระบุชื่อจะไม่ไหลไปเป็นอาร์กิวเมนต์ตำแหน่งที่เหลือ หากสับสนว่าดอกจันตัวเดียวรับพจนานุกรมและดอกจัน 2 ตัวรับทูเพิล จะดูเหมือนว่า args มี {'x': 9} และ kwargs ว่างเปล่า

ค่าเริ่มต้น [] จะถูกสร้างเพียงครั้งเดียวตอนที่รันบรรทัด def และลิสต์เดียวกันนั้นจะถูกเก็บไว้ในอ็อบเจกต์ฟังก์ชัน ไม่ได้สร้างลิสต์ว่างใหม่ทุกครั้งที่เรียก ผลของ append จึงคงเหลืออยู่ในการเรียกครั้งถัดไป ยืดออกเป็น [1], [1, 2], [1, 2, 3] หากคิดว่าทุกครั้งที่เรียกจะได้ลิสต์ใหม่ จะกลายเป็น [1] / [2] / [3] แต่นั่นคือพฤติกรรมเมื่อกำหนดค่าเริ่มต้นเป็น lst=None แล้วสร้างใหม่ในเนื้อหาฟังก์ชัน หากเขียนเนื้อหาผิดเป็น return lst.append(x) จะได้ None ซึ่งเป็นค่าที่ append คืนกลับเรียงกัน 3 ครั้ง นอกจากนี้ หากไม่แยกเป็น 3 บรรทัดแต่เขียนเป็น print(add(1), add(2), add(3)) ในบรรทัดเดียว เนื่องจากทั้ง 3 ตัวชี้ไปที่ลิสต์เดียวกัน จะแสดง [1, 2, 3] เรียงกัน 3 ครั้งหลังจากประเมินค่าทั้งหมดเสร็จแล้ว

อ็อบเจกต์ฟังก์ชันจะเก็บค่าเริ่มต้นไว้ในแอตทริบิวต์ที่ชื่อ __defaults__ ในรูปแบบทูเพิล ในบรรดาพารามิเตอร์ทางการ มีเพียง lst เท่านั้นที่มีค่าเริ่มต้น จึงกลายเป็นทูเพิลที่มี 1 องค์ประกอบและมีจุลภาคติดท้าย เนื้อหาข้างในคือลิสต์ตัวเดียวกันที่ถูกสร้างเพียงครั้งเดียวตอนบรรทัด def ผลของการ append ที่เกิดจาก 3 ครั้งที่เรียกจะคงเหลืออยู่ตามเดิม จึงกลายเป็น ([1, 2, 3],) หากยังไม่เคยเรียกเลยจะเป็น ([],) แต่ผลกระทบจากการเรียกที่ปรากฏในจุดนี้คือความน่ากลัวของอาร์กิวเมนต์ค่าเริ่มต้นที่เปลี่ยนแปลงได้ (Mutable) __defaults__ เองเป็นทูเพิล จึงไม่แสดงผลด้วยวงเล็บเหลี่ยม และเนื้อหาที่เป็นลิสต์ก็ไม่เปลี่ยนเป็นทูเพิลด้วย

นิพจน์ของค่าเริ่มต้นจะไม่ถูกประเมินทุกครั้งที่เรียกฟังก์ชัน แต่จะถูกประเมินเพียงครั้งเดียวตอนที่บรรทัด def ถูกรัน ในเวลานั้น i เป็น 5 ดังนั้น 5 จะถูกเก็บไว้ในอ็อบเจกต์ฟังก์ชัน แม้ภายหลังจะเขียนทับ i เป็น 10 ค่าเริ่มต้นที่เก็บไว้แล้วก็ไม่เปลี่ยน h() จึงคืนค่า 5 ในขณะที่ h(i) จะอ่าน i ณ เวลาที่เรียกแล้วส่งเข้าไป จึงคืนค่า ณ เวลานั้นคือ 10 หากคิดว่าค่าเริ่มต้นถูกประเมินทุกครั้งที่เรียก จะกลายเป็นทั้ง 2 บรรทัดเป็น 10 หากคิดว่าค่าที่ส่งเป็นอาร์กิวเมนต์ก็ถูกแทนที่ด้วยค่าเริ่มต้นด้วย จะกลายเป็นทั้ง 2 บรรทัดเป็น 5 กับดักของอาร์กิวเมนต์ค่าเริ่มต้นที่เปลี่ยนแปลงได้ก็เกิดจากกฎเดียวกันนี้

ไม่สามารถวางพารามิเตอร์ทางการที่ไม่มีค่าเริ่มต้นไว้หลังพารามิเตอร์ทางการที่มีค่าเริ่มต้นได้ กฎนี้ถูกตรวจสอบตั้งแต่ขั้นตอนไวยากรณ์ ดังนั้นเมื่อรันไฟล์จะเกิด SyntaxError ก่อน พร้อมข้อความ non-default argument follows default argument เนื่องจากการวิเคราะห์ไวยากรณ์ทำกับทั้งไฟล์ก่อนรันจริง จึงไม่มีแม้แต่บรรทัดเดียวถูกรัน รวมถึงบรรทัด print ด้วย นี่เป็นคนละขั้นตอนกับ TypeError ที่เกิดจากการเรียกผิดวิธี g(2, 3) เองมีจำนวนตรงกับพารามิเตอร์ทางการ หากนิยามถูกต้องก็ควรจะแสดง 5 แต่ไปไม่ถึงจุดนั้น หากจะเขียนให้ถูกต้องควรเขียนเป็น def g(b, a=1) โดยวางตัวที่มีค่าเริ่มต้นไว้ด้านหลัง

one จบการทำงานโดยไม่ผ่าน return เลยแม้แต่ครั้งเดียว ดังนั้นค่าที่คืนกลับจึงเป็น None ไม่ใช่ทูเพิลว่างหรือสตริงว่าง two เรียง 1 กับ 2 ไว้ด้วยจุลภาคหลัง return แต่นั่นไม่ใช่การคืนค่า 2 ตัว แต่เป็นการคืนทูเพิล 1 ตัวคือ (1, 2) ดังนั้น type(two()).__name__ จึงเป็น tuple หากคิดว่าค่าที่คืนหลายตัวจะถูกรวมเป็นลิสต์ จะกลายเป็น list แต่นิพจน์ที่เรียงด้วยจุลภาคจะสร้างทูเพิล สาเหตุที่มักสะดุดเมื่อพยายามกำหนดค่าจากค่าที่คืนกลับของฟังก์ชันที่แสดงผลไปแล้วนั้น ส่วนใหญ่มาจาก None ตัวนี้

เมื่อฝั่งเรียกใส่เครื่องหมายดอกจันตัวเดียวไว้หน้าลิสต์ เนื้อหาข้างในจะถูกแจกจ่ายทีละตัวเป็นอาร์กิวเมนต์ตำแหน่ง ดังนั้น a จะได้ 1 และ b จะได้ 2 ส่วน 3 ที่เหลือจะถูกรวมเป็นทูเพิลไว้ใน args ที่มีดอกจันตัวเดียว กลายเป็น (3,) เนื่องจากมีองค์ประกอบเดียวจึงมีจุลภาคติดท้าย เนื่องจากไม่ได้ส่งคีย์เวิร์ดอาร์กิวเมนต์ kwargs จึงเป็นพจนานุกรมว่าง {} ไม่ใช่ None หากลืมใส่ดอกจันแล้วเขียนเป็น f(vals) ตัวลิสต์เองจะเข้าไปที่พารามิเตอร์ทางการตัวแรก กลายเป็น ([1, 2, 3], 2, (), {}) โดยไม่เกิดข้อผิดพลาดแต่ผลลัพธ์เปลี่ยนไป สิ่งที่อยู่ใน args เป็นทูเพิล จึงไม่มีทางที่จะแสดงด้วยวงเล็บเหลี่ยม

Annotation จะถูกบันทึกไว้ในพจนานุกรมที่ชื่อ __annotations__ ของอ็อบเจกต์ฟังก์ชันเท่านั้น จะไม่มีการตรวจสอบชนิดขณะรันจริง แม้จะเขียน int ไว้ที่ a ก็ยังส่งสตริงได้ แม้จะเขียน str ไว้ที่ b ก็ยังส่งจำนวนเต็มได้ แม้จะเขียน bool ไว้ที่ค่าที่คืนกลับ สิ่งที่คืนกลับจริงก็คือสตริงที่รับเข้ามานั่นเอง ดังนั้นบรรทัดที่ 1 จะแสดง 文字列 (สตริง) ตามเดิม สิ่งที่อยู่ใน __annotations__['a'] คืออ็อบเจกต์ชนิด int ดังนั้นเมื่อ print จะแสดงในรูปแบบ <class 'int'> ไม่ใช่แสดงเพียงตัวอักษร int 3 ตัว หากต้องการตรวจสอบชนิดจริง ๆ ต้องใช้เครื่องมือตรวจสอบแยกต่างหาก หรือตรวจสอบเองในเนื้อหาฟังก์ชัน

วิธีมาตรฐานคือกำหนดค่าเริ่มต้นเป็น None แล้วตรวจสอบว่าเป็น None หรือไม่ที่ต้นเนื้อหาฟังก์ชัน จากนั้นจึงสร้างลิสต์ว่างใหม่ เนื่องจาก None เป็นค่าที่เปลี่ยนแปลงไม่ได้ แม้จะถูกประเมินเพียงครั้งเดียวก็ไม่เกิดปัญหาการใช้ร่วมกัน ครั้งที่ 1 และครั้งที่ 2 ที่ละ lst ไว้ จะสร้างลิสต์ว่างใหม่แยกกันในแต่ละครั้ง จึงได้ [1] และ [2] องค์ประกอบจากการเรียกครั้งก่อนจะไม่คงเหลืออยู่ ครั้งที่ 3 ฝั่งเรียกส่ง [9] เข้ามา lst is None จึงเป็นเท็จ 3 จะถูกเพิ่มต่อท้ายลิสต์ที่ส่งเข้ามา กลายเป็น [9, 3] หากยังคงเป็น lst=[] เหมือนเดิมไม่ได้แก้ไข ครั้งที่ 2 ที่ละไว้จะมีองค์ประกอบจากครั้งก่อนคงเหลืออยู่ กลายเป็น [1, 2] หากละเลยลิสต์ที่ฝั่งเรียกส่งมาแล้วสร้างลิสต์ใหม่แทน จะกลายเป็น [1] / [2] / [3] ซึ่งทำให้ข้อดีของวิธีมาตรฐานนี้ที่ว่า “หากมีการส่งเข้ามาก็ใช้อันนั้น” หายไป หากใช้ insert(0, x) ที่ใส่ไว้ต้นแทนที่จะเป็น append ที่เพิ่มต่อท้าย ครั้งที่ 3 จะกลายเป็น [3, 9]

LEGB คือตัวย่อของ Local, Enclosing, Global, Built-in ซึ่งแสดงถึงการค้นหาจากชั้นในสุดออกไปชั้นนอก โดยจะดูในฟังก์ชันที่กำลังทำงานก่อน ถัดไปคือฟังก์ชันชั้นนอกที่ครอบตัวเองอยู่ ถัดไปคือระดับบนสุดของโมดูล และสุดท้ายคือ built-in อย่าง len หรือ print เมื่อพบแล้วการค้นหาจะจบทันที ดังนั้นหากใช้ชื่อเดียวกันในชั้นใน ชื่อของชั้นนอกจะถูกซ่อนไว้ หากค้นหาจากชั้นนอกไปชั้นใน จะทำให้ตัวแปรท้องถิ่นที่สร้างในฟังก์ชันแพ้ตัวแปรชื่อเดียวกันที่ระดับบนสุดของโมดูล ซึ่งไม่ตรงกับพฤติกรรมจริง การสลับลำดับระหว่าง Global กับ Enclosing ก็เป็นข้อผิดพลาดที่พบบ่อย แต่ฟังก์ชันชั้นนอกอยู่ในตำแหน่งที่ลึกกว่าระดับบนสุดของโมดูล

เมื่อกำหนดค่าให้กับชื่อภายในฟังก์ชัน ชื่อนั้นจะถูกสร้างเป็นตัวแปรท้องถิ่นใหม่ ตัวแปรชื่อเดียวกันที่ระดับบนสุดของโมดูลจะไม่ได้รับผลกระทบเลย print(x) ที่อยู่ในฟังก์ชันจะอ่าน x ที่เป็นตัวแปรท้องถิ่น จึงแสดง local แต่ print(x) หลังออกจากฟังก์ชันแล้วจะอ่าน x ที่ระดับบนสุดของโมดูล จึงแสดง global หากคิดว่าการกำหนดค่าในฟังก์ชันส่งผลไปถึงด้านนอกด้วย จะกลายเป็นทั้ง 2 บรรทัดเป็น local แต่การทำแบบนั้นต้องประกาศ global x ไว้ที่ต้นฟังก์ชัน ในทางกลับกัน หากคิดว่าการกำหนดค่าในฟังก์ชันถูกละเลยและอ่านค่าด้านนอกแทน จะกลายเป็นทั้ง 2 บรรทัดเป็น global แต่เมื่อกำหนดค่าแล้วตัวแปรท้องถิ่นก็ถูกสร้างขึ้นแน่นอน ความไม่สมมาตรที่ว่า “อ่านจะไปถึงด้านนอกแต่เขียนไปไม่ถึง” นี้คือพื้นฐานของขอบเขต (Scope) ของ Python

inner ของ outer มีการเขียน nonlocal n ไว้ ดังนั้นการกำหนดค่าให้ n จะส่งผลถึง n ของฟังก์ชัน outer ที่อยู่ชั้นนอกถัดไป n ที่ outer คืนกลับหลังเรียก inner จึงเป็น 2 ในขณะที่ inner ของ outer2 ไม่มีการประกาศไว้ n = 2 จะเป็นเพียงการสร้างตัวแปรท้องถิ่นใหม่ของ inner เท่านั้น n ของ outer2 จึงยังคงเป็น 1 ไม่เปลี่ยนแปลง ดังนั้นจึงแสดงผล 2 1 หากคิดว่าทั้งคู่ส่งผลถึงกัน จะกลายเป็น 2 2 หากคิดว่าทั้งคู่ไม่ส่งผลถึงกันเลย จะกลายเป็น 1 1 แต่สิ่งที่สร้างความแตกต่างนี้คือบรรทัดเดียวของ nonlocal เท่านั้น นอกจากนี้ nonlocal จะใช้ไม่ได้หากไม่มีตัวแปรชื่อเดียวกันอยู่ในฟังก์ชันชั้นนอก และไม่สามารถชี้ไปที่ตัวแปรระดับบนสุดของโมดูลได้ หากต้องการเขียนทับตัวแปรระดับบนสุดต้องใช้ global

Python จะตัดสินตั้งแต่ตอนคอมไพล์เนื้อหาฟังก์ชันว่า ชื่อใดที่มีการกำหนดค่าอยู่ในฟังก์ชันนั้นจะถือเป็นตัวแปรท้องถิ่นทั้งหมด การตัดสินจะทำกับทั้งฟังก์ชัน ไม่เกี่ยวกับลำดับของบรรทัด ใน bad นี้มีการกำหนดค่า z = 1 อยู่ในบรรทัดถัดไป ดังนั้น z จะถูกจัดการเป็นตัวแปรท้องถิ่นของฟังก์ชันนี้ เมื่อถึง print(z) จึงยังไม่มีค่าใส่อยู่ เกิด UnboundLocalError ข้อความของข้อยกเว้นนี้อาจเปลี่ยนไปตามเวอร์ชันของ Python แต่ชื่อชนิดคือ UnboundLocalError ไม่เปลี่ยน แม้จะมี z = 100 อยู่ที่ระดับบนสุดก็จะไม่ถูกอ้างอิงถึง หากคิดว่าเนื่องจากอยู่ก่อนบรรทัดที่กำหนดค่า จึงอ่านค่าด้านนอก จะกลายเป็น 100 แต่ Python ไม่ทำงานแบบนั้น และก็ไม่มีทางที่ตัวแปรท้องถิ่นที่ยังไม่มีค่าจะกลายเป็น None ด้วย

f มีการเขียน global n ไว้ ดังนั้น n = 20 จะเขียนทับ n ที่ระดับบนสุดของโมดูล f เองคืนค่า 20 และ n ที่ระดับบนสุดก็เป็น 20 ด้วย g ไม่มีการประกาศไว้ n = 30 จะเป็นเพียงการสร้างตัวแปรท้องถิ่นของ g เท่านั้น จึงไม่ส่งผลถึง n ที่ระดับบนสุด g จะคืนค่าตัวแปรท้องถิ่นของตนคือ 30 print สุดท้ายที่อ่าน n จะเป็นตัวที่ระดับบนสุด ซึ่งถูกเขียนทับโดย f ไปแล้ว จึงเป็น 20 หากคิดว่าการกำหนดค่าของ g ก็ส่งผลไปถึงด้านนอกด้วย จะกลายเป็น 20 30 30 หากคิดว่า global ไม่มีผล จะกลายเป็น 20 30 10 การประกาศ global คือคำสั่งที่ว่า “ให้การกำหนดค่าให้ชื่อนี้ส่งผลไปถึงระดับบนสุด” หากเพียงแค่อ่านค่าอย่างเดียวก็ไม่จำเป็นต้องประกาศ ควรระวังจุดนี้ด้วย

การนำเข้าด้วยเครื่องหมายดอกจันโดยปกติจะนำเข้าชื่อทั้งหมดที่ไม่ได้ขึ้นต้นด้วยขีดล่าง แต่ถ้าฝั่งโมดูลมีลิสต์ของสตริงที่ชื่อ __all__ จะจำกัดเฉพาะชื่อที่ระบุไว้ในนั้นเท่านั้น ในตัวอย่างนี้ __all__ มีเพียง pub เท่านั้น ดังนั้นทั้ง other และ hello จะไม่ถูกนำเข้ามา other ไม่ได้ขึ้นต้นด้วยขีดล่าง แต่เมื่อมี __all__ อยู่แล้ว รายการนั้นจะมีความสำคัญเหนือกว่า เนื่องจากไม่มีการปฏิบัติพิเศษเพราะเป็นฟังก์ชัน hello ก็จะไม่ถูกนำเข้ามาเช่นกัน __all__ จะมีผลเฉพาะตอนนำเข้าด้วยเครื่องหมายดอกจันเท่านั้น การนำเข้าโดยระบุชื่ออย่าง from mymod import hello หรือวิธี import mymod แล้วเขียนเป็น mymod.hello() จะไม่ถูกขัดขวาง

เมื่อรันไฟล์นั้นโดยตรงด้วย python3 __name__ จะมีค่าเป็น '__main__' เมื่อถูก import จากไฟล์อื่น จะมีค่าเป็นชื่อไฟล์ที่ตัดนามสกุลออกคือ 'mymod2' ดังนั้นเมื่อรันโดยตรง จะแสดง 2 บรรทัดคือ mymod2: __main__ และ 直接実行 (รันโดยตรง) เมื่อถูก import จะแสดงเพียง 1 บรรทัดคือ mymod2: mymod2 if __name__ == '__main__': คือวิธีเขียนมาตรฐานที่ใช้ประโยชน์จากความแตกต่างนี้เพื่อแยก “การประมวลผลที่ต้องการให้ทำงานเฉพาะเมื่อรันโดยตรง” หากสลับชุดค่าผสมนี้ จะทำให้การประมวลผลสำหรับตรวจสอบการทำงานทำงานขึ้นมาตอน import ซึ่งไม่ตรงกับจุดประสงค์ของวิธีเขียนนี้ หากทั้งสองกรณีให้ค่าเดียวกัน ก็จะไม่สามารถแยกแยะได้ตั้งแต่แรก

sys.argv เป็นลิสต์ที่เรียงค่าที่ส่งมาจากบรรทัดคำสั่ง โดยตัวแรกสุดจะเป็นชื่อสคริปต์เอง ในตัวอย่างนี้จะกลายเป็นลิสต์ 3 องค์ประกอบคือ ['args.py', 'foo', 'bar'] ดังนั้น len จึงเป็น 3 sys.argv[1:] ที่ตัดออกมาตั้งแต่ดัชนี 1 เป็นต้นไป จะเป็น ['foo', 'bar'] ที่ตัดชื่อสคริปต์ออกแล้ว หากคิดว่าจำนวนอาร์กิวเมนต์ที่ส่งมาจะกลายเป็นความยาวโดยตรง จะได้ 2 ซึ่งลืมนับชื่อสคริปต์ตัวแรก การคิดว่า sys.argv[1:] จะกลายเป็น ['args.py', 'foo'] เป็นกรณีที่อ่านตำแหน่งเริ่มต้นของการแบ่งส่วน (slice) ผิด หากรันโดยไม่ส่งอาร์กิวเมนต์เลย ความยาวจะเป็น 1 และ sys.argv[1:] จะเป็นลิสต์ว่าง

โมดูลที่ถูกอ่านครั้งหนึ่งแล้วจะถูกแคชไว้ในพจนานุกรมที่ชื่อ sys.modules การ import ครั้งที่ 2 จะเป็นเพียงการผูกชื่อเข้ากับอ็อบเจกต์โมดูลตัวเดิมที่ลงทะเบียนไว้แล้วเท่านั้น จึงไม่มีการอ่านไฟล์ใหม่หรือรันเนื้อหาซ้ำอีก หากเขียน print ไว้ที่ระดับบนสุดของโมดูล จะสามารถยืนยันได้ว่าแม้ import 2 ครั้งก็จะแสดงผลเพียงครั้งเดียว แม้จะตั้งชื่อแทนตอน import ก็ยังคงชี้ไปที่อ็อบเจกต์เดียวกัน ดังนั้นหากเขียนทับตัวแปรของโมดูลหนึ่ง ที่อื่นที่ import โมดูลนั้นอยู่ก็จะเห็นค่าที่ถูกเขียนทับแล้วด้วย การ import ชื่อเดียวกันซ้ำ 2 ครั้งจะไม่เกิดข้อผิดพลาด หากต้องการอ่านเนื้อหาใหม่ระหว่างพัฒนาต้องใช้ฟังก์ชันของ importlib อย่างชัดเจน

sys.prefix ชี้ไปที่ตำแหน่งที่ติดตั้ง Python ที่กำลังทำงานอยู่ ส่วน sys.base_prefix ชี้ไปที่ตำแหน่งของ Python ต้นทางที่เป็นที่มา นอกสภาพแวดล้อมเสมือนทั้งสองจะเป็นค่าเดียวกัน แต่ในสภาพแวดล้อมที่สร้างด้วย python3 -m venv sys.prefix จะชี้ไปที่ไดเรกทอรีของสภาพแวดล้อมที่สร้างขึ้น ในขณะที่ sys.base_prefix ยังคงชี้ไปที่ Python ต้นทางเหมือนเดิม ทั้งสองจึงไม่ตรงกัน การไม่ตรงกันนี้เองเป็นเบาะแสของการตัดสิน การที่ทั้งสองตรงกันคือเงื่อนไขตรงข้ามของการอยู่ในสภาพแวดล้อมเสมือน sys.base_prefix จะถูกกำหนดไว้เสมอแม้นอกสภาพแวดล้อมเสมือน จึงตัดสินด้วยการมีอยู่หรือไม่ไม่ได้ sys.prefix ก็ถูกกำหนดไว้เสมอเช่นกัน สตริงพาธที่เฉพาะเจาะจงหรือเวอร์ชันของ pip จะต่างกันไปในแต่ละสภาพแวดล้อม จึงจำไว้เพียงความสัมพันธ์นี้ก็พอ

write จะคืนค่าจำนวนตัวอักษรที่เขียนไปเป็นค่าที่คืนกลับ "one\ntwo\nthree\n" ประกอบด้วย one 3 ตัวอักษร two 3 ตัวอักษร three 5 ตัวอักษร รวมกัน 11 ตัวอักษร บวกกับการขึ้นบรรทัดใหม่ 3 ตัว รวมทั้งหมดเป็น 14 ตัวอักษร หากลืมนับการขึ้นบรรทัดใหม่จะได้ 11 หากคิดว่าจำนวนบรรทัดที่เขียนจะถูกคืนกลับ จะได้ 3 แต่สิ่งที่ write นับคือจำนวนตัวอักษรเท่านั้น การเลือก None เพราะคิดว่าไม่คืนค่าอะไรเลยก็เป็นข้อผิดพลาดที่พบบ่อย มักสับสนกับเมธอดอย่าง append หรือ sort ที่คืนค่า None แต่ write จะคืนค่าจำนวน ทั้งนี้ write จะไม่ใส่การขึ้นบรรทัดใหม่ให้อัตโนมัติ หากต้องการแบ่งบรรทัดต้องเขียนไว้ในสตริงเอง

readlines จะคืนค่าทุกบรรทัดเป็นลิสต์ โดยอักขระขึ้นบรรทัดใหม่ที่ท้ายแต่ละองค์ประกอบจะยังคงติดอยู่ ดังนั้นจึงเป็น ['one\n', 'two\n', 'three\n'] หากคิดว่าการขึ้นบรรทัดใหม่จะถูกตัดออก จะกลายเป็น ['one', 'two', 'three'] แต่หากต้องการผลนั้นต้องใช้ rstrip กับแต่ละองค์ประกอบ สิ่งที่คืนค่าเป็นสตริงเดียวโดยไม่แบ่งคือ read ในขณะที่ readlines จะคืนค่าเป็นลิสต์ หากคิดว่าไม่ได้ใช้การขึ้นบรรทัดใหม่เป็นตัวแบ่ง แต่ห่อทั้งไฟล์ไว้เป็นองค์ประกอบเดียว จะกลายเป็น ['one\ntwo\nthree\n'] แต่ readlines จะแบ่งองค์ประกอบทุกครั้งที่พบการขึ้นบรรทัดใหม่ เมื่อเขียนเป็น for line in f เพื่อดึงทีละบรรทัด บรรทัดที่ส่งมาก็จะมีการขึ้นบรรทัดใหม่ติดมาด้วยเช่นกัน

อ็อบเจกต์ไฟล์จะจดจำตำแหน่งปัจจุบันไว้ read ครั้งแรกจะอ่านตั้งแต่ต้นจนจบ ดังนั้น a จะได้ 14 ตัวอักษรรวมการขึ้นบรรทัดใหม่ และตำแหน่งจะเลื่อนไปที่ท้ายสุด read ครั้งที่ 2 จะพยายามอ่านจากท้ายสุด เนื่องจากไม่มีส่วนที่เหลือ จึงคืนค่าสตริงว่าง ดังนั้น len(a) จึงเป็น 14 และ b == '' จึงเป็น True หากคิดว่าครั้งที่ 2 จะคืนเนื้อหาเดียวกัน จะกลายเป็น b == '' เป็น False แต่หากต้องการอ่านเนื้อหาเดิมซ้ำต้องใช้ f.seek(0) เพื่อย้ายตำแหน่งกลับไปที่ต้น การที่ len(a) จะเป็น 0 คือกรณีที่ไฟล์ว่างเปล่าหรือตำแหน่งอยู่ที่ท้ายสุดอยู่แล้วตั้งแต่ต้น การไม่แสดงอะไรเลยมักถูกเข้าใจผิดว่าการอ่านล้มเหลว แต่ที่จริงเกิดจากตำแหน่งอยู่ที่ท้ายสุด

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

เมื่อเปิดด้วย 'w' ไฟล์จะถูกตัดให้มีความยาว 0 ณ เวลานั้น ไม่ว่าจะมีเนื้อหาเดิมอยู่หรือไม่ ไล่ตามลำดับ 'w' ครั้งแรกจะใส่ AAA เข้าไป จากนั้น 'a' ถัดมาเป็นการเขียนต่อท้าย จึงกลายเป็น AAABBB แต่พอเปิดด้วย 'w' เป็นครั้งที่ 3 AAABBB จะถูกลบทิ้งทันที แล้วเขียน C เข้าไปแทน สุดท้ายจึงเหลือเพียง C เท่านั้น หากคิดว่าเปิดด้วย 'a' ทั้ง 3 ครั้ง จะกลายเป็น AAABBBC หากคิดว่าการเขียนครั้งสุดท้ายถูกละเลย จะกลายเป็น AAABBB การเขียนทับตั้งแต่ต้นโดยไม่ตัดทิ้งคือพฤติกรรมของ 'r+' ซึ่งในกรณีนั้นจะมีเพียงตัวอักษรแรกเท่านั้นที่ถูกแทนที่ กลายเป็นแบบ CAABBB การตัดทิ้งจะเกิดขึ้น ณ วินาทีที่เปิด ไม่ใช่วินาทีที่เขียน ดังนั้นหากเปิดด้วย 'w' แล้วไม่เขียนอะไรเลย ไฟล์ก็จะกลายเป็นว่างเปล่า หากตั้งใจจะเขียนต่อท้ายให้ใช้ 'a' หากตั้งใจจะสร้างใหม่ให้ใช้ 'w' แสดงเจตนาด้วยโหมด

เมื่อเรียก read กับอ็อบเจกต์ไฟล์หลังจาก close แล้ว จะเกิด ValueError พร้อมข้อความ I/O operation on closed file. ตัวอ็อบเจกต์จะจดจำไว้ว่าถูกปิดแล้ว จึงไม่มีการเปิดใหม่โดยอัตโนมัติแม้จะจำเป็นต้องใช้ ไม่ได้คืนค่าสตริงว่างในความหมายว่าไม่มีอะไรให้อ่าน นั่นเป็นพฤติกรรมของ read หลังอ่านจนถึงท้ายสุดแล้วต่างหาก ข้อผิดพลาดอย่าง FileNotFoundError ที่เกิดเมื่อหาไฟล์ไม่พบเป็นพวกเดียวกับ OSError แต่ข้อยกเว้นเมื่อดำเนินการกับไฟล์ที่ปิดแล้วเป็นคนละอย่างคือ ValueError หากใช้ประโยค with จะหลีกเลี่ยงการพยายามอ่านหลังออกจากบล็อกได้โดยโครงสร้างเอง

หากละอาร์กิวเมนต์ตัวที่ 2 ของ open ไว้ จะเป็นโหมดอ่านได้อย่างเดียวคือ 'r' หากเรียก write กับอ็อบเจกต์ไฟล์ที่เปิดด้วยโหมดอ่านได้อย่างเดียว จะเกิด io.UnsupportedOperation พร้อมข้อความ not writable เนื่องจากเป็นวิธีเขียนที่ผ่านไวยากรณ์ได้ จึงจะรู้ตัวว่าเลือกโหมดผิดหลังจากรันจริงแล้ว หากต้องการเขียนทับให้ใช้ 'w' หากต้องการเพิ่มต่อท้ายให้ใช้ 'a' หากต้องการทั้งอ่านและเขียนให้เปิดใหม่ด้วย 'r+' ในทางกลับกัน หากเรียก read กับไฟล์ที่เปิดด้วย 'w' หรือ 'a' ก็จะเกิด io.UnsupportedOperation เช่นเดียวกันพร้อมข้อความ not readable กล่าวได้ว่าโหมดคือที่ที่ประกาศว่าจะอนุญาตให้ทำอะไรกับอ็อบเจกต์ไฟล์นั้นได้บ้าง

หากส่งจำนวนเข้าไปให้ read จะอ่านเพียงจำนวนตัวอักษรนั้น 5 ตัวอักษรจากต้นคือ one 3 ตัวอักษร การขึ้นบรรทัดใหม่ 1 ตัว และ t ของ two จึงกลายเป็น 'one\nt' เนื่องจากตำแหน่งจะเลื่อนไปตามจำนวนที่อ่าน tell ที่เรียกทันทีหลังจากนั้นจะคืนค่า 5 seek(0) ถัดมาจะย้ายตำแหน่งกลับไปที่ต้น ดังนั้น tell สุดท้ายจึงเป็น 0 หากคิดว่า read ไม่ทำให้ตำแหน่งเคลื่อนที่ จะกลายเป็น tell เป็น 0 ทั้ง 2 ครั้ง หากคิดว่า seek ไม่มีผล จะกลายเป็น tell เป็น 5 ทั้ง 2 ครั้ง หากสับสนว่าอาร์กิวเมนต์ของ read เป็นจำนวนบรรทัดไม่ใช่จำนวนตัวอักษร จะเข้าใจผิดว่าตั้งใจอ่านถึงบรรทัดที่ 5 แล้วเลือกทั้งไฟล์ 'one\ntwo\nthree\n' กับ 14 ผิดไป หากใช้ seek(0) สามารถอ่านจากต้นซ้ำได้โดยใช้อ็อบเจกต์ไฟล์เดิม

ใน JSON มีแต่อาร์เรย์เท่านั้น ไม่มีชนิดที่เรียกว่าทูเพิลอยู่ ดังนั้น ณ เวลาที่เรียก dumps ทูเพิลจะถูกแปลงเป็นอาร์เรย์ เอาต์พุตจึงเป็น {"t": [1, 2]} เมื่ออ่านกลับ อาร์เรย์ก็จะถูกคืนสภาพเป็นลิสต์ ดังนั้นชนิดของ back['t'] จึงเป็น list ไม่กลับไปเป็นทูเพิล ข้อมูลที่ว่าเดิมเป็นทูเพิลจะไม่หลงเหลืออยู่ที่ใดเลย ดังนั้นเมื่อผ่านไปกลับชนิดจึงเปลี่ยน หากต้องการให้ยังคงเป็นทูเพิล ต้องเรียก tuple() เองหลังจากอ่านกลับมาแล้ว วงเล็บกลมจะไม่ปรากฏในเอาต์พุตของ JSON และทูเพิลก็จะไม่ถูกแปลงเป็นสตริงด้วย ด้วยเหตุผลเดียวกัน หากใช้จำนวนเต็มเป็นคีย์ของพจนานุกรม จะถูกแปลงเป็นสตริงตอน dumps และเมื่ออ่านกลับก็จะไม่กลับไปเป็นจำนวนเต็ม

คีย์ของออบเจกต์ใน JSON ต้องเป็นสตริงเท่านั้น ดังนั้นเมื่อ dumps พจนานุกรมที่มีจำนวนเต็มเป็นคีย์ คีย์นั้นจะถูกแปลงเป็นสตริงแล้วแสดงผลเป็น {"1": "a"} นี่คือการดำเนินการที่สำเร็จตามปกติ ไม่เกิดข้อยกเว้น ณ จุดนี้ แต่ควรระวังว่าเมื่ออ่านกลับมา คีย์จะยังคงเป็นสตริงตามเดิม ไม่กลับไปเป็นจำนวนเต็ม เซตในบรรทัดที่ 2 ไม่มีชนิดที่สอดคล้องใน JSON ดังนั้นเมื่อพยายาม dumps จะเกิด TypeError พร้อมข้อความ Object of type set is not JSON serializable หากคิดว่าเซตจะถูกเขียนออกมาเป็นอาร์เรย์ จะกลายเป็น [1, 2] แต่หากต้องการให้แปลงแบบนั้นต้องเรียก list() เองก่อนแล้วจึงส่งเข้าไป สำหรับค่าที่มีภาษาญี่ปุ่นปนอยู่ ตามค่าเริ่มต้นจะถูก escape แล้วแสดงผล หากส่งค่าเท็จให้กับ ensure_ascii จะแสดงผลเป็นตัวอักษรตามเดิม