อะไรอธิบายความแตกต่างในพฤติกรรมของการดำเนินการบูลีนและระดับบิตในรายการเทียบกับ NumPy อาร์เรย์?

ฉันสับสนเกี่ยวกับการใช้&vs andใน Python ที่เหมาะสมแสดงในตัวอย่างต่อไปนี้

mylist1 = [True,  True,  True, False,  True]
mylist2 = [False, True, False,  True, False]

>>> len(mylist1) == len(mylist2)
True

# ---- Example 1 ----
>>> mylist1 and mylist2
[False, True, False, True, False]
# I would have expected [False, True, False, False, False]

# ---- Example 2 ----
>>> mylist1 & mylist2
TypeError: unsupported operand type(s) for &: 'list' and 'list'
# Why not just like example 1?

>>> import numpy as np

# ---- Example 3 ----
>>> np.array(mylist1) and np.array(mylist2)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
# Why not just like Example 4?

# ---- Example 4 ----
>>> np.array(mylist1) & np.array(mylist2)
array([False,  True, False, False, False], dtype=bool)
# This is the output I was expecting!

คำตอบนี้และคำตอบนี้ช่วยให้ฉันเข้าใจว่าandเป็นการดำเนินการบูลีน แต่&เป็นการดำเนินการระดับบิต

ฉันอ่านเกี่ยวกับการทำงานระดับบิตเพื่อทำความเข้าใจแนวคิด แต่ฉันพยายามใช้ข้อมูลนั้นเพื่อให้เข้าใจถึง 4 ตัวอย่างข้างต้น

ตัวอย่างที่ 4 นำฉันไปที่ต้องการออกของฉันเพื่อให้เป็นดี แต่ฉันยังคงสับสนเกี่ยวกับเมื่อ / วิธีการ / ทำไมฉันจึงควรใช้VSand &เหตุใดรายการและอาร์เรย์ NumPy จึงทำงานต่างกันกับตัวดำเนินการเหล่านี้

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

andการทดสอบไม่ว่าจะเป็นทั้งการแสดงออกเป็นเหตุผลTrueในขณะที่&(เมื่อใช้กับTrue/ Falseค่า) Trueการทดสอบถ้าทั้งสอง

ในหลามว่างในตัววัตถุที่ได้รับการรักษามักจะเป็นเหตุผลFalseในขณะที่ไม่ว่างเปล่า built-ins Trueจะมีเหตุผล สิ่งนี้จะช่วยให้กรณีการใช้งานทั่วไปที่คุณต้องการทำบางสิ่งบางอย่างถ้ารายการว่างเปล่าและอย่างอื่นถ้าไม่มีรายการ โปรดทราบว่านี่หมายความว่ารายการ [เท็จ] มีเหตุผลTrue:

>>> if [False]:
...    print 'True'
...
True

ดังนั้นในตัวอย่างที่ 1 รายการแรกไม่ว่างเปล่าและมีเหตุผลTrueดังนั้นค่าความจริงของรายการandนั้นเหมือนกับรายการที่สอง (ในกรณีของเรารายการที่สองไม่ว่างเปล่าและมีเหตุผลTrueแต่ระบุว่าจะต้องมีขั้นตอนการคำนวณที่ไม่จำเป็น)

ยกตัวอย่างเช่น 2 รายการไม่สามารถรวมกันอย่างมีความหมายในแบบ bitwise ได้เพราะมันสามารถมีองค์ประกอบที่ไม่เหมือนกัน สิ่งต่าง ๆ ที่สามารถรวมกันใน bitwise: Trues และ Falses, จำนวนเต็ม

ตรงกันข้าม NumPy วัตถุสนับสนุนการคำนวณแบบเวกเตอร์ นั่นคือพวกเขาช่วยให้คุณดำเนินการเดียวกันกับข้อมูลหลายชิ้น

ตัวอย่างที่ 3 ล้มเหลวเนื่องจากอาร์เรย์ NumPy (ความยาว> 1) ไม่มีค่าจริงเนื่องจากจะช่วยป้องกันความสับสนเชิงตรรกะของเวกเตอร์

ตัวอย่างที่ 4 เป็นการandดำเนินการบิตเวคเตอร์

บรรทัดล่าง

