Python基础学习参考（六）：列表和元组

一．列表

列表是一个容器，里面可以放置一组数据，并且列表中的每个元素都具有位置索引。列表中的每个元素是可以改变的，对列表操作都会影响原来的列表。列表的定义通过”[ ]”来定义，元素之间用逗号隔开，举例如下：

a = [12,'hello',15.5,True]

上面就定义了一个列表，列表中的元素可以是任意数据类型，并不仅限于例子中的这些数据类型。

1.访问列表中的元素

最直接的方式就是通过位置索引来访问元素，列表的索引是从0开始的。比如想访问上面列表中的第一个元素，并打印出来：

print(a[1])

打印结果：“hello”，其中索引的值可以是负数，表示从后面开始计数，比如：

print(a[-1])

结果为：“True”表示获取到最后一个元素。注意：负数索引就不是从0开始啦，而是从-1开始表示最后一个。

如果想更改某个位置元素：

a = [12,'hello',15.5,True]
a[1] = 'world'
print(a)

打印结果：[12,'world', 15.5, True]，想更改某个位置的元素直接通过位置索引即可实现。

2.  列表的切片

Python中有一种操作方式叫切片，我认为其实就是语法糖，如何使用举例如下：

a = [12,'hello',15.5,True]
b = a[:]
print(b)

结果为：[12,'hello', 15.5, True]，打印结果和列表a是一样的，相当与将a拷贝了一份。再来看下面例子：

a = [12,'hello',15.5,True]
b = a[1:3]
print(b)

结果为：“['hello',15.5]”，切片后得到的是第一个位置索引和第二个位置索引上的元素。通过上面两个例子“：”前后表示要获取的元素的位置索引的开始和结束，但不包含结束索引对应的元素。如果不写，默认前面为第一个位置索引，后面为最后一个位置索引。除此以外还可以非常容易的获取从后面开始计算的元素列表，比如：

a = [12,'hello',15.5,True]
b = a[1:-1]
print(b)

结果：“['hello',15.5]”表示从列表中第一个开始到最后一个结束（但不包含最后一个）。再比如：

a = [12,'hello',15.5,True]
b = a[-3:3]
print(b)

结果：“['hello',15.5]”，使用起来非常灵活，但是无论是正还是负，一定要确保冒号前面的位置索引一定要小于冒号后面的位置索引。

3. in 和  not in

当我们想判断一个元素是否在列表中，就可以通过in或者not in关键字来判断

a = [12,'hello',15.5,True]
b = 'hello'
c = b in a
print(c)

打印结果为：“True”说明b元素在列表a中存在。

4. “+”和 extend

直接看例子：

a = [12,'hello',15.5,True]
b = ['world',22,False]
c = a + b
print(c)

打印结果：[12,'hello', 15.5, True, 'world', 22, False]，可以看出列表a和列表b合并为一个新的列表。接着看例子：

a = [12,'hello',15.5,True]
b = ['world',22,False]
a.extend(b)
print(a)

打印结果：[12,'hello', 15.5, True, 'world', 22, False]，可以看出extend的作用是将列表b添加到列表a中了，同样实现了列表合并的目的。

5.  “ * ”

a = ['哈']*4
print(a)

打印结果：['哈', '哈', '哈', '哈']，列表中都是重复元素可以通过“*”来实现。

6.列表常用方法

a.     count()

a = ['abc','hello','abc','world']
print(a.count('abc'))

打印结果：2，表示字符串‘abc’在列表中出现了2次。

b.     index()

a = ['abc','hello','abc','world']
print(a.index('abc'))

打印结果：0，表示字符串‘abc’在列表中第一次出现的位置在第0个位置索引上。

c.     append()

在列表末尾追加一个元素

a = ['hello']
a.append('world')
print(a)

打印结果：['hello','world']，在列表a末尾又添加了一个元素‘world’

d.     insert()

append()方法只能在末尾添加元素，如果想在任意位置添加元素，就需要用insert().

a = [12,'hello',15.5,True]
a.insert(2,'world')
print(a)

打印结果：[12,'hello', 'world', 15.5, True]，可以看到在列表a的索引是2也就是第三个位置上面添加了一个“world”

e.     pop()

pop()删除列表中的元素

a = [12,'hello',15.5,True]
a.pop()
print(a)

打印结果：[12, 'hello',15.5]，最后一个元素被删除了，其实还可以在pop中加上索引，指定要删除的元素：

a = [12,'hello',15.5,True]
a.pop(2)
print(a)

打印结果：[12,'hello', True]，列表a的索引是2，也就是第三个位置的元素被删除了。

f.      remove()

pop()是通过索引删除元素，当我们不知道索引，只知道要删除的某个元素的时候，可以通过remove方法

a = [12,'hello',15.5,'hello']
a.remove('hello')
print(a)

打印结果：[12, 15.5,'hello']，可以看到最前面“hello”被删除了。换句话说就是删除了第一个匹配到的元素。

g.     sort()

对列表中的元素进行排序：

a = ["abc",'hello','world','Tom','Lucy']
a.sort()
print(a)

打印结果：['Lucy','Tom', 'abc', 'hello', 'world']，对类别a的元素以ASCII表的顺序排序了，这个方法跟内置函数中的sorted方法是一样的，感兴趣的同学自己试一下。如果想排序好了以后在逆序一下：

a = ["abc",'hello','world','Tom','Lucy']
a.sort(reverse=True)
print(a)

结果：['world','hello', 'abc', 'Tom', 'Lucy']，加sort中加reverse为True就可以了，默认为False的。sort方法中可以在添加一个参数，自己定义排序的方式，等学过函数或者匿名函数以后再介绍。

h.     reverse()

将原列表逆序一下：

a = ["abc",'hello','world','Tom','Lucy']
a.reverse()
print(a)

打印结果：['Lucy', 'Tom','world', 'hello', 'abc']。这个方法其实跟内置函数中的reversed()方法是一样的，感兴趣的同学自己试一下。

二．for循环

前面简单介提到过for循环，这里再进一步了解一下。for循环用法如下：

a = ["abc",'hello','world','Tom','Lucy']
for i in a:
    print(i,end=" ")

打印结果：“abc helloworld Tom Lucy ”，遍历列表a中的所有元素，并把遍历的元素打印出来

其中的i就表示每次遍历的元素。用法很简单。再结合前面提到的内置函数enumerate()结合使用，看看效果：

a = ["abc",'hello','world','Tom','Lucy']
for x,i in enumerate(a):
    print("位置：%d 对应元素：%s"%(x,i))

最后结果：

通过for循环将列表中的位置索引和对应的元素都一一的遍历出来了。

三．元组

元组可以理解为特殊的列表，特殊在哪里呢？元组是不可变的。通过“（）”来定义一组数据：具体如下：

a = (12,"hello",12.5,False)
print(a)

打印结果：(12,'hello', 12.5, False)。上面我们定义了一个元组a，当我们初始化完成以后，元组a就再也不能被改变了。特殊说明一下空元组和1一个元素的元组：

a = () #创建一个空元组
b = (1,) #创建一个含有一个元素的元组

其中创建含有一个元素的元组的时候需要在后面加个逗号来避免歧义。

由于元组是不可变的，所以它不像列表那样有很多的操作和方法。

元组依然可以通过位置索引获得对应的元素，但是不能够进行修改了：

a = (12,"hello",12.5,False)
print(a[1])

打印结果：“hello”。跟列表的使用是一样的。大家可以自己试一下，更改某个元素的值。看看是否可变。

在元组中“+”运算依然可以使用，因为没有改变原来的元组，只是组成了一个新的元组：

a = (12,"hello",12.5,False)
b = ('world',22,False)
c = a + b
print(c)

打印结果：(12,'hello', 12.5, False, 'world', 22, False)

在元组中index()和count()方法依然可以使用，同样这两个方法并没有改变原来的元组，使用方法和列表是完全一样的，这里就不举例了，大家自己动手试一下。

除此以外，在内置函数里还有一个list()的内置方法，用来将元组变为列表的，举例如下：

a = (12,"hello",12.5,False)
b = list(a)
print(b)

打印结果：[12,'hello', 12.5, False]，可以看出list函数并没有改变原来的元组，而是根据元组a重新生成了一个新的列表。内置函数中还有一个tuple()函数，将列表转为元组，实际例子大家自己试一下吧。

大家思考一下，元组就是一个特殊的列表，跟列表一样可以封装各种数据类型，也就是说元组里面同样可以封装列表，例如：

a = [12,'hello',15.5,True]
b = ('world',22,False,a)

上面元组b中包含一个特殊元素就是列表a，大家都知道列表a是可以改变的，当a中元素改变了，元组b是不是也改变了，也就是说元组可变了，是不是跟上面描述的出现违背了？其实a中的元素发送变化了，在内存中a地址是不变的，也就说变量a所指向的地址是不变的，也就是说无论a怎么变化，b中的a所指向的地址是不变的，变的是地址中的内容而已。前面提到过，a只是一个变量名，变量名实际上都会指向内存的一个地址，这个地址存储着实际的内容。说白点，a就是一个地址，这个地址是不变的，a中元素发送改变，变的是地址中的内容，比如：地址就是你家的地址，你的家可以装修，砸墙，发送变化，但是地址还是那个地址。通过地址依然能找到你家。通过改变a表面上b发生了改变，其实b中的内容依然是没有改变的。这段内容有些深刻大家能理解多少就理解多少，随着以后学习的深入会慢慢的理解的。

四．拷贝问题

拷贝的问题跟上面的元组包含列表的原理都是一样的，如果上面内容没理解拷贝问题也很难理解，不过没关系，理解多少算多少。

在切片的时候可以通过[ : ]这样的方式拷贝一个列表，这个拷贝的方式是一个浅拷贝，什么意思呢？举个例子：

a = [12,'hello',15.5,True]
b = ('world',22,False,a)
c = b[:]
print('改变前：',c)
a[1] = 'nihao'
print('改变后',c)

运行结果：

大家看虽然c是我们重新拷贝的一份，但是当原来的b中发送改变的时候，c也会跟着变化，这样的拷贝我们称为浅拷贝，浅拷贝的本质就新建了一个对象，但是内部的引用也是简单的复制了一份。“引用“说白了就是上面提到的变量指向的地址，也就说地址还是那个地址，仅仅是拷贝一份而已。有浅拷贝就有深拷贝，这个时候需要引入一个copy的模块。举例如下：

import copy
a = [12,'hello',15.5,True]
b = ('world',22,False,a)
c = copy.deepcopy(b)
print('改变前：',c)
a[1] = 'nihao'
print('改变后',c)

运行结果：

大家发现，原始的b改变了，但是拷贝出来的c并没有改变。深拷贝不但新建了一个对象，连引用也都是全新的引用了。这部分内容对于没有基础的同学来说可能会难理解一些，但是慢慢学习深入以后再回头来看这部分内容，就没那么难理解了。切莫着急。

福利：回复python书，可获得目前python学习的一些认可度比较高的电子书

Tips：上面涉及到的代码。初学者一定要认认真真的自己敲一下，所有的运行的结果我也都在文章中给出来了，千万不要眼高手低。初学者大忌，很多时候自己实现的结果和想象的是不一样的。

特此说明：作者的内容均为原创，转载表明出处。由于本人的能力水平有限，如有发现错误和纰漏请联系作者，拜谢！

如果软件安装、使用python等内容，还有写不明白的同学，可以加入qq群：476581018交流。或者关注微信公众号（快扫下图(●’◡’●)）系列文章会在公众号最新发布，欢迎大家持续关注，获取最新更新内容，并且有更多福利等你哦！