Runestone Academy hanya dapat dilanjutkan jika kami mendapat dukungan dari orang-orang seperti Anda. Sebagai seorang siswa, Anda sangat menyadari tingginya biaya buku pelajaran. Misi kami adalah menyediakan buku-buku bagus untuk Anda secara gratis, tetapi kami meminta Anda mempertimbangkan donasi $10, lebih jika Anda bisa atau kurang jika $10 menjadi beban
Sebelum melanjutkan membaca
Membuat hal-hal hebat membutuhkan waktu dan $$. Jika Anda menghargai buku yang sedang Anda baca sekarang dan ingin agar materi berkualitas tetap gratis untuk siswa lain, harap pertimbangkan untuk memberikan donasi ke Runestone Academy. Kami meminta Anda mempertimbangkan donasi $10, tetapi jika Anda dapat memberikan lebih banyak, itu bagus, jika $10 terlalu banyak untuk anggaran Anda, kami akan senang dengan apa pun yang Anda mampu sebagai bentuk dukungan
Banyak perhitungan melibatkan pemrosesan string satu karakter pada satu waktu. Seringkali, mereka mulai dari awal, memilih setiap karakter secara bergiliran, melakukan sesuatu, dan melanjutkan sampai akhir. Pola pemrosesan ini disebut traversal. Salah satu cara untuk menulis traversal adalah dengan loop while
Aktivitas. CodeLens 7. 3. 1 (stringWhileLoop)
Loop ini melintasi string dan menampilkan setiap huruf pada baris dengan sendirinya. Kondisi perulangan adalah index < len(fruit), jadi ketika index sama dengan panjang string, kondisinya salah, dan badan perulangan tidak dieksekusi. Karakter terakhir yang diakses adalah karakter dengan indeks len(fruit)-1, yang merupakan karakter terakhir dalam string
Tulis loop while yang dimulai pada karakter terakhir dalam string dan berjalan mundur ke karakter pertama dalam string, mencetak setiap huruf pada baris terpisah. Sebagai referensi, CodeLens di atas menunjukkan contoh kata yang dicetak huruf demi huruf
Cara lain untuk menulis traversal adalah dengan loop for
Setiap kali melalui loop, karakter berikutnya dalam string ditugaskan ke variabel char. Pengulangan berlanjut hingga tidak ada karakter yang tersisa
Pernyataan sederhana terdiri dari satu baris logis. Beberapa pernyataan sederhana dapat terjadi pada satu baris yang dipisahkan oleh titik koma. Sintaks untuk pernyataan sederhana adalah
simple_stmt ::= expression_stmt | assert_stmt | assignment_stmt | augmented_assignment_stmt | annotated_assignment_stmt | pass_stmt | del_stmt | return_stmt | yield_stmt | raise_stmt | break_stmt | continue_stmt | import_stmt | future_stmt | global_stmt | nonlocal_stmt7. 1. Pernyataan ekspresi
Pernyataan ekspresi digunakan (kebanyakan secara interaktif) untuk menghitung dan menulis nilai, atau (biasanya) untuk memanggil prosedur (fungsi yang tidak mengembalikan hasil yang berarti; dalam Python, prosedur mengembalikan nilai class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 0). Penggunaan lain dari pernyataan ekspresi diperbolehkan dan terkadang berguna. Sintaks untuk pernyataan ekspresi adalah
expression_stmt ::= starred_expressionPernyataan ekspresi mengevaluasi daftar ekspresi (yang mungkin berupa ekspresi tunggal)
Dalam mode interaktif, jika nilainya bukan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 0, itu diubah menjadi string menggunakan fungsi bawaan dan string yang dihasilkan ditulis ke output standar pada baris dengan sendirinya (kecuali jika hasilnya adalah class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 0, sehingga pemanggilan prosedur melakukan . )
7. 2. Pernyataan penugasan
Pernyataan penugasan digunakan untuk (kembali) mengikat nama ke nilai dan untuk memodifikasi atribut atau item dari objek yang dapat diubah
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target(Lihat bagian untuk definisi sintaks untuk attributeref, subscription, dan slicing. )
Pernyataan penugasan mengevaluasi daftar ekspresi (ingat bahwa ini bisa berupa ekspresi tunggal atau daftar yang dipisahkan koma, yang terakhir menghasilkan tupel) dan menugaskan objek hasil tunggal ke masing-masing daftar target, dari kiri ke kanan
Penugasan didefinisikan secara rekursif tergantung pada bentuk target (daftar). Ketika target adalah bagian dari objek yang dapat diubah (referensi atribut, langganan, atau pemotongan), objek yang dapat diubah pada akhirnya harus melakukan penugasan dan memutuskan validitasnya, dan dapat menimbulkan pengecualian jika penugasan tersebut tidak dapat diterima. Aturan yang diamati oleh berbagai tipe dan pengecualian yang diangkat diberikan dengan definisi tipe objek (lihat bagian )
Penugasan objek ke daftar target, secara opsional diapit tanda kurung atau tanda kurung siku, didefinisikan secara rekursif sebagai berikut
Jika daftar target adalah target tunggal tanpa tanda koma, secara opsional dalam tanda kurung, objek ditetapkan ke target tersebut
Kalau tidak
Jika daftar target berisi satu target yang diawali dengan tanda bintang, disebut target "berbintang". Objek harus iterable dengan setidaknya item sebanyak target dalam daftar target, minus satu. Item pertama dari iterable ditetapkan, dari kiri ke kanan, ke target sebelum target yang berbintang. Item terakhir dari iterable ditetapkan ke target setelah target berbintang. Daftar item yang tersisa di iterable kemudian ditetapkan ke target berbintang (daftar bisa kosong)
Kalau tidak. Objek harus iterable dengan jumlah item yang sama dengan target dalam daftar target, dan item ditugaskan, dari kiri ke kanan, ke target yang sesuai
Penugasan objek ke target tunggal didefinisikan secara rekursif sebagai berikut
Jika target adalah pengidentifikasi (nama)
Jika nama tidak muncul di atau pernyataan di blok kode saat ini. nama terikat ke objek di namespace lokal saat ini
Jika tidak. nama terikat ke objek di namespace global atau namespace luar ditentukan oleh , masing-masing
Namanya rebound kalau sudah terikat. Ini dapat menyebabkan jumlah referensi untuk objek yang sebelumnya terikat pada nama mencapai nol, menyebabkan objek dibatalkan alokasinya dan destruktornya (jika ada) dipanggil
Jika target adalah referensi atribut. Ekspresi utama dalam referensi dievaluasi. Itu harus menghasilkan objek dengan atribut yang dapat dialihkan; . Objek itu kemudian diminta untuk menetapkan objek yang ditugaskan ke atribut yang diberikan;
Catatan. Jika objek adalah instance kelas dan referensi atribut terjadi di kedua sisi operator penugasan, ekspresi sisi kanan, class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 9 dapat mengakses atribut instance atau (jika tidak ada atribut instance) atribut kelas. Target sisi kiri class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 9 selalu ditetapkan sebagai atribut instance, membuatnya jika perlu. Jadi, dua kemunculan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 _9 tidak harus mengacu pada atribut yang sama. jika ekspresi sisi kanan mengacu pada atribut kelas, sisi kiri membuat atribut instance baru sebagai target penugasan
class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 _
Deskripsi ini tidak selalu berlaku untuk atribut deskriptor, seperti properti yang dibuat dengan
Jika targetnya adalah langganan. Ekspresi utama dalam referensi dievaluasi. Itu harus menghasilkan objek urutan yang bisa berubah (seperti daftar) atau objek pemetaan (seperti kamus). Selanjutnya, ekspresi subskrip dievaluasi
Jika primer adalah objek urutan yang dapat diubah (seperti daftar), subskrip harus menghasilkan bilangan bulat. Jika negatif, panjang urutan ditambahkan padanya. Nilai yang dihasilkan harus berupa bilangan bulat nonnegatif yang kurang dari panjang urutan, dan urutan diminta untuk menetapkan objek yang ditetapkan ke itemnya dengan indeks tersebut. Jika indeks di luar rentang, dinaikkan (penugasan ke urutan subskrip tidak dapat menambahkan item baru ke daftar)
Jika primer adalah objek pemetaan (seperti kamus), subskrip harus memiliki tipe yang kompatibel dengan tipe kunci pemetaan, dan pemetaan kemudian diminta untuk membuat pasangan kunci/datum yang memetakan subskrip ke objek yang ditetapkan. Ini dapat mengganti pasangan kunci/nilai yang ada dengan nilai kunci yang sama, atau menyisipkan pasangan kunci/nilai baru (jika tidak ada kunci dengan nilai yang sama)
Untuk objek yang ditentukan pengguna, metode x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) _4 dipanggil dengan argumen yang sesuai
Jika targetnya adalah irisan. Ekspresi utama dalam referensi dievaluasi. Itu harus menghasilkan objek urutan yang bisa berubah (seperti daftar). Objek yang ditugaskan harus berupa objek urutan dari jenis yang sama. Selanjutnya, ekspresi batas bawah dan atas dievaluasi, sejauh ada; . Batas harus dievaluasi menjadi bilangan bulat. Jika salah satu ikatan negatif, panjang barisan ditambahkan padanya. Batas yang dihasilkan dipotong agar berada di antara nol dan panjang urutan, inklusif. Terakhir, objek urutan diminta untuk mengganti potongan dengan item urutan yang ditetapkan. Panjang irisan mungkin berbeda dari panjang urutan yang ditetapkan, sehingga mengubah panjang urutan target, jika urutan target mengizinkannya
Detail implementasi CPython. Dalam implementasi saat ini, sintaks untuk target dianggap sama dengan ekspresi, dan sintaks yang tidak valid ditolak selama fase pembuatan kode, menyebabkan pesan kesalahan yang kurang detail
Meskipun definisi penugasan menyiratkan bahwa tumpang tindih antara sisi kiri dan sisi kanan adalah 'simultan' (misalnya x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) 5 menukar dua variabel), tumpang tindih dalam kumpulan variabel yang ditugaskan ke terjadi dari kiri ke kanan, terkadang . Misalnya, program berikut mencetak x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) 6
x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x)
Lihat juga
PEP 3132 - Pembongkaran Iterable yang DiperpanjangSpesifikasi untuk fitur x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) _7
7. 2. 1. Pernyataan penugasan tambahan
Penugasan augmented adalah kombinasi, dalam satu pernyataan, dari operasi biner dan pernyataan penugasan
augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|="(Lihat bagian untuk definisi sintaks dari tiga simbol terakhir. )
Penugasan yang ditambah mengevaluasi target (yang, tidak seperti pernyataan penugasan normal, tidak dapat membongkar) dan daftar ekspresi, melakukan operasi biner khusus untuk jenis penugasan pada dua operan, dan menetapkan hasilnya ke target asli. Target hanya dievaluasi satu kali
Ekspresi penugasan yang ditambah seperti x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) _8 dapat ditulis ulang sebagai x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) 9 untuk mencapai efek yang serupa, tetapi tidak persis sama. Dalam versi tambahan, augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 0 hanya dievaluasi sekali. Juga, jika memungkinkan, operasi sebenarnya dilakukan di tempat, artinya daripada membuat objek baru dan menugaskannya ke target, objek lama malah dimodifikasi.
Tidak seperti penugasan normal, penugasan augmented mengevaluasi sisi kiri sebelum mengevaluasi sisi kanan. Misalnya, augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" _1 pertama mencari augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 2, lalu mengevaluasi augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 3 dan melakukan penambahan, dan terakhir, menulis hasilnya kembali ke augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 2
Dengan pengecualian penugasan ke tupel dan beberapa target dalam satu pernyataan, penugasan yang dilakukan oleh pernyataan penugasan tambahan ditangani dengan cara yang sama seperti penugasan normal. Demikian pula, dengan pengecualian perilaku di tempat yang mungkin, operasi biner yang dilakukan oleh penugasan yang diperbesar sama dengan operasi biner normal.
Untuk target yang merupakan referensi atribut, hal yang sama berlaku untuk penetapan reguler
7. 2. 2. Pernyataan penugasan beranotasi
penugasan adalah kombinasi, dalam satu pernyataan, dari anotasi variabel atau atribut dan pernyataan penugasan opsional
annotated_assignment_stmt ::= augtarget ":" expression ["=" (starred_expression | yield_expression)]Perbedaan dari normal adalah hanya satu target yang diperbolehkan
Untuk nama sederhana sebagai target penugasan, jika dalam ruang lingkup kelas atau modul, anotasi dievaluasi dan disimpan dalam atribut kelas atau modul khusus augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 5 yang merupakan pemetaan kamus dari nama variabel (hancur jika pribadi) ke anotasi yang dievaluasi. Atribut ini dapat ditulis dan dibuat secara otomatis pada awal kelas atau eksekusi badan modul, jika anotasi ditemukan secara statis
Untuk ekspresi sebagai target penugasan, anotasi dievaluasi jika dalam lingkup kelas atau modul, tetapi tidak disimpan
Jika nama dianotasi dalam lingkup fungsi, maka nama ini adalah lokal untuk lingkup tersebut. Anotasi tidak pernah dievaluasi dan disimpan dalam cakupan fungsi
Jika ada sisi kanan, penugasan beranotasi melakukan penugasan sebenarnya sebelum mengevaluasi anotasi (jika berlaku). Jika sisi kanan tidak ada untuk target ekspresi, maka penafsir mengevaluasi target kecuali untuk panggilan x = [0, 1] i = 0 i, x[i] = 1, 2 # i is updated, then x[i] is updated print(x) 4 atau augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 7 terakhir
Lihat juga
PEP 526 - Sintaks untuk Anotasi VariabelProposal yang menambahkan sintaks untuk membubuhi keterangan jenis variabel (termasuk variabel kelas dan variabel instan), alih-alih mengungkapkannya melalui komentar
PEP 484 - Ketik petunjukProposal yang menambahkan modul untuk menyediakan sintaks standar untuk anotasi jenis yang dapat digunakan dalam alat analisis statis dan IDE
Berubah di versi 3. 8. Sekarang tugas beranotasi memungkinkan ekspresi yang sama di sisi kanan seperti tugas reguler. Sebelumnya, beberapa ekspresi (seperti ekspresi tupel yang tidak dikurung) menyebabkan kesalahan sintaksis.
7. 3. Pernyataan augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 9
Pernyataan penegasan adalah cara mudah untuk menyisipkan pernyataan debug ke dalam program
assert_stmt ::= "assert" expression ["," expression]Bentuk sederhananya, annotated_assignment_stmt ::= augtarget ":" expression ["=" (starred_expression | yield_expression)] _0, setara dengan
if __debug__: if not expression: raise AssertionError
Bentuk diperpanjang, annotated_assignment_stmt ::= augtarget ":" expression ["=" (starred_expression | yield_expression)] _1, setara dengan
if __debug__: if not expression1: raise AssertionError(expression2)
Kesetaraan ini mengasumsikan bahwa dan merujuk ke variabel bawaan dengan nama tersebut. Dalam implementasi saat ini, variabel bawaan adalah annotated_assignment_stmt ::= augtarget ":" expression ["=" (starred_expression | yield_expression)] 5 dalam keadaan normal, annotated_assignment_stmt ::= augtarget ":" expression ["=" (starred_expression | yield_expression)] 6 saat pengoptimalan diminta (opsi baris perintah ). Pembuat kode saat ini tidak mengeluarkan kode untuk pernyataan tegas saat pengoptimalan diminta pada waktu kompilasi. Perhatikan bahwa tidak perlu menyertakan kode sumber untuk ekspresi yang gagal dalam pesan kesalahan;
Penugasan ke adalah ilegal. Nilai untuk variabel bawaan ditentukan saat penafsir memulai
7. 4. Pernyataan ________23______9
expression_stmt ::= starred_expression 0adalah operasi nol — ketika dijalankan, tidak ada yang terjadi. Ini berguna sebagai placeholder ketika pernyataan diperlukan secara sintaksis, tetapi tidak ada kode yang perlu dieksekusi, misalnya
expression_stmt ::= starred_expression 1
7. 5. Pernyataan assert_stmt ::= "assert" expression ["," expression] 1
expression_stmt ::= starred_expression 2Penghapusan didefinisikan secara rekursif sangat mirip dengan cara penugasan didefinisikan. Daripada mengejanya dengan detail lengkap, berikut adalah beberapa petunjuk
Penghapusan daftar target secara rekursif menghapus setiap target, dari kiri ke kanan
Penghapusan nama menghapus pengikatan nama itu dari ruang nama lokal atau global, tergantung pada apakah nama tersebut muncul dalam pernyataan di blok kode yang sama. Jika nama tidak terikat, pengecualian akan dimunculkan
Penghapusan referensi atribut, langganan, dan irisan diteruskan ke objek utama yang terlibat;
Berubah di versi 3. 2. Sebelumnya menghapus nama dari namespace lokal adalah ilegal jika muncul sebagai variabel bebas di blok bersarang.
7. 6. Pernyataan assert_stmt ::= "assert" expression ["," expression] 4
expression_stmt ::= starred_expression _3hanya dapat terjadi secara sintaksis bersarang dalam definisi fungsi, bukan dalam definisi kelas bersarang
Jika ada daftar ekspresi, itu dievaluasi, kalau tidak class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 0 diganti
meninggalkan panggilan fungsi saat ini dengan daftar ekspresi (atau class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 0) sebagai nilai pengembalian
Ketika melewati kontrol dari pernyataan dengan klausa, klausa if __debug__: if not expression: raise AssertionError 1 itu dieksekusi sebelum benar-benar meninggalkan fungsi
Dalam fungsi generator, pernyataan tersebut menunjukkan bahwa generator telah selesai dan akan menyebabkan dinaikkan. Nilai yang dikembalikan (jika ada) digunakan sebagai argumen untuk membangun dan menjadi atribut if __debug__: if not expression: raise AssertionError 6
Dalam fungsi generator asinkron, pernyataan kosong menunjukkan bahwa generator asinkron telah selesai dan akan dimunculkan. Pernyataan assert_stmt ::= "assert" expression ["," expression] _4 yang tidak kosong adalah kesalahan sintaksis dalam fungsi generator asinkron
7. 7. Pernyataan if __debug__: if not expression1: raise AssertionError(expression2) 0
expression_stmt ::= starred_expression _4Pernyataan secara semantik ekuivalen dengan a. Pernyataan hasil dapat digunakan untuk menghilangkan tanda kurung yang seharusnya diperlukan dalam pernyataan ekspresi hasil yang setara. Misalnya, pernyataan hasil
expression_stmt ::= starred_expression 5
setara dengan pernyataan ekspresi hasil
expression_stmt ::= starred_expression 6
Ekspresi hasil dan pernyataan hanya digunakan saat mendefinisikan fungsi, dan hanya digunakan di badan fungsi generator. Menggunakan hasil dalam definisi fungsi cukup untuk menyebabkan definisi tersebut membuat fungsi generator alih-alih fungsi normal
Untuk detail semantik selengkapnya, lihat bagian ini
7. 8. Pernyataan ________32______3
expression_stmt ::= starred_expression 7Jika tidak ada ekspresi, munculkan kembali pengecualian yang sedang ditangani, yang juga dikenal sebagai pengecualian aktif. Jika saat ini tidak ada pengecualian aktif, pengecualian akan dimunculkan yang menunjukkan bahwa ini adalah kesalahan
Jika tidak, evaluasi ekspresi pertama sebagai objek pengecualian. Itu harus berupa subclass atau instance dari. Jika itu adalah kelas, instance pengecualian akan diperoleh saat dibutuhkan dengan membuat instance kelas tanpa argumen
Jenis pengecualian adalah kelas instance pengecualian, nilainya adalah instance itu sendiri
Objek traceback biasanya dibuat secara otomatis saat pengecualian dimunculkan dan dilampirkan padanya sebagai atribut if __debug__: if not expression1: raise AssertionError(expression2) 8 , yang dapat ditulisi. Anda dapat membuat pengecualian dan menyetel traceback Anda sendiri dalam satu langkah menggunakan metode pengecualian (yang mengembalikan instance pengecualian yang sama, dengan traceback disetel ke argumennya), seperti itu
expression_stmt ::= starred_expression _8
Klausa expression_stmt ::= starred_expression _00 digunakan untuk rangkaian pengecualian. jika diberikan, ekspresi kedua harus berupa kelas atau instance pengecualian lain. Jika ekspresi kedua adalah instance pengecualian, itu akan dilampirkan ke pengecualian yang dimunculkan sebagai atribut expression_stmt ::= starred_expression 01 (yang dapat ditulis). Jika ekspresi adalah kelas pengecualian, kelas tersebut akan dibuat dan contoh pengecualian yang dihasilkan akan dilampirkan ke pengecualian yang dimunculkan sebagai atribut expression_stmt ::= starred_expression 01. Jika pengecualian yang dimunculkan tidak ditangani, kedua pengecualian akan dicetak
expression_stmt ::= starred_expression _9
Mekanisme serupa bekerja secara implisit jika pengecualian baru dimunculkan saat pengecualian sudah ditangani. Pengecualian dapat ditangani ketika klausa atau, atau pernyataan, digunakan. Pengecualian sebelumnya kemudian dilampirkan sebagai atribut expression_stmt ::= starred_expression 06 pengecualian baru
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target 0
Pengecualian rantai dapat ditekan secara eksplisit dengan menentukan dalam klausa expression_stmt ::= starred_expression 00
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target 1
Informasi tambahan tentang pengecualian dapat ditemukan di bagian , dan informasi tentang penanganan pengecualian ada di bagian
Berubah di versi 3. 3. sekarang diizinkan sebagai expression_stmt ::= starred_expression 10 di expression_stmt ::= starred_expression 11.
Baru di versi 3. 3. Atribut expression_stmt ::= starred_expression 12 untuk menekan tampilan otomatis dari konteks pengecualian.
Berubah di versi 3. 11. Jika traceback dari pengecualian aktif diubah dalam sebuah klausa, pernyataan if __debug__: if not expression1: raise AssertionError(expression2) 3 berikutnya memunculkan kembali pengecualian dengan traceback yang dimodifikasi. Sebelumnya, pengecualian dimunculkan kembali dengan traceback yang dimilikinya saat ditangkap.
7. 9. Pernyataan expression_stmt ::= starred_expression 15
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target 2hanya dapat terjadi secara sintaksis bersarang dalam loop or, tetapi tidak bersarang dalam definisi fungsi atau kelas dalam loop itu
Ini mengakhiri loop penutup terdekat, melewatkan klausa expression_stmt ::= starred_expression 19 opsional jika loop memiliki satu
Jika loop diakhiri oleh , target kontrol loop mempertahankan nilainya saat ini
Ketika melewati kontrol dari pernyataan dengan klausa, klausa if __debug__: if not expression: raise AssertionError 1 itu dieksekusi sebelum benar-benar meninggalkan loop
7. 10. Pernyataan expression_stmt ::= starred_expression 26
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target _3hanya dapat terjadi secara sintaksis bersarang dalam loop or, tetapi tidak bersarang dalam definisi fungsi atau kelas dalam loop itu. Ini berlanjut dengan siklus berikutnya dari loop penutup terdekat
Ketika melewati kontrol dari pernyataan dengan klausa, klausa if __debug__: if not expression: raise AssertionError 1 itu dieksekusi sebelum benar-benar memulai siklus loop berikutnya
7. 11. Pernyataan ________2______34
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target _4Pernyataan impor dasar (tanpa klausa) dijalankan dalam dua langkah
temukan modul, muat dan inisialisasi jika perlu
tentukan nama atau nama di namespace lokal untuk ruang lingkup tempat pernyataan itu muncul
Ketika pernyataan berisi banyak klausa (dipisahkan dengan koma), kedua langkah dilakukan secara terpisah untuk setiap klausa, seolah-olah klausa telah dipisahkan menjadi pernyataan impor individual
Detail dari langkah pertama, menemukan dan memuat modul, dijelaskan secara lebih rinci di bagian , yang juga menjelaskan berbagai jenis paket dan modul yang dapat diimpor, serta semua pengait yang dapat digunakan untuk menyesuaikan . Perhatikan bahwa kegagalan dalam langkah ini dapat menunjukkan bahwa modul tidak dapat ditemukan, atau terjadi kesalahan saat menginisialisasi modul, yang mencakup eksekusi kode modul
Jika modul yang diminta berhasil diambil, itu akan tersedia di namespace lokal dengan salah satu dari tiga cara
Jika nama modul diikuti oleh expression_stmt ::= starred_expression _37, maka nama yang mengikuti expression_stmt ::= starred_expression 37 terikat langsung ke modul yang diimpor
Jika tidak ada nama lain yang ditentukan, dan modul yang diimpor adalah modul tingkat atas, nama modul terikat di namespace lokal sebagai referensi ke modul yang diimpor
Jika modul yang diimpor bukan modul tingkat atas, maka nama paket tingkat atas yang berisi modul terikat di namespace lokal sebagai referensi ke paket tingkat atas. Modul yang diimpor harus diakses menggunakan nama lengkapnya yang memenuhi syarat, bukan secara langsung
Bentuknya menggunakan proses yang sedikit lebih rumit
temukan modul yang ditentukan dalam klausa, muat dan inisialisasi jika perlu;
untuk setiap pengidentifikasi yang ditentukan dalam klausa
periksa apakah modul yang diimpor memiliki atribut dengan nama itu
jika tidak, coba impor submodule dengan nama itu dan kemudian periksa kembali modul yang diimpor untuk atribut itu
jika atribut tidak ditemukan, dinaikkan
jika tidak, referensi ke nilai tersebut disimpan di ruang nama lokal, menggunakan nama di klausa expression_stmt ::= starred_expression 37 jika ada, jika tidak menggunakan nama atribut
Contoh
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target 5
Jika daftar pengidentifikasi diganti dengan bintang (expression_stmt ::= starred_expression 44), semua nama publik yang didefinisikan dalam modul terikat dalam ruang nama lokal untuk ruang lingkup di mana pernyataan itu muncul
Nama publik yang ditentukan oleh modul ditentukan dengan memeriksa namespace modul untuk variabel bernama expression_stmt ::= starred_expression 46; . Nama-nama yang diberikan dalam expression_stmt ::= starred_expression _46 semuanya dianggap publik dan harus ada. Jika expression_stmt ::= starred_expression 46 tidak ditentukan, set nama publik mencakup semua nama yang ditemukan di ruang nama modul yang tidak dimulai dengan karakter garis bawah (expression_stmt ::= starred_expression 49). expression_stmt ::= starred_expression 46 harus berisi seluruh API publik. Ini dimaksudkan untuk menghindari pengeksporan item yang bukan bagian dari API secara tidak sengaja (seperti modul pustaka yang diimpor dan digunakan di dalam modul)
Bentuk wild card impor — expression_stmt ::= starred_expression _51 — hanya diperbolehkan pada tingkat modul. Mencoba menggunakannya dalam definisi kelas atau fungsi akan menimbulkan a
Saat menentukan modul apa yang akan diimpor, Anda tidak harus menentukan nama mutlak modul tersebut. Ketika sebuah modul atau paket terdapat di dalam paket lain, dimungkinkan untuk melakukan impor relatif di dalam paket teratas yang sama tanpa harus menyebutkan nama paket. Dengan menggunakan titik terdepan dalam modul atau paket yang ditentukan setelah Anda dapat menentukan seberapa tinggi untuk melintasi hierarki paket saat ini tanpa menentukan nama persisnya. Satu titik terdepan berarti paket saat ini di mana modul yang membuat impor ada. Dua titik berarti naik satu level paket. Tiga titik naik dua tingkat, dst. Jadi jika Anda menjalankan expression_stmt ::= starred_expression 54 dari modul dalam paket expression_stmt ::= starred_expression 55 maka Anda akan mengimpor expression_stmt ::= starred_expression 56. Jika Anda mengeksekusi expression_stmt ::= starred_expression 57 dari dalam expression_stmt ::= starred_expression 58 Anda akan mengimpor expression_stmt ::= starred_expression 59. Spesifikasi untuk impor relatif terdapat di bagian ini
disediakan untuk mendukung aplikasi yang menentukan secara dinamis modul yang akan dimuat
Memunculkan expression_stmt ::= starred_expression _34 dengan argumen expression_stmt ::= starred_expression 62, expression_stmt ::= starred_expression 63, expression_stmt ::= starred_expression 64, expression_stmt ::= starred_expression 65, expression_stmt ::= starred_expression 66
7. 11. 1. Pernyataan mendatang
Pernyataan masa depan adalah arahan ke kompiler bahwa modul tertentu harus dikompilasi menggunakan sintaks atau semantik yang akan tersedia dalam rilis Python yang ditentukan di masa mendatang di mana fitur tersebut menjadi standar
Pernyataan masa depan dimaksudkan untuk memudahkan migrasi ke versi masa depan Python yang memperkenalkan perubahan yang tidak kompatibel ke bahasa. Ini memungkinkan penggunaan fitur-fitur baru berdasarkan per-modul sebelum rilis di mana fitur tersebut menjadi standar
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target _6Pernyataan mendatang harus muncul di dekat bagian atas modul. Satu-satunya baris yang dapat muncul sebelum pernyataan mendatang adalah
docstring modul (jika ada),
komentar,
baris kosong, dan
pernyataan masa depan lainnya
Satu-satunya fitur yang memerlukan penggunaan pernyataan mendatang adalah expression_stmt ::= starred_expression 67 (lihat PEP 563)
Semua fitur historis yang diaktifkan oleh pernyataan masa depan masih dikenali oleh Python 3. Daftar ini mencakup expression_stmt ::= starred_expression _68, expression_stmt ::= starred_expression 69, expression_stmt ::= starred_expression 70, expression_stmt ::= starred_expression 71, expression_stmt ::= starred_expression 72, expression_stmt ::= starred_expression 73, expression_stmt ::= starred_expression 74 dan expression_stmt ::= starred_expression 75. Semuanya mubazir karena selalu diaktifkan, dan hanya disimpan untuk kompatibilitas mundur
Pernyataan masa depan dikenali dan diperlakukan secara khusus pada waktu kompilasi. Perubahan semantik konstruksi inti sering diimplementasikan dengan menghasilkan kode yang berbeda. Bahkan mungkin fitur baru memperkenalkan sintaks baru yang tidak kompatibel (seperti kata baru yang dicadangkan), dalam hal ini kompiler mungkin perlu mengurai modul secara berbeda. Keputusan seperti itu tidak dapat didorong hingga runtime
Untuk setiap rilis yang diberikan, kompiler mengetahui nama fitur mana yang telah ditentukan, dan menimbulkan kesalahan waktu kompilasi jika pernyataan di masa mendatang berisi fitur yang tidak dikenalnya.
Semantik runtime langsung sama dengan pernyataan impor apa pun. ada modul standar , dijelaskan nanti, dan itu akan diimpor dengan cara biasa pada saat pernyataan yang akan datang dieksekusi
Semantik runtime yang menarik bergantung pada fitur spesifik yang diaktifkan oleh pernyataan mendatang
Perhatikan bahwa tidak ada yang istimewa tentang pernyataan itu
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target _7
Itu bukanlah pernyataan masa depan;
Kode dikompilasi oleh panggilan ke fungsi bawaan dan yang terjadi dalam modul expression_stmt ::= starred_expression 79 yang berisi pernyataan masa depan, secara default, akan menggunakan sintaks atau semantik baru yang terkait dengan pernyataan masa depan. Ini dapat dikontrol dengan argumen opsional untuk — lihat dokumentasi fungsi tersebut untuk detailnya
Pernyataan yang akan datang yang diketik pada permintaan juru bahasa interaktif akan berlaku selama sisa sesi juru bahasa. Jika seorang juru bahasa dimulai dengan opsi, diberi nama skrip untuk dieksekusi, dan skrip menyertakan pernyataan di masa mendatang, itu akan berlaku di sesi interaktif yang dimulai setelah skrip dijalankan
Lihat juga
PEP 236 - Kembali ke __masa depan__Proposal asli untuk mekanisme __future__
7. 12. Pernyataan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target _8Pernyataan itu adalah deklarasi yang berlaku untuk seluruh blok kode saat ini. Ini berarti bahwa pengidentifikasi yang terdaftar harus ditafsirkan sebagai global. Tidak mungkin untuk menetapkan ke variabel global tanpa class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4, meskipun variabel bebas dapat merujuk ke global tanpa dinyatakan global
Nama yang tercantum dalam pernyataan tidak boleh digunakan dalam blok kode yang sama secara tekstual sebelum pernyataan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4 itu
Nama yang tercantum dalam pernyataan tidak boleh didefinisikan sebagai parameter formal, atau sebagai target dalam pernyataan atau klausa, atau dalam daftar target, definisi, definisi fungsi, pernyataan, atau anotasi variabel
Detail implementasi CPython. Implementasi saat ini tidak memberlakukan beberapa pembatasan ini, tetapi program tidak boleh menyalahgunakan kebebasan ini, karena implementasi di masa mendatang dapat memberlakukannya atau secara diam-diam mengubah makna program.
Catatan programmer. adalah arahan untuk parser. Ini hanya berlaku untuk kode yang diuraikan pada saat yang sama dengan pernyataan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4. Secara khusus, pernyataan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 _4 yang terkandung dalam string atau objek kode yang diberikan ke fungsi bawaan tidak memengaruhi blok kode yang berisi pemanggilan fungsi, dan kode yang terkandung dalam string tersebut tidak terpengaruh oleh class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 4 pernyataan dalam kode yang berisi pemanggilan fungsi. Hal yang sama berlaku untuk dan fungsi
7. 13. Pernyataan class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 5
assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" [target_list] ")" | "[" [target_list] "]" | attributeref | subscription | slicing | "*" target _9Pernyataan tersebut menyebabkan pengidentifikasi terdaftar untuk merujuk ke variabel terikat sebelumnya dalam lingkup terlampir terdekat tidak termasuk global. Ini penting karena perilaku default untuk pengikatan adalah mencari namespace lokal terlebih dahulu. Pernyataan tersebut memungkinkan kode yang dienkapsulasi untuk mengikat ulang variabel di luar lingkup lokal selain lingkup global (modul).
Nama yang tercantum dalam pernyataan, tidak seperti yang tercantum dalam pernyataan, harus mengacu pada pengikatan yang sudah ada sebelumnya dalam lingkup terlampir (lingkup di mana pengikatan baru harus dibuat tidak dapat ditentukan secara jelas)