Fungsi Bawaan
*************

Interpreter Python memiliki sejumlah fungsi dan tipe bawaan di
dalamnya yang selalu tersedia. Mereka terdaftar di sini dalam urutan
abjad.

+---------------------+-------------------+--------------------+--------------------+----------------------+
|                     |                   | Fungsi Bawaan      |                    |                      |
|=====================|===================|====================|====================|======================|
| "abs()"             | "delattr()"       | "hash()"           | "memoryview()"     | "set()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "all()"             | "dict()"          | "help()"           | "min()"            | "setattr()"          |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "any()"             | "dir()"           | "hex()"            | "next()"           | "slice()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "ascii()"           | "divmod()"        | "id()"             | "object()"         | "sorted()"           |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bin()"             | "enumerate()"     | "input()"          | "oct()"            | "staticmethod()"     |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bool()"            | "eval()"          | "int()"            | "open()"           | "str()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "breakpoint()"      | "exec()"          | "isinstance()"     | "ord()"            | "sum()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bytearray()"       | "filter()"        | "issubclass()"     | "pow()"            | "super()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bytes()"           | "float()"         | "iter()"           | "print()"          | "tuple()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "callable()"        | "format()"        | "len()"            | "property()"       | "type()"             |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "chr()"             | "frozenset()"     | "list()"           | "range()"          | "vars()"             |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "classmethod()"     | "getattr()"       | "locals()"         | "repr()"           | "zip()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "compile()"         | "globals()"       | "map()"            | "reversed()"       | "__import__()"       |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "complex()"         | "hasattr()"       | "max()"            | "round()"          |                      |
+---------------------+-------------------+--------------------+--------------------+----------------------+

abs(x)

   Return the absolute value of a number.  The argument may be an
   integer or a floating point number.  If the argument is a complex
   number, its magnitude is returned. If *x* defines "__abs__()",
   "abs(x)" returns "x.__abs__()".

all(iterable)

   Kembalikan "True" jika semua elemen dari *iterable* bernilai benar
   (atau jika *iterable* kosong). Setara dengan:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

any(iterable)

   Kembalikan "True" jika ada elemen dari *iterable* bernilai benar.
   Jika *iterable* kosong, kembalikan "False". Setara dengan:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

ascii(object)

   Sebagai "repr()", kembalikan string yang berisi representasi objek
   yang dapat dicetak, tetapi memisahkan karakter non-ASCII dalam
   string yang dikembalikan oleh "repr()" menggunakan pemisah "\x",
   "\u" atau "\U". Ini menghasilkan string yang mirip dengan yang
   dikembalikan oleh "repr()" di Python 2.

bin(x)

   Ubah angka bulat atau integer menjadi string biner yang diawali
   dengan "0b". Hasilnya adalah ekspresi Python yang valid. Jika *x*
   bukan objek Python :class: *int*, ia harus mendefinisikan metode
   "__index__()" yang mengembalikan integer. Beberapa contoh:

   >>> bin(3)
   '0b11'
   >>> bin(-10)
   '-0b1010'

   Jika awalan "0b" diinginkan atau tidak, Anda dapat menggunakan
   salah satu dari cara berikut.

   >>> format(14, '#b'), format(14, 'b')
   ('0b1110', '1110')
   >>> f'{14:#b}', f'{14:b}'
   ('0b1110', '1110')

   Lihat juga "format()" untuk informasi lebih lanjut.

class bool([x])

   Kembalikan nilai Boolean, mis. salah satu dari "True" atau "False".
   *x* dikonversi menggunakan standar truth testing procedure. Jika
   *x* salah atau dihilangkan, ini mengembalikan "False"; sebaliknya
   mengembalikan "True". Kelas "bool" adalah subkelas dari "int"
   (lihat Numeric Types --- int, float, complex). Tidak dapat di-
   subkelas-kan lebih lanjut. Satu-satunya *instance* adalah "False"
   dan "True" (lihat Nilai Boolean).

   Berubah pada versi 3.7: *x* sekarang menjadi parameter sesuai-
   posisi.

breakpoint(*args, **kws)

   Fungsi ini mengarahkan Anda ke *debugger* di situs pemanggil.
   Secara khusus, ia memanggil "sys.breakpointhook()", melewati "args"
   dan "kws" langsung. Secara default, "sys.breakpointhook()"
   memanggil "pdb.set_trace()" tanpa mengharapkan argumen. Dalam hal
   ini, ini murni fungsi kenyamanan sehingga Anda tidak perlu
   mengimpor secara eksplisit "pdb" atau mengetikkan sebanyak mungkin
   kode untuk masuk ke debugger. Namun, "sys.breakpointhook()" dapat
   diatur ke beberapa fungsi lain dan "breakpoint()" secara otomatis
   akan memanggil itu, memungkinkan Anda untuk masuk ke debugger
   pilihan.

   Memunculkan auditing event "builtins.breakpoint" dengan argumen
   "breakpointhook".

   Baru pada versi 3.7.

class bytearray([source[, encoding[, errors]]])

   Kembalikan array byte baru. Kelas "bytearray" adalah urutan
   bilangan bulat yang dapat berubah dalam kisaran 0 <= x <256. Ia
   memiliki sebagian besar metode urutan-urutan yang dapat berubah,
   yang dijelaskan dalam Mutable Sequence Types, dan juga sebagian
   besar metode yang dimiliki oleh "bytes", lihat Bytes and Bytearray
   Operations.

   Parameter opsional *source* dapat digunakan untuk menginisialisasi
   array dengan beberapa cara berbeda:

   * Jika ini adalah *string*, Anda juga harus memberikan parameter
     *encoding* (dan opsional, *errors*); "bytearray()" kemudian
     mengonversi string menjadi byte menggunakan "str.encode()".

   * Jika ini adalah *integer*, array akan memiliki ukuran itu dan
     akan diinisialisasi dengan *null bytes*.

   * Jika itu adalah objek yang sesuai dengan *buffer interface*,
     buffer yang hanya baca dari objek tersebut akan digunakan untuk
     menginisialisasi array byte.

   * Jika ini adalah *iterable*, itu harus iterable dari bilangan
     bulat dalam kisaran "0 <= x < 256", yang digunakan sebagai konten
     awal array.

   Tanpa argumen, dibuat array berukuran 0.

   Lihat juga: ref:*binaryseq* dan :ref:` typebytearray`.

class bytes([source[, encoding[, errors]]])

   Kembalikan objek "bytes" baru, yang merupakan urutan bilangan bulat
   yang tidak dapat diubah *immutable* dalam kisaran "0 <= x < 256".
   "bytes" adalah versi yang tidak dapat diubah dari "bytearray" -- ia
   memiliki metode non-mutasi *non-mutating* yang sama dan perilaku
   pengindeksan dan pengirisan yang sama.

   Dengan demikian, argumen konstruktor ditafsirkan untuk
   "bytearray()".

   Objek byte juga dapat dibuat dengan literal, lihat String and Bytes
   literals.

   Lihat juga Binary Sequence Types --- bytes, bytearray, memoryview,
   Bytes Objects, dan Bytes and Bytearray Operations.

callable(object)

   Kembalikan "True" jika argumen *object* tampak dapat dipanggil,
   "False" jika tidak. Jika ini mengembalikan nilai "True", masih
   mungkin bahwa pemanggilan gagal, tetapi jika itu "False", memanggil
   *object* tidak akan pernah berhasil. Perhatikan bahwa kelas dapat
   dipanggil (memanggil kelas mengembalikan instansi baru); instansi
   dapat dipanggil jika kelasnya memiliki metode "__call__()".

   Baru pada versi 3.2: Fungsi ini pertama kali dihapus di Python 3.0
   dan kemudian dibawa kembali di Python 3.2.

chr(i)

   Kembalikan string yang mewakili karakter dimana titik kode Unicode
   sebagai integer *i*. Misalnya, "chr(97)" mengembalikan string
   "'a'", sementara "chr(8364)" mengembalikan string "'€'". Ini adalah
   kebalikan dari "ord()".

   Rentang yang valid untuk argumen adalah dari 0 hingga 1.114.111
   (0x10FFFF dalam basis 16). "ValueError" akan ditimbulkan jika *i*
   berada di luar rentang itu.

