7、数据结构

7、数据结构

文章目录

• 数据结构
• • 列表
  • • 1. 什么是列表
    • • 1.1 访问列表元素
    • 2. 修改、添加和删除元素
    • • 2.1 修改列表元素
      • 2.2 添加列表元素
      • 2.3 删除列表元素
    • 3. 组织列表
    • • 3.1 使用方法 `sort()` 对列表进行永久排序
      • 3.2 使用函数 `sorted()` 对列表进行临时排序
      • 3.3 反转列表
      • 3.4 确定列表长度
    • 4. 注意索引错误
    • 5. 操作列表
    • • 5.1 遍历整个列表
      • 5.2 避免缩进错误
    • 5.3 数值列表
    • • 5.3.1 使用函数 `range()`
      • 5.3.2 使用` range()` 创建数字列表
      • 5.3.3 对数字列表的统计计算函数
      • 5.3.4 列表解析
    • 5.4 使用列表的一部分
    • • 5.4.1 切片
      • 5.4.2 遍历切片
      • 5.4.3 复制列表
  • 元组
  • • 1. 定义元组
    • 2. 遍历元组
    • 3. 修改元组变量
  • 字典
  • • 1. 使用字典
    • • 1.1 定义字典
      • 1.2 访问字典中的值
      • 1.3添加键—值对
      • 1.4 先创建一个空字典
      • 1.5 修改字典中的值
      • 1.6 删除 键—值 对
      • 1.7 由类似对象组成的字典
    • 2. 遍历字典
    • • 2.1 遍历所有的键值对
      • 2.2 遍历字典中所有的键
      • 2.3 按顺序遍历字典中的所有键
      • 2.4 遍历字典中的所有值
    • 3. 嵌套
    • • 3.1 字典列表
      • 3.2 在字典中存储列表
      • 3.3 在字典中存储字典
  • 序列
  • 集合
  • 引用

数据结构

Python 中有四种内置的数据结构——列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。

列表

1. 什么是列表

列表是一种用于保存一系列有序项目的集合。

是一种可变的数据类型。

列表是使用对象和类的实例。

在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

输出结果：

['trek', 'cannondale', 'redline', 'specialized']

如果直接打印列表（列表名），Python将打印列表的内部表示，包括方括号。

1.1 访问列表元素

• 类似于数组元素的下标访问。

• 索引从0开始而不是1 。

  Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1 ，可让Python返回最后一个列表元素：

  print(bicycles[-1])  #返回最后一个元素
  

  经常需要在不知道列表长度的情况下访问最后的元素。这种约定也适用于其他负数索引，例如，索引-2 返回倒数第 二个列表元素，索引-3 返回倒数第三个列表元素，以此类推。

2. 修改、添加和删除元素

2.1 修改列表元素

修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，指定列表名和要修改的元素的索引，在指定元素的新值。

 motorcycles = ['honda', 'yamaha', 'suzuki']motorcycles[0] = 'ducati'

2.2 添加列表元素

python 提供了在多种既有列表中添加新数据的方式

1. 在列表末尾添加元素

   函数append()将新元素添加到列表末尾，而不影响列表中其他所有元素

   motorcycles = ['honda', 'yamaha', 'suzuki']
   motorcycles.append('ducati')
   

   这种方法可以动态地创建列表

   motorcycles = []				#创建空列表motorcycles.append('honda')
   motorcycles.append('yamaha')
   motorcycles.append('suzuki')
   

2. 在列表中插入元素

   函数insert() 可在列表的任何位置添加新元素。为此，需要指定新元素的索引和值。

   这种操作将列表中既有的每个元素都右移一个位置

   motorcycles = ['honda', 'yamaha', 'suzuki']
   motorcycles.insert(0, 'ducati')			#insert()函数两个参数
   

   结果

   ['ducati', 'honda', 'yamaha', 'suzuki']
   

2.3 删除列表元素

1. 使用 del 语句删除元素

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

   motorcycles = ['honda', 'yamaha', 'suzuki']
   del motorcycles[1]		#指定删除第二个元素
   

