Python容器
Python中的容器
- 之前我们学的变量只能存储简单的，单一的数据，如果要同时存储多个值，变量就实现不了了。此时就需要用 容器类型 来实现。例如：存储咱们所有人的姓名, 年龄…
- 分类
---- 字符串 (str)
---- 列表 (list)
---- 字典 (tuple)
---- 元祖 (dict)
---- 集合(set)
一、字符串
1. 介绍
1、概述:
它属于容器类型的一种, 属于 不可变类型. 它由多个字符组成.
2、例如:
'abc', 'hello world', '张三'...
3、定义格式:
方式1: 一对引号, 单双引号均可.
方式2: 三引号, 可以保留字符串的格式.
代码演示
# 1、通过 一对引号的方式 定义字符串, 单双引号均可.
s1 = '张三'
s2 = "李四"
print(s1, s2) # 可以同时输出多个值. 打印结果：张三 李四
# 2、通过 三引号 的方式定义字符串.
s3 = """
select
[distinct] 列1, 列2...
from
表名
where
组前筛选
group by
分组字段
having
组后筛选
order by
排序字段 [asc | desc]
limit
起始索引, 数据条数;
"""
print(s3) # 打印结果 ： select
[distinct] 列1, 列2...
from
表名
where
组前筛选
group by
分组字段
having
组后筛选
order by
排序字段 [asc | desc]
limit
起始索引, 数据条数;
# 3. 字符串特殊格式, 定义字符串变量, 记录: I'm Tom!
s4 = "I'm Tom!" # 为了防止跟语句中的单引号发生冲突，可以选择用双引号
s5 = 'I\'m Tom!' # \' 表示转义符, 即: 代表1个普通的单引号.
print(s4, s5) # 打印结果：I'm Tom!
2. 字符串索引(下标)与切片
2.1 字符串索引(下标)
字符串索引详解:
"""
1、概述:
Python中, 为了更好, 更方便的从字符串中获取到指定的内容, 给字符串的每个元素 提供的有索引.
索引也叫: 下标, 角标, 编号等...
2、细节:
1. Python中, 字符串的索引 有正向索引 和 逆向索引之分.
2. 正向索引: 从左往右(从前往后)编号, 且 编号从 0 开始.
3. 逆向索引: 从右往左(从后往前)编号, 且 编号从 -1 开始.
4. 例如:
字符串: a b c d e f g
正向索引: 0 1 2 3 4 5 6
逆向索引: -7 -6 -5 -4 -3 -2 -1
5. 可以通过 字符串变量名[索引] 的形式, 从字符串中 获取到 指定的内容.
"""
代码演示
s1 = 'abcdefg'
# 2. 从字符串中获取指定内容, 并打印.
print(s1[2]) # 'c'
print(s1[-5]) # 'c'
print(s1[5]) # 'f'
print(s1[-2]) # 'f'
print(s1[3]) # 'd'
print(s1[-2]) # 'f'
2.2 字符串切片
字符串切片详解:
"""
1、概述:
从字符串中 截取出 指定的内容 就称之为: 字符串切片.
2、格式:
字符串变量名[起始索引:结束索引:步长] 包左不包右.
3、细节:
1. 正向索引是从前往后(从左往右), 从 0 开始.
2. 逆向索引是从后往前(从右往左), 从 -1 开始.
3. 如果不写起始索引, 默认从: 0开始,
如果不写结束默认, 默认到字符串末尾.
如果不写步长, 默认是: 1
4. 如果 索引 和 步长的方向相反, 获取不到数据.
5. 特殊写法, 字符串[::-1] 表示反转字符串, 这个是面试题.
例如:
字符串: a b c d e f g h
正向索引: 0 1 2 3 4 5 6 7
逆向索引: -8 -7 -6 -5 -4 -3 -2 -1
"""
代码演示
# 1. 定义变量s1, 记录字符串内容.
s1 = 'abcdefgh'
# 2. 演示字符串的切片.
print(s1[1:3]) # bc 不写步长, 默认是: 1
print(s1[:5]) # abcde 不写起始索引, 默认是: 0
print(s1[3:]) # defgh 不写结束索引, 默认到: 字符串最后
print(s1[1:5:2]) # bd 起始索引是1, 结束索引是5, 步长是2, 包左不包右.
print(s1[-6:-2]) # cdef, 不写步长, 默认是: 1
print(s1[-6:-2:1]) # 效果同上.
print(s1[-6:-2:-1]) # 不报错, 但是啥都没有. 因为查找的顺序是 -6到-2 从前往后, 而步长是-1, 顺序是 从后往前 查找和步长顺序相反, 无数据.
print(s1[-1:-5:-1]) # hgfe
print(s1[:-3]) # abcde
print(s1[-5:]) # defgh
print(s1[2:-3]) # cde
print(s1[-2:1]) # 不报错, 但是啥都没有. 查找方向 和 方向顺序不一致.
print(s1[-2:1:-1]) # gfedc
# 面试题
print(s1[:]) # abcdefgh, 即: 字符串本身.
print(s1[::-1]) # hgfedcba, 即: 反转字符串
print(s1[::-3]) # heb
3. 字符串遍历
- 字符串遍历(也叫迭代, 即: 逐个获取 容器类型中 每个元素的动作)
代码演示
s1 = 'abcdefg'
# 方式1：直接遍历
for i in s1:
print(i) # i就是字符串s1中的 每个字符, 例如: a b c d e f g
# 方式2: 通过 索引 的方式遍历.
# print(s1[0]) # a
# print(s1[1]) # b
# print(s1[2]) # c
# print(s1[3]) # d
# print(s1[4]) # e
# print(s1[5]) # f
# print(s1[6]) # g
# len()函数返回的是字符串的长度 len(s1) = 7
for i in range( len(s1) ): # i的值的范围: 0 ~ 7, 包左不包右.
print(s1[i]) # 根据索引, 获取到每个字符.
4. 字符串常用函数方法
4.1 函数index和find、rindex和rfind
字符串函数介绍:
"""
1、概述:
就是Python提供的, 可以直接操作 字符串变量 或者 字符串值的一些函数.
2、常用的 字符串查找类 相关的函数如下:
字符串变量名.find(要查找的子串, 起始索引, 结束索引) 找子串在字符串中第一次出现的位置, 找到就返回子串的起始索引, 找不到就返回-1
字符串变量名.index(要查找的子串, 起始索引, 结束索引) 找子串在字符串中第一次出现的位置, 找到就返回子串的起始索引, 找不到就报错.
字符串变量名.rfind(要查找的子串, 起始索引, 结束索引) 找子串在字符串中最后一次出现的位置, 找到就返回子串的起始索引, 找不到就返回-1
字符串变量名.rindex(要查找的子串, 起始索引, 结束索引) 找子串在字符串中最后一次出现的位置, 找到就返回子串的起始索引, 找不到就报错.
"""
代码演示
# 1. 定义变量, 记录字符串值.
# 0 13 25
s1 = 'hello python hello world hello sql'
# 2. 查找 hello 字符串在 s1中出现的索引.
# find()函数
print(s1.find('hello')) # 0, 不写起始和结束索引, 默认是在 整个字符串中 查找的.
print(s1.find('hello', 2)) # 13, 从索引2的位置处, 开始查找.
print(s1.find('hello', 2, 17)) # -1, 因为是在 索引 2 ~ 17位置查找, 包左不包右.
# index()函数
print(s1.index('hello')) # 0, 效果同上
print(s1.index('hello', 2)) # 13, 效果同上.
# print(s1.index('hello', 2, 17)) # 找不到就: 报错.
# rfind()函数, 最后一次出现的位置, 找不到返回 -1
print(s1.rfind('hello')) # 25
print(s1.rfind('hello', 2)) # 25
print(s1.rfind('hello', 2, 17)) # -1
# rindex()函数, 最后一次出现的位置, 找不到: 报错
print(s1.rindex('hello')) # 25
print(s1.rindex('hello', 2)) # 25
# print(s1.rindex('hello', 2, 17)) # 报错.
4.2 函数 replace 和 split
字符串函数介绍:
"""
1、概述:
就是Python提供的, 可以直接操作 字符串变量 或者 字符串值的一些函数.
2、常用的 字符串 替换和切割类 相关的函数如下:
字符串变量名.replace(旧子串, 新子串, 替换次数) 用新的替换旧的, 且可以设置替换几个(如超出真实旧子串个数, 则以实际为准)
字符串变量名.split(分隔符, 切割次数) 按照分隔符切割, 且可以设置切割次数(如超出真实切割次数, 则以实际为准)
3、细节:
因为字符串属于 不可变数据类型, 所以上述的函数操作字符串后, 会返回1个新的结果, 即: 旧字符串不变.
"""
代码演示
# 1. 定义变量, 记录字符串内容.
s1 = 'hello python hello sql hello pandas'
# 2. 用 numpy 来替换上述的 hello.
s2 = s1.replace('hello', 'numpy') # 如果不写个数, 则会一次性替换所有.
s3 = s1.replace('hello', 'numpy', 2) # 只会替换2次(前2个)
s4 = s1.replace('hello', 'numpy', 5) # 超出真实个数, 则以实际为准.
# 3. 打印结果.
print(f's1: {s1}') # hello python hello sql hello pandas
print(f's2: {s2}') # numpy python numpy sql numpy pandas
print(f's3: {s3}') # numpy python numpy sql hello pandas
print(f's4: {s4}') # numpy python numpy sql numpy pandas
# 4. 测试split()函数.
s5 = 'hello python hello sql hello pandas'
list1 = s5.split(' ') # 切割后, 获取的是一个 字符串形式的列表, 即: ['hello', 'python', 'hello'...]
list2 = s5.split(' ', 2) # 按空格切割, 只会切割2次(前2个), 即: 获取的元素个数为: 2 + 1 = 3个.
list3 = s5.split(' ', 9) # 如果切割的个数超过真实个数, 则以实际为准.
# 5. 打印结果.
print(f's5: {s5}') # hello python hello sql hello pandas
print(f'list1: {list1}') # ['hello', 'python', 'hello', 'sql', 'hello', 'pandas']
print(f'list2: {list2}') # ['hello', 'python', 'hello sql hello pandas']
print(f'list3: {list3}') # ['hello', 'python', 'hello', 'sql', 'hello', 'pandas']
# 扩展: len()函数, 获取字符串的长度的, 即: 字符串有几个字符.
print(len(s1)) # 35
# 分隔符.join(字符串) 用分隔符隔开 字符串中的每个字符.
s4 = 'hello'
s5 = ','.join(s4)
print(s5) # h,e,l,l,o
# 需求: 把 'hello' => ['h', 'e', 'l', 'l', 'o']
list3 = ','.join(s4).split(',')
print(list3) # ['h', 'e', 'l', 'l', 'o']
4.3 函数 endswith
介绍
"""
1. 概述:
用来判断字符串中是否已某元素结尾
2. 格式
字符串名.endswith(要判断的元素)
"""
代码演示
# 定义一个字符串
s1 = 'rarfddsf'
# 打印结果
print(s1.endswith('f')) # 若以 f 结尾返回True 否则返回 Flase
二、列表
1. 介绍
"""
1、概述:
它属于容器类型的一种, 属于 可变类型. 它可以同时存储 多个元素.
2、格式:
格式1: 列表名 = [值1, 值2, 值3...]
格式2: 列表名 = list()
格式3: 列表名 = []
3、细节:
1. 列表可以同时存储多个元素, 可以是不同类型的, 也可以是同类型的元素.
2. 实际开发中, 为了方便统一操作, 建议: 列表存储的多个元素 是 同类型.
3. 列表的元素也是有索引的, 且索引也是从 0(正向), -1(逆向) 开始的.
4. 列表和字符串一样, 也是支持 "切片" 操作的, 规则都一样: 列表名[起始索引:结束索引:步长]
"""
代码演示
# 1. 定义列表.
list1 = [10, 20.3, True, 'abc']
list2 = list()
list3 = []
# 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'>
# 4. 打印列表的 某个元素. 即: 测试列表的索引.
print(list1[1]) # 20.3, 正向索引
print(list1[-3]) # 20.3, 逆向索引.
2. 列表的遍历
"""
1、概述:
逐个的获取容器类型中的每个元素的过程, 就称之为: 遍历.
2、遍历思路:
思路1: for循环, 直接从 容器类型中获取每个元素.
思路2: 采用 索引的 方式实现.
"""
代码演示
# 1. 定义列表.
list1 = [11, 22, 33, 44, 55]
# 2. 遍历列表.
# 思路1: 采用 for循环, 直接获取列表的每个元素.
for value in list1:
print(value)
# 思路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. 列表的常用操作方法
"""
1、概述:
列表的常见操作指的是 列表元素的 增删改查的相关操作.
2、涉及到的函数如下:
增 相关:
列表名.append(任意变量即可) 往列表的末尾追加元素.并且只支持单个元素追加
列表名.extend(必须是容器变量) 把容器类型中的每个变量都添加到 列表中.
列表名.insert(索引, 元素) 往列表的指定位置插入元素.
查 相关:
列表名.index(元素, 起始索引, 结束索引) 去列表中查找指定的元素(第一次出现的位置), 找到就返回, 找不到就: 报错.
列表名.count(元素) 计数.
变量名或者元素值 in 列表名 是否在.
变量名或者元素值 not in 列表名 是否不在.
删:
列表名.pop(索引) 删除指定索引位置的元素, 并返回被删除的元素.
列表名.remove(元素) 删除指定元素, 删除第一个找到的元素.
del 列表名[索引] 删除指定索引位置的元素.
del 列表名 从内存中删除整个列表, 相当于该列表从未定义.
列表名.clear() 清空列表, 得到1个 空列表, 类似于: list1 = []
改:
列表名[索引] = 值
列表名.reverse() 反转列表元素内容.
列表名.sort(key=None, reverse=False) 列表元素排序, key可以指定排序规则(后边讲), reverse表示升序还是降序, 默认是False(升序)
3、细节:
1. append() 和 extend()的区别:
区别1: 参数要求不同.
append(): 可以传入 任意变量,只支持单个元素
extend(): 必须传入 容器类型.
区别2: 作用不同.
append(): 把元素追加到末尾, 默认是 当做1个整体 来添加的.
extend(): 把容器类型的每个元素, 逐个添加进来, 底层有遍历的动作.
2. insert()函数是往指定的位置插入数据, 如果索引值不合法, 则会默认添加到 最前 或者 最后, 具体要看下的索引值.
3. 列表属于可变类型, 所以其函数(例如: reverse(), sort()等)大多数都是直接修改 列表本身的.
"""
代码演示
# 需求1: 演示列表相关操作 增.
# 1. 定义列表.
list1 = ['a', 'b', 'c']
# 2. 演示 增 相关的函数.
#列表名.append(任意变量即可) 往列表的末尾追加元素.
list1.append('d')
list1.append('e','b') # 报错,因为list.append()方法只接受一个参数，即要添加到列表末尾的元素
list1.append('xyz') # 是把 'xyz'当做整体来添加的.
# list1.append([10, 20, 30]) # 是把 列表 当做整体来添加的.
# 列表名.extend(必须是容器变量) 把容器类型中的每个变量都添加到 列表中.
# list1.extend(10) # 报错.
# list1.extend('xyz') # 字符串 = 容器类型.
# list1.extend([10, 20, 30]) # 字符串 = 容器类型.
# 列表名.insert(索引, 元素) 往列表的指定位置插入元素.
# list1.insert(1, 'd') # 往 索引1的(前边)位置插入元素 d
list1.insert(-2, 'd') # 往 索引-2的(前边)位置插入元素 d
# 3. 打印结果.
print(f'list1: {list1}')
print('-' * 30)
=============================================
# 需求2: 演示列表相关操作 查.
# 1. 定义列表.
list1 = ['a', 'b', 'c', 'd', 'b', 'd']
# 2. 演示列表的 查找 相关的函数.
# 列表名.index(元素, 起始索引, 结束索引) 去列表中查找指定的元素(第一次出现的位置), 找到就返回, 找不到就: 报错.
print(list1.index('b')) # 1
print(list1.index('b', 2)) # 4, 从索引2开始查找, 元素b 在列表中的索引
# print(list1.index('b', 2, 4)) # 在索引区间 2 ~ 4之间查找 元素b, 包左不包右, 找不到就 报错.
print('-' * 30)
# 列表名.count(元素) 计数.
print(list1.count('b')) # 2次
# 变量名或者元素值 in 列表名 是否在.
print('d' in list1) # True
print(10 in list1) # False
# 变量名或者元素值 not in 列表名 是否不在.
print('d' not in list1) # False
print(10 not in list1) # True
=============================================
# 需求3: 演示列表相关操作 删.
# 1. 定义列表, 记录元素.
list1 = ['a', 'b', 'c', 'd', 'b', 'd']
print(f'删除前: {list1}')
# 2. 测试上述的方法.
# 列表名.pop(索引) 删除指定索引位置的元素, 并返回被删除的元素.
# print(list1.pop(2)) # c
# print(list1.pop(5)) # 正常是可以的, 但是这里是报错, 因为上边删了一个元素, 就没有索引5了
# print(list1.pop(10)) # IndexError, 索引越界错误.
# 列表名.remove(元素) 删除指定元素, 删除第一个找到的元素.
# list1.remove(0) # ValueError, revmoe是根据元素值删除的.
# print(list1.remove('b')) # 删除第1个匹配到的'b', 无任何返回, 如果打印, 结果是: None
# list1.remove('b') # 正确
# del 列表名[索引] 删除指定索引位置的元素.
del(list1[2])
del list1[2] # 写法同上.
# del 列表名 从内存中删除整个列表, 相当于该列表从未定义.
# del list1
# del(list1) # 写法同上.
# 列表名.clear() 清空列表, 得到1个 空列表, 类似于: list1 = []
# list1.clear()
# 3. 打印结果.
print(f'删除后: {list1}')
print('-' * 30)
=============================================
# 需求4: 演示列表相关操作 改.
# 1. 定义列表, 记录元素.
list1 = ['a', 'b', 'c', 'd', 'b', 'd']
print(f'修改前: {list1}')
# 2. 演示列表的 改 相关操作.
# 列表名[索引] = 值
# list1[1] = 100
# 列表名.reverse() 反转列表元素内容.
# list1.reverse() # 扩展, 你可以通过 for循环 或者 while循环的方式, 自定义代码对列表内容进行反转.
# 列表名.sort(key=None, reverse=False) 列表元素排序, key可以指定排序规则(后边讲), reverse表示升序还是降序, 默认是False(升序)
# list1.sort()
# list1.sort(reverse=False) # 效果同上, False = 不反转, 即: 升序.
list1.sort(reverse=True) # True = 反转, 即: 降序.
# 3. 打印结果.
print(f'修改后: {list1}')
4. 列表的嵌套
"""
1、概述:
所谓的列表嵌套指的是: 列表的元素还是1个列表, 这种写法就称之为: 列表嵌套.
2、格式:
列表名 = [列表1, 列表2, 列表3...]
3、如何获取元素?
方式1: 遍历.
方式2: 列表名[外部列表的索引][内部列表的索引]
"""
代码如下（示例）：
list2 = [[10, 20, 30], [40, 50], [60, 70, 80, 90]]
# 如何获取 50?
print(list2[1][1])
# 如何修改 60 => 666
list2[2][0] = 666
# 如何遍历上述的列表嵌套形式.
# 思路1: 直接获取元素值.
for inner_list in list2:
# 因为 inner_list 还是1个列表, 所以我们接着遍历.
# print(inner_list)
for value in inner_list:
print(value, end='\t')
print() # 打印完1个列表后, 记得加换行.
print('-' * 30)
# 思路2: 根据索引获取元素值.
for i in range(len(list2)):
# print(i) # 0, 1, 2 分别代表list2列表的 3个子列表的索引.
# print(list2[i]) # list2[i] 就是列表list2的每个 子列表, 我们接着遍历.
for j in range(len(list2[i])):
# 具体的获取元素值的过程, 并打印.
print(list2[i][j], end='\t')
print()
三、元组
1. 介绍
"""
1、概述:
它属于容器类型的一种, 属于 不可变类型.
它也可以同时存储多个元素, 可以是不同类型的, 实际开发中, 建议存储: 相同类型的多个值.
2、特点:
元组和列表的区别, 元组用小括号来表示, 且元组的 元素值不允许修改.
3、定义格式:
t1 = (值1, 值2, 值3...) 列表: list1 = [值1, 值2, 值3...]
t2 = tuple() 列表: list2 = list()
t3 = (值1, )
4、细节:
1. 元组属于不可变类型, 其元素值不能更改.
2. 元组和列表一致, 也是有索引的概念的.
3. 定义元组时, 如果只有1个值, 则该值的末尾必须要加 逗号, 否则: 就是在定义1个普通的变量(即: 不是元组)
"""
代码如下（示例）：
# 需求1: 演示如何定义元组.
# 1. 演示如何定义元组.
tuple1 = (10, 20, 30, 40, 50)
tuple2 = tuple()
tuple3 = ()
tuple4 = (10,)
tuple5 = (10)
tuple6 = ('aa')
# 2. 打印上述的变量.
print(tuple1) # (10, 20, 30, 40, 50)
print(tuple2) # ()
print(tuple3) # ()
print(tuple4) # (10,)
print(tuple5) # 10
print(tuple6) # aa
# 3. 打印上述的变量的 数据类型.
print(type(tuple1)) # <class 'tuple'>
print(type(tuple2)) # <class 'tuple'>
print(type(tuple3)) # <class 'tuple'>
print(type(tuple4)) # <class 'tuple'>
print(type(tuple5)) # <class 'int'>
print(type(tuple6)) # <class 'str'>
2. 元组索引 和 切片
# 需求2: 演示元组的 索引 和 切片操作.
tuple7 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# 根据索引, 获取 元组的元素值.
print(tuple7[3]) # 4
# 尝试修改元组的元素值.
# tuple7[3] = 200 # 报错, 因为元组内容是 不可变 的.
# 元组切片.
print(tuple7[2:6]) # [3, 4, 5, 6]
# 打印元组的内容.
print(f'tuple7: {tuple7}') #(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
3. 元组常用函数
# 需求3. 和列表, 字符串一样, 元组也是支持函数的, 例如: 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)
4. 细节问题, 即: 元组嵌套列表
# 需求4. 元组的细节问题, 即: 元组嵌套列表.
# 前提: 元组是属于容器类型的一种, 它属于 不可变类型,
# 但是当: 元组嵌套列表的时候, 其内部列表的值是可以修改的, 但是 列表的地址值是不变的.
t1 = (1, 2, 3, ['a', 'b', 'c'])
print(f'修改前: {t1}') # (1, 2, 3, ['a', 'b', 'c'])
# 需求, 把 'b' => 'z'
# print(t1[3])
t1[3][1] = 'z'
print(f'修改后: {t1}') # (1, 2, 3, ['a', 'z', 'c'])
四、字典
1. 介绍
"""
1、概述:
它属于容器类型的一种, 存储的是 键值对数据, 它(字典)属于 可变类型.
2、定义格式:
dict1 = {键:值, 键:值......}
dict2 = {}
dict3 = dict()
3、细节:
1. 字典用 大括号 包裹.
2. 字典存储的市 键值对形式的数据, 冒号左边的叫: 键, 右边的叫: 值.
3. 键具有唯一性, 值可以重复.
"""
代码如下（示例）：
# 1. 演示如何定义字典.
# 键 值 键 值 键值对数据
dict1 = {'name': '张三', 'age': 23, 'gender': 'male'}
dict2 = dict()
dict3 = {}
dict4 = {10, 20, 30, 40, 50} # 这个可不是字典, 而是1个集合(set)
# 2. 打印字典.
print(dict1) # {'name': '张三', 'age': 23, 'gender': 'male'}
print(dict2) # {}
print(dict3) # {}
print(dict4) # {50, 20, 40, 10, 30}
# 3. 打印字典的类型.
print(type(dict1)) # <class 'dict'>
print(type(dict2)) # <class 'dict'>
print(type(dict3)) # <class 'dict'>
print(type(dict4)) # <class 'set'>
2. 字典的 常见操作
"""
1、演示字典的常用 函数 如下:
增: 字典名[键名] = 值
删: del 字典名 或者 clear()
改: 字典名[键名] = 值
查: get(), keys(), values(), items()
# 字典名[key] 和 字典名.get(key)都能获取到其对应的value值，两者之间有什么不同：
# 字典[key]的方法,key值不存在,会报错
# get方法,key值不存在,不会报错，返回None
2、字典使用细节:
1. 字典存储的是键值对元素, 键具有唯一性, 值可以重复.
2. 字典属于可变类型, 其元素值可以修改.
"""
代码演示：
# 1. 定义变量, 表示: 字典.
dict1 = {'杨过':'小龙女', '郭靖':'黄蓉', '张无忌':'赵敏'}
# 2. 演示 字典相关的 函数.
# 增: 字典名[键名] = 值
dict1['段誉'] = '王语嫣' # 键不存在, 就添加该键值对.
# 删: del 字典名 或者 clear()
# dict1.clear() # 清空元素(即: 删除所有的键值对)
# del dict1 # 从内存中删除该字典.
# del dict1['郭靖'] # 根据键, 删除该键值对.
# 改: 字典名[键名] = 值
dict1['段誉'] = '木婉清'
# 3. 打印字典内容.
print(f'dict1: {dict1}') # {'杨过': '小龙女', '郭靖': '黄蓉', '张无忌': '赵敏', '段誉': '木婉清'}
# 查: get(), keys(), values(), items()
# get(键, 默认值) 根据键获取值, 如果键不存在, 就获取默认值.
print(dict1.get('杨过')) # 小龙女
print(dict1.get('杨过', '李四')) # 小龙女
print(dict1.get('乔峰')) # None
print(dict1.get('乔峰', '张三')) # 张三
# 注意两种获取key对应的value的值
print(dict1.get('乔峰')) #返回None
print(dict1['乔峰']) #报错
# keys() 获取字典中所有的键.
print(dict1.keys()) # dict_keys(['杨过', '郭靖', '张无忌', '段誉'])
# values() 获取字典中所有的值.
print(dict1.values()) # dict_values(['小龙女', '黄蓉', '赵敏', '木婉清'])
# items() 把 每对键值对元素 封装成 元组, 然后再放到 列表中.
print(dict1.items()) # 列表 嵌套 元组, 即: dict_items([('杨过', '小龙女'), ('郭靖', '黄蓉'), ('张无忌', '赵敏'), ('段誉', '木婉清')])
3. 字典的遍历
"""
字典遍历方式:
思路1: 根据 键 获取其对应的值.
思路2: 根据 键值对 获取其对应的 键 和 值.
"""
代码演示：
# 需求: 演示如何遍历字典, 即: 逐个的获取字典中键值对的过程.
# 1. 定义字典, 记录元素.
dict1 = {'name': '乔峰', 'age': 41, 'gender': '男', 'kongfu': '降龙十八掌'}
# 思路1: 根据 键 获取其对应的 值.
# step1: 获取所有的键.
keys = dict1.keys()
# step2: 遍历, 获取到 每个键.
for key in keys:
# key 就是字典的中的每个键, 根据键 获取值.
value = dict1.get(key)
# step3: 打印结果.
print(key, value)
print('-' * 30)
# 上述格式简化版
for key in dict1.keys():
print(key, dict1.get(key))
print('-' * 30)
# 思路2: 根据 键值对 找键和值.
# step1: 获取所有的键值对.
items = dict1.items()
# step2: 遍历, 获取到每一组 键值对.
for item in items:
# item就是每组键值对的 元组形式, 即: (键, 值)
# step3: 从item中获取到 键 和 值.
key = item[0]
value = item[1]
# step4: 打印结果
print(key, value)
# 合并版.
for item in dict1.items():
print(item[0], item[1])
# 最终版, 实际开发写法, 加入拆包, 目前了解即可,后续详解.
# item的格式为: (键, 值)
for k, v in dict1.items():
print(k, v)
# 拆包
tuple1 = ('name', '乔峰')
k, v = tuple1
print(k, v) # 能获取到键值对的值
五. 集合
集合（set）是一个不重复无序的元素序列
介绍
"""
1、概述:
它属于容器类型的一种, 其元素特点为: 无序, 唯一.
2、无序解释:
这里的无序, 并不是排序的意思, 而是: 元素的存, 取顺序不一致, 例如: 存的时候顺序是1, 2, 3, 取的时候顺序是2, 1, 3
3、应用场景:
去重.
4、set集合定义格式:
set1 = {值1, 值2, 值3...}
set2 = set()
"""
代码演示
# 1. 定义集合.
set1 = {10, 2, 'c', 5, 'a', 6, 3, 'b', 10, 5, 'a'}
set2 = set()
set3 = {} # 注意：这个不是在定义集合, 而是在定义: 字典.
# 2. 打印变量的数据类型
print(type(set1)) # <class 'set'>
print(type(set2)) # <class 'set'>
print(type(set3)) # <class 'dict'>
# 3. 打印元素内容.
print(f'set1: {set1}') # set1: {2, 3, 5, 6, 'a', 10, 'c', 'b'}
print(f'set2: {set2}') # set2: set()
print(f'set3: {set3}') # set3: {}
# 需求: 对列表元素值进行去重.
list1 = [10, 20, 30, 20, 10, 30, 50]
# 去重
# 思路1: 定义新列表, 遍历原始列表获取每个元素, 然后判断是否在新列表中, 不存在就添加.
list2 = []
for i in list1:
if i not in list2
list2.append(i)
print(list2) # [10, 20, 30, 50]
# 思路2: list -> set, 会自动去重 -> list
set_tmp = set(list1)
list1 = list(set_tmp)
# 打印去重后的结果.
print(f'list1: {list1}') # [10, 20, 30, 50]
总结
- 以上就是python中容器所涉及到的基本知识，涉及到的公共方法我们下一章在做讲解。
扫一扫
1394
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
