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

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

+---------------------------+-------------------------+-------------------------+---------------------------+
| Fungsi Bawaan                                                                                             |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "anext()" "any()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   Return the absolute value of a number.  The argument may be an
   integer, a floating-point number, or an object implementing
   "__abs__()". If the argument is a complex number, its magnitude is
   returned.

aiter(async_iterable)

   Return an *asynchronous iterator* for an *asynchronous iterable*.
   Equivalent to calling "x.__aiter__()".

   Note: Unlike "iter()", "aiter()" has no 2-argument variant.

   Added in version 3.10.

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

awaitable anext(async_iterator)
awaitable anext(async_iterator, default)

   When awaited, return the next item from the given *asynchronous
   iterator*, or *default* if given and the iterator is exhausted.

   This is the async variant of the "next()" builtin, and behaves
   similarly.

   This calls the "__anext__()" method of *async_iterator*, returning
   an *awaitable*. Awaiting this returns the next value of the
   iterator. If *default* is given, it is returned if the iterator is
   exhausted, otherwise "StopAsyncIteration" is raised.

   Added in version 3.10.

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)

   As "repr()", return a string containing a printable representation
   of an object, but escape the non-ASCII characters in the string
   returned by "repr()" using "\x", "\u", or "\U" escapes.  This
   generates a string similar to that returned by "repr()" in Python
   2.

bin(x)

   Convert an integer number to a binary string prefixed with "0b".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. Some examples:

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

   If the prefix "0b" is desired or not, you can use either of the
   following ways.

   >>> 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(object=False, /)

   Return a Boolean value, i.e. one of "True" or "False".  The
   argument is converted using the standard truth testing procedure.
   If the argument is false or omitted, this returns "False";
   otherwise, it returns "True".  The "bool" class is a subclass of
   "int" (see Numeric Types --- int, float, complex). It cannot be
   subclassed further.  Its only instances are "False" and "True" (see
   Boolean Type - bool).

   Berubah pada versi 3.7: The parameter is now positional-only.

breakpoint(*args, **kws)

   This function drops you into the debugger at the call site.
   Specifically, it calls "sys.breakpointhook()", passing "args" and
   "kws" straight through.  By default, "sys.breakpointhook()" calls
   "pdb.set_trace()" expecting no arguments.  In this case, it is
   purely a convenience function so you don't have to explicitly
   import "pdb" or type as much code to enter the debugger.  However,
   "sys.breakpointhook()" can be set to some other function and
   "breakpoint()" will automatically call that, allowing you to drop
   into the debugger of choice. If "sys.breakpointhook()" is not
   accessible, this function will raise "RuntimeError".

   By default, the behavior of "breakpoint()" can be changed with the
   "PYTHONBREAKPOINT" environment variable. See "sys.breakpointhook()"
   for usage details.

   Note that this is not guaranteed if "sys.breakpointhook()" has been
   replaced.

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

   Added in version 3.7.

