Functions

• Fungsi adalah blok kode yang hanya berjalan ketika dipanggil.

• Fungsi dapat mengembalikan data sebagai hasilnya.

• Fungsi membantu menghindari pengulangan kode.

Python Functions

Membuat Fungsi

Dalam Python, sebuah fungsi didefinisikan menggunakan kata kunci def, diikuti dengan nama fungsi dan tanda kurung:

def greet():

print("Hello from a function")

Ini menciptakan fungsi bernama my_function yang mencetak "Hello!" saat dipanggil.

Catatan

Kode di dalam fungsi harus menjorok. Python menggunakan indentasi untuk mendefinisikan blok kode.

Memanggil Fungsi

Untuk memanggil suatu fungsi, tuliskan namanya diikuti tanda kurung:

def my_function():
  print("Hello from a function")

my_function()

Anda dapat memanggil fungsi yang sama beberapa kali:

def my_function():
  print("Hello from a function")

my_function()
my_function()
my_function()

Nama Fungsi

Nama fungsi mengikuti aturan yang sama dengan nama variabel dalam Python:

• Nama fungsi harus dimulai dengan huruf atau garis bawah

• Nama fungsi hanya boleh berisi huruf, angka, dan garis bawah

• Nama fungsi peka huruf besar-kecil (myFunction dan myfunction berbeda)

# Valid function names:

calculate_sum()
_private_function()
myFunction2()

Tip

Merupakan praktik yang baik untuk menggunakan nama deskriptif yang menjelaskan fungsi apa yang dilakukan.

Mengapa Menggunakan Fungsi?

Bayangkan Anda perlu mengonversi suhu dari Fahrenheit ke Celsius beberapa kali dalam program Anda. Tanpa fungsi, Anda harus menulis kode perhitungan yang sama berulang kali:

# Without functions - repetitive code:

temp1 = 77
celsius1 = (temp1 - 32) * 5 / 9
print(celsius1)

temp2 = 95
celsius2 = (temp2 - 32) * 5 / 9
print(celsius2)

temp3 = 50
celsius3 = (temp3 - 32) * 5 / 9
print(celsius3)


# With functions - reusable code:

def fahrenheit_to_celsius(fahrenheit):
  return (fahrenheit - 32) * 5 / 9

print(fahrenheit_to_celsius(77))
print(fahrenheit_to_celsius(95))
print(fahrenheit_to_celsius(50))

Nilai Kembalian

Fungsi dapat mengirimkan data kembali ke kode yang memanggilnya menggunakan pernyataan return.

Ketika suatu fungsi mencapai pernyataan return, ia berhenti mengeksekusi dan mengirimkan kembali hasilnya:

# A function that returns a value:

def get_greeting():
  return "Hello from a function"

message = get_greeting()
print(message)

Anda dapat menggunakan nilai yang dikembalikan secara langsung:

# Using the return value directly:

def get_greeting():
  return "Hello from a function"

print(get_greeting())

Catatan

Jika suatu fungsi tidak memiliki pernyataan return, ia akan mengembalikan None secara default.

pass Statement

Definisi fungsi tidak boleh kosong. Jika Anda perlu membuat placeholder fungsi tanpa kode apa pun, gunakan pernyataan pass:

def my_function():
  pass

Pernyataan pass kerap digunakan saat pengembangan, yang memungkinkan Anda menentukan strukturnya terlebih dahulu dan mengimplementasikan detailnya kemudian.

Arguments

• Informasi dapat diteruskan ke fungsi sebagai argumen.

• Argumen ditentukan setelah nama fungsi, di dalam tanda kurung. Anda dapat menambahkan argumen sebanyak yang Anda inginkan, cukup pisahkan dengan koma.

• Contoh berikut memiliki fungsi dengan satu argumen (fname). Ketika fungsi dipanggil, kita meneruskan nama depan, yang digunakan di dalam fungsi untuk mencetak nama lengkapnya:

# A function with one argument:

def my_function(fname):
  print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")

Parameters vs Arguments

Istilah parameter dan argumen dapat digunakan untuk hal yang sama: informasi yang diteruskan ke suatu fungsi.

Catatan

Dari perspektif fungsi: - Parameter adalah variabel yang tercantum di dalam tanda kurung dalam definisi fungsi. - Argumen adalah nilai aktual yang dikirimkan ke fungsi ketika dipanggil.

