Kategori
Python

Modul Python

Anda sudah lihat bagaimana Anda dapat menggunakan kembali kode di dalam program dengan membuat fungsi sekali saja. Bagaimana jika ingin menggunakan beberapa fungsi di program lain yang Anda tulis. Sebagaimana sudah ditebak, jawabannya adalah modul Python.

Ada beberapa metode dalam menulis modul, tapi cara yang paling mudah adalah membuat file dengan ekstensi .py yang berisi fungsi dan variabel.

Metode lain untuk menulis modul adalah dengan menulis modul di bahasa ibu di mana interpreter Python ditulis. Sebagai contoh, Anda dapat menulis modul di bahasa pemrograman C dan saat selesai dikompilasi, modul tersebut dapat digunakan dalam kode Python Anda dengan menggunakan interpreter Python standar.

Contoh Modul

Sebuah modul dapat diimpor oleh program lain dan menggunakan fungsinya. Cara ini juga kita pakai dalam memanfaatkan pustaka standar Python. Pertama, akan kita lihat dulu bagaimana menggunakan modul pustaka standar.

Contoh (simpan dengan nama pakai_sys.py):

import sys

print('Argumen baris perintahnya adalah:')
for i in sys.argv:
    print(i)

print('\n\n PYTHONPATH yang ditentukan adalah ', sys.path, '\n')

Keluaran:

$ python3 pakai_sys.py ini argumen kami
Argumen baris perintahnya adalah:
pakai_sys.py
ini
argumen
kami

PYTHONPATH yang ditentukan adalah [<nowiki>''</nowiki>, 'C:\\Windows\\system32\\python30.zip',
'C:\\Python30\\DLLs', 'C:\\Python30\\lib',
'C:\\Python30\\lib\\plat-win', 'C:\\Python30', 
'C:\\Python30\\lib\\site-packages']

Bagaimana Cara Kerjanya

Pertama, kita melakukan import modul sys lewat statemen import. Pada dasarnya, ini bisa diterjemahkan sebagai keinginan kita kepada Python bahwa kita ingin menggunakan modul ini. Modul sys berisi fungsi yang berkaitan dengan interpreter Python dan lingkungannya, antara lain system.

Saat Python mengeksekusi statemen import sys, dia akan mencari modul sys. Dalam hal ini, modul tersebut merupakan modul built-in, sehingga Python langsung tahu di mana mencarinya.

Jika modul yang diinginkan bukan modul terkompilasi, atau modul yang ditulis di Python, maka interpreter Python akan mencari direktori yang terdaftar dalam variabel sys.path. Jika modul ditemukan, maka isi modul tersebut dijalankan dan modul akan tersedia untuk Anda gunakan. Catat bahwa inisialisasi dilakukan saat pertama kali kita mengimpor modul.

Variabel argv di dalam modul sys akan diakses dengan notasi titik, misal sys.argv. Ini secara jelas mengindikasikan bahwa nama tersebut merupakan bagian dari modul sys. Keuntungan lain dari pendekatan ini adalah bahwa nama fungsi tersebut tidak akan bentrok dengan variabel argv yang digunakan di dalam program Anda.

Variabel sys.argv berisi list string (lists dijelaskan lebih detail di bab berikutnya). Secara lebih khusus sys.argv berisi list dari seluruh argumen baris perinta yakni seluruh argumen yang dituliskan pada program Anda saat menjalankannya di baris perintah.

Jika Anda menggunakan IDE untuk menulis dan menjalankan program ini, cari cara untuk menambahkan argumen program dari menu.

Di sini, ketika kita mengeksekusi python pakai_sys ini argumen kami, kita menjalankan modul pakai_sys.py lewat perintah python dan kata-kata yang ditulis setelahnya adalah argumen yang dilemparkan ke dalam program. Python menyimpan baris argumen di variabel sys.argv untuk dapat kita manfaaatkan.

Ingat, nama dari skrip yang dijalankan akan selalu menjadi argumen pertama dalam list sys.argv. Sehingga dalam kasus ini 'pakai_sys.py' sebagai sys.argv[0]'ini' sebagai sys.argv[1]'argumen' sebagai sys.argv[2] dan 'kami' sebagai sys.argv[3]. Perhatikan bahwa Python menghitung dari 0, dan bukan 1.

sys.path berisi daftar nama direktori tempat di mana modul-modul diimpor. Coba perhatikan bahwa string pertama dari sys.path tidak ada isinya – string kosong ini mengindikasikan bahwa direktori program tersebut dijalankan juga merupakan bagian dari sys.path, yang sama dengan environment variable PYTHONPATH. Ini berarti Anda dapat mengimpor modul secara langsung dari direktori tempat file berada saat ini. Jika tidak maka Anda harus meletakkan modul di dalam salah satu direktori yang terdaftar dalam sys.path.

Catat bahwa direktori saat ini adalah direktori tempat program ini dijalankan. Jalankan import os; print(os.getcwd()) untuk mencari direktori program Anda saat ini.

Berkas Byte-compiled .pyc

Mengimpor modul relatif sangat mahal sumber daya, sehingga Python punya trik untuk membuatnya lebih cepat. Salah satu cara adalah membuat berkas byte-compiled (terkompilasi dalam bahasa mesin) dengan ekstensi .pyc. Berkas .pyc ini merupakan bentuk lanjut yang diubah oleh Python ke dalam bahasa yang lebih dekat dengan mesin (ingat bagian pengenalan bagaimana Python bekerja?). Berkas .pyc ini berguna saat Anda lain kali mengimpor modul dari program yang berbeda – modul tersebut akan dijalankan lebih cepat mengingat bagian dari proses yang dibutuhkan untuk mengimpor modul sudah pernah dilaksanakan. Juga, berkas byte-compiled ini tidak tergantung terhadap platform (platform-independent).Catatan

Berkas .pyc biasanya dibuat di dalam direktori yang sama dari berkas .py. Jika Python tidak punya izin untuk menulis berkas ke dalam direktori tersebut, maka berkas .pyc tidak akan dibuat.

Statemen from … import

Jika Anda secara langsung mengimport argv ke dalam program Anda (untuk menghindari sys. setiap kali akan menggunakannya), maka Anda dapat menggunakan statemen from sys import argv.

Secara umum, Anda sebisa mungkin menghindari penggunaan statemen ini dan gunakan statemen import agar program Anda dapat menghindari bentrokan nama modul dan program lebih mudah dibaca.

Contoh:

from math import sqrt
print("Akar dari 16 adalah ", sqrt(16))

name di Dalam Modul

Setiap modul memiliki nama dan statemen yang dapat memberikan informasi nama modul. Hal ini bermanfaat untuk kepentingan khusus apakah modul tersebut jalan sendiri atau berjalan lewat import. Sebagaimana telah disebutkan sebelumnya, saat sebuah modul diimpor pertama kali, kode di dalamnya akan dieksekusi terlebih dahulu. Kita dapat menggunakan hal ini untuk membuat modul memberikan keluaran yang berbeda tergantung apakah modul tersebut digunakan secara sendiri, atau diimpor lewat modul lain. Ini dapat dicapai dengan atribut __name__ di dalam modul.

Contoh (simpan dengan nama pakai_nama.py):

if __name__ == '__main__':
    print('Program ini dijalankan sendiri')
else:
    print('Saya diimpor dari modul lain')

Keluaran:

$ python3 pakai_nama.py
Program ini dijalankan sendiri

$ python3
>>> import pakai_nama
Saya diimpor dari modul lain
>>>

Bagaimana Cara Kerjanya

Setiap modul python memiliki definisi __name__ di dalamnya. Jika saat ini program berjalan sama dengan nilai definisi '__main', maka hal tersebut menunjukkan bahwa modul dijalankan secara sendirian (standalone) oleh pengguna, dan kita dapat menuliskan tindak lanjut yang sesuai dari kondisi tersebut.

Membuat Modul Python Anda Sendiri

Membuat modul Anda sendiri relatif mudah, Anda sudah melakukannya selama ini! Hal ini terjadi karena setiap program Python adalah sebuah modul. Anda hanya perlu memastikan program tersebut memiliki ekstensi .py. Gambaran lebih jelas dapat dilihat dalam contoh berikut.

Contoh (simpan dengan nama modulku.py):

def katakanhai():
    print('Hai, ini modulku berbicara.')

__version__ = '0.1'

Baris kode di atas adalah contoh modul. Sebagaimana Anda lihat, tidak ada yang khusus tentangnya dibandingkan dengan program Python yang biasa kita buat. Kita akan lihat berikutnya, bagaimana menggunakan modul tersebut di dalam program Python yang lain.

Ingat bahwa modul harus diletakkan pada direktori yang sama dengan program yang mengimpornya, atau salah satu dari direktori yang terdaftar di sys.path.

Modul lain (simpan dengan nama demo_modulku.py):

import modulku

modulku.katakanhai()
print ('Versi', modulku.__version__)

Keluaran:

$ python3 demo_modulku.py
Hai, ini modulku berbicara.
Versi 0.1

Bagaimana Cara Kerjanya

Perhatikan bahwa kita menggunakan notasi bertitik yang sama untuk mengakses anggota modul. Python membuat penggunaan kembali secara baik dengan notasi yang sama untuk memberikan rasa ‘Pythonic’ sehingga kita tidak harus belajar cara baru untuk mengerjakan hal-hal lainnya.

Berikut versi yang menggunakan sintaks from..import (simpan dengan nama demo2_modulku.py):

from modulku import katakanhai, __version__

katakanhai()
print('Versi', __version__)

Keluaran demo2_modulku.py sama dengan keluaran demo_modulku.py.

Perhatikan bahwa jika ada __version__ yang dideklarasikan sebelumnya oleh demo_modulku.py atau demo2_modulku.py maka akan terjadi bentrok. Ini juga karena praktik yang umum pada setiap modul untuk mendeklarasikan versi dengan menggunakan namanya. Sehingga, selalu direkomendasikan untuk statemen import meskipun hal itu membuat program Anda sedikit lebih lama.

Anda dapat juga menggunakan:

from modulku import *

Ini akan mengimpor seluruh nama publik seperti katakanhai tapi tidak akan mengimpor __version__ karena nama tersebut diawali dengan dua garis bawah.Zen of Python

Salah satu prinsip panduan Python adalah bahwa “Eksplisit lebih baik daripada Implicit”. Jalankan import this untuk mempelajari prinsip-prinsip lainnya dan lihat diskusi di StackOverflow tentang hal ini yang membuat daftar contoh dari masing-masing prinsip.

Fungsi dir

Anda dapat menggunakan fungsi built-in (sudah ada secara otomatis) dir untuk melihat daftar seluruh nama yang didefinisikan oleh objek (dalam hal ini didefinisikan oleh sebuah modul). Dalam hal modul, fungsi dir() akan memuat daftar seluruh fungsi, kelas dan variabel yang didefinisikan oleh modul tersebut.

Jika Anda memberikan nama modul untuk fungsi dir(), akan memberikan daftar nama yang didefinisikan dalam modul yang dimasukkan tersebut. Jika tidak memasukkan argumen, maka akan mengembalikan nama yang didefinisikan oleh modul yang dipakai saat ini.

Contoh:

$ python3

>>> import sys # mengambil seluruh atribut, dalam kasus ini, dari modul sys

>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s
tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists',
'_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', '
byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle'
, 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable',
'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfil
esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof',
'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode
', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platfor
m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_in
fo', 'warnoptions', 'winver']

>>> dir() # menampilkan daftar seluruh atribut dari modul yang sedang dijalankan
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>> a = 5 # membuat variabel baru 'a'

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']

>>> del a # menghapus nama a

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>>

Bagaimana Cara Kerjanya:

Pertama, kita lihat penggunaan dir dari modul sys yang telah diimpor sebelumnya. Kita lihat banyak sekali daftar atribut yang ada di dalamnya.

Selanjutnya, kita menggunakan fungsi dir tanpa memasukkan parameter. Secara baku, fungsi tersebut mengembalikan daftar seluruh atribut dari modul yang sedang dijalankan. Perhatikan bahwa daftar modul yang diimpor juga merupakan bagian dari daftar ini.

Dalam rangka observasi dir, kita mendefinisikan variabel baru dengan nama a lalu memberinya nilai. Saat kita cek dengan dir kita akan melihat baris tambahan dari daftar yang sama. Kita menghapus variabel/atribut dari modul saat ini dengan statemen del dan perubahan tersebut akan langsung terlihat dalam keluaran fungsi dir.

A note on del – this statement is used to delete a variable/name and after the statement has run, in this case del a, you can no longer access the variable a – it is as if it never existed before at all.

Catat bahwa fungsi dir() dapat dijalankan dalam setiap objek. Sebagai contoh, jalankan dir('print') untuk mempelajari fungsi print, atau dir(str) untuk atribut-atribut yang ada dalam kelas str.

Paket

Hingga saat ini, Anda seharusnya sudah mulai belajar mengobservasi hierarki dari struktur program Anda. Variabel biasanya ada di dalam fungsi. Fungsi dan variabel global biasanya ada di dalam modul. Bagaimana jika Anda ingin mengatur modul supaya lebih terorganisir? Saatnya kita berkenalan dengan struktur baru bernama paket.

Paket hanyalah berupa folder yang didalamnya berisi modul, dengan satu tambahan berkas khusus bernama __init__.py, yang mengindikasikan kepada Python bahwa folder tersebut khusus berisi modul Python.

Sebagai contoh Anda ingin membuat paket bernama ‘world’ dengan sub paket bernama ‘asia’, ‘afrika’, dan seterusnya, dan sub paket ini berisi modul dengan nama ‘india’, ‘madagaskar’ dan seterusnya.

Begini seharusnya struktur di dalam folder:

- <salah satu folder yang ada dalam sys.path>/
    - world/
        - __init__.py
        - asia/
            - __init__.py
            - india/
                - __init__.py
                - foo.py
        - afrika/
            - __init__.py
            - madagaskar/
                - __init__.py
                - bar.py

Paket hanyalah berupa cara yang nyaman untuk menata modul secara lebih teroganisir. Anda dapat lihat contoh-contohnya dalam pustaka standar.

Ringkasan

Sebagaimana fungsi yang merupakan bagian dari program yang dapat digunakan kembali, modul adalah program yang dapat digunakan kembali. Paket adalah hierarki di atasnya untuk membuat modul dapat lebih tertata. Pustaka standar yang ada di dalam Python adalah contoh yang dapat dilihat bagaimana hierarki dari paket dan modul.

Kita telah melihat bagaimana menggunakan modul ini dan membuat modul kita sendiri.

Berikutnya, kita akan belajar konsep menarik lainnya yang bernama struktur data.

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *