Python大数据之python学习总结day07-08——数据容器汇总

数据容器含义: 能够存储多个元素的数据类型,叫数据容器

常见的数据容器:  列表(list)  元组(tuple)  字符串(str)   集合(set)   字典(dict)

各个容器符号
	列表: 中括号 []   举例: [元素1,元素2,元素3,...]
	元组: 小括号 ()   举例: (元素1,元素2,元素3,...)
	字符串: 引号 '内容'/"内容"/'''内容'''/"""内容"""       注意: 在字符串中每个字符都是一个元素
	集合: 大括号 {}   举例: {元素1,元素2,元素3,...}
	字典: 大括号 {}   举例: {key:value , key:value ,...}  注意: 每个键值对是一个元素	

	

方法和函数对比

知识点:

方法: 本质是一个函数,只是这个函数放到class xxx 类中

注意: 可以说方法一定是一个函数,但是不能说函数一定是一个方法

示例:

# 生成随机数
# 自己不会写这个功能,而且python已经提供了,拿过来用
import random

num = random.randint(1, 10)
print(num)


# 定义一个计算两个数和的函数
def get_sum(a, b):
    return a + b


he = get_sum(1, 10)
print(he)

"""
方法: 本质是一个函数,只是这个函数放到class xxx 类中
上述random中的randint本质是一个函数,一般称之为方法
自己写的get_sum就是一个函数
"""

列表的定义

知识点:

空列表:  列表名=[] 或者 列表名=list()

非空列表: 列表名=[元素1,元素2,元素3,...]

列表支持嵌套

示例:

# 定义空列表
list1 = []
print(list1)
list2 = list()
print(list2)

# 定义非空列表
list3 = ['a', 'b', 'c']
print(list3)

# 列表的嵌套
class1_list = ['张三', '李四', '王五']
print(class1_list)
class2_list = ['赵六', '田七', '周八']
print(class2_list)
school_list = [class1_list, class2_list]
print(school_list)

列表的下标索引

知识点:

下标索引: 就是咱们说的编号,也就是容器中每个元素的编号

正索引: 从0开始,从左到右,依次递增

负索引: 从-1开始,从右到左,依次递减

根据下标索引查找对应元素格式:  列表名[索引]

示例:

# 下标索引: 就是列表中每个元素的编号
# 需求1: 定义列表存储5个学生姓名
name_list = ['张三', '李四', '王五', '赵六', '田七']

# 需求2:查找第一个列表中第一个姓名
name = name_list[0]
print(name)
# 当然也可以使用负索引查找
print(name_list[-5])

# 需求3: 查找最后一个姓名
print(name_list[-1])
# 当然也可以使用正索引查找
print(name_list[4])
# 注意: 因为正索引从0开始数,有时候很容易数错,如果访问了不存在的索引就会包索引越界异常
# print(name_list[5])  # IndexError: list index out of range

# 需求4: 查找索引为2位置的姓名
print(name_list[2])

列表的增删改查

列表是可变类型

知识点:

增:添加元素
	列表名.append(元素): 把指定元素追加到列表中
	列表名.extend(容器): 把指定容器中每个元素取出,依次放到当前列表中
	列表名.insert(索引,元素): 把指定元素插入到列表指定索引位置
	
删:删除元素
	del 列表名[索引]: 把指定索引位置的元素删除
	列表名.pop(索引): 把指定索引位置的元素删除
	列表名.remove(元素): 把指定元素直接删除
	列表名.clear() : 清空当前列表
	del 列表名: 删除当前列表
	
改:修改元素
	列表名[索引] = 新元素
	
查:查找元素
	列表名[索引]: 查找指定索引位置上的元素
	列表名.count(元素): 查找指定元素在列表中出现的次数    
	列表名.index(元素): 查找指定元素在列表中的索引位置    注意: 如果不存在就报错
	len(列表名): 查询当前列表中所有元素的总个数

示例:

"""
因为方法名都是见名知意的,所以建议同学们记重点单词
添加元素相关单词:
    append:附加
    extend:扩展
    insert:插入
查询元素相关单词:
    count: 计数
    index: 索引
    length: 长度
删除元素相关单词
    delete:删除
    pop : 弹出
    remove:移除
    clear: 清空
"""
# 1.演示添加功能
# 需求:已知空列表,要求使用三种方式添加元素到列表中
name_list = []
# 需求:依次添加'张三','李四'到列表中
name_list.append('张三')
name_list.append('张三')
name_list.append('李四')
print(name_list)
# 需求: 一次性添加'王五','赵六','田七'到列表中
name_list.extend(['王五', '赵六', '田七'])
print(name_list)
# 需求: 把'周八'直接插入到第一个位置
name_list.insert(0, '周八')
print(name_list)

# 2.演示查询功能
# 需求: 查询'张三'在列表中个数
print(name_list.count('张三'))
# 需求: 查询'周八'的索引
print(name_list.index('周八'))
# 注意: index方法如果查询的元素不存在会报错
# print(name_list.index('周一'))# ValueError: '周一' is not in list
# 需求: 查询列表中元素个数
print(len(name_list))
# 需求: 查询最后元素内容
print(name_list[-1])

# 3.演示修改功能
# 需求: 修改最后元素内容为'钱九'
name_list[-1] = '钱九'
# 再次查看最后一个元素内容
print(name_list[-1])

# 4.演示删除功能
# 删除第一个元素
del name_list[0]
print(name_list)
# 删除最后一个元素
name_list.pop(-1)
print(name_list)
# 删除张三这个元素
name_list.remove('张三')
print(name_list)
# 清空列表中所有元素
name_list.clear()
print(name_list)
# 删除name_list这个列表
del name_list
print(name_list)  # 报错说明删除成功,NameError: name 'name_list' is not defined

列表的遍历

知识点:

1.for循环遍历
	for 元素名 in 列表:
		操作元素
		
2.while循环遍历
	核心思想: 利用while变量作为列表的索引使用
	index = 0
	while index < len(列表):
		元素名 = 列表[index]
		操作元素
		index+=1
		
3.对比
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
    while循环可以自定循环条件，并自行控制
    for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
    while循环可以通过条件控制做到无限循环
    for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
    while循环适用于任何想要循环的场景
    for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

示例:

# 分别使用while循环和for循环遍历列表
# 定义非空列表
name_list = ['张三', '李四', '王五']
# while循环遍历(前提该容器要有索引)
# 核心思想: 利用while中变量作为列表的索引使用
# 1.定义初始变量
index = 0
# 2.条件判断
while index < 3:
    # 3.循环体
    # 根据索引去列表中找对应的元素并打印
    element = name_list[index]
    print(element)
    # 4.条件控制
    index += 1
print('-----------------------------')
# for循环遍历
for element in name_list:
    print(element)

列表的特点

可以存储多个元素
可以存储不同类型数据
支持下标索引
支持修改
支持重复
支持for循环
支持while循环

元组

元组的定义

知识点:

定义空元组:  元组名 = ()   或者  元组名 = tuple()

定义非空元组:  元组名 = (元素1,元素2,元素3,...)   注意: 如果只有一个元素需要加逗号

示例:

"""
替换: ctrl+R
查找: ctrl+F
"""
# 定义空元组
tuple1 = ()
print(tuple1, type(tuple1))
tuple2 = tuple()
print(tuple2, type(tuple2))

# 定义非空元组
tuple3 = ('a', 'b', 'c')
print(tuple3, type(tuple3))

# 注意: 如果元组中是一个元素,必须加逗号,
tuple4 = ("张三",)
print(tuple4, type(tuple4))

# 元组的嵌套
class1_tuple = ('张三', '李四', '王五')
print(class1_tuple)
class2_tuple = ('赵六', '田七', '周八')
print(class2_tuple)
school_tuple = (class1_tuple, class2_tuple)
print(school_tuple, type(school_tuple))

元组的下标索引

知识点:

下标索引: 就是咱们说的编号,也就是容器中每个元素的编号

正索引: 从0开始,从左到右,依次递增

负索引: 从-1开始,从右到左,依次递减

根据下标索引查找对应元素格式:  元组名[索引]

示例:

# 需求:定义非空元组,存储4个姓名
name_tuple = ('张三', '李四', '王五', '赵六')
# 需求:打印第一个位置的姓名
print(name_tuple[0])  # 正索引
print(name_tuple[-4])  # 负索引
# 需求: 打印最后一个位置的姓名
print(name_tuple[-1])  # 负索引
print(name_tuple[3])  # 正索引
# 注意: 如果访问了不存在的索引就会报错
# print(name_tuple[4])  # IndexError: tuple index out of range

元组的常用操作

元组是不可变类型

知识点:

元组是不支持修改(元素的增删改操作不支持的)

查:查找元素
	元组名[索引]: 查找指定索引位置上的元素
	元组名.count(元素): 查找指定元素在元组中出现的次数    
	元组名.index(元素): 查找指定元素在元组中的索引位置    注意: 如果不存在就报错
	len(元组名): 查询当前元组中所有元素的总个数

基础示例:

# 因为元组是不支持修改的,所以只有查询操作
# 需求: 定义非空元组
t1 = ('张三', '李四', '王五', '赵六', '李四')
# 注意: 元组不支持修改
# t1[0] = '田七' # 报错
print(t1[0])
# index(): 查询指定元素在元组中的索引,不存在就报错
# 需求: 查询'李四'的索引
index = t1.index('李四')
print(index)
# count(): 查询指定元素在元组中的个数,不存在就返回0
count = t1.count('李四')
print(count)
# len(): 查询元组中元素的总个数
print(len(t1))

元组嵌套列表:

# id(数据): 查看数据的内存地址

# 定义元组嵌套列表
t1 = (10, 20, ['张三', '李四'])
# 需求: 获取元组中的每个元素
print(t1[0], id(t1[0]))  # 10
print(t1[1], id(t1[1]))  # 20
print(t1[2], id(t1[2]))  # ['张三', '李四']
# 测试元组中每个元素本身是否可以修改? 结论:元素整体不能修改
# t1[0] = 11 # 报错
# t1[1] = 22 # 报错
new_list = [33, 44]
print(new_list, id(new_list))
# t1[2] = new_list # 报错


# 注意: 列表本身是支持修改的
t1[2][0] = '王五'
t1[2][1] = '赵六'
print(t1[2], id(t1[2]))

元组的遍历

知识点:

1.for循环遍历
	for 元素名 in 元组:
		操作元素
		
2.while循环遍历
	核心思想: 利用while变量作为元组的索引使用
	index = 0
	while index < len(元组):
		元素名 = 元组[index]
		操作元素
		index+=1
		
3.对比
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
    while循环可以自定循环条件，并自行控制
    for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
    while循环可以通过条件控制做到无限循环
    for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
    while循环适用于任何想要循环的场景
    for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

示例:

# 定义非空元组
name_tuple = ('张三', '李四', '王五', '赵六')
# for循环遍历元组
for name in name_tuple:
    print(name)

print('--------------------------')
# while循环遍历元组
# 利用元组的索引找每个元素
index = 0
while index < len(name_tuple):
    name = name_tuple[index]
    print(name)
    index += 1

元组的特点

可以存储多个元素
可以存储不同类型数据
支持下标索引
不支持修改
支持重复
支持for循环
支持while循环

字符串[重点]

字符串的定义

知识点:

空字符串:字符串名=str() 字符串名=''  或者 字符串名=""   或者  字符串名='''''' 或者  字符串名=""""""

非空字符串:字符串名='内容' 或者 字符串名="内容"   或者  字符串名='''内容''' 或者  字符串名="""内容"""

示例:

# 定义空字符串
s = str()
s1 = ''
s2 = ""
s3 = ''''''
s4 = """"""
# 定义非空字符串
s5 = '传智'
s6 = "黑马"
s7 = '''传智
教育
'''
s8 = """黑马
程序员
"""
print(s)
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)
print(s7)
print(s8)

字符串的下标索引

知识点:

下标索引: 就是咱们说的编号,也就是容器中每个元素的编号

正索引: 从0开始,从左到右,依次递增

负索引: 从-1开始,从右到左,依次递减

根据下标索引查找对应元素格式:  字符串[索引]

示例:

# 需求: 定义非空字符串
name = '黑马程序员'
# 需求: 查询第一个位置的元素/字符
print(name[0])
print(name[-5])
# 需求: 查询最后一个位置的元素/字符
print(name[-1])
print(name[4])
# 注意: 如果访问了不存在的索引就会报错: 索引越界异常
print(name[5])  # IndexError: string index out of range

字符串的常用操作

字符串是不可变类型

知识点:

字符串是不支持修改的(元素的增删改操作不支持的)

类似列表和元组的查询操作:
	字符串[索引]: 查找指定索引位置上的元素
	字符串名.count(元素): 查找指定元素在字符串中出现的次数    
	字符串名.index(元素):从左往右查找指定元素在字符串中的索引位置,返回第一个正索引,如果不存在就报错
	len(字符串名): 查询当前元组中所有元素的总个数
	
特有查询操作:
   字符串名.rindex(元素):从右往左查找指定元素在字符串中的索引位置,返回第一个正索引,如果不存在就报错
   字符串名.find(元素):从左往右查找指定元素在字符串中的索引位置,返回第一个正索引,不存在就返回-1
   字符串名.rfind(元素):从右往左查找指定元素在字符串中的索引位置,返回第一个正索引,不存在就返回-1
	
其他特有操作:
	replace:替换
	split: 切割
	join: 连接
	strip: 去除
	startswitch: 以...开头
	endswitch: 以...结尾
	upper: 大写
	lower: 小写

查询操作:

# 需求: 定义非空字符串
s1 = '黑马程序员是传智教育集团旗下的线下IT教育品牌'
# 需求: 查找第二个位置上的字符
print(s1[1])
# 需求: 查询该字符串中有多少个字符
print(len(s1))
# 需求: 查询'育'出现的次数
print(s1.count('育'))
# 需求: 查询'育'出现的索引位置
print(s1.index('育'))  # 从左往右找,返回第一个正索引  9
# 注意: 如果访问了不存在就会报错
# print(s1.index('你')) # 报错 ValueError: substring not found

# 拓展
# 和列表元组查询操作不同的查询操作
print(s1.rindex('育'))  # 从右往左找,返回第一个正索引  20
# print(s1.rindex('你')) # 报错 ValueError: substring not found

# 因为index和rindex如果找不到就报错,会影响程序继续执行,字符串中提供了find和rfind解决了此问题
print(s1.find('育')) # 9
print(s1.find('你'))  # 不报错,如果找不到直接返回-1,不影响后续代码执行
print(s1.rfind('育')) # 20
print(s1.rfind('你'))  # 不报错,如果找不到直接返回-1,不影响后续代码执行

其他特有操作:

"""
大字符串.replace(旧子串,新子串): 把大字符串中所有的旧子串替换为新子串
"""
# 需求: 聊天敏感词替换,举例: '你TMD的哦'变成'你***的哦'
s1 = '你TMD的哦'
s2 = s1.replace('TMD', '***')
print(s2)
# 思考:如果多个敏感词怎么替换? 使用链式编程
# 举例: '你TMD的哦,真sb呀' 变成 你***的哦,真**呀
s3 = '你TMD的哦,真sb呀'
s4 = s3.replace('TMD', '***').replace('sb', '**')
print(s4)

