Penulisan nilai variabel string benar pada python kecuali

4.1. Pernyataan if¶

Mungkin tipe pernyataan yang paling terkenal adalah pernyataan if. Sebagai contoh:

>>> x = int[input["Please enter an integer: "]]
Please enter an integer: 42
>>> if x >> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print[w, len[w]]
...
cat 3
window 6
defenestrate 12

If you need to modify the sequence you are iterating over while inside the loop [for example to duplicate selected items], it is recommended that you first make a copy. Iterating over a sequence does not implicitly make a copy. The slice notation makes this especially convenient:

>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len[w] > 6:
...         words.insert[0, w]
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

With for w in words:, the example would attempt to create an infinite list, inserting defenestrate over and over again.

4.3. Fungsi range[]¶

Jika Anda perlu mengulangi urutan angka, fungsi bawaan range[] berguna. Ini menghasilkan urutan pregressions aritmatika:

>>> for i in range[5]:
...     print[i]
...
0
1
2
3
4

Titik akhir yang diberikan tidak pernah menjadi bagian dari urutan yang dihasilkan; range[10] menghasilkan 10 nilai, indeks sah legal untuk item dengan urutan panjang 10. Dimungkinkan untuk membiarkan rentang mulai dari nomor lain, atau untuk menentukan kenaikan yang berbeda [bahkan negatif; kadang-kadang ini disebut 'step']:

range[5, 10]
   5, 6, 7, 8, 9

range[0, 10, 3]
   0, 3, 6, 9

range[-10, -100, -30]
  -10, -40, -70

Untuk beralih pada indeks urutan, Anda dapat menggabungkan range[] dan len[] sebagai berikut:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range[len[a]]:
...     print[i, a[i]]
...
0 Mary
1 had
2 a
3 little
4 lamb

Dalam kebanyakan kasus seperti itu, bagaimanapun, lebih mudah untuk menggunakan fungsi enumerate[], lihat Teknik Perulangan.

Hal aneh terjadi jika Anda hanya mencetak rentang range:

>>> print[range[10]]
range[0, 10]

Dalam banyak hal objek dikembalikan oleh range[] berperilaku seolah-olah itu adalah daftar list, tetapi sebenarnya tidak. Ini adalah objek yang mengembalikan item berurutan dari urutan yang diinginkan ketika Anda mengulanginya, tetapi itu tidak benar-benar membuat daftar list, sehingga menghemat ruang.

We say such an object is iterable, that is, suitable as a target for functions and constructs that expect something from which they can obtain successive items until the supply is exhausted. We have seen that the for statement is such an iterator. The function list[] is another; it creates lists from iterables:

>>> list[range[5]]
[0, 1, 2, 3, 4]

Later we will see more functions that return iterables and take iterables as argument.

4.4. Pernyataan break dan continue, dan else Klausa pada Perulangan Loops¶

Pernyataan break, seperti dalam C, keluar dari bagian terdalam yang terlampir perulangan for atau while.

Loop statements may have an else clause; it is executed when the loop terminates through exhaustion of the list [with for] or when the condition becomes false [with while], but not when the loop is terminated by a break statement. This is exemplified by the following loop, which searches for prime numbers:

