python编程:(六)元组、字典、集合

admin 2021年03月23日 709次浏览

1、元组(tuple)

1.1、定义

  • 元组由一系列变量组成的不可变序列容器
  • 不可变是指,一但创建就不可以再添加/删除/修改元素

1.2、基础操作

  • 创建空元组
    元组名 = ()
    元组名 = tuple()
  • 创建非空元组
    元组名 = (20,)
    元组名 = (1, 2, 3)
    元组名 = 100,200,300
    元组名 = tuple(可迭代对象)
  • 获取元素
    索引、切片
  • 遍历元组
    • 正向
      for 变量名 in 列表名:
          变量名就是元素
    
    • 反向
      for 索引名 in range(len(列表名)-1,-1,-1):
          元祖名[索引名]就是元素
    

1.3、 作用

  • 元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素
  • 元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小

1.4、应用

  • 变量交换的本质就是创建元组
    x, y = (y, x )
  • 格式化字符串的本质就是创建元祖
    "姓名:%s, 年龄:%d" % ("张三", 15)

1.5、元组操作示例

# ---------- 1、创建元组 ----------
# 创建空元组
tuple01 = ()
tuple01 = tuple()

# 创建具有默认值元组
# 如果元组只有一个元素,必须要在末尾添加逗号
tuple02 = (1,)
tuple02 = (1,2)

# 列表转元组
list01 = ["a","b"]
tuple02 = tuple(list01)

# 元组转列表
list02 = list(tuple02)

# 多个变量 = 序列
name01,name02 = ("张三","李四")

# ---------- 2、获取元素 ----------
tuple03 = ("a","b","c","d")
# 获取单个元素
print(tuple03[2]) # c

# 获取多个元素
print(tuple03[1:3]) # ("b","c")

# 获取所有元素
# # 正向
for item in tuple03:
    print(item)
    
## 反向
for i in range(len(tuple03)-1,-1,-1):
    print(tuple03[i])

2、字典 (dict)

2.1、定义

  • 字典由一系列键值对组成的可变散列容器
  • 散列:对键进行哈希运算,确定在内存中的存储位置,每条数据存储无先后顺序
  • 键必须惟一且不可变(字符串/数字/元组),值没有限制

2.2、基础操作

  • 创建字典:
    字典名 = {键1:值1,键2:值2}
    字典名 = dict (可迭代对象)
  • 添加/修改元素:
    • 语法:
      字典名[键] = 数据
    • 说明:
      • 键不存在,创建记录
      • 键存在,修改映射关系。

2.3、获取元素

  • 语法
    变量 = 字典名[键]
  • 说明
    没有键则错误

2.4、遍历字典

说明:查找元素前,一定要先使用in判断

for 键名 in 字典名:
    字典名[键名]

for 键名,值名 in 字典名.items():
    语句

2.5、删除元素:

del 字典名[键]

2.6、获取所有值

for 值 in 字典名.values():
    语句    

2.7、字典推导式

  • 定义:
    使用简易方法,将可迭代对象转换为字典

  • 语法:
    {键:值 for 变量 in 可迭代对象}
    {键:值 for 变量 in 可迭代对象 if 条件}

  • 实例

    """
        两个列表,一个列表存名字,另一个列表存房间号
        然后名字做为键,房间号作为值
    """
    list01 = ['张三', '李四', '王五']
    list02 = [101, 102, 103]
    
    # 常规写法
    dict01 = {}
    for i in range(len(list01)):
        dict01[list01[i]] = list02[i]
    print(dict01)
    
    # 字典推导式
    dict02 = {list01[i]: list02[i] for i in range(len(list01))}
    print(dict02)
    

2.8、字典 VS 列表

  • 都是可变容器。
  • 获取元素方式不同,列表用索引,字典用键
  • 字典的插入,删除,修改的速度快于列表
  • 列表的存储是有序的,字典的存储是无序的

2.9、字典基础操作示例

# ---------- 1、创建字典 ----------
# 创建空字典
dict01 = {}
dict01 = dict()

# 创建具有默认值
dict02 = {"zs":18,"ls":20,"ww":23}
list01 = [["a","b"],("c","d")]
dict02 = dict(list01)

# ---------- 2、添加元素 ----------
dict02["键"] = "值"

# ---------- 3、修改元素 ----------
dict02["键"] = "值2"

# ---------- 4、删除元素 ----------
del dict02["键"]

# ---------- 5、查找单个元素 ----------
# 在查找元素时,如果字典中不存在该键,则错误, 所以查找前,一定通过in判断
if "zs" in dict02:
    print(dict02["zs"])
