元祖hash了解字典集合类型

Posted 2020-10-21 neozheng

元祖：

元组跟列表差不多，也是存一组数，只是它一旦创建，便不能再修改，所以又叫只读列表。

创建：

names = (\'neo\', \'mike\', \'eric\')

特性：

# 1.可存放多个值
# 2. 不可变。 元祖本身不可变，但，如果元祖中还包含其他可变元素，这些可变元素还可以改变。
# 3. 按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

功能：

1. index
2. count
3. slice（切片）

改变可变元素示例：

n = ( 1,2,5,8,[ \'a\', \'b\'], 9)
n[4][2] = \'B\'
# 则n就变成了  (1,2,5,8,[ \'a\', \'B\'], 9)

使用场景：

1. 显示的告知别人，此处数据不可修改

2. 数据连接配置信息等

 

Hash：

hash，被叫做“散列”或者“哈希”，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。 这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一地确定输入值。简单来说，就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

特征：

hash值的计算过程是依据这个值的一些特征计算的，这就要求被hash的值必须固定，因此被hash的值必须是不可变的

不可变类型：数字、字符串、元祖
可变类型：  列表、字典
语法： hash（\'abc\'） 

用途：

文件签名、

md5加密（密码明文变密文，md5的特性是无法反解）

密码验证

 

字典：

字典是一种key - value的数据类型，通过前面的key能够找出后面的value。

创建：

｛key1:value1,key2:value2｝

1、键与值用冒号“:”分开；
2、项与项用逗号“,”分开；
3. key的值不能重复 

查询字典的某条信息： 

info[key值]

修改字典某条信息：

dic = { \'neo\': [\'a\',\'b\',\'c\'], \'alex\': [ \'c\', \'m\',\'n\']}
dic[\'neo\'][1] = \'B\' 
# 则字典dic就变成了   {\'neo\': [\'a\', \'B\', \'c\'], \'alex\': [\'c\', \'m\', \'n\']} 

 特性：

1. key-value结构
2. key必须可hash，必须为不可变数据类型、必须唯一
3. 可以存放任意多个值，值可以修改，可以不唯一
4. 无序
5. 查找速度快

key必须可hash和查找速度快：计算机需要先利用hash把key值转化成一个数字，然后再利用“折半查找”（二分查找，算法的一种）的方式去找key的hash值，查询次数大概是2的n次方。（字典不是利用二分法）

字典添加：

dic[ key ] = value   #value可以是任意类型
info = {\'student1\': \' Tenglan Wu\', \'student2\': \'Cangjingkou\', \'student3\': \'Jiatengying\'}     
info[ \' student4\' ] = \'abc\'

# 则字典info变成： {\'student1\': \' Tenglan Wu\', \'student2\': \'Cangjingkou\', \'student3\': \'Jiatengying\', \' student4\': \'abc\'}  

修改：

info[student2] = \'苍井空\'
# 字典info变成： {\'student1\': \' Tenglan Wu\', \'student2\': \'Cangjingkou\', \'student3\': \'Jiatengying\', \' student2\': \'苍井空\'}     #添加的顺序是随机的，因为字典的无序性。 

查找：

# 1. 标准用法： 
\'student2\' in info      # in是新的语法，用于判断字典info里面是否有\'student2\'这个key值，输出" True" 或者" False "。
# 如：
if \'student2\' in info:   #  如果student2是info的key值

# 2. 获取用法1： 
info.get(\'student2\')   #  如果有该键值则获取键值对应的value， 如果没有则输出None；推荐使用这种

# 3. 获取用法2： 
info[\'student2\']    # 有该键值则获取该键值，没有则会报错。  所以通常使用 info.get() 

删除：

# 方式1：
info.pop(键值)  #删除该键值及其对应的值，并将其返回。# Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.
# 方式2：
info.popitem()   # 随机删除字典里的某个元素
# 方式3： 
del info[ 键值 ] 

修改：

字典多层嵌套修改：  

方法： 多层嵌套就是找到一级之后，再一层一层往下找，一个key一个key往下找。

其他方法：

info.clear()   # 清空字典
info.copy()   # 跟列表的copy一模一样
info.keys()   # 获取所有的key值,放到一个列表里面
info.values()   # 获取所有的value，放到一个列表里面
info.items()    #是把info所有的key和value放到一个小元祖里面。 
# 例：   info.items()  为  dict_items([(\'student1\', \' Tenglan Wu\'), (\'student2\', \'Cangjingkou\'), (\'student3\', \'Jiatengying\')])   #把这些元祖再放到一个列表里面

dic1.update(dic2)    #效果类似于列表里面list1.extend(list2)。    把dic2和dic1合并起来， 如果dic2和dic1有重复的key值， 就用dic2 key值所对应的value 覆盖 dic1 key值所对应的value，也就是所谓的update（更新）。

# 注：列表里的list1.extend( list2) 的效果 类似于  list1 += list2

info.setdefault( key1, value1)   #  如果key这个键值在info字典里面本来就存在，那么info没有变化； 如果key这个键值在info里面不存在， 就把键值为key1、value值为value1的元素添加到字典info里面

info.fromkeys( [\'key1\', \'key2\', \'key3\'] , value1]      #  批量往info字典里面添加“键值为key1，value值为value1”、“键值为key2，value值为value1”和“键值为key3，value值为value1”的元素， 如果不输入“ ,value ” ， 则往info里面就只添加了键值分别为key1、 key2和 key3但value值为None的元素。   

"""
classmethod fromkeys(seq[, value])
　　Create a new dictionary with keys from seq and values set to value.
　　fromkeys()is a class method that returns a new dictionary. value defaults to None.
"""

dict.fromkeys 的用法：https://zhuanlan.zhihu.com/p/38440589

字典的循环：

for k in info:
    print(k)      #  注意：  打印的只是键值key。 只是键值在循环。

for k in info:
    print( k, info[k] )     # 这种方式能把键值、value值都打印出来

 

集合类型：

示例：

iphone7 = [ \'alex\', \'rain\', \'jack\', \'old_driver\' ]
iphone8 = [ \'alex\', \'shanshan\', \'jack\', \'old_boy\' ]
如何找出同时买了iPhone7和8的人 ？ 

常规做法：  循环列表iphone7里面的人， 然后判断7里面的人是否在 iphone8里面 （交集）

iphone7 = [ \'alex\', \'rain\', \'jack\', \'old_driver\' ]
iphone8 = [ \'alex\', \'shanshan\', \'jack\', \'old_boy\' ]

#定义一个空列表：同时买了7和8的人
both_list = [ ]

#循环7里面的人，一个个判断这些人是否也在8里面，在的话就添加到both_list
for name in iphone7:
    if name in iphone8:    #if ...in.. 语法
        both_list.append(name)    print(both_list)  

#打印结果：
[\'alex\', \'jack\']

 找出只买了iPhone7的人？ （差集）

iphone7 = [ \'alex\', \'rain\', \'jack\', \'old_driver\' ]
iphone8 = [ \'alex\', \'shanshan\', \'jack\', \'old_boy\' ]

only7 = [ ]

for name in iphone7:
    if name not in iphone8:     #if...not in...语法
        only7.append(name)
print(only7)

#打印结果：
[\'rain\', \'old_driver\']

集合定义：

集合是一个无序的、不重复的数据组合，它的作用如下：

# 集合作用：
1. 去重，把一个列表变成集合，就自动去重了；
2. 关系测试，测试两组数据之间的交集、并集、差集等关系。

语法：  

s = {1,2,3,4,\'a\',\'b\'}   #中间没有冒号（：）
# 空集合的类型是“字典”， 但按照集合的语法定义后，类型就是“集合”了 。

假如我定义了如下集合：
s = { 1, 2, 2, 2, 2, 3}
它会自动变成  s = { 1, 2, 3 }

列表（元祖也可以转）转成集合：

set( list)
# 如：  
list1 = [ 1,2,3]
# set(list1) 就成了  { 1, 2, 3 }

添加：

s.add(元素)    # 如果添加的元素原集合中已存在，就添加不进去。  # 只能添加一个元素

删除：

s.pop( )    # 随机删除集合元素 
s.remove( 元素 )   #删除该元素， 如果该元素不存在则会报错
s.discard(元素）    #删除该元素， 如果该元素不存在也不会报错 

合并：

s1.update( s2)     # 表面上看是s1和s2的合并， 其实是把s2 update到s1中， 所以最后的结果是： s2不变， 但s1变成了s2和原先s1的合并。效果类似于 s1 += s2
# 也可以利用 s.update() 往集合里面添加列表， 如：
s1 = { 1,2,3, \'a\'}
s1.update( [\'A\',\'B\',\'C\' ] ) 
# s1就变成了 ： {1, 2, 3, \'A\', \'C\', \'B\', \'a\'}       #利用这种方式可以向集合里面批量 添加元素

清空：

s.clear( )      #  清空

判断集合关系：

交集：

# 交集1： 
s1.intersection( s2 )
# 并集2： 
s1 & s2

如上面的同时买了iPhone7和8的人：

iphone7 = [ \'alex\', \'rain\', \'jack\', \'old_driver\' ]
iphone8 = [ \'alex\', \'shanshan\', \'jack\', \'neo\' ]

print(set(iphone7).intersection(set(iphone8))) 

# 或者 print( iphone7 & iphone8 )

#输出结果： {\'jack\', \'alex\'}

差集：

# 差集1：
s1.difference(s2)   # s1对s2的差集   #s1和s2的位置不能互换
# 差集2： 
s1 - s2    # s1对s2的差集 

如上面只买了iphone7的人：

iphone7 = {\'alex\', \'rain\', \'jack\', \'old_driver\' }
iphone8 = { \'alex\', \'shanshan\', \'jack\', \'neo\' }

print(set(iphone7).difference(set(iphone8)))
# 或者  print(iphone7 - iphone8)

#输出结果： {\'old_driver\', \'rain\'}

并集：

# 并集1： 
s1.union( s2 )    #会自动去重
# 并集2:   
s1 | s2    

示例：

iphone7 = {\'alex\', \'rain\', \'jack\', \'old_driver\' }
iphone8 = { \'alex\', \'shanshan\', \'jack\', \'neo\' }

print(set(iphone8).union(set(iphone7)))

#输出结果：
{\'old_driver\', \'neo\', \'shanshan\', \'jack\', \'rain\', \'alex\'}

对称差集：

s1.symmetric_difference( s2 )    #  相当于s1和s2的并集 减去  s1和s2的交集   #s1和s2的位置互换不会影响最后结果

如： 只购买了 iphone7和iphone8中 一个型号的人  ：

iphone7 = {\'alex\', \'rain\', \'jack\', \'old_driver\' }
iphone8 = { \'alex\', \'shanshan\', \'jack\', \'neo\' }

print(set(iphone7).symmetric_difference(set(iphone8)))

#输出结果为：{\'neo\', \'shanshan\', \'rain\', \'old_driver\'}

子集关系：

# 子集1：  
s1.issubset( s2 )   #判断s1是否为s2的子集，
# 子集2：  s1<=s2;

超集（父集）：

# 超集1：  
s1.issuperset( s2 )    # 判断s1是否为s2的超集（父集）
# 超集2：  
s1>= s2 

判断关系： 

s1.isdisjoint( s2)    # 判断两个集合是否不相交
in,，not in：    # 判断某元素是否在集合内
== ，！= ：     # 判断两个集合是否相等

补充：

s1.difference_update(s2)   # 把s1和s2差集的结果赋值给s1。
s1.intersection_update( s2 )   #把s1和s2交集的结果赋值给s1。