Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Community Proposals
Community Proposals
tag:snake search within a tag
answers:0 unanswered questions
user:xxxx search by author id
score:0.5 posts with 0.5+ score
"snake oil" exact phrase
votes:4 posts with 4+ votes
created:<1w created < 1 week ago
post_type:xxxx type of post
Search help
Notifications
Mark all as read See all your notifications »
Users Search
Help Dashboard Sign In Sign Up
Q&A Code Reviews Meta
Q&A
Posts Tags Edits
Ask Question

Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Post History

50%
+1 −1
Q&A Understanding mutable default arguments in Python

Everything you put on the line with def is global (global to the file, not as in the global keyword), so the (initially empty) list you create with param=[] persists and gets reused between calls t...

posted 12mo ago by matthewsnyder‭  ·  edited 12mo ago by matthewsnyder‭

Answer
#6: Post edited by user avatar matthewsnyder‭ · 2023-12-02T19:43:45Z (12 months ago)
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python
  • * Implementation details of the interpreter
  • * The history of Python design decisions
  • * Why not just `def (param=None):`
  • * Why not just `if param:`
  • Please comment on this question if you do ask these separately, and want me to answer them.
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it. However, you will then have to add comments for other people who don't expect it, and IDEs which don't understand them, so they will not be so pithy in the end. You're best off just using the normal way above.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python
  • * Implementation details of the interpreter
  • * The history of Python design decisions
  • * Why not just `def (param=None):`
  • * Why not just `if param:`
  • Please comment on this question if you do ask these separately, and want me to answer them.
#5: Post edited by user avatar matthewsnyder‭ · 2023-12-02T19:41:13Z (12 months ago)
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python
  • * Implementation details of the interpreter
  • * The history of Python design decisions
  • * Why the normal way has `: list | None`
  • * Why the normal way doesn't just do `if param:`
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python
  • * Implementation details of the interpreter
  • * The history of Python design decisions
  • * Why not just `def (param=None):`
  • * Why not just `if param:`
  • Please comment on this question if you do ask these separately, and want me to answer them.
#4: Post edited by user avatar matthewsnyder‭ · 2023-12-02T19:40:09Z (12 months ago)
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python - a big topic and almost a red herring in this case
  • * Implementation details of the interpreter - very advanced topic that will not be accessible to someone who gets confused about the above
  • * The history of Python design decisions - many people have contributed to the language over 30+ years and it continues to evolve
  • * Why the normal way has `: list | None` - type hints, long story
  • * Why the normal way doesn't just do `if param:` - in case user wants to mutate their own empty list, long story
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python
  • * Implementation details of the interpreter
  • * The history of Python design decisions
  • * Why the normal way has `: list | None`
  • * Why the normal way doesn't just do `if param:`
#3: Post edited by user avatar matthewsnyder‭ · 2023-12-02T19:39:47Z (12 months ago)
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python - a big topic and almost a red herring in this case
  • * Implementation details of the interpreter - very advanced topic that will not be accessible to someone who gets confused about the above
  • * The history of Python design decisions - many people have contributed to the language over 30+ years and it continues to evolve
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python - a big topic and almost a red herring in this case
  • * Implementation details of the interpreter - very advanced topic that will not be accessible to someone who gets confused about the above
  • * The history of Python design decisions - many people have contributed to the language over 30+ years and it continues to evolve
  • * Why the normal way has `: list | None` - type hints, long story
  • * Why the normal way doesn't just do `if param:` - in case user wants to mutate their own empty list, long story
#2: Post edited by user avatar matthewsnyder‭ · 2023-12-02T19:37:54Z (12 months ago)
  • Everything you put on the line with `def` is *global*, so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python - a big topic and almost a red herring in this case
  • * Implementation details of the interpreter - very advanced topic that will not be accessible to someone who gets confused about the above
  • * The history of Python design decisions - many people have contributed to the language over 30+ years and it continues to evolve
  • Everything you put on the line with `def` is *global* (global to the file, not as in the `global` keyword), so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.
  • The normal way is:
  • ```
  • def example(param: list | None = None):
  • if param is None:
  • param = []
  • ```
  • Python is powerful and fun, so you can come up with more pithy ways of doing it like:
  • ```
  • def example(param=[]):
  • if param == []:
  • param = []
  • ```
  • These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.
  • I think other details are best addressed in separate questions, such as:
  • * Mutable vs. immutable in Python - a big topic and almost a red herring in this case
  • * Implementation details of the interpreter - very advanced topic that will not be accessible to someone who gets confused about the above
  • * The history of Python design decisions - many people have contributed to the language over 30+ years and it continues to evolve
#1: Initial revision by user avatar matthewsnyder‭ · 2023-12-02T19:37:16Z (12 months ago) 
Everything you put on the line with `def` is *global*, so the (initially empty) list you create with `param=[]` persists and gets reused between calls to `example()`. You probably want to create a *local* list for each invocation instead. For that, you have to find a way to put `param = []` inside the method.

The normal way is:
```
def example(param: list | None = None):
    if param is None:
        param = []
```

Python is powerful and fun, so you can come up with more pithy ways of doing it like:
```
def example(param=[]):
    if param == []:
        param = []
```

These are neat but people will not be expecting them and will get confused, so you will have to leave comments explaining it. You will also have to leave comments for the IDE, because it's not smart enough to realize the problem is solved. After all these comments, your solution will turn out to be not so pithy, so in the end you are better off just using the normal way I gave.

I think other details are best addressed in separate questions, such as:

* Mutable vs. immutable in Python - a big topic and almost a red herring in this case
* Implementation details of the interpreter - very advanced topic that will not be accessible to someone who gets confused about the above
* The history of Python design decisions - many people have contributed to the language over 30+ years and it continues to evolve