Untuk loop dari kanan ke kiri python

Question

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

Table of Contents Show

7. 1. Pernyataan ekspresi
7. 2. Pernyataan penugasan
7. 2. 1. Pernyataan penugasan tambahan
7. 2. 2. Pernyataan penugasan beranotasi
7. 3. Pernyataan augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" 9
7. 4. Pernyataan ________23______9
7. 5. Pernyataan assert_stmt ::= "assert" expression ["," expression] 1
7. 6. Pernyataan assert_stmt ::= "assert" expression ["," expression] 4
7. 7. Pernyataan if __debug__: if not expression1: raise AssertionError(expression2) 0
7. 8. Pernyataan ________32______3
7. 9. Pernyataan expression_stmt ::= starred_expression 15
7. 10. Pernyataan expression_stmt ::= starred_expression 26
7. 11. Pernyataan ________2______34
7. 11. 1. Pernyataan mendatang
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
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
Bagaimana Anda membuat for loop mundur dengan Python?
Bagaimana Anda membalik daftar dalam for loop?
Bagaimana cara mencetak loop berdampingan dengan Python?
Apa fungsi terbalik di Python?

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_stmt

7. 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_expression

Pernyataan 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 Diperpanjang

Spesifikasi 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 Variabel

Proposal yang menambahkan sintaks untuk membubuhi keterangan jenis variabel (termasuk variabel kelas dan variabel instan), alih-alih mengungkapkannya melalui komentar

PEP 484 - Ketik petunjuk

Proposal 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 __239

expression_stmt ::=  starred_expression

0

adalah 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

2

Penghapusan 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

_3

hanya 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

_4

Pernyataan 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 __323

expression_stmt ::=  starred_expression

7

Jika 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

2

hanya 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

_3

hanya 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 __234

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

_4

Pernyataan 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
1. periksa apakah modul yang diimpor memiliki atribut dengan nama itu
2. jika tidak, coba impor submodule dengan nama itu dan kemudian periksa kembali modul yang diimpor untuk atribut itu
3. jika atribut tidak ditemukan, dinaikkan
4. 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

_6

Pernyataan 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

_8

Pernyataan 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

_9

Pernyataan 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)

Bagaimana Anda membuat for loop mundur dengan Python?

Tetapi Python memang memiliki fungsi terbalik bawaan. Jika Anda membungkus range() di dalam reversed() , maka Anda dapat mencetak bilangan bulat dalam urutan terbalik. range() memungkinkan untuk mengulangi urutan angka yang menurun, sedangkan reversed() umumnya digunakan untuk mengulang urutan dalam urutan terbalik.

Bagaimana Anda membalik daftar dalam for loop?

3) Menggunakan for loop . Buat daftar kosong untuk menyalin elemen terbalik. Pada perulangan for, tambahkan iterator sebagai elemen daftar di awal dengan elemen daftar baru. Jadi dengan cara itu, elemen daftar akan dibalik.

Bagaimana cara mencetak loop berdampingan dengan Python?

Untuk membuat kedua daftar muncul berdampingan, Anda dapat menggunakan zip yang dikombinasikan dengan for loop . Ini akan mengubah daftar menjadi kumpulan tupel yang kemudian akan muncul dalam format hampir-tabular saat dicetak.

Apa fungsi terbalik di Python?

reversed adalah fungsi bawaan di Python yang digunakan untuk mendapatkan iterator urutan terbalik . fungsi terbalik mirip dengan metode iter() tetapi dalam urutan terbalik. Iterator adalah objek yang digunakan untuk mengulang iterable. Kita dapat membuat objek iterator menggunakan metode iter pada iterable.

kode python