>>> for n in range[2, 10]:
...     for x in range[2, n]:
...         if n % x == 0:
...             print[n, 'equals', x, '*', n//x]
...             break
...     else:
...         # loop fell through without finding a factor
...         print[n, 'is a prime number']
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

[Ya, ini adalah kode yang benar. Perhatikan baik-baik: klausul else milik perulangan for, not pernyataan if.]

When used with a loop, the else clause has more in common with the else clause of a try statement than it does that of if statements: a try statement's else clause runs when no exception occurs, and a loop's else clause runs when no break occurs. For more on the try statement and exceptions, see Menangani Pengecualian.

Pernyataan continue, juga dipinjam dari C, melanjutkan dengan pengulangan berikutnya dari loop:

>>> for num in range[2, 10]:
...     if num % 2 == 0:
...         print["Found an even number", num]
...         continue
...     print["Found a number", num]
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

4.5. Pernyataan pass¶

Pernyataan pass tidak melakukan apa-apa. Ini dapat digunakan ketika pernyataan diperlukan secara sintaksis tetapi program tidak memerlukan tindakan. Sebagai contoh:

>>> while True:
...     pass  # Busy-wait for keyboard interrupt [Ctrl+C]
...

Ini biasanya digunakan untuk membuat kelas minimal:

>>> class MyEmptyClass:
...     pass
...

Tempat lain pass dapat digunakan adalah sebagai tempat-penampung place-holder untuk fungsi atau badan bersyarat conditional body saat Anda bekerja pada kode baru, memungkinkan Anda untuk terus berpikir pada tingkat yang lebih abstrak. pass diabaikan secara diam-diam:

>>> def initlog[*args]:
...     pass   # Remember to implement this!
...

4.6. Mendefinisikan Fungsi¶

Kita dapat membuat fungsi yang menulis seri Fibonacci ke batas acak arbitrary:

>>> def fib[n]:    # write Fibonacci series up to n
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a >> # Now call the function we just defined:
... fib[2000]
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Kata kunci def memperkenalkan fungsi definition. Itu harus diikuti oleh nama fungsi dan daftar parameter formal yang di dalam tanda kurung. Pernyataan yang membentuk tubuh fungsi mulai dari baris berikutnya, dan harus diberi indentasi.

Pernyataan pertama dari tubuh fungsi secara opsional dapat berupa string literal; string literal ini adalah string dokumentasi fungsi, atau docstring. [Lebih lanjut tentang docstring dapat ditemukan di bagian String Dokumentasi.] Ada alat yang menggunakan docstring untuk secara otomatis menghasilkan dokumentasi online atau cetak, atau untuk membiarkan pengguna menelusuri kode secara interaktif; itu praktik yang baik untuk memasukkan dokumen dalam kode yang Anda tulis, jadi biasakan seperti itu.

execution dari suatu fungsi memperkenalkan tabel simbol baru yang digunakan untuk variabel lokal dari fungsi tersebut. Lebih tepatnya, semua tugas variabel dalam suatu fungsi menyimpan nilai dalam tabel simbol lokal; sedangkan referensi variabel pertama-tama terlihat pada tabel simbol lokal, kemudian pada tabel simbol lokal lampiran enclosing fungsi, kemudian pada tabel simbol global, dan akhirnya pada tabel nama bawaan. Dengan demikian, variabel global dan variabel lampiran enclosing fungsi tidak dapat secara langsung menetapkan nilai dalam suatu fungsi [kecuali, untuk variabel global, disebutkan dalam pernyataan global, atau, untuk variabel lampiran enclosing fungsi, dinamai dalam pernyataan nonlocal], meskipun mungkin direferensikan.

The actual parameters [arguments] to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value [where the value is always an object reference, not the value of the object]. 1 When a function calls another function, a new local symbol table is created for that call.

A function definition introduces the function name in the current symbol table. The value of the function name has a type that is recognized by the interpreter as a user-defined function. This value can be assigned to another name which can then also be used as a function. This serves as a general renaming mechanism:

>>> fib

>>> f = fib
>>> f[100]
0 1 1 2 3 5 8 13 21 34 55 89

Berasal dari bahasa lain, Anda mungkin keberatan bahwa fib bukan fungsi melainkan prosedur karena tidak mengembalikan nilai. Bahkan, fungsi bahkan tanpa pernyataan return mengembalikan nilai, meskipun yang agak membosankan. Nilai ini disebut None [ini adalah nama bawaan]. Menulis nilai None biasanya dihilangkan suppressed oleh interpreter jika itu akan menjadi satu-satunya nilai yang ditulis. Anda dapat melihatnya jika Anda benar-benar ingin menggunakan print[]:

>>> fib[0]
>>> print[fib[0]]
None

Sangat mudah untuk menulis fungsi yang mengembalikan daftar list nomor seri Fibonacci, alih-alih mencetaknya:

>>> def fib2[n]:  # return Fibonacci series up to n
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a >> f100 = fib2[100]    # call it
>>> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Contoh ini, seperti biasa, menunjukkan beberapa fitur Python baru:

• Pernyataan return kembali dengan nilai dari suatu fungsi. return tanpa argumen ekspresi mengembalikan None. Keluar dari akhir suatu fungsi juga mengembalikan None.

• Pernyataan result.append[a] memanggil method dari objek daftar list result. Sebuah metode adalah fungsi yang 'milik' sebuah objek dan dinamai obj.methodname, di mana obj adalah suatu objek [ini mungkin sebuah ekspresi], dan methodname adalah nama dari metode yang ditentukan oleh tipe objek. Jenis yang berbeda menentukan metode yang berbeda. Metode tipe yang berbeda mungkin memiliki nama yang sama tanpa menimbulkan ambiguitas. [Dimungkinkan untuk menentukan jenis dan metode objek Anda sendiri, menggunakan classes, lihat Classes] Metode append[] yang ditunjukkan pada contoh didefinisikan untuk objek daftar; itu menambahkan elemen baru di akhir daftar. Dalam contoh ini setara dengan result = result + [a], tetapi lebih efisien.

4.7. Lebih lanjut tentang Mendefinisikan Fungsi¶

Dimungkinkan juga untuk mendefinisikan fungsi dengan sejumlah variabel argumen. Ada tiga bentuk, yang bisa digabungkan.

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 keyword argument 'a'

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]]

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

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

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

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

