python -【五】数据容器

数据容器

一、列表

列表的循环

name_list = ['张三', '李四', '王五']
print(f'类型是：{type(name_list)}')

# while 遍历列表
count = 0
while count < len(name_list):
    print(f'while 下标为[{count}] 的内容是[{name_list[count]}]')
    count += 1

# for 循环
for name in name_list:
    print(f'for 值为[{name}]')

# for range 循环
for i in range(len(name_list)):
    print(f'for range 下标为[{i}] 的内容是[{name_list[i]}]')

    
"""
类型是：<class 'list'>
while 下标为[0] 的内容是[张三]
while 下标为[1] 的内容是[李四]
while 下标为[2] 的内容是[王五]
for 值为[张三]
for 值为[李四]
for 值为[王五]
for range 下标为[0] 的内容是[张三]
for range 下标为[1] 的内容是[李四]
for range 下标为[2] 的内容是[王五]
"""

列表的练习题

定义一个列表，内容是 [1,2,3,4,5,6,7,8,9,10]

• 遍历列表，取出偶数，放入到新的列表对象种
• 使用 while 和 for 个循环一次

"""
定义一个列表，内容是 [1,2,3,4,5,6,7,8,9,10]
遍历列表，取出偶数，放入到新的列表对象种
使用 while 和 for 个循环一次
"""

# 生成原始数据
def generator_origin():
    origin = []
    for i in range(1, 11):
        origin.append(i)
    print(f'原始数组种的内容是：{origin}')
    return origin


# 使用 for 循环实现
def for_iteration(origin: list):
    even_number = []
    for e in origin:
        if not e % 2:
            even_number.append(e)
    print(f'使用for循环得到的偶数列表：{even_number}')


# 使用 while 循环实现
def while_iteration(origin: list):
    even_number = []
    ct = 0
    while ct < len(origin):
        n = origin[ct]
        if not n % 2:
            even_number.append(n)
        ct += 1
    print(f'使用while循环得到的偶数列表：{even_number}')


# 函数汇总入口
def main_func():
    origin = generator_origin()
    for_iteration(origin)
    while_iteration(origin)


# main 函数入口
if __name__ == '__main__':
    main_func()

    
"""
原始数组种的内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
使用for循环得到的偶数列表：[2, 4, 6, 8, 10]
使用while循环得到的偶数列表：[2, 4, 6, 8, 10]
"""

二、元组

元组： 元素一旦被定义完成，不可被修改（抽象理解只读的 list）
数据类型： (元素，元素，元素，元素，元素)

定义元组:
元组字面量：            (元素1, 元素2, 元素3, 元素4)
定义元组变量：        变量名称 = (元素1, 元素2, 元素3, 元素4)
定义空元组方式一： 变量名称 = ()
定义空元组方式二： 变量名称 = tuple()

元组的定义

# 定义元组字面量
(1, 'hello', True)

# 定义元组
t1 = (1, 'hello', True)
# 定义空元组
t2 = ()
t3 = tuple()
# 特殊：一个元素的元组定义，必须要加上 ','
# 不加都好
t4 = ('hello')  # str
t5 = ('hello',)  # tuple

print(f't1 的类型{type(t1)}')
print(f't2 的类型{type(t2)}')
print(f't3 的类型{type(t3)}')
print(f't4 的类型{type(t4)}')
print(f't5 的类型{type(t5)}')

"""
t1 的类型<class 'tuple'>
t2 的类型<class 'tuple'>
t3 的类型<class 'tuple'>
t4 的类型<class 'str'>
t5 的类型<class 'tuple'>
"""

元组的嵌套

t6 = ((1, 2, 3), (4, 5, 6),)
# 通过下表索引取数据
print(t6[0])
# 从元组中取出 6 元素
print(f'下标为：t6[1][2] 的内容是 {t6[1][2]}')

"""
(1, 2, 3)
下标为：t6[1][2] 的内容是 6
"""

元组三个函数的使用 index(), count(), len(tuple)

