python的字典与集合_python集合和字典的区别

1.集合

首先记住：集合是一个无序的不重复元素序列。
集合的元素必须时不可变数据类型！
空集合不能使用{}, 而要使用set()
只显示一次出现过的数字！
1,2,3,4,1,2,3，4，3，2 = 1,2,3,4

接下来创建一个集合！

s = {1, 2, 3, 1, 2, 3}
print(s, type(s))

结果如下：

若在集合里面加入可变元素就会报错！

空集合不能使用{}，它会显示是个字典！ 而要使用set()
结果如下：

集合的特点

集合不支持 加 ，index, slice
支持in和not in
例如：

集合中常用的操作

1.增加
往集合中添加元素：有add,update两种方式！！

i = {1,2,3}
i.add(5)
print(i)

i.update({3,5,7})
print(i)
1
2
3
4
5
6

结果如下：

2.删除

三种方式：
remove,pop,discard!!!

  remove: 如果元素存在，删除，否则报错
 discard: 如果元素存在，删除，否则do nothing
 pop: 随机删除元素，集合为空则报错
1
2
3

操作如下：

但是，当remove不存在的元素。discard不存在的元素：

s = {1,2,3,4}
s.discard(5)
print(s)
s = {1,2,3,4}
s.remove(5)
print(s)
1
2
3
4
5
6

结果如下：
discard:不会报错

remove:会报错！！

集合间的关系：

差集: s1 - s2
交集: s1 & s2
对称差分: s1 ^ s2
并集: s1 | s2
s1.issubset(s2):判断s1是否是s2的子集！！
isdisjoint的功能：
判断两个集合是否包含相同的元素，如果没有返回True，否则返回False

s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 - s2)
print(s1 & s2)
s1 = {6, 5, 3}
s2 = {1, 2, 4}
print(s1 ^ s2)
print(s1 | s2)
print(s1.issubset(s2))
print(s1.isdisjoint(s2))
1
2
3
4
5
6
7
8
9
10

结果如下:

练习

题目：
小明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从大到小排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

import random
N = int(input("input your num ! "))
s = set()
for item in range(N):
    s.add(random.randint(1,1000))
s = sorted(s)
print(s)
1
2
3
4
5
6
7

因为输入1-1000的数字！
所以需要输入N转化为int
结果如下：

frozenset：不可变的集合

frozenset 是 set 的不可变版本，因此 set 集合中所有能改变集合本身的方法（如 add、remove、discard、xxx_update 等），frozenset 都不支持；
set 集合中不改变集合本身的方法，fronzenset 都支持。
frozenset 的这些方法和 set 集合同名方法的功能完全相同。

frozenset 的作用主要有两点：

1，当集合元素不需要改变时，使用 frozenset 代替 set 更安全。

2，当某些 API 需要不可变对象时，必须用 frozenset代替set。比如 dict 的 key 必须是不可变对象，因此只能用 frozenset

3,再比如 set 本身的集合元素必须是不可变的，因此 set 不能包含 set，set 只能包含 frozenset。

例如：

s = frozenset({1,2,3,4})
print(s,type(s))
1
2

执行的结果如下：

字典

字典是另一种可变容器模型，且可存储任意类型对象。
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

先创建字典！

d = {'name':'westos','age':18,'obj':'linux'}
print(d,type(d))
d = {}
print(d,type(d))

1
2
3
4
5

结果如下：
字典和集合的区别在于：字典里的元素中间用：来解释！
集合之间只有逗号隔开！

字典的特点

不支持+,*, index, slice(因为集合无序不重复的)
持in和not in

如：

d = {'name':'linux','age':20,'obj':'python'}
print('name' in d)
print('city' in d)
1
2
3

字典的用法

首先：字典的查看

查看所有：keys,values,items
看局部：d[key],d.get(key),d.get(key,default-value)

因为字典是由key-values组成的！！

d = {'name':'linux','age':20,'obj':'python'}
print(d.keys()) # 查看字典所有的key值
print(d.values()) #查看字典所有地value值
print(d.items())#查看字典所有地key-value值（items 元素）

print(d['name']) #查看key-name对应地value值
print(d.get('name')) #查看key-name对应地value值
print(d.get('city','xian')) ##查看key对应地value值，如果存在返回，如果不存在返回默认值

print(d.get('province')) #查看key对应地value值，如果存在返回，如果不存在返回None
1
2
3
4
5
6
7
8
9
10

结果如下：

增加，修改

增加的方式比较简单！

d = {"name":"linux","age":18}
d['city'] = "xian" # key不存在就添加
print(d)
1
2
3

修改：

d = {"name":"sun","age":18}
d['city']= "xian" # key不存在就添加
print(d)
d['city'] = "成都"  # key存在就修改
print(d)
1
2
3
4
5

还有一种添加的方式
若是不存在就添加，存在的话就什么都不做（就是不改变！）

d = {"name":"linux","age":18}
d.setdefault('city',"xian") # key不存在就添加
print(d)
d.setdefault('city','chengdu') #key存在do nothing
print(d)
1
2
3
4
5

结果如下：

删除

删除的两种方式：
先定义字典 d!!

1,一种和集合一样d.pop( )
2,另一种del d[ ]

d = {"name":"linux","age":18}
d.pop('name')
print(d)
d = {"name":"linux","age":18}
del d['age']
print(d)
1
2
3
4
5
6

结果如下：

遍历字典

就是for循环！
例如：

d = {"name":"linux","age":18,'city':'xian'}
for item in d: # 默认情况下，字典只会遍历key值
    print(item)
for item in d.items(): #如果遍历字典地key和value值
    print(item)
for key,value in d.items():
    print(f"key={key},value={value}")
1
2
3
4
5
6
7

结果如下：

练习题

两数之和：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

    给定 nums = [2, 7, 11, 15], target = 9
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]
1
2
3
4
5

思路如下：

从给定列表中依次不放回的取出一个数字,取一个新列表（mirror）存放这个数字，用target减去该数字，看差值是否在所给列表中。若在，将差值也存放在mirror中，然后找出这两个值在给定列表中的位置并输出；若不在，将mirror中的数字弹出(我用的remove)，继续下一个数字。相当于遍历的方法。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            dif = target - i
            if dif in nums:
                return [nums.index(dif), nums.index(i)]
1
2
3
4
5
6
7
8
9
10
11

测试结果如下：

拓展：defaultdict

collections.defaultdict类，本身提供了默认值的功能， 默认值可以是整形，列表，集合等.

defaultdict 是 dict 的子类。但它与 dict 最大的区别在于，如果程序试图根据不存在的 key 访问 value，会引发 KeyError 异常；
而 defaultdict 提供default_factory 属性，该为不存在的 key 来自动生成生成默认的 value。

问题

需要将一个key映射到多个值的字！！

方式：
可以用到刚才所说的：
collections.defaultdic

操作如下：

from collections import defaultdict
d = defaultdict(list)
d['allow_users'].append("user1")
print(d)

d = defaultdict(set)
d['love_movies'].add("你好 李焕英")
print(d)
1
2
3
4
5
6
7
8

结果如下：
能够映射两种类型！

练习

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

str0 = input("请输入一组字符串：")
def flongest(str):
    list0=[]
    length=len(str) 
    for i in range(length):
        sum = str[i]
        for j in range(i+1, length):
            if str[j] not in sum:
                sum += str[j]
            else:
                break
        list0.append(sum)
    N=len(list0)
    for n in range (N):
        for m in range(n+1,N):
            if len(list0[n])<len(list0[m]):
                list0[n],list0[m]=list0[m],list0[n]
    return list0[0]
longest_str=flongest(str0)
longest_str_length=len(flongest(str0))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

执行结构如下：