【Python学习笔记系列】[万字长文] 一文带你彻底搞懂列表和元组-CSDN博客

本文链接：https://blog.csdn.net/m0_70968573/article/details/131650816

写在前面

最近这段时间比较充裕，想要系统学习一下python，这个系列算是对自己学习的一个记录吧。同时也想提供一个比较完整详细的python教程供有需要的小伙伴进行学习，大家一起共同进步！！！努力冲冲冲！！！

虽然我也不知道自己能够坚持多久，但我尽量坚持不断更哈哈哈。如果这篇文章对你有帮助的话，请多多点赞支持呀。你们的鼓励支持就是我坚持的最大动力【比心】。

如果需要查看往期文章的话，可以点击下面的文章链接，全部都已经汇总好了

前言

本文为python学习笔记系列文章。

本文主要介绍了python中的序列，列表和元组，介绍了其基本概念和基本操作。

注：本文主要参考了C语言中文网中的python教程。

序列

序列介绍

Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。Python 中的序列类型包括字符串、列表（list）、元组（tuple）、字典（dict）和集合（set）。

列表（list）和元组（tuple）比较相似，它们都是按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。它们的区别在于：列表是可以修改的，而元组是不可修改的。

字典（dict）和集合（set）存储的数据都是无序的，每份元素占用不同的内存，其中字典元素以 key-value 的形式保存

序列索引

序列中，每个元素都有属于自己的编号（索引）。从起始元素开始，索引值从 0 开始递增，如下图所示：

与很多编程语言不同的是，Python 支持索引值为负数，此时索引是从右向左计数，也就是说从最后一个元素开始计数，该元素索引值为 -1 ，然后往左依次递减。如下图所示。

注意，在使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。

无论是采用正索引值，还是负索引值，都可以访问序列中的任何元素。

举例：

# 序列索引举例
str="人生苦短，我学python"
print(str[0],"==",str[-13])
print(str[5],"==",str[-8])

运行结果为：

人 == 人
我 == 我

序列切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。

切片操作语法格式如下：

sname[start : end : step]

说明：各个参数的含义分别是：

sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。

举例：

# 序列切片举例
str="人生苦短，我学python!"

# 取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:4])

# 隔 1 个字符取一个字符，区间是整个字符串
print(str[::4])

# 取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])

# 取索引区间为[-6,-1]之间（不包括索引2处的字符）的字符串
print(str[-7:-1])

运行结果为：

人生苦短
人，yn
人生苦短，我学python!
python

序列相加

Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

“类型相同”，指的是“+”运算符的两侧序列要么都是列表类型，要么都是元组类型，要么都是字符串。

举例：

# 序列相加举例
str1="人生苦短"
str2="我学python"
print(str1+str2)

输出结果为：

人生苦短我学python

序列相乘

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次。

举例：

# 序列相乘举例
str1="我爱python"
print(str1*4)

输出结果为：

我爱python我爱python我爱python我爱python

说明：列表类型在进行乘法运算时，还可以实现初始化指定长度列表的功能。例如如下的代码，将创建一个长度为 5 的列表，列表中的每个元素都是 None，表示什么都没有。

举例：

# 序列相乘--初始化指定列表长度举例
list = [None]*5
print(list)

输出结果为：

[None, None, None, None, None]

检查元素是否包含在序列中

Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

value in sequence

其中，value 表示要检查的元素，sequence 表示指定的序列。

举例：

# 检查元素是否包含在序列中举例
str="我爱学python"
print("我" in str)
print("人" in str)

运行结果为：

True
False

与in关键字相对应，有 not in 关键字，它用来检查某个元素是否不包含在指定的序列中。

举例：

# 检查元素是否不包含在序列中举例
str="我爱学python"
print("我" not in str)
print("人" not in str)

输出结果为：

False
True

和序列相关的内置函数

Python提供了几个内置函数（如下表所示），可用于实现与序列相关的一些常用操作。


函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素。
max()	找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。
min()	找出序列中的最小元素。
list()	将序列转换为列表。
str()	将序列转换为字符串。
sum()	计算元素和。
sorted()	对元素进行排序。
reversed()	反向序列中的元素。
enumerate()	将序列组合为一个索引序列，多用在 for 循环中。

举例：

# 与序列相关的内置函数举例
str="python"

# 找出最大的字符
print(max(str))

# 找出最小的字符
print(min(str))

# 对字符串中的元素进行排序
print(sorted(str))

输出结果为：