2. 使用 pop() 函数删除元素

   pop()可删除列表末尾的元素，并且返回该元素。此时列表就像一个栈，删除列表末尾元素相当于弹出栈顶元素。

   motorcycles = ['honda', 'yamaha', 'suzuki']
   last_owned = motorcycles.pop()
   

3. 弹出列表中任何位置处的元素

   实际上，你可以使用pop() 来删除列表中任何位置的元素。此时需要传递给 pop() 函数参数。

   motorcycles = ['honda', 'yamaha', 'suzuki']
   first_owned = motorcycles.pop(0)	#pop 函数指定了参数
   

如果你不确定该使用del语句还是pop()方法，下面是一个简单的判断标准：

如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；

如果你要在删除元素后同时还需要继续使用它，就使用方法pop()。

4. 根据值删除元素

   有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove()，该函数无返回值。

   motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']ve('ducati')
   

   注意 方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

3. 组织列表

3.1 使用方法 sort() 对列表进行永久排序

举例：

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
cars.sort()

永久性地修改了列表元素的排列顺序

还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True)

3.2 使用函数 sorted() 对列表进行临时排序

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted() 。函数sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。

举例：

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
print(sorted(cars))
print(cars)

sorted()函数返回一个新的排序列表。

如果你要按与字母顺序相反的顺序显示列表，也可向函数sorted()传递参数reverse=True

3.3 反转列表

要反转列表元素的排列顺序，可使用方法reverse()。

cars = ['bmw', 'audi', 'toyota', 'subaru']
verse()

3.4 确定列表长度

使用函数len() 可快速获悉列表的长度。

cars = ['bmw', 'audi', 'toyota', 'subaru']
len(cars)		

4. 注意索引错误

• 和 c/c++ 一样注意数组越界问题。

• 别忘了，每当需要访问最后一个列表元素时，都可使用索引-1 。这在任何情况下都行之有效，即便你最后一次访问列表后，其长度发生了变化。

  • 仅当列表为空时，这种访问最后一个元素的方式才会导致错误。

5. 操作列表

5.1 遍历整个列表

5.2 避免缩进错误

1. 忘记缩进
2. 不必要的缩进
3. 循环后不必要的缩进
4. 遗漏冒号

5.3 数值列表

5.3.1 使用函数 range()

for value in range(1,5): print(value)

上述代码好像应该打印数字1~5，但实际上它不会打印数字5

在这个示例中，range()只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。

函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）。

添加第三个参数可以确定步长

5.3.2 使用range() 创建数字列表

可使用函数list() 将range() 的结果直接转换为列表。

将range() 作为list() 的参数。

numbers = list(range(1,6))
print(numbers)

使用函数range() 几乎能够创建任何需要的数字集，例如创建一个平方值列表

 squares = []for value in range(1,11):squares.append(value**2)print(squares)

5.3.3 对数字列表的统计计算函数

有几个专门用于处理数字列表的Python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45

5.3.4 列表解析

前面介绍的生成列表squares 的方式包含三四行代码，而列表解析让你只需编写一行代码就能生成这样的列表。

列表解析：将for 循环和创建新元素的代码合并成一行，并自动附加新元素。

新列表名 = [表达式 for 更新表达式的for语句]
squares = [value**2 for value in range(1,11)]

首先指定一个描述性的列表名，如squares ；然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式 为value**2 ，它计算平方值。接下来，编写一个for 循环，用于给表达式提供值，再加上右方括号。

5.4 使用列表的一部分

5.4.1 切片

列表的部分元素——Python称之为切片

1. 创建切片

   指定要使用的第一个元素和最后一个元素的索引。

   与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。

   players = ['charles', 'martina', 'michael', 'florence', 'eli']
   print(players[0:3])
   

   结果：['charles', 'martina', 'michael']

   • 如果没有指定第一个索引，python将自动从列表头开始

     print(players[:4])
     

     结果：['charles', 'martina', 'michael', 'florence']

   • 要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2 ，并省略终止索引。

     print(players[2:])
     

     Python将返回从第3个元素到列表末尾的所有元素：['michael', 'florence', 'eli']

   • 负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。 例如，如果你要输出名单上的最后三名队员，可使用切片players[-3:]。 又如 players[:-1] 从开始到倒数第二个。

   • 你同样可以在切片操作中提供第三个参数，这一参数将被视为切片的==步长（Step）==（在默认 情况下，步长大小为 1）

     >>> shoplist = ['apple', 'mango', 'carrot', 'banana']
     >>> shoplist[::1]
     ['apple', 'mango', 'carrot', 'banana']
     >>> shoplist[::2]
     ['apple', 'carrot']
     >>> shoplist[::3]
     ['apple', 'banana']
     >>> shoplist[::-1]
     ['banana', 'carrot', 'mango', 'apple']
     

     当步长为 2 时，我们得到的是第 0、2、4…… 位项目。当步长为 3 时，我们得到 的是第 0、3……位项目。