# index 函数
t7 = ('成都', '重庆', '北京')
idx = t7.index('北京')
print(f'"北京" 的下表是：{idx}')

# count 函数
t8 = ('成都', '重庆', '北京', '北京', '北京', '北京', '北京')
ct = t8.count('北京')
print(f'"北京" 在元组中有{ct}个')

# len 函数
len_ = len(t8)
print(f'"t8" 元组有 {len_}个元素')

"""
"北京" 的下表是：2
"北京" 在元组中有5个
"t8" 元组有 7个元素
"""

元组的遍历

t8 = ('成都', '重庆', '北京', '北京', '北京', '北京', '北京')

# while 遍历
i = 0
while i < len(t8):
    print(f'while 元素：【{t8[i]}】')
    i += 1

# for 遍历
for e in t8:
    print(f'for 元素：【{e}】')
    
   
"""
while 元素：【成都】
while 元素：【重庆】
while 元素：【北京】
while 元素：【北京】
while 元素：【北京】
while 元素：【北京】
while 元素：【北京】
for 元素：【成都】
for 元素：【重庆】
for 元素：【北京】
for 元素：【北京】
for 元素：【北京】
for 元素：【北京】
for 元素：【北京】
"""

元组的练习题

定义一个元组，内容是 ('周杰伦', 11, ['football', 'music']) ，记录的是一个学生信息（姓名，年龄，爱好）

请通过元组的功能对其进行：

• 查询器年龄所在的下表位置
• 查询学生姓名
• 删除学生的爱好中的 ‘football’
• 增加爱好：coding

def tuple_homework():
    age = 11
    old_ = 'football'
    new_ = 'coding'
    t = ('周杰伦', age, [old_, 'music'])
    # 查询器年龄所在的下表位置
    age_idx = t.index(age)
    print(f'年龄[{age}]下标：{age_idx}')
    # 查询学生姓名
    print(f'姓名[{t[0]}]')
    # 删除学生的爱好中的 'football'
    t[2].remove(old_)
    print(f'删除元素【{old_}】后，元组内容：{t}')
    # 增加爱好：coding
    t[2].append(new_)
    print(f'增加爱好【{new_}】后，元组内容：{t}')


tuple_homework()


"""
年龄[11]下标：1
姓名[周杰伦]
删除元素【football】后，元组内容：('周杰伦', 11, ['music'])
增加爱好【coding】后，元组内容：('周杰伦', 11, ['music', 'coding'])
"""

三、字符串容器

字符串被看作容器，是因为字符串支持下标索引

字符串的特点：

• 只能存储字符串
• 任意长度，却决于内存大小
• 支持索引下标
• 允许字符串重复内容
• while / for 循环都支持

# 字符串的基础操作
my_str = 'hello and world !!!!'

# 字符串的替换
new_str = my_str.replace('and', '和')
# 得到一个新的字符串，并没有修改原始的字符串
print(f'修改前：[{my_str}], 修改后：[{new_str}]')

# 字符串的切分
strs = my_str.split(' ')
print(f'将 [{my_str}] 切分后：{strs}, 类型：{type(strs)}')

# 字符串去前后空格
space = ' im zhang san   '
strip = space.strip()
print(f'规整前：[{space}], 规整后：[{strip}]')

# 字符串去前后指定内容
str_ = '211我爱python1111 '
new_str = str_.strip('12 ')   # 1,2,空格  都会移除，而不是一个整体的移除
print(f'规整前：[{str_}], 规整后：[{new_str}]')

# 统计某个字符串出现的次数
count = my_str.count('l')
print(f'字符串【{my_str}】内 "l" 出现了 {count} 次')

# 统计字符串的长度
len_ = len(my_str)
print(f'字符串【{my_str}】的长度是：{len_}')


"""
修改前：[hello and world !!!!], 修改后：[hello 和 world !!!!]
将 [hello and world !!!!] 切分后：['hello', 'and', 'world', '!!!!'], 类型：<class 'list'>
规整前：[ im zhang san   ], 规整后：[im zhang san]
规整前：[211我爱python1111 ], 规整后：[我爱python]
字符串【hello and world !!!!】内 "l" 出现了 3 次
字符串【hello and world !!!!】的长度是：20
"""

