Modul 4

4.1.1.
1 Python Essentials: Modul 4

Dasar-Dasar Pemrograman dalam Python: Modul 4
Dalam modul ini, Anda akan belajar tentang:
 mendefinisikan dan menggunakan fungsi;
 berbagai cara menyampaikan argumen;
 cakupan nama;
 tupel dan kamus;
 pengolahan data.
4.1.1.2 Fungsi
Mengapa kita membutuhkan fungsi?
Anda telah menemukan fungsi berkali-kali sejauh ini, tetapi pandangan tentang manfaatnya
yang kami berikan kepada Anda agak sepihak. Anda hanya memanggil fungsi dengan
menggunakannya sebagai alat untuk membuat hidup lebih mudah, dan untuk
menyederhanakan tugas yang memakan waktu dan membosankan.
Ketika Anda ingin beberapa data dicetak pada konsol, Anda gunakan print(). Saat Anda ingin
membaca nilai suatu variabel, Anda menggunakan input(), ditambah dengan salah
satu int()atau float().
Anda juga memanfaatkan beberapa metode , yang sebenarnya berfungsi, tetapi
dideklarasikan dengan cara yang sangat spesifik.
Sekarang Anda akan belajar cara menulis fungsi Anda sendiri, dan cara
menggunakannya. Kami akan menulis beberapa fungsi secara bersamaan, dari yang sangat
sederhana hingga yang agak rumit, yang akan membutuhkan fokus dan perhatian Anda.
Sering terjadi potongan kode tertentu diulang berkali-kali dalam program Anda . Itu diulangi
baik secara harfiah, atau dengan hanya beberapa modifikasi kecil, yang terdiri dari
penggunaan variabel lain dalam algoritma yang sama. Itu juga terjadi bahwa seorang
programmer tidak bisa menahan penyederhanaan pekerjaan, dan mulai mengkloning
potongan-potongan kode seperti menggunakan clipboard dan operasi copy-paste.
Itu bisa menjadi sangat frustasi ketika tiba-tiba ternyata ada kesalahan dalam kode
kloning. Programmer akan memiliki banyak pekerjaan yang membosankan untuk menemukan
semua tempat yang perlu diperbaiki. Ada juga risiko tinggi dari koreksi yang menyebabkan
kesalahan.
Kami sekarang dapat menentukan kondisi pertama yang dapat membantu Anda memutuskan
kapan harus mulai menulis fungsi Anda sendiri: jika suatu fragmen kode tertentu mulai muncul di
lebih dari satu tempat, pertimbangkan kemungkinan mengisolasinya dalam bentuk fungsi
yang dipanggil dari titik di mana kode asli ditempatkan sebelumnya.
Mungkin saja algoritme yang akan Anda implementasikan begitu rumit sehingga kode Anda
mulai tumbuh dengan cara yang tidak terkontrol, dan tiba-tiba Anda melihat bahwa Anda
tidak dapat menavigasi dengan begitu mudah lagi.
Anda dapat mencoba untuk mengatasi masalah ini dengan mengomentari kode secara luas,
tetapi segera Anda menemukan bahwa ini secara dramatis memperburuk situasi Anda - terlalu
banyak komentar membuat kode lebih besar dan lebih sulit dibaca . Beberapa mengatakan
bahwa fungsi yang ditulis dengan baik harus dilihat seluruhnya dalam satu pandangan .
Pengembang yang baik dan penuh perhatian membagi kode (atau lebih tepatnya: masalah)
menjadi potongan-potongan yang terisolasi, dan mengkodekan masing-masing dalam bentuk
fungsi .
Ini sangat menyederhanakan pekerjaan program, karena masing-masing bagian kode dapat
dikodekan secara terpisah, dan diuji secara terpisah. Proses yang dijelaskan di sini sering
disebut dekomposisi .
1
Kita sekarang dapat menyatakan kondisi kedua: jika sepotong kode menjadi begitu besar
sehingga membaca dan mengecilkannya dapat menyebabkan masalah, pertimbangkan
untuk membaginya menjadi masalah yang terpisah, lebih kecil, dan terapkan masing-masing
dalam bentuk fungsi yang terpisah .
Dekomposisi ini berlanjut sampai Anda mendapatkan satu set fungsi pendek, mudah
dimengerti dan diuji.
4.1.1.3 Fungsi
Penguraian
Sering terjadi bahwa masalahnya sangat besar dan kompleks sehingga tidak dapat ditugaskan
ke pengembang tunggal, dan tim pengembang harus mengerjakannya. Masalahnya harus
dipisah antara beberapa pengembang dengan cara yang memastikan kerja sama yang
efisien dan mulus.
Tampaknya tidak dapat dibayangkan bahwa lebih dari satu programmer harus menulis kode
yang sama pada saat yang sama, sehingga pekerjaan itu harus tersebar di antara semua
anggota tim.
Dekomposisi semacam ini memiliki tujuan yang berbeda dengan yang dijelaskan sebelumnya -
ini bukan hanya tentang berbagi pekerjaan , tetapi juga tentang berbagi tanggung jawab
di antara banyak pengembang.
Masing-masing dari mereka menulis seperangkat fungsi yang didefinisikan dengan jelas dan
dijelaskan, yang bila digabungkan ke dalam modul (kami akan memberi tahu Anda sedikit
tentang ini nanti) akan memberikan produk akhir.
Ini membawa kita langsung ke kondisi ketiga: jika Anda akan membagi pekerjaan di antara
beberapa programmer, uraikan masalah untuk memungkinkan produk diimplementasikan
sebagai satu set fungsi yang ditulis secara terpisah yang dikemas bersama dalam modul yang
berbeda .
Dari mana fungsi itu berasal?
Secara umum, fungsi datang dari setidaknya tiga tempat:
 dari Python sendiri - banyak fungsi (seperti print()) merupakan bagian integral dari
Python , dan selalu tersedia tanpa upaya tambahan atas nama programmer; kami
menyebut fungsi ini fungsi bawaan ;
 dari modul pra - instal Python - banyak fungsi, yang sangat berguna, tetapi digunakan
secara signifikan lebih jarang daripada yang built-in, tersedia dalam sejumlah modul
yang dipasang bersama dengan Python; penggunaan fungsi-fungsi ini memerlukan
beberapa langkah tambahan dari programmer untuk membuatnya sepenuhnya dapat
diakses (kami akan memberi tahu Anda tentang ini sebentar lagi);
 langsung dari kode Anda - Anda dapat menulis fungsi Anda sendiri, menempatkannya
di dalam kode Anda, dan menggunakannya secara bebas;
 ada satu kemungkinan lain, tetapi terhubung dengan kelas, jadi kami akan
menghilangkannya untuk saat ini.
2
4.1.1.4 Fungsi penulisan
Fungsi pertama Anda

Lihatlah cuplikan di editor.
Ini agak sederhana, tetapi kami hanya ingin itu menjadi contoh mengubah bagian berulang
kode menjadi fungsi .
Pesan yang dikirim ke konsol dengan print()fungsi selalu sama. Tentu saja, tidak ada yang
benar-benar buruk dalam kode seperti itu, tetapi coba bayangkan apa yang harus Anda
lakukan jika bos Anda meminta Anda untuk mengubah pesan agar lebih sopan, misalnya untuk
memulai dengan kalimat "Please,".
Tampaknya Anda harus meluangkan waktu untuk mengubah semua kemunculan pesan (Anda
akan menggunakan papan klip, tentu saja, tetapi itu tidak akan membuat hidup Anda lebih
mudah). Sudah jelas bahwa Anda mungkin akan membuat beberapa kesalahan selama
proses amandemen, dan Anda (dan bos Anda) akan sedikit frustrasi.
Apakah mungkin untuk memisahkan bagian kode yang dapat diulang, beri nama dan
membuatnya dapat digunakan kembali? Itu berarti bahwa perubahan yang dilakukan sekali
di satu tempat akan disebarkan ke semua tempat di mana ia digunakan .
Tentu saja, kode semacam itu hanya akan berfungsi jika diluncurkan secara eksplisit.
Iya itu mungkin. Inilah fungsi sebenarnya.
4.1.1.5 Fungsi penulisan

Fungsi pertama Anda
Bagaimana Anda membuat fungsi seperti itu?
Anda perlu mendefinisikannya . Kata define penting di sini.
Ini adalah definisi fungsi yang paling sederhana:
def functionName(): functionBody
 Itu selalu dimulai dengan kata kuncidef (untuk didefinisikan )

 selanjutnya setelah defpergi nama fungsi (aturan untuk fungsi penamaan persis sama
dengan variabel penamaan)
 setelah nama fungsi, ada tempat untuk sepasang tanda kurung (tidak mengandung
apa pun di sini, tetapi itu akan segera berubah)
 garis harus diakhiri dengan tanda titik dua ;
 garis langsung setelah defmemulai fungsi tubuh - pasangan (setidaknya satu)
dari instruksi yang harus bersarang , yang akan dieksekusi setiap kali fungsi
dipanggil; Catatan: fungsi berakhir di mana sarang berakhir , jadi Anda harus berhati-
hati.
Kami siap mendefinisikan fungsi bisikan kami . Kami akan menamainya message- ini dia:
def message(): print("Enter a value: ")
Fungsi ini sangat sederhana, tetapi sepenuhnya dapat digunakan . Kami telah
menamainya message, tetapi Anda dapat memberi label sesuai dengan selera Anda. Mari kita
gunakan.
Kode kami berisi definisi fungsi sekarang:

def message(): print("Enter a value: ") print("We start here.") print("We end here.")
Catatan: kami tidak menggunakan fungsi sama sekali - tidak ada permintaan di dalam kode.
Ketika Anda menjalankannya, Anda melihat output berikut:
We start here. We end here.
Ini berarti bahwa Python membaca definisi fungsi dan mengingatnya, tetapi tidak akan
meluncurkannya tanpa izin Anda.
Kami telah memodifikasi kodenya sekarang - kami telah memasukkan permohonan
fungsi antara pesan mulai dan akhir:
def message(): print("Enter a value: ") print("We start here.") message() print("We end here.")
Outputnya terlihat berbeda sekarang:
3
We start here. Enter a value: We end here.
Uji kodenya, modifikasi, eksperimen dengan itu.
4.1.1.6 Fungsi
Bagaimana fungsi bekerja
Lihatlah gambar di bawah ini:
Mencoba menunjukkan seluruh proses:

 ketika Anda menjalankan fungsi, Python mengingat tempat di mana itu terjadi
dan melompat ke fungsi yang dipanggil;
 tubuh fungsi kemudian dieksekusi ;
 mencapai akhir fungsi memaksa Python untuk kembali ke tempat itu langsung setelah
titik doa.
Ada dua tangkapan yang sangat penting. Inilah yang pertama dari mereka:
Anda tidak boleh memanggil fungsi yang tidak dikenal pada saat doa.
Ingat - Python membaca kode Anda dari atas ke bawah. Ini tidak akan melihat ke depan untuk
menemukan fungsi yang Anda lupa taruh di tempat yang tepat ("benar" berarti "sebelum
doa").
Kami telah memasukkan kesalahan ke dalam kode ini - dapatkah Anda melihat
perbedaannya?
print("We start here.") message() print("We end here.") def message(): print("Enter a value: ")
Kami telah memindahkan fungsi ke akhir kode. Apakah Python dapat menemukannya ketika
eksekusi mencapai doa?
Tidak. Pesan kesalahan akan membaca:
NameError: name 'message' is not defined
Jangan mencoba memaksa Python untuk mencari fungsi yang tidak Anda berikan pada waktu
yang tepat.
Tangkapan kedua terdengar sedikit lebih sederhana:
Anda tidak boleh memiliki fungsi dan variabel dengan nama yang sama .
Cuplikan berikut ini salah:
def message(): print("Enter a value: ") message = 1
Menetapkan nilai pada pesan nama menyebabkan Python melupakan peran

sebelumnya. Fungsi yang dinamai messagemenjadi tidak tersedia.
Untungnya, Anda bebas untuk mencampur kode Anda dengan fungsi - Anda tidak wajib
meletakkan semua fungsi Anda di bagian atas file sumber Anda.
Lihatlah cuplikannya:
print("We start here.") def message(): print("Enter a value: ") message() print("We end here.")
Ini mungkin terlihat aneh, tetapi sepenuhnya benar, dan berfungsi sebagaimana mestinya.
Mari kembali ke contoh utama kami, dan gunakan fungsi untuk pekerjaan yang tepat, seperti
di sini:
def message(): print("Enter a value: ") message() a = int(input()) message() b = int(input())
message() c = int(input())
4
Mengubah pesan yang diminta sekarang mudah dan jelas - Anda dapat melakukannya
dengan mengubah kode hanya di satu tempat - di dalam tubuh fungsi.
Buka kotak pasir, dan coba lakukan sendiri.
4.1.1.7 RINGKASAN BAGIAN
Takeaways kunci
1. Fungsi adalah blok kode yang melakukan tugas tertentu ketika fungsi dipanggil
(dipanggil). Anda dapat menggunakan fungsi untuk membuat kode Anda dapat digunakan
kembali, lebih terorganisir, dan lebih mudah dibaca. Fungsi dapat memiliki parameter dan
mengembalikan nilai.
2. Setidaknya ada empat jenis fungsi dasar di Python:
 fungsi bawaan yang merupakan bagian integral dari Python
(seperti print()fungsi). Anda dapat melihat daftar lengkap fungsi bawaan Python
di https://docs.python.org/3/library/functions.html .
 yang berasal dari modul pra-instal (Anda akan mempelajarinya dalam Modul 5 kursus
ini)
 fungsi yang ditentukan pengguna yang ditulis oleh pengguna untuk pengguna - Anda
dapat menulis fungsi Anda sendiri dan menggunakannya secara bebas dalam kode
Anda,
 yang lambdafungsi (Anda akan belajar tentang mereka di Modul 6 dari kursus ini.)
3. Anda dapat menentukan fungsi Anda sendiri menggunakan defkata kunci dan sintaks
berikut:
def yourFunction(optional parameters): # the body of the function
Anda dapat mendefinisikan fungsi yang tidak mengambil argumen apa pun, misalnya:
def message(): # defining a function print("Hello") # body of the function message() # calling
the function
Anda dapat mendefinisikan fungsi yang mengambil argumen juga, seperti fungsi satu-
parameter di bawah ini:
def hello(name): # defining a function print("Hello,", name) # body of the function name =
input("Enter your name: ") hello(name) # calling the function
Kami akan memberi tahu Anda lebih banyak tentang fungsi parametrized di bagian
selanjutnya. Jangan khawatir.
Latihan 1
The input()Fungsi adalah contoh dari:
a) fungsi yang ditetapkan pengguna

