Python元组基础：定义、操作与列表比较

python中元组应该如何定义?

在Python编程中，元组是一种非常实用的数据结构，它提供了与列表不同的独特属性。
下面，我们将详细学习元组的定义、运算、打包和拆包操作、变量值交换以及与列表的比较。
首先，元组是一种不可变的容器数据类型，意味着一旦定义，其内部元素就无法添加或删除，元素值也无法更改。
元组通常使用(x,y,z)形式的语法来定义。
例如，('Hello',100)是正确的元组定义，而('Hello')和(100)分别表示字符串和整数。
元组支持与列表相同的运算符，例如加法、减法、乘法、除法等。
它们还支持成员操作、索引操作、切片操作等。
另外，当多个值被分配给一个变量时，这些值会被打包到一个元组中；相反，当一个元组被分配给多个变量时，该元组被打包成多个值；例如，将(1,2,3)赋值给(A,B,C)后，A、B、C分别收到值1、2、3。
在解包过程中，如果解包后的值与变量数量不匹配，则会引发ValueError异常。
为了处理变量个数小于元组元素个数的情况，可以使用星号表达式（*）。
这样，一个变量可以接收多个值，并且这些值被打包到一个表中。
例如，将(1,2,3)解包为(A,B)后，A为[1,2]，B为3。
注意星号表达式只能在解包语句中使用一次。
元组与列表共享许多操作，例如拼接、排序等。
然而，由于其不可变的特性，元组不具备列表的动态调整能力。
列表支持添加、删除、清除和排序元素等操作，而元组不支持这些操作，但元组通常占用较少的内存。
最后，列表和元组的生成语法是Python语言的一个非常独特且高效的功能。
建议使用列表构造来创建列表，以提高代码可读性和执行效率。

python里面元组是什么意思？

‍

↑↑↑点击上方蓝字，回复信息，10G惊喜

作者：陈太洋@阿里云Python训练营博客-地址：https://blog.csdn.net/weixin_43509371/article/details/108522941

Python是一种通用编程语言，在科学计算和机器学习领域有着广泛的应用。
如果我们计划使用Python进行机器学习，那么对Python有一个基本的了解很重要。
这个Python入门系列就是为这样的初学者精心准备的。

列表的定义

列表的创建

将项目添加到列表

列表中的项目删除

检索列表中的元素列表

常见列表运算符

列表的其他方法

元组

创建一个元组并访问它

更新并删除元组

元组相关运算符

内置方法

解包元组

列表

简单数据类型

整数

浮点型

布尔型

容器数据类型

列表

元组

字典

集合

单词字符串

列表的定义

列表是一个没有固定大小的有序集合，可以有任何号码来自存储任何类型的Python对象[元素1、元素2、...、元素n]。

最重要的一点是“方括号[]”和“逗号”，

方括号将所有元素连接在一起

逗号单独分隔个元素

列表创建创建一个普通列表x=['星期一','星期二','星期三','星期四','星期五']print(x,type(x))#['星期一','星期二','星期三','星期四','星期五']

x=[2,3,4,5,6,7]print(x,type(x))#[2,3,4,5,6,7]使用range()创建列表x=list(range(10))print(x,type(x))#[0,1,2,3,4,5,6,7,8,9]

x=list(范围(1,11,2))print(x,type(x))#[1,3,5,7,9]

x=list(range(10,1,-2))print(x,type(x))#[10,8,6,4,2]用于创建推导创建列表x=[0]*5print(x,type(x))#[0,0,0,0,0]

x=[0foriinrange(5)]print(x,type(x))#[0,0,0,0,0]

x=[iforiinrange(10)]print(x,type(x))#[0,1,2,3,4,5,6,7,8,9]

x=[iforiinrange(1,10,2)]print(x,type(x))#[1,3,5,7,9]

x=[iforiinrange(10,1,-2)]print(x,type(x))#[10,8,6,4,2]

x=[i**2foriinrange(1,10)]print(x,type(x))#[1,4,9,16,25,36,49,64,81]

x=[iforiinrange(100)if(i%2)!=0and(i%3)==0]打印（x，类型（x））

#[3,9,15,21,27,33.39、

注意：

由于列表的元素可以是任意对象，因此列表中存储的是对象的指针。
即使存储简单的[1,2,3]也有3个指针和3个整数对象。

