day04 列表和元组

今日内容概要

1. 列表
2. 元组
3. range

昨日内容回顾

1. 整型

   • Python 2中由int和long；Python 3中只有int
   • 进制转换

2. 字符串的索引

3. 切片和步长

   • 变量名[起始位置:终止位置:步长默认为1] 顾头不顾腚
   • 通过修改步长可以控制查找的步数和查找方向
   • 索引超出最大值时会报错
   • 切片超出最大值不会报错

4. 字符串方法

5. for循环

   • for：关键字

   • i：变量名

   • in：关键字

   • 可迭代对象

   • for循环打印九九乘法表：

     for i in range(1, 10):
         for j in range(1, 10):
             if i >= j:
                 print(f"{j} * {i} = {i * j}", end=' ')
         print('')
     

今日内容详细

列表

列表的定义

同整型、字符串和布尔值一样，列表也是Python中的数据结构之一。列表的关键字是list。在Python中，最常用的三种用来储存数据的数据结构分别是字典、列表和字符串，可见它是十分重要的。

列表的作用更像是一种容器，形象一点说就是我们用的书包：

1. 列表能储存大量数据
2. 列表能储存不同数据类型的数据

与列表相对照，我们先来观察一下这样一个字符串：a = '123alexTrue'这个字符串中包含数字、字母和布尔值，但是表现出来的全都是字符串。我们虽然能够通过索引取到内容，但取到的值仍然是字符串。这就需要我们进行额外的判断转换操作。列表则不同，列表可以储存不同类型的数据，并且可以随时把它们直接取出来用。就像把东西装到书包里，用的时候直接取出来即可。

我们可以通过如下方法定义一个列表：

lst = [1, 'alex', True]

列表中的每个元素以逗号分隔。各个元素以原本的数据类型存储在列表中。

列表元素的增加

列表元素的增加主要有三种方法：.append()、.insert()和.extend()。

.append()方法实在列表的末尾添加内容。.append()的参数就是需要增加的列表元素：

lst = ['Python学习手册', '核心编程']
print(lst.append("流畅的Python"))
print(lst)

输出的结果是：
None
['Python学习手册', '核心编程', '流畅的Python']

None在Python中是空的意思。.append()方法的返回值为None。而当我们打印列表lst时发现，列表已经被改变。这里我们可以得出结论：

• 列表是可变数据类型
• .append()操作会直接对列表进行修改而不需要重新赋值

.insert()方法用来向列表中插入数据。.insert()方法有两个参数，参数1是要插入位置的索引值，参数2是要插入的内容：

lst = ['Python学习手册', '核心编程']
lst.insert(1, '流畅的Python')
print(lst)

输出的结果是：['Python学习手册', '流畅的Python', '核心编程']

实际操作中，不推荐使用.insert()方法。因为一旦使用这个方法，需要把插入位置后的每一个元素都后移一位，且发生索引值的变化，有可能给项目带来不可预测的影响。

.extend()方法也是在列表的最后插入内容。.extend()方法的参数必须是可迭代对象。执行.extend()方法时，会将参数内容迭代追加到列表结尾：

lst = ['Python学习手册', '核心编程']
lst.extend('流畅的Python')
print(lst)

输出的结果为：['Python学习手册', '核心编程', '流', '畅', '的', 'P', 'y', 't', 'h', 'o', 'n']

.extend()方法用来将多个数据批量添加到列表末尾。

列表元素的删除

列表元素的删除主要有四种方法：.remove()、.pop()、.clear()和del。

.remove()方法可以删除指定元素名的列表元素，它的参数是要删除元素的元素名：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
lst.remove('新力')
print(lst)

输出的结果为：['大圣', '海芋', '一帆', '靓仔', '石淦']

.pop()方法如果不加参数的话，默认删除列表中的最后一个元素，并且有返回值，返回的内容是是被删除的元素。.pop()是唯一一个有返回值的列表元素删除方法：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
print(lst.pop())
print(lst)

输出的结果为：
石淦
['大圣', '海芋', '新力', '一帆', '靓仔']

.pop()方法也可以通过输入索引参数的方法，删除指定位置的列表元素：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
print(lst.pop(1))
print(lst)

输出的结果为：
海芋
['大圣', '新力', '一帆', '靓仔', '石淦']

.clear()方法用来将列表清空，最终会得到一个空列表：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
lst.clear()
print(lst)

输出的结果为：[]

del是用来删除的关键字。del后面直接跟列表名，会将列表整个删除掉：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
del lst
print(lst)

程序运行后报错：
Traceback (most recent call last):
  File "C:/Users/Sure/PyProject/day04/02 exercise.py", line 31, in <module>
    print(lst)
NameError: name 'lst' is not defined

程序报错，因为lst已经被从内从中整个移除。后来print调用lst时，找不到相应的内容，所以报错。

也可以用del删除指定索引的列表元素：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
del lst[2]
print(lst)

输出的结果为：['大圣', '海芋', '一帆', '靓仔', '石淦']

del也可以通过切片来批量删除多个列表元素：

lst = ['大圣', '海芋', '新力', '一帆', '靓仔', '石淦']
del lst[1:4]
print(lst)

输出结果为：['大圣', '靓仔', '石淦']

列表元素的修改

列表元素可以通过索引值赋值直接修改：

lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
lst[2] = '秀色可餐'
print(lst)

输出的结果为：['大圣', '海煜', '秀色可餐', '一帆', '靓仔', '石淦']

也可以通过列表的切片方法对列表元素进行批量修改：

lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
lst[1:4] = 10, 20, 30
print(lst)