def my_function(name): # name is a parameter
  print("Hello", name)

my_function("Emil") # "Emil" is an argument

Number of Arguments

Secara default, suatu fungsi harus dipanggil dengan jumlah argumen yang tepat.

Jika fungsi Anda membutuhkan 2 argumen, Anda harus memanggilnya dengan tepat 2 argumen.

# This function expects 2 arguments, and gets 2 arguments::

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil", "Refsnes")

Jika Anda mencoba memanggil fungsi dengan jumlah argumen yang salah, Anda akan mendapatkan kesalahan:

Default Parameter Values

Anda dapat menetapkan nilai default ke parameter. Jika fungsi dipanggil tanpa argumen, fungsi tersebut akan menggunakan nilai default:

def my_function(name = "friend"):
  print("Hello", name)

my_function("Emil")
my_function("Tobias")
my_function()
my_function("Linus")

Keyword Arguments

Anda dapat mengirim argumen dengan sintaksis kunci = nilai.

def my_function(animal, name):
  print("I have a", animal)
  print("My", animal + "'s name is", name)

my_function(animal = "dog", name = "Buddy")

Dengan cara ini, dengan argumen kata kunci, urutan argumen tidak menjadi masalah.

my_function(name = "Buddy", animal = "dog")

Positional Arguments

Ketika Anda memanggil fungsi dengan argumen tanpa menggunakan kata kunci, argumen tersebut disebut argumen posisional.

Argumen posisional harus dalam urutan yang benar:

Mixing Positional and Keyword Arguments

Anda dapat mencampur argumen posisi dan kata kunci dalam pemanggilan fungsi.

Namun, argumen posisi harus diletakkan sebelum argumen kata kunci:

def my_function(animal, name, age):
  print("I have a", age, "year old", animal, "named", name)

my_function("dog", name = "Buddy", age = 5)

Passing Different Data Types

Anda dapat mengirimkan tipe data apa pun sebagai argumen ke suatu fungsi (string, angka, list, dictionary, dll.).

Tipe data akan dipertahankan di dalam fungsi:

# Sending a list as an argument:

def my_function(fruits):

for fruit in fruits:

print(fruit)

my_fruits = ["apple", "banana", "cherry"] my_function(my_fruits)

# Sending a dictionary as an argument:

def my_function(person):

print("Name:", person["name"]) print("Age:", person["age"])

my_person = {"name": "Emil", "age": 25} my_function(my_person)

Return Values

Fungsi dapat mengembalikan nilai menggunakan pernyataan return:

def my_function(x, y):
  return x + y

result = my_function(5, 3)
print(result)

Returning Different Data Types

Fungsi dapat mengembalikan tipe data apa pun, termasuk daftar, tupel, kamus, dan banyak lagi.

# A function that returns a list:

def my_function():
  return ["apple", "banana", "cherry"]

fruits = my_function()
print(fruits[0])
print(fruits[1])
print(fruits[2])


# A function that returns a tuple:

def my_function():
  return (10, 20)

x, y = my_function()
print("x:", x)
print("y:", y)

Positional-Only Arguments

Anda dapat menentukan bahwa suatu fungsi HANYA boleh memiliki argumen posisional.

Untuk menentukan argumen posisional saja, tambahkan , / setelah argumen:

def my_function(name, /):
  print("Hello", name)

my_function("Emil")

Tanpa , / Anda sebenarnya diizinkan menggunakan argumen kata kunci meskipun fungsi tersebut mengharapkan argumen posisi:

def my_function(name):
  print("Hello", name)

my_function(name = "Emil")

Keyword-Only Arguments

Untuk menentukan bahwa suatu fungsi hanya dapat memiliki argumen kata kunci, tambahkan *, sebelum argumen:

def my_function(*, name):
  print("Hello", name)

my_function(name = "Emil")

Tanpa *,, Anda diizinkan menggunakan argumen posisi bahkan jika fungsi mengharapkan argumen kata kunci:

Combining Positional-Only and Keyword-Only

Anda dapat menggabungkan kedua tipe argumen dalam fungsi yang sama.

Argumen sebelum / hanya bersifat posisional, dan argumen setelah * hanya bersifat kata kunci:

def my_function(a, b, /, *, c, d):
  return a + b + c + d

result = my_function(5, 10, c = 15, d = 20)
print(result)

