Python其实很简单 第九章 列表与元组（一）

在前面，我们要保存一个数据，需要先定义一个变量，而且一个变量中只能保存一个数据。譬如，语句：a1=1，值“1”就被保存了，但要保存“2”，就还需要再定义一个变量：a2=2......这样以来，随着数据的增多，岂不是要定义更多的变量吗？

创新互联建站于2013年创立，公司以成都网站制作、做网站、系统开发、网络推广、文化传媒、企业宣传、平面广告设计等为主要业务，适用行业近百种。服务企业客户上千，涉及国内多个省份客户。拥有多年网站建设开发经验。为企业提供专业的网站建设、创意设计、宣传推广等服务。 通过专业的设计、独特的风格，为不同客户提供各种风格的特色服务。

可以使用一个新的数据类型，它记录很多数据，并且将它们按照顺序存储在连续的内存空间中，这便是序列。Python中有5种常用的序列结构，分别是列表、元组、集合、字典和字符串。

9.1列表

语法格式：

listname=[element1,element2,element3,......,elementn]

其中，listname为列表名，element1,element2,element3,......,elementn表示列表中的元素。各个元素的数据类型可以相同，也可以不同，但通常元素的类型都是相同的，含义也是相同的。

如：

list1=[‘风’,’马‘,’牛’,1,2,3,’a’,’b’,’c’]就没有太多的实际用途。

list2=['张三','男',18,'13901001000']虽然元素的类型不同，但表示了同一个人的信息。

1、访问列表元素

列表中元素的索引号从0开始标记，访问列表元素时，可以直接按照索引号读取。

如：

list2=['张三','男',18,'13901001000']

print(list2[1]) #输出列表中索引号为1的元素

输出结果：男

和字符串一样，序列都是可以使用切片操作的。

如：

print(list2[:2])

输出结果：['张三', '男']

print(list2[2:])

输出结果：[18, '13901001000']

2、使用range()函数创建数值列表

格式：range(start, stop [,step]) ；start 指的是计数起始值，默认是 0；stop 指的是计数结束值，但不包括 stop ；step 是步长，默认为 1，不可以为 0 。range() 方法生成一段左闭右开的整数范围。

可以使用range()函数创建数值列表，如：

list1=list(range(10,20,2))

print(list1)

运行结果：[10, 12, 14, 16, 18]

3、删除列表

语法格式如下：

del listname

其中，listname为要删除列表的名称。

删除列表与删除变量的方法是完全一样的，前面已经介绍过了。

4、遍历列表

常用的遍历列表的方法有是利用for语句，举例如下：

list1=list(range(10))

for item in list1:

print(item,end=' ') # end=’ ‘表示以空格结束，如果不写这个参数，相当于默认值end=’ ’

输出结果：0 1 2 3 4 5 6 7 8 9

为了获取列表元素的索引值，就需要使用enumerate()函数。

list1=list(range(10,20,2))

for index,item in enumerate(list1):

print(index,'-',item,end=' ')

输出结果：0 - 10 1 - 12 2 - 14 3 - 16 4 - 18

5、追加、修改和删除列表元素

追加元素

list1=['春','夏','秋']

list1.append('冬')

list1

['春', '夏', '秋', '冬']

还有一种方法，就是使用“+”号将两个序列连接起来。如：

list1=['春','夏','秋']

list1=list1+['冬']

print(list1)

输出结果为：['春', '夏', '秋', '冬']

注意，下面的做法是错误的：

list1=['春','夏','秋']

list1=list1+'冬'

Traceback (most recent call last):

File " ", line 1, in

list1=list1+'冬'

TypeError: can only concatenate list (not "str") to list

从这个提示可知，列表只能与列表连接，而不能与字符串连接。

修改元素

list1[2]='autumn' #通过索引对元素直接赋值

print(list1)

['春', '夏', 'autumn', '冬']

删除元素

del list1[2] #通过索引直接删除元素

print(list1)

['春', '夏', '冬']

6、列表元素排序

在讨论列表元素排序时，为了将有序列表变成无序列表，这里用到了shuffle()函数，但它不是Python的内置函数，需要先使用import语句将random模块包含进来，这样才能像使用内置函数那样使用扩展模块中的函数。

import random #导入random模块

list1=list(range(10)) #生成列表，元素为0到9的整数。

list1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