四、切片

序列支持切片，即：列表，元组，字符串

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

• 起始下标：从何处开始，可以留空，留空视为从头开始
• 结束下标（不含）：从何处结束，可以留空，留空视为截取到结尾
• 步长：
  • 步长 1：一个个取元素
  • 步长 2：没跳过一个元素取
  • 步长 N：每次跳过 N - 1 个元素取
  • 步长为负数：反向取（注意：起始下标和结束下标也要反向标记）

注意：对一个序列切片后，并会影响原始的序列，而是的到一个新的序列

arr = [0, 1, 2, 3, 4, 5, 6, 7]
tup = (0, 1, 2, 3, 4, 5, 6, 7)
str_ = '01234567'

s1 = arr[1:4]
print(f'list 正向切片 [1:4] 结果为：{s1}')
s2 = arr[3:1:-1]
print(f'list 反向切片 [3:1:-1] 结果为：{s2}')

s3 = tup[:]
print(f'tuple 正向切片 [:] 结果为：{s3}')
s4 = tup[7:1:-2]
print(f'tuple 反向切片 [7:1:-2] 结果为：{s4}')

s5 = str_[::2]
print(f'str 正向切片 [::2] 结果为：{s5}')
s6 = str_[::-1]
print(f'str 反向切片 [::-1] 结果为：{s6}')


"""
list 正向切片 [1:4] 结果为：[1, 2, 3]
list 反向切片 [3:1:-1] 结果为：[3, 2]
tuple 正向切片 [:] 结果为：(0, 1, 2, 3, 4, 5, 6, 7)
tuple 反向切片 [7:1:-2] 结果为：(7, 5, 3)
str 正向切片 [::2] 结果为：0246
str 反向切片 [::-1] 结果为：76543210
"""

切片练习

有一个字符串：“万过薪月，员序程马黑来，nohtyP学”

使用任何学过的方式，得到 “黑马程序员”

content = "万过薪月，员序程马黑来，nohtyP学"
print(content[9:4:-1])

"""
黑马程序员
"""

五、Set 集合

Set 集合，元素无序且不允许重复

语法：

• 变量名 = {元素1，元素2}
• 变量名 = set()

# 张三重复了，所以元素个数是 3
my_set = {'张三', '李四', '王五', '张三'}
print(f'my_set 的元素个数：{len(my_set)}, 内容：{my_set}, 类型是：{type(my_set)}')

# 1. 向集合添加元素
my_set.add('赵六')
print(f'my_set 的元素个数：{len(my_set)}, 内容：{my_set}')

# 2. 删除元素
my_set.remove('赵六')
print(f'my_set 的元素个数：{len(my_set)}, 内容：{my_set}')

# 3. 随机取出一个元素
ele = my_set.pop()
print(f'随机取出的元素：{ele}, 取出后的set：{my_set}')

# 4. 清空集合
my_set.clear()
print(f'清空集合, 清空后的：{my_set}')


set_1 = {1, 2, 3}
set_2 = {1, 5, 6}

# 5. 取出两个集合的差集，不更新原集合
set_3 = set_1.difference(set_2)
print(f'不更新, 集合1：{set_1}， 集合2：{set_2}，差集：{set_3}')
# 取出两个集合的差集，更新原集合
# set_1 集合中的元素会被更新
set_1.difference_update(set_2)
print(f'更新 集合1：{set_1}， 集合2：{set_2}')

# 6.
# set_1 被更新了，需要重置里面的数据
set_1 = {1, 2, 3}
# 取出两个集合的并集
set_5 = set_1.intersection(set_2)
print(f'集合1：{set_1}， 集合2：{set_2}，并集：{set_5}')

# 7. 合并两个集合
set_6 = set_1.union(set_2)
print(f'集合1：{set_1}， 集合2：{set_2}，合并：{set_6}')