b) built-in fungsi
Memeriksa
b - ini adalah fungsi bawaan
Latihan 2
Apa yang terjadi ketika Anda mencoba menjalankan fungsi sebelum Anda
mendefinisikannya? Contoh:
hi() def hi(): print("hi!")
Memeriksa
Sebuah pengecualian dilemparkan ( NameErrorpengecualian lebih tepatnya)
Latihan 3
Apa yang akan terjadi ketika Anda menjalankan kode di bawah ini?
def hi(): print("hi") hi(5)
Memeriksa
5
Pengecualian akan dilempar ( TypeErrorpengecualian lebih tepatnya) - hi()fungsi tidak
mengambil argumen apa pun
4.1.2.1 How functions communicate with their environment
Parametrized functions
The function's full power reveals itself when it can be equipped with an interface that is able to
accept data provided by the invoker. Such data can modify the function's behavior, making it
more flexible and adaptable to changing conditions.
A parameter is actually a variable, but there are two important factors that make parameters
different and special:
 parameters exist only inside functions in which they have been defined, and the only
place where the parameter can be defined is a space between a pair of parentheses in
the def statement;
 assigning a value to the parameter is done at the time of the function's invocation, by
specifying the corresponding argument.
def function(parameter): ###
Don't forget:
 parameters live inside functions (this is their natural environment)
 arguments exist outside functions, and are carriers of values passed to corresponding
parameters.
There is a clear and unambiguous frontier between these two worlds.
Let's enrich the function above with just one parameter - we're going to use it to show the user
the number of a value the function asks for.
We have to rebuild the def statement - this is how it looks now:

def message(number): ###
The definition specifies that our function operates on just one parameter named number. You
can use it as an ordinary variable, but only inside the function - it isn't visible anywhere else.
Let's now improve the function's body:
def message(number): print("Enter a number:", number)
We've made use of the parameter. Note: we haven't assigned the parameter with any value. Is
it correct?
Yes, it is.
A value for the parameter will arrive from the function's environment.
Remember: specifying one or more parameters in a function's definition is also a requirement,
and you have to fulfil it during invocation. You must provide as many arguments as there are
defined parameters.
Failure to do so will cause an error.
Parametrized functions: continued

Try to run the code in the editor.
This is what you'll see in the console:
TypeError: message() missing 1 required positional argument: 'number'
This looks better, for sure:

def message(number): print("Enter a number:", number) message(1)
Moreover, it behaves better. The code will produce the following output:
6
Enter a number: 1
Can you see how it works? The value of the argument used during invocation (1) has been
passed into the function, setting the initial value of the parameter named number.
We have to make you sensitive to one important circumstance.

It's legal, and possible, to have a variable named the same as a function's parameter.
The snippet illustrates the phenomenon:
def message(number): print("Enter a number:", number) number = 1234 message(1)
print(number)
A situation like this activates a mechanism called shadowing:

 parameter x shadows any variable of the same name, but...
 ... only inside the function defining the parameter.
The parameter named numberis a completely different entity from the variable named number.
This means that the snippet above will produce the following output:
Enter a number: 1 1234
Parametrized functions: continued

A function can have as many parameters as you want, but the more parameters you have, the
harder it is to memorize their roles and purposes.
Let's modify the function - it has two parameters now:

def message(what, number): print("Enter", what, "number", number)
This also means that invoking the function will require two arguments.
The first new parameter is intended to carry the name of the desired value.
Here it is:
def message(what, number): print("Enter", what, "number", number) message("telephone", 11)
message("price", 5) message("number", "number")
This is the output you're about to see:

Enter telephone number 11 Enter price number 5 Enter number number number
Run the code, modify it, add more parameters, and see how this affects the output.
Positional parameter passing

A technique which assigns the ith(first, second, and so on) argument to the ith (first, second, and
so on) function parameter is called positional parameter passing, while arguments passed in this
way are named positional arguments.
You've used it already, but Python can offer a lot more. We're going to tell you about it now.
def myFunction(a, b, c): print(a, b, c) myFunction(1, 2, 3)
7
Note: positional parameter passing is intuitively used by people in many social occasions. For
example, it may be generally accepted that when we introduce ourselves we mention our first
name(s) before our last name, e.g., "My name's John Doe."
Incidentally, Hungarians do it in reverse order.
Let's implement that social custom in Python. The following function will be responsible for
introducing somebody:
def introduction(firstName, lastName): print("Hello, my name is", firstName, lastName)
introduction("Luke", "Skywalker") introduction("Jesse", "Quick") introduction("Clark", "Kent")
Can you guess the output? Run the code and find out if you were right.
Now imagine that the same function is being used in Hungary. In this case, the code would look
like this:
introduction("Skywalker", "Luke") introduction("Quick", "Jesse") introduction("Kent", "Clark")
The output will look different. Can you guess it?

Run the code to see if you were right here, too. Are you surprised?
Can you make the function more culture-independent?
Keyword argument passing

Python offers another convention for passing arguments, where the meaning of the argument is
dictated by its name, not by its position - it's called keyword argument passing.
Take a look at the snippet:
introduction(firstName = "James", lastName = "Bond") introduction(lastName = "Skywalker",
firstName = "Luke")
The concept is clear - the values passed to the parameters are preceded by the target
parameters' names, followed by the = sign.
The position doesn't matter here - each argument's value knows its destination on the basis of
the name used.
You should be able to predict the output. Run the code to check if you were right.
Of course, you mustn't use a non-existent parameter name.

The following snippet will cause a runtime error:
introduction(surname="Skywalker", firstName="Luke")
This is what Python will tell you:

TypeError: introduction() got an unexpected keyword argument 'surname'
Try it out yourself.
8
Mixing positional and keyword arguments

You can mix both fashions if you want - there is only one unbreakable rule: you have to
put positional arguments before keyword arguments.
If you think for a moment, you'll certainly guess why.
To show you how it works, we'll use the following simple three-parameter function:
def sum(a, b, c): print(a, "+", b, "+", c, "=", a + b + c)
Its purpose is to evaluate and present the sum of all its arguments.
The function, when invoked in the following way:
sum(1, 2, 3)
will output:
1+2+3=6
It was - as you may suspect - a pure example of positional argument passing.
Of course, you can replace such an invocation with a purely keyword variant, like this:
sum(c = 1, a = 2, b = 3)
Our program will output a line like this:

2+3+1=6
Note the order of the values.
Let's try to mix both styles now.

Look at the function invocation below:
sum(3, c = 1, b = 2)
Let's analyze it:

 the argument (3) for the aparameter is passed using the positional way;
 the arguments for c and bare specified as keyword ones.
This is what you'll see in the console:
3+2+1=6
Be careful, and beware of mistakes. If you try to pass more than one value to one argument, all
you'll get is a runtime error.
Look at the invocation below - it seems that we've tried to set atwice:
sum(3, a = 1, b = 2)
Python's response:
9
TypeError: sum() got multiple values for argument 'a'
Look at the snipet below. A code like this is fully correct, but it doesn't make much sense:
sum(4, 3, c = 2)
Everything is right, but leaving in just one keyword argument looks a bit weird - what do you
think?
Parametrized functions - more details

It happens at times that a particular parameter's values are in use more often than others. Such
arguments may have their default (predefined) values taken into consideration when their
corresponding arguments have been omitted.
They say that the most popular English last name is Smith. Let's try to take this into account.
The default parameter's value is set using clear and pictorial syntax:
def introduction(firstName, lastName="Smith"): print("Hello, my name is", fistName, lastName)
You only have to extend the parameter's name with the = sign, followed by the default
value./p>
Let's invoke the function as usual:
introduction("James", "Doe")
Can you guess the output of the program? Run it and check if you were right.
And? Everything looks the same, but when you invoke the function in a way that looks a bit
suspicious at first sight, like this:
introduction("Henry")
or this:
introduction(firstName="William")
there will be no error, and both invocations will succeed, while the console will show the
following output:
Hello, my name is Henry Smith Hello, my name is William Smith
Test it.
You can go further if it's useful. Both parameters have their default values now, look at the code
below:
def introduction(firstName="John", lastName="Smith"): print("Hello, my name is", firstName,
lastName)
This makes the following invocation absolutely valid:

introduction()
And this is the expected output:

Hello, my name is John Smith
If you use one keyword argument, the remaining one will take the default value:
introduction(lastName="Hopkins")
The output is:

Hello, my name is John Hopkins
Test it.
10
Congratulations - you have just learned the basic ways of communicating with functions.
Takeaways kunci
1. Anda dapat meneruskan informasi ke fungsi dengan menggunakan parameter. Fungsi Anda
dapat memiliki parameter sebanyak yang Anda butuhkan.
Contoh fungsi satu-parameter:
def hi(name): print("Hi,", name) hi("Greg")
Contoh fungsi dua parameter:

def hiAll(name1, name2): print("Hi,", name2) print("Hi,", name1) hiAll("Sebastian", "Konrad")
Contoh fungsi tiga parameter:

def address(street, city, postalCode): print("Your address is:", street, "St.,", city, postalCode) s =
input("Street: ") pC = input("Postal Code: ") c = input("City: ") address(s, c, pC)
2. Anda bisa meneruskan argumen ke suatu fungsi menggunakan teknik berikut:

 argumen posisi yang lewat di mana urutan argumen melewati hal-hal (Kel. 1),
 kata kunci (bernama) argumen yang lewat di mana urutan argumen yang disahkan
tidak masalah (Kel. 2),
 campuran dari pengajuan argumen posisi dan kata kunci (Kel. 3).
Ex. 1 def subtra(a, b): print(a - b) subtra(5, 2) # outputs: 3 subtra(2, 5) # outputs: -3 Ex. 2 def
subtra(a, b): print(a - b) subtra(a=5, b=2) # outputs: 3 subtra(b=2, a=5) # outputs: 3 Ex. 3 def
subtra(a, b): print(a - b) subtra(5, b=2) # outputs: 3 subtra(5, 2) # outputs: 3
Penting untuk diingat bahwa argumen posisi tidak boleh mengikuti argumen kata kunci . Itu
sebabnya jika Anda mencoba menjalankan cuplikan berikut:
def subtra(a, b): print(a - b) subtra(5, b=2) # outputs: 3 subtra(a=5, 2) # Syntax Error
Python tidak akan membiarkan Anda melakukannya dengan memberi tanda a SyntaxError.
3. Anda dapat menggunakan teknik melewati argumen kata kunci untuk menentukan
sebelumnya nilai untuk argumen yang diberikan:
def name(firstN, lastN="Smith"): print(firstN, lastN) name("Andy") # outputs: Andy Smith
name("Betty", "Johnson") # outputs: Betty Johnson (the keyword argument replaced by
"Johnson")
Latihan 1
Apa output dari cuplikan berikut?
def intro(a="James Bond", b="Bond"): print("My name is", b + ".", a + ".") intro()
Memeriksa
My name is Bond. James Bond.
Latihan 2
def intro(a="James Bond", b="Bond"): print("My name is", b + ".", a + ".") intro(b="Sean Connery")
Memeriksa
My name is Sean Connery. James Bond.
Latihan 3
11
def intro(a, b="Bond"): print("My name is", b + ".", a + ".") intro("Susan")
Memeriksa
My name is Bond. Susan.
Latihan 4
def sum(a, b=2, c): print(a + b + c) sum(a=1, c=3)
Memeriksa
SyntaxError- argumen non-default ( c) mengikuti argumen default ( b=2)
4.1.3.1 Mengembalikan hasil dari suatu fungsi
Efek dan hasil: instruksi pengembalian