• andถ้าคุณไม่ได้จัดการกับอาร์เรย์และไม่ได้ปฏิบัติกิจวัตรคณิตศาสตร์ของจำนวนเต็มคุณอาจต้องการ

• ถ้าคุณมีพาหะของค่าความจริงที่คุณต้องการที่จะรวมการใช้งานด้วยnumpy&

เกี่ยวกับ list

จุดแรกที่สำคัญมากซึ่งทุกอย่างจะตามมา (ฉันหวังว่า)

ในไพ ธ อนธรรมดาlistไม่ได้มีความพิเศษ แต่อย่างใด (ยกเว้นมีซินแท็กซ์ที่น่ารักสำหรับการสร้างซึ่งส่วนใหญ่เป็นอุบัติเหตุทางประวัติศาสตร์) เมื่อรายการ[3,2,6]จะทำก็คือสำหรับ intents และวัตถุประสงค์เพียงวัตถุหลามธรรมดาเช่นหมายเลข3ชุดหรือฟังก์ชั่น{3,7}lambda x: x+5

(ใช่มันรองรับการเปลี่ยนแปลงองค์ประกอบของมันและรองรับการทำซ้ำและสิ่งอื่น ๆ อีกมากมาย แต่นั่นเป็นสิ่งที่ประเภท: สนับสนุนการดำเนินงานบางอย่างในขณะที่ไม่สนับสนุนคนอื่น ๆ int สนับสนุนการเพิ่มอำนาจ แต่ไม่ได้ ทำให้มันพิเศษมาก - มันคือสิ่งที่ int เป็น lambda รองรับการโทร แต่นั่นไม่ได้ทำให้พิเศษมาก - นั่นคือสิ่งที่แลมบ์ดาใช้สำหรับ :)

เกี่ยวกับ and

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

ผลที่ตามมาก็คือ andไม่สามารถโหลดได้มากเกินไปเช่นเดียวกับที่forไม่สามารถโอเวอร์โหลดได้ มันเป็นเรื่องทั่วไปอย่างสมบูรณ์และสื่อสารผ่านโปรโตคอลที่ระบุ สิ่งที่คุณสามารถทำได้คือปรับแต่งส่วนของโพรโทคอล แต่นั่นไม่ได้หมายความว่าคุณสามารถปรับเปลี่ยนพฤติกรรมของโพรโทคอลได้andอย่างสมบูรณ์ โปรโตคอลคือ:

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

ถ้าaไม่ตอบandให้ถามมันความยาวของคุณคืออะไร (อีกครั้งคุณสามารถปรับแต่งสิ่งนี้เป็นผู้เขียนของaคลาส) ถ้าaตอบ 0andทำเช่นเดียวกันกับด้านบน - ถือว่าเป็นเท็จ ( ไม่ใช่เท็จ) ข้าม b และให้aผลลัพธ์

หากaตอบคำถามอื่นที่ไม่ใช่ 0 ถึงคำถามที่สอง ("ความยาวของคุณคืออะไร") หรือไม่ตอบเลยหรือตอบว่า "ใช่" กับคำถามแรก ("คุณเป็นคนจริง") andประเมินค่า b และ พูดว่า: bคือผลลัพธ์ของฉัน โปรดทราบว่าจะไม่ถามbคำถามใด ๆ

อีกวิธีหนึ่งในการพูดทั้งหมดนี้a and bคือเกือบจะเหมือนกับb if a else aยกเว้น a ถูกประเมินเพียงครั้งเดียว

ทีนี้นั่งสักครู่ด้วยปากกาและกระดาษและโน้มน้าวตัวเองว่าเมื่อ {a, b} เป็นส่วนย่อยของ {True, False} มันทำงานได้อย่างที่คุณคาดหวังจากผู้ให้บริการบูลีน แต่ฉันหวังว่าฉันจะทำให้คุณมั่นใจว่ามันเป็นเรื่องทั่วไปมากขึ้นและอย่างที่คุณเห็นมันมีประโยชน์มากกว่านี้

นำสองสิ่งนี้มารวมกัน

ตอนนี้ฉันหวังว่าคุณจะเข้าใจตัวอย่างของคุณ 1 andไม่สนใจว่า mylist1 เป็นตัวเลขรายการแลมบ์ดาหรือวัตถุของคลาส Argmhbl เพียงแค่ใส่ใจกับคำตอบของ mylist1 สำหรับคำถามของโปรโตคอล และแน่นอน mylist1 ตอบคำถาม 5 ข้อเกี่ยวกับความยาวดังนั้นและส่งคืน mylist2 และนั่นคือมัน มันไม่มีส่วนเกี่ยวข้องกับองค์ประกอบของ mylist1 และ mylist2 - พวกเขาไม่ได้ป้อนรูปภาพทุกที่

ตัวอย่างที่สอง: &เปิดlist

ในทางกลับกัน&ผู้ประกอบการเหมือนคนอื่น ๆ เช่น+เป็น มันสามารถกำหนดประเภทโดยการกำหนดวิธีการพิเศษในชั้นเรียนนั้น intกำหนดเป็นบิต "และ" และบูลกำหนดเป็นตรรกะ "และ" แต่นั่นเป็นเพียงหนึ่งตัวเลือก: ยกตัวอย่างเช่นชุดและวัตถุอื่น ๆ เช่นมุมมองปุ่ม Dict กำหนดมันเป็นจุดตัดชุดlistเพียงแค่ไม่ได้นิยามอาจเป็นเพราะกุยโดไม่ได้คิดวิธีการกำหนดที่ชัดเจน

numpy

ในอีกด้านหนึ่ง: -D อาร์เรย์ที่มีจำนวนมากเป็นพิเศษหรืออย่างน้อยก็พยายามเป็น แน่นอนว่า numpy.array เป็นเพียงคลาสมันไม่สามารถแทนที่ได้andในทางใดทางหนึ่งดังนั้นจึงทำสิ่งที่ดีที่สุดต่อไป: เมื่อถูกถามว่า "คุณจริงหรือไม่" numpy.array เพิ่ม ValueError โดยพูดว่า "โปรดใช้คำถามใหม่อีกครั้ง มุมมองของความจริงไม่สอดคล้องกับโมเดลของคุณ " (โปรดทราบว่าข้อความ ValueError ไม่ได้พูดถึงand- เนื่องจาก numpy.array ไม่รู้ว่าใครกำลังถามคำถามมันแค่พูดถึงความจริงเท่านั้น)

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

HTH,

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

something_true and x -> x
something_false and x -> something_false
something_true or x -> something_true
something_false or x -> x

โปรดทราบว่า (ผลลัพธ์ของการประเมิน) ตัวถูกดำเนินการจริงจะถูกส่งคืนไม่ใช่ค่าความจริง

วิธีเดียวในการปรับแต่งพฤติกรรมของพวกเขาคือการแทนที่__nonzero__(เปลี่ยนชื่อเป็น__bool__ใน Python 3) ดังนั้นคุณสามารถส่งผลต่อตัวถูกดำเนินการที่ส่งคืน แต่ไม่ส่งคืนสิ่งที่แตกต่าง รายการ (และคอลเลกชันอื่น ๆ ) ถูกกำหนดให้เป็น "ความจริง" เมื่อมีสิ่งใดเลยและ "เท็จ" เมื่อไม่มีข้อมูล

อาร์เรย์ของ NumPy ปฏิเสธความเชื่อดังกล่าว: สำหรับกรณีการใช้งานที่พวกเขาตั้งเป้าไว้ความคิดที่แตกต่างกันสองประการของความจริงนั้นเป็นเรื่องปกติ: (1) องค์ประกอบใดเป็นจริงหรือไม่ เนื่องจากทั้งสองจะสมบูรณ์ (และอย่างเงียบ ๆ ) เข้ากันไม่ได้และไม่เป็นที่ชัดเจนถูกต้องมากขึ้นหรือกันมากขึ้น NumPy ปฏิเสธที่จะคาดเดาและคุณจะต้องใช้อย่างชัดเจนหรือ.any().all()