# 8. 统计集合元素数量
size = len(set_1)
print(f'set_1 的元素个数是：{size}')

# 9. 集合的遍历
for e in set_1:
    print(f'元素：{e}')

set集合练习题

信息去重
有如下列表对象:
my_list = ['aaa', 'bbb', 'ccc', 'aaa', 'fff', 'ggg', 'fff', 'ggg', 'best']

请:

• 定义一个空集合
• 通过for循环遍历列表
• 在for循环中将列表的元素添加至集合
• 最终得到元素去重后的集合对象，并打印输出

my_list = ['aaa', 'bbb', 'ccc', 'aaa', 'fff', 'ggg', 'fff', 'ggg', 'best']

my_set = set()
for my in my_list:
    my_set.add(my)
print(f'去重后的集合：{my_set}, 原集合大小：{len(my_list)}, 去重后大小：{len(my_set)}')

六、字典

字典不允许重复，且无序
字典的定义
字面量：{key: v, key: v}
定义字典变量：my_dict = {key: v, key: v}
定义空字典：my_dict = {}
定义空字典：my_dict = dict()

字典元素的CRUD

"""
字典的增上查改
"""

my_dice = {'张三': 77, '李四': 88, '王五': 99}

# 新增元素
print('------------新增-------------')
print(f'新增前：{my_dice}')
my_dice['赵六'] = 88
print(f'新增后：{my_dice}')

# 更新元素
print('------------更新-------------')
print(f'更新前：{my_dice}')
my_dice['赵六'] = 150
print(f'更新后：{my_dice}')

# 删除元素
print('------------删除-------------')
print(f'删除前：{my_dice}')
score = my_dice.pop('赵六')
print(f'删除后：{my_dice}, 被删除的值：{score}')


# 获取所有的 key
print('------------获取所有的 key-------------')
keys = my_dice.keys()
print(f'所有的key：{keys}')


# 遍历字典: 方式1
print('------------遍历字典：方式1-------------')
keys = my_dice.keys()
for key in keys:
    print(f'key:{key}, value：{my_dice[key]}')

# 遍历字典: 方式2
print('------------遍历字典：方式2-------------')
for k in my_dice:
    print(f'key:{k}, value：{my_dice[k]}')


# 元素数量
print('------------元素数量-------------')
print(f'my_dict 的数量：{len(my_dice)}')

# 清空元素
print('------------清空-------------')
print(f'清空前：{my_dice}')
my_dice.clear()
print(f'清空后：{my_dice}')


"""
------------新增-------------
新增前：{'张三': 77, '李四': 88, '王五': 99}
新增后：{'张三': 77, '李四': 88, '王五': 99, '赵六': 88}
------------更新-------------
更新前：{'张三': 77, '李四': 88, '王五': 99, '赵六': 88}
更新后：{'张三': 77, '李四': 88, '王五': 99, '赵六': 150}
------------删除-------------
删除前：{'张三': 77, '李四': 88, '王五': 99, '赵六': 150}
删除后：{'张三': 77, '李四': 88, '王五': 99}, 被删除的值：150
------------获取所有的 key-------------
所有的key：dict_keys(['张三', '李四', '王五'])
------------遍历字典：方式1-------------
key:张三, value：77
key:李四, value：88
key:王五, value：99
------------遍历字典：方式2-------------
key:张三, value：77
key:李四, value：88
key:王五, value：99
------------元素数量-------------
my_dict 的数量：3
------------清空-------------
清空前：{'张三': 77, '李四': 88, '王五': 99}
清空后：{}
"""

练习题

练习题：有如下员工信息，请使用字典完成数据的记录
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元

姓名  部门  工资  级别
张三  科技  3000  1
李四  市场  5000  2
王五  市场  7000  3
赵六  科技  4000  1
钱七  市场  6000  2

{
 '姓名': {'部门', '工资', '级别'}
}

