精华内容
下载资源
问答
  • Python数据类型有哪些,哪些是可变类型,哪些是不可变类型? 类型: 整数int 字符串str 浮点数float 布尔型bool 列表list 字典dict 集合set 元组tuple 可变类型:就是这个数据类型的值在不改变这一块内存空间,而去...

    Python数据类型有哪些,哪些是可变类型,哪些是不可变类型?

    类型:

    整数int 字符串str 浮点数float 布尔型bool 列表list 字典dict 集合set 元组tuple

    可变类型:就是这个数据类型的值在不改变这一块内存空间,而去改变这个数据类型的值。

    1.列表
    2.字典
    3.集合

    不可变类型:当改变值得时候,会申请一块新的内存空间,不再是原来的那一块内存空间了。

    1. 整数
    2. 字符串
    3. 浮点数
    4. 布尔型
    5. 元组
    展开全文
  • python精讲 不可变对象与可变对象

    千次阅读 2020-07-22 15:46:35
    文章目录对象可变对象与不可变对象可变对象不可变对象 对象 Python 中的变量不是装有对象的“容器”,而是贴在对象上的“标签”。 真正的存贮位置是内存中 在python中,可变对象包括:list、set、dict、自定义对象...

    对象(object)

    cpu,内存,硬盘之间的关系:

    CPU与内存间的工作关系为:
    当我们在计算机上执行一个程序时,首先由输入设备向CPU发出操作指令,

    CPU接收到操作指令后,硬盘中对应的程序指令被直接加载到内存中,此

    后,CPU再对内存进行寻址操作,将加载到内存中的指令翻译出来,而后

    发送操作信号给操作控制器,实现程序的运行或数据的处理。

    对象

    • 对象即在内存中存储数据的一块区域
    • Python 中的变量不是装有对象的“容器”,而是贴在对象上的“标签”。
      真正的存贮位置是内存中
    - 每个对象都有三个要素:id(标识)(唯一性,每个对象都有唯一的id)
    					  type(类型)(决定对象的功能)
    					  value(值)(对象存储的数据值)
    

    对象

    • 在python中,可变对象包括:list、set、dict、自定义对象;
    • 不可对对象包括:int、float、str、bool、tuple等。
    • 不可变对象步允许自身内容进行修改。如果我们队一个不可变对象进行赋值,实际上是生成一个新对象,再让变量指向这个对象。哪怕这个对象简单到只是数字0和1

    每个对象在内存中都会存储三个数据:
    1.id(标识)
    2.type(类型)
    3.value(值)

    可变对象与不可变对象

    可变对象

    而可变对象即指在对象不改变的前提下让对象的数据发生改变
    即值发生改变但是 对象 未发生改变,例如 标识id 不会发生改变

    a = [1,2,3]
    print('修改前',a,id(a))
    a[0] = 4  #改变了值
    print('修改后',a,id(a))  #但是id未变
    
    修改前 [1, 2, 3] 1221617771648
    修改后 [4, 2, 3] 1221617771648
    

    对象没有发生改变而值发生改变
    a[0]=4

    重新赋值则开辟新的内存块存储新的值,顶替原来的对象和值
    在这里插入图片描述

    a = [1,2,3]
    print('修改前',a,id(a))
    a = [2,3,4]  #重新赋值即重新建立一个a,所以这个a不是原来的a,
                 #而是新生的a
    print('修改后',a,id(a))  #所以内存中重新开辟空间,对象发生改变
    
    修改前 [1, 2, 3] 2057897038528
    修改后 [2, 3, 4] 2057897038720
    

    因为对象不可变,所以为了提高效率,Python 会使用一些公用的对象:

    a = 1
    print('a', id(a))
    b = 1
    print('b', id(b))
    print(a == b)
    print(a is b)
    c = 'hello world'
    print('c', id(c))
    d = 'hello world'
    print('d', id(d))
    print(c == d)
    print(c is d)
    

    输出:

    a 4423761776
    b 4423761776
    True
    True
    c 4430180912
    d 4430180912
    True
    True
    

    这里顺便提一下 is 这个操作符。它和 == 的区别在于:== 只判断“值”是不是相等,而 is 则判断是否为同一个对象,也就是地址一致。比如:

    a = 2
    b = 2.0
    print(a == b)
    print(a is b)
    

    输出:

    True
    False
    

    不可变对象

    不可变对象不允许对自身内容进行修改。如果我们对一个不可变对象进行赋值,实际上是生成一个新对象,再让变量指向这个对象。:
    即重新赋值

    a = 0
    print('a', id(a))
    a = 1
    print('a', id(a))
    

    输出:

    a 4463151440
    a 4463151472
    

    在这里插入图片描述

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

    万次阅读 多人点赞 2015-11-16 13:13:19
    python的可变与不可变数据类型

    python的可变与不可变数据类型


        初学python的时候,可能会有很多疑惑,尤其是最先接触的所谓的“可变数据类型”和“不可变数据类型”。python与C/C++不一样,它的变量使用有自己的特点,当初学python的时候,一定要记住“一切皆为对象,一切皆为对象的引用”这句话,其实这个特点类似于JAVA,所以在python里面大家也不用担心类似于C/C++中的指针的复杂问题。下面本文将对python里面的“可变数据类型”和“不可变数据类型”进行分析。

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

        然后,我们以int和list为例,来看看“可变数据类型”和“不可变数据类型”到底有什么区别。

    (1)不可变数据类型分析。先来看一段程序:

    >>> x = 1
    >>> id(x)
    31106520
    >>> y = 1
    >>> id(y)
    31106520
    >>> x = 2
    >>> id(x)
    31106508
    >>> y = 2
    >>> id(y)
    31106508
    >>> z = y
    >>> id(z)
    31106508
    >>> x += 2
    >>> id(x)
    31106484 

        上面这段程序都是对不可变数据类型中的int类型的操作,id()查看的是当前变量的地址值。我们先来看x = 1和y = 1两个操作的结果,从上面的输出可以看到x和y在此时的地址值是一样的,也就是说x和y其实是引用了同一个对象,即1,也就是说内存中对于1只占用了一个地址,而不管有多少个引用指向了它,都只有一个地址值,只是有一个引用计数会记录指向这个地址的引用到底有几个而已。当我们进行x = 2赋值时,发现x的地址值变了,虽然还是x这个引用,但是其地址值却变化了,后面的y = 2以及z = y,使得x、y和z都引用了同一个对象,即2,所以地址值都是一样的。当x和y都被赋值2后,1这个对象已经没有引用指向它了,所以1这个对象占用的内存,即31106520地址要被“垃圾回收”,即1这个对象在内存中已经不存在了。最后,x进行了加2的操作,所以创建了新的对象4,x引用了这个新的对象,而不再引用2这个对象。

        那么为什么称之为不可变数据类型呢?这里的不可变大家可以理解为x引用的地址处的值是不能被改变的,也就是31106520地址处的值在没被垃圾回收之前一直都是1,不能改变,如果要把x赋值为2,那么只能将x引用的地址从31106520变为31106508,相当于x = 2这个赋值又创建了一个对象,即2这个对象,然后x、y、z都引用了这个对象,所以int这个数据类型是不可变的,如果想对int类型的变量再次赋值,在内存中相当于又创建了一个新的对象,而不再是之前的对象。从下图中就可以看到上面程序的过程。



    图1 python不可变数据类型分析

        从上面的过程可以看出,不可变数据类型的优点就是内存中不管有多少个引用,相同的对象只占用了一块内存,但是它的缺点就是当需要对变量进行运算从而改变变量引用的对象的值时,由于是不可变的数据类型,所以必须创建新的对象,这样就会使得一次次的改变创建了一个个新的对象,不过不再使用的内存会被垃圾回收器回收。

    (2)可变数据类型分析。下面同样先看一段程序。

    >>> a = [1, 2, 3]
    >>> id(a)
    41568816
    >>> a = [1, 2, 3]
    >>> id(a)
    41575088
    >>> a.append(4)
    >>> id(a)
    41575088
    >>> a += [2]
    >>> id(a)
    41575088
    >>> a
    [1, 2, 3, 4, 2]

        从上面的程序中可以看出,进行两次a = [1, 2, 3]操作,两次a引用的地址值是不同的,也就是说其实创建了两个不同的对象,这一点明显不同于不可变数据类型,所以对于可变数据类型来说,具有同样值的对象是不同的对象,即在内存中保存了多个同样值的对象,地址值不同。接着来看后面的操作,我们对列表进行添加操作,分别a.append(4)和a += [2],发现这两个操作使得a引用的对象值变成了上面的最终结果,但是a引用的地址依旧是41575088,也就是说对a进行的操作不会改变a引用的地址值,只是在地址后面又扩充了新的地址,改变了地址里面存放的值,所以可变数据类型的意思就是说对一个变量进行操作时,其值是可变的,值的变化并不会引起新建对象,即地址是不会变的,只是地址中的内容变化了或者地址得到了扩充。下图对这一过程进行了图示,可以很清晰地看到这一过程。


    图2 python可变数据类型分析

        从上述过程可以看到,可变数据类型是允许同一对象的内容,即值可以变化,但是地址是不会变化的。但是需要注意一点,对可变数据类型的操作不能是直接进行新的赋值操作,比如说a = [1, 2, 3, 4, 5, 6, 7],这样的操作就不是改变值了,而是新建了一个新的对象,这里的可变只是对于类似于append、+=等这种操作。

        总之,用一句话来概括上述过程就是:“python中的不可变数据类型,不允许变量的值发生变化,如果改变了变量的值,相当于是新建了一个对象,而对于相同的值的对象,在内存中则只有一个对象,内部会有一个引用计数来记录有多少个变量引用这个对象;可变数据类型,允许变量的值发生变化,即如果对变量进行append、+=等这种操作后,只是改变了变量的值,而不会新建一个对象,变量引用的对象的地址也不会变化,不过对于相同的值的不同对象,在内存中则会存在不同的对象,即每个对象都有自己的地址,相当于内存中对于同值的对象保存了多份,这里不存在引用计数,是实实在在的对象。”

        最后,大家主要区分开什么是变量值的变化、什么是变量引用的对象地址的变化这些概念就很清楚了,千说万说都不如自己动手写一些程序测试一下看看来得实在,所以建议大家有什么疑惑可以自己写一些基本的程序测试一下便知道结果。如果大家有新的意见,欢迎补充,谢谢。
    展开全文
  • python 可变与不可变变量

    千次阅读 2019-03-09 19:17:28
    python中不存在所谓的传值调用,一切传递的都是对象的引用,也可以认为是传址。可变变量和不可变变量。为什么python函数参数不会被修改

    不可变变量

    操作某个对象时,重新开辟了内存,使其内存地址改变了,我们称其为可变对象,反之称为不可变变量

    我们可以通过下面的例子来感受上面的话

    x=1
    print (id(x))
    x+=1
    print (id(x))
    
    52454056
    52454032
    

    id()是一个内置函数,可以返回对象内存地址
    同样的变量x经过加操作后地址改变了。

    x=1
    y=1
    z=1
    print (id(x))
    print (id(y))
    print (id(z))
    
    56976040
    56976040
    56976040
    

    可以发现虽然变量名不同但是地址确实一样的。

    这种特性是不是很像某些语言中的字符串。我们称有这种特性的变量为不可变变量(值一旦改变就会占据新的内存空间)。python中的不可变变量有如下

    不可变(immutable):int、字符串(string)、float、(数值型number)、元组(tuple),None

    优点:
    这样可以减少重复的值对内存空间的占用。
    缺点:
    操作之后就开辟内存的特性。执行效率会有一定程度的降低。

    可变变量

    我再来看看可变变量

    x=[]
    y=[]
    z=[]
    print (id(x))
    print (id(y))
    print (id(z))
    
    62566472
    62669960
    62671368
    

    可以看见对于可变变量 ,创建一次就开辟一次地址,不会引用同一块内存

    x=[]
    print (id(x))
    x.append(1)
    print (id(x))
    
    49918024
    49918024
    

    而对同一个对象的操作。内存地址是不会改变的

    可变(mutable)变量:字典型(dictionary)、列表型(list)

    函数默认参数和None的作用

    python 中不可变量为按值传递,可变变量按引用传递

    def f(l=[]):
        l.append(1)
        return l
    print (f())
    print (f())
    print (f())
    
    [1]
    [1, 1]
    [1, 1, 1]
    

    这是为什么呢?首先我们要知道python 你看见的任何东西都是对象。函数也不例外,默认参数有如下特点

    • 一个函数参数的默认值,仅仅在该函数定义的时候,被赋值一次。
    • 函数默认参数参数在每次调用时指向那个定义时创建的参数

    现在我们来验证上上面的结果。
    参数的默认值就存在__defaults__中。

    def f(l=[]):
    
        l.append(1)
        return l
    f()
    print (f.__defaults__)
    f()
    print (f.__defaults__)
    f()
    print (f.__defaults__)
    
    
    ([1],)
    ([1, 1],)
    ([1, 1, 1],)
    

    可以看见参数的默认值就在其中,但是是不是同一个呢,现在我们来看看地址

    def f(i=1):
        print (id(i))
        i+=1
        print (id(i))
        return i
    
    f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    f()
    print ('默认值地址:%s'%+id(f.__defaults__[0]))
    f()
    print ('默认值地址:%s'%+id(f.__defaults__[0]))
    
    56976040
    56976016
    默认值地址:56976040
    56976040
    56976016
    默认值地址:56976040
    56976040
    56976016
    默认值地址:56976040
    

    可以发现函数定义时默认值就已近存在在__defaults__中了。在调用函数时我们的参数变量就会被赋值为这个__defaults__[0]地址。当.__defaults__[0]是不可变变量时,我们对参数变量进行修改时我们的参数变量地址会变化。这个和我们的逻辑思维一致。
    然而,可变变量就不一样了!

    def f(l=[]):
        print id(l)
        l.append(1)
        print id(l)
        return l
    
    f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    
    58904648
    58904648
    默认值地址:58904648
    58904648
    58904648
    默认值地址:58904648
    58904648
    58904648
    默认值地址:58904648
    

    因为可变变量的特性。我们在更改时时不会换地址的,所以我们一直都是在更改__defaults__[0] 。这种特性在默认参数中不是我们想要的。我们用如下的代码完成任务

    def f(l=None):
        print id(l)
        l=[]
        l.append(1)
        print id(l)
        return l
    
    print f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    print f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    print f()
    print ('默认值地址:%s'%id(f.__defaults__[0]))
    
    
    1792584792
    47296584
    [1]
    默认值地址:1792584792
    1792584792
    47296584
    [1]
    默认值地址:1792584792
    1792584792
    47296584
    [1]
    默认值地址:1792584792
    

    因为None是不可变变量,所以我对他的所有操作都是在新的内存中完成的。这其实也就是None的作用

    类中局部变量的注意事项

    class b:
        x = []
        def set(self):
            self.x.append(1)
        def get(self):
            return self.x
    for i in range(3):
        a = b()
        print (b.__dict__)
        a.set()
        a.get()
    
    
    {'x': [], '__module__': '__main__', 'set': <function set at 0x0000000002DE5AC8>, '__doc__': None, 'get': <function get at 0x0000000002DE5B38>}
    {'x': [1], '__module__': '__main__', 'set': <function set at 0x0000000002DE5AC8>, '__doc__': None, 'get': <function get at 0x0000000002DE5B38>}
    {'x': [1, 1], '__module__': '__main__', 'set': <function set at 0x0000000002DE5AC8>, '__doc__': None, 'get': <function get at 0x0000000002DE5B38>}
    

    可以发现每次创建类b时,其中的x都是不一样的。这是因为类的变量被所有实例共享,而变量又是可变变量,所有x都是指向同一个地址。类似c++类中的静态变量,所有类的实例共享一个。而对于不可变变量就不一样了。

    
    class b:
        x = 1
        def set(self):
            self.x+=1
        def get(self):
            return self.x
    for i in range(3):
        a = b()
        a.set()
        print("---------------------------")
        print("%d对象地址:%s"%(i,id(a)))
        print ("x的值:%d"%a.get())
        print("x的地址:%d" % id(a.x))
        print("---------------------------")
    
    
    ---------------------------
    0对象地址:1632001448536
    x的值:2
    x的地址:1896902144
    ---------------------------
    ---------------------------
    1对象地址:1632001471096
    x的值:2
    x的地址:1896902144
    ---------------------------
    ---------------------------
    2对象地址:1632001448536
    x的值:2
    x的地址:1896902144
    ---------------------------
    

    可以发现,类的”全局变量“是不可变变量,被操纵之后重新占据内存空间。如果想把可变变量变成静态变量(所有类的实例共享一个),我们可以有两个方法。

    1. 使用不可变变量包装一下,比如在原来的代码上进行如下的修改:
    class b:
        x = [1]
        def set(self):
            self.x[0]+=1
        def get(self):
            return self.x[0]
    for i in range(3):
        a = b()
        a.set()
        print("---------------------------")
        print("%d对象地址:%s"%(i,id(a)))
        print ("x的值:%d"%a.get())
        print("x的地址:%d" % id(a.x))
        print("---------------------------")
    
    D:\Python\learningExampleForPython\venv\Scripts\python.exe D:/Python/learningExampleForPython/example/test.py
    ---------------------------
    0对象地址:2433377426008
    x的值:2
    x的地址:2433377460872
    ---------------------------
    ---------------------------
    1对象地址:2433377448568
    x的值:3
    x的地址:2433377460872
    ---------------------------
    ---------------------------
    2对象地址:2433377426008
    x的值:4
    x的地址:2433377460872
    ---------------------------
    
    Process finished with exit code 0
    
    
    1. 使用global关键字,操作全局变量
    x=1
    class b:
        def set(self):
            global x
            x+=1
        def get(self):
            global x
            return x
    for i in range(3):
        a = b()
        a.set()
        print("---------------------------")
        print("%d对象地址:%s"%(i,id(a)))
        print ("x的值:%d"%a.get())
        print("x的地址:%d" % id(x))
        print("---------------------------")
    
    
    ---------------------------
    0对象地址:1739802401032
    x的值:2
    x的地址:1896902144
    ---------------------------
    ---------------------------
    1对象地址:1739802401368
    x的值:3
    x的地址:1896902176
    ---------------------------
    ---------------------------
    2对象地址:1739802401032
    x的值:4
    x的地址:1896902208
    ---------------------------
    
    Process finished with exit code 0
    
    
    展开全文
  • python可变和不可变类型

    千次阅读 2018-08-10 14:20:53
    列表是可变的(Mutable) 1)索引改变 2)方法改变 字符串是不可变的(Immutable) 通过索引改变会报错 字符串方法只是返回一个新字符串,并不改变原来的值 如果想改变字符串的值,可以用重新赋值的方法  ...
  • python中不可变数据类型和可变数据类型

    万次阅读 多人点赞 2019-05-29 17:43:15
    可变数据类型: 当该数据类型的对应变量的值发生了改变,那么它对应的内存地址也会发生改变,对于这种数据类型,就称不可变数据类型。 可变数据类型 :当该数据类型的对应变量的值发生了改变,那么它对应的内存...
  • python可变数据类型和不可变数据类型

    千次阅读 多人点赞 2019-01-06 23:44:46
    Python3可变数据类型与不可变数据类型 有很多人在刚开始接触 python 这个语言的时候,总是搞不清楚什么是 可变数据类型 什么是 不可变数据类型,今天就让我们通过这篇小文章来详细了解一下。 知识点目录: 1....
  • Scala的可变集合与不可变集合

    千次阅读 2020-03-25 21:15:48
    Scala语言中的集合可以分为可变与不可变集合。但是主要来自三个包: scala.collection scala.collection.immutable scala.collection.mutable 可变集合可以在适当的时候被更新或被扩展,这意味着你...
  • JAVA - 可变对象与不可变对象

    千次阅读 2018-06-14 18:34:08
    可变对象在并发程序中比较有用,由于其状态无法改变,因此无法被线程的干扰损坏或者被...* 可变对象(Mutable Objects):相对于不可变类,可变类创建实例后可以改变其成员变量值,开发中创建的大部分类都属于可变类...
  • java安全编码指南之:Mutability可变

    万次阅读 2020-09-03 09:20:15
    文章目录简介可变对象和不可变对象创建mutable对象的拷贝为mutable类创建copy方法不要相信equals不要直接暴露可修改的属性public static fields应该被置位finalpublic static final field 应该是不可变的 ...
  • python中的可变对象与不可变对象

    千次阅读 2018-12-20 22:40:20
    python与C/C++不一样,它的变量使用有自己的特点,...下面本文将对python里面的“可变数据类型”和“不可变数据类型”进行分析。 首先,我们需要知道在python中哪些是可变数据类型,哪些是不可变数据类型。可变数据...
  • java中可变对象与不可变对象

    千次阅读 2017-03-17 16:11:10
    可变对象(mutable Objects),不可变对象(Immutable ojbects),那么他们有什么区别呢? 不可变对象意味着这个对象是final的,对象中所有的公共属性是final的。同时说明这个对象是线程安全的,这意味着他们可以在多...
  • Python中的可变与不可变类型

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

    千次阅读 2017-10-01 20:11:38
    String类在java中是immutable(不可变),因为它被关键字final修饰。当String实例创建时就会被初始化,并且以后无法修改实例信息。String类是工程师精心设计的艺术品。 一、String为什么不可变? 要了解String类...
  • 可变和不可变类型 列表是可变的(Mutable) a = [1,2,3,4] a [1, 2, 3, 4] 通过索引改变: a[0] = 100 a [100, 2, 3, 4] 通过方法改变: a.insert(3, 200) a [100, 2, 3, 200, 4] a.sort() a [2, 3, 4, 100, ...
  • 可变类型与不可变类型的区分

    千次阅读 2018-10-28 19:57:24
    在python中的数据可以分为可变数据类型和不变数据类型。 可变数据类型:列表(list),字典(dict),集合(set)-------不可哈希 即:变量名存储的是一个地址,该地址指向一个具体的对象,并且不管对变量的值即对象...
  • python不可变类型和可变类型

    万次阅读 2018-02-28 14:45:50
    python变量可以分为两种类型不可变类型(数字、字符串、元组、不可变集合)可变类型(列表、字典、可变集合)python所声明的变量都以对象的形式存在,存在于机器的固定内存之中。可以理解为变量名为对象的指针如声明...
  • Java中可变类型和不可变类型

    千次阅读 2015-01-05 10:43:09
    Java中可变类型和不可变类型
  • 在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后就不能改变了(注意与val修饰的变量进行区别)1.1. 序列不可变的序列 import scala.collection.immutable._ 在Scala中...
  • python中的可变与不可变数据类型

    千次阅读 2017-09-05 22:06:45
    python中的可变数据类型包括字典和列表,而不可变数据类型包括字符串、数字和元组。 可变数据类型中,即便对数据进行更改,数据的id也不会发生变化,而不可变数据类型中,只要对数据的值进行更改,则数据的id就发生...
  • Java数据类型的可变与不可变

    千次阅读 2019-06-29 17:02:06
    可变数据类型: 当该数据类型的对应变量的值发生了改变,那么它对应的内存地址也会发生改变,对于这种数据类型,就称不可变数据类型。其中基本数据类型都是不可变数据类型,例如int,如果一个int类型的数据发生...
  • Scala入门_不可变列表与可变列表

    千次阅读 2020-02-08 14:19:02
    在scala中,也有两种列表,一种是不可变列表、另一种是可变列表 定义 不可变列表就是列表的元素、长度都是不可变的。 语法 使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表,语法格式: val/var 变量名...
  • Scala入门_不可变集与可变

    千次阅读 2020-02-08 14:21:18
    scala中的集也分为两种,一种是不可变集,另一种是可变集。 不可变集 定义 语法 创建一个空的不可变集,语法格式: val/var 变量名 = Set[类型]() 给定元素来创建一个不可变集,语法格式: val/var 变量名 = Set...
  • Java 可变 数组 可变 参数 实例

    千次阅读 2017-02-04 09:40:24
    Java将可变长参数当成数组对待。可以将一个数组或可变的参数个数传递给可变长参数。当用可变的参数个数调用方法时,Java会创建一个数组并把参数传给它。 public class TestArgs { /** * @param args */ public ...
  • Java可变参数/可变长参数

    千次阅读 2016-10-20 10:52:32
    Java可变参数/可变长参数传递的参数不确定长度,是变长的参数,例如小例子:package demo; public class Demo { public static int sum(int n, int... nums) { for (int i = 0; i ; i++) { n = n + nums[i];...
  • 什么是可变、不可变类型?

    千次阅读 2018-07-02 20:41:47
    可变可变指的是内存中的值是否可以被改变,不可变类型指的是对象所在内存块里面的值不可以改变,有数值、字符串、元组;可变类型则是可以改变,主要有列表、字典。...
  • 可变参数及可变参数宏的使用

    千次阅读 2018-06-12 09:15:19
    我们在C语言编程中会遇到一些参数个数可变的函数,例如printf()这个函数,这里将介绍可变函数的写法以及原理.* 1. 可变参数的宏一般在调试打印Debug 信息的时候, 需要可变参数的宏. 从C99开始可以使编译器标准支持可变...
  • python 序列的有序无序可变可变的理解 不可变数据类型: 是指变量的值发生改变时,其对应的内存地址也发生改变。 可变数据类型:是指变量的值发生改变时,其对应的内存地址不发生改变 1. 列表(有序可变): 循环...
  • Python中的可变对象和不可变对象

    千次阅读 2017-12-11 10:25:31
    python变量赋值(可变与不可变)知识点:python中,万物皆对象。  python中不存在所谓的传值调用,一切传递的都是对象的引用,也可以认为是传址。 Python在heap中分配的对象分成两类:可变对象和不可变对象。所谓...
  • 细谈python序列可变与不可变

    千次阅读 2019-07-08 20:56:36
    python中序列分为可变和不可变序列 可变序列:列表,字典 不可变序列:元组,字符串 二者的区别,看如下代码 1, a = [1,2,3,4,5] print(id(a)) # 函数id()可以表示出该对象的内存地址 a[0] = 0 print(id(a)) # 输出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,334,121
精华内容 933,648
关键字:

可变