Cara menggunakan CANCATINATE pada Python

8.1. Kesalahan Sintaksis

Kesalahan sintaksis, juga dikenal sebagai kesalahan penguraian parsing, mungkin merupakan jenis keluhan paling umum yang Anda dapatkan saat Anda masih belajar Python:

>>> while True print['Hello world']
  File "", line 1
    while True print['Hello world']
                   ^
SyntaxError: invalid syntax

Pengurai parser mengulangi baris yang menyinggung dan menampilkan sedikit 'arrow' yang menunjuk pada titik paling awal di baris di mana kesalahan terdeteksi. Kesalahan disebabkan oleh [atau setidaknya terdeteksi pada] token preceding panah: dalam contoh, kesalahan terdeteksi pada fungsi , karena titik dua [

>>> while True:
...     try:
...         x = int[input["Please enter a number: "]]
...         break
...     except ValueError:
...         print["Oops!  That was no valid number.  Try again..."]
...

8.2. Pengecualian

Bahkan jika suatu pernyataan atau ungkapan secara sintaksis benar, itu dapat menyebabkan kesalahan ketika suatu usaha dilakukan untuk mengeksekusinya. Kesalahan yang terdeteksi selama eksekusi disebut exceptions dan tidak fatal tanpa syarat: Anda akan segera belajar cara menanganinya dalam program Python. Namun, sebagian besar pengecualian tidak ditangani oleh program, dan menghasilkan pesan kesalahan seperti yang ditunjukkan di sini:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

Baris terakhir dari pesan kesalahan menunjukkan apa yang terjadi. Pengecualian ada berbagai jenis yang berbeda, dan tipe dicetak sebagai bagian dari pesan: tipe dalam contoh adalah , dan . String yang dicetak sebagai jenis pengecualian adalah nama pengecualian bawaan yang terjadi. Ini berlaku untuk semua pengecualian bawaan, tetapi tidak harus sama untuk pengecualian yang dibuat pengguna [meskipun ini adalah konvensi yang bermanfaat]. Nama pengecualian standar adalah pengidentifikasi bawaan [bukan kata kunci yang dipesan reserved keyword].

Sisa baris menyediakan detail berdasarkan jenis pengecualian dan apa yang menyebabkannya.

The preceding part of the error message shows the context where the exception occurred, in the form of a stack traceback. In general it contains a stack traceback listing source lines; however, it will not display lines read from standard input.

memberikan daftar pengecualian bawaan dan artinya.

8.3. Menangani Pengecualian

Dimungkinkan untuk menulis program yang menangani pengecualian yang dipilih. Lihatlah contoh berikut, yang meminta masukan dari pengguna sampai integer yang valid telah dimasukkan, tetapi memungkinkan pengguna untuk menghentikan program [menggunakan Control-C atau apa pun yang didukung sistem operasi]; perhatikan bahwa gangguan yang dibuat pengguna ditandai dengan munculnya pengecualian .

>>> while True:
...     try:
...         x = int[input["Please enter a number: "]]
...         break
...     except ValueError:
...         print["Oops!  That was no valid number.  Try again..."]
...

Pernyataan berfungsi sebagai berikut.

• Pertama, try clause [pernyataan[-pernyataan] di antara kata kunci dan ] dieksekusi.

• Jika tidak ada pengecualian terjadi, except clause dilewati dan eksekusi pernyataan :keyword: try selesai.

• If an exception occurs during execution of the clause, the rest of the clause is skipped. Then, if its type matches the exception named after the keyword, the except clause is executed, and then execution continues after the try/except block.

• If an exception occurs which does not match the exception named in the except clause, it is passed on to outer statements; if no handler is found, it is an unhandled exception and execution stops with a message as shown above.

A statement may have more than one except clause, to specify handlers for different exceptions. At most one handler will be executed. Handlers only handle exceptions that occur in the corresponding try clause, not in other handlers of the same

>>> while True:
...     try:
...         x = int[input["Please enter a number: "]]
...         break
...     except ValueError:
...         print["Oops!  That was no valid number.  Try again..."]
...

... except [RuntimeError, TypeError, NameError]:
...     pass

A class in an clause is compatible with an exception if it is the same class or a base class thereof [but not the other way around --- an except clause listing a derived class is not compatible with a base class]. For example, the following code will print B, C, D in that order:

class B[Exception]:
    pass

class C[B]:
    pass

class D[C]:
    pass

for cls in [B, C, D]:
    try:
        raise cls[]
    except D:
        print["D"]
    except C:
        print["C"]
    except B:
        print["B"]

Note that if the except clauses were reversed [with

... except [RuntimeError, TypeError, NameError]:
...     pass

All exceptions inherit from , and so it can be used to serve as a wildcard. Use this with extreme caution, since it is easy to mask a real programming error in this way! It can also be used to print an error message and then re-raise the exception [allowing a caller to handle the exception as well]:

import sys

try:
    f = open['myfile.txt']
    s = f.readline[]
    i = int[s.strip[]]
except OSError as err:
    print["OS error: {0}".format[err]]
except ValueError:
    print["Could not convert data to an integer."]
except BaseException as err:
    print[f"Unexpected {err=}, {type[err]=}"]
    raise

Alternatively the last except clause may omit the exception name[s], however the exception value must then be retrieved from

... except [RuntimeError, TypeError, NameError]:
...     pass

The ... statement has an optional else clause, which, when present, must follow all except clauses. It is useful for code that must be executed if the try clause does not raise an exception. For example:

for arg in sys.argv[1:]:
    try:
        f = open[arg, 'r']
    except OSError:
        print['cannot open', arg]
    else:
        print[arg, 'has', len[f.readlines[]], 'lines']
        f.close[]

Penggunaan klausa

class B[Exception]:
    pass

class C[B]:
    pass

class D[C]:
    pass

for cls in [B, C, D]:
    try:
        raise cls[]
    except D:
        print["D"]
    except C:
        print["C"]
    except B:
        print["B"]

>>> while True:
...     try:
...         x = int[input["Please enter a number: "]]
...         break
...     except ValueError:
...         print["Oops!  That was no valid number.  Try again..."]
...

Ketika pengecualian terjadi, itu mungkin memiliki nilai terkait, juga dikenal sebagai argument pengecualian. Kehadiran dan jenis argumen tergantung pada jenis pengecualian.

The except clause may specify a variable after the exception name. The variable is bound to an exception instance with the arguments stored in

class B[Exception]:
    pass

class C[B]:
    pass

class D[C]:
    pass

for cls in [B, C, D]:
    try:
        raise cls[]
    except D:
        print["D"]
    except C:
        print["C"]
    except B:
        print["B"]

class B[Exception]:
    pass

class C[B]:
    pass

class D[C]:
    pass

for cls in [B, C, D]:
    try:
        raise cls[]
    except D:
        print["D"]
    except C:
        print["C"]
    except B:
        print["B"]

class B[Exception]:
    pass

class C[B]:
    pass

class D[C]:
    pass

for cls in [B, C, D]:
    try:
        raise cls[]
    except D:
        print["D"]
    except C:
        print["C"]
    except B:
        print["B"]

>>> try:
...     raise Exception['spam', 'eggs']
... except Exception as inst:
...     print[type[inst]]    # the exception instance
...     print[inst.args]     # arguments stored in .args
...     print[inst]          # __str__ allows args to be printed directly,
...                          # but may be overridden in exception subclasses
...     x, y = inst.args     # unpack args
...     print['x =', x]
...     print['y =', y]
...

['spam', 'eggs']
['spam', 'eggs']
x = spam
y = eggs

Jika pengecualian memiliki argumen, mereka dicetak sebagai bagian terakhir ['detail'] dari pesan untuk pengecualian yang tidak ditangani.

Exception handlers don't just handle exceptions if they occur immediately in the try clause, but also if they occur inside functions that are called [even indirectly] in the try clause. For example:

>>> def this_fails[]:
...     x = 1/0
...
>>> try:
...     this_fails[]
... except ZeroDivisionError as err:
...     print['Handling run-time error:', err]
...
Handling run-time error: division by zero

8.4. Memunculkan Pengecualian

Pernyataan memungkinkan programmer untuk memaksa pengecualian yang ditentukan terjadi. Sebagai contoh:

>>> raise NameError['HiThere']
Traceback [most recent call last]:
  File "", line 1, in 
NameError: HiThere

Satu-satunya argumen untuk menunjukkan pengecualian yang dimunculkan. Ini harus berupa instance pengecualian atau kelas pengecualian [kelas yang berasal dari ]. Jika kelas pengecualian dikirimkan, itu akan secara implisit diinstansiasi dengan memanggil pembangunnya constructor tanpa argumen:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

Jika Anda perlu menentukan apakah pengecualian muncul tetapi tidak bermaksud menanganinya, bentuk yang lebih sederhana dari pernyataan memungkinkan Anda untuk memunculkan kembali pengecualian:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

8.5. Exception Chaining

If an unhandled exception occurs inside an section, it will have the exception being handled attached to it and included in the error message:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

To indicate that an exception is a direct consequence of another, the statement allows an optional clause:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

This can be useful when you are transforming exceptions. For example:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

It also allows disabling automatic exception chaining using the

import sys

try:
    f = open['myfile.txt']
    s = f.readline[]
    i = int[s.strip[]]
except OSError as err:
    print["OS error: {0}".format[err]]
except ValueError:
    print["Could not convert data to an integer."]
except BaseException as err:
    print[f"Unexpected {err=}, {type[err]=}"]
    raise

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

For more information about chaining mechanics, see .

8.6. Pengecualian yang Ditentukan Pengguna

Program dapat memberi nama pengecualian mereka sendiri dengan membuat kelas pengecualian baru [lihat tut-class untuk informasi lebih lanjut tentang kelas Python]. Pengecualian biasanya berasal dari kelas , baik secara langsung atau tidak langsung.

Exception classes can be defined which do anything any other class can do, but are usually kept simple, often only offering a number of attributes that allow information about the error to be extracted by handlers for the exception.

Sebagian besar pengecualian didefinisikan dengan nama yang diakhiri dengan "Error", mirip dengan penamaan pengecualian standar.

Banyak modul standar menentukan pengecualian mereka sendiri untuk melaporkan kesalahan yang mungkin terjadi pada fungsi yang mereka tetapkan. Informasi lebih lanjut tentang kelas disajikan dalam bab tut-class.

8.7. Mendefinisikan Tindakan Pembersihan

Pernyataan memiliki klausa opsional lain yang dimaksudkan untuk menentukan tindakan pembersihan yang harus dijalankan dalam semua keadaan. Sebagai contoh:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

Jika ada klausa , klausa untuk

import sys

try:
    f = open['myfile.txt']
    s = f.readline[]
    i = int[s.strip[]]
except OSError as err:
    print["OS error: {0}".format[err]]
except ValueError:
    print["Could not convert data to an integer."]
except BaseException as err:
    print[f"Unexpected {err=}, {type[err]=}"]
    raise

import sys

try:
    f = open['myfile.txt']
    s = f.readline[]
    i = int[s.strip[]]
except OSError as err:
    print["OS error: {0}".format[err]]
except ValueError:
    print["Could not convert data to an integer."]
except BaseException as err:
    print[f"Unexpected {err=}, {type[err]=}"]
    raise

>>> while True:
...     try:
...         x = int[input["Please enter a number: "]]
...         break
...     except ValueError:
...         print["Oops!  That was no valid number.  Try again..."]
...

• Jika pengecualian terjadi selama eksekusi klausa untuk :keyword: !try, maka pengecualian tersebut dapat ditangani oleh klausa . Jika pengecualian tidak ditangani oleh klausa :keyword: !except, maka pengecualian dimunculkan kembali setelah klausa

  import sys
  
  try:
      f = open['myfile.txt']
      s = f.readline[]
      i = int[s.strip[]]
  except OSError as err:
      print["OS error: {0}".format[err]]
  except ValueError:
      print["Could not convert data to an integer."]
  except BaseException as err:
      print[f"Unexpected {err=}, {type[err]=}"]
      raise
  

  7 dieksekusi.

• Pengecualian dapat terjadi selama pelaksanaan klausa

  >>> while True:
  ...     try:
  ...         x = int[input["Please enter a number: "]]
  ...         break
  ...     except ValueError:
  ...         print["Oops!  That was no valid number.  Try again..."]
  ...
  

  9 atau

  class B[Exception]:
      pass
  
  class C[B]:
      pass
  
  class D[C]:
      pass
  
  for cls in [B, C, D]:
      try:
          raise cls[]
      except D:
          print["D"]
      except C:
          print["C"]
      except B:
          print["B"]
  

  1. Sekali lagi, pengecualian akan muncul kembali setelah klausa

  import sys
  
  try:
      f = open['myfile.txt']
      s = f.readline[]
      i = int[s.strip[]]
  except OSError as err:
      print["OS error: {0}".format[err]]
  except ValueError:
      print["Could not convert data to an integer."]
  except BaseException as err:
      print[f"Unexpected {err=}, {type[err]=}"]
      raise
  

  7 telah dieksekusi.

• If the

  import sys
  
  try:
      f = open['myfile.txt']
      s = f.readline[]
      i = int[s.strip[]]
  except OSError as err:
      print["OS error: {0}".format[err]]
  except ValueError:
      print["Could not convert data to an integer."]
  except BaseException as err:
      print[f"Unexpected {err=}, {type[err]=}"]
      raise
  

  7 clause executes a , or statement, exceptions are not re-raised.

• Jika pernyataan klausa untuk

  >>> while True:
  ...     try:
  ...         x = int[input["Please enter a number: "]]
  ...         break
  ...     except ValueError:
  ...         print["Oops!  That was no valid number.  Try again..."]
  ...
  

  7 mencapai klausa , atau :keyword:` return` maka, pernyataan untuk klausa

  import sys
  
  try:
      f = open['myfile.txt']
      s = f.readline[]
      i = int[s.strip[]]
  except OSError as err:
      print["OS error: {0}".format[err]]
  except ValueError:
      print["Could not convert data to an integer."]
  except BaseException as err:
      print[f"Unexpected {err=}, {type[err]=}"]
      raise
  

  7 akan dieksekusi sebelum

  for arg in sys.argv[1:]:
      try:
          f = open[arg, 'r']
      except OSError:
          print['cannot open', arg]
      else:
          print[arg, 'has', len[f.readlines[]], 'lines']
          f.close[]
  

  8,

  for arg in sys.argv[1:]:
      try:
          f = open[arg, 'r']
      except OSError:
          print['cannot open', arg]
      else:
          print[arg, 'has', len[f.readlines[]], 'lines']
          f.close[]
  

  9 atau

  >>> try:
  ...     raise Exception['spam', 'eggs']
  ... except Exception as inst:
  ...     print[type[inst]]    # the exception instance
  ...     print[inst.args]     # arguments stored in .args
  ...     print[inst]          # __str__ allows args to be printed directly,
  ...                          # but may be overridden in exception subclasses
  ...     x, y = inst.args     # unpack args
  ...     print['x =', x]
  ...     print['y =', y]
  ...
  
  ['spam', 'eggs']
  ['spam', 'eggs']
  x = spam
  y = eggs
  

  0 dieksekusi.

• Jika klausa untuk :keyword:!finally` telah menyertakan pernyataan

  >>> try:
  ...     raise Exception['spam', 'eggs']
  ... except Exception as inst:
  ...     print[type[inst]]    # the exception instance
  ...     print[inst.args]     # arguments stored in .args
  ...     print[inst]          # __str__ allows args to be printed directly,
  ...                          # but may be overridden in exception subclasses
  ...     x, y = inst.args     # unpack args
  ...     print['x =', x]
  ...     print['y =', y]
  ...
  
  ['spam', 'eggs']
  ['spam', 'eggs']
  x = spam
  y = eggs
  

  0, nilai yang dikembalikan akan menjadi salah satu dari pernyataan untuk

  import sys
  
  try:
      f = open['myfile.txt']
      s = f.readline[]
      i = int[s.strip[]]
  except OSError as err:
      print["OS error: {0}".format[err]]
  except ValueError:
      print["Could not convert data to an integer."]
  except BaseException as err:
      print[f"Unexpected {err=}, {type[err]=}"]
      raise
  

  7 dan dari klausa

  >>> try:
  ...     raise Exception['spam', 'eggs']
  ... except Exception as inst:
  ...     print[type[inst]]    # the exception instance
  ...     print[inst.args]     # arguments stored in .args
  ...     print[inst]          # __str__ allows args to be printed directly,
  ...                          # but may be overridden in exception subclasses
  ...     x, y = inst.args     # unpack args
  ...     print['x =', x]
  ...     print['y =', y]
  ...
  
  ['spam', 'eggs']
  ['spam', 'eggs']
  x = spam
  y = eggs
  

  0, bukan nilai dari

  >>> while True:
  ...     try:
  ...         x = int[input["Please enter a number: "]]
  ...         break
  ...     except ValueError:
  ...         print["Oops!  That was no valid number.  Try again..."]
  ...
  

  7 pernayataan untuk

  >>> try:
  ...     raise Exception['spam', 'eggs']
  ... except Exception as inst:
  ...     print[type[inst]]    # the exception instance
  ...     print[inst.args]     # arguments stored in .args
  ...     print[inst]          # __str__ allows args to be printed directly,
  ...                          # but may be overridden in exception subclasses
  ...     x, y = inst.args     # unpack args
  ...     print['x =', x]
  ...     print['y =', y]
  ...
  
  ['spam', 'eggs']
  ['spam', 'eggs']
  x = spam
  y = eggs
  

  0.

Sebagai contoh:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

Contoh yang lebih rumit:

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

Seperti yang Anda lihat, klausa dieksekusi dalam peristiwa apa pun. yang ditimbulkan dengan membagi dua string tidak ditangani oleh klausa dan karenanya kembali muncul setelah klausa

import sys

try:
    f = open['myfile.txt']
    s = f.readline[]
    i = int[s.strip[]]
except OSError as err:
    print["OS error: {0}".format[err]]
except ValueError:
    print["Could not convert data to an integer."]
except BaseException as err:
    print[f"Unexpected {err=}, {type[err]=}"]
    raise

Dalam aplikasi dunia nyata, klausa berguna untuk melepaskan sumber daya eksternal [seperti berkas atau koneksi jaringan], terlepas dari apakah penggunaan sumber daya tersebut berhasil.

8.8. Tindakan Pembersihan yang Sudah Ditentukan

Beberapa objek mendefinisikan tindakan pembersihan standar yang harus dilakukan ketika objek tidak lagi diperlukan, terlepas dari apakah operasi menggunakan objek berhasil atau gagal. Lihatlah contoh berikut, yang mencoba membuka berkas dan mencetak isinya ke layar.

>>> 10 * [1/0]
Traceback [most recent call last]:
  File "", line 1, in 
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback [most recent call last]:
  File "", line 1, in 
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: can only concatenate str [not "int"] to str

Masalah dengan kode ini adalah bahwa ia membiarkan berkas terbuka untuk jumlah waktu yang tidak ditentukan setelah bagian kode ini selesai dieksekusi. Ini bukan masalah dalam skrip sederhana, tetapi bisa menjadi masalah untuk aplikasi yang lebih besar. Pernyataan memungkinkan objek seperti berkas digunakan dengan cara yang memastikan mereka selalu dibersihkan secepatnya dan dengan benar.

>>> while True:
...     try:
...         x = int[input["Please enter a number: "]]
...         break
...     except ValueError:
...         print["Oops!  That was no valid number.  Try again..."]
...

Setelah pernyataan dieksekusi, file f selalu ditutup, bahkan jika ada masalah saat pemrosesan baris-baris. Objek yang, seperti berkas-berkas, memberikan tindakan pembersihan yang telah ditentukan, akan menunjukkan ini dalam dokumentasinya.

Apa itu append pada python?

Apa itu array di Python?