x=[a]*4操作仅创建对列表的4个引用。
因此，一旦a发生变化，x中的4个a也会发生变化。

x=[[0]*3]*4print(x,type(x))#[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]

x[0][0]=1print(x,type(x))#[[1,0,0],[1,0,0],[1,0,0],[1,0,0]]

a=[0]*3x=[a]*4print(x,type(x))#[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]

x[0][0]=1print(x,类型(x))#[[1,0,0],[1,0,0],[1,0,0],[1,0,0]]创建混合列表mix=[1,'lsgo',3.14,[1,2,3]]print(mix,type(mix))#[1,'lsgo',3.14,[1,2,3]]创建一个空列表empty=[]print(empty,type(empty))#[]

列表与元组不同。
列表的内容是可以改变的（changeable），所以追加（append、expand）、插入（Insert）、删除操作（Remove、Pop）都可以在上面使用。

向列表中添加元素

list.append(obj)向列表末尾添加一个新对象，只接受一个参数，并且该参数可以是任何数据类型。
附加元素保留列表中的原始结构类型。

x=['星期一','星期二','星期三','星期四','星期五']x.append('星期四')print(x)#['星期一','星期二','星期三','星期四','星期五','星期四']

print(len(x))#6

如果这样element是一个列表，列表被视为追加时，要注意append()和extension()的区别。

x=['星期一','星期二','星期三','星期四','星期五']x.append(['星期四','星期日'])print(x)#[“星期一”、“星期二”、“星期三”、'星期四','星期五',['星期四','星期日']]

print(len(x))#6

list.extend(seq)一次将另一个序列中的多个值添加到列表末尾（扩展原始列表以包含新列表）。
)

x=['星期一','星期二','星期三','星期四','星期五']x.extend(['星期四','星期日'])print(x)#['星期一','星期二','星期三day','星期四','星期五','星期四','星期日']

print(len(x))#7

严格来说，追加是“Append”将整个事物添加到列表的末尾，而“extend”是将事物的所有元素添加到列表的末尾的扩展。

list.insert(index,obj)在索引位置插入obj。

x=['星期一','星期二','星期三','星期四','星期五']x.insert(2,'星期日')print(x)#["星期一","星期二","星期日","星期三","星期四","星期五"]

print(len(x))#列表中的6个元素delete

list.remove(obj)删除OneHit列表中值的第一个元素

x=['星期一','星期二','星期三','星期四','星期五']x.remove('星期一')print(x)#['星期二sday','Wednesday','Thursday','Friday']

list.pop([index=-1])删除列表中的一个元素（默认为最后一个元素），并返回元素的值

x=['星期一','星期二','星期三','星期四','星期五']y=x.pop()print(y)#星期五

y=x.pop(0)print(y)#星期一

y=x.pop(-2)print(y)#Wednesdayprint(x)#['Tuesday','Thursday']

Remove和Pop都可以删除元素。
前者指定要删除的具体元素，后者指定索引。

delvar1[,var2...]删除单个或多个对象。

如果你知道要删除的项目在列表中的位置，则可以使用del语句。

x=['星期一','星期二','星期三','星期四','星期五']delx[0:2]print(x)#['星期三','星期四','Friday']检索列表中的元素

通过元素的索引值从列表中检索单个元素。
请注意，列表索引值从0开始。

通过指定索引-1，您可以告诉Python返回最后一个列表元素，-2返回倒数第二个列表元素。
最后一个列表项，等等。

x=['星期一','星期二','星期三',['星期四','星期五']]print(x[0],type(x[0]))#Mondayprint(x[-1],type(x[-1]))#['星期四','Friday']print(x[-2],type(x[-2]))#Wednesday

切片的常用写法是start:stop:step

"start:"

从列表的起始编号到末尾进行切片，步长设置为1（默认）。

x=['星期一','星期二','星期三','星期四','星期五']print(x[3:])#['星期四','星期五day']print(x[-3:])#['星期三','星期四','星期五']":stop"

从步骤1开始列表头部（默认）将零件剪切到编号停止处。

week=['星期一','星期二','星期三','星期四','星期五']print(week[:3])#['星期一','星期二','Wednesday']print(week[:-3])#['Monday','Tuesday']"start:stop"

对于数字，从步骤1开始（默认）朝编号的停靠点切去。

