W jaki pythoniczny sposób można uniknąć parametrów domyślnych, które są pustymi listami?

Czasami wydaje się naturalne, że domyślny parametr jest pustą listą. Jednak w takich sytuacjach Python zachowuje się w nieoczekiwany sposób .

Jeśli na przykład mam funkcję:

def my_func(working_list = []):
    working_list.append("a")
    print(working_list)

Pierwsze wywołanie ustawienia domyślnego zadziała, ale późniejsze wywołania zaktualizują istniejącą listę (z jednym „a” na każde połączenie) i wydrukują zaktualizowaną wersję.

Jaki jest więc pythonowy sposób uzyskania pożądanego zachowania (nowa lista przy każdym połączeniu)?

def my_func(working_list=None):
    if working_list is None: 
        working_list = []

    working_list.append("a")
    print(working_list)

Dokumentacja mówi, że powinieneś używać go Nonejako domyślnego i jawnie testować go w treści funkcji.

Istniejące odpowiedzi dostarczyły już bezpośrednich rozwiązań, o które proszono. Jednakże, ponieważ jest to bardzo częsta pułapka dla nowych programistów Pythona, warto dodać wyjaśnienie, dlaczego python zachowuje się w ten sposób, co jest ładnie podsumowane w " The Hitchhikers Guide to Python " jako " Mutable Default Arguments ": http: // docs .python-guide.org / pl / latest / writing / gotchas /

Cytuj: „ Domyślne argumenty Pythona są oceniane raz, gdy funkcja jest zdefiniowana, a nie za każdym razem, gdy funkcja jest wywoływana (tak jak to jest w przypadku Rubiego). Oznacza to, że jeśli użyjesz zmiennego argumentu domyślnego i zmienisz go, będziesz zmutował ten obiekt również dla wszystkich przyszłych wywołań funkcji "

Przykładowy kod do implementacji:

def foo(element, to=None):
    if to is None:
        to = []
    to.append(element)
    return to

Nie ma to znaczenia w tym przypadku, ale możesz użyć tożsamości obiektu, aby przetestować brak:

if working_list is None: working_list = []

Możesz również skorzystać z tego, jak operator boolowski lub jest zdefiniowany w Pythonie:

working_list = working_list or []

Chociaż będzie to zachowywać się nieoczekiwanie, jeśli wywołujący poda pustą listę (która liczy się jako fałsz) jako working_list i oczekuje, że funkcja zmodyfikuje podaną przez niego listę.

Jeśli celem funkcji jest zmodyfikowanie parametru przekazanego jako working_list, zobacz odpowiedź HenryR (= None, sprawdź brak wewnątrz).

Ale jeśli nie zamierzałeś modyfikować argumentu, po prostu użyj go jako punktu wyjścia dla listy, możesz go po prostu skopiować:

def myFunc(starting_list = []):
    starting_list = list(starting_list)
    starting_list.append("a")
    print starting_list

(lub w tym prostym przypadku tylko, print starting_list + ["a"]ale myślę, że to był tylko przykład zabawki)

Ogólnie rzecz biorąc, mutowanie argumentów to zły styl w Pythonie. Jedynymi funkcjami, od których w pełni oczekuje się, że będą mutować obiekt, są metody obiektu. Jeszcze rzadziej mutuje się opcjonalny argument - czy efekt uboczny, który występuje tylko w niektórych wywołaniach, jest naprawdę najlepszym interfejsem?

• Jeśli robisz to z nawyku „argumentów wyjściowych” w języku C, jest to całkowicie niepotrzebne - zawsze możesz zwrócić wiele wartości jako krotkę.

• Jeśli robisz to, aby efektywnie budować długą listę wyników bez tworzenia list pośrednich, rozważ napisanie jej jako generatora i używanie go result_list.extend(myFunc())podczas wywoływania. W ten sposób konwencje powołania pozostają bardzo czyste.

Jednym ze wzorców, w którym często przeprowadza się mutację opcjonalnego argumentu, jest ukryty argument typu „memo” w funkcjach rekurencyjnych:

def depth_first_walk_graph(graph, node, _visited=None):
    if _visited is None:
        _visited = set()  # create memo once in top-level call

    if node in _visited:
        return
    _visited.add(node)
    for neighbour in graph[node]:
        depth_first_walk_graph(graph, neighbour, _visited)

Mogę być poza tematem, ale pamiętaj, że jeśli chcesz przekazać tylko zmienną liczbę argumentów, pythonowym sposobem jest przekazanie krotki *argslub słownika **kargs. Są one opcjonalne i lepsze niż składniamyFunc([1, 2, 3]) .

Jeśli chcesz przekazać krotkę:

def myFunc(arg1, *args):
  print args
  w = []
  w += args
  print w
>>>myFunc(1, 2, 3, 4, 5, 6, 7)
(2, 3, 4, 5, 6, 7)
[2, 3, 4, 5, 6, 7]

Jeśli chcesz przekazać słownik:

def myFunc(arg1, **kargs):
   print kargs
>>>myFunc(1, option1=2, option2=3)
{'option2' : 2, 'option1' : 3}

Udzielono już dobrych i poprawnych odpowiedzi. Chciałem tylko podać inną składnię do pisania tego, co chcesz zrobić, co uważam za piękniejsze, gdy na przykład chcesz utworzyć klasę z domyślnymi pustymi listami:

class Node(object):
    def __init__(self, _id, val, parents=None, children=None):
        self.id = _id
        self.val = val
        self.parents = parents if parents is not None else []
        self.children = children if children is not None else []

Ten fragment wykorzystuje składnię operatora if else. Podoba mi się to zwłaszcza dlatego, że jest to zgrabny, mały, jednolinijkowy tekst bez dwukropków itp. I prawie brzmi jak normalne angielskie zdanie. :)

W twoim przypadku mógłbyś pisać

def myFunc(working_list=None):
    working_list = [] if working_list is None else working_list
    working_list.append("a")
    print working_list

Wziąłem klasę rozszerzenia UCSC Python for programmer

Co jest prawdą w przypadku: def Fn (data = []):

a) to dobry pomysł, aby listy danych były puste przy każdym wywołaniu.

b) jest dobrym pomysłem, aby wszystkie wywołania funkcji, które nie dostarczają żadnych argumentów w wywołaniu, otrzymają pustą listę jako dane.

c) jest rozsądnym pomysłem, o ile twoje dane są listą ciągów.

d) to zły pomysł, ponieważ domyślne [] będzie gromadzić dane, a domyślne [] będzie się zmieniać wraz z kolejnymi wywołaniami.

Odpowiedź:

d) to zły pomysł, ponieważ domyślne [] będzie gromadzić dane, a domyślne [] będzie się zmieniać wraz z kolejnymi wywołaniami.