コミュニティ 学ぶ ツールライブラリ レジャー
検索
日本語
ホームページ > バックエンド開発 > Python チュートリアル > Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

王林
リリース： 2023-05-15 16:37:06
転載
866 人が閲覧しました

    まえがき

    次のプログラムの一部の出力結果をご存知ですか? 

    a = [1, 2, 3, 4]
b = a
print(f"{a = } \t|\t {b = }")
a[0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー
    a = [1, 2, 3, 4]
b = a.copy()
print(f"{a = } \t|\t {b = }")
a[0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー
    a = [[1, 2, 3], 2, 3, 4]
b = a.copy()
print(f"{a = } \t|\t {b = }")
a[0][0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー
    a = [[1, 2, 3], 2, 3, 4]
b = copy.copy(a)
print(f"{a = } \t|\t {b = }")
a[0][0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    a = [[1, 2, 3], 2, 3, 4]
b = copy.deepcopy(a)
print(f"{a = } \t|\t {b = }")
a[0][0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー

    Python オブジェクトのメモリ レイアウト

    Python でオブジェクトのメモリ アドレスを決定するにはどうすればよいでしょうか? Python には、オブジェクトのメモリ アドレスを取得する埋め込み関数 id() が用意されています: 

    a = [1, 2, 3, 4]
b = a
print(f"{a = } \t|\t {b = }")
a[0] = 100
print(f"{a = } \t|\t {b = }")
print(f"{id(a) = } \t|\t {id(b) = }")
# 输出结果
# a = [1, 2, 3, 4]  |  b = [1, 2, 3, 4]
# a = [100, 2, 3, 4]  |  b = [100, 2, 3, 4]
# id(a) = 4393578112  |  id(b) = 4393578112
    ログイン後にコピー

    実際には、上記のオブジェクトのメモリ レイアウトに問題があるか、精度が十分ではありません。さまざまなオブジェクト間の関係を表現することもできます。 Cpython では、各変数を、表現されるデータを指すポインターとして考えることができ、このポインターは Python オブジェクトのメモリ アドレスを保存します。

    Python では、リストには実際のデータではなく、各 Python オブジェクトへのポインターが実際に格納されます。したがって、上記の小さなコードは、次の図を使用してメモリ内のオブジェクトのレイアウトを表すことができます:

    Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

    変数 a はメモリ内のリスト [1, 2, 3, 4] を指します。リストには 4 つのデータがあります。これら 4 つのデータはポインタですこれら 4 つのポインタはメモリ内の 4 つのデータ 1、2、3、4 を指します。という疑問があるかもしれませんが、これは問題ではないでしょうか？これらはすべて整数データなので、なぜ整数データをリストに直接保存しないのでしょうか? なぜこのデータを指すポインターを追加する必要があるのでしょうか?

    実際、Python では、任意の Python オブジェクトをリストに格納できます。たとえば、次のプログラムは有効です: 

    data = [1, {1:2, 3:4}, {'a', 1, 2, 25.0}, (1, 2, 3), "hello world"]
    ログイン後にコピー

    The data type in the first data to last data in the上記リスト 対象: 整数データ、辞書、セット、タプル、文字列 さて、Python のこの機能を実現するには、ポインタの機能が要件を満たしているでしょうか?各ポインターは同じメモリを占有するため、配列を使用して Python オブジェクトのポインターを格納し、このポインターを実際の Python オブジェクトを指すようにすることができます。

    小刀

    上記の分析の後、次のコードとそのメモリ レイアウトを見てみましょう: 

    data = [[1, 2, 3], 4, 5, 6]
data_assign = data
data_copy = data.copy()
    ログイン後にコピー

    Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

    Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

    • data_assign = data、この代入ステートメントのメモリ レイアウトについては以前に説明しましたが、もう一度確認してみましょう。この代入ステートメントの意味は次のとおりです。 data_assign と data が指すデータが同じデータ、つまり同じリストであること。

    • data_copy = data.copy()、この代入ステートメントの意味は、data が指すデータの浅いコピーを作成し、data_copy を実行させることです。ここでの浅いコピーとは、リスト内のポインタが指すデータをコピーせずに、リスト内の各ポインタをコピーすることを意味します。上記のオブジェクトのメモリ レイアウト図から、data_copy が新しいリストを指していることがわかりますが、リスト内のポインタが指すデータは、データ リスト内のポインタが指すデータと同じです。緑の矢印、データで表されます。これを示すには黒の矢印を使用します。

    オブジェクトのメモリ アドレスを表示する

    前の記事では主にオブジェクトのメモリ レイアウトを分析しましたが、このセクションでは Python を使用して、これを検証するための非常に効果的なツールです。 Python では、オブジェクトのメモリ アドレスを表示するには id() を使用できます。id(a) は、オブジェクト a が指すオブジェクトのメモリ アドレスを表示します。

    次のプログラムの出力を見てください: 

    a = [1, 2, 3]
b = a
print(f"{id(a) = } {id(b) = }")
for i in range(len(a)):
    print(f"{i = } {id(a[i]) = } {id(b[i]) = }")
    ログイン後にコピー

    前の分析によると、a と b は同じメモリを指します。これは、2 つの変数が同じ Python オブジェクトを指すことを意味します。したがって、上記の出力 ID 結果 a と b は同じです。上記の出力結果は次のようになります:

    id(a) = 4392953984 id(b) = 4392953984
    i = 0 id (a[i]) = 4312613104 id(b[i]) = 4312613104
    i = 1 id(a[i]) = 4312613136 id(b[i]) = 4312613136
    i = 2 id( a [i]) = 4312613168 id(b[i]) = 4312613168

    浅いコピーのメモリ アドレスを見てください: 

    a = [[1, 2, 3], 4, 5]
b = a.copy()
print(f"{id(a) = } {id(b) = }")
for i in range(len(a)):
    print(f"{i = } {id(a[i]) = } {id(b[i]) = }")
    ログイン後にコピー

    以前の分析によると、呼び出しリストはそれ自体 copy メソッドはリストの浅いコピーを作成することです. これはリストのポインタ データをコピーするだけであり, リスト内のポインタが指す実際のデータはコピーしません. したがって, リスト内のデータを走査して取得する場合指されたオブジェクトのアドレス、リスト a とリスト b によって返される結果は同じですが、前の例と異なるのは、a と b によって指されるリストのアドレスが異なることです (データがコピーされるため、理解するには、以下の浅いコピーの結果を参照してください)。

    Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

    可以结合下面的输出结果和上面的文字进行理解：

    id(a) = 4392953984 id(b) = 4393050112 # 两个对象的输出结果不相等
i = 0 id(a[i]) = 4393045632 id(b[i]) = 4393045632 # 指向的是同一个内存对象因此内存地址相等 下同
i = 1 id(a[i]) = 4312613200 id(b[i]) = 4312613200
i = 2 id(a[i]) = 4312613232 id(b[i]) = 4312613232
    ログイン後にコピー

    copy模块

    在 python 里面有一个自带的包 copy ，主要是用于对象的拷贝，在这个模块当中主要有两个方法 copy.copy(x) 和 copy.deepcopy()。

    copy.copy(x) 方法主要是用于浅拷贝，这个方法的含义对于列表来说和列表本身的 x.copy() 方法的意义是一样的，都是进行浅拷贝。这个方法会构造一个新的 python 对象并且会将对象 x 当中所有的数据引用（指针）拷贝一份。

    Python でオブジェクトのコピーとメモリ レイアウトを実装する方法

    copy.deepcopy(x) 这个方法主要是对对象 x 进行深拷贝，这里的深拷贝的含义是会构造一个新的对象，会递归的查看对象 x 当中的每一个对象，如果递归查看的对象是一个不可变对象将不会进行拷贝，如果查看到的对象是可变对象的话，将重新开辟一块内存空间，将原来的在对象 x 当中的数据拷贝的新的内存当中。（关于可变和不可变对象我们将在下一个小节仔细分析）

    根据上面的分析我们可以知道深拷贝的花费是比浅拷贝多的，尤其是当一个对象当中有很多子对象的时候，会花费很多时间和内存空间。

    对于 python 对象来说进行深拷贝和浅拷贝的区别主要在于复合对象（对象当中有子对象，比如说列表，元祖、类的实例等等）。这一点主要是和下一小节的可变和不可变对象有关系。

    可变和不可变对象与对象拷贝

    在 python 当中主要有两大类对象，可变对象和不可变对象，所谓可变对象就是对象的内容可以发生改变，不可变对象就是对象的内容不能够发生改变。

    • 可变对象：比如说列表(list)，字典(dict)，集合(set)，字节数组(bytearray)，类的实例对象。

    • 不可变对象：整型(int)，浮点型(float)，复数(complex)，字符串，元祖(tuple)，不可变集合(frozenset)，字节(bytes)。

    看到这里你可能会有疑问了，整数和字符串不是可以修改吗？

    a = 10
a = 100
a = "hello"
a = "world"
    ログイン後にコピー

    比如下面的代码是正确的，并不会发生错误，但是事实上其实 a 指向的对象是发生了变化的，第一个对象指向整型或者字符串的时候，如果重新赋一个新的不同的整数或者字符串对象的话，python 会创建一个新的对象，我们可以使用下面的代码进行验证：

    a = 10
print(f"{id(a) = }")
a = 100
print(f"{id(a) = }")
a = "hello"
print(f"{id(a) = }")
a = "world"
print(f"{id(a) = }")
    ログイン後にコピー

    上面的程序的输出结果如下所示：

    id(a) = 4365566480
    id(a) = 4365569360
    id(a) = 4424109232
    id(a) = 4616350128

    可以看到的是当重新赋值之后变量指向的内存对象是发生了变化的（因为内存地址发生了变化），这就是不可变对象，虽然可以对变量重新赋值，但是得到的是一个新对象并不是在原来的对象上进行修改的！

    我们现在来看一下可变对象列表发生修改之后内存地址是怎么发生变化的：

    data = []
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
data.append(1)
print(f"{id(data) = }")
    ログイン後にコピー

    上面的代码输出结果如下所示：

    id(data) = 4614905664
    id(data) = 4614905664
    id(data) = 4614905664
    id(data) = 4614905664
    id(data) = 4614905664

    从上面的输出结果来看可以知道，当我们往列表当中加入新的数据之后（修改了列表），列表本身的地址并没有发生变化，这就是可变对象。

    我们在前面谈到了深拷贝和浅拷贝，我们现在来分析一下下面的代码：

    data = [1, 2, 3]
data_copy = copy.copy(data)
data_deep = copy.deepcopy(data)
print(f"{id(data ) = } | {id(data_copy) = } | {id(data_deep) = }")
print(f"{id(data[0]) = } | {id(data_copy[0]) = } | {id(data_deep[0]) = }")
print(f"{id(data[1]) = } | {id(data_copy[1]) = } | {id(data_deep[1]) = }")
print(f"{id(data[2]) = } | {id(data_copy[2]) = } | {id(data_deep[2]) = }")
    ログイン後にコピー

    上面的代码输出结果如下所示：

    id(data ) = 4620333952 | id(data_copy) = 4619860736 | id(data_deep) = 4621137024
    id(data[0]) = 4365566192 | id(data_copy[0]) = 4365566192 | id(data_deep[0]) = 4365566192
    id(data[1]) = 4365566224 | id(data_copy[1]) = 4365566224 | id(data_deep[1]) = 4365566224
    id(data[2]) = 4365566256 | id(data_copy[2]) = 4365566256 | id(data_deep[2]) = 4365566256

    看到这里你肯定会非常疑惑，为什么深拷贝和浅拷贝指向的内存对象是一样的呢？前列我们可以理解，因为浅拷贝拷贝的是引用，因此他们指向的对象是同一个，但是为什么深拷贝之后指向的内存对象和浅拷贝也是一样的呢？这正是因为列表当中的数据是整型数据，他是一个不可变对象，如果对 data 或者 data_copy 指向的对象进行修改，那么将会指向一个新的对象并不会直接修改原来的对象，因此对于不可变对象其实是不用开辟一块新的内存空间在重新赋值的，因为这块内存中的对象是不会发生改变的。

    我们再来看一个可拷贝的对象：

    data = [[1], [2], [3]]
data_copy = copy.copy(data)
data_deep = copy.deepcopy(data)
print(f"{id(data ) = } | {id(data_copy) = } | {id(data_deep) = }")
print(f"{id(data[0]) = } | {id(data_copy[0]) = } | {id(data_deep[0]) = }")
print(f"{id(data[1]) = } | {id(data_copy[1]) = } | {id(data_deep[1]) = }")
print(f"{id(data[2]) = } | {id(data_copy[2]) = } | {id(data_deep[2]) = }")
    ログイン後にコピー

    上面的代码输出结果如下所示：

    id(data ) = 4619403712 | id(data_copy) = 4617239424 | id(data_deep) = 4620032640
    id(data[0]) = 4620112640 | id(data_copy[0]) = 4620112640 | id(data_deep[0]) = 4620333952
    id(data[1]) = 4619848128 | id(data_copy[1]) = 4619848128 | id(data_deep[1]) = 4621272448
    id(data[2]) = 4620473280 | id(data_copy[2]) = 4620473280 | id(data_deep[2]) = 4621275840

    从上面程序的输出结果我们可以看到，当列表当中保存的是一个可变对象的时候，如果我们进行深拷贝将创建一个全新的对象（深拷贝的对象内存地址和浅拷贝的不一样）。

    代码片段分析

    经过上面的学习对于在本篇文章开头提出的问题对于你来说应该是很简单的，我们现在来分析一下这几个代码片段：

    a = [1, 2, 3, 4]
b = a
print(f"{a = } \t|\t {b = }")
a[0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー

    这个很简单啦，a 和 b 不同的变量指向同一个列表，a 中间的数据发生变化，那么 b 的数据也会发生变化，输出结果如下所示：

    a = [1, 2, 3, 4] | b = [1, 2, 3, 4]
    a = [100, 2, 3, 4] | b = [100, 2, 3, 4]
    id(a) = 4614458816 | id(b) = 4614458816

    我们再来看一下第二个代码片段

    a = [1, 2, 3, 4]
b = a.copy()
print(f"{a = } \t|\t {b = }")
a[0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー

    因为 b 是 a 的一个浅拷贝，所以 a 和 b 指向的是不同的列表，但是列表当中数据的指向是相同的，但是由于整型数据是不可变数据，当a[0] 发生变化的时候，并不会修改原来的数据，而是会在内存当中创建一个新的整型数据，因此列表 b 的内容并不会发生变化。因此上面的代码输出结果如下所示：

    a = [1, 2, 3, 4]  |  b = [1, 2, 3, 4]
a = [100, 2, 3, 4]  |  b = [1, 2, 3, 4]
    ログイン後にコピー

    再来看一下第三个片段：

    a = [[1, 2, 3], 2, 3, 4]
b = a.copy()
print(f"{a = } \t|\t {b = }")
a[0][0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー

    这个和第二个片段的分析是相似的，但是 a[0] 是一个可变对象，因此进行数据修改的时候，a[0] 的指向没有发生变化，因此 a 修改的内容会影响 b。

    a = [[1, 2, 3], 2, 3, 4]  |  b = [[1, 2, 3], 2, 3, 4]
a = [[100, 2, 3], 2, 3, 4]  |  b = [[100, 2, 3], 2, 3, 4]
    ログイン後にコピー

    最后一个片段：

    a = [[1, 2, 3], 2, 3, 4]
b = copy.deepcopy(a)
print(f"{a = } \t|\t {b = }")
a[0][0] = 100
print(f"{a = } \t|\t {b = }")
    ログイン後にコピー
    ログイン後にコピー

    深拷贝会在内存当中重新创建一个和a[0]相同的对象，并且让 b[0] 指向这个对象，因此修改 a[0]，并不会影响 b[0]，因此输出结果如下所示：

    a = [[1, 2, 3], 2, 3, 4]  |  b = [[1, 2, 3], 2, 3, 4]
a = [[100, 2, 3], 2, 3, 4]  |  b = [[1, 2, 3], 2, 3, 4]
    ログイン後にコピー

    撕开 Python 对象的神秘面纱

    我们现在简要看一下 Cpython 是如何实现 list 数据结构的，在 list 当中到底定义了一些什么东西：

    typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;

    /* ob_item contains space for 'allocated' elements.  The number
     * currently in use is ob_size.
     * Invariants:
     *     0 <= ob_size <= allocated
     *     len(list) == ob_size
     *     ob_item == NULL implies ob_size == allocated == 0
     * list.sort() temporarily sets allocated to -1 to detect mutations.
     *
     * Items must normally not be NULL, except during construction when
     * the list is not yet visible outside the function that builds it.
     */
    Py_ssize_t allocated;
} PyListObject;
    ログイン後にコピー

    在上面定义的结构体当中 ：

    allocated 表示分配的内存空间的数量，也就是能够存储指针的数量，当所有的空间用完之后需要再次申请内存空间。

    ob_item 指向内存当中真正存储指向 python 对象指针的数组，比如说我们想得到列表当中第一个对象的指针的话就是 list->ob_item[0]，如果要得到真正的数据的话就是 *(list->ob_item[0])。

    PyObject_VAR_HEAD 是一个宏，会在结构体当中定一个子结构体，这个子结构体的定义如下：

    typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;
    ログイン後にコピー

    这里我们不去谈对象 PyObject 了，主要说一下 ob_size，他表示列表当中存储了多少个数据，这个和 allocated 不一样，allocated 表示 ob_item 指向的数组一共有多少个空间，ob_size 表示这个数组存储了多少个数据 ob_size

    在了解列表的结构体之后我们现在应该能够理解之前的内存布局了，所有的列表并不存储真正的数据而是存储指向这些数据的指针。

    以上がPython でオブジェクトのコピーとメモリ レイアウトを実装する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

    関連ラベル：
    python
    ソース：yisu.com
    前の記事：Python を使用してダウンロードされた 11 の姿勢。それぞれ前回よりも高度です 次の記事：Pythonで小数点以下の桁数の問題を解く方法
    このウェブサイトの声明
    この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。
    著者別の最新記事
    最新の問題
    Python/MySQL は整数データを正しく保持できません ここではコードは必要ありません。ゲームを作成していてスコアを保存する必要があるため、非常に長い数値を保存したいと考えています。ただし、テストしてスコアを 25000000000 に...
    から 2024-04-04 19:09:44
    0
    1
    367
    Seleniumを使用してクラス内でURLをクリックして定義したい 今日はもう一つヒントが必要です。私は Python/Selenium コードを構築しようとしていますが、そのアイデアは www.thewebsiteIwantoclickon をク...
    から 2024-04-04 14:14:44
    0
    1
    3492
    Selenium + Python -execute_script を介して画像を検査します Python の Selenium を使用して画像がページに表示されることを確認する必要があります。たとえば、https://openweathermap.org/ ページの左上隅...
    から 2024-04-03 09:32:15
    0
    1
    375
    最初の X 行を保持し、テーブルの行を削除する方法 MySQLincident_archive に数百万のレコードを含む大きなテーブルがあります。作成した列で行をソートし、最初の X 行を保持し、残りを削除したいのですが、最も効率的...
    から 2024-04-01 18:32:54
    0
    1
    347
    BeautifulSoupを使用して特定のGoogle天気テキストをスクレイピングする方法は? BeautifulSoupを使用してPythonでコーステキスト「米国ニューヨーク市」を見つけるにはどうすればよいですか?練習のためにビデオをコピーしようとしましたが、うまくいきま...
    から 2024-04-01 14:06:14
    0
    1
    308
    関連トピック
    詳細>
    人気のおすすめ
    人気のチュートリアル
    詳細>
    関連するチュートリアル
    人気のおすすめ
    最新のコース
    最新のダウンロード
    詳細>
    ウェブエフェクト
    公式サイト
    サイト素材
    フロントエンドテンプレート