else:
    print("不存在")

# 获取字典中所有键
for key in dict02.keys():
    print(key)
    
# 获取字典中所有值
for value in dict02.values():
    print(value)
    
# 获取所有键与值
for key,value in dict02.items():
    print(key,value)

2.10、字典与列表嵌套使用实例

# 打印一个省份对应的景点
dict_info = {
    "西藏":
        {
            "城市": ["拉萨", "山南", "日喀则", '林芝', '阿里', '那曲', '昌都'],

            "景点": ["布达拉宫", "羊湖", "珠峰", "桃花谷", '冈仁波齐'],
        },
    "四川":
        {
            "城市": ["成都", "德阳", "绵阳", '自贡', '资阳'],

            "景点": ["青城山", "三星堆", "科技馆", "恐龙博物馆"],
        }
}
for item in dict_info["四川"]["景点"]:
    print(item)

1、元组(tuple)

1.1、定义

  • 元组由一系列变量组成的不可变序列容器
  • 不可变是指,一但创建就不可以再添加/删除/修改元素

1.2、基础操作

  • 创建空元组
    元组名 = ()
    元组名 = tuple()
  • 创建非空元组
    元组名 = (20,)
    元组名 = (1, 2, 3)
    元组名 = 100,200,300
    元组名 = tuple(可迭代对象)
  • 获取元素
    索引、切片
  • 遍历元组
    • 正向
      for 变量名 in 列表名:
      变量名就是元素

    • 反向
      for 索引名 in range(len(列表名)-1,-1,-1):
      元祖名[索引名]就是元素

1.3、 作用

  • 元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素
  • 元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小

1.4、应用

  • 变量交换的本质就是创建元组:
    x, y = (y, x )
  • 格式化字符串的本质就是创建元祖:
    "姓名:%s, 年龄:%d" % ("张三", 15)

1.5、元组操作示例

# ---------- 1、创建元组 ----------
# 创建空元组
tuple01 = ()
tuple01 = tuple()

# 创建具有默认值元组
# 如果元组只有一个元素,必须要在末尾添加逗号
tuple02 = (1,)
tuple02 = (1,2)

# 列表转元组
list01 = ["a","b"]
tuple02 = tuple(list01)

# 元组转列表
list02 = list(tuple02)

# 多个变量 = 序列
name01,name02 = ("张三","李四")

# ---------- 2、获取元素 ----------
tuple03 = ("a","b","c","d")
# 获取单个元素
print(tuple03[2]) # c

# 获取多个元素
print(tuple03[1:3]) # ("b","c")

# 获取所有元素
# # 正向
for item in tuple03:
    print(item)
    
## 反向
for i in range(len(tuple03)-1,-1,-1):
    print(tuple03[i])

2、字典 (dict)

2.1、定义

  • 字典由一系列键值对组成的可变散列容器
  • 散列:对键进行哈希运算,确定在内存中的存储位置,每条数据存储无先后顺序
  • 键必须惟一且不可变(字符串/数字/元组),值没有限制

2.2、基础操作

  • 创建字典:
    字典名 = {键1:值1,键2:值2}
    字典名 = dict (可迭代对象)
  • 添加/修改元素:
    • 语法:
      字典名[键] = 数据
    • 说明:
      • 键不存在,创建记录
      • 键存在,修改映射关系。

2.3、获取元素

  • 语法
    变量 = 字典名[键]
  • 说明
    没有键则错误

2.4、遍历字典

说明:查找元素前,一定要先使用in判断

for 键名 in 字典名:
字典名[键名]

for 键名,值名 in 字典名.items():
语句

2.5、删除元素:

del 字典名[键]

2.6、获取所有值

for 值 in 字典名.values():
语句

2.7、字典推导式

  • 定义:
    使用简易方法,将可迭代对象转换为字典

  • 语法:
    {键:值 for 变量 in 可迭代对象}
    {键:值 for 变量 in 可迭代对象 if 条件}

  • 实例

    """
        两个列表,一个列表存名字,另一个列表存房间号
        然后名字做为键,房间号作为值
    """
    list01 = ['张三', '李四', '王五']
    list02 = [101, 102, 103]
    
    # 常规写法
    dict01 = {}
    for i in range(len(list01)):
        dict01[list01[i]] = list02[i]
    print(dict01)
    
    # 字典推导式
    dict02 = {list01[i]: list02[i] for i in range(len(list01))}
    print(dict02)
    

2.8、字典 VS 列表

  • 都是可变容器。
  • 获取元素方式不同,列表用索引,字典用键
  • 字典的插入,删除,修改的速度快于列表
  • 列表的存储是有序的,字典的存储是无序的

2.9、字典基础操作示例

# ---------- 1、创建字典 ----------
# 创建空字典
dict01 = {}
dict01 = dict()

# 创建具有默认值
dict02 = {"zs":18,"ls":20,"ww":23}
list01 = [["a","b"],("c","d")]
dict02 = dict(list01)

# ---------- 2、添加元素 ----------
dict02["键"] = "值"

# ---------- 3、修改元素 ----------
dict02["键"] = "值2"

# ---------- 4、删除元素 ----------
del dict02["键"]

# ---------- 5、查找单个元素 ----------
# 在查找元素时,如果字典中不存在该键,则错误, 所以查找前,一定通过in判断
if "zs" in dict02:
    print(dict02["zs"])
else:
    print("不存在")

# 获取字典中所有键
for key in dict02.keys():
    print(key)
    
# 获取字典中所有值
for value in dict02.values():
    print(value)
    
# 获取所有键与值
for key,value in dict02.items():
    print(key,value)

2.10、字典与列表嵌套使用实例

# 打印一个省份对应的景点
dict_info = {
    "西藏":
        {
            "城市": ["拉萨", "山南", "日喀则", '林芝', '阿里', '那曲', '昌都'],

            "景点": ["布达拉宫", "羊湖", "珠峰", "桃花谷", '冈仁波齐'],
        },
    "四川":
        {
            "城市": ["成都", "德阳", "绵阳", '自贡', '资阳'],

            "景点": ["青城山", "三星堆", "科技馆", "恐龙博物馆"],
        }
}
for item in dict_info["四川"]["景点"]:
    print(item)

3、集合(set)

3.1、定义

  • 集合是由一系列不重复的不可变类型的变量(元组/数/字符串)组成的可变散列容器
  • 集合相当于只有键没有值的字典(键则是集合的数据)

3.2、作用

  • 数据去重复
  • 数据计算

3.3、基础操作

  • 创建空集合:
    集合名 = set()
    集合名 = set(可迭代对象)

  • 创建具有默认值集合:
    集合名 = {1, 2, 3}
    集合名 = set(可迭代对象)

  • 添加元素:
    集合名.add(元素)

  • 删除元素:
    集合名.remove(元素)
    集合名.discard(元素)

3.4、运算

  • 交集 &:返回共同元素。
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s3 = s1 & s2 # {2, 3}

  • 并集 |:返回不重复元素
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s3 = s1 | s2 # {1, 2, 3, 4}

  • 补集 -:返回只属于其中之一的元素
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s1 - s2 # {1} 属于s1但不属于s2

  • 补集 :返回不同的的元素(对称补集)
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s3 = s1
    s2 # {1, 4} 等同于(s1-s2 | s2-s1)

  • 子集<:判断一个集合的所有元素是否完全在另一个集合中

  • 超集>:判断一个集合是否具有另一个集合的所有元素
    s1 = {1, 2, 3}
    s2 = {2, 3}
    s2 < s1 # True
    s1 > s2 # True

  • 相同或不同== !=:判断集合中的所有元素是否和另一个集合相同。
    s1 = {1, 2, 3}
    s2 = {3, 2, 1}
    s1 == s2 # True
    s1 != s2 # False

    子集或相同,超集或相同 <= >=

3.5、集合_示例

# 创建空集合
s01 = set()

# 创建具有默认值的集合
s02 = {"a","b"}
s02 = set("abcabc")
tuple02 = tuple(s02)

# 增加
s02.add("zs")

# 删除
s02.remove("zs") # 如果没有该元素 则报错

# 获取所有
for item in s02:
    print(item)

# 数学运算
# 交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
print(s3)

# 并集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}

# 对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4}  等同于(s1-s2 | s2-s1)

# 补集
print(s2 - s1) # {4}
print(s1 - s2) # {1}

# 子集超集
s1 = {1, 2, 3}
s2 = {2, 3}
print(s2 < s1) # True
print(s1 > s2) # True

3.6、集合推导式

  • 定义:
    使用简易方法,将可迭代对象转换为集合。

  • 语法:
    {表达式 for 变量 in 可迭代对象}
    {表达式 for 变量 in 可迭代对象 if 条件}

4、固定集合 frozenset

  • 定义
    不可变的集合

  • 作用
    固定集合可以作为字典的键,还可以作为集合的值。

  • 基础操作
    创建固定集合:frozenset(可迭代对象)

  • 运算
    等同于set