*args and **kwargs

Secara default, suatu fungsi harus dipanggil dengan jumlah argumen yang tepat.

Namun, terkadang Anda mungkin tidak tahu berapa banyak argumen yang akan diteruskan ke fungsi Anda.

*args dan **kwargs memungkinkan fungsi untuk menerima argumen dalam jumlah yang tidak diketahui.

# Using *args to accept any number of arguments:

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")

Catatan

Arbitrary Arguments are often shortened to *args in Python documentation.

What is *args?

Parameter *args memungkinkan suatu fungsi menerima sejumlah argumen posisi.

Di dalam fungsi, args menjadi tuple yang berisi semua argumen yang diteruskan:

# Accessing individual arguments from *args:

def my_function(*args):
  print("Type:", type(args))
  print("First argument:", args[0])
  print("Second argument:", args[1])
  print("All arguments:", args)

my_function("Emil", "Tobias", "Linus")

Using *args with Regular Arguments

Anda dapat menggabungkan parameter reguler dengan *args.

Parameter reguler harus diletakkan sebelum *args:

def my_function(greeting, *names):
  for name in names:
    print(greeting, name)

my_function("Hello", "Emil", "Tobias", "Linus")

Dalam contoh ini, "Hello" ditetapkan untuk greeting, dan sisanya dikumpulkan dalam names.

Contoh Praktis dengan *args

*args berguna ketika Anda ingin membuat fungsi yang fleksibel:

# A function that calculates the sum of any number of values:

def my_function(*numbers):
  total = 0
  for num in numbers:
    total += num
  return total

print(my_function(1, 2, 3))
print(my_function(10, 20, 30, 40))
print(my_function(5))


# Finding the maximum value:

def my_function(*numbers):
  if len(numbers) == 0:
    return None
  max_num = numbers[0]
  for num in numbers:
    if num > max_num:
      max_num = num
  return max_num

print(my_function(3, 7, 2, 9, 1))

Arbitrary Keyword Arguments - **kwargs

Jika Anda tidak tahu berapa banyak argumen kata kunci yang akan diteruskan ke fungsi Anda, tambahkan dua tanda bintang ** sebelum nama parameter.

Dengan cara ini, fungsi akan menerima kamus argumen dan dapat mengakses item yang sesuai:

# Using **kwargs to accept any number of keyword arguments:

def my_function(**kid):
  print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

Catatan

Arbitrary Keyword Arguments are often shortened to **kwargs in Python documentation.

What is **kwargs?

Parameter **kwargs memungkinkan suatu fungsi menerima sejumlah argumen kata kunci.

Di dalam fungsi, kwargs menjadi kamus yang berisi semua argumen kata kunci:

# Accessing values from **kwargs:

def my_function(**myvar):
  print("Type:", type(myvar))
  print("Name:", myvar["name"])
  print("Age:", myvar["age"])
  print("All data:", myvar)

my_function(name = "Tobias", age = 30, city = "Bergen")

Using **kwargs with Regular Arguments

Anda dapat menggabungkan parameter reguler dengan **kwargs.

Parameter reguler harus ada sebelum **kwargs:

def my_function(username, **details):
  print("Username:", username)
  print("Additional details:")
  for key, value in details.items():
    print(" ", key + ":", value)

my_function("emil123", age = 25, city = "Oslo", hobby = "coding")

Combining *args and **kwargs

Anda dapat menggunakan *args dan **kwargs dalam fungsi yang sama.

Urutannya harus:

1. regular parameters

2. *args

3. **kwargs

def my_function(title, *args, **kwargs):
  print("Title:", title)
  print("Positional arguments:", args)
  print("Keyword arguments:", kwargs)

my_function("User Info", "Emil", "Tobias", age = 25, city = "Oslo")

Unpacking Arguments

Operator * dan ** juga dapat digunakan saat memanggil fungsi untuk membongkar (memperluas) daftar atau kamus menjadi argumen terpisah.

Unpacking Lists with *

Jika Anda memiliki nilai yang disimpan dalam daftar, Anda dapat menggunakan * untuk menguraikannya menjadi argumen individual:

# Using * to unpack a list into arguments:

def my_function(a, b, c):
  return a + b + c

numbers = [1, 2, 3]
result = my_function(*numbers) # Same as: my_function(1, 2, 3)
print(result)

