0基础跟德姆（dom）一起学AI Python基础04-数据容器-列表,元祖,字典

* 列表详解
* 元组详解
* 字典详解

---

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

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

# 2. 打印列表(元素值)
print(f'list1: {list1}')    # list1: [10, 20.3, True, 'abc']
print(f'list2: {list2}')    # list2: []
print(f'list3: {list3}')    # list3: []

# 3. 打印列表(类型)
print(type(list1))  # <class 'list'>
print(type(list2))  # <class 'list'>
print(type(list3))  # <class 'list'>
print('-' * 28)

# 4. 打印列表的 某个元素. 即: 测试列表的索引.
print(list1[1])       # 20.3, 正向索引
print(list1[-3])      # 20.3, 逆向索引.

# 初体验: 切片
print(list1[1:])      # [20.3, True, 'abc']

2.列表遍历
"""
遍历介绍:
    概述:
        逐个的获取容器类型中的每个元素的过程, 就称之为: 遍历.
    遍历思路:
        思路1: for循环, 直接从 容器类型中获取每个元素.
        思路2: 采用 索引的 方式实现.
"""

# 1. 定义列表.
list1 = [11, 22, 33, 44, 55]

# 2. 遍历列表.
# 思路1: 采用 for循环, 直接获取列表的每个元素.
for value in list1:
    print(value)
print('-' * 28)

# 思路2: 采用 索引的 方式实现, while循环写法.
# print(list1[0])
# print(list1[1])
# print(list1[2])
# print(list1[3])
# print(list1[4])
i = 0
while i < len(list1):   # 细节: 不要直接写数值, 建议写成 列表的长度.
    print(list1[i])     # i 就是列表中每个元素的索引, 例如: 0, 1, 2, 3, 4
    i += 1
print('-' * 28)

# 思路2: 采用 索引的 方式实现, for循环写法.
for i in range(len(list1)):
    print(list1[i])     # i 就是列表中每个元素的索引, 例如: 0, 1, 2, 3, 4

3.列表-增
"""
列表相关操作介绍:
    概述:
        列表的相关操作主要指的是 CURD(增删改查), 以及常用的 公共运算符 和 函数等.
    列表 增(添加元素) 相关操作如下:
        列表名.append(单个值 或者 列表)       在列表末尾添加元素, 如果(添加的内容)是列表, 则是把列表当做1个元素, 来添加的.
        列表名.extend(列表)                 在列表末尾添加元素, 如果(添加的内容)是列表, 则是把列表中逐个元素添加过来.
        列表名.insert(索引值, 要插入的元素)    在指定的位置插入元素, 如果索引不存在, 就默认往 "最后" 添加.
    结论:
        列表 是 可变类型, 即: 其中的元素值时可以变化的.
"""

# 1. 定义列表.
list1 = [10, 20, 30, 40, 50]
list2 = ['a', 'b', 'c']

# 2. 演示列表 增 相关的函数.
# 列表名.append(单个值 或者 列表)       在列表末尾添加元素, 如果(添加的内容)是列表, 则是把列表当做1个元素, 来添加的.
list1.append('张三')
list1.append(list2)

# 列表名.extend(列表)       在列表末尾添加元素, 如果(添加的内容)是列表, 则是把列表中逐个元素添加过来.
# list1.extend(100)       # 报错.
list1.extend(list2)       # extend('abc')           for value in 100:

# 列表名.insert(索引值, 要插入的元素)    在指定的位置插入元素, 如果索引不存在, 就默认往 "最后" 添加.
list1.insert(2, 100)      # 2在这里是: 正向索引.
list1.insert(-2, 100)     # -2在这里是: 逆向索引

# list1.insert(20, 666)
list1.insert(-20, 666)

# 3. 打印结果.
print(f'list1: {list1}')
print(f'list2: {list2}')

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

# 1. 定义列表
list1 = ['a', 'b', 'c', 'a', 'c']

# 2. 演示列表的 查询 相关的函数.
# 列表名.index(要查找的元素, 起始索引, 结束索引)       类似于字符串的 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 列表名                                 判断元素在不在列表中, 在: True, 不在: False
print('a' in list1)     # True

