Come risolvere TypeError: unsupported operand type(s) per -: 'str' e 'str' in Python

OK. Le probabilità sono che quegli "operandi" dovrebbero essere stati convertiti in tipi numerici (come int) ad un certo punto. In questo caso, TL;DR e leggi la risposta di Tony Flury, che lo spiega accuratamente, meglio di quanto potrei fare io.

Tuttavia, c'è ancora una possibilità che tu fossi ben consapevole che queste erano stringhe (diciamo, a e b), e volevi sottrarle comunque. In questo caso, assumiamo che il risultato desiderato fosse la cosa più ragionevole da aspettarsi, che, per me, è rimuovere ogni occorrenza di b da a.

Se trovate questa assunzione troppo pericolosa, allora questo spiega automaticamente perché non c'è un operatore predefinito per la sottrazione di stringhe in Python. (a parte, naturalmente, il fatto che porterebbe a risultati sconcertanti, come '150'-'5' == '10', e che questo tipo di sottrazione non è simmetrico all'addizione, il che significa che a-b+b non porterebbe quasi mai ad a, a meno che b si trovi solo una volta, alla fine di a).

Le buone notizie sono che c'è un metodo per le stringhe che può ottenere questo facilmente, chiamato replace, quindi, chiamandolo su una stringa per sostituire una sottostringa con una vuota, farebbe il trucco. Per esempio, per rimuovere "bad" dalla stringa "questo è un cattivo esempio", si potrebbe scrivere

1. 'questo è un cattivo esempio'.replace('bad', '') 

However, if you find that using ‘-’ operator on strings is critical for the readability of your code, you can always create a new string subclass that implements this behavior.

Then, having started with arithmetic operations on strings, why not division, too? Not too apparent what we would expect it to do, though…

Let’s say, that when called with a string as second operand, it splits the first one by that, or, with an int (say n) as a second operand, it ‘divides’ the string to n, same-sized segments.

What about the remainder? Well, let’s implement that, too. A mod, it is :-)

1. # Some preparation stuff for the example to work in both Py2 & 3... 
2. from six import PY2, integer_types 
3. if PY2: 
4. from types import StringType 
5. else: 
6. StringType = str 
7.  
8.  
9. class Thong(StringType): 
10. """ A string ... with extras """ 
11.  
12. def __sub__(self, other): 
13. """ Remove from self all occurrences of 'other' """ 
14. return self.replace(other, '') 
15.  
16. def __div__(self, other): 
17. """ String division: 
18. if 'other' is a string, split self by that string 
19. if 'other' is a number, slice self in that number of same-sized  
20. segments  
21. regretfully, not symmetric with multiplication """ 
22.  
23. if isinstance(other, (integer_types, float)): 
24. seglen = int(len(self)/other) 
25. return [self[n-seglen:n] for n in range(seglen, len(self)+1, seglen)] 
26.  
27. # else: # possibly isinstance(other, (string_types)) 
28. return self.split(other) 
29.  
30. def __mod__(self, other): 
31. """ String modulo: 
32. Return what remained from string division with 'other' """ 
33. # if isinstance(other, (integer_types, float)):  
34. # let it raise for incompatible types 
35. seglen = int(len(self)/other) 
36. return self[other*seglen:] 
37.  
38. # examples 
39. if __name__ == '__main__': 
40. t = Thong("this is a test string") 
41. print(t - "is") 
42. print(t / 5) 
43. print(t % 5) 
44. # note that we also get -= as a bonus :-) 
45. t-="a " 
46. print(t) 

OK, OK, this is the kind of meaningless operator overloading that Linus used to criticize on C++ …

But when programming purely for fun, I guess it doesn’t hurt :-)