元组

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

  • 基础操作
# 1. 创建
# -- 元组名 = (元素1, 元素2, 元素3)
tuple01 = (10, 20, 30)
# -- 元组名 = tuple( 可迭代对象 )
list01 = ["a", "b", "c"]
tuple02 = tuple(list01)
# 2. 定位
# -- 读取(索引／切片)
print(tuple01[0]) # 10
print(tuple01[:2]) # (10, 20)
# 3. 遍历
for item in tuple01:
print(item)
for i in range(len(tuple01) - 1, -1, -1):
print(tuple01[i])
# 4. 特殊
# 注意1：小括号可以省略
tuple03 = 10, 20, 30
# 注意2：如果元组中只有一个元素,必须有逗号
tuple04 = (10,)
# 拆包: 多个变量 = 容器
# a,b,c = tuple03
# a,b,c = ["A","B","C"]
a,b,c = "孙悟空"
*a,b = "孙悟空"
print(a) # ['孙', '悟']
print(b) # 空

作用

  • 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素
  • 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小
  • 变量交换的本质就是创建元组：x, y = (y,x)
  • 格式化字符串的本质就是创建元祖："姓名:%s, 年龄:%d" % ("tarena", 15)

字典

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

  • 基础操作
# 1. 创建
# -- { 键1:值1, 键2:值2 }
dict_wk = {"name": "悟空", "age": 25, "sex": "女"}
dict_bj = {"name": "八戒", "age": 26, "sex": "男"}
dict_xbl = {"name": "小白龙", "age": 23, "sex": "女"}
# -- dict( [( , ),( , )] )
# 列表转换为字典的格式要求：列表元素必须能够"一分为二"
list01 = ["八戒", ("ts", "唐僧"), [1001, "齐天大圣"]]
dict01 = dict(list01)
# 2. 添加 字典名[键] = 值
dict_wk["money"] = 100000
print(dict_wk) # {'name': '悟空', 'age': 25, 'sex': '女', 'money': 100000}
# 字典不能使用 索引 切片
# 3. 定位：字典名[键]
# -- 读取
print(dict_wk["name"])
# 注意：如果没有键则报错
# 解决：读取数据前,通过in判断.
if "money" in dict_wk:
print(dict_wk["money"])
# -- 修改(与添加数据语法相同)
# 具有key为修改,没有key为添加
dict_wk["name"] = "空空"
print(dict_wk) # {'name': '空空', 'age': 25, 'sex': '女', 'money': 100000}
# 4. 删除 del 字典名[键]
del dict_wk["sex"]
print(dict_wk) # {'name': '空空', 'age': 25, 'money': 100000}
# 5. 遍历
# 方式1：for 键 in 字典名称
for key in dict_wk:
print(key)
# 方式2：for 值 in 字典名称.values()
for value in dict_wk.values():
print(value)
# 方式3：for 键,值 in 字典名称.items()
for key,value in dict_wk.items():
print(key)
print(value)
# 数据类型名称( ... )
# [('name', '李佳豪'), ('age', 25), ('sex', '女')]
print(list(dict_wk.items())) # [('name', '空空'), ('age', 25), ('money',
100000)]

字典推导式

  • 定义：使用简易方法，将可迭代对象转换为字典。
# 语法
{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}

字典函数

  • https://www.runoob.com/python3/python3-dictionary.html
  • get(key, default=None) : 返回指定键的值，如果值不在字典中返回default值
  • setdefault(key, default=None) : 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
  • popitem() : 随机返回并删除字典中的一对键和值(一般删除末尾对)。
  • items() : 以列表返回可遍历的(键, 值) 元组数组
  • keys() : 返回一个迭代器，可以使用list()来转换为列表
  • values() : 返回一个迭代器，可以使用list()来转换为列表
  • update(dict2) : 字典记录累加
  • clear() : 删除字典内所有元素

集合

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

  • 基础操作
# 1. 创建
# -- 集合名 = {元素1,元素2,元素3}
set01 = {"悟空", "唐僧", "八戒"}
list01 = ["唐僧", "悟空", "唐僧", "八戒", "唐僧"]
# -- 集合名 = set(可迭代对象)
set02 = set(list01)
print(set02) # {'八戒', '悟空', '唐僧'}
# 2. 添加:集合名.add(元素)
set02.add("小白龙")
print(set02) # {'悟空', '八戒', '小白龙', '唐僧'}
# 定位
#(因为无序不能使用索引切片)
#(因为不是键值对不能使用键查找键)
# 3. 遍历
for item in set01:
print(item)
# 4. 删除
if "悟空1" in set01:
set01.remove("悟空1")

集合推导式

  • 使用简易方法，将可迭代对象转换为集合
# 语法
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}

运算

交集&：返回共同元素

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