精华内容
下载资源
问答
  • 列表与元组小结

    2019-05-24 15:21:23
    1.列表与元组的相似之处 a. 列表与元组都是可以用于储存不同的数据类型有序集合...2. 列表与元组的不同之处 a. 列表是动态的,长度可变,可以对列表进行删除、改变、添加元素 b. 元组是静态的,长度大小固定,无法增...

    1.列表与元组的相似之处

    a. 列表与元组都是可以用于储存不同的数据类型有序集合
    li = ['cdsc',1245,'dsd',5678]          ## 列表
    
    tup = ('sxsc',12345,'sds',78)       ##  元组
    
    

    2. 列表与元组的不同之处

    a. 列表是动态的,长度可变,可以对列表进行删除、改变、添加元素
    b. 元组是静态的,长度大小固定,无法增加删减或者改变

    3. 列表与元组的存储关系

    a. 元组是静态的,一旦确定元组的大小就不可以进行更改,基于元组的这条特性,元组的存储大小一开始就已经确定。
    b. 列表是动态的,列表的大小一般会比本身存储的元素的总字节大,因为动态的特性导致了列表中存储了一个指向当前元素的指针,该指针会占用一定的存储空间。动态的特性也会导致列表分配的空间会比当前存储的字节数大。

    4. 列表与元组的嵌套

    a. 列表嵌套列表,其中的每一个元素都是可变的,相当于二维指针
    b. 列表嵌套元组,列表中的元素可变,但是元组元素不可变
    
    输入:
    	lie = [(1,2,3),(4,5,6),78,'4551']
    	lie[0] = (1245,45678)
    	lie
    输出:
    	[(1245, 45678), (4, 5, 6), 78, '4551']
    *************************************************
    
    输入:
    	lie = [(1,2,3),(4,5,6),78,'4551']
    	lie[0][0] = 23
    	lie
    输出:
    	TypeError: 'tuple' object does not support item assignment
    
    c. 元组嵌套列表,导致一个元组成为“可变”元组。
    输入:
    	tup =([12,34,56],[78,96],78,'sdsd')
    	tup[0] = [1234,5678]
    	tup
    输出:
    	TypeError: 'tuple' object does not support item assignment
    ********************************************************************************
    
    输入:
    	tup =([12,34,56],[78,96],78,'sdsd')
    	tup[0][0]= 124578
    	tup[0][1]= 369874
    	tup
    
    输出:
    	([124578, 369874, 56], [78, 96], 78, 'sdsd')
    
    d. 元组嵌套元组,其中的每一个数据都是不可变的

    思考?

    创建一个空列表,使用下面的两种方式,哪一个效率更好?

    方式一:

    empty_list = list()  
    

    方式二:

    empty_list = []
    

    答案:

    方式一是调用函数创建空列表,会出现其他的一系列栈的分配操作
    方式二直接调用,[ ] 是一个内置的c函数,更优。

    展开全文
  • 除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列数据,事实真是如此吗?看起来除了元组不可变之外,列表完全可以取代元组,为什么要多此一举创造出元组...

    如果有了解过python中的列表和元组,你可能会知道相对于列表,元组是不可变的,也就是说元组中的数据不能随意更改。除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗?

    看起来除了元组不可变之外,列表完全可以取代元组,为什么要多此一举创造出元组这种类型?其实这背后有更深层的含义,列表是用来表示一组相同类型(相同价值)的数据,而元组用来存放不同类型(不同价值)的数据,简单来说,列表是同质的,而元组是异构的。

    比如说,现在有一本书,书里面有一些批注。我们用元组来表示书中第几页第几行的内容,像这样:position = (page, line),然后把它放到字典里作为批注的键,表示第几页第几行有批注。同时,我们用列表来表示这些位置,如果有新的位置,可以加入列表。这符合列表可以更改数据的特点。但是如果更改元组里面的数据就没有意义了,因为这些坐标本来就是存在的。

    在python的模块中,我们可以找到很多例子:

    比如range方法用来生成一列有序地数据,这些数据是等价的,并没有不同的功能,所以用列表来表示最合适。而像下面的例子:

    当前时间适合用元组来表式,因为元组中每个数据有不同的功能,或者说有不同的价值,像第一个数据表示年份。

    说到这,想起了我们之前说过的具名元组nametuple,它用来快速的生成一个类,可以看成是类的轻量级替代方法,也很符合我们上面说的元组的功能。

    原文链接:https://segmentfault.com/a/1190000012463067

    展开全文
  • 列表与元组

    2019-10-22 20:46:15
    2.列表与元组的区别 1)列表是动态的,长度大小不固定,可以随意的增加、删减或者改变元素。 2)元组是静态的,长度大小固定,无法增加、删减或者改变。 3.列表和元组的基本操作和注意事项 1)首先,和其他语言不同...

    1.列表和元组的基础
    列表和元组都是一个可以放置任意数据类型的有序合集。(在绝大多数编程语言中,集合的数据类型必须一致。不过,对于python的列表和元组来说,并无此要求)
    2.列表与元组的区别
    1)列表是动态的,长度大小不固定,可以随意的增加、删减或者改变元素。
    2)元组是静态的,长度大小固定,无法增加、删减或者改变。
    3.列表和元组的基本操作和注意事项
    1)首先,和其他语言不同,Python中的列表和元组都支持负数索引,-1表示最后一个元素,-2表示倒数第二个元素,以此类推。
    2)列表和元组都支持切边操作
    3)列表和元组都可以随意嵌套
    4)两者可以通过list()和tuple()函数相互转换:

    list = [1,2,3]list[0]=10print(list)# [10, 2, 3] 
    tuple = ([2,4,6],2,"ni")
    tuple[0].append(1)print(tuple)# ([2, 4, 6, 1], 2, 'ni') tuple[0]=["1",3,5]---------------------------------------------------------------------------
    print(tuple)      
    tuple[0]=["1",3,5] 
    TypeError: 'tuple' object does not support item assignment

    4.性能差异
    通过学习列表和元组存储方式的差异,我们可以得出结论:元组要比列表更加轻量级一些,所以总体上来说,元组的性能速度要略优于列表。
    另外,Python会在后台,对静态数据做一些资源缓存(resource caching)。通常来说,因为垃圾回收机制的存在,如果一些变量不被使用,Python就会回收它们所占用的内存,返还给操作系统,以便其他变量或其他应用使用。
    但是对于一些静态变量,比如元组,如果它不被使用并且占用空间不大时,Python会暂时缓存这部分内存。这样,下次我们在创建同样大小的元组时,Python就可以不用再向操作系统发出请求,去寻找内存,而是可以直接分配之前缓存的内存空间,这样就能大大加快程序的运行速度。

    展开全文
  • 列表与元组的不同点在于列表可修改而元组不可以。 索引 和C++的数组类似,Python里列表的索引从0开始。 #第一个例子 >>>G='stars' &...

    Python列表与元组学习笔记

    列表与元组都是一种序列。而列表与元组的不同点在于列表可修改而元组不可以。

    索引

    和C++的数组类似,Python里列表的索引从0开始。

     #第一个例子
    >>>G='stars'
    >>> G[1]
     't'
     #第二个例子
    >>>'hello'[0]
    'h'

    切片

    获取列表中指定范围的元素

    >>>Num=[1,2,3,4,5,6,7,8,9]
    >>>Num[1:3]
     [2,3]
     #切片的值还可为负数
     >>>Num=[1,2,3,4,5,6,7,8,9]
     >>>Num[-3:-1]  #负数表示倒数
     [7,8]
     #还可以省略
     >>>Num=[1,2,3,4,5,6,7,8,9]
     >>>Num[-3:]  #省略后项
     [7,8,9]
     >>>Num=[1,2,3,4,5,6,7,8,9]
     >>>Num[:3]  #省略前项
     [1,2,3]
     >>>Num=[1,2,3,4,5,6,7,8,9]
     >>>Num[:]  #均省略
    [1,2,3,4,5,6,7,8,9]
     #实际上还可以超出索引
     >>>Num=[1,2,3,4,5,6,7,8,9]
     >>>Num[7:9]
     [8,9] 
    

    注意:如果在使用切片时,第一个索引指定的元素位于了第二个指定元素的后方,则会返回一个空序列,即:[]

    切片的步长

    切片的步长默认为1,但我们也可以进行自定义设置

    方法如下

     >>>Num=[1,2,3,4,5,6,7,8,9]
     >>>Num[0,6,2]  #设置步长为2
     [1,3,5]

    想象一下步长设置为负数时会发生什么

    成员资格

    即检查特定的值是否包含在序列中
    使用运算符in

    示例如下

    >>>chec=['hero','man','woman']
    >>>'man' in chec
    True

    序列:长度,最值

    三个函数:len,max,min

    示例如下:

    >>>num=[123,34,57,89]
    >>>len(num)
    4
    >>>max(num)
    123
    >>>min(num)
    34

    列表

    列表亦有加减乘

    #加法
    lst=['Hello','World']+['Python']
    >>>['Hello','World','Python']
    #乘法
    lst=3*['python']
    >>>['python','python','python']

    函数list

    创建列表的函数,示例如下:

    >>>list('hello')
    ['h','e','l','l','o']

    注:可将任何序列作为list的参数而不只局限于字符串。

    列表的操作

    列表的赋值

    >>>num=[1,2,3]
    >>>num[1]=6
    >>>num
    [1,6,3]

    如何删除元素

    使用del语句

    >>>num=[1,2,3]
    >>>del num[1]
    >>>num
    [1,3]

    切片赋值

    包含多种情况,如下所示

    #情况1
    >>>lang=['C','C#','Java','Html','PHP']
    >>>lang[3:]=['Python','R']
    >>>lang
    ['C', 'C#', 'Java','Python', 'R']
    #情况2(长度改变)
    >>>lang=['C','C#','Java','Html','PHP']
    >>>lang[2:]=['Python','R','C++']
    >>>lang
    ['C', 'C#', 'Python', 'R', 'C++']
    #情况3(从中间插入)
    >>> lang=['C','C#','Java','Html','PHP']       
    >>> lang[2:2]=['Python','R']          
    >>> lang          
    ['C', 'C#', 'Python', 'R', 'Java', 'Html', 'PHP']
    #情况4(替换为空)
    >>> lang=['C','C#','Java','Html','PHP']       
    >>> lang[1:]=[]       
    >>> lang          
    ['C']

    列表的方法

    append方法

    用于将一个对象附加到列表末尾。

    >>> lst = [1, 2, 3] 
    >>> lst.append(4)
    >>> lst
     [1, 2, 3, 4] 
    clear方法

    清空列表的内容

    >>>lst=[1,2,3]
    >>>lst.clear()
    >>>lst
    []
    copy方法

    复制列表.值得一提的是,常规复制只是将另一个名称关联到列表.如下所示:

    #常规复制
    >>>a=[1,2,3]
    >>>b=a
    >>>b[1]=9
    >>>a
    [1,9,3]
    #copy方法
    >>>a[1,2,3]
    >>>b=a.copy()
    >>>b[1]=9
    >>>a
    [1,2,3]
    count方法

    计算指定的元素在列表中出现了多少次

    >>>name=['ag','eg','lg','ex','ag','lg','ag',[1,2]]
    >>>name.count('ag')
    3
    >>>name.count([1,2])
    1
    extend方法

    能够同时将多个值附加到列表末

    >>>a=[1,2,3]
    >>>b=[4,5,6]
    >>>a.extend(b)
    >>>a
    [1,2,3,4,5,6]
    index方法

    在列表中查找指定值第一次出现的索引

    >>>name=['a','b','c','a']
    >>>name.index(a)
    0
    insert方法

    将一个对象插入列表

    >>>num=[1,2,3,4]
    >>>num.insert(2,'a')
    >>>num
    [1,2,'a',3,4]
    pop方法

    从列表中删除一个元素(末尾为后一个元素),并返回这一元素。

    >>>num=[1,2,3]
    >>>num.pop()
    3
    >>>num
    [1,2]
    remove方法

    用于删除第一个为指定值的元素。

    >>>num=[1,2,3,1]
    >>>num.remove(1)
    >>>num
    [2,3,1]
    reverse方法

    按相反的顺序排列列表中的元素

    >>>num=[1,2,3]
    >>>num.reverse()
    >>>num
    [3,2,1]
    sort方法

    对列表就地排序。就地排序意味着对原来的列表进行修改

    >>> x = [4, 6, 2, 1, 7, 9] 
    >>> x.sort() 
    >>> x 
    [1, 2, 4, 6, 7, 9] 
    #以下为错误示范
    >>> x = [4, 6, 2, 1, 7, 9] 
    >>> y=x.sort() 
    >>> y
    None
    #改正为
    >>> x = [4, 6, 2, 1, 7, 9] 
    >>>y=sorted(x)
    >>> x 
    [4,6,2,1,7,9]
    >>>y
    [1,2,4,6,7,9]
    sort高级排序

    方法sort接受两个可选参数:key和reverse。这两个参数通常是按名称指定的,称为关键字 参数,将在第6章详细讨论。参数key类似于参数cmp:你将其设置为一个用于排序的函数。然而, 不会直接使用这个函数来判断一个元素是否比另一个元素小,而是使用它来为每个元素创建一个 键,再根据这些键对元素进行排序。因此,要根据长度对元素进行排序,可将参数key设置为函数len。

    >>>x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
    >>>x.sort(key=len) 
    >>>x
    ['add', 'acme', 'aerate', 'abalone', 'aardvark'] 

    对于另一个关键字参数reverse,只需将其指定为一个真值(True或False,将在第5章详细介 绍),以指出是否要按相反的顺序对列表进行排序。

     x = [4, 6, 2, 1, 7, 9]
     x.sort(reverse=True) 
     x 
     [9, 7, 6, 4, 2, 1] 

    函数sorted也接受参数key和reverse。在很多情况下,将参数key设置为一个自定义函数很有用。

    元组

    创建方式

    >>>1,2,3
    (1,2,3)   #此即为元组
    >>>()
    ()
    >>>100,   #逗号不可省略
    (100)

    元组的用法

    元组的用法与列表大致相同

    展开全文
  • 列表与元组都是两种数据结构:相同点 都是序列 都可以存储任何数据类型 可以通过索引访问 可以存放任何类型数据,支持切片,迭代等操作, 不同点; 可变与不可变,元组是不可变类型,大小固定,而列表是可变...
  • python — 列表与元组

    2019-05-15 23:39:00
    2.列表与元组的区别 1)列表是动态的,长度大小不固定,可以随意的增加、删减或者改变元素。 2)元组是静态的,长度大小固定,无法增加、删减或者改变。 3.列表和元组的基本操作和注意事项 1)首先,和其他语言...
  • • 元组与列表类似,也是一种序列,不同之处在于元组中元素不能被改变,并且使用小括号中的一系列元素。 5.5.1 元组的创建 • 创建元组的语法非常简单,只需用逗号将元素隔开,具体示例如下: tuple1 = 1, 2, 3, 4 ...
  • 列表与元组都是容器,是一系列对象 都可以包含任意类型元素甚至可以是一个序列,还可以包含元素顺序 不同点: 列表是可变,而元组是不可变,tuple 不可追加,tuple大小不可再改变。 不能把...
  • 字符串不同的是,元组列表并不要求所有元素种类相同,每个元素都可以是任何python类型对象。列表可变,赋值后可插入或删除其中元素。元组不可变,赋值后不可更改1.列表1.1使用[]或list[]创建列表使用[]...
  • Python之列表与元组

    2019-07-18 16:31:44
    Python列表与元组列表列表增列表删除列表遍历其他操作赋值与深浅拷贝列表解析式列表生成式元组通过索引值查找对应元素查找元素索引值注意:不能够增,删,改。拼接重复判断元素是否存在内置函数(最大值最小值...
  • Python 列表与元组

    2019-06-21 15:41:24
    Python中元组与列表类似,不同之处在于元组元素不能修改。但是不可变的元组有什么意义?因为元组不可变,所以代码更安全。所以,如果可能,能用元组代替列表就尽量用元组列表:[1,2,3,4,5] 。 list('...
  • Python列表与元组

    2019-05-01 19:31:29
    列表元组是Python中最常用两种数据结构,字典是第三种。 相同点: 1.都是序列 2.都可以存储任何数据类型 3.可以通过索引访问 不同点: 语法差异 使用方括号[]创建列表,而使用括号()创建元组。 请看以下示例: ...
  • 相同点: 都是可以放置任意数据类型有序集合。 内部实现都是 数组 形式。...列表的存储空间要比元组大一些,因为列表是可变,所以要多存两个元素,一个是当前列表的大小,另一个是存储一个指
  • python2: 列表与元组

    2019-08-08 18:28:14
    列表与元组 1.序列概述 最常用两种序列:列表和元组。另一种重要的序列是字符串 列表和元组的主要不同在于,列表是可以修改的,而元组不可以。这意味着列表适用于需要 中途添加元素的情形,而元组适用于出于某种...
  • 列表的命名规则就是一个方括号([]),创建一个列表只要把逗号分隔的不同的数据项使用方括号括起来即可。列表中每个元素都分配有一个数字(从0开始),这个数字即为该元素的位置(或索引)也可以认为是该元素的下标,第一...
  • Python中的列表与元组

    2019-12-05 11:15:33
    #一、序列 l 成员有序排列,且可以通过下标偏移量访问到它一个或者几个成员,这类类 型统称为序列。 l 序列数据类型包括:字符...Python中的列表与C语言中数组不同,数组中存储是同一种数据类型集合,而列表...
  • 相同点:属于有序序列、可以强制转换、使用len()统计元素个数、使用count()统计指定元素的出现次数。不同点:1、元组类型为tuple,列表类型为...Python列表元组的相同点与不同点1.相同点( 1 )索引相同,从左到右都...
  • python列表与元组

    2017-08-31 23:45:23
    列表可变数据类型 列表的定义 列表的特性 列表的方法 1增加 ... 1 列表是打了激素数组,数组只能存储同种类型数据,而列表像一个仓库,存储不同类型数据. 2 序列是Python中最基本数据结
  • 字符串、列表元组的相同点和不同点 符号 引号“ ” 方括号[ ] 小括号() 特征 字符串 列表 元组 类型 string list tuple 顺序 \ 有序 有序 重复、索引、切片 T T T 增 T append()、extend()、...
  • 相同点:属于有序序列、可以强制转换、使用len()统计元素个数、使用count()统计指定元素的出现次数。不同点:1、元组类型为tuple,列表类型为...Python列表元组的相同点与不同点1.相同点( 1 )索引相同,从左到右都...
  • 字符串、列表元组的与不同 1.相同点: 拼接方法相同 a+b 重复方法相同 a*3 索引中的切片、定位相同 a[i] a[ : : ] 元素遍历 li = "abcd"/["a","b","c","d"]/("a","b","c","d") for i in range...
  • 字符串、列表元组的相同之处 运算符方面 Python 表达式(以列表为例) 结果 描述 len([1, 2, 3]) 3 长度 [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合 [‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ...
  • 0. 写在前面今天,我们先来介绍python里数据基本组成方式。 在python里面有这些高级父类,叫做容器,容器包含但不仅限于以下3类:...1)列表,就如同数组一样,不过各个元素可以是不同的,比如:Edward=[‘a’,2
  • 列表与元组的不同之处 列表 元组 [] () 可以修改 不能修改 定义元组 元组可以被理解为不能更改的列表,也是用来存放一组相关的元素的。 1.直接定义 直接将元素用",“隔开放在”()"里。 >>>tup_...
  • 列表与元组、字典与集合、字符串大杂烩 列表与元组 基础 相同点: 列表和元组都是一个可以放置任意数据类型有序集合; 列表和元组都支持负数索引; 列表和元组都支持切片操作; 列表和元组都可以随意嵌套。 不同...

空空如也

空空如也

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

列表与元组的不同