Day06_Python_元组&字典&集合

一、dict字典

1、概念：

列表和元组的使用缺点：当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦：
解决方案：既能存储多个数据，还能在访问元素的很方便的定位到需要的元素，采用字典

语法： {键1: 值1, 键2: 值2, 键3: 值3, …, 键n: 值n}

说明：键值对: key-value

• 字典和列表类似，都可以用来存储多个数据
• 在列表中查找某个元素时，是根据下标进行的；字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典中的每个元素都由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
• 键可以使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表等可变数据类型
• 每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value

习惯使用场景：

• 列表更适合保存相似数据，比如多个商品、多个姓名、多个时间
• 字典更适合保存不同数据，比如一个商品的不同信息、一个人的不同信息

2、演示：

#Python数据类型
# int, float, bool, None, bytes,list
# dict, tuple, set, str

# 字典dict
# a. 里面的元素是一个健值对：key-value
# b. key有3个特点：
#       1，唯一
#       2，不可变类型
#       3，无序（没有下标）
# 1. 创建字典
d = {"name": "蔡徐坤", "age": 22, "height": 184}
# d = {0: 1, 1: 2, 1: 3}
print(d)

# 2. 查：通过key来查value
print(d['name'])
print(d.get('name'))
# print(d['sex'])  # 报错，没有key则报错
print(d.get('sex'))   # 没有key不报错，但是返回None
print(d.get('sex', "男"))   # 没有key不报错，返回默认值

key = "name"
print(d[key])   #  不要加引号，否则报错
print(d.get(key))

# 3、遍历字典
d = {"name": "蔡徐坤", "age": 22, "height": 184}
for k in d:
    print(k)   #key
# for k in d.keys():
#   print(k)   # key

for v in d.values():
    print(v)   # value

for k, v in d.items():    #  每一项
    print(k, v)   #  key value

k = d.keys()
print(k, list(k))  # dict_keys(['name', 'age', 'height']) ['name', 'age', 'height']
print(d.values())  # dict_values(['蔡徐坤', 22, 184])

# 4. 合并
# print({1:2} + {3:4})  #  c错误
d1 = {1: 2}
d2 = {3: 4}
d1.update(d2)    # 用来合并
print(d1)    # {1, 2, 3, 4}

# 5.增删改查
d = {"name": "蔡徐坤", "age": 22, "height": 184}
# 增
d['sex'] = '男'
print(d)    # {'name': '蔡徐坤', 'age': 22, 'height': 184, 'sex': '男'}

# 改
d['age'] = 30
print(d)    # {'name': '蔡徐坤', 'age': 30, 'height': 184, 'sex': '男'}

# 删
d.pop('age')   # 删除指定key的元素    {'name': '蔡徐坤', 'height': 184, 'sex': '男'}
# d.clear()    # 清空字典
# d.popitem()   # 删除最后一项，可以认为是随机删除一项，【了解】
# del d['age']
print(d)

# 查

#6、长度
print(len(d))

# 7、成员:判断的是key是否在字典中存在
print('name' in d)  # True

# 8、zip
d = dict(name="张三", age=30)
print(d)    # {'name': '张三', 'age': 30}
# zip
d = dict(zip(['name', 'age'], ['张三', 30]))   # {'name': '张三', 'age': 30}
d = dict(zip('123', 'abc'))   # {'1': 'a', '2': 'b', '3': 'c'}
print(list(zip(['name', 'age'], ['张三', 30])))   # [('name', '张三'), ('age', 30)]
print(d)
'''
# 列表和字典的区别：
    list:
        1、定义方式不同：[], 一般存放相同类型的数据
        2、内存相对字典较小
        3、当数据量较大时（特别是数据特别大时），查找所需时间越久
    dict:
        1、定义方式：{},一般是存放同一个事物的不同属性
        2、内存的消耗较大
        3、数据量不管多少，对查询速度影响不大
'''

二、tuple元组

1、概述：

和列表相似，本质上是一种有序的集合
元组和列表的不同之处：
a. 列表：[]. 元组：（）
b. 列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素一旦被初始化，将不能发生改变】

2、演示：

#   就是一个不可以改变的列表

# 1、创建元组
t = ()    #空元组
t = (1, )    #  包含1个元素的元组
t = (1, 2, 3, 'hello', True)
print(t, type(t))

# 2、下标
t = (11, 22, 33, 44)
print(t[0], t[1], t[2], t[3])
print(t[-1])

# 3、合并
print((1, 2)+ (3, 4))   #(1, 2, 3, 4)

# 4、重复
print((1, 2, 3)*3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# 5、长度
print(len(t))

# 6、 成员
print(33 in t)   # True

# 7、切片
t = (1, 2, 3, 4, 5, 6)
print(t[2:5])  #(3, 4, 5)
print(t[::-1])  #  (6, 5, 4, 3, 2, 1)

# 8、遍历
t = (11, 22, 33, 44)
for n in t:
    print(n)    # n是元素

for i in range(len(t)):
    print(i)   # 下标

t = (11, 22, 33, 44)
for i,n in enumerate(t):
    print(i, n)

# 其他功能
#增删改查
t = (11, 22, 33, 44)
# t[0] = 9    # 报错，不能修改

# 排序
t = (3, 2, 7, 1, 9)
t2 = sorted(t)    # 升序   # [1, 2, 3, 7, 9]
t2 = sorted(t, reverse=True)
print(t2)

t = (3, 2, 7, 1, 9)
t2 = reversed(t)   # [9, 7, 3, 2, 1]
print(list(t2))

# 列表和元组的转换
print(list((1, 2, 3)))   #[1, 2, 3]
print(tuple([1, 2, 3]))   # [1, 2, 3]

# 元组列表可以快速取值
x, y = (2, 3)
x, y = [2, 3]
print(x, y)    # 2  3

# 元组中有列表
t = (1, 2, [3, 4])

t[-1][0] = 0
print(t)

三、set集合

1、概念：

和数学上的集合基本是一样的，
特点:不允许有重复元素，可以进行交集，并集，差集的运算
本质：无序，无重复元素的集合

# 集合 set
#   1、无序
#   2、唯一：不能重复

# 1. 创建集合
s = {1, 2, 2, 2 ,3, 4}
print(s)   # {1, 2, 3, 4}

s = set()   # 空集合
print(s)

# 无序
s = {'a','b', 'c'}
print(s)

# 类型转换
# int（）
# float()
# str()
# list()
# tuple()
# dict()
# set()
l = [1, 2, 3]
l = (1, 2, 3)
l = "123"
l = {1: 2, 2: 3, 3:4}   # 只取key
print(set(l))

# 列表去重
l = [1, 2, 4, 4, 4, 3, 3, 5, 5, 5, 6]
l2 = list(set(l))
print(l2)     # [1, 2, 3, 4, 5, 6]

# 遍历
s = {11, 22, 33, 44}
for n in s:
    print(n)

# 长度
print(len(s))

# 增
s.add(55)
s.update([66, 77])
print(s)    # {33, 66, 11, 44, 77, 22, 55}

# 删
s.remove(33)   # {66, 11, 44, 77, 22, 55}
# s.discard(333)
s.clear()
print(s)

# 集合之间的关系
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1 & s2)   # 交集；  {3, 4}
print(s1 | s2)   # 并集    {1, 2, 3, 4, 5, 6}
print(s1 - s2)   # 差集     {1, 2}
print(s1 ^ s2)   # 对称差集   {1, 2, 5, 6}
print(s1 > s2)   # s1包含s2   False
print(s1 < s2)   # s2包含s1   False

四、排序算法

# 冒泡排序

"""
原理：
        【9,7,6,8,5,4,3,2,1】
    第一次     【9,7,6,8,5,4,3,2,1】 => 【7,6,8,5,4,3,2,1,9】
    第二次     【7,6,8,5,4,3,2,1,9】 =>  [6,7,5,4,3,2,1,8,9]
    第三次      [6,7,5,4,3,2,1,8,9] =>  [6,5,4,3,2,1,7,8,9]
    ...
    第八次     [2,1,3,4,5,6,7,8,9] =>   [1,2,3,4,5,6,7,8,9]
"""
nums = [9,7,6,8,5,4,3,2,1]
for i in range(len(nums)-1):  # i =0,1,2,3,4,5,6,7
    for j in range(len(nums)-1-i):
        if nums[j] > nums[j+1]:
            nums[j], nums[j+1] = nums[j+1], nums[j]
print(nums)

# 选择排序
"""
原理： 
                    【9,7,6,8,5,4,3,2,1】
    第一次：   【9,7,6,8,5,4,3,2,1】 =>   【1，9,7,6,8,5,4,3,2】
    第二次；    [1，9,7,6,8,5,4,3,2] =>   [1，2,9,7,6,8,5,4,3]
    第三次：    [1，2,9,7,6,8,5,4,3] =>   [1，2,3,9,7,6,8,5,4]
    ....
    第八次     [1,2,3,4,5,6,7,8,9]  =>    [1,2,3,4,5,6,7,8,9]
"""
nums = [9,7,6,8,5,4,3,2,1]
for i in range(len(nums)-1):  # i=0,1,2,3,4,5,6,7
    # 求剩下数中最小数的下标
    min_index = i
    for j in range(i, len(nums)):
        if nums[j] <  nums[min_index]:
            min_index = j

    # 用最小数和第i个元素交换
    nums[i], nums[min_index] = nums[min_index], nums[i]

print(nums)