Unpacking Dictionaries with **

Jika Anda memiliki argumen kata kunci yang disimpan dalam kamus, Anda dapat menggunakan ** untuk membongkarnya:

# Using ** to unpack a dictionary into keyword arguments:

def my_function(fname, lname):
  print("Hello", fname, lname)

person = {"fname": "Emil", "lname": "Refsnes"}
my_function(**person) # Same as: my_function(fname="Emil", lname="Refsnes")

Catatan

Use * and ** in function definitions to collect arguments, and use them in function calls to unpack arguments.

Scope

Suatu variabel hanya dapat diakses dari dalam wilayah tempat variabel tersebut dibuat. Ini disebut scope.

Local Scope

Variabel yang dibuat di dalam suatu fungsi termasuk dalam cakupan lokal fungsi tersebut, dan hanya dapat digunakan di dalam fungsi tersebut.

# A variable created inside a function is available inside that function:

def myfunc():
  x = 300
  print(x)

myfunc()

Function Inside Function

As explained in the example above, the variable x is not available outside the function, but it is available for any function inside the function:

# The local variable can be accessed from a function within the function:

def myfunc():
  x = 300
  def myinnerfunc():
    print(x)
  myinnerfunc()

myfunc()

Global Scope

Variabel yang dibuat di badan utama kode Python adalah variabel global dan termasuk dalam cakupan global.

Variabel global tersedia dalam cakupan apa pun, global maupun lokal.

# A variable created outside of a function is global and can be used by anyone:

x = 300

def myfunc():
  print(x)

myfunc()

print(x)

Penamaan Variabel

Jika Anda menggunakan nama variabel yang sama di dalam dan di luar suatu fungsi, Python akan memperlakukannya sebagai dua variabel terpisah, satu tersedia dalam lingkup global (di luar fungsi) dan satu lagi tersedia dalam lingkup lokal (di dalam fungsi):

# The function will print the local x, and then the code will print the global x:

x = 300

def myfunc():
  x = 200
  print(x)

myfunc()

print(x)

Global Keyword

Jika Anda perlu membuat variabel global, tetapi terjebak dalam lingkup lokal, Anda dapat menggunakan kata kunci global.

Kata kunci global menjadikan variabel tersebut global.

# If you use the global keyword, the variable belongs to the global scope:

def myfunc():
  global x
  x = 300

myfunc()

print(x)

Gunakan juga kata kunci global jika Anda ingin membuat perubahan pada variabel global di dalam suatu fungsi.

# To change the value of a global variable inside a function, refer to the variable by using the global keyword:

x = 300

def myfunc():
  global x
  x = 200

myfunc()

print(x)

Nonlocal Keyword

Kata kunci nonlocal digunakan untuk bekerja dengan variabel di dalam fungsi bersarang.

Kata kunci nonlocal menjadikan variabel tersebut milik fungsi terluar.

# If you use the nonlocal keyword, the variable will belong to the outer function:

def myfunc1():
  x = "Jane"
  def myfunc2():
    nonlocal x
    x = "hello"
  myfunc2()
  return x

print(myfunc1())

The LEGB Rule

Python mengikuti aturan LEGB saat mencari nama variabel, dan mencarinya dalam urutan berikut:

• **L**ocal - Di dalam fungsi saat ini

• **E**nclosing - Di dalam fungsi yang melampirkan (dari dalam ke luar)

• **G**lobal - Di tingkat atas modul

• **B**uilt-in - Di namespace bawaan Python

# Understanding the LEGB rule:

x = "global"

def outer():
  x = "enclosing"
  def inner():
    x = "local"
    print("Inner:", x)
  inner()
  print("Outer:", x)

outer()
print("Global:", x)

Decorators

Dekorator memungkinkan Anda menambahkan perilaku tambahan ke suatu fungsi tanpa mengubah kode fungsi tersebut.

Dekorator adalah fungsi yang menerima fungsi lain sebagai input dan mengembalikan fungsi baru.

Basic Decorator

Tentukan dekorator terlebih dahulu, lalu terapkan dengan @decorator_name di atas fungsi.

# A basic decorator that uppercases the return value of the decorated function.

def changecase(func):
  def myinner():
    return func().upper()
  return myinner

@changecase
def myfunction():
  return "Hello Sally"

print(myfunction())

Dengan menempatkan @changecase tepat di atas definisi fungsi, fungsi myfunction "dihiasi" dengan fungsi changecase.

Fungsi changecase adalah dekoratornya.

Fungsi myfunction adalah fungsi yang didekorasi.

Multiple Decorator Calls

Dekorator dapat dipanggil beberapa kali. Cukup letakkan dekorator di atas fungsi yang ingin Anda dekorasi.

# Using the @changecase decorator on two functions:

def changecase(func):
  def myinner():
    return func().upper()
  return myinner

@changecase
def myfunction():
  return "Hello Sally"

@changecase
def otherfunction():
  return "I am speed!"

print(myfunction())
print(otherfunction())

Arguments in the Decorated Function

Fungsi yang memerlukan argumen juga dapat didekorasi, pastikan saja Anda meneruskan argumen ke fungsi pembungkus:

# Functions with arguments can also be decorated:

def changecase(func):
  def myinner(x):
    return func(x).upper()
  return myinner

@changecase
def myfunction(nam):
  return "Hello " + nam

print(myfunction("John"))

Terkadang fungsi dekorator tidak memiliki kendali atas argumen yang diteruskan dari fungsi yang didekorasi, untuk mengatasi masalah ini, tambahkan (*args, **kwargs) ke fungsi pembungkus, dengan cara ini fungsi pembungkus dapat menerima angka berapa pun, dan jenis argumen apa pun, dan meneruskannya ke fungsi yang didekorasi.

# Secure the function with *args and **kwargs arguments:

def changecase(func):
  def myinner(*args, **kwargs):
    return func(*args, **kwargs).upper()
  return myinner

@changecase
def myfunction(nam):
  return "Hello " + nam

print(myfunction("John"))

Decorator With Arguments

Dekorator dapat menerima argumen mereka sendiri dengan menambahkan tingkat pembungkus lain.

# A decorator factory that takes an argument and transforms the casing based on the argument value.

def changecase(n):
  def changecase(func):
    def myinner():
      if n == 1:
        a = func().lower()
      else:
        a = func().upper()
      return a
    return myinner
  return changecase

@changecase(1)
def myfunction():
  return "Hello Linus"

print(myfunction())

Multiple Decorators

Anda dapat menggunakan beberapa dekorator dalam satu fungsi.

Hal ini dilakukan dengan menempatkan pemanggilan dekorator di atas satu sama lain.

Dekorator dipanggil sesuai urutan yang ditentukan.

# One decorator for upper case, and one for adding a greeting:

def changecase(func):
  def myinner():
    return func().upper()
  return myinner

def addgreeting(func):
  def myinner():
    return "Hello " + func() + " Have a good day!"
  return myinner

@changecase
@addgreeting
def myfunction():
  return "Tobias"

print(myfunction())

Preserving Function Metadata

Fungsi dalam Python memiliki metadata yang dapat diakses menggunakan atribut __name__ dan __doc__.

# Normally, a function's name can be returned with the __name__ attribute:

def myfunction():
  return "Have a great day!"

print(myfunction.__name__)

Namun, ketika suatu fungsi didekorasi, metadata fungsi aslinya hilang.

Lambda Functions

Fungsi lambda adalah fungsi anonim berukuran kecil.

Fungsi lambda dapat menerima sejumlah argumen, tetapi hanya dapat memiliki satu ekspresi.

Sintaks

lambda arguments : expression

Ekspresi dieksekusi dan hasilnya dikembalikan:

#Add 10 to argument a, and return the result:

x = lambda a : a + 10
print(x(5))

Fungsi lambda dapat mengambil sejumlah argumen:

# Multiply argument a with argument b and return the result:

x = lambda a, b : a * b
print(x(5, 6))


# Summarize argument a, b, and c and return the result:

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

Mengapa Menggunakan Fungsi Lambda?

Kehebatan lambda akan terlihat lebih jelas ketika Anda menggunakannya sebagai fungsi anonim di dalam fungsi lain.

Misalkan Anda memiliki definisi fungsi yang membutuhkan satu argumen, dan argumen tersebut akan dikalikan dengan angka yang tidak diketahui:

def myfunc(n):
  return lambda a : a * n

Gunakan definisi fungsi tersebut untuk membuat fungsi yang selalu menggandakan angka yang Anda kirim:

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
print(mydoubler(11)) # return 22

Catatan

Gunakan fungsi lambda ketika fungsi anonim diperlukan untuk jangka waktu yang singkat.

Lambda with Built-in Functions

Fungsi lambda umumnya digunakan dengan fungsi bawaan seperti map(), filter(), dan sort().

Using Lambda with map()

Fungsi map() menerapkan fungsi ke setiap item dalam suatu iterable:

#Double all numbers in a list:

numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled) #return [2, 4, 6, 8, 10]

Using Lambda with filter()

Fungsi filter() membuat daftar item yang mana suatu fungsi mengembalikan True:

# Filter out even numbers from a list:

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
odd_numbers = list(filter(lambda x: x % 2 != 0, numbers))
print(odd_numbers) #return [1, 3, 5, 7]

Using Lambda with sorted()

Fungsi sort() dapat menggunakan lambda sebagai kunci untuk pengurutan khusus:

# Sort a list of tuples by the second element:

students = [("Emil", 25), ("Tobias", 22), ("Linus", 28)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)
#return [('Tobias', 22), ('Emil', 25), ('Linus', 28)]


# Sort strings by length:

words = ["apple", "pie", "banana", "cherry"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)

Recursion

Rekursi adalah proses ketika suatu fungsi memanggil dirinya sendiri.

Rekursi adalah konsep matematika dan pemrograman yang umum. Artinya, suatu fungsi memanggil dirinya sendiri. Hal ini memiliki manfaat, yaitu Anda dapat melakukan pengulangan data untuk mencapai suatu hasil.

Pengembang harus sangat berhati-hati dengan rekursi karena dapat dengan mudah tergelincir ke dalam penulisan fungsi yang tidak pernah berakhir, atau fungsi yang menggunakan memori atau daya prosesor secara berlebihan. Namun, jika ditulis dengan benar, rekursi dapat menjadi pendekatan pemrograman yang sangat efisien dan elegan secara matematis.

# A simple recursive function that counts down from 5:

def countdown(n):
  if n <= 0:
    print("Done!")
  else:
    print(n)
    countdown(n - 1)

countdown(5)

Base Case and Recursive Case

Setiap fungsi rekursif harus memiliki dua bagian:

• A base case - Kondisi yang menghentikan rekursi

• A recursive case - Fungsi yang memanggil dirinya sendiri dengan argumen yang dimodifikasi

Tanpa base case, fungsi akan memanggil dirinya sendiri selamanya, yang menyebabkan kesalahan stack overflow.

# Identifying base case and recursive case:

def factorial(n):
  # Base case
  if n == 0 or n == 1:
    return 1
  # Recursive case
  else:
    return n * factorial(n - 1)

print(factorial(5))

Catatan

Kasus dasar sangatlah penting. Selalu pastikan fungsi rekursif Anda memiliki kondisi yang pada akhirnya akan terpenuhi.

Fibonacci Sequence

Deret Fibonacci adalah contoh klasik di mana setiap angka merupakan penjumlahan dari dua angka sebelumnya. Deret ini dimulai dengan 0 dan 1:

0, 1, 1, 2, 3, 5, 8, 13, ...

Deret ini berlanjut tanpa batas, dengan setiap angka merupakan penjumlahan dari dua angka sebelumnya.

Kita dapat menggunakan rekursi untuk menemukan angka tertentu dalam deret ini:

# Find the 7th number in the Fibonacci sequence:

def fibonacci(n):
  if n <= 1:
    return n
  else:
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(7)) #return 13

Recursion with Lists

Rekursi dapat digunakan untuk memproses daftar dengan menangani satu elemen pada satu waktu:

# Calculate the sum of all elements in a list:

def sum_list(numbers):

if len(numbers) == 0:

return 0

else:

return numbers[0] + sum_list(numbers[1:])

my_list = [1, 2, 3, 4, 5] print(sum_list(my_list)) #return 15

# Find the maximum value in a list:

def find_max(numbers):

if len(numbers) == 1:

return numbers[0]

else:

max_of_rest = find_max(numbers[1:]) return numbers[0] if numbers[0] > max_of_rest else max_of_rest

my_list = [3, 7, 2, 9, 1] print(find_max(my_list)) #return 9

Recursion Depth Limit

Python memiliki batasan seberapa dalam rekursi dapat dilakukan. Batas default biasanya sekitar 1000 pemanggilan rekursif.

# Check the recursion limit:

import sys
print(sys.getrecursionlimit())

Jika Anda memerlukan rekursi yang lebih dalam, Anda dapat meningkatkan batasnya, tetapi berhati-hatilah karena hal ini dapat menyebabkan kerusakan:

import sys
sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())

Peringatan

Peningkatan batas rekursi harus dilakukan dengan hati-hati. Untuk rekursi yang sangat dalam, pertimbangkan untuk menggunakan iterasi.

Generators

Generator adalah fungsi yang dapat menjeda dan melanjutkan eksekusinya.

Ketika fungsi generator dipanggil, ia mengembalikan objek generator, yang merupakan sebuah iterator.

Kode di dalam fungsi tersebut belum dieksekusi, melainkan baru dikompilasi. Fungsi tersebut hanya dieksekusi ketika Anda melakukan iterasi pada generator.

# A simple generator function:

def my_generator():
  yield 1
  yield 2
  yield 3

for value in my_generator():
  print(value)

Catatan

Generator memungkinkan Anda melakukan iterasi data tanpa menyimpan seluruh dataset di memori. Alih-alih menggunakan return, generator menggunakan kata kunci yield.

The yield Keyword

Kata kunci yield inilah yang menjadikan suatu fungsi sebagai generator.

Ketika yield ditemukan, status fungsi disimpan, dan nilainya dikembalikan. Saat generator dipanggil lagi, fungsi tersebut melanjutkan dari titik terakhirnya.

# Generator that yields numbers:

def count_up_to(n):
  count = 1
  while count <= n:
    yield count
    count += 1

for num in count_up_to(5):
  print(num)

Tidak seperti return, yang mengakhiri fungsi, yield menjedanya dan dapat dipanggil beberapa kali.

Generators Saves Memory

Generator hemat memori karena menghasilkan nilai secara langsung, alih-alih menyimpan semuanya di memori.

Untuk kumpulan data besar, generator menghemat memori:

# Generator for large sequences:

def large_sequence(n):
  for i in range(n):
    yield i

# This doesn't create a million numbers in memory
gen = large_sequence(1000000)
print(next(gen))
print(next(gen))
print(next(gen))

Using next() with Generators

Anda dapat mengulang generator secara manual menggunakan fungsi next():

def simple_gen():
  yield "Emil"
  yield "Tobias"
  yield "Linus"

gen = simple_gen()
print(next(gen))
print(next(gen))
print(next(gen))

Jika tidak ada lagi nilai yang dapat dihasilkan, generator akan memunculkan pengecualian StopIteration:

def simple_gen():
  yield 1
  yield 2

gen = simple_gen()
print(next(gen))
print(next(gen))
print(next(gen)) # This will raise StopIteration

Generator Expressions

Mirip dengan pemahaman daftar, Anda dapat membuat generator menggunakan ekspresi generator dengan tanda kurung, bukan tanda kurung siku:

# List comprehension vs generator expression:
# List comprehension - creates a list
list_comp = [x * x for x in range(5)]
print(list_comp)

# Generator expression - creates a generator
gen_exp = (x * x for x in range(5))
print(gen_exp)
print(list(gen_exp))


# Using a generator expression with sum:
# Calculate sum of squares without creating a list
total = sum(x * x for x in range(10))
print(total)

Fibonacci Sequence Generator

Generator dapat digunakan untuk membuat deret Fibonacci.

Generator dapat terus menghasilkan nilai tanpa batas, tanpa kehabisan memori:

# Generate 100 Fibonacci numbers:

def fibonacci():
  a, b = 0, 1
  while True:
    yield a
    a, b = b, a + b

# Get first 100 Fibonacci numbers
gen = fibonacci()
for _ in range(100):
  print(next(gen))

Generator Methods

Generator memiliki metode khusus untuk kontrol lanjutan:

send() Method

Metode send() memungkinkan Anda mengirim nilai ke generator:

def echo_generator():
  while True:
    received = yield
    print("Received:", received)

gen = echo_generator()
next(gen) # Prime the generator
gen.send("Hello")
gen.send("World")

close() Method

Metode close() menghentikan generator:

def my_gen():
  try:
    yield 1
    yield 2
    yield 3
  finally:
    print("Generator closed")

gen = my_gen()
print(next(gen))
gen.close()