class bytearray(source=b'')
class bytearray(source, encoding)
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=b'')
class bytes(source, encoding)
class bytes(source, encoding, errors)

   Return a new "bytes" object which is an immutable sequence of
   integers in the range "0 <= x < 256".  "bytes" is an immutable
   version of "bytearray" -- it has the same non-mutating methods and
   the same indexing and slicing behavior.

   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)

   Return "True" if the *object* argument appears callable, "False" if
   not.  If this returns "True", it is still possible that a call
   fails, but if it is "False", calling *object* will never succeed.
   Note that classes are callable (calling a class returns a new
   instance); instances are callable if their class has a "__call__()"
   method.

   Added in version 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.

   A class method receives the class as an implicit first argument,
   just like an instance method receives the instance. To declare a
   class method, use this idiom:

      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()" in this section. For more
   information on class methods, see The standard type hierarchy.

   Berubah pada versi 3.9: Class methods can now wrap other
   *descriptors* such as "property()".

   Berubah pada versi 3.10: Class methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__") and have a new "__wrapped__" attribute.

   Berubah pada versi 3.11: Class methods can no longer wrap other
   *descriptors* such as "property()".

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
   compiler options should be activated and which future features
   should be allowed. If neither is present (or both are zero) the
   code is compiled with the same flags that affect the code that is
   calling "compile()". If the *flags* argument is given and
   *dont_inherit* is not (or is zero) then the compiler options and
   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 flags
   (future features and compiler options) in the surrounding code are
   ignored.

   Compiler options and future statements are specified by bits which
   can be bitwise ORed together to specify multiple options. The
   bitfield required to specify a given future feature can be found as
   the "compiler_flag" attribute on the "_Feature" instance in the
   "__future__" module. Compiler flags can be found in "ast" module,
   with "PyCF_" prefix.

   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" dan
   "filename". *event* ini juga dapat dimunculkan oleh kompilasi
   implisit.

   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: Allowed use of Windows and Mac newlines.
   Also, input in "'exec'" mode does not have to end in a newline
   anymore.  Added the *optimize* parameter.

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

   Added in version 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(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   Convert a single string or number to a complex number, or create a
   complex number from real and imaginary parts.

   Examples:

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

   If the argument is a string, it must contain either a real part (in
   the same format as for "float()") or an imaginary part (in the same
   format but with a "'j'" or "'J'" suffix), or both real and
   imaginary parts (the sign of the imaginary part is mandatory in
   this case). The string can optionally be surrounded by whitespaces
   and the round parentheses "'('" and "')'", which are ignored. The
   string must not contain whitespace between "'+'", "'-'", the "'j'"
   or "'J'" suffix, and the decimal number. For example,
   "complex('1+2j')" is fine, but "complex('1 + 2j')" raises
   "ValueError". More precisely, the input must conform to the
   "complexvalue" production rule in the following grammar, after
   parentheses and leading and trailing whitespace characters are
   removed:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

   If the argument is a number, the constructor serves as a numeric
   conversion like "int" and "float". For a general Python object "x",
   "complex(x)" delegates to "x.__complex__()". If "__complex__()" is
   not defined then it falls back to "__float__()". If "__float__()"
   is not defined then it falls back to "__index__()".

   If two arguments are provided or keyword arguments are used, each
   argument may be any numeric type (including complex). If both
   arguments are real numbers, return a complex number with the real
   component *real* and the imaginary component *imag*. If both
   arguments are complex numbers, return a complex number with the
   real component "real.real-imag.imag" and the imaginary component
   "real.imag+imag.real". If one of arguments is a real number, only
   its real component is used in the above expressions.

   If all arguments are omitted, returns "0j".

   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: Falls back to "__index__()" if
   "__complex__()" and "__float__()" are not defined.

delattr(object, name)

   This is a relative of "setattr()".  The arguments are an object and
   a string.  The string must be the name of one of the object's
   attributes.  The function deletes the named attribute, provided the
   object allows it.  For example, "delattr(x, 'foobar')" is
   equivalent to "del x.foobar". *name* need not be a Python
   identifier (see "setattr()").

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()
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.

   If the object has a method named "__dir__()", this method will be
   called and must return the list of attributes. This allows objects
   that implement a custom "__getattr__()" or "__getattribute__()"
   function to customize the way "dir()" reports their attributes.

   If the object does not provide "__dir__()", the function tries its
   best to gather information from the object's "__dict__" attribute,
   if defined, and from its type object.  The resulting list is not
   necessarily complete and may be inaccurate when the object has a
   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)

   Take two (non-complex) numbers as arguments and return a pair of
   numbers consisting of their quotient and remainder when using
   integer division.  With mixed operand types, the rules for binary
   arithmetic operators apply.  For integers, the result is the same
   as "(a // b, a % b)". For floating-point numbers the result is "(q,
   a % b)", where *q* is usually "math.floor(a / b)" but may be 1 less
   than that.  In any case "q * b + a % b" is very close to *a*, if "a
   % b" is non-zero it has the same sign as *b*, and "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(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(expression, globals=None, locals=None)

   Parameter:
      * **expression** ("str" | code object) -- A Python expression.

      * **globals** ("dict" | "None") -- The global namespace
        (default: "None").

      * **locals** (*mapping* | "None") -- The local namespace
        (default: "None").

   Kembali:
      The result of the evaluated expression.

   Raises:
      Syntax errors are reported as exceptions.

   Peringatan:

     This function executes arbitrary code. Calling it with user-
     supplied input may lead to security vulnerabilities.

   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.  That way you can control what builtins are
   available to the executed code by inserting your own "__builtins__"
   dictionary into *globals* before passing it to "eval()".  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.

   Example:

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

   This function can also be used to execute arbitrary code objects
   (such as those created by "compile()").  In this case, pass a code
   object instead of a string.  If the code object has been compiled
   with "'exec'" as the *mode* argument, "eval()"'s return value will
   be "None".

   Hints: dynamic execution of statements is supported by the "exec()"
   function.  The "globals()" and "locals()" functions return the
   current global and local dictionary, respectively, which may be
   useful to pass around for use by "eval()" or "exec()".

   If the given source is a string, then leading and trailing spaces
   and tabs are stripped.

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

   Memunculkan auditing event "exec" dengan objek kode sebagai
   argumen. Kompilasi kode *events* juga dapat dimunculkan.

exec(object, globals=None, locals=None, /, *, closure=None)

   Peringatan:

     This function executes arbitrary code. Calling it with user-
     supplied input may lead to security vulnerabilities.

   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
   Masukan dari Berkas 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".

   In all cases, if the optional parts are omitted, the code is
   executed in the current scope.  If only *globals* is provided, it
   must be a dictionary (and not a subclass of dictionary), which will
   be used for both the global and the local variables.  If *globals*
   and *locals* are given, they are used for the global and local
   variables, respectively.  If provided, *locals* can be any mapping
   object.  Remember that at the module level, globals and locals are
   the same dictionary.

   Catatan:

     Most users should just pass a *globals* argument and never
     *locals*. If exec gets two separate objects as *globals* and
     *locals*, the code will be executed as if it were embedded in a
     class definition.

   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()".

   The *closure* argument specifies a closure--a tuple of cellvars.
   It's only valid when the *object* is a code object containing free
   variables. The length of the tuple must exactly match the number of
   free variables referenced by the code object.

   Memunculkan auditing event "exec" dengan objek kode sebagai
   argumen. Kompilasi kode *events* juga dapat dimunculkan.

   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.

   Berubah pada versi 3.11: Added the *closure* parameter.

filter(function, iterable)

   Construct an iterator from those elements of *iterable* for which
   *function* is true.  *iterable* may be either a sequence, a
   container which supports iteration, or an iterator.  If *function*
   is "None", the identity function is assumed, that is, all elements
   of *iterable* that are false are removed.

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

   See "itertools.filterfalse()" for the complementary function that
   returns elements of *iterable* for which *function* is false.

class float(number=0.0, /)
class float(string, /)

   Return a floating-point number constructed from a number or a
   string.

   Examples:

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

   If the argument is a string, it should contain a decimal number,
   optionally preceded by a sign, and optionally embedded in
   whitespace.  The optional sign may be "'+'" or "'-'"; a "'+'" sign
   has no effect on the value produced.  The argument may also be a
   string representing a NaN (not-a-number), or positive or negative
   infinity. More precisely, the input must conform to the
   "floatvalue" production rule in the following grammar, after
   leading and trailing whitespace characters are removed:

      sign          ::= "+" | "-"
      infinity      ::= "Infinity" | "inf"
      nan           ::= "nan"
      digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart     ::= digit (["_"] digit)*
      number        ::= [digitpart] "." digitpart | digitpart ["."]
      exponent      ::= ("e" | "E") [sign] digitpart
      floatnumber   ::= number [exponent]
      absfloatvalue ::= floatnumber | infinity | nan
      floatvalue    ::= [sign] absfloatvalue

   Case is not significant, so, for example, "inf", "Inf", "INFINITY",
   and "iNfINity" are all acceptable spellings for positive infinity.

   Otherwise, if the argument is an integer or a floating-point
   number, a floating-point number with the same value (within
   Python's floating-point precision) is returned.  If the argument is
   outside the range of a Python float, an "OverflowError" will be
   raised.

   For a general Python object "x", "float(x)" delegates to
   "x.__float__()".  If "__float__()" is not defined then it falls
   back to "__index__()".

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

   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: The parameter is now positional-only.

   Berubah pada versi 3.8: Falls back to "__index__()" if
   "__float__()" is not defined.

format(value, format_spec='')

   Convert a *value* to a "formatted" representation, as controlled by
   *format_spec*.  The interpretation of *format_spec* will depend on
   the type of the *value* argument; however, there is a standard
   formatting syntax that is used by most built-in types: Format
   Specification Mini-Language.

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

   A call to "format(value, format_spec)" is translated to
   "type(value).__format__(value, format_spec)" which bypasses the
   instance dictionary when searching for the value's "__format__()"
   method. A "TypeError" exception is raised if the method search
   reaches "object" and the *format_spec* is non-empty, or if either
   the *format_spec* or the return value are not strings.

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

class frozenset(iterable=set())

   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)
getattr(object, name, default)

   Return the value of the named attribute of *object*.  *name* must
   be a string. If the string is the name of one of the object's
   attributes, the result is the value of that attribute.  For
   example, "getattr(x, 'foobar')" is equivalent to "x.foobar".  If
   the named attribute does not exist, *default* is returned if
   provided, otherwise "AttributeError" is raised. *name* need not be
   a Python identifier (see "setattr()").

   Catatan:

     Since private name mangling happens at compilation time, one must
     manually mangle a private attribute's (attributes with two
     leading underscores) name in order to retrieve it with
     "getattr()".

globals()

   Return the dictionary implementing the current module namespace.
   For code within functions, this is set when the function is defined
   and remains the same regardless of where the function is called.

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:

     For objects with custom "__hash__()" methods, note that "hash()"
     truncates the return value based on the bit width of the host
     machine.

help()
help(request)

   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.

   Note that if a slash(/) appears in the parameter list of a function
   when invoking "help()", it means that the parameters prior to the
   slash are positional-only. For more info, see 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)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer. Some
   examples:

   >>> 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()".

   **Detail implementasi CPython:** This is the address of the object
   in memory.

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

input()
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"
   sebelum membaca masukan

   Raises an auditing event "builtins.input/result" with the result
   after successfully reading input.

class int(number=0, /)
class int(string, /, base=10)

   Return an integer object constructed from a number or a string, or
   return "0" if no arguments are given.

   Examples:

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

   If the argument defines "__int__()", "int(x)" returns
   "x.__int__()".  If the argument defines "__index__()", it returns
   "x.__index__()".  If the argument defines "__trunc__()", it returns
   "x.__trunc__()". For floating-point numbers, this truncates towards
   zero.

   If the argument is not a number or if *base* is given, then it must
   be a string, "bytes", or "bytearray" instance representing an
   integer in radix *base*.  Optionally, the string can be preceded by
   "+" or "-" (with no space in between), have leading zeros, be
   surrounded by whitespace, and have single underscores interspersed
   between digits.

   A base-n integer string contains digits, each representing a value
   from 0 to n-1. The values 0--9 can be represented by any Unicode
   decimal digit. The values 10--35 can be represented by "a" to "z"
   (or "A" to "Z"). The default *base* is 10. The allowed bases are 0
   and 2--36. Base-2, -8, and -16 strings can be optionally prefixed
   with "0b"/"0B", "0o"/"0O", or "0x"/"0X", as with integer literals
   in code.  For base 0, the string is interpreted in a similar way to
   an integer literal in code, in that the actual base is 2, 8, 10, or
   16 as determined by the prefix. Base 0 also disallows leading
   zeros: "int('010', 0)" is not legal, while "int('010')" and
   "int('010', 8)" are.

   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: The first parameter is now positional-only.

   Berubah pada versi 3.8: Falls back to "__index__()" if "__int__()"
   is not defined.

   Berubah pada versi 3.11: The delegation to "__trunc__()" is
   deprecated.

   Berubah pada versi 3.11: "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 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)

   Return "True" if the *object* argument is an instance of the
   *classinfo* argument, or of a (direct, indirect, or *virtual*)
   subclass thereof.  If *object* is not an object of the given type,
   the function always returns "False". If *classinfo* is a tuple of
   type objects (or recursively, other such tuples) or a Union Type of
   multiple types, return "True" if *object* is an instance of any of
   the types. If *classinfo* is not a type or tuple of types and such
   tuples, a "TypeError" exception is raised. "TypeError" may not be
   raised for an invalid type if an earlier check succeeds.

   Berubah pada versi 3.10: *classinfo* can be a Union Type.

issubclass(class, classinfo)

   Return "True" if *class* is a subclass (direct, indirect, or
   *virtual*) of *classinfo*.  A class is considered a subclass of
   itself. *classinfo* may be a tuple of class objects (or
   recursively, other such tuples) or a Union Type, in which case
   return "True" if *class* is a subclass of any entry in *classinfo*.
   In any other case, a "TypeError" exception is raised.

   Berubah pada versi 3.10: *classinfo* can be a Union Type.

iter(object)
iter(object, sentinel)

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, *object* must be a collection object
   which supports the *iterable* protocol (the "__iter__()" method),
   or it must support the sequence protocol (the "__getitem__()"
   method with integer arguments starting at "0").  If it does not
   support either of those protocols, "TypeError" is raised. If the
   second argument, *sentinel*, is given, then *object* must be a
   callable object.  The iterator created in this case will call
   *object* with no arguments for each call to its "__next__()"
   method; if the value returned is equal to *sentinel*,
   "StopIteration" will be raised, otherwise the value will be
   returned.

   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*).

   **Detail implementasi CPython:** "len" raises "OverflowError" on
   lengths larger than "sys.maxsize", such as "range(2 ** 100)".

class list
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, *iterables)

   Return an iterator that applies *function* to every item of
   *iterable*, yielding the results.  If additional *iterables*
   arguments are passed, *function* must take that many arguments and
   is applied to the items from all iterables in parallel.  With
   multiple iterables, the iterator stops when the shortest iterable
   is exhausted.  For cases where the function inputs are already
   arranged into argument tuples, see "itertools.starmap()".