@classmethod

   Ubah metode menjadi metode kelas.

   Metode kelas atau *class method* menerima kelas sebagai argumen
   implisit pertama, seperti halnya metode *instance* menerima
   *instance*. Untuk mendeklarasikan metode kelas, gunakan idiom ini:

      class C:
          @classmethod
          def f(cls, arg1, arg2, ...): ...

   Bentuk "@classmethod" adalah fungsi *decorator* -- lihat Definisi
   fungsi untuk detail.

   Metode kelas dapat dipanggil baik pada kelas (seperti "C.f()") atau
   pada *instance* (seperti "C().f()"). Instance diabaikan kecuali
   untuk kelasnya. Jika metode kelas dipanggil untuk kelas turunan,
   objek kelas turunan dilewatkan sebagai argumen pertama yang
   tersirat.

   Class methods are different than C++ or Java static methods. If you
   want those, see "staticmethod()".

   For more information on class methods, see The standard type
   hierarchy.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

   Kompilasi *source* menjadi kode atau objek AST. Objek kode dapat
   dieksekusi oleh "exec()" atau "eval()". *source* dapat berupa
   string normal, string byte, atau objek AST. Rujuk ke dokumentasi
   modul "ast" untuk informasi tentang cara bekerja dengan objek AST.

   Argumen *filename* harus memberikan berkas dari mana kode dibaca;
   berikan nilai yang dapat dikenali jika tidak dibaca dari berkas
   ("'<string>'" biasa digunakan).

   Argumen *mode* menentukan jenis kode apa yang harus dikompilasi;
   itu bisa "'exec'" jika *source* terdiri dari urutan pernyataan,
   "'eval'" jika terdiri dari satu ekspresi, atau "'single'" jika
   terdiri dari satu pernyataan interaktif (dalam kasus terakhir,
   pernyataan ekspresi yang mengevaluasi sesuatu selain "None" akan
   dicetak).

   The optional arguments *flags* and *dont_inherit* control which
   future statements affect the compilation of *source*.  If neither
   is present (or both are zero) the code is compiled with those
   future statements that are in effect in the code that is calling
   "compile()".  If the *flags* argument is given and *dont_inherit*
   is not (or is zero) then the future statements specified by the
   *flags* argument are used in addition to those that would be used
   anyway. If *dont_inherit* is a non-zero integer then the *flags*
   argument is it -- the future statements in effect around the call
   to compile are ignored.

   Future statements are specified by bits which can be bitwise ORed
   together to specify multiple statements.  The bitfield required to
   specify a given feature can be found as the "compiler_flag"
   attribute on the "_Feature" instance in the "__future__" module.

   The optional argument *flags* also controls whether the compiled
   source is allowed to contain top-level "await", "async for" and
   "async with". When the bit "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" is set,
   the return code object has "CO_COROUTINE" set in "co_code", and can
   be interactively executed via "await eval(code_object)".

   Argumen *optimize* menentukan tingkat optimisasi *compiler*; nilai
   default "-1" memilih tingkat optimisasi interpreter seperti yang
   diberikan oleh opsi "-O". Level eksplisitnya adalah "0" (tidak ada
   optimisasi; "__debug__" bernilai benar), "1" (*asserts* dihapus,
   "__debug__" bernilai salah) atau "2" (*docstrings* juga dihapus ).

   Fungsi ini memunculkan "SyntaxError" jika sumber yang dikompilasi
   tidak valid, dan "ValueError" jika sumbernya berisi byte *null*.

   Jika Anda ingin mengurai kode Python ke dalam representasi AST-nya,
   lihat "ast.parse()".

   Memunculkan auditing event "compile" dengan argumen "source",
   "filename".

   Catatan:

     Ketika mengkompilasi string dengan kode multi-baris dalam mode
     "'single'" atau "'eval'", masukan harus diakhiri oleh setidaknya
     satu karakter baris baru. Ini untuk memudahkan deteksi pernyataan
     tidak lengkap dan lengkap dalam modul "code".

   Peringatan:

     Dimungkinkan untuk membuat *crash* *interpreter* Python dengan
     string yang cukup besar/kompleks ketika dikompilasi ke objek AST
     karena batasan kedalaman tumpukan dalam kompiler AST Python.

   Berubah pada versi 3.2: Diizinkan menggunakan baris baru Windows
   dan Mac. Juga masukan dalam mode "'exec'" tidak harus berakhir di
   baris baru lagi. Menambahkan parameter *optimize*.

   Berubah pada versi 3.5: Sebelumnya, "TypeError" dimunculkan ketika
   byte *null* ditemui di *source*.

   Baru pada versi 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" sekarang
   dapat diberikan tanda untuk mengaktifkan dukungan untuk "await",
   "async for", dan "async with" tingkat atas.

class complex([real[, imag]])

   Kembalikan bilangan kompleks dengan nilai *real* + *imag**1j atau
   ubah string atau angka menjadi bilangan kompleks. Jika parameter
   pertama adalah string, itu akan ditafsirkan sebagai bilangan
   kompleks dan fungsinya harus dipanggil tanpa parameter kedua.
   Parameter kedua tidak pernah menjadi string. Setiap argumen dapat
   berupa tipe numerik apa pun (termasuk kompleks). Jika *imag*
   dihilangkan, defaultnya adalah nol dan pembangun *constructor*
   berfungsi sebagai konversi numerik seperti "int" dan "float". Jika
   kedua argumen dihilangkan, kembalikan "0j".

   Untuk objek Python umum "x", "complex(x)" didelegasikan ke
   "x.__complex__()". Jika "__complex__()" tidak didefinisikan maka
   beralih ke "__float__()". Jika "__float__()" tidak didefinisikan
   maka beralih ke "__index__()".

   Catatan:

     Saat mengkonversi dari string, string tidak boleh berisi spasi
     *whitespace* di sekitar operator "+" atau "-" pusat. Misalnya,
     "complex('1+2j')" baik-baik saja, tetapi "complex('1 + 2j')"
     menimbulkan "ValueError".

   Tipe kompleks dijelaskan dalam Numeric Types --- int, float,
   complex.

   Berubah pada versi 3.6: Pengelompokan angka dengan garis bawah
   seperti dalam literal kode diperbolehkan.

   Berubah pada versi 3.8: Dialihkan ke "__index__()" jika
   "__complex__()" dan "__float__()" tidak terdefinisi.

delattr(object, name)

   Ini adalah kerabat *relative* dari "setattr()". Argumen adalah
   objek dan string. String haruslah nama dari salah satu atribut
   objek. Fungsi menghapus atribut bernama, asalkan objek
   memperbolehkannya. Misalnya, "delattr(x, 'foobar')" setara dengan
   "del x.foobar".

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

   Buat *dictionary* baru. Objek "dict" adalah kelas kamus
   *dictionary*. Lihat "dict" dan Mapping Types --- dict untuk
   dokumentasi tentang kelas ini.

   Untuk wadah *containers* lain, lihat kelas-kelas bawaan :class:
   *list*, "set", dan "tuple", dan juga modul "collections".

