Software Development

#6: Post edited by

matthewsnyder‭ · 2023-12-02T19:43:45Z (5 months ago)

Copy Link

Raw

Markdown

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

matthewsnyder‭ · 2023-12-02T19:41:13Z (5 months ago)

Copy Link

Raw

Markdown

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

matthewsnyder‭ · 2023-12-02T19:40:09Z (5 months ago)

Copy Link

Raw

Markdown

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

matthewsnyder‭ · 2023-12-02T19:39:47Z (5 months ago)

Copy Link

Raw

Markdown

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

matthewsnyder‭ · 2023-12-02T19:37:54Z (5 months ago)

Copy Link

Raw

Markdown

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

matthewsnyder‭ · 2023-12-02T19:37:16Z (5 months ago)

Copy Link

Raw

Markdown

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

Communities

Post History