Python ไม่เท่ากับ Operaทอร์ (!=)

⚡ สรุปอย่างชาญฉลาด

Python ตัวดำเนินการไม่เท่ากับจะเปรียบเทียบตัวถูกดำเนินการสองตัว และส่งคืนค่าบูลีนเมื่อเนื้อหาของตัวถูกดำเนินการทั้งสองแตกต่างกัน สัญลักษณ์ != ทำงานใน Python 2 และ 3 และเนื่องจาก Python เนื่องจากเป็นตัวแปรแบบไดนามิก จึงสามารถเปรียบเทียบค่าระหว่างชนิดข้อมูลที่แตกต่างกันได้ด้วย

  • 🔘 ความหมาย: ตัวดำเนินการ "ไม่เท่ากับ" จะคืนค่า True เมื่อตัวถูกดำเนินการสองตัวมีค่าต่างกัน และคืนค่า False เมื่อค่าทั้งสองตรงกัน
  • ☑️ สัญลักษณ์สองตัว: Python มี != สำหรับทุกเวอร์ชันและรูปแบบ <> แบบเก่า ซึ่งใช้งานได้เฉพาะภายใต้ Python 2.
  • ผลลัพธ์แบบบูลีน: การเปรียบเทียบแต่ละครั้งจะให้ผลลัพธ์เป็นค่าบูลีน ทำให้ตัวดำเนินการนี้เหมาะสำหรับเงื่อนไขและการตรวจสอบความถูกต้อง
  • 🧪 ไดนามิกไทping: เพราะ Python เนื่องจากเป็นตัวกำหนดประเภทข้อมูลที่เข้มงวดและไดนามิก เครื่องหมาย != จึงสามารถเปรียบเทียบจำนวนเต็ม จำนวนทศนิยม และสตริงได้อย่างปลอดภัย
  • 🛠️ การควบคุมการไหล: การใช้เครื่องหมาย != ร่วมกับคำสั่ง if และลูป while ช่วยกรองข้อมูล เช่น การแยกตัวเลขคู่หรือคี่
  • ⚙️ วัตถุที่กำหนดเอง: การเขียนทับเมธอด __ne__ ช่วยให้คลาสสามารถกำหนดได้อย่างแม่นยำว่าตัวดำเนินการไม่เท่ากับทำงานอย่างไร

Python ไม่เท่ากับ OperaTor

ความหมายของ Python ไม่เท่ากับ Operaทอร์?

Python ระบุว่าเป็นภาษาการเขียนโปรแกรมที่ไดนามิกมาก และโดยทั่วไปถือว่าเป็นภาษาที่มีการกำหนดประเภทอย่างเข้มงวด คำชี้แจงนี้สามารถอธิบายได้โดยการทำความเข้าใจความสำคัญของตัวดำเนินการที่ไม่เท่ากัน not equal ตัวดำเนินการ ถ้าค่าของตัวดำเนินการสองตัวที่อยู่แต่ละด้านของตัวดำเนินการไม่เท่ากัน ตัวดำเนินการนั้นจะให้ค่าจริง มิฉะนั้นจะให้ค่าเท็จ

In not equal ตัวดำเนินการ "ไม่เท่ากัน" หากตัวแปรสองตัวมีชนิดข้อมูลต่างกัน แต่เก็บค่าเดียวกัน ตัวดำเนินการ "ไม่เท่ากัน" จะส่งคืนค่าจริง อย่างไรก็ตาม ภาษาโปรแกรมส่วนใหญ่ไม่สามารถจัดประเภทค่าเป็นจริงได้หากชนิดของตัวแปรแตกต่างกัน ซึ่งทำให้... Python ภาษาที่มีพลวัตสูงมาก ใน Pythonตัวดำเนินการที่ไม่เท่ากันสามารถจัดอยู่ในประเภทของตัวดำเนินการเปรียบเทียบได้

ประเภทของตัวดำเนินการไม่เท่ากับที่มีไวยากรณ์ใน Python

ไวยากรณ์ของทั้งสองประเภทแสดงอยู่ด้านล่าง: –

X<>Y

X!=Y

มีตัวดำเนินการไม่เท่ากันอยู่สองประเภทใน Python:-

  • !=
  • <>

ประเภทแรก != ถูกใช้ใน Python เวอร์ชัน 2 และ 3

