Function, Building and Block of Code

Namespace

Namespace adalah pemetaan nama-nama ke objek-objek. Contohnya kumpulannames bawaan (fungsi yang dapat diakses dimana saja program python manapun) seperti help(), dir() atau print(), global names dalam sebuah module, dann local name pada sebuah function. Bahkan kumpulan dari attributes dari sebuah objek dapat disebut juga dengan namespace.

Info

names artinya varibael. Sebuah nama yang menampung objek.

Manfaat dari namespace ini, kita dapat mendefinisikan dan mengelola names secara jelas. Misalkan kita ingin fungsi menggunakan fungsi standard_normal, dan kita harus mengimport from numpy.random import standard_normal.

Inline syntax diatas dimulai dengan masuk ke namespace numpy , lalu masuk lagi ke namespace terakhir random dan terakhir memanggil names yang ingin kita gunakan, yaitu standard_nomal.

Ada konsep lain yang berhubungan denga namespace, yaitu scope.

Scope

Scope adalah wilayah tekstual dari program python, dimana namespace dapat diakses secara langsung. Scope ditetukan secara statis, namun sebenarnya, mereka menentukannya dinamis. Artinya, jika kita menginspeksi ke kode yang ditulis dengan python kita dapat mengetahui names scope dari objek tersebut. Misalkan standard_normal berasal dari objek numpy.

Ada empat scope yang python buat dapat diakses.

1. Local, scope paling dalam dan mengadung local names

2. enclosing, scope ini mengadung enclosing names. diantara global dan local scope.

3. global, scope yang mengandung global scope

4. built-in, scope yang mengandung built-in names, semisal prin, abs, help, die dst.

Aturan python mencari sebuah names yang ditulis pada program python sebagai berikut :

Pertama, python akan mencari dari namespace saat ini. Jika tidak ditemukan selanjutnya akan dicari pada enclosing scope, dan terus hingga buil-in scope. JIka names juga tidak ditemukan maka python akan mengeluarkan exception NameError yang artinya names tersebut belum terdefinisi.

Urutanya pencarian name, LEGB, (Local,Enclosing ,Global, Built-in)

Scope dan Name Resolution

Diatas kita berbicara tentang teori, sekarang kita akan langsung bermain dengan program python. Lihatlah kode dibawah ini.

Code

Demo Global dan Local

def my_function():
    test = 1 # name yang didefinisikan pada local scope
    print('my_function:', test)

test = 0 # name yang didefinisikan pada global scope
my_function()
print('global:', test)

Print output

my_function: 1
global: 0

variable test pada pada my_function menghasilkan nilai 1 karena didefinisikan pada local scope dan test pada global scope adalah 0 karena test terdefinisi pada global scope. Ingat, Python akan mencari name pada masing-masing namespace saat ini. Artinya python akan mencari name testmy_function di localscope, dan name test pada global di global scope.

Code

Demo Global dan Local

def my_function():
    # test = 1 #(1)!
    print('my_function:', test)

test = 0 # name yang didefinisikan pada global scope
my_function()
print('global:', test)

Print output

my_function: 0
global: 0

Kode diatas, name test pada my_function menjadi 0. Ingat LEGB, karena python tidak menemukan test pada localscope (current scope fungsi tersebut) selanjutnya python akan mencari di enclosing scope, karena fungsi diatas tidak memliki enclosing scope selanjutnya python akan mencari test pada global scope dan menemukanya dengan nilai test adalah 0.

Sekarang lihat kode dibawah ini untuk demo yang lebih tajam

Code

Demo Global dan Local

def outer():
    test = 1 #(1)!

    def inner():
        # test = 2

        def deep_inner():
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')


outer()
test = 0
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 1
Outer : 1
Global : 0

Kali ini, karena python tidak menesmukan name test dari fungsi inner maka akan mencari name test pada enclosing scope, yaitu pada fungsi outer.

Global dan Nonlocal Statement

Just look at the behavior of nonlocal and global

nonlocal

The nonlocal statement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope excluding globals.

Code

Non local pada inner()Non local pada deep_inner()Non local pada inner() &#!python deep_inner()`Non local pada outer()

Demo Global dan Local

def outer():
    test = 1


    def inner():
        nonlocal test
        test = 2


        def deep_inner():
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')


test = 0
outer()
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 2
Outer : 2
Global : 0

Demo Global dan Local

def outer():
    test = 1

    def inner():
        test = 2

        def deep_inner():
            nonlocal test
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()#(1)!
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')

