随着数据越来越丰富，几十万、几百万甚至上亿的数据就会出现，而对这么大堆数据进行搜索、插入或者排序等的操作就越来越慢，数据结构就是用来解决这些问题的。

简单来说，数据结构是指特定关系的数据元素的集合。在Python语言，常用的数据结构有列表、元组、集合和字典4种数据结构类型。

6.1 列表

列表(list)是Python内置的，可以保存任何数据类型，最常用的基本数据结构。它是可改变的序列，它的元素可进行增删改。

除了内置的函数进行操作外，还可以通过索引(从0开始)的方式进行。列表是有序的，可对其元素进行排序、比较等操作。

1. 列表声明

列表可通过中括号[]或list()进行声明。里面没有元素时，为空列表。列表元素可以同时存在不同的数据类型。

# 用[]声明一个空列表
ls = []
print(type(ls), ls)
# 用list()声明一个空列表
ls = list()
print(type(ls), ls)
# 支持不同数据类型
lst = ["历史", 100, 25.68]
print(lst)
# list内容
ls = list(["test", 15.21, 520])
print(ls)

输出结果

<class 'list'> []
<class 'list'> []
['历史', 100, 25.68]
['test', 15.21, 520]

2. 新增对象

通过append(obj)方法添加新的对象，insert(index, obj) 方法在指定位置将对象插入列表。

ls = ["I", "love", "Python"]
# 在指定位置插入一个对象
ls.insert(3, "and Java")
# 添加一个对象
ls.append(".")
print(ls)

输出结果

['I', 'love', 'Python', 'and Java', '.']

通过extend(seq)方法在列表末尾一次性追加另一个序列中的多个值。通过+号可将两个列表进行拼接。

# 将ls2附加到ls1后面
ls1 = [1, 2, 3]
ls2 = [4, 5, 6]
ls1.extend(ls2)
print(ls1)

输出结果

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

通过+号可将两个列表进行拼接。

# 通过+号进行拼接
ls3 = [1, 3]
ls4 = [1, 4]
ls3 = ls3 + ls4
print(ls3)

输出结果

[1, 3, 1, 4]

3. 删除

通过pop(n) 删除指定下标对应的元素 。如指定的下标n不存在，会报下标越界错误。第1个元素下标为0，最后一个为-1。不指定下标值时，会默认删除最后一个元素。成功删除，会返回元素值。

# 删除第一个元素
ls = ["Android", "iOS", "Python", "C#"]
ls.pop(0)
print(ls)
# 删除最后一个元素
ls.pop()
print(ls)
v = ls.pop(-1)
print(v)

输出结果

['iOS', 'Python', 'C#']
['iOS', 'Python']
Python

remove(x) 删除x指定的一个元素，有多个相同的元素，删除第一个。如若指定的x值在列表里不存在，会报错。删除不会返回值。

# 删除指定内容
lang = ["Chinese", "English", "French", "German"]
lang.remove("German")
print(lang)

输出结果

['Chinese', 'English', 'French']

可通过del list[n] 删除指定下标对应的元素 , del list 删除整个列表， list删除后无法访问。另外可通过clear()清空内容。

# 删除指定元素
number = [5, 6, 7, 8]
del number[0]
print(number)
# 清空内容
number.clear()
print(number)
# 删除整个列表后，不可再访问
del number

输出结果

[6, 7, 8]
[]

4. 修改

可指定下标或区间范围，对元素进行修改。指定下标不存在时，会报越界错误。指定的区间范围长度超过的那个部分内容,会新增元素。

# 指定下标进行修改元素
number = [5, 6, 7, 8]
number[0] = 1
print(number)
# 指定区间，修改或新增元素
number[1:5] = [2, 3, 4, 5]
print(number)

输出结果

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

5. 访问

用下标或区间范围可进行元素访问。指定的下标不存在时，会报越界错误。第1个元素下标为0，最后1个为-1。通过区间范围可截取子列表。

# 用下标访问元素
colors = ["Red", "Yellow", "Blue", "Orange"]
print(colors[0])
print(colors[-1])
# 用区间访问元素
color = colors[1:3]
print(color)

输出结果

Red
Orange
['Yellow', 'Blue']

可用in或not in关键字判断元素是否存在。