输出的结果是：['大圣', 10, 20, 30, '靓仔', '石淦']

切片获取的内容空间是连续的时候，修改时内容可以多可以少；切片获取的内容空间是不连续的时候，修改时内容必须一一对应：

lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
lst[1:4] = 10, 20, 30, 40 #切片空间连续，可多
print(lst)
lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
lst[1:4] = 10, 20 #切片空间连续，可少
print(lst)
lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
lst[1:5:2] = ['alex', 'wusir'] # 切片空间不连续，必须一一对应
print(lst)

输出的结果为：
['大圣', 10, 20, 30, 40, '靓仔', '石淦']
['大圣', 10, 20, '靓仔', '石淦']
['大圣', 'alex', '新力', 'wusir', '靓仔', '石淦']

列表元素的查看

列表元素可以通过索引查询和for循环遍历两种方法查看：

lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
print(lst[3])
for i in lst:
    print(i)

需要注意的是，进行切片操作时，获取的内容时切片的原数据本身。也就是说，切片不会改变数据类型。字符串切片后得到的还是字符串，列表切片后得到的还是列表：

lst = ["大圣","海煜","新力","一帆","靓仔","石淦"]
print(lst[1:4])

a = 'alex'
print(a[1:3])

输出的结果为：
['海煜', '新力', '一帆']
le

列表总结

• 列表是可变数据类型，可迭代数据类型，有序的数据结构
• 列表用来储存大量数据，并且可以储存不同数据类型
• 列表就是一个容器
• 列表储存的是元素的内存地址

列表的嵌套

因为列表可以储存各种数据类型的数据，那么列表当然也可以储存列表，这就造成了列表的嵌套。

现在有这样一个相互嵌套的列表：

lst = [1,"alex",True,["wusir","污",["嫂子","衣服多"]], ["alex","吹nb","熬鸡汤",["嫂子","教育","从基层做起"]]]

如果我们想调用其中的"衣服多"这个字符串，该怎么做呢？

我们可以像下面这样逐层操作：

lst1 = lst[3]
lst2 = lst1[2]
lst3 = lst2[1]

这样，lst3就是我们想要的"衣服多"字符串。

但是这样的操作实在太过繁琐。我们发现，lst1 = lst[3]，既然如此，第二个式子我们可不可以把lst1[2]替换成lst[3][2]呢？那进一步说，我们可不可以直接通过lst[3][2][1]来调出"衣服多"字符串呢？

答案是完全可以的：

lst = [1,"alex",True,["wusir","污",["嫂子","衣服多"]], ["alex","吹nb","熬鸡汤",["嫂子","教育","从基层做起"]]]
print(lst[3][2][1])
print(lst[4][3][1])

打印出的结果是：
衣服多
教育

像这样调用嵌套在内层列表元素的方法也被称作降维，就是将类似于["wusir","污",["嫂子","衣服多"]的结构当作一个元素查看。

元组

元组也是Python中的数据类型之一。元组的关键字是tuple。

元组的定义方法和列表极其相似，只是将中括号变成了小括号。很多时候，小括号可以省略：

tu = (1, 2, 3, 'alex')
tu1 = 1, 2, 3, 'alex'

元组就是一个不可变的列表。因为不可变，元组没有增删改的方法，只能进行查看。

元组也可以通过索引方式进行查找，也同样支持切片操作：

tu = 1, 2, 3, 'alex'
print(tu[0])
print(tu[1:3])

输出的结果为：
1
(2, 3)

注意元组切片后得到的还是元组数据。

元组同样可以通过for循环的方法来查看：

tu = 1, 2, 3, 'alex'
for i in tu:
    print(i)

元组的.count()方法可以用来统计指定元素在元组中出现的次数；.index()方法可以通过元素的名称获取元素的索引：

tu = 1, 2, 3, 'alex'
print(tu.count(3))
print(tu.index(3))

输出的结果为：
1
2

需要注意的是，并不是出现小括号表示该数据的数据类型时元组。当小括号中没有出现逗号时，数据类型就是括号中数据类型本身：

a = (10)
print(type(a))
b = ('alex')
print(type(b))

输出的结果为：
<class 'int'>
<class 'str'>

当小括号中没有数据时，代表的是空元组：

c = ()
print(c)

输出的结果为：()

元组的应用场景有：

1. 为了防止误操作时修改数据，元组用来存放一些重要数据
2. 配置文件中用来存储数据

range

在Python中，通过range可以达到循环数字的效果：

for i in range(1, 5):
    print(i)
    
输出的结果为：
1
2
3
4

对于下面一行代码：

a = range(0, 5)
print(a)

在Python 2中，会打印出列表[0, 1, 2, 3, 4]；在Python 3中则会被打印为range(0, 5)。可以通过list()函数将range对象转化为列表：

a = range(0, 5)
print(list(a))

输出的结果为：[0, 1, 2, 3, 4]

range中的参数和切片极其相似：

for i in range(0, 51, 2):
    print(i)	# 打印0-50间的所有偶数
for i in range(1, 51, 2):
    print(i)	# 打印0-50间的所有奇数

range与切片所不同的是，range的终止位置为负数时，表示的是负数位置，而不是从右向左数的位置：

for i in range(10, -11, -1):
    print(i)	# 打印10到-10的数字

一般情况下，我们可以直接写入一个终止位置。这时，起始位置默认为0，步长默认为1：

print(list(range(5)))

输出结果为：[0, 1, 2, 3, 4]

需要注意，如果要设置步长，一定要把变量写全，要包含起始位置。

很显然，range是一个可迭代对象。