05 python数据容器

5.1 数据容器认识

5.2 python列表

5.2.1 列表的定义

'''
演示数据容器之：list
语法：[元素，元素，....]
'''

#定义一个列表List
List = ['itheima','uityu','gsdfg']
List1 = ['itheima','6666','True']
print(List)
print(List1)
print(type(List))
print(type(List1))

#定义嵌套列表
List2 = [[1,2,3],['dadd','dadad','fefefe']]
print(List2)
print(type(List2))

5.2.2 列表的下标索引

'''
通过下标索引取出对应位置的数据
'''


#定义列表
List = ['tom','python','lalal']

#列表[下标索引]，从前向后从0开始，每次+1，   从后往前从-1开始，每次-1
print(List[0])
print(List[1])
print(List[-1])

#定义嵌套列表
List1 = [[1,2,3],[123,333,444]]
#取出嵌套索引的元素
print(List1[0][1])
print(List1[1][-2])

5.2.3 列表的常用操作方法

'''
演示数据容器之：List列表常用操作
'''

my_list = [11111,'num',['qqqqq',676767]]

#1.1 查找某元素在列表内的下标索引                           列表.index
index = my_list.index(['qqqqq',676767])
print(f'[qqqqq,676767]在列表中的下标索引是：{index}')

# 1.2如果查找的元素不存在，会报错
# index = my_list.index(0000)
# print(f'0000在列表中的下标索引是：{index}')

#2 修改特定下标索引的值
my_list[0] = 9999
print(f'列表被修改后的值是：{my_list}')

#3 在特定位置插入新元素                                    列表.insert
my_list.insert(1,777777)
print(f'列表插入元素后它的结果是：{my_list}')

#4 在元素列表中追加一个元素，在列表尾部加入新元素               列表.append
my_list.append('学python')
print(f'列表在追加元素后，结果是：{my_list}')

#5 在元素列表中追加一个新列表，在列表尾部加入新列表              列表.extend
my_list2 = [1,'best']
my_list.extend(my_list2)
print(f'列表在追加列表后，结果是：{my_list}')

#6 删除列表中的元素（两种方法）
my_list3 = [11111,'num',['qqqqq',676767]]
#6.1 del方法  列表[下标]
del my_list3[2][1]
print(f'del方法删除后的结果是{my_list3}')
#6.2 方法2： 列表.pop(下标)                                 列表.pop
my_list3 = [11111,'num',['qqqqq',676767]]
my_list3.pop(1)
print(f'列表.pop(下标)方法删除后的结果是{my_list3}')


#7  删除某元素在列表的第一个匹配项                             列表.remove
my_list4 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
my_list4.remove('num')
my_list4.remove('num')
my_list4.remove('num')
print(f'通过remove方法移除元素后，列表的结果是：{my_list4}')

#8 清空列表                                                列表.clear
my_list4.clear()
print(f'列表被清空了，结果是：{my_list4}')

#9  统计列表内某元素的数量                                    列表.count
my_list5 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
count = my_list5.count('num')
print(f'列表中num的数量为：{count}')

#统计列表中有多少元素                                         len（列表）
my_list6 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
count = len(my_list6)
print(f'列表中的元素数量为：{count}')

5.2.4 列表的基础操作案例

age = [21,25,21,23,22,20]

#追加31到列表末尾
age.append(31)
print(age)

#追加新列表到列表尾部
age1 = [29,33,30]
age.extend(age1)
print(age)

#取出第一个元素
age.pop(0)
print(age)

#取出最后一个元素
del age[7]
print(age)

#查看31在列表中的下表位置
index = age.index(31)
print(index)

5.3 元组

5.3.1 元组的定义和操作

'''
演示tuple元组的定义和操作
'''
#定义元祖
t1 = (1,'hello',True)
t2 = ()
t3 = tuple()
print(f't1的类型是{type(t1)},内容是{t1}')
print(f't2的类型是{type(t2)},内容是{t2}')
print(f't3的类型是{type(t3)},内容是{t3}')

#定义单个元素的元素(单个元素需要带上单个逗号)
t4 = (1,)
t5 = (2)
print(f't4的类型是{type(t4)},内容是{t4}')
print(f't5的类型是{type(t5)},内容是{t5}')

# 元组的嵌套
t6 = ((1,2,3),(9,0,34))
print(f't6的类型是{type(t6)},内容是{t6}')

