# 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()`
`all()`
`anext()`
`any()`
`ascii()`
B
`bin()`
`bool()`
`breakpoint()`
`bytearray()`
`bytes()`
C
`callable()`
`chr()`
`classmethod()`
`compile()`
`complex()`
D
`delattr()`
`dict()`
`dir()`
`divmod()`

E
`enumerate()`
`eval()`
`exec()`
F
`filter()`
`float()`
`format()`
`frozenset()`
G
`getattr()`
`globals()`
H
`hasattr()`
`hash()`
`help()`
`hex()`
I
`id()`
`input()`
`int()`
`isinstance()`
`issubclass()`
`iter()`

L
`len()`
`list()`
`locals()`
M
`map()`
`max()`
`memoryview()`
`min()`
N
`next()`
O
`object()`
`oct()`
`open()`
`ord()`
P
`pow()`
`print()`
`property()`

R
`range()`
`repr()`
`reversed()`
`round()`
S
`set()`
`setattr()`
`slice()`
`sorted()`
`staticmethod()`
`str()`
`sum()`
`super()`
T
`tuple()`
`type()`
V
`vars()`
Z
`zip()`
_
`__import__()`

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.

  Deprecated since version 3.11, removed in version 3.13: 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(source, /, globals=None, locals=None)
  Parameter:

    - source (`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 mappings 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 mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the expression is executed with the globals and locals in the environment where `eval()` is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is calling `eval()` (e.g. via a `nonlocal` statement).

  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.

  Berubah pada versi 3.13: The globals and locals arguments can now be passed as keywords.

  Berubah pada versi 3.13: The semantics of the default locals namespace have been adjusted as described for the `locals()` builtin.

exec(source, /, 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. source 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

  When `exec` gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition. This means functions and classes defined in the executed code will not be able to access variables assigned at the top level (as the "top level" variables are treated as class variables 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 (closure) variables. The length of the tuple must exactly match the length of the code object's `co_freevars` attribute.

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

  Catatan

  The built-in functions `globals()` and `locals()` return the current global and local namespace, respectively, which may be useful to pass around for use as the second and third argument to `exec()`.

  Catatan

  The default locals act as described for function `locals()` below. Pass an explicit locals dictionary if you need to see effects of the code on locals after function `exec()` returns.

  Berubah pada versi 3.11: Added the closure parameter.

  Berubah pada versi 3.13: The globals and locals arguments can now be passed as keywords.

  Berubah pada versi 3.13: The semantics of the default locals namespace have been adjusted as described for the `locals()` builtin.

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

  > Return a mapping object representing the current local symbol table, with variable names as the keys, and their currently bound references as the values.

  > At module scope, as well as when using `exec()` or `eval()` with a single namespace, this function returns the same namespace as `globals()`.

  > At class scope, it returns the namespace that will be passed to the metaclass constructor.

  > When using `exec()` or `eval()` with separate local and global arguments, it returns the local namespace passed in to the function call.

  > In all of the above cases, each call to `locals()` in a given frame of execution will return the same mapping object. Changes made through the mapping object returned from `locals()` will be visible as assigned, reassigned, or deleted local variables, and assigning, reassigning, or deleting local variables will immediately affect the contents of the returned mapping object.

  > In an optimized scope (including functions, generators, and coroutines), each call to `locals()` instead returns a fresh dictionary containing the current bindings of the function's local variables and any nonlocal cell references. In this case, name binding changes made via the returned dict are not written back to the corresponding local variables or nonlocal cell references, and assigning, reassigning, or deleting local variables and nonlocal cell references does not affect the contents of previously returned dictionaries.

  > Calling `locals()` as part of a comprehension in a function, generator, or coroutine is equivalent to calling it in the containing scope, except that the comprehension's initialised iteration variables will be included. In other scopes, it behaves as if the comprehension were running as a nested function.

  > Calling `locals()` as part of a generator expression is equivalent to calling it in a nested generator function.

  Berubah pada versi 3.12: The behaviour of `locals()` in a comprehension has been updated as described in PEP 709.

  Berubah pada versi 3.13: As part of PEP 667, the semantics of mutating the mapping objects returned from this function are now defined. The behavior in optimized scopes is now as described above. Aside from being defined, the behaviour in other scopes remains unchanged from previous versions.

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.

  __name__

    Attribute holding the name of the property. The name of the property can be changed at runtime.

    Added in version 3.13.

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 and better commutativity 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).

  When called directly within an ordinary method of a class, both arguments may be omitted ("zero-argument `super()`"). In this case, type will be the enclosing class, and obj will be the first argument of the immediately enclosing function (typically `self`). (This means that zero-argument `super()` will not work as expected within nested functions, including generator expressions, which implicitly create nested functions.)

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

  Without an argument, `vars()` acts like `locals()`.

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

  Berubah pada versi 3.13: The result of calling this function without an argument has been updated as described for the `locals()` builtin.

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.