Cara menggunakan python response ok

4.8.1. Nilai Argumen Bawaan¶

Bentuk yang paling berguna adalah menentukan nilai bawaan untuk satu atau lebih argumen. Ini menciptakan fungsi yang bisa dipanggil dengan argumen yang lebih sedikit daripada yang didefinisikan untuk diizinkan. Sebagai contoh:

def ask_ok[prompt, retries=4, reminder='Please try again!']:
    while True:
        ok = input[prompt]
        if ok in ['y', 'ye', 'yes']:
            return True
        if ok in ['n', 'no', 'nop', 'nope']:
            return False
        retries = retries - 1
        if retries >> def function[a]:
...     pass
...
>>> function[0, a=0]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: function[] got multiple values for argument 'a'

Ketika parameter formal terakhir dari bentuk **name ada, ia menerima kamus dictionary [lihat Mapping Types --- dict] yang berisi semua argumen kata kunci keyword argument kecuali yang terkait dengan parameter formal. Ini dapat digabungkan dengan parameter formal dari bentuk *name [dijelaskan dalam subbagian berikutnya] yang menerima tuple yang berisi argumen posisi di luar daftar parameter formal. [*name harus ada sebelum **name.] Misalnya, jika kita mendefinisikan fungsi seperti ini:

def cheeseshop[kind, *arguments, **keywords]:
    print["-- Do you have any", kind, "?"]
    print["-- I'm sorry, we're all out of", kind]
    for arg in arguments:
        print[arg]
    print["-" * 40]
    for kw in keywords:
        print[kw, ":", keywords[kw]]

Ini bisa disebut seperti ini:

cheeseshop["Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch"]

dan tentu saja itu akan mencetak:

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

Perhatikan bahwa bagaimana urutan argumen kata kunci dicetak telah dijamin sesuai dengan urutan yang disediakan dalam pemanggilan fungsi.

4.8.3. Parameter spesial¶

Secara bawaan, argumen dapat diteruskan ke fungsi Python baik dengan posisi atau secara eksplisit oleh kata kunci. Untuk keterbacaan dan kinerja, masuk akal untuk membatasi cara argumen dapat dilewatkan sehingga pengembang hanya perlu melihat definisi fungsi untuk menentukan apakah item dilewatkan secara posisi saja, posisi atau kata kunci, atau kata kunci saja.

Definisi fungsi mungkin terlihat seperti:

def f[pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2]:
      -----------    ----------     ----------
        |             |                  |
        |        Positional or keyword   |
        |                                - Keyword only
         -- Positional only

di mana / dan * adalah opsional. Jika digunakan, simbol-simbol ini menunjukkan jenis parameter dengan cara argumen dilewatkan ke fungsi: posisi-saja, posisi-atau-kata kunci, dan kata kunci-saja. Parameter kata kunci juga disebut sebagai parameter bernama.

>>> def standard_arg[arg]:
...     print[arg]
...
>>> def pos_only_arg[arg, /]:
...     print[arg]
...
>>> def kwd_only_arg[*, arg]:
...     print[arg]
...
>>> def combined_example[pos_only, /, standard, *, kwd_only]:
...     print[pos_only, standard, kwd_only]

>>> standard_arg[2]
2

>>> standard_arg[arg=2]
2

>>> pos_only_arg[1]
1

>>> pos_only_arg[arg=1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: pos_only_arg[] got some positional-only arguments passed as keyword arguments: 'arg'

>>> kwd_only_arg[3]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: kwd_only_arg[] takes 0 positional arguments but 1 was given

>>> kwd_only_arg[arg=3]
3

>>> combined_example[1, 2, 3]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: combined_example[] takes 2 positional arguments but 3 were given

>>> combined_example[1, 2, kwd_only=3]
1 2 3

>>> combined_example[1, standard=2, kwd_only=3]
1 2 3

>>> combined_example[pos_only=1, standard=2, kwd_only=3]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: combined_example[] got some positional-only arguments passed as keyword arguments: 'pos_only'

def foo[name, **kwds]:
    return 'name' in kwds

>>> foo[1, **{'name': 2}]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: foo[] got multiple values for argument 'name'
>>>

def foo[name, /, **kwds]:
    return 'name' in kwds
>>> foo[1, **{'name': 2}]
True

def f[pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2]:

4.8.4. Daftar Argumen Berubah-ubah Arbitrary¶

Akhirnya, opsi yang paling jarang digunakan adalah menentukan bahwa suatu fungsi dapat dipanggil dengan sejumlah argumen acak arbitrary. Argumen-argumen ini akan dibungkus dalam sebuah tuple [lihat tuttuples]. Sebelum jumlah variabel argumen, nol atau lebih argumen normal dapat muncul.

def write_multiple_items[file, separator, *args]:
    file.write[separator.join[args]]

Normally, these variadic arguments will be last in the list of formal parameters, because they scoop up all remaining input arguments that are passed to the function. Any formal parameters which occur after the *args parameter are 'keyword-only' arguments, meaning that they can only be used as keywords rather than positional arguments.

>>> def concat[*args, sep="/"]:
...     return sep.join[args]
...
>>> concat["earth", "mars", "venus"]
'earth/mars/venus'
>>> concat["earth", "mars", "venus", sep="."]
'earth.mars.venus'

4.8.5. Pembukaan Paket Unpacking Daftar Argumen¶

Situasi sebaliknya terjadi ketika argumen sudah ada dalam daftar list atau tuple tetapi perlu dibongkar untuk panggilan fungsi yang membutuhkan argumen posisi terpisah. Sebagai contoh, fungsi bawaan range[] mengharapkan argumen terpisah start dan stop. Jika tidak tersedia secara terpisah, tulis fungsi panggilan dengan operator-* untuk membongkar argumen dari daftar list atau tuple:

>>> list[range[3, 6]]            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list[range[*args]]            # call with arguments unpacked from a list
[3, 4, 5]

Dengan cara yang sama, kamus dapat mengirimkan argumen kata kunci dengan operator-**:

>>> def parrot[voltage, state='a stiff', action='voom']:
...     print["-- This parrot wouldn't", action, end=' ']
...     print["if you put", voltage, "volts through it.", end=' ']
...     print["E's", state, "!"]
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot[**d]
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

4.8.6. Ekspresi Lambda¶

Fungsi kecil anonim dapat dibuat dengan kata kunci lambda. Fungsi ini mengembalikan jumlah dari dua argumennya: lambda a, b: a+b. Fungsi Lambda dapat digunakan di mana pun objek fungsi diperlukan. Mereka secara sintaksis terbatas pada satu ekspresi. Secara semantik, mereka hanya pemanis sintaksis untuk definisi fungsi normal. Seperti definisi fungsi bersarang, fungsi lambda dapat mereferensikan variabel dari cakupan yang mengandung

>>> def make_incrementor[n]:
...     return lambda x: x + n
...
>>> f = make_incrementor[42]
>>> f[0]
42
>>> f[1]
43

Contoh di atas menggunakan ekspresi lambda untuk mengembalikan fungsi. Penggunaan lain adalah untuk melewatkan fungsi kecil sebagai argumen:

>>> pairs = [[1, 'one'], [2, 'two'], [3, 'three'], [4, 'four']]
>>> pairs.sort[key=lambda pair: pair[1]]
>>> pairs
[[4, 'four'], [1, 'one'], [3, 'three'], [2, 'two']]

4.8.7. String Dokumentasi¶

Berikut adalah beberapa konvensi tentang konten dan format string dokumentasi.

Baris pertama harus selalu berupa ringkasan singkat dan ringkas dari tujuan objek. Untuk singkatnya, itu tidak boleh secara eksplisit menyatakan nama atau jenis objek, karena ini tersedia dengan cara lain [kecuali jika nama tersebut merupakan kata kerja yang menggambarkan operasi fungsi]. Baris ini harus dimulai dengan huruf kapital dan diakhiri dengan titik.

Jika ada lebih banyak baris dalam string dokumentasi, baris kedua harus kosong, memisahkan ringkasan secara visual dari sisa deskripsi. Baris berikut harus satu atau lebih paragraf yang menggambarkan konvensi pemanggilan objek, efek sampingnya, dll.

Pengurai Python tidak menghapus lekukan dari string multi-baris literal di Python, jadi alat yang memproses dokumentasi harus menghapus indentasi jika diinginkan. Ini dilakukan dengan menggunakan konvensi berikut. Baris tidak-kosong pertama setelah baris pertama string menentukan jumlah indentasi untuk seluruh string dokumentasi. [Kami tidak dapat menggunakan baris pertama karena umumnya berbatasan dengan tanda kutip pembukaan string sehingga indentasinya tidak terlihat dalam string literal.] Spasi "equivalent" untuk indentasi ini kemudian dihilangkan dari awal semua baris string. Baris yang indentasi lebih sedikit seharusnya tidak terjadi, tetapi jika terjadi semua spasi whitespace utama harus dihilangkan. Kesetaraan spasi harus diuji setelah ekspansi tab [hingga 8 spasi, biasanya].

Berikut adalah contoh dari multi-baris docstring:

>>> def my_function[]:
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print[my_function.__doc__]
Do nothing, but document it.

    No, really, it doesn't do anything.

4.8.8. Anotasi Fungsi¶

Function annotations informasi metadata yang sepenuhnya opsional tentang jenis yang digunakan oleh fungsi yang ditentukan pengguna [lihat PEP 3107 dan PEP 484 untuk informasi lebih lanjut].

Annotations are stored in the __annotations__ attribute of the function as a dictionary and have no effect on any other part of the function. Parameter annotations are defined by a colon after the parameter name, followed by an expression evaluating to the value of the annotation. Return annotations are defined by a literal ->, followed by an expression, between the parameter list and the colon denoting the end of the def statement. The following example has a required argument, an optional argument, and the return value annotated:

>>> def f[ham: str, eggs: str = 'eggs'] -> str:
...     print["Annotations:", f.__annotations__]
...     print["Arguments:", ham, eggs]
...     return ham + ' and ' + eggs
...
>>> f['spam']
Annotations: {'ham': , 'return': , 'eggs': }
Arguments: spam eggs
'spam and eggs'