元组和字典

元组和字典

元组

1.什么是元组

元组是不可变的列表

元组也是容器型数据类型，将（）作为容器标志多个元组之间用逗号隔开：（元素1，元素2，元素3.。。。）

元组不可变（不能增删改）；元组是有序的（支持下标操作）

元组中的元素要求和列表一样（具体看列表笔记）

1. 空元组

tuple = （）
int（type（tuple））

2. 单个元素的元组

st1=[1]   # 单个元素的列表
tuple2 = (10,)  # 单个元素的元组（元素后加逗号）
print(tuple2, type(tuple)) # (10,) <class 'tuple'>

3. 多个元素的元组

tuple3 = (10, 20, 30)
print(tuple3, type(tuple3))  # (10, 20, 30) <class 'tuple'>
# 变量 = 元素1，元素2，元素3，...
tuple4 = 10, 20, 30
print(tuple4, type(tuple4))  # (10, 20, 30) <class 'tuple'>

2.获取元组中的元素

1. 列表获取元素的方法元组都能用

# a.获取单个元素
# 元组[下标]
names = 1, 2, 3, 4
print(names[1])
# b.切片
print(names[1::])  # (2, 3, 4)
# c.遍历
for x in names:
    print(x)

2. 其他方式（同样适用于列表）

# a. 变量1,变量2,变量3...... = 元组
# 注意:变量的个数要和元组中元素的个数保持一致
tuple6 = (11, 22, 33)
x, y, z = tuple6
print(x, y, z)  # 11 22 33
# b.变量1,变量2,变量3...... = 元组
# 前面变量的个数小于元组中元素的个数,并且有且只有一个变量前面有  *  .
nums = (2, 3, 4, 5, 6)
num1, num2, *num3 = nums
print(num1, num2, num3)  # 2 3 [4, 5, 6]
num4, *num5, num6 = nums
print(num4, num5, num6)  # 2 [3, 4, 5] 6
# 补充:*的解包功能
list1=(10,20,30)
print(*list1)   # 10 20 30   (等同于print(10,20,30))

注：列表相关操作都适用于列表

字典基础

1.什么时候用字典

需要同时保存多个数据，并且多个数据意义不同（需要做区分）

1. 什么是字典

字典是容器型数据类型，将{}作为容器的标志，多个元素用逗号隔开（字典元素都是键值对）{键1：值1，键2，值2，。。。}

# 格式:{键1:值1,键2:值2,键3:值3,键4:值4......}

字典是可变的（支持增删改）；字典是无序的（不支持下标操作）

字典中的元素“键值对

键 – 不可变，唯一的（一般是字符串）

值 – 任何类型的数据，可重复

字典在保存数据的时候，真正保存的是值，键用来对之进行区分和说明

# 空字典
dict1 = {}
dict2 = {1: 456, 2: 65, 3: 52, 4: 19}
print(dict2)
print({'a': 1, 'b': 2} == {'b': 2, 'a': 1})  # True

2. 获取字典的值

获取字典单个元素对应的值

a.字典[key] – 获取字典中指定 key 对应的值(如果key不存在会报错)

dog = {'name': '阿黄', 'age': 3, 'breed': '土狗', 'gander': '母', 'weight': 10}
print(dog['name'])  # 阿黄
print(dog['breed'])  # 土狗

字典.get(key)  -  获取字典中指定  key 对应的值(如果key不存在不会报错,返回  None)
字典.get(key,默认值)  -- 获取字典中指定key对应的值(如果key不存在不会报错,返回  默认值)

print(dog.get('age'))  # 3
print(dog.get('height'))  # None
print(dog.get('height', 50))  # 50

2. 遍历

for 变量 in 字典:
    循环体

注意：变量取到的是字典中的所有的key

dog = {'name': '阿黄', 'age': 3, 'breed': '土狗', 'gander': '母', 'weight': 10}
for x in dog:
    print(x, dog[x], end=' ')  
    # name 阿黄 age 3 breed 土狗 gander 母 weight 10   
print() 

"""
b.
其他两种情况1
for 变量 in 字典.values():
    循环体

变量取到的是字典所有的值
"""
for x in dog.values():
    print(x, end='')  # 阿黄3土狗母10
print()


"""
b.
其他两种情况2
for 变量1,变量2 in 字典.items():
    循环体

变量1取到字典所有的key,变量2取到的是字典所有的值
"""
print('==============')
for x, y in dog.items():
    print(x, y, end=' ')  # name 阿黄 age 3 breed 土狗 gander 母 weight 10
print()

练习1:声明一个变量,同时保存四个学生的信息(每个学生需要包含:姓名\年龄\电话\成绩)

练习2:统计上面四个学生中未成年人的个数

students = [
    {'name': '张一', 'age': '22', 'number': '110', 'score': '98'},
    {'name': '张二', 'age': '14', 'number': '120', 'score': '91'},
    {'name': '张三', 'age': '20', 'number': '130', 'score': '32'},
    {'name': '张四', 'age': '17', 'number': '140', 'score': '59'}
]
count = 0
for stu in students:
    if stu['age'] < 18:
        count += 1
print('未成年人个数为:', count)

字典元素的增删改查

1. 增/改

"""
语法:
字典[key]=值

如果key存在,就将key对应的值修改成指定的值(改)
如果key不存在,以'key:值'的形式添加一盒键值(增)
"""

2. 删

字典.move.pop

字典的相关操作

字典相关操作

字典不支持加法乘法运算

1. 比较运算

字典只支持比较相等不支持比较大小

print({'a':1,'b':2}=={'b':2,'a':1})  # True

2. in 和 not in

# 数据 in 字典  --  判断字典中是否存在指定的key
# 数据 not in 字典   -- 判断字典中是否不存在指定的key

3. 相关函数

len(字典) -- 统计字典中键值对的个数
dict（数据） -- 将指定数据转换为字典
数据的要求：是容器型数据类型，数据中元素是两个小元素（小容器），小容器中的第一个元素是不可变的

x = [(1, 2), (3, 4), (5, 6)]
dict1 = dict(x)
print(dict1)  # {1: 2, 3: 4, 5: 6}

x = ('xy', 'qw', 'ds')
dict1 = dict(x)
print(dict1)  # {'x': 'y', 'q': 'w', 'd': 's'}

字典转换成其他类型
bool（字典）     -- 空字典为False
list（字典）     -- 将所有的key转换为列表的元素
tuple（字典）    -- 将所有的key转换为元组的元素

2.相关操作

1. 字典.clear() – 清空字典
2. 字典.copy() – 复制字典产生一个新的字典
3. dict.formkeys() – 创建一个字典

# dict.fromkeys(序列)   -- 创建一个新的字典,字典中的key是序列中的元素,值是None
# dict.fromkeys(序列,值)   -- 创建一个新的字典,字典中的key是序列中的元素,值是指定的值

dict3 = dict.fromkeys('asd')
print(dict3)  # {'a': None, 's': None, 'd': None}
dict4 = dict.fromkeys('qwe', 1)
print(dict4)  # {'q': 1, 'w': 1, 'e': 1}

4. items,keys,values

"""
字典.keys()    -- 获取字典中所有的key，返回一个容器（这个容器不是列表）
字典.values()  -- 或取字典中所有的值，返回一个容器（不是列表）
字典.items()   -- 获取字典中所有的key和值，返回一个容器，容器中的元素是元组，没一个元组对应一个键值对（不是列表）

"""

5. update

字典.update()序列 – 用序列生产字典去更新原字典（更新方式：添加或修改）

dict5 = {'q': 1, 'w': 1, 'e': 1}
dict5.update({'q': 100, 'r': 6})
print(dict5)  # {'q': 100, 'w': 1, 'e': 1, 'r': 6}

集合

1.什么是集合

集合是可变的容器型数据类型，将{}作为容器的标志，里面多个元素用都有号隔开：{元素1，元素2，元素3…}

集合是可变的（支持增删改），集合是无序的（不支持下标操作）

注意：

set1={} — 这是空字典

empty = set() – 空集合

非空集合

set1 = {1, 3, 9}
set2 = {1, 2, 3, 1, 2}
print(set2)  # {1, 2, 3}  (元素是唯一的不能重复)

print({1, 2, 3} == {3, 2, 1})  # True  (集合是无序的)

2. 集合中的增删改查

   1）查

   集合没有办法直接获取单个元素只能遍历

   """
   for 变量 in 集合:
       循环体
   
   变量取到的就是集合中的每个元素
   
   """
   

nums = {1, 31, 56, 4, 2}
for x in nums:
    print(x, end=' ')  # 1 2 4 56 31

2）增

"""
集合.add(元素)  -- 在集合中添加指定元素
集合.update(序列)   -- 将序列中的元素全部添加到集合中
"""
nums = {1, 31, 56, 4, 2}
nums.add(100)
print(nums)  # {1, 2, 4, 100, 56, 31}
nums.update('dfg')  
print(nums)  # {1, 2, 4, 100, 'g', 'd', 56, 'f', 31}

chuzai

3）删

集合.remove( 元素)  --  删除集合中指定元素（元素不存在会报错）
集合.discard(元素)  --  删除集合中指定元素（元素不存在不会报错）

nums = {10, 20, 30, 40}
nums.remove(10)
nums.discard(20)
print(nums)  # {40, 30}
# nums.remove(100)   # 报错
nums.discard(100)  # 不报错

4)改 – 集合无法修改

3. 数学集合运算

python中的集合支持数学运算：

& （交集） | （并集） - （求差集） ^(对称差集) >/<（判断是否是真子集）

1）交集：求两个集合的公共部分

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)  # {4, 5}

2. 并集

print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}

3）差集

print(set1 - set2)  # {1, 2, 3}
print(set2-set1)    # {8, 6, 7}

4）对称差集：去掉公共部分

print(set1^set2)  # {1, 2, 3, 6, 7, 8}

5）真子集

集合1 > 集合2 – 判断集合2是否是集合1的真子集
集合1 < 集合2 – 判断集合1是否是集合2的真子集