week=['星期一','星期二','星期三','星期四','星期五']print(week[1:3])#['星期二','Wednesday']print(week[-3:-1])#['Wednesday','Thursday']-"start:stop:step"

使用特定步骤从将数字的开头分段到数字的结尾。
请注意，最后将步骤设置为-1相当于以相反的顺序对列表进行排序。

week=['星期一','星期二','星期三','星期四','星期五']print(week[1:4:2])#['星期二','星期四']print(周[:4:2])#['星期一','星期三day']print(week[1::2])#['星期二','星期四']print(week[::-1])#['星期五','星期四','星期三','星期二','Monday']::

复制列表中的所有元素（浅复制）。

week=['星期一','星期二','星期三','星期四','星期五']print(week[:])#['星期一','星期二','星期三','星期四','星期五']浅复制和深复制list1=[123,456,789,213]list2=list1list3=list1[:]

print(list2)#[123,456,789,213]print(list3)#[123,456,789,213]list1.sort()print(list2)#[123,213,456,789]print(list3)#[123,456,789,213]

list1=[[123,456],[789,213]]list2=list1list3=list1[:]print(list2)#[[123,456],[789,213]]print(list3)#[[123,456],[789,213]]list1[0][0]=111print(list2)#[[111,456],[789,213]]print(list3)#[[111,456],[789,213]]列表常用运算符

等号运算符：==

串联运算符+

硬复运算符*

成员运算符in，而不是

“等于仅当成员和成员位置相等时，sign=="才返回True。

组合列表有两种方式：“加号+”和“乘*”。
前者连接开头和结尾，后者连接文案。

list1=[123,456]list2=[456,123]list3=[123,456]

print(list1==list2)#Falseprint(list1==lis)t3)#True

list4=list1+list2#extend()print(list4)#[123,456,456,123]

list5=list3*3print(list5)#[123,456,123,456,123,456]

list3*=3print(list3)#[123,456,123,456,123,456]

print(123inlist3)#Trueprint(456notinlist3)#False

前三个方法（append、extension、insert)可以向列表中添加元素。
它们没有返回值，直接修改原始数对象。
添加两个列表需要创建一个新的列表对象，这会消耗额外的内存。
特别是当列表很大时，尽量不要使用“+”来添加列表。

其他列表方法

list.count(obj)统计元素在列表中出现的频率

list1=[123,456]*3print(list1)#[123,456,123,456,123,456]num=list1.count(123)print(num)#3

list.index(x[,start[,end]])从列表索引中查找给定值的第一个匹配元素位置

list1=[123,456]*5print(list1.index(123))#0print(list1.index(123,1))#2print(list1.index(123,3,7))#4

list.reverse()反转元素List

x=[123,456,789]x.reverse()print(x)#[789,456,123]

list.sort(key=None,reverse=False)对原始列表进行排序。

Key-主要用于谓词元素，只有一个参数，具体函数参数取自可迭代对象并指定可迭代对象中的某个元素用于排序。

reverse–排序规则，reverse=True降序，reverse=False升序（默认）。

该方法没有返回值，但对对象进行排序在列表中。

x=[123,456,789,213]x.sort()print(x)#[123,213,456,789]

x.sort(reverse=True)print(x)#[789,456,213,123]

#获取列表第二个元素deftakeSecond(elem):returnelem[1]

x=[(2,2),(3,4),(4,1),(1,3)]x.sort(key=takeSecond)print(x)#[(4,1),(2,2),(1,3),(3,4)]

x.sort(key=lambdaa:a[0])print(x)#[(1,3),(2,2),(3,4),(4,1)]元组

“元组”的定义语法为：(Element1,Element2,...,Elementn)

方括号将所有元素连接在一起

逗号将每个元素连接在一起，如下所示一旦它是独立的

创建并访问元组

Python元组与列表类似，只不过它们一旦创建就无法访问。
“它会被修改，类似于字符串。
”

对元组使用方括号，对列表使用方括号。

元组与列表类似，也是用整数进行索引和分段。

t1=(1,10.31,'python')t2=1,10.31,'python'print(t1,type(t1))#(1,10.31,'pythonn')

print(t2,type(t2))#(1,10.31,'python')