&และ|(และnotโดยวิธี) สามารถ overriden อย่างเต็มที่เนื่องจากพวกเขาไม่ลัดวงจร พวกเขาสามารถคืนสิ่งใดก็ได้เมื่ออยู่เหนือระดับและ NumPy ใช้ประโยชน์จากสิ่งนั้นเพื่อดำเนินการตามองค์ประกอบที่ชาญฉลาดเช่นเดียวกับการใช้งานสเกลาร์อื่น ๆ ในทางกลับกันรายการจะไม่ถ่ายทอดการทำงานข้ามองค์ประกอบ อย่างที่mylist1 - mylist2ไม่ได้แปลความหมายอะไรเลยและmylist1 + mylist2หมายถึงบางสิ่งที่แตกต่างอย่างสิ้นเชิงไม่มี&โอเปอเรเตอร์สำหรับรายการ

ตัวอย่างที่ 1:

นี่คือวิธีการและตัวดำเนินการทำงาน

xและy => ถ้าxเป็นเท็จแล้วx , อื่นy

ดังนั้นในคำอื่น ๆ เนื่องจากmylist1ไม่ได้เป็นผลมาจากการแสดงออกคือFalse mylist2(เฉพาะรายการที่ว่างเปล่าประเมินเป็นFalse)

ตัวอย่างที่ 2:

&ประกอบการสำหรับค่าที่เหมาะสมและเป็นคุณพูดถึง การทำงานของบิตทรัลนั้นใช้ได้กับตัวเลขเท่านั้น ผลมาจากการ& Bเป็นจำนวนประกอบด้วย 1s ในบิตที่ 1 ทั้งในและข ตัวอย่างเช่น:

>>> 3 & 1
1

มันง่ายกว่าที่จะเห็นสิ่งที่เกิดขึ้นโดยใช้ตัวอักษรไบนารี (ตัวเลขเดียวกันข้างต้น):

>>> 0b0011 & 0b0001
0b0001

การดำเนินการ Bitwise คล้ายกันในแนวคิดการดำเนินการบูลีน (ความจริง) แต่ทำงานในบิตเท่านั้น

ดังนั้นให้สองงบเกี่ยวกับรถของฉัน

1. รถของฉันเป็นสีแดง
2. รถของฉันมีล้อ

ตรรกะ "และ" ของทั้งสองคำสั่งคือ:

(รถของฉันเป็นสีแดงหรือไม่) และ (รถมีล้อหรือไม่?) => ตรรกะจริงของค่าเท็จ

ทั้งสองอย่างนี้เป็นจริงสำหรับรถของฉันอย่างน้อย ดังนั้นคุณค่าของข้อความโดยรวมจึงเป็นจริงตามหลักเหตุผล

bitwise "และ" ของทั้งสองประโยคนี้มีความคลุมเครือเล็กน้อย:

(ค่าตัวเลขของคำสั่ง 'รถยนต์ของฉันเป็นสีแดง') & (ค่าตัวเลขของคำสั่ง 'รถของฉันมีล้อ') => จำนวน

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

ตัวอย่างที่ 3 และ 4:

Numpy ใช้การดำเนินการทางคณิตศาสตร์สำหรับอาร์เรย์:

การดำเนินการทางคณิตศาสตร์และการเปรียบเทียบใน ndarrays ถูกกำหนดให้เป็นการดำเนินการตามองค์ประกอบที่ชาญฉลาดและโดยทั่วไปให้ผลตอบแทนวัตถุ ndarray เป็นผลลัพธ์

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

เพื่อที่จะตอบของคุณandเทียบกับ&คำถาม: andการใช้

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

การดำเนินงานเชิงตรรกะ ( and, or, not) แต่ถูกนำมาใช้ตลอดเวลา

1. ใน Python การแสดงออกของX and Yผลตอบแทนที่Yกำหนดbool(X) == Trueหรือใด ๆXหรือYประเมินเป็นเท็จเช่น:

   True and 20 
   >>> 20
   
   False and 20
   >>> False
   
   20 and []
   >>> []

2. ตัวดำเนินการ Bitwise ไม่ได้ถูกกำหนดสำหรับรายการ แต่มันถูกกำหนดไว้สำหรับจำนวนเต็ม - ปฏิบัติการผ่านการแสดงเลขฐานสองของตัวเลข พิจารณา 16 (01000) และ 31 (11111):

   16 & 31
   >>> 16

3. NumPy ไม่ใช่พลังจิตไม่ทราบว่าคุณหมายความว่าเช่น[False, False]ควรเท่ากับTrueในการแสดงออกทางตรรกะ ในสิ่งนี้มันจะแทนที่พฤติกรรมของ Python มาตรฐานซึ่งก็คือ: "คอลเลกชันใด ๆ ที่ว่างเปล่าด้วยlen(collection) == 0คือFalse"

4. อาจเป็นพฤติกรรมที่คาดหวังของอาร์เรย์และตัวดำเนินการของ NumPy

สำหรับตัวอย่างแรกและอ้างอิงจากเอกสารของ django
มันจะส่งคืนรายการที่สองเสมอแน่นอนรายการที่ไม่ว่างจะเห็นว่าเป็นค่าที่แท้จริงสำหรับ Python ดังนั้น Python จะส่งคืนค่า True 'สุดท้าย' ดังนั้นรายการที่สอง

In [74]: mylist1 = [False]
In [75]: mylist2 = [False, True, False,  True, False]
In [76]: mylist1 and mylist2
Out[76]: [False, True, False, True, False]
In [77]: mylist2 and mylist1
Out[77]: [False]

การดำเนินงานที่มีรายชื่องูใหญ่ทำงานในรายการ list1 and list2จะตรวจสอบว่าlist1ว่างเปล่าและส่งคืนlist1ถ้ามีและlist2ไม่ได้ list1 + list2จะผนวกlist2เข้ากับlist1ดังนั้นคุณจะได้รับรายการใหม่พร้อมlen(list1) + len(list2)องค์ประกอบ

ผู้ประกอบการที่เหมาะสมเมื่อใช้องค์ประกอบที่ชาญฉลาดเช่น&เพิ่มกTypeErrorการดำเนินการตามองค์ประกอบที่ไม่ได้รับการสนับสนุนโดยไม่ต้องวนรอบองค์ประกอบ

อาร์เรย์ Numpy สนับสนุนการดำเนินการองค์ประกอบที่ชาญฉลาด array1 & array2จะคำนวณค่าที่เหมาะสมหรือองค์ประกอบที่สอดคล้องกันในแต่ละและarray1 จะคำนวณผลรวมสำหรับองค์ประกอบที่สอดคล้องกันในแต่ละและarray2array1 + array2array1array2

นี้ไม่ได้ทำงานให้และandor

array1 and array2 เป็นหลักสั้น ๆ สำหรับรหัสต่อไปนี้:

if bool(array1):
    return array2
else:
    return array1

bool(array1)สำหรับนี้คุณจำเป็นต้องมีความหมายที่ดีของ สำหรับการดำเนินงานทั่วโลกเช่นที่ใช้ในรายการ Python คำจำกัดความคือbool(list) == Trueหากlistไม่ว่างเปล่าและFalseหากไม่มีข้อมูล สำหรับการดำเนินงานองค์ประกอบที่ชาญฉลาดของ numpy มี disambiguity บางส่วนว่าจะตรวจสอบว่าประเมินองค์ประกอบใด ๆ ไปหรือองค์ประกอบทั้งหมดที่จะประเมินTrue Trueเนื่องจากทั้งคู่มีเนื้อหาที่ถูกต้อง numpy จึงไม่คาดเดาและเรียก a ValueErrorเมื่อbool()เรียก (โดยอ้อม) บนอาเรย์

คำถามที่ดี. เช่นเดียวกับการสังเกตที่คุณมีเกี่ยวกับตัวอย่างที่ 1 และ 4 (หรือฉันควรจะพูดว่า 1 & 4 :)) กับตัวดำเนินการandbitwise แบบลอจิคัล&ฉันพบกับsumตัวดำเนินการ ก้อนsumและพีมีsumพฤติกรรมแตกต่างกันเช่นกัน ตัวอย่างเช่น:

สมมติว่า "mat" เป็นอาร์เรย์ 5x5 2d จำนวนมากเช่น:

array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25]])

จากนั้น numpy.sum (mat) ให้ผลรวมของเมทริกซ์ทั้งหมด ในขณะที่ผลรวมในตัวจาก Python เช่นผลรวม (mat) รวมตามแกนเท่านั้น ดูด้านล่าง:

np.sum(mat)  ## --> gives 325
sum(mat)     ## --> gives array([55, 60, 65, 70, 75])