y
h
['h', 'n', 'o', 'p', 't', 'y']

reserved()函数；

是Python 内置函数之一，其功能是对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）。

语法格式如下：

reversed(seq)

其中，seq 可以是列表，元素，字符串以及 range() 生成的区间列表。

举例：

# reversed函数举例
#将列表进行逆序
print([x for x in reversed([1,2,3,4,5])])

#将元组进行逆序
print([x for x in reversed((1,2,3,4,5))])

#将字符串进行逆序
print([x for x in reversed("abcdefg")])

#将 range() 生成的区间列表进行逆序
print([x for x in reversed(range(10))])

运行结果为：

[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]
['g', 'f', 'e', 'd', 'c', 'b', 'a']
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

除了使用列表推导式的方式，还可以使用 list() 函数，将 reversed() 函数逆序返回的迭代器，直接转换成列表。

#将列表进行逆序
print(list(reversed([1,2,3,4,5])))

运行结果为：

[5, 4, 3, 2, 1]

使用 reversed() 函数进行逆序操作，并不会修改原来序列中元素的顺序，

举例：

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

#将列表进行逆序
print(list(reversed(a)))
print("a=",a)

程序执行结果为：

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

reversed（）举例：

>>> list1=['p','y','t','h','o','n']
>>> a=reversed(list1)
>>> print(a)
<list_reverseiterator object at 0x0000021626E4A4D0> #表明为迭代器对象
>>> list(a)
['n', 'o', 'h', 't', 'y', 'p']
>>> print(list(a))
[] #表明迭代器对象已失效
>>> b=reversed(list1)
>>> print(list(b))
['n', 'o', 'h', 't', 'y', 'p']

说明：reversed()函数返回的是一个迭代器，并不是一个列表，并且迭代器是一次性的，即用完就失效。

sorted()

内置函数之一，其功能是对序列（列表、元组、字典、集合、还包括字符串）进行排序。

语法格式如下：

list = sorted(iterable, key=None, reverse=False)

其中，iterable 表示指定的序列，key 参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted() 函数会返回一个排好序的列表。

key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。

举例：

# sort()函数举例
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))

#对元组进行排序
a = (5,4,3,1,2)
print(sorted(a))

#字典默认按照key进行排序
a = {4:1,\
5:2,\
3:3,\
2:6,\
1:8}
print(sorted(a.items()))

#对集合进行排序
a = {1,5,3,2,4}
print(sorted(a))

#对字符串进行排序
a = "51423"
print(sorted(a))

程序执行结果为：

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[(1, 8), (2, 6), (3, 3), (4, 1), (5, 2)]
[1, 2, 3, 4, 5]
['1', '2', '3', '4', '5']

使用 sorted() 函数对序列进行排序，并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。

举例：

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))

#再次输出原来的列表 a
print(a)

程序执行结果为：

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

除此之外，sorted(）函数默认对序列中元素进行升序排序，通过手动将其 reverse 参数值改为 True，可实现降序排序。

举例：

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a,reverse=True))

程序执行结果为：

[5, 4, 3, 2, 1]

另外在调用 sorted() 函数时，还可传入一个 key 参数，它可以接受一个函数，该函数的功能是指定 sorted() 函数按照什么标准进行排序。

举例：

chars=['http://c.biancheng.net',\
'http://c.biancheng.net/python/',\
'http://c.biancheng.net/shell/',\
'http://c.biancheng.net/java/',\
'http://c.biancheng.net/golang/']

#默认排序
print(sorted(chars))

#自定义按照字符串长度排序
print(sorted(chars,key=lambda x:len(x)))

程序执行结果为：

['http://c.biancheng.net',
'http://c.biancheng.net/golang/',
'http://c.biancheng.net/java/',
'http://c.biancheng.net/python/',
'http://c.biancheng.net/shell/']
['http://c.biancheng.net',
'http://c.biancheng.net/java/',
'http://c.biancheng.net/shell/',
'http://c.biancheng.net/python/',
'http://c.biancheng.net/golang/']

注意：这里涉及到了lambda表达式，可以暂时不用理会

列表list

许多编程语言中都有数组，它可以把多个数据挨个存储到一起，通过数组下标可以访问数组中的每个元素。python中没有数组，但是加入了更加强大的列表。

从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：

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

格式中，element1 ~ elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。

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

["http://www.baidu.com", 1, [2,3,4,5,6] , 2.0]

注意，在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