ประเภทที่สอง <> ถูกใช้ใน Python ในเวอร์ชัน 2 และเวอร์ชัน 3 เป็นต้นไป ตัวดำเนินการนี้ถูกยกเลิกการใช้งานแล้ว

ตัวอย่างของการ Python ไม่เท่ากับ OperaTor

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

A = 44
B = 284
C = 284
print(B!=A)
print(B!=C)

Output:

True
False

ต่อไปนี้เป็นตัวอย่างของการไม่เท่ากันใน Python สำหรับชนิดข้อมูลที่แตกต่างกันแต่มีค่าเท่ากัน

C = 12222
X = 12222.0
Y = "12222"
print(C!=X)
print(X!=Y)
print(C!=Y)

Output:

False
True
True

วิธีใช้ไม่เท่ากัน Operaทอร์ด้วยคำสั่ง IF

ใน python คำสั่ง if สามารถอธิบายได้ว่าเป็นคำสั่งที่ตรวจสอบเงื่อนไขระดับเริ่มต้นและดำเนินการเมื่อเป็นจริง

มาดูตัวอย่างพื้นฐานในการใช้คำสั่ง if และไม่เท่ากับตัวดำเนินการดังแสดงด้านล่าง:

X = 5
Y = 5
if ( X != Y ):
  print("X is not equal to Y")
else:
  print("X is equal to Y")

Output:

X is equal to Y

ตรงนี้ไม่เท่ากับ != ใช้ร่วมกับคำสั่ง if

วิธีใช้ตัวดำเนินการเท่ากับ (==) กับลูป while

ใน Python ลูป while จะวนซ้ำบล็อกของโค้ดตราบใดที่เงื่อนไขเป็นจริงหรือเท็จ ลองพิจารณาการพิมพ์เลขคี่โดยใช้ลูป while และตัวดำเนินการเท่ากับดังแสดงด้านล่าง: –

m = 300
while m <= 305:
   m = m + 1
  if m%2 == 0:
     continue
   print (m)

Output:

301
303
305

ตรงนี้, เท่ากับ == ใช้ร่วมกับคำสั่ง if

ตัวอย่าง: การหาเลขคู่โดยใช้ตัวดำเนินการไม่เท่ากับ

ใน Python สามารถใช้ลูป while กับตัวดำเนินการ not equal ได้เช่นกัน ลองพิจารณาการพิมพ์ตัวเลขคู่โดยใช้ลูป while กับตัวดำเนินการ not equal ดังแสดงด้านล่าง:

m = 300
while m <= 305:
  m = m + 1
  if m%2 != 0:
    continue
  print (m)

Output:

302
304
306

ตรงนี้ไม่เท่ากับ != ใช้ร่วมกับคำสั่ง if

วิธีใช้ Python ไม่เท่ากับ Operaทอร์ด้วยวัตถุที่กำหนดเอง

ออบเจ็กต์แบบกำหนดเองช่วยให้ผู้ใช้หรือนักพัฒนาสามารถสร้างการใช้งานแบบกำหนดเองได้ สิ่งนี้ทำให้นักพัฒนาสามารถเปลี่ยนผลลัพธ์จริงได้มากกว่าที่คาดไว้

มาดูตัวอย่างของวัตถุที่กำหนดเองซึ่งใช้ตัวดำเนินการไม่เท่ากับดังแสดงด้านล่าง: –

ตัวอย่าง:

class G9Example:

   s_n=''

def __init__(self, name):

   self.s_n = name

def __ne__(self, x):

if type(x) != type(self):

  return True

# return True for different values

if self.s_n != x.s_n:

  return True

else:

  return False

G1 = G9Example("Guru99")

G2 = G9Example("HipHop99")

G3 = G9Example("Guru99")

print(G1 != G2)

print(G2 != G3)

print(G1 != G3)

Output:

True

True

False

ตัวดำเนินการเปรียบเทียบใน Python

ตารางต่อไปนี้จะอธิบายรายการการเปรียบเทียบ ตัวดำเนินการใน Python: -

