Konvensi penamaan variabel python menggarisbawahi


Variabel dapat memiliki nama pendek (seperti x dan y) atau nama yang lebih deskriptif (umur, nama mobil, total_volume). Aturan untuk variabel Python
  • Nama variabel harus dimulai dengan huruf atau karakter garis bawah
  • Nama variabel tidak boleh dimulai dengan angka
  • Nama variabel hanya boleh berisi karakter alfanumerik dan garis bawah (A-z, 0-9, dan _ )
  • Nama variabel peka terhadap huruf besar-kecil (usia, Usia, dan UMUR adalah tiga variabel berbeda)

Contoh

Nama variabel hukum

myvar = "John"
my_var = "Yohanes"
_my_var = "Yohanes"
myVar = "John"
MYVAR = "Yohanes"
myvar2 = "Yohanes"

Cobalah sendiri "

Contoh

Nama variabel ilegal

2myvar = "Yohanes"
my-var = "John"
var saya = "John"

Cobalah sendiri "

Ingatlah bahwa nama variabel peka terhadap huruf besar-kecil



Nama Variabel Banyak Kata

Nama variabel dengan lebih dari satu kata bisa sulit dibaca

Ada beberapa teknik yang dapat Anda gunakan untuk membuatnya lebih mudah dibaca

Kasus Unta

Setiap kata, kecuali yang pertama, dimulai dengan huruf kapital


Kasus Paskal

Setiap kata dimulai dengan huruf kapital


Kasus Ular

Setiap kata dipisahkan oleh karakter garis bawah

my_variable_name = "John"



Variabel dapat memiliki nama pendek (seperti x dan y) atau nama yang lebih deskriptif (umur, nama mobil, total_volume)

Aturan untuk variabel Python

  • Nama variabel harus dimulai dengan huruf atau karakter garis bawah
  • Nama variabel tidak boleh dimulai dengan angka
  • Nama variabel hanya boleh berisi karakter alfanumerik dan garis bawah (A-z, 0-9, dan _ )
  • Nama variabel peka terhadap huruf besar-kecil (usia, Usia, dan UMUR adalah tiga variabel berbeda)

Contoh

#Nama variabel legal
myvar = "John"
my_var = "Yohanes"
_my_var = "Yohanes"
myVar = "John"
MYVAR = "Yohanes"
myvar2 = "Yohanes"

#Nama variabel ilegal
2myvar = "Yohanes"
my-var = "John"
var saya = "John"

Cobalah sendiri "

Ingatlah bahwa nama variabel peka terhadap huruf besar-kecil




Hari ini kita akan melihat konsep yang sangat penting dalam Python. penggunaan garis bawah saat memberi nama variabel. Dalam Python kami memiliki lima konvensi penamaan berbeda yang melibatkan garis bawah

Variabel dengan satu garis bawah utama seperti _elms

  • Ini adalah konvensi penamaan yang diikuti oleh sebagian besar kode Python
  • Nama yang diawali dengan garis bawah harus diperlakukan sebagai bagian non-publik dari API dan dapat diubah tanpa pemberitahuan
  • Ini berlaku terlepas dari apakah itu fungsi, metode atau anggota data

Variabel dengan (setidaknya) dua garis bawah di depan dan paling banyak satu garis bawah di belakang seperti __my_private_variable

Dokumen ini memberikan konvensi pengkodean untuk kode Python yang terdiri dari pustaka standar dalam distribusi Python utama. Silakan lihat PEP informasi pendamping yang menjelaskan pedoman gaya untuk kode C dalam implementasi C Python

Dokumen ini dan PEP 257 (Konvensi Docstring) diadaptasi dari esai Panduan Gaya Python asli Guido, dengan beberapa tambahan dari panduan gaya Barry

Panduan gaya ini berkembang dari waktu ke waktu sebagai konvensi tambahan diidentifikasi dan konvensi masa lalu dianggap usang oleh perubahan dalam bahasa itu sendiri

Banyak proyek memiliki pedoman gaya pengkodean sendiri. Jika terjadi konflik, panduan khusus proyek tersebut diutamakan untuk proyek tersebut

Salah satu wawasan utama Guido adalah bahwa kode lebih sering dibaca daripada ditulis. Pedoman yang disediakan di sini dimaksudkan untuk meningkatkan keterbacaan kode dan membuatnya konsisten di seluruh spektrum kode Python. Seperti yang dikatakan PEP 20, "Keterbacaan diperhitungkan"

Panduan gaya adalah tentang konsistensi. Konsistensi dengan panduan gaya ini penting. Konsistensi dalam suatu proyek lebih penting. Konsistensi dalam satu modul atau fungsi adalah yang paling penting

Namun, ketahuilah kapan harus tidak konsisten – terkadang rekomendasi panduan gaya tidak berlaku. Jika ragu, gunakan penilaian terbaik Anda. Lihat contoh lain dan putuskan mana yang terlihat terbaik. Dan jangan ragu untuk bertanya

Secara khusus. jangan merusak kompatibilitas mundur hanya untuk mematuhi PEP ini

Beberapa alasan bagus lainnya untuk mengabaikan pedoman tertentu

  1. Saat menerapkan guideline akan membuat kode kurang terbaca, bahkan bagi seseorang yang sudah terbiasa membaca kode yang mengikuti PEP ini
  2. Agar konsisten dengan kode di sekitarnya yang juga merusaknya (mungkin karena alasan historis) – meskipun ini juga merupakan peluang untuk membersihkan kekacauan orang lain (dalam gaya XP yang sebenarnya)
  3. Karena kode yang dipermasalahkan mendahului pengenalan pedoman dan tidak ada alasan lain untuk memodifikasi kode itu
  4. Saat kode harus tetap kompatibel dengan versi Python lama yang tidak mendukung fitur yang direkomendasikan oleh panduan gaya

Gunakan 4 spasi per tingkat lekukan

Garis lanjutan harus menyelaraskan elemen yang dibungkus baik secara vertikal menggunakan garis implisit Python yang bergabung di dalam tanda kurung, tanda kurung, dan tanda kurung, atau menggunakan indentasi gantung. Saat menggunakan lekukan gantung, hal-hal berikut harus dipertimbangkan;

# Correct:

# Aligned with opening delimiter.
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

# Add 4 spaces (an extra level of indentation) to distinguish arguments from the rest.
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

# Hanging indents should add a level.
foo = long_function_name(
    var_one, var_two,
    var_three, var_four)

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_

Aturan 4 spasi adalah opsional untuk garis lanjutan

Opsional