# 下标索引取出内容
num = t6[1][1]
print(f'从嵌套元祖中取出的数据是：{num}')

#元组的操作：index查找方法
t1 = (1,0,'hello',True,False,True,False,True,False,'hhhh')
index = t1.index(False)
print(f'True在t1中的下标是：{index}')

#元组的操作： count统计方法
num = t1.count(True)
print(f'在元祖中统计True的数量有{num}个')

#元祖的操作：len函数统计元组元素的的数量
num = len(t1)
print(f'元祖的数量有：{num}个')

#元组的遍历 while循环
index = 0
while index < len(t1):
    print(f"元组的元素有：{t1[index]}")
    index += 1

#元组的遍历 for循环
for i in t1:
    print(f"2元组的元素有：{i}")

# 定义一个元组
#元组的元素不可修改，但元组内列表内容元素可以修改
t10 = (1,2,[3333,5555])
print(f't10的内容是：{t10}')
t10[2][0] = '黑马python'
t10[2][1] = '西八'
print(f't10的内容是：{t10}')

5.3.2 元组的基本操作案例

#定义元组
information = ('周几轮',18,['basketball','rap'])

#查询年龄所在下标位置
index = information.index(18)
print(f'年龄所在下标位置：{index}')

#查询学生姓名
name = information[0]
print(f"学生姓名是{name}")

#删除学生爱好basketball
del information[2][0]
print(information)

#增加爱好dance
information[2].append('dance')
print(information)

5.4 字符串

5.4.1 字符串的定义和操作

'''
演示以数据容器的角色，学习字符串的相关操作
'''

my_str = 'python learning time'
#通过下标索引取值
a = my_str[3]
b = my_str[-6]
print(f'下标为2的值是：{a}，下标为-6的值是{b}')

# index方法
c = my_str.index('learning')
print(f'learing的起始下标是：{c}')

#replace方法
new_my_str = my_str.replace("i",'程序')
print(f'{my_str}替换i后结果是：{new_my_str}')

#split方法 字符串的分割
my_str3 = 'aaabbaddaeeaggakka'
my_str3_list = my_str3.split('a')
print(f'字符串{my_str3}按照a进行split分割后得到：{my_str3_list}，类型是：{type(my_str3_list)}')

#strip方法  去除字符串收尾元素
my_str = '  123python   learning   time21   '
new_my_str = my_str.split() #不传入参数，则去除首尾空格
print(new_my_str)
new_my_str2 = my_str.split('12')
print(new_my_str2)

#统计字符串某字符串出现的次数
my_str = '  123python   learning   time21   '
count = my_str.count('2')
print(f'2出现的次数是{count}')

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

#字符串的while的循环遍历
my_str2 = 'whoiam'
index = 0
while index < len(my_str2):
    print(my_str2[index])
    index += 1

#字符串的for的循环遍历
for i in my_str3:
    print(i)

5.4.2字符串的大小比较

'''
演示字符串的大小比较
'''

#abc 比较abd
print(f"abc 小于 abd的结果是：{'abd' > 'abc'}")

#ab比较a
print(f"a小于 ab的结果是：{'ab' > 'a'}")

#ab比较A
print(f"A小于 a的结果是：{'a' > 'A'}")

#key1比较key2
print(f"key1小于 key2的结果是：{'key2' > 'key1'}")

5.4.3字符串的基础操作案例

str = 'itheima itcast boxuegu'

#统计字符串内it数量
count = str.count('it')
print(f'字符串内it数量有：{count}')

#将空格替换为|
new_str = str.replace(' ','|')
print(f'将字符串{str}内空格替换为|的结果为{new_str}')

#按照|字符分割为列表
new_str_list = new_str.split("|")
print(new_str_list)

5.5 对数据容器进行切片操作

5.5.1 演示对序列进行切片操作

'''
演示对序列进行切片操作
'''

#对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
re = my_list[1:4]       #步长默认1，可以不写
print(f'结果1：{re}')

#对tuple进行切片，最开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
re2 = my_tuple[:]       #步长默认1，可以不写
print(f'结果2：{re2}')

#对str进行切片，最开始，到最后结束，步长2
my_str = '0123456'
re3 = my_str[::2]
print(f'结果3：{re3}')

#对str进行切片，最开始，到最后结束，步长-1
my_str = '0,1,2,3,4,5,6'
re4 = my_str[::-1]
print(f'结果4：{re4}')

