Functions dan OOP Python: Lambda, Decorator, Class, dan Inheritance

1
# Fungsi dasar
2
def greet():
3
    print("Hello, World!")
4

5
greet()  # Hello, World!
6

7
# Fungsi dengan parameter
8
def greet_name(name):
9
    print(f"Hello, {name}!")
10

11
greet_name("Budi")  # Hello, Budi!
12

13
# Fungsi dengan return value
14
def add(a, b):
15
    return a + b
16

17
result = add(3, 5)  # 8

1
# Default parameter
2
def greet(name, greeting="Hello"):
3
    print(f"{greeting}, {name}!")
4

5
greet("Budi")              # Hello, Budi!
6
greet("Siti", "Selamat Pagi")  # Selamat Pagi, Siti!
7

8
# Keyword arguments
9
def person_info(name, age, city):
10
    print(f"{name}, {age} tahun, dari {city}")
11

12
person_info(age=25, city="Jakarta", name="Budi")  # urutan bebas
13

14
# *args — menerima banyak argumen posisional
15
def total(*numbers):
16
    return sum(numbers)
17

18
print(total(1, 2, 3))        # 6
19
print(total(1, 2, 3, 4, 5))  # 15
20

21
# **kwargs — menerima banyak keyword arguments
22
def display(**info):
23
    for key, val in info.items():
24
        print(f"{key}: {val}")
25

26
display(name="Budi", age=25, city="Jakarta")
27

28
# Kombinasi
29
def mixed(a, b, *args, **kwargs):
30
    print(a, b, args, kwargs)
31

32
mixed(1, 2, 3, 4, x=10, y=20)
33
# 1 2 (3, 4) {'x': 10, 'y': 20}

1
def min_max(numbers):
2
    return min(numbers), max(numbers)  # return tuple
3

4
lo, hi = min_max([3, 1, 4, 1, 5, 9])
5
print(lo, hi)  # 1 9

1
x = 10  # global variable
2

3
def func():
4
    x = 20  # local variable (tidak ubah global)
5
    print(x)  # 20
6

7
func()
8
print(x)  # 10 (global tetap)
9

10
# Pakai global keyword untuk ubah global dari dalam fungsi
11
def change_global():
12
    global x
13
    x = 99
14

15
change_global()
16
print(x)  # 99

1
# Syntax: lambda parameter: ekspresi
2

3
# Fungsi biasa
4
def square(x):
5
    return x ** 2
6

7
# Lambda equivalent
8
square = lambda x: x ** 2
9
print(square(5))  # 25
10

11
# Lambda dengan multiple parameter
12
add = lambda a, b: a + b
13
print(add(3, 4))  # 7
14

15
# Lambda dengan kondisi
16
classify = lambda x: "genap" if x % 2 == 0 else "ganjil"
17
print(classify(4))  # genap

1
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2

3
# map() — terapkan fungsi ke setiap elemen
4
squares = list(map(lambda x: x**2, numbers))
5
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
6

7
# filter() — filter elemen berdasarkan kondisi
8
evens = list(filter(lambda x: x % 2 == 0, numbers))
9
# [2, 4, 6, 8, 10]
10

11
# reduce() — akumulasi nilai
12
from functools import reduce
13
total = reduce(lambda acc, x: acc + x, numbers)
14
# 55 (1+2+3+...+10)
15

16
product = reduce(lambda acc, x: acc * x, [1, 2, 3, 4, 5])
17
# 120 (1*2*3*4*5)
18

19
# Sorting dengan lambda
20
students = [('Budi', 85), ('Siti', 92), ('Andi', 78)]
21
students.sort(key=lambda s: s[1], reverse=True)
22
# [('Siti', 92), ('Budi', 85), ('Andi', 78)]

1
# Decorator dasar
2
def my_decorator(func):
3
    def wrapper(*args, **kwargs):
4
        print("Sebelum fungsi dipanggil")
5
        result = func(*args, **kwargs)
6
        print("Setelah fungsi dipanggil")
7
        return result
8
    return wrapper
9

10
@my_decorator
11
def say_hello(name):
12
    print(f"Hello, {name}!")
13

14
say_hello("Budi")
15
# Sebelum fungsi dipanggil
16
# Hello, Budi!
17
# Setelah fungsi dipanggil
18

19
# Decorator untuk timing
20
import time
21

22
def timer(func):
23
    def wrapper(*args, **kwargs):
24
        start = time.time()
25
        result = func(*args, **kwargs)
26
        end = time.time()
27
        print(f"{func.__name__} selesai dalam {end-start:.4f} detik")
28
        return result
29
    return wrapper
30

31
@timer
32
def slow_function():
33
    time.sleep(1)
34
    return "done"
35

36
slow_function()
37
# slow_function selesai dalam 1.0012 detik

1
# Mendefinisikan class
2
class Person:
3
    # Class variable (shared oleh semua instance)
4
    species = "Homo sapiens"
5

6
    # Constructor