"""
大字符串.split(分隔符,切几次): 根据指定分隔符把一个大字符串切割成多个小字符串,放到列表中返回
                           注意: 默认切割所有
"""
# 需求: 切水果案例
# 举例: 已知大字符串'苹果-梨-橘子-香蕉',把每个水果单独切割出来房东容器中返回
s5 = '苹果,梨,橘子,香蕉'
fruit_list = s5.split(',')
print(fruit_list, type(fruit_list))

"""
'分隔符',join(可迭代对象): 使用指定分隔符把可迭代对象中每个元素连接到一起,生成字符串返回
"""
s6 = ','.join(['苹果', '梨', '橘子', '香蕉'])
print(s6, type(s6))


"""
大字符串.strip(): 默认去除大字符串两端的空白,当然也可以指定要去除两端的字符
大字符串.lstrip(): 默认去除大字符串左端的空白
大字符串.rstrip(): 默认去除大字符串右端的空白
"""
name = '张三'
user_name = ' 张三     '
print(name == user_name)  # False
print(name == user_name.strip())  # True
pwd = '123'
user_pwd = '%123%'
print(pwd == user_pwd)  # False
print(pwd == user_pwd.strip('%'))  # True

"""
大字符串.startswith(子串): 判断大字符串是否以指定的子串开头
大字符串.endswith(子串): 判断大字符串是否以指定的子串结尾
"""
# 定义姓名列表,存储多个姓名
name_list = ['张一山', '郭靖', '张无忌', '张翠山', '黄蓉']
# 遍历列表,判断如果以张开头并且以山结尾的打印出来
for name in name_list:
    if name.startswith('张') and name.endswith('山'):
        print(name)

"""
字符串.upper(): 把字符串中所有的字母都转换为大小大写字母
字符串.isupper() : 判断是否是大写
字符串.lower(): 把字符串中所有的字母都转换为大小小写字母
字符串.islower() : 判断是否是小写
"""
# 定义字符串
ss = 'abc123CDE中国'
# 把所有字母转为大写
print(ss.upper())
print('ABC'.isupper())
# 把所有字母转为小写
print(ss.lower())
print('abc'.islower())

字符串的遍历

知识点:

1.for循环遍历
	for 元素名 in 字符串:
		操作元素
		
2.while循环遍历
	核心思想: 利用while变量作为字符串的索引使用
	index = 0
	while index < len(字符串):
		元素名 = 字符串[index]
		操作元素
		index+=1
		
3.对比
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
    while循环可以自定循环条件，并自行控制
    for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
    while循环可以通过条件控制做到无限循环
    for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
    while循环适用于任何想要循环的场景
    for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

示例:

# 定义字符串
name = '黑马程序员'
# for循环遍历
for n in name:
    print(n)

print('-------------')
# while循环遍历
# 核心: 利用while循环变量作为字符串的下标索引
index = 0
while index < len(name):
    n = name[index]
    print(n)
    index += 1

字符串的特点

可以存储多个元素
只能存储字符串类型
支持下标索引
不支持修改
支持重复
支持for循环
支持while循环

序列[重点]

知识点:

序列含义: 有下标索引,元素有序,可重复的一类数据容器

序列分类: 列表  元组  字符串

序列特点: 除了有下标索引,有序,可以重复,支持while循环外,还有最大的特点是支持切片操作

切片格式: 序列[开始索引:结束索引:步长]
		切片解释: 
            开始索引(可以留空,代表从头开始) 
            结束索引(可以留空,代表带末尾结束) 
            步长(默认1,正数代表从左往右,负数代表从右往左)

列表切片示例:

# 序列: 列表  元组  字符串
# 列表的切片操作
# 需求: 定义非空列表
my_list = ['a', 'b', 'c', 'd', 'e']
# 需求: 打印大列表
print(my_list)
print(my_list[:])
print(my_list[::])
# 需求: 从大列表中截取abc列表
print(my_list[0:3:1])
print(my_list[0:3:])
print(my_list[:3:])
# 需求: 从大列表中截取cde列表
print(my_list[2:5:1])
print(my_list[2:5])
print(my_list[2:])
# 需求(面试题): 反转列表
print(my_list[::-1])
# 需求:从大列表中截取dcb列表
print(my_list[3:0:-1])
print(my_list[-2:-5:-1])

