python中list和tuple的用法及区别,列表list和元组tuple的不同有哪些

　　列表和元组Tuple是Python中最通用、最有用的数据类型。列表是动态的，而元组具有静态特征。本文将通过实例详细讲解如何使用它们，有需要的可以参考。

　　00-1010 List List List是一个有序列表，可以包含任何对象。通过索引访问列表元素列表嵌套列表变量元组元组定义和元组元素比较列表元组分配的优点，打包和解包列表和元组的区别

列表 List

　　是列表对象的有序集合。定义列表时，指定元素的顺序是列表的固有特征，并且在列表的生命周期中保持不变。

　　#顺序不同的相同元素的列表是不同的。

　　List_=[曹操，曹丕，甄嬛，蔡文桓]

　　List_b=[冯真，蔡文风，曹丕，曹操]

　　list_==list_b

　　错误的

　　list_ is list_b

　　错误的

列表是有序的

　　列表中的元素可以都是同一类型。

　　List_=[曹操，曹丕，甄嬛，甄嬛]

　　列表_

　　[曹操，曹丕，贞观，贞观]

　　元素可以是不同的类型。

　　List_=[21.42，曹操，3，4，曹丕，False，3.14159]

　　列表_

　　[21.42，《曹操》，3，4，《曹丕》，假，3.14159]

　　列表甚至可以包含复杂的对象(函数、类和模块)

　　（同Internationalorganizations）国际组织

　　类“int”

　　低输入联网（low-entry networking的缩写）

　　内置功能镜头

　　def王朝_勇士():

　　及格

　　王朝_勇士

　　0x000002A96EAB1840处的功能王朝_勇士

　　导入数学

　　数学

　　模块“数学”(内置)

　　list_=[int，len，王朝_勇士，数学]

　　列表_

　　[class int ，内置函数len，函数王朝_勇士at0x000002A96EAB1840，模块 math (内置)]

　　该列表不必是唯一的。给定的对象可以在列表中出现多次。

　　List_=[曹丕，冯真，冯真，曹丕，冯真，曹丕]

　　列表_

　　[曹丕，珍珍，珍珍，曹丕，珍珍，曹丕]

列表可以包含任意对象

　　类似字符串的列表索引可以使用方括号中的索引来访问列表中的每个元素。

　　List_=[曹操，曹丕，甄嬛，蔡文桓]

　　列表_[0]，列表_[2]

　　(《曹操》，《贞观》)

　　列表_[-1]，列表_[-2]

　　(《蔡文》，《甄》)

　　切片表达式 [m:n] 返回索引 m 到 n 包括索引 n 的元素。

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_[2:4]
　　[甄姫, 蔡文姫]

　　字符串切片的其他特性也适用于列表切片

　　正索引和负索引

list_[-5:-2]
　　[曹操, 曹丕]
　　list_[0:2]
　　[曹操, 曹丕]
　　list_[-5:-2] == list_[0:2]
　　True

　　省略索引开头和结束索引

print(list_[:2], list_[0:2])
　　[曹操, 曹丕][曹操, 曹丕]
　　print(list_[2:], list_[2:len(a)])
　　[甄姫, 蔡文姫][甄姫, 蔡文姫] 
　　list_[:4] + list_[4:]
　　[曹操, 曹丕, 甄姫, 蔡文姫]
　　list_[:4] + list_[4:] == list_
　　True

　　指定步幅的正负索引

list_[0:4:2]
　　[曹操, 甄姫]
　　list_[1:4:2]
　　[曹丕, 蔡文姫]
　　list_[4:0:-2]
　　[蔡文姫, 曹丕]

　　反转列表

list_[::-1]
　　[蔡文姫, 甄姫, 曹丕, 曹操]

　　运算符和内置函数处理列表

　　运算符 in 和 not in

list_

　　[曹操, 曹丕, 甄姫, 蔡文姫]

　　蔡文姫 in list_

　　True

　　曹仁 not in list_

　　True

　　连接( + )和复制( * )运算符

list_ = [曹操, 曹丕]
　　list_ + [甄姫, 蔡文姫]
　　[曹操, 曹丕, 甄姫, 蔡文姫]
　　list_ * 2
　　[曹操, 曹丕, 甄姫, 蔡文姫 曹操, 曹丕, 甄姫,蔡文姫]

　　函数 len()、min()、max()

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　len(a)
　　4
　　min(list_ )
　　曹丕
　　max(list_ )
　　蔡文姫

列表嵌套

　　列表中的元素可以是任何类型的对象，一个列表可以包含子列表，而子列表又可以包含子列表本身，依此类推。

　　常规嵌套列表操作

