你需要知道的 Python 基础知识：数据结构

数据结构是一种存储、组织和处理数据的格式，它允许您有效地对其执行操作

Photo by 保罗花冈 on 不飞溅

例如，存储人们的电子邮件地址，全天每小时记录温度等。这些结构中的数据可以称为元素。

有许多数据结构，几乎所有的数据结构都可以用任何编程语言实现——它们要么内置在语言中，要么可以创建或导入。

在本文中，我们将使用 Python 探索数据结构。

因此，有 4 种数据结构直接内置于 python 中—— 列表、字典、集合和元组—— 我们将在本文中讨论。在我们进入这些结构之前，需要快速理解的一件事是 可变性——改变的能力。 一些数据结构是可变的，即可以修改结构——可以在数据结构创建后添加、删除和更新元素。其他数据结构是不可变的，即在创建后不能对其进行修改。

列表

列表将数据存储为方括号内的逗号分隔元素。它是一种有序的、顺序的、异构的、索引的、可变的、非唯一的数据结构。

 奇数 = [1, 3, 5, 7, 9]

订购： 列表会在您插入元素时保持它们的顺序。

顺序： 可以迭代列表。

异质： 存储在列表中的元素可以是不同的数据类型，因此您可以拥有一个包含整数、字符串和浮点数的列表。由于此功能，数据不太紧密地打包在一起（内存方面），因此列表占用更多空间。

索引： 列表中的每个元素都有一个与之关联的索引，这基本上就像一个地址。索引用于访问元素。

正索引 列表中的第一个元素从 0 开始，最后一个元素继续到 n-1，其中 n 是元素的数量。这称为前向遍历。

负索引 列表中的最后一个元素从 -1 开始，第一个元素继续 -n，其中 n 是元素的数量。这称为反向遍历。

By Author.

可变： 列表在 python 的幕后实现为动态数组，因此它们是可变的。您可以添加、删除和修改列表中的元素，python 将相应地自动释放或分配内存。某些操作（例如在列表开头添加或删除元素）是昂贵的，因为列表中每个其他元素的索引都需要更改。

非唯一： 同一个元素可以在一个列表中存储两次，即列表可以包含重复值。

让我们编码吧！

创建一个列表——您可以使用方括号 [] 或调用 list() 方法。

 id = [234, 534, 239, 392] 字母=列表（'shubhangi'）  
 #创建一个字符串列表将字符串分成单独的#characters  
 >>> ['s', 'h', 'u', 'b', 'h', 'a', 'n', 'g', 'i'] 名称 = list(['shubhangi', 'nita', 'pooja', 'jordan'])  
 >>> ['shubhangi', 'nita', 'pooja', '乔丹'] 混合 = [234, 'shubhangi', 'nita', 23.9]

在列表末尾添加一个元素

 names.append('shagun')  
 >>>['shubhangi', 'nita', '乔丹', 'shagun'] names.append('nita')  
 >>>['shubhangi'，'nita'，'pooja'，'jordan'，'shagun'，'nita']

将元素添加到列表的特定索引

 名称.插入（2，'nidhi'）  
 >>>['shubhangi'，'nita'，'nidhi'，'pooja'，'jordan'，'shagun'，'nita']

计算相同值的出现次数

 names.count('nita')  
 >>>2

从列表中删除具有特定值的元素。如果该值的元素出现多次，则仅删除第一次出现的元素。

 names.remove('pooja')  
 >>>['shubhangi'，'nita'，'nidhi'，'jordan'，'shagun'，'nita'] names.remove('nita')  
 >>>['shubhangi', 'nidhi', '乔丹', 'shagun', 'nita']

删除特定索引处的元素

 名称.pop(3)  
 >>>['shubhangi', 'nidhi', '乔丹', 'nita']

从列表中删除最后一个元素

 名称.pop()  
 >>>['shubhangi'，'nidhi'，'乔丹']

获取具有特定值的元素的索引

 names.index('乔丹')  
 >>>2