元组切片示例:

# 序列: 元组  元组  字符串
# 元组的切片操作
# 需求: 定义非空元组
my_tuple = ('a', 'b', 'c', 'd', 'e')
# 需求: 打印大元组
print(my_tuple)
print(my_tuple[:])
print(my_tuple[::])
# 需求: 从大元组中截取abc元组
print(my_tuple[0:3:1])
print(my_tuple[0:3:])
print(my_tuple[:3:])
# 需求: 从大元组中截取cde元组
print(my_tuple[2:5:1])
print(my_tuple[2:5])
print(my_tuple[2:])
# 需求(面试题): 反转元组
print(my_tuple[::-1])
# 需求:从大元组中截取dcb元组
print(my_tuple[3:0:-1])
print(my_tuple[-2:-5:-1])

字符串切片示例:

# 序列: 字符串  字符串  字符串
# 字符串的切片操作
# 需求: 定义非空字符串
my_str = 'abcde'
# 需求: 打印大字符串
print(my_str)
print(my_str[:])
print(my_str[::])
# 需求: 从大字符串中截取abc字符串
print(my_str[0:3:1])
print(my_str[0:3:])
print(my_str[:3:])
# 需求: 从大字符串中截取cde字符串
print(my_str[2:5:1])
print(my_str[2:5])
print(my_str[2:])
# 需求(面试题): 反转字符串
print(my_str[::-1])
# 需求:从大字符串中截取dcb字符串
print(my_str[3:0:-1])
print(my_str[-2:-5:-1])

综合练习:

# 需求: 定义列表存储多个手机号
phone_list = ['15861626162', '15812344321', '13861123456', '15866667788']

# 需求: 已知多个手机号,要求把中间4位隐藏为****
# 方式1:
for phone in phone_list:
    # 依次获取到每个手机号phone
    # print(phone)
    new_phone = phone[:3] + "****" + phone[-4::]
    print(new_phone)

print('------------------------------------')
# 方式2:
for phone in phone_list:
    # 依次获取到每个手机号phone
    # print(phone)
    new_phone = phone.replace(phone[3:7], "****", 1)
    print(new_phone)

集合

集合的定义

知识点:

定义空集合: 集合名 = set()   注意: 千万不要使用空的{},因为它代表字典

定义非空集合: 集合名 = {元素1,元素2,元素3,...}   注意: 集合中不要嵌套可变类型

示例:

# 定义空集合
set1 = set()
print(set1, type(set1))
# 注意: 空集合不能是{}代表,因为它代表空字典!!!
test = {}
print(test, type(test))
# 定义非空集合
my_set = {'a', 'b', 'a', 'b', 'e'}
print(my_set, type(my_set))
# 注意: 集合内不能存储可变类型(列表,集合等)

集合的增删改查

知识点:

增:
	添加指定元素: 集合名.add(元素)
删:
	删除指定元素: 集合名.remove(元素)
	删除任意元素: 集合名.pop()
	清空所有元素: 集合名.clear()
改:
	修改集合A的内容为它和集合B的差集: 集合A.difference_update(集合B)
	修改集合A的内容为它和集合B的并集: 集合A.update(集合B)
查:
	查看集合中元素个数: len(集合名)

示例:

# 定义空集合
name_set = set()
# 1.演示集合的添加操作
name_set.add('张三')
name_set.add('李四')
name_set.add('张三')
name_set.add('王五')
print(name_set)
# 2.演示集合删除操作
name_set.remove('李四')
print(name_set)
name_set.pop()
print(name_set)
name_set.clear()
print(name_set)
# 3.演示集合修改操作
s1 = {1, 2, 3}
s2 = {1, 5, 6}
# 需求: 修改s2: 只保留和s1的差集
s2.difference_update(s1)
print(s1)  # {1,2,3}
print(s2)  # {5,6}
# 需求: 修改s2: 保留和s1的并集
s2.update(s1)
print(s1)  # {1,2,3}
print(s2)  # {1,2,3,5,6}
# 4.演示集合的查询操作
print(len(s1))
print(len(s2))