max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)

   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)".

   Berubah pada versi 3.4: Added the *default* keyword-only parameter.

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

class memoryview(object)

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

min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)

   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)".

   Berubah pada versi 3.4: Added the *default* keyword-only parameter.

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

next(iterator)
next(iterator, default)

   Retrieve the next item from the *iterator* by calling its
   "__next__()" method.  If *default* is given, it is returned if the
   iterator is exhausted, otherwise "StopIteration" is raised.

class object

   This is the ultimate base class of all other classes. It has
   methods that are common to all instances of Python classes. When
   the constructor is called, it returns a new featureless object. The
   constructor does not accept any arguments.

   Catatan:

     "object" instances do *not* have "__dict__" attributes, so you
     can't assign arbitrary attributes to an instance of "object".

oct(x)

   Convert an integer number to an octal string prefixed with "0o".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. For example:

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

   If you want to convert an integer number to an octal string either
   with the prefix "0o" or not, you can use either of the following
   ways.

   >>> '%#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* is a *path-like object* giving the pathname (absolute or
   relative to the current working directory) of the file to be opened
   or an integer file descriptor of the file to be wrapped.  (If a
   file descriptor is given, it is closed when the returned I/O object
   is closed unless *closefd* is set to "False".)

   *mode* is an optional string that specifies the mode in which the
   file is opened.  It defaults to "'r'" which means open for reading
   in text mode. Other common values are "'w'" for writing (truncating
   the file if it already exists), "'x'" for exclusive creation, and
   "'a'" for appending (which on *some* Unix systems, means that *all*
   writes append to the end of the file regardless of the current seek
   position).  In text mode, if *encoding* is not specified the
   encoding used is platform-dependent: "locale.getencoding()" is
   called to get the current locale encoding. (For reading and writing
   raw bytes use binary mode and leave *encoding* unspecified.)  The
   available modes are:

   +-----------+-----------------------------------------------------------------+
   | 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'"     | open for writing, appending to the end of file if it exists     |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | mode biner                                                      |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | mode teks (bawaan)                                              |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | terbuka untuk memperbarui (membaca dan menulis)                 |
   +-----------+-----------------------------------------------------------------+

   The default mode is "'r'" (open for reading text, a synonym of
   "'rt'"). Modes "'w+'" and "'w+b'" open and truncate the file.
   Modes "'r+'" and "'r+b'" open the file with no truncation.

   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.

   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* is an optional integer used to set the buffering
   policy.  Pass 0 to switch buffering off (only allowed in binary
   mode), 1 to select line buffering (only usable when writing in text
   mode), and an integer > 1 to indicate the size in bytes of a fixed-
   size chunk buffer. Note that specifying a buffer size this way
   applies for binary buffered I/O, but "TextIOWrapper" (i.e., files
   opened with "mode='r+'") would have another buffering. To disable
   buffering in "TextIOWrapper", consider using the "write_through"
   flag for "io.TextIOWrapper.reconfigure()". When no *buffering*
   argument is given, the default buffering policy works as follows:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is chosen using a heuristic trying to determine the
     underlying device's "block size" and falling back on
     "io.DEFAULT_BUFFER_SIZE".  On many systems, the buffer will
     typically be 4096 or 8192 bytes long.

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

   *encoding* is the name of the encoding used to decode or encode the
   file. This should only be used in text mode.  The default encoding
   is platform dependent (whatever "locale.getencoding()" returns),
   but any *text encoding* supported by Python can be used. See the
   "codecs" module for the list of supported encodings.

   *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'" will represent any incorrect bytes as low
     surrogate code units ranging from U+DC80 to U+DCFF. These
     surrogate code units will then be turned back into the same bytes
     when the "surrogateescape" error handler is used when writing
     data.  This is useful for processing files in an unknown
     encoding.

   * "'xmlcharrefreplace'" is only supported when writing to a file.
     Characters not supported by the encoding are replaced with the
     appropriate XML character reference "&#*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* determines how to parse newline characters from the
   stream. It can be "None", "''", "'\n'", "'\r'", and "'\r\n'".  It
   works as follows:

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

   If *closefd* is "False" and a file descriptor rather than a
   filename was given, the underlying file descriptor will be kept
   open when the file is closed.  If a filename is given *closefd*
   must be "True" (the default); otherwise, an error will be raised.

   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.

   See also the file handling modules, such as "fileinput", "io"
   (where "open()" is declared), "os", "os.path", "tempfile", and
   "shutil".

   Raises an auditing event "open" with arguments "path", "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.

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

   Berubah pada versi 3.11: The "'U'" mode has been removed.

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=None)

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

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For
   "int" operands, the result has the same type as the operands (after
   coercion) unless the second argument is negative; in that case, all
   arguments are converted to float and a float result is delivered.
   For example, "pow(10, 2)" returns "100", but "pow(10, -2)" returns
   "0.01".  For a negative base of type "int" or "float" and a non-
   integral exponent, a complex result is delivered.  For example,
   "pow(-9, 0.5)" returns a value close to "3j". Whereas, for a
   negative base of type "int" or "float" with an integral exponent, a
   float result is delivered. For example, "pow(-9, 2.0)" returns
   "81.0".

   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=None, flush=False)

   Print *objects* to the text stream *file*, separated by *sep* and
   followed by *end*.  *sep*, *end*, *file*, and *flush*, if present,
   must be given as 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.

   Output buffering is usually determined by *file*. However, if
   *flush* is true, the stream is forcibly flushed.

   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.")

   If *c* is an instance of *C*, "c.x" will invoke the getter, "c.x =
   value" will invoke the setter, and "del c.x" the 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

   The "@property" decorator turns the "voltage()" method into a
   "getter" for a read-only attribute with the same name, and it sets
   the docstring for *voltage* to "Get the current voltage."

   @getter

   @setter

   @deleter

      A property object has "getter", "setter", and "deleter" methods
      usable as decorators that create a copy of the property with the
      corresponding accessor function set to the decorated function.
      This is best explained with an example:

         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=1)

   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)

   Return a string containing a printable representation of an object.
   For many types, this function makes an attempt to return a string
   that would yield an object with the same value when passed to
   "eval()"; otherwise, the representation is a string enclosed in
   angle brackets that contains the name of the type of the object
   together with additional information often including the name and
   address of the object.  A class can control what this function
   returns for its instances by defining a "__repr__()" method. If
   "sys.displayhook()" is not accessible, this function will raise
   "RuntimeError".

   This class has a custom representation that can be evaluated:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(seq)

   Return a reverse *iterator*.  *seq* must be an object which has a
   "__reversed__()" method or supports the sequence protocol (the
   "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "0").

round(number, ndigits=None)

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

   For the built-in types supporting "round()", values are rounded to
   the closest multiple of 10 to the power minus *ndigits*; if two
   multiples are equally close, rounding is done toward the even
   choice (so, for example, both "round(0.5)" and "round(-0.5)" are
   "0", and "round(1.5)" is "2").  Any integer value is valid for
   *ndigits* (positive, zero, or negative).  The return value is an
   integer if *ndigits* is omitted or "None". Otherwise, the return
   value has the same type as *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 Floating-Point Arithmetic:
     Issues and Limitations untuk informasi lebih lanjut.

class set
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)

   This is the counterpart of "getattr()".  The arguments are an
   object, a string, and an arbitrary value.  The string may name an
   existing attribute or a new attribute.  The function assigns the
   value to the attribute, provided the object allows it.  For
   example, "setattr(x, 'foobar', 123)" is equivalent to "x.foobar =
   123".

   *name* need not be a Python identifier as defined in Identifiers
   and keywords unless the object chooses to enforce that, for example
   in a custom "__getattribute__()" or via "__slots__". An attribute
   whose name is not an identifier will not be accessible using the
   dot notation, but is accessible through "getattr()" etc..

   Catatan:

     Since private name mangling happens at compilation time, one must
     manually mangle a private attribute's (attributes with two
     leading underscores) name in order to set it with "setattr()".

