精华内容
下载资源
问答
  • 在python中整形,字符串,元组是不可变类型,而列表和字典都是可变类型。 对于不可变类型进行重新赋值,相当于是用以前的变量名重新指向了新的地址,这个地址中存的变量值就是重新的赋值 通过python中提供的函数id...

    在python中整形,字符串,元组是不可变类型,而列表和字典都是可变类型。

    对于不可变类型进行重新赋值,相当于是用以前的变量名重新指向了新的地址,这个地址中存的变量值就是重新的赋值

    通过python中提供的函数id可以看到变量在内存中存储的位置

    >>> a = 10
    >>> id(a)
    25407616
    >>> a = 6
    >>> id(a)
    25407712

    同时,对于0-256之间的任意整形,以及稍微短一点的字符串来讲,相同的值,在python中内存位置是相同的。

    >>> a =256
    >>> b = 256
    >>> id(a)
    25413664
    >>> id(b)
    25413664
    >>> a =257
    >>> b = 257
    >>> id(a)
    25833048
    >>> id(b)
    25832952

    对于可变类型,以列表为例进行描述

    >>> a = [1,2,3]
    >>> id(a)
    140640457811584
    >>> a.append(5)
    >>> id(a)
    140640457811584

    也就是说,可变类型,即使改变了变量的内容,变量的地址也不会发生变化。

    和不可变类型比较,可变类型的多次操作对应的仍然是这个变量,而不可变对象的多次操作,就会生成多个不可变对象。

     

    转载于:https://www.cnblogs.com/andyniu/p/7571545.html

    展开全文
  • Python中的可变与不可变对象 首先要明确一点,...在Python中,数字、字符串、元组是不可变的,,列表、字典、集合是可变的。可以这么理解,Python是传引用,不可变对象的就是不能改变原来引用的值,那么操作对...

    Python中的可变与不可变对象

    首先要明确一点,在Python中 ,一切赋值或者函数传值的方式都是靠引用。这与C++不同,C++有传值、传引用和传指针。因为Python不能显式的定义数据类型,而且没有指针,所以默认的都是按引用传递

    在Python中,数字、字符串、元组是不可变的,,列表、字典、集合是可变的。可以这么理解,Python是传引用,不可变对象的就是不能改变原来引用的值,那么操作对象的时候,是复制原来的值后,开辟新的内存空间;而可变对象就是在原来的基础上进行更改。

    不可变对象

    虽然是传递引用,但是由于不能改变原来引用的值,所以只能开辟新的内存空间,在复制原来值的基础上,进行改变。

    a=1
    b=a  # 按引用传递
    print(a is b)  # 输出 True
    b+=1  # 开辟新的空间,在原来的基础上+1
    print(a is b)  # 输出False 
    print(a,b)  # 1,2
    
    s1="abc" 
    s2=s1  # 按引用传递
    print(s1 is s2)  # 输出True
    s2+="de"  # 开辟新的空间,追加'de'
    print(s1 is s2)  # 输出False
    print(s1,s2)  # abc,abcde

    可变对象

    可变对象可以直接在原来的引用上进行更改,更改的时候不会开辟新的内存空间,是在原来的内存空间上进行处理。

    l1=[1,2,3]  # 定义列表
    l2=l1  # 传引用
    print(l1 is l2)  # 输出True
    l2.append(4)  # 原来的基础上追加元素
    print(l1 is l2)  # 输出True
    print(l1,l2)  # [1,2,3,4,],[1,2,3,4]
    
    s1={1,2,3,4,5}  # 定义集合
    s2=s1  # 传引用
    print(s1 is s2)  # 输出True
    s2.remove(1)  # 删除1
    print(s1 is s2)  # 输出True
    print(s1,s2)  # {1,2,3,4},{1,2,3,4}
    # 字典同理,不在编码了

    自定义对象的可变性

    自定义对象都是可变的类型的。

    class Test:  # 自定义测试对象
      def __init__(self,a=0,b=0):
        self._a=a
        self._b=b
    
    t1=Test(1,2)
    t2=t1  # 传引用
    print(t1 is t2)  # 输出True
    t2._a=0  # 按引用更改
    t2._b=0
    print(t1 is t2)  # True
    print("t1:",t1._a,t1._a)  # t1:0,0
    print("t2:",t2._a,t2._b)  # t2:0,0

    对象作为函数参数的可变性

    可变对象作为函数参数,传入后还是可变对象,相当于传递的引用,函数返回可变对象,返回的是引用。不可变对象传递参数可以理解为按值传递!!

    def fun1(a):
      a+=1
    
    def fun2(a):
      a+=1
      return a
    
    def fun3(l):
      l.append(2)
    
    def fun4(l):
      l.append(4)
      return l
    
    a=1
    b=a
    fun1(a)
    print(b is a)  # True
    print(a)  # 1
    b=fun2(a)  # 2
    print(b is a)  # False
    print(b)  # None
    
    l1=[1,2,3]
    l2=l1
    fun3(l1) 
    print(l1 is l2)  # True
    print(l1)  # [1,2,3,2]
    l2=fun4(l1)
    print(l1 is l2)  # True
    print(l2)  # [1,2,3,2,4]
    

    当函数内部新定义了一个参数,同时返回这个参数的时候,是返回函数内部参数的引用,不论这个参数是可变还是不可变的!!!!

    def test():
      l=[1,2,3]
      print(id(l))  # 140482206588104
      return l
    
    def test1():
      a=1
      print(id(a))  # 10919424
      return a
    
    l=test()
    print(l)  # [1,2,3]
    print(id(l))  # 140482206588104
    
    b=test1()
    print(b)  # 1
    print(id(b))  # 10919424
    

    在上述代码中可以看出,函数内部的list、数字a与函数外部的list、数字a是同一个!

    展开全文
  • Python中的可变与不可变类型

    千次阅读 2018-02-18 17:49:15
    首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据类型:列表list和字典dict;不可变数据类型:整型int、浮点型float、字符串型string和元组tuple。用一句话来概括上述过程就是:...

    首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据类型:列表list和字典dict;不可变数据类型:整型int、浮点型float、字符串型string和元组tuple。

    用一句话来概括上述过程就是:“python中的不可变数据类型,不允许变量的值发生变化,如果改变了变量的值,相当于是新建了一个对象,

    而对于相同的值的对象,在内存中则只有一个对象,内部会有一个引用计数来记录有多少个变量引用这个对象;可变数据类型,允许变量的值发生变化,即如果对变量进行append、+=等这种操作后,只是改变了变量的值,而不会新建一个对象,变量引用的对象的地址也不会变化,

    不过对于相同的值的不同对象,在内存中则会存在不同的对象,即每个对象都有自己的地址,相当于内存中对于同值的对象保存了多份,这里不存在引用计数,是实实在在的对象。


    突然想到一点,比如说:字符串 s= 'fei',然后 s.upper()输出'FEI', 但 s还是输出'fei',不会改变自己,如果不想要a了,可以

    a = a.upper(),这样自己覆盖自己。

    而对于字典,比如 dict = {          

                                    'name':'fei',

                                    'pwd':'weweweas',

                                }

    而,dict.clear()就会删除字典中的所有值,就会改变dict的值

    都是自己的理解不知道对不对,如果不对,大神可以指出来。

    地址:https://www.cnblogs.com/howhy/p/6672257.html



    展开全文
  • 总的来说 python中可变类型有列表,字典,集合 不可变类型有字符串 数字 元组 对不可变类型的变量重新赋值,实际上重新创建一个不可变类型的对象,并将原来的变量重新指向新创建的对象(新开辟了一块内存地址),...

    python中的可变类型与不可变类型区别较大,另int类型较其他不可变类型还有细微不同
    总的来说 python中可变类型有列表,字典,集合 不可变类型有字符串 数字 元组
    对不可变类型的变量重新赋值,实际上是重新创建一个不可变类型的对象,并将原来的变量重新指向新创建的对象(新开辟了一块内存地址),如果没有其他变量引用原有对象的话(即引用计数为0),原有对象就会被回收

    不可变类型
    以int型为例 实际上 i+=1并不是在原有的int对象上加1,而是重新创建一个value为6的对象,i这个引用指向这个新对象

    i=5
    i+=1
    print(i)
    ---6
    

    通过id函数查看变量i的内存地址进行验证

    >>> i = 5
    >>> i += 1
    >>> i
    6
    >>> id(i)
    140243713967984
    >>> i += 1
    >>> i
    7
    >>> id(i)
    140243713967960
    

    可以看到i的值发生变化 其内存地址就会变化 其实就是创建了一个新对象 i这个引用指向这个对象
    看一下多个int类型的变量值相同时,看看他们的内存地址是否相同

    >>> i = 5
    >>> j = 5
    >>> id(i)
    140656970352216
    >>> id(j)
    140656970352216
    >>> k = 5
    >>> id(k)
    140656970352216
    >>> x = 6
    >>> id(x)
    140656970352192
    >>> y = 6
    >>> id(y)
    140656970352192
    >>> z = 6
    >>> id(z)
    140656970352192
    

    对于不可变类型int,无论创建多少个引用,只要值相同,都指向同一内存地址。同样还有字符串
    在这里插入图片描述
    在这里插入图片描述
    对于其他不可变类型则不同 如浮点型,从代码运行结果来看它是不可变类型,对i的值修改后,内存地址改变

    >>> i = 1.5
    >>> id(i)
    140675668569024
    >>> i = i + 1.7
    >>> i
    3.2
    >>> id(i)
    140675668568976
    

    但两个相同值的浮点型变量,内存地址不同 这一点和int这种不可变类型不同(这方面涉及Python内存管理机制,Python对int类型和较短的字符串进行了缓存,无论声明多少个值相同的变量,实际上都指向同个内存地址。)。

    >>> i = 2.5
    >>> id(i)
    140564351733040
    >>> j = 2.5
    >>> id(j)
    140564351733016
    

    可变类型
    以list为例,list在append之后,还是指向同个内存地址,因为list是可变类型,可以在原处修改。

    >>> a = [1, 2, 3]
    >>> id(a)
    4435060856
    >>> b = [1, 2, 3]
    >>> id(b)
    4435102392
    

    改改代码,当存在多个值相同的不可变类型变量时,看看它们是不是跟可变类型一样指向同个内存地址

    >>> a = [1, 2, 3]
    >>> id(a)
    4435060856
    >>> b = [1, 2, 3]
    >>> id(b)
    4435102392
    

    从运行结果可以看出,虽然a、b的值相同,但是指向的内存地址不同。我们也可以通过b = a 的赋值语句,让他们指向同个内存地址:

    >>> a = [1, 2, 3]
    >>> id(a)
    4435060856
    >>> b = [1, 2, 3]
    >>> id(b)
    4435102392
    >>> b = a
    >>> id(b)
    4435060856
    

    这个时候需要注意,因为a、b指向同个内存地址,而a、b的类型都是List,可变类型,对a、b任意一个List进行修改,都会影响另外一个List的值。

    >>> b.append(4)
    >>> a
    [1, 2, 3, 4]
    >>> b
    [1, 2, 3, 4]
    >>> id(a)
    4435060856
    >>> id(b)
    4435060856
    

    代码中,b变量append(4),对a变量也是影响的。输出他们的内存地址,还是指向同个内存地址。

    此文章部分借鉴于博客园 BlackMatrix先生的博客

    展开全文
  • 在Python中主要有两种数据类型, 一种是可变数据类型, 另一种是不可变数据类型 不可变数据类型 数字型: int, float, complex, bool, long 字符型: str 元 祖: tuple 可变数据类型 列表: list ...
  • python面试常考的题目:...用一句话来概括上述过程就是:“python中不可变数据类型,不允许变量的值原地发生变化,如果改变了变量的值,相当于新建了一个对象,而对于相同的值的对象,内存中则只有一个对象...
  • Python中不可变变量和可变变量不可变变量可变变量 不可变变量 不可变量包括:数值类型、字符串和元组。一旦被重新赋值,变量对应的内存地址就会发生改变。 可变变量 不可变量包括:列表、字典、集合。添加或者修改...
  • 在Python中,一切皆对象,对于对象中的数字,字符串,元组,其是不可变的对象。而对于列表是可变的对象。  可变与不可变性,是对内存地址而言的。由于Python是解释性语言,因而对于每个对象的赋值都是对内存块的...
  • Python中不可变的元组

    2018-04-02 16:57:51
    元组被称为带了紧箍咒的列表,因为列表是可变的,元组是不可变的。 创建时只需括号添加元素,并用逗号分离。 t1 = (1, 2, 4) print t1, type(t1) 创建一个空元组 t4 = () print t4, type...
  • 首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据类型:列表list和字典dict;不可变数据类型:整型int、浮点型float、字符串型string和元组tuple。 用一句话来概括上述过程就是:...
  • python中,对象分为可变(mutable)和不可变(immutable)两种类型,元组(tuple)、数值型(number)、字符串(string)均为不可变对象,而字典型(dictionary)和列表型(list)的对象可变对象。 不可变对象 见一个例子,...
  • python中的可变、不可变对象

    千次阅读 2018-04-11 10:05:22
    今天的motivation来自写python当中的一个问题,简化如下:(当我做数据分析的时候,将数据存入列表或者字典,传入函数后原来列表发生改变与否,关键字:in-place,原地操作) def fun(): data = ['我...
  • 在python中一切皆对象,但对象有可变对象与不可变对象之分。 可变与不可变指的其内容是否可变。 可变对象 对象创建完之后内容可改变,但地址不会变 不可变对象 对象创建之后内容不可改变,如果改变其地址也会变...
  • 开始学python时不理解可变数据类型和不可变数据类型到底该怎么区分?当时也没时间多想,后来有一次和一个朋友又说到这个问题,所以决定去弄个究竟。谨以此文献给更多的后来者参考。 可变数据类型:当该数据类型对应...
  • Python 的内建标准类型有一种分类标准分为可变类型与不可变类型:可变类型:列表、字典不可变类型:数字、字符串、元组因为变量保存的实际都对象的引用,所以给一个不可变类型(比如 int)的变量 a 赋新值的...
  • 可变与不可变指的对对象本身进行操作时,引用所指向的地址里的内容是否发生变化。 比如函数局部变量本身发生变化,同名的全局变量是否发生变化。 举例 可变类型-列表 先看个实例 >>&...
  • 当改变一个对象的值时,如果能维持其 id 值不变,我们就说这个对象可变的,否则这个对象就是不可变的。 对于变量 x 来说,如果 id(x) 不随 x 的内容发生变化而变化,我们就说 x 可变的;否则 x 就是不变的。 ...
  • 文章目录写前面1、有哪些可变类型和不可变类型2、区分3、原理4、易错点(深浅拷贝相关) 写前面 本文源自:http://baijiahao.baidu.com/s?id=1598145363846525787&wfr=spider&for=pc 1、有哪些可...
  • 首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据类型:列表list和字典dict;不可变数据类型:整型int、浮点型float、字符串型string和元组tuple。 用一句话来概括上述过程就是:...
  • 我们知道列表中的元素可修改的,但如果我们要创建一系列不可修改的元素,这个时候我们就要用到元组。 1.定义元组:元组名(元素,) 注意:元组只包含一个元素时,需要元素后面添加逗号,否则括号会被当作...
  • 不可变的对象则相反,表示其内容不可变。 不可变(immutable):int、字符串(str)、float、(数值型number)、元组(tuple)、None(空) 可变(mutable):字典型(dictionary)、列表型(list), set(集合) 廖...
  • 讲有序无序列表之前我们先讲一下python的赋值吧。 python中如果我们令a=3我们需要经历两个步骤: 1.创建一个整数对象并且赋值为3. ...什么是可变类型,什么是不可变类型? 可变类型,可以原始数据上修...
  • 首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据类型:列表list和字典dict;不可变数据类型:整型int、浮点型float、字符串型str和元组tuple。 用一句话来概括上述过程就是:...
  • 在说错误之前,先来看一下在python中的哪些是可变数据和哪些是不可变数据吧1.可变数据类型 列表list字典dict2.不可变数据类型 整型int浮点型float字符串型string元组tuple。 下面我们以int和list为例,来说一下“可...
  • 什么是可变类型,什么是不可变类型呢? 这里所说的是内存地址的可变不可变,在python中 不可变类型 数字型 字符串 元组 可变类型 字典 列表 那么他们是怎么不可变和可变呢? 当我们定义一个 a = 10 的时候 ...
  • 首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据类型:列表list和字典dict;不可变数据类型:整型int、浮点型float、字符串型string和元组tuple。 用一句话来概括上述过程就是:...
  •  在python中,我们对数据类型除了分为数字类型、字符串类型、列表类型、元组类型、字典类型和集合类型外, 还有另外一种分类方式,我们给数据类型分为可变数据类型和不可变数据类型。  可变数据类型:列表、字典...
  • python中函数参数引用传递(不是值传递) 对于不可变类型来说,变量不能修改,运算不会影响到变量自身 对于可变类型来说,函数体中的运算可能会更改传入的参数变量 可变数据类型对象被引用时,会内存中为新对象...
  • 下面,我们将讨论两者的功能,并强调元组实际应用中的不可变性。 你也可以喜欢:Python中的映射和筛选函数. 元组记录 作为记录,元组保存数据,它的每一个项都代表一个字段。这种情况下,项的顺序非常重要,因为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,605
精华内容 642
关键字:

列表在python中是不可变的

python 订阅