# 元素值 not in 列表名                             判断元素在不在列表中, 在: False, 不在: True
print('a' not in list1) # False

5.扩展-大串中小串出现的次数

```python
# 需求: 统计 小串 在 大串中出现的次数.

# 1. 定义变量, 表示: 大串.
max_str = "woaiheima, buguanheimahaishibaima, zhaodaogongzuojiushihaoma"

# 2. 定义变量, 表示: 小串.
min_str = "heima"

# 3. 统计 小串在大串中出现的次数.
# 思路1: 字符串自带的count()函数.
# result = max_str.count(min_str)

# 思路2: split()切割 + 统计 元素个数.
# list1 = max_str.split(min_str)
# result = len(list1) - 1         # 分析出的规律.

# 思路3: 替换的思路.  公式: (大串长度 - 新串长度) / 小串长度
new_str = max_str.replace(min_str, '')
result = (len(max_str) - len(new_str)) // len(min_str)

# 思路4: find() + 切片, 自己写.

# 4. 打印结果.
print(result)

6.列表-删

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

# 1. 定义列表.
list1 = [10, 20, 30, 10, 30]

# 2. 演示 列表删除元素相关函数.
# 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)            # 索引不存在, 就报错.

# 3. 打印列表.
print(f'list1: {list1}')

"""
扩展题:
    需求1: 删除列表中的重复元素, 只保留1个. 
        [10, 20, 30, 10, 30]        =>   [10, 20, 30]
        
    需求2: 键盘录入字符串, 接收并存储到列表中. 直至用户录入 end, 结束录入. 判断其中是否有 abc 这个字符串, 有就全部删除.
        [10, 20, 'abc', 'abc', 10.3, 'abc', 'bcd']     =>   至少2种解题思路.
"""

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

# 1. 定义列表.
list1 = [10, 20, 30, 10, 30]

# 2. 演示列表 修改相关的操作.
# 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)      # 降序

# 3. 打印列表元素内容.
print(f'list1: {list1}')

8.列表-嵌套
"""
列表嵌套介绍:
    概述:
        所谓的列表嵌套指的是: 列表的元素还是1个列表, 这种写法就称之为: 列表嵌套.
    格式:
        列表名 = [列表1, 列表2, 列表3...]
    如何获取元素?
        方式1: 遍历.
        方式2: 列表名[外部列表的索引][内部列表的索引]
"""

# 1. 定义列表, 记录: 姓名.
name_list = [['刘怡铭', '陈正', '蔡徐坤'], ['王心凌', '王祖贤', '张曼玉'], ['李白', '杜甫', '李贺']]

# 2. 获取指定的元素.
print(name_list[1])         # ['王心凌', '王祖贤', '张曼玉']
print(name_list[1][0])      # '王心凌'
print(name_list[2][1])      # '杜甫'
print('-' * 28)

# 3. 遍历.
for i in range(len(name_list)):
    # i 代表的是 二维列表的每个元素的 索引.
    child_list = name_list[i]           # ['刘怡铭', '陈正', '蔡徐坤']...
    # 因为 child_list 还是1个列表, 所以我们接着遍历.
    for j in range(len(child_list)):
        print(child_list[j])
    print('-' * 28)

print('*' * 28)

for child_list in name_list:
    for name in child_list:
        print(name)
    print('#' * 28)

9.列表-嵌套-随机分配办公室
"""
需求:
    已知有三个教室, 格式为: class_list = [[], [], []]
    只有有8名教师, 格式为: name_list = [1, 2, 3...]
    请用所学实现, 把8名教师随机分配到上述的3个教室中.
涉及到的知识点:
    列表嵌套, 随机数, 循环, append()...
"""
# 0.导包
import random

# 1. 定义列表, 记录: 教室.
class_list = [[], [], []]
# 2. 定义列表, 记录: 老师.
name_list = ['乔峰', '虚竹', '段誉', '杨过', '郭靖', '张三丰', '岳不群', '令狐冲']
# name_list = [1, 2, 3, 4, 5, 6, 7]

# 3. 开始随机分配, 遍历 老师列表, 获取到每一个老师(的名字)
for name in name_list:
    # 4. 核心细节: 随机生成教室的编号, 这个教室, 就是当前教师要去的教室.  添加即可.
    class_id = random.randint(0, 2)     # 包左包右.
    class_list[class_id].append(name)

# 5. 循环结束后, 教室分配完毕, 打印结果即可.
# 方式1: 直接输出.
# print(class_list)

# 方式2: 遍历输出.
for class_info in class_list:   # 遍历: 获取到每个教室的信息
    for name in class_info:     # 遍历: 获取到教室中的每个 老师的信息
        print(name)
    print('-' * 28)

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

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

# 2. 打印元组的内容.
print(t1)
print(t2)
print(t3)
print(t4)

# 3. 打印上述几个变量的 数据类型.
print(type(t1)) # <class 'tuple'>
print(type(t2)) # <class 'tuple'>
print(type(t3)) # <class 'tuple'>
print(type(t4)) # <class 'int'>
print('-' * 28)

# 4. 和列表, 字符串一样, 元组也是支持函数的, 例如: index(), count(), len()
t5 = ('a', 'b', 'c', 'd', 'e', 'b', 'd')

# 根据索引, 获取元组的内容.
print(t5.index('b'))     # 1
# print(t5.index('f'))     # 找不到, 就报错.

# count(), 统计元组中元素的个数.
print(t5.count('b'))    # 2

# len(), 统计元组的长度, 即: 元组的元素个数.
print(len(t5))

# 元组也支持索引, 可以通过 元组名[索引] 的方式获取数据.
print(t5[3])            # d

# 元组和列表最大的区别: 元组属于不可变类型, 其元素值不能改变.
# t5[1] = 'bb'
print(t5)

11.幸运数字6
"""
需求:
    输入任意的数字, 然后生成 1 ~ 该数字之间额列表, 从中选取幸运数字(能被6整除的)移动到新列表 lucky, 并打印两个列表.
"""

# 1. 定义列表 nums, 用于记录: 生成的数据.
nums = []
# 2. 定义列表 lucky, 用于记录: 幸运数字.
lucky = []

# 3. 提示用户键盘录入1个值, 并接收. 细节: 转成int类型.
input_num = int(input('请录入1个大于0的整数: '))     # 例如: 9

# 4. 生成 1 ~ 用户录入的数字 区间内的所有整数, 然后添加到 nums 列表中.
for i in range(1, input_num + 1):
    nums.append(i)

# 5. 遍历nums列表, 获取到每个值.
for num in nums:
    # 6. 判断当前的值是否是 6的倍数, 如果是, 就将其添加到 lucky列表中.
    if num % 6 == 0:
        lucky.append(num)

# 7. 打印 nums 和 lucky两个列表的信息.
print(f'nums: {nums}')
print(f'lucky: {lucky}')

print('-' * 28)

# 合并版, 列表推导式.
# 1. 提示用户键盘录入1个值, 并接收. 细节: 转成int类型.
input_num = int(input('请录入1个大于0的整数: '))     # 例如: 9

# 2. 生成 1 ~ 用户录入的数字之间的 数字列表.
nums = [i for i in range(1, input_num + 1)]

# 3. 从上述的 nums列表中, 找到 幸运数字.
lucky = [i for i in nums if i % 6 == 0]

# 7. 打印 nums 和 lucky两个列表的信息.
print(f'nums: {nums}')
print(f'lucky: {lucky}')

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

# 1. 定义变量, 表示: 字典.
dict1 = {'杨过':'小龙女', '郭靖':'黄蓉', '张无忌':'赵敏'}
dict2 = {}
dict3 = dict()

# 2. 打印字典内容.
print(f'dict1: {dict1}')
print(f'dict2: {dict2}')
print(f'dict3: {dict3}')

# 3. 打印字典的数据类型.
print(type(dict1))
print(type(dict2))
print(type(dict3))

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

字典使用细节:
    1. 字典存储的是键值对元素, 键具有唯一性, 值可以重复.
    2. 字典属于可变类型, 其元素值可以修改.
"""

# 1. 定义变量, 表示: 字典.
dict1 = {'杨过':'小龙女', '郭靖':'黄蓉', '张无忌':'如花'}

# 2. 演示 字典相关的 函数.
# 增:  字典名[键名] =  值
dict1['刘怡铭'] = '金莲'      # 键不存在, 就添加该键值对.

# 删:  del 字典名   或者 clear()
# dict1.clear()       # 清空元素(即: 删除所有的键值对)
# del dict1           # 从内存中删除该字典.
# del dict1['郭靖']     # 根据键, 删除该键值对.

# 改:  字典名[键名] =  值
dict1['刘怡铭'] = '如花'

# 3. 打印字典内容.
print(f'dict1: {dict1}')
print('-' * 28)

# 查:  get(), keys(), values(), items()
# get(键, 默认值)       根据键获取值, 如果键不存在, 就获取默认值.
print(dict1.get('杨过'))              # 小龙女
print(dict1.get('杨过', '李四'))       # 小龙女

print(dict1.get('乔峰'))              # None
print(dict1.get('乔峰', '张三'))       # 张三
print('-' * 28)

# keys() 获取字典中所有的键.
print(dict1.keys())     # dict_keys(['杨过', '郭靖', '张无忌', '刘怡铭'])

# values() 获取字典中所有的值.
print(dict1.values())   # dict_values(['小龙女', '黄蓉', '如花', '如花'])

# items()   把 每对键值对元素 封装成 元组, 然后再放到 列表中.
print(dict1.items())        # 列表 嵌套 元组, 即:  dict_items([('杨过', '小龙女'), ('郭靖', '黄蓉'), ('张无忌', '如花'), ('刘怡铭', '如花')])

14.字典-遍历
"""
字典遍历介绍:
    概述:
        所谓的遍历, 就是逐个获取容器中 每个元素的操作.
    字典遍历方式:
        思路1: 根据 键 获取其对应的值.              理解为: 根据 丈夫 找 妻子.
        思路2: 根据 键值对 获取其对应的 键 和 值.    理解为: 根据 结婚证 找 丈夫 和 妻子.
"""
# 1. 定义字典, 记录: 键值对元素.
dict1 = {'乔峰': '阿朱', '虚竹': '梦姑', '杨过': '小龙女', '郭靖': '黄蓉'}

# 2. 遍历字段.
# 思路1: 根据 键 获取其对应的值.              理解为: 根据 丈夫 找 妻子.
# 2.1 获取到所有的键.      类似于: 获取所有的丈夫.
keys = dict1.keys()

# 2.2 遍历, 获取到每个键.  类似于: 获取到具体的某1个丈夫.
for key in keys:
    # 2.3 根据 键 找 值.      类似于: 根据 丈夫 找 妻子.
    value = dict1.get(key)
    print(f'{key} <=> {value}')  # 打印结果

print('-' * 28)

# 上述格式简化写法.
for key in dict1.keys():
    print(f'{key} <=> {dict1.get(key)}')  # 打印结果

print('-' * 28)

# 思路2: 根据 键值对 获取其对应的 键 和 值.    理解为: 根据 结婚证 找 丈夫 和 妻子.
# 2.1 获取所有的 键值对对象.      即: 获取所有的 结婚证.
items = dict1.items()
# 2.2 遍历, 获取到每个键值对.     即: 获取到 每个结婚证.
for item in items:
    # print(item)     # 每个键值对, 例如: ('乔峰', '阿朱'), ('虚竹', '梦姑')...

    # 2.3 根据 键值对 找键和值.       即: 根据结婚证找 丈夫 和 妻子.
    key, value = item[0], item[1]
    print(f'{key} <=> {value}')  # 打印结果

print('-' * 28)

# 上述格式简化写法.
for item in dict1.items():
    # key, value = item[0], item[1]
    print(f'{item[0]} <=> {item[1]}')  # 打印结果

print('-' * 28)

# 实际开发写法, 拆包(后续详解)
for k,v in dict1.items():       # 等价于:   k, v = ('键', '值')
    # key, value = item[0], item[1]
    print(f'{k} <=> {v}')  # 打印结果

print('-' * 28)

# 扩展: 拆包写法.
t1 = ('abc', 'bcd')
a, b = t1       # 拆包写法, a 和 b 分别表示 元组t1的前两个元素.
print(a)
print(b)