dir([object])

   Tanpa argumen, kembalikan daftar *list* nama dalam lingkup lokal
   saat ini. Dengan argumen, mencoba untuk mengembalikan daftar *list*
   atribut yang valid untuk objek itu.

   Jika objek memiliki metode bernama "__dir__()", metode ini akan
   dipanggil dan harus mengembalikan daftar atribut. Ini memungkinkan
   objek yang mengimplementasikan fungsi alihsuai *custom*
   "__getattr__()" atau "__getattribute__()" untuk menyesuaikan cara
   "dir()" melaporkan atributnya.

   Jika objek tidak menyediakan :meth: *__dir__*, fungsi mencoba yang
   terbaik untuk mengumpulkan informasi dari atribut objek "__dict__",
   jika ditentukan, dan dari objek tipenya. Daftar yang dihasilkan
   belum tentu lengkap, dan mungkin tidak akurat ketika objek memiliki
   alihsuai *custom* "__getattr__()".

   Mekanisme bawaan "dir()" berperilaku berbeda dengan berbagai jenis
   objek, karena berusaha menghasilkan informasi yang paling relevan,
   dibanding lengkap,:

   * Jika objek adalah objek modul, daftar berisi nama-nama atribut
     modul.

   * Jika objek adalah tipe atau objek kelas, daftar berisi nama
     atributnya, dan secara rekursif atribut dari basisnya.

   * Jika tidak, daftar berisi nama atribut objek, nama atribut
     kelasnya, dan secara rekursif atribut dari kelas dasar kelasnya.

   Daftar yang dihasilkan diurutkan berdasarkan abjad.  Sebagai
   contoh:

   >>> import struct
   >>> dir()   # show the names in the module namespace  
   ['__builtins__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module 
   ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

   Catatan:

     Karena "dir()" disediakan terutama sebagai kenyamanan untuk
     digunakan pada prompt interaktif, ia mencoba untuk memasok
     sekumpulan nama yang menarik lebih dari sekedar untuk menyediakan
     sekumpulan nama yang didefinisikan secara ketat atau konsisten,
     dan perilakunya yang terperinci dapat berubah lintas rilis.
     Misalnya, atribut metaclass tidak ada dalam daftar hasil ketika
     argumennya adalah kelas.

divmod(a, b)

   Ambil dua angka (bukan kompleks) sebagai argumen dan kembalikan
   sepasang angka yang terdiri dari hasil bagi dan sisanya ketika
   menggunakan divisi integer. Dengan tipe operan campuran, aturan
   untuk operator aritmatika biner berlaku. Untuk bilangan bulat,
   hasilnya sama dengan "(a // b, a % b)". Untuk angka pecahan
   *floating point* hasilnya adalah "(q, a % b)", di mana *q* biasanya
   "math.floor(a / b)" tetapi mungkin 1 kurang dari itu. Bagaimanapun,
   "q * b + a % b" sangat dekat dengan *a*, jika "a % b" adalah bukan
   nol, ia memiliki tanda yang sama dengan *b*, dan "0 <= abs(a % b) <
   abs(b)".

enumerate(iterable, start=0)

   Kembalikan objek enumerasi. *iterable* harus berupa urutan, sebuah
   *iterator*, atau objek lain yang mendukung iterasi. The
   "__next__()" metode iterator dikembalikan oleh "enumerate()"
   mengembalikan tuple yang berisi hitungan (dari *start* yang bawaan
   ke 0) dan nilai yang diperoleh dari mengelilingi *iterable*.

   >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
   >>> list(enumerate(seasons))
   [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
   >>> list(enumerate(seasons, start=1))
   [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

   Setara dengan:

      def enumerate(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   Argumennya adalah string dan opsional global dan lokal. Jika
   disediakan, *globals* harus berupa *dictionary*. Jika disediakan,
   *locals* dapat berupa objek pemetaan apa pun.

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries as global and local namespace.
   If the *globals* dictionary is present and does not contain a value
   for the key "__builtins__", a reference to the dictionary of the
   built-in module "builtins" is inserted under that key before
   *expression* is parsed.  This means that *expression* normally has
   full access to the standard "builtins" module and restricted
   environments are propagated.  If the *locals* dictionary is omitted
   it defaults to the *globals* dictionary.  If both dictionaries are
   omitted, the expression is executed with the *globals* and *locals*
   in the environment where "eval()" is called.  Note, *eval()* does
   not have access to the *nested scopes* (non-locals) in the
   enclosing environment.

   Nilai kembalian adalah hasil dari ekspresi yang dievaluasi.
   Kesalahan sintaks dilaporkan sebagai pengecualian. Contoh:

   >>> x = 1
   >>> eval('x+1')
   2

   Fungsi ini juga dapat digunakan untuk mengeksekusi objek kode
   *arbitrary* (seperti yang dibuat oleh "compile()"). Dalam hal ini,
   berikan objek kode alih-alih string. Jika objek kode telah
   dikompilasi dengan "'exec'" sebagai argumen *mode*, "eval()" nilai
   kembaliannya akan menjadi "None".

   Petunjuk: eksekusi dinamis dari pernyataan didukung oleh fungsi
   "exec()". Fungsi "globals()" dan "locals()" mengembalikan kamus
   global dan lokal saat ini, masing-masing, yang mungkin berguna
   untuk diedarkan untuk digunakan oleh "eval()" atau "exec()".

   Lihat "ast.literal_eval()" untuk fungsi yang dapat dengan aman
   mengevaluasi string dengan ekspresi yang hanya mengandung literal.

   Memunculkan auditing event "exec" dengan argumen "code_object".

exec(object[, globals[, locals]])

   This function supports dynamic execution of Python code. *object*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section
   "File input" in the Reference Manual). Be aware that the
   "nonlocal", "yield",  and "return" statements may not be used
   outside of function definitions even within the context of code
   passed to the "exec()" function. The return value is "None".

   Dalam semua kasus, jika bagian-bagian opsional dihilangkan, kode
   dieksekusi dalam lingkup saat ini. Jika hanya *globals* disediakan,
   itu harus berupa *dictionary* (dan bukan subkelas *dictionary*),
   yang akan digunakan untuk variabel global dan lokal. Jika *globals*
   dan *locals* diberikan, masing-masing digunakan untuk variabel
   global dan lokal. Jika disediakan, *locals* dapat berupa objek
   pemetaan apa pun. Ingat bahwa pada level modul, global dan lokal
   adalah kamus yang sama. Jika exec mendapat dua objek terpisah
   sebagai *globals* dan *lokals*, kode akan dieksekusi seolah-olah
   itu tertanam dalam definisi kelas.

   Jika *dictionary* *globals* tidak mengandung nilai untuk kunci
   "__builtins__", referensi ke *dictionary* modul bawaan "builtins"
   dimasukkan di bawah kunci itu. Dengan begitu Anda dapat mengontrol
   bawaan apa yang tersedia untuk kode yang dieksekusi dengan
   memasukkan *dictionary* "__builtins__" Anda sendiri ke *globals*
   sebelum meneruskannya ke "exec()".

   Memunculkan auditing event "exec" dengan argumen "code_object".

   Catatan:

     Fungsi bawaan :func: *globals* dan "locals()" masing-masing
     mengembalikan *dictionary* global dan lokal, yang mungkin berguna
     untuk digunakan sebagai argumen kedua dan ketiga untuk "exec()" .

   Catatan:

     Bawaan *locals* bertindak seperti yang dijelaskan untuk fungsi
     "locals()" di bawah: modifikasi ke *dictionary* *locals* default
     tidak boleh dicoba. Melewatkan *dictionary *locals* eksplisit
     jika Anda perlu melihat efek kode pada *locals* setelah fungsi
     "exec()" mengembalikan.

filter(function, iterable)

   Bangun sebuah *iterator* dari elemen-elemen *iterable* yang
   *functions* mengembalikan benar. *iterable* dapat berupa urutan,
   wadah *container* yang mendukung iterasi, atau *iterator*. Jika
   *function* adalah "None", fungsi identitas diasumsikan, yaitu,
   semua elemen *iterable* yang salah dihapus.

   Perhatikan bahwa "filter(function, iterable)" setara dengan
   ekspresi generator "(item for item in iterable if function(item))"
   jika *function* tidak "None" dan "(item for item in iterable if
   item)" if *function* adalah "None".

   Lihat "itertools.filterfalse()" untuk fungsi komplementer yang
   mengembalikan elemen *iterable* yang berfungsi *function*
   mengembalikan salah.

class float([x])

   Kembalikan angka pecahan *floating point* yang dibangun dari angka
   atau string *x*.

   Jika argumennya berupa string, harus berisi angka desimal, secara
   opsional didahului oleh tanda, dan secara opsional tertanam di
   spasi *whitespace*. Tanda opsional mungkin "'+'" atau "'-'"; tanda
   "'+'" tidak memengaruhi nilai yang dihasilkan. Argumen juga dapat
   berupa string yang mewakili NaN (bukan angka), atau tak terhingga
   positif atau negatif. Lebih tepatnya, masukan harus sesuai dengan
   tata bahasa berikut karakter spasi awalan dan akhiran dihapus:

      sign           ::= "+" | "-"
      infinity       ::= "Infinity" | "inf"
      nan            ::= "nan"
      numeric_value  ::= floatnumber | infinity | nan
      numeric_string ::= [sign] numeric_value

   Di sini "floatnumber" adalah bentuk Python *floating-point*
   literal, dijelaskan dalam Floating point literals. Kasus tidak
   signifikan, jadi, misalnya, "inf", "Inf", "INFINITY" dan "iNfINity"
   adalah semua ejaan yang dapat diterima untuk infinity positif.

   Kalau tidak, jika argumennya adalah bilangan bulat atau angka
   pecahan *floating point*, angka pecahan dengan nilai yang sama
   (dalam presisi *floating point* Python) dikembalikan. Jika argumen
   di luar kisaran *float* Python, "OverflowError" akan dimunculkan.

   Untuk objek Python umum "x", "float(x)" didelegasikan ke
   "x.__float__()". Jika "__float__()" tidak terdefinisi maka beralih
   ke "__index__()".

   Jika tidak ada argumen yang diberikan, dikembalikan sebagai "0.0".

   Contoh:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

   Tipe float dijelaskan dalam Numeric Types --- int, float, complex.

   Berubah pada versi 3.6: Pengelompokan angka dengan garis bawah
   seperti dalam literal kode diperbolehkan.

   Berubah pada versi 3.7: *x* sekarang menjadi parameter sesuai-
   posisi.

   Berubah pada versi 3.8: Dialihkan ke "__index__()" jika
   "__float__()" tidak terdefinisi.

format(value[, format_spec])

   Konversi *value* ke representasi "formatted", sebagaimana
   dikendalikan oleh *format_spec*. Interpretasi *format_spec* akan
   tergantung pada jenis argumen *value*, namun ada sintaks
   pemformatan standar yang digunakan oleh sebagian besar tipe bawaan:
   *formatpec*.

   Default *format_spec* adalah string kosong yang biasanya memberikan
   efek yang sama dengan memanggil "str(value)".

   Pemanggilan ke "format(value, format_spec)" diterjemahkan ke
   "type(value).__format__(value, format_spec)" yang memintas
   *instance* *dictionary* saat mencari nilai dari methode
   >>:met:`__format__`<<. Pengecualian *exception* "TypeError"
   dimunculkan jika pencarian metode mencapai "object" dan
   *format_spec* tidak kosong, atau jika *format_spec* atau nilai
   kembalian bukan string.

   Berubah pada versi 3.4: "object().__format__(format_spec)"
   menimbulkan "TypeError" jika *format_spec* bukan string kosong.

class frozenset([iterable])

   Kembalikan objek baru "frozenset", secara opsional dengan elemen
   yang diambil dari *iterable*. "frozenset" adalah kelas bawaan.
   Lihat "frozenset" dan Set Types --- set, frozenset untuk
   dokumentasi tentang kelas ini.

   Untuk wadah *containers* lain lihat kelas-kelas bawaan "set",
   "list",: class: *tuple*, dan "dict", serta modul "collections".

getattr(object, name[, default])

   Kembalikan nilai atribut bernama dari *object*. *name* harus berupa
   string. Jika string adalah nama salah satu atribut objek, hasilnya
   adalah nilai atribut itu. Misalnya, "getattr(x, 'foobar')" setara
   dengan "x.foobar". Jika atribut yang disebutkan tidak ada,
   *default* dikembalikan jika disediakan, jika tidak "AttributeError"
   dimunculkan.

globals()

   Kembalikan dictionary yang mewakili tabel simbol global saat ini.
   Ini selalu merupakan dictionary dari modul saat ini (di dalam suatu
   fungsi atau metode, ini adalah modul di mana ia didefinisikan,
   bukan modul dari mana ia dipanggil).

hasattr(object, name)

   Argumen adalah objek dan string. Hasilnya adalah "True" jika string
   adalah nama salah satu atribut objek, "False" jika tidak. (Ini
   diimplementasikan dengan memanggil "getattr(object, name)" dan
   melihat apakah itu memunculkan "AttributeError" atau tidak.)

hash(object)

   Kembalikan nilai hash objek (jika ada). Nilai hash adalah bilangan
   bulat. Mereka digunakan untuk dengan cepat membandingkan kunci
   kamus *dictionary keys* selama pencarian dictionary. Nilai numerik
   yang membandingkan sama memiliki nilai hash yang sama (bahkan jika
   mereka dari jenis yang berbeda, seperti halnya untuk 1 dan 1.0).

   Catatan:

     Untuk objek dengan metode ubahsuai *custom* "__hash__()",
     perhatikan bahwa "hash()" memotong atau mengosongkan kembali
     nilai berdasarkan lebar bit mesin *host*. Lihat "__hash__()"
     untuk detailnya.

help([object])

   Meminta sistem bantuan bawaan. (Fungsi ini dimaksudkan untuk
   penggunaan interaktif.) Jika tidak ada argumen yang diberikan,
   sistem bantuan interaktif dimulai pada konsol interpreter. Jika
   argumennya adalah string, maka string tersebut dicari sebagai nama
   modul, fungsi, kelas, metode, kata kunci, atau topik dokumentasi,
   dan halaman bantuan dicetak pada konsol. Jika argumennya adalah
   objek jenis apa pun, halaman bantuan tentang objek tersebut
   dihasilkan.

   Perhatikan bahwa jika garis miring (/) muncul di daftar parameter
   suatu fungsi, ketika menjalankan "help()", itu berarti bahwa
   parameter sebelum garis miring adalah hanya posisional. Untuk info
   lebih lanjut, lihat the FAQ entry on positional-only parameters.

   Fungsi ini ditambahkan ke *namespace* bawaan dengan modul "site".

   Berubah pada versi 3.4: Perubahan ke "pydoc" dan "inspect" berarti
   bahwa tanda tangan *signatures* yang dilaporkan untuk *callables*
   sekarang lebih komprehensif dan konsisten.

hex(x)

   Ubah angka integer menjadi string heksadesimal huruf kecil yang
   diawali dengan "0x". Jika *x* bukan objek Python "int", ia harus
   mendefinisikan metode "__index__()" yang mengembalikan integer.
   Beberapa contoh:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'

   Jika Anda ingin mengonversi bilangan bulat menjadi string
   heksadesimal huruf besar atau huruf kecil dengan awalan atau tidak,
   Anda dapat menggunakan salah satu dari cara berikut:

   >>> '%#x' % 255, '%x' % 255, '%X' % 255
   ('0xff', 'ff', 'FF')
   >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
   ('0xff', 'ff', 'FF')
   >>> f'{255:#x}', f'{255:x}', f'{255:X}'
   ('0xff', 'ff', 'FF')

   Lihat juga "format()" untuk informasi lebih lanjut.

   Lihat juga "int()" untuk mengonversi string heksadesimal menjadi
   integer menggunakan basis 16.

   Catatan:

     Untuk mendapatkan representasi string heksadesimal untuk float,
     gunakan metode "float.hex()".

id(object)

   Kembalikan "identity" suatu objek. Ini adalah bilangan bulat yang
   dijamin unik dan konstan untuk objek ini selama masa pakainya. Dua
   objek dengan masa hidup yang tidak tumpang tindih mungkin memiliki
   nilai yang sama "id()".

   **CPython implementation detail:** This is the address of the
   object in memory.

   Memunculkan sebuah *auditing event* "builtins.id" dengan argumen
   "id".

input([prompt])

   Jika argumen *prompt* ada, ini ditulis ke keluaran standar tanpa
   baris tambahan. Fungsi ini kemudian membaca sebuah baris dari
   masukan, mengubahnya menjadi sebuah string (menghapus baris baru
   yang tertinggal), dan mengembalikannya. Ketika EOF dibaca,
   "EOFError" dimunculkan. Contoh:

      >>> s = input('--> ')  
      --> Monty Python's Flying Circus
      >>> s  
      "Monty Python's Flying Circus"

   Jika modul "readline" dimuat, maka "input()" akan menggunakannya
   untuk menyediakan fitur pengeditan baris dan riwayat.

   Memunculkan auditing event "builtins.input" dengan argumen
   "prompt".

   Memunculkan auditing event "builtins.input/result" dengan argumen
   "result".

class int([x])
class int(x, base=10)

   Kembalikan objek integer yang dibangun dari angka atau string *x*,
   atau kembalikan "0" jika tidak ada argumen yang diberikan. Jika *x*
   mendefinisikan "__int__()", "int(x)" mengembalikan "x.__int__()".
   Jika *x* mendefinisikan "__index__()", ia mengembalikan
   "x.__index__()". Jika *x* mendefinisikan "__trunc__()", ia
   mengembalikan "x.__trunc__()". Untuk angka *floating point*, ini
   memotong menuju nol.

   Jika *x* bukan angka atau jika *base* diberikan, maka *x* harus
   berupa string, "bytes", atau "bytearray" *instance* mewakili
   integer literal dalam radix *base*. Secara opsional, literal dapat
   didahului oleh "+" atau "-" (tanpa ada ruang di antaranya) dan
   dikelilingi oleh spasi *whitespace*. Basis-n literal terdiri dari
   digit 0 hingga n-1, dengan "a" hingga "z" (atau "A" hingga "Z")
   memiliki nilai 10 hingga 35. Nilai bawaan *base* adalah 10. Nilai
   yang diizinkan adalah 0 dan 2--36. Basis-2, -8, dan -16 literal
   dapat secara opsional diawali dengan "0b"/"0B", "0o"/"0O", atau
   "0x"/"0X", seperti halnya literal integer dalam kode. Basis 0
   berarti menafsirkan secara tepat sebagai kode literal, sehingga
   basis aktualnya adalah 2, 8, 10, atau 16, dan sehingga "int('010',
   0)" tidak sah, sedangkan "int('010')" adalah sah, serta "int('010',
   8)".

   Tipe integer dijelaskan dalam Numeric Types --- int, float,
   complex.

   Berubah pada versi 3.4: Jika *base* bukan turunan dari "int" dan
   objek *base* memiliki metode "base.__index__", metode itu dipanggil
   untuk mendapatkan integer untuk basis. Versi sebelumnya digunakan
   "base.__int__" alih-alih :meth: *base.__index__ <objek .__ index
   __>*.

   Berubah pada versi 3.6: Pengelompokan angka dengan garis bawah
   seperti dalam literal kode diperbolehkan.

   Berubah pada versi 3.7: *x* sekarang menjadi parameter sesuai-
   posisi.

   Berubah pada versi 3.8: Dialihkan ke "__index__()" jika "__int__()"
   tidak terdefinisi.

   Berubah pada versi 3.8.14: "int" string inputs and string
   representations can be limited to help avoid denial of service
   attacks. A "ValueError" is raised when the limit is exceeded while
   converting a string *x* to an "int" or when converting an "int"
   into a string would exceed the limit. See the integer string
   conversion length limitation documentation.

isinstance(object, classinfo)

   Kembalikan nilai "True" jika argumen *object* adalah instansi dari
   argumen *classinfo*, atau dari sebuah subkelasnya (langsung, tidak
   langsung atau *virtual*). Jika *object* bukan objek dari tipe yang
   diberikan, fungsi selalu mengembalikan "False". Jika *classinfo*
   adalah *tuple* dari objek tipe (atau secara rekursif, tuple lain
   semacam itu), kembalikan "True" jika *object* adalah instansi dari
   salah satu tipe. Jika *classinfo* bukan tipe atau tuple dari tipe
   dan *tuple* semacam itu, eksepsi "TypeError" dimunculkan.

issubclass(class, classinfo)

   Kembalikan "True" jika *class* adalah sebuah subkelas (langsung,
   tidak langsung atau *virtual*) dari *classinfo*. Kelas dianggap
   sebagai subkelas dari dirinya sendiri. *classinfo* dapat berupa
   *tuple* dari objek kelas, dalam hal ini setiap entri dalam
   *classinfo* akan diperiksa. Dalam kasus lain, eksepsi "TypeError"
   akan dimunculkan.

iter(object[, sentinel])

   Kembalikan objek *iterator*. Argumen pertama ditafsirkan sangat
   berbeda tergantung pada keberadaan argumen kedua. Tanpa argumen
   kedua, *object* harus berupa objek koleksi yang mendukung protokol
   iterasi (metode "__iter__()"), atau objek tersebut harus mendukung
   protokol urutan (metode "__getitem__()" dengan argumen integer
   mulai dari "0"). Jika tidak mendukung salah satu dari protokol itu,
   "TypeError" akan dimunculkan. Jika argumen kedua, *sentinel*,
   diberikan, maka *object* harus menjadi objek yang bisa dipanggil.
   *Iterator* yang dibuat dalam kasus ini akan memanggil *object*
   tanpa argumen untuk setiap panggilan ke "__next__()" metode; jika
   nilai yang dikembalikan sama dengan *sentinel*, :exc:
   *StopIteration* akan ditimbulkan, jika tidak nilai akan
   dikembalikan.

   Lihat juga Iterator Types.

   Salah satu kegunaan dari bentuk kedua dari "iter()" adalah untuk
   membangun pembaca blok. Misalnya, membaca blok dengan lebar tetap
   dari berkas basis data biner hingga akhir file tercapai:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

   Mengembalikan panjang (jumlah item) suatu objek. Argumennya bisa
   berupa urutan (seperti string, byte, *tuple*, *list*, atau *range*)
   atau koleksi (seperti *dictionary*, set, atau *frozen set*).

class list([iterable])

   Alih-alih menjadi sebuah fungsi, "list" sebenarnya adalah tipe
   urutan yang bisa berubah *mutable*, seperti yang didokumentasikan
   dalam List dan :ref: *typesseq*.

locals()

   Perbarui dan kembalikan *dictionary* yang mewakili tabel simbol
   lokal saat ini. Variabel bebas dikembalikan oleh "locals()" saat
   dipanggil dalam blok fungsi, tetapi tidak di blok kelas. Perhatikan
   bahwa pada tingkat modul, "locals()" dan "globals()" adalah
   *dictionary* yang sama.

   Catatan:

     Isi *dictionary* ini tidak boleh dimodifikasi; perubahan mungkin
     tidak mempengaruhi nilai variabel lokal dan bebas yang digunakan
     oleh interpreter.

map(function, iterable, ...)

   Kembalikan iterator yang berlaku *function* untuk setiap item
   *iterable*, menghasilkan *yielding* hasilnya. Jika argumen
   *iterable* tambahan disahkan, *fungsi* harus menerima banyak
   argumen dan diterapkan ke item dari semua *iterables* secara
   paralel. Dengan beberapa iterables, iterator berhenti ketika
   *iterable* terpendek habis. Untuk kasus-kasus di mana input fungsi
   sudah diatur ke dalam argumen *tuples*, lihat
   "itertools.starmap()".

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

   Kembalikan item terbesar dalam iterable atau yang terbesar dari dua
   atau lebih argumen.

   Jika satu argumen posisi disediakan, itu harus berupa *iterable*.
   Item terbesar di *iterable* dikembalikan. Jika dua atau lebih
   argumen posisi disediakan, argumen posisi terbesar dikembalikan.

   Ada dua opsional hanya argumen kata kunci *keyword arguments*.
   Argumen *key* menentukan fungsi pengurutan satu argumen seperti
   yang digunakan untuk "list.sort()". Argumen *default* menentukan
   objek yang akan dikembalikan jika yang disediakan itu kosong. Jika
   iterable kosong dan *default* tidak disediakan, "ValueError" akan
   dimunculkan.

   Jika beberapa item maksimal, fungsi mengembalikan item pertama yang
   ditemui. Ini konsisten dengan alat pengawet *preserving* sortir
   yang stabil lain seperti "sorted(iterable, key=keyfunc,
   reverse=True)[0]" dan "heapq.nlargest(1, iterable, key=keyfunc)".

   Baru pada versi 3.4: *default* hanya argumen kata kunci *keyword
   argument*.

   Berubah pada versi 3.8: *key* bisa jadi "None".

