Teknik Elektro LinksThermostat, Panel Bel, Board Mikro, Driver Relay.

Belajar Python – Program Tabel Kebenaran Gerbang Logika AND, OR, NAND, NOR

Gerbang logika adalah blok rangkaian digital yang melambangkan proses operasi aljabar boolean. Kita mengenal gerbang logika AND, OR, XOR, NOT, NAND, NOR, XOR dan XNOR. Masing-masing gerbang logika memiliki satu jalur keluaran dan satu atau lebih jalur masukan. Gerbang logika dengan satu jalur masukan adalah gerbang NOT. Untuk gerbang logika yang lain jumlah masukan minimal adalah 2.

Gambar di bawah ini menunjukkan simbol gerbang logika dan tabel kebenarannya untuk 2 jalur masukan (kecuali gerbang NOT).

Gerbang Logika

Programmer dan orang teknik elektro sudah pasti hafal dengan simbol-simbol di atas.

Nah, di sini saya akan memberikan contoh program Python untuk membuat Tabel Kebenaran dari gerbang logika AND, OR, NAND dan NOR yang memiliki masukan dengan jumlah tertentu (ditentukan dengan parameter). Contoh program ini cukup bagus untuk pembelajaran Python karena di dalamnya terdapat contoh penggunaan dari:

  • fungsi
  • class
  • tuple
  • list
  • dictionary
  • penyeleksi-kondisi
  • perulangan
  • dan argument

Sebelum masuk kepada pembahasan program (secara singkat), marilah kita simak terlebih dahulu listing programnya secara keseluruhan.

Listing Program gates.py

#****************************************************
# Logic Gates Truth Table Generator for n logic input
# Gates: AND, OR, NAND, NOR
#
# Oleh: Chandra MDE
# Email: chandra at teknikelektrolinks.com
# Linux Forte - Linux For Teknik Elektro
# http://linux.teknikelektrolinks.com
#****************************************************

import sys

LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
Logic = {'0': False, '1': True}
Logix = {False: '0', True: '1'}

# Function AND with tuple input
def f_and(inputs):
    l = Logic[inputs[0]]
    for i in range(1, len(inputs)):
        l = l and Logic[inputs[i]]
    return l

# Function OR with tuple input
def f_or(inputs):
    l = Logic[inputs[0]]
    for i in range(1, len(inputs)):
        l = l or Logic[inputs[i]]
    return l

# Function NAND with tuple input
def f_nand(inputs):
    return not f_and(inputs)

# Function NOR with tuple input
def f_nor(inputs):
    return not f_or(inputs)

# Map a gate's name with it's correspondence function
Gates = {'AND': f_and, 'OR': f_or, 'NAND': f_nand, 'NOR': f_nor}

# Function integer-to-binary-string
def int2bin(intvalue, digit):
    binstr = ''; val = intvalue
    while val>0:
        if val % 2 == 0:
            binstr = '0' + binstr
        else:
            binstr = '1' + binstr
        val = val >> 1
    if len(binstr)<digit:
        binstr = '0'*(digit-len(binstr)) + binstr
    return binstr

# Simple Truth-Table Class
class TruthTable:
    "Generate a truth table for a logic gate with n inputs"
    def __init__(self, gate, numofinputs):
        if gate.upper() not in Gates:
            print "Wrong logic gate. Choose: AND, OR, NAND or NOR."
            quit()
        if numofinputs<2:
            numofinputs = 2
        if numofinputs>10:
            numofinputs = 10
        self.gate = gate.upper()
        self.numberofinputs = numofinputs
        self.logicoutput = []
        self.labels = [LETTERS[i] for i in range(self.numberofinputs)]
        self.labels.append('Y')
        self.logicinput = [tuple(int2bin(i, self.numberofinputs)) for i in range(2**self.numberofinputs)]
        for i in self.logicinput:
            l = Gates[self.gate](i) 
            self.logicoutput.append(l)

    def display(self):
        print
        print self.gate, "Gate with %i-Inputs" % self.numberofinputs + " Truth Table"
        print len(self.labels)*6*'-'
        for i in self.labels:
            print "%4s" % i,
        print
        print len(self.labels)*6*'-'
        x = 0
        for i in self.logicinput:
            for j in i:
                print "%4s" % j,
            print "%4s" % Logix[self.logicoutput[x]]
            x += 1
        print len(self.labels)*6*'-'
        print

# Example how to use class TruthTable
T = TruthTable(sys.argv[1], int(sys.argv[2]))
T.display()