#对列表进行切片，从3开始，1结束，步长-1
my_list = [0,1,2,3,4,5,6,7,8,9,100]
re5 = my_list[3:1:-1]
print(f'结果5：{re5}')



#对元祖进行切片，最开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6,3333,7,89,99,99999)
re6 = my_tuple[::-2]
print(f'结果6：{re6}')

5.5.2 对数据容器操作的基础案例

str = '万过薪月，员序程马黑来，nohtyp学'

#方法一   切片，倒序取出
re = str[9:4:-1]
print(re)

#方法二  倒序取出，然后切片
re2 = str[::-1][9:14]
print(re2)

#方法三，split分割，replace分割“来”为空，倒序字符串
re3 = str.split('，')[1].replace('来','')[::-1]
print(re3)

5.6 集合

5.6.1 集合的定义和操作

'''
演示数据容器集合
'''
#定义集合  集合会去重，不支持重复元素
my_set = {'sss','qqq','wwww','rrr','ww'}
my_set_empty = set() #定义空集合
print(f'{my_set}，{type(my_set)}')
print(f'{my_set_empty}，{type(my_set_empty)}')

#添加新元素
my_set.add("python")
print(f'{my_set}')

#移除元素
my_set.remove('python')
print(f'{my_set}')

#从集合中随机取出元素
element =my_set.pop()
print(f'{my_set},{element}')

#清空集合
my_set.clear()
print(f'{my_set}')

#取出两个集合的差集  会产生新集合，集合1和2不变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.difference(set2)
print(f'{set1},{set2},{set3}')

#消除两个集合的差集  不会产生新集合，集合1变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.difference_update(set2)
print(f'{set1},{set2}')

#两个集合合并    会产生新集合，集合1和2不变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.union(set2)
print(f'{set1},{set2},{set3}')

#统计集合数量
count = len(set3)
print(f'{count}')

#集合的遍历
#集合不支持下标索引，不可以while循环
for i in set3:
    print(f"{i}")


'''
集合的基本操作案例
'''
my_list = [1,2,3,4,5,6,7,8,9,0,5,6,5,3,21,1,334,4,3,2,1]

#定义空集合
set = set()

#通过for循环遍历列表
#将列表中元素添加到集合中
for i in my_list:
    print(f'{i}')
    set.add(i)
print(f"{set}")

5.7 字典

5.7.1 字典的定义和操作

'''
演示字典的定义
'''

#定义字典  字典中的key不可以重复 {key，value}
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
#定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f'{my_dict},{type(my_dict)},\n'
      f'{my_dict2},{type(my_dict2)},\n'
      f'{my_dict3},{type(my_dict3)}')

#从字典中基于key获取value
score = my_dict['林俊杰']
print(f'{score}')

#字典的嵌套，key，value可以是任意数据类型，（key不可为字典）
stu_score_dict = {
    '王力宏':{
        'aa':77,
        'bb':55,
        'cc':66
    },
    '周杰伦':{
        'aa': 47,
        'bb': 555,
        'cc': 106
    },
    '林俊杰':{
        'aa': 127,
        'bb': 545,
        'cc': 876
    }
}
print(f'{stu_score_dict}')

#查看学生成绩
score = stu_score_dict['周杰伦']['aa']
print(f'{score}')

'''
字典的常用操作
'''
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
#新增元素
my_dict['张学友'] = 62
print(f'{my_dict}')

#更新元素
my_dict['周几轮'] = 9
print(f'{my_dict}')

#删除元素

score = my_dict.pop('周几轮')
print(f'{my_dict}，{score}')

#清空元素
my_dict.clear()
print(f'{my_dict}')

#遍历字典
#获取全部key
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
keys = my_dict.keys()
print(f'{keys}')
# 方式1  通过获取所有key来遍历字典
for key in keys:
    print(f'{key},{my_dict[key]}')

#方式2 通过直接对字典进行for循环，每一次循环得到key
for key in my_dict:
    print(f'222\t{key},aaaa\t{my_dict[key]}')

#统计字典内的元素数量
num = len(my_dict)
print(f'{num}')


'''
字典的基本操作案例
'''

