python 字典_集合

Ctrl + / #快速注释

拷贝：深拷贝、浅拷贝

eg:
n1 = [1,2,3]
n2 = n1
n1.append (4)
print(n2)
结果：
1,2,3,4

n1 = [1,2,3]
n2 = n1.copy()  #n1和n2的储存空间不同
print(id(n1),id(n2))   #id(n1) n1的内存空间id
n1.append(4)
print(n2)
结果：
1540531179712 1540531180800
[1, 2, 3]

为什么要用深拷贝？

如果我们拷贝时，列表的元素包含可变数据类型，一定要是用深拷贝

n1 = [1,2,[3,1]]
n2 = n1.copy()
print(id(n1),id(n2))
n1[-1].append(4)  #n1 = [1,2[3,1,4]]
print(n2)
结果：
2480062092544 2480062403648
[1, 2, [3, 1, 4]]  #n2的值发生改变

注：浅拷贝(n1.copy)拷贝的是地址，不会拷贝地址指向的值；深拷贝（copy.deepcopy()）值和地址都会拷贝
赋值：创建一个对象的新应用，修改其中一个另一个也会改变（n1=n2）

可变数据类型：list
可以增删改查，a.append(4) a的内存id不会改变

不可变数据类型：数值，str，tuple，nametuple
不可变数据类型，变量指向内存空间的值不会改变 #当给a重新赋值时

如何实现深拷贝：

import copy
n1 = [1,2,[3,1]]
n2 = copy.deepcopy(n1)
print(id(n1),id(n2))
n1[-1].append(4)  #n1 = [1,2[3,1,4]]
print(n2)
结果：
2416382921728 2416382919424
[1, 2, [3, 1]]

集合

无序的****不重复的元素序列
集合
1.集合得创建
#注意点1：集合的元素必须是不可变数据类型

s = {1,2,3,{1,2,3}}
print(s,tupe(s))
结果：
   s = {1,2,3,{1,2,3}}
TypeError: unhashable type: 'set'

#注意点2：空集合不能使用{}，而要使用set（）

s=set()
print (s,type(s))
结果：
set() <class 'set'>

2，集合的特性

#集合不支持 +（连接），*（重复），index（索引）。slice（切片）
#支持in和not in
print(1 in {1,2,3})
ture

3.集合常用的操作
#3.1 增加

s= {1,2,3}
s.add(100)
print(s)
t={4,5,6}
t.update({1,2,3})
print(t)
结果：
{1, 2, 3, 100}
{1, 2, 3, 4, 5, 6}

#3.2删除
remove #元素存在删除。没有报错

s= {1,2,3}
s.remove(3)
print(s)
s.remove(100)
print(s)

discord #删除，元素不存在跳过
s.discord(1)
pop #随机删除一个元素，没有元素报错

#3.1查看
差集：s1 - s2
交集：s1 & s2
堆成差分：s1 ^ s2 #并集减交集
isdisjoint（）

s1 = {1,2,3}
s2 = {1,2}
print(s1 - s2)
print (s1 & s2)
s2 = {1,2,4}
print(s1^s2)  # {1,2,3,4}-{1,2}
print(s1 | s2)
print(s1.isdisjoint(s2))  #s1 s2 是否没有交集
结果：
{3}
{1, 2}
{3, 4}
{1, 2, 3, 4}
False

练习：
随机生成n个1到1000之间的整数（n<=1000）,对于重复的数字只保留一个，再将这些数字按从大到小排列。

import  random
n = int(input("please input n:"))
s = set ()
for i in range(n):
    s.add(random.randint(1,1000))
print(sorted(s,reverse=True))  
结果：
please input n:10
[695, 570, 509, 442, 389, 215, 165, 107, 91, 37]

frozenset #不可变的集合

#不可以进行增加删除

s= frozenset({1,2,3})
print(s,type(s))
结果：
frozenset({1, 2, 3}) <class 'frozenset'>

字典

可变的数据类型、可储存任意类型数据

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

1.字典的创建 dict
#key-vaiue对或键值对

d  = {"name":"westos","age":"23","city":"beijing"}
print(d,type(d))
结果：
{'name': 'westos', 'age': '23', 'city': 'beijing'} <class 'dict'>

2.字典的特性
#不支持 +（连接），*（重复），index（索引）。slice（切片）
#支持 in 和not in

d  = {"name":"westos","age":"23","city":"beijing"}
print(d,type(d))
print('name' in d)  #判断是否为所有key的成员
print("westos" in d)
结果：
{'name': 'westos', 'age': '23', 'city': 'beijing'} <class 'dict'>
True
False

3.字典的常用方法
3.1 查看

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

d  = {"name":"westos","age":"23","city":"beijing"}
print(d.keys())     #查看字典的所有的key值
print(d.values())  #查看字典的所有的values值
print(d.items())   #查看字典的所有的key-values值
print(d['name'])   #查看key为name对应的values值
print(d.get('province'))    #查看key对应的value值，if存在则返回，不存在返回none
print(d.get('province',"陕西"))  #查看key对应的value值，if存在则返回，不存在返回默认值 陕西
print(d.get('name'))
结果：
dict_keys(['name', 'age', 'city'])
dict_values(['westos', '23', 'beijing'])
dict_items([('name', 'westos'), ('age', '23'), ('city', 'beijing')])
westos
None
陕西

3.2 增加
d[ ] , d.setdefatlt( , )

d  = {"name":"westos","age":"23","city":"beijing"}
d['province'] = '西安'    #key不存在 添加
print(d)
d['name'] = 'linux'      #key存在 更改
print(d)
d.setdefault("sex","male")  #key 不存在添加
print(d)
d.setdefault('city',"xian")  #key存在do nothing
print(d)
结果：
{'name': 'westos', 'age': '23', 'city': 'beijing', 'province': '西安'}
{'name': 'linux', 'age': '23', 'city': 'beijing', 'province': '西安'}
{'name': 'linux', 'age': '23', 'city': 'beijing', 'province': '西安', 'sex': 'male'}
{'name': 'linux', 'age': '23', 'city': 'beijing', 'province': '西安', 'sex': 'male'}

3.3 删除

d  = {"name":"westos","age":"23","city":"beijing"}
d.pop('name')
print(d)
d  = {"name":"westos","age":"23","city":"beijing"}
del d['name']
print(d)
结果：
{'age': '23', 'city': 'beijing'}
{'age': '23', 'city': 'beijing'}

4.遍历字典
#默认情况下字典只会遍历key值

#默认遍历key
d  = {"name":"westos","age":"23","city":"beijing"}
for i in d :
    print(i)

d  = {"name":"westos","age":"23","city":"beijing"}
for i in d.items():
    print(i)

#如何遍历字典的key和value 
d  = {"name":"westos","age":"23","city":"beijing"}
for i,n in d.items():
    print(f"key={i},value={n}")
结果：
name
age
city
('name', 'westos')
('age', '23')
('city', 'beijing')
key=name,value=westos
key=age,value=23
key=city,value=beijing

练习：

defaultdict （默认字典,设置默认value）

from  collections import defaultdict

d = defaultdict(int)
print(d['views'])      #默认value值0
d['views'] += 1
d['transfer'] += 1
print(d)

d = defaultdict(list)  #列表
d['allow_users'].append('westos')
d['deny_users'].extend(['user1', 'user2', 'user3'])
print(d)

d = defaultdict(set)  #集合
d['love_moves'].add('呵呵')
d['dislike_moves'].update({'fei', 'yu'})
print(d)

结果：
0
defaultdict(<class 'int'>, {'views': 1, 'transfer': 1})
defaultdict(<class 'list'>, {'allow_users': ['westos'], 'deny_users': ['user1', 'user2', 'user3']})
defaultdict(<class 'set'>, {'love_moves': {'呵呵'}, 'dislike_moves': {'fei', 'yu'}})

内置数据类型总结：

1.可变不可变
可变数据类型：list 、set、dict
不可变数据类型：数值类型、tuple、str

2.序列（有序、无序）和非序列

3、

#题目
1.两数之和
2.无重复最长子串