test = 0
outer()
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 3
Outer : 1
Global : 0

Demo Global dan Local

def outer():
    test = 1

    def inner():
        test = 2

        def deep_inner():
            nonlocal test
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()#(1)!
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')

test = 0
outer()
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 3
Outer : 3
Global : 0

Demo Global dan Local

def outer():
    nonlocal test
    test = 1

    def inner():
        test = 2

        def deep_inner():
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()#(1)!
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')

test = 0
outer()
print(f'Global : {test}')

Print output

Input In [162]
    nonlocal test
    ^
SyntaxError: no binding for nonlocal 'test' found

And now for global. Menggunakan kode yang sama diatas. Coba kita comment name test pada inner(). Merujuk ke LEGB, python akan mengambil nilai test pada enclosing scope, yaitu name test pada outer() dengan nilai 1.

Code

Demo Global dan Local

def outer():
    test = 1

    def inner():
        # test = 2

        def deep_inner():
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()#(1)!
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')

test = 0
outer()
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 1
Outer : 1
Global : 0

Namun dengan membuat global naming test pada fungsi inner() membuat python mengambil nilai test langsung dari global.

Code

Demo Global dan Local

def outer():
    test = 1

    def inner():
        global test
        # test = 2

        def deep_inner():
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()#(1)!
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')

test = 0
outer()
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 0
Outer : 1
Global : 0

Dan jika kita uncomment lagi name test pada inner dan menulis global pada test maka nilai test pada global akan di overwrite dengan nilai test pada `#!python inner.

Code

Demo Global dan Local

def outer():
    test = 1

    def inner():
        global test
        test = 2

        def deep_inner():
            test = 3
            print(f'Deeper inner : {test}')

        deep_inner()#(1)!
        print(f'Inner : {test}')
    inner()
    print(f'Outer : {test}')

test = 0
outer()
print(f'Global : {test}')

Print output

Deeper inner : 3
Inner : 2
Outer : 1
Global : 2

Input Parameters

Untuk memahami semua tipe parameter anda harus memahami apa itu maksud dari memberikan argumen pada sebuah fungsi. Ada 3 kunci yang harus anda pahami;

• Argument-passing, memberikan nilai dari objek ke variable name pada local scope fungsi.
• Mengisi nilai dari objek ke argument name didalam fungsi tidak memberikan dampak pada caller.
• Mengubah argumen mutable object pada sebuah fungsi akan mempengaruhi caller.

Argument-passing

Memberikan nilai dari objek ke variable name pada local scope fungsi.

Code

x = 10
def ganda(y):
    print(y*2)

ganda(x)

Print output

20

Assignment to parameter name

Mengisi nilai dari objek ke argument name didalam fungsi tidak memberikan dampak pada caller.

Code

x = 10
def ganda(x):
    x = 2 #(1)!
    print(x*2) 

ganda(x)
print(x) #(2)!

Print output

4
10

1. Assignment x ini hanya terjadi pada local scope, tidak mempengaruhi global scope (caller).
2. Nilai global x tetap 10, tidak dipengaruhi asiggment didalam fungsi ganda.

Mengubah mutable objek

Mengubah argumen mutable object pada sebuah fungsi akan mempengaruhi caller.

Code

lst = [1,2,3,4,5]
def func(x):
    for a,b in enumerate(x):
        lst[a] = b**2

func(lst)
print(lst)

Print output

[1, 4, 9, 16, 25]

Jika kembali melihat poin kedua "=Mengisi= nilai dari objek ke argument name didalam fungsi tidak memberikan dampak pada caller.". Lihat kode dibawah ini, saya menambahkan kode yang mengisi nilai x dengan nilai baru.

Code

lst = [1,2,3,4,5]
def func(x):
    for a,b in enumerate(x):
        lst[a] = b**2

    x = [0,0,0,0,0] #(1)!
func(lst)
print(lst) #(2)!

1. Tidak dapat mengganti nilai caller, lst pada global scope yang sudah dimodifikasi.
2. Tetap mengambil nilai lst pada global scope yang sudah dimodifikasi oleh fungsi func.

Print output

[1, 4, 9, 16, 25]

Memberikan argumen

Ada empat cara untuk memberikan sebuah argumen pada fungsi

• Positional arguments
• Keyword arguments
• Iterable unpacking
• Dictionary unpacking

Positional arguments

Ini adalah pemberian argumenyang paling umum.

Code

def func (satu, dua, tiga):
    print(satu, dua ,tiga)

func (10,20,30) #(1)!

1. Penempatan argumen sesuai posisi

Print output

10 20 30

Keyword arguments

Ketika memberikan argumen pada sebuah fungsi, keyword argumen tidak harus dalam urutan.

Code

def func (satu, dua, tiga):
    print(satu, dua ,tiga)

func (tiga=30, satu=10, dua=20) #(1)!

1. Penempatan argumen sesuai nama dari argumen

Print output

10 20 30

Anda juga dapat menggabungkan positional argument dan keyword argumen.

Code

def func (satu, dua, tiga):
    print(satu, dua ,tiga)

func (10, tiga=30,  dua=20) #(1)!

1. 10, adalah positional argumen, dan {20,30} menggunakan keyword argumen.

Print output

10 20 30

Warning

Jika anda ingin menggabungkan positional dan keyword argumen pastikan positional argumen harus ditempatkan sebelum keyword. Kalau tidak akan menyebabkan syntax error

Code

def func (satu, dua, tiga):
    print(satu, dua ,tiga)

func (dua= 20, satu=10,  30) #(1)!

1. 30, adalah positional argumen, dan {10,20} menggunakan keyword argumen.

Print output

  Input In [231]
    func (dua= 20, satu=10,  30)
                            ^
SyntaxError: positional argument follows keyword argument

Iterable unpacking

Untuk menggunakan iterable unpacking anda dapat menggunakan tanda bintang =*= sebelum nama variabel yang menampung objek iterable. Iterable unpacking akan memberikan argumen sesuai dengan posisi dari iterable yang diberikan.

Code

Iterable upacking pada tupleIterable upacking pada list

deret = (10,20,30)
def func (satu, dua, tiga):
    print(satu, dua ,tiga)

func(*deret)

Print output

10 20 30

deret = [10,20,30]
def func (satu, dua, tiga):
    print(satu, dua ,tiga)

func(*deret)

Print output

10 20 30

Dictionary unpacking

Sejenis dengan iterable unpacking yang memberikan argumen sesuai dengan posisi, Dictionary unpacking memberikan nilai sesuai dengan keyword argument. Yang harus diingat, key yang digunakan pada Dictionary akan diberikan pada keyword argument yang sesuai.

Code

deret = {'satu':10,'dua':20,'tiga':30}
def func (satu, dua, tiga):
    deret["satu"] = 50
    print(satu, dua ,tiga)

func(**deret)

Print output

10 20 30

Kombinasi tipe argumen

Kita dapat menggabungkan antara keyword anda positional selama kita menempatkan dalam urutan yang benar. Kita juga dapat mengkombinasi Ditctionary dan Iterable unpacking dengan positional dan keyword argumen dengan ketentuan sebagai berikut;

1. Posisi awal, bisa positional argument (name) dan iterable unpacking *(name)
2. Selanjutnya, keyword argument (name=value) yang dapat digabung dengan iterable unpacking *(name)
3. Terakhir, dictionary unpacking **{name:value} yang dapat digabung dengan keyword argument (name=value)

Code

def func (a,b,c,d,e,f,g):
    print(a,b,c,d,e,f,g)


func(1,*(2,3,4,5), **{'f':6,'g':7})
func(c = 3, d= 4, *(1,2), e=5,f=6,**{'g':7})
func(*(1,2), d=4, c=3,  **{'f':6,'g':7}, e=5)

Print output

1 2 3 4 5 6 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7

Mendefinisikan parameter

Parameter pada fungsi terbagi menjadi 5 kelompok

1. Positional atau Keyword parameter, dapat diberikan oleh positional argumen dan keyword argument

2. Variable Positional Parameters, menerima kumpulan nilai dari positional argument dalam sebuah tuple

3. Variable Keyword parameters, menerima kumpulan nilai dari keyword argument dalam sebuah dictionary

4. Positional-only parameters, hanya dapat menerima positional arguments.

5. Keyword-only parameters, hanya dapat menerima keyword arguments

Parameter opsional

Diluar dari kategori parameter diatas, parameter dapat diatur untuk menjadi opsional atau wajib. Parameter Opsional memeliki nilai bawaan yang harus didefinisikan pada parameter fungsi dengan syntax name=value.

Code

def func (a,b=2,c=3):
    print(a,b,c)

func (1)
func (b=4,c=6,a=2)
func(*(4,5),6)
func(2,3)

Print output

1 2 3
2 4 6
4 5 6
2 3 3

Penting untuk dicatat bahwa, paramter yang wajib harus diletakan dibagian yang paling kiri dan tidak bisa disebalah kanan dari parameter yang opsi. Dibawah ini saya menghapus parameter opsi c dan merubahnya menjadi parameter wajib.

Code

def func (a,b=2,c):
    print(a,b,c)

func (1)
func (b=4,c=6,a=2)
func(*(4,5),6)
func(2,3)

Print output

Input In [283]
    def func (a,b=2,c):
                    ^
SyntaxError: non-default argument follows default argument

Variable Positional Parameter

Dalam kondisi tertentu mungkin tidak ingin menspesifikan dengan tepat jumlah positional parameter pada sebuah fungsi. Python menyediakan sebuah fitur untuk menyelesaikan diatas dengan varible positional paramters.

Code

def terkecil (*post):
    # print(type(post)) (1)
    if post:
        terkecil = post[0] # Terkecil sementara
        for a in post[1:]:
            if a < terkecil:
                terkecil = a
        return terkecil

print(terkecil(1,-2,4,-5,6))

1. Variable Positional Parameters akan mengumpulkan argumen yang diterima menjadi sebuah tuple.

Print output

-5

Info

Fungsi setidaknya hanya dapat memiliki satu buah variable positional parameters. Karena python tidak tahu bagaimana membagi argumen-argumen yang diberikan menjadi dua atau lebih tuple. anda jgua tidak dapat menetapkan nilai bawaan pada variable positional parameters. Nilai default variable positional parameter adalah empty tuple.

Dua variable positional parameterVariable positional parameter dengan default value

def dua_positional_parameter (*post, *post2):
    print(type(post), type(post2))

Print output

Input In [298]
    def dua_positional_parameter (*post, *post2):
                                        ^
SyntaxError: invalid syntax

def dua_positional_parameter (*post = (1,2,3)):
    print(type(post))

Print output

Input In [300]
    def dua_positional_parameter (*post = (1,2,3)):
                                        ^
SyntaxError: invalid syntax

Jika anda perhatikan, penggunaan variable positional parameters sama dengan iterable unpacking. Kedua fitur tersebut seringkali digunakan secara bersamaan. Dimana variabel positional parameters memastikan panjang dari iterable yang di unpacking cocok dengan jumlah parameter yang terdifinisi disebuah fungsi.

Code

Penggunakan variable positional parameters dengan iterable unpacking

def terkecil (*post): #(1)!
    if post:
        terkecil = post[0] # Terkecil sementara
        for a in post[1:]:
            if a < terkecil:
                terkecil = a
        return terkecil

deret = [1,-2,3,-4,5,6]
print(terkecil(*deret)) #(2)!

1. Varriable Positional Parameters
2. Itrable Unpacking

Print output

-4

Variable Keyword Parameters

Sama dengan variable positional parameters, yang berbeda adalah fitur ini mengumpulkan parameter dalam bentuk dictionary dan menggunakan dua buah asterik **.

Code

def func (**kwargs):
    print(kwargs)

func(a=2,b=3)

Print output

{'a': 2, 'b': 3}

Sama seperti variable positional paramters yang mengumpulkan kembali iterable unpacking, variable keyword parameters mengumpulkan kembali dictionary unpacking. Dictionary unpacking juga sering digunakan untuk memberikan argumen ke fungsi dengan variable keyword parameters.

Code

def connect(**options):
    conn_params = {
    'host': options.get('host', '127.0.0.1'),
    'port': options.get('port', 5432),
    'user': options.get('user', ''),
    'pwd': options.get('pwd', ''),
    }
    print(conn_params)
    # we then connect to the db (commented out)
    # db.connect(**conn_params)
connect()
connect(host='127.0.0.42', port=5433)
connect(port=5431, user='fab', pwd='gandalf')

Print output

{'host': '127.0.0.1', 'port': 5432, 'user': '', 'pwd': ''}
{'host': '127.0.0.42', 'port': 5433, 'user': '', 'pwd': ''}
{'host': '127.0.0.1', 'port': 5431, 'user': 'fab', 'pwd': 'gandalf'}

Didalam fungsi, kita dapat menyiapkan dictionary untuk parameter connection (conn_params) menggunakan nilai bawaan yang dapat ditiban.

Positional-only parameters

Untuk mengindikasi parameter pada sebuah fungsi harus sesuai dengan urutan posisi dan melarang menggunakan keyword argument gunakan syntax /.

Position onlyContain keyword arguments

Code

def func(a,b,/,c):
    print(a,b,c)

func(1,2,c=3)
func(*(2,4), 8)

Print output

1 2 3
2 4 8

Code

def func(a,b,/,c): #(1)!
    print(a,b,c)

func(a=1,b=2,c=3)

1. parameter a dan b harus diisi dengan positional argumen, jika tidak akan menghasilkan exception.

Print output

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [337], in <cell line: 7>()
    4 func(1,2,c=3)
    5 func(*(2,4), 8)
----> 7 func(a=1,b=2,c=3)

TypeError: func() got some positional-only arguments passed as keyword arguments: 'a, b'

Info

Parameter disebelah slash / adalah parameter yang ditetapkan sebagai positional-only parameters.

Positional-only parameters juga dapat menerima default value, menjadi parameter opsional.

Code

def func (a,b=2,/):
    print(a,b)

func(1,3)
func(8)

Print output

1 3
8 2

Warning

Ingat tentang parameter opsional ?, parameter opsional harus diletakan disebelah kanan dari parameter wajib.

Combining Input Parameters

Mengkombinasi argumen dengan tipe yang berbeda pada fungsi yang sama ada beberapa batasan dalam urutan, diantaranya:

1. Positional only parameters harus ditempatkan diawal, diikut dengan /

2. Normal parameters ditempatkan setelah Positional only paramaters.

3. Variable positional parameters ditempatkan setelah normal parameters.
4. Keyword only parameters ditempatkan setelah variable positional paramaters
5. Variable keyword parameters selalu ditempatkan dibagian yang paling akhir.
6. Untuk positional only parameters and norma paramenters, semua parameter wajib harus didefinisi sebelum parameter opsional Artinya, jika anda memliki positional only parameters opsional, maka semua normal parameter harus opsional.

Code

def func (a,b,/,c,d,e,f,*args,**kwargs):
    print (f'a,b : {a,b}')
    print(f'c,d,e : {c,d,e}')
    print(f'f : {f}')
    print(args)
    print(kwargs)

func(0,1,*(4,5,6,7,8),*(9,10,11,12,13,14,15,16,17,18), detail="test", more="more-detail")

Print output

a,b : (0, 1)
c,d,e : (4, 5, 6)
f : 7
(8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
{'detail': 'test', 'more': 'more-detail'}

Bugs pada nilai default objek mutanble

Katakan kita memliki fungsi dibawahi ini

Code

def func(a=[],b={}):
    print(f'{"-"*6}start{"-"*6}')
    b[len(a)] = a
    a.append(len(a))
    print(a)
    print(b)
    print()

func()
func()
func()

Print output

------start------
[0]
{0: [0]}

------start------
[0, 1]
{0: [0, 1], 1: [0, 1]}

------start------
[0, 1, 2]
{0: [0, 1, 2], 1: [0, 1, 2], 2: [0, 1, 2]}

Parameter defalut diatas selalu update ketika memanggil fungsi yang sama. Behavior yang diingikan nilai default tersebut selalu refresh, diperbaharui.

Code

def func(a=None,b=None):
    if a is None:
        a = []

    if b is None:
        b = {}
    print(f'{"-"*6}start{"-"*6}')
    b[len(a)] = a
    a.append(len(a))
    print(a)
    print(b)
    print()

func()
func()
func()

Print output

------start------
[0]
{0: [0]}

------start------
[0]
{0: [0]}

------start------
[0]
{0: [0]}

Retrun value

One return valueMultiple return value

Code

def func (a,b):
    return (a+b)
hasil = func(1,2)
print(hasil)

```{.python .no-copy title="Print output"}
3

Code

def func_mul (a,b):
    return (a,b)
hasil_1, hasil_2 = func_mul(1,2)
print(hasil_1)
print(hasil_2)

```{.python .no-copy title="Print output"}
1
2

Recursive function

Ketika fungsi memanggil dirinya sendiri untuk menghasilkan nilai return maka itu dikatakan Recursive function

Code

def faktorial (n):
    # base, kondisi stop recursive function
    if n in (0,1):
        return 1

    return faktorial (n-1) * n

faktorial (4)

Print output

24

Info

Jika anda bingung, anda bisa merujuk ke catatan tambahan Recursive Function Python

Anonymous Function

Anonymouse function didalam python disebut dengan lambda. Penggunaan fitur ini bermanfaat jika kita hanya ingin membuatsebuah fungsi simple, ditulis hanya dengan satu baris. Untuk membuat fungsi ini gunakan syntax dibawah ini;

Syntax

name_function = lambda [parameter_list] : return_expression

Oke, dibawah ini contoh implementasi penggunan lambda. Katakan kita ingin membuat sebuah fungsi untuk mengembalikan nilai genap.

Code

ambil_genap = lambda *lists : [a for a in lists if a%2 == 0]

jumlah(*range(20))

Print output

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Pada baris yang di hightlight kita menggunakan lambda function untuk mengembalikan nilai mana saja yang genap. Pada fungsi lambda diatas kita meenggunakan fitur yang telah kita bahas, Pada pemanggilan fungsi jumlah(*range(20)) kita menggunakan iterable unpacking, pada penetuan parameter lambda lambda *lists : menggunakan variable positional pamater, dan pada expression lambda menggunakan comprehension.

Function attributes

Setiap fungsi, khususnya pada sebuah objek yang besar memiliki atribut-atribut. Beberapa dari atribute tersebut dapat digunakan untuk meng-inspeksi fungsi tersebut saat runtime. attribute yang paling sering digunakan adalah __doc__, __name__, __qualname__, __module__, __defaults__, __code__, __globals__, __dict__, __closure__, __annotations__, __kwdefaults__, __builtins__.

Misalkan kita ingin mendapatkan dokumentasi dari objek pow

Code

Menggunakan fungsi getattr()Menggunakan atribute langsung dari objek

print(getattr(pow,"__doc__"))

print(pow.__doc__)

Built-in function

Python memliki fungsi bawaan yang dapat kita akses dari mana saja. Kita telah meyinnggunya pada Scope dan Name Resoulution ketika membahas bagaimana python mencari sebuah names dengan urutan Local, Enclosing, Global dan Built-in.

Untukmelihat daftar fungsi built_in anda dapat menggunakan dir() pada attribute __builtins__.

Code

[a for a in dir(__builtins__) if a[0].islower()][10:20] #(1)!

1. Saya hanya mengambil built-in function beberapa saja.

Print output

['chr',
'classmethod',
'compile',
'complex',
'copyright',
'credits',
'delattr',
'dict',
'dir',
'display']

Dokumentasi Kode

Saat membahas tentang attribute kita menggunakan contaoh attribute #!__doc__. Sekarang kita akan membahas cara membuat dokumentasi sehingga bisa diakes menggunakan attribute #!__doc__ atau fungsi built-in fungsi #!help().

Untuk membuat dokumentasi anda dapat mengikuti contoh dibawah.

Code

def contoh_doc(nama, tempat):
    """ Contoh dokumentasi

    Ini adalah dokumentasi yang berisikan penjelasan tentang fungsi ini. Fungsi ini,
    Fungsi ini,Fungsi ini,Fungsi ini,Fungsi ini,Fungsi ini.

    :param nama: Pembuat dokumentasi
    :param tempat: Tempat membuat dokumentasi
    :return: String detail hasil fungsi ini
    """

    return f'Nama {nama}, tempat {tempat}'

    help(contoh_doc)
    # Sama dengan print(contoh_doc.__doc__)

Print output

Contoh dokumentasi

    Ini adalah dokumentasi yang berisikan penjelasan tentang fungsi ini. Fungsi ini,
    Fungsi ini,Fungsi ini,Fungsi ini,Fungsi ini,Fungsi ini.

    :param nama: Pembuat dokumentasi
    :param tempat: Tempat membuat dokumentasi
    :return: String detail hasil fungsi ini

Import Objects

Tujuan utama kita membuat seuah fungsi adalah untuk dapat digunakan kembali tanpa harus menulis ulang kode dimanampun python program ditulis. Di python kita harus mengimport mereka (fungsi-fungsi dalam sebuah object atau module) dalam bentuk namespace di tempat dimana kita membutuhkan fungsi tersebut. Ada beberapa cara untuk mengimport objects dalam bentuk namespace, yang paling sering dipakai adalah.

1. import module_name
2. from module_name import function_name

Code

import numpy as np #(1)!
from numpy.random import standard_normal  #(2)!

1. Mengimport module name saja, penggunaan selanjutnya, misal np.random.standard_nromal().
2. Mengimport module name dan function name, penggunaan langsung memanggil nama fungsi standard_normal().