Python adalah bahasa pemrograman yang berdaya dan mudah dipelajari. Python memiliki struktur data tingkat tinggi yang efisien dan pendekatan yang sederhana namun efektif untuk pemrograman berorientasi objek. Sintaksis Python yang elegan dan tipe dinamis, bersama dengan sifatnya yang diinterpretasikan, menjadikannya bahasa yang ideal untuk skrip dan pengembangan aplikasi yang cepat di banyak area di sebagian besar platform.
The Python interpreter and the extensive standard library are freely available in source or binary form for all major platforms from the Python web site, //www.python.org/, and may be freely distributed. The same site also contains distributions of and pointers to many free third party Python modules, programs and tools, and additional documentation.
Interpreter Python mudah dikembangkan dengan fungsi dan tipe data baru diimplementasikan dalam C atau C ++ (atau bahasa lain yang bisa dipanggil dari C). Python juga cocok sebagai bahasa tambahan untuk aplikasi yang dapat disesuaikan.
Tutorial ini memperkenalkan pembaca secara informal ke konsep dan fitur dasar bahasa dan sistem Python. Akan membantu untuk memiliki interpreter Python yang praktis untuk pengalaman mencoba langsung, tetapi semua contoh mandiri, sehingga tutorialnya dapat dibaca secara off-line juga.
Untuk deskripsi objek dan modul standar, lihat . memberikan definisi bahasa yang lebih formal. Untuk menulis ekstensi dalam C atau C ++, baca dan . Ada juga beberapa buku yang membahas Python secara mendalam.
Tutorial ini tidak mencoba menjadi komprehensif dan mencakup semua fitur, atau bahkan setiap fitur yang umum digunakan. Alih-alih, ini memperkenalkan banyak fitur Python yang paling penting, dan akan memberi Anda ide bagus tentang rasa dan gaya bahasa itu. Setelah membacanya, Anda akan dapat membaca dan menulis modul serta program Python, dan Anda akan siap untuk mempelajari lebih lanjut tentang berbagai modul pustaka Python yang dijelaskan dalam .
Jika Anda berhenti dari interpreter Python dan memasukkannya lagi, definisi yang Anda buat (fungsi dan variabel) akan hilang. Karena itu, jika Anda ingin menulis program yang agak lebih panjang, Anda lebih baik menggunakan editor teks untuk menyiapkan input bagi penerjemah dan menjalankannya dengan file itu sebagai input. Ini dikenal sebagai membuat script. Saat program Anda menjadi lebih panjang, Anda mungkin ingin membaginya menjadi beberapa file untuk pengelolaan yang lebih mudah. Anda mungkin juga ingin menggunakan fungsi praktis yang Anda tulis di beberapa program tanpa menyalin definisi ke setiap program.
Untuk mendukung ini, Python memiliki cara untuk meletakkan definisi dalam file dan menggunakannya dalam skrip atau dalam contoh interaktif dari interpreter. File seperti itu disebut module; definisi dari modul dapat imported ke modul lain atau ke modul main (kumpulan variabel yang Anda memiliki akses ke dalam skrip yang dieksekusi di tingkat atas dan dalam mode kalkulator).
Modul adalah file yang berisi definisi dan pernyataan Python. Nama berkas adalah nama modul dengan akhiran >>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 7 diakhirnya. Dalam sebuah modul, nama modul (sebagai string) tersedia sebagai nilai variabel global >>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 8. Misalnya, gunakan editor teks favorit Anda untuk membuat bernama bernama >>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 9 di direktori saat ini dengan konten berikut
# Fibonacci numbers module def fib(n): # write Fibonacci series up to n a, b = 0, 1 while a < n: print(a, end=' ') a, b = b, a+b print() def fib2(n): # return Fibonacci series up to n result = [] a, b = 0, 1 while a < n: result.append(a) a, b = b, a+b return result
Sekarang masukkan interpreter Python dan impor modul ini dengan perintah berikut:
>>> import fibo
This does not add the names of the functions defined in >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 directly to the current (see for more details); it only adds the module name >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 there. Using the module name you can access the functions:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo'
Jika Anda sering ingin menggunakan suatu fungsi, Anda dapat menetapkannya ke nama lokal:
>>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6.1. Lebih lanjut tentang Modul
Modul dapat berisi pernyataan yang dapat dieksekusi serta definisi fungsi. Pernyataan ini dimaksudkan untuk menginisialisasi modul. Mereka dieksekusi hanya first kali nama modul ditemui dalam pernyataan impor. (Mereka juga dijalankan jika file dieksekusi sebagai skrip.)
Each module has its own private namespace, which is used as the global namespace by all functions defined in the module. Thus, the author of a module can use global variables in the module without worrying about accidental clashes with a user's global variables. On the other hand, if you know what you are doing you can touch a module's global variables with the same notation used to refer to its functions, >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 2.
Modules can import other modules. It is customary but not required to place all statements at the beginning of a module (or script, for that matter). The imported module names, if placed at the top level of a module (outside any functions or classes), are added to the module's global namespace.
There is a variant of the statement that imports names from a module directly into the importing module's namespace. For example:
>>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
This does not introduce the module name from which the imports are taken in the local namespace (so in the example, >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 is not defined).
Bahkan ada varian untuk mengimpor semua nama yang didefinisikan oleh modul:
>>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Ini mengimpor semua nama kecuali yang dimulai dengan garis bawah (>>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 6). Dalam kebanyakan kasus, programmer Python tidak menggunakan fasilitas ini karena ia memperkenalkan sekumpulan nama yang tidak diketahui ke dalam interpreter, mungkin menyembunyikan beberapa hal yang sudah Anda definisikan.
Perhatikan bahwa secara umum praktik mengimpor >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7 dari modul atau paket tidak disukai, karena sering menyebabkan kode yang kurang dapat dibaca. Namun, boleh saja menggunakannya untuk menghemat pengetikan di sesi interaktif.
Jika nama modul diikuti oleh >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 8, maka nama setelah >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 8 terikat langsung ke modul yang diimpor.
>>> import fibo as fib >>> fib.fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Ini secara efektif mengimpor modul dengan cara yang sama dengan >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 akan dilakukan, dengan satu-satunya perbedaan adalah sebagai >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 1.
Itu juga dapat digunakan ketika menggunakan dengan efek yang sama:
>>> from fibo import fib as fibonacci >>> fibonacci(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Catatan
Untuk alasan efisiensi, setiap modul hanya diimpor satu kali per sesi interpreter. Karenanya, jika Anda mengubah modul, Anda harus memulai ulang interpreter -- atau, jika hanya satu modul yang ingin Anda uji secara interaktif, gunakan , mis. >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 4.
6.1.1. Mengoperasikan modul sebagai skrip
Ketika Anda mengoperasikan modul Python dengan
python fibo.py <arguments>
kode dalam modul akan dieksekusi, sama seperti jika Anda mengimpornya, tetapi dengan >>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 8 diatur ke >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 6. Itu berarti bahwa dengan menambahkan kode ini di akhir modul Anda
if __name__ == "__main__": import sys fib(int(sys.argv[1]))
Anda dapat membuat berkas dapat digunakan sebagai skrip dan juga modul yang dapat diimpor, karena kode yang mengurai parsing baris perintah hanya beroperasi jika modul dieksekusi sebagai berkas "main":
>>> import fibo 0
Jika modul diimpor, kode ini tidak dioperasikan
>>> import fibo 1
Ini sering digunakan baik untuk menyediakan antarmuka pengguna yang nyaman ke modul, atau untuk tujuan pengujian (menjalankan modul sebagai skrip mengeksekusi rangkaian pengujian).
6.1.2. Jalur Pencarian Modul
When a module named >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7 is imported, the interpreter first searches for a built-in module with that name. These module names are listed in . If not found, it then searches for a file named >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 9 in a list of directories given by the variable . is initialized from these locations:
Direktori yang berisi skrip masukan (atau direktori saat ini ketika tidak ada file ditentukan).
(daftar nama direktori, dengan sintaksis yang sama dengan variabel shell >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 3).
The installation-dependent default (by convention including a >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 4 directory, handled by the module).
Catatan
Pada sistem file yang mendukung symlink, direktori yang berisi skrip masukan dihitung setelah symlink diikuti. Dengan kata lain direktori yang berisi symlink not ditambahkan ke jalur pencarian modul.
Setelah inisialisasi, program Python dapat memodifikasi: data :sys.path. Direktori yang berisi skrip yang dijalankan ditempatkan di awal jalur pencarian, di depan jalur pustaka standar. Ini berarti bahwa skrip dalam direktori itu akan dimuat bukan modul dengan nama yang sama di direktori pustaka. Ini adalah kesalahan kecuali penggantian memang diharapkan. Lihat bagian untuk informasi lebih lanjut.
6.1.3. Berkas Python "Compiled"
Untuk mempercepat memuat modul, Python menyimpan cache versi terkompilasi dari setiap modul di direktori >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 6 dengan nama >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7, di mana versi menyandikan format berkas terkompilasi; umumnya berisi nomor versi Python. Misalnya, dalam rilis CPython 3.3 versi yang dikompilasi dari spam.py akan di-cache sebagai >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 8. Konvensi penamaan ini memungkinkan modul yang dikompilasi dari rilis yang beragam dan versi Python yang berbeda untuk hidup berdampingan.
Python memeriksa tanggal modifikasi sumber terhadap versi yang dikompilasi untuk melihat apakah itu kedaluwarsa dan perlu dikompilasi ulang. Ini adalah proses yang sepenuhnya otomatis. Juga, modul yang dikompilasi adalah platform-independen, sehingga perpustakaan yang sama dapat dibagi di antara sistem dengan arsitektur yang berbeda.
Python tidak memeriksa cache dalam dua keadaan. Pertama, selalu mengkompilasi ulang dan tidak menyimpan hasil untuk modul yang dimuat langsung dari baris perintah. Kedua, itu tidak memeriksa cache jika tidak ada modul sumber. Untuk mendukung distribusi non-sumber (dikompilasi saja), modul yang dikompilasi harus ada di direktori sumber, dan tidak boleh ada modul sumber.
Beberapa tips untuk para ahli:
Anda dapat menggunakan atau mengaktifkan perintah Python untuk mengurangi ukuran modul yang dikompilasi. Saklar >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 9 menghapus pernyataan tegas assert, saklar >>> import fibo as fib >>> fib.fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 menghapus pernyataan tegas assert dan string __doc__. Karena beberapa program bergantung pada ketersediaannya, Anda hanya boleh menggunakan opsi ini jika Anda tahu apa yang Anda lakukan. Modul "Optimized" memiliki tag >>> import fibo as fib >>> fib.fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 3 dan biasanya lebih kecil. Rilis di masa depan dapat mengubah efek pengoptimalan.
Suatu program tidak berjalan lebih cepat ketika itu dibaca dari file >>> import fibo as fib >>> fib.fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 4 daripada ketika itu dibaca dari file >>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 7; satu-satunya hal yang lebih cepat tentang berkas >>> import fibo as fib >>> fib.fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 4 adalah kecepatan memuatnya.
Modul dapat membuat berkas .pyc untuk semua modul dalam direktori.
Ada detail lebih lanjut tentang proses ini, termasuk bagan alur keputusan, di PEP 3147.
6.2. Modul Standar
Python dilengkapi dengan pustaka modul standar, yang dijelaskan dalam dokumen terpisah, Referensi Pustaka Python ("Library Reference" selanjutnya). Beberapa modul dibangun ke dalam interpreter; ini menyediakan akses ke operasi yang bukan bagian dari inti bahasa tetapi tetap dibangun, baik untuk efisiensi atau untuk menyediakan akses ke sistem operasi primitif seperti pemanggilan sistem. Himpunan modul tersebut adalah opsi konfigurasi yang juga tergantung pada platform yang mendasarinya. Sebagai contoh, modul hanya disediakan pada sistem Windows. Satu modul tertentu patut mendapat perhatian: , yang dibangun ke dalam setiap interpreter Python. Variabel >>> from fibo import fib as fibonacci >>> fibonacci(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 dan >>> from fibo import fib as fibonacci >>> fibonacci(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 1 menentukan string yang digunakan sebagai prompt primer dan sekunder
>>> import fibo 2
Kedua variabel ini hanya ditentukan jika interpreter dalam mode interaktif.
Variabel >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 adalah daftar string yang menentukan jalur pencarian interpreter untuk modul. Ini diinisialisasi ke jalur default yang diambil dari variabel lingkungan , atau dari bawaan bawaan jika tidak disetel. Anda dapat memodifikasinya menggunakan operasi standar untuk list:
>>> import fibo 3
6.3. Fungsi
Fungsi bawaan digunakan untuk mencari tahu nama-nama yang ditentukan oleh modul. Ia mengembalikan list string yang diurutkan:
>>> import fibo 4
Tanpa argumen, mencantumkan nama yang telah Anda tentukan saat ini:
>>> import fibo 5
Perhatikan bahwa ini mencantumkan semua jenis nama: variabel, modul, fungsi, dll.
tidak mencantumkan nama fungsi dan variabel bawaan. Jika Anda ingin daftar itu, mereka didefinisikan dalam modul standar :
>>> import fibo 6
6.4. Paket
Paket adalah cara penataan namespace modul Python dengan menggunakan "dotted module names". Sebagai contoh, nama modul python fibo.py <arguments> 0 menetapkan submodule bernama python fibo.py <arguments> 1 dalam sebuah paket bernama python fibo.py <arguments> 2. Sama seperti penggunaan modul menyelamatkan penulis modul yang berbeda dari harus khawatir tentang nama variabel global masing-masing, penggunaan nama modul bertitik menyelamatkan penulis paket multi-modul seperti NumPy atau Pillow dari harus khawatir tentang nama modul masing-masing .
Misalkan Anda ingin merancang koleksi modul ("paket") untuk penanganan berkas suara dan data suara yang seragam. Ada banyak format berkas suara yang berbeda (biasanya dikenali oleh ekstensi mereka, misalnya: python fibo.py <arguments> 3, python fibo.py <arguments> 4, python fibo.py <arguments> 5), jadi Anda mungkin perlu membuat dan memelihara koleksi modul yang terus bertambah untuk konversi antara berbagai format file. Ada juga banyak operasi berbeda yang mungkin ingin Anda lakukan pada data suara (seperti mencampur, menambahkan gema, menerapkan fungsi equalizer, menciptakan efek stereo buatan), jadi selain itu Anda akan menulis aliran modul tanpa henti untuk melakukan operasi ini. Berikut adalah struktur yang mungkin untuk paket Anda (dinyatakan dalam hierarki sistem file):
>>> import fibo 7
Saat mengimpor paket, Python mencari melalui direktori pada >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 0 mencari subdirektori paket.
Berkas python fibo.py <arguments> 7 diperlukan untuk membuat Python memperlakukan direktori yang berisi file sebagai paket. Ini mencegah direktori dengan nama umum, seperti python fibo.py <arguments> 8, menyembunyikan modul valid yang muncul kemudian pada jalur pencarian modul. Dalam kasus yang paling sederhana, :file: __init__.py dapat berupa file kosong, tetapi juga dapat menjalankan kode inisialisasi untuk paket atau mengatur variabel python fibo.py <arguments> 9, dijelaskan nanti.
Pengguna paket dapat mengimpor modul individual dari paket, misalnya:
>>> import fibo 8
Ini memuat submodule if __name__ == "__main__": import sys fib(int(sys.argv[1])) 0. Itu harus dirujuk dengan nama lengkapnya.
>>> import fibo 9
Cara alternatif mengimpor submodule adalah:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 0
Ini juga memuat submodul :mod: echo, dan membuatnya tersedia tanpa awalan paketnya, sehingga dapat digunakan sebagai berikut:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 1
Namun variasi lain adalah mengimpor fungsi atau variabel yang diinginkan secara langsung:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 2
Sekali lagi, ini memuat submodul if __name__ == "__main__": import sys fib(int(sys.argv[1])) 1, tetapi ini membuat fungsinya if __name__ == "__main__": import sys fib(int(sys.argv[1])) 2 langsung tersedia:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 3
Perhatikan bahwa ketika menggunakan if __name__ == "__main__": import sys fib(int(sys.argv[1])) 3, item tersebut dapat berupa submodul (atau subpaket) dari paket, atau beberapa nama lain yang ditentukan dalam paket, seperti fungsi, kelas atau variabel. Pernyataan >>> fib = fibo.fib >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 3 pertama menguji apakah item tersebut didefinisikan dalam paket; jika tidak, ini dianggap sebagai modul dan mencoba memuatnya. Jika gagal menemukannya, pengecualian dimunculkan.
Sebaliknya, ketika menggunakan sintaksis seperti if __name__ == "__main__": import sys fib(int(sys.argv[1])) 6, setiap item kecuali yang terakhir harus berupa paket; item terakhir dapat berupa modul atau paket tetapi tidak bisa berupa kelas atau fungsi atau variabel yang didefinisikan dalam item sebelumnya.
6.4.1. Mengimpor * Dari Paket
Sekarang apa yang terjadi ketika pengguna menulis if __name__ == "__main__": import sys fib(int(sys.argv[1])) 7? Idealnya, orang akan berharap bahwa ini entah bagaimana keluar ke sistem file, menemukan submodul mana yang ada dalam paket, dan mengimpor semuanya. Ini bisa memakan waktu lama dan mengimpor submodul mungkin memiliki efek samping yang tidak diinginkan yang seharusnya hanya terjadi ketika submodul diimpor secara eksplisit.
Satu-satunya solusi adalah bagi pembuat paket untuk memberikan indeks paket secara eksplisit. Pernyataan menggunakan konvensi berikut: jika suatu paket punya kode if __name__ == "__main__": import sys fib(int(sys.argv[1])) 9 yang mendefinisikan daftar bernama python fibo.py <arguments> 9, itu diambil sebagai daftar nama modul yang harus diimpor ketika >>> import fibo 01 ditemukan. Terserah pembuat paket untuk tetap memperbarui daftar ini ketika versi baru dari paket dirilis. Pembuat paket juga dapat memutuskan untuk tidak mendukungnya, jika mereka tidak melihat penggunaan untuk mengimpor * dari paket mereka. Sebagai contoh, berkas >>> import fibo 02 dapat berisi kode berikut:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 4
This would mean that if __name__ == "__main__": import sys fib(int(sys.argv[1])) 7 would import the three named submodules of the >>> import fibo 04 package.
Jika python fibo.py <arguments> 9 tidak didefinisikan, pernyataan if __name__ == "__main__": import sys fib(int(sys.argv[1])) 7 tidak impor semua submodul dari paket >>> import fibo 04 ke namespace saat ini; itu hanya memastikan bahwa paket >>> import fibo 04 telah diimpor (mungkin menjalankan kode inisialisasi apa pun di python fibo.py <arguments> 7) dan kemudian mengimpor nama apa pun yang didefinisikan dalam paket. Ini termasuk semua nama yang didefinisikan (dan submodul yang dimuat secara eksplisit) oleh python fibo.py <arguments> 7. Itu juga termasuk semua submodul dari paket yang secara eksplisit dimuat oleh sebelumnya pernyataan . Pertimbangkan kode ini
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 5
Dalam contoh ini, modul if __name__ == "__main__": import sys fib(int(sys.argv[1])) 1 dan >>> import fibo 13 diimpor dalam namespace saat ini karena mereka didefinisikan dalam paket >>> import fibo 04 ketika paket >>> import fibo 15 Pernyataan dieksekusi. (Ini juga berfungsi ketika python fibo.py <arguments> 9 didefinisikan.)
Meskipun modul-modul tertentu dirancang hanya untuk mengekspor nama-nama yang mengikuti pola tertentu ketika Anda menggunakan >>> import fibo 17, itu masih dianggap praktik buruk dalam lingkungan kode produksi production.
Ingat, tidak ada yang salah dengan menggunakan >>> import fibo 18! Sebenarnya, ini adalah notasi yang disarankan kecuali modul impor perlu menggunakan submodul dengan nama yang sama dari paket yang berbeda.
6.4.2. Referensi Intra-paket
Ketika paket disusun menjadi subpaket (seperti pada paket >>> import fibo 19 pada contoh), Anda dapat menggunakan impor absolut untuk merujuk pada submodul paket saudara kandung. Misalnya, jika modul >>> import fibo 20 perlu menggunakan modul if __name__ == "__main__": import sys fib(int(sys.argv[1])) 1 dalam paket >>> import fibo 04, ia dapat menggunakan >>> import fibo 23.
Anda juga dapat menulis impor relatif, dengan bentuk >>> import fibo 24 pada pernyataan impor. Impor ini menggunakan titik-titik di awalan untuk menunjukkan paket saat ini dan induk yang terlibat dalam impor relatif. Dari modul >>> import fibo 13 misalnya, Anda dapat menggunakan:
>>> fibo.fib(1000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo' 6
Perhatikan bahwa impor relatif didasarkan pada nama modul saat ini. Karena nama modul utama selalu >>> from fibo import fib, fib2 >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 6, modul yang dimaksudkan untuk digunakan sebagai modul utama aplikasi Python harus selalu menggunakan impor absolut.
6.4.3. Paket di Beberapa Direktori
Paket mendukung satu atribut khusus lagi, . Ini diinisialisasi menjadi daftar yang berisi nama direktori yang menyimpan file paket: __init__.py sebelum kode dalam file tersebut dieksekusi. Variabel ini dapat dimodifikasi; hal itu memengaruhi pencarian modul dan subpackage di masa depan yang terkandung dalam paket.
Meskipun fitur ini tidak sering dibutuhkan, fitur ini dapat digunakan untuk memperluas rangkaian modul yang ditemukan dalam suatu paket.
Catatan kaki
In fact function definitions are also 'statements' that are 'executed'; the execution of a module-level function definition adds the function name to the module's global namespace.