Semua fungsi yang disajikan sebelumnya memiliki semacam efek - mereka menghasilkan
beberapa teks dan mengirimkannya ke konsol.
Tentu saja, fungsi - seperti saudara kandung matematika mereka - mungkin memiliki hasil.
Untuk mendapatkan fungsi untuk mengembalikan nilai (tetapi tidak hanya untuk tujuan ini)
Anda menggunakan returninstruksi.
Kata ini memberi Anda gambaran lengkap tentang kemampuannya. Catatan: ini adalah kata
kunci Python .
The returninstruksi memiliki dua varian yang berbeda - mari kita mempertimbangkan secara
terpisah.
kembali tanpa ekspresi
Yang pertama terdiri dari kata kunci itu sendiri, tanpa mengikutinya.
Ketika digunakan di dalam suatu fungsi, itu menyebabkan penghentian segera dari eksekusi
fungsi, dan pengembalian instan (karenanya namanya) ke titik doa .
Catatan: jika suatu fungsi tidak dimaksudkan untuk menghasilkan suatu
hasil, menggunakan returninstruksi tidak wajib - itu akan dieksekusi secara implisit di akhir fungsi.
Bagaimanapun, Anda dapat menggunakannya untuk menghentikan aktivitas fungsi sesuai
permintaan , sebelum kontrol mencapai baris terakhir fungsi.
Mari kita pertimbangkan fungsi berikut:

def happyNewYear(wishes = True): print("Three...") print("Two...") print("One...") if not wishes:
return print("Happy New Year!")
Ketika dipanggil tanpa argumen:

happyNewYear()
Fungsi menyebabkan sedikit noise - output akan terlihat seperti ini:

Three... Two... One... Happy New Year!
Memberikan Falsesebagai argumen:

happyNewYear(False)
akan mengubah perilaku fungsi - returninstruksi akan menyebabkan penghentiannya tepat

sebelum keinginan - ini adalah output yang diperbarui:
Three... Two... One...
kembali dengan sebuah ekspresi

returnVarian kedua diperpanjang dengan ekspresi :
function(): return expression
Ada dua konsekuensi dari menggunakannya:
12
 itu menyebabkan penghentian segera eksekusi fungsi (tidak ada yang baru
dibandingkan dengan varian pertama)
 selain itu, fungsi akan mengevaluasi nilai ekspresi dan akan mengembalikan