# 用in判断是否存在
lang = ["Chinese", "English", "French", "German"]
if "Japanese" in lang:
    lang.remove("Japanese")
print(lang)

输出结果

['Chinese', 'English', 'French', 'German']

用index(obj) 从列表中找出某个值的第一个匹配项的索引位置，如果找不到，会报错。count(obj) 统计某个元素在列表中出现的次数。max(list) 返回列表元素最大值，min(list) 返回列表元素最小值。

# 查找指定元素的第一个下标
number = [5, 5, 6, 7, 8]
i = number.index(8)
print(i)
# 统计元素出现的次数
n = number.count(5)
print(n)
# 获取最大值
max_v = max(number)
print(max_v)
# 获取最小值
min_v = min(number)
print(min_v)

输出结果

4
2
8
5

6. 遍历

在遍历列表时，经常会用到列表长度，可用len(list) 计算列表元素个数(即列表长度)。如果只是遍历元素的内容，可直接用for循环，如果通过下标的方式访问元素，则可通过rang()函数，如果同时需要下标和元素值，可使用enumerate()函数。

# 直接遍历元素
number = [1, 3, 1, 4]
for n in number:
    print(n)

# 通过下标访问元素
length = len(number)
for i in range(length):
    print(number[i])

# 同时获取下标和元素
for i, n in enumerate(number):
    print(i, n)

输出结果

1
3
1
4
1
3
1
4
0 1
1 3
2 1
3 4

7. 排序

可用reverse() 方法，反向列表中的元素。可用sort() 对原列表进行升序(从小到大)排列，如要使用降序(从大到小)则使用sort(reverse=True)方法，还有用sorted()函数，可以获取排序后的列表内容。排序要求列表内容是针对同一类型的。

# 对列表进行倒序
number = [1, 5, 2, 3, 4]
number.reverse()
print(number)
# 列表升序
number.sort()
print(number)
# 列表降序
number.sort(reverse=True)
print(number)
# 列表升序排列后的结果
new = sorted(number)
print(new)
# 列表降序排列后的结果
new = sorted(number, reverse=True)
print(new)

输出结果

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

8. 转换

可通过list()方法将字符串、元组、集合转成列表。

# 字符串转为列表
s = "string"
ls1 = list(s)
print(ls1)
# 元组转为列表
t = ("a", "b", "c")
ls2 = list(t)
print(ls2)
# 集合转为列表
set1 = {1, 3, 4}
ls3 = list(set1)
print(ls3)

输出结果

['s', 't', 'r', 'i', 'n', 'g']
['a', 'b', 'c']
[1, 3, 4]

如果列表内容全是字符串，可直接通过join()方法将列表转成字符串。如果内容有其他数据类型，通过join(map(str, list))的方式转换。

# 列表(全字符串内容)转为字符串
ls = ["O", "K", "!"]
print("".join(ls))
# 有整型内容
ls = [10, "K"]
print("".join(map(str, ls)))

输出结果

OK!
10K

奥力给，列表到这就结束了，如果你觉得程序哪里不对，请一定要告诉我，反正我也不会改，你别憋出病来。有些没学会的朋友，可能会说："老陈，你教的都是没用的东西"。那我只能回答你：“我不允许你这么说你自己”。不信的话，你接着看有关元组的内容。

6.2 元组

元组与列表相似，不同之处在于它的元素是不可改变的，不可进行增删改的，也就是说元组一旦创建，便不可以编辑(增删改)其中的元素。虽然元素不允许删除，但可以使用del语句来删除整个元组。

1. 元组声明

元组可通过小括号()或tuple()进行声明。里面没有元素时，为空元组。元组元素可以同时存在不同的数据类型。用()声明元组时，如果只有一个元素，后面要加逗号, 否则会被当作运算符处理。

# 用()声明一个空元组
t = ()
print(type(t), t)
# 用tuple()声明一个空元组
t = tuple()
print(type(t), t)
# 支持不同数据类型
t = ("化学", 100, 25.68)
print(t)
# 只有一个元素,记得加,
t = ("中文",)
print(t)

输出结果

<class 'tuple'> ()
<class 'tuple'> ()
('化学', 100, 25.68)
('中文',)

2. 新增