5.4.2 遍历切片

举例：

players = ['charles', 'martina', 'michael', 'florence', 'eli']print("Here are the first three players on my team:")	#输出前三个
for player in players[:3]:		#在切片中遍历print(player.title())

应用举例：

• 编写游戏时，你可以在玩家退出游戏时将其最终得分加入到一个列表中。然后，为获取该玩家的三个最高得分，你可以将该列表按降序排列，再创建一个只包含前三个得分的切片。
• 处理数据时，可使用切片来进行批量处理；
• 编写Web应用程序时，可使用切片来分页显示信息，并在每页显示数量合适的信息。

5.4.3 复制列表

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:] ）。这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]

相当于深拷贝/浅拷贝：如果直接用赋值号 = 将就列表名赋值给新列表，这种语法实际上是让Python将新变量friend_foods 关联到包含 在my_foods 中的列表，因此这两个变量都指向同一个列表。

（相当于两个指针指向同一个变量，并不是复制（出一个新的），两个变量实际上同一个。）

元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组 。

1. 定义元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

dimensions = (200, 50) 
print(dimensions[0])
print(dimensions[1])

2. 遍历元组

像列表一样，也可以使用for 循环来遍历元组中的所有值：

dimensions = (200, 50)
for dimension in dimensions:print(dimension)

3. 修改元组变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值，即重新定义整个元组。

相比于列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。

字典

在Python中，字典 是一系列 键—值 对 。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。

事实上，可将任何Python对象用作字典中的值。

字典是属于 dict类下的实例或对象

1. 使用字典

1.1 定义字典

在Python中，字典用放在花括号{}中的一系列键—值对表示:

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)		#直接打印字典

• 键—值 对：是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用 逗号分隔。
• 字典中可包含任意数量的键—值对。
• 直接打印字典将会打印字典全部信息

1.2 访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键

alien_0 = {'color': 'green'}
print(alien_0['color'])

结果：green

1.3添加键—值对

字典是一种动态结构，可随时在其中添加键—值对。

要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)alien_0['x_position'] = 0	#添加新的键值对
alien_0['y_position'] = 25	#添加新的键值对
print(alien_0)

注意：键—值对的排列顺序与添加顺序不同。Python不关心键—值对 的添加顺序，而只关心键和值之间的关联关系。

1.4 先创建一个空字典

有时候，在空字典中添加键—值对是为了方便，而有时候必须这样做。为此，可先使用一对空的花括号定义一个字典，再分行添加各个键—值对。

alien_0 = {}alien_0['color'] = 'green'
alien_0['points'] = 5print(alien_0)

结果：{'color': 'green', 'points': 5}

使用字典来存储用户提供的数据或在编写能自动生成大量键—值对的代码时，通常都需要先定义一个空字典。

1.5 修改字典中的值

要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。

alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")alien_0['color'] = 'yellow'		#将与键 'color' 相关联的值改为'yellow'
print("The alien is now " + alien_0['color'] + ".")

1.6 删除 键—值 对

对于字典中不再需要的信息，可使用del 语句将相应的键—值对彻底删除。

使用del语句时，必须指定字典名和要删除的键。

alien_0 = {'color': 'green', 'points': 5}del alien_0['points']		#码从字典alien_0 中删除键'points' 及其值

1.7 由类似对象组成的字典

也可以使用字典来存储众多对象的同一种信息。

2. 遍历字典

鉴于字典可能包含大量的数据，Python支持对字典遍历。字典可用于以各种方式存储信息，因此有多种遍历字典的方式：可遍历字典的所有键—值对、键或值。

2.1 遍历所有的键值对

user_0 = {'username': 'efermi','first': 'enrico','last': 'fermi',}
for key, value in user_0.items():print("nKey: " + key)print("Value: " + value)

简化变量名的形式

for k, v in user_0.items()

• 方法items()，它返回一个键—值对列表。

注意，即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

2.2 遍历字典中所有的键

在不需要使用字典中的值时，方法keys() 很有用。

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}for name in favorite_languages.keys():print(name.title())

结果：

Jen
Sarah
Phil
Edward

遍历字典时，会默认遍历所有的键，

因此，如果将上述代码中的

for name in favorite_languages.keys(): 替换为for name in favorite_languages:，

输出将不变。

显示地使用 keys() 可以让代码更容易理解。

2.3 按顺序遍历字典中的所有键

要以特定的顺序返回元素，一种办法是在for 循环中对返回的键进行排序。为此，可使用函数sorted()来获得按特定顺序排列的键列表的副本

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}
for name in sorted(favorite_languages.keys()):print(name.title() + ", thank you for taking the poll.")

2.4 遍历字典中的所有值

如果你感兴趣的主要是字典包含的值，可使用方法 values() ，它返回一个值列表，而不包含任何键。

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}print("The following languages have been mentioned:")
for language in favorite_languages.values():print(language.title())

这种方法可能会包含重复项，为了剔除重复项，可使用集合 set。

Set 类似与列表，但是每个元素都是独一无二的。

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):print(language.title())

通过对包含重复元素的列表调用set() ，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

3. 嵌套

有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套 。

你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。

3.1 字典列表

下面代码创建了一个包含三个外星人的列表

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}aliens = [alien_0, alien_1, alien_2]	#字典列表

自动生成举例：

# 创建一个用于存储外星人的空列表
aliens = []
# 创建30个绿色的外星人
for alien_number in range(30):new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}aliens.append(new_alien)

3.2 在字典中存储列表

有时候，需要将列表存储在字典中，而不是将字典存储在列表中。

# 存储所点比萨的信息
pizza = {'crust': 'thick','toppings': ['mushrooms', 'extra cheese'],}for topping in pizza['toppings']:	#打印字典中的列表print("t" + topping)	

注意 列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决问题的方案。

3.3 在字典中存储字典

可在字典中嵌套字典，但这样做时，代码可能很快复杂起来。

users = {		#先定义了一个 users 的字典，包含两个键，与每个键相关的值都是字典'aeinstein': {'first': 'albert','last': 'einstein','location': 'princeton',},'mcurie': {'first': 'marie','last': 'curie','location': 'paris',},
}
for username, user_info in users.items():print("nUsername: " + username)full_name = user_info['first'] + " " + user_info['last']location = user_info['location']print("tFull name: " + full_name.title())print("tLocation: " + location.title())

序列

列表、元组和字符串可以看作序列（Sequence）的某种表现形式。

序列的主要功能是资格测试（Membership Test）（也就是 in与not in 表达式）和索引 操作（Indexing Operations），它们能够允许我们直接获取序列中的特定项目。

上面所提到的序列的三种形态——列表、元组与字符串，同样拥有一种切片（Slicing）运算 符，它能够允许我们序列中的某段切片——也就是序列之中的一部分。

这些操作前面已经提到过，略。

集合

集合（Set）是简单对象的无序集合（Collection）。

当集合中的项目存在与否比起次序或其出现次数更加重要时，我们就会使用集合。

>>> bri = set(['brazil', 'russia', 'india'])
>>> 'india' in bri
True
>>> 'usa' in bri
False
>>> bric = py()
>>> bric.add('china')
>>> bric.issuperset(bri)
True
>>> ve('russia')
>>> bri & bric # OR bri.intersection(bric)
{'brazil', 'india'}

引用

当你创建了一个对象并将其分配给某个变量时，变量只会查阅（Refer）某个对象，并且它也 不会代表对象本身。也就是说，变量名只是指向你计算机内存中存储了相应对象的那一部 分。这叫作将名称绑定（Binding）给那一个对象。

这里要注意的是深拷贝和浅拷贝的问题。