Contoh program di atas dapat membangkitkan tabel kebenaran untuk gerbang AND, OR, NAND dan NOR. Gerbang yang lain saya sisakan untuk Anda tambahkan sendiri, anggap saja sebagai latihan.

class TruthTable

Kita mulai pembahasan singkat program di atas dengan class TruthTable. Class TruthTable didefinisikan sebagai berikut:

# Simple Truth-Table Class
class TruthTable:
    "Generate a truth table for a logic gate with n inputs"
    def __init__(self, gate, numofinputs):
        if gate.upper() not in Gates:
            print "Wrong logic gate. Choose: AND, OR, NAND or NOR."
            quit()
        if numofinputs<2:
            numofinputs = 2
        if numofinputs>10:
            numofinputs = 10
        self.gate = gate.upper()
        self.numberofinputs = numofinputs
        self.logicoutput = []
        self.labels = [LETTERS[i] for i in range(self.numberofinputs)]
        self.labels.append('Y')
        self.logicinput = [tuple(int2bin(i, self.numberofinputs)) for i in range(2**self.numberofinputs)]
        for i in self.logicinput:
            l = Gates[self.gate](i) # This is Python!
            self.logicoutput.append(l)

    def display(self):
        print
        print self.gate, "Gate with %i-Inputs" % self.numberofinputs + " Truth Table"
        print len(self.labels)*6*'-'
        for i in self.labels:
            print "%4s" % i,
        print
        print len(self.labels)*6*'-'
        x = 0
        for i in self.logicinput:
            for j in i:
                print "%4s" % j,
            print "%4s" % Logix[self.logicoutput[x]]
            x += 1
        print len(self.labels)*6*'-'
        print

Class TruthTable ini memiliki variabel instance antara lain:

  • gate – nama gerbang logika
  • numberofinputs – jumlah masukan
  • logicoutput – data keluaran dari kombinasi nilai masukan (2 pangkat n)
  • labels – label untuk masukan (A, B, C, dst) dan keluaran (Y)
  • logicinput – data kombinasi bit dari sejumlah masukan gerbang logika

Class TruthTable menerima 2 parameter yakni gate (nama gerbang) dan numofinputs (jumlah masukan). Nama gerbang logika dapat ditulis dengan huruf kapital maupun campuran. Nama gerbang akan selalu diubah menjadi kapital dengan perintah:

self.gate = gate.upper()

Jumlah masukan gerbang dibatasi paling sedikit adalah 2 dan paling banyak adalah 10. Anda bisa memodifikasi batas jumlah masukan maksimum sesuai kebutuhan.

Untuk membuat instance dari class TruthTable, caranya adalah sebagai berikut:

T1 = TruthTable('And', 4)   # Gerbang AND 4-Masukan
T2 = TruthTable('NaND', 7)  #Gerbang NAND 7-Masukan

Menyusun Tabel Kebenaran

Tabel kebenaran logika dibangkitkan dalam metode spesial (konstruktor) __init__(). Prosesnya diawali dengan membuat label untuk masukan dan keluaran. Perintahnya adalah sebagai berikut:

self.labels = [LETTERS[i] for i in range(self.numberofinputs)]
self.labels.append('Y')

Untuk jumlah masukan 5, maka variabel labels akan berisi ‘A’, ‘B’, ‘C’, ‘D’, ‘E’ dan ‘Y’.

Proses selanjutnya adalah membuat daftar kombinasi bit sesuai dengan jumlah masukan yang disimpan dalam variabel instance logicinput. Daftar kombinasi bit yang dibuat adalah sebanyak 2^n (2 pangkat n) dimana n adalah jumlah masukan gerbang logika. Perintahnya adalah sebagai berikut:

self.logicinput = [tuple(int2bin(i, self.numberofinputs)) for i in range(2**self.numberofinputs)]

Untuk jumlah masukan 3, maka logicinput akan berisi: (‘0′, ‘0’, ‘0’) hingga (‘1′, ‘1’, ‘1’). Type-casting tuple akan mengubah data string ‘000’ yang dihasilkan oleh fungsi int2bin menjadi (‘0′, ‘0’, ‘0’).

int2bin adalah fungsi untuk mengubah nilai integer menjadi biner (string). Saya membuat sendiri fungsi int2bin dengan definisi sebagai berikut:

# Function integer-to-binary-string
def int2bin(intvalue, digit):
    binstr = ''; val = intvalue
    while val>0:
        if val % 2 == 0:
            binstr = '0' + binstr
        else:
            binstr = '1' + binstr
        val = val >> 1
    if len(binstr)<digit:
        binstr = '0'*(digit-len(binstr)) + binstr
    return binstr

Sebenarnya kita bisa menggunakan fungsi bin yang telah disediakan Python. Sengaja saya buatkan fungsi int2bin untuk menambah arena latihan saja. Jika menggunakan fungsi bin, maka baris program di atas akan berubah menjadi:

self.logicinput = [tuple(bin(i)[2:].zfill(self.numberofinputs)) for i in range(2**self.numberofinputs)]

Anda bisa mencoba keduanya dengan hasil yang sama. Mencoba keduanya tentu akan memperkaya wawasan pemrograman Python.

Setelah daftar kombinasi bit masukan selesai dibuat, langkah selanjutnya adalah menyusun daftar keluaran dari masing-masing kombinasi masukan yang telah disusun sebelumnya. Bagian program yang menyusun daftar keluaran adalah:

for i in self.logicinput:
    l = Gates[self.gate](i)
    self.logicoutput.append(l)

Gates adalah variabel struktur data dictionary. Dengan menggunakan tipe data dictionary, kita bisa memetakan atau mengorelasikan antara nama gerbang dengan fungsi operasionalnya. Untuk memetakan nama gerbang dengan fungsinya, perintah yang digunakan adalah:

Gates = {'AND': f_and, 'OR': f_or, 'NAND': f_nand, 'NOR': f_nor}

Fungsi untuk gerbang AND adalah f_and. Fungsi untuk gerbang OR adalah f_or. Fungsi untuk gerbang NAND adalah f_nand. Dan fungsi untuk gerbang NOR adalah f_nor. Definisi dari fungsi-fungsi tersebut adalah sebagai berikut:

# Function AND with tuple input
def f_and(inputs):
    l = Logic[inputs[0]]
    for i in range(1, len(inputs)):
        l = l and Logic[inputs[i]]
    return l

# Function OR with tuple input
def f_or(inputs):
    l = Logic[inputs[0]]
    for i in range(1, len(inputs)):
        l = l or Logic[inputs[i]]
    return l

# Function NAND with tuple input
def f_nand(inputs):
    return not f_and(inputs)

# Function NOR with tuple input
def f_nor(inputs):
    return not f_or(inputs)

Pemetaan ini merupakan bagian dari trik untuk memudahkan proses penyusunan daftar keluaran. Perhatikaan baris perintah:

l = Gates[self.gate](i)

Dengan menggunakan dictionary, kita dapat memanggil fungsi operasional gerbang berdasarkan namanya. Cara seperti ini tentu lebih ringkas dibandingkan dengan melakukan seleksi nama gerbang.

Mencetak Tabel Kebenaran

Class TruthTable memiliki metode bernama display() yang berfungsi untuk menampilkan tabel kebenaran yang telah dibuat atau dibangkitkan (generated) oleh konstruktor __init__().

Ada beberapa trik yang terdapat dalam metode display, yakni yang pertama adalah:

print len(self.labels)*6*'-'

Perintah tersebut akan mencetak garis dari karakter ‘-‘. Jumlah karakter yang dicetak adalah 6 kali jumlah label yang terdiri dari masukan dan keluaran. Untuk gerbang logika dengan jumlah masukan 3, maka jumlah karakternya adalah 6 x (3 + 1) = 24 karakter.

Trik berikutnya adalah penggunaan variabel dictionary Logix.

print "%4s" % Logix[self.logicoutput[x]]

Logix adalah dictionary yang memetakan nilai False menjadi ‘0’ dan nilai True menjadi ‘1’. Variabel keluaran gerbang, yakni logicoutput, berisi daftar keluaran dari kombinasi bit masukan yang memiliki tipe data boolean. Tampilan yang kita inginkan adalah ‘0’ untuk False dan ‘1’ untuk True. Untuk itulah variabel Logix dibuat, yakni memudahkan proses pencetakan keluaran.

Trik yang sama juga diterapkan pada fungsi f_and dan f_or yang menggunakan variabel dictionary Logic untuk memetakan nilai ‘0’ menjadi False dan ‘1’ menjadi True, sehingga dapat dioperasikan secara aritmatika logika.

Program Utama

Program utama gates.py terdiri dari 2 baris perintah saja, yakni:

T = TruthTable(sys.argv[1], int(sys.argv[2]))
T.display()

Perintah pertama menciptakan instance objek TruthTable dengan parameter argument yang diberikan saat pemanggilan program. Selanjutnya ditampilkan tabel kebenaran sesuai dengan nama gerbang dan jumlah masukan.

Penggunaan Program

Untuk memanggil program gates.py, perintahnya adalah sebagai berikut:

$ python gates.py and 3
$ python gates.py or 6
$ python gates Nor 4

Hasil Eksekusi Program gates.py

Berikut ini adalah hasil eksekusi program untuk gerbang AND dengan 3 masukan dan gerbang NOR dengan 8 masukan.

Python Gerbang AND 3-Masukan

Untuk gerbang NOR dengan 8 masukan, hasil eksekusi saya alih-arahkan (redireksi) menjadi file dengan hasil sebagai berikut:

NOR Gate with 8-Inputs Truth Table
------------------------------------------------------
   A    B    C    D    E    F    G    H    Y
------------------------------------------------------
   0    0    0    0    0    0    0    0    1
   0    0    0    0    0    0    0    1    0
   0    0    0    0    0    0    1    0    0
   0    0    0    0    0    0    1    1    0
   0    0    0    0    0    1    0    0    0
   0    0    0    0    0    1    0    1    0
   0    0    0    0    0    1    1    0    0
   0    0    0    0    0    1    1    1    0
   0    0    0    0    1    0    0    0    0
   0    0    0    0    1    0    0    1    0
   0    0    0    0    1    0    1    0    0
   0    0    0    0    1    0    1    1    0
   0    0    0    0    1    1    0    0    0
   0    0    0    0    1    1    0    1    0
   0    0    0    0    1    1    1    0    0
   0    0    0    0    1    1    1    1    0
   0    0    0    1    0    0    0    0    0
   0    0    0    1    0    0    0    1    0
   0    0    0    1    0    0    1    0    0
   0    0    0    1    0    0    1    1    0
   0    0    0    1    0    1    0    0    0
   0    0    0    1    0    1    0    1    0
   0    0    0    1    0    1    1    0    0
   0    0    0    1    0    1    1    1    0
   0    0    0    1    1    0    0    0    0
   0    0    0    1    1    0    0    1    0
   0    0    0    1    1    0    1    0    0
   0    0    0    1    1    0    1    1    0
   0    0    0    1    1    1    0    0    0
   0    0    0    1    1    1    0    1    0
   0    0    0    1    1    1    1    0    0
   0    0    0    1    1    1    1    1    0
   0    0    1    0    0    0    0    0    0
   0    0    1    0    0    0    0    1    0
   0    0    1    0    0    0    1    0    0
   0    0    1    0    0    0    1    1    0
   0    0    1    0    0    1    0    0    0
   0    0    1    0    0    1    0    1    0
   0    0    1    0    0    1    1    0    0
   0    0    1    0    0    1    1    1    0
   0    0    1    0    1    0    0    0    0
   0    0    1    0    1    0    0    1    0
   0    0    1    0    1    0    1    0    0
   0    0    1    0    1    0    1    1    0
   0    0    1    0    1    1    0    0    0
   0    0    1    0    1    1    0    1    0
   0    0    1    0    1    1    1    0    0
   0    0    1    0    1    1    1    1    0
   0    0    1    1    0    0    0    0    0
   0    0    1    1    0    0    0    1    0
   0    0    1    1    0    0    1    0    0
   0    0    1    1    0    0    1    1    0
   0    0    1    1    0    1    0    0    0
   0    0    1    1    0    1    0    1    0
   0    0    1    1    0    1    1    0    0
   0    0    1    1    0    1    1    1    0
   0    0    1    1    1    0    0    0    0
   0    0    1    1    1    0    0    1    0
   0    0    1    1    1    0    1    0    0
   0    0    1    1    1    0    1    1    0
   0    0    1    1    1    1    0    0    0
   0    0    1    1    1    1    0    1    0
   0    0    1    1    1    1    1    0    0
   0    0    1    1    1    1    1    1    0
   0    1    0    0    0    0    0    0    0
   0    1    0    0    0    0    0    1    0
   0    1    0    0    0    0    1    0    0
   0    1    0    0    0    0    1    1    0
   0    1    0    0    0    1    0    0    0
   0    1    0    0    0    1    0    1    0
   0    1    0    0    0    1    1    0    0
   0    1    0    0    0    1    1    1    0
   0    1    0    0    1    0    0    0    0
   0    1    0    0    1    0    0    1    0
   0    1    0    0    1    0    1    0    0
   0    1    0    0    1    0    1    1    0
   0    1    0    0    1    1    0    0    0
   0    1    0    0    1    1    0    1    0
   0    1    0    0    1    1    1    0    0
   0    1    0    0    1    1    1    1    0
   0    1    0    1    0    0    0    0    0
   0    1    0    1    0    0    0    1    0
   0    1    0    1    0    0    1    0    0
   0    1    0    1    0    0    1    1    0
   0    1    0    1    0    1    0    0    0
   0    1    0    1    0    1    0    1    0
   0    1    0    1    0    1    1    0    0
   0    1    0    1    0    1    1    1    0
   0    1    0    1    1    0    0    0    0
   0    1    0    1    1    0    0    1    0
   0    1    0    1    1    0    1    0    0
   0    1    0    1    1    0    1    1    0
   0    1    0    1    1    1    0    0    0
   0    1    0    1    1    1    0    1    0
   0    1    0    1    1    1    1    0    0
   0    1    0    1    1    1    1    1    0
   0    1    1    0    0    0    0    0    0
   0    1    1    0    0    0    0    1    0
   0    1    1    0    0    0    1    0    0
   0    1    1    0    0    0    1    1    0
   0    1    1    0    0    1    0    0    0
   0    1    1    0    0    1    0    1    0
   0    1    1    0    0    1    1    0    0
   0    1    1    0    0    1    1    1    0
   0    1    1    0    1    0    0    0    0
   0    1    1    0    1    0    0    1    0
   0    1    1    0    1    0    1    0    0
   0    1    1    0    1    0    1    1    0
   0    1    1    0    1    1    0    0    0
   0    1    1    0    1    1    0    1    0
   0    1    1    0    1    1    1    0    0
   0    1    1    0    1    1    1    1    0
   0    1    1    1    0    0    0    0    0
   0    1    1    1    0    0    0    1    0
   0    1    1    1    0    0    1    0    0
   0    1    1    1    0    0    1    1    0
   0    1    1    1    0    1    0    0    0
   0    1    1    1    0    1    0    1    0
   0    1    1    1    0    1    1    0    0
   0    1    1    1    0    1    1    1    0
   0    1    1    1    1    0    0    0    0
   0    1    1    1    1    0    0    1    0
   0    1    1    1    1    0    1    0    0
   0    1    1    1    1    0    1    1    0
   0    1    1    1    1    1    0    0    0
   0    1    1    1    1    1    0    1    0
   0    1    1    1    1    1    1    0    0
   0    1    1    1    1    1    1    1    0
   1    0    0    0    0    0    0    0    0
   1    0    0    0    0    0    0    1    0
   1    0    0    0    0    0    1    0    0
   1    0    0    0    0    0    1    1    0
   1    0    0    0    0    1    0    0    0
   1    0    0    0    0    1    0    1    0
   1    0    0    0    0    1    1    0    0
   1    0    0    0    0    1    1    1    0
   1    0    0    0    1    0    0    0    0
   1    0    0    0    1    0    0    1    0
   1    0    0    0    1    0    1    0    0
   1    0    0    0    1    0    1    1    0
   1    0    0    0    1    1    0    0    0
   1    0    0    0    1    1    0    1    0
   1    0    0    0    1    1    1    0    0
   1    0    0    0    1    1    1    1    0
   1    0    0    1    0    0    0    0    0
   1    0    0    1    0    0    0    1    0
   1    0    0    1    0    0    1    0    0
   1    0    0    1    0    0    1    1    0
   1    0    0    1    0    1    0    0    0
   1    0    0    1    0    1    0    1    0
   1    0    0    1    0    1    1    0    0
   1    0    0    1    0    1    1    1    0
   1    0    0    1    1    0    0    0    0
   1    0    0    1    1    0    0    1    0
   1    0    0    1    1    0    1    0    0
   1    0    0    1    1    0    1    1    0
   1    0    0    1    1    1    0    0    0
   1    0    0    1    1    1    0    1    0
   1    0    0    1    1    1    1    0    0
   1    0    0    1    1    1    1    1    0
   1    0    1    0    0    0    0    0    0
   1    0    1    0    0    0    0    1    0
   1    0    1    0    0    0    1    0    0
   1    0    1    0    0    0    1    1    0
   1    0    1    0    0    1    0    0    0
   1    0    1    0    0    1    0    1    0
   1    0    1    0    0    1    1    0    0
   1    0    1    0    0    1    1    1    0
   1    0    1    0    1    0    0    0    0
   1    0    1    0    1    0    0    1    0
   1    0    1    0    1    0    1    0    0
   1    0    1    0    1    0    1    1    0
   1    0    1    0    1    1    0    0    0
   1    0    1    0    1    1    0    1    0
   1    0    1    0    1    1    1    0    0
   1    0    1    0    1    1    1    1    0
   1    0    1    1    0    0    0    0    0
   1    0    1    1    0    0    0    1    0
   1    0    1    1    0    0    1    0    0
   1    0    1    1    0    0    1    1    0
   1    0    1    1    0    1    0    0    0
   1    0    1    1    0    1    0    1    0
   1    0    1    1    0    1    1    0    0
   1    0    1    1    0    1    1    1    0
   1    0    1    1    1    0    0    0    0
   1    0    1    1    1    0    0    1    0
   1    0    1    1    1    0    1    0    0
   1    0    1    1    1    0    1    1    0
   1    0    1    1    1    1    0    0    0
   1    0    1    1    1    1    0    1    0
   1    0    1    1    1    1    1    0    0
   1    0    1    1    1    1    1    1    0
   1    1    0    0    0    0    0    0    0
   1    1    0    0    0    0    0    1    0
   1    1    0    0    0    0    1    0    0
   1    1    0    0    0    0    1    1    0
   1    1    0    0    0    1    0    0    0
   1    1    0    0    0    1    0    1    0
   1    1    0    0    0    1    1    0    0
   1    1    0    0    0    1    1    1    0
   1    1    0    0    1    0    0    0    0
   1    1    0    0    1    0    0    1    0
   1    1    0    0    1    0    1    0    0
   1    1    0    0    1    0    1    1    0
   1    1    0    0    1    1    0    0    0
   1    1    0    0    1    1    0    1    0
   1    1    0    0    1    1    1    0    0
   1    1    0    0    1    1    1    1    0
   1    1    0    1    0    0    0    0    0
   1    1    0    1    0    0    0    1    0
   1    1    0    1    0    0    1    0    0
   1    1    0    1    0    0    1    1    0
   1    1    0    1    0    1    0    0    0
   1    1    0    1    0    1    0    1    0
   1    1    0    1    0    1    1    0    0
   1    1    0    1    0    1    1    1    0
   1    1    0    1    1    0    0    0    0
   1    1    0    1    1    0    0    1    0
   1    1    0    1    1    0    1    0    0
   1    1    0    1    1    0    1    1    0
   1    1    0    1    1    1    0    0    0
   1    1    0    1    1    1    0    1    0
   1    1    0    1    1    1    1    0    0
   1    1    0    1    1    1    1    1    0
   1    1    1    0    0    0    0    0    0
   1    1    1    0    0    0    0    1    0
   1    1    1    0    0    0    1    0    0
   1    1    1    0    0    0    1    1    0
   1    1    1    0    0    1    0    0    0
   1    1    1    0    0    1    0    1    0
   1    1    1    0    0    1    1    0    0
   1    1    1    0    0    1    1    1    0
   1    1    1    0    1    0    0    0    0
   1    1    1    0    1    0    0    1    0
   1    1    1    0    1    0    1    0    0
   1    1    1    0    1    0    1    1    0
   1    1    1    0    1    1    0    0    0
   1    1    1    0    1    1    0    1    0
   1    1    1    0    1    1    1    0    0
   1    1    1    0    1    1    1    1    0
   1    1    1    1    0    0    0    0    0
   1    1    1    1    0    0    0    1    0
   1    1    1    1    0    0    1    0    0
   1    1    1    1    0    0    1    1    0
   1    1    1    1    0    1    0    0    0
   1    1    1    1    0    1    0    1    0
   1    1    1    1    0    1    1    0    0
   1    1    1    1    0    1    1    1    0
   1    1    1    1    1    0    0    0    0
   1    1    1    1    1    0    0    1    0
   1    1    1    1    1    0    1    0    0
   1    1    1    1    1    0    1    1    0
   1    1    1    1    1    1    0    0    0
   1    1    1    1    1    1    0    1    0
   1    1    1    1    1    1    1    0    0
   1    1    1    1    1    1    1    1    0
------------------------------------------------------

Download Program

Anda dapat mengunduh program gates.py menggunakan link berikut ini:

gates-python.zip

Penutup

Demikianlah listing program beserta penjelasan singkat tentang membuat tabel kebenaran gerbang logika menggunakan bahasa Python. Semoga tulisan ini bermanfaat bagi kita semua.

Terima kasih telah membaca dan selamat berkarya.

Add a Comment

Your email address will not be published. Required fields are marked *