标签：基础知识 Python 元素 列表 shubhangi nita 数据结构 元组 字典
你需要知道的 Python 基础知识：数据结构
数据结构是一种存储、组织和处理数据的格式，它允许您有效地对其执行操作
例如，存储人们的电子邮件地址，全天每小时记录温度等。这些结构中的数据可以称为元素。
有许多数据结构，几乎所有的数据结构都可以用任何编程语言实现——它们要么内置在语言中，要么可以创建或导入。
在本文中，我们将使用 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
标签：基础知识,Python,元素,列表,shubhangi,nita,数据结构,元组,字典 来源： https://www.cnblogs.com/amboke/p/16641563.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。