(karenanya namanya sekali lagi) sebagai hasil fungsi .
Ya, kami sudah tahu - contoh ini tidak terlalu canggih:
def boringFuncton(): return 123 x = boringFunction() print("The boringFunction has returned its
result. It's:", x)
Cuplikan menulis teks berikut ke konsol:

The boringFunction has returned its result. It's: 123
Mari kita selidiki sebentar.

Analisis gambar di bawah ini:
The returninstruksi, diperkaya dengan ekspresi (ekspresi sangat sederhana di sini), "mengangkut"
nilai ekspresi untuk tempat fungsi telah dipanggil.
Hasilnya dapat digunakan secara bebas di sini, misalnya, untuk ditugaskan ke variabel.
Itu mungkin juga sepenuhnya diabaikan dan hilang tanpa jejak.
Catatan, kami tidak terlalu sopan di sini - fungsi mengembalikan nilai, dan kami
mengabaikannya (kami tidak menggunakannya dengan cara apa pun):
def boringFunction(): print("'Boredom Mode' ON.") return 123 print("This lesson is interesting!)
boringFunction() print("This lesson is boring...")
Program menghasilkan output sebagai berikut:

This lesson is interesting! 'Boredom Mode' ON. This lesson is boring...
Apakah bisa dihukum? Tidak semuanya.

Satu-satunya kelemahan adalah bahwa hasilnya telah hilang tanpa dapat diperbaiki kembali.
Jangan lupa:
 Anda selalu diizinkan untuk mengabaikan hasil fungsi , dan puas dengan efek fungsi
(jika ada fungsi)
 jika suatu fungsi ingin mengembalikan hasil yang bermanfaat, itu harus mengandung
varian kedua dari returninstruksi.
Tunggu sebentar - apakah ini berarti ada hasil yang tidak berguna juga? Ya - dalam arti
tertentu.
Beberapa kata tentang None

Biarkan kami memperkenalkan Anda dengan nilai yang sangat aneh (jujur, tidak ada nilai)
bernama None.
Datanya tidak mewakili nilai wajar - sebenarnya, itu bukan nilai sama sekali; karenanya, ia tidak
boleh ikut serta dalam ekspresi apa pun .
Misalnya, cuplikan seperti ini:
print(None + 2)
13
akan menyebabkan kesalahan runtime, dijelaskan oleh pesan diagnostik berikut:
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
Catatan: Noneadalah kata kunci .

Hanya ada dua jenis keadaan saat None dapat digunakan dengan aman:
 ketika Anda menetapkannya ke variabel (atau mengembalikannya sebagai
hasil fungsi )
 ketika Anda membandingkannya dengan variabel untuk mendiagnosis keadaan
internalnya.
Sama seperti di sini:
value = None
if value == None:
print("Sorry, you don't carry any value")
Jangan lupa ini: jika suatu fungsi tidak mengembalikan nilai tertentu menggunakan klausa
ekspresi kembali, diasumsikan bahwa itu mengembalikan secara implisitNone .
Ayo kita coba.
Beberapa kata tentang None : lanjutan

Lihatlah kode di editor.
Jelas bahwa strangeFunctionfungsi kembali Trueketika argumennya genap.
Apa yang dikembalikan sebaliknya?
Kita dapat menggunakan kode berikut untuk memeriksanya:
print(strangeFunction(2)) print(strangeFunction(1))
Inilah yang kami lihat di konsol:

True None
Jangan kaget lain kali Anda melihat Nonesebagai hasil fungsi - itu mungkin merupakan gejala
kesalahan halus di dalam fungsi.
Efek dan hasil: daftar dan fungsi

Ada dua pertanyaan tambahan yang harus dijawab di sini.
Yang pertama adalah: bisakah daftar dikirim ke suatu fungsi sebagai argumen?
Tentu saja mungkin! Entitas apa pun yang dikenali oleh Python dapat memainkan peran
argumen fungsi, meskipun harus diyakinkan bahwa fungsi tersebut mampu mengatasinya.
Jadi, jika Anda meneruskan daftar ke suatu fungsi, fungsi tersebut harus menanganinya seperti
daftar.
Fungsi seperti ini di sini:
14
.def sumOfList(lst): sum = 0 for elem in lst: sum += elem return sum
dan dipanggil seperti ini:

print(sumOfList([5, 4, 3]))
akan kembali 12sebagai hasilnya, tetapi Anda harus mengharapkan masalah jika Anda
memohonnya dengan cara yang berisiko ini:
print(sumOfList(5))
Tanggapan Python akan tegas:

TypeError: 'int' object is not iterable
Ini disebabkan oleh fakta bahwa nilai integer tunggal tidak boleh diulangi oleh forloop.
Efek dan hasil: daftar dan fungsi - lanjutan

Pertanyaan kedua adalah: bisakah daftar menjadi hasil fungsi?
Ya tentu saja! Entitas apa pun yang dikenali oleh Python dapat menjadi hasil fungsi.
Lihatlah kode di editor. Output program akan seperti ini:
[4, 3, 2, 1, 0]
Sekarang Anda dapat menulis fungsi dengan dan tanpa hasil.

Mari selami lebih dalam masalah yang terkait dengan variabel dalam fungsi. Ini penting untuk
menciptakan fungsi yang efektif dan aman.
4.1.3.6 LAB: Setahun kabisat: menulis fungsi Anda sendiri
LABORATORIUM
Perkiraan waktu
10-15 menit
Tingkat kesulitan
Mudah
Tujuan
Biasakan siswa dengan:
 memproyeksikan dan menulis fungsi parameterisasi;
 menggunakan pernyataan return ;
 menguji fungsi.
Skenario
Tugas Anda adalah menulis dan menguji fungsi yang membutuhkan satu argumen (satu tahun)
dan kembali Truejika tahun tersebut merupakan tahun kabisat , atau Falsesebaliknya.
Benih fungsi sudah ditaburkan dalam kode kerangka di editor.
Catatan: kami juga menyiapkan kode pengujian singkat, yang dapat Anda gunakan untuk
menguji fungsi Anda.
Kode menggunakan dua daftar - satu dengan data uji, dan yang lainnya berisi hasil yang
diharapkan. Kode akan memberi tahu Anda jika ada hasil yang tidak valid.
4.1.3.7 LAB: Berapa hari: menulis dan menggunakan fungsi Anda sendiri
LABORATORIUM
Perkiraan waktu
15-20 menit
15
Tingkat kesulitan
Medium
Prasyarat
LAB 4.1.3.6
Tujuan
 menggunakan pernyataan pengembalian ;
 memanfaatkan fungsi siswa sendiri.
Skenario
Tugas Anda adalah menulis dan menguji fungsi yang membutuhkan dua argumen (satu tahun
dan satu bulan) dan mengembalikan jumlah hari untuk pasangan bulan / tahun yang diberikan
(sementara hanya Februari yang peka terhadap yearnilai, fungsi Anda harus universal).
Bagian awal dari fungsi sudah siap. Sekarang, yakinkan fungsi untuk kembali Nonejika
argumennya tidak masuk akal.
Tentu saja, Anda dapat (dan harus) menggunakan fungsi yang telah ditulis dan diuji
sebelumnya (LAB 4.1.3.6). Ini mungkin sangat membantu. Kami menyarankan Anda untuk
menggunakan daftar yang diisi dengan panjang bulan. Anda dapat membuatnya di dalam
fungsi - trik ini akan secara signifikan mempersingkat kode.
Kami telah menyiapkan kode pengujian. Perluas untuk memasukkan lebih banyak kasus uji.
4.1.3.8 LAB: Hari dalam setahun: menulis dan menggunakan fungsi Anda sendiri
LABORATORIUM
Perkiraan waktu
20-30 menit
Tingkat kesulitan
Medium
Prasyarat
LAB 4.1.3.6
LAB 4.1.3.7
Tujuan
 menggunakan pernyataan pengembalian ;
 membangun seperangkat fungsi utilitas;
 memanfaatkan fungsi siswa sendiri.
Skenario
Tugas Anda adalah menulis dan menguji fungsi yang membutuhkan tiga argumen (satu tahun,
satu bulan, dan satu hari dalam sebulan) dan mengembalikan hari yang sesuai tahun itu, atau
mengembalikan Nonejika salah satu argumen tidak valid.
Gunakan fungsi yang ditulis dan diuji sebelumnya. Tambahkan beberapa test case ke kode. Tes
ini hanya permulaan.
4.1.3.9 BAL: Bilangan prima - cara menemukannya
LABORATORIUM
Perkiraan waktu
15-20 menit
Tingkat kesulitan
Medium
Tujuan
 membiasakan siswa dengan gagasan dan algoritma klasik;
 meningkatkan keterampilan siswa dalam mendefinisikan dan menggunakan fungsi.
16
Skenario
Bilangan alami adalah prima jika lebih besar dari 1 dan tidak memiliki pembagi selain 1 dan itu
sendiri.
Rumit? Tidak semuanya. Misalnya, 8 bukan bilangan prima, karena Anda dapat membaginya
dengan 2 dan 4 (kami tidak dapat menggunakan pembagi sama dengan 1 dan 8, karena
definisi melarang ini).
Di sisi lain, 7 adalah bilangan prima, karena kami tidak dapat menemukan pembagi hukum
untuk itu.
Tugas Anda adalah menulis fungsi yang memeriksa apakah suatu bilangan prima atau tidak.
Fungsi:
 disebut isPrime;
 membutuhkan satu argumen (nilai untuk memeriksa)
 kembali Truejika argumennya adalah bilangan prima, dan Falsesebaliknya.
Petunjuk: coba bagi argumen dengan semua nilai berikutnya (mulai dari 2) dan periksa sisanya
- jika nol, angka Anda tidak dapat menjadi prima; pikirkan baik-baik kapan Anda harus
menghentikan prosesnya.
Jika Anda perlu mengetahui akar kuadrat dari nilai apa pun, Anda dapat
memanfaatkan **operator. Ingat: akar kuadrat dari x sama dengan x 0,5
Lengkapi kode di editor.
Jalankan kode Anda dan periksa apakah output Anda sama dengan kami.
Data Uji
Output yang diharapkan:
2 3 5 7 11 13 17 19
4.1.3.10 LAB: Mengkonversi konsumsi bahan bakar
LABORATORIUM
Perkiraan waktu
10-15 menit
Tingkat kesulitan
Mudah
Tujuan
 meningkatkan keterampilan siswa dalam mendefinisikan, menggunakan, dan menguji
fungsi.
Skenario
Konsumsi bahan bakar mobil dapat dinyatakan dengan berbagai cara. Misalnya, di Eropa,
ditampilkan sebagai jumlah bahan bakar yang dikonsumsi per 100 kilometer.
Di AS, ditampilkan sebagai jumlah mil yang ditempuh oleh mobil menggunakan satu galon
bahan bakar.
Tugas Anda adalah menulis sepasang fungsi yang mengubah l / 100km menjadi mpg, dan
sebaliknya.
Fungsi:
 diberi nama l100kmtompgdan mpgtol100kmmasing - masing;
 ambil satu argumen (nilai yang sesuai dengan namanya)
Lengkapi kode di editor.
Jalankan kode Anda dan periksa apakah output Anda sama dengan kami.
Berikut ini beberapa informasi untuk membantu Anda:
 1 mile Amerika = 1609.344 meter;
 1 galon Amerika = 3,785411784 liter.
Data Uji
Output yang diharapkan:
60.31143162393162
31.36194444444444
23.52145833333333
17
3.9007393587617467
7.490910297239916
10.009131205673757
Takeaways kunci
1. Anda dapat menggunakan returnkata kunci untuk memberi tahu fungsi untuk
mengembalikan nilai. The returnpernyataan keluar fungsi, misalnya:
def multiply(a, b): return a * b print(multiply(3, 4)) # outputs: 12 def multiply(a, b): return
print(multiply(3, 4)) # outputs: None
2. Hasil suatu fungsi dapat dengan mudah ditugaskan ke variabel, misalnya:

def wishes(): return "Happy Birthday!" w = wishes() print(w) # outputs: Happy Birthday!
Lihatlah perbedaan dalam output dalam dua contoh berikut:

# Example 1 def wishes(): print("My Wishes") return "Happy Birthday" wishes() # outputs: My
Wishes # Example 2 def wishes(): print("My Wishes") return "Happy Birthday" print(wishes()) #
outputs: My Wishes # Happy Birthday
3. Anda dapat menggunakan daftar sebagai argumen fungsi, misalnya:

def hiEverybody(myList): for name in myList: print("Hi,", name) hiEverybody(["Adam", "John",
"Lucy"])
4. Daftar dapat menjadi hasil fungsi juga, misalnya:

def createList(n): myList = [] for i in range(n): myList.append(i) return myList print(createList(5))
Latihan 1
18
def hi(): return print("Hi!") hi()
Memeriksa
fungsi akan mengembalikan Nonenilai implisit
Latihan 2
def isInt(data): if type(data) == int: return True elif type(data) == float: return False print(isInt(5))
print(isInt(5.0)) print(isInt("5"))
Memeriksa
True False None
Latihan 3
def evenNumLst(ran): lst = [] for num in range(ran): if num % 2 == 0: lst.append(num) return lst
print(evenNumLst(11))
Memeriksa
[0, 2, 4, 6, 8, 10]
Latihan 4
def listUpdater(lst): updList = [] for elem in lst: elem **= 2 updList.append(elem) return updList l =
[1, 2, 3, 4, 5] print(listUpdater(l))
Memeriksa
[1, 4, 9, 16, 25]
4.1.4.1 Lingkup dalam Python
Fungsi dan cakupan

Mari kita mulai dengan definisi:
The lingkup nama (misalnya, nama variabel) adalah bagian dari kode di mana nama adalah
benar dikenali.
Misalnya, ruang lingkup parameter fungsi adalah fungsi itu sendiri. Parameter tidak dapat
diakses di luar fungsi.
Mari kita periksa. Lihatlah kode di editor. Apa yang akan terjadi ketika Anda menjalankannya?
Program akan gagal saat dijalankan. Pesan kesalahan akan membaca:
NameError: name 'x' is not defined
Ini yang diharapkan.

Kami akan melakukan beberapa percobaan dengan Anda untuk menunjukkan kepada Anda
bagaimana Python membangun lingkup, dan bagaimana Anda dapat menggunakan
kebiasaannya untuk keuntungan Anda.
Fungsi dan cakupan: lanjutan

Mari kita mulai dengan memeriksa apakah variabel yang dibuat di luar fungsi apa pun terlihat
di dalam fungsi. Dengan kata lain, apakah nama variabel menyebar ke tubuh fungsi?
Lihatlah kode di editor. Babi guinea kita ada di sana.
Hasil tes positif - kode keluaran:
Do I know that variable? 1 1
Jawabannya adalah: variabel yang ada di luar fungsi memiliki cakupan di dalam tubuh fungsi .
Aturan ini memiliki pengecualian yang sangat penting. Mari kita coba menemukannya.
19
Mari kita lakukan sedikit perubahan pada kode:
def myFunction(): var = 2 print("Do I know that variable?", var) var = 1 myFunction() print(var)
Hasilnya telah berubah juga - kode menghasilkan keluaran yang sedikit berbeda sekarang:
Apa yang terjadi?

 yang varvariabel dibuat dalam fungsi tidak sama seperti ketika didefinisikan di luar itu -
tampaknya bahwa ada dua variabel yang berbeda dengan nama yang sama;
 Selain itu, variabel fungsi ini membayangi variabel yang datang dari dunia luar.
Kita dapat membuat aturan sebelumnya lebih tepat dan memadai:
Variabel yang ada di luar fungsi memiliki cakupan di dalam tubuh fungsi, tidak termasuk
variabel yang mendefinisikan variabel dengan nama yang sama.
Ini juga berarti bahwa ruang lingkup variabel yang ada di luar fungsi hanya didukung ketika
mendapatkan nilainya(membaca). Menetapkan nilai memaksa pembuatan variabel fungsi
sendiri.
Pastikan Anda memahami ini dengan baik dan melakukan eksperimen Anda sendiri.
4.1.4.3 Lingkup dalam Python | global
Fungsi dan cakupan: kata kunci global

Mudah-mudahan, Anda seharusnya sudah sampai pada pertanyaan berikut: apakah ini berarti
bahwa suatu fungsi tidak dapat memodifikasi variabel yang didefinisikan di luarnya? Ini akan
membuat banyak ketidaknyamanan.
Untungnya, jawabannya adalah tidak .
Ada metode Python khusus yang dapat memperluas ruang lingkup variabel dengan cara yang
mencakup tubuh fungsi (bahkan jika Anda ingin tidak hanya membaca nilai-nilai, tetapi juga
memodifikasinya).
Efek seperti itu disebabkan oleh kata kunci bernama global:
global name global name1, name2, ...
Menggunakan kata kunci ini di dalam suatu fungsi dengan nama (atau nama yang dipisahkan
dengan koma) dari suatu variabel, memaksa Python untuk menahan diri dari membuat
variabel baru di dalam fungsi - yang dapat diakses dari luar akan digunakan sebagai gantinya.
Dengan kata lain, nama ini menjadi global (memiliki cakupan global , dan tidak masalah
apakah itu subjek yang dibaca atau ditugaskan).

Kami telah menambahkan globalke fungsi.
Kode sekarang menghasilkan:
20
Ini harus menjadi bukti yang cukup untuk menunjukkan bahwa globalkata kunci melakukan
apa yang dijanjikan.
Bagaimana fungsi berinteraksi dengan argumennya

Sekarang mari kita cari tahu bagaimana fungsinya berinteraksi dengan argumennya.
Kode dalam editor seharusnya mengajarkan Anda sesuatu. Seperti yang Anda lihat, fungsi
mengubah nilai parameternya. Apakah perubahan itu memengaruhi argumen?
Jalankan program dan periksa.
Keluaran kode adalah:
I got 1 I have 2 1
Kesimpulannya jelas - mengubah nilai parameter tidak menyebar di luar fungsi (dalam hal apa
pun, tidak ketika variabel adalah skalar, seperti dalam contoh).
Ini juga berarti bahwa suatu fungsi menerima nilai argumen , bukan argumen itu sendiri. Ini
berlaku untuk skalar.
Apakah perlu memeriksa cara kerjanya dengan daftar (apakah Anda mengingat kekhasan
penugasan irisan daftar versus penugasan daftar secara keseluruhan?).
Contoh berikut akan menjelaskan masalah ini:

def myFunction(myList1): print(myList1) myList1 = [0, 1] myList2 = [2, 3] myFunction(myList2)
print(myList2)
Keluaran kode adalah:
21
[2, 3] [2, 3]
Tampaknya aturan sebelumnya masih berfungsi.
Akhirnya, dapatkah Anda melihat perbedaan dalam contoh di bawah ini:

def myFunction(myList1): print(myList1) del myList1[0] myList2 = [2, 3] myFunction(myList2)
print(myList2)
Kami tidak mengubah nilai parameter myList1(kami sudah tahu itu tidak akan mempengaruhi
argumen), tetapi memodifikasi daftar yang diidentifikasi olehnya.
Outputnya mungkin mengejutkan. Jalankan kode dan periksa:
[2, 3] [3]
Bisakah Anda menjelaskannya?

Mari mencoba:
 jika argumennya adalah daftar, maka mengubah nilai parameter yang sesuai tidak
mempengaruhi daftar (ingat: variabel yang berisi daftar disimpan dengan cara yang
berbeda dari skalar)
 tetapi jika Anda mengubah daftar yang diidentifikasi oleh parameter (catatan: daftar,
bukan parameter!), daftar tersebut akan mencerminkan perubahan.
Saatnya menulis beberapa contoh fungsi. Anda akan melakukannya di bagian selanjutnya.
Takeaways kunci
1. Variabel yang ada di luar fungsi memiliki cakupan di dalam tubuh fungsi (Contoh 1) kecuali
fungsi tersebut mendefinisikan variabel dengan nama yang sama (Contoh 2, dan Contoh 3),
misalnya:
Contoh 1:
var = 2 def multByVar(x): return x * var print(multByVar(7)) # outputs: 14
Contoh 2:
def mult(x): var = 5 return x * var print(mult(7)) # outputs: 35
Contoh 3:
def multip(x): var = 7 return x * var var = 3 print(multip(7)) # outputs: 49
2. Variabel yang ada di dalam suatu fungsi memiliki cakupan di dalam tubuh fungsi (Contoh 4),
misalnya:
Contoh 4:
def adding(x): var = 7 return x + var print(adding(4)) # outputs: 11 print(var) # NameError
3. Anda dapat menggunakan globalkata kunci diikuti oleh nama variabel untuk membuat
lingkup variabel global, misalnya:
var = 2 print(var) # outputs: 2 def retVar(): global var var = 5 return var print(retVar()) # outputs:
5 print(var) # outputs: 5
Latihan 1
Apa yang akan terjadi ketika Anda mencoba menjalankan kode berikut?
def message(): alt = 1 print("Hello, World!") print(alt)
Memeriksa
The NameErrorpengecualian akan dilempar ( NameError: name 'alt' is not defined)
Latihan 2
22
a = 1 def fun(): a = 2 print(a) fun() print(a)
Memeriksa
21
Latihan 3
a = 1 def fun(): global a a = 2 print(a) fun() a = 3 print(a)
Memeriksa
23
Latihan 4
a = 1 def fun(): global a a = 2 print(a) a = 3 fun() print(a)
Memeriksa
22
4.1.5.1 Membuat fungsi | fungsi dua parameter
Beberapa fungsi sederhana: mengevaluasi BMI

Mari kita mulai fungsi untuk mengevaluasi Indeks Massa Tubuh (IMT).
Seperti yang Anda lihat, rumus ini mendapat dua nilai:

 berat (awalnya dalam kilogram)
 tinggi (awalnya dalam meter)
Tampaknya fungsi baru ini akan memiliki dua parameter. Namanya akan bmi, tetapi jika Anda
lebih suka nama lain, gunakan saja.
Mari kita beri kode fungsi.
Fungsi selesai di bawah ini (dan di jendela editor):

def bmi(weight, height): return weight / height ** 2 print(bmi(52.5, 1.65))
Hasil yang dihasilkan oleh permohonan contoh terlihat sebagai berikut:

19.283746556473833
Fungsi ini memenuhi harapan kami, tetapi agak sederhana - ia mengasumsikan bahwa nilai dari
kedua parameter selalu bermakna. Sudah pasti layak untuk diperiksa apakah mereka dapat
dipercaya.
Mari kita periksa keduanya dan kembali Nonejika ada yang mencurigakan.
4.1.5.2 Membuat fungsi | fungsi dua parameter
Beberapa fungsi sederhana: mengevaluasi BMI dan mengkonversi unit imperial menjadi unit
metrik
Lihatlah kode di editor. Ada dua hal yang perlu kita perhatikan.
Pertama, permintaan tes memastikan bahwa perlindunganberfungsi dengan baik - hasilnya
adalah:
None
23
Kedua, lihat cara simbol backslash( \) digunakan. Jika Anda menggunakannya dalam kode
Python dan mengakhiri baris dengan itu, itu akan memberitahu Python untuk melanjutkan baris
kode di baris kode berikutnya.
Ini bisa sangat berguna ketika Anda harus berurusan dengan baris kode yang panjang dan
Anda ingin meningkatkan keterbacaan kode.
Oke, tapi ada sesuatu yang kita hilangkan terlalu mudah - pengukuran kekaisaran. Fungsi ini
tidak terlalu berguna untuk orang yang terbiasa dengan pound, kaki dan inci.
Apa yang bisa dilakukan untuk mereka?
Kita dapat menulis dua fungsi sederhana untuk mengonversi satuan imperial menjadi satuan
metrik . Mari kita mulai dengan pound.
Adalah fakta yang terkenal itu 1 lb = 0.45359237 kg. Kami akan menggunakan ini dalam fungsi
baru kami.
Ini adalah fungsi pembantu kami, bernama lbtokg:
def lbtokg(lb): return lb * 0.45359237 print(lbtokg(1))
Hasil permohonan tes terlihat bagus:

0.45359237
Dan sekarang saatnya untuk kaki dan inci:, 1 ft = 0.3048 mdan 1 in = 2.54 cm = 0.0254 m.
Fungsi yang kami tulis bernama ftintom:
def ftintom(ft, inch): return ft * 0.3048 + inch * 0.0254 print(ftintom(1, 1))
Hasil tes cepat adalah:

0.3302
Itu terlihat seperti yang diharapkan.

Catatan: kami ingin memberi nama parameter kedua saja in, tidak inch, tetapi kami tidak
bisa. Apa kamu tahu kenapa?
inadalah kata kunci Python - tidak dapat digunakan sebagai nama.
Mari kita konversi enam kaki menjadi meter:

print(ftintom(6, 0))
Dan inilah hasilnya:

1.8288000000000002
Sangat mungkin bahwa kadang-kadang Anda mungkin ingin menggunakan hanya kaki tanpa
inci. Akankah Python membantu Anda? Tentu saja akan.
Kami telah sedikit memodifikasi kode:
def ftintom(ft, inch = 0.0): return ft * 0.3048 + inch * 0.0254 print(ftintom(6))
Sekarang inchparameter memiliki nilai standarnya sama dengan 0.0.

Kode menghasilkan output berikut - inilah yang diharapkan:
1.8288000000000002
Akhirnya, kode tersebut mampu menjawab pertanyaan: berapa BMI seseorang yang tinggi 5'7
"dan beratnya £ 176?
Ini adalah kode yang kami bangun:
def ftintom(ft, inch = 0.0): return ft * 0.3048 + inch * 0.0254 def lbstokg(lb): return lb * 0.45359237
def bmi(weight, height): if height < 1.0 or height > 2.5 or \ weight < 20 or weight > 200: return
None return weight / height ** 2 print(bmi(weight = lbstokg(176), height = ftintom(5, 7)))
Dan jawabannya adalah:
24
27.565214082533313
Jalankan kodenya dan ujilah.
4.1.5.3 Creating functions | three-parameter functions
Some simple functions: continued

Let's play with triangles now. We'll start with a function to check whether three sides of given
lengths can build a triangle.
We know from school that the sum of two arbitrary sides has to be longer than the third side.
It won't be a hard challenge. The function will have three parameters - one for each side.
It will return True if the sides can build a triangle, and Falseotherwise. In this case, isItATriangle is
a good name for such a function.
Look at the code in the editor. You can find our function there. Run the program.
It seems that it works well - these are the results:
True False
Can we make it more compact? It looks a bit wordy.
This is a more compact version:

def isItATriangle(a, b, c): if a + b <= c or b + c <= a or \ c + a <= b: return False return True
print(isItATriangle(1, 1, 1)) print(isItATriangle(1, 1, 3))
Can we compact it even more?

Yes, we can - look:
def isItATriangle(a, b, c): return a + b > c and b + c > a and c + a > b print(isItATriangle(1, 1, 1))
print(isItATriangle(1, 1, 3))
We've negated the condition (reversed the relational operators and replaced ors with ands,
receiving a universal expression for testing triangles).
Let's install the function in a larger program. It'll ask the user for three values and make use of the
function.
25
4.1.5.4 Membuat fungsi | menguji segitiga
Beberapa fungsi sederhana: segitiga dan teorema Pythagoras

Lihatlah kode di editor. Itu meminta pengguna untuk tiga nilai. Kemudian
memanfaatkan isItATrianglefungsi. Kode siap dijalankan.
Pada langkah kedua, kami akan mencoba memastikan bahwa segitiga tertentu adalah
segitiga siku -siku .
Kita perlu menggunakan teorema Pythagoras :
c2=a2+b2
Bagaimana kita mengenali yang mana dari ketiga sisi yang merupakan sisi miring?
Sisi miring adalah sisi terpanjang.
Ini kodenya:
def isItATriangle(a, b, c): return a + b > c and b + c > a and c + a > b def isItRightTriangle(a, b,
c): if not isItATriangle(a, b, c): return False if c > a and c > b: return c ** 2 == a ** 2 + b ** 2 if a > b
and a > c: return a ** 2 == b ** 2 + c ** 2 print(isItRightTriangle(5, 3, 4)) print(isItRightTriangle(1, 3,
4))
Lihatlah bagaimana kita menguji hubungan antara sisi miring dan sisi lainnya - kita memilih sisi
terpanjang, dan menerapkan teorema Pythagoras untuk memeriksa apakah semuanya
benar. Ini membutuhkan total tiga cek.
26
4.1.5.5 Membuat fungsi | segitiga siku-siku
Beberapa fungsi sederhana: mengevaluasi bidang segitiga

Kami juga dapat mengevaluasi bidang segitiga. Formula heron akan berguna di sini:
Kami akan menggunakan operator eksponensial untuk menemukan akar kuadrat - ini mungkin
aneh, tetapi berfungsi:
Ini adalah kode yang dihasilkan:

def isItATriangle(a, b, c): return a + b > c and b + c > a and c + a > b def heron(a, b, c): p = (a +
b + c) / 2 return (p * (p - a) * (p - b) * (p - c)) ** 0.5 def fieldOfTriangle(a, b, c): if not
isItATriangle(a, b, c): return None return heron(a, b, c) print(fieldOfTriangle(1., 1., 2. ** .5))
Kami mencobanya dengan segitiga siku-siku sebagai setengah dari persegi dengan satu sisi
sama dengan 1. Ini berarti bahwa bidangnya harus sama dengan 0,5.
Ini aneh - kode menghasilkan output berikut:
0.49999999999999983
Sangat dekat dengan 0,5, tetapi tidak tepat 0,5. Apa artinya? Apakah ini sebuah kesalahan?
Tidak. Ini adalah spesifik dari perhitungan titik-mengambang . Kami akan segera memberi tahu
Anda tentang hal itu.
4.1.5.6 Membuat fungsi | faktorial
Beberapa fungsi sederhana: faktorial

Fungsi lain yang akan kita tulis adalah faktorial . Apakah Anda ingat bagaimana faktorial
didefinisikan?
0! = 1 (yes! it's true) 1! = 1 2! = 1 * 2 3! = 1 * 2 * 3 4! = 1 * 2 * 3 * 4 : : n! = 1 * 2 ** 3 * 4 * ... * n-1 * n
Itu ditandai dengan tanda seru , dan sama dengan produk dari semua bilangan alami dari satu
hingga argumennya.
Mari kita menulis kode kita. Kami akan membuat fungsi dan menyebutnya factorialFun. Ini
kodenya:
def factorialFun(n): if n < 0: return None if n < 2: return 1 product = 1 for i in range(2, n + 1):
product *= i return product for n in range(1, 6): # testing print(n, factorialFun(n))
27
Perhatikan bagaimana kita mencerminkan definisi matematika langkah demi langkah, dan
bagaimana kita menggunakan forloop untuk menemukan produk .
Kami menambahkan kode pengujian sederhana, dan ini adalah hasil yang kami dapatkan:
11
22
36
4 24
5 120
4.1.5.7 Membuat fungsi | Angka-angka Fibonacci
Beberapa fungsi sederhana: Angka Fibonacci

Apakah Anda terbiasa dengan angka Fibonacci ?
Mereka adalah urutan bilangan bulat yang dibangun menggunakan aturan yang sangat
sederhana:
 elemen pertama dari urutannya sama dengan satu ( Fib 1 = 1 )
 yang kedua juga sama dengan satu ( Fib 2 = 1 )
 setiap angka selanjutnya adalah jumlah dari dua angka sebelumnya ( Fib i = Fib i-1 +
Fib i-2 )
Berikut adalah beberapa angka Fibonacci pertama:
fib1 = 1 fib2 = 1 fib3 = 1 + 1 = 2 fib4 = 1 + 2 = 3 fib5 = 2 + 3 = 5 fib6 = 3 + 5 = 8 fib7 = 5 + 8 = 13
Apa yang Anda pikirkan tentang mengimplementasikannya sebagai suatu fungsi ?

Mari kita buat fibfungsi kita dan mengujinya. Ini dia:
def fib(n): if n < 1: return None if n < 3: return 1 elem1 = elem2 = 1 sum = 0 for i in range(3, n + 1):
sum = elem1 + elem2 elem1, elem2 = elem2, sum return sum for n in range(1, 10): # testing
print(n, "->", fib(n))
Analisis forloop body dengan hati-hati, dan cari tahu bagaimana

kita menggerakkan elem1dan elem2variabel melalui angka Fibonacci berikutnya .
Bagian uji kode menghasilkan output berikut:
1 -> 1 2 -> 1 3 -> 2 4 -> 3 5 -> 5 6 -> 8 7 -> 13 8 -> 21 9 -> 34
28
4.1.5.8 Membuat fungsi | rekursi
Beberapa fungsi sederhana: rekursi

Ada satu hal lagi yang kami ingin tunjukkan kepada Anda untuk membuat semuanya lengkap -
ini adalah rekursi .
Istilah ini dapat menggambarkan banyak konsep yang berbeda, tetapi salah satunya sangat
menarik - yang mengacu pada pemrograman komputer.
Dalam bidang ini, rekursi adalah teknik di mana fungsi memanggil dirinya sendiri .
Dua kasus ini tampaknya menjadi yang terbaik untuk menggambarkan fenomena - faktorial
dan angka Fibonacci. Terutama yang terakhir.
Definisi angka-angka Fibonacci adalah contoh jelas rekursi . Kami sudah memberi tahu Anda
bahwa:
Fib i = Fib i-1 + Fib i-2
Definisi dari i th jumlah mengacu pada jumlah i-1, dan seterusnya, sampai Anda mencapai dua
yang pertama.
Bisakah itu digunakan dalam kode? Ya bisa. Itu juga dapat membuat kode lebih pendek dan
lebih jelas.
Versi kedua dari fib()fungsi kami menggunakan langsung definisi ini:

def fib(n): if n < 1: return None if n < 3: return 1 return fib(n - 1) + fib(n - 2)
Kode jauh lebih jelas sekarang.

Tetapi apakah ini benar-benar aman? Apakah itu mengandung risiko?
Ya, memang ada sedikit risiko. Jika Anda lupa untuk mempertimbangkan kondisi yang dapat
menghentikan rantai doa rekursif, program dapat memasuki loop tak terbatas . Kamu harus
Berhati-hati.
Faktorial memiliki sisi rekursifkedua juga. Melihat:

n! = 1 × 2 × 3 × ... × n-1 × n
Sudah jelas bahwa:

1 × 2 × 3 × ... × n-1 = (n-1)!
Jadi, akhirnya, hasilnya adalah:

n! = (n-1)! × n
Ini sebenarnya resep siap untuk solusi baru kami.
Ini dia:
def factorialFun(n): if n < 0: return None if n < 2: return 1 return n * factorialFun(n - 1)
Apakah itu bekerja? Ya, benar. Cobalah sendiri.
Perjalanan fungsional singkat kami hampir berakhir. Bagian selanjutnya akan menangani dua
tipe data Python yang ingin tahu: tuple dan kamus.
29
Takeaways kunci
1. Suatu fungsi dapat memanggil fungsi lain atau bahkan dirinya sendiri. Ketika suatu fungsi
memanggil dirinya sendiri, situasi ini dikenal sebagai rekursi , dan fungsi yang memanggil dirinya
sendiri dan berisi kondisi terminasi yang ditentukan (yaitu, kasus dasar - suatu kondisi yang tidak
memberi tahu fungsi untuk melakukan panggilan lebih jauh ke fungsi itu) disebut fungsi rekursif .
2. Anda dapat menggunakan fungsi rekursif dalam Python untuk menulis kode yang bersih dan
elegan, dan membaginya menjadi potongan yang lebih kecil dan terorganisir . Di sisi lain, Anda
harus sangat berhati-hati karena mungkin mudah membuat kesalahan dan membuat fungsi
yang tidak pernah berakhir . Anda juga perlu ingat bahwa panggilan rekursif menghabiskan
banyak memori , dan karenanya terkadang tidak efisien.
Saat menggunakan rekursi, Anda harus mempertimbangkan semua kelebihan dan
kekurangannya.
Fungsi faktorial adalah contoh klasik tentang bagaimana konsep rekursi dapat dipraktikkan:
# Recursive implementation of the factorial function def factorial(n): if n == 1: # the base case
(termination condition) return 1 else: return n * factorial(n - 1) print(factorial(4)) # 4 * 3 * 2 * 1 = 24
Latihan 1
Apa yang akan terjadi ketika Anda mencoba menjalankan cuplikan berikut dan mengapa?
def factorial(n): return n * factorial(n - 1) print(factorial(4))
Memeriksa
Fungsi faktorial tidak memiliki kondisi terminasi (tidak ada kasus dasar) sehingga Python akan
melempar pengecualian ( RecursionError: maximum recursion depth exceeded)
Latihan 2
def fun(a): if a > 30: return 3 else: return a + fun(a + 3) print(fun(25))
Memeriksa
56
30
4.1.6.1 Tuple dan kamus
Jenis urutan dan mutabilitas

Sebelum kita mulai berbicara tentang tupel dan kamus , kita harus memperkenalkan dua
konsep penting: tipe urutan dan mutabilitas .
Sebuah jenis urutan adalah jenis data dalam Python yang mampu menyimpan lebih dari satu
nilai (atau kurang dari satu, sebagai urutan mungkin kosong), dan nilai-nilai ini dapat berurutan
(maka nama) diakses , elemen dengan elemen.
Karena forloop adalah alat yang dirancang khusus untuk beralih melalui urutan, kita dapat
mengekspresikan definisi sebagai: urutan adalah data yang dapat dipindai oleh forloop .
Anda telah menemukan satu urutan Python sejauh ini - daftar. Daftar ini adalah contoh klasik
dari urutan Python, meskipun ada beberapa urutan lain yang layak disebutkan, dan kami akan
menyajikannya kepada Anda sekarang.
Gagasan kedua - mutabilitas - adalah properti dari setiap data Python yang menggambarkan
kesiapannya untuk diubah secara bebas selama eksekusi program. Ada dua jenis data
Python: bisa berubah dan tidak berubah .
Data yang dapat berubah dapat diperbarui secara bebas kapan saja - kami menyebutnya
operasi di tempat.
In situ adalah frasa Latin yang diterjemahkan secara literal dalam posisi . Misalnya, instruksi
berikut mengubah data di tempat:
list.append(1)
Data yang tidak dapat diubah tidak dapat dimodifikasi dengan cara ini .
Bayangkan sebuah daftar hanya dapat ditugaskan dan dibaca. Anda tidak dapat
menambahkan elemen ke dalamnya, atau menghapus elemen apa pun darinya. Ini berarti
bahwa menambahkan elemen ke akhir daftar akan memerlukan rekreasi daftar dari awal.
Anda harus membuat daftar yang benar-benar baru, yang terdiri dari semua elemen dari
daftar yang sudah ada, ditambah elemen baru.
Tipe data yang ingin kami beri tahu sekarang adalah tuple . Sebuah tuple adalah tipe urutan
yang tidak berubah . Itu bisa berperilaku seperti daftar, tetapi tidak boleh dimodifikasi in situ.
Apa itu tuple?

Perbedaan pertama dan paling jelas antara daftar dan tupel adalah sintaks yang digunakan
untuk membuatnya - tupel lebih suka menggunakan tanda kurung , sedangkan daftar suka
melihat tanda kurung, meskipun juga memungkinkan untuk membuat tuple hanya dari
serangkaian nilai yang dipisahkan oleh koma .
Lihat contohnya:
tuple1 = (1, 2, 4, 8) tuple2 = 1., .5, .25, .125
Ada dua tupel, keduanya mengandung empat elemen .

Mari kita cetak:
print(tuple1) print(tuple2)
Inilah yang harus Anda lihat di konsol:

(1, 2, 4, 8) (1.0, 0.5, 0.25, 0.125)
Catatan: setiap elemen tuple mungkin dari tipe yang berbeda (floating-point, integer, atau
jenis data lain yang belum diperkenalkan).
Bagaimana cara membuat tuple?
Dimungkinkan untuk membuat tuple kosong - tanda kurung diperlukan kemudian:
emptyTuple = ()
31
Jika Anda ingin membuat tupel satu elemen , Anda harus mempertimbangkan fakta bahwa,
karena alasan sintaks (tuple harus dapat dibedakan dari nilai tunggal, biasa), Anda harus
mengakhiri nilainya dengan koma:
oneElementTuple1 = (1, ) oneElementTuple2 = 1.,
Menghapus koma tidak akan merusak program dalam arti sintaksis apa pun, tetapi Anda akan
mendapatkan dua variabel tunggal, bukan tupel.
4.1.6.2 Kamus dan kamus
Bagaimana cara menggunakan tuple?

Jika Anda ingin mendapatkan elemen tuple untuk membacanya, Anda dapat menggunakan
konvensi yang sama dengan yang Anda terbiasa saat menggunakan daftar.
Program harus menghasilkan output berikut - jalankan dan periksa:
1 1000 (10, 100, 1000) (1, 10) 1 10 100 1000
Persamaannya mungkin menyesatkan - jangan coba-coba memodifikasi konten tuple ! Itu

bukan daftar!
Semua instruksi ini (kecuali yang paling atas) akan menyebabkan kesalahan runtime:
myTuple = (1, 10, 100, 1000) myTuple.append(10000) del myTuple[0] myTuple[1] = -10
Ini adalah pesan yang akan diberikan Python di jendela konsol:

AttributeError: 'tuple' object has no attribute 'append'
Cara menggunakan tuple: lanjutan

Apa lagi yang bisa dilakukan tuple untuk Anda?
 yang len()fungsi menerima tupel, dan mengembalikan jumlah unsur yang terkandung di
dalamnya;
 yang +operator dapat bergabung tupel bersama-sama (kami telah menunjukkan Anda
ini sudah)
 yang *operator dapat berkembang biak tupel, seperti daftar;
 yang indan not inoperator bekerja dengan cara yang sama seperti di daftar.
Cuplikan dalam editor menyajikan semuanya.
Outputnya akan terlihat sebagai berikut:
9 (1, 10, 100, 1000, 10000) (1, 10, 100, 1, 10, 100, 1, 10, 100) True True
32
Salah satu properti tuple yang paling berguna adalah kemampuannya untuk muncul di sisi kiri
operator penugasan . Anda melihat fenomena ini beberapa waktu lalu, ketika itu diperlukan
untuk menemukan alat yang elegan untuk menukar nilai dua variabel.
Lihatlah potongan di bawah ini:
var = 123 t1 = (1, ) t2 = (2, ) t3 = (3, var) t1, t2, t3 = t2, t3, t1 print(t1, t2, t3)
Ini menunjukkan tiga tuple berinteraksi - efeknya, nilai-nilai yang tersimpan di dalamnya
"bersirkulasi" - t1menjadi t2, t2menjadi t3, dan t3menjadi t1.
Catatan: contoh menyajikan satu fakta penting: elemen tuple dapat berupa variabel , bukan
hanya literal. Selain itu, mereka dapat menjadi ekspresi jika mereka berada di sisi kanan
operator penugasan.
Apa itu kamus?

The kamus adalah struktur data Python lain. Ini bukan tipe urutan (tetapi dapat dengan mudah
disesuaikan dengan pemrosesan urutan) dan dapat diubah .
Untuk menjelaskan apa sebenarnya kamus Python, penting untuk dipahami bahwa itu adalah
kamus.
Kamus Python bekerja dengan cara yang sama seperti kamus dwibahasa . Misalnya, Anda
memiliki kata bahasa Inggris (misalnya, kucing) dan memerlukan padanan bahasa
Prancisnya. Anda menjelajah kamus untuk menemukan kata (Anda dapat menggunakan
teknik berbeda untuk melakukannya - tidak masalah) dan akhirnya Anda
mendapatkannya. Selanjutnya, Anda memeriksa mitra bahasa Prancis dan itu kemungkinan
besar adalah kata "obrolan".
Di dunia Python, kata yang Anda cari bernama a key. Kata yang Anda dapatkan dari kamus
disebut a value.
Ini berarti bahwa kamus adalah seperangkat pasangan nilai kunci . catatan:
33
 setiap kunci harus unik - tidak mungkin memiliki lebih dari satu kunci dengan nilai yang
sama;
 kunci dapat berupa data dari jenis apa pun : mungkin berupa angka (bilangan bulat
atau float), atau bahkan string;
 kamus bukan daftar - daftar berisi sekumpulan nilai bernomor, sementara kamus
menyimpan pasangan nilai ;
 yang len()fungsi bekerja untuk kamus, juga - ia mengembalikan jumlah elemen kunci-
nilai dalam kamus;
 kamus adalah alat satu arah - jika Anda memiliki kamus Bahasa Inggris-Bahasa Prancis,
Anda dapat mencari padanan kata dalam Bahasa Inggris yang setara dengan bahasa
Prancis, tetapi tidak sebaliknya.
Sekarang kami dapat menunjukkan beberapa contoh yang berfungsi.
Bagaimana cara membuat kamus?

Jika Anda ingin menetapkan beberapa pasangan awal ke kamus, Anda harus menggunakan
sintaks berikut:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} phoneNumbers = {'boss' : 5551234567,
'Suzy' : 22657854310} emptyDictionary = {} print(dict) print(phoneNumbers)
print(emptyDictionary)
Dalam contoh pertama, kamus menggunakan kunci dan nilai yang keduanya merupakan
string. Dalam yang kedua, kunci adalah string, tetapi nilainya adalah integer. Tata letak terbalik
(tombol → angka, nilai → string) juga dimungkinkan, serta kombinasi angka-angka.
Daftar pasangan dikelilingi oleh kurung kurawal , sementara pasangan itu sendiri dipisahkan
oleh koma , dan kunci dan nilai oleh titik dua .
Kamus pertama kami adalah kamus Inggris-Perancis yang sangat sederhana. Yang kedua -
direktori telepon yang sangat kecil.
Kamus kosong dibangun oleh sepasang kurung kurawal yang kosong - tidak ada yang aneh.
Kamus secara keseluruhan dapat dicetak dengan

satu print()permintaan. Cuplikan dapat menghasilkan output berikut:
{'dog': 'chien', 'horse': 'cheval', 'cat': 'chat'} {'Suzy': 5557654321, 'boss': 5551234567} {}
Pernahkah Anda memperhatikan sesuatu yang mengejutkan? Urutan pasangan tercetak

berbeda dari pada penugasan awal. Apa artinya?
Pertama-tama, ini adalah konfirmasi bahwa kamus bukan daftar - kamus tidak
mempertahankan urutan data mereka, karena urutannya sama sekali tidak berarti (tidak
seperti kamus kertas yang sebenarnya). Urutan di mana kamus menyimpan datanya
sepenuhnya di luar kendali Anda , dan harapan Anda. Itu normal. (*)
CATATAN
(*) Dalam kamus Python 3.6x telah menjadi koleksi yang dipesan secara default. Hasil Anda
dapat bervariasi tergantung pada versi Python apa yang Anda gunakan.
4.1.6.5 Tupel dan kamus
Bagaimana cara menggunakan kamus?

Jika Anda ingin mendapatkan salah satu nilai, Anda harus memberikan nilai kunci yang valid:
print(dict['cat']) print(phoneNumbers['Suzy'])
Mendapatkan nilai kamus menyerupai pengindeksan, terutama berkat tanda kurung yang
mengelilingi nilai kunci.
catatan:
 jika kuncinya adalah string, Anda harus menentukannya sebagai string;
 kunci adalah case-sensitive : 'Suzy'adalah sesuatu yang berbeda dari 'suzy'.
Cuplikan menghasilkan dua baris teks:
34
chat 5557654321
Dan sekarang berita paling penting: Anda tidak boleh menggunakan kunci yang tidak
ada . Mencoba sesuatu seperti ini:
print(phoneNumbers['president'])
akan menyebabkan kesalahan runtime. Coba untuk melakukannya.
Untungnya, ada cara sederhana untuk menghindari situasi seperti itu. The inoperator, bersama
dengan pendamping nya, not in, bisa menyelamatkan situasi ini.
Kode berikut dengan aman mencari beberapa kata bahasa Prancis:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} words = ['cat', 'lion', 'horse'] for word in
words: if word in dict: print(word, "->", dict[word]) else: print(word, "is not in dictionary")
Output kode terlihat sebagai berikut:

cat -> chat lion is not in dictionary horse -> cheval
4.1.6.6 Kamus dan kamus | metode
Cara menggunakan kamus: tombol ()

Bisakah kamus dijelajahimenggunakan forloop, seperti daftar atau tupel?
Tidak dan ya.
Tidak, karena kamus bukan tipe urutan - forloop tidak berguna dengan itu.
Ya, karena ada alat sederhana dan sangat efektif yang dapat mengadaptasi kamus apa pun
dengan forpersyaratan loop(dengan kata lain, membangun tautan perantara antara kamus
dan entitas urutan sementara).
Yang pertama adalah metode yang dinamai keys(), dimiliki oleh masing-masing
kamus. Metode mengembalikan daftar yang dibangun dari semua kunci yang dikumpulkan
dalam kamus . Memiliki daftar kunci memungkinkan Anda untuk mengakses seluruh kamus
dengan cara yang mudah dan praktis.
Sama seperti di sini:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} for key in dict.keys(): print(key, "->",
dict[key]
Output kode terlihat sebagai berikut:

horse -> cheval dog -> chien cat -> chat
The diurutkan () function

Apakah Anda ingin diurutkan ? Cukup perkaya forloop untuk mendapatkan formulir seperti itu:
for key in sorted(dict.keys()):
The sorted()fungsi akan melakukan yang terbaik - output akan terlihat seperti ini:
cat -> chat dog -> chien horse -> cheval
4.1.6.7 Tupel dan kamus | metode
Cara menggunakan kamus: The item () dan nilai-nilai ()metode

Cara lain didasarkan pada penggunaan metode kamus
bernama items(). Metode mengembalikan daftar tupel (ini adalah contoh pertama di mana
tupel adalah sesuatu yang lebih dari sekadar contohnya sendiri) di mana setiap tupel adalah
pasangan nilai-kunci .
Begini Cara kerjanya:
35
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} for english, french in dict.items():
print(english, "->", french)
Perhatikan cara tuple digunakan sebagai forvariabel loop.