class memoryview(obj)

   Kembalikan objek "memory view" yang dibuat dari argumen yang
   diberikan. Lihat Memory Views untuk informasi lebih lanjut.

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

   Kembalikan item terkecil dalam *iterable* atau terkecil dari dua
   atau lebih argumen.

   Jika satu argumen posisi disediakan, itu harus berupa *iterable*.
   Item terkecil di *iterable* dikembalikan. Jika dua atau lebih
   argumen posisional disediakan, argumen posisional terkecil akan
   dikembalikan.

   Ada dua opsional hanya argumen kata kunci *keyword arguments*.
   Argumen *key* menentukan fungsi pengurutan satu argumen seperti
   yang digunakan untuk "list.sort()". Argumen *default* menentukan
   objek yang akan dikembalikan jika yang disediakan itu kosong. Jika
   iterable kosong dan *default* tidak disediakan, "ValueError" akan
   dimunculkan.

   Jika beberapa item minimal, fungsi mengembalikan item pertama yang
   ditemui. Ini konsisten dengan alat pengawet *preserving* sortir
   yang stabil lain seperti "sorted(iterable, key=keyfunc)[0]" dan
   "heapq.nsmallest(1, iterable, key=keyfunc)".

   Baru pada versi 3.4: *default* hanya argumen kata kunci *keyword
   argument*.

   Berubah pada versi 3.8: *key* bisa jadi "None".