random.shuffle(list1) #用random包中的shuffle()函数将list1中元素次序打乱

list1

[8, 6, 3, 5, 0, 7, 1, 9, 2, 4]

list1.sort() #对list1升序排列

list1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

random.shuffle(list1) #将list1顺序重新打乱

list1

[5, 9, 7, 8, 4, 3, 2, 0, 6, 1]

list1.sort(reverse=True) #对list1降序排列

list1

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

方法sort()的语法格式：

listname.sort(key=None,reverse=False)

其中，listname表示要排序的列表；key表示指定一个键，如”key=str.lower”表示排序时不区分字母大小写；reverse为True表示降序排列（为默认值，可省缺），为False表示升序排列。

还有一个函数sorted()，功能与方法sort()相似。格式如下：

sorted(listname,key=None,reverse=False)

7、 利用列表推导式快速生成一个列表

例1：生成指定范围的数值列表。

import random

list1=[random.randint(0,20) for i in range(10)]

list1

[16, 20, 19, 6, 5, 7, 10, 5, 12, 5] #生成了包含10个值在0到20之间的元素构成的列表。

例2：根据现有列表生成新的列表。

radius=list(range(1,6)) #生成列表 radius保存半径的值

radius

[1, 2, 3, 4, 5]

s=[round(2*3.14*r,2) for r in radius]

#生成列表s，将计算得到的周长值保存起来，其中round（）可以保留指定小数位，格式 round(var, n)，var为变量名，n为指定保留小数位。

s

[6.28, 12.56, 18.84, 25.12, 31.4]

例3：从列表中选择符合条件的元素组成新的列表。

score=[98,65,77,56,82,89] #列表score用来存储成绩

good=[x for x in score if x=80]

#从列表score中选取=80的元素存入新列表good中

good

[98, 82, 89]

count()、index()和sum()方法

count()方法

用于统计指定元素在列表中出现的次数。

例：

list1=['a','b','c','d','e','f','c','d','e','a','b','c','d']

num=list1.count('c') #统计列表list1中'c'的个数

num

3

index()方法

用于获取指定元素在列表中第一次出现的索引值。

list1=['a','b','c','d','e','f','c','d','e','a','b','c','d']

position=list1.index('c')

position

2

sum()方法

用于计算数值列表中全部或指定元素的和。

list1=[1,2,3,4,5]

total=sum(list1) #计算列表list1中全部元素的和

total

15

total=sum(list1,1) #在列表list1全部元素的和后，在加上参数（“1”）的值

total

16

total=sum(list1[:2]) #计算切片list1[:2]中各元素的和

total

3

二维列表

格式：listname[下标1][下标2]

其中，listname表示列表的名称，下标1表示列表中的行号，下标2表示列表中的列号。对于n行m列的二维列表，第一个元素的行号和列号都是0，最后一个元素的行号和列号都是n-1。如下所示：

list[0][0] list[0][1] list[0][2] ............ list[0][m-1]

list[1][0] list[1][1] list[1][2] ............ list[1][m-1]

......

......

list[n-1][0] list[n-1][1] list[n-1][2] ............ list[n-1][m-1]

通俗地讲，如果一个列表中的元素本身就是一个列表，则这个列表就是一个二维列表。

如：

list1=['a1','b1','c1','d1']

list2=['a2','b2','c2','d2']

list3=['a3','b3','c3','d3']

listtwo=[list1,list2,list3]

listtwo

[['a1', 'b1', 'c1', 'd1'], ['a2', 'b2', 'c2', 'd2'], ['a3', 'b3', 'c3', 'd3']]

如果要查看二维列表listtwo按照行、列的排列，可以运行如下代码：

for i in range(3):

for j in range(4):

print(listtwo[i][j],end=' ')

print()

运行结果：

a1 b1 c1 d1

a2 b2 c2 d2

a3 b3 c3 d3

如果要读取二维列表中的某一行，可以使用如下方法：

listtwo[2] #读取第3行的元素（注意索引号都是从0开始的）

['a3', 'b3', 'c3', 'd3']

如果要读取某一个元素的值，可以使用如下方法：

listtwo[2][2] #读取第3行第3列的元素

'c3'

Python元组常用操作小技巧

所以这篇文章，我们先来回顾和总结Python数据结构里常用操作。Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。而扁平序列如str、bytes、bytearray、memoryview 和 array.array等不在这篇文章的讨论范围内。