#定义字典
my_dict = {
    '王力宏':{
        '部门':'科技部',
        '工资':3000,
        '级别':1
    },
    '周杰伦':{
        '部门': '市场部',
        '工资': 5000,
        '级别': 2
    },
    '林俊杰':{
        '部门': '市场部',
        '工资': 7000,
        '级别': 3
    },
    '张学友':{
        '部门': '科技部',
        '工资': 4000,
        '级别': 1
    },
    '刘德华':{
        '部门': '市场部',
        '工资': 6000,
        '级别': 2
    }
}
#遍历字典，找到name这个key
for name in my_dict:
    #判断name key对应的级别是否为1
    if my_dict[name]['级别'] == 1:
        #如果是级别加1，工资加1000
            my_dict[name]['级别'] += 1
            my_dict[name]['工资'] += 1000
print(f'{my_dict}')

5.8 数据容器的通用操作

'''
演示数据容器的通用操作
'''

list1  =  [17,27,30,4,45]
tuple1 =  (10,2,3,44,5)
str1   =  'abcdefghij'
set1   =  {1,2,3,4,5}
dict1  =   {'key8':9,'key2':8,'key6':7,'key4':6,'key7':4}

#len元素个数
num = len(list1)
print(f'{num}')

num = len(tuple1)
print(f'{num}')

num = len(str1)
print(f'{num}')

num = len(set1)
print(f'{num}')

num = len(dict1)
print(f'{num}')

#max 最大元素
print(f'列表 最大的元素是：{max(list1)}')
print(f'元组 最大的元素是：{max(tuple1)}')
print(f'字符串最大的元素是：{max(str1)}')
print(f'集合 最大的元素是：{max(set1)}')
print(f'字典 最大的元素是：{max(dict1)}')

#min最小元素
print(f'列表 最小的元素是：{max(list1)}')
print(f'元组 最小的元素是：{max(tuple1)}')
print(f'字符串最小的元素是：{max(str1)}')
print(f'集合 最小的元素是：{max(set1)}')
print(f'字典 最小的元素是：{max(dict1)}')

#类型转换：容器转列表
print(f'列表   列表转换为列表的结果是：{list(list1)}')
print(f'元组   元组转换为列表的结果是：{list(tuple1)}')
print(f'字符串转字符串换为列表的结果是：{list(str1)}')
print(f'集合   集合转换为列表的结果是：{list(set1)}')
print(f'字典   字典转换为列表的结果是：{list(dict1)}')

#类型转换：容器转元组
print(f'列表   列表转换为元组的结果是：{tuple(list1)}')
print(f'元组   元组转换为元组的结果是：{tuple(tuple1)}')
print(f'字符串转字符串换为元组的结果是：{tuple(str1)}')
print(f'集合   集合转换为元组的结果是：{tuple(set1)}')
print(f'字典   字典转换为元组的结果是：{tuple(dict1)}')

#类型转换：容器转字符串
print(f'列表   列表转换为字符串的结果是：{str(list1)}')
print(f'元组   元组转换为字符串的结果是：{str(tuple1)}')
print(f'字符串转字符串换为字符串结果是：  {str(str1)}')
print(f'集合   集合转换为字符串的结果是：{str(set1)}')
print(f'字典   字典转换为字符串的结果是：{str(dict1)}')

#类型转换：容器转集合
print(f'列表   列表转换为集合的结果是：{set(list1)}')
print(f'元组   元组转换为集合的结果是：{set(tuple1)}')
print(f'字符串  字符串换为集合的结果是：{set(str1)}')
print(f'集合   集合转换为集合的结果是：{set(set1)}')
print(f'字典   字典转换为集合的结果是：{set(dict1)}')

#容器的通用排序功能 排序后结果会变成列表对象
print(f'列表   列表排序的结果是：{sorted(list1)}')
print(f'元组   元组排序的结果是：{sorted(tuple1)}')
print(f'字符串  字符排序的结果是：{sorted(str1)}')
print(f'集合   集合排序的结果是：{sorted(set1)}')
print(f'字典   字典排序的结果是：{sorted(dict1)}')

#反向排序
print(f'列表   列表反向排序的结果是：{sorted(list1,reverse=True)}')
print(f'元组  元组反向排序的结果是：{sorted(tuple1,reverse=True)}')
print(f'字符串  字符反向排序的结果是： {sorted(str1,reverse=True)}')
print(f'集合   集合反向排序的结果是： {sorted(set1,reverse=True)}')
print(f'字典   字典反向排序的结果是：{sorted(dict1,reverse=True)}')