結果を保存しなければいけないメソッドとそうでないものの違いについての質問

気になったこと

replace()メソッドを使用していて気が付いたのですが、
例えば

python
1a = ['123','456']
2b = '123456123456'
3for i in a:
4    b.replace(i,"グループ"+str(a.index(i)))
5print(b)
6# >123456123456

のように書いた場合、bは置き換えられませんが、

python
1a = ['123','456']
2b = '123456123456'
3for i in a:
4    b=b.replace(i,"グループ"+str(a.index(i)))
5print(b)
6# >グループ0グループ1グループ0グループ1

とbに保存するように書くとbが置き換えられます。

しかし例えばappend()では、

python
1a = ['10']
2a.append('100')
3print(a)
4# >['10', '100']

のように、appendした結果をaに代入して保存しなくても、aが変わっています。

聞きたいこと

なぜappend()は replace()のように結果を代入しなくても良いのか。
結果を代入しなければ結果が変わらないメソッドは、これ以外に何があるか。

補足情報（FW/ツールのバージョンなど）

Python 3.9

B.J.Q

2023/11/28 08:13

具体的に何を調査すればよいのでしょうか

行動規範の内容に同意します

回答3件

なぜappend()は replace()のように結果を代入しなくても良いのか。

このメソッドを作った人(たち)がその方が便利/理に叶うと考えたからです。

結果を代入しなければ結果が変わらないメソッドは、これ以外に何があるか。

たくさんあります。 replaceのような文字列のメソッドはすべてそのようになっています。
また、数値演算系のメソッドも同様です。

使おうとしているメソッド/関数がどちらの性質のものなのかは、仕様を確認しなければわかりません。

pythonのデータにはミュータブルなデータとイミュータブルなデータがあります。
ミュータブルなデータというのは、リストや辞書などのように、そのオブジェクトが持つ値や性質・状態を替えることができるデータです。
イミュータブルなデータというのは、文字列や数値などのようにそのオブジェクトを変更できないものです。

文字列はイミュータブルなデータなので、それを変更するメソッドは常に変更を加えた後の新しいオブジェクトを返します。

python
1a = 'abc'
2b = a.replace('a', 'x')
3
4print(a)  # -> abc
5print(b)  # -> xbc

aに代入されている文字列'abc'を変更する方法が無いので、そういう仕様ですね。

ミュータブルなデータの場合、そのオブジェクトを変更することができるので、変更することが適切だったり、そもそも変更が求められている場合は、そのオブジェクトを変更するようになっています。

python
1a = ['10']
2b = a.append('100')
3
4print(a)  # ['10', '100']
5print(b)  # None

リストというのはそれそのものを操作することが目的で使うことがある(多い？)ので、変更できるようになっていて、変更するためのメソッド(関数)が用意されています。
仕様を見ると、copyメソッド以外はそのものを変更するメソッドになっていますね。
https://docs.python.org/ja/3/tutorial/datastructures.html
また、例に出てくるスタックやキューなどはリストを変更することで機能している例です。

ただ、そういうデータでも、元は替えたくないという場合もあります。
https://docs.python.org/ja/3/library/functions.html#sorted
リストのソートのためのsorted関数は、リストのメソッドではありませんが、整列されたリストを返します。

python
1a = [3, 1, 4, 1]
2y = a.sort()
3
4print(a)
5print(y)
6
7b = [3, 1, 4, 1]
8x = sorted(b)
9
10print(b)
11print(x)

sortメソッドはリストを変更しますが、sorted関数はソート済みの新たなリストを返します。

このように、データが変更可能だったとしても、必要であれば、元のデータを変更せずに新しいデータを作って返すようなメソッド/関数も作ることができるわけです。

投稿2023/11/28 08:43

TakaiY

総合スコア14307

(一応)公式のFAQもポイントしておきます。目は通しておくべきかと思いました。

https://docs.python.org/ja/3/faq/programming.html#why-did-changing-list-y-also-change-list-x

Python では一般に (そして標準ライブラリの全てのケースで)、このような 2 つのタイプの演算にまつわる混乱を避けるために、オブジェクトを変更するメソッドは None を返します。

メソッドの性質以上に、インスタンスの性質──ミュータブルなのかイミュータブルなのか──が関わっている話かと思います。

投稿2023/11/28 11:35

quickquip

総合スコア11299

ベストアンサー

具体的に何を調査すればよいのでしょうか

「結果を代入しなければ結果が変わらないメソッドは、これ以外に何があるか」については help で確認する方法があります。(str.replace では "Return a copy ..." と書かれています)

python
1>>> help(list.append)
2append(self, object, /)
3    Append object to the end of the list.
4
5>>> help(str.replace)
6replace(self, old, new, count=-1, /)
7    Return a copy with all occurrences of substring old replaced by new.
8
9>>> help(str.strip)
10strip(self, chars=None, /)
11    Return a copy of the string with leading and trailing whitespace removed.
12
13>>> help(str.upper)
14upper(self, /)
15    Return a copy of the string converted to uppercase.

「なぜappend()は replace()のように結果を代入しなくても良いのか」に関してですが、以下の記事が傍証になるかもしれません。
この記事は20年も前の投稿ですが、Python を作り出した Guido van Rossum によるものです。

[Python-Dev] sort() return value

I'd like to explain once more why I'm so adamant that sort() shouldn't return 'self'.

This comes from a coding style (popular in various other languages, I believe especially Lisp revels in it) where a series of side effects on a single object can be chained like this:

x.compress().chop(y).sort(z)

which would be the same as

x.compress()
x.chop(y)
x.sort(z)

I find the chaining form a threat to readability; it requires that the reader must be intimately familiar with each of the methods. The second form makes it clear that each of these calls acts on the same object, and so even if you don't know the class and its methods very well, you can understand that the second and third call are applied to x (and that all calls are made for their side-effects), and not to something else.

I'd like to reserve chaining for operations that return new values, like string processing operations:

y = x.rstrip("\n").split(":").lower()

There are a few standard library modules that encourage chaining of side-effect calls (pstat comes to mind). There shouldn't be any new ones; pstat slipped through my filter when it was weak.