Tutorial Python untuk bukan pengatur cara/Ungkapan Boolean

Berikut contoh ungkapan boolean (anda tidak perlu menaipnya):

a = 6
b = 7
c = 42
print 1, a == 6
print 2, a == 7
print 3, a == 6 and b == 7
print 4, a == 7 and b == 7
print 5, not a == 7 and b == 7
print 6, a == 7 or b == 7
print 7, a == 7 or b == 6
print 8, not (a == 7 and b == 6)
print 9, not a == 7 and b == 6

Dengan output:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Python hanya pandai berbahasa Inggeris. Jadi anda perlu menggunakan "and" dan bukan "dan" dalam kod ungakapan anda. Juga Python akan memulangkan nilai ungkapan Boolean dalam bahasa Inggeris: "True" (benar) atau "False" (palsu)

Apa yang berlaku? Program ini terdiri daripada kenyataan print yang aneh. Setiap kenyataan print mencetak sebuah nombor dan sebuah ungkapan. Nombor membantu saya menjejak kenyataan mana yang sedang saya guna. Perhatikan bagaimana kenyataan berakhir sama ada dengan False atau True. Dengan Python, false juga boleh ditulis sebagai 0 dan true sebagai 1.

Baris-baris:

print 1, a == 6
print 2, a == 7

mencetak masing-masing True dan False seperti yang disangkakan oleh sebab kenyataan pertama benar dan yang kedua palsu. Cetakan ketiga, print 3, a == 6 and b == 7, berlainan sedikit. Operator and membawa makna jika kedua-dua kenyataan sebelum dan kenyataan selepas benar, seluruh ungkapan itu benar, dan jika tidak, ia bermakna seluruh ungkapan itu palsu. Baris berikutnya, print 4, a == 7 and b == 7, menunjukkan bagaimana jika sebahagian ungkapan and itu palsu, seluruh perkara itu palsu. Fiil and dapat diringkaskan begini:

ungkapan	hasil
true `and` true	true
true `and` false	false
false `and` true	false
false `and` false	false

Perhatikan bahawa sekiranya ungkapan pertama itu palsu, Python tidak akan memeriksa ungkapan kedua kerana ia tahu bahawa seluruh ungkapan itu palsu.

Baris berikut, print 5, not a == 7 and b == 7, mengguna operator not. Hasil not ialah lawan ungkapan tersebut. (Ungkapan boleh ditulis semula sebagai print 5, a != 7 and b == 7). Ini rajahnya:

ungkapan	hasil
`not` true	false
`not` false	true

Dua baris berikutan itu, print 6, a == 7 or b == 7 dan print 7, a == 7 or b == 6, mengguna operator or. Operator or memulangkan true jika ungkapan pertama benar, dan jika ungkapan kedua benar atau kedua-duanya benar. Jika kedua-duanya tidak benar (yakni, palsu), ia akan memulangkan false. Ini rajahnya:

ungkapan	hasil
true `or` true	true
true `or` false	true
false `or` true	true
false `or` false	false

Perhatikan bahawa sekiranya ungkapan pertama itu true Python tidak akan memeriksa ungkapan kedua oleh sebab ia tahu bahawa seluruh ungkapan itu benar. Ini dapat dilakukan kerana or itu benar jika sekurang-kurangnya separuh ungkapan itu benar. Bahagian pertama itu benar, jadi bahagian kedua mungkin palsu atau benar, akan tetapi seluruh ungkapan itu tetap benar.

Dua baris berikutnya, print 8, not (a == 7 and b == 6) dan print 9, not a == 7 and b == 6, menunjukkan bahawa tanda kurungan boleh digunakan untuk mengumpul ungkapan dan memaksa sebahagiannya dinilai dahulu. Perhatikan bahawa tanda kurungan menukar ungkapan daripada false kepada true. Ini berlaku kerana tanda kurungan memaksa not dikenakan terhadap seluruh ungkapan dan tidak hanya pada bahagian a == 7.

Ini satu contoh penggunaan ungkapan boolean:

list = ["Hayat", "Alam", "Semua", "Jack", "Jill", "Hayat", "Jill"]

# buat salinan list. Lihat bab Tambahan tentang List untuk mendapatkan penerangan tentang [:].
salinan = list[:]
# isih salinan
salinan.sort()
sebelum = salinan[0]
del salinan[0]

count = 0

# hurai list untuk mencari padanan
while count < len(salinan) and salinan[count] != sebelum:
    sebelum = salinan[count]
    count = count + 1

# Jika padanan tidak ditemu, tak mungkin count < len
# oleh sebab gelung berterusan selagi count < len
# dan tiada padanan ditemui

if count < len(salinan):
    print "Padanan Pertama:", sebelum

Dan ini outputnya:

Padanan Pertama: Hayat

Anda sudah tentu dapat lihat bahawa bahasa dalam kod di atas bercampur aduk bahasa Inggeris dan bahasa Melayu. Bahagian yang dikekalkan dalam bahasa Inggeris diguna oleh Python dan setakat ini hanya pemboleh ubah (variable) dan string dalam kenyataan print dialih bahasa. Kaedah ini digunakan dalam buku ini.

Program ini terlaksana dengan ia sentiasa mencari padanan selagi while count < len(salinan) dan salinan[count] tidak sama dengan sebelum. Apabila sama ada count lebih daripada indeks terakhir salinan ataupun padanan ditemui justeru and tidak lagi benar, gelung akan berhenti atau keluar. Operator if hanya memeriksa untuk memastikan yang while keluar kerana tiada padanan ditemui.

"Muslihat" kedua and digunakan dalam contoh ini. Jika anda lihat rajah bagi and anda akan dapati bahawa entri ketiga ialah "palsu, dan tidak akan memeriksa". Jika count >= len(salinan) (dalam kata lain count < len(copy) ialah palsu), bahagian salinan[count] tidak akan diperiksa. Ini kerana Python tahu yang sekiranya yang pertama itu palsu, sudah semestinya kedua-duanya tidak boleh menjadi benar. Ini dikenali sebagai litar pintas dan berguna jika bahagian kedua and menyebabkan ralat jika sesuatu tidak kena. Saya mengguna ungkapan pertama (count < len(copy)) untuk mendapat kepastian sama ada count ialah indeks sah bagi salinan. (Jika anda tak percaya anda boleh buang padanan "Hayat" dan "Jill" dan periksa sama ada program masih bekerja dan kemudian terbalikkan urutan count < len(salinan) and salinan[count] != sebelum ke salinan[count] != sebelum and count < len(salinan).)

Ungkapan Boolean boleh digunakan apabila anda mahu memeriksa dua atau lebih perkara sekaligus.

Nota berkaitan dengan operator Boolean

Satu kesilapan yang sering dibuat prang yang baru mengatur cara adalah menyalah faham bagaimana operator Boolean bekerja, yang berpunca daripada cara pentafsir Python membaca ungkapan-ungkapan ini. Misalnya, selepas mempelajari kenyataan-kenyataan and dan or, seseorang itu mungkin membuat tanggapan bahawa ungkapan x == ('a' or 'b') akan memeriksa sama ada pemboleh ubah x sama dengan rentetan 'a' atau 'b'. Ia tidak begitu. Untuk melihat apa yang saya maksudkan, mulakan sesi interaktif dengan pentafsir dan masukkan ungkapan-ungkapan berikut:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Dan ini hasil kurang intuitifnya:

>>> 'a' == ('a' or 'b')
True
>>> 'b' == ('a' or 'b')
False
>>> 'a' == ('a' and 'b')
False 
>>> 'b' == ('a' and 'b')
True

Pada peringkat ini, operator-operator and dan or kelihatan seperti rosak. Tidak masuk akal yang, buat dua ungkapan terdahulu, 'a' sama dengan 'a' atau 'b' sementara 'b' tidak. Tambah lagi, tidak masuk akal yang 'b' sama dengan 'a' dan 'b'. Namun, selepas meneliti apa yang dilakukan pentafsir terhadap operator-operator Boolean, keputusan yang dipaparkan sebenarnya membuat apa yang anda minta, hanya ia tidak sama dengan apa yang anda fikir yang anda minta.

Apabila pentafsir Python melihat ungkapan or, ia mengambil kenyataan pertama dan memeriksa sama ada ia true atau benar. Jika kenyataan pertama benar, Python memulangkan nilai objek tanpa memeriksa kenyataan kedua. Ini kerana untuk ungkapan or, keseluruhan kenyataan itu benar jika satu daripada nilainya benar; program tidak perlu memeriksa bahagian kedua. Sebaliknya, jika nilai pertama dinilai sebagai false atau palsu, Python akan memeriksa bahagian kedua dan memulangkan nilai itu. Bahagian kedua itu menentukan nilai benar keseluruhan ungkapan oleh sebab bahagian pertama palsu. "Kemalasan" pentafsir ini digelar short circuiting (litar pintas) dan adalah cara penilaian ungkapan Boolean yang sering terjumpa dalam banyak bahasa pengaturcaraan.

Sama juga, bagi ungkapan and, Python menggunakan jalan pintas bagi mempercepatkan evaluasi nilai benar. Jika kenyataan pertama itu palsu, pada kiraan Python kesemua ungkapan itu palsu dan ia memulangkan nilai tersebut (yakni, false). Sebaliknya jika kenyataan pertama itu benar, Python akan memeriksa kenyataan kedua dan memulangkan nilainya.

Satu perkara yang harus anda maklum di sini adalah bahawa ungkapan Boolean memulangkan nilai yang menunjukkan True ataupun False, akan tetapi Python menganggap beberapa perkara yang berlainan sebagai memiliki nilai kebenaran yang terkait. Bagi memeriksa nilai kebenaran mana-mana objek x, anda boleh menggunakan fungsi bool(x) bagi melihat nilai kebenarannya. Jadual yang mengandungi contoh nilai kebenaran dihuraikan di bawah:

True	False
True	False
1	0
Nombor selain daripada sifar	Rentetan 'None'
Rentetan yang tak kosong	Rentetan kosong
Senarai yang tak kosong	Senarai kosong
Kamus yang tak kosong	Kamus kosong

Sekarang kita dapat memahami keputusan yang mengelirukan yang kita peroleh semasa menguji ungkapan-ungkapan Boolean sebelum ini. Mari kita tengok apa yang "dilihat" pentafsir Python semasa ia mengendalikan kod:

Kes pertama:

>>> 'a' == ('a' or 'b')  # Lihat tanda kurungan dahulu,  menilai ungkapan "('a' or 'b')"
                        # 'a' sebuah rentetan tak kosong, jadi nilai pertamanya True
                        # Memulangkan nilai pertama: 'a'
>>> 'a' == 'a'    # rentetan 'a' setara dengan rentetan 'a', jadi ungkapan menjadi True
True

Kes kedua:

>>> 'b' == ('a' or 'b')  # Lihat tanda kurungan dahulu, menilai ungkapan "('a' or 'b')"
                           # 'a' sebuah rentetan tak kosong, jadi nilai pertamanya True
                           # Memulangkan nilai pertama: 'a'
>>> 'b' == 'a'       # rentetan 'b' tidak setara dengan rentetan 'a', 
                           # jadi ungkapan menjadi False
False

Kes ketiga

>>> 'a' == ('a' and 'b') # Lihat tanda kurungan dahulu, menilai ungkapan "('a' and 'b')"
                           # 'a' sebuah rentetan tak kosong, jadi nilai pertamanya True, 
                           # periksa nilai kedua
                           # 'b' sebuah rentetan tak kosong, jadi nilai keduanya True
                           # Memulangkan nilai kedua hasil ungkapan penuh: 'b'
>>> 'a' == 'b'       # rentetan 'a' tidak setara dengan rentetan 'b', 
                           # jadi ungkapan adalah False
False

Kes keempat:

>>> 'b' == ('a' and 'b') # Lihat tanda kurungan dahulu, menilai ungkapan "('a' and 'b')"
                           # 'a' sebuah rentetan tak kosong, jadi nilai pertamanya True, 
                           # periksa nilai kedua
                           # 'b' sebuah rentetan tak kosong, jadi nilai keduanya True
                           # Memulangkan nilai kedua hasil ungkapan penuh: 'b'
>>> 'b' == 'b'       # rentetan 'b' setara dengan rentetan 'b', 
                           #jadi ungkapan adalah True

True

Jadi sebenarnya Python menjalankan tugasnya apabila ia mengembalikan keputusan yang sekali imbas kelihatan palsu. Seperti yang dinyatakan dahulu, perkara yang penting adalah pemastian nilai yang akan dipulangkan ungkapan Boolean selepas ia dinilai, oleh sebab operasi ini kadang kalanya tidak berapa jelas.

Berpulang kepada ungkapan-ungkapan awal, ini cara yang harus digunakan agar ungkapan-ungkapan tersebut bertindak dengan cara yang anda mahu:

>>> 'a' == 'a' or 'a' == 'b' 
True
>>> 'b' == 'a' or 'b' == 'b' 
True
>>> 'a' == 'a' and 'a' == 'b' 
False
>>> 'b' == 'a' and 'b' == 'b'
False

Apabila perbandingan-perbandingan ini dinilai, ungkapan-ungkapan Boolean akan memulangkan nilai kebenaran dalam bentuk True atau False, bukannya rentetan, jadi kita mendapat keputusan yang betul.

Contoh

kata_laluan1.py

## Program ini meminta nama pengguna dan kata laluan 
# Kemudian ia memeriksa kedua-dua bagi 
# memastikan pengguna dibenar masuk.

nama = raw_input("Siapa gerangan yang datang malam-malam begini?")
kata_laluan = raw_input("Apa kata laluan? ")
if nama == "Jefri" and kata_laluan == "Jambul":
    print "Selamat datang Jefri"
elif nama == "Zain" and kata_lauan == "Brylcreem":
    print "Selamat datang Zain"
else:
    print "Maaf, saya tidak mengenali anda."

Pengendalian sampel

Siapa gerangan yang datang malam-malam begini? Jefri
Apa kata laluan? Jambul
Selamat datang Jefri

Siapa gerangan yang datang malam-malam begini? Jins
Apa kata laluan? Yankee
Maaf, saya tidak mengenali anda.

Latihan

Tulis satu program yang meminta pengguna meneka nama anda, namun mereka cuma mendapat 3 peluang sebelum program itu tamat.

Penyelesaian

Tulis satu program yang meminta pengguna meneka nama anda, namun mereka cuma mendapat 3 peluang sebelum program itu tamat.

print "Cuba teka nama saya!"
kiraan = 0
nama = "Ahmad"
tekaan = raw_input("Apa nama saya? ")
while kiraan < 3 and tekaan != nama:
    print "Anda silap!"
    tekaan = raw_input("Apa nama saya? ")
    kiraan = kiraan + 1

if tekaan != nama:
    print "Anda silap!" # pesanan ini tidak dicetak pada cubaan ketiga, jadi kita cetak sekarang
    print "Anda kehabisan peluang."
    quit
else:
    print "Ya! Nama saya", nama + "!"

Kembali: Gelung For

Muka Depan

Seterusnya: Kamus