next(iterator[, default])

   Ambil item berikutnya dari *iterator* dengan memanggil metode
   "__next__()". Jika *default* diberikan, itu dikembalikan jika
   *iterator* habis, jika tidak "StopIteration" akan dimunculkan.

class object

   Kembalikan objek tanpa fitur baru. "object" adalah basis untuk
   semua kelas. Ini memiliki metode yang umum untuk semua contoh kelas
   Python. Fungsi ini tidak menerima argumen apa pun.

   Catatan:

     "object" *not* memiliki "__dict__", jadi Anda tidak dapat
     menetapkan atribut *arbitrary* ke turunan dari kelas "object".

oct(x)

   Ubah angka integer menjadi string oktal yang diawali dengan "0o".
   Hasilnya adalah ekspresi Python yang valid. Jika *x* bukan objek
   Python :class: *int*, ia harus mendefinisikan metode "__index__()"
   yang mengembalikan integer. Sebagai contoh:

   >>> oct(8)
   '0o10'
   >>> oct(-56)
   '-0o70'

   Jika Anda ingin mengonversi bilangan bulat menjadi string oktal
   baik dengan awalan "0o" atau tidak, Anda dapat menggunakan salah
   satu dari cara berikut.

   >>> '%#o' % 10, '%o' % 10
   ('0o12', '12')
   >>> format(10, '#o'), format(10, 'o')
   ('0o12', '12')
   >>> f'{10:#o}', f'{10:o}'
   ('0o12', '12')

   Lihat juga "format()" untuk informasi lebih lanjut.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   Buka *file* dan mengembalikan yang sesuai dengan *file object*.
   Jika file tersebut tidak dapat dibuka, sebuah "OSError" akan
   dinaikkan. Lihat Membaca dan Menulis Berkas untuk contoh yang lebih
   banyak terkait bagaimana menggunakan fungsi ini.

   *file* adalah *path-like object* yang memberikan jalur nama
   *pathname* (absolut atau relatif terhadap direktori kerja saat ini)
   dari berkas yang akan dibuka atau deskriptor berkas integer dari
   berkas yang akan dibungkus. (Jika deskriptor berkas diberikan, itu
   ditutup ketika objek I/O yang dikembalikan ditutup, kecuali
   *closefd* diatur ke "False".)

   *mode* adalah string opsional yang menentukan mode di mana berkas
   dibuka. Bawaannya adalah "'r'" yang artinya terbuka untuk membaca
   dalam mode teks. Nilai umum lainnya adalah "'w'" untuk penulisan
   (mengosongkan berkas jika sudah ada), "'x'" untuk pembuatan
   eksklusif dan "'a'" untuk menambahkan (yang pada *beberapa* sistem
   Unix, berarti bahwa *all* penulisan ditambahkan ke akhir file
   terlepas dari posisi pencarian saat ini). Dalam mode teks, jika
   *encoding* tidak ditentukan, penyandian *encoding* yang digunakan
   bergantung pada platform: "locale.getpreferredencoding(False)"
   dipanggil untuk mendapatkan penyandian lokal *locale encoding* saat
   ini. (Untuk membaca dan menulis byte *raw*, gunakan mode biner dan
   biarkan *encoding* tidak ditentukan.) Mode yang tersedia adalah:

   +-----------+-----------------------------------------------------------------+
   | Karakter  | Artinya                                                         |
   |===========|=================================================================|
   | "'r'"     | terbuka untuk membaca (bawaan)                                  |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | buka untuk menulis, mengosongkan berkas terlebih dahulu         |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | terbuka untuk pembuatan eksklusif, gagal jika file sudah ada    |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | terbuka untuk menulis, menambahkan di bagian akhir berkas jika  |
   |           | ada                                                             |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | mode biner                                                      |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | mode teks (bawaan)                                              |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | terbuka untuk memperbarui (membaca dan menulis)                 |
   +-----------+-----------------------------------------------------------------+

   Mode bawaan adalah "'r'" (terbuka untuk membaca teks, sinonim dari
   "'rt'"). Mode "'w+'" dan "'w+b'" membuka dan mengosongkan berkas.
   Mode "'r+'" dan "'r+b'" membuka file tanpa mengosongkan.

   Seperti disebutkan dalam Overview, Python membedakan antara biner
   dan teks I/O. Berkas dibuka dalam mode biner (termasuk "'b'" dalam
   argumen *mode*) mengembalikan konten sebagai objek "bytes" tanpa
   *decoding*. Dalam mode teks (bawaan, atau ketika "'t'" termasuk
   dalam argumen *mode*), isi file dikembalikan sebagai "str", byte
   yang pertama kali diterjemahkan *decoded* menggunakan *encoding*
   bergantung-platform atau menggunakan *encoding* yang ditentukan
   jika diberikan.

   Ada karakter mode tambahan yang diizinkan, "'U'", yang tidak lagi
   memiliki efek apa pun, dan dianggap sudah usang. Ini sebelumnya
   diaktifkan *universal newlines* dalam mode teks, yang menjadi
   perilaku bawaan di Python 3.0. Rujuk ke dokumentasi parameter
   newline untuk rincian lebih lanjut.

   Catatan:

     Python tidak tergantung pada gagasan sistem operasi yang
     mendasari file teks; semua pemrosesan dilakukan oleh Python
     sendiri, dan oleh karena itu tidak bergantung platform.

   *buffering* adalah integer opsional yang digunakan untuk mengatur
   kebijakan *buffering*. Berikan nilai 0 untuk menonaktifkan
   *buffering* (hanya diizinkan dalam mode biner), 1 untuk memilih
   *line buffering* (hanya dapat digunakan dalam mode teks), dan
   integer > 1 untuk menunjukkan ukuran dalam byte penyangga potongan
   *chunk* berukuran tetap. Ketika tidak ada argumen *buffering* yang
   diberikan, kebijakan *buffering* bawaan berfungsi sebagai berikut:

   * File biner disangga *buffered* dalam potongan ukuran tetap;
     ukuran penyangga dipilih menggunakan heuristik yang mencoba
     menentukan "block size" perangkat yang mendasarinya dan
     bergantung pada "io.DEFAULT_BUFFER_SIZE". Pada banyak sistem,
     panjang penyangga biasanya adalah 4096 atau 8192 byte.

   * Berkas teks "interactive" (berkas yang "isatty()" mengembalikan
     "True") menggunakan *line buffering*. File teks lainnya
     menggunakan kebijakan yang dijelaskan di atas untuk file biner.

   *encoding* adalah nama penyandian *encoding* yang digunakan untuk
   menerjemahkan *decode* atau menyandikan *encode* berkas. Ini hanya
   digunakan dalam mode teks. *encoding* bawaan bergantung pada
   platform (apa pun kembalian "locale.getpreferredencoding()"),
   tetapi apa pun *text encoding* yang didukung oleh Python dapat
   digunakan. Lihat modul "codecs" untuk daftar penyandian *encoding*
   yang didukung.

   *errors* adalah string opsional yang menentukan bagaimana kesalahan
   *encoding* dan *decoding* ditangani — ini tidak dapat digunakan
   dalam mode biner. Berbagai penangan kesalahan standar tersedia
   (terdaftar di bawah Penangan Kesalahan), meskipun nama penanganan
   kesalahan yang telah terdaftar dengan "codecs.register_error()"
   juga valid. Nama standar meliputi:

   * "'strict'" untuk memunculkan pengecualian "ValueError" jika ada
     kesalahan penyandian *encoding*. Nilai bawaan dari "None"
     memiliki efek yang sama.

   * "'ignore'" mengabaikan kesalahan. Perhatikan bahwa mengabaikan
     kesalahan penyandian *encoding* dapat menyebabkan hilangnya data.

   * "'replace'" menyebabkan penanda  pengganti (seperti "'?'")
     disisipkan di mana ada data yang tidak sesuai format.

   * "'surrogateescape'" akan mewakili byte yang salah sebagai titik
     kode di Area Penggunaan Pribadi Unicode mulai dari U+DC80 hingga
     U+DCFF. Poin kode pribadi ini kemudian akan kembali menjadi byte
     yang sama ketika penangan kesalahan "surrogateescape" digunakan
     saat menulis data. Ini berguna untuk memproses berkas dalam
     penyandian *encoding* yang tidak dikenal.

   * "'xmlcharrefreplace'" hanya didukung saat menulis ke berkas.
     Karakter yang tidak didukung oleh penyandian *encoding* diganti
     dengan referensi karakter XML yang sesuai "&#nnn;".

   * "'backslashreplace'" menggantikan data yang salah dengan urutan
     pemisahan dengan *backslash* dari Python.

   * "'namereplace'" (juga hanya didukung saat menulis) menggantikan
     karakter yang tidak didukung dengan "\N{...}" urutan pemisahan.

   *newline* mengontrol bagaimana mode *universal newlines* bekerja
   (ini hanya berlaku untuk mode teks). Itu bisa "None", "''", "'\n'",
   "'\r'", dan "'\r\n'". Ia bekerja sebagai berikut:

   * Saat membaca masukan dari aliran *stream*, jika *newline* adalah
     "None", mode universal baris baru diaktifkan. Baris dalam masukan
     dapat diakhiri dengan "'\n'", "'\r'", atau "'\r\n'", dan ini
     diterjemahkan ke dalam "'\n'" sebelum dikembalikan ke pemanggil.
     Jika "''", mode baris baru universal diaktifkan, tetapi akhir
     baris dikembalikan ke pemanggil yang tidak diterjemahkan. Jika
     memiliki salah satu nilai legal lainnya, jalur masukan hanya
     diakhiri oleh string yang diberikan, dan akhir baris dikembalikan
     ke pemanggil yang tidak diterjemahkan.

   * Saat menulis keluaran ke aliran *stream*, jika *newline* adalah
     "None", setiap karakter "'\n'" yang ditulis diterjemahkan ke
     pemisah garis bawaan sistem, "os.linesep". Jika *newline* adalah
     "''" atau "'\n'", tidak ada terjemahan yang terjadi. Jika
     *newline* adalah salah satu dari nilai legal lainnya, setiap
     karakter "'\n'" yang ditulis diterjemahkan ke string yang
     diberikan.

   Jika *closefd* bernilai "False" dan diberikan deskriptor berkas
   daripada nama berkas, deskriptor berkas yang mendasarinya akan
   tetap terbuka ketika berkas ditutup. Jika nama berkas diberikan
   *closefd* harus bernilai "True" (bawaan) jika tidak kesalahan akan
   dimunculkan.

   Pembuka khusus dapat digunakan dengan melewatkan *callable* sebagai
   *opener*. Deskriptor berkas yang mendasari untuk objek berkas
   kemudian diperoleh dengan memanggil *opener* dengan (*file*,
   *flags*). *opener* harus mengembalikan deskriptor berkas terbuka
   (lewat "os.open" sebagai *opener* menghasilkan fungsionalitas yang
   mirip dengan melewatkan "None").

   Berkas yang baru dibuat adalah non-inheritable.

   Contoh berikut menggunakan parameter dir_fd dari fungsi "os.open()"
   untuk membuka berkas relatif ke direktori yang diberikan:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   Tipe *file object* yang dikembalikan oleh fungsi "open()"
   tergantung pada mode. Ketika "open()" digunakan untuk membuka
   berkas dalam mode teks ("'w'", "'r'", "'wt'", "'rt'", dll.), ia
   mengembalikan subkelas dari "io.TextIOBase" (khusus
   "io.TextIOWrapper"). Ketika digunakan untuk membuka file dalam mode
   biner dengan *buffering*, kelas yang dikembalikan adalah subkelas
   dari "io.BufferedIOBase". Kelas yang tepat bervariasi: dalam mode
   baca biner, ia mengembalikan "io.BufferedReader"; dalam mode tulis
   biner dan *append* biner, ia mengembalikan sebuah
   "io.BufferedWriter", dan dalam mode baca/tulis, ia mengembalikan
   sebuah "io.BufferedRandom". Ketika *buffering* dinonaktifkan,
   aliran tak diproses *raw stream*, subkelas dari "io.RawIOBase",
   "io.FileIO", dikembalikan.

   Lihat juga modul penanganan berkas, seperti, "fileinput", "io" (di
   mana "open()" dideklarasikan), "os", "os.path", "tempfile", dan
   "shutil".

   Memunculkan auditing event "open" dengan argumen "file", "mode",
   "flags".

   Argumen "mode" dan "flags" mungkin telah dimodifikasi atau
   disimpulkan dari pemanggilan asli.

      Berubah pada versi 3.3:

      * Parameter *opener* telah ditambahkan.

      * Mode "'x'" telah ditambahkan.

      * "IOError" sebelumnya ditimbulkan, sekarang merupakan alias
        dari "OSError".

      * "FileExistsError" sekarang ditimbulkan jika berkas yang dibuka
        dalam mode pembuatan eksklusif ("'x'") sudah ada.

      Berubah pada versi 3.4:

      * Berkas sekarang tidak dapat diwariskan.

   Deprecated since version 3.4, will be removed in version 3.9: Mode
   "'U'".

      Berubah pada versi 3.5:

      * Jika panggilan sistem terganggu dan penangan sinyal tidak
        menimbulkan pengecualian, fungsi sekarang mencoba ulang
        panggilan sistem alih-alih menimbulkan pengecualian
        "InterruptedError" (lihat **PEP 475** untuk penjelasannya).

      * Penangan kesalahan "'namereplace'" telah ditambahkan.

      Berubah pada versi 3.6:

      * Dukungan ditambahkan untuk menerima objek yang
        mengimplementasikan "os.PathLike".

      * Di Windows, membuka penyangga *buffer* konsol dapat
        mengembalikan subclass dari "io.RawIOBase" selain "io.FileIO".

