รายการความเข้าใจกับตัวกรองแลมบ์ดา +

ฉันพบว่าตัวเองมีความจำเป็นในการกรองขั้นพื้นฐาน: ฉันมีรายการและฉันต้องกรองตามคุณลักษณะของรายการ

รหัสของฉันดูเหมือนว่านี้:

my_list = [x for x in my_list if x.attribute == value]

แต่ฉันก็คิดว่ามันคงจะดีกว่าถ้าเขียนมันแบบนี้?

my_list = filter(lambda x: x.attribute == value, my_list)

สามารถอ่านได้มากขึ้นและหากจำเป็นสำหรับการแสดงแลมบ์ดาสามารถนำออกมาเพื่อรับบางสิ่งได้

คำถามคือมีคำเตือนในการใช้วิธีที่สองหรือไม่? มีความแตกต่างด้านประสิทธิภาพหรือไม่ ฉันทำ Pythonic Way ™หายไปทั้งหมดและควรทำในวิธีอื่น (เช่นใช้ itemgetter แทนที่จะเป็นแลมบ์ดา) หรือไม่?

มันแปลกที่ความงามแตกต่างกันไปในแต่ละคน ฉันพบว่ารายการนั้นมีความเข้าใจที่ชัดเจนมากกว่าfilter+ lambdaแต่ใช้สิ่งที่คุณพบได้ง่ายกว่า

filterมีสองสิ่งที่อาจชะลอตัวลงการใช้งานของมี

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

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

ตัวเลือกอื่น ๆ ที่ควรพิจารณาคือการใช้ตัวสร้างแทนความเข้าใจในรายการ:

def filterbyvalue(seq, value):
   for el in seq:
       if el.attribute==value: yield el

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

นี่เป็นปัญหาทางศาสนาใน Python แม้ว่ากุยพิจารณาลบmap, filterและreduceจากงูหลาม 3มีเพียงพอของฟันเฟืองว่าในท้ายที่สุดเพียงreduceถูกย้ายจากตัว -ins เพื่อfunctools.reduce

ส่วนตัวฉันค้นหาความเข้าใจในรายการง่ายต่อการอ่าน มันชัดเจนมากขึ้นว่าเกิดอะไรขึ้นจากนิพจน์[i for i in list if i.attribute == value]เนื่องจากพฤติกรรมทั้งหมดอยู่บนพื้นผิวที่ไม่ได้อยู่ในฟังก์ชันตัวกรอง

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

นอกจากนี้เนื่องจากBDFLต้องการให้filterหายไปจากภาษาแล้วแน่นอนว่าจะทำให้รายการความเข้าใจมากขึ้นโดยอัตโนมัติ Pythonic ;-)

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

กรณีการใช้งานบ่อยมากคือการดึงค่าของ X ที่ทำซ้ำได้บางส่วนไปยังเพรดิเคต P (x):

[x for x in X if P(x)]

แต่บางครั้งคุณต้องการใช้ฟังก์ชั่นบางอย่างกับค่าแรก:

[f(x) for x in X if P(f(x))]

เป็นตัวอย่างที่เฉพาะเจาะจงพิจารณา

primes_cubed = [x*x*x for x in range(1000) if prime(x)]

ฉันคิดว่ามันดูดีกว่าการใช้filterเล็กน้อย แต่ตอนนี้พิจารณา

prime_cubes = [x*x*x for x in range(1000) if prime(x*x*x)]

ในกรณีนี้เราต้องการfilterเทียบกับค่าที่คำนวณภายหลัง นอกเหนือจากปัญหาการคำนวณคิวบ์สองครั้ง (จินตนาการการคำนวณที่แพงกว่า) มีปัญหาในการเขียนนิพจน์สองครั้งละเมิดDRYความงามแบบในกรณีนี้ฉันจะใช้

prime_cubes = filter(prime, [x*x*x for x in range(1000)])

แม้ว่าfilterอาจเป็น "วิธีที่เร็วกว่า" แต่ "Pythonic way" จะไม่สนใจสิ่งต่าง ๆ เว้นแต่ว่าประสิทธิภาพจะมีความสำคัญอย่างยิ่ง (ในกรณีนี้คุณจะไม่ใช้ Python!)

ฉันคิดว่าฉันเพิ่งจะเพิ่มใน python 3 filter () เป็นจริงวัตถุตัววนซ้ำดังนั้นคุณจะต้องผ่านการเรียกเมธอด filter ไปยัง list () เพื่อสร้างรายการตัวกรอง ดังนั้นใน python 2:

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = filter(lambda num: num % 2 == 0, lst_a)

รายการ b และ c มีค่าเท่ากันและเสร็จในเวลาเดียวกับตัวกรอง () เท่ากับ [x สำหรับ x ใน y ถ้า z] อย่างไรก็ตามใน 3 รหัสเดียวกันนี้จะปล่อยให้รายการ c มีวัตถุตัวกรองไม่ใช่รายการที่ถูกกรอง เพื่อสร้างค่าเดียวกันใน 3:

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = list(filter(lambda num: num %2 == 0, lst_a))

ปัญหาคือ list () รับค่า iterable เนื่องจากเป็นอาร์กิวเมนต์และสร้างรายการใหม่จากอาร์กิวเมนต์นั้น ผลลัพธ์คือการใช้ตัวกรองด้วยวิธีนี้ใน python 3 ใช้เวลานานถึงสองเท่าของวิธี [x สำหรับ x ใน y if z] เพราะคุณต้องวนซ้ำผลลัพธ์จากตัวกรอง () เช่นเดียวกับรายการต้นฉบับ

ความแตกต่างที่สำคัญคือความเข้าใจในรายการจะส่งคืน a listในขณะที่ตัวกรองส่งคืน a filterซึ่งคุณไม่สามารถจัดการได้เหมือนlist(เช่น: เรียกใช้lenบนซึ่งไม่ทำงานกับการส่งคืนfilter)

การเรียนรู้ด้วยตนเองของฉันเองทำให้ฉันมีปัญหาคล้ายกัน

ที่ถูกกล่าวว่าหากมีวิธีที่จะได้รับผลlistจาก a filter, บิตเช่นคุณจะทำใน. NET เมื่อคุณทำlst.Where(i => i.something()).ToList()ฉันอยากรู้ว่ามัน

แก้ไข: นี่เป็นกรณีสำหรับ Python 3 ไม่ใช่ 2 (ดูการสนทนาในความคิดเห็น)

ฉันค้นหาวิธีที่สองที่สามารถอ่านได้มากขึ้น มันจะบอกคุณอย่างชัดเจนว่าความตั้งใจคืออะไร: กรองรายการ
PS: อย่าใช้ 'รายการ' เป็นชื่อตัวแปร

โดยทั่วไป filterจะเร็วกว่าเล็กน้อยหากใช้ฟังก์ชัน builtin

ฉันคาดหวังว่าความเข้าใจในรายการจะเร็วขึ้นเล็กน้อยในกรณีของคุณ

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

ในตัวอย่างของคุณจะดีกว่าการใช้ตัวกรองมากกว่า list comprehension ตามนิยาม อย่างไรก็ตามถ้าคุณต้องการพูด other_attribute จากองค์ประกอบรายการในตัวอย่างของคุณจะถูกดึงเป็นรายการใหม่จากนั้นคุณสามารถใช้รายการความเข้าใจ

return [item.other_attribute for item in my_list if item.attribute==value]

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

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

ในกรณีนี้ฉันกำลังอ่านไฟล์การลอกบรรทัดว่างการคอมเม้นต์บรรทัดและอะไรก็ได้หลังจากความคิดเห็นบนบรรทัด:

# Throw out blank lines and comments
with open('file.txt', 'r') as lines:        
    # From the inside out:
    #    [s.partition('#')[0].strip() for s in lines]... Throws out comments
    #   filter(lambda x: x!= '', [s.part... Filters out blank lines
    #  y for y in filter... Converts filter object to list
    file_contents = [y for y in filter(lambda x: x != '', [s.partition('#')[0].strip() for s in lines])]

นอกเหนือจากคำตอบที่ยอมรับแล้วยังมีตัวพิมพ์ของมุมเมื่อคุณควรใช้ตัวกรองแทนความเข้าใจในรายการ หากรายการ unhashable คุณไม่สามารถประมวลผลได้โดยตรงด้วยความเข้าใจในรายการ ตัวอย่างโลกแห่งความจริงคือถ้าคุณใช้pyodbcเพื่ออ่านผลลัพธ์จากฐานข้อมูล fetchAll()ผลจากการcursorเป็นรายการที่ unhashable ในสถานการณ์นี้เพื่อจัดการโดยตรงกับผลลัพธ์ที่ส่งคืนควรใช้ตัวกรอง:

cursor.execute("SELECT * FROM TABLE1;")
data_from_db = cursor.fetchall()
processed_data = filter(lambda s: 'abc' in s.field1 or s.StartTime >= start_date_time, data_from_db) 

หากคุณใช้รายการความเข้าใจที่นี่คุณจะได้รับข้อผิดพลาด:

TypeError: ประเภท unhashable: 'รายการ'

มันเอาฉันบางเวลาที่จะได้รับการช่วยเหลือด้วยและhigher order functions filter mapดังนั้นฉันจึงคุ้นเคยกับพวกเขาและฉันชอบจริง ๆfilterเพราะมันชัดเจนว่ามันกรองโดยการรักษาสิ่งที่เป็นความจริงและฉันรู้สึกดีที่ฉันรู้บางfunctional programmingคำ

จากนั้นฉันอ่านข้อนี้ (Fluent Python Book):

ฟังก์ชั่นแผนที่และตัวกรองยังคงมีอยู่ใน Python 3 แต่เนื่องจากการแนะนำความเข้าใจในรายการและการสร้างเครื่องกำเนิดไฟฟ้าจึงไม่สำคัญ listcomp หรือ genexp ทำงานของแผนที่และตัวกรองรวมกัน แต่อ่านได้ง่ายขึ้น

และตอนนี้ฉันคิดว่าทำไมตื๊อกับแนวคิดของ filter/ mapถ้าคุณสามารถประสบความสำเร็จกับการแพร่กระจายสำนวนที่กว้างขวางอยู่แล้วเช่นความเข้าใจในรายการ นอกจากนี้mapsและfiltersเป็นประเภทของฟังก์ชั่น ในกรณีนี้ฉันชอบใช้แลมAnonymous functionsบ์ดา

ในที่สุดก็แค่ทำการทดสอบฉันได้กำหนดเวลาทั้งสองวิธี ( mapและlistComp) และฉันไม่เห็นความแตกต่างของความเร็วที่เกี่ยวข้องที่จะพิสูจน์การโต้แย้งเกี่ยวกับมัน

from timeit import Timer

timeMap = Timer(lambda: list(map(lambda x: x*x, range(10**7))))
print(timeMap.timeit(number=100))

timeListComp = Timer(lambda:[(lambda x: x*x) for x in range(10**7)])
print(timeListComp.timeit(number=100))

#Map:                 166.95695265199174
#List Comprehension   177.97208347299602

อยากรู้อยากเห็นเกี่ยวกับ Python 3 ฉันเห็นตัวกรองทำงานได้เร็วกว่ารายการความเข้าใจ

ฉันมักจะคิดว่ารายการความเข้าใจจะมีประสิทธิภาพมากกว่า บางอย่างที่ต้องการ: [ชื่อสำหรับชื่อใน brand_names_db หากชื่อไม่ใช่ไม่มี] bytecode ที่สร้างขึ้นนั้นดีขึ้นเล็กน้อย

>>> def f1(seq):
...     return list(filter(None, seq))
>>> def f2(seq):
...     return [i for i in seq if i is not None]
>>> disassemble(f1.__code__)
2         0 LOAD_GLOBAL              0 (list)
          2 LOAD_GLOBAL              1 (filter)
          4 LOAD_CONST               0 (None)
          6 LOAD_FAST                0 (seq)
          8 CALL_FUNCTION            2
         10 CALL_FUNCTION            1
         12 RETURN_VALUE
>>> disassemble(f2.__code__)
2           0 LOAD_CONST               1 (<code object <listcomp> at 0x10cfcaa50, file "<stdin>", line 2>)
          2 LOAD_CONST               2 ('f2.<locals>.<listcomp>')
          4 MAKE_FUNCTION            0
          6 LOAD_FAST                0 (seq)
          8 GET_ITER
         10 CALL_FUNCTION            1
         12 RETURN_VALUE

แต่พวกเขาจะช้ากว่าจริง:

   >>> timeit(stmt="f1(range(1000))", setup="from __main__ import f1,f2")
   21.177661532000116
   >>> timeit(stmt="f2(range(1000))", setup="from __main__ import f1,f2")
   42.233950221000214

ของฉัน

def filter_list(list, key, value, limit=None):
    return [i for i in list if i[key] == value][:limit]