# Hanging indents *may* be indented to other than 4 spaces.
foo = long_function_name(
  var_one, var_two,
  var_three, var_four)

Ketika bagian bersyarat dari pernyataan

# Wrong:
# operators sit far away from their operands
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)
_7 cukup panjang untuk mengharuskannya ditulis dalam beberapa baris, perlu dicatat bahwa kombinasi kata kunci dua karakter (i. e.
# Wrong:
# operators sit far away from their operands
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)
7), ditambah satu spasi, ditambah tanda kurung buka membuat indentasi 4 spasi alami untuk baris berikutnya dari kondisi multiline. Hal ini dapat menghasilkan konflik visual dengan rangkaian kode berindentasi yang bersarang di dalam pernyataan
# Wrong:
# operators sit far away from their operands
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)
7, yang juga secara alami akan diindentasi menjadi 4 spasi. PEP ini tidak mengambil posisi eksplisit tentang bagaimana (atau apakah) untuk lebih membedakan secara visual garis bersyarat tersebut dari rangkaian bersarang di dalam pernyataan
# Wrong:
# operators sit far away from their operands
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)
7. Opsi yang dapat diterima dalam situasi ini termasuk, namun tidak terbatas pada

# No extra indentation.
if (this_is_one_thing and
    that_is_another_thing):
    do_something()

# Add a comment, which will provide some distinction in editors
# supporting syntax highlighting.
if (this_is_one_thing and
    that_is_another_thing):
    # Since both conditions are true, we can frobnicate.
    do_something()

# Add some extra indentation on the conditional continuation line.
if (this_is_one_thing
        and that_is_another_thing):
    do_something()

(Lihat juga pembahasan apakah break sebelum atau sesudah operator biner di bawah ini. )

Tanda kurung kurawal/kurung/kurung penutup pada konstruksi multibaris dapat berbaris di bawah karakter non-spasi putih pertama dari baris terakhir daftar, seperti pada

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_

atau mungkin berbaris di bawah karakter pertama dari baris yang memulai konstruksi multiline, seperti pada

my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
)
_

Spasi adalah metode indentasi yang disukai

Tab harus digunakan semata-mata agar tetap konsisten dengan kode yang sudah diindentasi dengan tab

Python melarang pencampuran tab dan spasi untuk lekukan

Batasi semua baris hingga maksimal 79 karakter

Untuk mengalirkan blok teks yang panjang dengan batasan struktural yang lebih sedikit (dokumen atau komentar), panjang baris harus dibatasi hingga 72 karakter

Membatasi lebar jendela editor yang diperlukan memungkinkan beberapa file terbuka berdampingan, dan bekerja dengan baik saat menggunakan alat tinjauan kode yang menyajikan dua versi di kolom yang berdekatan

Pembungkusan default di sebagian besar alat mengganggu struktur visual kode, membuatnya lebih sulit untuk dipahami. Batas dipilih untuk menghindari pembungkusan di editor dengan lebar jendela diatur ke 80, bahkan jika alat menempatkan mesin terbang penanda di kolom terakhir saat membungkus garis. Beberapa alat berbasis web mungkin tidak menawarkan pembungkus garis dinamis sama sekali

Beberapa tim sangat menyukai panjang garis yang lebih panjang. Untuk kode yang dikelola secara eksklusif atau terutama oleh tim yang dapat mencapai kesepakatan tentang masalah ini, tidak apa-apa untuk menambah batas panjang baris hingga 99 karakter, asalkan komentar dan dokumen masih dibungkus dengan 72 karakter

Pustaka standar Python bersifat konservatif dan membutuhkan batasan baris hingga 79 karakter (dan dokumen/komentar hingga 72)

Cara yang disukai untuk membungkus garis panjang adalah dengan menggunakan kelanjutan garis tersirat Python di dalam tanda kurung, tanda kurung, dan tanda kurung. Garis panjang dapat dipecah menjadi beberapa baris dengan membungkus ekspresi dalam tanda kurung. Ini harus digunakan sebagai preferensi untuk menggunakan garis miring terbalik untuk kelanjutan baris

Garis miring terbalik terkadang masih sesuai. Misalnya, panjang, beberapa

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
_1-pernyataan tidak bisa menggunakan kelanjutan implisit sebelum Python 3. 10, jadi garis miring terbalik dapat diterima untuk kasus itu

with open('/path/to/some/file/you/want/to/read') as file_1, \
     open('/path/to/some/file/being/written', 'w') as file_2:
    file_2.write(file_1.read())

(Lihat pembahasan sebelumnya untuk pemikiran lebih lanjut tentang lekukan seperti multiline

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
1-pernyataan. )

Kasus serupa lainnya adalah dengan

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
_3 pernyataan

Pastikan untuk mengindentasi baris lanjutan dengan benar

Selama beberapa dekade, gaya yang direkomendasikan adalah mendobrak setelah operator biner. Tapi ini bisa merusak keterbacaan dalam dua cara. operator cenderung tersebar di berbagai kolom di layar, dan setiap operator dipindahkan dari operannya ke baris sebelumnya. Di sini, mata harus bekerja ekstra untuk mengetahui item mana yang ditambahkan dan mana yang dikurangi

# Wrong:
# operators sit far away from their operands
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)

Untuk mengatasi masalah keterbacaan ini, matematikawan dan penerbitnya mengikuti konvensi yang berlawanan. Donald Knuth menjelaskan aturan tradisional dalam seri Computers and Typesetting-nya. “Meskipun rumus dalam paragraf selalu terputus setelah operasi dan relasi biner, rumus yang ditampilkan selalu terputus sebelum operasi biner”

Mengikuti tradisi dari matematika biasanya menghasilkan kode yang lebih mudah dibaca

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

Dalam kode Python, diizinkan untuk memecah sebelum atau sesudah operator biner, asalkan konvensi konsisten secara lokal. Untuk kode baru, gaya Knuth disarankan

Kelilingi fungsi tingkat atas dan definisi kelas dengan dua baris kosong

Definisi metode di dalam kelas dikelilingi oleh satu baris kosong

Baris kosong ekstra dapat digunakan (sesedikit mungkin) untuk memisahkan kelompok fungsi terkait. Baris kosong dapat dihilangkan di antara banyak baris satu baris terkait (mis. g. satu set implementasi dummy)

Gunakan baris kosong dalam fungsi, hemat, untuk menunjukkan bagian logis

Python menerima kontrol-L (i. e. ^L) membentuk karakter feed sebagai spasi; . Perhatikan, beberapa editor dan penampil kode berbasis web mungkin tidak mengenali control-L sebagai umpan formulir dan akan menampilkan mesin terbang lain sebagai gantinya

