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)}')
320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