list_ = [a, [bb, [ccc, ddd], ee, ff], g, [hh, ii], j]
　　[a, [bb, [ccc, ddd], ee, ff], g, [hh, ii], j]
　　# list_[0], list_[2], 和list_[4]是字符串
　　print(list_[0], list_[2], list_[4])
　　a g j
　　# list_[1]和list_[3]是子列表
　　list_[1]
　　[bb, [ccc, ddd], ee, ff]
　　list_[3]
　　[hh, ii]
　　# 访问子列表中的元素需附加索引
　　list_[1]
　　[bb, [ccc, ddd], ee, ff]
　　list_[1][0]
　　bb
　　list_[1][1]
　　[ccc, ddd]
　　list_[1][2]
　　ee
　　list_[1][3]
　　ff
　　list_[3]
　　[hh, ii]
　　print(list_[3][0], list_[3][1])
　　hh ii
　　# list_[1][1]是另一个子列表，访问需要添加索引
　　list_[1][1]
　　[ccc, ddd]
　　print(list_[1][1][0], list_[1][1][1])
　　ccc ddd
　　# 索引和切片的常用语法也适用于子列表。
　　list_[1][1][-1]
　　ddd
　　list_[1][1:3]
　　[[ccc, ddd], ee]
　　list_[3][::-1]
　　[ii, hh]
　　# in 操作符使用。
　　ddd in x
　　False
　　ddd in x[1]
　　False
　　ddd in x[1][1]
　　True

列表可变

　　创建列表后，可以随意添加、删除、移动和移动元素。

　　修改单个列表值

　　列表中的值可以通过索引和简单赋值进行替换。

s = 曹操，曹丕，甄姫
　　s[2] = 蔡文姫
　　Traceback (most recent call last):
　　 File "<stdin>", line 1, in <module>
　　TypeError: str object does not support item assignment

　　使用 del 命令删除列表项

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　del list_[3]
　　list_
　　[曹操, 曹丕, 甄姫]

　　修改多个列表值

　　切片实现 a[m:n] = <iterable> 序列迭代替换值

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_[1:4]
　　[曹丕, 甄姫, 蔡文姫]
　　list_[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]
　　list_
　　[曹操, 1.1, 2.2, 3.3, 4.4, 5.5]

　　多个元素来代替单个元素

list_ = [1, 2, 3]
　　list_[1:2] = [2.1, 2.2, 2.3]
　　list_
　　[1, 2.1, 2.2, 2.3, 3]
　　list_ = [1, 2, 3]
　　list_[1] = [2.1, 2.2, 2.3]
　　list_
　　[1, [2.1, 2.2, 2.3], 3]
　　list_ = [1, 2, 7, 8]
　　list_[2:2] = [3, 4, 5, 6]
　　list_
　　[1, 2, 3, 4, 5, 6, 7, 8]

　　切片分配空列表删除列表中间的多个元素

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_[1:4] = []
　　list_
　　[曹操]

　　列表附加元素或元素附加到列表

list_ = [曹操, 曹丕]
　　list_ += [ 甄姫, 蔡文姫]
　　list_
　　[曹操, 曹丕, 甄姫, 蔡文姫]
　　list_ = [10, 20] + list_
　　list_
　　[10, 20, 曹操, 曹丕, 甄姫, 蔡文姫]

　　列表拼接元素的方法不能直接添加

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_ += 20
　　Traceback (most recent call last):
　　 File "<pyshell#58>", line 1, in <module>
　　 list_ += 20
　　TypeError: int object is not iterable
　　list_ += [20]
　　list_
　　[曹操, 曹丕, 甄姫, 蔡文姫, 20]

　　append(<obj>) 将对象附加到列表中

list_ = [曹操, 曹丕]
　　list_.append(123)
　　list_
　　[曹操, 曹丕, 123]
　　x = list_.append(123)
　　print(x)
　　None

　　list.extend(<iterable>)，追加元素

list_ = [曹操, 曹丕]
　　list_.extend([1, 2, 3])
　　list_
　　[曹操, 曹丕, 1, 2, 3]

　　list.insert(<index>, <obj>)，插入元素

　　将对象插入列表

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_.insert(3, 3.14159)
　　list_[3]
　　3.14159
　　list_
　　[曹操, 曹丕, 甄姫, 3.14159, 蔡文姫]

　　list.remove(<obj>)，按照元素删除元素

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_.remove(甄姫)
　　list_
　　[曹操, 曹丕, 蔡文姫]
　　# 如果<obj>不在中列表，则会引发异常。
　　list_.remove(曹丕k)
　　Traceback (most recent call last):
　　 File "<pyshell#13>", line 1, in <module>
　　 list_.remove(曹丕k)
　　ValueError: list.remove(x): x not in list