在此，我们先从元组开始说起。

元组区别于列表的显著特征之一就是它不能被修改，但其另外一个作用就是 用于没有字段名的记录 [1] 。因为后者经常被忽略，我们先来看看元组作为记录的作用。

使用括号就可以定义一个元组。元组中的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。正是这个位置信息给数据赋予了意义。下面的例子中，元组就被当作记录加以利用：

输出为：

上述for循环中的操作提取了元组中的元素，也叫作拆包（unpacking）。平行赋值是对元组拆包很好的应用，示例如下：

还有一个经典而优雅的应用是交换变量的值：

用 * 运算符把一个可迭代对象拆开作为函数的参数，例如Python的内置函数pmod接收两个数字类型的参数，返回商和余数。以下范例将使用 * 将元组传入函数。

输出为：

有些函数有多个返回值，将其赋给一个变量时，变量类型即是元组：

输出为：

zip是Python的内置函数，能够接收两个或多个序列，并组成一个元组列表，在Python3中会返回一个迭代器，如下所示：

输出为：

元组当然也支持一些常规操作，如对于元组 a = (1, 'y', 5, 5, 'x') ：

上述内容不仅涵盖了元组的基本操作，同时也结合了实际工作中常搭配使用的其他函数、运算符等。在回顾这些知识时主要参考了两本经典的Python编程书籍：《流畅的Python》和《像计算机科学家一样思考Python》，有兴趣的朋友可以深入阅读！

希望这篇文章对你有帮助，下回将总结Python列表的使用技巧。

[1]《流畅的Python》:

学习Python元组，有哪些必须要掌握的内容

学习Python元组，有哪些必须要掌握的内容？

1.Python元组

定义

元组是Python的一种内建数据结构。关于元组：

1、元组属于序列，可以存放任意元素（任意类型对象），且有序（前后位置关系）。

2、元组支持整数索引访问其中的数据，也支持切片。

3、元组和列表不同是，元组不可变，列表可变。

元组不可变，某些操作比列表高效。

创建元组

可以用以下两种方法创建元组：

1、使用()创建

2、使用构造函数tuple()

图：使用()创建元组

使用()可以创建元组，元组元素间使用”,”分隔，元组内部元素可以是任意元素，也可以是元组。

图：创建元组代码示例

元组不可变除了不能修改，也不能删除元组元素，但删除与元组绑定的变量是没问题的。

图：元组不可变

使用（）方式创建只有一个元素的元组时要注意，因为一个元素使用()括起来，表示元素本身，如100， （100），两者等价，如果创建只包含100的元组应该使用：(100,)方式。

图：使用（）创建只有一个元素的元组

使用构造函数tuple()创建元组。了解更多信息可以使用help(tuple)来查看具体帮助内容。

图：tuple函数帮助

1、tuple()如果没有参数创建一个空元组。

2、tuple(可迭代对象) 由可迭代对象创建一个元组，如字符串，列表。如果参数是元组将返回该元组。

图：使用tuple函数创建元组

2.元组的访问

和字符串列表一样，元组支持使用整数索引（下标方式访问），也支持切片方式访问元组的元素。

下标索引如果是正整数则从0开始表示第一个元素，…… 最有一个元素用 元组长度-1表示；如果使用负整数做下标，-1表示最后一个元素，-2表示倒数第二个元素，…… 负的长度表示第一个元素。

！！！需要注意的是下标索引不能越界！！！

1、使用索引访问：

图：使用索引访问元组元素

2、切片访问：

图：使用切片访问元组

3.使用内建的常用函数操作元组

常用内建函数len、max、min、sum、reversed可以操作元组，函数解释如下：

操作示例如下:

注意事项：

使用min，max，sum函数操作元组，元组元素类型能被函数接受才可以，否则将报异常等错误。

4.元组常用方法

主要有count和index方法：

count返回元组中对应值的个数，index返回对应值的位置（索引）。

5.元组运算

元组支持 + 连接， * 复制运算，in /not in 运算

图：元组运算

6.序列

字符串，元组，列表都属于Python的序列结构，序列具有很多相同的属性和操作方法，如：序列中的每个元素被分配一个序号（位置，也叫索引），序号（索引）从0开始，依次类推；序列都支持切片操作等等。

图：序列通用操作