Contoh mencetak:
cat -> chat dog -> chien horse -> cheval
Ada juga metode yang dinamai values(), yang berfungsi serupa dengan keys(),
tetapi mengembalikan daftar nilai .
Ini adalah contoh sederhana:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} for french in dict.values(): print(french)
Karena kamus tidak dapat secara otomatis menemukan kunci untuk nilai yang diberikan, peran
metode ini agak terbatas.
Inilah output yang diharapkan:
cheval
chien
chat
Cara menggunakan kamus: memodifikasi dan menambahkan nilai

Menetapkan nilai baru ke kunci yang ada sederhana - karena kamus sepenuhnya dapat
berubah , tidak ada kendala untuk memodifikasi mereka.
Kita akan mengganti nilainya "chat"dengan "minou", yang tidak terlalu akurat, tetapi itu akan
bekerja dengan baik dengan contoh kita.
Melihat:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} dict['cat'] = 'minou' print(dict)
Outputnya adalah:
{'dog': 'chien', 'horse': 'cheval', 'cat': 'minou'}
Menambahkan kunci baru

Menambahkan pasangan nilai kunci baru ke kamus semudah mengubah nilai - Anda hanya
perlu menetapkan nilai ke kunci baru yang sebelumnya tidak ada .
Catatan: ini adalah perilaku yang sangat berbeda dibandingkan dengan daftar, yang tidak
memungkinkan Anda untuk menetapkan nilai ke indeks yang tidak ada.
Mari menambahkan pasangan kata baru ke kamus - agak aneh, tetapi masih valid:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} dict['swan'] = 'cygne' print(dict)
Contoh output:
{'swan': 'cygne', 'horse': 'cheval', 'dog': 'chien', 'cat': 'chat'}
TAMBAHAN
Anda juga dapat memasukkan item ke kamus dengan menggunakan update()metode ini,
misalnya:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} dict.update({"duck" : "canard"}) print(dict)
Menghapus kunci
Bisakah Anda menebak cara menghapus kunci dari kamus?
Catatan: menghapus kunci akan selalu menyebabkan penghapusan nilai terkait . Nilai tidak
bisa ada tanpa kunci mereka .
Ini dilakukan dengan delinstruksi.
Inilah contohnya:
36
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} del dict['dog'] print(dict)
Catatan: menghapus kunci yang tidak ada menyebabkan kesalahan .

