彻底理解Python中浅拷贝和深拷贝的区别

article/2025/10/5 16:08:32

目录

前言

1. 浅拷贝和深拷贝的概念

2. is和==的区别

3. 赋值操作

4. copy模块里面的copy()方法

5. copy模块里面的deepcopy()方法

6.字典自带的copy方法

7.切片表达式拷贝

8.总结

前言

Python 的所有变量其实都是指向内存中的对象的一个指针，这确实和之前学过的强类型语言（Java）是有不同的。在Java中基本数据类型数据直接存储在栈(stack)中，引用数据类型数据存储的是该对象在栈中引用，真实的数据存放在堆内存里，引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

而在Python中因为变量是指针，所以所有的变量无类型限制，可以指向任意对象。指针的内存空间大小是与类型无关的，其内存空间只是保存了所指向数据的内存地址。

对象还分两类：一类是可修改的，一类是不可修改的。可修改(mutable)的类型叫做值类型，不可修改(immutable)类型叫做引用类型。

不可变(immutable)对象类型

int，float，decimal，complex，bool，str，tuple，range，frozenset，bytes

可变(mutable)对象类型

list，dict，set，bytearray，user-defined classes (unless specifically made immutable)

为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(唯一标识符，标识符是一个整数）其实，这里所谓的身份，就是该对象的内存地址。

a = 1

print(id(a))

print(hex(id(a)))

在我的计算机上，它们返回的是:

11246696 '0xab9c68'

分别为内存地址的十进制和十六进制表示。

1. 浅拷贝和深拷贝的概念

以下分别是百度百科对浅拷贝和深拷贝的定义：

浅拷贝：

浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

深拷贝：

深拷贝会拷贝所有的属性，并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。深拷贝相比于浅拷贝速度较慢并且花销较大。

简单说就是：

浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存。

深拷贝会创造一个一模一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象。

在python中

浅拷贝(copy())：拷贝父对象，不会拷贝对象内部的子对象。

深拷贝(deepcopy())：是copy模块中的方法，完全拷贝了子对象和父对象

2. is和==的区别

python是一种面向对象的语言，python中对象包含三种基本要素：id(返回的是对象的地址)、type(返回的是对象的数据类型)及value(对象的值)。

is和==都可以对两个对象进行比较，而且它们的返回值都是布尔类型。但是它们比较的内容是不同的，不然两个函数的作用就重复了。首先我们来看下例子，从实际操作中来看下二者的区别。

 从上面的例子可以得出，is和==比较的对象的内容时不同的，即：is比较的是两个对象的地址值，也就是说两个对象是否为同一个实例对象；而==比较的是对象的值是否相等，其调用了对象的__eq__()方法。

那么怎么才能让两个对象的地址值相等呢，如果想让一个对象ls2 is ls1返回True应该怎么操作呢，我们可以把ls1赋值给ls2，这样ls1和ls2指向的就是同一个内存地址，ls1 == ls2和ls1 is ls2返回的都是True。如下图所示：

3. 赋值操作

在上面提到了赋值操作， 在python中对象赋值实际上是对象的引用。当创建一个对象，然后把它赋值给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。

ls1 = ls赋值引用，ls1和ls都指向同一个对象。内存图如下所示： 

综上，赋值操作只是浅拷贝传递对象的引用而已，原始列表改变，被赋值的变量也会做相同的改变，所以属于浅拷贝。

前面讲到python中分为可变类型和不可变类型，下面分别按照这2种类型介绍浅拷贝和深拷贝。

4. copy模块里面的copy()方法

可变类型和不可变类型在浅拷贝中的区别

# coding=utf-8import copy'''
不可变类型Number String Tuple
'''
num1 = 17
num2 = copy.copy(num1)print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同str1 = "hello"
str2 = copy.copy(str1)
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同tup1 = (18, "tom")
tup2 = copy.copy(tup1)
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同'''
可变类型List、Dictionary、Set
'''
list1 = [11,12]
list2 = copy.copy(list1)
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同dic1 = {"key": "hello", "num": 18}
dic2 = copy.copy(dic1)
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同set1 = {"AA","BB"}
set2 = copy.copy(set1)
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同输出结果：
num1:58549080
num2:58549080
str1:60653712
str2:60653712
tup1:60127112
tup2:60127112
list1:60101000
list2:60190344
dic1:60203624
dic2:60205528
set1:60064936
set2:60064712

从以上输出结果可以看到：

  • 对于不可变类型 Number String Tuple，浅复制仅仅是地址指向，不会开辟新空间拷贝值
  • 对于可变类型 List、Dictionary、Set，浅复制会开辟新的空间地址，进行浅拷贝

那如果对对象作出修改操作呢？

1）最外层的数据类型是不可变的，内层数据是可变的

import copy'''
最外层的数据类型是不可变的，内层数据是可变的
'''
a=[34, 56]
b=[89, 37]
c=(a, b)
d=copy.copy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))a.append(90)
print("c: %s" % str(c))
print("d: %s" % str(d))输出结果：
c: ([34, 56], [89, 37])
d: ([34, 56], [89, 37])
id(a): 56627592
id(b): 56639880
id(c): 56640648
id(d): 56640648
id(c[0]): 56627592
id(c[1]): 56639880
id(d[0]): 56627592
id(d[1]): 56639880
c: ([34, 56, 90], [89, 37])
d: ([34, 56, 90], [89, 37])

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行浅拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。当a发生变化后，d也随之发生了变更。

2）最外层的数据类型是不可变的，内层数据也是不可变的

import copy'''
最外层的数据类型是不可变的，内层数据也是不可变的
'''
a=(34, 56)
b=(89, 37)
c=(a, b)
d=copy.copy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))输出结果：
c: ((34, 56), (89, 37))
d: ((34, 56), (89, 37))
id(a): 59722120
id(b): 59722184
id(c): 59720840
id(d): 59720840
id(c[0]): 59722120
id(c[1]): 59722184
id(d[0]): 59722120
id(d[1]): 59722184

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行浅拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。

3）最外层的数据类型是可变的，内层数据也是可变的

import copy'''
最外层的数据类型是可变的，内层数据也是可变的
'''
a=[34, 56]
b=[89, 37]
c=[a, b]
d=copy.copy(c)
print("c: %s" % c)
print("d: %s" % d)print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))a.append(90)
print("c: %s" % c)
print("d: %s" % d)输出结果：
c: [[34, 56], [89, 37]]
d: [[34, 56], [89, 37]]
id(a): 59249032
id(b): 59261320
id(c): 59263624
id(d): 59338568
id(d[0]): 59249032
id(d[1]): 59261320
c: [[34, 56, 90], [89, 37]]
d: [[34, 56, 90], [89, 37]]

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行浅拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。当a发生变化后，d也随之发生了变更。

4）最外层的数据类型是可变的，内层数据是不可变的

import copy'''
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。
最外层的数据类型是可变的，内层数据是不可变的
'''
a=(34, 56)
b=(89, 37)
c=[a, b]
d=copy.copy(c)
print("c: %s" % c)
print("d: %s" % d)print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))输出结果：
c: [(34, 56), (89, 37)]
d: [(34, 56), (89, 37)]
id(a): 52381896
id(b): 52381960
id(c): 52367752
id(d): 52448968
id(d[0]): 52381896
id(d[1]): 52381960

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行浅拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。

综上，可以得出结论：

浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。使用浅拷贝的时候，分为两种情况。
第一种，如果最外层的数据类型是可变的，比如说列表，字典等，浅拷贝会开启新的地址空间去存放。
第二种，如果最外层的数据类型是不可变的，比如元组，字符串等，浅拷贝对象的时候，还是引用对象的地址空间。
 

5. copy模块里面的deepcopy()方法

1）最外层的数据类型是不可变的，内层数据是可变的

import copy'''
最外层的数据类型是不可变的，内层数据是可变的
'''
a=[34, 56]
b=[89, 37]
c=(a, b)
d=copy.deepcopy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))a.append(90)
print("c: %s" % str(c))
print("d: %s" % str(d))输出结果：
c: ([34, 56], [89, 37])
d: ([34, 56], [89, 37])
id(a): 52367752
id(b): 52380040
id(c): 52380808
id(d): 52380872
id(c[0]): 52367752
id(c[1]): 52380040
id(d[0]): 52382472
id(d[1]): 52457160
c: ([34, 56, 90], [89, 37])
d: ([34, 56], [89, 37])

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行深拷贝的时候，内层元素也开辟了新的地址空间存放。当a发生变化后，d并没有发生变更。

2）最外层的数据类型是不可变的，内层数据也是不可变的

import copy'''
最外层的数据类型是不可变的，内层数据也是不可变的
'''
a=(34, 56)
b=(89, 37)
c=(a, b)
d=copy.deepcopy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))输出结果：
c: ((34, 56), (89, 37))
d: ((34, 56), (89, 37))
id(a): 48187848
id(b): 48187912
id(c): 48186504
id(d): 48186504
id(c[0]): 48187848
id(c[1]): 48187912
id(d[0]): 48187848
id(d[1]): 48187912

从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行深拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行深拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。

3）最外层的数据类型是可变的，内层数据也是可变的

import copy'''
最外层的数据类型是可变的，内层数据也是可变的
'''
a=[34, 56]
b=[89, 37]
c=[a, b]
d=copy.deepcopy(c)
print("c: %s" % c)
print("d: %s" % d)print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))a.append(90)
print("c: %s" % c)
print("d: %s" % d)输出结果：
c: [[34, 56], [89, 37]]
d: [[34, 56], [89, 37]]
id(a): 59380104
id(b): 59392392
id(c): 59394696
id(d): 59394824
id(d[0]): 59469512
id(d[1]): 59469768
c: [[34, 56, 90], [89, 37]]
d: [[34, 56], [89, 37]]

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行深拷贝的时候，内层元素也开辟了新的地址空间存放。当a发生变化后，d并没有发生变更。

4）最外层的数据类型是可变的，内层数据是不可变的

import copy'''
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。
最外层的数据类型是可变的，内层数据是不可变的
'''
a=(34, 56)
b=(89, 37)
c=[a, b]
d=copy.deepcopy(c)
print("c: %s" % c)
print("d: %s" % d)print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))输出结果：
c: [(34, 56), (89, 37)]
d: [(34, 56), (89, 37)]
id(a): 45041928
id(b): 45041992
id(c): 45027720
id(d): 45040008
id(d[0]): 45041928
id(d[1]): 45041992

从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行深拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。

综上，可以得出结论：

深拷贝对一个对象是所有层次的拷贝（递归），内部和外部都会被拷贝过来。
深拷贝也分两种情况：
第一种，最外层数据类型可变。外层的会新开辟地址空间存放。如果里面是可变数据类型，内部会新开辟地址空间存放。如果内部数据类型不可变，内部则是对地址的引用。
第二种，外层数据类型不可变，如果内部数据是可变数据类型，外部和内部都会新开辟地址空间存放。如果内部数据类型不可变，外部和内部都是对地址的引用。

6.字典自带的copy方法

dict_1 = {"key1":[1,2,3,4],"key2":"val2"}
dict_2 = dict_1.copy()
dict_1["key1"].append(5)
print("id(dict_1)",id(dict_1),id(dict_1["key1"]),dict_1)
print("id(dict_2)",id(dict_2),id(dict_1["key1"]),dict_2)输出结果：
('id(dict_1)', 43262840L, 48538120L, {'key2': 'val2', 'key1': [1, 2, 3, 4, 5]})
('id(dict_2)', 48598552L, 48538120L, {'key2': 'val2', 'key1': [1, 2, 3, 4, 5]})

可以看出，父对象被拷贝到了一个新内存地址，但是对于子对象只是引用了它的内存地址，并没有拷贝子对象里面可迭代的内容。如果子对象里面的内容修改后，被赋值的变量也会做相同的改变，所以字典中的copy方法属于浅拷贝。

7.切片表达式拷贝

num1 = [1, 2, 3, [4, 5]]
num2 = num1[:]
num1[0] = 0
num1.append(5)
num1[3].append(6)
print(num1, id(num1))
print(num2, id(num2))
print(num1[3], id(num1[3]))
print(num2[3], id(num2[3]))输出结果：
([0, 2, 3, [4, 5, 6], 5], 57012616L)
([1, 2, 3, [4, 5, 6]], 57012744L)
([4, 5, 6], 57000328L)
([4, 5, 6], 57000328L)

由此可见，切片操作并没有复制可变类型的元素而是复制了可变类型的地址，相当于浅拷贝。

8.总结

首先深拷贝和浅拷贝都是对象的拷贝，都会生成一个看起来相同的对象，他们本质的区别是拷贝出来的对象的地址是否和原对象一样
(1)深拷贝：拷贝了一份与原对象不同地址的对象，修改对象中的任何值，都不会改变深拷贝的对象的值。
(2)浅拷贝：对原对象值的拷贝，地址仍然指向原对象的地址，原对象的值发生变化，拷贝对象的值也会随着改变。
(3)深拷贝和浅拷贝需要注意的地方是：可变元素的拷贝
在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象里的地址是相同的。也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去，而是和原对象里的指向同一个地址。

下面解释可变类型和不可变类型的嵌套使用：

（1）可变类型:
浅拷贝和深拷贝只要最外层是可变类型都会生成新的对象

  • [] 或者{}, 浅拷贝和深拷贝都会生成新的对象
  • [[],[]]列表的嵌套，可变类型嵌套了可变类型，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，都是全新的对象，都有独立的存储空间
  • [(),()] 外层可变，内层不可变，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，外层会生成新对象，但是由于内层是不可变类型，所以内层依然是引用
  • [(),[]] 外层可变，内层有一个是可变，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，外层会生成新对象，内层可变对象会生成新对象，内层不可变对象是引用

（2）不可变类型:
最外层是不可变类型，浅拷贝就一定是引用

  • Number、字符串或者(), 浅拷贝和深拷贝都是引用
  • ([],[]), copy浅拷贝：只会拷贝最外层，内层只是引用，但是最外层是不可变，拷贝之后毫无意义，仅仅是引用关系。deepcopy：从外层到内层都会拷贝，内层是可变，为了达到和原来的数据完全隔离，会生成全新的对象
  • ((),()) 完全不可变，拷贝了之后如果生成新的数据也无法修改，所以不管深拷贝还是浅拷贝都是引用
  • ((),[]) 外层不可变，但是内层有一个是可变，copy依然是引用，deepcopy,会生成新的对象，内层的不可变类型是引用，可变类型会生成新的对象。

参考文章：

python之浅拷贝和深拷贝的区别_埃菲尔没有塔尖的博客-CSDN博客_python 深拷贝和浅拷贝的区别

Python之中切片是浅拷贝吗？Python怎么实现浅拷贝 - 优草派

python赋值、深拷贝和浅拷贝的区别详解_测试小白00的博客-CSDN博客_python赋值和浅拷贝

python中的is和==区别_Tonywu2018的博客-CSDN博客_python is和==的区别

python3浅拷贝与深拷贝的区别和理解 - 简书


http://chatgpt.dhexx.cn/article/bu6TPIrG.shtml

相关文章

如何理解java的回调函数？

如何理解java的回调函数？

对于技术问题，会用是一回事，理解这个技术问题的来龙去脉、设计者当初为什么要设计这个功能、这个技术问题有哪些优势、适用哪些场景又是另外回事了。 前者照猫画虎得其形，后者形神兼备得其意，这也是所谓青铜与王者的区别。 会使…
阅读更多...
java使用回调函数

java使用回调函数

java回调函数 回调函数（callback Function），顾名思义就是用来回调的函数。在两个类A、B中，A在调用B接口的同时B也在调用A 回调函数也常用于线程中的异步获取消息。 举个简单的例子，公司中老板分发任务给员工A&#…
阅读更多...
java中回调函数的实现

java中回调函数的实现

在java的事务中，有时候可能会遇到以下情况，第一步是更新某某表，中间可能要更新不确定的多步，最后一步是更新缓存，结构大致如下： （1）updateA(); （2）updateXX…
阅读更多...
什么是java回调函数

什么是java回调函数

回调函数 一：故事背景二：概念三：回调函数的作用四：java中如何进行回调4.1 类图4.2 定义回调接口4.3 实现回调接口4.4 调用方法使用回调函数4.5 Main函数调用4.6 总结描述 五：回调函数的优点5.1 灵活性5.2 解耦性5.3 异…
阅读更多...
简单举例JAVA回调函数的实现

简单举例JAVA回调函数的实现

来自维基百科的对回调（Callback）的解释：In computer programming, a callback is any executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at a given time. This execut…
阅读更多...
java回调函数机制

java回调函数机制

Java回调函数机制 参考了网上的一些资料，下面也做出一些总结，供初学者了解学习。 一、 概述 软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调、异步调用 。 同步调用：一…
阅读更多...
java中如何实现回调函数

java中如何实现回调函数

最近工作需要研究了一会别人写的库，其中充满着各种"回调函数"，因此把自己理解给记录下来，存档。 首先我们来看看回调函数 这个概念的具体由来，百度百科的示义如下： 回调函数就是一个通过函数指针调用的函数。…
阅读更多...
Java回调函数 + 使用案例

Java回调函数 + 使用案例

文章目录 前言什么是回调函数第0个版本第1个版本第2个版本第3个版本第4个版本第5个版本第6个版本回头解析前言描述的问题1. MethodIntrospector.selectMethods()2. 抽象类MethodIntrospector3. 方法selectMethods()4. 成员变量USER_DECLARED_METHODS5. 方法doWithMethods()6. d…
阅读更多...
Java-回调函数

Java-回调函数

什么是回调 函数调用可以分为三种模式，串行调用、异步调用、回调。这三种都是日常开发中常见到的方式。 一个方法执行完，再执行下一个，串行逻辑会阻塞线程执行流程，等到所有逻辑执行结束，线程才会结束。 异步执行是…
阅读更多...
java回调函数（callBack）

java回调函数（callBack）

最近有个新同事给我写了个接口，说是用到了回调，我等了半天发现结果才返回回来，把我都整急了。最后我看了他的代码，目瞪口呆。他还信誓旦旦的说没错，按网上的例子来写的。 我一搜，网上例子真一大堆&#xff…
阅读更多...
java回调函数的作用以及运用

java回调函数的作用以及运用

模块之间总是存在这一定的接口，从调用方式上看，可以分为三类：同步调用、回调和异步调用。同步调用是一种阻塞式调用，也是我们在写程序中经常使用的；回调是一种双向的调用模式，也就是说，被调用的…
阅读更多...
Java回调函数理解和应用

Java回调函数理解和应用

#Java回调函数理解和应用 所谓回调：就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法，这样子说你是不是有点晕晕的。 在未理解之前，我也是一脸懵逼，等我理解之后&…
阅读更多...
java回调函数（全干货）

java回调函数（全干货）

产生接口回调的场景 产生接口回调的场景很简单,比如A叫B帮忙做一件事,交代完后A去忙别的事，然后B做完这件事之后会通知A, 通知A的这个动作就是接口回调的动作。接口回调 接口回调的意义是通过接口来实现解耦的的前提下调用另一个类的方法，也就是B为A准…
阅读更多...
深入理解Java回调函数

深入理解Java回调函数

废话不多说，像许多网上介绍回调机制的文章一样，我这里也以一个现实的例子开头：假设你公司的总经理出差前需要你帮他办件事情，这件事情你需要花些时间去做，这时候总经理肯定不能守着你做完再出差吧，于是就他…
阅读更多...
java 回调函数解读

java 回调函数解读

模块间调用 在一个应用系统中，无论使用何种语言开发，必然存在模块之间的调用，调用的方式分为几种： （1）同步调用 同步调用是最基本并且最简单的一种调用方式，类A的方法a()调用类B的方法b()&…
阅读更多...
java中的回调函数

java中的回调函数

CALLBACK，即回调函数，是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接…
阅读更多...
Java回调函数详解

Java回调函数详解

什么是回调函数（CallBack） 在编写程序时，有时候会调用许多API中实现实现的函数，但某些方法需要我们传入一个方法，以便在需要的时候调用我们传入进去的函数。这个被传入的函数称为回调函数（Callback functi…
阅读更多...
numpy 数据类型转换

numpy 数据类型转换

参考NumPy 数据类型 - 云社区 - 腾讯云 首先需要导入numpy模块 import numpy as np 首先生成一个浮点数组 a np.random.random(4) dtype的用法 看看结果信息，左侧是结果信息，右侧是对应的python语句 我们发现这个数组的type是float64，…
阅读更多...
javascript学习之数据类型转换

javascript学习之数据类型转换

⭐️⭐️⭐️ 作者：船长在船上 🚩🚩🚩 主页：来访地址船长在船上的博客 🔨🔨🔨 简介：资深前端开发工程师，专注前端开发，欢迎咨询交流&#xff0…
阅读更多...
【Python入门篇】——Python基础语法（数据类型与数据类型转换）

【Python入门篇】——Python基础语法（数据类型与数据类型转换）

作者简介： 辭七七，目前大一，正在学习C/C，Java，Python等 作者主页： 七七的个人主页 文章收录专栏： Python入门，本专栏主要内容为Python的基础语法，Python中的选择循环语句…
阅读更多...
推荐文章

Copyright @ 2022~2023