Python内置了多种序列结构:字符串、列表、元组、Unicode字符串、buffer对象、range对象。序列是Python中一种重要的数据结构，必须要掌握，也很容易掌握。

Python中的元组如何应用？

元组是不可变的，即元组的项不能被修改。元组用圆括号“()”括起来，并用逗号“,”来分隔其中的项。

例如，下面的元组包含了三个不同数据类型的项：

与列表不同的是，元组一旦创建就不可修改，如果尝试修改，Python解释器会报错：

元组是一种序列类型，因此，上一节介绍的通用序列操作元组也都支持，此处不再赘述。下面要介绍的是元组的另外一些用法或特性。

1、 创建元组

在创建元组时，可以不用加圆括号(除非它是其他数据类型的一部分，如一个在列表中的元组，此时必须加圆括号)：

可以使用元组的工厂函数tuple()创建元组。如果要创建一个空的元组，可以使用不包含任何项的圆括号或者是没有参数的tuple()函数：

tuple()函数也可以有参数，且参数必须为可迭代对象：

创建只有一个项的元组时有个“小陷阱”，即用圆括号创建元组时，如果括号中只有一个项，而没有逗号，那么创建的并不是元组，而是这个项本身的类型：

创建只有一个项的元组，应该在该项的后面紧跟着一个逗号(或者使用tuple()函数)：

2、 嵌套元组

元组与列表一样，可以嵌套，同样元组中也可以包含列表：

关于Python的基础问题可以看下这个网页的视频教程，网页链接，希望我的回答能帮到你。

python里面元组是什么意思？

↑↑↑点击上方蓝字，回复资料，10个G的惊喜

作者：陈tooyoung@阿里云Python训练营 博客地址：

Python 是一种通用编程语言，其在科学计算和机器学习领域具有广泛的应用。如果我们打算利用 Python 来执行机器学习，那么对 Python 有一些基本的了解就是至关重要的。本 Python 入门系列体验就是为这样的初学者精心准备的。

列表的定义

列表的创建

向列表中添加元素

删除列表中的元素

获取列表中的元素

列表的常用操作符

列表的其他方法

元组

创建和访问一个元组

更新和删除一个元组

元组相关的操作符

内置方法

解压元组

列表

简单数据类型

整型

浮点型

布尔型

容器数据类型

列表

元组

字典

集合

字符串

列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为[元素1, 元素2, ..., 元素n]。

关键点是「中括号 []」和「逗号 ,」

中括号 把所有元素绑在一起

逗号 将每个元素一一分开

列表的创建 创建一个普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(x, type(x))

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

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(range(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] * 5

print(x, type(x))

# [0, 0, 0, 0, 0]

x = [0 for i in range(5)]

print(x, type(x))

# [0, 0, 0, 0, 0]

x = [i for i in range(10)]

print(x, type(x))

# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x = [i for i in range(1, 10, 2)]

print(x, type(x))

# [1, 3, 5, 7, 9]

x = [i for i in range(10, 1, -2)]

print(x, type(x))

# [10, 8, 6, 4, 2]

x = [i ** 2 for i in range(1, 10)]

print(x, type(x))

# [1, 4, 9, 16, 25, 36, 49, 64, 81]

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]

print(x, type(x))

# [3, 9, 15, 21, 27, 33, 39,

注意：

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

x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

x = [[0] * 3] * 4

print(x, type(x))

# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

x[0][0] = 1

print(x, type(x))

# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]

a = [0] * 3

x = [a] * 4

print(x, type(x))

# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

x[0][0] = 1

print(x, type(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)) # []

列表不像元组，列表内容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、删除 (remove,pop) 这些操作都可以用在它身上。

向列表中添加元素

list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.append('Thursday')

print(x)

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']

print(len(x)) # 6

此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.append(['Thursday', 'Sunday'])

print(x)

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]

print(len(x)) # 6

list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.extend(['Thursday', 'Sunday'])

print(x)

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

print(len(x)) # 7

严格来说append是追加，把一个东西整体添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。

list.insert(index, obj)在编号index位置插入obj。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.insert(2, 'Sunday')

print(x)

# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']

print(len(x)) # 6

删除列表中的元素

list.remove(obj)移除列表中某个值的第一个匹配项

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.remove('Monday')

print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']

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

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

y = x.pop()

print(y) # Friday

y = x.pop(0)

print(y) # Monday

y = x.pop(-2)

print(y) # Wednesday

print(x) # ['Tuesday', 'Thursday']

remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

del var1[, var2 ……]删除单个或多个对象。

如果知道要删除的元素在列表中的位置，可使用del语句。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

del x[0:2]

print(x) # ['Wednesday', 'Thursday', 'Friday']

获取列表中的元素

通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。

通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]

print(x[0], type(x[0])) # Monday

print(x[-1], type(x[-1])) # ['Thursday', 'Friday']

print(x[-2], type(x[-2])) # Wednesday

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

"start :"

以step为 1 (默认) 从编号start往列表尾部切片。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(x[3:]) # ['Thursday', 'Friday']

print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']

": stop"

以step为 1 (默认) 从列表头部往编号stop切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']

print(week[:-3]) # ['Monday', 'Tuesday']

"start : stop"

以step为 1 (默认) 从编号start往编号stop切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[1:3]) # ['Tuesday', 'Wednesday']

print(week[-3:-1]) # ['Wednesday', 'Thursday']

- "start : stop : step"

以具体的step从编号start往编号stop切片。注意最后把step设为 -1，相当于将列表反向排列。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[1:4:2]) # ['Tuesday', 'Thursday']

print(week[:4:2]) # ['Monday', 'Wednesday']

print(week[1::2]) # ['Tuesday', 'Thursday']

print(week[::-1])

# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

" : "

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

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

print(week[:])

# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

浅拷贝与深拷贝list1 = [123, 456, 789, 213]

list2 = list1

list3 = 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 = list1

list3 = list1[:]

print(list2) # [[123, 456], [789, 213]]

print(list3) # [[123, 456], [789, 213]]

list1[0][0] = 111

print(list2) # [[111, 456], [789, 213]]

print(list3) # [[111, 456], [789, 213]]

列表的常用操作符

等号操作符：==

连接操作符+

重复操作符*

成员关系操作符in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

list1 = [123, 456]

list2 = [456, 123]

list3 = [123, 456]

print(list1 == list2) # False

print(list1 == list3) # True

list4 = list1 + list2 # extend()

print(list4) # [123, 456, 456, 123]

list5 = list3 * 3

print(list5) # [123, 456, 123, 456, 123, 456]

list3 *= 3

print(list3) # [123, 456, 123, 456, 123, 456]

print(123 in list3) # True

print(456 not in list3) # False

前面三种方法（append,extend,insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

列表的其它方法

list.count(obj)统计某个元素在列表中出现的次数

list1 = [123, 456] * 3

print(list1) # [123, 456, 123, 456, 123, 456]

num = list1.count(123)

print(num) # 3

list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置

list1 = [123, 456] * 5

print(list1.index(123)) # 0

print(list1.index(123, 1)) # 2

print(list1.index(123, 3, 7)) # 4

list.reverse()反向列表中元素

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]

# 获取列表的第二个元素

def takeSecond(elem):

return elem[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=lambda a: a[0])

print(x)

# [(1, 3), (2, 2), (3, 4), (4, 1)]

元组

「元组」定义语法为：(元素1, 元素2, ..., 元素n)

小括号把所有元素绑在一起

逗号将每个元素一一分开

创建和访问一个元组

Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。

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

元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。

t1 = (1, 10.31, 'python')

t2 = 1, 10.31, 'python'

print(t1, type(t1))

# (1, 10.31, 'python')

print(t2, type(t2))

# (1, 10.31, 'python')

tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)

print(tuple1[1]) # 2

print(tuple1[5:]) # (6, 7, 8)

print(tuple1[:5]) # (1, 2, 3, 4, 5)

tuple2 = tuple1[:]

print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)

创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

x = (1)

print(type(x)) #

x = 2, 3, 4, 5

print(type(x)) #

x = []

print(type(x)) #

x = ()

print(type(x)) #

x = (1,)

print(type(x)) #

print(8 * (8)) # 64

print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)

创建二维元组。

x = (1, 10.31, 'python'), ('data', 11)

print(x)

# ((1, 10.31, 'python'), ('data', 11))

print(x[0])

# (1, 10.31, 'python')

print(x[0][0], x[0][1], x[0][2])

# 1 10.31 python

print(x[0][0:2])

# (1, 10.31)

更新和删除一个元组week = ('Monday', 'Tuesday', 'Thursday', 'Friday')

week = week[:2] + ('Wednesday',) + week[2:]

print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

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

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

t1[3][0] = 9

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

元组相关的操作符

等号操作符：==

连接操作符+

重复操作符*

成员关系操作符in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

t1 = (123, 456)

t2 = (456, 123)

t3 = (123, 456)

print(t1 == t2) # False

print(t1 == t3) # True

t4 = t1 + t2

print(t4) # (123, 456, 456, 123)

t5 = t3 * 3

print(t5) # (123, 456, 123, 456, 123, 456)

t3 *= 3

print(t3) # (123, 456, 123, 456, 123, 456)

print(123 in t3) # True

print(456 not in t3) # False

内置方法

元组大小和内容都不可更改，因此只有count和index两种方法。

t = (1, 10.31, 'python')

print(t.count('python')) # 1

print(t.index(10.31)) # 1

count('python')是记录在元组t中该元素出现几次，显然是 1 次

index(10.31)是找到该元素在元组t的索引，显然是 1

解压元组

解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t = (1, 10.31, 'python')

(a, b, c) = t

print(a, b, c)

# 1 10.31 python

解压二维元组（按照元组里的元组结构来定义变量）

t = (1, 10.31, ('OK', 'python'))

(a, b, (c, d)) = t

print(a, b, c, d)

# 1 10.31 OK python

如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest变量。

t = 1, 2, 3, 4, 5

a, b, *rest, c = t

print(a, b, c) # 1 2 5

print(rest) # [3, 4]

如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。

t = 1, 2, 3, 4, 5

a, b, *_ = t

print(a, b) # 1 2

python自学笔记13:元组和字典的操作

定义元组(tuple):

t1=(1,2,3,4)#多个数据元组

t2=(1,)#如果元组内只有一个数据，也需要手逗号隔开，否则这个数据将是他本身的类型。

元组的操作:

元组类型数据不支持修改，可查找

查找:

按下标查找:

print(t1[1])

函数查找:

print(t1.index(1))返回对应下标,如果数据不存在，程序将报错

print(t1.count(1))统计数据在元组当中出现的次数

print(len(t1))统计元组当中的数据个数

注意:当元组内嵌套列表数据，可以通过下标的方法对列表数据进行修改如:

t3=(1,2,["a","b"])

t3[2][0]=c #t3的值将变为(1,2,["c","b"])

——————————————————

——————————————————

定义字典(dict)

字典的特点

1:符号为{}

2:数据为键(key)值(value)对形式,每个键值对之间用逗号隔开如:

dict1={"name":"小明","age":18,"gender:男"}

字典的操作:

dict1["name"]="小红"

dict1["id"]=3

如果key存在，将修改其所对应的值。如果不存在，将在字典最后添加该键值对

2.删除数据

del():删除字典或删除字典内的键值对

del dict1["name"] 删除字典内的键值对，如果删除的key不存在，程序将会报错

del(del)删除字典

clear(dict1) 清空字典

3.查找数据

一.按照key进行查找，最后返回相对应的值

二.按函数进行查找:

(1) get(key,默认值):

如果查找的key不存在则返回所写的默认值，如果不写默认值则返回None

dict1={"name":"小明","age":18,"gender:男"}

print(dict1.get("name")) #小明

print(dict1.get("id",110)) # 110

——————————————————

(2) keys():返回字典内的所有key 可用for遍历

print(dict1.keys())

返回 ["name","age","gender"]

for key in dict1.keys():

..print(key)

逐行输出name age gender

——————————————————

(3) values(): 返回字典内的值 可用for遍历

print(dict1.values())

返回["小明",18,"男"]

for value dict1.values():

..print(value)

逐行输出小明 18 男

——————————————————

(4) items():将字典内的数据以元组的形式返回

print(dict1.items()) 可用for遍历

返回[("name","小明"),("age",18),("gender","男")]

for item in dict1.items():

..print(item)

逐行输出 ("name","小明") ("age",18)("gender","男")

——————————————————

遍历字典键值对(拆包) 可在for内使用两个临时变量

dict1={"name":"小明","age":18,"gender:男"}

for key,value in dict1.items():

..print(f"{key}=value")

逐行输出:

name=小明 age=18 gender=男

本文题目：python元组操作函数,python元组常用方法
文章路径：http://myzitong.com/article/hsdodh.html