if title == user_input.upper():
That is, you convert a string to upper without binding the result to a name. You just use it in-place and discard the result, which is fine.With compiler, you mean mypy or linters?
>>> def up(v):
... v.upper()
...
>>> dis.dis(up)
2 0 LOAD_FAST 0 (v)
2 LOAD_METHOD 0 (upper)
4 CALL_METHOD 0
6 POP_TOP
8 LOAD_CONST 0 (None)
10 RETURN_VALUE
>>> def up(v):
... if v.upper() == "HelloWorld":
... return True
...
>>> dis.dis(up)
2 0 LOAD_FAST 0 (v)
2 LOAD_METHOD 0 (upper)
4 CALL_METHOD 0
6 LOAD_CONST 1 ('HelloWorld')
8 COMPARE_OP 2 (==)
10 POP_JUMP_IF_FALSE 16
3 12 LOAD_CONST 2 (True)
14 RETURN_VALUE
>> 16 LOAD_CONST 0 (None)
18 RETURN_VALUE
Notice in the first example, right after CALL_METHOD the return value on the stack is just immediately POP'd away. The parent is saying that when you run `python example.py` CPython should see that the return value is never used and emit a warning. This would only happen because `upper()` was manually marked using the suggested `must_use` annotation. msg.upper()
should trigger a warning as this clearly doesn't do anything.In fact, any program can replace anything on the fly, and swap your string for something similar but mutable.
It's the trade off you make when choosing it.
x if y else z
Is effectively syntax sugar for: y and x or z
Nothing is discarded after evaluation, one of three arms is never evaluated, just as one of two arms of a common short-circuiting Boolean operator often (but not always) is not. That's essentially the opposite of executing and producing possible side effects and then discarding the results.You can definitely catch most cases at runtime. I’ve done something like this, in an library, to catch a case where people were treating the copy of data as a mutable view.
interface[address][slice] = new_values # fancy noop
Where a read, modify, write was required: byte_values = interface[address]
byte_values[slice] = new_values
interface[address] = byte_values
It would log/raise a useful error if the there was no assignment/passing of the return value.The existence of mypy and other static type checkers for Python disproves that; given their existence, warning of an expression producing a type other than “any” or strictly “None” was used in a position where it would neither be passed to another function or assigned to a variable that is used later should be possible. Heck, you could be stricter and only allow strictly “None” in that position.