class slice(stop)
class slice(start, stop, step=None)

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".

   start

   stop

   step

      Slice objects have read-only data attributes "start", "stop",
      and "step" which merely return the argument values (or their
      default).  They have no other explicit functionality; however,
      they are used by NumPy and other third-party packages.

   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   *iterator*.

   Berubah pada versi 3.12: Slice objects are now *hashable* (provided
   "start", "stop", and "step" are hashable).

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

   The sort algorithm uses only "<" comparisons between items.  While
   defining an "__lt__()" method will suffice for sorting, **PEP 8**
   recommends that all six rich comparisons be implemented.  This will
   help avoid bugs when using the same data with other ordering tools
   such as "max()" that rely on a different underlying method.
   Implementing all six comparisons also helps avoid confusion for
   mixed type comparisons which can call reflected the "__gt__()"
   method.

   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, argN): ...

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

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()"). Moreover, the static method
   *descriptor* is also callable, so it can be used in the class
   definition (such as "f()").

   Static methods in Python are similar to those found in Java or C++.
   Also, see "classmethod()" for a variant that is useful for creating
   alternate class constructors.

   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:

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

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

   Berubah pada versi 3.10: Static methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__"), have a new "__wrapped__" attribute, and are now
   callable as regular functions.

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.

   For some use cases, there are good alternatives to "sum()". The
   preferred, fast way to concatenate a sequence of strings is by
   calling "''.join(sequence)".  To add floating-point values with
   extended precision, see "math.fsum()".  To concatenate a series of
   iterables, consider using "itertools.chain()".

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

   Berubah pada versi 3.12: Summation of floats switched to an
   algorithm that gives higher accuracy on most builds.

class super
class super(type, object_or_type=None)

   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.

   The *object_or_type* determines the *method resolution order* to be
   searched.  The search starts from the class right after the *type*.

   For example, if "__mro__" of *object_or_type* is "D -> B -> C -> A
   -> object" and the value of *type* is "B", then "super()" searches
   "C -> A -> object".

   The "__mro__" attribute of the class corresponding to
   *object_or_type* lists the method resolution search order used by
   both "getattr()" and "super()".  The attribute is dynamic and can
   change whenever the inheritance hierarchy is updated.

   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.

   Note that "super()" is implemented as part of the binding process
   for explicit dotted attribute lookups such as
   "super().__getitem__(name)". It does so by implementing its own
   "__getattribute__()" method for searching classes in a predictable
   order that supports cooperative multiple inheritance. Accordingly,
   "super()" is undefined for implicit lookups using statements or
   operators such as "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
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)

   With one argument, return the type of an *object*.  The return
   value is a type object and generally the same object as returned by
   "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))

   See also:

   * Documentation on attributes and methods on classes.

   * 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: Subclasses of "type" which don't override
   "type.__new__" may no longer use the one-argument form to get the
   type of an object.

vars()
vars(object)

   Return the "__dict__" attribute for a module, class, instance, or
   any other object with a "__dict__" attribute.

   Objects such as modules and instances have an updateable "__dict__"
   attribute; however, other objects may have write restrictions on
   their "__dict__" attributes (for example, classes use a
   "types.MappingProxyType" to prevent direct dictionary updates).

   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, strict=False)

   Iterate over several iterables in parallel, producing tuples with
   an item from each one.

   Example:

      >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   More formally: "zip()" returns an iterator of tuples, where the
   *i*-th tuple contains the *i*-th element from each of the argument
   iterables.

   Another way to think of "zip()" is that it turns rows into columns,
   and columns into rows.  This is similar to transposing a matrix.

   "zip()" is lazy: The elements won't be processed until the iterable
   is iterated on, e.g. by a "for" loop or by wrapping in a "list".

   One thing to consider is that the iterables passed to "zip()" could
   have different lengths; sometimes by design, and sometimes because
   of a bug in the code that prepared these iterables.  Python offers
   three different approaches to dealing with this issue:

   * By default, "zip()" stops when the shortest iterable is
     exhausted. It will ignore the remaining items in the longer
     iterables, cutting off the result to the length of the shortest
     iterable:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" is often used in cases where the iterables are assumed to
     be of equal length.  In such cases, it's recommended to use the
     "strict=True" option. Its output is the same as regular "zip()":

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     Unlike the default behavior, it raises a "ValueError" if one
     iterable is exhausted before the others:

     >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
     ...     print(item)
     ...
     (0, 'fee')
     (1, 'fi')
     (2, 'fo')
     Traceback (most recent call last):
       ...
     ValueError: zip() argument 2 is longer than argument 1

     Without the "strict=True" argument, any bug that results in
     iterables of different lengths will be silenced, possibly
     manifesting as a hard-to-find bug in another part of the program.

   * Shorter iterables can be padded with a constant value to make all
     the iterables have the same length.  This is done by
     "itertools.zip_longest()".

   Edge cases: With a single iterable argument, "zip()" returns an
   iterator of 1-tuples.  With no arguments, it returns an empty
   iterator.

   Tips and tricks:

   * The left-to-right evaluation order of the iterables is
     guaranteed. This makes possible an idiom for clustering a data
     series into n-length groups using "zip(*[iter(s)]*n,
     strict=True)".  This repeats the *same* iterator "n" times so
     that each output tuple has the result of "n" calls to the
     iterator. This has the effect of dividing the input into n-length
     chunks.

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

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

   Berubah pada versi 3.10: Added the "strict" argument.

__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()".

   The function imports the module *name*, potentially using the given
   *globals* and *locals* to determine how to interpret the name in a
   package context. The *fromlist* gives the names of objects or
   submodules that should be imported from the module given by *name*.
   The standard implementation does not use its *locals* argument at
   all and uses its *globals* only to determine the package context of
   the "import" statement.

   *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).

   Berubah pada versi 3.9: When the command line options "-E" or "-I"
   are being used, the environment variable "PYTHONCASEOK" is now
   ignored.

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