>>> 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]

>>> 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 !

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

>>> 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']]

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

>>> 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'

4.8. Intermezzo: Gaya Coding¶

Sekarang Anda akan menulis potongan Python yang lebih panjang dan lebih kompleks, ini adalah saat yang tepat untuk berbicara tentang coding style. Sebagian besar bahasa dapat ditulis [atau lebih ringkas, formatted] dalam gaya yang berbeda; beberapa lebih mudah dibaca daripada yang lain. Memudahkan orang lain untuk membaca kode Anda selalu merupakan ide yang baik, dan mengadopsi gaya pengkodean yang bagus sangat membantu untuk itu.

Untuk Python, PEP 8 telah muncul sebagai panduan gaya yang dipatuhi sebagian besar proyek; itu mempromosikan gaya pengkodean yang sangat mudah dibaca dan menyenangkan. Setiap pengembang Python harus membacanya di beberapa bagian; di sini adalah poin paling penting yang ditunjukkan untuk Anda:

• Gunakan lekukan 4-spasi, dan tanpa tab.

  4 spasi adalah kompromi yang baik antara indentasi kecil [memungkinkan kedalaman bersarang lebih besar] dan indentasi besar [lebih mudah dibaca]. Tab menimbulkan kebingungan, dan sebaiknya ditinggalkan.

• Bungkus wrap garis agar tidak melebihi 79 karakter.

  Ini membantu pengguna dengan tampilan kecil dan memungkinkan untuk memiliki beberapa file kode berdampingan pada tampilan yang lebih besar.

• Gunakan baris kosong untuk memisahkan fungsi dan kelas, dan blok kode yang lebih besar di dalam fungsi.

• Jika memungkinkan, berikan komentar pada baris terkait.

• Gunakan String Dokumentasi docstrings.

• Gunakan spasi di sekitar operator dan setelah koma, tetapi tidak secara langsung di dalam konstruksi kurung bracketing: a = f[1, 2] + g[3, 4].

• Beri nama kelas dan fungsi Anda secara konsisten; konvensi ini menggunakan UpperCamelCase untuk kelas dan lowercase_with_underscores untuk fungsi dan metode. Selalu gunakan self sebagai nama untuk argumen metode pertama [lihat tut-firstclass untuk lebih lanjut tentang kelas dan metode].

• Jangan gunakan pengkodean ajaib fancy encodings jika kode Anda dimaksudkan untuk digunakan di lingkungan internasional. Default Python, UTF-8, atau bahkan ASCII biasa berfungsi paling baik dalam hal apa pun.

• Demikian juga, jangan gunakan karakter non-ASCII dalam pengidentifikasi jika hanya ada sedikit kesempatan orang berbicara bahasa yang berbeda akan membaca atau merawat kode.

Catatan kaki

Sebenarnya, call by object reference akan menjadi deskripsi yang lebih baik, karena jika objek yang bisa ditransmisikan dilewatkan, pemanggil akan melihat perubahan yang dibuat oleh yang dipanggil callee [item dimasukkan ke dalam daftar].