python tuple获取元组元素,python元组常用的五种方法

　　元组是python中另一个重要的序列结构。与list类似，tuple由一系列按特定顺序排序的元素组成。

　　元组和列表的区别在于：

　　列表的元素可以改变，包括修改元素值，删除和插入元素，所以列表是一个可变序列；一旦元组被创建，它的元素就不能被改变，所以元组是不可变的序列。元组也可以看作是不可变的列表。通常，元组用于保存不需要修改的内容。

　　形式上，元组的所有元素都放在一对括号()中，相邻的元素用逗号分隔，如下所示：

　　(元素1、元素2、元素n)

　　其中element1~elementn表示元组中的每个元素，数量不限，只要是Python支持的数据类型即可。

　　从存储内容来看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据。并且在同一个元组中，元素的类型可以不同，例如：

　　( c.biancheng.net ，1，[2， a]，( abc ，3.0))

　　在这个tuple中，数据的类型有很多种，包括shaping、string、list和tuple。

　　另外，我们都知道list的数据类型是List，那么tuple的数据类型是什么呢？让我们来看看type()函数：

　　类型(( c.biancheng.net ，1，[2， a]，( abc ，3.0)))

　　类“元组”

　　如你所见，元组就是元组，这也是为什么很多教程用元组来指代元组的原因。

　　Python创建元组Python提供了两种创建元组的方法，如下所述。

　　1)使用()直接创建。

　　通过()创建一个元组后，一般用=将其赋给一个变量。具体格式是：

　　tuplename=(element1，element2，元素n)

　　其中tuplename表示变量名，element1 ~ elementn表示元组的元素。

　　例如，以下元组都是合法的：

　　Num=(7，14，21，28，35) course=(Python教程， 3358c.biancheng.net/Python/)ABC=( Python ，19，[1，2]，( C ，2.0)) in

　　课程=Python教程， http://c.biancheng.net/python/print(课程)运行结果是：