Kode dalam distribusi inti Python harus selalu menggunakan UTF-8, dan tidak boleh memiliki deklarasi penyandian

Di perpustakaan standar, pengkodean non-UTF-8 harus digunakan hanya untuk tujuan pengujian. Gunakan karakter non-ASCII dengan hemat, sebaiknya hanya untuk menunjukkan tempat dan nama manusia. Jika menggunakan karakter non-ASCII sebagai data, hindari karakter Unicode yang berisik seperti z̯̯͡a̧͎̺l̡͓̫g̹̲o̡̼̘ dan tanda urutan byte

Semua pengidentifikasi di pustaka standar Python HARUS menggunakan pengidentifikasi khusus ASCII, dan HARUS menggunakan kata-kata bahasa Inggris jika memungkinkan (dalam banyak kasus, singkatan dan istilah teknis digunakan yang bukan bahasa Inggris)

Proyek open source dengan audiens global didorong untuk mengadopsi kebijakan serupa

  • Impor biasanya harus berada di jalur terpisah

    # Correct:
    import os
    import sys
    

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _0

    Tidak apa-apa untuk mengatakan ini

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _1

  • Impor selalu diletakkan di bagian atas file, tepat setelah komentar modul dan docstring apa pun, dan sebelum modul global dan konstanta

    Impor harus dikelompokkan dalam urutan berikut

    1. Impor pustaka standar
    2. Impor pihak ketiga terkait
    3. Impor khusus aplikasi/perpustakaan lokal

    Anda harus meletakkan baris kosong di antara setiap grup impor

  • Impor absolut direkomendasikan, karena biasanya lebih mudah dibaca dan cenderung berperilaku lebih baik (atau setidaknya memberikan pesan kesalahan yang lebih baik) jika sistem impor salah dikonfigurasi (seperti ketika direktori di dalam paket berakhir pada
    # Correct:
    # easy to match operators with operands
    income = (gross_wages
              + taxable_interest
              + (dividends - qualified_dividends)
              - ira_deduction
              - student_loan_interest)
    
    4)

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _2

    Namun, impor relatif eksplisit adalah alternatif yang dapat diterima untuk impor absolut, terutama ketika berhadapan dengan tata letak paket yang kompleks di mana menggunakan impor absolut tidak perlu bertele-tele.

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _3

    Kode pustaka standar harus menghindari tata letak paket yang rumit dan selalu menggunakan impor absolut

  • Saat mengimpor kelas dari modul yang berisi kelas, biasanya tidak apa-apa untuk mengeja ini

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _4

    Jika ejaan ini menyebabkan bentrok nama lokal, maka eja secara eksplisit

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _5

    dan gunakan “myclass. MyClass” dan “foo. batang. kelasmu. Kelas Anda”

  • Impor karakter pengganti (
    # Correct:
    # easy to match operators with operands
    income = (gross_wages
              + taxable_interest
              + (dividends - qualified_dividends)
              - ira_deduction
              - student_loan_interest)
    
    _5) harus dihindari, karena membuat tidak jelas nama mana yang ada di ruang nama, membingungkan pembaca dan banyak alat otomatis. Ada satu kasus penggunaan yang dapat dipertahankan untuk impor wildcard, yaitu memublikasikan ulang antarmuka internal sebagai bagian dari API publik (misalnya, menimpa implementasi antarmuka Python murni dengan definisi dari modul akselerator opsional dan definisi mana yang akan menjadi

    Saat memublikasikan ulang nama dengan cara ini, pedoman di bawah terkait antarmuka publik dan internal tetap berlaku

Tingkat modul "dunders" (i. e. nama dengan dua garis bawah depan dan dua garis bawah) seperti

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
6,
# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
7,
# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
8, dll. harus ditempatkan setelah docstring modul tetapi sebelum pernyataan impor apa pun kecuali
# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
9 impor. Mandat Python bahwa impor masa depan harus muncul dalam modul sebelum kode lain kecuali docstrings

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_6

Dalam Python, string yang dikutip tunggal dan string yang dikutip ganda adalah sama. PEP ini tidak membuat rekomendasi untuk ini. Pilih aturan dan patuhi itu. Namun, ketika sebuah string berisi karakter kutip tunggal atau ganda, gunakan yang lain untuk menghindari garis miring terbalik dalam string. Ini meningkatkan keterbacaan

Untuk string dengan kutip tiga, selalu gunakan karakter kutip ganda agar konsisten dengan konvensi docstring di PEP 257

Hindari spasi kosong dalam situasi berikut

  • Tepat di dalam tanda kurung, tanda kurung atau kawat gigi

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _7

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _8

  • Antara tanda koma dan tanda kurung tutup berikut

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _9

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    0

  • Tepat sebelum koma, titik koma, atau titik dua

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    1

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    2

  • Namun, dalam irisan usus besar bertindak seperti operator biner, dan harus memiliki jumlah yang sama di kedua sisinya (memperlakukannya sebagai operator dengan prioritas terendah). Dalam irisan yang diperpanjang, kedua titik dua harus menerapkan jumlah spasi yang sama. Pengecualian. ketika parameter irisan dihilangkan, spasi dihilangkan

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    _3

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    _4

  • Segera sebelum tanda kurung buka yang memulai daftar argumen pemanggilan fungsi

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    5

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    6

  • Tepat sebelum tanda kurung buka yang memulai pengindeksan atau pemotongan

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    7

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    _8

  • Lebih dari satu ruang di sekitar operator penugasan (atau lainnya) untuk menyelaraskannya dengan yang lain

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    _9

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    0

  • Hindari membuntuti spasi di mana saja. Karena biasanya tidak terlihat, itu bisa membingungkan. e. g. garis miring terbalik diikuti dengan spasi dan baris baru tidak dihitung sebagai penanda kelanjutan baris. Beberapa editor tidak menyimpannya dan banyak proyek (seperti CPython sendiri) memiliki pengait pra-komitmen yang menolaknya
  • Selalu kelilingi operator biner ini dengan satu spasi di kedua sisi. penugasan (
    # Correct:
    import os
    import sys
    
    _0), penugasan tambahan (
    # Correct:
    import os
    import sys
    
    1,
    # Correct:
    import os
    import sys
    
    2 dll. ), comparisons (
    # Correct:
    import os
    import sys
    
    3,
    # Correct:
    import os
    import sys
    
    4,
    # Correct:
    import os
    import sys
    
    5,
    # Correct:
    import os
    import sys
    
    6,
    # Correct:
    import os
    import sys
    
    7,
    # Correct:
    import os
    import sys
    
    8,
    # Correct:
    import os
    import sys
    
    9,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    00,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    01,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    02,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    03), Booleans (
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    04,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    05,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    06)
  • Jika operator dengan prioritas berbeda digunakan, pertimbangkan untuk menambahkan spasi di sekitar operator dengan prioritas terendah. Gunakan penilaian Anda sendiri;

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    1

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    2

  • Anotasi fungsi harus menggunakan aturan normal untuk titik dua dan selalu memiliki spasi di sekitar panah
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    07 jika ada. (Lihat di bawah untuk informasi lebih lanjut tentang anotasi fungsi. )

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    3

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    4

  • Jangan gunakan spasi di sekitar tanda
    # Correct:
    import os
    import sys
    
    _0 saat digunakan untuk menunjukkan argumen kata kunci, atau saat digunakan untuk menunjukkan nilai default untuk parameter fungsi yang tidak dianotasi

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    5

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    6

    Namun, saat menggabungkan anotasi argumen dengan nilai default, gunakan spasi di sekitar tanda

    # Correct:
    import os
    import sys
    
    0

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    7

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    _8

  • Pernyataan majemuk (beberapa pernyataan pada baris yang sama) umumnya tidak disarankan

    # No extra indentation.
    if (this_is_one_thing and
        that_is_another_thing):
        do_something()
    
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        that_is_another_thing):
        # Since both conditions are true, we can frobnicate.
        do_something()
    
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
        do_something()
    
    _9

    Lebih baik tidak

    my_list = [
        1, 2, 3,
        4, 5, 6,
        ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
        )
    
    _0

  • Meskipun terkadang tidak apa-apa untuk meletakkan if/for/while dengan badan kecil di baris yang sama, jangan pernah melakukan ini untuk pernyataan multi-klausa. Juga hindari melipat garis panjang seperti itu

    Lebih baik tidak

    my_list = [
        1, 2, 3,
        4, 5, 6,
        ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
        )
    
    _1

    Tentu saja tidak

    my_list = [
        1, 2, 3,
        4, 5, 6,
        ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
        )
    
    _2

Tanda koma biasanya opsional, kecuali koma wajib saat membuat tuple dari satu elemen. Untuk kejelasan, disarankan untuk mengelilingi yang terakhir dalam tanda kurung (secara teknis berlebihan).

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_3

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_4

Saat tanda koma berlebihan, mereka sering membantu saat sistem kontrol versi digunakan, saat daftar nilai, argumen, atau item yang diimpor diharapkan diperpanjang dari waktu ke waktu. Polanya adalah untuk menempatkan setiap nilai (dll. ) pada satu baris dengan sendirinya, selalu tambahkan tanda koma, dan tambahkan tanda kurung tutup/bracket/brace pada baris berikutnya. Namun tidak masuk akal untuk memiliki tanda koma pada baris yang sama dengan pembatas penutup (kecuali dalam kasus tupel tunggal di atas)

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_5

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_6

Komentar yang bertentangan dengan kode lebih buruk daripada tidak ada komentar. Selalu jadikan prioritas untuk selalu memperbarui komentar saat kode berubah

Komentar harus berupa kalimat lengkap. Kata pertama harus dikapitalisasi, kecuali itu adalah pengidentifikasi yang dimulai dengan huruf kecil (jangan pernah mengubah kasus pengidentifikasi. )

Komentar blok umumnya terdiri dari satu atau lebih paragraf yang dibangun dari kalimat lengkap, dengan setiap kalimat diakhiri dengan tanda titik

Anda harus menggunakan dua spasi setelah titik akhir kalimat dalam komentar multi-kalimat, kecuali setelah kalimat terakhir

Pastikan komentar Anda jelas dan mudah dimengerti oleh penutur lain dari bahasa yang Anda tulis

Pembuat kode Python dari negara-negara yang tidak berbahasa Inggris. tolong tulis komentar Anda dalam bahasa Inggris, kecuali Anda 120% yakin bahwa kode tersebut tidak akan pernah dibaca oleh orang yang tidak berbicara bahasa Anda

Blokir komentar umumnya berlaku untuk beberapa (atau semua) kode yang mengikutinya, dan diindentasi ke tingkat yang sama dengan kode tersebut. Setiap baris komentar blokir dimulai dengan

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
10 dan satu spasi (kecuali jika itu adalah teks menjorok di dalam komentar)

Paragraf di dalam komentar blok dipisahkan oleh baris yang berisi

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
10 tunggal

Gunakan komentar sebaris dengan hemat

Komentar sebaris adalah komentar pada baris yang sama dengan pernyataan. Komentar sebaris harus dipisahkan oleh setidaknya dua spasi dari pernyataan. Mereka harus mulai dengan # dan satu spasi

Komentar sebaris tidak diperlukan dan bahkan mengganggu jika menyatakan hal yang sudah jelas. Jangan lakukan ini

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_7

Tapi terkadang, ini berguna

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )
_8

Konvensi untuk menulis string dokumentasi yang baik (a. k. a. “docstrings”) diabadikan dalam PEP 257

  • Menulis docstring untuk semua modul publik, fungsi, kelas, dan metode. Docstring tidak diperlukan untuk metode non-publik, tetapi Anda harus memiliki komentar yang menjelaskan fungsi metode tersebut. Komentar ini akan muncul setelah baris
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _12
  • PEP 257 menjelaskan konvensi docstring yang baik. Perhatikan bahwa yang paling penting,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _13 yang mengakhiri dokumen multibaris harus berada di baris dengan sendirinya

    my_list = [
        1, 2, 3,
        4, 5, 6,
        ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
        )
    
    _9

  • Untuk dokumen one liner, harap simpan penutup
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    13 pada baris yang sama

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _0

Konvensi penamaan perpustakaan Python sedikit berantakan, jadi kami tidak akan pernah mendapatkan ini sepenuhnya konsisten – namun demikian, berikut adalah standar penamaan yang direkomendasikan saat ini. Modul dan paket baru (termasuk kerangka kerja pihak ketiga) harus ditulis dengan standar ini, tetapi jika pustaka yang ada memiliki gaya yang berbeda, konsistensi internal lebih disukai

Nama yang terlihat oleh pengguna sebagai bagian publik dari API harus mengikuti konvensi yang mencerminkan penggunaan, bukan implementasi

Ada banyak gaya penamaan yang berbeda. Ini membantu untuk dapat mengenali gaya penamaan apa yang digunakan, terlepas dari untuk apa mereka digunakan

