精华内容
下载资源
问答
  • 由于在学校最开始的是学的是C和C++,所以学java和...在c和c++中,把一个变量赋新的变量,其实是创建一个新的空间去存储那个新的变量, 但在java中貌似是把已有的变量的地址赋予了新的变量,就像是C++中的取...

    由于在学校最开始的是学的是C和C++,所以学java和python因为还保留着写c的习惯,所以写了不少bug,

    这里说一下关于java和python赋值的问题,这个问题以前只以为是java独有,结果今天写python又遇到了,不能忍了

    在c和c++中,把一个变量赋给新的变量,其实是创建一个新的空间去存储那个新的变量,

    但在java中貌似是把已有的变量的地址赋予给了新的变量,就像是C++中的取别名

    而python中,普通变量赋予给新的变量,倒是不会出现问题

    >>s1 = 5
    >>s2 = s1
    >>s1 =s1-1
    >>print(s2)
    5

    但是列表赋值却仍然存在这个问题,下面附上测试代码:

    L = [2, 3, 1, 0, 12, 11, 4, 5]
    L1 = []
    L1_1 = []
    L2 = []
    L3 = []
    for i in range(0,len(L)):
    	L1.append(L[i])
    	L1_1 = L[i]
    L2 = L
    L3 = L.copy()
    L.sort()
    print(L)
    print(L1)
    print(L1_1)
    print(L2)
    print(L3)
    
    
    
    
    [0, 1, 2, 3, 4, 5, 11, 12]
    [2, 3, 1, 0, 12, 11, 4, 5]
    5
    [0, 1, 2, 3, 4, 5, 11, 12]
    [2, 3, 1, 0, 12, 11, 4, 5]

     

    展开全文
  • 我的问题是这样的: 当前[控制器C]的一个方法[ActionA] 从数据库中通过特定条件查询并排序 ...还有是ViewModel对象数据保存到ViewBag里 再在ActionB里赋值给新的ViewModel 可为什么不能直接传ViewModel对象过去呢?
  • 当我们对象赋值给另一个变量的时候,这个变量并没有拷贝这个对象,而只是拷贝了这个对象的引用而已。 一般情况下我们会通过三种方法来实现拷贝对象的引用。 直接赋值 直接赋值,默认浅拷贝传递对象的引用而已,...

    在python中,给一个对象赋值,实际上就是对象对内存空间存储的值的引用。当我们把对象赋值给另一个变量的时候,这个变量并没有拷贝这个对象,而只是拷贝了这个对象的引用而已。

    一般情况下我们会通过三种方法来实现拷贝对象的引用。

    直接赋值

    直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变,被赋值的变量也会做相同的改变。其实就是对‘对象’的引用

    示例:

    >>> list_demo = [2, 4, 6]
    >>> a = list_demo
    >>> print(a)
    [2, 4, 6]
    >>> id(list_demo)
    65006808
    >>> id(a)
    65006808
    >>> list_demo.append(8)
    >>> print(list_demo)
    [2, 4, 6, 8]
    >>> print(a)
    [2, 4, 6, 8]
    >>> id(list_demo)
    65006808
    >>> id(a)
    65006808
    >>>
    

    通过 id() 函数我们可以得出,变量 list_demo 与 a 指向的都是同一个内存空间地址,当被赋值的 list_demo改变,被赋值的 a 同样会做相同的改变。这种现象普遍存在于 Python 之中,这种赋值的方式实现了 “假装” 拷贝,真实的情况还是两个变量和同一个对象之间的引用关系。

    浅拷贝

    import copy 模块的 copy.copy() 方法,该方法只拷贝父对象,没有拷贝子对象。且浅拷贝是创建一块新的内存空间,但是内存空间内的元素的地址均是父对象元素的地址的拷贝。所以当父对象内部的子对象发生改变时,拷贝对象的内部的子对象也会跟着改变。

    示例:

    >>> list_demo1 = [2, 4, 6, [8, 10]]
    >>> a = list_demo1
    >>> print(list_demo1)
    [2, 4, 6, [8, 10]]
    >>> print(a)
    [2, 4, 6, [8, 10]]
    >>>
    >>>
    >>> import copy
    >>> b = copy.copy(list_demo1)
    >>> id(list_demo1)
    65103472
    >>> id(b)
    6011200
    >>> list_demo1.append(12)
    >>> print(list_demo1)
    [2, 4, 6, [8, 10], 12]
    >>> list_demo1[3]
    [8, 10]
    >>>
    >>>
    >>>
    >>> list_demo1[3].append('hello')
    >>> print(list_demo1)
    [2, 4, 6, [8, 10, 'hello'], 12]
    >>> print(b)
    [2, 4, 6, [8, 10, 'hello']]
    >>> list_demo1[3]
    [8, 10, 'hello']
    >>> b[3]
    [8, 10, 'hello']
    >>>
    >>>
    >>>
    >>> id(list_demo1)
    65103472
    >>> id(b)
    6011200
    >>> id(list_demo1[3])
    64679128
    >>> id(b[3])
    64679128
    >>>

    从上述代码可以看出,在执行浅拷贝的时候,浅拷贝实际上只拷贝引用,不拷贝内容。同时,浅拷贝会针对父对象的子对象进行判断,当父对象的子对象发生改变时,拷贝对象内的子对象同时也跟着改变。

    深拷贝

    import copy 模块的 copy.deepcopy() 方法,深拷贝与浅拷贝相反,就是彻彻底底的拷贝,完全的拷贝了父对象及子对象,同时指向一个新的内存空间地址。此时,虽然源对象与拷贝对象的内容是一样的,但是不管针对谁进行改动,另一个是丝毫不会受到影响的。

    >>> list_demo2 = [2,3,4]
    >>> c= copy.deepcopy(list_demo2)
    >>> print(list_demo2)
    [2, 3, 4]
    >>> print(c)
    [2, 3, 4]
    >>> id(list_demo2)
    6011440
    >>> id(c)
    6012440
    >>> list_demo2.append(['a','b'])
    >>> c.append([5,6])
    >>> print(list_demo2)
    [2, 3, 4, ['a', 'b']]
    >>> print(c)
    [2, 3, 4, [5, 6]]
    >>> list_demo2[3].append('c')
    >>> c[3].append(7)
    >>> print(list_demo2)
    [2, 3, 4, ['a', 'b', 'c']]
    >>> print(c)
    [2, 3, 4, [5, 6, 7]]
    >>>

    从上述代码示例可以看出 list_demo2 与 c 相互独立,无论 list_demo2 与 c本身进行了修改,或者各自的子对象进行了修改 都没有互相影响。

    总结

    赋值

    赋值的本质就是将一个对象的内存空间地址赋值给一个变量,让变量指向该内存空间地址。

    浅拷贝

    浅拷贝是拷贝了源对象的引用,并创建了一个新的内存空间地址。但是引用的对象的子对象的地址仍然是源对象的,所以当源对象的子对象发生改变时,拷贝对象内的子对象同时也跟着改变。

    深拷贝

    深拷贝就是彻底的拷贝,完全的拷贝了父对象及子对象,同时指向一个新的内存空间地址。源对象与拷贝对象之间的修改互不影响。

    展开全文
  • 当创建一个对象,赋值给另一个变量的时候,python并没有拷贝这个对象,只是拷贝了这个对象的引用而已。原始数据改变,被赋值的对象数据也会做相同的改变。 (1)列表之间的赋值 a = [11,22] b = a print...

    1、赋值

    对象之间赋值本质上是对象之间的引用传递,也就是多个对象指向同一个数据空间。当创建一个对象,把它赋值给另一个变量的时候,python并没有拷贝这个对象,只是拷贝了这个对象的引用而已。原始数据改变,被赋值的对象数据也会做相同的改变。

    (1)列表之间的赋值

    	a = [11,22]
    	b = a
    	print(id(a))    # 用来显示 a 指向的数据的内存地址
    	print(id(b))    # 用来显示 b 指向的数据的内存地址
    
    运行结果:
    	1610957499464
    	1610957499464
    

    结论:
    以上结果相同,说明了当给一个变量赋值时,其实就是将数据的引用复制了一份给了另外一个变量,这其实就是最简单的浅拷贝。

    类似于 xx1 = xx2 这种类型的基本都是浅拷贝。

    (2)字典之间的赋值

    	c = {"name":"teacher"}
    	d = c
    	print(id(c))
    	print(id(d))
    	
    	c["age"] = 20
    	print(c)
    	print(d)
    	
    运行结果:
    	3127108004240
    	3127108004240
    	{'name': 'teacher', 'age': 20}
    	{'name': 'teacher', 'age': 20}
    

    2、浅拷贝

    浅拷贝是对于一个对象的顶层拷贝,也就是只能拷贝最外面的一层。对于只有一层的数据可以完全拷贝;对于有多层数据的对象,只拷贝该对象的顶层,其余的只是把存放变量的地址值传给被赋值的对象,最后两个变量引用了同一份地址。通俗的理解是:拷贝了引用,并没有拷贝内容(指向了别人的内存地址,并没有建立一个新的内存地址)。

    (1)对于只有一层数据的浅拷贝(完全拷贝,相当于深拷贝)

    	import copy
    	a = [1,2,3,4]
    	b = copy.copy(a)
    	print(a)
    	print(b)
    	print(id(a))
    	print(id(b))
    	a.append(9)
    	print(a)
    	print(b)
    	print(id(a))
    	print(id(b))
    	
    运行结果:
    	[1, 2, 3, 4]
    	[1, 2, 3, 4]
    	2076501879368
    	2076501879560
    	[1, 2, 3, 4, 9]
    	[1, 2, 3, 4]
    	2076501879368
    	2076501879560
    

    (2)对于有两层数据的浅拷贝

    1)查看id

    	a = [11, 22]
    	b = [33, 44]
    	c = [a, b]
    	print(id(a))
    	print(id(b))
    	print(id(c))
    	print(id(c[0]))
    	print(id(c[1]))
    	
    运行结果:
    	2163059240008
    	2163058363336
    	2163059239880
    	2163059240008
    	2163058363336
    

    2)举例

    	import copy
    	a = [11, 22]
    	b = [33, 44]
    	c = [a, b]
    	d = copy.copy(c)
    	print(id(a))
    	print(id(b))
    	print(id(c))
    	print(id(d))
    	print(id(d[0]))
    	print(id(d[1]))
    	a.append(11)
    	print(c)
    	print(d)
    	
    运行结果:
    	2163059240008
    	2163058363336
    	2163059239880
    	2163060779784
    	2163059240008
    	2163058363336
    	[[11, 22, 11], [33, 44]]
    	[[11, 22, 11], [33, 44]]
    

    结论:
    C对象的顶层数据就是[a,b],所以通过浅拷贝给D对象时D对象中也是[a,b]。
    浅拷贝,只会复制最顶层的那个列表。

    3、深拷贝

    深拷贝是对于一个对象所有层次的拷贝(递归)。深拷贝是在内存中建立了一个新的内存地址,并另建了相同的数据。

    (1)深拷贝举例

    	import copy
    	a = [11, 22]
    	b = copy.deepcopy(a)   # 对a指向的列表进行深拷贝
    	print(a)
    	print(b)
    	print(id(a))
    	print(id(b))
    	# 以上结果说明了通过deepcopy确实将a列表中所有的数据的引用拷贝了,而不是只拷贝了a指向的列表的引用
    	a.append(33)
    	print(a)
    	print(b)
    	
    运行结果:
    	[11, 22]
    	[11, 22]
    	2492948097608
    	2492948097800
    	[11, 22, 33]
    	[11, 22]
    

    (2)进一步理解深拷贝

    	import copy
    	a = [11, 22]
    	b = [33, 44]
    	c = [a, b]
    	d = copy.deepcopy(c)
    	print(id(a))
    	print(id(b))
    	print(id(c))
    	print(id(c[0]))
    	print(id(c[1]))
    	print(id(d))
    	print(id(d[0]))
    	print(id(d[1]))
    	c[0].append(55)
    	print(c)
    	print(d)
    	
    运行结果:
    	1784636648008
    	1784636648200
    	1784635290184
    	1784636648008
    	1784636648200
    	1784635290312
    	1784635290376
    	1784636649224
    	[[11, 22, 55], [33, 44]]
    	[[11, 22], [33, 44]]
    

    4、浅拷贝和深拷贝对不可变类型的拷贝

    copy.copy对于可变类型,会进行浅拷贝。
    copy.copy和copy.deepcopy对于不可变类型没有意义,全部等价于对象之间的赋值操作,即为引用的传递。

    (1)浅拷贝对可变类型的copy

    	import copy
    	a = (11, 22, 33)
    	b = copy.copy(a)
    	print(id(a))
    	print(id(b))
    	
    运行结果:
    	2130815156424
    	2130815156424
    

    (2)深拷贝对可变类型的copy

    	import copy
    	a = (11, 22, 33)
    	b = copy.deepcopy(a)
    	print(id(a))
    	print(id(b))
    	
    运行结果:
    	2341555192456
    	2341555192456
    

    总结

    (1)不可变对象类型,不管是深拷贝还是浅拷贝,地址值和拷贝后的值都是一样的。
    (2)对于可变对象深浅拷贝:

    • =(浅拷贝)浅拷贝:值相等,地址相等
    • copy(浅拷贝):值相等,地址不相等
    • deepcopy(深拷贝):值相等,地址不相等

    (3)深浅拷贝的作用:

    • 减少内存的使用。
    • 以后在做数据的清洗、修改或者入库的时候,对原数据进行复制一- 份,以防数据修改之后,找不到原数据。
    展开全文
  • python 赋值 类 对象

    千次阅读 2014-08-15 11:27:46
    #由于对象之间的赋值,并不是把一个对象的值复制一份给另一个值, #而是把这两个对象绑定到相同的一块内存空间上。 #可以想象在一开始创建a的时候,在内存中创建了一个列表存储着1,2,3然后让a指向他,接着让b等 #...
    # _*_ coding:utf-8 _*_
    
    a = [1, 2, 3]
    
    b = a
    
    #由于对象之间的赋值,并不是把一个对象的值复制一份给另一个值,
    #而是把这两个对象绑定到相同的一块内存空间上。
    #可以想象在一开始创建a的时候,在内存中创建了一个列表存储着1,2,3然后让a指向他,接着让b等
    #于a实际上相当于把b也指向那块内存,这样当通过b改变那块内存的元素时a所对应的list的值也改变了。
    #如果要复制a的值,应当用
    #b = a[:]
    
    b.append(4)  #append()在末尾添加一个对象,
    
    c = [1, 2]
    d = [3, 4]
    
    c.append(d)  #c.append(d) 在c的末尾添加d这个对象,而不是单纯的数值
    d.append(c)
    
    e = [1, 2]
    f = [3, 4]
    
    e.extend(f)  #e.extend(f)  在e的末尾只是添加f里的数值,对e进行扩展
    f.extend(e)
    
    print a
    print b
    print c
    print d
    print e
    print f

    结果

    >>> 
    [1, 2, 3, 4]
    [1, 2, 3, 4]
    [1, 2, [3, 4, [...]]]
    [3, 4, [1, 2, [...]]]
    [1, 2, 3, 4]
    [3, 4, 1, 2, 3, 4]

    类是对象的定义,我们上一节看到的list a和list b相当于是list 这个类的实例化,类就像一个模板,告诉每个由他实例化出来的对象应该长什么样子。

    展开全文
  • 变量地址和赋值

    2016-02-28 20:22:00
    python变量是指向内存对象的指针。 当执行 a = [] 时, python将新建一个列表对象...但是如果执行 a = ["3"] , 重新 a 赋值,就是 a 指向另一个内存对象。以后a 的操作将不会影响 b 。 转载于:https://www.cnbl...
  • 当我们对象赋值给另一个变量的时候,这个变量并没有拷贝这个对象,而只是拷贝了这个对象的引用而已。 一般情况下我们会通过三种方法来实现拷贝对象的引用。 Python直接赋值 直接赋值,默认浅拷贝传递对象的引用而已...
  • 赋值运算符可以类的一个对象赋值给该类的另一个对象。此时,类还可以定义其它赋值运算符以使用别的类型作为右侧运算对象。 在拷贝赋值和移动赋值之外,标准库vector类还定义了第三种赋值运算符,该运算符接受花...
  • Python高级语法_Python的赋值、深拷贝与浅拷贝的区别

    千次阅读 多人点赞 2019-05-05 17:40:44
    当我们对象赋值给另一个变量的时候,这个变量并没有拷贝这个对象,而只是拷贝了这个对象的引用而已。 一般情况下我们会通过三种方法来实现拷贝对象的引用。 直接赋值 直接赋值,默认浅拷贝传递对象的引用而已,原始...
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法, alist=[1,2,3,["a","b"]] (1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变...
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 (1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变,被赋值的b也会做相同的改变 >>> b=...
  • 前天做一个发起群聊的功能,需要做一个成员去重以及一个另一个群的成员列表 当时直接参数赋值给了两个不同的集合参数,但是执行后发现两个集合的数据并不是各自处理的结果,而是保持了两个集合操作后的数据一致。...
  • 在Python可变数据类型(列表,字典,集合)中,把一个可变数据类型的变量赋给另一个变量,这两个变量引用的是同一个对象,内存地址是一样的,修改当中的一个变量,另一个变量相应也会被修改 >>> a = [1,2,3...
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法, alist=[1,2,3,["a","b"]] (1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变...
  • 这篇文章主要介绍了python sorted方法和列表使用...注意:y=x通过分片操作将列表x的元素全部拷贝给y,如果简单的X赋值给Y:y=x,y和x还是指向同一个列表,并没有产生新的副本。另一种获取已排序的列表副本的方法是使用so
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法, alist=[1,2,3,[“a”,“b”]] (1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变...
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法, alist=[1,2,3,['a','b']] (1)直接赋值,传递对象的引用而已,原始列表改变,被赋值的b...
  • 2.使用一个列表变量给另一个变量赋值时,不是拷贝一份给该变量,而是该变量的指针指向原变量所指向的列表 1 a = [1, 2, 3] 2 b = a 3 b[0] = 5 4 则a[0]也是5 5 a, b指向的内存为同一地址 3.for in ...
  • 在Python可变数据类型(列表,字典,集合)中,把一个可变数据类型的变量赋给另一个变量,这两个变量引用的是同一个对象,内存地址是一样的,修改当中的一个变量,另一个变量相应也会被修改 >>> a = [1,...
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 >>> alist = [1,2,3,["a","b",[5,6]]] >>&gt...
  • 当创建一个对象,然后它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 一般有三种方法, alist=[1,2,3,["a","b"]] (1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变...
  • o 4.12 我需要根据条件把一个复杂的表达式赋值给两个变量中的一个。可以用下边这样的代码吗? ((condition) ? a : b) = complicated_expression; * 5. 指针 o 5.1 我想声明一个指针并为它分配一些空间, 但却...
  • 经常我们会发现,当我们把一个对象列表赋值给另一个对象列表之后,一个改变了,另一个也跟着改变了,但是这往往不是我们想看到的那么,怎么办呢?办法只有一个,那就是让你的对象实现IClonable接口对象代码:...
  • 你必须知道的495C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    3.18 需要根据条件把一个复杂的表达式赋两个变量中的一个。可以用下面这样的代码吗?((condition)?a:b)=complicated_expression; 3.19 我有些代码包含这样的表达式。a?b=c:d有些编译器可以接受,有些却不能。为...
  • python3浅拷贝与深拷贝的实现方式、区别: list1 = [1,2,3] list2 = list1 ...通过把一个列表变量名赋值给另一个变量名,只是把一个列表变量名list1的指引赋值给另一个变量名list2,使list1和list

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 240
精华内容 96
关键字:

把一个列表赋值给另一个列表