标准数据类型--字典简介

  • 列表是数值索引,不支持其它索引,而且列表相对较慢,字典是一种无序可变容器,且可存储任意类型对象。字典的每个键(key=>value)对用冒号(:)分割,每个对之间用逗号分割,整个字典包括在花括号{}中。字典键必须唯一且不可变,值可以是任意类型,也可以重复。
  • 字典格式:d = {key1 : value1, key2 : value2 }

1 . 初始化

In [146]: d={}                                                                                        

In [147]: d={'name':'zhangsan'}                                                           

In [148]: d                                                                                             

Out[148]: {'name': 'zhangsan'}

In [150]: d=dict.fromkeys('abc','test') 

In [152]: d                                                                                             

Out[152]: {'a': 'test', 'b': 'test', 'c': 'test'}

2.增加,修改元素

  • d['key1'] = 'value1'
  • d.update({'key':'value'})
  • d.setdefault('key','test')

列如:

In [153]: d.update({'age':20})                                                                              

In [154]: d                                                                                                 
Out[154]: {'a': 'test', 'b': 'test', 'c': 'test', 'age': 20}

In [155]: d.setdefault('age','100')        
如果键'key',存在不对字典操作,如果'key'不存在,则添加 'key':'test'

Out[155]: 20

In [156]: d                                                                                                 
Out[156]: {'a': 'test', 'b': 'test', 'c': 'test', 'age': 20}

3.查看键值

  • d.keys()
  • d.values()
  • d.items()

列如:

In [157]: d.keys()                               \\查看键                                                           
Out[157]: dict_keys(['a', 'b', 'c', 'age'])

In [158]: d.values()                              \\查看值                                                
Out[158]: dict_values(['test', 'test', 'test', 20])

In [159]: d.items()                                \\查看全部                                                         
Out[159]: dict_items([('a', 'test'), ('b', 'test'), ('c', 'test'), ('age', 20)])

4.获取单个键值

  • d.get(key[,d])
  • d.pop(key[,d])
  • a.popitem()

列如:

In [165]: d                                                                                                 

Out[165]: {'a': 'test', 'b': 'test', 'c': 'test', 'age': 20}

In [166]: d.get('a')                                                                                        
Out[166]: 'test'

In [166]: d.get('a')                                                                                        
Out[166]: 'test'

In [173]: d.popitem()                    \\随机删除                                                                   
Out[173]: ('c', 'test')

5.其他方法

  • d1.clear()
  • key in d
  • key not in d
  • del(D['tom']) \将字典D中的 键为 'tom'的元素删除掉

列如:

In [187]: d1                                                                                                
Out[187]: {'name': 'lisi', 'age': '20'}

In [188]: d1.clear()                           \\清除所有                                                            

In [189]: d1                                                                                                
Out[189]: {}

In [198]: d={"name":"zhangsan","dizhi":"beijin"}    

In [201]: "name" in d                                                                                       
Out[201]: True

In [202]: "name" not in d                                                                                   
Out[202]: False

In [206]: del(d['name'])

标准数据类型--集合

set和dict类似,是一组key的集合没有value 而且keys不可以重复并且必须为不可变对象。相当于一个只有key没有value的字典。

  1. 创建集合
In [209]: t1=set([1,2,3,4,5,6])                                                                             

In [210]: type(t1)                                                                                          
Out[210]: set

2.

  • add(添加元素)
  • update(将两个集合合并到一块)

例如:

In [211]: t1.add('abc') 

In [215]: t1.update(a)  

3.

  • clear (清空)
  • discard(删除一个元素,如果元素不存在什么也不做)
  • pop (随机弹出一个元素)
  • remove (删除指定元素,若不存在则异常)

列如:

In [217]: t1                                                                                                
Out[217]: {1, 2, 3, 4, 5, 6, 'a', 'abc', 'd', 'f', 'g', 'h', 'j', 's', 'test'}

In [218]: t1.discard('abc')                                                                                 

In [219]: t1.pop()                                                                                          
Out[219]: 1

In [220]: t1.pop()                                                                                          
Out[220]: 2

In [221]: t1.remove('test')                                                                                 

In [222]: t1.clear()                                                                                        

In [223]: t1                                                                                                
Out[223]: set()

4.判断

  • isdisjoint (没有交集返回True)
  • issubset (A.issubset(B),判断集合A是不是集合B的子集)
  • issuperset (A.issuperset(B),判断集合A是不是集合B的父集合)

列如:

In [234]: a=set([1,2,3,4,5,6])                                                                              

In [235]: b=set([2,3,4,5,6,7])                                                                   
In [237]: c=set([2,3,4])

In [236]: a.isdisjoint(b)                                                                                   
Out[236]: False

In [238]: c.issubset(a)                                                                                     
Out[238]: True

In [239]: a.issuperset(c)                                                                                   
Out[239]: True


5.求差集

  • difference A.difference(B),在集合A中但不再集合B中
  • difference_update A.difference_update(B),类似difference,区别是将结果复制给A.
  • symmetric_difference 返回两个集合中不同的元素
  • symmetric_difference_update A.symmetric_difference_update(B),返回两个集合中的不同元 素,并将结果赋值给A

例如:

In [240]: a                                                                                                 
Out[240]: {1, 2, 3, 4, 5, 6}

In [241]: b                                                                                                 
Out[241]: {2, 3, 4, 5, 6, 7}

In [242]: c                                                                                                 
Out[242]: {2, 3, 4}

In [243]: a.difference(b)                                                                                   
Out[243]: {1}

In [246]: a.difference_update(c)                                                                            

In [247]: a                                                                                                 
Out[247]: {1}

In [248]: b.symmetric_difference(c)                                                                         
Out[248]: {5, 6, 7}

In [249]: b.symmetric_difference_update(c)                                                                  

In [250]: b                                                                                                 
Out[250]: {5, 6, 7}

6.求交集

  • intersection A.intersection(B),返回两个集合的交集
  • intersection_update A.intersection_update(B),返回集合A和集合B的交集,并将结果赋值给A
  • 也可以直接使用 & 符号 列如:
In [254]: a=set([1,2,3,4,5,6])                                                                              

In [255]: b=set([2,3,4,5])                                                                                  

In [256]: a.intersection(b)                                                                                 
Out[256]: {2, 3, 4, 5}

In [257]: a.intersection_update(b)                                                                          

In [258]: a                                                                                                 
Out[258]: {2, 3, 4, 5}

7.求并集

  • union 返回两个集合的并集

列如:

In [262]: a=set([1,2,3,4,5])                                                                                

In [263]: b=set([5,6,7,8,9])                                                                                

In [264]: a.union(b)                                                                                        
Out[264]: {1, 2, 3, 4, 5, 6, 7, 8, 9}

7.深拷贝

  • copy (深拷贝) 列如:
In [270]: a=b.copy()                                                                                        

In [271]: b                                                                                                 
Out[271]: {5, 6, 7, 8, 9}

In [272]: a                                                                                                 
Out[272]: {5, 6, 7, 8, 9}

In [273]: b.add("test")                                                                                     

In [274]: b                                                                                                 
Out[274]: {5, 6, 7, 8, 9, 'test'}

In [275]: a                                                                                                 
Out[275]: {5, 6, 7, 8, 9}