Аргумент за замовчуванням, що змінюється Python: чому?

Я знаю, що аргументи за замовчуванням створюються в час ініціалізації функції, і не кожен раз, коли функція викликається. Дивіться наступний код:

def ook (item, lst=[]):
    lst.append(item)
    print 'ook', lst

def eek (item, lst=None):
    if lst is None: lst = []
    lst.append(item)
    print 'eek', lst

max = 3
for x in xrange(max):
    ook(x)

for x in xrange(max):
    eek(x)

Чого я не розумію, це тому, що це було реалізовано таким чином. Які переваги пропонує така поведінка над ініціалізацією під час кожного виклику?

Я думаю, що причина - простота в реалізації. Дозвольте мені детальніше.

Значення за замовчуванням функції - це вираз, який потрібно оцінити. У вашому випадку це простий вираз, який не залежить від закриття, але це може бути щось, що містить вільні змінні - def ook(item, lst = something.defaultList()). Якщо ви плануєте розробляти Python, у вас буде вибір - чи оцінюєте ви його один раз, коли функція визначена, або кожен раз, коли функція викликається. Python вибирає перший (на відміну від Ruby, який йде з другим варіантом).

Для цього є деякі переваги.

По-перше, ви отримуєте деяке збільшення швидкості та пам’яті. У більшості випадків у вас будуть незмінні аргументи за замовчуванням, і Python може сконструювати їх лише один раз, замість кожного виклику функції. Це економить (деяку) пам’ять та час. Звичайно, це не дуже добре працює з змінними значеннями, але ви знаєте, як можна обійтись.

Ще одна перевага - простота. Досить просто зрозуміти, як оцінюється вираз - він використовує лексичну область, коли функція визначена. Якщо вони пішли іншим шляхом, лексична область може змінитись між визначенням і викликом і зробити його дедалі складніше налагодження. Python проходить довгий шлях, щоб бути надзвичайно простим у тих випадках.

Один із способів сказати, що параметр lst.append(item) не мутує lstпараметр. lstяк і раніше посилається на той самий список. Просто вміст цього списку було вимкнено.

В принципі, Python взагалі не має (я пам’ятаю) жодних постійних чи незмінних змінних - але він має деякі постійні незмінні типи. Ви не можете змінити ціле значення, ви можете лише замінити його. Але ви можете змінювати вміст списку, не замінюючи його.

Як ціле число, ви не можете змінити посилання, ви можете лише замінити його. Але ви можете змінити вміст об'єкта, на який посилається.

Щодо створення об’єкта за замовчуванням один раз, я думаю, що це здебільшого як оптимізація, щоб заощадити на створенні об'єктів та збору сміття.

Які переваги пропонує така поведінка над ініціалізацією під час кожного виклику?

Це дозволяє вам вибрати поведінку, яку ви хочете, як ви продемонстрували у своєму прикладі. Отже, якщо ви хочете, щоб аргумент за замовчуванням був незмінним, ви використовуєте незмінне значення , наприклад, Noneабо 1. Якщо ви хочете зробити аргумент за замовчуванням зміним, ви використовуєте щось, що змінюється, наприклад []. Це просто гнучкість, хоча це, правда, може вкусити, якщо ви цього не знаєте.

Я думаю, що справжня відповідь така: Python був написаний як процедурна мова і лише прийняв функціональні аспекти після факту. Те, що ви шукаєте, - це те, що параметри за замовчуванням будуть зроблені як закриття, а закриття в Python насправді лише напівфабрикати. Для підтвердження цього спробуйте:

a = []
for i in range(3):
    a.append(lambda: i)
print [ f() for f in a ]

що дає [2, 2, 2]можливість очікувати справжнього закриття [0, 1, 2].

Дуже багато речей, які б мені хотілося, якби Python мав змогу завершувати параметри за замовчуванням у закриттях. Наприклад:

def foo(a, b=a.b):
    ...

Було б надзвичайно зручно, але "a" не є сферою в час визначення функції, тому ви не можете цього зробити, а замість цього потрібно зробити незграбний:

def foo(a, b=None):
    if b is None:
        b = a.b

Що майже те саме ... майже.

Величезна користь - це запам'ятовування. Це стандартний приклад:

def fibmem(a, cache={0:1,1:1}):
    if a in cache: return cache[a]
    res = fib(a-1, cache) + fib(a-2, cache)
    cache[a] = res
    return res

і для порівняння:

def fib(a):
    if a == 0 or a == 1: return 1
    return fib(a-1) + fib(a-2)

Вимірювання часу в ipython:

In [43]: %time print(fibmem(33))
5702887
CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 200 µs

In [43]: %time print(fib(33))
5702887
CPU times: user 1.44 s, sys: 15.6 ms, total: 1.45 s
Wall time: 1.43 s

Це відбувається тому, що компіляція в Python виконується шляхом виконання описового коду.

Якщо хтось сказав

def f(x = {}):
    ....

було б цілком зрозуміло, що ви хотіли кожного разу новий масив.

Але що робити, якщо я скажу:

list_of_all = {}
def create(stuff, x = list_of_all):
    ...

Тут я б здогадався, що хочу створити матеріали в різні списки і мати єдиний глобальний підсумок, коли я не вказую список.

Але як би компілятор здогадався про це? То навіщо намагатися? Ми можемо розраховувати на те, назвали це чи ні, і це може допомогти іноді, але насправді це просто здогадки. При цьому є вагома причина не пробувати - послідовність.

Як і є, Python просто виконує код. Змінна list_of_all вже призначена об'єкту, так що цей об'єкт передається посиланням на код, який за замовчуванням x таким же чином, що виклик будь-якої функції отримає посилання на локальний об'єкт, названий тут.

Якби ми хотіли відрізнити неназваний від названого випадку, це включало б код при компіляції, що виконує призначення, значно іншим чином, ніж це виконується під час виконання. Тому ми не робимо особливого випадку.

Це відбувається тому, що функції в Python є першокласними об'єктами :

Значення параметрів за замовчуванням оцінюються, коли виконується визначення функції. Це означає, що вираз оцінюється один раз , коли функція визначена, і що для кожного виклику використовується те саме «попередньо обчислене» значення .

Далі пояснюється, що редагування значення параметра змінює значення за замовчуванням для наступних викликів, і що просте рішення використання None як типового, з явним тестом у тілі функцій, - все, що потрібно для забезпечення несподіванок.

Що означає, що він def foo(l=[])стає екземпляром цієї функції при виклику і повторно використовується для подальших дзвінків. Розгляньте параметри функції як розрізнення атрибутів об'єкта.

Професійні програми можуть включати використання цього класу, щоб мати класи-статичні змінні у C. Тож найкраще оголосити значення за замовчуванням None та ініціалізувати їх за потребою:

class Foo(object):
    def bar(self, l=None):
        if not l:
            l = []
        l.append(5)
        return l

f = Foo()
print(f.bar())
print(f.bar())

g = Foo()
print(g.bar())
print(g.bar())

врожайність:

[5] [5] [5] [5]

замість несподіваного:

[5] [5, 5] [5, 5, 5] [5, 5, 5, 5]