ord(c)

   Diberikan string yang mewakili satu karakter Unicode, kembalikan
   integer yang mewakili titik kode Unicode dari karakter itu.
   Misalnya, "ord('a')" mengembalikan integer "97" dan "ord('€')"
   (tanda Euro) mengembalikan "8364". Ini adalah kebalikan dari
   "chr()".

pow(base, exp[, mod])

   Kembalikan *base* ke *power* *exp*; jika *mod* ada, kembalikan
   *base* ke *power* *exp*, *modulo* *mod* (dihitung lebih efisien
   daripada "pow(base, exp) % mod"). Bentuk dua argumen "pow(base,
   exp)" setara dengan menggunakan operator *power*: "base**exp".

   Argumen harus memiliki tipe numerik. Dengan tipe operan campuran,
   aturan paksaan untuk operator aritmatika biner berlaku. Untuk
   operan "int", hasilnya memiliki tipe yang sama dengan operan
   (setelah paksaan) kecuali argumen kedua negatif; dalam hal itu,
   semua argumen dikonversi menjadi pecahan *float* dan hasil pecahan
   *float* dikirimkan. Misalnya, "10**2" mengembalikan "100", tetapi
   "10**-2" mengembalikan "0.01".

   Untuk operan "int" *base* dan *exp*, jika *mod* ada, *mod* juga
   harus bertipe integer dan *mod* harus bukan nol. Jika *mod* ada dan
   *exp* negatif, *basis* harus relatif prima ke *mod*. Dalam kasus
   itu, "pow(inv_base, -exp, mod)" dikembalikan, di mana *inv_base*
   adalah kebalikan dari *base* *modulo* *mod*.

   Berikut adalah contoh penghitungan kebalikan untuk "38" modulo
   "97":

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   Berubah pada versi 3.8: Untuk operan "int", bentuk tiga argumen
   dari "pow" sekarang memungkinkan argumen kedua menjadi negatif,
   memungkinkan perhitungan *inverse* modular.

   Berubah pada versi 3.8: Izinkan argumen kata kunci *keyword
   arguments*. Sebelumnya, hanya argumen posisi yang didukung.

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

   Cetak *objects* ke aliran teks *file*, dipisahkan oleh *sep* dan
   diikuti oleh *end*. *sep*, *end*, *file* dan *flush*, jika ada,
   harus diberikan sebagai argumen kata kunci *keyword arguments*.

   Semua argumen non-kata kunci dikonversi ke string seperti "str()"
   dan ditulis ke aliran *stream*, dipisahkan oleh *sep* dan diikuti
   oleh *end*. Baik *sep* dan *end* harus berupa string; mereka juga
   bisa "None", yang berarti menggunakan nilai bawaan. Jika tidak ada
   *objects* yang diberikan, "print()" hanya akan menulis *end*.

   Argumen *file* harus berupa objek dengan metode "write(string)";
   jika tidak ada atau "None", "sys.stdout" akan digunakan. Karena
   argumen yang dicetak dikonversi ke string teks, "print()" tidak
   dapat digunakan dengan objek file mode biner. Untuk ini, gunakan
   "file.write(...)" sebagai gantinya.

   Meski penyangga *buffer* keluaran biasanya ditentukan oleh *file*,
   tetapi jika argumen kata kunci *flush* bernilai benar, aliran
   *stream* dihapus *flushed* secara paksa.

   Berubah pada versi 3.3: Menambahkan argumen kata kunci *flush*.

class property(fget=None, fset=None, fdel=None, doc=None)

   Kembalikan atribut properti.

   *fget* adalah fungsi untuk mendapatkan nilai atribut. *fset* adalah
   fungsi untuk mengatur nilai atribut. *fdel* adalah fungsi untuk
   menghapus nilai atribut. Dan *doc* membuat docstring untuk atribut.

   Penggunaan khasnya untuk mendefinisikan atribut yang dikelola "x":

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   Jika *c* adalah *instance* dari *C*, "c.x" akan memanggil *getter*,
   "c.x = value" akan memanggil *setter* dan "del c.x" memanggil
   deleter.

   Jika diberikan, *doc* akan menjadi *docstring* dari atribut
   properti. Jika tidak, properti akan menyalin *docstring* dari
   *fget* (jika ada). Ini memungkinkan untuk membuat properti baca-
   saja *read-only* dengan mudah menggunakan "property()" sebagai
   *decorator*:

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   *Decorator* "@property" mengubah metode "voltage()" menjadi
   "getter" untuk atribut baca-saja *read-only* dengan nama yang sama,
   dan mengatur *docstring* untuk *voltage* menjadi "Get the current
   voltage."

   Properti dari objek memiliki: attr:*~property.getter*, "setter",
   dan "deleter" metode yang dapat digunakan sebagai dekorator yang
   membuat salinan properti dengan fungsi *accessor* yang sesuai.
   diatur ke fungsi yang didekorasi. Ini paling baik dijelaskan dengan
   contoh:

      class C:
          def __init__(self):
              self._x = None

          @property
          def x(self):
              """I'm the 'x' property."""
              return self._x

          @x.setter
          def x(self, value):
              self._x = value

          @x.deleter
          def x(self):
              del self._x

   Kode ini persis sama dengan contoh pertama. Pastikan untuk memberi
   fungsi tambahan nama yang sama dengan properti asli ("x" dalam
   kasus ini.)

   Properti dari objek yang dikembalikan juga memiliki atribut "fget",
   "fset", dan "fdel" yang sesuai dengan argumen pembangun
   *constructor*.

   Berubah pada versi 3.5: docstrings dari properti objek-objek
   sekarang dapat ditulisi.

