ข้อยกเว้น คลาส และไลบรารีมาตรฐาน

9 / 3 ไม่ส่งข้อยกเว้นออกมา จึงไม่เข้า except ส่วน else จะทำงานเฉพาะเมื่อไม่เกิดข้อยกเว้นเท่านั้น จึงทำงานหลัง try ส่วน finally จะทำงานเสมอไม่ว่าจะมีข้อยกเว้นหรือไม่ จึงทำงานเป็นลำดับสุดท้าย ดังนั้นจึงได้ 3 บรรทัดคือ try, else, finally ตัวเลือกที่มี except ปรากฏอยู่คือลำดับที่เกิดจากการเข้าใจผิดว่าเกิดข้อยกเว้น แต่การเรียกนี้ไม่เกิด ZeroDivisionError ตัวเลือกที่ขาด finally ไปคือลำดับที่เกิดจากการสับสนว่า finally คือ “การจัดการหลังบ้านเมื่อเกิดข้อยกเว้น”

ส่วน else ของประโยค try จะทำงานเฉพาะเมื่อส่วน try จบลงโดยไม่ส่งข้อยกเว้นออกมาเลยเท่านั้น ในขณะที่ else ของประโยค if คือ “เมื่อเงื่อนไขเป็นเท็จ” else ของประโยค try จะอยู่ฝั่ง “เมื่อสำเร็จ” จึงควรจำไว้ว่าทิศทางตรงข้ามกัน สิ่งที่ทำงานเมื่อเกิดข้อยกเว้นคือส่วน except สิ่งที่ทำงานเสมอไม่ว่าจะมีข้อยกเว้นหรือไม่คือส่วน finally หากไม่ตรงกับ except ข้อใดเลย จะไม่ตกไปที่ else แต่ข้อยกเว้นนั้นจะถูกส่งต่อไปยังฝั่งที่เรียก

f() จะเตรียมค่าที่จะ return ไว้ก่อน แล้วรันส่วน finally ก่อนที่จะคืนค่าจริง ดังนั้น F จะแสดงก่อน และค่าที่คืนกลับยังคงเป็น T ตามเดิม g() มี return อยู่ในส่วน finally ซึ่งจะเขียนทับ return ของส่วน try ค่าที่คืนกลับจึงเป็น N print จะประเมิน f() และ g() เสร็จก่อนแล้วจึงแสดงรวมเป็นบรรทัดเดียว ดังนั้นบรรทัด F จะมาก่อน บรรทัด T N จะตามมาทีหลัง ตัวเลือกที่เป็น T T คือคำตอบเมื่อคิดว่า return ของ finally ถูกละเลย ตัวเลือกที่ F มาทีหลังคือคำตอบเมื่อคิดว่า finally ทำงานหลัง return

KeyboardInterrupt อยู่ใต้ BaseException โดยตรง ไม่ได้สืบทอดมาจาก Exception issubclass(KeyboardInterrupt, Exception) จะเป็น False เนื่องจากเป็นสิ่งที่เกิดขึ้นเมื่อผู้ใช้พยายามหยุดด้วย Ctrl-C จึงถูกแยกลำดับชั้นไว้เพื่อไม่ให้ except Exception ที่เขียนไว้กว้าง ๆ กลืนไปโดยไม่ตั้งใจ SystemExit ก็อยู่ในตำแหน่งเดียวกันนี้ ส่วนอีก 3 ตัวที่เหลือล้วนเป็นลูกหลานของ Exception ทั้งหมด ZeroDivisionError อยู่ใต้ ArithmeticError, FileNotFoundError อยู่ใต้ OSError, ModuleNotFoundError อยู่ใต้ ImportError จึงถูก except Exception ดักจับได้

ทั้ง IndexError และ KeyError มีลักษณะร่วมกันคือใช้ดัชนีหรือคีย์ค้นหาแล้วไม่พบ จึงถูกวางไว้ใต้คลาสแม่ร่วมกันคือ LookupError หากเขียน except LookupError จะสามารถรับทั้งการเข้าถึงลิสต์นอกขอบเขตและคีย์ที่ไม่มีอยู่ในพจนานุกรมได้พร้อมกัน ArithmeticError เป็นคลาสแม่ของ ZeroDivisionError เป็นต้น ใช้ในกรณีที่การคำนวณเองไม่สำเร็จ AttributeError เป็นข้อยกเว้นเมื่อหาแอตทริบิวต์ไม่พบ ReferenceError เป็นข้อยกเว้นเมื่อสิ่งที่ weak reference ชี้ไปหายไปแล้ว ทั้งสองอยู่ใต้ Exception โดยตรงและเป็นคนละสายกับ LookupError

8 / 0 จะส่ง ZeroDivisionError ออกมา แต่ ZeroDivisionError เป็นคลาสลูกของ ArithmeticError ส่วน except จะตรวจสอบเรียงจากบนลงล่างและหยุดที่จุดแรกที่ตรงกัน ดังนั้น except ArithmeticError ที่เขียนไว้ก่อนจะดักจับไปก่อน แสดงเฉพาะ A เท่านั้น ส่วน except ZeroDivisionError ที่อยู่ถัดมาจะไม่มีโอกาสทำงาน เนื่องจาก except ที่ตรงกันจะทำงานเพียงตัวเดียว จึงไม่มีทางที่ทั้ง A และ Z จะปรากฏพร้อมกัน หลักการคือให้เรียงตัวที่แคบกว่า (คลาสลูก) ไว้ก่อน แล้วเรียงตัวที่กว้างกว่า (คลาสแม่) ไว้ทีหลัง โค้ดในโจทย์นี้เขียนสลับลำดับนี้

หากเขียนทูเพิลที่ล้อมด้วยวงเล็บกลมไว้หลัง except จะทำงานเมื่อตรงกับตัวใดตัวหนึ่งในนั้น conv("21") จะได้ 42 เพราะ int("21") เป็น 21 conv("abc") ส่งเป็นสตริงได้แต่ตีความเป็นตัวเลขไม่ได้ จึงเกิด ValueError conv(None) ไม่ใช่ชนิดที่ส่งให้ int() ได้ จึงเกิด TypeError การแยกแยะว่าชนิดถูกต้องแต่ค่าไม่เหมาะสมจะเป็น ValueError ส่วนถ้าชนิดไม่ตรงตั้งแต่แรกจะเป็น TypeError นี่คือลำดับของคำตอบโดยตรง

หากเขียน raise เฉย ๆ โดยไม่มีอาร์กิวเมนต์ในส่วน except จะเป็นการส่งข้อยกเว้นที่กำลังจัดการอยู่กลับไปยังฝั่งที่เรียกอีกครั้งตามเดิม ดังนั้นหลังแสดง inner แล้ว LoadError จะแพร่ออกไปนอก load() แล้ว except Exception ชั้นนอกจะรับไว้ เนื่องจาก LoadError สืบทอดมาจาก Exception จึงถูก except Exception ดักจับได้ ไม่หยุดการทำงาน type(e).__name__ จะคืนชื่อคลาสข้อยกเว้นที่ถูกส่งออกมาจริง ดังนั้นจะแสดง LoadError ไม่ใช่ชื่อชนิดของฝั่งที่ดักจับคือ Exception การที่แสดงเฉพาะ inner คือผลลัพธ์เมื่อกลืนข้อยกเว้นไว้ ณ จุดนั้นโดยไม่ส่งต่ออีกครั้ง

การเรียกครั้งที่ 1 ใช้ดัชนี 1 ของลิสต์ จึงได้ 2 กลับมา ครั้งที่ 2 ดึงคีย์ที่ไม่มีในพจนานุกรม จึงเกิด KeyError แต่สิ่งที่เขียนไว้ใน except มีเพียง IndexError เท่านั้น แม้ทั้ง IndexError และ KeyError จะเป็นลูกของ LookupError เหมือนกัน แต่ไม่ได้เป็นพ่อลูกกันเอง except ของ IndexError จึงดักจับ KeyError ไม่ได้ ข้อยกเว้นที่ดักจับไม่ได้จะแพร่ไปยังฝั่งที่เรียก เมื่อไม่มีผู้รับไว้ โปรแกรมจึงหยุดทำงาน หากต้องการรับทั้งคู่ ให้เขียนเป็น except LookupError หรือเรียงทั้งสองไว้ในทูเพิล

assert เงื่อนไข, ข้อความ จะส่ง AssertionError เมื่อเงื่อนไขเป็นเท็จ หากเงื่อนไขเป็นจริงจะไม่เกิดอะไรขึ้นเลย สิ่งสำคัญคือเมื่อรันในโหมดปรับให้เหมาะสมอย่าง python3 -O ประโยค assert ทั้งหมดจะถูกตัดออกไป ไม่มีแม้แต่บรรทัดเดียวถูกรัน ดังนั้นห้ามใช้ assert เพื่อจุดประสงค์ในการตรวจสอบข้อมูลนำเข้าจากผู้ใช้ สำหรับจุดประสงค์นั้นควรตรวจสอบเงื่อนไขด้วย if แล้วส่ง raise ValueError(...) แทน ควรจำไว้แยกบทบาทว่า assert เป็นเครื่องมือสำหรับบันทึกสมมติฐานภายในไว้ระหว่างการพัฒนา

เมื่อเขียน d.speak() Python จะแปลงให้เป็น Dog.speak(d) แล้วเรียก ในตำแหน่งอาร์กิวเมนต์ตัวที่ 1 นั้นเองที่ตัวอินสแตนซ์ที่เรียกจะถูกส่งเข้ามา การสะกดว่า self เป็นเพียงธรรมเนียมปฏิบัติ ไม่ใช่ชื่อที่ภาษาสงวนไว้ สิ่งที่กำหนดไว้ในข้อกำหนดมีเพียงตำแหน่งที่อาร์กิวเมนต์ตัวที่ 1 จะรับตัวเองเท่านั้น ดังนั้นแม้จะเขียนเองว่า Dog.speak(d) ก็ยังทำงานเหมือนเดิม การสร้างอินสแตนซ์แล้วคืนกลับเป็นหน้าที่ของ __new__ และกลไกการเรียกคลาส ส่วน __init__ เป็นเพียงการกำหนดค่าเริ่มต้นให้กับอินสแตนซ์ที่ถูกสร้างขึ้นแล้วเท่านั้น การอ้างอิงคลาสแม่ใช้ super()

kind เป็นตัวแปรของคลาสที่เขียนไว้ใต้ class โดยตรง อินสแตนซ์ทั้งหมดที่สร้างจากคลาสนี้จะใช้ตัวเดียวกันร่วมกัน เนื่องจากทั้ง a และ b ไม่มี kind อยู่ใน __dict__ ของตนเอง เมื่ออ่านแอตทริบิวต์จึงย้อนไปดูที่ฝั่งคลาสและเห็นค่าเดียวกัน การกำหนดค่าให้ Dog.kind คือการเขียนทับตัวที่ใช้ร่วมกันนี้ ดังนั้นทั้ง a และ b ที่สร้างไว้แล้วจะเห็น wolf ทั้งคู่ เนื่องจากค่าไม่ได้ถูกคัดลอกตอนสร้างอินสแตนซ์ จึงไม่มีทางที่ canine จะยังคงเหลืออยู่

การกำหนดค่าให้ a.kind จะไม่เขียนทับตัวแปรของคลาส แต่จะสร้างรายการใหม่ชื่อ kind ไว้ในพจนานุกรมของอินสแตนซ์ a นับจากนั้นเมื่ออ่าน a.kind จะพบรายการใหม่นี้ก่อน กลายเป็นการทอดเงาทับตัวแปรของคลาส ส่วน b และ Dog.kind ยังคงเป็น canine ตามเดิม ดังนั้นใน a.__dict__ จะมีทั้ง name ที่ใส่ไว้ใน __init__ และ kind เรียงอยู่ด้วย เมื่อ sorted จะได้ ['kind', 'name'] ตัวเลือกที่ทั้งหมดเป็น husky คือคำตอบเมื่อเข้าใจผิดว่าการกำหนดค่าที่อินสแตนซ์เขียนทับตัวแปรของคลาส ตัวเลือกที่มีเพียง ['name'] คือคำตอบเมื่อคิดว่าไม่เกิดเงาขึ้น

self.items.append(x) ไม่ใช่การกำหนดค่าให้ self.items แต่เป็นเพียงการเรียกอ็อบเจกต์ที่ self.items ไปถึงเท่านั้น เนื่องจากทั้ง p และ q ไม่มี items เป็นของตัวเอง ปลายทางที่ไปถึงจึงเป็นลิสต์ตัวเดียวกันของตัวแปรคลาส ผลคือทั้ง 1 ที่เพิ่มจาก p และ 2 ที่เพิ่มจาก q จะเข้าไปอยู่ในลิสต์เดียวกัน มองจากฝั่งไหนก็จะเห็นเป็น [1, 2] เหมือนกัน หากต้องการให้แต่ละอินสแตนซ์มีภาชนะแยกกัน ต้องกำหนดค่า self.items = [] ไว้ใน __init__ เพื่อสร้างขึ้นใหม่ เมื่อนั้นจะแยกเป็น [1] และ [2]

__init__ ของ Cat เรียก super().__init__(name) จึงให้ Animal ซึ่งเป็นคลาสแม่กำหนดค่า self.name ให้ จากนั้นจะใส่ black ให้ self.color ทำให้มีแอตทริบิวต์ทั้งสองครบ เนื่องจาก cry ถูกนิยามใหม่ในคลาสลูก การทำงานของคลาสแม่จึงถูกเขียนทับ และจะเรียก meow แทน isinstance(c, Animal) จะเป็น True เนื่องจาก Cat สืบทอดมาจาก Animal หากลืมเขียน super() name จะไม่ถูกกำหนดค่าและจะเกิด AttributeError จึงไม่มีทางที่จะกลายเป็นความล้มเหลวแบบเงียบ ๆ อย่างตัวเลือกที่เป็น None

ลำดับการค้นหาเมธอด (MRO) ถูกกำหนดด้วยกฎ C3 Linearization ไม่ใช่การค้นหาแบบเจาะลึกก่อนอย่างง่าย ๆ คลาสแม่ร่วม A จะถูกวางไว้หลังคลาสลูกทั้งหมดที่สืบทอดจาก A ดังนั้นจึงเรียงเป็น D, B, C, A, object หากเป็นการค้นหาแบบเจาะลึกก่อนที่ลงไปที่ B แล้วไปที่ A ตรง ๆ จะได้ D, B, A, C, object แต่ไม่ได้เป็นเช่นนั้น จุดนี้ต้องระวังเป็นพิเศษ who() จะค้นหาจากต้น MRO แล้วใช้ตัวแรกที่พบ จึงได้ B หากเขียนเป็น class E(C, B) จะได้ E, C, B, A, object ตัวที่เขียนไว้ก่อนจะมีความสำคัญเหนือกว่า

C3 Linearization มีกฎ 2 ข้อคือ ต้องรักษาลำดับที่เรียงคลาสฐานไว้ และคลาสแม่ต้องอยู่หลังคลาสลูก F(A, B) เป็นการระบุให้วาง A ไว้ก่อน B แต่เนื่องจาก B เป็นลูกของ A คลาสแม่ A จึงต้องอยู่หลังคลาสลูก B เงื่อนไขทั้งสองนี้ไม่สามารถสอดคล้องกันได้พร้อมกัน จึงถือว่าไม่สามารถสร้าง MRO ที่สอดคล้องกันได้ และจะเกิด TypeError ณ เวลาที่ประเมินนิยามคลาส ไม่ใช่ว่าต้องรอลองรันดูก่อนถึงจะรู้ แต่จะล้มเหลวทันทีที่ผ่านประโยค class หากเขียนให้ถูกต้องต้องเขียนเป็น class F(B, A) โดยวางคลาสลูกไว้ก่อน

_one ที่ขึ้นต้นด้วยขีดล่าง 1 ตัว เป็นเพียงธรรมเนียมที่บ่งบอกว่าใช้ภายในเท่านั้น ชื่อจะไม่เปลี่ยนแปลงและอ่านจากภายนอกได้ตามปกติ ในขณะที่ __two ที่ขึ้นต้นด้วยขีดล่าง 2 ตัว จะเกิดการปรับเปลี่ยนชื่อ (Name Mangling) ชื่อแอตทริบิวต์จริงจะถูกเขียนใหม่เป็น _P__two กล่าวคือ _ชื่อคลาส__ชื่อ ดังนั้นหากเขียน p.__two จะเกิด AttributeError แต่หากเขียน p._P__two จะอ่านได้ ใน __dict__ ก็จะเรียงเป็นชื่อหลังปรับเปลี่ยนแล้วเช่นกัน เมื่อ sorted จะได้ ['_P__two', '_one'] สิ่งที่ถูกปรับเปลี่ยนคือเฉพาะที่ขึ้นต้นด้วยขีดล่าง 2 ตัวเท่านั้น _one ไม่ได้เป็นเป้าหมาย

print(v) และ str(v) จะใช้ __str__ จึงได้ V(1, 2) ในขณะที่หากใส่ไว้ในคอนเทนเนอร์อย่างลิสต์หรือพจนานุกรมแล้วแสดงผล แต่ละองค์ประกอบจะใช้ __repr__ แทน จึงได้ [Vec(x=1, y=2)] การแยกใช้แบบนี้คือจุดสำคัญของข้อนี้ len(v) คือค่าที่ __len__ คืนกลับคือ 2 ส่วน v + Vec(3, 4) คือ Vec ตัวใหม่ที่ __add__ คืนกลับ เมื่อส่งเข้า print จะใช้ __str__ อีกครั้งจึงแสดงเป็น V(4, 6) ในคลาสที่ไม่ได้นิยาม __str__ ไว้ __repr__ จะถูกใช้แทน แต่ในทางกลับกัน __str__ จะไม่ถูกใช้แทน __repr__

เนื่องจากนิยาม __eq__ ไว้ p == q จะเปรียบเทียบแอตทริบิวต์ x แล้วได้ True แต่ p กับ q เป็นอ็อบเจกต์ที่ถูกสร้างแยกกัน p is q จึงยังคงเป็น False สิ่งที่สำคัญในที่นี้คือ คลาสที่นิยาม __eq__ ไว้จะทำให้ __hash__ ถูกตั้งเป็น None โดยอัตโนมัติ Point.__hash__ is None จึงเป็น True อ็อบเจกต์ที่ไม่มีแฮชจะใช้เป็นสมาชิกของเซตหรือคีย์ของพจนานุกรมไม่ได้ ดังนั้นเมื่อพยายามสร้าง {p, q} จะเกิด TypeError หากต้องการใส่ในเซตด้วย ต้องนิยาม __hash__ เองให้คืนค่าเดียวกันเมื่อเท่ากัน

math.sqrt จะคืนค่า float เสมอแม้จะหารลงตัวก็ตาม ดังนั้นรากที่สองของ 16 จึงแสดงเป็น 4.0 ไม่ใช่ 4 math.floor จะปัดทิ้งในทิศทางลบบนเส้นจำนวน ดังนั้น -1.5 จึงเป็น -2 ส่วน math.ceil เป็นทิศทางขึ้น ดังนั้น -1.5 จึงเป็น -1 สำหรับจำนวนลบ ควรระวังว่า int(-1.5) ที่ปัดทิ้งเข้าหา 0 จะได้ -1 ซึ่งต่างจากผลของ floor หากสับสน floor กับ ceil จะกลายเป็นเรียง -1 -2 หากเข้าใจผิดว่าค่าที่ sqrt คืนกลับเป็นชนิด int จะได้ 4

os.path.splitext จะแยกเฉพาะส่วนนามสกุลออก โดยจุดจะติดไปกับฝั่งนามสกุลด้วย แล้วคืนค่าเป็นทูเพิล 2 องค์ประกอบ ดังนั้นจึงได้ ('/tmp/z', '.txt') จุดจะไม่หลุดหายไปกลายเป็น 'txt' os.path.basename จะคืนชื่อที่ท้ายสุดของพาธ จึงเป็น 'z.txt' ส่วนที่คืนไดเรกทอรีฝั่ง '/tmp' คือ os.path.dirname หากต้องการทูเพิลที่รวมทั้งสองไว้ด้วยกันให้ใช้ os.path.split ควรจำแยกบทบาทไว้ว่า splitext จะตัดที่นามสกุล ไม่ใช่ที่ตัวแบ่งไดเรกทอรี

re.match จะจับคู่จากต้นสตริงเท่านั้น ต้นของ 'abc' คือ 'a' จึงไม่ตรงกับ 'b' และคืนค่า None re.search จะค้นหาแม้ในระหว่างทาง จึงตรงกับ 'b' และ .group() จะดึงสตริงที่ตรงกันคือ b ออกมาได้ ความแตกต่างนี้คือสิ่งที่ถูกถามบ่อยที่สุดในเรื่อง re re.findall จะคืนลิสต์ที่รวมส่วนที่ตรงกับแพตเทิร์นทั้งหมด \d+ คือตัวเลขที่ต่อเนื่องกัน จึงได้ ['1', '22', '333'] จะไม่มีอักขระที่ใช้คั่นรวมอยู่ด้วย หากไม่ตรงเลยจะคืนลิสต์ว่าง

เมื่อ print อ็อบเจกต์ date ตรง ๆ จะแสดงในรูปแบบ ISO ที่คั่นด้วยยัติภังค์คือ 2026-08-22 เมธอดที่ใช้เปลี่ยนรูปแบบคือ strftime หากส่ง '%Y/%m/%d' เข้าไปจะได้สตริงที่คั่นด้วยเครื่องหมายทับคือ 2026/08/22 เมื่อบวก timedelta(days=10) เข้ากับ date สิ่งที่คืนกลับไม่ใช่ timedelta แต่เป็น date ใหม่ที่ชี้ไปที่ 10 วันถัดไป ดังนั้นเมื่อ print จะแสดงเป็น 2026-09-01 การคำนวณที่ข้ามเดือนจะถูกจัดการให้โดยฝั่ง datetime เอง จึงไม่กลายเป็นวันที่ไม่มีอยู่จริงอย่าง 2026-08-32 ที่เพียงบวกตัวเลขของวันด้วย 10 หากคิดว่า print(d) จะมีรูปแบบเดียวกับ strftime จะกลายเป็นคั่นด้วยเครื่องหมายทับเรียงกัน แต่การแสดงผลตามค่าเริ่มต้นคือคั่นด้วยยัติภังค์ หากลบวันที่ทั้งสองออกจากกัน จะได้ timedelta ไม่ใช่ date และการแสดงผลจะอยู่ในรูปแบบเช่น 10 days, 0:00:00

'abracadabra' มี a อยู่ 5 ตัว b และ r อยู่ตัวละ 2 ตัว c และ d อยู่ตัวละ 1 ตัว most_common(2) จะคืนเฉพาะ 2 รายการที่มากที่สุดในรูปทูเพิลของ (องค์ประกอบ, จำนวน) จึงได้ [('a', 5), ('b', 2)] b กับ r ที่มีจำนวนเท่ากัน ตัวที่ปรากฏก่อนจะถูกเรียงไว้ก่อน จึงเลือก b Counter เป็นชนิดหนึ่งของพจนานุกรม แต่ต่างจากพจนานุกรมทั่วไปตรงที่แม้จะดึงองค์ประกอบที่ไม่มีอยู่ก็จะไม่เกิด KeyError แต่จะคืนค่า 0 แทน ออกแบบมาเพื่อไม่ต้องตรวจสอบว่ามีอยู่หรือไม่ก่อนนับ

ชนิดที่สร้างด้วย namedtuple เมื่อแสดงผลจะอยู่ในรูปแบบที่มีชื่อชนิดและชื่อฟิลด์ติดมาด้วยคือ Pt(x=1, y=2) ค่าสามารถอ่านได้ทั้งด้วยชื่อและด้วยดัชนี ดังนั้น p.x และ p[0] จึงเป็น 1 ทั้งคู่ และเนื่องจาก namedtuple เป็นชนิดที่สืบทอดมาจากทูเพิล isinstance(p, tuple) จึงเป็น True กล่าวคือเป็นทูเพิลชนิดหนึ่ง จึงไม่สามารถเขียนทับองค์ประกอบในภายหลังได้ หากต้องการค่าที่แก้ไขได้ ให้ใช้ _replace เพื่อสร้างอินสแตนซ์ใหม่ที่แทนที่ค่าแล้ว หรือนิยามเป็นคลาสธรรมดาแทน

สิ่งที่ map คืนกลับไม่ใช่ลิสต์ แต่เป็น Iterator ซึ่งจะส่งค่าถัดไปทีละตัวทุกครั้งที่เรียก next() และเมื่อหมดแล้วก็จะหมดไปเลย list() ครั้งแรกจะดึงออกมาทั้ง 3 ตัว list() ครั้งที่สองจึงไม่มีอะไรเหลือ กลายเป็นลิสต์ว่าง ไม่กลายเป็นข้อผิดพลาดหรือ None แต่จะว่างเปล่าอย่างเงียบ ๆ จึงสังเกตเห็นได้ยาก map(str, ...) จะทำให้แต่ละองค์ประกอบกลายเป็นสตริง ดังนั้นเนื้อหาครั้งแรกจึงไม่ใช่ตัวเลข แต่เป็น ['1', '2', '3'] เรื่องเดียวกันนี้เกิดขึ้นกับ filter zip enumerate และเจเนอเรเตอร์ด้วย หากจะวนซ้ำหลายครั้งควรใช้ list() ห่อไว้ทันทีที่ได้รับมา

หากส่ง None เป็นอาร์กิวเมนต์ตัวที่ 1 ของ filter จะคัดกรองตามค่าความจริงเทียม-เท็จขององค์ประกอบเอง 0 สตริงว่าง และ None ถูกประเมินเป็นเท็จ จึงตกไป เหลืออยู่คือ [1, 2, 'a'] ไม่ใช่ว่าตัวที่ตกไปจะเหลืออยู่ all มีข้อกำหนดว่าจะคืนค่า True เมื่อไม่มีองค์ประกอบที่เป็นเท็จอยู่เลยแม้แต่ตัวเดียว ดังนั้นในลิสต์ว่างที่ไม่มีองค์ประกอบเลยจะได้ True any จะคืนค่า True เมื่อมีองค์ประกอบที่เป็นจริงอยู่อย่างน้อย 1 ตัว ดังนั้นถ้าว่างเปล่าจะได้ False จุดที่ทั้งสองให้คำตอบตรงข้ามกันเมื่อส่งลำดับว่างเข้าไปคือจุดที่มักถูกถาม

แม้จะเรียกฟังก์ชันที่มี yield อยู่ เนื้อหาจะยังไม่ถูกรันแม้แต่บรรทัดเดียว สิ่งที่คืนกลับมามีเพียงอ็อบเจกต์เจเนอเรเตอร์เท่านั้น จึงแสดง created ก่อน เมื่อเรียก next(g) ครั้งแรกจึงจะเริ่มทำงานจากต้น แสดง start แล้วหยุดที่ yield 1 คืนค่า 1 next(g) ครั้งถัดไปจะกลับมาทำงานต่อจากจุดที่หยุดไว้ แสดง mid แล้วหยุดที่ yield 2 คืนค่า 2 การทำงานแบบล่าช้านี้คือความแตกต่างที่ชัดเจนจากฟังก์ชันปกติ หากเรียก next(g) ต่ออีกครั้ง ฟังก์ชันจะจบและเกิด StopIteration

== เป็นตัวดำเนินการที่ถามว่าค่าเท่ากันหรือไม่ ดังนั้น a กับ b ที่มีเนื้อหาเหมือนกันจะได้ True is เป็นตัวดำเนินการที่ถามว่าเป็นอ็อบเจกต์เดียวกันหรือไม่ a กับ b เป็นลิสต์ 2 ตัวที่ถูกสร้างแยกกัน จึงได้ False ในขณะที่ c = a ไม่ได้สร้างลิสต์ใหม่ แต่เพียงตั้งชื่ออื่นให้กับอ็อบเจกต์เดียวกัน ดังนั้น a is c จึงเป็น True กล่าวคือหากเขียนทับลิสต์ผ่าน c จะเห็นการเปลี่ยนแปลงจาก a ด้วย None เป็นอ็อบเจกต์พิเศษที่มีอยู่เพียงตัวเดียว จึงเป็นธรรมเนียมที่จะเขียนว่า x is None แต่หากต้องการเปรียบเทียบค่า ให้ใช้ == เสมอ