Python中的列表、元组、集合、字典

Python中的列表、元组、集合、字典

我们将学习一些在 Python 中广泛使用的著名数据结构,例如 List、Tuple、Set、Dictionaries 等。

目录

  • 列表
  • 元组
  • 字典

让我们从列表开始

  • 列表是项目的有序集合
  • 动态和可变
  • 可以有不同数据类型的项目

列表是可变的。您可以修改列表中的元素。

 # 空列表  
 我的列表 = []  
 我的列表  
 **[]** # 整数列表  
 my_list = [1, 2, 3, 4, 5]  
 我的列表  
 **[1、2、3、4、5]** # 不同类型的列表  
 my_list = [1, "2", 3.0]  
 我的列表  
 **[1, '2', 3.0]**

访问列表元素:

访问列表元素的方法有很多种,最常见的一种是索引。

列表为 0 索引。访问超出长度的元素将引发 IndexError。

 my_list = ['汽车','公共汽车','火车','船'] # 获取 my_list 的第二个元素  
 我的列表[1]  
 **'公共汽车'** # 获取 my_list 的第四个元素  
 我的列表[3]  
 **'船'** # 修改 my_list 值  
 my_list[3] = "飞机" # 超出长度  
 我的列表[4]  
 **回溯(最近一次通话最后):  
 文件 ”<input> ",第 1 行,在<module>  
 IndexError:列表索引超出范围**

我们还可以使用负索引从末尾访问列表元素。

 my_list = ['汽车','公共汽车','火车','船'] # 获取 my_list 的最后一个元素  
 我的列表[-1]  
 **'船'**

一些重要的 List 方法

  • append() — 在列表末尾添加项目。

  • insert() — 在列表的给定索引处添加项目。

  • extend() — 将另一个列表的所有元素添加到列表中。

  • pop() — 从列表中删除最后一个元素。

  • sort() — 对列表中的元素进行就地排序。

  • reverse() — 将列表中的元素反转到位。

  • remove() — 从列表中删除给定元素。

    初始列表

    my_list = ['汽车','公共汽车','火车','船'] my_list.append('空中飞机')
    我的列表
    ['汽车','公共汽车','火车','轮船','飞机'] my_list.insert(0, "循环")
    我的列表
    ['自行车','汽车','公共汽车','火车','轮船','飞机'] my_list.extend(['another', 'list'])
    我的列表
    ['Cycle', 'Car', 'Bus', 'Train', 'Ship', 'Air Plane', 'another', 'list'] my_list.pop()
    我的列表
    ['自行车','汽车','公共汽车','火车','船','飞机','另一个'] my_list.sort()
    我的列表
    ['Air Plane', 'Bus', 'Car', 'Cycle', 'Ship', 'Train', 'another'] my_list.reverse()
    我的列表
    ['another', 'Train', 'Ship', 'Cycle', 'Car', 'Bus', 'Air Plane'] my_list.remove('另一个')
    我的列表
    ['火车','船','自行车','汽车','公共汽车','飞机']

元组

元组与列表非常相似,但几乎没有区别:

  • 元组是不可变的

  • 不支持修改元组元素的方法

  • 使用 () 包围元素

  • 使用比具有相同元素的列表更少的内存,因为您事先知道内存需求

    空元组

    我的元组 = ()
    我的元组
    () # 整数元组
    my_tuple = (1, 2, 3, 4 ,5)
    我的元组
    (1, 2, 3, 4, 5) # 不同类型的元组
    my_tuple = (1, "abc", 10.0)
    我的元组
    (1, 'abc', 10.0) # 一个元素的元组;需要添加尾随逗号
    my_tuple = ('a',)
    我的元组
    ('一个',)

在创建只有一个元素的元组时,请注意尾随的逗号 (,)。如果没有这个逗号,它将是一个字符串而不是元组。

访问元组元素:

索引用于访问元组元素。

元组索引为 0。访问超出长度的元素将引发 IndexError。

 my_tuple = (1, 2, 3, 4 ,5) # 获取 my_tuple 的第一个元素  
 我的元组[0]  
 **1** # 获取 my_tuple 的第三个元素  
 我的元组[2]  
 **3** # 改变元素  
 我的元组 [1] = 22 **# 不允许,元组是不可变的  
 回溯(最近一次通话最后):  
 文件 ”<input> ",第 1 行,在<module>  
 TypeError:“元组”对象不支持项目分配**

元组是不可变的(不允许就地更改)。但是,如果元组中存在任何可变元素……修改该元素将更改元组值。这种操作会导致错误。尽量避免这种情况。

 my_tuple = (1, 2, [3, 4, 5]) my_tuple[2].append(6) 我的元组  
 **(1, 2, [3, 4, 5, 6])**

  • 无序的数据收集

  • 不包含重复

  • 可以有不同数据类型的项目

  • 所有项目都必须是可散列的(例如:列表不能是集合中的元素)

  • 由于可散列元素,性能比列表和元组好得多

    空集

    my_set = set()
    我的集
    放() # 整数集
    my_set = {1, 2, 3, 3, 4, 5}
    我的集
    {1, 2, 3, 4, 5} # 注意 3 只出现一次 # 不同类型的集合
    my_set = {1, '2', 3.0, (4, 5)}
    我的集
    {1, (4, 5), 3.0, '2'} # 使用不可散列元素设置 - 不允许
    my_set = {1, '2', 3.0, [4, 5]}
    回溯(最近一次通话最后):
    文件 ” ",第 1 行,在
    类型错误:不可散列类型:“列表”

set 的 Python 内部实现不允许在 set 中有不可散列的元素。

访问集合元素:

无法使用索引访问集合元素。

我们可以使用循环来遍历集合元素。

 my_set = {'绿色','红色','黑色'} 对于 my_set 中的颜色:  
 打印(彩色)

或者我们可以使用 in 关键字来检查集合中元素的存在。

 my_set = {'绿色','红色','黑色'} 如果 my_set 中的“绿色”:  
 print('在集合中找到绿色')  
 别的:  
 print('集合中没有绿色')

一些重要的Set方法

  • add() — 在集合中添加元素

  • pop() — 移除并返回任意集合元素。如果 set 为空,则引发 KeyError。

  • remove() — 从集合中移除给定元素。如果不存在,则提高 KeyError

  • clear() — 从集合中删除所有元素。

    my_set = {'绿色','红色','黑色'}
    我的集
    {'红色','绿色','黑色'} my_set.add("蓝色")
    我的集
    {'红色','蓝色','绿色','黑色'} my_set.pop()
    '红色的'
    我的集
    {'蓝色','绿色','黑色'} my_set.remove('黑色')
    我的集
    {'蓝绿色'} my_set.remove('黑色')
    回溯(最近一次通话最后):
    文件 ” ",第 1 行,在
    键错误:'黑色'
    my_set.clear()
    我的集
    放()

字典

  • 键值对的有序集合(无序 ≤ Python 3.7)

  • 字典中的所有键必须是唯一的

  • 字典中的所有键都必须是可散列的(例如:列表不能是字典键)

  • 性能非常好

    空字典

    我的字典 = {}
    我的字典
    {} # 带有一些数据的字典
    my_dict = {'一':1,'二':2,'三':3,'四':4,'五':5}
    我的字典
    {'一':1,'二':2,'三':3,'四':4,'五':5} # 带有不可哈希键的字典
    my_dict = {[1, 2, 3]: "unhashable key"}
    回溯(最近一次通话最后):
    文件 ” ",第 1 行,在
    类型错误:不可散列类型:“列表”

字典的 Python 内部实现不允许字典中有不可散列的键。

访问字典中的元素

我们可以使用键来访问字典元素,也可以使用循环遍历字典。

 我的字典  
 **{'一':1,'二':2,'三':3,'四':4,'五':5}** my_dict['一个']  
 **1** my_dict['五']  
 **5**

访问不存在的密钥将引发 键错误。 在这种情况下,我们可以使用 get() 方法来提供一些默认值。

 my_dict['六']  
 **回溯(最近一次通话最后):  
 文件 ”<input> ",第 1 行,在<module>  
 键错误:“六”** my_dict.get('六', '默认值')  
 **'默认值'**

一些重要的字典方法

  • keys() — 一个类似集合的对象,提供 dict 键的视图

  • values() — 一个类似集合的对象,提供 dict 值的视图

  • items() — 一个类似集合的对象,提供关于 dict 项目的视图

  • update() — 用给定的字典更新字典

  • get() — 从 dict 中获取给定键的值

  • clear() — 从 dict 中删除所有元素

    my_dict.keys()
    dict_keys(['一', '二', '三', '四', '五']) my_dict.values()
    dict_values([1, 2, 3, 4, 5]) my_dict.items()
    dict_items([('一', 1), ('二', 2), ('三', 3), ('四', 4), ('五', 5)]) my_dict.get('两个')
    2 my_dict.update({'六': 6})
    我的字典
    {‘一’:1,‘二’:2,‘三’:3,‘四’:4,‘五’:5,‘六’:6} my_dict.clear()
    我的字典
    {}

概括

  • List 是有序的、动态的、可变的元素集合
  • 元组是元素的不可变集合,但元组内的任何可变元素都可以修改。
  • 元组比具有相同元素的列表使用更少的内存。
  • Set 无序且不包含重复项。
  • Set 只能有可散列的元素
  • 字典存储键、值对
  • 字典键只能是可散列类型,并且必须是唯一的
  • Set 和 Dictionary 提供了优于其他数据结构的非常好的性能。

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

本文链接:https://www.qanswer.top/32238/48191300

posted @ 2022-09-13 00:48  哈哈哈来了啊啊啊  阅读(79)  评论(0编辑  收藏  举报