tuple1=(1,2,3,4,5,6,7,8)打印(元组1[1])#2print(元组1[5:])#(6,7,8)print(元组1[:5])#(1,2,3,4,5)tuple2=元组1[:]print(tuple2)#(1,2,3,4,5,6,7,8)

您可以使用括号来创建创建tuple()，你也可以什么也不做使用。
为了可读性，建议使用()。

如果元组只包含一个元素，则必须在元素后面添加逗号，否则括号将用作运算符。

x=(1)print(类型(x))#x=2,3,4,5print(类型(x))#x=[]print(类型(x))#x=()print(类型(x))#x=(1,)print(类型(x))#print(8*(8))#64print(8*(8,))#(8,8,8,8,8,8,8,8)

创建一个二维元组。

x=(1,10.31,'python'),('数据',11)print(x)#((1,10.31,'python'),('数据',11))

打印(x[0])#(1,10.31,'ppython')print(x[0][0],x[0][1],x[0][2])#110.31python

print(x[0][0:2])#(1,10.31)更新和删除一个元组week=('Monday','Tuesday','星期四','星期五')week=week[:2]+('星期三',)+week[2:]print(week)#('星期一','星期二','星期三','Thursday','Friday')

元组具有不可变的属性，所以你不能直接给元组的元素赋值，只要元组中的元素不可变即可是可变的我们可以直接改变它的元素。
请注意，这与分配其元素不同。

t1=(1,2,3,[4,5,6])print(t1)#(1,2,3,[4,5,6])

t1[3][0]=9print(t1)#(1,2,3,[9,5,6])元组相关运算符

等号运算符号：==

连接运算符+

重复运算符*

成员运算符in，而不是

“等号==”，返回仅当成员和成员职位相同时才正确。

元组的组合有两种方式：“加号+”和“乘号*”。
前者是从头到尾拼接的，后者是复制拼接的。

t1=(123,456)t2=(456,123)t3=(123,456)

print(t1==t2)#Falseprint(t1==t3)#正确

t4=t1+t2print(t4)#(123,456,456,123)

t5=t3*3print(t5)#(123,456,123,456,123,456)

t3*=3print(t3)#(123,456,123,456,123,456)

print(123int3)#Trueprint(456notint3)#False内置方法

都不是元组大小和内容都无法更改，因此只有两种方法：计数和索引。

t=(1,10.31,'python')print(t.count('python'))#1print(t.index(10.31))#1

count('python')在元组t中记录了该元素出现了多少次，明显是一次？

index(10.31)是元组中元素的索引t，显然是1

解压元组

解压元组维元组（左括号定义了多少个元素？变量）

t=(1,10.31,'python')(a,b,c)=tprint(a,b,c)#110.31python

解包二维元组(根据元组中的元组结构定义变量）

t=(1,10.31,('OK','python'))(a,b,(c,d))=tprint(a,b,c,d)#110.31OKpython

如果只需要部分元组元素使用这个通配符“*”，英文称为通配符，在计算机语言中代表一个或多个元素。
以下示例将多个元素抛出到其余变量。

t=1,2,3,4,5a,b,*休息,c=tprint(a,b,c)#125print(休息)#[3,4]

如果余数变量对您来说根本不重要，请使用通配符“*”加下划线“_”。

t=1,2,3,4,5a,b,*_=tprint(a,b)#12

元组元组是python中内置的一种数据结构

在Python中，元组是一种内置的数据结构，类似于列表，但不可变，这意味着一旦创建就无法更改。
元组在括号中定义，元素之间用逗号分隔。
元组通常用于需要保护数据免受意外更改的场景，例如将参数传递给函数时。
在Python中编写元组的正确格式是tuplename=(tupleitem1,tupleitem2,tupleitem3,tupleitem4)或tuplename=tupleitem1,tupleitem2,tupleitem3,tupleitem4。
请注意，定义元组时，使用逗号而不是括号。
例如，要创建一个包含动物的元组：Zoo=('wolf','elephant','penguin')，您可以使用len(zoo)来获取动物的数量。
元组可以与其他数据结构组合，例如new_zoo=('monkey','dolphin',zoo)，其中new_zoo[2]代表从旧动物园转移的动物，new_zoo[2][2]代表最后一个动物转移。
空元组由一对空括号表示，例如myempty=()，但单元素元组需要在元素后加逗号，例如mysingle=(1,)以避免与表达式不同。