python用float显示list index out of range_Python 基础入门（四）从列表到元组 学习小结...

本系列第四章

一. 学习路线概述

学习地址：

Python入门（中） - AI开发者体验中心​developer.aliyun.com

总学习路线：

1. 列表
2. 元组
3. 字符串
4. 字典
5. 集合
6. 序列

本章学习1~2小节。

二. 具体学习内容

列表

前几章中也有浅略提到关于数据类型的问题。关于这个问题，这一章节会拓展数据的种类及其使用方法。

前几章提到的数据类型包括：

整型 <class ‘int’>
浮点型 <class ‘float’>
布尔型 <class ‘bool’>

本节主要内容--->容器数据类型

列表 <class ‘list’>
元组 <class ‘tuple’>
字典 <class ‘dict’>
集合 <class ‘set’>
字符串 <class ‘str’>

列表的定义

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

• 关键点是「中括号 []」和「逗号 ,」（在Python中，不同类型的“括号”有不同的作用，请不要将其他计算机语言中的“常识”引入Python，容易引起不必要的错误）
• 中括号 ---> 把所有元素绑在一起
• 逗号 ---> 将每个元素一一分开

Python中列表的功能极其强大，而且不限制列表内元素的数据类型（弱类型语言实锤）列表的强大使得在使用Python做文件处理时有着相当巨大的优势，这个有机会的话之后再叙。

列表的创建

# 例：如何创建一个列表

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))

# 运行结果：
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>

x = [2, 3, 4, 5, 6, 7]
print(x, type(x))

# 运行结果：
# [2, 3, 4, 5, 6, 7] <class 'list'>

上面的例子中，分别以字符串为单独元素和以整型数据为单一元素创立。当然这并不意味着Python中的列表就限制了列表只能有一种数据类型。

就比如这样：

x = [2, 3, 4, 5, 6, 7, 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))

# 运行结果：
# [2, 3, 4, 5, 6, 7, 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>

可以看到，依然是可以正常运行的。

同时，结合不同的函数、方法，也可以简略列表创建的过程：

# 利用 range() 创建列表（再提一嘴，range()函数是左闭右开的！）

x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>

x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>

与此类似的创建列表的方法还有很多，这里不再赘述。

注意：

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

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

（著名的“贴标签”理论：和C语言的“装盒子”有所不同，Python中的变量更趋近于“在XX（目标上）贴了给它命名的标签”。所以，在多个指针指向同一处时，一旦被指向的值改变，每个指针解引用的数据都会相应改变）

# 例子
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

可以创建空列表：

empty = []
print(empty, type(empty))  # [] <class 'list'>

列表与之后要讲的元组有一个很大的区别，就是列表是可以更改的（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.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

请注意，上面两者是有差别的，而且不仅仅在于一个是单而个是多个——事实上list.append(seq)后面也可以跟有多个参数。但是结果会有很大的不同：

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]

print(len(x))  

# 运行结果：
# 6

这个错误初学者很容易犯，勤加复习这一点即可。

严格来说 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

可以看到，'Sunday'被放到了索引值为2的位置，但是并没有将原本的元素覆盖，而是依次后延。（这样的特性笔者第一次看到时真的是觉得方便哭了）

删除列表中的元素

既然能添加列表元素，自然也能删除列表元素。对应的方法也有很多。

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']

方法返回值就是被删除的元素，这一点也十分的方便，数据不容易丢失，可以方便地另行处理。

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

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2] # 这里用的是切片操作，依然是左开右闭的原则
print(x)  # ['Wednesday', 'Thursday', 'Friday']

如果这里不进行切片操作的话，列表中全部元素都会被删除。

获取列表中的元素

• 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
• 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

（本小节主要讲序列的切片操作，方法是通用的）

切片的通用写法是 start : stop : step （左闭右开你懂得）

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

给了start的数值：

就会从相应的索引值元素一直读取到最后一个元素（start为正数的情况）如果为负数的话，原本最末尾的元素索引值变为-1并且依此向左类推，最后的读取依然是从相应的元素向右读取到末尾为止。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3])  # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3])  # ['Monday', 'Tuesday']

给了end值的情况：

从最前面的元素开始，直到读取到对应end值的索引元素为止（正数情况）。负数情况类似，也是从最左开始读取直到end值对应的数据，区别在于相应的索引值有所不同，具体看上一条。

step表示步长，和之前的range()里的用法基本一致，在此不再赘述。

不难看出，在合理运用参数的情况下，使用切片方法读取列表中元素还是很方便的。

# 关于浅拷贝与深拷贝

eek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

Python是不能像C-like语言中用list2 = list1的方法完成拷贝（之前也谈到了，这样的写法不过是加了一条“标签”，不能起到真实的拷贝的作用）

对比：

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]]

关于浅拷贝深拷贝问题，请初学者一定要注意，真的很容易忽视这个问题而又找不到bug浪费时间。（别问我是怎么知道的呜呜）

列表的常用操作符

• 等号操作符：==
• 连接操作符 +
• 重复操作符 *
• 成员关系操作符 in、not in

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

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

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

列表的其它常用方法

list.count(obj)统计某个元素在列表中出现的次数 list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置 list.reverse()反向列表中元素 list.sort(key=None, reverse=False)对原列表进行排序。

具体操作本文不再赘述，在具体需要时自行查阅即可。

元组

「元组」定义语法为：(元素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') <class 'tuple'>

print(t2, type(t2))
# (1, 10.31, 'python') <class 'tuple'>

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, 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)

更新和删除一个元素

我们上面在列表的讲解中谈到了，元组和列表的区别：列表是可改的（mutable），而元组是不可改的(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

而 + 和 * 分别为收尾拼接和复制拼接，这这些操作符在tuple（元组）中和在list（列表）中的意义是一致的。这里就不再举例赘述。

内置方法

由于元组的大小和内容都不可更改，因此只有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

解压元组

解压一维元组

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，在计算机语言中代表一个或多个元素。

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4] # 以列表形式存储在通配符中

如果这些元素是需要舍弃的数据，可以使用通配符「*」加上下划线「_」。

t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b)  

# 运行结果：
# 1 2