Tutorial Python Bahasa Indonesia

Machine Translated by Google
Tutorial Python
Rilis 3.11.1
Guido van Rossum dan tim pengembangan Python
15 Januari 2023
Email Yayasan Perangkat

Lunak Python: docs@python.org
ISI
1 Membangkitkan Nafsu Makan Anda 3
2 Menggunakan Interpreter
Python 2.1 Memanggil Interpreter. .. . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 5.5.
2.1.1 Melewati Argumen . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 6.6.
2.1.2 Mode Interaktif 2.2 . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 6.6
Interpreter dan Lingkungannya . . . . . . . . . . . . . . . . ..... . . . . . . . . . . .
2.2.1 Pengkodean Kode Sumber . ..... . . . . . . . . . . . . ..... . . . . . . . . . . .
3 Pengantar Informal Python 3.1

Menggunakan Python sebagai Kalkulator . .. . . . . .
. . . . . . . . . . . . ..... . . . . . . . . . . . 9.9.
3.1.1 Angka . 3.1.2 . . . . . . . . . . . . .
. . . . . . . . . . . . ..... . . . . . . . . . . . 9
String . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 11
3.1.3 Daftar . . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 14
3.2 Langkah Pertama Menuju Pemrograman . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 16
4 Alat Aliran Kontrol Lainnya 4.1

Pernyataan if . 4.2 untuk. . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . .
Pernyataan . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . .
4.3 Fungsi range() 4.4 memecah . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 17 17
dan melanjutkan Pernyataan, dan lainnya Klausul pada Loops . . . . . 4.5 lulus . . . . . . . . . . . 17 .
Pernyataan . 4.6 Pernyataan. kecocokan
. . . . . . .. . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 18 .
. . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 19 .
4.7 Mendefinisikan Fungsi . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 20 .
4.8 Lebih Lanjut tentang . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . .
Mendefinisikan Fungsi 4.8.1 Nilai Argumen Default . . .. . .. .. . . . . . . . . . . . . . . . . . . . . . . . . .
4.8.2 Argumen Kata Kunci . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 20 .
4.8.3 Parameter khusus . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . .
4.8.4 Daftar Argumen Sewenang- . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 23 24
wenang 4.8.5 Membuka Kemasan . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 24 .
. .
Daftar Argumen 4.8.6 Ekspresi Lambda .. . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 25
4.8.7 Rangkaian Dokumentasi . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 27 .
4.8.8 Anotasi Fungsi . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 29 .
4.9 Selingan: Gaya Pengodean . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 30 . 30 . 31 . 31 . 32
5 Struktur Data 33
. . . . . . . . . . .
5.1 Lebih Lanjut tentang Daftar ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 33
5.1.1 Menggunakan Daftar sebagai Tumpukan . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 34 .
5.1.2 Menggunakan Daftar sebagai Antrian . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 35 .
5.1.3 Daftar Pemahaman . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 35 .
5.1.4 Pemahaman Daftar Bersarang . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 36 .
5.2 Pernyataan del 5.3 . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 37 .
Tupel dan Urutan . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 38 .
5.4 Set . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 39 .
5.5 Kamus . . . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 39
saya
5.6 Teknik Perulangan . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 40

5.7 Lebih Lanjut Tentang Ketentuan . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 42
5.8 Membandingkan Barisan dan Jenis Lainnya . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 42
6 Modul 6.1 43
Lebih Lanjut tentang . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 44
Modul 6.1.1 Menjalankan modul sebagai skrip . . .. . . . . . . . . . . . ..... . . . . . . . . . . . . 45 .
6.1.2 Jalur Pencarian Modul 6.1.3 . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 45 .
File Python yang “Dikompilasi” 6.2 . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 46 .
Modul Standar 6.3 Fungsi .dir()
. . 6.4
. . Paket
. . . .. . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 46
. . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . .
. . . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 47 .
6.4.1 Mengimpor * Dari Paket . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 48 .
6.4.2 Referensi Intra-paket 6.4.3 . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 49 .
Paket dalam Banyak Direktori . . . . . . . . . . . . . ..... . . . . . . . . . . . 50 . 50
7 Input dan Output 7.1

Pemformatan Output yang Lebih Menarik .. . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 51 .
7.1.1 Literal String Terformat 7.1.2 . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 51 .
Metode String format() 7.1.3 .... . . . . . . . . . . . . ..... . . . . . . . . . . . 52 .
Pemformatan String Manual . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 53 .
7.1.4 Pemformatan string lama . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 54 .
7.2 Membaca dan Menulis File . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 55 .
7.2.1 Metode Objek File . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 55 .
7.2.2 Menyimpan data terstruktur dengan json . . . . . . . . . . . . . ..... . . . . . . . . . . . 56 . 57
8 Kesalahan dan
Pengecualian 8.1 . . . . . . . . . . . ..... . . . . .
. . . . . . . ..... . . . . . . . . . . . 59 .
. . . . . . . .. . . . . . . . .
Kesalahan Sintaks 8.2 Pengecualian . . . . .
. . . . . . . ..... . . . . . . . . . . . 59 .
8.3 Menangani Pengecualian . . . . . . . . . . . . . . . . .
. . . . . . . ..... . . . . . . . . . . . 59 .
8.4 Menaikkan Pengecualian . . . . . . . . . . . . . . . . .
. .
. . . . . . ..... . . . . . . . . . . . 60 .
8.5 Rangkaian Pengecualian . . . . . . . . . . . . . . . . .
. .
. . . . . . ..... . . . . . . . . . . . 62 .
8.6 Pengecualian yang Ditentukan Pengguna . . . . . . . . . . . . . .
. .
. . . . . . ..... . . . . . . . . . . . 63 .
8.7 Menentukan Tindakan Pembersihan 8.8 . . . . . . . . . . . . .
. .
. . . . . . ..... . . . . . . . . . . . 64 .
Tindakan Pembersihan yang Ditentukan . . . . . . . . . . . .
. .
. . . . . . ..... . . . . . . . . . . . 64 .
Sebelumnya 8.9 Meningkatkan dan Menangani Berbagai Pengecualian yang Tidak Terkait ..
. . . . . ..... . . . . . . . . . . . 65 .
8.10 Memperkaya Pengecualian dengan Catatan . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 66 . 67
9 Kelas
9.1 Sebuah Kata Tentang Nama dan Objek . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 69 .
9.2 Cakupan dan Ruang Nama Python . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 69 .
9.2.1 Ruang Lingkup dan Contoh Namespace . . . . . . . . . . . . . ..... . . . . . . . . . . . . 70
9.3 Sekilas tentang Kelas . 9.3.1 . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 71
Sintaks Definisi Kelas . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 72
9.3.2 Objek Kelas . . . . . . . .... . . . . . . . . . . . . ..... . . . . . . . . . . . . 72
9.3.3 Objek Contoh . . . . . . .... . . . . . . . . . . . . ..... . . . . . . . . . . . 72 .
9.3.4 Metode Objek . . . . . . .... . . . . . . . . . . . . ..... . . . . . . . . . . . 73 .
9.3.5 Variabel Kelas dan Contoh . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 73
9.4 Keterangan Acak 9.5 . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 74 .
Pewarisan 9.5.1 . . . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 75 . 76
Pewarisan Ganda 9.6 Variabel . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 77
Privat . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 78 .
9.7 Peluang dan Akhir . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 78 .
. . . .. . . . . . . . . . . . . . . .
9.8 Iterator 9.9 Generator . . . . . . . . . . . . ..... . . . . . . . . . . . 79 .
. . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 80 .
9.10 Ekspresi Generator . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 81
10 Tur Singkat Perpustakaan Standar

10.1 Antarmuka Sistem Operasi . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 83 . 83
ii
10.2 File Wildcard . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 83 .

10.3 Argumen Baris Perintah . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 84 .
10.4 Kesalahan Pengalihan Keluaran dan Pemutusan . . . . . . . . ..... . . . . . . . . . . . 84 .
. . .. . . . . . .
Program 10.5 Pencocokan Pola String . . . . . . . . . . . . ..... . . . . . . . . . . . 84 .
10.6 Matematika . . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 85 .
10.7 Akses Internet . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 85 .
10.8 Tanggal dan . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 86 .
Waktu 10.9 Kompresi Data . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 86 .
10.10 Pengukuran Kinerja 10.11 . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 86 .
Kontrol Kualitas . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 87 .
10.12 Termasuk Baterai . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 87
11 Tur Singkat Perpustakaan Standar — Bagian II

11.1 Pemformatan Keluaran . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 89 .
11.2 Pembuatan Templat . . . . . . . . . . . . . . . . .. . . . . . . . . . . . ..... . . . . . . . . . . . 89 .
11.3 Bekerja dengan Tata Letak Rekaman Data Biner . . . . . . . . . . . . . ..... . . . . . . . . . . . 90 .
11.4 Multi-threading . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 91 .
11.5 Pencatatan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 91 .
11.6 Referensi Lemah . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 92 .
11.7 Alat untuk Bekerja dengan . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 92 .
.
Daftar 11.8 Aritmatika Titik Mengambang Desimal . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 93 . 94
12 Lingkungan dan Paket Virtual

12.1 Pendahuluan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 95 .
12.2 Membuat Lingkungan Virtual . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 95 .
12.3 Mengelola Paket dengan pip . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 95 . 96
13 Apa Sekarang? 99
14 Pengeditan Input Interaktif dan Penggantian Riwayat

14.1 Penyelesaian Tab dan Pengeditan Riwayat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 .
14.2 Alternatif Interpreter Interaktif . . . . . . . . . . . . . . ..... . . . . . . . . . . . 101 . 101
15 Aritmatika Titik Terapung: Masalah dan Keterbatasan

15.1 Kesalahan Representasi . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 103 . 105
16 Lampiran
16.1 Mode Interaktif . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 107 .
16.1.1 Penanganan Kesalahan . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 107 .
16.1.2 Skrip Python yang Dapat Dijalankan . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . 107 .
16.1.3 File Startup Interaktif 16.1.4 .... . . . . . . . . . . . . ..... . . . . . . . . . . . 107 .
Modul Kustomisasi .... . . . . . . . . . . . . ..... . . . . . . . . . . . 108 . 108
Glosarium 109
B Tentang dokumen-
dokumen ini B.1 Kontributor Dokumentasi Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 . 123
C Sejarah dan Lisensi

C.1 Sejarah perangkat lunak . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 125 .
C.2 Syarat dan ketentuan untuk mengakses atau menggunakan Python . . . . . . . . . . . . . . . . . . . 125 .
C.2.1 PERJANJIAN LISENSI PSF UNTUK PYTHON 3.11.1 . ..... . . . . . . . . . . . 126 .
C.2.2 PERJANJIAN LISENSI BEOPEN.COM UNTUK PYTHON 2.0 . . . . . . . . . . . . . . 126
C.2.3 PERJANJIAN LISENSI CNRI UNTUK PYTHON 1.6.1 . ..... . . . . . . . . . . . 127 .
C.2.4 PERJANJIAN LISENSI CWI UNTUK PYTHON 0.9.0 MELALUI 1.2 . . . . . . . . . 128 . 129
C.2.5 LISENSI ZERO-CLAUSE BSD UNTUK KODE PYTHON 3.11.1 DOKUMEN
TASI . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 129 .
C.3 Lisensi dan Pengakuan untuk Incorporated Software . . . . ..... . . . . . . . . . . . 130 .
C.3.1 Mersenne Twister . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 130 .
C.3.2 Soket . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 131
aku aku aku

C.3.3 Layanan soket asinkron . . . . . . . . . . . . . . . ..... . . . . . . . . . . . .

C.3.4 Manajemen cookie . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 131 .
C.3.5 Pelacakan eksekusi . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 132 .
C.3.6 Fungsi UUencode dan UUdecode C.3.7 . . . . . . . . . . . . ..... . . . . . . . . . . . 132 .
Panggilan Prosedur Jarak Jauh XML . . . . . . . . . . . . . . ..... . . . . . . . . . . . 133 . 133
C.3.8 test_epoll . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 134
C.3.9 Pilih kqueue . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 134 .
C.3.10 SipHash24 . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 135 .
C.3.11 strtod dan dtoa . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 135 .
C.3.12 OpenSSL . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 136 .
C.3.13 pendatang . . . . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 138 .
C.3.14 libffi . . . . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 138 .
C.3.15 zlib . . . . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 139 .
C.3.16 cfuhash . . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 139 .
C.3.17 libmpdec . . . . . .
. . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 140 .
C.3.18 Rangkaian uji W3C . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . 140
C14N C.3.19 Audioop. .. . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 141
D. Hak Cipta 143
Indeks 145
iv
Tutorial Python, Rilis 3.11.1
Python adalah bahasa pemrograman yang mudah dipelajari dan kuat. Ini memiliki struktur data tingkat tinggi yang efisien dan
pendekatan yang sederhana namun efektif untuk pemrograman berorientasi objek. Sintaks elegan dan pengetikan dinamis Python,
bersama dengan sifatnya yang ditafsirkan, menjadikannya bahasa yang ideal untuk skrip dan pengembangan aplikasi cepat di banyak
area di sebagian besar platform.
Penerjemah Python dan perpustakaan standar yang luas tersedia secara bebas dalam bentuk sumber atau biner untuk
semua platform utama dari situs web Python, https://www.python.org/, dan dapat didistribusikan secara bebas. Situs
yang sama juga berisi distribusi dan penunjuk ke banyak modul, program dan alat Python pihak ketiga gratis, dan
dokumentasi tambahan.
Interpreter Python mudah diperluas dengan fungsi baru dan tipe data yang diimplementasikan dalam C atau C++ (atau bahasa
lain yang dapat dipanggil dari C). Python juga cocok sebagai bahasa ekstensi untuk aplikasi yang dapat disesuaikan.
Tutorial ini memperkenalkan pembaca secara informal pada konsep dasar dan fitur bahasa dan sistem Python. Ini membantu
untuk memiliki juru bahasa Python yang berguna untuk pengalaman langsung, tetapi semua contoh mandiri, sehingga tutorialnya
dapat dibaca secara offline juga.
Untuk deskripsi objek dan modul standar, lihat library-index. referensi-indeks memberikan definisi bahasa yang lebih formal.
Untuk menulis ekstensi dalam C atau C++, baca indeks-ekstensi dan indeks-c-api. Ada juga beberapa buku yang membahas
Python secara mendalam.
Tutorial ini tidak berusaha untuk komprehensif dan mencakup setiap 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 bahasanya. Setelah membacanya, Anda akan dapat membaca dan menulis modul dan program Python, dan Anda
akan siap untuk mempelajari lebih lanjut tentang berbagai modul library Python yang dijelaskan di library-index.
Glosarium juga layak untuk dibaca .
ISI 1
2 ISI
BAB
SATU
MENINGKATKAN NAFSU MAKAN ANDA
Jika Anda melakukan banyak pekerjaan di komputer, akhirnya Anda menemukan bahwa ada beberapa tugas yang ingin Anda otomatisasi.
Misalnya, Anda mungkin ingin melakukan pencarian-dan-ganti pada sejumlah besar file teks, atau mengganti nama dan mengatur ulang
sekumpulan file foto dengan cara yang rumit. Mungkin Anda ingin menulis database kustom kecil, atau aplikasi GUI khusus, atau game
sederhana.
Jika Anda seorang pengembang perangkat lunak profesional, Anda mungkin harus bekerja dengan beberapa pustaka C/C++/Java tetapi mendapati siklus
tulis/kompilasi/tes/kompilasi ulang yang biasa terlalu lambat. Mungkin Anda sedang menulis rangkaian pengujian untuk perpustakaan semacam itu dan
menganggap menulis kode pengujian sebagai tugas yang membosankan. Atau mungkin Anda telah menulis sebuah program yang dapat menggunakan
bahasa ekstensi, dan Anda tidak ingin merancang dan mengimplementasikan bahasa baru untuk aplikasi Anda.
Python hanyalah bahasa untuk Anda.
Anda dapat menulis skrip shell Unix atau file batch Windows untuk beberapa tugas ini, tetapi skrip shell paling baik untuk memindahkan file
dan mengubah data teks, tidak cocok untuk aplikasi atau game GUI. Anda dapat menulis program C/C++/Java, tetapi akan membutuhkan
banyak waktu pengembangan untuk mendapatkan draf program pertama sekalipun. Python lebih mudah digunakan, tersedia di sistem
operasi Windows, macOS, dan Unix, dan akan membantu Anda menyelesaikan pekerjaan lebih cepat.
Python mudah digunakan, tetapi ini adalah bahasa pemrograman nyata, menawarkan lebih banyak struktur dan dukungan untuk program
besar daripada yang ditawarkan skrip shell atau file batch. Di sisi lain, Python juga menawarkan lebih banyak pemeriksaan kesalahan
daripada C, dan, sebagai bahasa tingkat sangat tinggi, ia memiliki tipe data tingkat tinggi bawaan, seperti larik fleksibel dan dictio naries.
Karena tipe datanya yang lebih umum, Python dapat diterapkan ke domain masalah yang jauh lebih besar daripada Awk atau bahkan Perl,
namun banyak hal yang setidaknya sama mudahnya dengan Python seperti dalam bahasa-bahasa tersebut.
Python memungkinkan Anda membagi program Anda menjadi modul yang dapat digunakan kembali di program Python lainnya. Muncul
dengan banyak koleksi modul standar yang dapat Anda gunakan sebagai dasar program Anda — atau sebagai contoh untuk mulai belajar
memprogram dengan Python. Beberapa modul ini menyediakan hal-hal seperti I/O file, panggilan sistem, soket, dan bahkan antarmuka ke
perangkat antarmuka pengguna grafis seperti Tk.
Python adalah bahasa yang ditafsirkan, yang dapat menghemat banyak waktu Anda selama pengembangan program karena tidak diperlukan
kompilasi dan penautan. Penerjemah dapat digunakan secara interaktif, yang membuatnya mudah untuk bereksperimen dengan fitur bahasa,
menulis program sekali pakai, atau menguji fungsi selama pengembangan program dari bawah ke atas.
Ini juga merupakan kalkulator meja yang praktis.
Python memungkinkan program ditulis dengan kompak dan mudah dibaca. Program yang ditulis dengan Python biasanya jauh lebih pendek
daripada program C, C++, atau Java yang setara, karena beberapa alasan:
• tipe data tingkat tinggi memungkinkan Anda mengekspresikan operasi kompleks dalam satu pernyataan;
• pengelompokan pernyataan dilakukan dengan indentasi, bukan tanda kurung awal dan akhir;
• tidak diperlukan deklarasi variabel atau argumen.
Python dapat diperluas: jika Anda tahu cara memprogram dalam C, mudah untuk menambahkan fungsi atau modul bawaan baru ke juru
bahasa, baik untuk melakukan operasi kritis dengan kecepatan maksimum, atau untuk menautkan program Python ke pustaka yang mungkin
hanya tersedia dalam bentuk biner (seperti perpustakaan grafis khusus vendor). Setelah Anda benar-benar ketagihan, Anda dapat menautkan
juru bahasa Python ke aplikasi yang ditulis dalam C dan menggunakannya sebagai ekstensi atau bahasa perintah untuk aplikasi itu.
Omong-omong, bahasa ini dinamai menurut acara BBC "Sirkus Terbang Monty Python" dan tidak ada hubungannya dengan reptil. Membuat
referensi ke sandiwara Monty Python dalam dokumentasi tidak hanya diperbolehkan, tetapi juga dianjurkan!
3
Sekarang Anda semua bersemangat tentang Python, Anda akan ingin memeriksanya lebih detail. Karena cara terbaik untuk mempelajari suatu bahasa
adalah dengan menggunakannya, tutorial ini mengundang Anda untuk bermain dengan juru bahasa Python sambil membaca.
Pada bab selanjutnya, mekanisme penggunaan juru bahasa dijelaskan. Ini adalah informasi yang agak biasa, tetapi
penting untuk mencoba contoh yang ditunjukkan nanti.
Tutorial selanjutnya memperkenalkan berbagai fitur bahasa dan sistem Python melalui contoh, mulai dengan ekspresi
sederhana, pernyataan dan tipe data, melalui fungsi dan modul, dan terakhir menyentuh konsep lanjutan seperti
pengecualian dan kelas yang ditentukan pengguna.
4 Bab 1. Membangkitkan Nafsu Makan Anda

BAB
DUA
MENGGUNAKAN INTERPRETER PYTHON
2.1 Memanggil Penerjemah
Interpreter Python biasanya diinstal sebagai /usr/local/bin/python3.11 pada mesin yang tersedia; menempatkan /usr/local/
bin di jalur pencarian shell Unix Anda memungkinkan untuk memulainya dengan mengetikkan perintah:
python3.11
ke shell.1 Karena pilihan direktori tempat tinggal juru bahasa adalah opsi instalasi, tempat lain dimungkinkan; periksa
dengan guru Python lokal atau administrator sistem Anda. (Misalnya, /usr/local/python adalah lokasi alternatif yang populer.)
Pada mesin Windows tempat Anda menginstal Python dari Microsoft Store, perintah python3.11 akan tersedia. Jika Anda
menginstal peluncur py.exe, Anda dapat menggunakan perintah py. Lihat pengaturan-envvars untuk cara lain meluncurkan
Python.
Mengetik karakter akhir file (Control-D di Unix, Control-Z di Windows) pada prompt utama menyebabkan juru bahasa keluar
dengan status keluar nol. Jika tidak berhasil, Anda dapat keluar dari penerjemah dengan mengetikkan perintah berikut:
quit().
Fitur penyuntingan baris interpreter mencakup penyuntingan interaktif, penggantian riwayat, dan penyelesaian kode pada sistem yang
mendukung GNU Readline perpustakaan. Mungkin pemeriksaan tercepat untuk melihat apakah pengeditan baris perintah didukung
adalah mengetikkan Control-P ke prompt Python pertama yang Anda dapatkan. Jika berbunyi bip, Anda memiliki pengeditan baris
perintah; lihat Lampiran Pengeditan Input Interaktif dan Penggantian Riwayat untuk pengenalan kunci. Jika tampaknya tidak terjadi apa-
apa, atau jika ^P digemakan, pengeditan baris perintah tidak tersedia; Anda hanya dapat menggunakan backspace untuk menghapus
karakter dari baris saat ini.
Interpreter beroperasi seperti shell Unix: ketika dipanggil dengan input standar yang terhubung ke perangkat tty, ia membaca
dan mengeksekusi perintah secara interaktif; ketika dipanggil dengan argumen nama file atau dengan file sebagai input standar,
ia membaca dan mengeksekusi skrip dari file itu.
Cara kedua untuk memulai juru bahasa adalah python -c command [arg] ..., yang mengeksekusi pernyataan dalam perintah,
analog dengan opsi -c shell. Karena pernyataan Python sering berisi spasi atau karakter lain yang khusus untuk shell,
biasanya disarankan untuk mengutip perintah secara keseluruhan.
Beberapa modul Python juga berguna sebagai skrip. Ini dapat dipanggil menggunakan python -m module [arg] ..., yang
mengeksekusi file sumber untuk modul seolah-olah Anda telah menyebutkan nama lengkapnya di baris perintah.
Saat file skrip digunakan, terkadang berguna untuk dapat menjalankan skrip dan masuk ke mode interaktif sesudahnya.
Ini dapat dilakukan dengan meneruskan -i sebelum skrip.
Semua opsi baris perintah dijelaskan dalam using-on-general.

1 Di Unix, interpreter Python 3.x secara default tidak diinstal dengan executable bernama python, sehingga tidak bertentangan dengan
secara bersamaan menginstal Python 2.x yang dapat dieksekusi.
5
2.1.1 Melewati Argumen

Saat diketahui oleh juru bahasa, nama skrip dan argumen tambahan selanjutnya diubah menjadi daftar string dan ditetapkan ke variabel argv
di modul sys. Anda dapat mengakses daftar ini dengan menjalankan import sys. Panjang daftar setidaknya satu; ketika tidak ada skrip dan
tidak ada argumen yang diberikan, sys.argv[0] adalah string kosong.
Ketika nama skrip diberikan sebagai '-' (artinya input standar), sys.argv[0] disetel ke '-'. Ketika perintah -c digunakan, sys.argv[0] disetel ke '-c'.
Saat modul -m digunakan, sys.argv[0] disetel ke nama lengkap modul yang berada. Opsi yang ditemukan setelah perintah -c atau modul -m
tidak dikonsumsi oleh pemrosesan opsi juru bahasa Python tetapi ditinggalkan di sys.argv untuk ditangani oleh perintah atau modul.
2.1.2 Mode Interaktif
Ketika perintah dibaca dari tty, interpreter dikatakan dalam mode interaktif. Dalam mode ini ia meminta perintah berikutnya dengan prompt
utama, biasanya tiga tanda lebih besar dari (>>>); untuk baris lanjutan diminta dengan prompt sekunder, secara default tiga titik (...).
Penerjemah mencetak pesan selamat datang yang menyatakan nomor versinya dan pemberitahuan hak cipta sebelum mencetak permintaan
pertama:
$ python3.11
Python 3.11 (default, 4 April 2021, 09:25:04)
[GCC 10.2.0] di linux Ketik "help",
"copyright", "credits", atau "license" untuk informasi lebih lanjut.
>>>
Garis lanjutan diperlukan saat memasuki konstruksi multi-garis. Sebagai contoh, lihat pernyataan if ini:
>>> the_world_is_flat = True >>> jika

the_world_is_flat:
... print("Hati -hati jangan sampai jatuh!")
...
Hati-hati jangan sampai jatuh!
Untuk informasi lebih lanjut tentang mode interaktif, lihat Mode Interaktif.
2.2 Penerjemah dan Lingkungannya
2.2.1 Pengkodean Kode Sumber

Secara default, file sumber Python diperlakukan sebagai dikodekan dalam UTF-8. Dalam pengkodean itu, karakter dari sebagian besar bahasa
di dunia dapat digunakan secara bersamaan dalam literal string, pengidentifikasi, dan komentar — meskipun perpustakaan standar hanya
menggunakan karakter ASCII untuk pengidentifikasi, sebuah konvensi yang harus diikuti oleh kode portabel apa pun. Untuk menampilkan
semua karakter ini dengan benar, editor Anda harus mengenali bahwa file tersebut adalah UTF-8, dan harus menggunakan font yang
mendukung semua karakter dalam file.
Untuk mendeklarasikan penyandian selain yang default, baris komentar khusus harus ditambahkan sebagai baris pertama file.
Sintaksnya adalah sebagai berikut:
# -*- pengkodean: pengkodean -*-
di mana penyandian adalah salah satu codec valid yang didukung oleh Python.
Misalnya, untuk menyatakan bahwa pengkodean Windows-1252 akan digunakan, baris pertama file kode sumber Anda harus:
# -*- pengkodean: cp1252 -*-
Satu pengecualian untuk aturan baris pertama adalah ketika kode sumber dimulai dengan baris “shebang” UNIX. Dalam hal ini, deklarasi
pengkodean harus ditambahkan sebagai baris kedua file. Sebagai contoh:
6 Bab 2. Menggunakan Penerjemah Python

#!/usr/bin/env python3 # -*-

koding: cp1252 -*-
2.2. Penerjemah dan Lingkungannya 7

8 Bab 2. Menggunakan Penerjemah Python

BAB
TIGA
PENGENALAN INFORMAL UNTUK PYTHON
Dalam contoh berikut, input dan output dibedakan dengan ada atau tidaknya prompt (»> dan …): untuk mengulang contoh,
Anda harus mengetik semuanya setelah prompt, saat prompt muncul; baris yang tidak dimulai dengan prompt adalah
keluaran dari juru bahasa. Perhatikan bahwa prompt sekunder pada baris dengan sendirinya dalam contoh berarti Anda
harus mengetikkan baris kosong; ini digunakan untuk mengakhiri perintah multi-baris.
Banyak contoh dalam manual ini, bahkan yang dimasukkan pada permintaan interaktif, menyertakan komentar. Komentar
dalam Python dimulai dengan karakter hash, #, dan diperpanjang hingga akhir baris fisik. Sebuah komentar mungkin muncul
di awal baris atau setelah spasi putih atau kode, tetapi tidak dalam literal string. Karakter hash dalam literal string hanyalah
karakter hash. Karena komentar adalah untuk mengklarifikasi kode dan tidak ditafsirkan oleh Python, komentar dapat
dihilangkan saat mengetikkan contoh.
Beberapa contoh:
# ini adalah komentar pertama

spam = 1 # dan ini adalah komentar kedua # ... dan sekarang yang ketiga!
text = "# Ini bukan komentar karena ada di dalam tanda kutip."
3.1 Menggunakan Python sebagai Kalkulator
Mari kita coba beberapa perintah Python sederhana. Mulai penerjemah dan tunggu perintah utama, >>>. (Seharusnya tidak butuh
waktu lama.)
3.1.1 Angka
Penerjemah bertindak sebagai kalkulator sederhana: Anda dapat mengetikkan ekspresi dan itu akan menulis nilainya.
Sintaks ekspresi langsung: operator +, -, * dan / berfungsi
kurung (())seperti
dapat kebanyakan
digunakan untuk
bahasa
pengelompokan.
lain (misalnya,Sebagai
Pascal atau
contoh:
C); tanda
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4 5.0
>>> 8/5 # pembagian selalu mengembalikan angka floating point 1.6
Bilangan bulat (misalnya 2, 4, 20) bertipe int, bilangan pecahan (misalnya 5.0, 1.6) bertipe float. Kita akan melihat lebih
banyak tentang tipe numerik nanti di tutorial.
Divisi (/) selalu mengembalikan pelampung. Untuk melakukan pembagian lantai dan mendapatkan hasil bilangan bulat, Anda dapat menggunakan operator //;
untuk menghitung sisanya, Anda dapat menggunakan %:
9
>>> 17/3 # divisi klasik mengembalikan pelampung

5.666666666666667
>>>
>>> 17 // 3 # pembagian lantai membuang bagian pecahan 5
>>> 17 % 3 # operator % mengembalikan sisa pembagian 2
>>> 5 * 3 + 2 # hasil bagi berlantai * pembagi + sisa

17
Dengan Python, dimungkinkan untuk menggunakan ** operator untuk menghitung kekuatan1 :
>>> 5 ** 2 # 5 kuadrat 25
>>> 2 ** 7 # 2 pangkat 7 128
Tanda sama dengan (=) digunakan untuk memberikan nilai ke variabel. Setelah itu, tidak ada hasil yang ditampilkan sebelum prompt interaktif
berikutnya:
>>> lebar = 20
>>> tinggi = 5 * 9 >>> lebar *
tinggi
900
Jika variabel tidak "didefinisikan" (diberi nilai), mencoba menggunakannya akan memberi Anda kesalahan:
>>> n # mencoba mengakses variabel yang tidak terdefinisi

Traceback (panggilan terbaru terakhir):
File "<stdin>", baris 1, di <module>
NameError: nama 'n' tidak ditentukan
Ada dukungan penuh untuk floating point; operator dengan operan tipe campuran mengubah operan integer menjadi floating point:
>>> 4 * 3,75 - 1
14.0
Dalam mode interaktif, ekspresi tercetak terakhir ditugaskan ke variabel _. Ini berarti bahwa ketika Anda menggunakan
Python sebagai kalkulator meja, agak lebih mudah untuk melanjutkan perhitungan, misalnya:
>>> pajak = 12,5 / 100 >>> harga =

100,50 >>> harga * pajak 12,5625
>>> harga + _
113.0625
>>> bulat(_, 2) 113.06
Variabel ini harus diperlakukan sebagai hanya-baca oleh pengguna. Jangan secara eksplisit memberikan nilai padanya — Anda akan membuat
variabel lokal independen dengan nama yang sama menutupi variabel bawaan dengan perilaku ajaibnya.
Selain int dan float, Python mendukung jenis angka lainnya, seperti Desimal dan Pecahan. Python juga memiliki dukungan bawaan untuk
bilangan kompleks, dan menggunakan akhiran j atau J untuk menunjukkan bagian imajiner (misalnya 3+5j).
1 -,
Karena ** memiliki prioritas lebih tinggi -3**2 akan ditafsirkan sebagai -(3**2) dan dengan demikian menghasilkan -9. Untuk menghindari ini dan mendapatkan 9, Anda dapat menggunakan
daripada (-3)**2.
10 Bab 3. Pengantar Informal Python

3.1.2 String
Selain angka, Python juga bisa memanipulasi string, yang bisa diekspresikan dalam beberapa cara. Mereka dapat diapit dengan tanda kutip
tunggal ('...') atau tanda kutip ganda ("...") dengan hasil yang sama2 . \ dapat digunakan untuk menghindari tanda kutip:
>>> 'telur spam' # tanda kutip tunggal 'telur spam' >>>

'tidak' # menggunakan \' untuk keluar dari tanda kutip
tunggal...
"tidak"
>>> "tidak" # ...atau gunakan tanda kutip ganda sebagai gantinya
"tidak"
>>> '"Ya," kata mereka.'
'"Ya," kata mereka.'
>>> "\"Ya,\" kata mereka."
'"Ya," kata mereka.'
>>> '"Bukankah," kata mereka.'
'"Bukan," kata mereka.'
Dalam interpreter interaktif, string keluaran diapit tanda kutip dan karakter khusus diloloskan dengan garis miring ke belakang. Meskipun ini
terkadang terlihat berbeda dari input (kutipan terlampir dapat berubah), kedua string tersebut setara. String diapit dengan tanda kutip ganda
jika string berisi tanda kutip tunggal dan tidak ada tanda kutip ganda, jika tidak maka diapit dengan tanda kutip tunggal. Fungsi print()
menghasilkan output yang lebih mudah dibaca, dengan menghilangkan tanda kutip terlampir dan dengan mencetak karakter khusus dan lolos:
>>> '"Bukankah," kata mereka.'

'"Bukan," kata mereka.' >>>
print('"Bukan," kata mereka.')
"Bukankah," kata mereka. >>>
s = ' Baris pertama.\nBaris kedua .' # \n berarti baris baru >>> s # tanpa print(), \n disertakan
dalam keluaran 'Baris pertama.\nBaris kedua.' >>> print(s) # dengan print(), \n menghasilkan
baris baru Baris pertama.
Baris kedua.
Jika Anda tidak ingin karakter diawali dengan \ ditafsirkan sebagai karakter khusus, Anda dapat menggunakan string mentah dengan
menambahkan r sebelum kutipan pertama:
>>> print('C:\some\name') # di sini \n artinya baris baru!

C:\beberapa
ame
>>> print(r'C:\some\name') # catat r sebelum kutipan
C:\beberapa\nama
Ada satu aspek halus pada string mentah: string mentah mungkin tidak diakhiri dengan \ karakter dalam jumlah ganjil; lihat entri FAQ untuk
informasi dan solusi lebih lanjut.
Literal string dapat menjangkau beberapa baris. Salah satu caranya adalah menggunakan tanda kutip tiga: """...""" atau '''...'''. Akhir baris secara
otomatis dimasukkan ke dalam string, tetapi hal ini dapat dicegah dengan menambahkan tanda \ di akhir baris. Contoh berikut:
mencetak("""\
Penggunaan: thingy [PILIHAN] -h
Tampilkan pesan penggunaan ini
-H nama host Nama host untuk terhubung
""")
menghasilkan keluaran berikut (perhatikan bahwa baris baru awal tidak disertakan):
2 Tidak seperti bahasa lain, karakter khusus seperti \n memiliki arti yang sama dengan tanda kutip tunggal ('...') dan ganda ("..."). Itu
satu-satunya perbedaan antara keduanya adalah bahwa dalam tanda kutip tunggal Anda tidak perlu melarikandiri " (tetapi Anda harus melarikan diri \') dan sebaliknya.
3.1. Menggunakan Python sebagai Kalkulator 11

Penggunaan: thingy [PILIHAN] -h

Tampilkan pesan penggunaan ini
-H nama host Nama host untuk terhubung
String dapat digabungkan (direkatkan) dengan operator +, dan diulangi dengan *:
>>> # 3 kali 'un', diikuti dengan 'ium' >>> 3 * 'un' + 'ium'
'unununium'
Dua atau lebih literal string (yaitu yang terlampir di antara tanda kutip) di samping satu sama lain secara otomatis digabungkan.
>>> 'Py' 'thon'

'Python'
Fitur ini sangat berguna ketika Anda ingin memutuskan string yang panjang:
>>> text = ('Masukkan beberapa string di dalam tanda kurung ' 'agar digabungkan.')
...
>>> teks
'Masukkan beberapa string dalam tanda kurung agar digabungkan menjadi satu.'
Ini hanya bekerja dengan dua literal, bukan dengan variabel atau ekspresi:
>>> awalan = 'Py' >>>

awalan 'thon' # tidak dapat menggabungkan variabel dan string literal
File "<stdin>", awalan baris 1 'thon'
^^^^^^
SyntaxError: sintaks tidak valid >>> ('un' * 3)

'ium'
File "<stdin>", baris 1
('un' * 3) 'ium'
^^^^^
SyntaxError: sintaks tidak valid
Jika Anda ingin menggabungkan variabel atau variabel dan literal, gunakan +:
>>> awalan + 'thon'

'Python'
String dapat diindeks (berlangganan), dengan karakter pertama memiliki indeks 0. Tidak ada tipe karakter yang terpisah; karakter
hanyalah string ukuran satu:
>>> kata = 'Python' >>> kata[0]

# karakter di posisi 0
'P'
>>> kata[5] # karakter di posisi 5 'n'
Indeks juga bisa berupa angka negatif, untuk mulai menghitung dari kanan:
>>> kata[-1] # karakter terakhir

'n'
>>> kata[-2] # karakter kedua-terakhir
'Hai'
>>> kata[-6]
'P'
Perhatikan bahwa karena -0 sama dengan 0, indeks negatif dimulai dari -1.
Selain pengindeksan, pemotongan juga didukung. Sementara pengindeksan digunakan untuk mendapatkan karakter individual, mengiris memungkinkan
Anda mendapatkan substring:

>>> kata[0:2] # karakter dari posisi 0 (disertakan) hingga 2 (dikecualikan)

'Py'
>>> kata[2:5] # karakter dari posisi 2 (disertakan) hingga 5 (dikecualikan) 'tho'
Indeks irisan memiliki default yang berguna; default indeks pertama yang dihilangkan menjadi nol, indeks kedua yang dihilangkan default ke
ukuran string yang diiris.
>>> kata[:2] # karakter dari awal hingga posisi 2 (dikecualikan)

'Py'
>>> kata[4:] # karakter dari posisi 4 (termasuk) hingga akhir 'on'
>>> kata[-2:] # karakter dari yang kedua terakhir (termasuk) sampai akhir
'pada'
Perhatikan bagaimana awal selalu disertakan, dan akhir selalu dikecualikan. Ini memastikan bahwa s[:i] + s[i:] selalu sama dengan s:
>>> kata[:2] + kata[2:]

'Python' >>>
kata[:4] + kata[4:]
'Python'
Salah satu cara untuk mengingat cara kerja irisan adalah menganggap indeks sebagai penunjuk antar karakter, dengan tepi kiri karakter pertama
diberi nomor 0. Kemudian tepi kanan karakter terakhir dari string n karakter memiliki indeks n, misalnya:
+---+---+---+---+---+---+
| P | y | t | h | o | n | +---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Baris angka pertama memberikan posisi indeks 0…6 dalam string; baris kedua memberikan indeks negatif yang sesuai. Irisan dari i ke j terdiri
dari semua karakter antara tepi berlabel i dan j, masing-masing.
Untuk indeks non-negatif, panjang irisan adalah selisih indeks, jika keduanya berada dalam batas. Misalnya, panjang kata[1:3] adalah 2.
Mencoba menggunakan indeks yang terlalu besar akan menghasilkan kesalahan:
>>> kata[42] # kata hanya memiliki 6 karakter

IndexError: indeks string di luar jangkauan
Namun, indeks irisan di luar jangkauan ditangani dengan anggun saat digunakan untuk mengiris:
>>> kata[4:42] 'aktif'
>>> kata[42:]
''
String python tidak dapat diubah — tidak dapat diubah. Oleh karena itu, menugaskan ke posisi terindeks dalam string menghasilkan kesalahan:
>>> kata[0] = 'J'

TypeError: objek 'str' tidak mendukung penetapan item >>> kata[2:] = 'py'

(bersambung ke halaman berikutnya)

(lanjutan dari halaman sebelumnya)

TypeError: objek 'str' tidak mendukung penugasan item
Jika Anda memerlukan string yang berbeda, Anda harus membuat yang baru:
>>> 'J' + kata[1:]

'Jython' >>>
kata[:2] + 'py'
'pipi'
Fungsi bawaan len() mengembalikan panjang string:
>>> s = 'supercalifragilisticexpialidocious' >>> len(s) 34
Lihat juga:
textseq String adalah contoh tipe urutan, dan mendukung operasi umum yang didukung oleh tipe tersebut.
string-methods String mendukung sejumlah besar metode untuk transformasi dasar dan pencarian.
f-strings String literal yang memiliki ekspresi tersemat.
formatstrings Informasi tentang pemformatan string dengan str.format().
old-string-formatting Operasi pemformatan lama dipanggil ketika string adalah operan kiri dari operator %
dijelaskan lebih rinci di sini.
3.1.3 Daftar
Python mengetahui sejumlah tipe data majemuk , yang digunakan untuk mengelompokkan nilai lain. Yang paling serbaguna adalah
daftar, yang dapat ditulis sebagai daftar nilai (item) yang dipisahkan koma di antara tanda kurung siku. Daftar mungkin berisi item dari
tipe yang berbeda, tetapi biasanya semua item memiliki tipe yang sama.
>>> kotak = [1, 4, 9, 16, 25]

>>> kotak [1, 4,
9, 16, 25]
Seperti string (dan semua jenis urutan bawaan lainnya), daftar dapat diindeks dan dipotong:
>>> kotak[0] # pengindeksan mengembalikan item 1
>>> kotak[-1] 25
>>> kotak[-3:] # slicing mengembalikan daftar baru [9, 16, 25]
Semua operasi irisan mengembalikan daftar baru yang berisi elemen yang diminta. Ini berarti potongan berikut mengembalikan salinan
daftar yang dangkal:
>>> kotak[:] [1, 4, 9,

16, 25]
Daftar juga mendukung operasi seperti penggabungan:
>>> kotak + [36, 49, 64, 81, 100] [1, 4, 9, 16, 25, 36, 49,
64, 81, 100]
Tidak seperti string, yang tidak dapat diubah, daftar adalah jenis yang dapat diubah , artinya kontennya dapat diubah:

>>> kubus = [1, 8, 27, 65, 125] # ada yang salah di sini >>> 4 ** 3 # kubus dari 4 adalah 64,
bukan 65! 64
>>> kubus[3] = 64 # ganti nilai yang salah >>> kubus
[1, 8, 27, 64, 125]
Anda juga dapat menambahkan item baru di akhir daftar, dengan menggunakan metode append() ( kita akan melihat lebih banyak tentang metode
nanti):
>>> cubes.append(216) # tambahkan kubus 6 >>> cubes.append(7 **

3) # dan kubus 7 >>> kubus
[1, 8, 27, 64, 125, 216, 343]
Penugasan ke irisan juga dimungkinkan, dan ini bahkan dapat mengubah ukuran daftar atau menghapusnya seluruhnya:
>>> huruf = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> huruf
['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> # ganti beberapa nilai >>>
huruf[2:5] = ['C' , 'D', 'E'] >>> huruf
['a', 'b', 'C', 'D', 'E', 'f', 'g'] >>> # sekarang hapus
>>> huruf[2:5] = []
>>> huruf
['a', 'b', 'f', 'g'] >>> # hapus daftar
dengan mengganti semua elemen dengan daftar kosong >>> huruf[:] = []
>>> huruf
[]
Fungsi bawaan len() juga berlaku untuk daftar:
>>> huruf = ['a', 'b', 'c', 'd'] >>> len(huruf) 4
Dimungkinkan untuk menyusun daftar (membuat daftar yang berisi daftar lain), misalnya:
>>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3]
>>> x = [a,n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>>
x[0] [1] 'b'

3.2 Langkah Pertama Menuju Pemrograman
Tentu saja, kita dapat menggunakan Python untuk tugas yang lebih rumit daripada menjumlahkan dua dan dua. Misalnya, kita dapat
menulis sub-urutan awal dari deret Fibonacci sebagai berikut:
>>> # Deret Fibonacci:

... # jumlah dari dua elemen mendefinisikan elemen berikutnya
... a, b = 0, 1 >>>
sedangkan a < 10:
... cetak(a) a,
... b = b, a+b
...
0
1
1
2
3
5
8
Contoh ini memperkenalkan beberapa fitur baru.
• Baris pertama berisi penugasan berganda: variabel a dan b secara bersamaan mendapatkan nilai baru 0 dan 1.
Pada baris terakhir ini digunakan lagi, menunjukkan bahwa ekspresi di sisi kanan semuanya dievaluasi terlebih dahulu sebelum
penugasan apa pun dilakukan. Ekspresi sisi kanan dievaluasi dari kiri ke kanan.
• Perulangan while dijalankan selama kondisi (di sini: a < 10) tetap benar. Di Python, seperti di C, nilai bilangan bulat bukan nol
adalah benar; nol adalah salah. Kondisinya juga bisa berupa string atau daftar nilai, bahkan urutan apa pun; apa pun dengan
panjang bukan nol adalah benar, urutan kosong adalah salah. Tes yang digunakan dalam contoh adalah perbandingan
sederhana. Operator perbandingan standar ditulis sama seperti di C: < (kurang dari), > (lebih besar dari), == (sama dengan), <=
(kurang dari atau sama dengan), >= (lebih besar dari atau sama dengan) dan != (tidak sama dengan).
• Badan perulangan diberi indentasi: indentasi adalah cara Python mengelompokkan pernyataan. Pada permintaan interaktif, Anda
harus mengetikkan tab atau spasi untuk setiap baris yang diindentasi. Dalam praktiknya, Anda akan menyiapkan masukan yang
lebih rumit untuk Python dengan editor teks; semua editor teks yang layak memiliki fasilitas indentasi otomatis. Saat pernyataan
majemuk dimasukkan secara interaktif, harus diikuti dengan baris kosong untuk menunjukkan penyelesaian (karena parser tidak
dapat menebak kapan Anda mengetik baris terakhir). Perhatikan bahwa setiap baris dalam blok dasar harus diindentasi dengan
jumlah yang sama.
• Fungsi print() menulis nilai argumen yang diberikan. Ini berbeda dari hanya menulis ekspresi yang ingin Anda tulis (seperti yang
kita lakukan sebelumnya pada contoh kalkulator) dengan cara menangani banyak argumen, kuantitas floating point, dan string.
String dicetak tanpa tanda kutip, dan spasi disisipkan di antara item, sehingga Anda dapat memformat semuanya dengan baik,
seperti ini:
>>> i = 256*256
>>> print(' Nilai i adalah', i)
Nilai i adalah 65536
Argumen kata kunci akhir dapat digunakan untuk menghindari baris baru setelah keluaran, atau mengakhiri keluaran dengan string yang
berbeda:
>>> a, b = 0, 1 >>>
sedangkan a < 1000:
... cetak(a, akhir=',') a, b = b,
... a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

BAB
EMPAT
LEBIH BANYAK ALAT KONTROL ALIRAN
Selain pernyataan while yang baru saja diperkenalkan, Python menggunakan pernyataan kontrol aliran biasa yang dikenal dari bahasa lain,
dengan beberapa perubahan.
4.1 jika Pernyataan
Mungkin jenis pernyataan yang paling terkenal adalah pernyataan if. Sebagai contoh:
>>> x = int(input(" Masukkan bilangan bulat: "))

Masukkan bilangan bulat: 42 >>> jika x
< 0:
... x=0
... print('Negatif berubah menjadi nol') ... elif x == 0:
... print('Nol') ... elif x

== 1:
... cetak('Tunggal')
... lain:
... cetak('Lainnya')
...
Lagi
Bisa ada nol atau lebih bagian elif, dan bagian lain bersifat opsional. Kata kunci 'elif' merupakan kependekan dari 'else if', dan
berguna untuk menghindari indentasi yang berlebihan. Urutan if … elif … elif … adalah pengganti untuk pernyataan sakelar
atau kasus yang ditemukan dalam bahasa lain.
Jika Anda membandingkan nilai yang sama dengan beberapa konstanta, atau memeriksa jenis atau atribut tertentu, Anda juga dapat menemukan
pernyataan kecocokan yang berguna. Untuk detail lebih lanjut, lihat Pernyataan kecocokan.
4.2 untuk Pernyataan
Pernyataan for di Python sedikit berbeda dari yang biasa Anda gunakan di C atau Pascal. Daripada selalu mengulangi
perkembangan aritmatika angka (seperti di Pascal), atau memberi pengguna kemampuan untuk menentukan langkah iterasi
dan menghentikan kondisi (sebagai C), pernyataan for Python mengulangi item dari urutan apa pun (daftar atau sebuah
string), dalam urutan kemunculannya dalam urutan. Misalnya (tidak ada permainan kata-kata):
>>> # Ukur beberapa string: ... kata =

['cat', 'window', 'defenestrate'] >>> untuk w dalam kata- kata:
... cetak(w, len(w))

...
kucing 3
jendela 6
defenestrasi 12
17
Kode yang memodifikasi koleksi sambil mengulangi koleksi yang sama bisa jadi sulit untuk dilakukan dengan benar. Alih-alih, biasanya
lebih mudah untuk mengulangi salinan koleksi atau membuat koleksi baru:
# Buat koleksi sampel users = {'Hans': 'active',

'Éléonore': 'inactive', '': 'active'}
# Strategi: Ulangi salinan untuk pengguna, status di

users.copy().items():
jika status == 'tidak aktif':
del pengguna[pengguna]
# Strategi: Buat koleksi baru active_users = {} untuk

pengguna, status di users.items(): jika status == 'aktif':
active_users[pengguna] = status
4.3 Fungsi range()
Jika Anda memang perlu mengulangi urutan angka, fungsi built-in range() sangat berguna. Ini menghasilkan progresi aritmatika:
>>> untuk saya dalam rentang (5):

... cetak(i)
...
0
1
2
3
4
Titik akhir yang diberikan tidak pernah menjadi bagian dari urutan yang dihasilkan; range(10) menghasilkan 10 nilai, indeks legal untuk
item dengan urutan panjang 10. Dimungkinkan untuk membiarkan rentang dimulai dari angka lain, atau untuk menentukan kenaikan
yang berbeda (bahkan negatif; terkadang ini disebut 'langkah') ):
>>> daftar(rentang(5, 10)) [5, 6, 7,

8, 9]
>>> daftar(rentang(0, 10, 3)) [0, 3, 6, 9]
>>> daftar(rentang(-10, -100, -30)) [-10, -40, -70]
Untuk mengulangi indeks urutan, Anda dapat menggabungkan range() dan len() sebagai berikut:
>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)):
... cetak(i, a[i])

...
0 Mary 1
punya
2a
3 kecil
4 domba
Namun, dalam sebagian besar kasus seperti itu, lebih mudah menggunakan fungsi enumerate(), lihat Teknik Perulangan.
Hal yang aneh terjadi jika Anda hanya mencetak rentang:
18 Bab 4. Lebih Banyak Alat Aliran Kontrol

>>> rentang(10)
rentang(0, 10)
Dalam banyak hal objek yang dikembalikan oleh range() berperilaku seolah-olah itu adalah daftar, tetapi sebenarnya bukan. Ini adalah objek yang
mengembalikan item berturut-turut dari urutan yang diinginkan saat Anda mengulanginya, tetapi tidak benar-benar membuat daftar, sehingga
menghemat ruang.
Kami mengatakan objek seperti itu dapat diubah, yaitu cocok sebagai target untuk fungsi dan konstruksi yang mengharapkan sesuatu dari
mana mereka dapat memperoleh item berturut-turut hingga persediaan habis. Kita telah melihat bahwa pernyataan for adalah sebuah
konstruk, sedangkan contoh fungsi yang menggunakan iterable adalah sum():
>>> jumlah(rentang(4)) # 0 + 1 + 2 + 3 6
Nanti kita akan melihat lebih banyak fungsi yang mengembalikan iterables dan menjadikan iterables sebagai argumen. Pada bab Struktur
Data, kita akan membahas lebih detail tentang list().
4.4 break and continue Statements, dan Klausa lain tentang Loops
Pernyataan break, seperti di C, keluar dari loop for atau while terlampir terdalam.
Pernyataan pengulangan mungkin memiliki klausa lain; itu dieksekusi ketika loop berakhir melalui kelelahan iterable (dengan for) atau
ketika kondisi menjadi salah (dengan while), tetapi tidak ketika loop diakhiri dengan pernyataan break. Ini dicontohkan oleh loop berikut,
yang mencari bilangan prima:
>>> untuk n dalam rentang(2, 10):

... untuk x dalam rentang(2, n):
... jika n % x == 0:
... cetak(n, 'sama dengan', x, '*', n//x)
... merusak
... kalau tidak:
... # loop gagal tanpa menemukan faktor print(n, 'adalah bilangan

... prima')
...
2 bilangan prima 3 bilangan
prima 4 sama dengan 2 * 2
5 bilangan prima 6 sama
dengan 2 * 3 7 bilangan
prima 8 sama dengan 2 * 4
9 sama dengan 3 * 3
(Ya, ini adalah kode yang benar. Perhatikan baik-baik: klausa else milik perulangan for, bukan pernyataan if.)
Ketika digunakan dengan perulangan, klausa else memiliki lebih banyak kesamaan dengan klausa else dari pernyataan try daripada dengan
pernyataan if: klausa else dari pernyataan try berjalan ketika tidak ada pengecualian yang terjadi, dan klausa else dari sebuah loop berjalan
ketika tidak ada break terjadi. Untuk informasi lebih lanjut tentang pernyataan try dan pengecualian, lihat Menangani Pengecualian.
Pernyataan continue, juga dipinjam dari C, dilanjutkan dengan iterasi loop berikutnya:
>>> untuk angka dalam rentang (2, 10):

... jika jumlah % 2 == 0:
... print("Ditemukan bilangan genap", num) lanjutkan
...
... print("Menemukan bilangan ganjil", num)
...
Ditemukan bilangan genap 2
Ditemukan angka ganjil 3
Ditemukan bilangan genap 4
4.4. hancurkan dan lanjutkan Pernyataan, dan Klausa lain tentang Loops 19

Menemukan angka genap 6
Menemukan angka genap 8
4.5 lulus Pernyataan
Pernyataan pass tidak melakukan apa-apa. Itu dapat digunakan ketika pernyataan diperlukan secara sintaksis tetapi program tidak
memerlukan tindakan. Sebagai contoh:
>>> sementara Benar:

... lulus # Sibuk-menunggu interupsi keyboard (Ctrl+C)
...
Ini biasanya digunakan untuk membuat kelas minimal:
>>> kelas KelasKosongku:

... lulus
...
Pass tempat lain yang dapat digunakan adalah sebagai placeholder untuk fungsi atau badan kondisional saat Anda mengerjakan kode baru,
memungkinkan Anda untuk terus berpikir pada tingkat yang lebih abstrak. Pass ini diam-diam diabaikan:
>>> def initlog(*args): pass # Ingatlah

... untuk mengimplementasikan ini!
...
4.6 Pernyataan kecocokan
Pernyataan kecocokan mengambil ekspresi dan membandingkan nilainya dengan pola berurutan yang diberikan sebagai satu atau beberapa
blok kasus. Ini mirip dengan pernyataan switch di C, Java atau JavaScript (dan banyak bahasa lainnya), tetapi lebih mirip dengan pencocokan
pola dalam bahasa seperti Rust atau Haskell. Hanya pola pertama yang cocok yang akan dieksekusi dan juga dapat mengekstrak komponen
(elemen urutan atau atribut objek) dari nilai menjadi variabel.
Bentuk paling sederhana membandingkan nilai subjek terhadap satu atau lebih literal:
def http_error(status): status cocok :
kasus 400:
kembalikan kasus
"Permintaan buruk" 404:
kembali "Tidak ditemukan"
kasus 418:
kembali "Saya poci teh"
kasus _:
kembali "Ada yang salah dengan internet"
Perhatikan blok terakhir: "nama variabel" _ bertindak sebagai wildcard dan tidak pernah gagal untuk mencocokkan. Jika tidak ada kasus yang cocok, tidak ada
cabang dieksekusi.
Anda dapat menggabungkan beberapa literal dalam satu pola menggunakan | ("atau"):
kasus 401 | 403 | 404:

kembali "Tidak diizinkan"
Pola dapat terlihat seperti tugas membongkar, dan dapat digunakan untuk mengikat variabel:

# poin adalah titik pertandingan tupel (x, y) :
case (0, 0):

print("Origin") case (0,
y): print(f"Y={y}") case (x, 0):
print(f"X={x}") case (x,
y): cetak(f"X={x}, Y={y}")
kasus _:
naikkan ValueError("Bukan poin")
Pelajari yang itu dengan cermat! Pola pertama memiliki dua literal, dan dapat dianggap sebagai perluasan dari pola literal yang ditunjukkan di
atas. Tapi dua pola berikutnya menggabungkan literal dan variabel, dan variabel mengikat nilai dari subjek (titik). Pola keempat menangkap
dua nilai, yang membuatnya secara konseptual mirip dengan tugas membongkar (x, y) = titik.
Jika Anda menggunakan kelas untuk menyusun data, Anda dapat menggunakan nama kelas diikuti dengan daftar argumen yang menyerupai
konstruktor, tetapi dengan kemampuan untuk menangkap atribut ke dalam variabel:
Poin kelas :
x: int
y: int
def where_is(point): match point:

case Point(x=0, y=0):
print("Origin") case Point(x=0, y=y):
print(f"Y={y}") titik kasus
(x=x, y=0): cetak(f"X={x}")
Titik kasus ():

print("Di tempat lain")
kasus _:
print("Bukan poin")
Anda dapat menggunakan parameter posisi dengan beberapa kelas bawaan yang menyediakan pengurutan untuk atributnya (misalnya kelas
data). Anda juga dapat menentukan posisi tertentu untuk atribut dalam pola dengan menyetel atribut khusus __match_args__ di kelas Anda.
Jika disetel ke (“x”, “y”), pola berikut semuanya setara (dan semua mengikat atribut y ke variabel var):
Titik(1, var)
Titik(1, y=var)
Titik(x=1, y=var)
Titik(y=var, x=1)
Cara yang disarankan untuk membaca pola adalah dengan melihatnya sebagai bentuk lanjutan dari apa yang akan Anda letakkan di sebelah
kiri tugas, untuk memahami variabel mana yang akan disetel ke apa. Hanya nama mandiri (seperti var di atas) yang diberikan oleh pernyataan
kecocokan. Nama bertitik (seperti foo.bar), nama atribut (x= dan y= di atas) atau nama kelas (dikenali dengan "(...)" di sebelahnya seperti Point
di atas) tidak pernah ditetapkan.
Pola dapat disarangkan secara sewenang-wenang. Misalnya, jika kita memiliki daftar poin yang singkat, kita dapat mencocokkannya seperti ini:
poin pertandingan :
kasus []:
print("Tidak ada titik") case
[Titik(0, 0)]: print(" Asal") case [Titik(x,
y)]: print(f"Titik tunggal {x}, {y}")
4.6. Pernyataan pertandingan 21

kasus [Titik(0, y1), Poin(0, y2)]:

print(f"Dua pada sumbu Y di {y1}, {y2}")
kasus _:
print("Sesuatu yang lain")
Kita bisa menambahkan klausa if ke sebuah pola, yang dikenal sebagai "penjaga". Jika penjaganya salah, pertandingan berlanjut untuk mencoba blok
kasus berikutnya. Perhatikan bahwa pengambilan nilai terjadi sebelum penjaga dievaluasi:
titik pertandingan :
case Point(x, y) if x == y: print(f"Y=X at {x}")
case Point(x, y): print(f"Tidak pada
diagonal")
Beberapa fitur kunci lain dari pernyataan ini:
• Seperti tugas unpacking, pola tuple dan list memiliki arti yang persis sama dan benar-benar cocok secara arbitrer
urutan. Pengecualian penting adalah bahwa mereka tidak cocok dengan iterator atau string.
• Pola urutan mendukung pembongkaran yang diperpanjang: [x, y, *rest] dan (x, y, *rest) berfungsi mirip dengan sehingga (x, y, *_)
membongkar tugas. Nama setelah * juga dapat menjadi dua item _, cocok dengan urutan setidaknya
tanpa mengikat item yang tersisa.
• Pola pemetaan: {"bandwidth": b, "latency": l} mengambil nilai "bandwidth" dan "latensi" dari kamus. Tidak seperti pola urutan, kunci
ekstra diabaikan. Pembongkaran seperti **rest juga didukung. (Tapi **_ akan berlebihan, jadi tidak diperbolehkan.)
• Subpola dapat ditangkap menggunakan kata kunci as:
kasus (Titik(x1, y1), Titik(x2, y2) sebagai p2): ...
akan menangkap elemen kedua dari input sebagai p2 (selama inputnya adalah urutan dua titik)
• Sebagian besar literal dibandingkan dengan persamaan, namun singleton True, False, dan None dibandingkan dengan
identitas.
• Pola dapat menggunakan konstanta bernama. Ini harus berupa nama bertitik untuk mencegahnya ditafsirkan sebagai
variabel tangkapan:
dari enum impor kelas Enum

Warna(Enum):
MERAH = 'merah'
HIJAU = 'hijau'
BIRU = 'biru'
color = Color(input("Masukkan pilihan 'merah', 'biru' atau 'hijau': "))
warna pertandingan :
kasus Warna MERAH:
print("Saya melihat merah!")
case Color.GREEN:
print("Rumput berwarna hijau")
kasus Warna. BIRU:
print("Saya merasa sedih :(")
Untuk penjelasan lebih rinci dan contoh tambahan, Anda dapat melihat PEP 636 yang ditulis dalam format tutorial.

4.7 Mendefinisikan Fungsi
Kita dapat membuat fungsi yang menulis deret Fibonacci ke batas arbitrer:
>>> def fib(n): # tulis deret Fibonacci hingga n """Cetak deret

... Fibonacci hingga n.""" a, b = 0, 1 sedangkan a < n:
...
...
... cetak(a, akhir=' ') a, b = b,
... a+b
... mencetak()
...
>>> # Sekarang panggil fungsi yang baru saja kita definisikan: ...
fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Kata kunci def memperkenalkan definisi fungsi . Itu harus diikuti oleh nama fungsi dan daftar parameter formal yang dikurung. Pernyataan
yang membentuk isi fungsi dimulai dari baris berikutnya, dan harus diberi indentasi.
Pernyataan pertama dari badan fungsi secara opsional dapat berupa string literal; literal string ini adalah string dokumentasi fungsi, atau
docstring. (Selengkapnya tentang docstrings dapat ditemukan di bagian Documentation Strings.) Ada alat yang menggunakan docstrings
untuk menghasilkan dokumentasi online atau cetak secara otomatis, atau membiarkan pengguna menelusuri kode secara interaktif;
merupakan praktik yang baik untuk menyertakan dokumen dalam kode yang Anda tulis, jadi biasakanlah.
Eksekusi suatu fungsi memperkenalkan tabel simbol baru yang digunakan untuk variabel lokal dari fungsi tersebut. Lebih tepatnya,
semua penugasan variabel dalam suatu fungsi menyimpan nilai dalam tabel simbol lokal; sedangkan referensi variabel pertama-tama
terlihat di tabel simbol lokal, lalu di tabel simbol lokal fungsi terlampir, lalu di tabel simbol global, dan terakhir di tabel nama bawaan.
Dengan demikian, variabel global dan variabel fungsi terlampir tidak dapat secara langsung diberi nilai dalam suatu fungsi (kecuali, untuk
variabel global, disebutkan dalam pernyataan global, atau, untuk variabel fungsi terlampir, disebutkan dalam pernyataan nonlokal),
meskipun mereka mungkin direferensikan.
Parameter aktual (argumen) untuk pemanggilan fungsi diperkenalkan di tabel simbol lokal dari fungsi yang dipanggil saat dipanggil;
dengan demikian, argumen diteruskan menggunakan pemanggilan berdasarkan nilai (di mana nilainya selalu berupa referensi objek,
bukan nilai objek).1 Ketika sebuah fungsi memanggil fungsi lain, atau memanggil dirinya sendiri secara rekursif, tabel simbol lokal baru
dibuat untuk pemanggilan tersebut. .
Definisi fungsi mengaitkan nama fungsi dengan objek fungsi dalam tabel simbol saat ini. Penerjemah mengenali objek yang ditunjuk oleh
nama itu sebagai fungsi yang ditentukan pengguna. Nama lain juga dapat menunjuk ke objek fungsi yang sama dan juga dapat digunakan
untuk mengakses fungsi tersebut:
>>> fib
<fungsi fib di 10042ed0>
>>> f = fib
>>> f(100) 0 1
1 2 3 5 8 13 21 34 55 89
Berasal dari bahasa lain, Anda mungkin keberatan bahwa fib bukanlah fungsi tetapi prosedur karena tidak mengembalikan nilai.
Faktanya, bahkan fungsi tanpa pernyataan pengembalian memang mengembalikan nilai, meskipun agak membosankan. Nilai ini disebut
Tidak Ada (ini adalah nama bawaan). Menulis nilai Tidak ada biasanya ditekan oleh juru bahasa jika itu akan menjadi satu-satunya nilai
yang ditulis. Anda dapat melihatnya jika Anda benar-benar ingin menggunakan print():
>>> fib(0)
>>> cetak(fib(0))
Tidak ada
Sangat mudah untuk menulis fungsi yang mengembalikan daftar angka deret Fibonacci, alih-alih mencetaknya:
>>> def fib2(n): # mengembalikan deret Fibonacci hingga n """Mengembalikan deret

... Fibonacci hingga n."""
1 Sebenarnya, referensi panggilan dengan objek akan menjadi deskripsi yang lebih baik, karena jika objek yang dapat diubah diteruskan, penelepon akan melihat perubahan apa pun yang dipanggil.
membuatnya (item dimasukkan ke dalam daftar).
4.7. Mendefinisikan Fungsi 23

... hasil = [] a, b = 0,
... 1 sedangkan a <
... n:
... result.append(a) a, b = b, # Lihat di bawah
... a+b
... hasil pengembalian
...
>>> f100 = fib2(100) >>> f100 # menyebutnya
# tulis hasilnya
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Contoh ini, seperti biasa, menunjukkan beberapa fitur baru Python:
• Pernyataan kembali kembali dengan nilai dari fungsi. kembali tanpa argumen ekspresi kembali
Tidak ada. Jatuh dari akhir fungsi juga mengembalikan Tidak Ada.
• Pernyataan result.append(a) memanggil metode dari hasil objek daftar. Metode adalah fungsi yang 'milik' objek dan diberi nama
obj.nama metode, di mana obj adalah beberapa objek (ini mungkin ekspresi), dan nama metode adalah nama metode yang
ditentukan oleh tipe objek. Jenis yang berbeda menentukan metode yang berbeda. Metode dari jenis yang berbeda dapat
memiliki nama yang sama tanpa menimbulkan ambiguitas. (Dimungkinkan untuk menentukan tipe dan metode objek Anda
sendiri, menggunakan kelas, lihat Kelas) Metode append() yang ditampilkan dalam contoh didefinisikan untuk objek daftar; itu
menambahkan elemen baru di akhir daftar. Dalam contoh ini sama dengan result = result + [a], tetapi lebih efisien.
4.8 Lebih Lanjut tentang Mendefinisikan Fungsi
Dimungkinkan juga untuk mendefinisikan fungsi dengan sejumlah variabel argumen. Ada tiga bentuk yang bisa digabungkan.
4.8.1 Nilai Argumen Default
Bentuk yang paling berguna adalah menentukan nilai default untuk satu atau beberapa argumen. Ini menciptakan fungsi yang dapat
dipanggil dengan lebih sedikit argumen daripada yang diizinkan. Sebagai contoh:
def ask_ok(prompt, retries=4, reminder='Silakan coba lagi!'): while True:
ok = input(prompt) if ok in ('y',
'ye', 'yes'): return True
jika ok di ('n', 'no', 'nop', 'nope'):

mengembalikan Salah
percobaan ulang = percobaan ulang - 1
jika coba lagi < 0:
naikkan ValueError('invalid user response') print(pengingat)
Fungsi ini dapat dipanggil dengan beberapa cara:
• hanya memberikan argumen wajib: ask_ok('Apakah Anda benar-benar ingin berhenti?')
• memberikan salah satu argumen opsional: ask_ok('OK untuk menimpa file?', 2)
• atau bahkan memberikan semua argumen: ask_ok('OK untuk menimpa file?', 2, 'Ayolah, hanya ya atau tidak!')
Contoh ini juga memperkenalkan kata kunci in. Ini menguji apakah urutan berisi nilai tertentu atau tidak.
Nilai default dievaluasi pada titik definisi fungsi dalam lingkup pendefinisian , sehingga

saya = 5
def f(arg=i): cetak(arg)
saya = 6
f()
akan dicetak 5.
Peringatan penting: Nilai default hanya dievaluasi sekali. Ini membuat perbedaan ketika defaultnya adalah objek yang dapat diubah
seperti daftar, kamus, atau instance dari sebagian besar kelas. Misalnya, fungsi berikut mengakumulasi argumen yang diteruskan ke
panggilan berikutnya:
def f(a, L=[]): L.append(a)

kembalikan L
cetak(f(1))
cetak(f(2))
cetak(f(3))
Ini akan dicetak
[1]
[1, 2] [1,
2, 3]
Jika Anda tidak ingin default dibagikan di antara panggilan berikutnya, Anda dapat menulis fungsi seperti ini:
def f(a, L=Tidak ada): jika

L tidak ada:
L = []
L.append(a)
mengembalikan L
4.8.2 Argumen Kata Kunci

Fungsi juga dapat dipanggil menggunakan argumen kata kunci dalam bentuk kwarg=nilai. Misalnya, fungsi berikut:
def parrot(voltage, state=' kaku', action='voom', type='Norwegian Blue'):

print("-- Burung beo ini tidak mau", action, end=' ') print("jika Anda memasukkan",
voltage, "volts through it.") print("-- Bulu indah, the", type) print ("-- Ini", nyatakan, "!")
menerima satu argumen yang diperlukan (tegangan) dan tiga argumen opsional (status, tindakan, dan tipe). Fungsi ini dapat dipanggil
dengan salah satu cara berikut:
burung beo(1000) # 1 argumen posisi # 1 argumen kata

burung beo(tegangan=1000) kunci # 2 argumen kata kunci # 2
burung beo(tegangan=1000000, action='VOOOOOM') burung argumen kata kunci # 3 argumen posisi
beo(action='VOOOOOM', tegangan=1000000) burung beo(' sejuta',
'kehilangan hidup', 'melompat' ) parrot(' seribu', status='mendorong bunga
aster') posisi #1, 1 kata kunci
tetapi semua panggilan berikut tidak valid:
4.8. Lebih lanjut tentang Mendefinisikan Fungsi 25

parrot() # argumen yang diperlukan tidak ada

parrot(voltage=5.0, 'dead') # argumen bukan kata kunci setelah argumen kata kunci parrot(110, voltage=220) parrot(actor='John
Cleese') # argumen kata kunci tidak diketahui # nilai duplikat untuk argumen yang sama
Dalam pemanggilan fungsi, argumen kata kunci harus mengikuti argumen posisi. Semua argumen kata kunci yang
diteruskan harus cocok dengan salah satu argumen yang diterima oleh fungsi (mis. aktor bukan argumen yang valid untuk
fungsi parrot), dan urutannya tidak penting. Ini juga termasuk argumen non-opsional (misalnya parrot(voltage=1000) juga
valid). Tidak ada argumen yang boleh menerima nilai lebih dari satu kali. Berikut adalah contoh yang gagal karena pembatasan ini:
>>> fungsi def (a):

... lulus
...
>>> fungsi(0, a=0)
TypeError: function() mendapat banyak nilai untuk argumen 'a'
Ketika parameter formal terakhir dari bentuk **nama hadir, ia menerima kamus (lihat pemetaan jenis) yang berisi semua
argumen kata kunci kecuali yang sesuai dengan parameter formal. Ini dapat digabungkan dengan parameter formal dari
bentuk *nama (dijelaskan pada sub-bagian berikutnya) yang menerima sebuah tuple yang berisi argumen posisi di luar
daftar parameter formal. (*nama harus muncul sebelum **nama.) Misalnya, jika kita mendefinisikan fungsi seperti ini:
def cheeseshop(kind, *arguments, **keywords): print("-- Apakah Anda punya",

kind, "?") print("-- Maaf, kami kehabisan", kind) untuk arg dalam
argumen: print(arg) print("-" * 40) untuk kw dalam kata kunci: print(kw, ":",
kata kunci[kw])
Bisa disebut seperti ini:
cheeseshop("Limburger", "Ini sangat encer, Pak.", "Benar-benar sangat, SANGAT

encer, Pak.", pemilik toko="Michael Palin", client="John Cleese",
sketch="Sketsa Toko Keju")
dan tentu saja itu akan mencetak:
-- Apakah Anda punya Limburger ?

-- Maaf, kami kehabisan Limburger Ini sangat encer, Pak.
Ini benar-benar sangat, SANGAT encer, Pak.

----------------------------------------
penjaga toko : Michael Palin klien : John

Cleese
sketsa: Sketsa Toko Keju
Perhatikan bahwa urutan argumen kata kunci dicetak dijamin cocok dengan urutan yang diberikan dalam pemanggilan
fungsi.

4.8.3 Parameter khusus

Secara default, argumen dapat diteruskan ke fungsi Python baik dengan posisi atau secara eksplisit dengan kata kunci.
Untuk keterbacaan dan kinerja, masuk akal untuk membatasi cara argumen dapat diteruskan sehingga pengembang hanya
perlu melihat definisi fungsi untuk menentukan apakah item diteruskan oleh posisi, posisi atau kata kunci, atau kata kunci.
Definisi fungsi mungkin terlihat seperti:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

----------- ---------- ----------
| | |
|
Posisi atau kata kunci |
|
- Kata kunci saja
-- Posisi saja
di mana / dan * adalah opsional. Jika digunakan, simbol ini menunjukkan jenis parameter dengan cara argumen dapat
diteruskan ke fungsi: hanya posisi, posisi atau kata kunci, dan kata kunci saja. Parameter kata kunci juga disebut sebagai
parameter bernama.
Argumen Posisi atau Kata Kunci
Jika / dan * tidak ada dalam definisi fungsi, argumen dapat diteruskan ke fungsi berdasarkan posisi atau kata kunci.
Parameter Hanya-Posisi
Melihat ini sedikit lebih detail, dimungkinkan untuk menandai parameter tertentu sebagai hanya posisi. Jika hanya posisi,
urutan parameter penting, dan parameter tidak dapat diteruskan dengan kata kunci. Parameter khusus posisi ditempatkan
sebelum / (garis miring). / digunakan untuk secara logis memisahkan parameter hanya-posisi dari parameter lainnya. Jika
tidak ada / dalam definisi fungsi, tidak ada parameter hanya posisi.
Parameter setelah / mungkin hanya posisi atau kata kunci atau hanya kata kunci.
Argumen Kata Kunci Saja
Untuk menandai parameter sebagai hanya kata kunci, yang menunjukkan bahwa parameter harus diteruskan oleh argumen kata kunci, beri tanda
* pada daftar argumen tepat sebelum parameter khusus kata kunci pertama .
Contoh Fungsi
Perhatikan contoh definisi fungsi berikut dengan memperhatikan penanda / dan *:
>>> def standard_arg(arg): print(arg)

...
...
>>> def pos_only_arg(arg, /):
... cetak(arg)
...
>>> def kwd_only_arg(*, arg):
... cetak(arg)
...
>>> def combine_example(pos_only, /, standard, *, kwd_only):
... cetak(pos_only, standar, kwd_only)
Definisi fungsi pertama, standard_arg, bentuk yang paling umum, tidak membatasi konvensi pemanggilan dan argumen dapat
diteruskan oleh posisi atau kata kunci:

>>> standard_arg(2) 2
>>> standard_arg(arg=2) 2
Fungsi kedua pos_only_arg dibatasi untuk hanya menggunakan parameter posisi karena ada / dalam definisi fungsi:
>>> pos_only_arg(1) 1
>>> pos_only_arg(arg=1)
TypeError: pos_only_arg() mendapat beberapa argumen hanya-posisi yang diteruskan sebagai kata kunciÿ
ÿargumen: 'arg'
Fungsi ketiga kwd_only_args hanya mengizinkan argumen kata kunci seperti yang ditunjukkan oleh * dalam definisi fungsi:
>>> kwd_only_arg(3)
TypeError: kwd_only_arg() membutuhkan 0 argumen posisi tetapi 1 diberikan
>>> kwd_only_arg(arg=3) 3
Dan yang terakhir menggunakan ketiga konvensi pemanggilan dalam definisi fungsi yang sama:
>>> contoh_gabungan(1, 2, 3)
TypeError: combine_example () membutuhkan 2 argumen posisi tetapi 3 diberikan
>>> contoh_gabungan (1, 2, kwd_only=3) 1 2 3
>>> contoh_gabungan (1, standar=2, kwd_only=3) 1 2 3
>>> contoh_gabungan(pos_only=1, standar=2, kwd_only=3)

TypeError: combine_example () mendapat beberapa argumen hanya-posisi yang diteruskan sebagai kata kunciÿ
ÿargumen: 'pos_only'
Terakhir, pertimbangkan definisi fungsi ini yang berpotensi bertabrakan antara nama argumen posisi dan **kwds yang memiliki nama sebagai
kunci:
def foo(nama, **kwds):

kembalikan 'nama' dalam kwds
Tidak ada kemungkinan pemanggilan yang membuatnya mengembalikan True karena kata kunci 'nama' akan selalu mengikat ke parameter pertama.
Sebagai contoh:
>>> foo(1, **{'nama': 2})

TypeError: foo() mendapat banyak nilai untuk argumen 'nama' >>>

Tetapi menggunakan / (argumen hanya posisi), itu dimungkinkan karena memungkinkan nama sebagai argumen posisi dan 'nama' sebagai kunci
dalam argumen kata kunci:
>>> def foo(nama, /, **kwds): kembalikan

... 'nama' dalam kwds
...
>>> foo(1, **{'nama': 2})
BENAR
Dengan kata lain, nama parameter hanya posisi dapat digunakan dalam **kwds tanpa ambiguitas.
Rekap
Kasus penggunaan akan menentukan parameter mana yang akan digunakan dalam definisi fungsi:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
Sebagai panduan:
• Gunakan hanya posisi jika Anda ingin nama parameter tidak tersedia bagi pengguna. Ini berguna ketika nama parameter tidak memiliki
arti sebenarnya, jika Anda ingin menerapkan urutan argumen saat fungsi dipanggil atau jika Anda perlu mengambil beberapa parameter
posisi dan kata kunci arbitrer.
• Gunakan hanya kata kunci jika nama memiliki arti dan definisi fungsi lebih mudah dipahami dengan nama yang eksplisit atau Anda ingin
mencegah pengguna bergantung pada posisi argumen yang diteruskan.
• Untuk API, gunakan positional-only untuk mencegah perubahan API yang rusak jika nama parameter diubah di
masa depan.
4.8.4 Daftar Argumen Sewenang-wenang
Akhirnya, opsi yang paling jarang digunakan adalah menentukan bahwa suatu fungsi dapat dipanggil dengan sejumlah argumen yang berubah-
ubah. Argumen ini akan dibungkus dalam sebuah tuple (lihat Tuples dan Sequences). Sebelum jumlah argumen variabel, nol atau lebih argumen
normal dapat terjadi.
def write_multiple_items(file, separator, *args): file.write(separator.join(args))
Biasanya, argumen variadik ini akan menjadi yang terakhir dalam daftar parameter formal, karena mereka meraup semua argumen masukan
yang tersisa yang diteruskan ke fungsi. Parameter formal apa pun yang terjadi setelah parameter *args adalah argumen 'kata kunci saja', yang
berarti bahwa parameter tersebut hanya dapat digunakan sebagai kata kunci daripada argumen posisional.
>>> def concat(*args, sep="/"): return sep.join(args)

...
...
>>> concat("bumi", "mars", "venus") 'bumi/mars/venus'
>>> concat("bumi", "mars", "venus", sep=".") 'bumi. mars
venus'

4.8.5 Membongkar Daftar Argumen
Situasi sebaliknya terjadi ketika argumen sudah ada dalam daftar atau tupel tetapi perlu dibongkar untuk pemanggilan
fungsi yang memerlukan argumen posisi terpisah. Misalnya, fungsi range() bawaan mengharapkan argumen start dan stop
yang terpisah. Jika tidak tersedia secara terpisah, tulis pemanggilan fungsi dengan *-operator untuk membongkar argumen
dari daftar atau tuple:
>>> daftar(rentang(3, 6)) [3, 4, # panggilan normal dengan argumen terpisah

5] >>> args = [3, 6] >>>
daftar(rentang(*args)) [3, 4, 5]
# panggil dengan argumen yang dibongkar dari daftar
Dengan cara yang sama, kamus dapat memberikan argumen kata kunci dengan **-operator:
>>> def parrot(tegangan, status=' kaku', aksi='voom'):

... print("-- Parrot ini tidak mau", action, end=' ') print("jika Anda memasukkan",
... voltage, "volts through it.", end=' ') print("E's", state, " !")
...
...
>>> d = {"voltage": "empat juta", "state": "bleedin' demised", "action": "VOOM"} >>> parrot(**d)
-- Beo ini tidak akan VOOM jika Anda memasukkan empat juta volt ke dalamnya. E berdarah
ÿ' mati!
4.8.6 Ekspresi Lambda
Fungsi anonim kecil dapat dibuat dengan kata kunci lambda. Fungsi ini mengembalikan jumlah dari dua argumennya:
lambda a, b: a+b. Fungsi Lambda dapat digunakan di mana pun objek fungsi diperlukan. Mereka secara sintaksis dibatasi
untuk satu ekspresi. Secara semantik, mereka hanyalah gula sintaksis untuk definisi fungsi normal. Seperti definisi fungsi
bersarang, fungsi lambda dapat mereferensikan variabel dari cakupan yang memuat:
>>> def make_incrementor(n): kembalikan

... lambda x: x + n
...
>>> f = make_incrementor(42) >>> f(0) 42
>>> f(1) 43
Contoh di atas menggunakan ekspresi lambda untuk mengembalikan fungsi. Kegunaan lain adalah untuk melewatkan fungsi kecil
sebagai argumen:
>>> pasang = [(1, 'satu'), (2, 'dua'), (3, 'tiga'), (4, 'empat')] >>> pasang.sort(key=lambda pasangan:
pasangan[1]) >>> pasangan [(4, 'empat'), (1, 'satu'), (3, 'tiga'), (2, 'dua')]

4.8.7 Rangkaian Dokumentasi
Berikut adalah beberapa konvensi tentang konten dan pemformatan string dokumentasi.
Baris pertama harus selalu merupakan ringkasan singkat dan ringkas dari tujuan objek. Untuk singkatnya, itu tidak boleh secara eksplisit
menyatakan nama atau tipe objek, karena ini tersedia dengan cara lain (kecuali jika nama tersebut kebetulan merupakan kata kerja yang
menjelaskan operasi fungsi). Baris ini harus dimulai dengan huruf kapital dan diakhiri dengan titik.
Jika ada lebih banyak baris dalam string dokumentasi, baris kedua harus kosong, memisahkan ringkasan secara visual dari deskripsi
lainnya. Baris berikut harus berupa satu atau lebih paragraf yang menjelaskan konvensi pemanggilan objek, efek sampingnya, dll.
Parser Python tidak menghapus indentasi dari literal string multi-baris di Python, jadi alat yang memproses dokumentasi harus
menghapus indentasi jika diinginkan. Ini dilakukan dengan menggunakan konvensi berikut. Baris tidak kosong pertama setelah baris
pertama string menentukan jumlah lekukan untuk seluruh string dokumentasi. (Kita tidak dapat menggunakan baris pertama karena
biasanya bersebelahan dengan tanda kutip pembuka string sehingga indentasinya tidak terlihat dalam literal string.) Spasi "setara"
dengan indentasi ini kemudian dihapus dari awal semua baris string . Garis yang indentasinya lebih kecil tidak boleh muncul, tetapi jika
muncul, semua spasi putih di depannya harus dihilangkan. Kesetaraan spasi harus diuji setelah penambahan tab (biasanya menjadi 8
spasi).
Berikut adalah contoh docstring multi-baris:
>>> def my_function(): """Tidak

... melakukan apa-apa, tetapi mendokumentasikannya.
...
... Tidak, sungguh, itu tidak melakukan apa-apa.
... """
... lulus
...
>>> cetak(my_function.__doc__)
Tidak melakukan apa-apa, tetapi mendokumentasikannya.
Tidak, sungguh, itu tidak melakukan apa-apa.
4.8.8 Anotasi Fungsi
Anotasi fungsi adalah informasi metadata yang sepenuhnya opsional tentang jenis yang digunakan oleh fungsi yang ditentukan pengguna
(lihat PEP 3107 dan PEP 484 untuk informasi lebih lanjut).
Anotasi disimpan dalam atribut __annotations__ dari fungsi sebagai kamus dan tidak berpengaruh pada bagian lain dari fungsi tersebut.
Anotasi parameter ditentukan oleh tanda titik dua setelah nama parameter, diikuti dengan ekspresi yang mengevaluasi nilai anotasi.
Anotasi pengembalian ditentukan oleh literal ->, diikuti oleh ekspresi, antara daftar parameter dan titik dua yang menunjukkan akhir
pernyataan def. Contoh berikut memiliki argumen yang diperlukan, argumen opsional, dan nilai pengembalian yang dianotasi:
>>> def f(ham: str, telur: str = 'telur') -> str:

... print("Anotasi:", f.__annotasi__) print("Argumen:", ham, telur)
... kembalikan ham + ' dan '
... + telur
...
>>> f('spam')
Anotasi: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Argumen: telur spam 'spam
dan telur'

4.9 Selingan: Gaya Pengodean
Sekarang Anda akan menulis potongan Python yang lebih panjang dan lebih kompleks, inilah saat yang tepat untuk berbicara tentang gaya pengkodean.
Sebagian besar bahasa dapat ditulis (atau lebih ringkas, diformat) dalam gaya yang berbeda; beberapa lebih mudah dibaca daripada yang lain.
Memudahkan orang lain untuk membaca kode Anda selalu merupakan ide yang bagus, dan mengadopsi gaya pengkodean yang bagus sangat membantu
untuk itu.
Untuk Python, PEP 8 telah muncul sebagai panduan gaya yang dipatuhi sebagian besar proyek; itu mempromosikan gaya pengkodean yang sangat
mudah dibaca dan menyenangkan mata. Setiap pengembang Python harus membacanya di beberapa titik; berikut adalah poin terpenting yang diekstraksi
untuk Anda:
• Gunakan lekukan 4 spasi, dan tanpa tab.
4 spasi adalah kompromi yang baik antara lekukan kecil (memungkinkan kedalaman sarang yang lebih besar) dan lekukan besar (lebih mudah
dibaca). Tab menimbulkan kebingungan, dan sebaiknya ditinggalkan.
• Bungkus baris sehingga tidak melebihi 79 karakter.
Ini membantu pengguna dengan tampilan kecil dan memungkinkan beberapa file kode berdampingan pada tampilan yang lebih besar.
• Gunakan baris kosong untuk memisahkan fungsi dan kelas, dan blok kode yang lebih besar di dalam fungsi.
• Jika memungkinkan, berikan komentar pada baris mereka sendiri.
• Gunakan docstrings.
• Gunakan spasi di sekitar operator dan setelah koma, tetapi tidak langsung di dalam konstruksi tanda kurung: a = f(1, 2)
+ g(3, 4).
• Beri nama kelas dan fungsi Anda secara konsisten; konvensinya adalah menggunakan UpperCamelCase untuk kelas dan huruf kecil_dengan_garis
bawah untuk fungsi dan metode. Selalu gunakan self sebagai nama untuk argumen metode pertama (lihat A First Look at Classes untuk informasi
lebih lanjut tentang kelas dan metode).
• Jangan gunakan penyandian mewah jika kode Anda dimaksudkan untuk digunakan di lingkungan internasional. Standar Python, UTF-8, atau
bahkan ASCII biasa berfungsi paling baik dalam hal apa pun.
• Demikian pula, jangan gunakan karakter non-ASCII dalam pengidentifikasi jika hanya ada sedikit kemungkinan orang yang berbicara bahasa lain
akan membaca atau mempertahankan kode tersebut.

BAB
LIMA
STRUKTUR DATA
Bab ini menjelaskan beberapa hal yang telah Anda pelajari secara lebih mendetail, dan menambahkan beberapa hal baru juga.
5.1 Lebih Lanjut tentang Daftar
Tipe data daftar memiliki beberapa metode lagi. Berikut ini semua metode objek daftar:
daftar.tambahkan(x)
Tambahkan item ke akhir daftar. Setara dengan a[len(a):] = [x].
list.extend(dapat diubah)
Perpanjang daftar dengan menambahkan semua item dari iterable. Setara dengan a[len(a):] = iterable.
daftar.sisipkan(i, x)
Masukkan item pada posisi tertentu. Argumen pertama adalah indeks elemen sebelum disisipkan, jadi a.insert(0, x)
menyisipkan di depan daftar, dan a.insert(len(a), x) setara dengan a. tambahkan (x).
daftar.hapus(x)
Hapus item pertama dari daftar yang nilainya sama dengan x. Itu memunculkan ValueError jika tidak ada item seperti itu.
daftar.pop([i])
Hapus item pada posisi yang diberikan dalam daftar, dan kembalikan. Jika tidak ada indeks yang ditentukan, a.pop()
menghapus dan mengembalikan item terakhir dalam daftar. (Kurung siku di sekitar i pada tanda tangan metode
menunjukkan bahwa parameternya opsional, bukan berarti Anda harus mengetikkan tanda kurung siku pada posisi itu.
Anda akan sering melihat notasi ini di Referensi Pustaka Python.)
daftar.hapus()
Hapus semua item dari daftar. Setara dengan del a[:].
daftar.indeks(x[, mulai[, akhir ] ])

Kembalikan indeks berbasis nol dalam daftar item pertama yang nilainya sama dengan x. Menimbulkan ValueError jika tidak
ada item tersebut.
Argumen opsional awal dan akhir diinterpretasikan seperti dalam notasi irisan dan digunakan untuk membatasi pencarian
ke urutan tertentu dari daftar. Indeks yang dikembalikan dihitung relatif terhadap awal urutan penuh daripada argumen
awal .
daftar.hitung(x)
Kembalikan berapa kali x muncul dalam daftar.
list.sort(*, key=None, reverse=False)

Sortir item daftar di tempat (argumen dapat digunakan untuk mengurutkan kustomisasi, lihat diurutkan() untuk
penjelasannya).
daftar.balik()
Balikkan elemen daftar pada tempatnya.
33
daftar.copy()
Kembalikan salinan daftar yang dangkal. Setara dengan [:].
Contoh yang menggunakan sebagian besar metode daftar:
>>> buah- buahan = ['jeruk', 'apel', 'pir', 'pisang', 'kiwi', 'apel', 'pisang'] >>> buah- buahan.hitung('apel') 2
>>> buah-buahan.hitung('jeruk keprok')

0
>>> buah-buahan.indeks('pisang')
3
>>> fruits.index('banana', 4) # Temukan pisang berikutnya mulai dari posisi 4
6
>>> buah-buahan.reverse() >>>
buah-buahan
['pisang', 'apel', 'kiwi', 'pisang', 'pir', 'apel', 'jeruk'] >>> buah-buahan.append('anggur') >>> buah- buahan
['pisang', 'apel', 'kiwi', 'pisang', 'pir', 'apel', 'jeruk', 'anggur'] >>> buah- buahan.sort() >>> buah-buahan
['apel', 'apel', 'pisang', 'pisang', 'anggur', 'kiwi', 'jeruk', 'pir'] >>> buah- buahan.pop() 'pir'
Anda mungkin telah memperhatikan bahwa metode seperti menyisipkan, menghapus, atau mengurutkan yang hanya mengubah daftar tidak memiliki nilai kembalian
1
yang dicetak – mereka mengembalikan default Tidak ada. Ini adalah prinsip desain untuk semua struktur data yang bisa berubah di Python.
Hal lain yang mungkin Anda perhatikan adalah tidak semua data dapat diurutkan atau dibandingkan. Misalnya, [Tidak ada, 'halo', 10] tidak
mengurutkan karena bilangan bulat tidak dapat dibandingkan dengan string dan Tidak ada yang tidak dapat dibandingkan dengan jenis
lainnya. Selain itu, ada beberapa tipe yang tidak memiliki relasi pengurutan yang ditentukan. Misalnya, 3+4j < 5+7j bukanlah perbandingan yang valid.
5.1.1 Menggunakan Daftar sebagai Tumpukan
Metode daftar membuatnya sangat mudah untuk menggunakan daftar sebagai tumpukan, di mana elemen terakhir yang ditambahkan adalah
elemen pertama yang diambil (“last-in, first-out”). Untuk menambahkan item ke bagian atas tumpukan, gunakan append(). Untuk mengambil item
dari atas tumpukan, gunakan pop() tanpa indeks eksplisit. Sebagai contoh:
>>> tumpukan = [3, 4, 5]

>>> stack.append(6) >>>
stack.append(7) >>> stack
[3, 4, 5, 6, 7] >>>
stack.pop() 7
>>> tumpukan
[3, 4, 5, 6] >>>
stack.pop() 6
>>> stack.pop() 5
>>> tumpukan
[3, 4]
1
Bahasa lain dapat mengembalikan objek yang dimutasi, yang memungkinkan rangkaian metode, seperti d->insert("a")->remove("b")->sort();
.
34 Bab 5. Struktur Data

5.1.2 Menggunakan Daftar sebagai Antrean
Dimungkinkan juga untuk menggunakan daftar sebagai antrian, di mana elemen pertama yang ditambahkan adalah elemen pertama yang
diambil ("masuk pertama, keluar pertama"); namun, daftar tidak efisien untuk tujuan ini. Sementara menambahkan dan muncul dari akhir daftar
cepat, melakukan sisipan atau muncul dari awal daftar lambat (karena semua elemen lain harus digeser satu).
Untuk mengimplementasikan antrean, gunakan collections.deque yang dirancang untuk menambahkan dan muncul dengan cepat dari kedua
ujungnya. Sebagai contoh:
>>> dari koleksi import deque >>> queue =

deque(["Eric", "John", "Michael"]) >>> queue.append("Terry") >>>
queue.append("Graham") >>> antrian.popleft() # Terry tiba
# Graham tiba
# Yang pertama tiba sekarang pergi
'Eric'
>>> antrian.popleft() # Yang kedua tiba sekarang pergi
'Yohanes'
deque(['Michael', 'Terry', 'Graham']) # Sisa antrian dalam urutan kedatangan >>> antrian
5.1.3 Daftar Pemahaman
Pemahaman daftar menyediakan cara ringkas untuk membuat daftar. Aplikasi umum adalah membuat daftar baru di mana setiap elemen adalah
hasil dari beberapa operasi yang diterapkan ke setiap anggota urutan lain atau iterable, atau untuk membuat urutan elemen yang memenuhi
kondisi tertentu.
Sebagai contoh, misalkan kita ingin membuat daftar kotak, seperti:
>>> kotak = [] >>> untuk

x dalam rentang(10):
... kotak.tambahkan(x**2)
...
>>> kotak [0, 1,
4, 9, 16, 25, 36, 49, 64, 81]
Perhatikan bahwa ini membuat (atau menimpa) variabel bernama x yang masih ada setelah loop selesai. Kami dapat menghitung daftar kotak
tanpa efek samping menggunakan:
kuadrat = daftar(peta(lambda x: x**2, range(10)))
atau, ekuivalen:
kuadrat = [x**2 untuk x dalam rentang(10)]
yang lebih ringkas dan mudah dibaca.
Daftar pemahaman terdiri dari tanda kurung yang berisi ekspresi yang diikuti oleh klausa for, kemudian nol atau lebih klausa for atau if. Hasilnya
akan berupa daftar baru yang dihasilkan dari evaluasi ekspresi dalam konteks klausa for dan if yang mengikutinya. Misalnya, listcomp ini
menggabungkan elemen dari dua daftar jika tidak sama:
>>> [(x, y) untuk x di [1,2,3] untuk y di [3,1,4] if x != y] [(1, 3), (1, 4), (2 , 3), (2, 1), (2, 4),
(3, 1), (3, 4)]
dan itu setara dengan:
>>> sisir = [] >>>

untuk x di [1,2,3]: untuk y di
... [3,1,4]: jika x != y:
...
... sisir.tambahkan((x, y))
...
5.1. Lebih lanjut tentang Daftar 35

>>> sisir
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Perhatikan bagaimana urutan pernyataan for dan if sama di kedua cuplikan ini.
Jika ekspresi adalah sebuah tupel (misalnya (x, y) pada contoh sebelumnya), maka harus diberi tanda kurung.
>>> vec = [-4, -2, 0, 2, 4] >>> # buat daftar

baru dengan nilai dua kali lipat
>>> [x*2 untuk x dalam vec]
[-8, -4, 0, 4, 8] >>> # filter
daftar untuk mengecualikan angka negatif >>> [x untuk x di vec jika x >= 0] [0, 2,
4] >>> # menerapkan fungsi ke semua elemen >>> [abs(x) untuk x dalam vec] [4,
2, 0, 2, 4] >>> # memanggil metode pada setiap elemen
>>> buah segar = ['pisang', 'loganberry ', 'markisa '] >>> [weapon.strip() untuk senjata di buah segar]
['pisang', 'loganberry', 'markisa'] >>> # buat daftar 2-tupel seperti (bilangan, kotak) >>> [(x, x**2) untuk x
dalam rentang(6)] [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)] >>> # tuple harus dalam tanda kurung, jika
tidak, kesalahan akan muncul >>> [x, x**2 untuk x dalam rentang (6)]
File "<stdin>", baris 1 [x, x**2

untuk x dalam rentang(6)]
^^^^^^^
SyntaxError: apakah Anda lupa tanda kurung di sekitar target pemahaman? >>> # ratakan daftar menggunakan listcomp
dengan dua 'for' >>> vec = [[1,2,3], [4,5,6], [7,8,9]] >>> [num untuk elem di vec untuk num di elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Daftar pemahaman dapat berisi ekspresi kompleks dan fungsi bersarang:
>>> from math import pi >>>

[str(round(pi, i)) for i in range(1, 6)] ['3.1', '3.14', '3.142', '3.1416', '3.14159' ]
5.1.4 Pemahaman Daftar Bersarang
Ekspresi awal dalam pemahaman daftar dapat berupa sembarang ekspresi, termasuk pemahaman daftar lainnya.
Pertimbangkan contoh matriks 3x4 berikut yang diimplementasikan sebagai daftar 3 daftar dengan panjang 4:
>>> matriks = [
... [1, 2, 3, 4], [5, 6, 7,
... 8], [9, 10, 11, 12],
...
... ]
Pemahaman daftar berikut akan mengubah urutan baris dan kolom:
>>> [[baris[i] untuk baris dalam matriks] untuk i dalam rentang(4)] [[1, 5, 9], [2, 6,
10], [3, 7, 11], [4, 8, 12]]
Seperti yang kita lihat di bagian sebelumnya, pemahaman daftar dalam dievaluasi dalam konteks for yang mengikutinya,
jadi contoh ini setara dengan:

>>> dialihkan = [] >>> untuk

i dalam rentang (4):
... transposed.append([baris[i] untuk baris dalam matriks])
...
>>> dialihkan [[1, 5,
9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
yang, pada gilirannya, sama dengan:
>>> transposed = [] >>> for

i in range(4): # 3 baris berikut
... mengimplementasikan nested listcomp transposed_row = [] untuk baris dalam
... matriks:
...
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> dialihkan [[1, 5,
9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Di dunia nyata, Anda harus memilih fungsi bawaan daripada pernyataan alur yang rumit. Fungsi zip() akan bekerja dengan baik untuk
kasus penggunaan ini:
>>> daftar(zip(*matriks)) [(1, 5, 9),

(2, 6, 10), (3, 7, 11), (4, 8, 12)]
Lihat Membongkar Daftar Argumen untuk detail tentang tanda bintang di baris ini.
5.2 Pernyataan del
Ada cara untuk menghapus item dari daftar yang diberikan indeksnya alih-alih nilainya: pernyataan del. Ini berbeda dari metode pop() yang
mengembalikan nilai. Pernyataan del juga dapat digunakan untuk menghapus irisan dari daftar atau menghapus seluruh daftar (yang kita
lakukan sebelumnya dengan menugaskan daftar kosong ke irisan). Sebagai contoh:
>>> a = [-1, 1, 66.25, 333, 333, 1234.5] >>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5] >>> dari a [2:4]
>>> a
[1, 66.25 , 1234.5] >>> dari
a[:]
>>> a
[]
del juga dapat digunakan untuk menghapus seluruh variabel:
>>> del a
Merujuk nama a selanjutnya adalah kesalahan (setidaknya sampai nilai lain diberikan padanya). Kami akan menemukan kegunaan lain
untuk del nanti.
5.2. Pernyataan del 37

5.3 Tupel dan Urutan

Kami melihat bahwa daftar dan string memiliki banyak properti umum, seperti operasi pengindeksan dan pemotongan. Mereka
adalah dua contoh tipe data urutan (lihat typeseq). Karena Python adalah bahasa yang berkembang, tipe data urutan lainnya
dapat ditambahkan. Ada juga tipe data urutan standar lainnya: tuple.
Sebuah tuple terdiri dari sejumlah nilai yang dipisahkan dengan koma, misalnya:
>>> t = 12345, 54321, 'halo!' >>> t[0] 12345
>>> t
(12345, 54321, 'halo!')
>>> # Tupel dapat disarangkan: ... u = t, (1, 2,
3, 4, 5)
>>> kamu
((12345, 54321, 'halo!'), (1, 2, 3, 4, 5))

>>> # Tupel tidak dapat diubah: ... t[0] = 88888

TypeError: objek 'tuple' tidak mendukung penugasan item >>> # tetapi dapat berisi objek yang dapat
diubah: v = ([1, 2, 3], [3, 2, 1])
...
>>> v
([1, 2, 3], [3, 2, 1])
Seperti yang Anda lihat, pada tupel keluaran selalu tertutup dalam tanda kurung, sehingga tupel bersarang diinterpretasikan dengan
benar; mereka mungkin dimasukkan dengan atau tanpa tanda kurung di sekitarnya, meskipun seringkali tanda kurung diperlukan (jika
tuple adalah bagian dari ekspresi yang lebih besar). Tidak mungkin menetapkan ke masing-masing item tupel, namun dimungkinkan
untuk membuat tupel yang berisi objek yang dapat diubah, seperti daftar.
Meskipun tupel mungkin tampak mirip dengan daftar, mereka sering digunakan dalam situasi yang berbeda dan untuk tujuan
yang berbeda. Tupel tidak dapat diubah, dan biasanya berisi urutan elemen heterogen yang diakses melalui pembongkaran
(lihat nanti di bagian ini) atau pengindeksan (atau bahkan dengan atribut dalam kasus Namedtuple). Daftar bisa berubah, dan
elemennya biasanya homogen dan diakses dengan mengulang daftar.
Masalah khusus adalah pembuatan tupel yang berisi 0 atau 1 item: sintaks memiliki beberapa keanehan tambahan untuk
mengakomodasi ini. Tupel kosong dibangun oleh sepasang tanda kurung kosong; tuple dengan satu item dibangun dengan
mengikuti nilai dengan koma (tidak cukup untuk menyertakan satu nilai dalam tanda kurung). Jelek, tapi efektif. Sebagai
contoh:
>>> kosong = () >>>

singleton = 'halo', >>> len(kosong) 0 # <- perhatikan tanda koma
>>> len(tunggal) 1
>>> lajang ('halo',)
Pernyataan t = 12345, 54321, 'halo!' adalah contoh pengepakan tupel: nilai 12345, 54321 dan 'hello!' dikemas bersama
dalam sebuah tuple. Operasi sebaliknya juga dimungkinkan:
>>> x, y, z = t
Ini disebut, cukup tepat, membongkar urutan dan berfungsi untuk setiap urutan di sisi kanan. Pembongkaran urutan
mensyaratkan bahwa ada banyak variabel di sisi kiri tanda sama dengan jumlah elemen dalam urutan. Perhatikan bahwa
beberapa penugasan sebenarnya hanyalah kombinasi dari pengepakan tupel dan pembongkaran urutan.

5.4 Set
Python juga menyertakan tipe data untuk set. Himpunan adalah koleksi tak terurut tanpa elemen duplikat. Penggunaan dasar termasuk
pengujian keanggotaan dan menghilangkan entri duplikat. Set objek juga mendukung operasi matematika seperti penyatuan,
persimpangan, perbedaan, dan perbedaan simetris.
Kurung kurawal atau fungsi set() dapat digunakan untuk membuat set. Catatan: untuk membuat set kosong Anda harus menggunakan
set(), bukan {}; yang terakhir membuat kamus kosong, struktur data yang akan kita bahas di bagian selanjutnya.
Berikut demonstrasi singkatnya:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} # menunjukkan bahwa duplikat telah dihapus >>>
print(basket) {'orange', ' pisang', 'pir', 'apel'} >>> 'jeruk' dalam keranjang
# pengujian keanggotaan cepat

BENAR
>>> 'crabgrass' di keranjang

PALSU
>>> # Mendemonstrasikan operasi set pada huruf unik dari dua kata
...
>>> a = set('abracadabra') >>> b =
set('alacazam')
>>> a # huruf unik dalam a
{'a', 'r', 'b', 'c', 'd'} >>> a - b
# huruf di a tetapi tidak di b
{'r', 'd', 'b'} >>> a | b {'a',
'c', 'r', 'd', 'b', 'm', 'z', 'l'} # huruf dalam a atau b atau keduanya
>>> a & b # huruf a dan b
{'a', 'c'}
>>> a ^
b # huruf dalam a atau b tetapi tidak keduanya
{'r', 'd', 'b', 'm', 'z', 'l'}
Mirip dengan pemahaman daftar, pemahaman set juga didukung:
>>> a = {x untuk x di 'abracadabra' jika x tidak di 'abc'}

>>> a
{'r', 'd'}
5.5 Kamus
Tipe data berguna lainnya yang dibangun ke dalam Python adalah kamus (lihat pemetaan jenis). Kamus terkadang ditemukan dalam
bahasa lain sebagai "memori asosiatif" atau "array asosiatif". Tidak seperti urutan, yang diindeks oleh rentang angka, kamus diindeks
oleh kunci, yang dapat berupa tipe apa pun yang tidak dapat diubah; string dan angka selalu bisa menjadi kunci. Tupel dapat digunakan
sebagai kunci jika hanya berisi string, angka, atau tupel; jika tuple berisi objek yang dapat diubah baik secara langsung maupun tidak
langsung, itu tidak dapat digunakan sebagai kunci. Anda tidak dapat menggunakan daftar sebagai kunci, karena daftar dapat dimodifikasi
di tempat menggunakan penetapan indeks, penetapan irisan, atau metode seperti append() dan extend().
Yang terbaik adalah menganggap kamus sebagai sekumpulan kunci: pasangan nilai, dengan persyaratan bahwa kuncinya unik (dalam
satu kamus). Sepasang kurung kurawal membuat kamus kosong: {}. Menempatkan daftar pasangan kunci:nilai yang dipisahkan koma di
dalam kurung kurawal akan menambahkan pasangan kunci:nilai awal ke kamus; ini juga cara kamus ditulis pada output.
Operasi utama pada kamus adalah menyimpan nilai dengan beberapa kunci dan mengekstraksi nilai yang diberikan kunci tersebut. Dimungkinkan juga
untuk menghapus key:value pair dengan del. Jika Anda menyimpan menggunakan kunci yang sudah digunakan, nilai lama yang terkait dengan kunci
tersebut akan dilupakan. Merupakan kesalahan untuk mengekstrak nilai menggunakan kunci yang tidak ada.
Melakukan daftar(d) pada kamus mengembalikan daftar semua kunci yang digunakan dalam kamus, dalam urutan penyisipan (jika Anda
ingin diurutkan, gunakan saja diurutkan(d) sebagai gantinya). Untuk memeriksa apakah satu kunci ada di kamus, gunakan kata kunci in.
Berikut adalah contoh kecil menggunakan kamus:
5.4. Set 39
>>> telp = {'jack': 4098, 'sape': 4139} >>> telp['guido'] = 4127

>>> telp
{'jack': 4098, 'sape': 4139, 'guido': 4127} >>> tel['jack'] 4098
>>> del tel['sape'] >>> tel['irv']

= 4127
>>> telp
{'jack': 4098, 'guido': 4127, 'irv': 4127} >>> daftar(telp)
['jack', 'guido', 'irv'] >>> diurutkan(telp)

['guido', 'irv', 'jack'] >>> 'guido' di tel
BENAR
>>> 'jack' tidak ada di telp

PALSU
Konstruktor dict() membangun kamus langsung dari urutan pasangan kunci-nilai:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'guido': 4127, 'jack': 4098}
Selain itu, pemahaman dict dapat digunakan untuk membuat kamus dari ekspresi kunci dan nilai arbitrer:
>>> {x: x**2 untuk x dalam (2, 4, 6)}

{2: 4, 4: 16, 6: 36}
Saat kunci berupa string sederhana, terkadang lebih mudah untuk menentukan pasangan menggunakan argumen kata kunci:
>>> dict(sape=4139, guido=4127, jack=4098) {'sape': 4139, 'guido':

4127, 'jack': 4098}
5.6 Teknik Perulangan
Saat mengulang melalui kamus, kunci dan nilai yang sesuai dapat diambil pada saat yang sama menggunakan
metode items() .
>>> ksatria = {'gallahad': 'yang murni', 'robin': 'yang berani'} >>> untuk k, v di knights.items():
print(k, v)
...
...
galahad robin murni yang
pemberani
Saat mengulang urutan, indeks posisi dan nilai terkait dapat diambil pada saat yang sama menggunakan fungsi
enumerate() .
>>> untuk i, v di enumerate(['tic', 'tac', 'toe']):

... cetak (i, v)
...
0 tik
1 tak
2 jari kaki
Untuk mengulangi dua urutan atau lebih pada saat yang sama, entri dapat dipasangkan dengan fungsi zip().

>>> pertanyaan = ['nama', 'pencarian', 'warna favorit'] >>> jawaban = ['lancelot',

'holy grail', 'biru'] >>> untuk q, a di zip(pertanyaan , jawaban):
... print('Apa {0} Anda ? Ini adalah {1}.'.format(q, a))

...
Siapa namamu? Itu adalah lancelot.
Apa pencarianmu? Itu adalah cawan suci.
Apa warna kesukaanmu? Itu biru.
Untuk mengulangi urutan secara terbalik, pertama tentukan urutan dalam arah maju dan kemudian panggil fungsi reversed() .
>>> for i in reversed(range(1, 10, 2)): print(i)

...
...
9
7
5
3
1
Untuk mengulangi urutan dalam urutan terurut, gunakan fungsi sortir() yang mengembalikan daftar terurut baru sambil membiarkan
sumbernya tidak diubah.
>>> keranjang = ['apel', 'jeruk', 'apel', 'pir', 'jeruk', 'pisang'] >>> untuk i di sortir(keranjang): print(i)
...
...
pisang
apel
apel
jeruk
jeruk
pir
Menggunakan set() pada urutan menghilangkan elemen duplikat. Penggunaan sortir() dalam kombinasi dengan set() di atas
urutan adalah cara idiomatis untuk mengulang elemen unik dari urutan dalam urutan terurut.
>>> keranjang = ['apel', 'jeruk', 'apel', 'pir', 'jeruk', 'pisang'] >>> untuk f di sortir(set(keranjang)): print(f)
...
...
pisang
apel
jeruk
pir
Terkadang tergoda untuk mengubah daftar saat Anda mengulanginya; namun, seringkali lebih mudah dan lebih aman untuk
membuat daftar baru.
>>> impor matematika

>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8] >>> filtered_data = [] >>> untuk nilai
dalam raw_data:
... jika bukan matematika.isnan(nilai):

... filtered_data.append(nilai)
...
>>> data_terfilter [56.2,
51.7, 55.3, 52.5, 47.8]
5.6. Teknik Looping 41

5.7 Lebih Lanjut tentang Ketentuan
Kondisi yang digunakan dalam pernyataan while dan if dapat berisi operator apa saja, bukan hanya perbandingan.
Operator pembanding in dan not in adalah uji keanggotaan yang menentukan apakah suatu nilai ada di dalam (atau tidak di dalam) wadah.
Operator adalah dan tidak membandingkan apakah dua objek benar-benar objek yang sama. Semua operator pembanding memiliki
prioritas yang sama, yang lebih rendah dari semua operator numerik.
Perbandingan dapat dirantai. Misalnya, a < b == c menguji apakah a kurang dari b dan terlebih lagi b sama dengan c.
Perbandingan dapat digabungkan menggunakan operator Boolean dan dan atau, dan hasil perbandingan (atau ekspresi Boolean lainnya)
dapat ditiadakan dengan not. Ini memiliki prioritas lebih rendah daripada operator pembanding; di antara mereka, tidak memiliki prioritas
tertinggi dan atau terendah, sehingga A dan bukan B atau C setara dengan (A dan (bukan B)) atau C. Seperti biasa, tanda kurung dapat
digunakan untuk menyatakan komposisi yang diinginkan.
Operator Boolean dan dan atau disebut operator hubung singkat : argumen mereka dievaluasi dari kiri ke kanan, dan evaluasi berhenti
segera setelah hasilnya ditentukan. Misalnya, jika A dan C benar tetapi B salah, A dan B dan C tidak mengevaluasi ekspresi C. Ketika
digunakan sebagai nilai umum dan bukan sebagai Boolean, nilai kembalian dari operator hubung singkat adalah yang terakhir argumen
yang dievaluasi.
Dimungkinkan untuk menetapkan hasil perbandingan atau ekspresi Boolean lainnya ke variabel. Sebagai contoh,
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance' >>> non_null = string1 atau string2 atau
string3 >>> non_null
'Trondheim'
Perhatikan bahwa dalam Python, tidak seperti C, penugasan di dalam ekspresi harus dilakukan secara eksplisit dengan operator walrus :=.
Ini menghindari kelas umum dari masalah yang dihadapi dalam program C: mengetikkan = dalam ekspresi ketika == dimaksudkan.
5.8 Membandingkan Urutan dan Jenis Lainnya
Objek urutan biasanya dapat dibandingkan dengan objek lain dengan tipe urutan yang sama. Perbandingannya menggunakan urutan
leksikografis : pertama dua item pertama dibandingkan, dan jika berbeda, ini menentukan hasil perbandingan; jika sama, dua item
berikutnya dibandingkan, dan seterusnya, sampai salah satu urutannya habis.
Jika dua item yang akan dibandingkan itu sendiri adalah urutan dari jenis yang sama, perbandingan leksikografis dilakukan secara rekursif.
Jika semua item dari dua urutan sebanding, urutannya dianggap sama. Jika satu urutan adalah sub-urutan awal dari yang lain, urutan yang
lebih pendek adalah yang lebih kecil (lebih kecil). Pengurutan leksikografis untuk string menggunakan nomor poin kode Unicode untuk
mengurutkan karakter individual. Beberapa contoh perbandingan antar barisan yang sejenis:
(1, 2, 3) < (1, 2, 4)

[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python' (1, 2, 3, 4) (1, 2) (1,
2, 3) (1, 2, ('aa', 'ab') ) < (1, 2, 4) < (1,
2, -1) == (1.0, 2.0,
3.0) < (1, 2, ('abc', 'a'), 4)
Perhatikan bahwa membandingkan objek dari tipe yang berbeda dengan < atau > diperbolehkan asalkan objek tersebut memiliki metode
perbandingan yang sesuai. Misalnya, tipe numerik campuran dibandingkan berdasarkan nilai numeriknya, jadi 0 sama dengan 0,0, dll. Jika
tidak, alih-alih memberikan pengurutan arbitrer, penafsir akan memunculkan pengecualian TypeError.

BAB
ENAM
MODUL
Jika Anda keluar dari juru bahasa Python dan memasukkannya lagi, definisi yang Anda buat (fungsi dan variabel) akan hilang. Oleh
karena itu, jika Anda ingin menulis program yang agak panjang, lebih baik Anda menggunakan editor teks untuk menyiapkan input
untuk juru bahasa dan menjalankannya dengan file tersebut sebagai input. Ini dikenal sebagai membuat skrip. Saat program Anda
semakin panjang, Anda mungkin ingin membaginya menjadi beberapa file untuk pemeliharaan yang lebih mudah. Anda mungkin
juga ingin menggunakan fungsi praktis yang telah Anda tulis di beberapa program tanpa menyalin definisinya ke setiap program.
Untuk mendukung ini, Python memiliki cara untuk meletakkan definisi dalam file dan menggunakannya dalam skrip atau
dalam contoh interaktif dari juru bahasa. File seperti itu disebut modul; definisi dari modul dapat diimpor ke modul lain atau
ke modul utama (kumpulan variabel yang dapat Anda akses dalam skrip yang dijalankan di tingkat atas dan dalam mode
kalkulator).
Modul adalah file yang berisi definisi dan pernyataan Python. Nama file adalah nama modul dengan akhiran .py
ditambahkan. Di dalam modul, nama modul (sebagai string) tersedia sebagai nilai variabel global __name__.
Misalnya, gunakan editor teks favorit Anda untuk membuat file bernama fibo.py di direktori saat ini dengan konten
berikut:
# Modul angka Fibonacci
def fib(n): # tulis deret Fibonacci hingga n a, b = 0, 1 sedangkan

a < n:
cetak(a, akhir=' ') a, b = b,

a+b
mencetak()
def fib2(n): # mengembalikan deret Fibonacci hingga n result = [] a, b = 0, 1 while a

< n:
result.append(a) a, b = b,
a+b
hasil pengembalian
Sekarang masukkan juru bahasa Python dan impor modul ini dengan perintah berikut:
>>> impor fibo
Ini tidak menambahkan nama fungsi yang didefinisikan di fibo langsung ke namespace saat ini (lihat Python Scopes dan
Namespaces untuk detail lebih lanjut); itu hanya menambahkan nama modul fibo di sana. Menggunakan nama modul Anda
dapat mengakses fungsi:
>>> 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.__nama__ 'fibo'
Jika Anda ingin sering menggunakan suatu fungsi, Anda dapat menetapkannya ke nama lokal:
43
>>> 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 saat pertama kali nama modul ditemukan dalam pernyataan import.1 (Mereka juga dijalankan jika file
dijalankan sebagai skrip.)
Setiap modul memiliki ruang nama pribadinya sendiri, yang digunakan sebagai ruang nama global oleh semua fungsi yang ditentukan
dalam modul. Dengan demikian, pembuat modul dapat menggunakan variabel global di dalam modul tanpa khawatir tentang bentrok
yang tidak disengaja dengan variabel global pengguna. Di sisi lain, jika Anda tahu apa yang Anda lakukan, Anda dapat menyentuh
variabel global modul dengan notasi yang sama yang digunakan untuk merujuk fungsinya, modname.itemname.
Modul dapat mengimpor modul lain. Merupakan kebiasaan tetapi tidak diharuskan untuk menempatkan semua pernyataan impor di
awal modul (atau skrip, dalam hal ini). Nama modul yang diimpor, jika ditempatkan di tingkat atas modul (di luar fungsi atau kelas apa
pun), ditambahkan ke ruang nama global modul.
Ada varian dari pernyataan impor yang mengimpor nama dari modul langsung ke ruang nama modul pengimpor. Sebagai contoh:
>>> dari fibo import fib, fib2 >>> fib(500) 0 1 1 2

3 5 8 13 21 34 55 89 144 233 377
Ini tidak memperkenalkan nama modul dari mana impor diambil di namespace lokal (jadi dalam contoh, fibo tidak ditentukan).
Bahkan ada varian untuk mengimpor semua nama yang ditentukan modul:
>>> dari impor fibo * >>> 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 (_). Dalam banyak kasus, pemrogram Python tidak menggunakan fasilitas
ini karena fasilitas ini memperkenalkan serangkaian nama yang tidak diketahui ke dalam juru bahasa, mungkin menyembunyikan beberapa hal
yang telah Anda tetapkan.
Perhatikan bahwa secara umum praktik mengimpor * dari modul atau paket tidak disukai, karena sering menyebabkan kode sulit
dibaca. Namun, tidak apa-apa menggunakannya untuk menghemat pengetikan dalam sesi interaktif.
Jika nama modul diikuti dengan as, maka nama yang mengikuti as terikat langsung ke modul yang diimpor.
>>> impor fibo sebagai 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 seperti impor fibo, dengan satu-satunya perbedaan adalah tersedia
sebagai fib.
Itu juga dapat digunakan saat menggunakan dari dengan efek serupa:
>>> dari fibo impor fib sebagai fibonacci >>> fibonacci(500)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1 Sebenarnya definisi fungsi juga merupakan 'pernyataan' yang 'dieksekusi'; eksekusi definisi fungsi tingkat modul menambahkan nama fungsi
ke namespace global modul.
44 Bab 6. Modul
Catatan: Untuk alasan efisiensi, setiap modul hanya diimpor satu kali per sesi juru bahasa. Oleh karena itu, jika Anda mengubah
modul, Anda harus me-restart interpreter – atau, jika hanya satu modul yang ingin Anda uji secara interaktif, gunakan importlib.reload(),
misalnya import importlib; importlib.reload(namamodul).
6.1.1 Menjalankan modul sebagai skrip
Saat Anda menjalankan modul Python dengan
python fibo.py <argumen>
kode dalam modul akan dieksekusi, sama seperti jika Anda mengimpornya, tetapi dengan __name__ disetel ke "__main__".
Itu artinya dengan menambahkan kode ini di akhir modul Anda:
jika __nama__ == "__main__": import

sys fib(int(sys.argv[1]))
Anda dapat menjadikan file tersebut dapat digunakan sebagai skrip dan juga sebagai modul yang dapat diimpor, karena kode yang mem-parsing
baris perintah hanya berjalan jika modul dijalankan sebagai file "utama":
$ python fibo.py 50 0 1 1 2 3
5 8 13 21 34
Jika modul diimpor, kode tidak dijalankan:
>>> impor fibo >>>
Ini sering digunakan baik untuk menyediakan antarmuka pengguna yang mudah digunakan ke modul, atau untuk tujuan pengujian (menjalankan
modul saat skrip menjalankan rangkaian pengujian).
6.1.2 Jalur Pencarian Modul
Saat modul bernama spam diimpor, interpreter pertama-tama akan mencari modul bawaan dengan nama tersebut. Nama modul ini
tercantum dalam sys.builtin_module_names. Jika tidak ditemukan, ia akan mencari file bernama spam.py di daftar direktori yang
diberikan oleh variabel sys.path. sys.path diinisialisasi dari lokasi berikut:
• Direktori yang berisi skrip input (atau direktori saat ini ketika tidak ada file yang ditentukan).
• PYTHONPATH (daftar nama direktori, dengan sintaks yang sama dengan variabel shell PATH).
• Default yang bergantung pada penginstalan (berdasarkan konvensi termasuk direktori paket-situs, ditangani oleh
modul situs).
Detail lebih lanjut ada di sys-path-init.
Catatan: Pada sistem file yang mendukung symlink, direktori yang berisi skrip masukan dihitung setelah symlink diikuti. Dengan kata
lain direktori yang berisi symlink tidak ditambahkan ke jalur pencarian modul.
Setelah inisialisasi, program Python dapat memodifikasi sys.path. Direktori yang berisi skrip yang sedang dijalankan ditempatkan di
awal jalur pencarian, di depan jalur pustaka standar. Ini berarti skrip di direktori itu akan dimuat alih-alih modul dengan nama yang
sama di direktori perpustakaan. Ini adalah kesalahan kecuali penggantian dimaksudkan. Lihat bagian Modul Standar untuk informasi
lebih lanjut.
6.1. Lebih lanjut tentang Modul 45

6.1.3 File Python yang “dikompilasi”.
Untuk mempercepat pemuatan modul, Python meng-cache versi terkompilasi dari setiap modul di direktori __pycache__ dengan
nama module.version.pyc, di mana versi menyandikan format file yang dikompilasi; umumnya berisi nomor versi Python.
Misalnya, dalam rilis CPython 3.3, versi spam.py yang dikompilasi akan di-cache sebagai __pycache__/spam.cpython-33.pyc.
Konvensi penamaan ini memungkinkan modul yang dikompilasi dari rilis yang berbeda dan versi Python yang berbeda untuk
hidup berdampingan.
Python memeriksa tanggal modifikasi sumber terhadap versi yang dikompilasi untuk melihat apakah sudah kedaluwarsa dan perlu
dikompilasi ulang. Ini adalah proses yang sepenuhnya otomatis. Selain itu, modul yang dikompilasi tidak bergantung pada platform,
sehingga pustaka yang sama dapat digunakan bersama di antara sistem dengan arsitektur yang berbeda.
Python tidak memeriksa cache dalam dua keadaan. Pertama, ia selalu mengkompilasi ulang dan tidak menyimpan hasil modul
yang dimuat langsung dari baris perintah. Kedua, tidak memeriksa cache jika tidak ada modul sumber. Untuk mendukung
distribusi non-sumber (hanya dikompilasi), modul yang dikompilasi harus berada di direktori sumber, dan tidak boleh ada modul
sumber.
Beberapa tips untuk para ahli:
• Anda dapat menggunakan sakelar -O atau -OO pada perintah Python untuk mengurangi ukuran modul yang dikompilasi.
Sakelar -O menghapus pernyataan tegas, sakelar -OO menghapus pernyataan tegas dan string __doc__. Karena
beberapa program mungkin mengandalkan ketersediaan ini, Anda hanya boleh menggunakan opsi ini jika Anda tahu apa
yang Anda lakukan. Modul “Optimized” memiliki opt-tag dan biasanya berukuran lebih kecil. Rilis mendatang dapat
mengubah efek pengoptimalan.
• Program tidak berjalan lebih cepat saat dibaca dari file .pyc dibandingkan saat dibaca dari file .py; satu-satunya hal yang
lebih cepat tentang file .pyc adalah kecepatan pemuatannya.
• Modul compileall dapat membuat file .pyc untuk semua modul dalam direktori.
• Ada rincian lebih lanjut tentang proses ini, termasuk bagan alur keputusan, di PEP 3147.
6.2 Modul Standar

Python hadir dengan pustaka modul standar, dijelaskan dalam dokumen terpisah, Referensi Pustaka Python (“Referensi Pustaka”
selanjutnya). Beberapa modul dibangun ke dalam juru bahasa; ini memberikan akses ke operasi yang bukan bagian dari inti
bahasa tetapi tetap dibangun, baik untuk efisiensi atau untuk menyediakan akses ke primitif sistem operasi seperti panggilan
sistem. Kumpulan modul tersebut adalah opsi konfigurasi yang juga bergantung pada platform yang mendasarinya. Misalnya,
modul winreg hanya tersedia di sistem Windows. Satu modul tertentu patut mendapat perhatian: sys, yang dibangun di setiap
juru bahasa Python. Variabel sys.ps1 dan sys.ps2 mendefinisikan string yang digunakan sebagai prompt primer dan sekunder:
>>> impor sys >>>

sys.ps1
'>>>'
>>> sys.ps2 '...'
>>> sys.ps1 = 'C> '

C> print('Yuck!')
ih!
C>
Kedua variabel ini hanya ditentukan jika penafsir berada dalam mode interaktif.
Variabel sys.path adalah daftar string yang menentukan jalur pencarian modul oleh juru bahasa. Ini diinisialisasi ke jalur default
yang diambil dari variabel lingkungan PYTHONPATH, atau dari default bawaan jika PYTHONPATH tidak disetel. Anda dapat
memodifikasinya menggunakan operasi daftar standar:
>>> impor sys >>>

sys.path.append('/ufs/guido/lib/python')
46 Bab 6. Modul
6.3 Fungsi dir()
Fungsi built-in dir() digunakan untuk mengetahui nama mana yang didefinisikan oleh modul. Ini mengembalikan daftar string yang diurutkan:
>>> impor fibo, sys >>> dir(fibo)

['__name__', 'fib', 'fib2'] >>>
dir(sys) ['__breakpointhook__',
'__displayhook__', '__doc__',
'__excepthook__' , '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__',
'__stdin__', '__stdout__', '__unraisablehook__', '_clear_type_cache', '_current_frames', '_debugmallocstats', ' _framework',
'_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook', 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
'breakpointhook' , 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode',
'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', ' bendera', 'float_info', 'float_repr_style', 'get_asyncgen_hooks',
'get_coroutine_origin_tracking_depth', 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencodeerrors',
'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount' , 'getsizeof', 'getswitchinterval', 'gettrace', 'hash_info',
'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value', 'maxsize', 'maxunicode',
'meta_path ', 'modul', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval',
'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info', 'warningoptions']
Tanpa argumen, dir() mencantumkan nama yang telah Anda tetapkan saat ini:
>>> a = [1, 2, 3, 4, 5] >>> impor fibo

>>> fib = fibo.fib
>>> dir()
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
Perhatikan bahwa ini mencantumkan semua jenis nama: variabel, modul, fungsi, dll.
dir() tidak mencantumkan nama fungsi dan variabel bawaan. Jika Anda menginginkan daftar itu, mereka ditentukan
dalam modul standar bawaan:
>>> impor bawaan >>>

dir(bawaan)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',
'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',
'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
'FileExistsError', 'FileNotFoundError', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',
'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',
'MemoryError', 'NameError', 'Tidak Ada', 'NotADirectoryError', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',
'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
'SystemExit', 'TabError', 'TimeoutError', 'Benar', 'TypeError',
'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', (berlanjut ke halaman berikutnya)
6.3. Fungsi dir() 47

'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__',

'__name__', '__package__', 'abs', 'all', 'any ', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod',
'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float',
'format', 'frozenset', 'getattr ', 'global', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
'len', 'lisensi', 'daftar', 'lokal', 'peta', 'maks', 'memoryview', 'min', 'berikutnya', 'objek', 'oct', 'buka', 'ord', 'pow ', 'print',
'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple',
'type', 'vars', 'zip']
6.4 Paket
Paket adalah cara menyusun ruang nama modul Python dengan menggunakan "nama modul bertitik". Misalnya, nama
modul AB menunjuk submodule bernama B dalam paket bernama A. Sama seperti penggunaan modul menyelamatkan
penulis modul yang berbeda dari keharusan khawatir tentang nama variabel global masing-masing, penggunaan nama
modul bertitik menghemat penulis paket multi-modul seperti NumPy atau Pillow karena harus mengkhawatirkan nama
modul masing-masing.
Misalkan Anda ingin merancang kumpulan modul ("paket") untuk penanganan file suara dan data suara yang
seragam. Ada banyak format file suara yang berbeda (biasanya dikenali dari ekstensinya, misalnya: .wav, .aiff, .au),
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, membuat efek stereo buatan), jadi selain itu
Anda akan menulis aliran modul tanpa henti untuk dilakukan. operasi ini. Berikut adalah kemungkinan struktur
untuk paket Anda (dinyatakan dalam sistem file hierarkis):
suara/ Paket tingkat atas

__init__.py Inisialisasi paket suara
format/ __init__.py Subpaket untuk konversi format file
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py auwrite.py
...
efek/ Subpaket untuk efek suara
__init__.py echo.py
surround.py
membalikkan.py
...
filter/ Sub-paket untuk filter
__init__.py equalizer.py
vocoder.py
karaoke.py
...
Saat mengimpor paket, Python mencari melalui direktori di sys.path untuk mencari sub direktori paket.
File __init__.py diperlukan untuk membuat Python memperlakukan direktori yang berisi file tersebut sebagai paket. Ini mencegah
direktori dengan nama umum, seperti string, secara tidak sengaja menyembunyikan modul valid yang muncul kemudian di jalur
pencarian modul. Dalam kasus paling sederhana, __init__.py bisa berupa file kosong, tetapi juga dapat menjalankan inisialisasi
48 Bab 6. Modul
kode untuk paket atau atur variabel __all__, dijelaskan nanti.
Pengguna paket dapat mengimpor modul individual dari paket, misalnya:
impor suara.efek.echo
Ini memuat submodule sound.efek.echo. Itu harus dirujuk dengan nama lengkapnya.
suara.efek.echo.echofilter(input, output, delay=0.7, atten=4)
Cara alternatif mengimpor submodule adalah:
dari suara.efek mengimpor gema
Ini juga memuat gema submodule, dan membuatnya tersedia tanpa awalan paketnya, sehingga dapat digunakan sebagai berikut:
echo.echofilter(input, output, delay=0.7, atten=4)
Variasi lainnya adalah mengimpor fungsi atau variabel yang diinginkan secara langsung:
dari sound.efek.echo impor echofilter
Sekali lagi, ini memuat gema submodule, tetapi ini membuat fungsinya echofilter() langsung tersedia:
echofilter(input, output, delay=0.7, atten=4)
Perhatikan bahwa saat menggunakan dari item impor paket, item tersebut dapat berupa submodul (atau subpaket) dari paket,
atau beberapa nama lain yang ditentukan dalam paket, seperti fungsi, kelas, atau variabel. Pernyataan impor pertama-tama
menguji apakah item tersebut didefinisikan dalam paket; jika tidak, dianggap sebagai modul dan mencoba memuatnya. Jika gagal
menemukannya, pengecualian ImportError dimunculkan.
Sebaliknya, saat menggunakan sintaks seperti import item.subitem.subsubitem, setiap item kecuali yang terakhir harus berupa
paket; item terakhir bisa berupa modul atau paket tetapi tidak bisa berupa kelas atau fungsi atau variabel yang didefinisikan di
item sebelumnya.
6.4.1 Mengimpor * Dari Paket

Sekarang apa yang terjadi ketika pengguna menulis dari sound. effects import *? 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 sub-modul mungkin memiliki efek samping yang tidak diinginkan yang seharusnya hanya
terjadi ketika sub-modul diimpor secara eksplisit.
Satu-satunya solusi adalah pembuat paket menyediakan indeks eksplisit dari paket tersebut. Pernyataan impor menggunakan
konvensi berikut: jika kode __init__.py paket mendefinisikan daftar bernama __all__, itu dianggap sebagai daftar nama modul
yang harus diimpor ketika from package import * 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
kegunaan untuk mengimpor * dari paket mereka. Misalnya, file sound/efek/__init__.py dapat berisi kode berikut:
__all__ = ["echo", "surround", "reverse"]
Ini berarti from sound. effects import * akan mengimpor tiga submodul bernama dari paket sound. effects .
Jika __all__ tidak ditentukan, pernyataan from sound.efek impor * tidak mengimpor semua submodul dari paket sound.efek ke
namespace saat ini; itu hanya memastikan bahwa paket sound.efek telah diimpor (mungkin menjalankan kode inisialisasi apa pun
di __init__.py) dan kemudian mengimpor nama apa pun yang ditentukan dalam paket. Ini termasuk nama apa pun yang ditentukan
(dan submodul dimuat secara eksplisit) oleh __init__.py.
Ini juga mencakup submodul paket apa pun yang dimuat secara eksplisit oleh pernyataan impor sebelumnya. Pertimbangkan
kode ini:
6.4. Paket 49
impor suara.efek.gema impor

suara.efek.surround dari suara.efek impor
*
Dalam contoh ini, modul echo dan surround diimpor dalam namespace saat ini karena keduanya ditentukan dalam
paket sound. effects ketika pernyataan from...import dijalankan. (Ini juga berfungsi saat __all__ didefinisikan.)
Meskipun modul tertentu dirancang hanya untuk mengekspor nama yang mengikuti pola tertentu saat Anda menggunakan import *, ini
masih dianggap sebagai praktik buruk dalam kode produksi.
Ingat, tidak ada salahnya menggunakan from package import specific_submodule! Faktanya, ini adalah notasi yang
disarankan kecuali modul pengimpor perlu menggunakan submodul dengan nama yang sama dari paket yang
berbeda.
6.4.2 Referensi Intra-paket
Ketika paket disusun menjadi sub-paket (seperti paket suara dalam contoh), Anda dapat menggunakan impor
absolut untuk merujuk ke submodul dari paket saudara. Misalnya, jika modul sound.filters.vocoder perlu menggunakan
modul echo dalam paket sound. effects, modul tersebut dapat menggunakan from sound. effects import echo.
Anda juga dapat menulis impor relatif, dengan bentuk dari nama impor modul dari pernyataan impor. Impor ini
menggunakan titik awal untuk menunjukkan paket saat ini dan induk yang terlibat dalam impor relatif. Dari modul
surround misalnya, Anda dapat menggunakan:
dari . impor gema dari ..

impor format dari ..filter impor
equalizer
Perhatikan bahwa impor relatif didasarkan pada nama modul saat ini. Karena nama modul utama selalu "__main__",
modul yang dimaksudkan untuk digunakan sebagai modul utama aplikasi Python harus selalu menggunakan impor
absolut.
6.4.3 Paket di Banyak Direktori
Paket mendukung satu lagi atribut khusus, __path__. Ini diinisialisasi menjadi daftar yang berisi nama direktori yang
menyimpan __init__.py paket sebelum kode dalam file tersebut dijalankan. Variabel ini dapat dimodifikasi; hal itu
memengaruhi pencarian modul dan subpaket di masa mendatang yang terdapat dalam paket.
Meskipun fitur ini tidak sering dibutuhkan, fitur ini dapat digunakan untuk memperluas kumpulan modul yang ditemukan dalam sebuah paket.
50 Bab 6. Modul
BAB
TUJUH
MASUKAN DAN KELUARAN
Ada beberapa cara untuk mempresentasikan output dari suatu program; data dapat dicetak dalam bentuk yang dapat dibaca manusia, atau ditulis
ke file untuk digunakan di masa mendatang. Bab ini akan membahas beberapa kemungkinan.
7.1 Pemformatan Keluaran yang Lebih Menarik
Sejauh ini kita menemukan dua cara penulisan nilai: pernyataan ekspresi dan fungsi print(). (Cara ketiga menggunakan metode
write() dari objek file; file output standar dapat dirujuk sebagai sys.stdout. Lihat Referensi Perpustakaan untuk informasi lebih lanjut
tentang ini.)
Seringkali Anda menginginkan kontrol lebih besar atas pemformatan keluaran Anda daripada sekadar mencetak nilai yang dipisahkan oleh ruang.
Ada beberapa cara untuk memformat keluaran.
• Untuk menggunakan literal string yang diformat, awali string dengan f atau F sebelum tanda kutip pembuka atau tanda kutip
tiga. Di dalam string ini, Anda bisa menulis ekspresi Python antara karakter { dan } yang bisa merujuk ke variabel atau nilai
literal.
>>> tahun = 2016 >>>

acara = 'Referendum'
>>> f'Hasil dari {tahun} {event}'
'Hasil Referendum 2016'
• Metode string str.format() membutuhkan lebih banyak upaya manual. Anda masih akan menggunakan { dan } untuk menandai
di mana variabel akan diganti dan dapat memberikan arahan pemformatan yang mendetail, tetapi Anda juga harus
memberikan informasi yang akan diformat.
>>> yes_votes = 42_572_654 >>> no_votes =

43_132_495 >>> persentase = yes_votes /
(yes_votes + no_votes)
>>> '{:-9} YA suara {:2.2%}'.format(yes_votes, persentase)
' 42572654 Suara YA 49,67%'
• Akhirnya, Anda dapat melakukan sendiri semua penanganan string dengan menggunakan pemotongan string dan operasi penggabungan
untuk membuat tata letak apa pun yang dapat Anda bayangkan. Tipe string memiliki beberapa metode yang melakukan operasi berguna
untuk mengisi string ke lebar kolom tertentu.
Saat Anda tidak membutuhkan output mewah tetapi hanya ingin tampilan cepat dari beberapa variabel untuk tujuan debugging, Anda
dapat mengonversi nilai apa pun menjadi string dengan fungsi repr() atau str().
Fungsi str() dimaksudkan untuk mengembalikan representasi nilai yang dapat dibaca oleh manusia, sedangkan repr() dimaksudkan
untuk menghasilkan representasi yang dapat dibaca oleh penafsir (atau akan memaksa SyntaxError jika tidak ada sintaks yang
setara). Untuk objek yang tidak memiliki representasi khusus untuk konsumsi manusia, str() akan mengembalikan nilai yang sama
dengan repr(). Banyak nilai, seperti angka atau struktur seperti daftar dan kamus, memiliki representasi yang sama menggunakan
salah satu fungsi. String, khususnya, memiliki dua representasi berbeda.
Beberapa contoh:
51
>>> s = 'Halo, dunia.' >>> str
'Halo Dunia.' >>>

perwakilan
"'Halo, dunia.'" >>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3,25
>>> y = 200 * 200 >>> s =
'Nilai x adalah ' + repr(x) + ', dan y adalah ' + repr(y) + '...'
>>> cetak
Nilai x adalah 32,5, dan y adalah 40000...
>>> # Repr() dari sebuah string menambahkan tanda kutip string dan garis miring terbalik: ... hello = 'hello, world\n'
>>> hellos = repr(hello) >>> print( hello, world\ n'
>>> # Argumen untuk repr() dapat berupa objek Python: ... repr((x, y, ('spam', 'eggs'))) "(32.5,
40000, ('spam', 'eggs '))"
Modul string berisi kelas Template yang menawarkan cara lain untuk mengganti nilai menjadi string, menggunakan placeholder
seperti $x dan menggantinya dengan nilai dari kamus, tetapi menawarkan lebih sedikit kontrol pemformatan.
7.1.1 Literal String Terformat
Literal string terformat (disingkat juga disebut f-string) memungkinkan Anda menyertakan nilai ekspresi Python di dalam string
dengan mengawali string dengan f atau F dan menulis ekspresi sebagai {ekspresi}.
Penentu format opsional dapat mengikuti ekspresi. Ini memungkinkan kontrol yang lebih besar atas bagaimana nilai diformat.
Contoh berikut membulatkan pi ke tiga tempat setelah desimal:

>>> print(f'Nilai pi kira-kira {math.pi:.3f}.')
Nilai pi kira-kira 3,142.
Meneruskan bilangan bulat setelah ':' akan menyebabkan bidang tersebut menjadi jumlah minimum karakter. Ini berguna
untuk membuat kolom berbaris.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678} >>> untuk nama, telepon di table.items():
... print(f'{nama:10} ==> {telepon:10d}')

...
Sjoerd ==> 4127
Mendongkrak ==> 4098
Dcab ==> 7678
Pengubah lain dapat digunakan untuk mengonversi nilai sebelum diformat. '!a' menerapkan ascii(), '!s' menerapkan str(), dan '!
r' menerapkan repr():
>>> hewan = 'belut'

>>> print(f'Hovercraft saya penuh dengan {binatang}.')
Hovercraft saya penuh dengan belut. >>>
print(f'Hovercraft saya penuh dengan {animals!r}.')
Hovercraft saya penuh dengan belut'.
Itu = specifier dapat digunakan untuk memperluas ekspresi ke teks ekspresi, tanda sama dengan, kemudian representasi dari
ekspresi yang dievaluasi:
52 Bab 7. Masukan dan Keluaran

>>> bug = 'kecoak' >>> hitung =

13
>>> area = 'ruang tamu' >>>
print(f'Debugging {bugs=} {count=} {area=}')
Men-debug bugs='kecoak' menghitung=13 area='ruang tamu'
Lihat ekspresi mendokumentasikan diri untuk informasi lebih lanjut tentang = specifier. Untuk referensi tentang spesifikasi format ini, lihat
panduan referensi untuk formatspec.
7.1.2 Metode String format()

Penggunaan dasar metode str.format() terlihat seperti ini:
>>> print('Kami adalah {} yang mengatakan "{}!"'.format('ksatria', 'Ni'))

Kami adalah ksatria yang mengatakan "Ni!"
Tanda kurung dan karakter di dalamnya (disebut bidang format) diganti dengan objek yang diteruskan ke str. format() metode. Angka dalam
tanda kurung dapat digunakan untuk merujuk ke posisi objek yang diteruskan ke metode str.format() .
>>> print('{0} dan {1}'.format('spam', 'eggs')) spam dan telur >>> print('{1} dan
{0}'.format('spam', 'telur')) telur dan spam
Jika argumen kata kunci digunakan dalam metode str.format() , nilainya dirujuk dengan menggunakan nama argumen.
>>> print(' {Makanan} ini adalah {kata sifat}.'.format(

... makanan='spam', kata sifat='benar-benar mengerikan'))
Spam ini benar-benar mengerikan.
Argumen posisi dan kata kunci dapat digabungkan secara sewenang-wenang:
>>> print(' Kisah {0}, {1}, dan {other}.'.format('Bill', 'Manfred',

... lainnya='Georg'))
Kisah Bill, Manfred, dan Georg.
Jika Anda memiliki format string yang sangat panjang yang tidak ingin Anda pisahkan, alangkah baiknya jika Anda dapat mereferensikan
variabel untuk diformat dengan nama, bukan dengan posisi. Ini dapat dilakukan hanya dengan meneruskan dict dan menggunakan tanda
kurung siku '[]' untuk mengakses kunci.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678} >>> print('Jack: {0[Jack]:d}; Sjoerd:
{0[Sjoerd]:d }; '
... 'Dcab: {0[Dcab]:d}'.format(tabel))
Mendongkrak: 4098; Sjoerd: 4127; Dcab: 8637678
Ini juga bisa dilakukan dengan mengirimkan kamus tabel sebagai argumen kata kunci dengan notasi **.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678} >>> print('Jack: {Jack:d}; Sjoerd:
{Sjoerd:d}; Dcab: {Dcab :d}'.format(**tabel))
Mendongkrak: 4098; Sjoerd: 4127; Dcab: 8637678
Ini sangat berguna dalam kombinasi dengan fungsi bawaan vars(), yang mengembalikan kamus yang berisi semua variabel lokal.
Sebagai contoh, baris-baris berikut menghasilkan kumpulan kolom yang tertata rapi yang menghasilkan bilangan bulat dan kuadrat serta kubusnya:
7.1. Pemformatan Keluaran yang Lebih Menarik 53

>>> untuk x dalam rentang(1, 11):

... cetak('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
Untuk ikhtisar lengkap pemformatan string dengan str.format(), lihat formatstrings.
7.1.3 Pemformatan String Manual
Berikut tabel kotak dan kubus yang sama, diformat secara manual:
>>> untuk x dalam rentang(1, 11):

... cetak(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # Catat penggunaan 'end' pada baris sebelumnya
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
(Perhatikan bahwa satu spasi di antara setiap kolom ditambahkan dengan cara kerja print(): selalu menambahkan spasi di
antara argumennya.)
Metode str.rjust() dari objek string membenarkan string dalam bidang dengan lebar tertentu dengan melapisinya dengan spasi
di sebelah kiri. Ada metode serupa str.ljust() dan str.center(). Metode ini tidak menulis apa pun, mereka hanya mengembalikan
string baru. Jika string input terlalu panjang, mereka tidak memotongnya, tetapi mengembalikannya tanpa perubahan; ini akan
mengacaukan tata letak kolom Anda tetapi itu biasanya lebih baik daripada alternatifnya, yang akan berbohong tentang suatu nilai.
(Jika Anda benar-benar menginginkan pemotongan, Anda selalu dapat menambahkan operasi irisan, seperti pada x.ljust(n)[:n].)
Ada metode lain, str.zfill(), yang melapisi string numerik di sebelah kiri dengan nol. Ia mengerti tentang tanda plus dan minus:
>>> '12'.zfill(5) '00012'
>>> '-3.14'.zfill(7) '-003.14'
>>> '3.14159265359'.zfill(5) '3.14159265359'

7.1.4 Pemformatan string lama
Operator % (modulo) juga dapat digunakan untuk pemformatan string. Diberi nilai % 'string', contoh % dalam string diganti dengan nol atau
lebih elemen nilai. Operasi ini umumnya dikenal sebagai interpolasi string. Sebagai contoh:

>>> print(' Nilai pi kira-kira %5.3f.' % matematika.pi)
Nilai pi kira-kira 3,142.
Informasi lebih lanjut dapat ditemukan di bagian pemformatan string lama.
7.2 Membaca dan Menulis File

open() mengembalikan objek file, dan paling sering digunakan dengan dua argumen posisional dan satu argumen kata kunci: open(filename,
mode, encoding=None)
>>> f = open('workfile', 'w', encoding="utf-8")
Argumen pertama adalah string yang berisi nama file. Argumen kedua adalah string lain yang berisi beberapa karakter yang menjelaskan
cara penggunaan file. mode bisa 'r' saat file hanya akan dibaca, 'w' hanya untuk menulis (file yang ada dengan nama yang sama akan
dihapus), dan 'a' membuka file untuk ditambahkan; data apa pun yang ditulis ke file secara otomatis ditambahkan ke akhir. 'r+' membuka file
untuk membaca dan menulis. Argumen mode bersifat opsional; 'r' akan diasumsikan jika dihilangkan.
Biasanya, file dibuka dalam mode teks, artinya, Anda membaca dan menulis string dari dan ke file, yang dikodekan dalam pengkodean
tertentu. Jika penyandian tidak ditentukan, defaultnya bergantung pada platform (lihat open()). Karena UTF-8 adalah standar de-facto
modern, encoding="utf-8" disarankan kecuali Anda tahu bahwa Anda perlu menggunakan pengkodean yang berbeda. Menambahkan 'b' ke
mode membuka file dalam mode biner. Data mode biner dibaca dan ditulis sebagai objek byte. Anda tidak dapat menentukan penyandian
saat membuka file dalam mode biner.
Dalam mode teks, default saat membaca adalah mengonversi akhir baris khusus platform (\n di Unix, \r\n di Windows) menjadi \n saja. Saat
menulis dalam mode teks, defaultnya adalah mengonversi kemunculan \n kembali ke akhiran baris khusus platform. Modifikasi di belakang
layar untuk file data ini bagus untuk file teks, tetapi akan merusak data biner seperti yang ada di file JPEG atau EXE. Berhati-hatilah untuk
menggunakan mode biner saat membaca dan menulis file semacam itu.
Ini adalah praktik yang baik untuk menggunakan kata kunci with ketika berhadapan dengan objek file. Keuntungannya adalah file ditutup
dengan benar setelah rangkaiannya selesai, bahkan jika pengecualian dimunculkan di beberapa titik. Menggunakan with juga jauh lebih
pendek daripada menulis blok try-finally yang setara:
>>> dengan open('workfile', encoding="utf-8") sebagai f:

... baca_data = f.baca()
>>> # Kami dapat memeriksa apakah file telah ditutup secara otomatis. >>> f.closed
BENAR
Jika Anda tidak menggunakan kata kunci with, maka Anda harus memanggil f.close() untuk menutup file dan segera mengosongkan sumber
daya sistem yang digunakan olehnya.
Peringatan: Memanggil f.write() tanpa menggunakan kata kunci with atau memanggil f.close() dapat menyebabkan argumen f.write()
tidak sepenuhnya ditulis ke disk, bahkan jika program berhasil keluar.
Setelah objek file ditutup, baik dengan pernyataan with atau dengan memanggil f.close(), upaya untuk menggunakan objek file akan gagal
secara otomatis.
7.2. Membaca dan Menulis File 55

>>> f.close() >>>

f.baca()
File "<stdin>", baris 1, di <module> ValueError: Operasi I/O
pada file tertutup.
7.2.1 Metode Objek File

Contoh-contoh lainnya di bagian ini akan mengasumsikan bahwa sebuah objek file bernama f telah dibuat.
Untuk membaca konten file, panggil f.read(size), yang membaca sejumlah data dan mengembalikannya sebagai string (dalam mode
teks) atau objek byte (dalam mode biner). size adalah argumen numerik opsional. Ketika ukuran dihilangkan atau negatif, seluruh
konten file akan dibaca dan dikembalikan; itu masalah Anda jika file tersebut dua kali lebih besar dari memori mesin Anda. Jika tidak,
sebagian besar ukuran karakter (dalam mode teks) atau ukuran byte (dalam mode biner) dibaca dan dikembalikan. Jika akhir file
telah tercapai, f.read() akan mengembalikan string kosong ('').
>>> f.baca()
'Ini adalah seluruh file.\n'
>>> f.baca()
''
f.readline() membaca satu baris dari file; karakter baris baru (\n) dibiarkan di akhir string, dan hanya dihilangkan di baris terakhir file
jika file tidak diakhiri di baris baru. Ini membuat nilai pengembalian tidak ambigu; jika f.readline() mengembalikan string kosong, akhir
file telah tercapai, sedangkan baris kosong diwakili oleh '\n', string yang hanya berisi satu baris baru.
>>> f.readline()
'Ini adalah baris pertama file.\n'
>>> f.readline()
'Baris kedua file\n'
>>> f.readline()
''
Untuk membaca baris dari file, Anda dapat mengulang objek file. Ini hemat memori, cepat, dan mengarah ke kode sederhana:
>>> untuk baris di f:

... cetak(baris, akhir='')
...
Ini adalah baris pertama dari file.
Baris kedua dari file
Jika Anda ingin membaca semua baris file dalam daftar, Anda juga dapat menggunakan daftar(f) atau f.readlines().
f.write(string) menulis konten string ke file, mengembalikan jumlah karakter yang ditulis.
>>> f.write('Ini adalah ujian\n')

15
Jenis objek lain perlu dikonversi – baik menjadi string (dalam mode teks) atau objek byte (dalam mode biner) – sebelum menulisnya:
>>> nilai = ('jawabannya', 42) >>> s = str(nilai) #

ubah tupel menjadi string >>> f.tulis(s) 18
f.tell() mengembalikan bilangan bulat yang memberikan posisi objek file saat ini dalam file yang direpresentasikan sebagai jumlah
byte dari awal file saat dalam mode biner dan angka buram saat dalam mode teks.
Untuk mengubah posisi objek file, gunakan f.seek(offset, where). Posisi dihitung dari penambahan offset ke titik referensi; titik referensi
dipilih oleh argumen wherece . Di mana nilai 0 mengukur

dari awal file, 1 menggunakan posisi file saat ini, dan 2 menggunakan akhir file sebagai titik referensi. dari mana dapat dihilangkan
dan default ke 0, menggunakan awal file sebagai titik referensi.
>>> f = open('workfile', 'rb+') >>>

f.write(b'0123456789abcdef') 16
>>> f.seek(5) 5 # Pergi ke byte ke-6 dalam file
>>> f.baca(1)
b'5'
>>> f.seek(-3, 2) # Pergi ke byte ke-3 sebelum akhir
13
>>> f.baca(1)
tidur'
Dalam file teks (yang dibuka tanpa ab dalam string mode), hanya pencarian relatif ke awal file yang diperbolehkan (pengecualian
mencari hingga akhir file dengan seek(0, 2)) dan satu-satunya nilai offset yang valid adalah yang dikembalikan dari f.tell(), atau nol.
Nilai offset lainnya menghasilkan perilaku yang tidak terdefinisi.
Objek file memiliki beberapa metode tambahan, seperti isatty() dan truncate() yang lebih jarang digunakan; berkonsultasi dengan
Referensi Perpustakaan untuk panduan lengkap untuk objek file.
7.2.2 Menyimpan data terstruktur dengan json
String dapat dengan mudah ditulis dan dibaca dari file. Angka memerlukan sedikit usaha, karena metode read() hanya mengembalikan
string, yang harus diteruskan ke fungsi seperti int(), yang mengambil string seperti '123' dan mengembalikan nilai numeriknya 123.
Bila Anda ingin menyimpan tipe data yang lebih kompleks seperti daftar bersarang dan kamus, parsing dan serialisasi dengan tangan
menjadi rumit.
Daripada membuat pengguna terus-menerus menulis dan men-debug kode untuk menyimpan tipe data yang rumit ke file, Python
memungkinkan Anda untuk menggunakan format pertukaran data populer yang disebut JSON (JavaScript Object Notation). Modul
standar bernama json dapat mengambil hierarki data Python, dan mengonversinya menjadi representasi string; proses ini disebut serialisasi.
Merekonstruksi data dari representasi string disebut deserializing. Antara serialisasi dan deserialisasi, string yang mewakili objek
mungkin telah disimpan dalam file atau data, atau dikirim melalui koneksi jaringan ke beberapa mesin yang jauh.
Catatan: Format JSON biasanya digunakan oleh aplikasi modern untuk memungkinkan pertukaran data. Banyak pemrogram sudah
mengenalnya, yang menjadikannya pilihan yang baik untuk interoperabilitas.
Jika Anda memiliki objek x, Anda dapat melihat representasi string JSON dengan baris kode sederhana:
>>> impor json >>> x =

[1, 'sederhana', 'daftar'] >>> json.dumps(x) '[1,
"sederhana", "daftar"]'
Varian lain dari fungsi dumps(), disebut dump(), hanya membuat serialisasi objek ke file teks. Jadi jika f adalah objek file teks yang
dibuka untuk menulis, kita dapat melakukan ini:
json.dump(x, f)
Untuk mendekode ulang objek, jika f adalah file biner atau objek file teks yang telah dibuka untuk dibaca:
x = json.memuat(f)
Catatan: File JSON harus dikodekan dalam UTF-8. Gunakan encoding="utf-8" saat membuka file JSON sebagai file teks untuk
membaca dan menulis.
7.2. Membaca dan Menulis File 57

Teknik serialisasi sederhana ini dapat menangani daftar dan kamus, tetapi membuat serialisasi instance kelas arbitrer
di JSON membutuhkan sedikit usaha ekstra. Referensi untuk modul json berisi penjelasan tentang ini.
Lihat juga:
acar - modul acar
Berlawanan dengan JSON, pickle adalah protokol yang memungkinkan serialisasi objek Python kompleks yang sewenang-wenang. Dengan
demikian, ini khusus untuk Python dan tidak dapat digunakan untuk berkomunikasi dengan aplikasi yang ditulis dalam bahasa lain. Ini juga
tidak aman secara default: deserializing pickle data yang berasal dari sumber yang tidak tepercaya dapat mengeksekusi kode arbitrer, jika
data dibuat oleh penyerang yang terampil.

BAB
DELAPAN
KESALAHAN DAN PENGECUALIAN
Sampai saat ini pesan kesalahan belum banyak disebutkan, tetapi jika Anda telah mencoba contoh-contohnya, Anda mungkin telah
melihat beberapa. Ada (setidaknya) dua jenis kesalahan yang dapat dibedakan: kesalahan sintaksis dan pengecualian.
8.1 Kesalahan Sintaks
Kesalahan sintaksis, juga dikenal sebagai kesalahan parsing, mungkin merupakan jenis keluhan paling umum yang Anda dapatkan saat
masih mempelajari Python:
>>> while True print('Halo dunia')

File "<stdin>", baris 1
while True print('Halo dunia')
^
SyntaxError: sintaks tidak valid
Parser mengulangi baris yang menyinggung dan menampilkan 'panah' kecil yang menunjuk ke titik paling awal di baris tempat
kesalahan terdeteksi. Kesalahan disebabkan oleh (atau setidaknya terdeteksi pada) token yang mendahului tanda panah:
dalam contoh, kesalahan terdeteksi pada fungsi print(), karena tanda titik dua (':') tidak ada sebelumnya. Nama file dan nomor
baris dicetak sehingga Anda tahu ke mana harus mencari jika input berasal dari skrip.
8.2 Pengecualian
Bahkan jika sebuah pernyataan atau ekspresi benar secara sintaksis, itu dapat menyebabkan kesalahan ketika upaya dilakukan untuk
mengeksekusinya. Kesalahan yang terdeteksi selama eksekusi disebut pengecualian dan tidak fatal tanpa syarat: Anda akan segera belajar
cara menanganinya dalam program Python. Namun, sebagian besar pengecualian tidak ditangani oleh program, dan menghasilkan pesan
kesalahan seperti yang ditampilkan di sini:
>>> 10 * (1/0)
ZeroDivisionError: pembagian dengan nol >>> 4 + spam*3

NameError: nama 'spam' tidak ditentukan >>> '2' + 2

TypeError: hanya dapat menggabungkan str (bukan "int") ke str
Baris terakhir dari pesan kesalahan menunjukkan apa yang terjadi. Pengecualian datang dalam berbagai jenis, dan jenisnya dicetak
sebagai bagian dari pesan: jenis dalam contoh adalah ZeroDivisionError, NameError, dan TypeError. String yang dicetak sebagai tipe
pengecualian adalah nama dari pengecualian bawaan yang terjadi. Ini benar untuk semua pengecualian bawaan, tetapi tidak harus
benar untuk pengecualian yang ditentukan pengguna (walaupun ini adalah konvensi yang berguna). Nama pengecualian standar
adalah pengidentifikasi bawaan (bukan kata kunci yang dicadangkan).
59
Baris selanjutnya memberikan detail berdasarkan jenis pengecualian dan apa yang menyebabkannya.
Bagian sebelumnya dari pesan kesalahan menunjukkan konteks di mana pengecualian terjadi, dalam bentuk stack traceback. Secara
umum ini berisi baris sumber daftar traceback stack; namun, ini tidak akan menampilkan baris yang dibaca dari input standar.
bltin-exception mencantumkan pengecualian bawaan dan artinya.
8.3 Penanganan Pengecualian
Dimungkinkan untuk menulis program yang menangani pengecualian yang dipilih. Lihat contoh berikut, yang meminta input dari pengguna
hingga integer yang valid telah dimasukkan, tetapi memungkinkan pengguna untuk menginterupsi program (menggunakan Control-C atau
apa pun yang didukung oleh sistem operasi); perhatikan bahwa interupsi yang dibuat pengguna ditandai dengan menaikkan pengecualian
KeyboardInterrupt.
>>> sementara Benar:

... coba:
... x = int(input("Silakan masukkan angka: "))
... merusak
... kecuali ValueError: print("Ups!
... Itu bukan nomor yang valid. Coba lagi...")
...
Pernyataan try berfungsi sebagai berikut.
• Pertama, klausa try (pernyataan antara kata kunci try dan exception) dijalankan.
• Jika tidak ada pengecualian yang terjadi, klausa exception dilewati dan eksekusi pernyataan try selesai.
• Jika pengecualian terjadi selama eksekusi klausa try, klausa lainnya akan dilewati. Kemudian, jika tipenya cocok dengan
pengecualian yang dinamai setelah kata kunci kecuali, klausa kecuali dieksekusi, dan kemudian eksekusi dilanjutkan setelah blok
coba/kecuali.
• Jika pengecualian terjadi yang tidak cocok dengan pengecualian yang disebutkan dalam klausa kecuali, itu diteruskan ke pernyataan try luar;
jika tidak ada penangan yang ditemukan, itu adalah pengecualian yang tidak tertangani dan eksekusi berhenti dengan pesan seperti yang
ditunjukkan di atas.
Pernyataan try mungkin memiliki lebih dari satu kecuali klausa, untuk menentukan penangan untuk pengecualian yang berbeda. Paling
banyak satu penangan akan dieksekusi. Penangan hanya menangani pengecualian yang terjadi pada klausa try yang sesuai, bukan pada
handler lain dari pernyataan try yang sama. Klausa exception dapat menyebutkan beberapa pengecualian sebagai tupel dalam tanda
kurung, misalnya:
... kecuali (RuntimeError, TypeError, NameError):

... lulus
Kelas dalam klausa pengecualian kompatibel dengan pengecualian jika itu adalah kelas yang sama atau kelas dasarnya (tetapi bukan
sebaliknya — klausa pengecualian yang mencantumkan kelas turunan tidak kompatibel dengan kelas dasar). Misalnya, kode berikut akan
mencetak B, C, D dalam urutan tersebut:
kelas B (Pengecualian):
lulus
kelas C(B):
lulus
kelas D(C):
lulus
untuk cls di [B, C, D]:

coba:
naikkan cls()
60 Bab 8. Kesalahan dan Pengecualian

kecuali D:
print("D")
kecuali C: print("C")
kecuali B:
print("B")
Perhatikan bahwa jika klausa kecuali dibalik (dengan kecuali B terlebih dahulu), itu akan dicetak B, B, B — pencocokan pertama kecuali
klausa dipicu.
Ketika pengecualian terjadi, itu mungkin memiliki nilai terkait, juga dikenal sebagai argumen pengecualian. Kehadiran dan jenis argumen
bergantung pada jenis pengecualian.
Klausa kecuali dapat menentukan variabel setelah nama pengecualian. Variabel terikat pada instance pengecualian yang biasanya
memiliki atribut args yang menyimpan argumen. Untuk kenyamanan, tipe pengecualian bawaan mendefinisikan __str__() untuk mencetak
semua argumen tanpa mengakses .args secara eksplisit.
>>> coba:
... naikkan Pengecualian('spam', 'telur') ... kecuali
Pengecualian sebagai inst: print(type(inst)) # contoh
... pengecualian print(inst.args) # argumen
disimpan di .args print(inst ) #
... __str__ mengizinkan arg untuk dicetak
dapat ditimpa
secara dalam
langsung,
subkelas
# tetapi
... pengecualian # unpack args
...
... x, y = inst.args print('x
... =', x) print('y =', y)
...
...
<kelas 'Pengecualian'>
('spam', 'telur') ('spam', 'telur')
x = spam
y = telur
Output __str__() pengecualian dicetak sebagai bagian terakhir ('detail') dari pesan untuk pengecualian yang tidak tertangani.
BaseException adalah kelas dasar umum dari semua pengecualian. Salah satu subkelasnya, Pengecualian, adalah kelas dasar dari
semua pengecualian non-fatal. Pengecualian yang bukan merupakan subkelas Pengecualian biasanya tidak ditangani, karena digunakan
untuk menunjukkan bahwa program harus dihentikan. Mereka termasuk SystemExit yang dimunculkan oleh sys.exit() dan KeyboardInterrupt
yang dimunculkan saat pengguna ingin menghentikan program.
Pengecualian dapat digunakan sebagai wildcard yang menangkap (hampir) semuanya. Namun, praktik yang baik adalah sespesifik
mungkin dengan jenis pengecualian yang ingin kami tangani, dan untuk memungkinkan setiap pengecualian yang tidak diharapkan menyebar.
pada.
Pola yang paling umum untuk menangani Pengecualian adalah dengan mencetak atau mencatat pengecualian dan kemudian menaikkannya kembali
(memungkinkan penelepon untuk menangani pengecualian juga):
impor sistem
coba:
f = open('myfile.txt') s = f.readline()
i = int(s.strip()) kecuali
OSError sebagai err:
print(" Kesalahan OS :", err) kecuali
ValueError: print("Tidak dapat mengonversi
data menjadi bilangan bulat.")
kecuali Pengecualian sebagai err:
print(f"Unexpected {err=}, {type(err)=}") kenaikan
8.3. Menangani Pengecualian 61

Pernyataan coba … kecuali memiliki klausa lain opsional, yang, jika ada, harus mengikuti semua kecuali klausa. Berguna untuk kode
yang harus dijalankan jika klausa try tidak memunculkan eksepsi. Sebagai contoh:
untuk arg di sys.argv[1:]: coba: f =

open(arg, 'r') kecuali OSError:
print('cannot open', arg)
kalau tidak:
print(arg, 'has', len(f.readlines()), 'lines') f.close()
Penggunaan klausa else lebih baik daripada menambahkan kode tambahan ke klausa try karena ini menghindari secara tidak sengaja
menangkap pengecualian yang tidak dimunculkan oleh kode yang dilindungi oleh try … kecuali pernyataan.
Penangan pengecualian tidak hanya menangani pengecualian yang muncul langsung di klausa try, tetapi juga yang terjadi di dalam fungsi
yang dipanggil (bahkan secara tidak langsung) di klausa try. Sebagai contoh:
>>> def this_fails():

... x = 1/0
...
>>> coba:
... this_fails()
... kecuali ZeroDivisionError sebagai err:
... print('Menangani kesalahan run-time:', err)
...
Menangani kesalahan run-time: pembagian dengan nol
8.4 Menaikkan Pengecualian
Pernyataan kenaikan memungkinkan programmer untuk memaksa pengecualian tertentu terjadi. Sebagai contoh:
>>> naikkan NameError('HaiAda')

NameError: Hai
Satu-satunya argumen yang akan dinaikkan menunjukkan pengecualian yang akan dimunculkan. Ini harus berupa instance pengecualian
atau kelas pengecualian (kelas yang berasal dari BaseException, seperti Pengecualian atau salah satu subkelasnya). Jika sebuah kelas
eksepsi dilewatkan, maka secara implisit akan dibuatkan instance-nya dengan memanggil konstruktornya tanpa argumen:
naikkan ValueError # singkatan untuk 'naikkan ValueError()'
Jika Anda perlu menentukan apakah pengecualian muncul tetapi tidak bermaksud untuk menanganinya, bentuk yang lebih sederhana dari pernyataan kenaikan
memungkinkan Anda untuk menaikkan kembali pengecualian:
>>> coba:
... naikkan NameError('HiThere') ... kecuali
NameError: print(' Pengecualian terbang lewat!')
... naikkan
...
...
Pengecualian berlalu!
NameError: Hai

8.5 Rangkaian Pengecualian
Jika pengecualian yang tidak tertangani terjadi di dalam bagian kecuali, pengecualian yang ditangani akan dilampirkan padanya dan
disertakan dalam pesan kesalahan:
>>> coba:
... buka("database.sqlite") ... kecuali
OSError: naikkan RuntimeError("tidak dapat
... menangani kesalahan")
...
File "<stdin>", baris 2, di <module> FileNotFoundError:
[Errno 2] Tidak ada file atau direktori seperti itu: 'database.sqlite'
Selama penanganan pengecualian di atas, pengecualian lain terjadi:

RuntimeError: tidak dapat menangani kesalahan
Untuk menunjukkan bahwa pengecualian adalah konsekuensi langsung dari yang lain, pernyataan kenaikan memungkinkan opsional
dari klausa:
# exc harus berupa pengecualian atau Tidak ada. naikkan

RuntimeError dari exc
Ini bisa berguna saat Anda mengubah pengecualian. Sebagai contoh:
>>> def fungsi():

... meningkatkan ConnectionError
...
>>> coba:
... func()
... kecuali ConnectionError sebagai exc: raise
... RuntimeError('Failed to open database') from exc
...
File "<stdin>", baris 2, di func
Koneksi error
Pengecualian di atas adalah penyebab langsung dari pengecualian berikut:

RuntimeError: Gagal membuka basis data
Itu juga memungkinkan penonaktifan rangkaian pengecualian otomatis menggunakan idiom dari Tidak ada:
>>> coba:
... buka('database.sqlite') ... kecuali OSError:
... naikkan RuntimeError dari Tidak Ada

...
RuntimeError
Untuk informasi lebih lanjut tentang mekanisme rantai, lihat bltin-pengecualian.
8.5. Rantai Pengecualian 63

8.6 Pengecualian yang Ditentukan Pengguna
Program dapat menamai pengecualiannya sendiri dengan membuat kelas pengecualian baru (lihat Kelas untuk informasi lebih lanjut tentang kelas
Python). Pengecualian biasanya harus diturunkan dari kelas Pengecualian, baik secara langsung maupun tidak langsung.
Kelas pengecualian dapat didefinisikan yang melakukan apa pun yang dapat dilakukan kelas lain, tetapi biasanya tetap sederhana, seringkali
hanya menawarkan sejumlah atribut yang memungkinkan informasi tentang kesalahan diekstrak oleh penangan untuk pengecualian.
Sebagian besar pengecualian ditentukan dengan nama yang diakhiri dengan "Kesalahan", mirip dengan penamaan pengecualian standar.
Banyak modul standar menentukan pengecualian mereka sendiri untuk melaporkan kesalahan yang mungkin terjadi pada fungsi yang mereka tentukan.
8.7 Mendefinisikan Tindakan Pembersihan
Pernyataan try memiliki klausa opsional lain yang dimaksudkan untuk menentukan tindakan pembersihan yang harus dijalankan dalam semua
keadaan. Sebagai contoh:
>>> coba:
... naikkan KeyboardInterrupt
... akhirnya:
... print('Selamat tinggal, dunia!')
...
Selamat tinggal Dunia!
KeyboardInterrupt
Jika klausa akhirnya ada, klausa akhirnya akan dieksekusi sebagai tugas terakhir sebelum pernyataan try selesai.
Klausa akhirnya berjalan apakah pernyataan try menghasilkan pengecualian atau tidak. Poin-poin berikut membahas kasus yang lebih kompleks
ketika pengecualian terjadi:
• Jika pengecualian terjadi selama eksekusi klausa try, pengecualian dapat ditangani oleh klausa kecuali. Jika pengecualian tidak ditangani
oleh pengecualian klausa, pengecualian akan dimunculkan kembali setelah klausa akhirnya dieksekusi.
• Pengecualian dapat terjadi selama pelaksanaan klausa kecuali atau yang lain. Sekali lagi, pengecualian dimunculkan kembali
setelah akhirnya klausa telah dieksekusi.
• Jika klausa akhirnya mengeksekusi pernyataan istirahat, lanjutkan atau kembalikan, pengecualian tidak dimunculkan kembali.
• Jika pernyataan try mencapai pernyataan break, continue atau return, klausa finally akan dieksekusi tepat sebelum eksekusi pernyataan
break, continue atau return.
• Jika klausa akhirnya menyertakan pernyataan kembali, nilai yang dikembalikan akan menjadi salah satu dari akhirnya
pernyataan pengembalian klausa, bukan nilai dari pernyataan pengembalian klausa try.
Sebagai contoh:
>>> def bool_return(): coba:

...
... kembali Benar
... akhirnya:
... kembali Salah
...
>>> bool_return()
PALSU
Contoh yang lebih rumit:
>>> def bagi(x, y): coba: hasil

... =x/y
...

... kecuali ZeroDivisionError:

... print("pembagian dengan nol!")
... kalau tidak:
... print("hasil adalah", hasil) akhirnya:

... print("mengeksekusi akhirnya klausa")
...
...
>>> bagi(2, 1) hasilnya
adalah 2.0
mengeksekusi akhirnya klausa >>>
bagi(2, 0) pembagian dengan nol!
mengeksekusi akhirnya klausa >>>
divide("2", "1") mengeksekusi akhirnya
klausa Traceback (panggilan terakhir
terakhir):

File "<stdin>", baris 3, di bagi
TypeError: jenis operan yang tidak didukung untuk /: 'str' dan 'str'
Seperti yang Anda lihat, klausa akhirnya dijalankan dalam acara apa pun. TypeError yang dimunculkan dengan membagi dua
string tidak ditangani oleh kecuali klausa dan oleh karena itu dimunculkan kembali setelah klausa akhirnya dieksekusi.
Dalam aplikasi dunia nyata, akhirnya klausa berguna untuk melepaskan sumber daya eksternal (seperti file atau koneksi
jaringan), terlepas dari apakah penggunaan sumber berhasil.
8.8 Tindakan Pembersihan yang Ditentukan Sebelumnya
Beberapa objek menentukan tindakan pembersihan standar yang harus dilakukan saat objek tidak lagi diperlukan, terlepas dari
apakah operasi menggunakan objek berhasil atau gagal. Lihat contoh berikut, yang mencoba membuka file dan mencetak isinya
ke layar.
untuk baris terbuka ("myfile.txt"): print(baris,

akhir="")
Masalah dengan kode ini adalah membiarkan file terbuka untuk waktu yang tidak ditentukan setelah bagian kode ini selesai
dieksekusi. Ini bukan masalah dalam skrip sederhana, tetapi bisa menjadi masalah untuk aplikasi yang lebih besar. Dengan
pernyataan memungkinkan objek seperti file untuk digunakan dengan cara yang memastikan mereka selalu dibersihkan dengan
cepat dan benar.
dengan open("myfile.txt") sebagai f: untuk

baris di f:
cetak(baris, akhir="")
Setelah pernyataan dieksekusi, file f selalu ditutup, bahkan jika terjadi masalah saat memproses baris. Objek yang, seperti file,
memberikan tindakan pembersihan yang telah ditentukan sebelumnya akan menunjukkan hal ini dalam dokumentasinya.
8.8. Tindakan Pembersihan yang Telah Ditentukan 65

8.9 Menaikkan dan Menangani Beberapa Pengecualian yang Tidak Terkait
Ada situasi di mana perlu melaporkan beberapa pengecualian yang telah terjadi. Ini sering terjadi dalam kerangka kerja konkurensi,
ketika beberapa tugas mungkin gagal secara paralel, tetapi ada juga kasus penggunaan lain yang diinginkan untuk melanjutkan
eksekusi dan mengumpulkan banyak kesalahan daripada memunculkan pengecualian pertama.
ExceptionGroup bawaan membungkus daftar instance pengecualian sehingga dapat dimunculkan bersama. Ini adalah pengecualian
itu sendiri, sehingga dapat ditangkap seperti pengecualian lainnya.
>>> def f(): excs =

... [OSError('error 1'), SystemError('error 2')] raise ExceptionGroup('ada masalah', excs)
...
...
>>> f()
+ Pengecualian Grup Traceback (panggilan terbaru terakhir):
| File "<stdin>", baris 1, di <module>
| File "<stdin>", baris 3, di f
| ExceptionGroup: ada masalah
+-+---------------- 1 ----------------
| OSError: kesalahan 1
+---------------- 2 ----------------
| SystemError: kesalahan 2
+---------------------------------------
>>> coba:
... f()
... kecuali Pengecualian sebagai e:
... print(f'tertangkap {type(e)}: e')
...
tertangkap <kelas 'ExceptionGroup'>: e
>>>
Dengan menggunakan exception* sebagai ganti dari exception, kita hanya dapat menangani pengecualian dalam grup yang cocok dengan
tipe tertentu secara selektif. Dalam contoh berikut, yang memperlihatkan grup pengecualian bersarang, setiap klausa exception*
mengekstrak dari pengecualian grup dari jenis tertentu sambil membiarkan semua pengecualian lainnya menyebar ke klausa lain dan
akhirnya dinaikkan kembali.
>>> def f():

... naikkan ExceptionGroup("group1",
... [OSError(1),
... Kesalahan Sistem(2),
... ExceptionGroup("grup2",
... [OSError(3), RecursionError(4)])])
...
>>> coba:
... f()
... kecuali* OSError sebagai e:
... print("Ada OSErrors") ... kecuali* SystemError
as e:
... print("Ada Kesalahan Sistem")
...
Ada OSError
Ada SystemErrors
| Grup Pengecualian: grup1
+-+---------------- 1 ----------------
| Grup Pengecualian: grup2
+-+---------------- 1 ----------------
| Kesalahan Rekursi: 4
+---------------------------------------
>>>

Perhatikan bahwa pengecualian yang bersarang di grup pengecualian harus berupa instance, bukan tipe. Ini karena dalam
praktiknya, pengecualian biasanya adalah pengecualian yang telah dimunculkan dan ditangkap oleh program, dengan pola berikut:
>>> excs = [] ...

untuk tes dalam tes:
... coba:
... test.run()
... kecuali Pengecualian sebagai
... e: excs.append(e)
...
>>> jika dikecualikan:
... naikkan ExceptionGroup(" Kegagalan Uji", excs)
...
8.10 Memperkaya Pengecualian dengan Catatan
Saat pengecualian dibuat untuk dimunculkan, biasanya diinisialisasi dengan informasi yang menjelaskan kesalahan yang terjadi.
Ada kasus di mana berguna untuk menambahkan informasi setelah pengecualian tertangkap. Untuk tujuan ini, pengecualian
memiliki metode add_note(note) yang menerima string dan menambahkannya ke daftar catatan pengecualian.
Render traceback standar menyertakan semua catatan, sesuai urutan penambahannya, setelah pengecualian.
>>> coba:
... naikkan TypeError('bad type')
... kecuali Pengecualian sebagai e:
... e.add_note('Tambahkan beberapa informasi')
... e.add_note('Tambahkan beberapa informasi lagi') naikkan
...
...
TypeError: tipe buruk
Tambahkan beberapa informasi
Tambahkan beberapa informasi lagi
>>>
Misalnya, saat mengumpulkan pengecualian ke dalam grup pengecualian, kami mungkin ingin menambahkan informasi konteks
untuk setiap kesalahan. Berikut ini setiap pengecualian dalam grup memiliki catatan yang menunjukkan kapan kesalahan ini terjadi.
>>> def f():

... naikkan OSError('operasi gagal')
...
>>> excs = [] >>>
for i in range(3): coba: f() kecuali
... Pengecualian
... sebagai e:
...
... e.add_note(f'Terjadi dalam Iterasi {i+1}') excs.append(e)
...
...
>>> naikkan ExceptionGroup('We have some problems', excs)
| ExceptionGroup: Kami memiliki beberapa masalah (3 sub-pengecualian)
+-+---------------- 1 ----------------
| Traceback (panggilan terbaru terakhir):
| OSError: operasi gagal
8.10. Memperkaya Pengecualian dengan Catatan 67

| Terjadi pada Iterasi 1 +---------------- 2

----------------
| Terjadi pada Iterasi 2 +---------------- 3
----------------
| Terjadi pada Iterasi 3
+---------------------------------------
>>>

BAB
SEMBILAN
KELAS
Kelas menyediakan sarana bundling data dan fungsionalitas bersama. Membuat kelas baru akan membuat tipe objek baru, yang
memungkinkan instance baru dari tipe tersebut dibuat. Setiap instance kelas dapat memiliki atribut yang melekat padanya untuk
mempertahankan statusnya. Instance kelas juga dapat memiliki metode (ditentukan oleh kelasnya) untuk memodifikasi statusnya.
Dibandingkan dengan bahasa pemrograman lain, mekanisme kelas Python menambahkan kelas dengan sintaks dan semantik
baru yang minimal. Ini adalah campuran dari mekanisme kelas yang ditemukan di C++ dan Modula-3. Kelas Python menyediakan
semua fitur standar Pemrograman Berorientasi Objek: mekanisme pewarisan kelas memungkinkan banyak kelas dasar, kelas
turunan dapat mengganti metode apa pun dari kelas atau kelas dasarnya, dan metode dapat memanggil metode kelas dasar
dengan nama yang sama . Objek dapat berisi jumlah dan jenis data yang sewenang-wenang. Seperti halnya modul, kelas
mengambil bagian dari sifat dinamis Python: mereka dibuat saat runtime, dan dapat dimodifikasi lebih lanjut setelah dibuat.
Dalam terminologi C++, biasanya anggota kelas (termasuk anggota data) bersifat publik (kecuali lihat di bawah Variabel Pribadi),
dan semua fungsi anggota bersifat virtual. Seperti di Modula-3, tidak ada singkatan untuk mereferensikan anggota objek dari
metodenya: fungsi metode dideklarasikan dengan argumen pertama yang eksplisit yang mewakili objek, yang disediakan secara
implisit oleh panggilan. Seperti di Smalltalk, kelas itu sendiri adalah objek. Ini menyediakan semantik untuk mengimpor dan
mengganti nama. Tidak seperti C++ dan Modula-3, tipe bawaan dapat digunakan sebagai kelas dasar untuk ekstensi oleh
pengguna. Juga, seperti di C++, sebagian besar operator bawaan dengan sintaks khusus (operator aritmatika, subskrip, dll.)
dapat didefinisikan ulang untuk instance kelas.
(Kurangnya terminologi yang diterima secara universal untuk berbicara tentang kelas, saya akan sesekali menggunakan istilah Smalltalk dan C+
+. Saya akan menggunakan istilah Modula-3, karena semantik berorientasi objeknya lebih dekat dengan Python daripada C++, tetapi saya
berharap bahwa beberapa pembaca pernah mendengarnya.)
9.1 Kata Tentang Nama dan Objek
Objek memiliki individualitas, dan banyak nama (dalam berbagai cakupan) dapat terikat ke objek yang sama. Ini dikenal sebagai aliasing
dalam bahasa lain. Ini biasanya tidak dihargai pada pandangan pertama di Python, dan dapat diabaikan dengan aman ketika berhadapan
dengan tipe dasar yang tidak dapat diubah (angka, string, tupel). Namun, aliasing mungkin memiliki efek yang mengejutkan pada
semantik kode Python yang melibatkan objek yang dapat diubah seperti daftar, kamus, dan sebagian besar jenis lainnya. Ini biasanya
digunakan untuk kepentingan program, karena alias berperilaku seperti penunjuk dalam beberapa hal. Misalnya, melewatkan objek itu
murah karena hanya sebuah pointer yang dilewatkan oleh implementasi; dan jika sebuah fungsi memodifikasi objek yang diteruskan
sebagai argumen, pemanggil akan melihat perubahannya — ini menghilangkan kebutuhan akan dua mekanisme penerusan argumen
yang berbeda seperti di Pascal.
69
9.2 Cakupan dan Ruang Nama Python

Sebelum memperkenalkan kelas, pertama-tama saya harus memberi tahu Anda sesuatu tentang aturan ruang lingkup Python. Definisi kelas
memainkan beberapa trik rapi dengan ruang nama, dan Anda perlu mengetahui cara kerja ruang lingkup dan ruang nama untuk memahami
sepenuhnya apa yang terjadi. Kebetulan, pengetahuan tentang subjek ini berguna untuk semua programmer Python tingkat lanjut.
Mari kita mulai dengan beberapa definisi.
Namespace adalah pemetaan dari nama ke objek. Sebagian besar ruang nama saat ini diimplementasikan sebagai kamus Python, tetapi
biasanya tidak terlihat dengan cara apa pun (kecuali untuk kinerja), dan mungkin berubah di masa mendatang. Contoh ruang nama adalah:
kumpulan nama bawaan (berisi fungsi seperti abs(), dan nama pengecualian bawaan); nama global dalam modul; dan nama lokal dalam
pemanggilan fungsi. Dalam arti himpunan atribut suatu objek juga membentuk namespace. Hal penting yang harus diketahui tentang ruang
nama adalah sama sekali tidak ada hubungan antara nama di ruang nama yang berbeda; misalnya, dua modul berbeda dapat menentukan
fungsi maksimalkan tanpa kebingungan — pengguna modul harus mengawalinya dengan nama modul.
Omong-omong, saya menggunakan atribut kata untuk nama apa pun yang mengikuti titik — misalnya, dalam ekspresi z.real, real adalah
atribut dari objek z. Sebenarnya, referensi ke nama dalam modul adalah referensi atribut: dalam ekspresi modname.funcname, modname
adalah objek modul dan funcname adalah atributnya. Dalam hal ini terjadi pemetaan langsung antara atribut modul dan nama global yang
didefinisikan dalam modul: mereka berbagi ruang nama yang sama!1
Atribut dapat berupa read-only atau writable. Dalam kasus terakhir, penugasan ke atribut dimungkinkan. Atribut modul dapat ditulis: Anda
dapat menulis modname.the_answer = 42. Atribut yang dapat ditulis juga dapat dihapus dengan pernyataan del. Misalnya, del
modname.the_answer akan menghapus atribut the_answer dari objek yang diberi nama modname.
Ruang nama dibuat pada momen yang berbeda dan memiliki masa hidup yang berbeda. Ruang nama yang berisi nama bawaan dibuat saat
juru bahasa Python dijalankan, dan tidak pernah dihapus. Ruang nama global untuk modul dibuat saat definisi modul dibaca; biasanya, ruang
nama modul juga bertahan hingga juru bahasa berhenti.
Pernyataan yang dieksekusi oleh pemanggilan tingkat atas dari juru bahasa, baik dibaca dari file skrip atau secara interaktif, dianggap sebagai
bagian dari modul bernama __main__, sehingga mereka memiliki namespace globalnya sendiri. (Nama bawaan sebenarnya juga hidup dalam
modul; ini disebut builtin.)
Ruang nama lokal untuk suatu fungsi dibuat saat fungsi dipanggil, dan dihapus saat fungsi mengembalikan atau memunculkan pengecualian
yang tidak ditangani dalam fungsi. (Sebenarnya, melupakan akan menjadi cara yang lebih baik untuk menggambarkan apa yang sebenarnya
terjadi.) Tentu saja, pemanggilan rekursif masing-masing memiliki namespace lokalnya sendiri.
Lingkup adalah wilayah tekstual dari program Python di mana namespace dapat diakses secara langsung. “Dapat diakses langsung” di sini
berarti referensi yang tidak memenuhi syarat ke sebuah nama mencoba menemukan nama tersebut di namespace.
Meskipun cakupan ditentukan secara statis, cakupan digunakan secara dinamis. Setiap saat selama eksekusi, ada 3 atau 4 cakupan
bersarang yang ruang namanya dapat diakses secara langsung:
• Lingkup terdalam, yang dicari terlebih dahulu, berisi nama-nama lokal
• Cakupan dari setiap fungsi penutup, yang dicari dimulai dengan cakupan penutup terdekat, berisi
nama non-lokal, tetapi juga non-global
• cakupan berikutnya hingga terakhir berisi nama global modul saat ini
• lingkup terluar (dicari terakhir) adalah ruang nama yang berisi nama bawaan
Jika sebuah nama dideklarasikan secara global, maka semua referensi dan penetapan langsung menuju ke lingkup berikutnya hingga terakhir
yang berisi nama global modul. Untuk mengikat ulang variabel yang ditemukan di luar lingkup terdalam, pernyataan nonlokal dapat digunakan;
jika tidak dideklarasikan nonlocal, variabel-variabel tersebut bersifat read-only (upaya untuk menulis ke variabel semacam itu hanya akan
membuat variabel lokal baru dalam lingkup terdalam, membiarkan variabel luar yang bernama identik tidak berubah).
Biasanya, cakupan lokal mereferensikan nama lokal dari fungsi (secara tekstual) saat ini. Di luar fungsi, cakupan lokal mereferensikan ruang
nama yang sama dengan ruang lingkup global: ruang nama modul. Definisi kelas menempatkan namespace lain dalam lingkup lokal.
1 Kecuali untuk satu hal. Objek modul memiliki atribut read-only rahasia yang disebut __dict__ yang mengembalikan kamus yang digunakan untuk
mengimplementasikan namespace modul; nama __dict__ adalah atribut tetapi bukan nama global. Jelas, menggunakan ini melanggar abstraksi
implementasi namespace, dan harus dibatasi untuk hal-hal seperti debugger post-mortem.
70 Bab 9. Kelas
Penting untuk disadari bahwa cakupan ditentukan secara tekstual: cakupan global dari suatu fungsi yang didefinisikan dalam modul adalah
ruang nama modul itu, tidak peduli dari mana atau dengan alias apa fungsi itu dipanggil. Di sisi lain, pencarian nama sebenarnya dilakukan
secara dinamis, pada saat dijalankan — namun, definisi bahasa berkembang menuju resolusi nama statis, pada waktu "kompilasi", jadi
jangan bergantung pada resolusi nama dinamis! (Faktanya, variabel lokal sudah ditentukan secara statis.)
Keunikan khusus Python adalah - jika tidak ada pernyataan global atau nonlokal yang berlaku - penugasan ke nama selalu masuk ke ruang
lingkup terdalam. Tugas tidak menyalin data — tugas hanya mengikat nama ke objek. Hal yang sama berlaku untuk penghapusan:
pernyataan del x menghapus pengikatan x dari namespace yang direferensikan oleh lingkup lokal.
Faktanya, semua operasi yang memperkenalkan nama baru menggunakan lingkup lokal: khususnya, pernyataan impor dan definisi fungsi
mengikat nama modul atau fungsi dalam lingkup lokal.
Pernyataan global dapat digunakan untuk menunjukkan bahwa variabel tertentu hidup dalam lingkup global dan harus melambung di sana;
pernyataan nonlokal menunjukkan bahwa variabel tertentu hidup dalam lingkup terlampir dan harus dikembalikan ke sana.
9.2.1 Ruang Lingkup dan Contoh Ruang Nama
Ini adalah contoh yang mendemonstrasikan cara mereferensikan cakupan dan ruang nama yang berbeda, dan bagaimana pengaruh global
dan nonlokal terhadap pengikatan variabel:
def scope_test(): def

do_local():
spam = "spam lokal"
def do_nonlocal(): spam

nonlokal = "spam
nonlokal"
def do_global(): spam

global spam =
"spam global"
spam = "uji spam" do_local()

print("Setelah penugasan
lokal:", spam) do_nonlocal() print("Setelah penugasan
nonlokal:", spam) do_global() print("Setelah penugasan
global:", spam)
scope_test()
print("Dalam lingkup global:", spam)
Output dari kode contoh adalah:
Setelah penetapan lokal: uji spam

Setelah penugasan nonlokal: spam nonlokal
Setelah penugasan global: spam nonlokal
Dalam lingkup global: spam global
Perhatikan bagaimana penetapan lokal (yang merupakan default) tidak mengubah pengikatan spam scope_test . Nonlocal as signment
mengubah pengikatan spam scope_test , dan penugasan global mengubah pengikatan tingkat modul.
Anda juga dapat melihat bahwa tidak ada pengikatan spam sebelumnya sebelum penetapan global.
9.2. Lingkup dan Ruang Nama Python 71

9.3 Pandangan Pertama tentang Kelas
Kelas memperkenalkan sedikit sintaks baru, tiga tipe objek baru, dan beberapa semantik baru.
9.3.1 Sintaks Definisi Kelas

Bentuk paling sederhana dari definisi kelas terlihat seperti ini:
nama kelas kelas :

<pernyataan-1>
.
.
.
<pernyataan-N>
Definisi kelas, seperti definisi fungsi (pernyataan def) harus dijalankan sebelum memiliki efek apa pun. (Anda dapat
menempatkan definisi kelas di cabang pernyataan if, atau di dalam fungsi.)
Dalam praktiknya, pernyataan di dalam definisi kelas biasanya berupa definisi fungsi, tetapi pernyataan lain diperbolehkan, dan
terkadang berguna — kita akan membahasnya lagi nanti. Definisi fungsi di dalam kelas biasanya memiliki bentuk daftar
argumen yang khas, ditentukan oleh konvensi pemanggilan metode — sekali lagi, ini akan dijelaskan nanti.
Saat definisi kelas dimasukkan, namespace baru dibuat, dan digunakan sebagai cakupan lokal — jadi, semua penugasan ke
variabel lokal masuk ke namespace baru ini. Secara khusus, definisi fungsi mengikat nama fungsi baru di sini.
Ketika definisi kelas dibiarkan normal (melalui akhir), objek kelas dibuat. Ini pada dasarnya adalah pembungkus isi namespace
yang dibuat oleh definisi kelas; kita akan mempelajari lebih lanjut tentang objek kelas di bagian selanjutnya. Lingkup lokal asli
(yang berlaku tepat sebelum definisi kelas dimasukkan) dipulihkan, dan objek kelas terikat di sini dengan nama kelas yang
diberikan dalam header definisi kelas (ClassName dalam contoh).
9.3.2 Objek Kelas

Objek kelas mendukung dua jenis operasi: referensi atribut dan instantiasi.
Referensi atribut menggunakan sintaks standar yang digunakan untuk semua referensi atribut di Python: obj.name. Nama
atribut yang valid adalah semua nama yang ada di ruang nama kelas saat objek kelas dibuat. Jadi, jika definisi kelas terlihat
seperti ini:
kelas Kelasku:
"""Contoh kelas sederhana""" i = 12345
def f(self):
kembalikan 'hello world'
maka MyClass.i dan MyClass.f adalah referensi atribut yang valid, masing-masing mengembalikan bilangan bulat dan objek
fungsi. Atribut kelas juga dapat ditetapkan, sehingga Anda dapat mengubah nilai MyClass.i berdasarkan penetapan. __doc__
juga merupakan atribut yang valid, mengembalikan docstring milik kelas: "A simple example class".
Instansiasi kelas menggunakan notasi fungsi. Anggap saja objek kelas adalah fungsi tanpa parameter yang mengembalikan
instance baru dari kelas. Misalnya (dengan asumsi kelas di atas):
x = KelasSaya()
membuat instance baru dari kelas dan menugaskan objek ini ke variabel lokal x.
Operasi instantiasi ("memanggil" objek kelas) membuat objek kosong. Banyak kelas suka membuat objek dengan instance
yang disesuaikan dengan keadaan awal tertentu. Oleh karena itu kelas dapat mendefinisikan metode khusus bernama
__init__(), seperti ini:
72 Bab 9. Kelas
def __init__(self): self.data = []
Saat kelas mendefinisikan metode __init__() , instantiasi kelas secara otomatis memanggil __init__() untuk instance kelas yang baru
dibuat. Jadi dalam contoh ini, instance baru yang diinisialisasi dapat diperoleh dengan:
x = KelasSaya()
Tentu saja, metode __init__() mungkin memiliki argumen untuk fleksibilitas yang lebih besar. Dalam hal ini, argumen yang diberikan
kepada operator instansiasi kelas diteruskan ke __init__(). Sebagai contoh,
>>> Kompleks kelas : def

... __init__(self, realpart, imagpart):
... self.r = realpart self.i =
... imagpart
...
>>> x = Kompleks(3.0, -4.5) >>> xr, xi (3.0,
-4.5)
9.3.3 Objek Contoh
Sekarang apa yang bisa kita lakukan dengan objek instan? Satu-satunya operasi yang dipahami oleh objek instan adalah referensi
atribut. Ada dua jenis nama atribut yang valid: atribut data dan metode.
atribut data sesuai dengan "variabel instan" di Smalltalk, dan dengan "anggota data" di C++. Atribut data tidak perlu dideklarasikan;
seperti variabel lokal, mereka muncul saat pertama kali ditugaskan. Misalnya, jika x adalah turunan dari MyClass yang dibuat di atas,
potongan kode berikut akan mencetak nilai 16, tanpa meninggalkan jejak:
x.hitung = 1
while x.counter < 10:
x.hitung = x.hitung * 2
print(x.counter) del
x.counter
Jenis lain dari referensi atribut instance adalah metode. Metode adalah fungsi yang "milik" suatu objek. (Dalam Python, istilah metode
tidak unik untuk instance kelas: tipe objek lain juga dapat memiliki metode. Misalnya, daftar objek memiliki metode yang disebut
append, insert, remove, sort, dan seterusnya. Namun, dalam pembahasan berikut, kita akan menggunakan istilah metode secara
eksklusif untuk mengartikan metode objek instance kelas, kecuali secara eksplisit dinyatakan sebaliknya.)
Nama metode yang valid dari objek instance bergantung pada kelasnya. Menurut definisi, semua atribut kelas yang merupakan objek
fungsi menentukan metode yang sesuai dari instance-nya. Jadi dalam contoh kita, xf adalah referensi metode yang valid, karena
MyClass.f adalah sebuah fungsi, tetapi xi bukan, karena MyClass.i bukan. Tapi xf tidak sama dengan MyClass. f — ini adalah objek
metode, bukan objek fungsi.
9.3.4 Metode Objek
Biasanya, sebuah metode dipanggil tepat setelah terikat:
xf()
Dalam contoh MyClass, ini akan mengembalikan string 'hello world'. Namun, tidak perlu memanggil metode langsung: xf adalah objek
metode, dan dapat disimpan dan dipanggil di lain waktu. Sebagai contoh:
xf = xf
sementara Benar:
cetak(xf())
9.3. Pandangan Pertama tentang Kelas 73

akan terus mencetak hello world hingga akhir zaman.
Apa yang sebenarnya terjadi ketika suatu metode dipanggil? Anda mungkin memperhatikan bahwa xf() dipanggil tanpa argumen
di atas, meskipun definisi fungsi untuk f() menentukan argumen. Apa yang terjadi dengan argumen itu? Tentunya Python
memunculkan pengecualian ketika fungsi yang membutuhkan argumen dipanggil tanpa apa pun — bahkan jika argumen tersebut
tidak benar-benar digunakan…
Sebenarnya, Anda mungkin sudah menebak jawabannya: hal khusus tentang metode adalah bahwa objek instance
dilewatkan sebagai argumen pertama dari fungsi tersebut. Dalam contoh kita, panggilan xf() sama persis dengan
MyClass.f(x). Secara umum, memanggil metode dengan daftar n argumen sama dengan memanggil fungsi yang sesuai
dengan daftar argumen yang dibuat dengan menyisipkan objek instance metode sebelum argumen pertama.
Jika Anda masih tidak memahami cara kerja metode, lihat penerapannya mungkin dapat memperjelas masalah. Ketika
atribut non-data dari suatu instance direferensikan, kelas instance dicari. Jika nama menunjukkan atribut kelas yang valid
yang merupakan objek fungsi, objek metode dibuat dengan mengemas (menunjuk ke) objek instance dan objek fungsi yang
baru saja ditemukan bersama dalam objek abstrak: ini adalah objek metode. Ketika objek metode dipanggil dengan daftar
argumen, daftar argumen baru dibuat dari objek instance dan daftar argumen, dan objek fungsi dipanggil dengan daftar
argumen baru ini.
9.3.5 Variabel Kelas dan Contoh

Secara umum, variabel instan untuk data unik untuk setiap instans dan variabel kelas untuk atribut dan metode yang
digunakan bersama oleh semua instans kelas:
Anjing kelas :
jenis = 'anjing' # variabel kelas dibagikan oleh semua instance
def __init__(self, name): self.name = nama #

variabel instance unik untuk setiap instance
>>> d = Anjing('Fido') >>> e =

Anjing('Teman') >>> d.kind
# dibagikan oleh semua anjing
'anjing'
>>> e.jenis # dibagikan oleh semua anjing
'anjing'
>>> d.nama # unik untuk d
'Fido'
>>> e.nama # unik untuk e
'Sobat'
Seperti yang dibahas dalam A Word About Names and Objects, data yang dibagikan mungkin memiliki efek mengejutkan dengan
melibatkan objek yang dapat berubah seperti daftar dan kamus. Misalnya, daftar trik dalam kode berikut tidak boleh digunakan sebagai
variabel kelas karena hanya satu daftar yang akan digunakan bersama oleh semua instance Anjing :
Anjing kelas :
trik = [] # penggunaan variabel kelas yang salah
def __init__(self, nama): self.name = nama
def add_trick(self, trik):

self.tricks.append(trick)
>>> d = Dog('Fido') >>> e =

Dog('Buddy') >>> d.add_trick('roll
over') >>> e.add_trick('play dead')
74 Bab 9. Kelas
>>> d.trik # tiba-tiba dibagikan oleh semua anjing

['berguling', 'pura-pura mati']
Desain kelas yang benar harus menggunakan variabel instan sebagai gantinya:
Anjing kelas :
def __init__(diri, nama):

self.nama = nama
self.trik = [] # membuat daftar kosong baru untuk setiap anjing
def add_trick(self, trik):

self.tricks.append(trick)
>>> d = Dog('Fido') >>> e =

Dog('Buddy') >>> d.add_trick('roll
over') >>> e.add_trick('play dead') >>> d .Trik
['berguling'] >>> e.trik
['pura pura mati']
9.4 Keterangan Acak
Jika nama atribut yang sama muncul di kedua instance dan di kelas, maka pencarian atribut akan memprioritaskan instance tersebut:
>>> gudang kelas :

... tujuan = 'penyimpanan'
... wilayah = 'barat'
...
>>> w1 = Gudang()
>>> print(w1.purpose, w1.region) penyimpanan
barat >>> w2 = Warehouse()
>>> w2.region = 'timur' >>>

penyimpanan print(w2.purpose, w2.region) timur
Atribut data dapat direferensikan oleh metode maupun oleh pengguna biasa ("klien") dari suatu objek. Dengan kata lain, kelas tidak dapat
digunakan untuk mengimplementasikan tipe data abstrak murni. Nyatanya, tidak ada apa pun dalam Python yang memungkinkan untuk
memaksakan penyembunyian data — semuanya didasarkan pada konvensi. (Di sisi lain, implementasi Python, yang ditulis dalam C, dapat
sepenuhnya menyembunyikan detail implementasi dan mengontrol akses ke objek jika perlu; ini dapat digunakan oleh ekstensi ke Python
yang ditulis dalam C.)
Klien harus menggunakan atribut data dengan hati-hati — klien dapat mengacaukan invarian yang dikelola oleh metode dengan menandai
atribut data mereka. Perhatikan bahwa klien dapat menambahkan atribut datanya sendiri ke objek instan tanpa memengaruhi validitas
metode, selama konflik nama dihindari — sekali lagi, konvensi penamaan dapat menghemat banyak kerumitan di sini.
Tidak ada singkatan untuk mereferensikan atribut data (atau metode lain!) dari dalam metode. Saya menemukan bahwa ini benar-benar
meningkatkan keterbacaan metode: tidak ada kemungkinan membingungkan variabel lokal dan variabel instan ketika melihat sekilas
melalui metode.
Seringkali, argumen pertama dari sebuah metode disebut self. Ini tidak lebih dari sebuah konvensi: nama self sama sekali tidak memiliki
arti khusus untuk Python. Perhatikan, bagaimanapun, bahwa dengan tidak mengikuti konvensi, kode Anda mungkin kurang dapat dibaca
oleh programmer Python lainnya, dan juga dapat dibayangkan bahwa program browser kelas dapat ditulis yang bergantung pada konvensi
semacam itu.
9.4. Keterangan Acak 75

Objek fungsi apa pun yang merupakan atribut kelas menentukan metode untuk instance kelas itu. Definisi fungsi tidak perlu
dilampirkan secara tekstual dalam definisi kelas: menugaskan objek fungsi ke variabel lokal di kelas juga boleh. Sebagai contoh:
# Fungsi didefinisikan di luar kelas

def f1(self, x, y): kembalikan
min(x, x+y)
kelas C:
f = f1
def g (diri sendiri):

kembali 'halo dunia'
h=g
Sekarang f, g dan h adalah semua atribut kelas C yang mengacu pada objek fungsi, dan akibatnya mereka semua adalah metode
turunan dari C — h sama persis dengan g. Perhatikan bahwa praktik ini biasanya hanya berfungsi untuk membingungkan pembaca
suatu program.
Metode dapat memanggil metode lain dengan menggunakan atribut metode dari argumen diri:
Tas kelas :
def __init__(self): self.data = []
def add(self, x):

self.data.append(x)
def tambahkan dua kali (self, x):

diri.tambahkan(x)
diri.tambahkan(x)
Metode dapat mereferensikan nama global dengan cara yang sama seperti fungsi biasa. Lingkup global yang terkait dengan metode
adalah modul yang berisi definisinya. (Kelas tidak pernah digunakan sebagai lingkup global.) Sementara seseorang jarang menemukan
alasan yang baik untuk menggunakan data global dalam suatu metode, ada banyak penggunaan yang sah dari lingkup global: untuk satu
hal, fungsi dan modul yang diimpor ke dalam lingkup global dapat digunakan oleh metode, serta fungsi dan kelas yang didefinisikan di
dalamnya. Biasanya, kelas yang berisi metode itu sendiri didefinisikan dalam lingkup global ini, dan di bagian selanjutnya kita akan
menemukan beberapa alasan bagus mengapa sebuah metode ingin mereferensikan kelasnya sendiri.
Setiap nilai adalah objek, dan karenanya memiliki kelas (juga disebut tipenya). Ini disimpan sebagai object.__class__.
9.5 Warisan
Tentu saja, fitur bahasa tidak akan layak disebut "kelas" tanpa mendukung pewarisan. Sintaks untuk definisi kelas turunan terlihat
seperti ini:
kelas DerivedClassName(BaseClassName):
<pernyataan-1>
.
.
.
<pernyataan-N>
Nama BaseClassName harus didefinisikan dalam ruang lingkup yang berisi definisi kelas turunan. Di tempat nama kelas dasar,
ekspresi sewenang-wenang lainnya juga diperbolehkan. Ini bisa berguna, misalnya, ketika kelas dasar didefinisikan dalam modul
lain:
kelas DerivedClassName(modname.BaseClassName):
76 Bab 9. Kelas
Eksekusi definisi kelas turunan berjalan sama seperti untuk kelas dasar. Ketika objek kelas dibangun, kelas dasar diingat. Ini
digunakan untuk menyelesaikan referensi atribut: jika atribut yang diminta tidak ditemukan di kelas, pencarian berlanjut untuk
mencari di kelas dasar. Aturan ini diterapkan secara rekursif jika kelas dasar itu sendiri diturunkan dari beberapa kelas lain.
Tidak ada yang istimewa tentang pembuatan instance kelas turunan: DerivedClassName() membuat instance baru dari kelas
tersebut. Referensi metode diselesaikan sebagai berikut: atribut kelas yang sesuai dicari, menuruni rantai kelas dasar jika perlu,
dan referensi metode valid jika ini menghasilkan objek fungsi.
Kelas turunan dapat menggantikan metode dari kelas dasarnya. Karena metode tidak memiliki hak istimewa saat memanggil metode
lain dari objek yang sama, metode dari kelas dasar yang memanggil metode lain yang didefinisikan dalam kelas dasar yang sama
mungkin akan memanggil metode dari kelas turunan yang menimpanya. (Untuk pemrogram C++: semua metode dalam Python
secara efektif bersifat virtual.)
Metode utama dalam kelas turunan mungkin sebenarnya ingin memperluas daripada sekadar mengganti metode kelas dasar
dengan nama yang sama. Ada cara sederhana untuk memanggil metode kelas dasar secara langsung: cukup panggil
NamaKelasBasis. nama metode(diri, argumen). Hal ini kadang-kadang berguna untuk klien juga. (Perhatikan bahwa ini hanya
berfungsi jika kelas dasar dapat diakses sebagai BaseClassName dalam lingkup global.)
Python memiliki dua fungsi bawaan yang bekerja dengan pewarisan:
• Gunakan isinstance() untuk memeriksa tipe instance: isinstance(obj, int) akan bernilai True hanya jika obj. __class__ adalah
int atau beberapa kelas yang berasal dari int.
• Gunakan issubclass() untuk memeriksa pewarisan kelas: issubclass(bool, int) bernilai True karena bool adalah subkelas dari
int. Namun, issubclass(float, int) adalah False karena float bukan subclass dari int.
9.5.1 Warisan Ganda

Python juga mendukung bentuk pewarisan berganda. Definisi kelas dengan beberapa kelas dasar terlihat seperti ini:
kelas DerivedClassName(Base1, Base2, Base3): <pernyataan-1>
.
.
.
<pernyataan-N>
Untuk sebagian besar tujuan, dalam kasus yang paling sederhana, Anda dapat memikirkan pencarian atribut yang diwarisi dari
kelas induk sebagai kedalaman pertama, kiri ke kanan, bukan pencarian dua kali di kelas yang sama di mana ada tumpang tindih
dalam hierarki. Jadi, jika atribut tidak ditemukan di DerivedClassName, maka dicari di Base1, kemudian (secara rekursif) di kelas
dasar Base1, dan jika tidak ditemukan di sana, dicari di Base2, dan seterusnya.
Nyatanya, ini sedikit lebih rumit dari itu; urutan resolusi metode berubah secara dinamis untuk mendukung panggilan kooperatif ke
super(). Pendekatan ini dikenal dalam beberapa bahasa pewarisan ganda lainnya sebagai metode panggilan-berikutnya dan lebih
kuat daripada panggilan super yang ditemukan dalam bahasa pewarisan tunggal.
Pengurutan dinamis diperlukan karena semua kasus pewarisan berganda menunjukkan satu atau lebih hubungan berlian (di mana
setidaknya salah satu kelas induk dapat diakses melalui beberapa jalur dari kelas paling bawah). Misalnya, semua kelas mewarisi
dari objek, jadi setiap kasus pewarisan berganda menyediakan lebih dari satu jalur untuk mencapai objek. Untuk menjaga agar
kelas dasar tidak diakses lebih dari satu kali, algoritme dinamis melinierkan urutan pencarian dengan cara mempertahankan urutan
kiri ke kanan yang ditentukan di setiap kelas, yang memanggil setiap induk hanya sekali, dan itu monoton (artinya sebuah kelas
dapat disubklasifikasikan tanpa mempengaruhi urutan prioritas induknya). Secara keseluruhan, properti ini memungkinkan untuk
merancang kelas yang andal dan dapat diperluas dengan pewarisan berganda. Untuk detail lebih lanjut, lihat https://www.python.org/
download/releases/2.3/mro/.
9.5. Warisan 77
9.6 Variabel Privat
Variabel instan "Pribadi" yang tidak dapat diakses kecuali dari dalam objek tidak ada di Python. Namun, ada konvensi yang diikuti
oleh sebagian besar kode Python: nama yang diawali dengan garis bawah (mis. _spam) harus diperlakukan sebagai bagian non-
publik dari API (apakah itu fungsi, metode, atau anggota data) . Ini harus dianggap sebagai detail implementasi dan dapat
berubah tanpa pemberitahuan.
Karena ada kasus penggunaan yang valid untuk anggota kelas-pribadi (yaitu untuk menghindari bentrokan nama nama dengan
nama yang ditentukan oleh subkelas), ada dukungan terbatas untuk mekanisme seperti itu, yang disebut name mangling.
Pengidentifikasi apa pun dalam bentuk __spam (setidaknya dua garis bawah di depan, paling banyak satu garis bawah di
belakang) secara tekstual diganti dengan _classname__spam, di mana classname adalah nama kelas saat ini dengan garis
bawah di depan yang dihilangkan. Penguraian ini dilakukan tanpa memperhatikan posisi sintaksis dari pengidentifikasi, asalkan
terjadi dalam definisi suatu kelas.
Name mangling sangat membantu untuk membiarkan subclass menimpa metode tanpa memutuskan panggilan metode intraclass.
Sebagai contoh:
Pemetaan kelas :
def __init__(self, iterable): self.items_list = []
self.__update(iterable)
def update(self, iterable): untuk item di

iterable:
self.items_list.append(item)
__update = perbarui # salinan pribadi dari metode update() asli
kelas PemetaanSubkelas(Pemetaan):
def update(self, keys, values): # menyediakan

tanda tangan baru untuk update() # tetapi tidak merusak
__init__() untuk item dalam zip(keys, values):
self.items_list.append(item)
Contoh di atas akan berfungsi bahkan jika MappingSubclass akan memperkenalkan pengenal __update karena diganti dengan
_Mapping__update di kelas Mapping dan _MappingSubclass__update di kelas MappingSubclass.
Perhatikan bahwa aturan mangling sebagian besar dirancang untuk menghindari kecelakaan; masih dimungkinkan untuk mengakses
atau memodifikasi variabel yang dianggap pribadi. Ini bahkan dapat berguna dalam keadaan khusus, seperti di debugger.
Perhatikan bahwa kode yang diteruskan ke exec() atau eval() tidak menganggap nama kelas dari kelas pemanggil sebagai kelas
saat ini; ini mirip dengan efek dari pernyataan global, yang efeknya juga terbatas pada kode yang dikompilasi byte bersama.
Pembatasan yang sama berlaku untuk getattr(), setattr() dan delattr(), serta saat mereferensikan __dict__ secara langsung.
9.7 Peluang dan Akhir
Kadang-kadang berguna untuk memiliki tipe data yang mirip dengan Pascal "record" atau C "struct", menggabungkan beberapa
item data bernama. Pendekatan idiomatis adalah menggunakan kelas data untuk tujuan ini:
dari kelas data mengimpor kelas data
@dataclass
kelas Karyawan:
nama: str
dept: str gaji:
int
78 Bab 9. Kelas
>>> john = Pegawai('john', 'lab komputer', 1000) >>> john.dept 'lab komputer' >>>
john.salary 1000
Sepotong kode Python yang mengharapkan tipe data abstrak tertentu seringkali dapat diteruskan ke kelas yang mengemulasi
metode dari tipe data tersebut. Misalnya, jika Anda memiliki fungsi yang memformat beberapa data dari objek file, Anda
dapat mendefinisikan kelas dengan metode read() dan readline() yang mendapatkan data dari buffer string, dan
meneruskannya sebagai argumen.
Objek metode instan juga memiliki atribut: m.__self__ adalah objek instan dengan metode m(), dan m. __func__ adalah
objek fungsi yang sesuai dengan metode.
9.8 Iterator
Sekarang Anda mungkin telah memperhatikan bahwa sebagian besar objek kontainer dapat di-loop menggunakan pernyataan for:
untuk elemen di [1, 2, 3]:

cetak(elemen)
untuk elemen dalam (1, 2, 3):
print(element) untuk
memasukkan { 'one':1, 'two':2}:
print(key) untuk
char di "123":
cetak(karakter)
untuk baris di open("myfile.txt"): print(line, end='')
Gaya akses ini jelas, ringkas, dan nyaman. Penggunaan iterator meliputi dan menyatukan Python. Di belakang layar,
pernyataan for memanggil iter() pada objek kontainer. Fungsi mengembalikan objek iterator yang mendefinisikan metode
__next__() yang mengakses elemen dalam wadah satu per satu. Ketika tidak ada lagi elemen, __next__() memunculkan
pengecualian StopIteration yang memberi tahu for loop untuk diakhiri. Anda dapat memanggil metode __next__()
menggunakan fungsi bawaan next() ; contoh ini menunjukkan cara kerjanya:
>>> s = 'abc'
>>> itu = iter(s) >>> itu
<str_iterator objek di 0x10c90e650> >>> berikutnya(itu) 'a'
>>> selanjutnya(itu)
'b'
>>> selanjutnya(itu)
'c'
>>> selanjutnya
selanjutnya
Hentikan Iterasi
Setelah melihat mekanisme di balik protokol iterator, mudah untuk menambahkan perilaku iterator ke kelas Anda. Tentukan
metode __iter__() yang mengembalikan objek dengan metode __next__(). Jika kelas mendefinisikan __next__(), maka
__iter__() bisa mengembalikan diri sendiri:
kelas Terbalik:
"""Iterator untuk mengulangi urutan mundur.""" def __init__(self, data): self.data = data
9.8. Iterator 79
self.index = len(data)
def __iter__(self): kembalikan

diri
def __next__(diri sendiri):

jika self.index == 0:
naikkan StopIteration self.index

= self.index - 1
return self.data[self.index]
>>> rev = Reverse('spam') >>> iter(rev)

<__main__.Reverse objek di
0x00A1DB50> >>> untuk char di rev:
... cetak(karakter)
...
m
sebuah
p
s
9.9 Generator
Generator adalah alat yang sederhana dan kuat untuk membuat iterator. Mereka ditulis seperti fungsi biasa tetapi menggunakan
pernyataan hasil kapan pun mereka ingin mengembalikan data. Setiap kali next() dipanggil, generator melanjutkan di mana ia
tinggalkan (ia mengingat semua nilai data dan pernyataan mana yang terakhir dieksekusi). Contoh menunjukkan bahwa
generator dapat dengan mudah dibuat:
def terbalik(data): untuk

indeks dalam rentang(len(data)-1, -1, -1):
data hasil [indeks]
>>> untuk char terbalik ('golf'): print(char)

...
...
f
l
Hai
Apapun yang bisa dilakukan dengan generator juga bisa dilakukan dengan iterator berbasis kelas seperti yang dijelaskan di
bagian sebelumnya. Apa yang membuat generator begitu kompak adalah bahwa metode __iter__() dan __next__() dibuat
secara otomatis.
Fitur utama lainnya adalah variabel lokal dan status eksekusi disimpan secara otomatis di antara panggilan. Ini membuat
fungsi lebih mudah untuk ditulis dan jauh lebih jelas daripada pendekatan yang menggunakan variabel instan seperti
self.index dan self.data.
Selain pembuatan metode otomatis dan menyimpan status program, ketika generator berhenti, mereka secara otomatis
menaikkan StopIteration. Dalam kombinasi, fitur-fitur ini memudahkan untuk membuat iterator tanpa usaha lebih dari
menulis fungsi biasa.
80 Bab 9. Kelas
9.10 Ekspresi Generator

Beberapa generator sederhana dapat dikodekan secara ringkas sebagai ekspresi menggunakan sintaks yang mirip dengan
pemahaman daftar tetapi dengan tanda kurung, bukan tanda kurung siku. Ekspresi ini dirancang untuk situasi di mana
generator langsung digunakan oleh fungsi penutup. Ekspresi generator lebih kompak tetapi kurang fleksibel daripada definisi
generator lengkap dan cenderung lebih ramah memori daripada pemahaman daftar yang setara.
Contoh:
>>> sum(i*i for i in range(10)) 285 # jumlah kuadrat
>>> xvec = [10, 20, 30] >>> yvec =

[7, 5, 3] >>> sum(x*y untuk x,y
dalam zip(xvec, yvec)) 260 # produk titik
>>> unique_words = set(kata demi baris di halaman demi kata di baris.split())
>>> valedictorian = max((student.gpa, student.name) untuk mahasiswa lulusan )
>>> data = 'golf' >>>

list(data[i] for i in range(len(data)-1, -1, -1)) ['f', 'l', 'o', ' g']
9.10. Ekspresi Generator 81

82 Bab 9. Kelas
BAB
SEPULUH
TUR SINGKAT PERPUSTAKAAN STANDAR
10.1 Antarmuka Sistem Operasi
Modul os menyediakan lusinan fungsi untuk berinteraksi dengan sistem operasi:
>>> impor os >>>

os.getcwd() # Kembalikan direktori kerja saat ini
'C:\\Python311' >>>
os.chdir('/server/accesslogs') # Ubah direktori kerja saat ini # Jalankan perintah mkdir di shell sistem >>>
os.system('mkdir hari ini')
0
Pastikan untuk menggunakan gaya import os daripada from os import *. Ini akan menjaga os.open() dari naungan
karena fungsi open() bawaan yang beroperasi jauh berbeda.
Fungsi built-in dir() dan help() berguna sebagai bantuan interaktif untuk bekerja dengan modul besar seperti os:
>>> impor os >>>

dir(os)
<mengembalikan daftar semua fungsi modul>
>>> help(os)
<mengembalikan halaman manual ekstensif yang dibuat dari dokumen modul>
Untuk tugas manajemen file dan direktori harian, modul shutil menyediakan antarmuka tingkat tinggi yang lebih mudah
menggunakan:
>>> impor shutil >>>

shutil.copyfile('data.db', 'archive.db') 'archive.db'
>>> shutil.move('/build/executables', 'installdir') 'installdir'
10.2 File Wildcard
Modul glob menyediakan fungsi untuk membuat daftar file dari pencarian wildcard direktori:
>>> impor glob >>>

glob.glob('*.py') ['primes.py',
'random.py', 'quote.py']
83
10.3 Argumen Baris Perintah
Skrip utilitas umum seringkali perlu memproses argumen baris perintah. Argumen ini disimpan dalam atribut argv modul sys
sebagai daftar. Misalnya hasil keluaran berikut dari menjalankan python demo.py satu dua tiga di baris perintah:
>>> impor sys >>>

print(sys.argv) ['demo.py',
'one', 'two', 'three']
Modul argparse menyediakan mekanisme yang lebih canggih untuk memproses argumen baris perintah. Skrip berikut
mengekstrak satu atau lebih nama file dan sejumlah baris opsional untuk ditampilkan:
import argparse
parser = argparse.ArgumentParser( prog='top',

description='Tampilkan baris teratas dari setiap
file')
parser.add_argument('nama file', nargs='+') parser.add_argument('-
l', '--lines', type=int, default=10) args = parser.parse_args() print(args)
Saat dijalankan pada baris perintah dengan python top.py --lines=5 alpha.txt beta.txt, skrip menyetel args.lines ke 5 dan
args.filenames ke ['alpha.txt', 'beta.txt'].
10.4 Kesalahan Pengalihan Keluaran dan Penghentian Program
Modul sys juga memiliki atribut untuk stdin, stdout, dan stderr. Yang terakhir berguna untuk memancarkan peringatan dan
pesan kesalahan agar terlihat bahkan ketika stdout telah dialihkan:
>>> sys.stderr.write('Peringatan, file log tidak ditemukan memulai yang baru \n')
Peringatan, file log tidak ditemukan memulai yang baru
Cara paling langsung untuk mengakhiri skrip adalah dengan menggunakan sys.exit().
10.5 Pencocokan Pola String
Modul re menyediakan alat ekspresi reguler untuk pemrosesan string tingkat lanjut. Untuk pencocokan dan manipulasi yang
rumit, ekspresi reguler menawarkan solusi ringkas dan optimal:
>>> import re >>>

re.findall(r'\bf[az]*', 'kaki atau tangan mana yang paling cepat jatuh') ['kaki', 'jatuh', 'tercepat'] >>>
re.sub (r'(\b[az]+) \1', r'\1', 'kucing di topi') 'kucing di topi'
Ketika hanya kemampuan sederhana yang diperlukan, metode string lebih disukai karena lebih mudah dibaca dan di-debug:
>>> 'teh untuk juga'.replace('too', 'two') 'teh untuk dua'
84 Bab 10. Tur Singkat Perpustakaan Standar

10.6 Matematika
Modul matematika memberikan akses ke fungsi perpustakaan C yang mendasari untuk matematika floating point:

>>> math.cos(math.pi / 4)
0,70710678118654757
>>> matematika.log(1024, 2)
10.0
Modul acak menyediakan alat untuk membuat pilihan acak:
>>> import random >>>

random.choice(['apple', 'pear', 'banana']) 'apple' >>> random.sample(range(100),
10) [30, 83, 16, 4, 8, 81, 41, 50, 18, 33] >>> acak.random()
0,17970987693706186 # pengambilan sampel tanpa penggantian
# pelampung acak
>>> acak.rangkaian(6) 4 # bilangan bulat acak dipilih dari range(6)
Modul statistik menghitung properti statistik dasar (rata-rata, median, varians, dll.) dari data numerik:
>>> impor statistik >>> data =

[2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5] >>> stats.mean(data)
1.6071428571428572
>>> stats.median(data)
1.25
>>> stats.variance(data)
1.3720238095238095
Proyek SciPy <https://scipy.org> memiliki banyak modul lain untuk perhitungan numerik.
10.7 Akses Internet

Ada sejumlah modul untuk mengakses internet dan memproses protokol internet. Dua yang paling sederhana
adalah urllib.request untuk mengambil data dari URL dan smtplib untuk mengirim email:
>>> dari urllib.request import urlopen >>> dengan

urlopen('http://worldtimeapi.org/api/timezone/etc/UTC.txt') sebagai tanggapan:
... untuk baris sebagai tanggapan:
... line = line.decode() jika # Ubah byte menjadi str
... line.startswith('datetime'): print(line.rstrip())
... # Hapus baris baru yang tertinggal
...
tanggal waktu: 2022-01-01T01:36:47.689215+00:00
>>> impor smtplib >>>

server = smtplib.SMTP('localhost') >>>
server.sendmail('soothsayer@example.org', 'jcaesar@example.org', ... """Ke: jcaesar @example.org ... Dari:
soothsayer@example.org
...
... Waspadalah terhadap Ides of March.
... """) >>>
server.quit()
(Perhatikan bahwa contoh kedua memerlukan server surat yang berjalan di localhost.)
10.6. Matematika 85
10.8 Tanggal dan Waktu
Modul datetime menyediakan kelas untuk memanipulasi tanggal dan waktu dengan cara sederhana dan kompleks.
Sementara aritmatika tanggal dan waktu didukung, fokus penerapannya adalah pada ekstraksi anggota yang efisien untuk
pemformatan dan manipulasi keluaran. Modul ini juga mendukung objek yang sadar zona waktu.
>>> # tanggal mudah dibuat dan diformat >>> dari datetime import date >>>
now = date.today()
>>> sekarang
datetime.date(2003, 12, 2) >>>

now.strftime("%m-%d-%y. %d %b %Y adalah %A pada %d hari %B.")
'12-02-03. 02 Des 2003 adalah hari Selasa pada tanggal 02 Desember.'
>>> # tanggal mendukung aritmatika kalender >>> ulang tahun =

tanggal(1964, 7, 31) >>> umur = sekarang - ulang tahun >>>
umur.hari 14368
10.9 Kompresi Data
Pengarsipan data umum dan format kompresi didukung langsung oleh modul termasuk: zlib, gzip, bz2, lzma, zipfile dan
tarfile.
>>> import zlib >>> s =

b'witch which has which witches wrist watch'
>>> len 41
>>> t = zlib.compress(s) >>> len(t) 37
>>> zlib.decompress(t) b'witch yang

memiliki jam tangan penyihir mana'
>>> zlib.crc32(s) 226805979
10.10 Pengukuran Kinerja
Beberapa pengguna Python mengembangkan minat yang mendalam untuk mengetahui kinerja relatif dari berbagai pendekatan untuk
masalah yang sama. Python menyediakan alat pengukuran yang segera menjawab pertanyaan tersebut.
Misalnya, mungkin tergoda untuk menggunakan fitur packing dan unpacking tuple daripada pendekatan tradisional untuk
bertukar argumen. Modul timeit dengan cepat menunjukkan keunggulan kinerja sederhana:
>>> dari timeit import Timer >>> Timer('t=a;

a=b; b=t', 'a=1; b=2').timeit() 0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit() 0,54962537085770791
Berbeda dengan tingkat perincian waktu yang halus, modul profil dan pstat menyediakan alat untuk mengidentifikasi bagian
penting waktu dalam blok kode yang lebih besar.

10.11 Kontrol Kualitas

Salah satu pendekatan untuk mengembangkan perangkat lunak berkualitas tinggi adalah dengan menulis tes untuk setiap fungsi saat dikembangkan
dan sering menjalankan tes tersebut selama proses pengembangan.
Modul doctest menyediakan alat untuk memindai modul dan memvalidasi tes yang disematkan dalam dokumen program.
Konstruksi pengujian semudah memotong-dan-menempelkan panggilan biasa beserta hasilnya ke dalam docstring. Ini meningkatkan
dokumentasi dengan memberikan contoh kepada pengguna dan memungkinkan modul doctest untuk memastikan kode tetap sesuai
dengan dokumentasi:
def rata-rata(nilai): """Menghitung

rata-rata aritmatika dari daftar angka.
>>> cetak(rata-rata([20, 30, 70])) 40.0
"""
kembali jumlah(nilai) / len(nilai)
import doctest
doctest.testmod() # secara otomatis memvalidasi pengujian tersemat
Modul unittest tidak semudah modul doctest, tetapi memungkinkan serangkaian pengujian yang lebih komprehensif untuk dipertahankan
dalam file terpisah:
impor unittest
kelas TestStatisticalFunctions(unittest.TestCase):
def test_average(self):
self.assertEqual(rata-rata([20, 30, 70]), 40.0) self.assertEqual(round(rata-
rata([1, 5, 7]), 1), 4.3) dengan self.assertRaises(ZeroDivisionError):
rata-rata([])
dengan self.assertRaises(TypeError): rata-rata(20, 30,
70)
unittest.main() # Memanggil dari baris perintah memanggil semua tes
10.12 Termasuk Baterai

Python memiliki filosofi "termasuk baterai". Ini paling baik dilihat melalui kemampuan canggih dan tangguh dari paket-paketnya yang lebih
besar. Sebagai contoh:
• Modul xmlrpc.client dan xmlrpc.server membuat penerapan panggilan prosedur jarak jauh menjadi tugas yang hampir sepele.
Terlepas dari nama modul, tidak diperlukan pengetahuan langsung atau penanganan XML.
• Paket email adalah pustaka untuk mengelola pesan email, termasuk MIME dan RFC lainnya Dokumen pesan berbasis 2822. Tidak
seperti smtplib dan poplib yang benar-benar mengirim dan menerima pesan, paket email memiliki perangkat lengkap untuk
membangun atau mendekode struktur pesan yang kompleks (termasuk lampiran) dan untuk mengimplementasikan protokol
penyandian dan header internet.
• Paket json memberikan dukungan kuat untuk mem-parsing format pertukaran data populer ini. Modul csv mendukung pembacaan
dan penulisan file secara langsung dalam format Comma-Separated Value, biasanya didukung oleh database dan spreadsheet.
Pemrosesan XML didukung oleh paket xml.etree.ElementTree, xml.dom dan xml.sax. Bersama-sama, modul dan paket ini sangat
menyederhanakan pertukaran data antara aplikasi Python dan alat lainnya.
• Modul sqlite3 adalah pembungkus pustaka database SQLite, menyediakan database persisten yang bisa
diperbarui dan diakses menggunakan sintaks SQL yang sedikit tidak standar.
10.11. Kontrol kualitas 87

• Internasionalisasi didukung oleh sejumlah modul termasuk gettext, locale, dan codec
kemasan.

BAB
SEBELAS
TUR SINGKAT PERPUSTAKAAN STANDAR — BAGIAN II
Tur kedua ini mencakup modul lanjutan yang mendukung kebutuhan pemrograman profesional. Modul ini jarang
muncul dalam skrip kecil.
11.1 Pemformatan Keluaran
Modul reprlib menyediakan versi repr() yang disesuaikan untuk tampilan singkat dari wadah bersarang besar atau
bersarang dalam:
>>> import reprlib >>>

reprlib.repr(set('supercalifragilisticexpialidocious')) "{'a', 'c', 'd', 'e', 'f', 'g', ...}"
Modul pprint menawarkan kontrol yang lebih canggih atas pencetakan objek bawaan dan yang ditentukan pengguna dengan cara
yang dapat dibaca oleh juru bahasa. Ketika hasilnya lebih panjang dari satu baris, "printer cantik" menambahkan jeda baris dan
lekukan untuk mengungkapkan struktur data dengan lebih jelas:
>>> import pprint >>> t =

[[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta', 'yellow'], ' biru']]]
...
...
>>> pprint.pprint(t, width=30) [[[['black', 'cyan'],
'white', ['green', 'red']], [['magenta', 'yellow' ],
'biru']]]
Modul textwrap memformat paragraf teks agar sesuai dengan lebar layar yang diberikan:
>>> import textwrap >>>

doc = """Metode wrap() sama seperti fill() kecuali mengembalikan ... daftar string, bukan satu string besar dengan
baris baru untuk memisahkan ... baris yang dibungkus ."""
...
>>> cetak(textwrap.fill(doc, lebar=40))
Metode wrap() sama seperti fill() kecuali ia mengembalikan
daftar string alih-alih satu string besar dengan baris baru untuk
memisahkan baris yang dibungkus.
Modul lokal mengakses database format data khusus budaya. Atribut pengelompokan fungsi format lokal
menyediakan cara langsung memformat angka dengan pemisah grup:
>>> impor lokal >>>

locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
89
>>> konv = locale.localeconv() >>> x = 1234567.8 # dapatkan pemetaan konvensi
>>> locale.format("%d", x, grouping=True) '1,234,567' >>>

locale.format_string("%s%.*f", (conv['currency_symbol'],
conv['frac_digits' ], x), pengelompokan=Benar)
...
'$1.234.567,80'
11.2 Pembuatan Templat
Modul string menyertakan kelas Templat serbaguna dengan sintaks sederhana yang cocok untuk diedit oleh pengguna akhir.
Ini memungkinkan pengguna untuk menyesuaikan aplikasi mereka tanpa harus mengubah aplikasi.
Formatnya menggunakan nama placeholder yang dibentuk oleh $ dengan pengidentifikasi Python yang valid (karakter alfanumerik
dan skor di bawah). Mengelilingi placeholder dengan tanda kurung memungkinkannya diikuti oleh lebih banyak huruf alfanumerik
tanpa spasi. Menulis $$ membuat satu $ yang lolos:
>>> from string import Template >>> t = Template('$

{village}folk send $$10 to $cause.') >>> t.substitute(village='Nottingham', cause='the ditch
fund')
'Nottinghamfolk mengirim $10 ke parit dana.'
Metode pengganti () memunculkan KeyError saat placeholder tidak disediakan dalam kamus atau argumen kata kunci. Untuk
aplikasi gaya penggabungan surat, data yang disediakan pengguna mungkin tidak lengkap dan metode safe_substitute() mungkin
lebih tepat — metode ini tidak mengubah placeholder jika data hilang:
>>> t = Template('Kembalikan $item ke $owner.') >>> d = dict(item='unladen

swallow') >>> t.substitute(d)

...
KeyError: 'pemilik' >>>
t.safe_substitute(d)
'Kembalikan burung layang-layang tanpa muatan kepada $pemilik.'
Subkelas template dapat menentukan pembatas khusus. Misalnya, utilitas penggantian nama batch untuk browser foto dapat
memilih untuk menggunakan tanda persen untuk placeholder seperti tanggal saat ini, nomor urut gambar, atau format file:
>>> waktu impor , os.path >>> photofiles

= ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg'] >>> class BatchRename(Template): delimiter = '%'
...
...
>>> fmt = input('Masukkan rename style (%d-date %n-seqnum %f-format): ')
Masukkan gaya ganti nama (%d-date %n-seqnum %f-format): Ashley_%n%f
>>> t = BatchRename(fmt) >>> date =

time.strftime('%d%b%y') >>> for i, nama file di
enumerate(photofiles):
... basis, ext = os.path.splitext(nama file) nama baru =
... t.substitute(d=tanggal, n=i, f=ext) print('{0} --> {1}'.format(nama file,
... nama baru) )
img_1074.jpg --> Ashley_0.jpg img_1076.jpg -->

Ashley_1.jpg img_1077.jpg --> Ashley_2.jpg
Aplikasi lain untuk templating adalah memisahkan logika program dari detail berbagai format keluaran. Hal ini memungkinkan untuk
mengganti template khusus untuk file XML, laporan teks biasa, dan laporan web HTML.
90 Bab 11. Tur Singkat Perpustakaan Standar — Bagian II

11.3 Bekerja dengan Tata Letak Rekaman Data Biner
Modul struct menyediakan fungsi pack() dan unpack() untuk bekerja dengan format rekaman biner dengan panjang variabel. Contoh
berikut menunjukkan cara mengulang informasi header dalam file ZIP tanpa menggunakan modul zipfile. Kode paket "H" dan "I"
masing-masing mewakili dua dan empat byte angka yang tidak ditandatangani. "<" menunjukkan bahwa ukurannya standar dan
dalam urutan byte little-endian:
struktur impor
dengan open('myfile.zip', 'rb') sebagai f:

data = f.baca()
mulai = 0
untuk saya dalam rentang (3): # tampilkan 3 header file pertama
mulai += 14
bidang = struct.unpack('<IIIHH', data[mulai:mulai+16]) crc32, comp_size, uncomp_size,
filenamesize, extra_size = bidang
mulai += 16
namafile = data[mulai:mulai+ukurannamafile] mulai += ukurannamafile
ekstra = data[mulai:mulai+ukuran_tambahan] cetak(namafile,

hex(crc32), ukuran_kompilasi, ukuran_penguraian)
mulai += extra_size + comp_size # lewati ke tajuk berikutnya
11.4 Multi-threading
Threading adalah teknik untuk memisahkan tugas yang tidak bergantung secara berurutan. Utas dapat digunakan untuk
meningkatkan daya tanggap aplikasi yang menerima input pengguna saat tugas lain berjalan di latar belakang. Kasus penggunaan
terkait sedang menjalankan I/O secara paralel dengan perhitungan di utas lainnya.
Kode berikut menunjukkan bagaimana modul threading tingkat tinggi dapat menjalankan tugas di latar belakang sementara program
utama terus berjalan:
impor threading, zipfile
kelas AsyncZip(threading.Thread):
def __init__(self, infile, outfile): threading.Thread.__init__(self)
self.infile = infile
self.outfile = file keluar
def jalankan (sendiri):

f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) f.write(self.infile) f.close() print('Selesai zip latar
belakang dari:', self.infile)
background = AsyncZip('mydata.txt', 'myarchive.zip') background.start() print('Program

utama terus berjalan di latar depan.')
background.join() # Tunggu hingga tugas latar belakang selesai dicetak (' Program
utama menunggu hingga latar belakang selesai.')
Tantangan utama dari aplikasi multi-utas adalah mengoordinasikan utas yang berbagi data atau sumber daya lainnya. Untuk itu,
modul threading menyediakan sejumlah primitif sinkronisasi termasuk kunci, peristiwa, variabel kondisi, dan semaphore.
11.3. Bekerja dengan Tata Letak Rekaman Data Biner 91

Meskipun alat tersebut sangat kuat, kesalahan desain kecil dapat menyebabkan masalah yang sulit direproduksi. Jadi, pendekatan yang
lebih disukai untuk koordinasi tugas adalah memusatkan semua akses ke sumber daya dalam satu utas dan kemudian menggunakan
modul antrian untuk memberi makan utas itu dengan permintaan dari utas lainnya. Aplikasi yang menggunakan objek Queue untuk
komunikasi dan koordinasi antar-thread lebih mudah dirancang, lebih mudah dibaca, dan lebih dapat diandalkan.
11.5 Pencatatan
Modul logging menawarkan sistem logging berfitur lengkap dan fleksibel. Sederhananya, pesan log dikirim ke file atau ke sys.stderr:
impor logging
logging.debug('Informasi debug ') logging.info('Pesan
informasi') logging.warning('Peringatan: file konfigurasi %s
tidak ditemukan', 'server.conf') logging.error('Terjadi kesalahan ') logging.critical(' Kesalahan kritis --
mematikan')
Ini menghasilkan output berikut:
PERINGATAN:root:Peringatan:file konfigurasi server.conf tidak ditemukan

ERROR:root:Terjadi kesalahan
KRITIS:root:Kesalahan kritis -- mematikan
Secara default, pesan informasi dan debug disembunyikan dan output dikirim ke kesalahan standar. Opsi keluaran lainnya termasuk
merutekan pesan melalui email, datagram, soket, atau ke Server HTTP. Filter baru dapat memilih perutean yang berbeda berdasarkan
prioritas pesan: DEBUG, INFO, WARNING, ERROR, dan CRITICAL.
Sistem logging dapat dikonfigurasi langsung dari Python atau dapat dimuat dari file konfigurasi yang dapat diedit pengguna untuk logging
yang disesuaikan tanpa mengubah aplikasi.
11.6 Referensi Lemah
Python melakukan manajemen memori otomatis (penghitungan referensi untuk sebagian besar objek dan pengumpulan sampah untuk
menghilangkan siklus). Memori dibebaskan segera setelah referensi terakhir untuk itu telah dihilangkan.
Pendekatan ini berfungsi dengan baik untuk sebagian besar aplikasi, tetapi kadang-kadang ada kebutuhan untuk melacak objek hanya
selama mereka digunakan oleh sesuatu yang lain. Sayangnya, hanya melacaknya akan membuat referensi yang menjadikannya permanen.
Modul weakref menyediakan alat untuk melacak objek tanpa membuat referensi. Ketika objek tidak lagi diperlukan, secara otomatis
dihapus dari tabel ref lemah dan panggilan balik dipicu untuk objek ref lemah. Aplikasi umum termasuk objek caching yang mahal untuk
dibuat:
>>> import weakref, gc >>> kelas

A:
... def __init__(self, nilai): self.nilai = nilai
...
... def __repr__(self):
... kembalikan str(self.value)
...
>>> a = A(10) >>> # buat referensi
d = weakref.WeakValueDictionary() >>> d['primer'] = a >>>
d['primer'] 10 # tidak membuat referensi
# ambil objek jika masih hidup
>>> del a # hapus satu referensi

>>> gc.mengumpulkan() # segera jalankan pengumpulan sampah
0
>>> d['primer'] # entri dihapus secara otomatis


d['primer'] # entri dihapus secara otomatis
File "C:/python311/lib/weakref.py", baris 46, di __getitem__
o = self.data[kunci]()
KeyError: 'primer'
11.7 Alat untuk Bekerja dengan Daftar
Banyak kebutuhan struktur data dapat dipenuhi dengan tipe daftar bawaan. Namun, terkadang ada kebutuhan untuk penerapan
alternatif dengan pertukaran kinerja yang berbeda.
Modul array menyediakan objek array() yang seperti daftar yang hanya menyimpan data homogen dan menyimpannya dengan
lebih kompak. Contoh berikut menunjukkan larik angka yang disimpan sebagai angka biner tak bertanda dua byte (kode ketik "H")
daripada 16 byte biasa per entri untuk daftar reguler objek int Python:
>>> dari array impor array >>> a = array('H',

[4000, 10, 700, 22222]) >>> sum(a) 26932
>>> a[1:3] larik('H',

[10, 700])
Modul koleksi menyediakan objek deque() yang seperti daftar dengan penambahan dan kemunculan yang lebih cepat dari sisi kiri
tetapi pencarian yang lebih lambat di tengah. Objek-objek ini sangat cocok untuk mengimplementasikan antrian dan pencarian
pohon luas pertama:
>>> dari koleksi impor deque >>> d = deque(["task1", "task2",

"task3"]) >>> d.append("task4") >>> print("Handling", d. popleft())
Menangani tugas1
belum dicari = deque([starting_node]) def breadth_first_search(belum

dicari):
node = unsearched.popleft() untuk m di
gen_moves(node):
jika is_goal(m):
kembalikan m
tidak dicari.tambahkan(m)
Selain implementasi daftar alternatif, perpustakaan juga menawarkan alat lain seperti modul membagi dua dengan fungsi untuk
memanipulasi daftar yang diurutkan:
>>> impor bagi dua >>> skor

= [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')] >>> bagi dua. skor, (300, 'rubi'))
>>> skor
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
Modul heapq menyediakan fungsi untuk mengimplementasikan tumpukan berdasarkan daftar reguler. Entri bernilai terendah selalu
disimpan di posisi nol. Ini berguna untuk aplikasi yang berulang kali mengakses elemen terkecil tetapi tidak ingin menjalankan
pengurutan daftar lengkap:
>>> dari heapq import heapify, heappop, heappush >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data) >>> heapush(data , -5)
# atur ulang daftar menjadi urutan tumpukan #
tambahkan entri baru
11.7. Alat untuk Bekerja dengan Daftar 93

>>> [heappop(data) for i in range(3)] # mengambil tiga entri terkecil [-5, 0, 1]
11.8 Aritmatika Titik Mengambang Desimal
Modul desimal menawarkan tipe data Desimal untuk aritmatika floating point desimal. Dibandingkan dengan implementasi float built-in dari
floating point biner, kelas ini sangat membantu
• aplikasi keuangan dan penggunaan lain yang membutuhkan representasi desimal yang tepat,
• kontrol atas presisi,
• kontrol atas pembulatan untuk memenuhi persyaratan hukum atau peraturan,
• pelacakan tempat desimal yang signifikan, atau
• aplikasi di mana pengguna mengharapkan hasil yang cocok dengan perhitungan yang dilakukan secara manual.
Misalnya, menghitung pajak 5% untuk biaya telepon 70 sen memberikan hasil yang berbeda dalam floating point desimal dan floating point
biner. Perbedaannya menjadi signifikan jika hasilnya dibulatkan ke sen terdekat:
>>> dari impor desimal * >>>

bulat(Desimal('0,70') * Desimal('1,05'), 2)
Desimal('0.74') >>>
bulat(.70 * 1.05, 2) 0.73
Hasil Desimal menyimpan nol tambahan, secara otomatis menyimpulkan signifikansi empat tempat dari perkalian dengan signifikansi dua
tempat. Desimal mereproduksi matematika seperti yang dilakukan dengan tangan dan menghindari masalah yang dapat muncul ketika
floating point biner tidak dapat secara tepat mewakili jumlah desimal.
Representasi yang tepat memungkinkan kelas Desimal untuk melakukan kalkulasi modulo dan uji kesetaraan yang tidak cocok untuk
floating point biner:
>>> Desimal('1.00') % Desimal('.10')

Desimal('0,00')
>>> 1,00 % 0,10
0,099999999999999995
>>> jumlah([Desimal('0.1')]*10) == Desimal('1.0')

BENAR
>>> jumlah([0.1]*10) == 1.0
PALSU
Modul desimal menyediakan aritmatika dengan presisi sebanyak yang diperlukan:
>>> getcontext().prec = 36 >>> Desimal(1) /

Desimal(7)
Desimal('0,142857142857142857142857142857142857')

BAB
DUA BELAS
LINGKUNGAN VIRTUAL DAN PAKET
12.1 Pendahuluan
Aplikasi Python akan sering menggunakan paket dan modul yang tidak disertakan sebagai bagian dari pustaka standar.
Aplikasi kadang-kadang memerlukan versi perpustakaan tertentu, karena aplikasi mungkin memerlukan bug tertentu yang
telah diperbaiki atau aplikasi mungkin ditulis menggunakan versi lama dari antarmuka perpustakaan.
Ini berarti tidak mungkin satu instalasi Python memenuhi persyaratan setiap aplikasi. Jika aplikasi A membutuhkan versi 1.0
dari modul tertentu tetapi aplikasi B membutuhkan versi 2.0, maka persyaratan tersebut bertentangan dan menginstal versi
1.0 atau 2.0 akan membuat satu aplikasi tidak dapat dijalankan.
Solusi untuk masalah ini adalah membuat lingkungan virtual, pohon direktori mandiri yang berisi instalasi Python untuk versi
Python tertentu, ditambah sejumlah paket tambahan.
Aplikasi yang berbeda kemudian dapat menggunakan lingkungan virtual yang berbeda. Untuk mengatasi contoh persyaratan
konflik sebelumnya, aplikasi A dapat memiliki lingkungan virtualnya sendiri dengan menginstal versi 1.0 sementara aplikasi B
memiliki lingkungan virtual lain dengan versi 2.0. Jika aplikasi B memerlukan pustaka yang ditingkatkan ke versi 3.0, ini tidak
akan memengaruhi lingkungan aplikasi A.
12.2 Membuat Lingkungan Virtual
Modul yang digunakan untuk membuat dan mengelola lingkungan virtual disebut venv. venv biasanya akan menginstal versi
Python terbaru yang Anda miliki. Jika Anda memiliki beberapa versi Python di sistem Anda, Anda dapat memilih versi Python
tertentu dengan menjalankan python3 atau versi apa pun yang Anda inginkan.
Untuk membuat lingkungan virtual, tentukan direktori tempat Anda ingin meletakkannya, dan jalankan modul venv sebagai
skrip dengan jalur direktori:
python3 -m venv tutorial-env
Ini akan membuat direktori tutorial-env jika tidak ada, dan juga membuat direktori di dalamnya yang berisi salinan interpreter
Python dan berbagai file pendukung.
Lokasi direktori umum untuk lingkungan virtual adalah .venv. Nama ini membuat direktori biasanya tersembunyi di shell Anda
dan dengan demikian menyingkir sambil memberinya nama yang menjelaskan mengapa direktori itu ada. Itu juga mencegah
bentrok dengan file definisi variabel lingkungan .env yang didukung beberapa perkakas.
Setelah Anda membuat lingkungan virtual, Anda dapat mengaktifkannya.
Di Windows, jalankan:
tutorial-env\Scripts\activate.bat
Di Unix atau MacOS, jalankan:
sumber tutorial-env/bin/aktifkan
95
(Skrip ini ditulis untuk bash shell. Jika Anda menggunakan csh atau fish shells, ada alternatif skrip activation.csh dan activation.fish
yang sebaiknya Anda gunakan.)
Mengaktifkan lingkungan virtual akan mengubah prompt shell Anda untuk menunjukkan lingkungan virtual apa yang Anda gunakan,
dan memodifikasi lingkungan sehingga menjalankan python akan memberi Anda versi dan pemasangan Python tertentu.
Sebagai contoh:
$ source ~/envs/tutorial-env/bin/activate (tutorial-env) $ python

Python 3.5.1 (default, 6 Mei 2016, 10:59:36)
...
>>> impor sys >>>
sys.path ['', '/usr/local/
lib/python35.zip', ..., '~/envs/tutorial-env/lib/python3.5/site-
packages ']
>>>
Untuk menonaktifkan lingkungan virtual, ketik:
menonaktifkan
ke dalam terminal.
12.3 Mengelola Paket dengan pip

Anda dapat menginstal, memutakhirkan, dan menghapus paket menggunakan program bernama pip. Secara default pip akan
menginstal paket dari Python Package Index, <https://pypi.org>. Anda dapat menelusuri Indeks Paket Python dengan membukanya di
browser web Anda.
pip memiliki sejumlah subperintah: "install", "uninstall", "freeze", dll. (Lihat panduan indeks instalasi untuk dokumentasi lengkap untuk
pip.)
Anda dapat menginstal versi terbaru dari sebuah paket dengan menentukan nama paket:
(tutorial-env) $ python -m pip install novas Mengumpulkan novas

Mengunduh novas-3.1.1.3.tar.gz (136kB)
Menginstal paket yang terkumpul: novas Menjalankan

setup.py install for novas Berhasil menginstal
novas-3.1.1.3
Anda juga dapat menginstal versi paket tertentu dengan memberikan nama paket diikuti dengan == dan nomor versi:
(tutorial-env) $ python -m pip install request==2.6.0 Mengumpulkan permintaan==2.6.0

Menggunakan cache request-2.6.0-py2.py3-none-any.whl
Menginstal paket yang dikumpulkan: permintaan Berhasil

menginstal permintaan-2.6.0
Jika Anda menjalankan kembali perintah ini, pip akan melihat bahwa versi yang diminta telah diinstal dan tidak melakukan apa pun.
Anda dapat memberikan nomor versi yang berbeda untuk mendapatkan versi itu, atau Anda dapat menjalankan python -m pip install --
upgrade untuk memutakhirkan paket ke versi terbaru:
(tutorial-env) $ python -m pip install --permintaan upgrade

Mengumpulkan permintaan
Menginstal paket yang dikumpulkan: permintaan
Ditemukan instalasi yang ada: permintaan 2.6.0
Menghapus instalan permintaan-2.6.0:
Berhasil menghapus permintaan-2.6.0
Berhasil menginstal permintaan-2.7.0
96 Bab 12. Lingkungan dan Paket Virtual

python -m pip uninstall diikuti oleh satu atau lebih nama paket akan menghapus paket dari lingkungan virtual.
python -m pip show akan menampilkan informasi tentang paket tertentu:
(tutorial-env) $ python -m permintaan pertunjukan pip

---
Metadata-Versi: 2.0
Nama: permintaan
Versi: 2.7.0
Ringkasan: HTTP Python untuk Manusia.
Beranda: http://python-requests.org
Pengarang: Kenneth Reitz
Email penulis: me@kennethreitz.com Lisensi: Apache
2.0 Lokasi: /Users/akuchling/envs/tutorial-env/lib/
python3.4/site-packages Membutuhkan:
python -m pip list akan menampilkan semua paket yang diinstal di lingkungan virtual:
(tutorial-env) $ python -m pip list novas (3.1.1.3) numpy

(1.9.2) pip (7.0.3) permintaan (2.7.0) setuptools (16.0)
python -m pip freeze akan menghasilkan daftar serupa dari paket yang diinstal, tetapi hasilnya menggunakan format yang
diharapkan oleh python -m pip install. Konvensi umum adalah meletakkan daftar ini di file requirements.txt:
(tutorial-env) $ python -m pip freeze > requirements.txt (tutorial-env) $ cat requirements.txt

novas==3.1.1.3
numpy==1.9.2
permintaan==2.7.0
Requirement.txt kemudian dapat dikomit ke kontrol versi dan dikirimkan sebagai bagian dari aplikasi. Pengguna kemudian
dapat menginstal semua paket yang diperlukan dengan install -r:
(tutorial-env) $ python -m pip install -r requirements.txt Mengumpulkan novas==3.1.1.3 (dari -r

requirements.txt (baris 1))
...
Mengumpulkan numpy==1.9.2 (dari -r requirements.txt (baris 2))
...
Mengumpulkan permintaan==2.7.0 (dari -r requirements.txt (baris 3))
...
Menginstal paket yang terkumpul: novas, numpy, request Menjalankan setup.py install
for novas
Berhasil menginstal novas-3.1.1.3 numpy-1.9.2 permintaan-2.7.0
pip memiliki lebih banyak opsi. Konsultasikan panduan penginstalan-indeks untuk dokumentasi lengkap untuk pip. Ketika
Anda telah menulis sebuah paket dan ingin membuatnya tersedia di Python Package Index, lihat panduan indeks distribusi.
12.3. Mengelola Paket dengan pip 97

98 Bab 12. Lingkungan dan Paket Virtual

BAB
TIGABELAS
APA SEKARANG?
Membaca tutorial ini mungkin telah memperkuat minat Anda untuk menggunakan Python — Anda harus bersemangat menerapkan Python untuk
memecahkan masalah dunia nyata Anda. Di mana Anda harus pergi untuk belajar lebih banyak?
Tutorial ini adalah bagian dari kumpulan dokumentasi Python. Beberapa dokumen lain di set adalah:
• indeks-pustaka:
Anda harus menelusuri manual ini, yang memberikan materi referensi lengkap (walaupun singkat) tentang tipe, fungsi, dan
modul di pustaka standar. Distribusi Python standar menyertakan banyak kode tambahan. Ada modul untuk membaca kotak
surat Unix, mengambil dokumen melalui HTTP, menghasilkan angka acak, mengurai opsi baris perintah, mengompres data, dan
banyak tugas lainnya. Membaca sekilas Referensi Perpustakaan akan memberi Anda gambaran tentang apa yang tersedia.
• install-index menjelaskan cara menginstal modul tambahan yang ditulis oleh pengguna Python lainnya.
• reference-index: Penjelasan rinci tentang sintaks dan semantik Python. Ini bacaan berat, tapi berguna sebagai
panduan lengkap untuk bahasa itu sendiri.
Lebih banyak sumber daya Python:
• https://www.python.org: Situs web utama Python. Ini berisi kode, dokumentasi, dan petunjuk ke Python
halaman terkait di seluruh web.
• https://docs.python.org: Akses cepat ke dokumentasi Python.
• https://pypi.org: Indeks Paket Python, sebelumnya juga dijuluki Cheese Shop1 , adalah indeks pengguna
membuat modul Python yang tersedia untuk diunduh. Setelah Anda mulai merilis kode, Anda dapat mendaftarkannya di sini
agar orang lain dapat menemukannya.
• https://code.activestate.com/recipes/langs/python/: The Python Cookbook adalah kumpulan contoh kode yang cukup besar,
modul yang lebih besar, dan skrip yang berguna. Kontribusi yang sangat penting dikumpulkan dalam sebuah buku yang juga
berjudul Python Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)
• https://pyvideo.org mengumpulkan tautan ke video terkait Python dari konferensi dan pertemuan kelompok pengguna.
• https://scipy.org: Proyek Scientific Python mencakup modul untuk perhitungan dan manipulasi larik cepat ditambah sejumlah
paket untuk hal-hal seperti aljabar linier, transformasi Fourier, pemecah non-linier, distribusi bilangan acak, analisis statistik, dan
sejenisnya.
Untuk pertanyaan dan laporan masalah terkait Python, Anda dapat memposting ke newsgroup comp.lang.python, atau mengirimkannya
ke milis di python-list@python.org. Newsgroup dan milis di-gateway, sehingga pesan yang diposting ke salah satu akan secara otomatis
diteruskan ke yang lain. Ada ratusan posting sehari, menanyakan (dan menjawab) pertanyaan, menyarankan fitur baru, dan
mengumumkan modul baru. Arsip milis tersedia di https://mail.python.org/pipermail/.
Sebelum memposting, pastikan untuk memeriksa daftar Pertanyaan yang Sering Diajukan (juga disebut FAQ). FAQ menjawab banyak
pertanyaan yang muncul berulang kali, dan mungkin sudah berisi solusi untuk masalah Anda.
1 "Toko Keju" adalah sketsa Monty Python: pelanggan memasuki toko keju, tetapi keju apa pun yang dia minta, petugas mengatakan itu hilang.
99
100 Bab 13. Apa Sekarang?

BAB
EMPAT BELAS
PENGEDIT INPUT INTERAKTIF DAN PENGGANTIAN SEJARAH
Beberapa versi juru bahasa Python mendukung pengeditan baris input saat ini dan substitusi riwayat, mirip dengan fasilitas
yang ditemukan di shell Korn dan shell GNU Bash. Ini diimplementasikan menggunakan GNU Readline perpustakaan, yang
mendukung berbagai gaya pengeditan. Pustaka ini memiliki dokumentasinya sendiri yang tidak akan kami gandakan di sini.
14.1 Penyelesaian Tab dan Pengeditan Riwayat
Penyelesaian nama variabel dan modul secara otomatis diaktifkan saat pengaktifan juru bahasa sehingga tombol
Tab memanggil fungsi penyelesaian; itu melihat nama pernyataan Python, variabel lokal saat ini, dan nama modul
yang tersedia. Untuk ekspresi bertitik seperti string.a, ini akan mengevaluasi ekspresi hingga akhir '.' dan kemudian
menyarankan penyelesaian dari atribut objek yang dihasilkan. Perhatikan bahwa ini dapat mengeksekusi kode yang
ditentukan aplikasi jika objek dengan metode __getattr__() adalah bagian dari ekspresi. Konfigurasi default juga
menyimpan riwayat Anda ke dalam file bernama .python_history di direktori pengguna Anda. Sejarah akan tersedia
lagi selama sesi juru bahasa interaktif berikutnya.
14.2 Alternatif untuk Interpreter Interaktif
Fasilitas ini merupakan langkah maju yang sangat besar dibandingkan dengan versi penerjemah sebelumnya; namun, ada beberapa
keinginan yang tersisa: Alangkah baiknya jika indentasi yang tepat disarankan pada baris lanjutan (parser mengetahui apakah token
indentasi diperlukan selanjutnya). Mekanisme penyelesaian mungkin menggunakan tabel simbol juru bahasa. Perintah untuk memeriksa
(atau bahkan menyarankan) tanda kurung yang cocok, tanda kutip, dll., juga akan berguna.
Salah satu penerjemah interaktif alternatif yang telah ada selama beberapa waktu adalah IPython, yang menampilkan
penyelesaian tab, eksplorasi objek, dan manajemen riwayat lanjutan. Itu juga dapat disesuaikan secara menyeluruh dan
disematkan ke dalam aplikasi lain. Lingkungan interaktif serupa lainnya yang disempurnakan adalah bpython.
101
102 Bab 14. Pengeditan Input Interaktif dan Penggantian Riwayat

BAB
LIMABELAS
ARITMETIK TITIK MENGAMBANG: ISU DAN BATASAN
Angka floating-point direpresentasikan dalam perangkat keras komputer sebagai pecahan basis 2 (biner). Misalnya, pecahan
desimal 0,125 bernilai 1/10 + 2/100 + 5/1000, dan dengan cara yang sama pecahan biner 0,001 bernilai 0/2 + 0/4 + 1/8. Kedua
pecahan ini memiliki nilai yang identik, satu-satunya perbedaan nyata adalah yang pertama ditulis dalam notasi pecahan berbasis
10, dan yang kedua ditulis dalam basis 2.
Sayangnya, sebagian besar pecahan desimal tidak dapat dinyatakan persis sebagai pecahan biner. Konsekuensinya adalah, secara
umum, angka titik-mengambang desimal yang Anda masukkan hanya didekati dengan angka-angka titik-mengambang biner yang
sebenarnya disimpan dalam mesin.
Soal ini lebih mudah dipahami pada awalnya di basis 10. Perhatikan pecahan 1/3. Anda dapat memperkirakannya sebagai pecahan
berbasis 10:
0,3
atau lebih baik,
0,33
atau lebih baik,
0,333
dan seterusnya. Tidak peduli berapa banyak digit yang ingin Anda tulis, hasilnya tidak akan pernah tepat 1/3, tetapi akan menjadi
perkiraan 1/3 yang semakin baik.
Dengan cara yang sama, tidak peduli berapa banyak digit basis 2 yang ingin Anda gunakan, nilai desimal 0,1 tidak dapat direpresentasikan
secara tepat sebagai pecahan basis 2. Dalam basis 2, 1/10 adalah pecahan berulang tak terhingga
0,0001100110011001100110011001100110011001100110011...
Berhenti pada jumlah bit yang terbatas, dan Anda mendapatkan perkiraan. Pada sebagian besar mesin saat ini, float didekati
menggunakan pecahan biner dengan pembilang menggunakan 53 bit pertama dimulai dengan bit paling signifikan dan dengan
penyebut sebagai pangkat dua. Dalam kasus 1/10, pecahan binernya adalah 3602879701896397 / 2 ** 55 yang mendekati tetapi
tidak persis sama dengan nilai sebenarnya dari 1/10.
Banyak pengguna tidak mengetahui perkiraan karena cara nilai ditampilkan. Python hanya mencetak perkiraan desimal ke nilai
desimal sebenarnya dari perkiraan biner yang disimpan oleh mesin. Pada kebanyakan mesin, jika Python mencetak nilai desimal
sebenarnya dari perkiraan biner yang disimpan untuk 0,1, itu harus ditampilkan
>>> 0,1
0,10000000000000000055511151231257827021181583404541015625
Itu lebih banyak digit daripada yang dianggap berguna oleh kebanyakan orang, jadi Python menjaga jumlah digit dapat dikelola dengan menampilkan
nilai bulat sebagai gantinya
>>> 1/10 _ _
0,1
103
Ingat saja, meskipun hasil cetak terlihat seperti nilai persis 1/10, nilai sebenarnya yang disimpan adalah pecahan biner terdekat yang
dapat diwakili.
Menariknya, ada banyak angka desimal berbeda yang memiliki perkiraan fraksi biner terdekat yang sama.
Misalnya, angka 0,1 dan 0,10000000000000001 dan 0.
10000000000000000000055511151231257827021181583404541015625 semuanya dapat diperkirakan dengan satu -satunya yang
memiliki nilai -nilai yang sama -sama, dengan nilai -nilai yang sama dengan satu -satunya yang sama -sama dengan nilai -nilai yang
sama dengan yang sama -sama dengan Nilai -Nilai -Nilai -Nilai -Nilai Sama. x)) == x.
Secara historis, prompt Python dan fungsi repr() bawaan akan memilih yang memiliki 17 digit signifikan, 0.
100000000000000001 Dimulai dengan Python 3.1, Python (pada kebanyakan sistem) sekarang dapat memilih yang terpendek dan
hanya menampilkan 0.1.
Perhatikan bahwa ini adalah sifat dari floating-point biner: ini bukan bug di Python, dan ini juga bukan bug dalam kode Anda. Anda
akan melihat hal yang sama di semua bahasa yang mendukung aritmetika floating-point perangkat keras Anda (walaupun beberapa
bahasa mungkin tidak menampilkan perbedaan secara default, atau di semua mode keluaran).
Untuk keluaran yang lebih menyenangkan, Anda mungkin ingin menggunakan pemformatan string untuk menghasilkan angka penting dalam jumlah terbatas:
>>> format(math.pi, '.12g') # beri 12 digit signifikan '3.14159265359'
>>> format(math.pi, '.2f') '3.14' # berikan 2 digit setelah titik
>>> repr(math.pi)
'3.141592653589793'
Penting untuk disadari bahwa ini, dalam arti sebenarnya, adalah ilusi: Anda hanya membulatkan tampilan nilai mesin yang
sebenarnya.
Satu ilusi mungkin melahirkan yang lain. Misalnya, karena 0,1 tidak tepat 1/10, menjumlahkan tiga nilai 0,1 mungkin juga tidak
menghasilkan tepat 0,3:
>>> .1 + .1 + .1 == .3
PALSU
Selain itu, karena 0,1 tidak bisa mendekati nilai pasti 1/10 dan 0,3 tidak bisa mendekati nilai pasti 3/10, maka pra-pembulatan dengan
fungsi round() tidak dapat membantu:
>>> bulat(.1, 1) + bulat(.1, 1) + bulat(.1, 1) == bulat(.3, 1)

PALSU
Meskipun angka tidak dapat dibuat lebih dekat dengan nilai eksak yang diinginkan, fungsi round() dapat berguna untuk pasca-
pembulatan sehingga hasil dengan nilai eksak menjadi sebanding satu sama lain:
>>> bulat(.1 + .1 + .1, 10) == bulat(.3, 10)

BENAR
Aritmatika floating-point biner menyimpan banyak kejutan seperti ini. Masalah dengan "0,1" dijelaskan dengan detail yang tepat di
bawah ini, di bagian "Kesalahan Representasi". Lihat Bahaya Floating Point untuk penjelasan yang lebih lengkap tentang kejutan
umum lainnya.
Seperti yang dikatakan menjelang akhir, "tidak ada jawaban yang mudah." Tetap saja, jangan terlalu waspada terhadap floating-
point! Kesalahan dalam operasi float Python diwariskan dari perangkat keras floating-point, dan pada sebagian besar mesin berada
di urutan tidak lebih dari 1 bagian dalam 2**53 per operasi. Itu lebih dari cukup untuk sebagian besar tugas, tetapi Anda harus ingat
bahwa ini bukan aritmatika desimal dan setiap operasi float dapat mengalami kesalahan pembulatan baru.
Meskipun kasus patologis memang ada, untuk sebagian besar penggunaan aritmatika floating-point biasa, Anda akan melihat hasil
yang Anda harapkan pada akhirnya jika Anda cukup membulatkan tampilan hasil akhir Anda ke jumlah digit desimal yang Anda
harapkan. str() biasanya cukup, dan untuk kontrol yang lebih baik, lihat penentu format metode str.format() dalam string format.
Untuk kasus penggunaan yang membutuhkan representasi desimal yang tepat, coba gunakan modul desimal yang
mengimplementasikan aritmatika desimal yang cocok untuk aplikasi akuntansi dan aplikasi presisi tinggi.
104 Bab 15. Aritmatika Titik Terapung: Masalah dan Keterbatasan

Bentuk lain dari aritmatika eksak didukung oleh modul pecahan yang mengimplementasikan aritmatika berdasarkan bilangan rasional (sehingga
bilangan seperti 1/3 dapat direpresentasikan dengan tepat).
Jika Anda adalah pengguna berat operasi floating point, Anda harus melihat paket NumPy dan banyak paket lain untuk operasi matematika dan
statistik yang disediakan oleh proyek SciPy. Lihat <https://scipy.org>.
Python menyediakan alat yang dapat membantu pada saat-saat langka ketika Anda benar -benar ingin mengetahui nilai sebenarnya dari sebuah
float. Metode float.as_integer_ratio() menyatakan nilai float sebagai pecahan:
>>> x = 3,14159
>>> x.as_integer_ratio()
(3537115888337719, 1125899906842624)
Karena rasionya tepat, ini dapat digunakan untuk membuat ulang nilai aslinya tanpa kerugian:
>>> x == 3537115888337719 / 1125899906842624

BENAR
Metode float.hex() menyatakan float dalam heksadesimal (basis 16), sekali lagi memberikan nilai persis yang disimpan oleh komputer Anda:
>>> x.hex()
'0x1.921f9f01b866ep+1'
Representasi heksadesimal yang tepat ini dapat digunakan untuk merekonstruksi nilai float dengan tepat:
>>> x == float.fromhex('0x1.921f9f01b866ep+1')
BENAR
Karena representasinya tepat, ini berguna untuk mem-porting nilai secara andal di berbagai versi Python (independensi platform) dan bertukar
data dengan bahasa lain yang mendukung format yang sama (seperti Java dan C99).
Alat bermanfaat lainnya adalah fungsi math.fsum() yang membantu mengurangi kehilangan presisi selama penjumlahan. Ini melacak "digit yang
hilang" saat nilai ditambahkan ke total berjalan. Itu dapat membuat perbedaan dalam akurasi keseluruhan sehingga kesalahan tidak terakumulasi
ke titik di mana mereka mempengaruhi total akhir:
>>> sum([0.1] * 10) == 1.0 Salah
>>> matematika.fsum([0.1] * 10) == 1.0

BENAR
15.1 Kesalahan Representasi
Bagian ini menjelaskan contoh "0.1" secara mendetail, dan menunjukkan bagaimana Anda dapat melakukan sendiri analisis yang tepat untuk
kasus seperti ini. Keakraban dasar dengan representasi floating-point biner diasumsikan.
Kesalahan representasi mengacu pada fakta bahwa beberapa (sebagian besar, sebenarnya) pecahan desimal tidak dapat direpresentasikan
persis sebagai pecahan biner (basis 2). Ini adalah alasan utama mengapa Python (atau Perl, C, C++, Java, Fortran, dan banyak lainnya) sering
tidak menampilkan angka desimal persis seperti yang Anda harapkan.
Mengapa demikian? 1/10 tidak dapat direpresentasikan sebagai pecahan biner. Hampir semua mesin saat ini (November 2000) menggunakan
aritmatika floating point IEEE-754, dan hampir semua platform memetakan float Python ke IEEE-754 "presisi ganda". 754 ganda berisi 53 bit
presisi, jadi pada input komputer berusaha untuk mengubah 0,1 menjadi pecahan terdekat yang bisa berbentuk J/2**N di mana J adalah bilangan
bulat yang berisi tepat 53 bit. Menulis ulang
1/10 ~ = J / ( 2 **N)
sebagai
J ~= 2**N / 10
15.1. Kesalahan Representasi 105

dan mengingat bahwa J memiliki tepat 53 bit (adalah >= 2**52 tetapi < 2**53), nilai terbaik untuk N adalah 56:
>>> 2**52 <= 2**56 // 10 < 2**53

BENAR
Artinya, 56 adalah satu-satunya nilai untuk N yang meninggalkan J tepat 53 bit. Nilai terbaik yang mungkin untuk J adalah hasil bagi yang
dibulatkan:
>>> q, r = divmod(2**56, 10)

>>> r
6
Karena sisanya lebih dari setengah dari 10, perkiraan terbaik diperoleh dengan pembulatan ke atas:
>>> q+1
7205759403792794
Oleh karena itu perkiraan terbaik untuk 1/10 dalam 754 presisi ganda adalah:
7205759403792794 / 2 ** 56
Membagi pembilang dan penyebut dengan dua mengurangi pecahan menjadi:
3602879701896397 / 2 ** 55
Perhatikan bahwa karena kami membulatkan, ini sebenarnya sedikit lebih besar dari 1/10; jika kita tidak membulatkannya, hasil bagi akan
menjadi sedikit lebih kecil dari 1/10. Tapi bagaimanapun juga itu tidak bisa tepat 1/10!
Jadi komputer tidak pernah "melihat" 1/10: yang dilihatnya adalah pecahan tepat yang diberikan di atas, perkiraan ganda 754 terbaik yang bisa
didapatkan:
>>> 0,1 * 2 ** 55
3602879701896397.0
Jika kita mengalikan pecahan itu dengan 10**55, kita dapat melihat nilainya menjadi 55 digit desimal:
>>> 3602879701896397 * 10 ** 55 // 2 ** 55
1000000000000000055511151231257827021181583404541015625
artinya angka persis yang disimpan di komputer sama dengan nilai desimal 0,10000000000000000055511151231257827021181583404541015625.
Alih-alih menampilkan nilai desimal penuh, banyak bahasa (termasuk versi Python yang lebih lama), bulatkan hasilnya menjadi 17 digit
signifikan:
>>> format(0.1, '.17f')

'0.100000000000000001'
Modul pecahan dan desimal membuat perhitungan ini mudah:
>>> dari desimal impor Desimal >>> dari pecahan

impor Fraksi
>>> Pecahan.dari_float(0.1)
Pecahan (3602879701896397, 36028797018963968)
>>> (0.1).as_integer_ratio() (3602879701896397,

36028797018963968)
>>> Desimal.dari_float(0.1)
Desimal('0.10000000000000000055511151231257827021181583404541015625')
>>> format(Decimal.from_float(0.1), '.17') '0.100000000000000001'
106 Bab 15. Aritmatika Titik Terapung: Masalah dan Keterbatasan

BAB
ENAMBELAS
LAMPIRAN
16.1 Mode Interaktif
16.1.1 Penanganan Error
Saat terjadi kesalahan, penafsir mencetak pesan kesalahan dan pelacakan tumpukan. Dalam mode interaktif, ini kemudian
kembali ke prompt utama; ketika masukan berasal dari file, ia keluar dengan status keluar bukan nol setelah mencetak jejak tumpukan.
(Pengecualian yang ditangani oleh klausa yang dikecualikan dalam pernyataan try bukanlah kesalahan dalam konteks ini.)
Beberapa kesalahan fatal tanpa syarat dan menyebabkan keluar dengan keluar bukan nol; ini berlaku untuk inkonsistensi
internal dan beberapa kasus kehabisan memori. Semua pesan kesalahan ditulis ke aliran kesalahan standar; output normal
dari perintah yang dieksekusi ditulis ke output standar.
Mengetik karakter interupsi (biasanya Control-C atau Delete) ke prompt primer atau sekunder akan membatalkan input
dan kembali ke prompt utama.1 Mengetik interupsi saat perintah dijalankan akan memunculkan pengecualian
KeyboardInterrupt, yang dapat ditangani oleh pernyataan try .
16.1.2 Skrip Python yang Dapat Dieksekusi
Pada sistem Unix BSD, skrip Python dapat dibuat langsung dapat dieksekusi, seperti skrip shell, dengan meletakkan baris
#!/usr/bin/env python3.5
(dengan asumsi bahwa juru bahasa ada di PATH pengguna) di awal skrip dan memberi file mode yang dapat dieksekusi. #!
harus menjadi dua karakter pertama dari file. Pada beberapa platform, baris pertama ini harus diakhiri dengan akhiran baris
bergaya Unix ('\n'), bukan akhiran baris Windows ('\r\n'). Perhatikan bahwa karakter hash, atau pound, '#', digunakan untuk
memulai komentar dengan Python.
Skrip dapat diberikan mode yang dapat dieksekusi, atau izin, menggunakan perintah chmod .
$ chmod +x myscript.py
Pada sistem Windows, tidak ada gagasan tentang "mode yang dapat dieksekusi". Penginstal Python secara otomatis
mengaitkan file .py dengan python.exe sehingga klik dua kali pada file Python akan menjalankannya sebagai skrip.
Ekstensi juga bisa .pyw, dalam hal ini, jendela konsol yang biasanya muncul akan ditekan.
1 Masalah dengan paket GNU Readline dapat mencegah hal ini.
107
16.1.3 File Startup Interaktif

Saat Anda menggunakan Python secara interaktif, seringkali berguna untuk mengeksekusi beberapa perintah standar
setiap kali juru bahasa dimulai. Anda dapat melakukan ini dengan menyetel variabel lingkungan bernama
PYTHONSTARTUP ke nama file yang berisi perintah start-up Anda. Ini mirip dengan fitur .profile dari cangkang Unix.
File ini hanya dibaca dalam sesi interaktif, bukan saat Python membaca perintah dari skrip, dan bukan saat /dev/ tty
diberikan sebagai sumber perintah eksplisit (yang berperilaku seperti sesi interaktif). Itu dieksekusi di namespace yang
sama di mana perintah interaktif dieksekusi, sehingga objek yang didefinisikan atau diimpor dapat digunakan tanpa
kualifikasi dalam sesi interaktif. Anda juga dapat mengubah prompt sys.ps1 dan sys.ps2 di file ini.
Jika Anda ingin membaca file start-up tambahan dari direktori saat ini, Anda dapat memprogramnya di file start up
global menggunakan kode seperti if os.path.isfile('.pythonrc.py'): exec(open('. pythonrc.py').baca()). Jika Anda ingin
menggunakan file startup dalam skrip, Anda harus melakukannya secara eksplisit dalam skrip:
impor os
nama file = os.environ.get('PYTHONSTARTUP') jika nama file
dan os.path.isfile(nama file):
dengan buka (nama file) sebagai fobj:
startup_file = fobj.read() exec(startup_file)
16.1.4 Modul Kustomisasi
Python menyediakan dua pengait untuk memungkinkan Anda menyesuaikannya: penyesuaian situs dan penyesuaian pengguna. Untuk melihat cara
kerjanya, Anda harus terlebih dahulu menemukan lokasi direktori paket situs pengguna Anda. Mulai Python dan jalankan kode ini:
>>> impor situs >>>

site.getusersitepackages() '/home/user/.local/
lib/python3.5/site-packages'
Sekarang Anda dapat membuat file bernama usercustomize.py di direktori itu dan meletakkan apa pun yang Anda inginkan di dalamnya.
Ini akan memengaruhi setiap pemanggilan Python, kecuali dimulai dengan opsi -s untuk menonaktifkan impor otomatis.
sitecustomize bekerja dengan cara yang sama, tetapi biasanya dibuat oleh administrator komputer di direktori paket
situs global, dan diimpor sebelum usercustomize. Lihat dokumentasi modul situs untuk detail lebih lanjut.
108 Bab 16. Lampiran

LAMPIRAN
SEBUAH
GLOSARIUM
>>> Prompt Python default dari shell interaktif. Sering terlihat untuk contoh kode yang dapat dieksekusi secara interaktif di
interpreter.
... Dapat merujuk ke:
• Perintah Python default dari shell interaktif saat memasukkan kode untuk blok kode berindentasi, saat berada dalam
sepasang pembatas kiri dan kanan yang cocok (tanda kurung, tanda kurung siku, kurung kurawal atau tanda kutip
tiga), atau setelah menentukan dekorator.
• Konstanta bawaan Ellipsis.
2to3 Alat yang mencoba mengonversi kode Python 2.x menjadi kode Python 3.x dengan menangani sebagian besar ketidaksesuaian
yang dapat dideteksi dengan mem-parsing sumber dan melintasi pohon parse.
2to3 tersedia di perpustakaan standar sebagai lib2to3; titik masuk mandiri disediakan sebagai Alat/skrip/2to3. Lihat 2to3-
referensi.
kelas dasar abstrak Kelas dasar abstrak melengkapi pengetikan bebek dengan menyediakan cara untuk mendefinisikan
antarmuka ketika teknik lain seperti hasattr() akan kikuk atau agak salah (misalnya dengan metode ajaib).
ABC memperkenalkan subkelas virtual, yaitu kelas yang tidak mewarisi dari kelas tetapi masih dikenali oleh isinstance()
dan issubclass(); lihat dokumentasi modul abc. Python hadir dengan banyak ABC bawaan untuk struktur data (dalam
modul collections.abc), angka (dalam modul angka), aliran (dalam modul io), pencari impor dan pemuat (dalam modul
importlib.abc). Anda dapat membuat ABC sendiri dengan modul abc.
anotasi Sebuah label yang terkait dengan variabel, atribut kelas atau parameter fungsi atau nilai kembalian, yang digunakan oleh
konvensi sebagai petunjuk tipe.
Anotasi variabel lokal tidak dapat diakses saat runtime, tetapi anotasi variabel global, kelas saat upeti, dan fungsi
disimpan dalam atribut khusus __annotations__ dari modul, kelas, dan fungsi, masing-masing.
Lihat anotasi variabel, anotasi fungsi, PEP 484 dan PEP 526, yang menggambarkan fungsi ini. Lihat juga anotasi-cara
untuk praktik terbaik bekerja dengan anotasi.
argumen Nilai yang diteruskan ke fungsi (atau metode) saat memanggil fungsi. Argumentasi ada dua macam:
• argumen kata kunci: argumen yang diawali dengan pengidentifikasi (mis. nama=) dalam pemanggilan fungsi atau diteruskan
sebagai nilai dalam kamus yang diawali dengan **. Misalnya, 3 dan 5 keduanya merupakan argumen kata kunci dalam
panggilan berikut ke complex():
kompleks(nyata=3, imag=5)
kompleks(**{'nyata': 3, 'imag': 5})
• argumen posisi: argumen yang bukan argumen kata kunci. Argumen posisi dapat muncul di awal daftar argumen
dan/atau diteruskan sebagai elemen iterable yang didahului oleh *. Misalnya, 3 dan 5 keduanya argumen posisional
dalam panggilan berikut:
kompleks(3, 5)
kompleks(*(3, 5))
109
Argumen ditugaskan ke variabel lokal bernama dalam badan fungsi. Lihat bagian panggilan untuk aturan yang mengatur penetapan
ini. Secara sintaksis, ekspresi apa pun dapat digunakan untuk mewakili argumen; nilai yang dievaluasi ditugaskan ke variabel lokal.
Lihat juga entri glosarium parameter , pertanyaan FAQ tentang perbedaan antara argumen dan parameter, dan PEP 362.
pengelola konteks asinkron Objek yang mengontrol lingkungan yang terlihat dalam async dengan pernyataan dengan mendefinisikan
metode __aenter__() dan __aexit__(). Diperkenalkan oleh PEP 492.
generator asinkron Fungsi yang mengembalikan iterator generator asinkron. Sepertinya fungsi coroutine didefinisikan dengan async def
kecuali bahwa itu berisi ekspresi hasil untuk menghasilkan serangkaian nilai yang dapat digunakan dalam async for loop.
Biasanya merujuk ke fungsi generator asinkron, tetapi dapat merujuk ke iterator generator asinkron dalam beberapa konteks.
Dalam kasus di mana arti yang dimaksud tidak jelas, menggunakan istilah lengkap menghindari ambiguitas.
Fungsi generator asinkron dapat berisi ekspresi menunggu serta async untuk, dan async dengan pernyataan.
iterator generator asinkron Objek yang dibuat oleh fungsi generator asinkron .
Ini adalah iterator asinkron yang ketika dipanggil menggunakan metode __anext__() mengembalikan objek yang dapat ditunggu
yang akan mengeksekusi badan fungsi generator asinkron hingga ekspresi hasil berikutnya.
Setiap hasil untuk sementara menangguhkan pemrosesan, mengingat status eksekusi lokasi (termasuk variabel lokal dan
pernyataan percobaan yang tertunda). Saat iterator generator asinkron secara efektif melanjutkan dengan awaitable lain yang
dikembalikan oleh __anext__(), ia melanjutkan dari bagian terakhirnya. Lihat PEP 492 dan PEP525.
asynchronous iterable Sebuah objek, yang dapat digunakan dalam pernyataan async for. Harus mengembalikan iterator asinkron dari
metode __aiter__() -nya. Diperkenalkan oleh PEP 492.
asynchronous iterator Objek yang mengimplementasikan metode __aiter__() dan __anext__(). __anext__ harus mengembalikan objek
yang ditunggu . async for menyelesaikan awaitables yang dikembalikan oleh metode __anext__() iterator asinkron hingga
memunculkan pengecualian StopAsyncIteration.
Diperkenalkan oleh PEP 492.
atribut Nilai yang terkait dengan objek yang biasanya direferensikan dengan nama menggunakan ekspresi bertitik. Sebagai contoh, jika
sebuah objek o memiliki atribut a maka akan direferensikan sebagai oa
Dimungkinkan untuk memberi objek atribut yang namanya bukan pengidentifikasi seperti yang didefinisikan oleh pengidentifikasi,
misalnya menggunakan setattr(), jika objek mengizinkannya. Atribut seperti itu tidak akan dapat diakses menggunakan ekspresi
bertitik, dan sebagai gantinya perlu diambil dengan getattr().
awaitable Objek yang dapat digunakan dalam ekspresi await. Bisa berupa coroutine atau objek dengan metode __await__(). Lihat juga
PEP 492.
Diktator Kebajikan BDFL Untuk Kehidupan, alias Guido van Rossum, pencipta Python.
file biner Objek file yang dapat membaca dan menulis objek seperti byte. Contoh file biner adalah file yang dibuka dalam mode biner ('rb',
'wb' atau 'rb+'), sys.stdin.buffer, sys.stdout.buffer, dan instance io.
BytesIO dan gzip.GzipFile.
Lihat juga file teks untuk objek file yang dapat membaca dan menulis objek str.
Referensi yang dipinjam Dalam C API Python, referensi yang dipinjam adalah referensi ke suatu objek. Itu tidak mengubah jumlah
referensi objek. Itu menjadi penunjuk yang menggantung jika objek dihancurkan. Misalnya, pengumpulan sampah dapat
menghapus referensi kuat terakhir ke objek dan menghancurkannya.
Memanggil Py_INCREF() pada referensi yang dipinjam disarankan untuk mengonversinya menjadi referensi yang kuat di tempat,
kecuali ketika objek tidak dapat dihancurkan sebelum penggunaan terakhir dari referensi yang dipinjam. Fungsi Py_NewRef()
dapat digunakan untuk membuat referensi kuat baru.
bytes-like object Sebuah objek yang mendukung bufferobjects dan dapat mengekspor buffer C-contiguous . Ini mencakup semua objek
byte, bytearray, dan array.array, serta banyak objek tampilan memori umum. Objek seperti byte dapat digunakan untuk berbagai
operasi yang bekerja dengan data biner; ini termasuk kompresi, menyimpan ke file biner, dan mengirim melalui soket.
110 Lampiran A. Glosarium

Beberapa operasi membutuhkan data biner agar bisa berubah. Dokumentasi sering menyebut ini sebagai "objek seperti byte baca
tulis". Contoh objek buffer yang dapat diubah termasuk bytearray dan tampilan memori dari bytearray. Operasi lain membutuhkan
data biner untuk disimpan dalam objek yang tidak dapat diubah ("byte seperti objek hanya-baca"); contohnya termasuk byte dan
tampilan memori dari objek byte.
bytecode Kode sumber Python dikompilasi menjadi bytecode, representasi internal dari program Python dalam juru bahasa CPython.
Bytecode juga di-cache dalam file .pyc sehingga mengeksekusi file yang sama lebih cepat untuk kedua kalinya (kompilasi ulang
dari sumber ke bytecode dapat dihindari). "Bahasa perantara" ini dikatakan berjalan di mesin virtual yang mengeksekusi kode
mesin yang sesuai dengan setiap bytecode. Perhatikan bahwa bytecode tidak diharapkan bekerja di antara mesin virtual Python
yang berbeda, juga tidak stabil di antara rilis Python.
Daftar instruksi bytecode dapat ditemukan di dokumentasi untuk modul dis.
callable Sebuah callable adalah objek yang bisa dipanggil, mungkin dengan sekumpulan argumen (lihat argumen), dengan yang berikut ini
sintaksis:
dapat dipanggil(argumen1, argumen2, ...)
Sebuah fungsi, dan dengan ekstensi metode, adalah callable. Instance kelas yang mengimplementasikan metode __call__() juga
bisa dipanggil.
callback Fungsi subrutin yang diteruskan sebagai argumen untuk dieksekusi di beberapa titik di masa mendatang.
kelas Template untuk membuat objek yang ditentukan pengguna. Definisi kelas biasanya berisi definisi metode yang
beroperasi pada instance kelas.
variabel kelas Sebuah variabel didefinisikan dalam kelas dan dimaksudkan untuk dimodifikasi hanya pada tingkat kelas (yaitu, bukan dalam contoh
kelas).
bilangan kompleks Perpanjangan dari sistem bilangan riil yang sudah dikenal di mana semua bilangan dinyatakan sebagai jumlah dari
bagian riil dan bagian imajiner. Bilangan imajiner adalah kelipatan nyata dari unit imajiner (akar kuadrat dari -1), sering ditulis i
dalam matematika atau j dalam teknik. Python memiliki dukungan bawaan untuk bilangan kompleks, yang ditulis dengan notasi
terakhir ini; bagian imajiner ditulis dengan akhiran aj, misalnya 3+1j. Untuk mendapatkan akses ke persamaan kompleks dari modul
matematika, gunakan cmath. Penggunaan bilangan kompleks adalah fitur matematika yang cukup maju. Jika Anda tidak mengetahui
adanya kebutuhan untuk itu, hampir pasti Anda dapat mengabaikannya dengan aman.
manajer konteks Objek yang mengontrol lingkungan yang terlihat dalam pernyataan with dengan mendefinisikan metode __enter__()
dan __exit__(). Lihat PEP 343.
variabel konteks Sebuah variabel yang dapat memiliki nilai yang berbeda tergantung pada konteksnya. Ini mirip dengan Penyimpanan
Lokal Utas di mana setiap utas eksekusi mungkin memiliki nilai yang berbeda untuk suatu variabel. Namun, dengan variabel
konteks, mungkin ada beberapa konteks dalam satu utas eksekusi dan penggunaan utama variabel konteks adalah untuk melacak
variabel dalam tugas asinkron bersamaan. Lihat contextvars.
bersebelahan Sebuah buffer dianggap bersebelahan persis jika bersebelahan dengan C atau Fortran bersebelahan. Buffer dimensi nol
adalah C dan Fortran yang bersebelahan. Dalam larik satu dimensi, item harus diletakkan di memori bersebelahan, agar indeks
meningkat mulai dari nol. Dalam array C-contiguous multidimensi, indeks terakhir bervariasi paling cepat saat mengunjungi item
dalam urutan alamat memori. Namun, dalam array yang berdekatan Fortran, indeks pertama bervariasi paling cepat.
coroutine Coroutine adalah bentuk subrutin yang lebih umum. Subrutin dimasukkan pada satu titik dan keluar pada titik lain. Coroutine
dapat dimasukkan, keluar, dan dilanjutkan di berbagai titik. Mereka dapat diimplementasikan dengan pernyataan async def. Lihat
juga PEP 492.
fungsi coroutine Fungsi yang mengembalikan objek coroutine . Fungsi coroutine dapat ditentukan dengan pernyataan async def, dan
mungkin berisi await, async for, dan async dengan kata kunci. Ini diperkenalkan oleh PEP 492.
CPython Implementasi kanonik dari bahasa pemrograman Python, seperti yang didistribusikan di python.org. Istilah "CPython" digunakan
bila diperlukan untuk membedakan implementasi ini dari yang lain seperti Jython atau IronPython.
dekorator Fungsi yang mengembalikan fungsi lain, biasanya diterapkan sebagai transformasi fungsi menggunakan sintaks @wrapper.
Contoh umum untuk dekorator adalah classmethod() dan staticmethod().
111
Sintaks dekorator hanyalah gula sintaksis, dua definisi fungsi berikut secara semantik setara:
def f(arg):
...
f = metode statis(f)
@staticmethod def
f(arg):
...
Konsep yang sama ada untuk kelas, tetapi lebih jarang digunakan di sana. Lihat dokumentasi untuk definisi fungsi dan definisi kelas
untuk informasi lebih lanjut tentang dekorator.
deskriptor Setiap objek yang mendefinisikan metode __get__(), __set__(), atau __delete__(). Ketika atribut kelas adalah deskriptor, perilaku
pengikatan khusus dipicu pada pencarian atribut. Biasanya, menggunakan ab untuk mendapatkan, menyetel, atau menghapus atribut
mencari objek bernama b di kamus kelas untuk a, tetapi jika b adalah deskriptor, metode deskriptor terkait akan dipanggil. Memahami
deskriptor adalah kunci untuk pemahaman mendalam tentang Python karena mereka adalah dasar dari banyak fitur termasuk fungsi,
metode, properti, metode kelas, metode statis, dan referensi ke kelas super.
Untuk informasi lebih lanjut tentang metode deskriptor, lihat deskriptor atau Panduan Cara Deskriptor.
kamus Sebuah array asosiatif, di mana kunci sewenang-wenang dipetakan ke nilai-nilai. Kuncinya bisa berupa objek apa saja
__hash__() dan __eq__() metode. Disebut hash di Perl.
pemahaman kamus Cara ringkas untuk memproses semua atau sebagian elemen dalam iterable dan mengembalikan kamus dengan
hasilnya. hasil = {n: n ** 2 untuk n dalam rentang (10)} menghasilkan
pemahaman.
kamus yang berisi kunci n dipetakan ke nilai n ** 2. Lihat
tampilan kamus Objek yang dikembalikan dari dict.keys(), dict.values(), dan dict.items() disebut tampilan kamus. Mereka memberikan
tampilan dinamis pada entri kamus, yang berarti bahwa ketika kamus berubah, tampilan mencerminkan perubahan ini. Untuk memaksa
tampilan kamus menjadi daftar lengkap gunakan list(dictview). Lihat tampilan-dikt.
docstring Sebuah string literal yang muncul sebagai ekspresi pertama dalam sebuah kelas, fungsi atau modul. Meskipun diabaikan saat suite
dijalankan, suite tersebut dikenali oleh kompiler dan dimasukkan ke dalam atribut __doc__ dari kelas, fungsi, atau modul yang
dilampirkan. Karena tersedia melalui introspeksi, ini adalah tempat kanonis untuk dokumentasi objek.
duck-typing Gaya pemrograman yang tidak melihat tipe objek untuk menentukan apakah objek tersebut memiliki antarmuka yang tepat;
sebagai gantinya, metode atau atribut hanya dipanggil atau digunakan ("Jika terlihat seperti bebek dan dukun seperti bebek, itu pasti
bebek.") Dengan menekankan antarmuka daripada tipe tertentu, kode yang dirancang dengan baik meningkatkan fleksibilitasnya
dengan mengizinkan substitusi polimorfik. Duck-typing menghindari pengujian menggunakan type() atau isinstance(). (Perhatikan,
bagaimanapun, duck-typing dapat dilengkapi dengan kelas dasar abstrak.) Sebagai gantinya, ini biasanya menggunakan pengujian
hasattr() atau pemrograman EAFP .
EAFP Lebih mudah meminta maaf daripada izin. Gaya pengkodean Python yang umum ini mengasumsikan adanya kunci atau atribut yang
valid dan menangkap pengecualian jika asumsi tersebut terbukti salah. Gaya bersih dan cepat ini ditandai dengan adanya banyak
pernyataan coba dan kecuali. Teknik kontras dengan gaya LBYL umum untuk banyak bahasa lain seperti C.
ekspresi Bagian dari sintaks yang dapat dievaluasi untuk beberapa nilai. Dengan kata lain, ekspresi adalah akumulasi elemen ekspresi
seperti literal, nama, akses atribut, operator atau pemanggilan fungsi yang semuanya mengembalikan nilai.
Berbeda dengan banyak bahasa lain, tidak semua konstruksi bahasa adalah ekspresi. Ada juga pernyataan yang tidak dapat
digunakan sebagai ekspresi, seperti while. Tugas juga merupakan pernyataan, bukan ekspresi.
modul ekstensi Modul yang ditulis dalam C atau C++, menggunakan API C Python untuk berinteraksi dengan inti dan dengan kode pengguna.
f-string Literal string yang diawali dengan 'f' atau 'F' biasa disebut “f-strings” yang merupakan kependekan dari formatted string
literal. Lihat juga PEP 498.
objek file Objek yang mengekspos API berorientasi file (dengan metode seperti read() atau write()) ke sumber daya yang mendasarinya.
Bergantung pada cara pembuatannya, objek file dapat memediasi akses ke file nyata di disk atau ke file lainnya

jenis penyimpanan atau perangkat komunikasi (misalnya input/output standar, buffer dalam memori, soket, pipa, dll.).
Objek file juga disebut objek atau aliran seperti file.
Sebenarnya ada tiga kategori objek file: file biner mentah, file biner buffer , dan file teks. Antarmuka mereka ditentukan
dalam modul io. Cara kanonik untuk membuat objek file adalah dengan menggunakan fungsi open().
objek seperti file Sinonim untuk objek file.
filesystem encoding dan error handler Encoding dan error handler digunakan oleh Python untuk mendekode byte dari op
sistem pengaktifan dan menyandikan Unicode ke sistem operasi.
Pengkodean sistem file harus menjamin untuk berhasil mendekode semua byte di bawah 128. Jika pengkodean sistem
file gagal memberikan jaminan ini, fungsi API dapat meningkatkan UnicodeError.
Fungsi sys.getfilesystemencoding() dan sys.getfilesystemencodeerrors() dapat digunakan untuk mendapatkan

penyandian sistem file dan penangan kesalahan.
Pengodean sistem file dan penangan kesalahan dikonfigurasikan saat startup Python oleh fungsi PyConfig_Read():
lihat anggota filesystem_encoding dan filesystem_errors dari PyConfig.
Lihat juga pengkodean lokal.
finder Objek yang mencoba menemukan loader untuk modul yang sedang diimpor.
Sejak Python 3.3, ada dua jenis pencari: pencari jalur meta untuk digunakan dengan sys.meta_path, dan pencari entri
jalur untuk digunakan dengan sys.path_hooks.
Lihat PEP 302, PPP 420 dan PEP 451 untuk lebih detail.
pembagian lantai Pembagian matematika yang membulatkan ke bawah ke bilangan bulat terdekat. Operator pembagian
lantai adalah //. Misalnya, ekspresi 11 // 4 bernilai 2 berbeda dengan 2,75 yang dikembalikan oleh float true division.
Perhatikan bahwa (-11) // 4 adalah -3 karena -2,75 dibulatkan ke bawah. Lihat PEP 238.
function Serangkaian pernyataan yang mengembalikan beberapa nilai ke pemanggil. Itu juga dapat melewati nol atau lebih
argumen yang dapat digunakan dalam eksekusi tubuh. Lihat juga bagian parameter, metode, dan fungsi.
anotasi fungsi Anotasi parameter fungsi atau nilai kembalian.
Anotasi fungsi biasanya digunakan untuk petunjuk tipe: misalnya, fungsi ini diharapkan mengambil dua argumen int
dan juga diharapkan memiliki nilai kembalian int:
def sum_two_numbers(a: int, b: int) -> int:

mengembalikan a + b
Sintaks anotasi fungsi dijelaskan di bagian fungsi.
Lihat anotasi variabel dan PEP 484, yang menggambarkan fungsi ini. Lihat juga anotasi-cara untuk praktik terbaik
bekerja dengan anotasi.
__future__ Pernyataan masa depan, from __future__ import <feature>, mengarahkan compiler untuk mengkompilasi modul
saat ini menggunakan sintaks atau semantik yang akan menjadi standar dalam rilis Python mendatang. Modul
__future__ mendokumentasikan kemungkinan nilai fitur. Dengan mengimpor modul ini dan mengevaluasi variabelnya,
Anda dapat melihat kapan fitur baru pertama kali ditambahkan ke bahasa dan kapan akan (atau memang) menjadi
default:
>>> import __future__ >>>

__future__.division
_Fitur((2, 2, 0, 'alfa', 2), (3, 0, 0, 'alfa', 0), 8192)
pengumpulan sampah Proses membebaskan memori saat tidak digunakan lagi. Python melakukan pengumpulan sampah
melalui penghitungan referensi dan pengumpul sampah siklik yang mampu mendeteksi dan memutus siklus referensi.
Pengumpul sampah dapat dikontrol menggunakan modul gc.
generator Fungsi yang mengembalikan iterator generator. Ini terlihat seperti fungsi normal kecuali berisi ekspresi hasil untuk
menghasilkan serangkaian nilai yang dapat digunakan dalam perulangan-for atau yang dapat diambil satu per satu
dengan fungsi next() .
113
Biasanya merujuk ke fungsi generator, tetapi dapat merujuk ke iterator generator dalam beberapa konteks. Dalam kasus di mana arti
yang dimaksud tidak jelas, menggunakan istilah lengkap menghindari ambiguitas.
generator iterator Objek yang dibuat oleh fungsi generator .
Setiap hasil untuk sementara menangguhkan pemrosesan, mengingat status eksekusi lokasi (termasuk variabel lokal dan pernyataan
percobaan yang tertunda). Saat iterator generator melanjutkan, ia melanjutkan dari bagian terakhirnya (berlawanan dengan fungsi yang
mulai baru di setiap pemanggilan).
ekspresi generator Ekspresi yang mengembalikan sebuah iterator. Sepertinya ekspresi normal diikuti oleh klausa for yang mendefinisikan
variabel loop, rentang, dan klausa if opsional. Ekspresi gabungan menghasilkan nilai untuk fungsi terlampir:
>>> sum(i*i untuk i dalam rentang(10)) # jumlah kuadrat 0, 1, 4, ... 81

285
fungsi generik Sebuah fungsi terdiri dari beberapa fungsi menerapkan operasi yang sama untuk jenis yang berbeda.
Implementasi mana yang harus digunakan selama panggilan ditentukan oleh algoritme pengiriman.
Lihat juga entri glosarium pengiriman tunggal , dekorator functools.singledispatch(), dan PEP 443.
tipe generik Tipe yang dapat diparameterisasi; biasanya kelas wadah seperti daftar atau dict. Digunakan untuk petunjuk jenis dan anotasi.
Untuk detail lebih lanjut, lihat tipe alias generik, PEP 483, PEP 484, PEP 585, dan modul pengetikan.
GIL Lihat kunci juru bahasa global.
kunci juru bahasa global Mekanisme yang digunakan oleh juru bahasa CPython untuk memastikan bahwa hanya satu utas yang mengeksekusi
bytecode Python pada satu waktu. Ini menyederhanakan implementasi CPython dengan membuat model objek (termasuk tipe bawaan
kritis seperti dict) secara implisit aman terhadap akses bersamaan. Mengunci seluruh juru bahasa memudahkan juru bahasa menjadi
multi-utas, dengan mengorbankan sebagian besar paralelisme yang diberikan oleh mesin multi-prosesor.
Namun, beberapa modul ekstensi, baik standar maupun pihak ketiga, dirancang untuk melepaskan GIL saat melakukan tugas intensif
komputasi seperti kompresi atau hashing. Juga, GIL selalu dirilis saat melakukan I/O.
Upaya sebelumnya untuk membuat juru bahasa "berulir bebas" (yang mengunci data bersama pada perincian yang jauh lebih halus)
belum berhasil karena kinerja menurun dalam kasus prosesor tunggal yang umum. Dipercayai bahwa mengatasi masalah kinerja ini
akan membuat penerapannya jauh lebih rumit dan karenanya lebih mahal untuk dipertahankan.
berbasis hash pyc File cache bytecode yang menggunakan hash daripada waktu modifikasi terakhir yang sesuai
file sumber untuk menentukan validitasnya. Lihat pyc-pembatalan.
hashable Sebuah objek hashable jika memiliki nilai hash yang tidak pernah berubah selama masa pakainya (memerlukan metode __hash__()),
dan dapat dibandingkan dengan objek lain (memerlukan metode __eq__()). Objek hashable yang membandingkan sama harus memiliki
nilai hash yang sama.
Kemampuan hash membuat objek dapat digunakan sebagai kunci kamus dan anggota himpunan, karena struktur data ini menggunakan
nilai hash secara internal.
Sebagian besar objek bawaan Python yang tidak dapat diubah bersifat hashable; wadah yang bisa berubah (seperti daftar atau kamus)
tidak; wadah yang tidak dapat diubah (seperti tupel dan set beku) hanya dapat di-hash jika elemennya dapat di-hash.
Objek yang merupakan instance dari kelas yang ditentukan pengguna dapat di-hash secara default. Mereka semua membandingkan tidak
sama (kecuali dengan diri mereka sendiri), dan nilai hash mereka berasal dari id() mereka.
IDLE Lingkungan Pengembangan dan Pembelajaran Terintegrasi untuk Python. idle adalah editor dan juru bahasa dasar
lingkungan yang dikirimkan dengan distribusi standar Python.
immutable Sebuah objek dengan nilai tetap. Objek yang tidak dapat diubah termasuk angka, string, dan tupel. Objek seperti itu tidak dapat
diubah. Objek baru harus dibuat jika nilai yang berbeda harus disimpan. Mereka memainkan peran penting di tempat-tempat di mana
nilai hash konstan diperlukan, misalnya sebagai kunci dalam kamus.

jalur impor Daftar lokasi (atau entri jalur) yang dicari oleh pencari berbasis jalur untuk modul yang akan diimpor.
Selama impor, daftar lokasi ini biasanya berasal dari sys.path, tetapi untuk subpaket, daftar ini juga dapat berasal dari atribut
__path__ paket induk.
importing Proses dimana kode Python dalam satu modul dibuat tersedia untuk kode Python dalam modul lain. importir Objek yang
menemukan dan memuat modul; objek finder dan loader .
interaktif Python memiliki juru bahasa interaktif yang berarti Anda dapat memasukkan pernyataan dan ekspresi pada prompt in terpreter,
segera jalankan dan lihat hasilnya. Luncurkan saja python tanpa argumen (mungkin dengan memilihnya dari menu utama komputer
Anda). Ini adalah cara yang sangat ampuh untuk menguji ide-ide baru atau memeriksa modul dan paket (ingat help(x)).
Python yang ditafsirkan adalah bahasa yang ditafsirkan, bukan bahasa yang dikompilasi, meskipun perbedaannya bisa kabur karena
adanya kompiler bytecode. Ini berarti file sumber dapat dijalankan secara langsung tanpa secara eksplisit membuat file yang
dapat dieksekusi yang kemudian dijalankan. Bahasa yang diterjemahkan biasanya memiliki siklus pengembangan/debug yang
lebih pendek daripada bahasa yang dikompilasi, meskipun program mereka umumnya juga berjalan lebih lambat. Lihat juga interaktif.
shutdown juru bahasa Ketika diminta untuk mematikan, juru bahasa Python memasuki fase khusus di mana ia secara bertahap
melepaskan semua sumber daya yang dialokasikan, seperti modul dan berbagai struktur internal penting. Itu juga membuat
beberapa panggilan ke pengumpul sampah. Ini dapat memicu eksekusi kode dalam destruktor yang ditentukan pengguna atau
panggilan balik lemah. Kode yang dijalankan selama fase penonaktifan dapat menghadapi berbagai pengecualian karena sumber
daya yang diandalkannya mungkin tidak berfungsi lagi (contoh umum adalah modul pustaka atau mesin peringatan).
Alasan utama penghentian juru bahasa adalah karena modul __main__ atau skrip yang dijalankan telah selesai dijalankan.
iterable Sebuah objek yang mampu mengembalikan anggotanya satu per satu. Contoh iterable mencakup semua tipe urutan (seperti
daftar, str, dan tupel) dan beberapa tipe non-urutan seperti dict, objek file, dan objek dari kelas apa pun yang Anda tentukan dengan
metode __iter__() atau dengan metode __getitem__() yang mengimplementasikan semantik urutan .
Iterables dapat digunakan dalam for loop dan di banyak tempat lain di mana urutan diperlukan (zip(), map(), …). Saat objek iterable
diteruskan sebagai argumen ke fungsi bawaan iter(), ia mengembalikan iterator untuk objek tersebut. Iterator ini bagus untuk satu
kali melewati kumpulan nilai. Saat menggunakan iterables, biasanya tidak perlu memanggil iter() atau berurusan dengan objek
iterator sendiri. Pernyataan for melakukannya secara otomatis untuk Anda, membuat variabel sementara yang tidak disebutkan
namanya untuk menahan iterator selama durasi loop. Lihat juga iterator, sequence, dan generator.
iterator Objek yang mewakili aliran data. Panggilan berulang ke metode __next__() iterator (atau meneruskannya ke fungsi bawaan next())
mengembalikan item berturut-turut dalam aliran. Ketika tidak ada lagi data yang tersedia, pengecualian StopIteration akan
dimunculkan. Pada titik ini, objek iterator habis dan panggilan selanjutnya ke metode __next__() hanya menaikkan StopIteration
lagi. Iterator diharuskan memiliki metode __iter__() yang mengembalikan objek iterator itu sendiri sehingga setiap iterator juga
dapat diubah dan dapat digunakan di sebagian besar tempat di mana iterable lainnya diterima. Satu pengecualian penting adalah
kode yang mencoba melewati beberapa iterasi. Objek wadah (seperti daftar) menghasilkan iterator baru setiap kali Anda
meneruskannya ke fungsi iter() atau menggunakannya dalam for loop. Mencoba ini dengan iterator hanya akan mengembalikan
objek iterator habis yang sama yang digunakan pada iterasi sebelumnya, membuatnya tampak seperti wadah kosong.
Informasi lebih lanjut dapat ditemukan di typeiter.
Detail implementasi CPython: CPython tidak secara konsisten menerapkan persyaratan yang ditentukan iterator __iter__().
key function Fungsi kunci atau fungsi collation adalah callable yang mengembalikan nilai yang digunakan untuk menyortir atau
mengurutkan. Misalnya, locale.strxfrm() digunakan untuk menghasilkan kunci pengurutan yang mengetahui konvensi pengurutan khusus lokal.
Sejumlah alat di Python menerima fungsi kunci untuk mengontrol bagaimana elemen disusun atau dikelompokkan. Mereka
termasuk min(), max(), sortir(), list.sort(), heapq.merge(), heapq.nsmallest(), heapq. nlargest(), dan itertools.groupby().
Ada beberapa cara untuk membuat fungsi kunci. Sebagai contoh. metode str.lower() dapat berfungsi sebagai fungsi kunci untuk
pengurutan case-insensitive. Alternatifnya, fungsi kunci dapat dibangun dari ekspresi lambda seperti lambda r: (r[0], r[2]). Juga,
operator.attgetter(), operator.itemgetter(),
115
dan operator.methodcaller() adalah tiga konstruktor fungsi utama. Lihat Sorting CARA untuk contoh cara membuat dan menggunakan
fungsi tombol.
argumen kata kunci Lihat argumen.
lambda Fungsi inline anonim yang terdiri dari ekspresi tunggal yang dievaluasi saat fungsi dipanggil. Sintaks untuk membuat fungsi lambda
adalah lambda [parameter]: ekspresi
LBYL Lihatlah sebelum Anda melompat. Gaya pengkodean ini secara eksplisit menguji prasyarat sebelum melakukan panggilan atau pencarian.
Gaya ini kontras dengan pendekatan EAFP dan dicirikan dengan adanya banyak pernyataan if.
Dalam lingkungan multi-utas, pendekatan LBYL dapat berisiko menyebabkan kondisi balapan antara "melihat" dan "melompat".
Misalnya, kode, if key in mapping: return mapping[key] bisa gagal jika utas lain menghapus kunci dari pemetaan setelah pengujian,
tetapi sebelum pencarian. Masalah ini dapat diselesaikan dengan kunci atau dengan menggunakan pendekatan EAFP.
pengkodean lokal Di Unix, ini adalah pengkodean lokal LC_CTYPE. Itu dapat diatur dengan lokal.
setlocale(locale.LC_CTYPE, new_locale).
Di Windows, ini adalah halaman kode ANSI (mis: "cp1252").
Di Android dan VxWorks, Python menggunakan "utf-8" sebagai pengkodean lokal.
locale.getencoding() dapat digunakan untuk mendapatkan pengkodean lokal.
Lihat juga filesystem encoding dan error handler.
list Urutan Python bawaan. Terlepas dari namanya, ini lebih mirip dengan array dalam bahasa lain daripada daftar tertaut
karena akses ke elemen adalah O(1).
pemahaman daftar Cara ringkas untuk memproses semua atau sebagian elemen secara berurutan dan mengembalikan daftar beserta
hasilnya. result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] menghasilkan daftar string yang berisi angka hex genap
(0x..) dalam rentang dari 0 hingga 255. Klausa if bersifat opsional.
Jika dihilangkan, semua elemen dalam range(256) akan diproses.
loader Objek yang memuat modul. Itu harus mendefinisikan metode bernama load_module(). Loader biasanya dikembalikan oleh pencari.
Lihat PEP 302 untuk detail dan importlib.abc.Loader untuk kelas dasar abstrak.
metode sulap Sinonim informal untuk metode khusus.
pemetaan Objek wadah yang mendukung pencarian kunci sewenang-wenang dan mengimplementasikan metode yang ditentukan dalam
kelas dasar abstrak collections.abc.Mapping atau collections.abc.MutableMapping. Contohnya termasuk dict, collections.defaultdict,
collections.OrderedDict, dan collections.Counter.
meta path finder Seorang finder dikembalikan oleh pencarian sys.meta_path. Pencari jalur meta terkait dengan, tetapi berbeda dari pencari
entri jalur.
Lihat importlib.abc.MetaPathFinder untuk metode yang diterapkan pencari jalur meta.
metaclass Kelas dari sebuah kelas. Definisi kelas membuat nama kelas, kamus kelas, dan daftar kelas dasar.
Metaclass bertanggung jawab untuk mengambil ketiga argumen tersebut dan membuat kelas. Sebagian besar bahasa pemrograman
berorientasi objek menyediakan implementasi default. Apa yang membuat Python istimewa adalah memungkinkan untuk membuat
metaclass khusus. Sebagian besar pengguna tidak pernah membutuhkan alat ini, tetapi ketika diperlukan, metaclass dapat
memberikan solusi yang kuat dan elegan. Mereka telah digunakan untuk mencatat akses atribut, menambahkan keamanan utas,
melacak pembuatan objek, mengimplementasikan lajang, dan banyak tugas lainnya.
Informasi lebih lanjut dapat ditemukan di metaclasses.
metode Sebuah fungsi yang didefinisikan di dalam tubuh kelas. Jika dipanggil sebagai atribut dari instance kelas tersebut, metode akan
mendapatkan objek instance sebagai argumen pertamanya (biasanya disebut self). Lihat fungsi dan bersarang
cakupan.
urutan resolusi metode Urutan Resolusi Metode adalah urutan di mana kelas dasar dicari anggota selama pencarian. Lihat Urutan
Resolusi Metode Python 2.3 untuk detail algoritme yang digunakan oleh juru bahasa Python sejak rilis 2.3.

modul Objek yang berfungsi sebagai unit organisasi kode Python. Modul memiliki ruang nama yang berisi objek Python sewenang-
wenang. Modul dimuat ke dalam Python melalui proses pengimporan.
Lihat juga paket.
module spec Ruang nama yang berisi informasi terkait impor yang digunakan untuk memuat modul. Contoh importlib.machinery.ModuleSpec.
MRO Lihat urutan resolusi metode.
objek yang dapat diubah dapat mengubah nilainya tetapi tetap mempertahankan id(). Lihat juga abadi.
Named tuple Istilah "named tuple" berlaku untuk semua tipe atau kelas yang mewarisi dari tuple dan elemen yang dapat diindeks juga
dapat diakses menggunakan atribut bernama. Jenis atau kelas mungkin memiliki fitur lain juga.
Beberapa tipe bawaan diberi nama tupel, termasuk nilai yang dikembalikan oleh time.localtime() dan os. stat(). Contoh lain
adalah sys.float_info:
>>> sys.float_info[1] 1024 # akses terindeks
>>> sys.float_info.max_exp 1024 # bernama akses bidang
>>> isinstance(sys.float_info, tuple) # jenis tupel

BENAR
Beberapa tupel bernama adalah tipe bawaan (seperti contoh di atas). Alternatifnya, tuple bernama dapat dibuat dari definisi kelas
reguler yang mewarisi dari tuple dan yang mendefinisikan field bernama. Kelas seperti itu dapat ditulis dengan tangan atau dapat
dibuat dengan fungsi pabrik collections.namedtuple(). Teknik yang terakhir juga menambahkan beberapa metode tambahan
yang mungkin tidak ditemukan dalam tuple yang ditulis tangan atau bawaan.
namespace Tempat penyimpanan variabel. Ruang nama diimplementasikan sebagai kamus. Ada ruang nama lokal, global, dan bawaan
serta ruang nama bersarang dalam objek (dalam metode). Ruang nama mendukung modularitas dengan mencegah konflik
penamaan. Misalnya, fungsi builtins.open dan os.open() dibedakan berdasarkan ruang namanya. Ruang nama juga membantu
keterbacaan dan pemeliharaan dengan memperjelas modul mana yang mengimplementasikan suatu fungsi. Misalnya, menulis
random.seed() atau itertools.islice() memperjelas bahwa fungsi tersebut diimplementasikan oleh modul random dan itertools.
paket namespace A PEP 420 paket yang hanya berfungsi sebagai wadah untuk sub-paket. Paket namespace mungkin tidak memiliki
representasi fisik, dan khususnya tidak seperti paket biasa karena tidak memiliki file __init__.py.
Lihat juga modul.
lingkup bersarang Kemampuan untuk merujuk ke variabel dalam definisi terlampir. Misalnya, fungsi yang didefinisikan di dalam fungsi
lain dapat merujuk ke variabel di luar fungsi. Perhatikan bahwa cakupan bersarang secara default hanya berfungsi untuk referensi
dan bukan untuk penugasan. Variabel lokal membaca dan menulis dalam lingkup terdalam. Demikian juga, variabel global
membaca dan menulis ke namespace global. Nonlokal memungkinkan penulisan ke lingkup luar.
kelas gaya baru Nama lama untuk ragam kelas sekarang digunakan untuk semua objek kelas. Di versi Python sebelumnya, hanya
kelas gaya baru yang bisa menggunakan fitur Python yang lebih baru dan serbaguna seperti __slots__, deskriptor, properti,
__getattribute__(), metode kelas, dan metode statis.
objek Setiap data dengan status (atribut atau nilai) dan perilaku (metode) yang ditentukan. Juga kelas dasar pamungkas dari apa pun
kelas gaya baru.
package Modul Python yang dapat berisi submodul atau secara rekursif, subpaket. Secara teknis, sebuah paket adalah modul Python
dengan atribut __path__.
Lihat juga paket reguler dan paket namespace.
parameter Entitas bernama dalam definisi fungsi (atau metode) yang menentukan argumen (atau dalam beberapa kasus, argu
ments) bahwa fungsi dapat menerima. Ada lima macam parameter:
• positional-or-keyword: menentukan argumen yang dapat diberikan baik secara posisional maupun sebagai kata kunci argu
ment. Ini adalah jenis parameter default, misalnya foo dan bar berikut ini:
117
def func(foo, bar=Tidak ada): ...
• positional-only: menentukan argumen yang hanya dapat diberikan oleh posisi. Parameter hanya-posisi dapat didefinisikan
dengan menyertakan karakter / dalam daftar parameter dari definisi fungsi setelahnya, misalnya posonly1 dan posonly2
berikut ini:
def func(posonly1, posonly2, /, positional_or_keyword): ...
• hanya kata kunci: menentukan argumen yang hanya dapat disediakan oleh kata kunci. Parameter khusus kata kunci
dapat ditentukan dengan menyertakan parameter var-positional tunggal atau bare * dalam daftar parameter definisi
fungsi sebelumnya, misalnya kw_only1 dan kw_only2 berikut ini:
def func(arg, *, kw_only1, kw_only2): ...
• var-positional: menetapkan bahwa urutan arbitrer dari argumen posisi dapat disediakan (selain argumen posisi yang
sudah diterima oleh parameter lain). Parameter seperti itu dapat didefinisikan dengan menambahkan nama parameter
dengan *, misalnya args berikut ini:
def func(*args, **kwargs): ...
• var-keyword: menentukan bahwa banyak argumen kata kunci dapat disediakan secara acak (selain argumen kata kunci
yang sudah diterima oleh parameter lain). Parameter seperti itu dapat didefinisikan dengan menambahkan nama
parameter dengan **, misalnya kwargs pada contoh di atas.
Parameter dapat menentukan argumen opsional dan wajib, serta nilai default untuk beberapa argumen opsional.
Lihat juga entri glosarium argumen , pertanyaan FAQ tentang perbedaan antara argumen dan parameter, kelas
inspect.Parameter, bagian fungsi, dan PEP 362.
entri jalur Satu lokasi di jalur impor yang dikonsultasikan oleh pencari berbasis jalur untuk menemukan modul yang akan diimpor.
path entry finder Seorang finder yang dikembalikan oleh callable pada sys.path_hooks (yakni sebuah path entry hook) yang mengetahui caranya
untuk menemukan modul yang diberi entri jalur.
Lihat importlib.abc.PathEntryFinder untuk mengetahui metode yang diterapkan oleh pencari entri jalur.
path entry hook Sebuah callable pada daftar sys.path_hook yang mengembalikan pencari entri path jika mengetahui cara menemukan
modul pada entri jalur tertentu.
path based finder Salah satu pencari jalur meta default yang mencari jalur impor untuk modul.
objek seperti jalur Objek yang mewakili jalur sistem file. Objek seperti jalur adalah objek str atau byte yang mewakili jalur, atau objek
yang mengimplementasikan protokol os.PathLike. Objek yang mendukung os.
Protokol PathLike dapat dikonversi menjadi jalur sistem file str atau byte dengan memanggil fungsi os.fspath(); os.fsdecode()
dan os.fsencode() masing-masing dapat digunakan untuk menjamin hasil str atau byte. Diperkenalkan oleh PEP 519.
Proposal Peningkatan PEP Python. PEP adalah dokumen desain yang memberikan informasi kepada komunitas Python, atau
menjelaskan fitur baru untuk Python atau proses atau lingkungannya. PEP harus memberikan spesifikasi teknis yang ringkas
dan alasan untuk fitur yang diusulkan.
PEP dimaksudkan sebagai mekanisme utama untuk mengusulkan fitur baru yang besar, untuk mengumpulkan masukan
komunitas tentang suatu masalah, dan untuk mendokumentasikan keputusan desain yang telah masuk ke Python. Penulis PEP
bertanggung jawab untuk membangun konsensus dalam komunitas dan mendokumentasikan perbedaan pendapat.
Lihat PEP 1.
porsi Satu set file dalam satu direktori (mungkin disimpan dalam file zip) yang berkontribusi pada paket namespace, seperti
didefinisikan dalam PEP 420.
argumen posisi Lihat argumen.
API sementara API sementara adalah salah satu yang sengaja dikecualikan dari jaminan kompatibilitas perpustakaan standar.
Sementara perubahan besar pada antarmuka seperti itu tidak diharapkan, asalkan memang demikian

ditandai sementara, perubahan tidak kompatibel mundur (hingga dan termasuk penghapusan antarmuka) dapat terjadi jika dianggap
perlu oleh pengembang inti. Perubahan tersebut tidak akan dilakukan secara serampangan – perubahan tersebut hanya akan terjadi
jika kelemahan mendasar yang serius terungkap yang terlewatkan sebelum penyertaan API.
Bahkan untuk API sementara, perubahan yang tidak kompatibel ke belakang dipandang sebagai "solusi upaya terakhir" - setiap upaya
akan tetap dilakukan untuk menemukan resolusi yang kompatibel ke belakang untuk setiap masalah yang teridentifikasi.
Proses ini memungkinkan perpustakaan standar untuk terus berkembang dari waktu ke waktu, tanpa mengunci kesalahan desain
yang bermasalah untuk waktu yang lama. Lihat PEP 411 untuk lebih jelasnya.
paket sementara Lihat API sementara.
Julukan Python 3000 untuk baris rilis Python 3.x (diciptakan sejak lama ketika rilis versi 3 adalah sesuatu
di masa depan yang jauh.) Ini juga disingkat "Py3k".
Pythonic Sebuah ide atau potongan kode yang mengikuti idiom paling umum dari bahasa Python, daripada mengimplementasikan kode
menggunakan konsep yang umum untuk bahasa lain. Misalnya, idiom umum dalam Python adalah mengulang semua elemen
iterable menggunakan pernyataan for. Banyak bahasa lain yang tidak memiliki jenis konstruk ini, jadi orang yang tidak terbiasa
dengan Python terkadang menggunakan penghitung numerik sebagai gantinya:
untuk i dalam rentang(len(makanan)):

print(makanan[i])
Berbeda dengan metode bersih, Pythonic:
untuk sepotong dalam

makanan: print(piece)
nama yang memenuhi syarat Nama titik-titik yang menunjukkan "jalur" dari cakupan global modul ke kelas, fungsi, atau metode yang
ditentukan dalam modul tersebut, sebagaimana didefinisikan dalam PEP 3155. Untuk fungsi dan kelas tingkat atas, nama yang
memenuhi syarat sama dengan nama objek:
>>> kelas C:
... kelas D:
... def meth (diri sendiri):
... lulus
...
>>> C.__qualname__ 'C'
>>> CD__qualname__ 'CD'
>>> CDmeth.__qualname__ 'CDmeth'
Saat digunakan untuk merujuk ke modul, nama yang sepenuhnya memenuhi syarat berarti seluruh jalur bertitik ke modul, termasuk
paket induk apa pun, misalnya email.mime.text:
>>> impor email.mime.text >>>

email.mime.text.__name__ 'email.mime.text'
jumlah referensi Jumlah referensi ke objek. Ketika jumlah referensi suatu objek turun menjadi nol, itu tidak dialokasikan. Penghitungan
referensi umumnya tidak terlihat oleh kode Python, tetapi merupakan elemen kunci dari implementasi CPython . Pemrogram dapat
memanggil fungsi sys.getrefcount() untuk mengembalikan jumlah referensi untuk objek tertentu.
regular package Paket tradisional , seperti direktori yang berisi file __init__.py.
Lihat juga paket namespace.
__slots__ Deklarasi di dalam kelas yang menghemat memori dengan mendeklarasikan ruang terlebih dahulu untuk atribut instance dan
menghapus kamus instance. Meskipun populer, teknik ini agak rumit untuk dilakukan dengan benar dan paling baik digunakan untuk
kasus yang jarang terjadi di mana terdapat sejumlah besar instans dalam aplikasi kritis-memori.
119
sequence Sebuah iterable yang mendukung akses elemen efisien menggunakan indeks integer melalui metode khusus __getitem__() dan
mendefinisikan metode __len__() yang mengembalikan panjang urutan. Beberapa tipe urutan bawaan adalah list, str, tuple, dan byte.
Perhatikan bahwa dict juga mendukung __getitem__() dan __len __(), tetapi dianggap sebagai pemetaan daripada urutan karena
pencarian menggunakan kunci tetap yang sewenang-wenang daripada bilangan bulat.
Kelas dasar abstrak collections.abc.Sequence mendefinisikan antarmuka yang jauh lebih kaya yang lebih dari sekadar __getitem__()
dan __len__(), menambahkan count(), index(), __contains__(), dan __reversed__(). Tipe yang mengimplementasikan antarmuka yang
diperluas ini dapat didaftarkan secara eksplisit menggunakan register().
pemahaman set Cara ringkas untuk memproses semua atau sebagian elemen dalam iterable dan mengembalikan set dengan hasilnya. hasil
= {c for c in 'abracadabra' if c not in 'abc'} menghasilkan kumpulan string {'r', 'd'}. Lihat pemahaman.
single dispatch Suatu bentuk pengiriman fungsi generik yang implementasinya dipilih berdasarkan jenis a
argumen tunggal.
slice Sebuah objek biasanya berisi sebagian dari urutan. Sebuah irisan dibuat menggunakan notasi subskrip, [] dengan titik dua di antara
angka ketika beberapa diberikan, seperti dalam nama_variabel[1:3:5]. Notasi braket (sub skrip) menggunakan objek irisan secara
internal.
metode khusus Metode yang dipanggil secara implisit oleh Python untuk mengeksekusi operasi tertentu pada suatu tipe, seperti penjumlahan.
Metode tersebut memiliki nama yang diawali dan diakhiri dengan garis bawah ganda. Metode khusus didokumentasikan dalam nama
khusus.
statement Sebuah statement adalah bagian dari suite (“blok” kode). Pernyataan adalah salah satu ekspresi atau salah satu dari beberapa
konstruksi dengan kata kunci, seperti if, while atau for.
referensi kuat Dalam API C Python, referensi kuat adalah referensi ke objek yang menambah jumlah referensi objek saat dibuat dan
mengurangi jumlah referensi objek saat dihapus.
Fungsi Py_NewRef() dapat digunakan untuk membuat referensi yang kuat ke suatu objek. Biasanya, fungsi Py_DECREF() harus
dipanggil pada referensi kuat sebelum keluar dari cakupan referensi kuat, untuk menghindari bocornya satu referensi.
Lihat juga referensi pinjaman.
pengkodean teks Sebuah string dalam Python adalah urutan poin kode Unicode (dalam rentang U+0000–U+10FFFF). Untuk menyimpan
atau mentransfer string, perlu serial sebagai urutan byte.
Serialisasi string menjadi urutan byte dikenal sebagai "encoding", dan membuat ulang string dari urutan byte dikenal sebagai
"decoding".
Ada berbagai codec serialisasi teks yang berbeda, yang secara kolektif disebut sebagai "pengkodean teks".
file teks Objek file yang dapat membaca dan menulis objek str. Seringkali, file teks benar-benar mengakses aliran data berorientasi byte dan
menangani pengkodean teks secara otomatis. Contoh file teks adalah file yang dibuka dalam mode teks ('r' atau 'w'), sys.stdin,
sys.stdout, dan contoh io.StringIO.
Lihat juga file biner untuk objek file yang dapat membaca dan menulis objek seperti byte.
triple-quoted string Sebuah string yang terikat oleh tiga contoh baik tanda kutip ("") atau apostrof ('). Meskipun mereka tidak menyediakan
fungsionalitas apa pun yang tidak tersedia dengan string yang dikutip tunggal, mereka berguna karena beberapa alasan. Mereka
memungkinkan Anda untuk menyertakan tanda kutip tunggal dan ganda yang tidak lolos dalam sebuah string dan mereka dapat
merentang beberapa baris tanpa menggunakan karakter kelanjutan, membuatnya sangat berguna saat menulis dokumen.
type Jenis objek Python menentukan jenis objek apa itu; setiap objek memiliki tipe. Jenis objek adalah
dapat diakses sebagai atribut __class__ atau dapat diambil dengan type(obj).
type alias Sinonim untuk sebuah tipe, dibuat dengan menugaskan tipe tersebut ke sebuah identifier.
Alias tipe berguna untuk menyederhanakan petunjuk tipe. Sebagai contoh:

def hapus_gray_shades(
warna: daftar[tuple[int, int, int]]) -> daftar[tuple[int, int, int]]:
lulus
dapat dibuat lebih mudah dibaca seperti ini:
Warna = tupel[int, int, int]
def hapus_gray_shades(warna: daftar[Warna]) -> daftar[Warna]:

lulus
Lihat pengetikan dan PEP 484, yang menggambarkan fungsi ini.
type hint Sebuah anotasi yang menentukan tipe yang diharapkan untuk sebuah variabel, atribut kelas, atau parameter fungsi atau
mengembalikan nilai.
Petunjuk jenis bersifat opsional dan tidak diberlakukan oleh Python tetapi berguna untuk alat analisis jenis statis, dan membantu IDE
dengan penyelesaian kode dan pemfaktoran ulang.
Ketikkan petunjuk variabel global, atribut kelas, dan fungsi, tetapi bukan variabel lokal, dapat diakses menggunakan typing.get_type_hints().
Lihat pengetikan dan PEP 484, yang menggambarkan fungsi ini.
baris baru universal Cara menafsirkan aliran teks di mana semua hal berikut diakui sebagai akhir baris: konvensi akhir baris Unix '\n', konvensi
Windows '\r\n', dan konvensi lama Macintosh ' \r'. Lihat PEP 278 dan PEP 3116, serta bytes.splitlines() untuk penggunaan tambahan.
anotasi variabel Sebuah anotasi dari variabel atau atribut kelas.
Saat membubuhi keterangan variabel atau atribut kelas, penugasan bersifat opsional:
kelas C:
kolom: 'anotasi'
Anotasi variabel biasanya digunakan untuk petunjuk jenis: misalnya variabel ini diharapkan mengambil nilai int:
jumlah: int = 0
Sintaks anotasi variabel dijelaskan pada bagian annassign.
Lihat anotasi fungsi, PEP 484 dan PEP 526, yang menggambarkan fungsi ini. Lihat juga anotasi-cara untuk praktik terbaik bekerja dengan
anotasi.
lingkungan virtual Lingkungan runtime yang terisolasi secara kooperatif yang memungkinkan pengguna dan aplikasi Python untuk menginstal
dan memutakhirkan paket distribusi Python tanpa mengganggu perilaku aplikasi Python lain yang berjalan pada sistem yang sama.
Lihat juga venv.
mesin virtual Sebuah komputer didefinisikan sepenuhnya dalam perangkat lunak. Mesin virtual Python mengeksekusi bytecode yang dipancarkan
oleh kompiler bytecode.
Zen of Python Daftar prinsip dan filosofi desain Python yang membantu dalam memahami dan menggunakan bahasa. Daftar dapat ditemukan
dengan mengetik "import this" pada prompt interaktif.
121

LAMPIRAN
TENTANG DOKUMEN INI
Dokumen-dokumen ini dihasilkan dari reStructuredText sumber oleh Sphinx, pengolah dokumen yang khusus ditulis untuk
dokumentasi Python.
Pengembangan dokumentasi dan rantai alatnya sepenuhnya merupakan upaya sukarela, seperti halnya Python itu sendiri. Jika
Anda ingin berkontribusi, silakan lihat halaman pelaporan-bug untuk informasi tentang cara melakukannya. Relawan baru selalu
diterima!
Terima kasih banyak kepada:
• Fred L. Drake, Jr., pembuat kumpulan alat dokumentasi Python asli dan penulis sebagian besar kontennya;
• Dokumen proyek untuk membuat reStructuredText dan suite Docutils;
• Fredrik Lundh untuk proyek Referensi Python Alternatifnya yang darinya Sphinx mendapatkan banyak ide bagus.
B.1 Kontributor Dokumentasi Python

Banyak orang telah berkontribusi pada bahasa Python, pustaka standar Python, dan dokumentasi Python.
Lihat Lain-Lain/ACKS dalam distribusi sumber Python untuk sebagian daftar kontributor.
Hanya dengan masukan dan kontribusi dari komunitas Python, Python memiliki dokumentasi yang luar biasa – Terima Kasih!
123
124 Lampiran B. Tentang dokumen-dokumen ini

LAMPIRAN
SEJARAH DAN LISENSI
C.1 Sejarah perangkat lunak

Python dibuat pada awal 1990-an oleh Guido van Rossum di Stichting Mathematisch Centrum (CWI, lihat https: //www.cwi.nl/) di Belanda
sebagai penerus bahasa yang disebut ABC. Guido tetap menjadi penulis utama Python, meskipun menyertakan banyak kontribusi dari
orang lain.
Pada tahun 1995, Guido melanjutkan pekerjaannya tentang Python di Corporation for National Research Initiatives (CNRI, lihat https://
www.cnri.reston.va.us/ ) di Reston, Virginia di mana dia merilis beberapa versi perangkat lunak.
Pada Mei 2000, Guido dan tim pengembangan inti Python pindah ke BeOpen.com untuk membentuk tim BeOpen Python Labs. Pada
bulan Oktober tahun yang sama, tim PythonLabs pindah ke Digital Creations (sekarang Zope Corporation; lihat https://www.zope.org/).
Pada tahun 2001, Python Software Foundation (PSF, lihat https://www.python.org/psf/) dibentuk, sebuah organisasi nirlaba yang dibuat
khusus untuk memiliki Kekayaan Intelektual terkait Python. Zope Corporation adalah anggota sponsor PSF.
Semua rilis Python adalah Open Source (lihat https://opensource.org/ untuk Definisi Open Source). Secara historis, sebagian besar, tetapi
tidak semua, rilis Python juga kompatibel dengan GPL; tabel di bawah merangkum berbagai rilis.
Melepaskan Berasal dari Tahun Pemilik GPL kompatibel?

0.9.0 hingga 1.2 n/a 1.3 1991-1995 CWI ya
hingga 1.5.2 1.2 1.6 1995-1999 CNRI 2000 ya
1.5.2 CNRI Tidak
2.0 1.6 2000 BeOpen.com no CNRI

1.6.1 1.6 2001 PSF Tidak
2.1 2.0+1.6.1 2001 Tidak
2.0.1 2.0+1.6.1 2001 PSF ya

2.1.1 2.1+2.0.1 2001 PSF ya
2.1.2 2.1.1 2002 PSF ya
2.1.3 2.1.2 2.2 dan di 2002 PSF ya
atasnya 2.1.1 2001-sekarang PSF ya
Catatan: Kompatibel dengan GPL tidak berarti bahwa kami mendistribusikan Python di bawah GPL. Semua lisensi Python, tidak seperti
GPL, memungkinkan Anda mendistribusikan versi modifikasi tanpa membuat perubahan menjadi open source. Lisensi yang kompatibel
dengan GPL memungkinkan untuk menggabungkan Python dengan perangkat lunak lain yang dirilis di bawah GPL; yang lain tidak.
Terima kasih kepada banyak sukarelawan luar yang telah bekerja di bawah arahan Guido untuk memungkinkan rilis ini.
125
C.2 Syarat dan ketentuan untuk mengakses atau menggunakan

Piton
Perangkat lunak dan dokumentasi Python dilisensikan berdasarkan Perjanjian Lisensi PSF.
Dimulai dengan Python 3.8.6, contoh, resep, dan kode lain dalam dokumentasi memiliki lisensi ganda di bawah Perjanjian Lisensi PSF dan lisensi
Zero-Clause BSD.
Beberapa perangkat lunak yang dimasukkan ke dalam Python berada di bawah lisensi yang berbeda. Lisensi terdaftar dengan kode
yang berada di bawah lisensi itu. Lihat Lisensi dan Pengakuan untuk Incorporated Software untuk daftar lisensi yang tidak lengkap.
C.2.1 PERJANJIAN LISENSI PSF UNTUK PYTHON 3.11.1
1. PERJANJIAN LISENSI ini antara Python Software Foundationÿ ÿ("PSF"), dan
Individu atau Organisasi ("Penerima Lisensi") mengakses dan sebaliknyaÿ

ÿmenggunakan Python
3.11.1 perangkat lunak dalam bentuk sumber atau biner dan yang terkaitÿ
ÿ dokumentasi.
2. Tunduk pada syarat dan ketentuan Perjanjian Lisensi ini, PSFÿ

ÿdengan ini
memberikan Lisensi lisensi non-eksklusif, bebas royalti, di seluruh dunia untukÿ ÿmereproduksi, menganalisis, menguji, melakukan
dan/atau menampilkan kepada publik, menyiapkan turunanÿ ÿkarya,
mendistribusikan, dan jika tidak menggunakan Python 3.11.1 sendiri atau dalam versi turunan apa pun, bagaimanapun, dengan
ketentuan bahwa Perjanjian Lisensi PSF dan ÿpemberitahuan PSF tentang
hak cipta, yaitu, "Hak Cipta © 2001-2023 Python Software Foundation; Allÿ ÿHak Dilindungi" dipertahankan dalam Python 3.11.1 sendiri
atau turunanÿ ÿversi yang disiapkan oleh Penerima Lisensi.
3. Dalam hal Penerima Lisensi menyiapkan karya turunan yang didasarkan pada atau
menggabungkan Python 3.11.1 atau bagian apa pun darinya, dan ingin membuat karya turunannya tersedia untuk orang lain
sebagaimana disediakan di sini, maka Penerima Lisensiÿ ÿ dengan ini setuju untuk memasukkan ke dalam karya semacam itu ringkasan
singkat dari perubahan yang dibuatÿ ÿke Python 3.11.1 .
4. PSF membuat Python 3.11.1 tersedia untuk Penerima Lisensi berdasarkan "SEBAGAIMANA ADANYA".
PSF TIDAK MEMBUAT PERNYATAAN ATAU JAMINAN, TERSURAT MAUPUN TERSIRAT. DENGAN CARAÿ ÿOF
CONTOH, TAPI BUKAN PEMBATASAN, PSF TIDAK MEMBUAT DAN MENYANGKAL APAPUNÿ
ÿ REPRESENTASI ATAU
JAMINAN DAPAT DIPERDAGANGKAN ATAU KESESUAIAN UNTUK TUJUAN TERTENTU APAPUN ATAUÿ
ÿ ITU
PENGGUNAAN PYTHON 3.11.1 TIDAK AKAN MELANGGAR HAK PIHAK KETIGA.
5. PSF TIDAK BERTANGGUNG JAWAB KEPADA PENERIMA LISENSI ATAU PENGGUNA PYTHON 3.11.1 LAINNYA
UNTUK KERUSAKAN ATAU KERUGIAN INSIDENTAL, KHUSUS, ATAU KONSEKUENSIAL SEBAGAI Aÿ
ÿ HASIL DARI
MEMODIFIKASI, MENDISTRIBUSIKAN, ATAU MENGGUNAKAN PYTHON 3.11.1, ATAU APAPUNÿ

ÿDERIVATIF
126 Lampiran C. Sejarah dan Lisensi

OLEH ITU, BAHKAN JIKA DIBERITAHU TENTANG KEMUNGKINANNYA.
6. Perjanjian Lisensi ini akan berakhir secara otomatis pada suatu materiÿ
ÿpelanggaran
syarat dan ketentuannya.
7. Tidak ada dalam Perjanjian Lisensi ini yang dianggap menciptakanÿ ÿhubungan apa pun
keagenan, kemitraan, atau usaha patungan antara PSF dan Penerima Lisensi. ÿ
ÿ Lisensi ini
Perjanjian tidak memberikan izin untuk menggunakan merek dagang atau nama dagang PSFÿ ÿdi a
rasa merek dagang untuk mendukung atau mempromosikan produk atau layanan Penerima Lisensi,ÿ
ÿatau pihak
ketiga mana pun.
8. Dengan menyalin, menginstal, atau menggunakan Python 3.11.1, Penerima Lisensi setuju untuk terikat dengan syarat
dan ketentuan Perjanjian Lisensi ini.
C.2.2 PERJANJIAN LISENSI BEOPEN.COM UNTUK PYTHON 2.0
PERJANJIAN LISENSI SUMBER TERBUKA BEOPEN PYTHON VERSI 1
1. PERJANJIAN LISENSI ini antara BeOpen.com ("BeOpen"), berkantor di

160 Saratoga Avenue, Santa Clara, CA 95051, dan Individu atau Organisasi ("Penerima Lisensi") yang mengakses dan menggunakan perangkat lunak
ini dalam bentuk sumber atau biner dan dokumentasi terkait ("Perangkat Lunak").
2. Tunduk pada syarat dan ketentuan Perjanjian Lisensi BeOpen Python ini,
BeOpen dengan ini memberi Lisensi lisensi non-eksklusif, bebas royalti, di seluruh dunia untuk mereproduksi, menganalisis, menguji, melakukan dan/
atau menampilkan secara publik, menyiapkan karya turunan, mendistribusikan, dan sebaliknya menggunakan Perangkat Lunak sendiri atau dalam versi
turunan apa pun, asalkan , bagaimanapun, Lisensi BeOpen Python dipertahankan dalam Perangkat Lunak, sendiri atau dalam versi turunan yang disiapkan
oleh Penerima Lisensi.
3. BeOpen membuat Perangkat Lunak tersedia untuk Penerima Lisensi berdasarkan "SEBAGAIMANA ADANYA".
BEOPEN TIDAK MEMBUAT PERNYATAAN ATAU JAMINAN, TERSURAT MAUPUN TERSIRAT. SEBAGAI CONTOH, NAMUN BUKAN
PEMBATASAN, BEOPEN TIDAK MEMBUAT DAN MENYANGKAL PERNYATAAN ATAU JAMINAN KELAYAKAN DIPERDAGANGKAN ATAU KESESUAIAN
UNTUK TUJUAN TERTENTU APAPUN ATAU YANG
PENGGUNAAN PERANGKAT LUNAK TIDAK AKAN MELANGGAR HAK PIHAK KETIGA.
4. BEOPEN TIDAK BERTANGGUNG JAWAB KEPADA PENERIMA LISENSI ATAU PENGGUNA PERANGKAT LUNAK LAINNYA UNTUK
KERUSAKAN ATAU KEHILANGAN INSIDENTAL, KHUSUS, ATAU KONSEKUENSIAL SEBAGAI AKIBAT PENGGUNAAN,
MEMODIFIKASI ATAU MENDISTRIBUSIKAN PERANGKAT LUNAK, ATAU TURUNAN DARINYA, MESKIPUN
DIBERITAHU TENTANG KEMUNGKINANNYA.
5. Perjanjian Lisensi ini akan berakhir secara otomatis jika terjadi pelanggaran material terhadap
6. Perjanjian Lisensi ini akan diatur oleh dan ditafsirkan dalam segala hal oleh hukum Negara Bagian California, tidak termasuk pertentangan ketentuan
hukum.
Tidak ada dalam Perjanjian Lisensi ini yang dianggap menciptakan hubungan keagenan, kemitraan, atau usaha patungan antara BeOpen dan Penerima
Lisensi. Perjanjian Lisensi ini tidak memberikan izin untuk menggunakan merek dagang atau nama dagang BeOpen dalam pengertian merek dagang untuk
mendukung atau mempromosikan produk atau layanan Penerima Lisensi, atau pihak ketiga mana pun. Sebagai pengecualian, logo "BeOpen Python" yang
tersedia di http://www.pythonlabs.com/logos.html dapat digunakan sesuai dengan izin yang diberikan pada halaman web tersebut.
C.2. Syarat dan ketentuan untuk mengakses atau menggunakan Python 127
7. Dengan menyalin, menginstal, atau menggunakan perangkat lunak, Penerima Lisensi menyetujuinya
terikat oleh syarat dan ketentuan Perjanjian Lisensi ini.
C.2.3 PERJANJIAN LISENSI CNRI UNTUK PYTHON 1.6.1
1. PERJANJIAN LISENSI ini antara Korporasi Riset Nasional

Inisiatif, berkantor di 1895 Preston White Drive, Reston, VA 20191 ("CNRI"), dan Individu atau Organisasi ("Penerima Lisensi") yang mengakses
dan menggunakan perangkat lunak Python 1.6.1 dalam bentuk sumber atau biner dan dokumentasi terkaitnya.
2. Tunduk pada syarat dan ketentuan Perjanjian Lisensi ini, CNRI dengan ini
memberi Penerima Lisensi lisensi noneksklusif, bebas royalti, di seluruh dunia untuk mereproduksi, menganalisis, menguji, melakukan dan/atau
menampilkan secara publik, menyiapkan karya turunan, mendistribusikan, dan sebaliknya menggunakan Python 1.6.1 sendiri atau dalam versi turunan
apa pun, asalkan, bagaimanapun , bahwa Perjanjian Lisensi CNRI dan pemberitahuan hak cipta CNRI, yaitu, "Hak Cipta © 1995-2001 Corporation for
National Research Initiatives; All Rights Reserved" dipertahankan dalam Python 1.6.1 saja atau dalam versi turunan yang disiapkan oleh Penerima Lisensi.
Sebagai alternatif, sebagai pengganti Perjanjian Lisensi CNRI, Penerima Lisensi dapat mengganti teks berikut (menghilangkan tanda kutip): "Python 1.6.1
tersedia dengan tunduk pada syarat dan ketentuan dalam Perjanjian Lisensi CNRI. Perjanjian ini bersama dengan Python 1.6.1 dapat terletak di internet
menggunakan pengidentifikasi unik dan persisten berikut (dikenal sebagai pegangan): 1895.22/1013. Perjanjian ini juga dapat diperoleh dari server proxy
di internet menggunakan URL berikut: http://hdl.handle.net/ 1895.22/1013."
3. Dalam hal Penerima Lisensi menyiapkan karya turunan yang didasarkan pada atau
menggabungkan Python 1.6.1 atau bagian apa pun darinya, dan ingin membuat karya turunannya tersedia untuk orang lain sebagaimana disediakan di
sini, maka Penerima Lisensi dengan ini setuju untuk menyertakan ringkasan singkat tentang perubahan yang dibuat pada Python 1.6.1 dalam karya
tersebut.
4. CNRI membuat Python 1.6.1 tersedia untuk Penerima Lisensi berdasarkan "SEBAGAIMANA ADANYA". CNRI
TIDAK MEMBUAT PERNYATAAN ATAU JAMINAN, TERSURAT MAUPUN TERSIRAT. SEBAGAI CONTOH, NAMUN BUKAN
PEMBATASAN, CNRI TIDAK MEMBUAT DAN MENYANGKAL PERNYATAAN ATAU JAMINAN KELAYAKAN DIPERDAGANGKAN
ATAU KESESUAIAN UNTUK TUJUAN TERTENTU APAPUN ATAU PENGGUNAAN
PYTHON 1.6.1 TIDAK AKAN MELANGGAR HAK PIHAK KETIGA.
5. CNRI TIDAK BERTANGGUNG JAWAB KEPADA PENERIMA LISENSI ATAU PENGGUNA PYTHON 1.6.1 LAINNYA UNTUK
KERUGIAN ATAU KERUGIAN INSIDENTAL, KHUSUS, ATAU KONSEKUENSIAL SEBAGAI HASIL DARI
MODIFIKASI, DISTRIBUSI, ATAU LAINNYA MENGGUNAKAN PYTHON 1.6.1, ATAU DERIVATIF APA PUN
DARINYA, BAHKAN JIKA DIBERITAHU TENTANG KEMUNGKINANNYA.
6. Perjanjian Lisensi ini akan berakhir secara otomatis jika terjadi pelanggaran material terhadap
7. Perjanjian Lisensi ini diatur oleh undang-undang kekayaan intelektual federal Amerika Serikat, termasuk namun tidak terbatas pada undang-undang hak
cipta federal, dan, sejauh undang-undang federal AS tersebut tidak berlaku, oleh undang-undang Persemakmuran Virginia, tidak termasuk Konflik
ketentuan hukum Virginia.
Sekalipun demikian, sehubungan dengan karya turunan berdasarkan Python 1.6.1 yang menggabungkan materi yang tidak dapat dipisahkan yang
sebelumnya didistribusikan di bawah Lisensi Publik Umum GNU (GPL), hukum Persemakmuran Virginia akan mengatur Perjanjian Lisensi ini hanya
untuk masalah yang timbul berdasarkan atau sehubungan dengan Paragraf 4, 5, dan 7 Perjanjian Lisensi ini. Tidak ada dalam Perjanjian Lisensi ini
yang dianggap menciptakan hubungan keagenan, kemitraan, atau usaha patungan antara CNRI dan Penerima Lisensi. Perjanjian Lisensi ini tidak
memberikan izin untuk menggunakan merek dagang atau nama dagang CNRI dalam pengertian merek dagang untuk mendukung atau mempromosikan
produk atau layanan Penerima Lisensi, atau pihak ketiga mana pun.

8. Dengan mengeklik tombol "TERIMA" jika ditunjukkan, atau dengan menyalin, menginstal, atau menggunakan Python 1.6.1, Penerima
Lisensi setuju untuk terikat dengan syarat dan ketentuan Perjanjian Lisensi ini.
C.2.4 PERJANJIAN LISENSI CWI UNTUK PYTHON 0.9.0 SAMPAI 1.2
Hak Cipta © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, Belanda. Seluruh hak cipta.
Izin untuk menggunakan, menyalin, memodifikasi, dan mendistribusikan perangkat lunak ini dan dokumentasinya
untuk tujuan apa pun dan tanpa biaya dengan ini diberikan, asalkan pemberitahuan hak cipta di atas muncul di semua salinan dan
bahwa pemberitahuan hak cipta dan pemberitahuan izin ini muncul di dokumentasi pendukung, dan bahwa nama Stichting
Mathematisch Centrum atau CWI tidak boleh digunakan dalam iklan atau publisitas yang berkaitan dengan pendistribusian perangkat
lunak tanpa izin khusus dan tertulis sebelumnya.
STICHTING MATHEMATISCH CENTRUM MENYANGKAL SEMUA JAMINAN TERKAIT DENGAN INI

PERANGKAT LUNAK, TERMASUK SEMUA JAMINAN TERSIRAT ATAS DAGANG DAN KESESUAIAN, DALAM NO
EVENT AKAN STICHTING MATHEMATISCH CENTRUM BERTANGGUNG JAWAB KHUSUS, TIDAK LANGSUNG
ATAU KERUSAKAN KONSEKUENSIAL ATAU KERUSAKAN APA PUN AKIBAT DARI KEHILANGAN PENGGUNAAN,
DATA ATAU KEUNTUNGAN, BAIK DALAM TINDAKAN KONTRAK, KELALAIAN ATAU KEKURANGAN LAINNYA
TINDAKAN, YANG TIMBUL DARI ATAU SEHUBUNGAN DENGAN PENGGUNAAN ATAU KINERJA INI
PERANGKAT LUNAK.
C.2.5 LISENSI ZERO-CLAUSE BSD UNTUK KODE DALAM PYTHON 3.11.1

DOKUMENTASI
Izin untuk menggunakan, menyalin, memodifikasi, dan/atau mendistribusikan perangkat lunak ini untuk tujuan apa pun
dengan atau tanpa biaya diberikan dengan ini.
PERANGKAT LUNAK DIBERIKAN "SEBAGAIMANA ADANYA" DAN PENULIS MENYANGKAL SEMUA JAMINAN DENGAN
SEHUBUNGAN DENGAN PERANGKAT LUNAK INI TERMASUK SEMUA JAMINAN TERSIRAT UNTUK DAPAT DIPERDAGANGKAN
DAN KEBUGARAN. DALAM KEADAAN APA PUN PENULIS TIDAK BERTANGGUNG JAWAB ATAS KERUGIAN KHUSUS,
LANGSUNG, TIDAK LANGSUNG, ATAU KONSEKUENSIAL ATAU KERUGIAN APA PUN AKIBAT DARI KEHILANGAN
PENGGUNAAN, DATA ATAU KEUNTUNGAN, BAIK DALAM TINDAKAN KONTRAK, KELALAIAN ATAU TINDAKAN KEKURANGAN
LAINNYA, YANG TIMBUL DARI ATAU SEHUBUNGAN DENGAN PENGGUNAAN ATAU KINERJA PERANGKAT LUNAK INI.
C.2. Syarat dan ketentuan untuk mengakses atau menggunakan Python 129
C.3 Lisensi dan Pengakuan untuk Incorporated Software
Bagian ini adalah daftar lisensi dan pengakuan yang tidak lengkap, tetapi berkembang untuk perangkat lunak pihak ketiga yang
tergabung dalam distribusi Python.
C.3.1 Mersenne Twister
Modul _random menyertakan kode berdasarkan unduhan dari http://www.math.sci.hiroshima-u.ac.jp/~m-

mat/ MT/MT2002/emt19937ar.html. Berikut ini adalah komentar verbatim dari kode asli:
Sebuah program-C untuk MT19937, dengan inisialisasi ditingkatkan 26/1/2002.

Dikodekan oleh Takuji Nishimura dan Makoto Matsumoto.
Sebelum menggunakan, inisialisasi status dengan menggunakan init_genrand(seed) atau

init_by_array(init_key, key_length).
Hak cipta (C) 1997 - 2002, Makoto Matsumoto dan Takuji Nishimura, Semua hak dilindungi undang-undang.
Redistribusi dan penggunaan dalam bentuk sumber dan biner, dengan atau tanpa modifikasi, diizinkan asalkan
kondisi berikut terpenuhi:
1. Redistribusi kode sumber harus mempertahankan pemberitahuan hak cipta di atas, daftar ketentuan ini, dan
penafian berikut.
2. Redistribusi dalam bentuk biner harus mereproduksi hak cipta di atas

pemberitahuan, daftar ketentuan ini dan penafian berikut dalam dokumentasi dan/atau materi lain yang disertakan
dengan distribusi.
3. Nama kontributornya tidak boleh digunakan untuk mendukung atau mempromosikan produk turunan dari perangkat
lunak ini tanpa izin tertulis khusus sebelumnya.
PERANGKAT LUNAK INI DISEDIAKAN OLEH PEMEGANG HAK CIPTA DAN KONTRIBUTOR
"SEBAGAIMANA ADANYA" DAN JAMINAN TERSURAT MAUPUN TERSIRAT, TERMASUK, NAMUN TIDAK
TERBATAS PADA, JAMINAN TERSIRAT TENTANG DAGANG DAN KESESUAIAN UNTUK TUJUAN TERTENTU
DITOLAK. DALAM HAL APAPUN PEMILIK HAK CIPTA ATAU
KONTRIBUTOR BERTANGGUNG JAWAB ATAS SETIAP HAL LANGSUNG, TIDAK LANGSUNG, INSIDENTAL, KHUSUS,
CONTOH, ATAU KERUSAKAN KONSEKUENSIAL (TERMASUK, NAMUN TIDAK TERBATAS PADA,
PENGADAAN BARANG ATAU JASA PENGGANTI; HILANGNYA PENGGUNAAN, DATA, ATAU
KEUNTUNGAN; ATAU GANGGUAN BISNIS) NAMUN PENYEBABNYA DAN PADA TEORI APAPUN
TANGGUNG JAWAB, BAIK DALAM KONTRAK, TANGGUNG JAWAB KETAT, ATAU KERUGIAN (TERMASUK
KELALAIAN ATAU LAINNYA) YANG TIMBUL DENGAN CARA APAPUN DARI PENGGUNAAN INI
PERANGKAT LUNAK, MESKIPUN DIBERITAHU TENTANG KEMUNGKINAN KERUSAKAN TERSEBUT.
Umpan balik apa pun sangat diterima. http://

www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html email: m-mat @ math.sci.hiroshima-u.ac.jp
(hapus spasi)

C.3.2 Soket
Modul soket menggunakan fungsi, getaddrinfo(), dan getnameinfo(), yang dikodekan dalam file sumber
terpisah dari WIDE Project, https://www.wide.ad.jp/.
Hak Cipta (C) 1995, 1996, 1997, dan 1998 WIDE Project.
Seluruh hak cipta.
Redistribusi dan penggunaan dalam bentuk sumber dan biner, dengan atau tanpa modifikasi, diizinkan dengan
ketentuan sebagai berikut
bertemu:
penafian berikut.
dengan distribusi.
3. Baik nama proyek maupun nama kontributornya
dapat digunakan untuk mendukung atau mempromosikan produk turunan dari perangkat lunak ini tanpa izin tertulis
khusus sebelumnya.
PERANGKAT LUNAK INI DISEDIAKAN OLEH PROYEK DAN KONTRIBUTOR ``SEBAGAIMANA ADANYA'' DAN
JAMINAN TERSURAT MAUPUN TERSIRAT, TERMASUK, NAMUN TIDAK TERBATAS PADA,
JAMINAN TERSIRAT TENTANG DAGANG DAN KESESUAIAN UNTUK TUJUAN TERTENTU
DITOLAK. DALAM HAL APAPUN PROYEK ATAU KONTRIBUTOR TIDAK BERTANGGUNG JAWAB
UNTUK KERUGIAN LANGSUNG, TIDAK LANGSUNG, INSIDENTAL, KHUSUS, CONTOH, ATAU KONSEKUENSIAL
(TERMASUK, NAMUN TIDAK TERBATAS PADA, PENGADAAN BARANG ATAU LAYANAN PENGGANTI; KEHILANGAN
PENGGUNAAN, DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS)
NAMUN PENYEBAB DAN TEORI TANGGUNG JAWAB APA PUN, BAIK DALAM KONTRAK, TANGGUNG JAWAB KETAT,
ATAU KERUGIAN (TERMASUK KELALAIAN ATAU LAINNYA) YANG TIMBUL DALAM CARA APAPUN DARI PENGGUNAAN
PERANGKAT LUNAK INI, BAHKAN JIKA DIBERITAHU TENTANG KEMUNGKINAN KERUSAKAN TERSEBUT.
C.3.3 Layanan soket asinkron
Modul asyncchat dan asynccore berisi pemberitahuan berikut:

Hak Cipta 1996 oleh Sam Rushing
Seluruh hak cipta
untuk tujuan apa pun dan tanpa biaya dengan ini diberikan, asalkan pemberitahuan hak cipta di atas muncul
di semua salinan dan bahwa pemberitahuan hak cipta dan pemberitahuan izin ini muncul di dokumentasi
pendukung, dan bahwa nama Sam Rushing tidak boleh digunakan dalam iklan atau publisitas yang berkaitan
dengan pendistribusian perangkat lunak tanpa izin khusus dan tertulis sebelumnya.
SAM RUSHING MENYANGKAL SEMUA GARANSI TERKAIT PERANGKAT LUNAK INI,

TERMASUK SEMUA JAMINAN TERSIRAT TENTANG DAGANG DAN KESESUAIAN, IN
TIDAK ADA KEJADIAN SAM RUSHING YANG BERTANGGUNG JAWAB ATAS KHUSUS, TIDAK LANGSUNG ATAU
KERUSAKAN KONSEKUENSIAL ATAU KERUGIAN APAPUN AKIBAT KERUGIAN
PENGGUNAAN, DATA, ATAU KEUNTUNGAN, BAIK DALAM TINDAKAN KONTRAK, KELALAIAN
ATAU TINDAKAN SAKIT LAINNYA, YANG TIMBUL DARI ATAU SEHUBUNGAN DENGAN
PENGGUNAAN ATAU KINERJA PERANGKAT LUNAK INI.
C.3. Lisensi dan Pengakuan untuk Incorporated Software 131

C.3.4 Manajemen cookie

Modul http.cookies berisi pemberitahuan berikut:
Hak Cipta 2000 oleh Timothy O'Malley <timo@alum.mit.edu>
Seluruh hak cipta
Izin untuk menggunakan, menyalin, memodifikasi, dan mendistribusikan perangkat lunak ini dan dokumentasinya untuk
tujuan apa pun dan tanpa biaya dengan ini diberikan, asalkan pemberitahuan hak cipta di atas muncul di semua salinan dan
bahwa pemberitahuan hak cipta dan pemberitahuan izin ini muncul di dokumentasi pendukung, dan bahwa nama Timothy
O'Malley tidak boleh digunakan dalam iklan atau publisitas yang berkaitan dengan pendistribusian perangkat lunak tanpa izin
khusus dan tertulis sebelumnya.
Timothy O'Malley MENYANGKAL SEMUA JAMINAN TERKAIT DENGAN PERANGKAT LUNAK INI, TERMASUK SEMUA
JAMINAN TERSIRAT ATAS KELAYAKAN DAGANG DAN KESESUAIAN, DALAM HAL APAPUN Timothy O'Malley
TIDAK BERTANGGUNG JAWAB ATAS KERUGIAN KHUSUS, TIDAK LANGSUNG ATAU KONSEKUENSIAL ATAU
KERUGIAN APAPUN AKIBAT DARI KEHILANGAN PENGGUNAAN, DATA ATAU KEUNTUNGAN, BAIK DALAM
TINDAKAN KONTRAK, KELALAIAN ATAU TINDAKAN SAKIT LAINNYA, YANG TIMBUL DARI ATAU SEHUBUNGAN
DENGAN PENGGUNAAN ATAU KINERJA PERANGKAT LUNAK INI.
C.3.5 Pelacakan eksekusi

Modul pelacakan berisi pemberitahuan berikut:
porsi hak cipta 2001, Autonomous Zones Industries, Inc., semua hak... err... dilindungi undang-undang dan ditawarkan kepada publik di bawah
ketentuan lisensi Python 2.2.
Pengarang: Zooko O'Whielacronx
http://zooko.com/
mailto:zooko@zooko.com
Hak Cipta 2000, Mojam Media, Inc., semua hak dilindungi undang-undang.
Pengarang: Lewati Montanaro
Hak Cipta 1999, Bioreason, Inc., semua hak dilindungi undang-undang.

Pengarang: Andrew Dalke
Hak cipta 1995-1997, Automatrix, Inc., semua hak dilindungi undang-undang.

Pengarang: Lewati Montanaro
Hak cipta 1991-1995, Stichting Mathematisch Centrum, semua hak dilindungi undang-undang.
Izin untuk menggunakan, menyalin, memodifikasi, dan mendistribusikan perangkat lunak Python ini dan dokumentasi terkaitnya untuk tujuan
apa pun tanpa biaya dengan ini diberikan, asalkan pemberitahuan hak cipta di atas muncul di semua salinan, dan bahwa pemberitahuan hak
cipta dan pemberitahuan izin ini muncul di pendukung dokumentasi, dan bahwa nama Automatrix, Bioreason atau Mojam Media tidak boleh
digunakan dalam iklan atau publisitas yang berkaitan dengan distribusi perangkat lunak tanpa izin khusus tertulis sebelumnya.

C.3.6 Fungsi UUencode dan UUdecode
Modul uu berisi pemberitahuan berikut:
Hak Cipta 1994 oleh Lance Ellinghouse Cathedral City,

Republik California, Amerika Serikat.
Seluruh hak cipta
untuk tujuan apa pun dan tanpa biaya dengan ini diberikan, asalkan pemberitahuan hak cipta di atas muncul di semua
salinan dan bahwa pemberitahuan hak cipta dan pemberitahuan izin ini muncul di dokumentasi pendukung, dan bahwa
nama Lance Ellinghouse tidak boleh digunakan dalam iklan atau publisitas yang berkaitan dengan pendistribusian
perangkat lunak tanpa izin khusus dan tertulis sebelumnya.
LANCE ELLINGHOUSE MENYANGKAL SEMUA GARANSI TERKAIT DENGAN

PERANGKAT LUNAK INI, TERMASUK SEMUA JAMINAN TERSIRAT ATAS DAGANG DAN
KESESUAIAN, DALAM HAL APAPUN, LANCE ELLINGHOUSE CENTRUM TIDAK BERTANGGUNG
JAWAB ATAS KERUGIAN KHUSUS, TIDAK LANGSUNG ATAU KONSEKUENSIAL ATAU KERUGIAN
APA PUN YANG AKIBAT DARI KEHILANGAN PENGGUNAAN, DATA ATAU KEUNTUNGAN, BAIK DALAM
TINDAKAN KONTRAK, KELALAIAN ATAU TINDAKAN SAKIT LAINNYA, YANG TIMBUL DARI ATAU
SEHUBUNGAN DENGAN PENGGUNAAN ATAU KINERJA PERANGKAT LUNAK INI.
Dimodifikasi oleh Jack Jansen, CWI, Juli 1995:

- Gunakan modul binascii untuk melakukan konversi baris demi baris yang sebenarnya
antara ascii dan biner. Ini menghasilkan percepatan 1000 kali lipat. Versi C masih 5 kali lebih cepat.
- Argumen lebih sesuai dengan standar Python
C.3.7 Panggilan Prosedur Jarak Jauh XML
Modul xmlrpc.client berisi pemberitahuan berikut:

Antarmuka klien XML-RPC adalah
Hak Cipta (c) 1999-2002 oleh Secret Labs AB

Hak cipta (c) 1999-2002 oleh Fredrik Lundh
Dengan memperoleh, menggunakan, dan/atau menyalin perangkat lunak ini dan/atau dokumentasi
terkaitnya, Anda setuju bahwa Anda telah membaca, memahami, dan akan mematuhi syarat dan ketentuan
berikut:
Izin untuk menggunakan, menyalin, memodifikasi, dan mendistribusikan perangkat lunak ini dan dokumentasi
terkaitnya untuk tujuan apa pun dan tanpa biaya dengan ini diberikan, asalkan pemberitahuan hak cipta di atas
muncul di semua salinan, dan bahwa pemberitahuan hak cipta dan pemberitahuan izin ini muncul di pendukung
dokumentasi, dan bahwa nama Secret Labs AB atau penulisnya tidak boleh digunakan dalam iklan atau publisitas
yang berkaitan dengan pendistribusian perangkat lunak tanpa izin khusus dan tertulis sebelumnya.
SECRET LABS AB DAN PENULIS MENYANGKAL SEMUA JAMINAN TERHADAP

PADA PERANGKAT LUNAK INI, TERMASUK SEMUA JAMINAN TERSIRAT TENTANG KEMAMPUAN
DAN KESESUAIAN PEDAGANG. DALAM HAL APAPUN LABS RAHASIA AB ATAU PENULIS HARUS
BERTANGGUNG JAWAB ATAS KERUGIAN KHUSUS, TIDAK LANGSUNG ATAU KONSEKUENSIAL ATAU
KERUGIAN APA PUN AKIBAT DARI KEHILANGAN PENGGUNAAN, DATA ATAU KEUNTUNGAN, BAIK
DALAM TINDAKAN KONTRAK, KELALAIAN ATAU TINDAKAN MERUGIKAN LAINNYA, YANG TIMBUL
DARI ATAU SEHUBUNGAN DENGAN PENGGUNAAN ATAU KINERJA INI PERANGKAT LUNAK.

C.3.8 test_epoll
Modul test_epoll berisi pemberitahuan berikut:
Hak Cipta (c) 2001-2006 Twisted Matrix Laboratories.
Izin dengan ini diberikan, tanpa biaya, kepada siapa pun yang mendapatkan salinan perangkat lunak ini dan file
dokumentasi terkait (file
"Perangkat Lunak"), untuk menangani Perangkat Lunak tanpa batasan, termasuk namun tidak terbatas pada hak
untuk menggunakan, menyalin, memodifikasi, menggabungkan, menerbitkan, mendistribusikan, mensublisensikan,
dan/atau menjual salinan Perangkat Lunak, dan untuk mengizinkan orang yang menerima Perangkat Lunak
tersebut diperlengkapi untuk itu, tunduk pada ketentuan-ketentuan berikut:
Pemberitahuan hak cipta di atas dan pemberitahuan izin ini harus disertakan dalam semua salinan atau
bagian substansial dari Perangkat Lunak.
PERANGKAT LUNAK INI DISEDIAKAN "SEBAGAIMANA ADANYA", TANPA JAMINAN APA PUN,
TERSURAT MAUPUN TERSIRAT, TERMASUK NAMUN TIDAK TERBATAS PADA JAMINAN DAPAT
DIPERDAGANGKAN, KESESUAIAN UNTUK TUJUAN TERTENTU DAN TANPA PELANGGARAN. DALAM
HAL APAPUN PENULIS ATAU PEMEGANG HAK CIPTA HARUS MENJADI
BERTANGGUNG JAWAB ATAS SETIAP KLAIM, KERUSAKAN, ATAU TANGGUNG JAWAB LAINNYA, BAIK DALAM
TINDAKAN KONTRAK, KERUGIAN ATAU LAINNYA, YANG TIMBUL DARI, DARI ATAU SEHUBUNGAN DENGAN
PERANGKAT LUNAK ATAU PENGGUNAAN ATAU URUSAN LAINNYA DALAM PERANGKAT LUNAK.
C.3.9 Pilih kqueue
Modul pilih berisi pemberitahuan berikut untuk antarmuka kqueue:
Hak cipta (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes Semua hak dilindungi undang-undang.
bertemu:
penafian berikut.
dengan distribusi.
PERANGKAT LUNAK INI DISEDIAKAN OLEH PENULIS DAN KONTRIBUTOR ``SEBAGAIMANA ADANYA'' DAN
DITOLAK. DALAM HAL APAPUN PENULIS ATAU KONTRIBUTOR TIDAK BERTANGGUNG JAWAB
UNTUK KERUGIAN LANGSUNG, TIDAK LANGSUNG, INSIDENTAL, KHUSUS, CONTOH, ATAU KONSEKUENSIAL
(TERMASUK, NAMUN TIDAK TERBATAS PADA, PENGADAAN BARANG ATAU LAYANAN PENGGANTI; KEHILANGAN
PENGGUNAAN, DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS)
NAMUN PENYEBAB DAN TEORI TANGGUNG JAWAB APA PUN, BAIK DALAM KONTRAK, TANGGUNG JAWAB KETAT,
ATAU KERUGIAN (TERMASUK KELALAIAN ATAU LAINNYA) YANG TIMBUL DALAM CARA APAPUN DARI PENGGUNAAN
PERANGKAT LUNAK INI, BAHKAN JIKA DIBERITAHU TENTANG KEMUNGKINAN KERUSAKAN TERSEBUT.

C.3.10 SipHash24
File Python/pyhash.c berisi implementasi Marek Majkowski dari algoritma SipHash24 Dan Bernstein.
Ini berisi catatan berikut:
<Lisensi MIT>
Hak Cipta (c) 2013 Marek Majkowski <marek@popcount.org>
dokumentasi terkait ("Perangkat Lunak"), untuk berurusan dengan Perangkat Lunak tanpa batasan, termasuk tanpa batasan
hak untuk menggunakan, menyalin, memodifikasi, menggabungkan , menerbitkan, mendistribusikan, mensublisensikan,
dan/atau menjual salinan Perangkat Lunak, dan untuk mengizinkan orang yang diberikan Perangkat Lunak untuk
melakukannya, tunduk pada ketentuan berikut:
Pemberitahuan hak cipta di atas dan pemberitahuan izin ini harus disertakan dalam semua salinan atau bagian
substansial dari Perangkat Lunak.
</ Lisensi MIT>
Lokasi asli:
https://github.com/majek/csiphash/
Solusi terinspirasi oleh kode dari: Samuel Neves

(supercop/crypto_auth/siphash24/little) djb (supercop/crypto_auth/siphash24/little2)
Jean-Philippe Aumasson (https://131002.net/siphash/siphash24.c)
C.3.11 strtod dan dtoa
File Python/dtoa.c, yang memasok fungsi C dtoa dan strtod untuk konversi C ganda ke dan dari string,
berasal dari file dengan nama yang sama oleh David M. Gay, saat ini tersedia dari https://web.archive .org/
web/20220517033456/http://www.netlib.org/fp/dtoa.c. Berkas asli, seperti yang diambil pada 16 Maret 2009,
berisi pemberitahuan hak cipta dan lisensi berikut:
/*************************************************** ****************
*
* Pembuat perangkat lunak ini adalah David M. Gay.
*
* Hak cipta (c) 1991, 2000, 2001 oleh Lucent Technologies.
*
* Izin untuk menggunakan, menyalin, memodifikasi, dan mendistribusikan perangkat lunak ini untuk siapa saja
*
tujuan tanpa biaya dengan ini diberikan, asalkan seluruh pemberitahuan ini
* disertakan dalam semua salinan perangkat lunak apa pun yang merupakan atau termasuk salinan atau modifikasi
*
dari perangkat lunak ini dan dalam semua salinan pendukungnya
* dokumentasi untuk perangkat lunak tersebut.
*
* PERANGKAT LUNAK INI DISEDIAKAN "SEBAGAIMANA ADANYA", TANPA JAMINAN TERSURAT MAUPUN
TERSIRAT. KHUSUSNYA, BAIK PENULIS MAUPUN LUCENT TIDAK MEMBUAT PERNYATAAN ATAU JAMINAN
APAPUN TENTANG KEMAMPUAN DIPERDAGANGKAN
* PERANGKAT LUNAK INI ATAU KESESUAIANNYA UNTUK TUJUAN TERTENTU APAPUN.
*
**************************************************** *************/

C.3.12 OpenSSL
Modul hashlib, posix, ssl, crypt menggunakan pustaka OpenSSL untuk menambah kinerja jika disediakan
oleh sistem operasi. Selain itu, penginstal Windows dan macOS untuk Python dapat menyertakan salinan
pustaka OpenSSL, jadi kami menyertakan salinan lisensi OpenSSL di sini:
MASALAH LISENSI
==============
Toolkit OpenSSL tetap berada di bawah lisensi ganda, yaitu ketentuan Lisensi OpenSSL dan lisensi SSLeay asli berlaku
untuk toolkit.
Lihat di bawah untuk teks lisensi yang sebenarnya. Sebenarnya kedua lisensi tersebut adalah lisensi Open Source gaya
BSD. Jika ada masalah lisensi terkait OpenSSL, silakan hubungi openssl-core@openssl.org.
Lisensi OpenSSL
---------------
/* ================================================ ====================
* Hak Cipta (c) 1998-2008 Proyek OpenSSL. Seluruh hak cipta.
*
* Redistribusi dan penggunaan dalam bentuk sumber dan biner, dengan atau tanpa * modifikasi, diizinkan
dengan ketentuan sebagai berikut
* bertemu:
*
* 1. Redistribusi kode sumber harus mempertahankan pemberitahuan hak cipta di atas, daftar ketentuan
*
ini, dan penafian berikut.
*
* 2. Redistribusi dalam bentuk biner harus mereproduksi pemberitahuan hak cipta di atas, daftar ketentuan ini
*
dan penafian berikut dalam dokumentasi dan/atau materi lain yang disediakan bersama distribusi.
*
*
*
* 3. Semua materi iklan menyebutkan fitur atau kegunaan ini
*
perangkat lunak harus menampilkan pengakuan berikut: "Produk ini menyertakan
*
perangkat lunak yang dikembangkan oleh Proyek OpenSSL untuk digunakan dalam OpenSSL Toolkit.
*
(http://www.openssl.org/)"
*
* 4. Nama "OpenSSL Toolkit" dan "OpenSSL Project" tidak boleh digunakan
*
mendukung atau mempromosikan produk turunan dari perangkat lunak ini tanpa izin tertulis
*
sebelumnya. Untuk izin tertulis, harap hubungi openssl-core@openssl.org.
*
*
* 5. Produk turunan dari perangkat lunak ini tidak boleh disebut "OpenSSL" atau "OpenSSL" tidak boleh
*
muncul dalam namanya tanpa izin tertulis sebelumnya dari Proyek OpenSSL.
*
*
* 6. Redistribusi dalam bentuk apa pun harus mempertahankan hal-hal berikut
*
pengakuan: "Produk ini
*
mencakup perangkat lunak yang dikembangkan oleh Proyek OpenSSL untuk digunakan dalam
*
OpenSSL Toolkit (http://www.openssl.org/)"
*
* PERANGKAT LUNAK INI DISEDIAKAN OLEH PROYEK OpenSSL ``SEBAGAIMANA ADANYA'' DAN APAPUN
* JAMINAN TERSURAT MAUPUN TERSIRAT, TERMASUK, NAMUN TIDAK TERBATAS PADA,
* JAMINAN TERSIRAT UNTUK DAPAT DIPERDAGANGKAN DAN KESESUAIAN UNTUK YANG TERTENTU
* TUJUAN DISCLAIMER. DALAM HAL APAPUN, PROYEK OpenSSL ATAU * KONTRIBUTORNYA TIDAK
BERTANGGUNG JAWAB ATAS SETIAP LANGSUNG, TIDAK LANGSUNG, INSIDENTAL,
* KERUSAKAN KHUSUS, CONTOH, ATAU KONSEKUENSIAL (TERMASUK, NAMUN
*TIDAK TERBATAS PADA, PENGADAAN BARANG ATAU JASA PENGGANTI;
* KEHILANGAN PENGGUNAAN, DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS)
* APAPUN PENYEBAB DAN PADA TEORI TANGGUNG JAWAB APA PUN, BAIK DALAM KONTRAK,
* KEWAJIBAN KERAS, ATAU KERUGIAN (TERMASUK KELALAIAN ATAU LAINNYA)

* YANG TIMBUL DENGAN CARA APAPUN DARI PENGGUNAAN PERANGKAT LUNAK INI, BAHKAN JIKA
DIBERITAHU * TENTANG KEMUNGKINAN KERUSAKAN TERSEBUT.
* ================================================== ==================
*
* Produk ini termasuk perangkat lunak kriptografi yang ditulis oleh Eric Young * (eay@cryptsoft.com). Produk ini
menyertakan perangkat lunak yang ditulis oleh Tim * Hudson (tjh@cryptsoft.com).
*
*/
Lisensi SSLeay Asli

-----------------------
/* Hak Cipta (C) 1995-1998 Eric Young (eay@cryptsoft.com)

* Seluruh hak cipta.
*
* Paket ini adalah implementasi SSL yang ditulis * oleh Eric Young
(eay@cryptsoft.com).
* Implementasi ditulis agar sesuai dengan Netscapes SSL.
*
* Perpustakaan ini gratis untuk penggunaan komersial dan non-komersial selama * kondisi berikut dipatuhi. Ketentuan
berikut *berlaku untuk semua kode yang terdapat pada distro ini, baik itu kode RC4, RSA, *lhash, DES, dll; bukan hanya
kode SSL. Dokumentasi SSL * yang disertakan dengan distribusi ini dilindungi oleh persyaratan hak cipta yang sama
*
kecuali pemegangnya adalah Tim Hudson (tjh@cryptsoft.com).
*
* Hak cipta tetap milik Eric Young, dan dengan demikian setiap pemberitahuan Hak Cipta dalam * kode tidak boleh
dihapus.
* Jika paket ini digunakan dalam suatu produk, Eric Young harus diberikan atribusi
*
sebagai penulis bagian-bagian perpustakaan yang digunakan.
* Ini bisa dalam bentuk pesan tekstual saat startup program atau * dalam dokumentasi (online atau tekstual) yang
disertakan dengan paket.
*
* Redistribusi dan penggunaan dalam bentuk sumber dan biner, dengan atau tanpa * modifikasi, diizinkan dengan
* bertemu:
* 1. Redistribusi kode sumber harus mempertahankan hak cipta

*
pemberitahuan, daftar kondisi ini dan disclaimer berikut.
* 2. Redistribusi dalam bentuk biner harus mereproduksi hak cipta di atas
*
*
dengan distribusi.
* 3. Semua materi iklan yang menyebutkan fitur atau penggunaan perangkat lunak ini harus menampilkan pengakuan berikut:
*
"Produk ini termasuk perangkat lunak kriptografi yang ditulis oleh Eric Young (eay@cryptsoft.com)"
*
*
*
Kata 'kriptografi' dapat dihilangkan jika rutin dari perpustakaan yang digunakan tidak terkait dengan kriptografi :-).
*
* 4. Jika Anda memasukkan kode khusus Windows (atau turunannya) dari

*
direktori aplikasi (kode aplikasi) Anda harus menyertakan pengakuan: "Produk ini menyertakan perangkat lunak yang ditulis
*
oleh Tim Hudson (tjh@cryptsoft.com)"
*
* PERANGKAT LUNAK INI DISEDIAKAN OLEH ERIC YOUNG ``SEBAGAIMANA ADANYA'' DAN
* SETIAP JAMINAN TERSURAT MAUPUN TERSIRAT, TERMASUK, NAMUN TIDAK TERBATAS PADA,
* JAMINAN TERSIRAT TENTANG DAGANG DAN KESESUAIAN UNTUK TUJUAN TERTENTU
* ADALAH DISCLAIME. DALAM HAL APAPUN PENULIS ATAU KONTRIBUTOR TIDAK BERTANGGUNG JAWAB
* UNTUK LANGSUNG, TIDAK LANGSUNG, INSIDENTAL, KHUSUS, CONTOH, ATAU KONSEKUENSIAL
* KERUGIAN (TERMASUK NAMUN TIDAK TERBATAS PADA PENGADAAN BARANG PENGGANTI
* ATAU LAYANAN; HILANGNYA PENGGUNAAN, DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS)
* APAPUN PENYEBAB DAN PADA TEORI TANGGUNG JAWAB APA PUN, BAIK DALAM KONTRAK, KETAT
* TANGGUNG JAWAB, ATAU KERUGIAN (TERMASUK KELALAIAN ATAU LAINNYA) YANG TIMBUL DALAM CARA APAPUN

* KELUAR DARI PENGGUNAAN PERANGKAT LUNAK INI, MESKIPUN DIBERITAHU TENTANG KEMUNGKINAN *
KERUSAKAN TERSEBUT.
*
* Persyaratan lisensi dan distribusi untuk setiap versi yang tersedia untuk umum atau * turunan dari kode ini tidak dapat
diubah. yaitu kode ini tidak dapat *disalin begitu saja dan diletakkan di bawah lisensi distribusi lain* [termasuk Lisensi Publik
GNU.] */
C.3.13 pendatang
Ekstensi pyexpat dibuat menggunakan salinan yang disertakan dari sumber ekspatriat kecuali build
dikonfigurasi --with-system-expat:
Hak Cipta (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
dan Clark Cooper
"Perangkat Lunak"), untuk menangani Perangkat Lunak tanpa batasan, termasuk namun tidak terbatas pada
hak untuk menggunakan, menyalin, memodifikasi, menggabungkan, menerbitkan, mendistribusikan,
mensublisensikan, dan/atau menjual salinan Perangkat Lunak, dan untuk mengizinkan orang yang menerima
Perangkat Lunak tersebut diperlengkapi untuk itu, tunduk pada ketentuan-ketentuan berikut:
PERANGKAT LUNAK INI DISEDIAKAN "SEBAGAIMANA ADANYA", TANPA JAMINAN APA PUN,
TERSURAT MAUPUN TERSIRAT, TERMASUK NAMUN TIDAK TERBATAS PADA JAMINAN DAPAT
DIPERDAGANGKAN, KESESUAIAN UNTUK TUJUAN TERTENTU DAN TANPA PELANGGARAN.
DALAM HAL APAPUN PENULIS ATAU PEMEGANG HAK CIPTA TIDAK BERTANGGUNG JAWAB ATAS APAPUN
KLAIM, KERUSAKAN ATAU TANGGUNG JAWAB LAINNYA, BAIK DALAM TINDAKAN KONTRAK, KERUGIAN
ATAU LAINNYA, YANG TIMBUL DARI, DARI ATAU SEHUBUNGAN DENGAN PERANGKAT LUNAK ATAU
PENGGUNAAN ATAU URUSAN LAINNYA DALAM PERANGKAT LUNAK.
C.3.14 libffi
Ekstensi _ctypes dibuat menggunakan salinan yang disertakan dari sumber libffi kecuali build dikonfigurasi
--with-system-libffi:
Hak Cipta (c) 1996-2008 Red Hat, Inc dan lainnya.
``Perangkat Lunak''), untuk menangani Perangkat Lunak tanpa batasan, termasuk namun tidak terbatas pada
hak untuk menggunakan, menyalin, memodifikasi, menggabungkan, menerbitkan, mendistribusikan,
mensublisensikan, dan/atau menjual salinan Perangkat Lunak, dan untuk mengizinkan orang kepada siapa
Perangkat Lunak dilengkapi untuk melakukannya, tunduk pada ketentuan berikut:
PERANGKAT LUNAK INI DISEDIAKAN ``SEBAGAIMANA ADANYA'', TANPA JAMINAN APA PUN,
TERSURAT MAUPUN TERSIRAT, TERMASUK NAMUN TIDAK TERBATAS PADA JAMINAN DARI
DAPAT DIPERDAGANGKAN, KESESUAIAN UNTUK TUJUAN TERTENTU DAN

TANPA PELANGGARAN. DALAM HAL APAPUN PENULIS ATAU HAK CIPTA

PEMEGANG BERTANGGUNG JAWAB ATAS KLAIM, KERUSAKAN ATAU KEWAJIBAN LAINNYA,
BAIK DALAM TINDAKAN KONTRAK, TORT ATAU LAINNYA, YANG TIMBUL DARI,
KELUAR DARI ATAU SEHUBUNGAN DENGAN PERANGKAT LUNAK ATAU PENGGUNAAN ATAU LAINNYA
DEALING DALAM PERANGKAT LUNAK.
C.3.15 zlib
Ekstensi zlib dibangun menggunakan salinan yang disertakan dari sumber zlib jika versi zlib yang ditemukan di sistem terlalu lama untuk
digunakan untuk pembangunan:
Hak Cipta (C) 1995-2011 Jean-loup Gailly dan Mark Adler
Perangkat lunak ini disediakan 'apa adanya', tanpa jaminan tersurat maupun tersirat. Dalam hal apa pun penulis tidak akan
bertanggung jawab atas segala kerusakan yang timbul dari penggunaan perangkat lunak ini.
Izin diberikan kepada siapa pun untuk menggunakan perangkat lunak ini untuk tujuan apa pun, termasuk aplikasi komersial, dan
untuk mengubah serta mendistribusikannya kembali secara bebas, tunduk pada batasan berikut:
1. Asal usul perangkat lunak ini tidak boleh disalahartikan; Anda tidak boleh mengklaim bahwa Anda yang menulis perangkat lunak asli.
Jika Anda menggunakan perangkat lunak ini dalam suatu produk, pengakuan dalam dokumentasi produk akan dihargai tetapi tidak
diperlukan.
2. Versi sumber yang diubah harus ditandai dengan jelas, dan tidak boleh disalahpahami sebagai perangkat lunak asli.
3. Pemberitahuan ini tidak boleh dihapus atau diubah dari distribusi sumber mana pun.
Jean-loup Gailly jloup@gzip.org Mark Adler

madler@alumni.caltech.edu
C.3.16 cfuhash
Implementasi tabel hash yang digunakan oleh tracemalloc didasarkan pada proyek cfuhash:
Hak cipta (c) 2005 Don Owens Semua hak

dilindungi undang-undang.
Kode ini dirilis di bawah lisensi BSD:
Redistribusi dan penggunaan dalam bentuk sumber dan biner, dengan atau tanpa modifikasi, diizinkan asalkan kondisi berikut
terpenuhi:
* Redistribusi kode sumber harus mempertahankan pemberitahuan hak cipta di atas, daftar ketentuan ini, dan penafian
berikut.
* Redistribusi dalam bentuk biner harus mereproduksi di atas

pemberitahuan hak cipta, daftar ketentuan ini dan penafian berikut dalam dokumentasi dan/atau materi lain yang
disediakan bersama distribusi.
* Baik nama penulis maupun nama-namanya
kontributor dapat digunakan untuk mendukung atau mempromosikan produk yang diturunkan

dari perangkat lunak ini tanpa izin tertulis khusus sebelumnya.
TERBATAS PADA, JAMINAN TERSIRAT TENTANG DAGANG DAN KESESUAIAN UNTUK TUJUAN
TERTENTU DITOLAK. DALAM HAL APAPUN AKAN
PEMILIK HAK CIPTA ATAU KONTRIBUTOR BERTANGGUNG JAWAB ATAS KERUSAKAN LANGSUNG, TIDAK
LANGSUNG, INSIDENTAL, KHUSUS, CONTOH, ATAU KONSEKUENSIAL (TERMASUK, NAMUN TIDAK
TERBATAS PADA, PENGADAAN BARANG ATAU LAYANAN PENGGANTI; KEHILANGAN PENGGUNAAN,
DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS)
NAMUN PENYEBABNYA DAN PADA TEORI TANGGUNG JAWAB APA PUN, BAIK DALAM KONTRAK,
TANGGUNG JAWAB KETAT, ATAU KERUGIAN (TERMASUK KELALAIAN ATAU LAINNYA)
TIMBUL DENGAN CARA APAPUN DARI PENGGUNAAN PERANGKAT LUNAK INI, BAHKAN JIKA DIBERITAHU
TENTANG KEMUNGKINAN KERUSAKAN TERSEBUT.
C.3.17 libmpdec
Modul _decimal dibangun menggunakan salinan perpustakaan libmpdec yang disertakan kecuali jika build
dikonfigurasi --with-system-libmpdec:
Hak Cipta (c) 2008-2020 Stefan Krah. Seluruh hak cipta.
bertemu:
penafian berikut.

dengan distribusi.
PERANGKAT LUNAK INI DISEDIAKAN OLEH PENULIS DAN KONTRIBUTOR "SEBAGAIMANA ADANYA" DAN
DITOLAK. DALAM HAL APAPUN PENULIS ATAU KONTRIBUTOR TIDAK BERTANGGUNG JAWAB
UNTUK LANGSUNG, TIDAK LANGSUNG, INSIDENTAL, KHUSUS, CONTOH, ATAU KONSEKUENSIAL
KERUSAKAN (TERMASUK NAMUN TIDAK TERBATAS PADA PENGADAAN BARANG PENGGANTI
ATAU LAYANAN; HILANGNYA PENGGUNAAN, DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS)
NAMUN PENYEBAB DAN PADA TEORI KEWAJIBAN APAPUN, BAIK DALAM KONTRAK, KETAT
TANGGUNG JAWAB, ATAU KERUGIAN (TERMASUK KELALAIAN ATAU LAINNYA) YANG TIMBUL DALAM CARA APAPUN
DARI PENGGUNAAN PERANGKAT LUNAK INI, BAHKAN JIKA DIBERITAHU TENTANG KEMUNGKINAN
KERUSAKAN TERSEBUT.
C.3.18 rangkaian uji W3C C14N
Suite pengujian C14N 2.0 dalam paket pengujian (Lib/test/xmltestdata/c14n-20/) diambil dari situs web W3C di
https://www.w3.org/TR/xml-c14n2-testcases/ dan didistribusikan di bawah lisensi BSD 3-klausa:
Hak Cipta (c) 2013 W3C(R) (MIT, ERCIM, Keio, Beihang), Semua Hak Dilindungi Undang-
Undang.
bertemu:

* Redistribusi karya harus mempertahankan pemberitahuan hak cipta asli,

daftar kondisi ini dan disclaimer berikut.
* Redistribusi dalam bentuk biner harus mereproduksi pemberitahuan hak cipta asli, daftar ketentuan ini dan penafian
berikut dalam dokumentasi dan/atau materi lain yang disediakan bersama distribusi.
* Baik nama W3C maupun nama kontributornya tidak boleh digunakan untuk mendukung atau mempromosikan produk
yang diturunkan dari karya ini tanpa izin tertulis khusus sebelumnya.
TERBATAS PADA, JAMINAN TERSIRAT TENTANG DAGANG DAN KESESUAIAN UNTUK TUJUAN TERTENTU
DITOLAK. DALAM HAL APAPUN HAK CIPTA
PEMILIK ATAU KONTRIBUTOR BERTANGGUNG JAWAB ATAS SETIAP LANGSUNG, TIDAK LANGSUNG, INSIDENTAL,
KERUSAKAN KHUSUS, CONTOH, ATAU KONSEKUENSIAL (TERMASUK, NAMUN TIDAK
TERBATAS PADA, PENGADAAN BARANG ATAU JASA PENGGANTI; KEHILANGAN PENGGUNAAN,
DATA, ATAU KEUNTUNGAN; ATAU GANGGUAN BISNIS) APAPUN PENYEBABNYA DAN PADA APAPUN
TEORI TANGGUNG JAWAB, BAIK DALAM KONTRAK, TANGGUNG JAWAB KETAT, ATAU TORT
(TERMASUK KELALAIAN ATAU LAINNYA) YANG TIMBUL DENGAN CARA APAPUN DARI PENGGUNAAN
PERANGKAT LUNAK INI, MESKIPUN DIBERITAHU TENTANG KEMUNGKINAN KERUSAKAN TERSEBUT.
C.3.19 Audio op
Modul audioop menggunakan basis kode dalam file g771.c proyek SoX:
Pemrograman AdLib/Sound Blaster FM Music Chips Versi

2.0 (24 Feb 1992)
Hak Cipta (c) 1991, 1992 oleh Jeffrey S. Lee jlee@smylex.uucp Garansi
dan Kebijakan Hak Cipta Dokumen ini diberikan atas dasar "sebagaimana
adanya", dan penulisnya tidak memberikan jaminan atau pernyataan,
tersurat maupun tersirat, sehubungan dengan kualitas kinerja atau kesesuaiannya untuk tujuan tertentu. Dalam
keadaan apa pun, penulis dokumen ini tidak akan bertanggung jawab atas kerugian langsung, tidak langsung,
khusus, insidental, atau konsekuensial yang timbul dari penggunaan atau ketidakmampuan untuk menggunakan
informasi yang terkandung di dalamnya. Penggunaan dokumen ini adalah risiko Anda sendiri.
File ini dapat digunakan dan disalin secara bebas selama pemberitahuan hak cipta yang berlaku dipertahankan,
dan tidak ada modifikasi yang dilakukan pada teks dokumen. Tidak ada uang yang akan dikenakan untuk
pendistribusiannya di luar biaya pengiriman, penanganan dan penggandaan yang wajar, juga tidak boleh ada perubahan
hak milik yang dilakukan terhadap dokumen ini sehingga tidak dapat didistribusikan secara bebas. Dokumen ini tidak
boleh disertakan dalam materi yang diterbitkan atau paket komersial tanpa persetujuan tertulis darinya
pengarang.


LAMPIRAN
HAK CIPTA
Python dan dokumentasi ini adalah:
Hak Cipta © 2001-2023 Yayasan Perangkat Lunak Python. Seluruh hak cipta.
Hak Cipta © 2000 BeOpen.com. Seluruh hak cipta.
Hak Cipta © 1995-2000 Corporation for National Research Initiatives. Seluruh hak cipta.
Hak Cipta © 1991-1995 Stichting Mathematisch Centrum. Seluruh hak cipta.
Lihat Riwayat dan Lisensi untuk informasi lisensi dan izin lengkap.
143
144 Lampiran D. Hak Cipta

INDEKS
Non-abjad panggilan balik, 111

..., 109 C-bersebelahan, 111
# (hash) kelas, 111 variabel
komentar, 9 kelas, 111 gaya
* (asterisk) dalam pengkodean, 32 bilangan
pemanggilan fungsi, 29 kompleks, 111
** pengelola konteks, 111
dalam pemanggilan fungsi, variabel konteks, 111
30 2to3, 109 : (titik dua) anotasi bersebelahan, 111 coroutine,
fungsi, 31 111 fungsi coroutine, 111
->
anotasi fungsi, 31 >>>, 109 CPython, 111
__all__, 49 __future__, 113 __slots__,
119
D
dekorator, 111
deskriptor, 112
kamus, 112
SEBUAH
pemahaman kamus, 112 tampilan kamus,
kelas dasar abstrak, 109 anotasi, 112 docstring, 112 docstring, 23, 31 string
109 fungsi anotasi, 31 argumen, dokumentasi, 23, 31 pengetikan bebek,
109 manajer konteks asinkron, 112
110 generator asinkron, 110
iterator generator asinkron, 110
iterable asinkron, 110 iterator asinkron, 110
atribut, 110 dapat ditunggu, 110 e
EAFP, 112
variabel lingkungan
JALAN, 45, 107
PYTHONPATH, 45, 46
PYTHONSTARTUP, 108
ekspresi, 112 modul ekstensi,
B 112
BDFL, 110
file biner, 110 referensi F
pinjaman, 110 f-string, 112
fungsi bawaan berkas
bantuan, objek, 55
83 objek file, 112 objek
terbuka, 55 bawaan mirip file, 113 pengkodean
modul, 47 sistem file dan penangan kesalahan, 113
bytecode, objek pencari, 113 divisi lantai, 113
mirip 111 byte, 110
C untuk
dapat dipanggil, 111 pernyataan, 17
145
Fortran bersebelahan , 111 fungsi metaclass , 116

, 113 metode , 116
anotasi , 31 sihir , 116
anotasi fungsi , 113 objek , 73
spesial , 120
G urutan resolusi metode , 116
pengumpulan sampah 113 , 113 modul , 117
generator
114 generator ekspresi ,
, 114 bawaan , 47
iterator 114 fungsi generik 114generator
tipe json , 4557
114 , generik , pencarianjalur
, 46 sys ,
, modulspesifikasi
117 , 117
GIL , MRO,
kunci juru bahasa global , 114 yg mungkin berubah , 117
H N
nama
berbasis hash pyc , 114 114
, hashable mangling , 78 117
Tolong bernama tuple , 117
fungsi bawaan , 83 namespace , paket
namespace , 117 nested scope ,
Saya
117 kelas gaya baru

MENGANGGUR , 114 , 117
jalur impor 115 , 114
HAI
yang
tidak dapat diubah ,
115 , impor 115importir
, objek , 117
interaktif berkas, 55
, 115 metode , 73
115
ditafsirkan, juru bahasa membuka
mematikan 115 iterable , 115 fungsi bawaan , 55

,
iterator , 115 P
paket , 117 117
J parameter , 45 107
json JALUR , ,
modul , 57
pencarian modul jalur , 45
K pencari berbasis jalur 118 , 118
entri jalur,
argumen kata kunci , 115 pencari entri jalur 118
fungsi kunci , 116 , 118
jalur masuk objek seperti ,
L jalur kait , 118 118
lambda , 116 ,
SEMANGAT
LBYL , 116 porsi , 118

daftar , 116 argumen posisi , 118 paket sementara
API sementara , 119 , 118
daftar pemahaman , 116 pemuat116
,
116 Piton 3000 , 119
pengkodean lokal ,
Proposal Peningkatan Python
M PEP 1 , 118
PEP 8 , 32
metode PP 238 , 113
sihir , 116 PP 278 , 121
metode sihir , 116 PPP 302 , 113, 116
mangling 78 PP 343 , 111
nama ,
PP 362 , 110 , 118
pemetaan, 116
PPP 411 , 119
pencari jalur meta , 116 PPP 420 , 113, 117 , 118
146 Indeks
PEP 443, 114 V

PEP 451, 113 anotasi variabel, 121 lingkungan
PEP 483, 114 virtual, 121 mesin virtual, 121
PEP 484, 31, 109, 113, 114, 121
PEP 492, 110, 111
PEP 498, 112 Z
PEP 519, 118
Zen Python, 121
PEP 525, 110
PEP 526, 109, 121
PEP 585, 114
PEP 636, 22
PEP 3107, 31
PEP 3116, 121
PEP 3147, 46
PEP 3155, 119
Pitonik, 119
PYTHONPATH, 45, 46
PYTHONSTARTUP, 108
Q
nama yang memenuhi syarat, 119
R
jumlah referensi, 119 paket
reguler, 119
RFC
RFC 2822, 87
S
Cari
jalur, modul, 45 urutan,
120 set pemahaman, 120
pengiriman tunggal, 120 irisan,
120 metode khusus, 120 metode
khusus, 120 pernyataan, 120
untuk, 17 string, dokumentasi, 23,
31 referensi kuat, 120
pengkodean gaya, 32
sys
modul, 46
Pengkodean teks T , 120

file teks, 120 string yang
dikutip tiga kali lipat, tipe 120, alias tipe
120 , petunjuk tipe 120 , 121
baris baru universal, 121
Indeks 147

Tutorial Python Bahasa Indonesia

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Tutorial Python Bahasa Indonesia

Diunggah oleh

Hak Cipta:

Format Tersedia

Machine Translated by Google

Guido van Rossum dan tim pengembangan Python

Email Yayasan Perangkat

1 Membangkitkan Nafsu Makan Anda 3

3 Pengantar Informal Python 3.1

4 Alat Aliran Kontrol Lainnya 4.1

5.6 Teknik Perulangan . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 40

7 Input dan Output 7.1

10 Tur Singkat Perpustakaan Standar

10.2 File Wildcard . . . . . . . . . . ..... . . . . . . . . . . . . ..... . . . . . . . . . . . . 83 .

11 Tur Singkat Perpustakaan Standar — Bagian II

12 Lingkungan dan Paket Virtual

14 Pengeditan Input Interaktif dan Penggantian Riwayat

15 Aritmatika Titik Terapung: Masalah dan Keterbatasan

C Sejarah dan Lisensi

aku aku aku

C.3.3 Layanan soket asinkron . . . . . . . . . . . . . . . ..... . . . . . . . . . . . .

D. Hak Cipta 143

Tutorial Python, Rilis 3.11.1

Glosarium juga layak untuk dibaca .

Tutorial Python, Rilis 3.11.1

MENINGKATKAN NAFSU MAKAN ANDA

Python hanyalah bahasa untuk Anda.

• tidak diperlukan deklarasi variabel atau argumen.

Tutorial Python, Rilis 3.11.1

4 Bab 1. Membangkitkan Nafsu Makan Anda

MENGGUNAKAN INTERPRETER PYTHON

2.1 Memanggil Penerjemah

Semua opsi baris perintah dijelaskan dalam using-on-general.

secara bersamaan menginstal Python 2.x yang dapat dieksekusi.

Tutorial Python, Rilis 3.11.1

2.1.1 Melewati Argumen

2.1.2 Mode Interaktif

>>> the_world_is_flat = True >>> jika

2.2 Penerjemah dan Lingkungannya

2.2.1 Pengkodean Kode Sumber

# -*- pengkodean: pengkodean -*-

# -*- pengkodean: cp1252 -*-

6 Bab 2. Menggunakan Penerjemah Python

Tutorial Python, Rilis 3.11.1

#!/usr/bin/env python3 # -*-

2.2. Penerjemah dan Lingkungannya 7

Tutorial Python, Rilis 3.11.1

8 Bab 2. Menggunakan Penerjemah Python

PENGENALAN INFORMAL UNTUK PYTHON

# ini adalah komentar pertama

3.1 Menggunakan Python sebagai Kalkulator

>>> 8/5 # pembagian selalu mengembalikan angka floating point 1.6

Tutorial Python, Rilis 3.11.1

>>> 17/3 # divisi klasik mengembalikan pelampung

>>> 17 % 3 # operator % mengembalikan sisa pembagian 2

>>> 5 * 3 + 2 # hasil bagi berlantai * pembagi + sisa

Dengan Python, dimungkinkan untuk menggunakan ** operator untuk menghitung kekuatan1 :

>>> 2 ** 7 # 2 pangkat 7 128

>>> n # mencoba mengakses variabel yang tidak terdefinisi

>>> pajak = 12,5 / 100 >>> harga =

10 Bab 3. Pengantar Informal Python

Tutorial Python, Rilis 3.11.1

>>> 'telur spam' # tanda kutip tunggal 'telur spam' >>>

>>> '"Bukankah," kata mereka.'

>>> print('C:\some\name') # di sini \n artinya baris baru!

3.1. Menggunakan Python sebagai Kalkulator 11

Tutorial Python, Rilis 3.11.1

Penggunaan: thingy [PILIHAN] -h

# -- pengkodean: pengkodean --

# -- pengkodean: cp1252 --