class range(stop)
class range(start, stop[, step])

   Alih-alih menjadi fungsi, "range" sebenarnya merupakan tipe urutan
   yang tidak dapat diubah *immutable*, seperti yang didokumentasikan
   dalam Ranges dan Sequence Types --- list, tuple, range.

repr(object)

   Mengembalikan string yang berisi representasi objek yang dapat
   dicetak. Untuk banyak tipe, fungsi ini berusaha untuk mengembalikan
   string yang akan menghasilkan objek dengan nilai yang sama ketika
   diteruskan ke "eval()", jika tidak, representasi adalah string yang
   tertutup kurung sudut yang berisi nama jenis objek bersama dengan
   informasi tambahan seringkali termasuk nama dan alamat objek. Kelas
   dapat mengontrol apa fungsi ini yang dikembalikan untuk
   *instance*-nya dengan mendefinisikan metode "__repr__()".

reversed(seq)

   Kembalikan kebalikan dari *iterator*. *seq* harus berupa objek yang
   memiliki "__reversed__()" metode atau dukungan protokol urutan
   (metode "__len__()" dan metode "__getitem__()" dengan argumen
   integer mulai dari "0" ).

round(number[, ndigits])

   Kembalikan *number* dibulatkan ke *ndigits* presisi setelah titik
   desimal. Jika *ndigits* dihilangkan atau "None", ini akan
   mengembalikan integer terdekat ke masukannya.

   Untuk tipe bawaan yang mendukung "round()", nilai dibulatkan ke
   kelipatan terdekat dari 10 dengan pangkat minus *ndigits*; jika dua
   kelipatan sama-sama dekat, pembulatan dilakukan menuju pilihan
   genap (jadi, misalnya, "round(0.5)" dan "round(-0.5)" adalah "0",
   dan "round(1.5)" adalah "2"). Nilai integer apa pun berlaku untuk
   *ndigits* (positif, nol, atau negatif). Nilai kembaliannya adalah
   bilangan bulat jika *ndigits* dihilangkan atau "None". Kalau tidak,
   nilai kembaliannya memiliki jenis yang sama dengan *number*.

   Untuk sebuah objek Python "number" secara umum, "round"
   mendelegasikan ke "number.__round__".

   Catatan:

     Perilaku "round()" untuk pecahan *floats* bisa mengejutkan:
     misalnya, "round(2.675, 2)" memberikan "2.67" alih-alih yang
     diharapkan "2.68". Ini bukan bug: ini adalah hasil dari fakta
     bahwa sebagian besar pecahan desimal tidak dapat diwakili persis
     seperti pelampung *float*. Lihat Aritmatika Pecahan Floating
     Point: Masalah dan Keterbatasan untuk informasi lebih lanjut.

class set([iterable])

   Kembalikan objek baru "set", secara opsional dengan elemen yang
   diambil dari *iterable*. "set" adalah kelas bawaan. Lihat:
   class:*set* dan Set Types --- set, frozenset untuk dokumentasi
   tentang kelas ini.

   Untuk wadah *containers* lain lihat kelas-kelas bawaan "frozenset",
   "list", "tuple", dan "dict", juga modul "collections".

setattr(object, name, value)

   Ini adalah bagian dari "getattr()". Argumen adalah objek, string
   dan nilai yang berubah-ubah *arbitrary*. String dapat memberi nama
   atribut yang ada atau atribut baru. Fungsi memberikan nilai ke
   atribut, asalkan objek memungkinkannya. Misalnya, "setattr(x,
   'foobar', 123)" setara dengan "x.foobar = 123".

class slice(stop)
class slice(start, stop[, step])

   Kembali sebuah objek *slice* yang mewakili sekumpulan indeks yang
   ditentukan oleh "range(start, stop, step)". The *start* dan *step*
   argumen bawaannya "None". Objek Slice memiliki atribut data hanya
   baca *read-only* "start", "stop" dan "step" yang hanya
   mengembalikan nilai argumen (atau bawaannya). Mereka tidak memiliki
   fungsi eksplisit lainnya; namun mereka digunakan oleh Numerical
   Python dan ekstensi pihak ketiga lainnya. Objek slice juga
   dihasilkan ketika sintaks pengindeksan yang diperbesar digunakan.
   Misalnya: "a[start:stop:step]" atau "a[start:stop, i]". Lihat
   "itertools.islice()" untuk versi alternatif yang mengembalikan
   sebuah *iterator*.

sorted(iterable, *, key=None, reverse=False)

   Kembalikan daftar baru yang diurutkan dari item di *iterable*.

   Memiliki dua argumen opsional yang harus ditentukan sebagai argumen
   kata kunci.

   *key* menentukan sebuah fungsi dari satu argumen yang digunakan
   untuk mengekstrak kunci perbandingan dari setiap elemen di
   *iterable* (misalnya, "key=str.lower"). Nilai bawaannya adalah
   "None" (bandingkan elemen secara langsung).

   *reverse* adalah nilai *boolean*. Jika diatur ke "True", maka
   elemen list atau daftar diurutkan seolah-olah setiap perbandingan
   dibalik.

   Gunakan "functools.cmp_to_key()" untuk mengubah fungsi *cmp* gaya
   lama menjadi fungsi *key*.

   Fungsi bawaan "sorted()" dijamin stabil. Semacam stabil jika
   menjamin tidak mengubah urutan relatif elemen yang membandingkan
   kesamaan --- ini berguna untuk menyortir dalam beberapa langkah
   (misalnya, urutkan berdasarkan departemen, lalu dengan tingkat
   gaji).

   Untuk contoh pengurutan dan tutorial singkat pengurutan, lihat
   :ref: *sortinghowto*.

@staticmethod

   Ubah sebuah metode menjadi sebuah metode statis.

   Metode statis tidak menerima argumen implisit pertama. Untuk
   mendeklarasikan metode statis, gunakan idiom ini:

      class C:
          @staticmethod
          def f(arg1, arg2, ...): ...

   Bentuk "@staticmethod" adalah fungsi *decorator* -- lihat Definisi
   fungsi untuk detail.

   Metode statis dapat dipanggil baik di kelas (seperti "C.f()") atau
   pada instance (seperti "C().f()").

   Metode statis di Python mirip dengan yang ditemukan di Java atau
   C++. Juga lihat "classmethod()" untuk varian yang berguna untuk
   membuat konstruktor kelas alternatif.

   Seperti semua dekorator, dimungkinkan juga untuk memanggil
   "staticmethod" sebagai fungsi biasa dan melakukan sesuatu dengan
   hasilnya. Ini diperlukan dalam beberapa kasus di mana Anda
   memerlukan referensi ke fungsi dari badan kelas dan Anda ingin
   menghindari transformasi otomatis ke metode *instance*. Untuk kasus
   ini, gunakan idiom ini:

      class C:
          builtin_open = staticmethod(open)

   Untuk informasi lebih lanjut tentang metode statis, lihat The
   standard type hierarchy.

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

   Kembalikan sebuah versi "str" dari *objek*.  Lihat "str()" untuk
   detailnya.

   "str" adalah string bawaan *class*.  Untuk informasi umum tentang
   string, lihat Text Sequence Type --- str.

sum(iterable, /, start=0)

   Jumlah *start* dan item dari *iterable* dari kiri ke kanan dan
   mengembalikan total. Item *iterable* biasanya berupa angka, dan
   nilai awal tidak boleh berupa string.

   Untuk beberapa kasus penggunaan, ada alternatif yang baik untuk
   "sum()". Cara yang disukai dan cepat untuk menggabungkan rangkaian
   string adalah dengan memanggil "''.join(sequence)". Untuk
   menambahkan nilai pecahan *floating point* dengan presisi yang
   diperluas, lihat "math.fsum()". Untuk menggabungkan serangkaian
   iterables, coba gunakan "itertools.chain()".

   Berubah pada versi 3.8: Parameter *mulai* dapat ditentukan sebagai
   argumen kata kunci.