集合的遍历

知识点:

集合是不支持下标索引,不支持重复元素,所以集合是无序的,也不支持while循环

因为for循环又叫遍历循环,最大特点就是遍历容器,所以集合容器支持for循环

示例:

# 定义集合
name_set = {'张三', '李四', '张三', '王五'}
# for循环遍历集合
for name in name_set:
    print(name)

集合的特点

集合特点总结:
    可以存储多个元素
    支持for循环
    不能存储可变类型
    不支持下标索引(无序)
    不支持while循环
    不支持重复
    支持修改

字典[重点]

字典的定义

知识点:

定义空字典:  字典名 = {}   或者  字典名 = dict()

定义非空字典:  字典名 = {k1:v1 , k2:v2 , ...}    注意: 字典的每个元素是一个键值对

示例:

# 定义空字典
d1 = {}
print(d1, type(d1))
d2 = dict()
print(d2, type(d2))
# 定义非空字典
d3 = {'郭靖': '黄蓉', '杨过': '小龙女', '邓超': '孙俪'}
print(d3, type(d3))
# 字典的嵌套
d4 = {
    '郭靖': {'语文': 88, '数学': 99},
    '杨过': {'语文': 100, '数学': 88},
    '邓超': {'语文': 98, '数学': 89}
}
print(d4, type(d4))

字典根据key找值

知识点:

根据键找值方式1: value =  字典名[key]

根据键找值方式2: value =  字典名.get(key)

示例:

# 定义非空字典
d3 = {
    '郭靖': '黄蓉',
    '杨过': '小龙女',
    '邓超': '孙俪'
}
# 字典的嵌套
d4 = {
    '张三': {'语文': 88, '数学': 99},
    '李四': {'语文': 100, '数学': 88},
    '王五': {'语文': 98, '数学': 89}
}

# 需求: 查找杨过的另一半?
print(f"杨过的另一半是:{d3['杨过']}")
print(f"杨过的另一半是:{d3.get('杨过')}")
# 需求: 查找张三的所有考试成绩?
print(f"张三的所有成绩为:{d4['张三']}")
print(f"张三的所有成绩为:{d4.get('张三')}")
# 需求: 查找王五的数学成绩?
print(f"王五的数学成绩为:{d4['王五']['数学']}")
print(f"王五的数学成绩为:{d4.get('王五').get('数学')}")

字典的增删改查

知识点:

增
	添加元素: 字典名[new_key] = value 
删
	删除元素: 字典名.pop(key)
	清空元素: 字典名.clear()
改
	修改元素: 字典名[old_key] = value 
查
	根据键找值方式1: 字典名[key]
	根据键找值方式2: 字典名.get(key)
	查询元数据的个数: len(字典名)
	查询所有的键: 字典名.keys()
	查询所有的值: 字典名.values()
	查询所有的键值对: 字典名.items()

添加和修改注意事项:

"""
注意:
key是不能重复的,如果重复了不报错,只是变成了修改对应值

字典的添加和修改是一个格式: 字典名[key]=value
如果key是已经存在的,就是修改操作
如果key是不存在的,就是添加操作
"""
# 演示定义字典的时候出现key重复情况,直接报黄警告,有重复key
score_dict = {'张三': 88, '李四': 88, '张三': 77}
print(score_dict)
# 需求: 添加元素
# 演示添加元素的时候出现key重复情况,不会报黄警告,直接修改对应值
score_dict['李四'] = 100
print(score_dict)
# 演示正常添加元素
score_dict['王五'] = 100
print(score_dict)

增删改查示例:

# 定义非空字典
score_dict = {'张三': 88, '李四': 88, '王五': 100}
# 1.演示删除操作
# pop(key): 根据key删除对应的整个键值对
score_dict.pop('李四')
print(score_dict)
# clear(): 清空所有的键值对
score_dict.clear()
print(score_dict)
# 2.增加元素
# 字典名[new_key]=value
score_dict['赵六'] = 90
score_dict['田七'] = 100
print(score_dict)
# 3.修改田七的成绩为99
# 字典名[old_key]=value
score_dict['田七'] = 99
print(score_dict)
# 4.查找元素
# 需求: 查找字典中元素个数
print(len(score_dict))
# 需求: 查找所有的键key
print(score_dict.keys())
# 需求: 查找所有的值value
print(score_dict.values())
# 需求: 查找所有的键值对items
print(score_dict.items())

字典的遍历

知识点:

集合是不支持下标索引,不支持重复元素,所以集合是无序的,也不支持while循环

因为for循环又叫遍历循环,最大特点就是遍历容器,所以集合容器支持for循环

示例:

"""
字典的核心就是key,主要操作的就是key
字典是不支持下标索引,key不支持重复元素,所以字典不支持while循环
"""
# 定义字典
name_age_dict = {'张三': 18, '李四': 18, '张三': 28, '王五': 38}
# for循环遍历字典
# 方式1  默认遍历获取的就是key,再根据key找值
for name in name_age_dict:
    # 根据key找value
    age = name_age_dict[name]
    print(name, age)
print('-----------------------------------')
# 方式2  先获取所有的key,再根据key找值
for name in name_age_dict.keys():
    # 根据key找value
    age = name_age_dict.get(name)
    print(name, age)

print('-----------------------------------')
# 方式3 先获取所有的键值对items(默认放到元组中),然后再根据索引找
for item in name_age_dict.items():
    print(item[0], item[1])

字典的特点

字典特点总结:
    可以存储多个元素
    支持for循环
     key不支持可变类型(value可以是任意类型)
    不支持下标索引
    不支持while循环
     key不支持重复(value支持重复)
    支持修改

示例：

"""Python的字典可以用来计数，让要被计数的元素作为key值，它出现的频次作为value值，只要在遇到key值后更新它对应的value即可。现输入一个单词，使用字典统计该单词中各个字母出现的频次。

如何理解，自己脑海里输入数字1,2,3,4,遇见重复的值，value值增加
"""
#方法一
ls1 = list(input())
ls2 = [ls1.count(i) for i in ls1]
print(dict(zip(ls1,ls2)))
#方法二
from collections import Counter
ls1 = input()
print(dict(Counter(ls1)))
#Counter() 是 collections 库中的一个函数，可以用来统计一个 python 列表、字符串、元组等可迭代对象中每个元素出现的次数，并返回一个字典

#方法三：
ls1 = list(input())
dict1 = {}
for i in ls1:
    if i in dict1:
        continue
    dict1[i] = ls1.count(i)
print(dict1)
#方法四
ls1 = list(input())
dict1 = {}
for i in ls1:
    if i in dict1:
        dict1[i] += 1
    else:
        dict1[i] = 1
print(dict1)
#方法五
ls1 = list(input())
dict1 = {}
for i in ls1:
    dict1[i] = dict1.get(i,0)+1
print(dict1)

数据容器特点总结

列表(list)	元组(tuple)	字符串(str)	集合(set)	字典(dict)
可以存储多个元素	可以存储多个元素	可以存储多个元素	可以存储多个元素	可以存储多个元素
支持for循环	支持for循环	支持for循环	支持for循环	支持for循环
可以存储不同类型数据	可以存储不同类型数据	只能存储字符串数据	不能存储可变类型	key不能存储可变类型
支持修改	不支持修改	不支持修改	支持修改	支持修改
支持下标索引（有序）	支持下标索引（有序）	支持下标索引（有序）	不支持下标索引(无序)	不支持下标索引
支持while循环	支持while循环	支持while循环	不支持while循环	不支持while循环
支持重复	支持重复	支持重复	不支持重复	key不支持重复