emp = {
    '张三': {'部门': '科技', '工资': 3000, '级别': 1},
    '李四': {'部门': '市场', '工资': 5000, '级别': 2},
    '王五': {'部门': '市场', '工资': 7000, '级别': 3},
    '赵六': {'部门': '科技', '工资': 4000, '级别': 1},
    '钱七': {'部门': '市场', '工资': 6000, '级别': 2}
}
print(f'全体员工信息如下：\n {emp}')
for em in emp:
    employ = emp[em]
    level = employ['级别']
    if level == 1:
        employ['级别'] = level + 1
        employ['工资'] = employ['工资'] + 1000

print(f'操作后：\n {emp}')

七、数据容器的通用操作

"""
容器的通用操作
"""

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# len元素个数
print('-------------元素个数------------')
print(f"列表 元素个数有:{len(my_list)}")
print(f"元组 元素个数有:{len(my_tuple)}")
print(f"字符串元素个数有:{len(my_str)}")
print(f"集合 元素个数有:{len(my_set)}")
print(f"字典 元素个数有:{len(my_dict)}")

# max最大元素
print('-------------最大元素------------')
print(f"列表 最大的元素是:{max(my_list)}")
print(f"元组 最大的元素是:{max(my_tuple)}")
print(f"字符串最大的元素是:{max(my_str)}")
print(f"集合 最大的元素是:{max(my_set)}")
print(f"字典 最大的元素是:{max(my_dict)}")

# min最小元素
print('-------------最小元素------------')
print(f"列表 最小的元素是:{min(my_list)}")
print(f"元组 最小的元素是:{min(my_tuple)}")
print(f"字符串最小的元素是:{min(my_str)}")
print(f"集合 最小的元素是:{min(my_set)}")
print(f"字典 最小的元素是:{min(my_dict)}")

# 容器转列表
print('-------------容器转列表------------')
print(f"列表 转列表:{list(my_list)}")
print(f"元组 转列表:{list(my_tuple)}")
print(f"字符串 转列表:{list(my_str)}")
print(f"集合 转列表:{list(my_set)}")
print(f"字典 转列表:{list(my_dict)}")

# 容器转元组
print('-------------容器转元组------------')
print(f"列表 转元组:{tuple(my_list)}")
print(f"元组 转元组:{tuple(my_tuple)}")
print(f"字符串 转元组:{tuple(my_str)}")
print(f"集合 转元组:{tuple(my_set)}")
print(f"字典 转元组:{tuple(my_dict)}")

# 容器转字符
print('-------------容器转字符------------')
print(f"列表 转字符串:{str(my_list)}")
print(f"元组 转字符串:{str(my_tuple)}")
print(f"字符串 转字符串:{str(my_str)}")
print(f"集合 转字符串:{str(my_set)}")
print(f"字典 转字符串:{str(my_dict)}")

# 容器转集合
print('-------------容器转集合------------')
print(f"列表 转集合:{set(my_list)}")
print(f"元组 转集合:{set(my_tuple)}")
print(f"字符串 转集合:{set(my_str)}")
print(f"集合 转集合:{set(my_set)}")
print(f"字典 转集合:{set(my_dict)}")

# 排序
print('-------------正序排序------------')
my_list = [2, 3, 4, 5, 1]
my_tuple = (2, 3, 4, 5, 1)
my_str = "fbcgdae"
my_set = {2, 3, 4, 5, 1}
my_dict = {"key5": 5, "key4": 4, "key1": 1, "key2": 2, "key3": 3}
print(f"列表 正序:{sorted(my_list)}")
print(f"元组 正序:{sorted(my_tuple)}")
print(f"字符 正序:{sorted(my_str)}")
print(f"集合 正序:{sorted(my_set)}")
print(f"字典 正序:{sorted(my_dict)}")
print('-------------倒序排序------------')
print(f"列表 倒序:{sorted(my_list, reverse=True)}")
print(f"元组 倒序:{sorted(my_tuple, reverse=True)}")
print(f"字符 倒序:{sorted(my_str, reverse=True)}")
print(f"集合 倒序:{sorted(my_set, reverse=True)}")
print(f"字典 倒序:{sorted(my_dict, reverse=True)}")