OperaTor ความหมาย ตัวอย่าง
!= ไม่เท่ากับให้เป็นจริงถ้าตัวดำเนินการไม่มีค่าเดียวกัน เอ!=บี
== เท่ากับ-ให้เป็นจริงถ้าตัวดำเนินการมีค่าเท่ากัน ก==ข
>= มากกว่าหรือเท่ากับ - ให้ค่าเป็นจริงหากตัวดำเนินการตัวแรกมากกว่าหรือเท่ากับตัวดำเนินการตัวที่สอง ก>=ข
<= Less มากกว่าหรือเท่ากับ- ให้ค่าเป็นจริงถ้าตัวดำเนินการตัวแรกเป็น Less มากกว่าหรือเท่ากับตัวดำเนินการตัวที่สอง อ<=บี
> มากกว่า – ให้ค่าเป็นจริงหากตัวดำเนินการตัวแรกมากกว่าตัวดำเนินการตัวที่สอง A>B
< Less กว่า – ให้ค่าเป็นจริงถ้าตัวดำเนินการตัวแรกเป็น Less มากกว่าตัวดำเนินการที่สอง เอ<บี

เคล็ดลับที่เป็นประโยชน์เกี่ยวกับการใช้ไม่เท่ากัน OperaTor

คำแนะนำที่เป็นประโยชน์มีดังนี้

  • ตัวดำเนินการไม่เท่ากับสามารถใช้ในสตริงที่มีการจัดรูปแบบได้
  • คุณลักษณะนี้ค่อนข้างใหม่และเป็นส่วนหนึ่งของ Python รุ่น 3.6.
  • นักพัฒนาควรตรวจสอบให้แน่ใจว่าไวยากรณ์ควรเป็น != และไม่ เพราะฟอนต์หรือล่ามบางตัวเปลี่ยนไวยากรณ์จาก != ไปยัง .

คำถามที่พบบ่อย

ตัวดำเนินการ != จะคืนค่า True เมื่อค่าสองค่าแตกต่างกัน ในขณะที่ตัวดำเนินการ == จะคืนค่า True เมื่อค่าสองค่าเท่ากัน ทั้งสองตัวดำเนินการจะประเมินค่าเป็นบูลีน True หรือ False

ไม่ ตัวดำเนินการ <> ทำงานใน Python 2 แต่ถูกลบออกไปใน Python 3. เฉพาะเครื่องหมาย != เท่านั้นที่ใช้ได้ในทั้งสองเวอร์ชัน ดังนั้นควรใช้ != ในโค้ดสมัยใหม่

ใช่. Python เป็นชนิดข้อมูลแบบไดนามิก ดังนั้น != จึงใช้เปรียบเทียบชนิดข้อมูลที่แตกต่างกัน จำนวนเต็ม 12222 และสตริง “12222” จะถูกมองว่าไม่เท่ากัน

ตัวดำเนินการ != เปรียบเทียบค่าและเรียกใช้เมธอด __ne__ เพื่อตรวจสอบความเท่าเทียมกัน ส่วนตัวดำเนินการ “is not” เปรียบเทียบความเหมือนกัน โดยทดสอบว่าตัวแปรสองตัวอ้างอิงถึงวัตถุเดียวกันในหน่วยความจำหรือไม่

ใช้ “is not None” None เป็นค่าที่มีตัวเดียว ดังนั้นการตรวจสอบตัวตนจึงเร็วกว่าและปลอดภัยกว่าการใช้ != ซึ่งเมธอด __ne__ ที่กำหนดเองสามารถเขียนทับได้

ผู้ช่วย AI จะตรวจสอบว่าเงื่อนไข != หรือ == เหมาะสมกับตรรกะของคุณหรือไม่ แจ้งเตือนการเปรียบเทียบที่มีความเสี่ยงระหว่างประเภทที่ไม่เข้ากัน และเขียนเงื่อนไขใหม่เพื่อให้ได้ผลลัพธ์ที่คุณคาดหวัง

ใช่. AI tracระบุค่าและประเภทในทั้งสองด้าน อธิบายผลลัพธ์ที่เป็นจริงหรือเท็จ และแนะนำให้ใช้ "ไม่ใช่" เมื่อเปรียบเทียบกับ "ไม่มี"

ใช่แล้ว GitHub Copilot จะเติมข้อความอัตโนมัติสำหรับเงื่อนไข != จากความคิดเห็น เครื่องมือ AI ของ Agentic จะปรับโครงสร้างการเปรียบเทียบข้ามไฟล์และระบุจุดที่การใช้ “is not” ปลอดภัยกว่า

สรุปโพสต์นี้ด้วย: