“ x <y <z” เร็วกว่า“ x <y และ y <z” หรือไม่

จากหน้านี้เรารู้ว่า:

การเปรียบเทียบแบบล่ามโซ่จะเร็วกว่าการใช้ตัวandดำเนินการ เขียนx < y < zแทนx < y and y < z.

อย่างไรก็ตามฉันได้รับผลลัพธ์ที่แตกต่างจากการทดสอบข้อมูลโค้ดต่อไปนี้:

$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.8" "x < y < z"
1000000 loops, best of 3: 0.322 usec per loop
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.8" "x < y and y < z"
1000000 loops, best of 3: 0.22 usec per loop
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.1" "x < y < z"
1000000 loops, best of 3: 0.279 usec per loop
$ python -m timeit "x = 1.2" "y = 1.3" "z = 1.1" "x < y and y < z"
1000000 loops, best of 3: 0.215 usec per loop

มันดูเหมือนว่าจะเร็วกว่าx < y and y < z ทำไม?x < y < z

หลังจากค้นหาโพสต์บางส่วนในเว็บไซต์นี้ (เช่นนี้ ) ฉันรู้ว่า "ประเมินเพียงครั้งเดียว" เป็นกุญแจสำคัญสำหรับx < y < zแต่ฉันก็ยังสับสน ในการศึกษาเพิ่มเติมฉันถอดฟังก์ชั่นทั้งสองนี้โดยใช้dis.dis:

import dis

def chained_compare():
        x = 1.2
        y = 1.3
        z = 1.1
        x < y < z

def and_compare():
        x = 1.2
        y = 1.3
        z = 1.1
        x < y and y < z

dis.dis(chained_compare)
dis.dis(and_compare)

และผลลัพธ์คือ:

## chained_compare ##

  4           0 LOAD_CONST               1 (1.2)
              3 STORE_FAST               0 (x)

  5           6 LOAD_CONST               2 (1.3)
              9 STORE_FAST               1 (y)

  6          12 LOAD_CONST               3 (1.1)
             15 STORE_FAST               2 (z)

  7          18 LOAD_FAST                0 (x)
             21 LOAD_FAST                1 (y)
             24 DUP_TOP
             25 ROT_THREE
             26 COMPARE_OP               0 (<)
             29 JUMP_IF_FALSE_OR_POP    41
             32 LOAD_FAST                2 (z)
             35 COMPARE_OP               0 (<)
             38 JUMP_FORWARD             2 (to 43)
        >>   41 ROT_TWO
             42 POP_TOP
        >>   43 POP_TOP
             44 LOAD_CONST               0 (None)
             47 RETURN_VALUE

## and_compare ##

 10           0 LOAD_CONST               1 (1.2)
              3 STORE_FAST               0 (x)

 11           6 LOAD_CONST               2 (1.3)
              9 STORE_FAST               1 (y)

 12          12 LOAD_CONST               3 (1.1)
             15 STORE_FAST               2 (z)

 13          18 LOAD_FAST                0 (x)
             21 LOAD_FAST                1 (y)
             24 COMPARE_OP               0 (<)
             27 JUMP_IF_FALSE_OR_POP    39
             30 LOAD_FAST                1 (y)
             33 LOAD_FAST                2 (z)
             36 COMPARE_OP               0 (<)
        >>   39 POP_TOP
             40 LOAD_CONST               0 (None)

ดูเหมือนว่ามีคำสั่งปิดบังน้อยกว่าx < y and y < z x < y < zควรพิจารณาx < y and y < zเร็วกว่าx < y < zไหม

ทดสอบด้วย Python 2.7.6 บน Intel (R) Xeon (R) CPU E5640 @ 2.67GHz

ความแตกต่างคือในx < y < z yจะได้รับการประเมินเพียงครั้งเดียว สิ่งนี้ไม่ได้สร้างความแตกต่างอย่างมากหาก y เป็นตัวแปร แต่จะเกิดขึ้นเมื่อเป็นการเรียกใช้ฟังก์ชันซึ่งต้องใช้เวลาในการคำนวณ

from time import sleep
def y():
    sleep(.2)
    return 1.3
%timeit 1.2 < y() < 1.8
10 loops, best of 3: 203 ms per loop
%timeit 1.2 < y() and y() < 1.8
1 loops, best of 3: 405 ms per loop

bytecode ที่เหมาะสมที่สุดสำหรับทั้งสองฟังก์ชันที่คุณกำหนดไว้

          0 LOAD_CONST               0 (None)
          3 RETURN_VALUE

เนื่องจากไม่ได้ใช้ผลของการเปรียบเทียบ มาทำให้สถานการณ์น่าสนใจยิ่งขึ้นโดยส่งคืนผลลัพธ์ของการเปรียบเทียบ นอกจากนี้ยังมีผลลัพธ์ที่ไม่สามารถทราบได้ในเวลารวบรวม

def interesting_compare(y):
    x = 1.1
    z = 1.3
    return x < y < z  # or: x < y and y < z

อีกครั้งการเปรียบเทียบทั้งสองเวอร์ชันมีความหมายเหมือนกันดังนั้นรหัสไบต์ที่เหมาะสมที่สุดจึงเหมือนกันสำหรับโครงสร้างทั้งสอง อย่างที่ดีที่สุดที่ฉันสามารถทำได้ก็จะมีลักษณะเช่นนี้ ฉันได้ใส่คำอธิบายประกอบแต่ละบรรทัดพร้อมเนื้อหาสแต็กก่อนและหลังแต่ละ opcode ในรูปแบบ Forth (ด้านบนของสแต็กทางขวา--หารก่อนและหลังการต่อท้าย?บ่งบอกถึงบางสิ่งที่อาจมีหรือไม่มีอยู่) โปรดทราบว่าRETURN_VALUEทิ้งทุกสิ่งที่เกิดขึ้นจะถูกทิ้งไว้บนสแต็กข้างใต้ค่าที่ส่งคืน

          0 LOAD_FAST                0 (y)    ;          -- y
          3 DUP_TOP                           ; y        -- y y
          4 LOAD_CONST               0 (1.1)  ; y y      -- y y 1.1
          7 COMPARE_OP               4 (>)    ; y y 1.1  -- y pred
         10 JUMP_IF_FALSE_OR_POP     19       ; y pred   -- y
         13 LOAD_CONST               1 (1.3)  ; y        -- y 1.3
         16 COMPARE_OP               0 (<)    ; y 1.3    -- pred
     >>  19 RETURN_VALUE                      ; y? pred  --

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

ตอนนี้มันเกิดขึ้นที่การใช้งานภาษาทั้งหมดในปัจจุบันมีคอมไพเลอร์ bytecode ที่มีคุณภาพต่ำ แต่คุณควรเพิกเฉยในขณะที่เขียนโค้ด! การหลอกว่าคอมไพเลอร์ bytecode นั้นดีและเขียนโค้ดที่อ่านได้มากที่สุด มันอาจจะเร็วพออยู่แล้ว หากไม่เป็นเช่นนั้นให้มองหาการปรับปรุงอัลกอริทึมก่อนและลองใช้Cythonเป็นครั้งที่สองซึ่งจะช่วยปรับปรุงความพยายามเดียวกันได้ดีกว่าการปรับแต่งระดับนิพจน์ใด ๆ ที่คุณอาจนำไปใช้

เนื่องจากความแตกต่างในผลลัพธ์ดูเหมือนจะเกิดจากการขาดการปรับให้เหมาะสมฉันคิดว่าคุณควรเพิกเฉยต่อความแตกต่างนั้นในกรณีส่วนใหญ่ - อาจเป็นไปได้ว่าความแตกต่างจะหายไป ความแตกต่างเป็นเพราะyควรได้รับการประเมินเพียงครั้งเดียวและแก้ไขได้โดยการทำซ้ำบนสแต็กซึ่งต้องใช้เพิ่มเติมPOP_TOP- วิธีแก้ปัญหาที่จะใช้LOAD_FASTอาจเป็นไปได้

ข้อแตกต่างที่สำคัญคือในx<y and y<zวินาทีyควรได้รับการประเมินสองครั้งหากx<yประเมินเป็นจริงสิ่งนี้มีผลกระทบหากการประเมินของyใช้เวลามากหรือมีผลข้างเคียง

ในสถานการณ์ส่วนใหญ่คุณควรใช้x<y<zแม้ว่าจะค่อนข้างช้ากว่าก็ตาม

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

x < y < zสร้าง:

1. มีความชัดเจนและตรงกว่าในความหมาย
2. ความหมายของมันคือสิ่งที่คุณคาดหวังจาก "ความหมายทางคณิตศาสตร์" ของการเปรียบเทียบ: evalute x, yและz ครั้งเดียวและตรวจสอบว่าสภาพทั้งถือ การใช้andการเปลี่ยนแปลงความหมายโดยการประเมินyหลาย ๆ ครั้งซึ่งสามารถเปลี่ยนแปลงผลลัพธ์ได้

ดังนั้นเลือกหนึ่งแทนอีกอันขึ้นอยู่กับความหมายที่คุณต้องการและถ้ามีค่าเท่ากันจะอ่านได้มากกว่าอีกอันหนึ่งหรือไม่

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

แต่โปรดทราบว่าผลลัพธ์นี้ไม่ได้เกิดขึ้นในสถานการณ์ทั่วไปมากกว่าเฉพาะใน "กรณีที่เลวร้ายที่สุด" ที่คุณเกิดขึ้นกับโปรไฟล์ อย่างที่คนอื่น ๆ ตั้งข้อสังเกตถ้าคุณเปลี่ยนไปyเป็นสิ่งที่ต้องใช้เวลามากขึ้นอีกเล็กน้อยคุณจะเห็นว่าผลลัพธ์เปลี่ยนไปเพราะสัญกรณ์ที่ถูกล่ามไว้จะประเมินเพียงครั้งเดียว

สรุป:

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