Python列表、元组、字典、集合详解

一、列表介绍:

   概述:
        它属于容器类型的一种, 属于 可变类型. 它可以同时存储 多个元素.
    格式:
        格式1:  列表名 = [值1, 值2, 值3...]
        格式2:  列表名 = list()
    细节:
        1. 列表可以同时存储多个元素, 可以是不同类型的, 也可以是同类型的元素.
        2. 实际开发中, 为了方便统一操作, 建议: 列表存储的多个元素 是 同类型.
        3. 列表的元素也是有索引的, 且索引也是从 0(正向), -1(逆向) 开始的.
        4. 列表和字符串一样, 也是支持 "切片" 操作的, 规则都一样:  列表名[起始索引:结束索引:步长]

list1 = [10, 20.3, True, 'abc']
list2 = list()
list3 = []          # 可以理解为 [] 是 list()的语法糖.

print(list1[1])       # 20.3, 正向索引
print(list1[-3])      # 20.3, 逆向索引.

print(list1[1:])      # [20.3, True, 'abc']

1、列表遍历

1）for循环, 直接从 容器类型中获取每个元素.

for value in list1:
    print(value)

2）采用索引的方式实现, while循环写法.

i = 0
while i < len(list1):   # 细节: 不要直接写数值, 建议写成 列表的长度.
    print(list1[i])     # i 就是列表中每个元素的索引, 例如: 0, 1, 2, 3, 4
    i += 1

        采用 索引的 方式实现, for循环写法.

for i in range(len(list1)):
    print(list1[i])     # i 就是列表中每个元素的索引, 例如: 0, 1, 2, 3, 4

2、列表增、删、改、查

1）列表-增

    列表 增(添加元素) 相关操作如下:

列表名.append(单个值 或者 列表) ——在列表末尾添加元素, 如果(添加的内容)是列表, 则是把列表当做1个元素, 来添加的.

list1 = [10, 20, 30, 40, 50]
list2 = ['a', 'b', 'c']

list1.append('张三')
list1.append(list2)

列表名.extend(列表) ——在列表末尾添加元素, 如果(添加的内容)是列表, 则是把列表中逐个元素添加过来.

list1.extend(list2)       # extend('abc')

# 遍历（括号内的列表list2）后追加到list1末尾

列表名.insert(索引值, 要插入的元素)——在指定的位置插入元素, 如果索引不存在, 就默认往 "最后" 添加.

list1.insert(2, 100)      # 2在这里是: 正向索引.
list1.insert(-2, 100)     # -2在这里是: 逆向索引

2）列表-查

列表 查询 相关函数:
    列表名.index(要查找的元素, 起始索引, 结束索引)       类似于字符串的 index()
    列表名.count(元素值)                             统计元素在列表中出现的总次数.
    元素值 in 列表名                                 判断元素在不在列表中, 在: True, 不在: False
    元素值 not in 列表名                             判断元素在不在列表中, 在: False, 不在: True

list1 = ['a', 'b', 'c', 'a', 'c']

列表名.index(要查找的元素, 起始索引, 结束索引)     

print(list1.index('a'))                             # 0,  不指定查找范围, 就从列表的开头开始查找, 直至列表末尾.
print(list1.index('a', 1))            # 3,  只指定开头, 不指定结尾, 就从列表的指定位置 找到 列表末尾.
# print(list1.index('a', 1, 3))  # 报错, 指定了开头和结尾, 就在指定区间查找, 包左不包右. 找不到就: 报错. 这点和字符串是一样的.

列表名.count(元素值)          

print(list1.count('a'))         # 2

元素值 in 列表名          

print('a' in list1)     # True

元素值 not in 列表名            

print('a' not in list1) # False

3）列表-删

列表 删除元素 相关方式 如下:
    del 列表名             删除列表, 从内存中把列表干掉, 即: 相当于没有定义过这个列表.
    del 列表名[索引]        根据索引, 删除元素.
    列表名.clear()         清空列表元素, 相当于: 删除列表所有数据, 得到1个空列表 []
    列表名.remove(元素值)   根据元素值, 删除: 元素.
    列表名.pop(索引值)      根据索引, 删除: 元素.

list1 = [10, 20, 30, 10, 30]

# 演示 列表删除元素相关函数.
del 列表名             删除列表, 从内存中把列表干掉, 即: 相当于没有定义过这个列表.
del list1

# del 列表名[索引]        根据索引, 删除元素.
del list1[1]

# 列表名.clear()         清空列表元素, 相当于: 删除列表所有数据, 得到1个空列表 []
list1.clear()

# 列表名.remove(元素值)   根据元素值, 删除: 元素.
list1.remove(10)        # 只删除第1个匹配到的值.
list1.remove(100)       # 要删除的元素不存在, 报错.