7
    def __init__(self, name, age):
8
        # Instance variables
9
        self.name = name
10
        self.age = age
11

12
    # Instance method
13
    def greet(self):
14
        print(f"Hi, saya {self.name}, {self.age} tahun")
15

16
    def __str__(self):
17
        return f"Person({self.name}, {self.age})"
18

19
    def __repr__(self):
20
        return f"Person(name='{self.name}', age={self.age})"
21

22
# Membuat object (instance)
23
p1 = Person("Budi", 25)
24
p2 = Person("Siti", 22)
25

26
p1.greet()              # Hi, saya Budi, 25 tahun
27
print(p1.name)          # Budi
28
print(Person.species)   # Homo sapiens
29
print(p1)               # Person(Budi, 25)

1
class BankAccount:
2
    def __init__(self, owner, balance=0):
3
        self.owner = owner
4
        self.__balance = balance  # private (name mangling)
5

6
    # Getter
7
    @property
8
    def balance(self):
9
        return self.__balance
10

11
    # Setter dengan validasi
12
    @balance.setter
13
    def balance(self, amount):
14
        if amount < 0:
15
            raise ValueError("Saldo tidak boleh negatif")
16
        self.__balance = amount
17

18
    def deposit(self, amount):
19
        if amount > 0:
20
            self.__balance += amount
21
            print(f"Deposit {amount}. Saldo: {self.__balance}")
22

23
    def withdraw(self, amount):
24
        if amount > self.__balance:
25
            print("Saldo tidak cukup")
26
            return
27
        self.__balance -= amount
28
        print(f"Tarik {amount}. Saldo: {self.__balance}")
29

30
acc = BankAccount("Budi", 1000000)
31
acc.deposit(500000)    # Deposit 500000. Saldo: 1500000
32
acc.withdraw(200000)   # Tarik 200000. Saldo: 1300000
33
print(acc.balance)     # 1300000
34
# acc.__balance        # AttributeError - tidak bisa akses langsung

1
# Parent class
2
class Animal:
3
    def __init__(self, name, sound):
4
        self.name = name
5
        self.sound = sound
6

7
    def speak(self):
8
        print(f"{self.name} berkata: {self.sound}")
9

10
    def __str__(self):
11
        return f"Animal({self.name})"
12

13
# Child class
14
class Dog(Animal):
15
    def __init__(self, name, breed):
16
        super().__init__(name, "Woof")  # panggil parent constructor
17
        self.breed = breed
18

19
    def fetch(self):
20
        print(f"{self.name} mengambil bola!")
21

22
    # Override method parent
23
    def speak(self):
24
        print(f"{self.name} ({self.breed}) menggonggong: {self.sound}!")
25

26
class Cat(Animal):
27
    def __init__(self, name):
28
        super().__init__(name, "Meow")
29

30
    def purr(self):
31
        print(f"{self.name} mendengkur...")
32

33
dog = Dog("Rex", "German Shepherd")
34
cat = Cat("Kitty")
35

36
dog.speak()   # Rex (German Shepherd) menggonggong: Woof!
37
cat.speak()   # Kitty berkata: Meow
38
dog.fetch()   # Rex mengambil bola!
39

40
# isinstance & issubclass
41
print(isinstance(dog, Dog))     # True
42
print(isinstance(dog, Animal))  # True (inheritance)
43
print(issubclass(Dog, Animal))  # True

1
class Shape:
2
    def area(self):
3
        raise NotImplementedError
4

5
class Circle(Shape):
6
    def __init__(self, r):
7
        self.r = r
8
    def area(self):
9
        return 3.14159 * self.r ** 2
10

11
class Rectangle(Shape):
12
    def __init__(self, w, h):
13
        self.w = w
14
        self.h = h
15
    def area(self):
16
        return self.w * self.h
17

18
# Polymorphism — fungsi yang sama, perilaku berbeda
19
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
20
for shape in shapes:
21
    print(f"{shape.__class__.__name__}: area = {shape.area():.2f}")
22
# Circle: area = 78.54
23
# Rectangle: area = 24.00
24
# Circle: area = 28.27

1
class Vector:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

6
    def __str__(self):          # str(obj)
7
        return f"Vector({self.x}, {self.y})"
8

9
    def __repr__(self):         # repr(obj)
10
        return f"Vector(x={self.x}, y={self.y})"
11

12
    def __add__(self, other):   # v1 + v2
13
        return Vector(self.x + other.x, self.y + other.y)
14

15
    def __len__(self):          # len(obj)
16
        return int((self.x**2 + self.y**2) ** 0.5)
17

18
    def __eq__(self, other):    # v1 == v2
19
        return self.x == other.x and self.y == other.y
20

21
v1 = Vector(3, 4)
22
v2 = Vector(1, 2)
23
print(v1)           # Vector(3, 4)
24
print(v1 + v2)      # Vector(4, 6)
25
print(len(v1))      # 5
26
print(v1 == v2)     # False