　　(《Python教程》，《http://c.biancheng.net/python/》)

　　需要注意的是，当创建的tuple中只有一个string类型的元素时，后面必须跟一个逗号，否则Python解释器会把它当作一个字符串。请看下面的代码：

　　#加逗号a=(3358c.biancheng.net/cplus/，)print (type (a)) print (a) #加逗号b=( 3358 c . biancheng . net/socket/)print(type(b))print(最后。

　　类“元组”

　　( http://c.biancheng.net/cplus/，)

　　类别“str”

　　http://c.biancheng.net/socket/

　　你看，只有变量A是元组，后面的变量B是字符串。

　　2)使用tuple()函数创建元组

　　除了用()创建元组，Python还提供了内置函数tuple()，将其他数据类型转换为元组类型。

　　tuple()的语法格式如下：

　　元组(数据)

　　其中，数据表示可以转换成元组的数据，包括字符串、元组、范围对象等。

　　Tuple()用法示例：

　　# Convert string to tuple tupl=tuple( hello )print(tupl)# Convert list to tuple list 1=[ Python ， Java ， C ，JavaScript ]tu p2=tuple(list 1)print(tu p2)# Convert dict 1={ a :100， b: 42， C :9 } tu P3=tuple(dict 1)print(tu P3)# Convert interval to tuple range 1 6)tu P4=tuple(range 1)print(tu P4)#创建空元组print(tuple())运行结果

　　( h ， e ， l ， l ， o )

　　(“Python”、“Java”、“C”、“JavaScript”)

　　(甲，乙，丙)

　　(1, 2, 3, 4, 5)

　　()

　　Python访问元组元素和访问列表是一样的。我们可以使用Index来访问元组中的一个元素(获取一个元素的值)，或者使用slice来访问元组中的一组元素(获取一个新的子元组)。

　　使用索引访问元组元素的格式是：

　　tuplename[i]

　　其中tuplename表示元组名，I表示索引值。元组的索引可以是正数，也可以是负数。

　　使用切片访问元组元素的格式是：

　　tuple name[开始：结束：步骤]

　　其中start表示起始索引，end表示结束索引，step表示步长。

　　请看下面的代码：

　　URL=tuple( 3358 c . biancheng . net/shell/)#使用索引访问一个元素print(url[3]) #使用正索引print(url[-4]) #使用负索引#使用slice访问一组元素print(url[9: 18]) #使用正数

　　p

　　e

　　( b ， I ， a ， n ， c ， h ， e ， n ， g )

　　( b ， n ， e )

　　( s ， h ， e ， l ， l )

　　Python修改元组我们之前说过，元组是不可变的序列，元组中的元素是不可修改的，所以只能创建一个新的元组来替换旧的元组。

　　例如，要重新分配元组变量：

　　Tup=(100，0.5，-36，73) print (tup) #重新分配元组tup=(Shell脚本， 3358c.biancheng.net/shell/ )print(tup)运行如下：

　　(100, 0.5, -36, 73)

　　(“贝壳剧本”，“http://c.biancheng.net/shell/”)

　　此外，还可以通过连接多个元组(使用可以拼接的元组)向元组添加新元素，例如：

　　P1=(100，0.5，-36，73) tup2=(3 12j，-54.6，99)print(tu P1 tu p2)print(tu P1)print(tu p2)运行结果如下：

　　(100，0.5，-36，73，(3 ^ 12j)，-54.6，99)

　　(100, 0.5, -36, 73)

　　((3 ^ 12j)，-54.6，99)

　　你看，用了串接元组之后，tup1和tup2的内容是不能改变的，也就是说生成了一个新的元组。

　　删除Python元组当创建的元组不再使用时，可以通过del关键字将其删除，例如：

　　Tup=(Java教程， http://c.biancheng.net/Java/)print(tup)del tup print(tup)运行如下：

　　(《Java教程》，《http://c.biancheng.net/java/》)

　　回溯(最近一次呼叫):

　　模块中文件“C:\ Users \ mozhiyan \ Desktop \ demo . py”的第4行

　　打印(一张)

　　名称错误：未定义名称“tup”

　　Python自带垃圾收集功能，会自动销毁未使用的元组，一般不需要通过del手动删除。

　　元组和列表的区别元组和列表都属于序列类型，都可以按照特定的顺序存储一组数据。数据类型不限，只要是Python支持的数据类型即可。那么，元组和列表有什么区别呢？

　　元组和列表最大的区别在于，列表中的元素可以随意修改，就像用铅笔在纸上写的字一样。如果它们是错误的，它们可以被删除和重写。除非替换整个元组，否则无法修改元组中的元素，这就像用圆珠笔写的字一样。一旦写了，除非换另一张纸，否则无法抹去。

　　可以理解为tuple是列表的只读版本。

　　需要注意的是，这样的差异必然会影响到两者的存储方式。让我们直接看下面的例子：

　　listdemo=[]

　　listdemo。__sizeof__()

　　40

　　tupleDemo=()

　　tupleDemo。__sizeof__()

　　24

　　可以看出，对于链表和元组来说，虽然都是空的，但是元组比链表少占用16个字节。为什么？

　　实际上，因为链表是动态的，所以需要存储指向相应元素的指针(占用8个字节)。此外，因为列表中的元素是可变的，所以需要额外存储分配的长度(占用8个字节)。但是对于元组来说，情况就不一样了。元组的长度是固定的，存储元素是不可变的，所以存储空间也是固定的。

　　读者可能会问，既然列表这么强大，为什么还需要序列类型tuple呢？

　　通过比较链表和元组的区别，我们可以得出这样的结论：元组比链表轻，所以总体来说，元组的执行速度比链表快。

　　另外，Python会在后台对静态数据做一些资源缓存。一般来说，由于垃圾收集机制的存在，如果一些变量没有被使用，Python会将它们占用的内存回收，并返回给操作系统，供其他变量或其他应用使用。

　　但是对于一些静态变量(比如元组)，Python会临时缓存这部分内存，如果不使用的话，占用空间也不大。这样，下次创建相同大小的元组时，Python可以直接分配之前缓存的内存空间，而不用向操作系统发送请求来寻找内存，从而大大加快了程序的运行速度。

　　下面的例子是计算初始化同一个元素的列表和元组所需的时间。我们可以看到元组的初始化速度比列表快5倍。

　　c:\ Users \ mengmapython-m time it x=(1，2，3，4，5，6)

　　20000000次循环，5次最佳：每次循环9.97纳秒

　　c:\ Users \ mengmapython-m time it x=[1，2，3，4，5，6]

　　5000000次循环，最佳5次：每次循环50.1纳秒

　　当然，如果你想添加、删除或更改元素，那么列表显然更好。因为对于元组，必须通过创建新的元组来完成。

　　一般来说，元组的用途不如列表，但元组仍然是最重要的序列类型之一，其不可替代性体现在以下场景中：

　　元组是作为很多内置函数和序列类型方法的返回值而存在的，也就是说当一些函数或方法被使用时，它们的返回值会是元组类型，所以你必须要处理元组。元组的访问和处理速度比链表快。因此，当需要访问指定的元素且不涉及修改元素的操作时，建议使用元组。元组可以用作映射中的“键”(以及集合的成员)，但列表不能。这将在后面的章节中详细解释。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。