# 列表名.pop(索引值)      根据索引, 删除: 元素.
list1.pop(1)
list1.pop(1)            # 索引不存在, 就报错.

4）列表-改

列表 修改相关的 函数如下:
    列表名[索引] = 值             根据索引, 修改其对应的元素
    列表名.reverse()             反转列表元素.
    列表名.sort(reverse=True)    对列表元素值进行排序, reverse=False 升序,  reverse=True 降序

list1 = [10, 20, 30, 10, 30]


# 演示列表 修改相关的操作.
list1[2] = 300      # 修改索引值为2的元素为: 300
list1[20] = 666     # 报错, 索引越界.

# 反转列表元素.
list1.reverse()       # [30, 10, 30, 20, 10]

# 对列表元素内容进行排序.
list1.sort()                # 默认: 升序
list1.sort(reverse=False)   # 效果同上, 升序
list1.sort(reverse=True)      # 降序

二、元组介绍:

    概述:
        它属于容器类型的一种, 属于 不可变类型.
        它也可以同时存储多个元素, 可以是不同类型的, 实际开发中, 建议存储: 相同类型的多个值.
    特点:
        元组和列表的区别, 元组用小括号来表示, 且元组的 元素值不允许修改.
    定义格式:
        t1 = (值1, 值2, 值3...)                        列表: list1 = [值1, 值2, 值3...]
        t2 = tuple()                                  列表: list2 = list()
        t3 = (值1, )
    细节:
        1. 元组属于不可变类型, 其元素值不能更改.
        2. 元组和列表一致, 也是有索引的概念的.
        3. 定义元组时, 如果只有1个值, 则该值的末尾必须要加 逗号, 否则: 就是在定义1个普通的变量(即: 不是元组)

t1 = (10, 20.3, True, 'abc')
t2 = tuple()
t3 = (10, )
t4 = (10)   # 它等价于 t4 = 10  这只是在定义1个普通的变量, 而不是定义元组.

三、字典介绍:

    概述:
        它属于容器类型的一种, 存储的是 键值对数据, 它(字典)属于 可变类型.
    定义格式:
        dict1 = {键:值, 键:值......}
        dict2 = {}
        dict3 = dict()
    细节:
        1. 字典用 大括号 包裹.
        2. 字典存储的市 键值对形式的数据, 冒号左边的叫: 键, 右边的叫: 值.
        3. 键具有唯一性, 值可以重复.

# 初始化一个字典
my_dict = {'name': 'Alice', 'age': 25}

2、字典增、删、改、查

演示字典的常用 函数 如下:
    增:  字典名[键名] =  值
    删:  del 字典名   或者 clear()
    改:  字典名[键名] =  值
    查:  get(), keys(), values(), items()

# 增加一个新的键值对
my_dict['city'] = 'New York'

print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}


# 删除指定的键值对
del my_dict['age']

print(my_dict)  # 输出: {'name': 'Alice', 'city': 'New York'}



# 修改键值对
my_dict['name'] = 'Bob'

print(my_dict)  # 输出: {'name': 'Bob', 'age': 25}


# 查询指定键的值
name = my_dict['name']

print(name)  # 输出: 'Alice'

3、字典-遍历

1）遍历字典的键：

使用字典的 keys() 方法，可以获得字典中所有的键，然后通过循环遍历这些键

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict.keys():
    print(key)

2）遍历字典的值：

使用字典的 values() 方法，可以获得字典中所有的值，然后通过循环遍历这些值。

my_dict = {'a': 1, 'b': 2, 'c': 3}
for value in my_dict.values():
    print(value)

3）遍历字典的键值对：

使用字典的 items() 方法，可以同时获得字典中的键和值，然后通过循环遍历这些键值对。

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

4）直接遍历字典：

直接遍历字典时，默认是遍历字典的键。

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
    print(f"Key: {key}, Value: {my_dict[key]}")

       

四、集合介绍

概述:
        它属于容器类型的一种, 其元素特点为: 无序, 唯一.
 

无序解释：这里的无序, 并不是排序的意思, 而是: 元素的存, 取顺序不一致, 例如: 存的时候顺序是1, 2, 3, 取的时候顺序是2, 1, 3
   

应用场景：去重.

set集合定义格式：
        set1 = {值1, 值2, 值3...}
        set2 = set()

# 1. 定义集合.
set1 = {10, 2, 'c', 5, 'a', 6, 3, 'b', 10, 5, 'a'}
set2 = set()
set3 = {}           # 这个不是在定义集合, 而是在定义: 字典.

对列表元素值进行去重.
list1 = [10, 20, 30, 20, 10, 30, 50]

# 去重
# 思路1: 定义新列表, 遍历原始列表获取每个元素, 然后判断是否在新列表中, 不存在就添加.

# 思路2: list -> set, 会自动去重 -> list
set_tmp = set(list1)
list1 = list(set_tmp)