Gaya penamaan berikut umumnya dibedakan

  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _15 (huruf kecil tunggal)
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _16 (huruf besar tunggal)
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _17
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _18
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _19
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _20
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    21 (atau CapWords, atau CamelCase – dinamai demikian karena tampilan hurufnya yang bergelombang ). Ini juga terkadang dikenal sebagai StudlyCaps

    Catatan. Saat menggunakan akronim di CapWords, huruf besar semua huruf akronim. Jadi HTTPServerError lebih baik daripada HttpServerError

  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _22 (berbeda dari Kata-kata Berhuruf Besar dengan huruf kecil awal. )
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _23 (jelek. )

Ada juga gaya menggunakan awalan pendek yang unik untuk mengelompokkan nama terkait. Ini tidak banyak digunakan dalam Python, tetapi disebutkan untuk kelengkapan. Misalnya, fungsi

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_24 mengembalikan tuple yang itemnya secara tradisional memiliki nama seperti
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
25,
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
26,
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
27 dan seterusnya. (Ini dilakukan untuk menekankan korespondensi dengan bidang struct system call POSIX, yang membantu pemrogram terbiasa dengan itu. )

Pustaka X11 menggunakan X terdepan untuk semua fungsi publiknya. Dalam Python, gaya ini umumnya dianggap tidak perlu karena nama atribut dan metode diawali dengan objek, dan nama fungsi diawali dengan nama modul

Selain itu, bentuk-bentuk khusus berikut yang menggunakan garis bawah di depan atau di belakang dikenali (ini umumnya dapat digabungkan dengan konvensi kasus apa pun)

  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _28. indikator “penggunaan internal” yang lemah. e. g.
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _29 tidak mengimpor objek yang namanya dimulai dengan garis bawah
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _30. digunakan oleh konvensi untuk menghindari konflik dengan kata kunci Python, mis. g

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _1

  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _31. saat menamai atribut kelas, panggil nama mangling (di dalam kelas FooBar,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    32 menjadi
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    33; lihat di bawah)
  • # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _34. objek atau atribut "ajaib" yang hidup di ruang nama yang dikontrol pengguna. e. g.
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _35,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    36 atau
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    37. Jangan pernah menciptakan nama seperti itu;

Jangan pernah menggunakan karakter 'l' (huruf kecil el), 'O' (huruf besar oh), atau 'I' (mata huruf besar) sebagai nama variabel karakter tunggal

Di beberapa font, karakter ini tidak dapat dibedakan dari angka satu dan nol. Saat tergoda untuk menggunakan 'l', gunakan 'L' sebagai gantinya

Pengidentifikasi yang digunakan di perpustakaan standar harus kompatibel dengan ASCII seperti yang dijelaskan dalam PEP 3131

Modul harus memiliki nama yang pendek dan semuanya dalam huruf kecil. Garis bawah dapat digunakan dalam nama modul jika meningkatkan keterbacaan. Paket-paket Python juga harus memiliki nama yang pendek dan semuanya ditulis dengan huruf kecil, meskipun penggunaan garis bawah tidak dianjurkan

Ketika modul ekstensi yang ditulis dalam C atau C++ memiliki modul Python yang menyertainya yang menyediakan level yang lebih tinggi (mis. g. lebih berorientasi objek), modul C/C++ memiliki garis bawah terdepan (mis. g.

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_38)

Nama kelas biasanya harus menggunakan konvensi CapWords

Konvensi penamaan untuk fungsi dapat digunakan sebagai gantinya dalam kasus di mana antarmuka didokumentasikan dan digunakan terutama sebagai callable

Perhatikan bahwa ada konvensi terpisah untuk nama bawaan. kebanyakan nama bawaan adalah kata tunggal (atau dua kata berjalan bersama), dengan konvensi CapWords hanya digunakan untuk nama pengecualian dan konstanta bawaan

Nama variabel tipe yang diperkenalkan di PEP 484 biasanya menggunakan CapWords yang lebih memilih nama pendek.

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_39,
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
40,
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
41. Direkomendasikan untuk menambahkan akhiran
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
42 atau
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
43 ke variabel yang digunakan untuk mendeklarasikan perilaku kovarian atau kontravarian.

my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
)
_2

Karena pengecualian harus berupa kelas, konvensi penamaan kelas berlaku di sini. Namun, Anda harus menggunakan akhiran "Kesalahan" pada nama pengecualian Anda (jika pengecualian tersebut sebenarnya adalah kesalahan)

(Mari berharap bahwa variabel-variabel ini dimaksudkan untuk digunakan di dalam satu modul saja. ) Konvensinya hampir sama dengan konvensi untuk fungsi

Modul yang dirancang untuk digunakan melalui

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_29 harus menggunakan mekanisme
# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
6 untuk mencegah pengeksporan global, atau gunakan konvensi yang lebih lama untuk mengawali global tersebut dengan garis bawah (yang mungkin ingin Anda lakukan untuk menunjukkan bahwa global ini adalah "modul non-publik")

Nama fungsi harus menggunakan huruf kecil, dengan kata-kata yang dipisahkan oleh garis bawah seperlunya untuk meningkatkan keterbacaan

Nama variabel mengikuti konvensi yang sama dengan nama fungsi

mixedCase hanya diperbolehkan dalam konteks di mana itu sudah menjadi gaya yang berlaku (mis. g. threading. py), untuk mempertahankan kompatibilitas mundur

Selalu gunakan

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_46 untuk argumen pertama ke metode instance

Selalu gunakan

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_47 untuk argumen pertama ke metode kelas

Jika nama argumen fungsi berbenturan dengan kata kunci yang dicadangkan, umumnya lebih baik untuk menambahkan satu garis bawah daripada menggunakan singkatan atau kerusakan ejaan. Jadi

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_48 lebih baik dari
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
49. (Mungkin lebih baik menghindari bentrokan seperti itu dengan menggunakan sinonim. )

Gunakan aturan penamaan fungsi. huruf kecil dengan kata-kata yang dipisahkan oleh garis bawah seperlunya untuk meningkatkan keterbacaan

Gunakan satu garis bawah utama hanya untuk metode non-publik dan variabel instan

Untuk menghindari bentrokan nama dengan subclass, gunakan dua garis bawah di depan untuk menjalankan aturan mangling nama Python

