精华内容
下载资源
问答
  • 参考链接:https://www.liaoxuefeng.com/wiki/1016959663602400/1017104324028448dict是字典,...补充:python中数值类型(int、float)、元组、str是不可变对象,而列表list、字典dict、集合set是可变对象list.cout('...

    参考链接:https://www.liaoxuefeng.com/wiki/1016959663602400/1017104324028448

    dict是字典,可以储存键值对类型的值,set与dict相同,只是set只储存key值,而不储存value。

    补充:

    python中数值类型(int、float)、元组、str是不可变对象,而列表list、字典dict、集合set是可变对象

    list.cout('a')查看list中'a'的个数

    >>> l

    ['a', 2]

    >>> l.count('a')

    List

    问题:list index out of range 和 list assignment index out of range的原因

    >>> a=[[],[],[1]]

    >>> a[0][-1]=5

    Traceback (most recent call last):

    File "", line 1, in

    IndexError: list assignment index out of range#是再下标溢出的情况下依旧分配值的时候出现的异常

    >>> a[0][-1]

    Traceback (most recent call last):

    File "", line 1, in

    IndexError: list index out of range#是访问的下标超出了list的地址

    >>> a[0][1]=5

    Traceback (most recent call last):

    File "", line 1, in

    IndexError: list assignment index out of range

    >>> a[0][1]

    Traceback (most recent call last):

    File "", line 1, in

    IndexError: list index out of range

    >>>

    dict

    a={'sex':'nan'}

    >>> 'sex' in a#默认在key中检查

    True

    >>> 'nan' in a

    False

    >>> 'sex' in a.values()

    False

    >>> 'nan' in a.values()

    True

    >>> 'sex' in a.keys()

    True

    >>>

    dict又称map,他以键值对的形式储存数据,并且为了查找方便,在存储数据的时候,会根据key的值去计算应该放置的位置。为了保证计算位置的算法的结果不冲突,所以就要求dict数据的key值不能重复。由于这种特性,使得在查找数据时,与list的从头开始查找相比,dict中储存的数据查找时极快的,但是对空间有些浪费,因为常规情况下的带储存数据经过算法处理后,并不会无间隔的紧密的按顺序放置在内存中,而是分散的。

    dict内部存放的顺序和key放入的顺序是完全没有关系的

    dict的key必须是不可变对象,因为dict内使用hash计算key存放的位置,如果每次计算相同的key得出的结果不同,就会造成key的混乱,如果用可变对象当作key,会报错

    >>> key = [1, 2, 3]

    >>> d[key] = 'a list'

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: unhashable type: 'list'

    dict的一些方法和特性

    一个key只能对应一个value

    可以通过in判断是否存在(只匹配key,不匹配value)

    >>> l={'a':'1','b':'2'}

    >>> 'a' in l

    True

    >>> '1' in l

    False

    还可以通过 get() 方法获取指定key的内容,若key不存在,返回None,或者返回自己指定的内容

    >>> l.get('a')

    '1'

    >>> l.get('1')#返回None

    >>> l.get('1',aaa)

    Traceback (most recent call last):

    File "", line 1, in

    NameError: name 'aaa' is not defined#因为必须写“aaa”

    >>> l.get('1',1111)

    1111

    >>>

    使用 pop(key) 方法删除指定的key值

    使用remove()删除list中的index

    参考链接:https://blog.csdn.net/u013066730/article/details/85260764

    使用dict一定要注意,dict的key一定是不可变对象,在Python中,字符串、整数等都是不可变的,而list是可变的。

    list与dict的区别:

    两者之间的区别主要在于查找速度和对储存的使用率上面

    1)list的查找速度会随着存放数据的数量的增加而增加,但占用的内存小,浪费内存还小。

    2)dict的查找速度极快,不会受存放数据数量大小的影响,但占用内存大,浪费空间多。

    set

    set 和dict类似,也是一组 key 的集合,但不储存 value ,同样的key不能重复。

    使用一个list作为输入创建set

    >>> s=set([1,2,'a'])#注意创建时传入的参数是一个list

    >>> s

    {1, 2, 'a'}#这样显示并不代表set是有序的

    >>> s=set([1,2,'a','a'])

    >>> s

    {1, 2, 'a'} #不重复

    >>>

    使用 add(key) 添加 key 到 set 中

    >>> s.add('b')

    >>> s.add('a')#重复添加没有效果

    >>> s

    {1, 2, 'a', 'b'}

    使用 romove(key) 删除

    set 可以看作为数学意义上的一个集合,这个集合中的元素是无序的、是不重复的,可以做数学意义上的交集、并集操作。

    >>> b=set([3,4,'d'])

    >>> s&b#交集

    set()

    >>> b

    {'d', 3, 4}

    >>> s|b#并集

    {1, 2, 'a', 3, 4, 'b', 'd'}

    >>>

    不能添加可变元素,注意:tuple虽然是不可变元素,但是包含可变元素的tuble也不行

    >>> b.add([5,6])

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: unhashable type: 'list'

    AttributeError: 'tuple' object has no attribute 'add'

    >>> b.add((1,2,[3,4]))#tuple中包含了可变元素list

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: unhashable type: 'list'

    >>>

    可变与不可变对象

    不可变对象就是虽然看起来对他的改变会生效,是因为其返回一个新的对象。如

    >>> a = 'abc'

    >>> b = a.replace('a', 'A')

    >>> b

    'Abc'

    >>> a

    'abc'

    而可变对象如 list

    >>> l=[1,2]

    >>> l

    [1, 2]

    >>> l[0]='a'

    >>> l

    ['a', 2]

    >>>

    所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

    展开全文
  • 可变与不可变类型对象可变和不可变,本质上就是改变了里面数据后,内存地址是否有改变可变类型、不可hash不可变类型,可hash列表字符串字典数字集合元组不可变的集合什么是可变/不可变对象不可变对象,该对象所...

    可变与不可变类型对象

    可变和不可变,本质上就是改变了里面的数据后,内存地址是否有改变

    可变类型、不可hash

    不可变类型,可hash

    列表

    字符串

    字典

    数字

    集合

    元组

    不可变的集合

    什么是可变/不可变对象

    不可变对象,该对象所指向的内存中的值不能被改变。当改变某个变量时候,由于其所指的值不能被改变,相当于把原来的值复制一份后再改变,这会开辟一个新的地址,变量再指向这个新的地址。

    可变对象,该对象所指向的内存中的值可以被改变。变量(准确的说是引用)改变后,实际上是其所指的值直接发生改变,并没有发生复制行为,也没有开辟新的出地址,通俗点说就是原地改变。

    不可变对象的例子

    a = 2b = 2c = a +0

    c +=0

    print(id(a), id(b), id(2)) # id都相同

    print(c is b) #True

    字符串里的不可变情况

    astr = 'good'bstr = 'good'cstr = astr + ''

    print(cstr is bstr) # True

    print(id(astr), id(bstr), id('good')) # 三个id相同

    如果是下面这种情况,变量修改后不在是good

    astr = 'good'

    print(id(astr))

    astr += 'aa'

    print(id(astr)) # id和上面的不一样

    由于是不可变对象,变量对应内存的值不允许被改变。当变量要改变时,实际上是把原来的值复制一份后再改变,开辟一个新的地址,

    astr再指向这个新的地址(所以前后astr的id不一样),原来astr对应的值因为不再有对象指向它,就会被垃圾回收。这对于int和float类型也是一样的。

    再看tuple

    add = (1, 2, 3)

    aee = (1, 2, 3)

    print(id(add), id(aee), id((1, 2, 3))) # id各不相同

    aee = (1, 2, 3)

    print(id(aee))

    aee += () # 加空元组

    print(id(aee)) # id变了!

    print(aee) #(1 ,2,3)

    虽然看上去都是(1 ,2, 3)按理说应该和上面一致才对。难道这是可变对象?再看

    add = (1, 2, 3)

    aee =add

    print(id(aee), id(add)) # 这两个id一样

    aee += (4, 5, 6)

    print(id(aee)) # aee的id变了!

    print(add) # add还是(1, 2, 3)没有变

    如果是可变对象add = aee,它们指向同一地址(id相同)是肯定的。aee的改变不会引起add的改变,所以tuple是不可变对象,但又和str数值类型稍微有点区别。平常说的tuple不可变更多时候是指里面存放的值不能被改变(有些特殊情况,如tuple里面存放了list,可改变list里的元素。但实际上这个tuple并没有被改变)。

    对于str、int、float只要在它们再类型相同的情况下,值也相同,那么它们的id相同。(为什么要说类型相同?)

    a = 2.0b = 2

    print(a is b) # False, 一个int一个float,类型都不同

    2和2.0就不在一个地址上。

    可变对象的例子

    lis = [1, 2, 3]

    lis2 = [1, 2, 3]

    # 虽然它们的内容一样,但是它们指向的是不同的内存地址

    print(lis islis2)

    print(id(lis), id(lis2), id([1, 2, 3])) # 三个id都不同

    再看赋值的情况下

    alist = [1, 2, 3]

    # alist实际上是对对象的引用,blist = alist即引用的传递,现在两个引用都指向了同一个对象(地址)

    blist =alist

    print(id(alist), id(blist)) # id一样

    # 所以其中一个变化,会影响到另外一个

    blist.append(4)

    print(alist) # 改变blist, alist也变成了[1 ,2 ,3 4]

    print(id(alist), id(blist)) # id一样,和上面值没有改变时候的id也一样

    集合也是一样的:

    abb = {1, 2, 3}

    acc =abb

    print(id(abb), id(acc))

    acc.add(4)

    print(abb) # {1, 2, 3, 4}

    print(id(abb), id(acc)) # 相等

    和上面list的例子一致。

    可变对象由于所指对象可以被修改,所以无需复制一份之后再改变,直接原地改变,所以不会开辟新的内存,改变前后id不变。

    当然不可变对象就不是这样了, 可以和这个对比一下

    abc = 3dd =abc

    dd = 43

    print(abc) # 3,并不随dd的改变而改变

    但是如果是拷贝,就仅仅是将内容拷贝过去,传递的并是不引用。这在想使用列表的值又不想修改原列表的时候特别有用。

    blist = alist[:] # or alist.copy()

    print(alist is blist) # False

    blist.append(4)

    print(alist) # 还是[1,2 ,3]没有变化

    ****关于内存地址相同的延伸:

    小数据池

    python 为了优化速度,避免整数频繁使用和占用内存空间。对较小的整数在【-5,256】范围内的整数对象是提前建立好的,不会被垃圾回收,公用同一个内存地址

    数字的比较:

    >>> a= 1000 # 使用Python编辑器,超过256,地址就不一样

    >>> b = 1000

    >>> a is b

    False>>> a = 233

    >>> b = 233

    >>> a is b

    True

    字符串的比较:

    当字符串中有空格的时候,内存地址不同

    >>> a = 'a b c'

    >>> b = 'a b c'

    >>> a is b

    False

    >>> a = 'a b'

    >>> b = 'a b'

    >>> a is b

    False

    >>> a = 'ab'

    >>> b = 'ab'

    >>> a is b

    True

    当字符串长度 >20,内存地址不同

    >>> a = 's'*20

    >>> b = 's'*20

    >>> a is b

    True

    >>> a = 's'*21

    >>> b = 's'*21

    >>> a is b

    False

    大整数池:

    终端(cmd\)是每执行一次,都会重新创建,而在pycharm中,每次运行都是将所有代码加载到内存中,属于一个整体,所以会有一个大整数对象池的概念,即处于一个代码块的大整数是同一个对象。

    # c1 和d1 处于一个代码块,相等

    # c1.b和c2.b分别有自己的代码块,不相等

    Pycharm中的程序:

    class C1(object):

    a = 100

    b = 100

    c = 1000

    d = 1000

    class D2(object):

    a = 100

    b = 100

    c = 1000

    print(C1.a is C1.b) # True

    print(C1.a isD2.a) # True

    print(C1.a isD2.b) # True

    print(C1.c is C1.d) # True

    print(C1.c is D2.c) # False

    展开全文
  • python中列表长度可变吗?...int()和str()都是不可变类型列表、字典是可变类型对于可变对象,比如list,对list进行操作,list内部内容是会变化,比如:>>> a = ['c', 'b', 'a']>>...

    python中列表长度可变吗?下面给大家介绍一下python中可变和不可变的类型:

    可变、不可变

    可变/不可变类型,指的是:内存id不变,type也不变的前提下,value是否是可变的。

    int()和str()都是不可变类型

    列表、字典是可变类型

    对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如:

    >>> a = ['c', 'b', 'a']>>> a.sort()>>> a

    ['a', 'b', 'c']

    相关推荐:《python视频教程》

    而对于不可变对象,比如str,对str进行操作呢:

    >>> a = 'abc'>>> a.replace('a', 'A')'Abc'>>> a'abc'

    虽然字符串有个replace()方法,也确实变出了'Abc',但变量a最后仍是'abc',应该怎么理解呢?

    我们先把代码改成下面这样:

    >>> a = 'abc'>>> b = a.replace('a', 'A')>>> b'Abc'>>> a'abc'

    要始终牢记的是,a是变量,而'abc'才是字符串对象!有些时候,我们经常说,对象a的内容是'abc',但其实是指,a本身是一个变量,它指向的对象的内容才是'abc':

    当我们调用a.replace('a', 'A')时,实际上调用方法replace是作用在字符串对象'abc'上的,而这个方法虽然名字叫replace,但却没有改变字符串'abc'的内容。相反,replace方法创建了一个新字符串'Abc'并返回,如果我们用变量b指向该新字符串,就容易理解了,变量a仍指向原有的字符串'abc',但变量b却指向新字符串'Abc'了:

    所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

    展开全文
  • python中列表长度可变吗?...int()和str()都是不可变范例列表、字典是可变范例关于可变对象,比方list,对list举行操纵,list内部内容是会变化,比方:>>> a = ['c', 'b', 'a']>&...

    python中列表长度可变吗?下面给人人引见一下python中可变和不可变的范例:

    可变、不可变

    可变/不可变范例,指的是:内存id稳定,type也稳定的前提下,value是不是是可变的。

    int()和str()都是不可变范例

    列表、字典是可变范例

    关于可变对象,比方list,对list举行操纵,list内部的内容是会变化的,比方:

    >>> a = ['c', 'b', 'a']>>> a.sort()>>> a

    ['a', 'b', 'c']

    相干引荐:《python视频教程》

    而关于不可变对象,比方str,对str举行操纵呢:

    >>> a = 'abc'>>> a.replace('a', 'A')'Abc'>>> a'abc'

    虽然字符串有个replace()要领,也确切变出了'Abc',但变量a末了还是'abc',应当怎样明白呢?

    我们先把代码改成下面如许:

    >>> a = 'abc'>>> b = a.replace('a', 'A')>>> b'Abc'>>> a'abc'

    要一直切记的是,a是变量,而'abc'才是字符串对象!有些时刻,我们经常说,对象a的内容是'abc',但实际上是指,a本身是一个变量,它指向的对象的内容才是'abc':

    当我们挪用a.replace('a', 'A')时,实际上挪用要领replace是作用在字符串对象'abc'上的,而这个要领虽然名字叫replace,但却没有转变字符串'abc'的内容。相反,replace要领建立了一个新字符串'Abc'并返回,假如我们用变量b指向该新字符串,就轻易明白了,变量a仍指向原有的字符串'abc',但变量b却指向新字符串'Abc'了:

    所以,关于稳定对象来讲,挪用对象本身的恣意要领,也不会转变该对象本身的内容。相反,这些要领会建立新的对象并返回,如许,就保证了不可变对象本身永远是不可变的。

    以上就是python中列表长度可变吗的细致内容,更多请关注ki4网别的相干文章!

    展开全文
  • python中列表长度可变,可变类型指是内存id不变,type也...下面给大家介绍一下python中可变和不可变的类型:可变、不可变可变/不可变类型,指是:内存id不变,type也不变前提下,value是否是可变。int()和...
  • python中列表长度可变吗?...int()和str()都是不可变类型列表、字典是可变类型对于可变对象,比如list,对list进行操作,list内部内容是会变化,比如:>>> a = ['c', 'b', 'a']>>...
  • python中列表长度可变吗?...int()和str()都是不可变类型列表、字典是可变类型对于可变对象,比如list,对list进行操作,list内部内容是会变化,比如:>>> a = ['c', 'b', 'a']>>...
  • python中列表长度可变吗?...int()和str()都是不可变类型列表、字典是可变类型对于可变对象,比如list,对list进行操作,list内部内容是会变化,比如:>>> a = ['c', 'b', 'a']>>...
  • 我试图从Excel表格中绘制一些数据(在同一个图上),我想要一个可变长度的字符串列表作为输入,对应不同材料。我得到以下错误:TypeError:“NoneType”对象不可读取我真不明白为什么。代码如下:import xlrdimport...
  • 可变长度参数列表

    2018-04-27 19:26:55
    概念:可变长度参数列表,其语法就是类型后跟…,表示此处接受参数为0到多个Object类型对象,或者是一个Object[]。栗子:写一个方法叫做test(String…strings),没毛病,能写test(String[] strings),会出编译...
  • scala的不可变列表

    千次阅读 2020-02-09 19:26:06
    列表 列表是scala中最重要的、...不可变列表就是列表的元素、长度都是不可变的。 语法 使用List(元素1, 元素2, 元素3, …)来创建一个不可变列表,语法格式: scala val/var 变量名 = List(元素1, 元素2, 元素3…) 使...
  • Scala入门_不可变列表与可变列表

    千次阅读 2020-02-08 14:19:02
    列表 列表是scala中最重要的、也是最...不可变列表就是列表的元素、长度都是不可变的。 语法 使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表,语法格式: val/var 变量名 = List(元素1, 元素2, 元素3....
  • 介绍一些函数没有参数,另一些具有多个。...在本文中,我们将研究如何定义和使用带有可变长度参数函数。这些函数可以接受数量不明输入,可以是连续输入,也可以是命名参数。通过* args使用许多参数让我...
  • 理解是你需要更快地编写代码,你只想知道为什么它更慢.要回答这个问题,让我们来看看反汇编.出于本讨论目的,我将在函数调用中包装每个方法,在每个反汇编中可以忽略u和v加载以及return命令.def test1(u,v):...
  • 为什么80%码农都做了架构师?>>> ...
  • 为了简化编码,c#提供了一个特殊关键字params,允许在调用方法时提供数量可变的实参,而不是由方法实现固定好形参数量。先看代码吧。 using System; using System.Linq; using System.IO; class HelloWorld { ...
  • scala的可变列表

    千次阅读 2020-02-09 19:35:25
    可变列表 ...可变集合都在mutable包中 不可变集合都在immutable包中(默认导入) 定义 使用ListBuffer元素类型创建空可变列表,语法结构: scala val/var 变量名 = ListBufferInt 使用ListBuf...
  • jdk1.5新特性:变长变量。 1. 定义实参个数可变的方法...而一个带有这样形参方法,就是一个实参个数可变的方法。注意调用参数可变方法多种形式 public static void main(String[] args) throws Exceptio...
  • Python元组与列表类似,不同之处在于元组元素能修改。元组使用小括号,列表使用方括号。>>> aTuple = ('et',77,99.9)>>> aTuple('et',77,99.9)<1>访问元组<2>修改元组说明: ...
  • 3.可变长度,异质,可任意嵌套 4.支持原位改变 5.对象引用数组 tuple元组: 1.可包含任意对象有序集合 2.通过下标索引(位置偏移)访问元素 3.固定长度,异质,可任意嵌套 4.对象引用数组
  • static final类型数组在某些情况下我们需要一个常量数组来保存一些不变值,但是单纯将数组声明成static final类型可以...解决方案一:使公有数组变成私有,并增加一个公有的不可变列表private static final St
  • J2SE 1.5之前,一直无法在Java程序里定义实参个数可变的方法——因为Java要求实参(Arguments)和形参(Parameters)数量和类型都必须逐一匹配,而形参数目是在定义方法时就已经固定下来了。尽管可以通过重载...
  • 我承认这个我以前还真是知道,汗一个!...当然不同资料可能将这项功能称之为:可变长度变元列表,或者,可变变元,或者,var-arg, 或者,vararg,这里,我们习惯称之为:可变元数参数,当然,它们指是同一件事
  • Mario Kart 64课程代码生成器,用于根据层列表定义首选项进行随机可变长度的大奖赛 Create React App入门 该项目是通过引导。 可用脚本 在项目目录中,可以运行: npm start 在开发模式下运行应用程序。 打开在...
  • java中可变参数列表

    2019-06-12 09:56:01
    java中的可变参数列表跟数组大致是一样的,其Object… object(可变参数列表)是可变长度的而数组的长度不可变的需要进行设定。 入参时传入参数 调用方法使用Object… object进行接收。 …表示此处接受的参数为0到多...
  • 在某些情况下我们希望函数参数个数可以根据实际需要来定,所以C语言中就提供了一种长度不确定参数,形如:“…”,C++语言也继承了这一语言特性。在采用ANSI标准形式时,参数个数可变的函数原型是: type ...
  • 内存地址不变化即可变类型不可变类型不可以变化,字符串和数字字符串内置方法索引取值索引切片成员运算for循环len长度strip 去掉空格lstrip/rstripstartswith/endswithsplitjoincountfind/indexcenter/ljust/rjust...
  • Java 可变参数列表

    2019-12-04 21:55:41
    可变长度参数列表是从Java 5开始,Java语言对方法参数支持一种新写法,在方法定义中可以使用个数确定参数,其语法就是类型后跟…。 在具有可变长参数方法中可以把参数当成数组使用,例如可以循环输出所有...

空空如也

空空如也

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

列表的长度不可变