super([type[, object-or-type]])

   Kembalikan objek proxy yang mendelegasikan panggilan metode ke
   kelas orang tua atau saudara dari *type*. Ini berguna untuk
   mengakses metode yang diwariskan yang telah ditimpa di suatu kelas.

   *object-or-type* menentukan *method resolution order* yang akan
   dicari. Pencarian dimulai dari kelas tepat setelah *type*.

   Sebagai contoh, jika "__ mro__" dari *object-or-type* adalah "D ->
   B -> C -> A -> object" dan nilai *type* adalah "B", lalu "super()"
   mencari "C -> A -> object".

   Atribut "__ mro__" dari *object-or-type* mencantumkan urutan metode
   pencarian resolusi yang digunakan oleh kedua "getattr()" dan
   "super()". Atributnya dinamis dan dapat berubah setiap kali
   hierarki warisan diperbarui.

   Jika argumen kedua dihilangkan, objek super yang dikembalikan tidak
   terikat *unbound*. Jika argumen kedua adalah objek,
   "isinstance(obj, type)" harus benar. Jika argumen kedua adalah
   tipe, "issubclass(type2, type)" harus benar (ini berguna untuk
   metode-metode kelas).

   Ada dua kasus penggunaan khas untuk *super*. Dalam hierarki kelas
   dengan pewarisan tunggal *single inheritance*, *super* dapat
   digunakan untuk merujuk ke kelas induk tanpa menyebutkannya secara
   eksplisit, sehingga membuat kode lebih mudah dikelola. Penggunaan
   ini sangat mirip dengan penggunaan *super* dalam bahasa pemrograman
   lain.

   The second use case is to support cooperative multiple inheritance
   in a dynamic execution environment.  This use case is unique to
   Python and is not found in statically compiled languages or
   languages that only support single inheritance.  This makes it
   possible to implement "diamond diagrams" where multiple base
   classes implement the same method.  Good design dictates that such
   implementations have the same calling signature in every case
   (because the order of calls is determined at runtime, because that
   order adapts to changes in the class hierarchy, and because that
   order can include sibling classes that are unknown prior to
   runtime).

   Untuk kedua kasus penggunaan, pemanggilan *superclass* yang khas
   terlihat seperti ini:

      class C(B):
          def method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

   Selain pencarian metode, "super()" juga berfungsi untuk pencarian
   atribut. Salah satu kemungkinan kasus penggunaan ini adalah
   pemanggilan *descriptors* di kelas induk atau saudara kandung.

   Perhatikan bahwa "super()" diimplementasikan sebagai bagian dari
   proses pengikatan *binding* untuk pencarian atribut eksplisit
   bertitik *dotted* seperti "super().__getitem__(name)". Itu
   melakukannya dengan menerapkan sendiri metode "__getattribute__()"
   untuk mencari kelas dalam urutan terprediksi yang mendukung
   *multiple inheritance* kooperatif. Dengan demikian, "super()" tidak
   ditentukan untuk pencarian implisit menggunakan pernyataan atau
   operator seperti "super()[name]".

   Juga perhatikan bahwa, selain dari bentuk tanpa argumen, "super()"
   tidak terbatas untuk menggunakan metode di dalam. Bentuk dua
   argumen menentukan argumen dengan tepat dan membuat referensi yang
   sesuai. Bentuk tanpa argumen hanya bekerja di dalam definisi kelas,
   karena *compiler* mengisi rincian yang diperlukan untuk mengambil
   kelas yang didefinisikan dengan benar, serta mengakses *instance*
   saat ini untuk metode biasa.

   Untuk saran praktis tentang bagaimana merancang kelas kooperatif
   menggunakan "super()", lihat guide to using super().

class tuple([iterable])

   Alih-alih menjadi fungsi, "tuple" sebenarnya merupakan tipe urutan
   yang tidak dapat diubah atau disebut *immutable*, seperti yang
   didokumentasikan dalam Tuples dan Sequence Types --- list, tuple,
   range.

class type(object)
class type(name, bases, dict, **kwds)

   Dengan satu argumen, kembalikan tipe dari sebuah *object*. Nilai
   kembaliannya adalah sebuah tipe objek dan umumnya objek yang sama
   seperti yang dikembalikan oleh "object.__class__".

   Fungsi bawaan "isinstance()" direkomendasikan untuk menguji jenis
   objek, karena ia memperhitungkan subkelas.

   With three arguments, return a new type object.  This is
   essentially a dynamic form of the "class" statement. The *name*
   string is the class name and becomes the "__name__" attribute. The
   *bases* tuple contains the base classes and becomes the "__bases__"
   attribute; if empty, "object", the ultimate base of all classes, is
   added.  The *dict* dictionary contains attribute and method
   definitions for the class body; it may be copied or wrapped before
   becoming the "__dict__" attribute. The following two statements
   create identical "type" objects:

   >>> class X:
   ...     a = 1
   ...
   >>> X = type('X', (), dict(a=1))

   Lihat juga Objek Tipe.

   Keyword arguments provided to the three argument form are passed to
   the appropriate metaclass machinery (usually "__init_subclass__()")
   in the same way that keywords in a class definition (besides
   *metaclass*) would.

   See also Customizing class creation.

   Berubah pada versi 3.6: Subkelas dari "type" yang tidak menimpa
   "type.__new__" mungkin tidak lagi menggunakan bentuk satu argumen
   untuk mendapatkan tipe dari suatu objek.

vars([object])

   Kembalikan atribut: attr:*~object.__ dict__* untuk modul, kelas,
   *instance*, atau objek lainnya yang memiliki atribut "__ dict__".

   Objek seperti modul dan *instance* memiliki atribut yang dapat
   diperbarui "__dict__"; namun, objek lain mungkin memiliki batasan
   penulisan pada atribut "__dict__" (misalnya, kelas menggunakan
   sebuah "types.MappingProxyType" untuk mencegah pembaruan kamus
   secara langsung).

   Tanpa argumen, "vars()" bertindak seperti "locals()". Catatan,
   *dictionary* lokal hanya berguna untuk dibaca karena pembaruan ke
   *dictionary* lokal diabaikan.

   Sebuah pengecualian untuk "TypeError" akan muncul jika suatu objek
   yang ditentukan tetapi tidak memiliki sebuah atribut "__dict__"
   (contohnya, jika suatu kelas didefinisikan sebagai atribut
   "__slots__").

zip(*iterables)

   Membuat *iterator* yang mengumpulkan elemen dari masing-masing
   *iterables*.

   Kembalikan *iterator* dari *tuples*, di mana tuple ke-*i* berisi
   elemen ke-*i* dari masing-masing urutan argumen atau *iterables*.
   Iterator berhenti ketika masukan terpendek *iterable* habis. Dengan
   argumen *iterable* tunggal, ia mengembalikan iterator 1-tupel.
   Tanpa argumen, ia mengembalikan *iterator* kosong. Setara dengan:

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

   Urutan evaluasi *iterables* dari kiri ke kanan dijamin. Hal ini
   memungkinkan idiom untuk mengelompokkan seri data ke dalam grup
   panjang-n menggunakan "zip(*[iter(s)]*n)". Ini mengulangi iterator
   yang sama *same* "n" kali sehingga setiap tuple keluaran memiliki
   hasil panggilan "n" ke *iterator*. Ini memiliki efek membagi input
   menjadi potongan panjang-n.

   "zip()" hanya boleh digunakan dengan masukan yang panjangnya tidak
   sama ketika Anda tidak peduli tentang bagian akhirnya, nilai yang
   tidak cocok dari *iterables* yang lebih panjang. Jika nilai-nilai
   itu penting, gunakan "itertools.zip_longest()" sebagai gantinya.

   "zip()" bersama dengan operator "*" dapat digunakan untuk *unzip*
   sebuah list atau daftar:

      >>> x = [1, 2, 3]
      >>> y = [4, 5, 6]
      >>> zipped = zip(x, y)
      >>> list(zipped)
      [(1, 4), (2, 5), (3, 6)]
      >>> x2, y2 = zip(*zip(x, y))
      >>> x == list(x2) and y == list(y2)
      True

__import__(name, globals=None, locals=None, fromlist=(), level=0)

   Catatan:

     Ini adalah fungsi lanjutan yang tidak diperlukan dalam
     pemrograman Python sehari-hari, tidak seperti
     "importlib.import_module()".

   Fungsi ini dipanggil oleh pernyataan "import". Itu dapat diganti
   (dengan mengimpor modul "builtins" dan mengisi ke
   "builtins.__import__") untuk mengubah semantik pernyataan "import",
   tetapi melakukannya **strongly** atau tidak disarankan karena
   biasanya lebih mudah menggunakan kait impor (lihat: pep:*302*)
   untuk mencapai tujuan yang sama dan tidak menyebabkan masalah
   dengan kode yang mengasumsikan implementasi impor standar sedang
   digunakan. Penggunaan langsung "__import__()" juga tidak disarankan
   untuk kepentingan "importlib.import_module()".

   Fungsi ini mengimpor modul *name*, berpotensi menggunakan *globals*
   dan *locals* yang diberikan untuk menentukan cara menafsirkan nama
   dalam konteks paket. *fromlist* memberikan nama-nama objek atau
   submodul yang harus diimpor dari modul yang diberikan oleh *name*.
   Implementasi standar sama sekali tidak menggunakan argumen
   *locals*, dan hanya menggunakan *globals* untuk menentukan konteks
   paket dari pernyataan "import".

   *level* menentukan apakah akan menggunakan impor absolut atau
   relatif. "0" (bawaan) berarti hanya melakukan impor absolut. Nilai
   positif untuk *level* menunjukkan jumlah direktori induk untuk
   mencari relatif ke direktori pemanggilan modul "__import__()"
   (lihat **PEP 328** untuk detailnya).

   Ketika variabel *name* dalam bentuk "package.module", biasanya,
   paket tingkat atas (nama hingga titik pertama) dikembalikan, *not*
   modul dinamai dengan *name*. Namun, ketika argumen tidak-kosong
   *fromlist * diberikan, modul bernama oleh *name* dikembalikan.

   Sebagai contoh, pernyataan "import spam" menghasilkan bytecode yang
   menyerupai kode berikut:

      spam = __import__('spam', globals(), locals(), [], 0)

   Pernyataan "import spam.ham" menghasilkan panggilan ini:

      spam = __import__('spam.ham', globals(), locals(), [], 0)

   Perhatikan caranya "__import__()" mengembalikan modul tingkat atas
   di sini karena ini adalah objek yang terikat pada nama oleh
   pernyataan "import".

   Di sisi lain, pernyataan "from spam.ham import eggs, sausage as
   saus" menghasilkan

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   Di sini, modul "spam.ham" dikembalikan dari "__import__()". Dari
   objek ini, nama yang akan diimpor diambil dan diisikan ke nama
   masing-masing.

   Jika Anda hanya ingin mengimpor sebuah modul (berpotensi dalam
   suatu paket) dengan nama, gunakan "importlib.import_module()".

   Berubah pada versi 3.3: Nilai negatif untuk *level* tidak lagi
   didukung (juga mengubah nilai default menjadi 0).

-[ Catatan kaki ]-

[1] Perhatikan bahwa pengurai hanya menerima konvensi akhir garis *end
    of line* gaya Unix. Jika Anda membaca kode dari sebuah berkas,
    pastikan untuk menggunakan mode konversi baris baru untuk
    mengkonversi baris baru gaya Windows atau Mac.