Python memotong nama-nama ini dengan nama kelas. jika kelas Foo memiliki atribut bernama

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_50, itu tidak dapat diakses oleh
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
51. (Pengguna yang bersikeras masih bisa mendapatkan akses dengan menelepon
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
52. ) Umumnya, garis bawah ganda di depan harus digunakan hanya untuk menghindari konflik nama dengan atribut di kelas yang dirancang untuk dijadikan subkelas

Catatan. ada beberapa kontroversi tentang penggunaan __names (lihat di bawah)

Konstanta biasanya didefinisikan pada tingkat modul dan ditulis dalam huruf besar semua dengan garis bawah memisahkan kata-kata. Contohnya termasuk

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
_53 dan
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
54

Selalu putuskan apakah metode kelas dan variabel instan (secara kolektif. "atribut") harus publik atau non-publik. Jika ragu, pilih non-publik;

Atribut publik adalah atribut yang Anda harapkan untuk digunakan oleh klien yang tidak terkait dengan kelas Anda, dengan komitmen Anda untuk menghindari perubahan yang tidak kompatibel ke belakang. Atribut non-publik adalah atribut yang tidak dimaksudkan untuk digunakan oleh pihak ketiga;

Kami tidak menggunakan istilah "pribadi" di sini, karena tidak ada atribut yang benar-benar pribadi di Python (tanpa jumlah pekerjaan yang umumnya tidak perlu)

Kategori atribut lainnya adalah yang merupakan bagian dari "subclass API" (sering disebut "dilindungi" dalam bahasa lain). Beberapa kelas dirancang untuk diwariskan, baik untuk memperluas atau memodifikasi aspek perilaku kelas. Saat mendesain kelas seperti itu, berhati-hatilah untuk membuat keputusan eksplisit tentang atribut mana yang bersifat publik, mana yang merupakan bagian dari API subkelas, dan mana yang benar-benar hanya untuk digunakan oleh kelas dasar Anda

Dengan mengingat hal ini, berikut adalah pedoman Pythonic

  • Atribut publik tidak boleh memiliki garis bawah di depan
  • Jika nama atribut publik Anda bertabrakan dengan kata kunci yang dicadangkan, tambahkan satu garis bawah di belakang ke nama atribut Anda. Ini lebih disukai daripada singkatan atau ejaan yang rusak. (Namun, terlepas dari aturan ini, 'cls' adalah ejaan yang lebih disukai untuk variabel atau argumen apa pun yang dikenal sebagai kelas, terutama argumen pertama untuk metode kelas. )

    Catatan 1. Lihat rekomendasi nama argumen di atas untuk metode kelas

  • Untuk atribut data publik sederhana, yang terbaik adalah mengekspos nama atribut saja, tanpa metode pengakses/mutator yang rumit. Perlu diingat bahwa Python menyediakan jalur mudah untuk peningkatan di masa mendatang, jika Anda menemukan bahwa atribut data sederhana perlu mengembangkan perilaku fungsional. Dalam hal ini, gunakan properti untuk menyembunyikan implementasi fungsional di balik sintaks akses atribut data sederhana

    Catatan 1. Cobalah untuk menjaga agar perilaku fungsional bebas dari efek samping, meskipun efek samping seperti caching umumnya baik-baik saja

    Catatan 2. Hindari menggunakan properti untuk operasi komputasi yang mahal;

  • Jika kelas Anda dimaksudkan untuk dijadikan subkelas, dan Anda memiliki atribut yang tidak ingin digunakan oleh subkelas, pertimbangkan untuk menamainya dengan garis bawah ganda di depan dan tanpa garis bawah di belakang. Ini memanggil algoritma penghancuran nama Python, di mana nama kelas dihancurkan menjadi nama atribut. Ini membantu menghindari tabrakan nama atribut jika subclass secara tidak sengaja berisi atribut dengan nama yang sama

    Catatan 1. Perhatikan bahwa hanya nama kelas sederhana yang digunakan dalam nama yang rusak, jadi jika sebuah subkelas memilih nama kelas dan nama atribut yang sama, Anda masih bisa mendapatkan tabrakan nama

    Catatan 2. Nama mangling dapat membuat penggunaan tertentu, seperti debugging dan

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    55, kurang nyaman. Namun nama algoritma mangling didokumentasikan dengan baik dan mudah dilakukan secara manual

    Catatan 3. Tidak semua orang suka mangling nama. Cobalah untuk menyeimbangkan kebutuhan untuk menghindari benturan nama yang tidak disengaja dengan potensi penggunaan oleh penelepon tingkat lanjut

Jaminan kompatibilitas mundur apa pun hanya berlaku untuk antarmuka publik. Oleh karena itu, penting bagi pengguna untuk dapat dengan jelas membedakan antara antarmuka publik dan internal

Antarmuka terdokumentasi dianggap publik, kecuali jika dokumentasi secara eksplisit menyatakannya sebagai antarmuka sementara atau internal yang dikecualikan dari jaminan kompatibilitas mundur yang biasa. Semua antarmuka yang tidak berdokumen harus dianggap internal

Untuk mendukung introspeksi dengan lebih baik, modul harus secara eksplisit mendeklarasikan nama di API publiknya menggunakan atribut

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
6. Menyetel
# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
_6 ke daftar kosong menunjukkan bahwa modul tidak memiliki API publik

Bahkan dengan

# Correct:
# easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)
_6 diatur dengan tepat, antarmuka internal (paket, modul, kelas, fungsi, atribut, atau nama lain) harus tetap diawali dengan satu garis bawah utama

Antarmuka juga dianggap internal jika ada ruang nama yang berisi (paket, modul, atau kelas) dianggap internal

Nama yang diimpor harus selalu dianggap sebagai detail implementasi. Modul lain tidak boleh bergantung pada akses tidak langsung ke nama yang diimpor tersebut kecuali mereka adalah bagian yang didokumentasikan secara eksplisit dari API modul yang memuatnya, seperti

# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
59 atau modul
# Wrong:

# Arguments on first line forbidden when not using vertical alignment.
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable.
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)
35 paket yang memperlihatkan fungsionalitas dari submodul

  • Kode harus ditulis dengan cara yang tidak merugikan implementasi Python lainnya (PyPy, Jython, IronPython, Cython, Psyco, dan semacamnya)

    Misalnya, jangan mengandalkan implementasi efisien dari penggabungan string di tempat CPython untuk pernyataan dalam bentuk

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    61 atau
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    62. Pengoptimalan ini rapuh bahkan di CPython (hanya berfungsi untuk beberapa jenis) dan tidak ada sama sekali dalam implementasi yang tidak menggunakan penghitungan ulang. Di bagian sensitif kinerja perpustakaan, formulir
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _63 harus digunakan sebagai gantinya. Ini akan memastikan bahwa penggabungan terjadi dalam waktu linier di berbagai implementasi

  • Perbandingan dengan lajang seperti Tidak ada harus selalu dilakukan dengan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    02 atau
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    03, tidak pernah dengan operator kesetaraan

    Juga, berhati-hatilah dalam menulis

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _66 ketika Anda benar-benar bermaksud
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    67 – e. g. saat menguji apakah variabel atau argumen yang default ke Tidak ada diatur ke beberapa nilai lain. Nilai lainnya mungkin memiliki tipe (seperti wadah) yang mungkin salah dalam konteks boolean

  • Gunakan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _03 operator daripada
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    69. Meskipun kedua ekspresi identik secara fungsional, yang pertama lebih mudah dibaca dan disukai

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _3

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _4

  • Saat menerapkan operasi pengurutan dengan banyak perbandingan, yang terbaik adalah menerapkan semua enam operasi (
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    70,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    71,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    72,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    73,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    74,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    75) daripada mengandalkan kode lain untuk hanya menjalankan perbandingan tertentu

    Untuk meminimalkan upaya yang terlibat, dekorator

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _76 menyediakan alat untuk menghasilkan metode perbandingan yang hilang

    PEP 207 menunjukkan bahwa aturan refleksivitas diasumsikan oleh Python. Dengan demikian, penerjemah dapat menukar

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _77 dengan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    78,
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    79 dengan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    80, dan dapat menukar argumen dari
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    81 dan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    82. Operasi
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    83 dan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    84 dijamin menggunakan operator
    # Correct:
    import os
    import sys
    
    4 dan fungsi
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    86 menggunakan operator
    # Correct:
    import os
    import sys
    
    5. Namun, yang terbaik adalah mengimplementasikan keenam operasi tersebut sehingga kebingungan tidak muncul dalam konteks lain

  • Selalu gunakan pernyataan def alih-alih pernyataan penugasan yang mengikat ekspresi lambda langsung ke pengidentifikasi

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _5

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _6

    The first form means that the name of the resulting function object is specifically ‘f’ instead of the generic ‘’. This is more useful for tracebacks and string representations in general. The use of the assignment statement eliminates the sole benefit a lambda expression can offer over an explicit def statement (i.e. that it can be embedded inside a larger expression)

  • Dapatkan pengecualian dari
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _88 daripada
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    89. Warisan langsung dari
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _89 dicadangkan untuk pengecualian di mana menangkap mereka hampir selalu merupakan hal yang salah untuk dilakukan

    Merancang hierarki pengecualian berdasarkan perbedaan yang mungkin diperlukan oleh kode yang menangkap pengecualian, daripada lokasi tempat pengecualian dimunculkan. Bertujuan untuk menjawab pertanyaan "Apa yang salah?"

    Konvensi penamaan kelas berlaku di sini, meskipun Anda harus menambahkan akhiran "Error" ke kelas pengecualian Anda jika pengecualiannya adalah kesalahan. Pengecualian non-kesalahan yang digunakan untuk kontrol aliran non-lokal atau bentuk pensinyalan lainnya tidak memerlukan akhiran khusus

  • Gunakan rantai pengecualian dengan tepat.
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _91 harus digunakan untuk menunjukkan penggantian eksplisit tanpa kehilangan traceback asli

    Saat dengan sengaja mengganti pengecualian dalam (menggunakan

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    92), pastikan detail yang relevan ditransfer ke pengecualian baru (seperti mempertahankan nama atribut saat mengonversi KeyError menjadi AttributeError, atau menyematkan teks pengecualian asli dalam pesan pengecualian baru)

  • Saat menangkap pengecualian, sebutkan pengecualian khusus bila memungkinkan alih-alih menggunakan klausa
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    93 kosong

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _7

    Klausa

    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _93 kosong akan menangkap pengecualian SystemExit dan KeyboardInterrupt, membuatnya lebih sulit untuk menginterupsi program dengan Control-C, dan dapat menyamarkan masalah lain. Jika Anda ingin menangkap semua pengecualian yang menandakan kesalahan program, gunakan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    95 (kecuali kecuali sama dengan
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    96)

    Aturan praktis yang baik adalah membatasi penggunaan klausa 'kecuali' telanjang menjadi dua kasus

    1. Jika penangan pengecualian akan mencetak atau mencatat traceback;
    2. Jika kode perlu melakukan beberapa pekerjaan pembersihan, tetapi biarkan pengecualian menyebar ke atas dengan
      # Wrong:
      
      # Arguments on first line forbidden when not using vertical alignment.
      foo = long_function_name(var_one, var_two,
          var_three, var_four)
      
      # Further indentation required as indentation is not distinguishable.
      def long_function_name(
          var_one, var_two, var_three,
          var_four):
          print(var_one)
      
      97.
      # Wrong:
      
      # Arguments on first line forbidden when not using vertical alignment.
      foo = long_function_name(var_one, var_two,
          var_three, var_four)
      
      # Further indentation required as indentation is not distinguishable.
      def long_function_name(
          var_one, var_two, var_three,
          var_four):
          print(var_one)
      
      _98 bisa menjadi cara yang lebih baik untuk menangani kasus ini
  • Saat menangkap kesalahan sistem operasi, lebih suka hierarki pengecualian eksplisit yang diperkenalkan di Python 3. 3 introspeksi terhadap
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    _99 nilai
  • Selain itu, untuk semua klausa coba/kecuali, batasi klausa
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    00 ke jumlah minimum mutlak kode yang diperlukan. Sekali lagi, ini menghindari masking bug

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _8

    my_list = [
        1, 2, 3,
        4, 5, 6,
    ]
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    )
    
    _9

  • Ketika sumber daya bersifat lokal untuk bagian kode tertentu, gunakan pernyataan
    # Correct:
    # easy to match operators with operands
    income = (gross_wages
              + taxable_interest
              + (dividends - qualified_dividends)
              - ira_deduction
              - student_loan_interest)
    
    1 untuk memastikannya dibersihkan dengan segera dan andal setelah digunakan. Pernyataan coba/akhirnya juga dapat diterima
  • Manajer konteks harus dipanggil melalui fungsi atau metode terpisah setiap kali mereka melakukan sesuatu selain memperoleh dan melepaskan sumber daya

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _0

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _1

    Contoh terakhir tidak memberikan informasi apa pun untuk menunjukkan bahwa metode

    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    02 dan
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    03 melakukan sesuatu selain menutup koneksi setelah transaksi. Menjadi eksplisit penting dalam kasus ini

  • Konsisten dalam pernyataan pengembalian. Entah semua pernyataan pengembalian dalam suatu fungsi harus mengembalikan ekspresi, atau tidak satupun dari mereka harus. Jika ada pernyataan pengembalian yang mengembalikan ekspresi, pernyataan pengembalian apa pun di mana tidak ada nilai yang dikembalikan harus secara eksplisit menyatakan ini sebagai
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    04, dan pernyataan pengembalian yang eksplisit harus ada di akhir fungsi (jika dapat dijangkau)

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _2

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _3

  • Gunakan
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    _05 dan
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    06 alih-alih memotong string untuk memeriksa prefiks atau sufiks

    dimulai dengan() dan diakhiridengan() lebih bersih dan lebih sedikit rawan kesalahan

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _4

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _5

  • Perbandingan tipe objek harus selalu menggunakan isinstance() daripada membandingkan tipe secara langsung

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _6

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _7

  • Untuk urutan, (string, daftar, tupel), gunakan fakta bahwa urutan kosong adalah salah

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _8

    with open('/path/to/some/file/you/want/to/read') as file_1, \
         open('/path/to/some/file/being/written', 'w') as file_2:
        file_2.write(file_1.read())
    
    _9

  • Jangan menulis literal string yang mengandalkan spasi kosong yang signifikan. Spasi kosong seperti itu secara visual tidak dapat dibedakan dan beberapa editor (atau baru-baru ini, reident. py) akan memotongnya
  • Jangan bandingkan nilai boolean dengan True atau False menggunakan
    # Correct:
    import os
    import sys
    
    3

    # Wrong:
    # operators sit far away from their operands
    income = (gross_wages +
              taxable_interest +
              (dividends - qualified_dividends) -
              ira_deduction -
              student_loan_interest)
    
    0

    # Wrong:
    # operators sit far away from their operands
    income = (gross_wages +
              taxable_interest +
              (dividends - qualified_dividends) -
              ira_deduction -
              student_loan_interest)
    
    1

    Lebih buruk

    # Wrong:
    # operators sit far away from their operands
    income = (gross_wages +
              taxable_interest +
              (dividends - qualified_dividends) -
              ira_deduction -
              student_loan_interest)
    
    2

  • Penggunaan pernyataan kontrol aliran
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    08/
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    09/
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    
    10 dalam paket akhirnya dari
    # Wrong:
    
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)
    
    98, di mana pernyataan kontrol aliran akan melompat keluar dari paket akhirnya, tidak disarankan. Ini karena pernyataan seperti itu secara implisit akan membatalkan pengecualian aktif apa pun yang menyebar melalui paket akhirnya

    # Wrong:
    # operators sit far away from their operands
    income = (gross_wages +
              taxable_interest +
              (dividends - qualified_dividends) -
              ira_deduction -
              student_loan_interest)
    
    _3