反转列表

 名称.reverse()  
 >>>['乔丹'，'nidhi'，'shubhangi']

列表推导： 这是我最喜欢的关于列表的部分。您可以以推导式的形式创建、添加、修改和基本上对列表执行任何操作，这是一种更加优雅和 综合的 将多行代码转换为一行的方法！

假设您想要一个从 1 到 40 的数字平方列表。一个乏味的方法是

 正方形 = []  
 对于范围 (1, 41) 中的 x：  
 squares.append(x**2) >>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576、625、676、729、784、841、900、961、1024、1089、1156、1225、1296、1369、1444、1521、1600]

使用列表推导，您可以简单地编写

 squares = [x**2 for x in range (1,41)]  
 >>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576、625、676、729、784、841、900、961、1024、1089、1156、1225、1296、1369、1444、1521、1600]

您还可以将 if 条件添加到列表推导中！让我们从 'squares' 列表中创建一个列表，该列表由可被 2 整除的数字组成

 nums = [num for num in squares if num%2==0]  
 >>>[4、16、36、64、100、144、196、256、324、400、484、576、676、784、900、1024、1156、1296、1444、1600]

让我们也添加一个else！

 结果 = [num if num%2==0 else 'no' for num in squares]  
 >>>['not', 4, 'not', 16, 'not', 36, 'not', 64, 'not', 100, 'not', 144, 'not', 196, 'not', 256, '不是', 324, '不是', 400, '不是', 484, '不是', 576, '不是', 676, '不是', 784, '不是', 900, '不是', 1024, '不是'，1156，'不是'，1296，'不是'，1444，'不是'，1600]

注意：当只有一个 如果 条件然后 如果 紧随其后 为了 .当有一个 如果别的 条件然后 如果 和 别的 来到 为了 .

切片： 这是列表的另一个很酷的功能！这是一种使用索引从列表中提取子集的方法。基本语法是

_ _ [ _ _ ： _ _ ： _ _ ]

 名称= ['shubhangi'，'nita'，'nidhi'，'pooja'，'jordan'，'shagun']

获取整个列表

 名称[::]  
 >>>['shubhangi'，'nita'，'nidhi'，'pooja'，'jordan'，'shagun']

获取两个索引之间的元素

 名字[1:5]  
 >>>['nita', 'nidhi', 'pooja', '乔丹']  
 #（索引为 1、2、3、4 的元素）

从列表中获取备用元素

 名称[::2]  
 >>>['shubhangi'，'nidhi'，'乔丹']  
 #（从索引 0 开始，跳过下一个索引，返回下一个元素，# 等等）

获取两个索引之间的替代元素

 名称[1:6:2]  
 >>>['nita', 'pooja', 'shagun']

反转列表

 名称[::-1]  
 >>>['shagun', 'jordan', 'pooja', 'nidhi', 'nita', 'shubhangi']

元组

元组将数据存储为括号内的逗号分隔元素。它是不可变的、异构的、有序的、顺序的和索引的。

 奇数 = (1, 3, 5, 7,9)

不可变： 元组本身是不可变的，这意味着不能动态添加、删除或修改元素。一旦一个元组被初始化，它就不能被改变。这就是为什么它们比列表更节省内存的原因，因为内存在创建时是固定的。这也使查找活动更快。

异质： 像列表一样，元组可以保存不同数据类型的元素，包括不同的数据结构。例如，一个元组可以有一个字符串，后跟一个浮点数，然后是一个列表。因此，尽管元组是不可变的，但它可以保存可变对象。因此，数据没有那么紧密地打包在一起（就像在列表中一样）。

订购： 像列表一样，元组保留元素的顺序。顺序将始终与您创建的顺序相同。

顺序： 元组是可迭代的，就像列表一样。

索引： 元组的索引方式与列表完全相同，因此也可以以相同的方式访问元素。

所以基本上，元组是一个不可变的列表。

让我们编码吧！

创建一个元组

 数据 = (1, 3, '草莓', [9, 3, 4]) even_nums = 2、4、6、8  
 >>> (2, 4, 6, 8) 类型（偶数）  
 >>><class ‘tuple’> nums = even_nums, (1, 3, 5, 7) # 嵌套元组  
 >>> ((2, 4, 6, 8), (1, 3, 5, 7)) 字母=元组（['a'，'b'，'c']）  
 >>> ('a', 'b', 'c') # 初始化一个只有一个元素的元组。如果没有  
 # 逗号它不会创建一个元组  
 单= 1，  
 >>> (1,)  
 单测试 = (1)  
 类型（single_test）  
 >>><class 'int'>

解包元组（将其值存储到单个变量中）

 a, b, c, d = even_nums  
 打印（a，b，c，d）  
 >>> 2 4 6 8

其他方法与列表相同，除了不插入、删除或更新元素。

字典

字典以键值对的形式存储数据。它是一种顺序的、异构的、无序的、索引的、可变的数据结构。

 数字 = {'奇数':[1, 3, 5, 7, 9], '偶数':[2, 4, 6, 8]}

很像电话通讯录，其中一个人的名字你有一个电话号码。名称是键，数字是值。一个键只能有一个值。值本身可以是另一个可以容纳多个元素的数据结构，例如列表。字典也称为映射、哈希映射、关联数组和查找表。

顺序： 像列表和元组一样，可以迭代字典。

异质： 像列表一样，字典可以保存不同数据类型的键和值。

无序： 内置字典中的 python 3.6.2 及以后版本是有序的；它们保留插入键的顺序。但在此之前，他们不保留订单。

索引： 它的要点很简单，您可以根据它们的键获取元素。这些键是字典的索引，它们可以是任何可散列类型——可散列对象是其值在其生命周期内不会改变的对象，因此任何不可变对象都是可散列的，例如数字和字符串。

可变： 虽然字典中的键是不可变的，但字典本身是可变的。这意味着您可以在创建后添加、删除和更新键值对。由于字典是可变的，它在创建时没有固定的大小——它是动态的。

字典在执行操作时也非常高效——查找、插入、更新和删除的时间复杂度为 O(1)。

虽然这本字典在 Python 中直接可用，但它的一些版本具有不同的功能，可以从 收藏品 图书馆和 类型 图书馆。其中一些版本如下：

• 有序字典：这保留了键插入的顺序，并且有一些基本字典没有的方法（python 3.6+ 普通字典也保留了插入顺序）
• 默认字典：如果您尝试获取尚不存在的键的值，则会返回默认值/响应
• 链式映射：这将多个字典组合成一个映射；当您对映射执行查找时，将搜索映射中的每个单独的字典，直到找到键
• 计数器：这对可散列对象进行计数，即它计算元素出现的次数并将其存储为以相应元素为键的值
• 映射代理类型：这是一个基于原始可变字典创建只读（即不可变）代理字典的包装器

让我们编码吧！

创建字典

 d = {'a':'apple', 'b':'banana'} # 使用 {} d = dict(a='apple', b='banana') # 使用 dict() 方法 d = dict([('a','apple'), ('b','banana')]) # 在元组列表上使用 dict 方法 id = [234, 534, 239, 392]  
 名称= ['shubhangi'，'nita'，'pooja'，'乔丹']  
 学生 = dict(zip(ids, names))  
 >>>{234：'shubhangi'，534：'nita'，239：'pooja'，392：'乔丹'}  
 # 在两个单独的列表上使用 zip 方法

获取字典的键

 学生.keys()  
 >>>dict_keys([234, 534, 239, 392]) list(students) # 以列表形式返回键  
 >>>[234、534、239、392] sorted(students) # 按排序顺序返回键  
 >>>[234、239、392、534]

获取字典的值

 学生.values()  
 >>>dict_values(['shubhangi', 'nita', 'pooja', 'jordan'])

获取特定键的值

 # 节省时间，但如果 key 不存在会引发 KeyError  
 学生.get(239)  
 >>>'pooja' # 如果key不存在则返回默认值  
 student.get(123, '不存在')  
 >>>'不存在' 学生[239]  
 >>>'pooja'

删除特定的键值对

 学生.pop(239)  
 >>>{234：'shubhangi'，534：'nita'，392：'乔丹'} 德尔学生[239]  
 >>>{234：'shubhangi'，534：'nita'，392：'乔丹'}

检查字典中是否存在/不存在特定键

 学生 234 人  
 >>>真 123 不在学生中  
 >>>真

检查字典是否为空

 如果学生：  
 ...print("非空")  
 别的：  
 ...打印（“空”）  
 >>>不是空的

迭代键值对

 对于 student.items() 中的 k、v：  
 ...打印（k，v）  
 >>>234  
 第534章  
 第392章

将键值对添加到字典

 学生.update({123:'nidhi'})  
 >>> {234：'shubhangi'，534：'nita'，392：'约旦'，123：'nidhi'} 学生 [901] = 'radhika'  
 >>>{234：'shubhangi'，534：'nita'，392：'jordan'，123：'nidhi'，901：'radhika'}

字典推导：就像列表一样，字典也可以使用推导来制作和修改！

 nums = { k: k**2 for k in (1, 2, 3)}  
 >>> {1:1, 2:4, 3:9} nums.update((k, k**3) for k,v in nums.items())  
 >>>{1:1, 2:8, 3:27} nums.update((k, v**3) for k,v in nums.items())  
 >>>{1：1、2：64、3：729}

清空字典

 nums.clear()  
 >>>{}

套

集合是大括号内逗号分隔、无序、唯一元素的集合。它是可变的、未索引的和异构的。

 元音 = {'a', 'e', 'i', 'o', 'u'}

无序： 不保持元素的顺序。

独特的： 与列表不同，集合不存储重复值。

未编入索引： 由于集合中的元素是无序的，因此它们没有索引。

可变： 像列表一样，集合是可变的。因此，可以在创建后添加和删除元素。但是，不能更改元素，因为由于缺少索引而无法访问特定元素。

异质： 只要它们是可散列的，集合就可以保存不同数据类型的元素，即元素本身应该是不可变的。例如，一个集合中不能有一个列表。

集合允许诸如数学中的集合（带有维恩图的集合）之类的操作——交集、并集、差集等。所有这些操作的时间复杂度为 O(n)。

集合由 python 中的字典数据类型支持，因此具有许多相似的特征。

还有一种不可变的集合，称为冻结集合。这可以用作字典中的键（因为它们是不可变的）或用作另一个集合的元素。

让我们编码吧！

创建一个集合

 元音 = set('aeiou')  
 >>> {'u', 'e', 'o', 'i', 'a'} 我的名字 = set('shubhangi')  
 >>> {'u'、'n'、'b'、'h'、's'、'g'、'i'、'a'}

与列表和字典一样，集合也适用于推导式！

 even = {x for x in range (20) if x%2==0}  
 >>> {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}

获取两个集合的交集，即两个集合中的共同元素

 myname.intersection（元音）  
 >>> {'u', 'i', 'a'}

将两组连接在一起（获取他们的并集）

 myname.union（元音）  
 >>> {'u'、'n'、'e'、'o'、'b'、'h'、's'、'g'、'i'、'a'}

获取一组中存在而另一组中不存在的元素

 myname.difference（元音）  
 >>> {'n', 'b', 'h', 's', 'g'}

向集合中添加一个元素

 myname.add('hora')  
 >>> {'u'，'n'，'hora'，'b'，'h'，'s'，'g'，'i'，'a'}

从集合中移除一个元素

 myname.remove('hora')  
 >>> {'u'、'n'、'b'、'h'、's'、'g'、'i'、'a'}

我希望这篇文章能帮助你学习/修改 Python 中列表、集合、元组和字典的方式、时间和原因！除此之外，还有一些数据结构，如数组、堆栈、队列、链表等，可以从 python 库中导入或使用现有数据结构创建。我们将在以后的文章中讨论这个问题:)

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明

本文链接：https://www.qanswer.top/1980/09463103