　　list.pop(index=-1)，按索引删除元素

　　从列表中删除一个元素，需要指定索引并返回被移除的项目的值，pop(-1) 等价于 pop()

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　list_.pop()
　　蔡文姫
　　list_
　　[曹操, 曹丕, 甄姫]
　　list_.pop()
　　甄姫
　　list_
　　[曹操, 曹丕]

　　列表是动态的，随着项目数据的变化而变化

list_ = [曹操, 曹丕, 甄姫, 蔡文姫]
　　# 数据增加
　　list_ [2:2] = [1, 2, 3]
　　list_ += [3.14159]
　　list_ 
　　[曹操, 曹丕, 1, 2, 3, 甄姫, 蔡文姫, 3.14159]
　　# 数据删除
　　a = [曹操, 曹丕, 甄姫, 蔡文姫]
　　a[2:3] = []
　　del a[0]
　　a
　　[曹丕, 蔡文姫]

元组 Tuple

　　对象的有序集合，称为元组。与列表的区别在于元组是通过括号 ( () ) 而不是方括号 ( [] ) 中来定义的，以及元素不可变。

定义和使用元组

t = (曹操, 曹丕, 甄姫, 蔡文姫)
　　t
　　(曹操, 曹丕, 甄姫, 蔡文姫)
　　t[0]
　　曹操
　　t[-1]
　　蔡文姫
　　t[1::2]
　　(曹丕, 蔡文姫)
　　# 可以进行倒序排列
　　t[::-1]
　　(蔡文姫, 甄姫, 曹丕, 曹操)
　　# 元组不可修改
　　t = (曹操, 曹丕, 甄姫, 蔡文姫)
　　t[2] = 曹丕k
　　Traceback (most recent call last):
　　 File "<pyshell#65>", line 1, in <module>
　　 t[2] = 曹丕k
　　TypeError: tuple object does not support item assignment

元素对比列表的优点

处理速度更快
防止被意外修改
字典需要不可变更类型的值作为组件

# 元素用,分割
　　a = 曹操
　　b = 42
　　a, 3.14159, b
　　(曹操, 3.14159, 42)
　　# 定义一个空的元组
　　t = ()
　　type(t)
　　<class tuple>
　　# 定义项目的元组
　　t = (2,)
　　type(t)
　　<class tuple>
　　t[0]
　　2
　　t[-1]
　　2
　　# 元组单一元素会包含符号
　　print(t)
　　(2,)

元组分配、打包和解包

　　可以将包含多个项目的文字元组分配给单个对象。

t
　　(曹操, 曹丕, 甄姫, 蔡文姫)
　　t[0]
　　曹操
　　t[-1]
　　蔡文姫

　　被打包的对象直接被分配新的元组中，并解释到各个元组对象。

(s1, s2, s3, s4) = t
　　s1
　　曹操
　　s2
　　曹丕
　　s3
　　甄姫
　　s4
　　蔡文姫

　　解包时，左边的变量个数必须与元组中的值个数相匹配

(s1, s2, s3) = t
　　Traceback (most recent call last):
　　 File "<pyshell#16>", line 1, in <module>
　　 (s1, s2, s3) = t
　　ValueError: too many values to unpack (expected 3)
　　(s1, s2, s3, s4, s5) = t
　　Traceback (most recent call last):
　　 File "<pyshell#17>", line 1, in <module>
　　 (s1, s2, s3, s4, s5) = t
　　ValueError: not enough values to unpack (expected 5, got 4)

　　打包、解包一步操作

(s1, s2, s3, s4) = (曹操, 曹丕, 甄姫, 蔡文姫)
　　s1, s2, s3, s4 = 曹操, 曹丕, 甄姫, 蔡文姫
　　s1
　　曹操
　　s2
　　曹丕
　　s3
　　甄姫
　　s4
　　蔡文姫

　　元组互换进行互换赋值

a = 曹操
　　b = 曹丕
　　a, b
　　(曹操, 曹丕)
　　a, b = b, a
　　a, b
　　(曹丕, 曹操)

List 与 Tuple 的区别

　　功能说明列表元组元素操作可变不可变迭代耗时耗时多相对较快操作修改执行插入、删除、追加操作仅限访问元素内存消耗消耗内存多消耗内存少内置方法内置方法多内置方法少容错概率易发生变化和错误难发生

　　到此这篇关于一文搞懂Python中列表List和元组Tuple的使用的文章就介绍到这了,更多相关Python列表元组内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

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