Dengan diterimanya PEP 484, aturan gaya untuk anotasi fungsi telah berubah

  • Anotasi fungsi harus menggunakan sintaks PEP 484 (ada beberapa rekomendasi pemformatan untuk anotasi di bagian sebelumnya)
  • Eksperimen dengan gaya anotasi yang direkomendasikan sebelumnya di PEP ini tidak lagi dianjurkan
  • Namun, di luar stdlib, eksperimen dalam aturan PEP 484 kini didorong. Misalnya, menandai perpustakaan atau aplikasi pihak ketiga yang besar dengan anotasi tipe gaya PEP 484, meninjau betapa mudahnya menambahkan anotasi tersebut, dan mengamati apakah kehadirannya meningkatkan pemahaman kode
  • Pustaka standar Python harus konservatif dalam mengadopsi anotasi seperti itu, tetapi penggunaannya diizinkan untuk kode baru dan untuk pemfaktoran ulang besar
  • Untuk kode yang ingin menggunakan anotasi fungsi yang berbeda, disarankan untuk memberi komentar pada formulir

    # Wrong:
    # operators sit far away from their operands
    income = (gross_wages +
              taxable_interest +
              (dividends - qualified_dividends) -
              ira_deduction -
              student_loan_interest)
    
    _4

    di dekat bagian atas file; . (Cara yang lebih halus untuk menonaktifkan keluhan dari pemeriksa tipe dapat ditemukan di PEP 484. )

  • Seperti linter, pemeriksa tipe adalah alat opsional dan terpisah. Penerjemah Python secara default tidak boleh mengeluarkan pesan apa pun karena pemeriksaan tipe dan tidak boleh mengubah perilakunya berdasarkan anotasi
  • Pengguna yang tidak ingin menggunakan pemeriksa tipe bebas untuk mengabaikannya. Namun, diharapkan pengguna paket perpustakaan pihak ketiga mungkin ingin menjalankan pemeriksa tipe atas paket tersebut. Untuk tujuan ini PEP 484 merekomendasikan penggunaan file rintisan. . pyi file yang dibaca oleh pemeriksa tipe dalam preferensi yang sesuai. file py. File rintisan dapat didistribusikan dengan perpustakaan, atau secara terpisah (dengan izin penulis perpustakaan) melalui repo yang diketik

PEP 526 memperkenalkan anotasi variabel. Rekomendasi gaya untuk mereka serupa dengan yang ada pada anotasi fungsi yang dijelaskan di atas

Apakah garis bawah diperbolehkan dalam nama variabel di Python?

Aturan untuk variabel Python. Nama variabel harus dimulai dengan huruf atau karakter garis bawah. Nama variabel tidak boleh dimulai dengan angka. Nama variabel hanya boleh berisi karakter alfanumerik dan garis bawah (A-z, 0-9, dan _ )

Kapan menggunakan _ dan __ dengan Python?

Ganda Trailing Underscore __var__. Menunjukkan metode khusus yang ditentukan oleh bahasa Python. Garis bawah _. Digunakan sebagai nama untuk variabel sementara .

Haruskah saya menggunakan _ dengan Python?

Single Post Underscore digunakan untuk menamai variabel Anda sebagai Kata Kunci Python dan untuk menghindari bentrok dengan menambahkan garis bawah di akhir nama variabel Anda .

Apa itu _ sebelum variabel di Python?

Satu garis bawah di depan variabel, fungsi, atau nama metode berarti bahwa objek ini digunakan secara internal . Ini lebih merupakan petunjuk sintaks untuk pemrogram dan tidak ditegakkan oleh juru bahasa Python yang berarti bahwa objek ini masih dapat diakses dengan satu cara dari skrip lain.