元组中的元素值是不允许修改的，但我们可以通过+号对元组进行连接组合。

# 两个元组拼接
t1 = (1, 2, 3)
t2 = (4, 5, 6)
t1 += t2
print(t1)

输出结果

(1, 2, 3, 4, 5, 6)

3. 删除

不可以对元组中的元素值进行删除，但可替换整个元组内容，还可以用del tuple 删除整个元组，删除后不可再访问。

# 元组替换内容
n1 = (5, 6, 7, 8)
n2 = (1, 2, 3)
print(n1)
n1 = n2
print(n1)
# 删除整个元组后，不可再访问
del n1

输出结果

(5, 6, 7, 8)
(1, 2, 3)

4. 访问

用下标或区间范围可进行元素访问。指定的下标不存在时，会报越界错误。第1个元素下标为0，最后1个为-1。通过区间范围可截取子元组。

# 用下标访问元素
colors = ("Red", "Yellow", "Blue", "Orange")
print(colors[0])
print(colors[-1])
# 用区间访问元素
color = colors[1:3]
print(color)

输出结果

Red
Orange
('Yellow', 'Blue')

可用in关键字判断元素是否存在，可用not in判断元素是否不存在。

# 用in 用in判断是否存在
lang = ("Chinese", "English", "French", "German")
if "Japanese" in lang:
    print("存在")
else:
    print("不存在")

输出结果

不存在

用index(obj) 从元组中找出某个值的第一个匹配项的索引位置，如果找不到，会报错。count(obj) 统计某个元素在元组中出现的次数。max(tuple) 返回元组元素最大值，min(tuple) 返回元组元素最小值。

# 查找指定元素的第一个下标
number = (6, 6, 7, 8)
i = number.index(6)
print(i)
# 统计元素出现的次数
n = number.count(8)
print(n)
# 获取元素最大值
max_v = max(number)
print(max_v)
# 获取元素最小值
min_v = min(number)
print(min_v)

输出结果

0
1
8
6

5. 遍历

在遍历元组时，经常会用到元组长度，可用len(tuple) 计算元组元素个数(即元组长度)。如果只是遍历元素的内容，可直接用for循环，如果通过下标的方式访问元素，则可通过rang()函数，如果同时需要下标和元素值，可使用enumerate()函数。

# 直接遍历元素
number = (1, 3, 1, 4)
for n in number:
    print(n)

# 通过下标访问元素
length = len(number)
for i in range(length):
    print(number[i])

# 同时获取下标和元素
for i, n in enumerate(number):
    print(i, n)

输出结果

1
3
1
4
1
3
1
4
0 1
1 3
2 1
3 4

6. 排序

可用sorted()函数，对元组内容进行排序，可获取排序后的元组内容。排序要求元组内容是针对同一类型的。

# 元组升序排列
number = (1, 5, 2, 3, 4)
new = sorted(number)
print(new)
# 元组降序排列
new = sorted(number, reverse=True)
print(new)

输出结果

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

7. 转换

可通过tuple()方法将字符串、列表、集合转成元组。

# 字符串转为元组
s = "string"
t1 = tuple(s)
print(t1)
# 列表转为元组
lst = ["a", "b", "c"]
t2 = tuple(lst)
print(t2)
# 集合转为元组
set1 = {1, 3, 4}
t3 = tuple(set1)
print(t3)

输出结果

('s', 't', 'r', 'i', 'n', 'g')
('a', 'b', 'c')
(1, 3, 4)

如果元组内容全是字符串，可直接通过join()方法将元组转成字符串，如果内容有其他数据类型，通过join(map(str, tuple))的方式转换。

# 元组(全字符串内容)转为字符串
t = ("O", "K", "!")
print("".join(t))
# 数字内容
t = (10, 8.6)
print("".join(map(str, t)))

输出结果

OK!
108.6

奥力给，元组到这就说完了，喜欢的朋友，赶紧转发出去，不喜欢的朋友，立即分享出去。老陈就告诉你，没背景的我是什么背景。

一个当了10年技术总监的老家伙，分享多年的编程经验。想学编程的朋友，可关注今日头条：老陈说编程。我将分享Python，前端(小程序)和App方面的编程知识。关注我，没错的。

#Python##Python编程从入门到实践##程序员#