另外，经常用 list 代指列表，这是因为列表的数据类型就是 list，通过 type() 函数就可知。

举例：

# 列表类型举例
print(type(["http://www.baidu.com", 1, [2,3,4,5,6] , 2.0]))

运行结果为：

<class 'list'>

创建列表

在 Python 中，创建列表的方法可分为两种，下面分别进行介绍。

1) 使用 [ ] 直接创建列表

使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：

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

其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

下面定义的列表都是合法的：

# 创建列表举例
num = [1, 2, 3, 4, 5, 6, 7]
name = ["人生苦短", "我学python"]
program = ["C语言", "Python", "Java"]
list1=[] # 创建了一个空列表

2) 使用 list() 函数创建列表

list()函数，使用它可以将其它数据类型转换为列表类型。

举例：

# 创建列表举例
# 将字符串转换成列表
list1 = list("hello")
print(list1)

# 将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)

# 将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)

# 将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

# 创建空列表
print(list())

运行结果：

['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]

访问列表

使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

使用索引访问列表元素的格式为：

listname[i]

其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。

使用切片访问列表元素的格式为：

listname[start : end : step]

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

举例：

# 列表访问元素举例
url = list("人生苦短，我学python")

#使用索引访问列表中的某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引

#使用切片访问列表中的一组元素
print(url[9: 18]) #使用正数切片
print(url[9: 18: 3]) #指定步长
print(url[-6: -1]) #使用负数切片

运行结果：

短
t
['t', 'h', 'o', 'n']
['t', 'n']
['p', 'y', 't', 'h', 'o']

删除列表

对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。

实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。

del 关键字的语法格式为：

del listname

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

举例：

# 删除列表举例
t_list = [1, 45, 8, 34]
print(t_list)
del t_list
print(t_list)

运行结果：

[1, 45, 8, 34]

Traceback (most recent call last):
File "D:\pythonLearning\basic\列表.py", line 49, in <module>
print(t_list)
NameError: name 't_list' is not defined. Did you mean: 'list'?

添加列表元素

使用+运算符可以将多个序列连接起来。

举例：

# 向列表中添加元素举例
language = ["Python", "C++", "Java"]
birthday = [1991, 1998, 1995]
info = language + birthday

print("language =", language)
print("birthday =", birthday)
print("info =", info)

运行结果：

language = ['Python', 'C++', 'Java']
birthday = [1991, 1998, 1995]
info = ['Python', 'C++', 'Java', 1991, 1998, 1995]

从运行结果可以发现，使用+会生成一个新的列表，原有的列表不会被改变。

+更多的是用来拼接列表，而且执行效率并不高，

append()

append() 方法用于在列表的末尾追加元素。

语法格式如下：

listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

举例：

# 向列表中添加元素举例--append()
l = ['Python', 'C++', 'Java']

#追加元素
l.append('PHP')
print(l)

#追加元组，整个元组被当成一个元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)

#追加列表，整个列表也被当成一个元素
l.append(['Ruby', 'SQL'])
print(l)

运行结果为：

['Python', 'C++', 'Java', 'PHP']
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]

可以看到，当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。

extend()

extend() 用于在列表的末尾追加元素，但它不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

语法格式如下：

listname.extend(obj)

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。

举例：

# 向列表中添加元素举例--extend()
l = ['Python', 'C++', 'Java']
#追加元素
l.extend('C')
print(l)

#追加元组，元祖被拆分成多个元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)

#追加列表，列表也被拆分成多个元素
l.extend(['Ruby', 'SQL'])
print(l)

运行结果：

['Python', 'C++', 'Java', 'C']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']

insert()

append() 和 extend() 只能在列表末尾插入元素，insert()可以在列表中间某个位置插入元素

语法格式如下：

listname.insert(index , obj)

其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。

举例：

# 向列表中添加元素举例--insert()
l = ['Python', 'C++', 'Java']
#插入元素
l.insert(1, 'C')
print(l)

#插入元组，整个元祖被当成一个元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)


#插入列表，整个列表被当成一个元素
l.insert(3, ['Ruby', 'SQL'])
print(l)

#插入字符串，整个字符串被当成一个元素
l.insert(0, "http://www.baidu.com")
print(l)

输出结果为：

['Python', 'C', 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
['http://www.baidu.com', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']

提示，insert() 主要用来在列表的中间位置插入元素。

删除列表元素

在python列表中删除元素主要分为以下 3 种场景：

根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

del：根据索引值删除元素

del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

del 可以删除列表中的单个元素，格式为：

del listname[index]

其中，listname 表示列表名称，index 表示元素的索引值。

举例：

# 在列表中删除元素--del单个元素
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]

#使用正数索引
del lang[2]
print(lang)

#使用负数索引
del lang[-2]
print(lang)

运行结果：

['Python', 'C++', 'PHP', 'Ruby', 'MATLAB']
['Python', 'C++', 'PHP', 'MATLAB']

del 也可以删除中间一段连续的元素，格式为：

del listname[start : end]

其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。

举例：

# 在列表中删除元素--del连续多个元素
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]

del lang[1: 4]
print(lang)

lang.extend(["SQL", "C#", "Go"])
del lang[-5: -2]
print(lang)

运行结果：

['Python', 'Ruby', 'MATLAB']
['Python', 'C#', 'Go']

pop()

pop() 方法用来删除列表中指定索引处的元素。

具体格式如下：

listname.pop(index)

其中，listname 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似“出栈”操作。

举例：

# 在列表中删除元素--pop()
nums = [40, 36, 89, 2, 36, 100, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)

运行结果：

[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]

大部分编程语言都会提供和 pop() 相对应的方法，就是 push()，该方法用来将元素添加到列表的尾部，类似于数据结构中的“入栈”操作。但是 Python 是个例外，Python 并没有提供 push() 方法，因为完全可以使用 append() 来代替 push() 的功能。

remove()

remove() 方法会根据元素本身的值来进行删除操作。

需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

举例：

# 在列表中删除元素--remove()
nums = [40, 36, 89, 2, 36, 100, 7]
#第一次删除36
nums.remove(36)
print(nums)
#第二次删除36
nums.remove(36)
print(nums)
#删除78
nums.remove(78)
print(nums)

运行结果：

[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]

Traceback (most recent call last):
File "D:\pythonLearning\basic\列表.py", line 149, in <module>
nums.remove(78)
ValueError: list.remove(x): x not in list

最后一次删除，因为 78 不存在导致报错

clear()

clear() 用来删除列表的所有元素，也即清空列表。

举例：

# 在列表中删除元素--clear()
url = list("http://www.baidu.com")
url.clear()
print(url)

运行结果：

[]

修改列表元素

python提供了两种修改列表（list）元素的方法，可以每次修改单个元素，也可以每次修改一组元素（多个）。

修改单个元素

修改单个元素非常简单，直接对元素赋值即可。

举例：

# 修改列表元素--修改单个元素
nums = [40, 36, 89, 2, 36, 100, 7]
nums[2] = -26 #使用正数索引
nums[-3] = -66.2 #使用负数索引
print(nums)

运行结果：

[40, 36, -26, 2, -66.2, 100, 7]

使用索引得到列表元素后，通过=赋值就改变了元素的值。

修改一组元素

Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

举例：

# 修改列表元素--修改一组元素
nums = [40, 36, 89, 2, 36, 100, 7]

#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)

运行结果：

[40, 45.25, -77, -52.5, 36, 100, 7]

如果对空切片（slice）赋值，就相当于插入一组新的元素：

# 修改列表元素--修改一组元素（空切片）
nums = [40, 36, 89, 2, 36, 100, 7]
#在4个位置插入元素
nums[4: 4] = [-77, -52.5, 999]
print(nums)

运行结果：

[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]

使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：

nums[4: 4] = -77

但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，

s = list("Hello")
s[2:4] = "XYZ"
print(s)

运行结果：
['H', 'e', 'X', 'Y', 'Z', 'o']

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同。

举例：

# 修改列表元素--指定步长时
nums = [40, 36, 89, 2, 36, 100, 7]

#步长为2，为第1、3、5个元素赋值
nums[1: 6: 2] = [0.025, -99, 20.5]
print(nums)

运行结果：

[40, 0.025, 89, -99, 36, 20.5, 7]

查找列表元素

python列表（list）提供了 index() 和 count() 方法，它们都可以用来查找元素。

index()

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

语法格式为：

listname.index(obj, start, end)

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。
start 和 end 参数用来指定检索范围：

start 和 end 可以都不写，此时会检索整个列表；
如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

举例：

# 查找列表元素--index()
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]

#检索列表中的所有元素
print( nums.index(2) )

#检索3~7之间的元素
print( nums.index(100, 3, 7) )

#检索4之后的元素
print( nums.index(7, 4) )

#检索一个不存在的元素
print( nums.index(55) )

运行结果：

3
5
6
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in <module>
print( nums.index(55) )
ValueError: 55 is not in list

count()

count() 方法用来统计某个元素在列表中出现的次数

语法格式为：

listname.count(obj)

其中，listname 代表列表名，obj 表示要统计的元素。
如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

举例：

# 查找列表元素--count()
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36,36,45,36]
#统计元素出现的次数
print("36出现了%d次" % nums.count(36))
#判断一个元素是否存在
if nums.count(100):
    print("列表中存在100这个元素")
else:
    print("列表中不存在100这个元素")

运行结果：

36出现了5次
列表中存在100这个元素

元组tuple

元组（tuple）是python中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。通常情况下，元组用于保存无需修改的内容。

元组和列表（list）的不同之处在于：

列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

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

(element1, element2, ... , elementn)

其中 element1~elementn 表示元组中的各个元素，个数没有限制，只要是 Python 支持的数据类型就可以。

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

("c.biancheng.net", 1, [2,'a'], ("abc",3.0))

元组是 tuple 类型

# 元组类型
print(type( ("c.biancheng.net",1,[2,'a'],("abc",3.0)) ))

运行结果为：

<class 'tuple'>

创建元组

Python 提供了两种创建元组的方法，下面一一进行介绍。

1) 使用 ( ) 直接创建

通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：

tuplename = (element1, element2, ..., elementn)

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

下面的元组都是合法的：

# 合法的元组举例
num = (7, 14, 21, 28, 35)
course = ("人生苦短","我学python")
abc = ( "Python", 19, [1,2], ('c',2.0) )

在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组

# 合法元组举例--没有括号
course = "百度网址", "http://www.baidu.com"
print(course)

运行结果为：

('百度网址', 'http://www.baidu.com')

注意，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号，否则 Python 解释器会将它视为字符串。

举例：

# 合法元组举例--只有一个字符串
# 最后加上逗号
a =("http://www.baidu.com",)
print(type(a))
print(a)

#最后不加逗号
b = ("http://www.taobao.com")
print(type(b))
print(b)

运行结果为：

<class 'tuple'>
('http://www.baidu.com',)
<class 'str'>
http://www.taobao.com

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

内置函数 tuple()，用来将其它数据类型转换为元组类型。

语法格式如下：

tuple(data)

其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。

举例：

# 创建元组举例--tuple()
#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)

#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)

#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)

#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)

#创建空元组
print(tuple())

运行结果为：

('h', 'e', 'l', 'l', 'o')
('Python', 'Java', 'C++', 'JavaScript')
('a', 'b', 'c')
(1, 2, 3, 4, 5)
()

访问元组

使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。

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

tuplename[i]

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

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

tuplename[start : end : step]

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

举例：

# 访问元组元素举例
url = tuple("http://www.baidu.com")

#使用索引访问元组中的某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引


#使用切片访问元组中的一组元素
print(url[9: 18]) #使用正数切片
print(url[9: 18: 3]) #指定步长
print(url[-6: -1]) #使用负数切片

运行结果：

p
.
('w', '.', 'b', 'a', 'i', 'd', 'u', '.', 'c')
('w', 'a', 'u')
('d', 'u', '.', 'c', 'o')

修改元组

元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。

例如，对元组变量进行重新赋值：

# 修改元组举例
tup = (100, 0.5, -36, 73)
print(tup)

#对元组进行重新赋值
tup = ('Shell脚本',"http://c.biancheng.net/shell/")
print(tup)

运行结果为：

(100, 0.5, -36, 73)
('Shell脚本', 'http://c.biancheng.net/shell/')

另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素，例如：

# 修改元组举例--使用+拼接
tup1 = (100, 0.5, -36, 73)
tup2 = (3+12j, -54.6, 99)

print(tup1+tup2)
print(tup1)
print(tup2)

运行结果为：

(100, 0.5, -36, 73, (3+12j), -54.6, 99)
(100, 0.5, -36, 73)
((3+12j), -54.6, 99)

说明：生成的是一个新的元组。

删除元组

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

# 删除元组举例
tup = ('人生苦短',"我学python")
print(tup)

del tup
print(tup)

运行结果为：

('人生苦短', '我学python')
Traceback (most recent call last):
File "D:\pythonLearning\basic\元组.py", line 85, in <module>
print(tup)
NameError: name 'tup' is not defined. Did you mean: 'tup1'?