Contoh output:
{'cat': 'chat', 'horse': 'cheval'}
TAMBAHAN
Untuk menghapus item terakhir dalam kamus, Anda dapat menggunakan popitem()metode
ini:
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"} dict.popitem() print(dict) # outputs: {'cat' :
'chat', 'dog' : 'chien'}
Dalam versi Python yang lebih lama, yaitu, sebelum 3.6.7, popitem()metode menghapus item
acak dari kamus.
Kamus dan kamus dapat bekerja bersama

Kami telah menyiapkan contoh sederhana, menunjukkan bagaimana tupel dan kamus dapat
bekerja bersama.
Mari kita bayangkan masalah berikut:
 Anda memerlukan program untuk mengevaluasi nilai rata-rata siswa;
 program harus menanyakan nama siswa, diikuti dengan nilai tunggalnya;
 nama dapat dimasukkan dalam urutan apa pun;
 memasukkan nama kosong menyelesaikan input data;
 daftar semua nama, bersama dengan skor rata-rata yang dievaluasi, harus kemudian
dipancarkan.
Lihatlah kode di editor. Ini cara melakukannya.
Sekarang, mari kita menganalisanya baris demi baris:
 baris 1 : buat kamus kosong untuk data input; nama siswa digunakan sebagai kunci,
sementara semua skor yang terkait disimpan dalam tuple (tuple mungkin merupakan
nilai kamus - itu bukan masalah sama sekali)
 baris 3 : masukkan loop "tak terbatas" (jangan khawatir, itu akan rusak pada saat yang
tepat)
 baris 4 : baca nama siswa di sini;
 baris 5-6 : jika namanya exit, biarkan loop;
 baris 8 : mintalah salah satu nilai siswa (bilangan bulat dari rentang 1-10)
 baris 10-11 : jika nama siswa sudah ada di kamus, perpanjang tuple terkait dengan skor
baru (perhatikan operator + =)
 baris 12-13 : jika ini adalah siswa baru (tidak dikenal dalam kamus), buat entri baru -
nilainya adalah tupel satu elemen yang berisi skor yang dimasukkan;
 baris 15 : beralih melalui nama-nama siswa yang diurutkan;
 baris 16-17 : inisialisasi data yang diperlukan untuk mengevaluasi rata-rata (jumlah dan
penghitung)
 baris 18-20 : kita beralih melalui tuple, mengambil semua skor berikutnya dan
memperbarui jumlahnya, bersama dengan penghitung;
 baris 21 : mengevaluasi dan mencetak nama siswa dan skor rata-rata.
Ini adalah catatan percakapan yang kami lakukan dengan program kami:
Enter the student's name and press Enter to stop: Bob Enter the student's score (0-10): 7 Enter the
student's name (or type exit to stop): Andy Enter the student's score (0-10): 3 Enter the student's
name (or type exit to stop): Bob Enter the student's score (0-10): 2 Enter the student's name (or
type exit to stop): Andy Enter the student's score (0-10): 10 Enter the student's name (or type exit
to stop): Andy Enter the student's score (0-10): 3 Enter the student's name (or type exit to stop):
Bob Enter the student's score (0-10): 9 Enter the student's name (or type exit to stop): Andy :
5.333333333333333 Bob : 6.0
37
4.1.6.10 RINGKASAN BAGIAN (1/3)
Kunci takeaways: tuple
1. Tuple diperintahkan dan koleksi tidak berubah (kekal) data. Mereka dapat dianggap
sebagai daftar abadi. Mereka ditulis dalam kurung bulat:
myTuple = (1, 2, True, "a string", (3, 4), [5, 6], None) print(myTuple) myList = [1, 2, True, "a string", (3,
4), [5, 6], None] print(myList)
Setiap elemen tuple mungkin dari tipe yang berbeda (yaitu, bilangan bulat, string, boolean,
dll.). Terlebih lagi, tuple dapat berisi tuple atau daftar lainnya (dan sebaliknya).
2. Anda dapat membuat tuple kosong seperti ini:
emptyTuple = () print(type(emptyTuple)) # outputs: <class 'tuple'>
3. Sebuah tupel satu elemen dapat dibuat sebagai berikut:

oneElemTup1 = ("one", ) # brackets and a comma oneElemTup2 = "one", # no brackets, just a
comma
Jika Anda menghapus koma, Anda akan memberi tahu Python untuk membuat variabel,
bukan tuple:
myTup1 = 1, print(type(myTup1)) # outputs: <class 'tuple'> myTup2 = 1 print(type(myTup2)) #
outputs: <class 'int'>
4. Anda dapat mengakses elemen tuple dengan mengindeksnya:

myTuple = (1, 2.0, "string", [3, 4], (5, ), True) print(myTuple[3]) # outputs: [3, 4]
5. Tuple tidak dapat diubah, artinya Anda tidak dapat mengubah elemennya (Anda tidak
dapat menambahkan tupel, atau memodifikasi, atau menghapus elemen tuple). Cuplikan
berikut akan menyebabkan pengecualian:
myTuple = (1, 2.0, "string", [3, 4], (5, ), True) myTuple[2] = "guitar" # a TypeError exception will be
raised
Namun, Anda dapat menghapus tuple secara keseluruhan:

myTuple = 1, 2, 3, del myTuple print(myTuple) # NameError: name 'myTuple' is not defined
6. Anda dapat mengulang melalui elemen tuple (Contoh 1), memeriksa apakah elemen
tertentu (tidak) ada dalam tupel (Contoh 2), gunakan len()fungsi ini untuk memeriksa berapa
38
banyak elemen yang ada dalam tupel (Contoh 3), atau bahkan bergabung / gandakan tupel
(Contoh 4):
# Example 1 t1 = (1, 2, 3) for elem in t1: print(elem) # Example 2 t2 = (1, 2, 3, 4) print(5 in t2)
print(5 not in t2) # Example 3 t3 = (1, 2, 3, 5) print(len(t3)) # Example 4 t4 = t1 + t2 t5 = t3 * 2
print(t4) print(t5)
TAMBAHAN
Anda juga dapat membuat tupel menggunakan fungsi bawaan Python yang
disebut tuple(). Ini sangat berguna ketika Anda ingin mengonversi iterable tertentu (misalnya,
daftar, rentang, string, dll.) Ke tuple:
myTup = tuple((1, 2, "string")) print(myTup) lst = [2, 4, 6] print(lst) # outputs: [2, 4, 6] print(type(lst))
# outputs: <class 'list'> tup = tuple(lst) print(tup) # outputs: (2, 4, 6) print(type(tup)) # outputs:
<class 'tuple'>
Dengan cara yang sama, saat Anda ingin mengonversi iterable ke daftar, Anda bisa
menggunakan fungsi bawaan Python yang disebut list():
tup = 1, 2, 3, lst = list(tup) print(type(lst)) # outputs: <class 'list'>
Kunci takeaways: kamus
1. Kamus tidak berurutan * , dapat diubah (dapat diubah), dan koleksi data yang
diindeks. ( * Dalam kamus Python 3.6x telah dipesan secara default.
Setiap kamus adalah serangkaian kunci: pasangan nilai . Anda dapat membuatnya dengan
menggunakan sintaks berikut:
myDictionary = { key1 : value1, key2 : value2, key3 : value3, }
2. Jika Anda ingin mengakses item kamus, Anda dapat melakukannya dengan membuat
referensi ke kuncinya di dalam sepasang kurung kotak (mis. 1) atau dengan
menggunakan get()metode (mis. 2):
polEngDict = { "kwiat" : "flower", "woda" : "water", "gleba" : "soil" } item1 = polEngDict["gleba"] #
ex. 1 print(item1) # outputs: soil item2 = polEngDict.get("woda") print(item2) # outputs: water
3. Jika Anda ingin mengubah nilai yang terkait dengan kunci tertentu, Anda dapat
melakukannya dengan merujuk ke nama kunci item dengan cara berikut:
polEngDict = { "zamek" : "castle", "woda" : "water", "gleba" : "soil" } polEngDict["zamek"] = "lock"
item = polEngDict["zamek"] # outputs: lock
4. Untuk menambah atau menghapus kunci (dan nilai terkait), gunakan sintaks berikut:
myPhonebook = {} # an empty dictionary myPhonebook["Adam"] = 3456783958 # create/add a
key-value pair print(myPhonebook) # outputs: {'Adam': 3456783958} del myPhonebook["Adam"]
print(myPhonebook) # outputs: {}
Anda juga dapat memasukkan item ke kamus dengan menggunakan update()metode, dan
menghapus elemen terakhir dengan menggunakan popitem()metode, misalnya:
polEngDict = {"kwiat" : "flower"} polEngDict = update("gleba" : "soil") print(polEngDict) # outputs:
{'kwiat' : 'flower', 'gleba' : 'soil'} polEngDict.popitem() print(polEngDict) # outputs: {'kwiat' :
'flower'}
5. Anda dapat menggunakan forloop untuk loop melalui kamus, misalnya:

polEngDict = { "zamek" : "castle", "woda" : "water", "gleba" : "soil" } for item in polEngDict:
print(item) # outputs: zamek # woda # gleba
39
6. Jika Anda ingin mengulang-ulang kunci dan nilai kamus, Anda dapat
menggunakan items()metode ini, misalnya:
polEngDict = { "zamek" : "castle", "woda" : "water", "gleba" : "soil" } for key, value in
polEngDict.items(): print("Pol/Eng ->", key, ":", value)
7. Untuk memeriksa apakah kunci yang diberikan ada dalam kamus, Anda dapat
menggunakan inkata kunci:
polEngDict = { "zamek" : "castle", "woda" : "water", "gleba" : "soil" } if "zamek" in polEngDict:
print("Yes") else: print("No")
8. Anda dapat menggunakan delkata kunci untuk menghapus item tertentu, atau menghapus
kamus. Untuk menghapus semua item kamus, Anda perlu menggunakan clear()metode ini:
polEngDict = { "zamek" : "castle", "woda" : "water", "gleba" : "soil" } print(len(polEngDict)) #
outputs: 3 del polEngDict["zamek"] # remove an item print(len(polEngDict)) # outputs: 2
polEngDict.clear() # removes all the items print(len(polEngDict)) # outputs: 0 del polEngDict #
removes the dictionary
9. Untuk menyalin kamus, gunakan copy()metode ini:

polEngDict = { "zamek" : "castle", "woda" : "water", "gleba" : "soil" } copyDict = polEngDict.copy()
Takeaways utama: tupel dan kamus
Latihan 1
Apa yang terjadi ketika Anda mencoba menjalankan cuplikan berikut?
myTup = (1, 2, 3) print(myTup[2])
Memeriksa
Program akan mencetak 3ke layar.
Latihan 2
tup = 1, 2, 3 a, b, c = tup print(a * b * c)
Memeriksa
Program akan mencetak 6ke layar. The tupelemen tupel telah "dibongkar" di a, b,
dan cvariabel.
Latihan 3
Lengkapi kode untuk menggunakan count()metode ini dengan benar untuk menemukan
jumlah duplikat 2dalam tuple berikut.
tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9 duplicates = # your code print(duplicates) # outputs: 4
Memeriksa
tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9 duplicates = tup.count(2) print(duplicates) # outputs: 4
Latihan 4
Tulis program yang akan "merekatkan" dua kamus ( d1dan d2) bersama-sama dan membuat
yang baru ( d3).
d1 = {'Adam Smith':'A', 'Judy Paxton':'B+'} d2 = {'Mary Louis':'A', 'Patrick White':'C'} d3 = {} for item
in (d1, d2): # your code print(d3)
Memeriksa
Solusi sampel:
d1 = {'Adam Smith':'A', 'Judy Paxton':'B+'} d2 = {'Mary Louis':'A', 'Patrick White':'C'} d3 = {} for item
in (d1, d2): d3.update(item) print(d3)
Latihan 5
40
Tulis program yang akan mengubah ldaftar menjadi tuple.
l = ["car", "Ford", "flower", "Tulip"] t = # your code print(t)
Memeriksa
Solusi sampel:
l = ["car", "Ford", "flower", "Tulip"] t = tuple(l) print(t)
Latihan 6
Tulis program yang akan mengonversi colorstuple ke kamus.
colors = (("green", "#008000"), ("blue", "#0000FF")) # your code print(colDict)
Memeriksa
Solusi sampel:
colors = (("green", "#008000"), ("blue", "#0000FF")) colDict = dict(colors) print(colDict)
Latihan 7
Apa yang akan terjadi ketika Anda menjalankan kode berikut?
myDict = {"A":1, "B":2} copyMyDict = myDict.copy() myDict.clear() print(copyMyDict)
Memeriksa
Program akan mencetak {'A': 1, 'B': 2}ke layar
Latihan 8
Apa output dari program berikut?
colors = { "white" : (255, 255, 255), "grey" : (128, 128, 128), "red" : (255, 0, 0), "green" : (0, 128, 0) } for
col, rgb in colors.items(): print(col, ":", rgb)
Memeriksa
white : (255, 255, 255) grey : (128, 128, 128) red : (255, 0, 0) green : (0, 128, 0)
4.1.6.13 PROYEK: Tic-Tac-Toe

PROYEK
Perkiraan waktu
30-60 menit
Tingkat kesulitan
Sedang / Keras
Tujuan
 menyempurnakan keterampilan siswa dalam menggunakan Python untuk
memecahkan masalah yang kompleks,
 integrasi teknik pemrograman dalam satu program yang terdiri dari berbagai bagian.
Skenario
Tugas Anda adalah menulis program sederhana yang berpura-pura bermain tic-tac-toedengan
pengguna . Untuk mempermudah Anda, kami telah memutuskan untuk menyederhanakan
permainan. Berikut adalah asumsi kami:
 komputer (yaitu, program Anda) harus memainkan game menggunakan 'X's;
 pengguna (misalnya, Anda) harus memainkan game menggunakan 'O's;
 langkah pertama adalah milik komputer - selalu menempatkan yang pertama 'X'di
tengah papan;
 semua kotak diberi nomor baris demi baris yang dimulai dengan 1(lihat sesi contoh di
bawah ini untuk referensi)
 pengguna memasukkan langkah mereka dengan memasukkan angka kuadrat yang
mereka pilih - angka harus valid, yaitu harus bilangan bulat, harus lebih besar dari 0dan
kurang dari 10, dan tidak bisa menunjuk ke bidang yang sudah ditempati;
 program memeriksa apakah permainan telah berakhir - ada empat kemungkinan vonis:
permainan harus dilanjutkan, atau permainan berakhir dengan seri, kemenangan Anda,
atau kemenangan komputer;
 komputer merespons dengan gerakannya dan pemeriksaan diulang;
 jangan menerapkan segala bentuk kecerdasan buatan - pilihan bidang acak yang
dibuat oleh komputer cukup baik untuk permainan.
41
Sesi contoh dengan program mungkin terlihat sebagai berikut:
Persyaratan
Terapkan fitur-fitur berikut:
 papan harus disimpan sebagai daftar tiga elemen, sementara masing-masing elemen
adalah daftar tiga elemen lain (daftar dalam mewakili baris) sehingga semua kotak
dapat diakses menggunakan sintaks berikut:
board[row][column]
 setiap elemen daftar dalam dapat berisi 'O',, 'X'atau digit yang mewakili nomor kuadrat
(kuadrat tersebut dianggap gratis)
 Penampilan papan harus persis sama dengan yang disajikan dalam contoh.
 mengimplementasikan fungsi yang didefinisikan untuk Anda di editor.
Menggambar angka integer acak dapat dilakukan dengan memanfaatkan fungsi Python yang
disebut randrange(). Contoh program di bawah ini menunjukkan cara menggunakannya
(program mencetak sepuluh angka acak dari 0 hingga 8).
Catatan: from-importinstruksi ini menyediakan akses ke randrangefungsi yang didefinisikan
dalam modul Python eksternal yang dipanggil random.
from random import randrange for i in range(10): print(randrange(8))
42
4.1.6.14 Penyelesaian Modul
Selamat! Anda telah menyelesaikan Modul 4.
Sudah selesai dilakukan dengan baik! Anda telah mencapai akhir Modul 4 dan menyelesaikan
tonggak utama dalam pendidikan pemrograman Python Anda. Berikut ini ringkasan singkat
dari tujuan yang telah Anda bahas dan ketahui dalam Modul 4:
 mendefinisikan dan menggunakan fungsi - alasan, tujuan, konvensi, dan perangkap
mereka;
 konsep meneruskan argumen dengan cara yang berbeda dan menetapkan nilai
defaultnya, bersama dengan mekanisme pengembalian hasil fungsi;
 masalah cakupan nama;
 agregat data baru: tupel dan kamus, dan perannya dalam pemrosesan data.
Anda sekarang siap untuk mengikuti kuis modul dan mencoba tantangan terakhir: Modul 4 Tes,
yang akan membantu Anda mengukur apa yang telah Anda pelajari sejauh ini.
43

Modul 4

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Modul 4

Diunggah oleh

Hak Cipta:

Format Tersedia

4.1.1.

1 Python Essentials: Modul 4

Fungsi pertama Anda

4.1.1.5 Fungsi penulisan

 Itu selalu dimulai dengan kata kuncidef (untuk didefinisikan )

Kode kami berisi definisi fungsi sekarang:

Outputnya terlihat berbeda sekarang:

Uji kodenya, modifikasi, eksperimen dengan itu.

Mencoba menunjukkan seluruh proses:

Menetapkan nilai pada pesan nama menyebabkan Python melupakan peran

4.1.1.7 RINGKASAN BAGIAN

a) fungsi yang ditetapkan pengguna

4.1.2.1 How functions communicate with their environment

We have to rebuild the def statement - this is how it looks now:

4.1.2.2 How functions communicate with their environment

Parametrized functions: continued

This looks better, for sure:

We have to make you sensitive to one important circumstance.

A situation like this activates a mechanism called shadowing:

Parametrized functions: continued

Let's modify the function - it has two parameters now:

This is the output you're about to see:

4.1.2.4 How functions communicate with their environment

Positional parameter passing

The output will look different. Can you guess it?

4.1.2.5 How functions communicate with their environment

Keyword argument passing

Of course, you mustn't use a non-existent parameter name.

This is what Python will tell you:

Try it out yourself.

Mixing positional and keyword arguments

It was - as you may suspect - a pure example of positional argument passing.

Our program will output a line like this:

Note the order of the values.

Let's try to mix both styles now.

Let's analyze it:

4.1.2.7 How functions communicate with their environment

Parametrized functions - more details

This makes the following invocation absolutely valid:

And this is the expected output:

The output is:

4.1.2.8 RINGKASAN BAGIAN

Contoh fungsi dua parameter:

Contoh fungsi tiga parameter:

2. Anda bisa meneruskan argumen ke suatu fungsi menggunakan teknik berikut:

4.1.3.1 Mengembalikan hasil dari suatu fungsi

Efek dan hasil: instruksi pengembalian

Mari kita pertimbangkan fungsi berikut:

Ketika dipanggil tanpa argumen:

Fungsi menyebabkan sedikit noise - output akan terlihat seperti ini:

Memberikan Falsesebagai argumen:

akan mengubah perilaku fungsi - returninstruksi akan menyebabkan penghentiannya tepat

kembali dengan sebuah ekspresi

Ada dua konsekuensi dari menggunakannya:

Cuplikan menulis teks berikut ke konsol:

Mari kita selidiki sebentar.

Program menghasilkan output sebagai berikut:

Apakah bisa dihukum? Tidak semuanya.

4.1.3.2 Mengembalikan hasil dari suatu fungsi

Beberapa kata tentang None

Catatan: Noneadalah kata kunci .

4.1.3.3 Mengembalikan hasil dari suatu fungsi

Beberapa kata tentang None : lanjutan

Inilah yang kami lihat di konsol: