Python学习日记（九）

字典

• 两个关系之间1：1的映射关系，映射类型。

• 创建和访问字典

• • 利用大括号{}创建字典

    >>> dict1={1:'yyl',2:'yu',3:'li'}
    >>> dict1
    {1: 'yyl', 2: 'yu', 3: 'li'}

  • 利用关键字dict参数创建字典，注意此时创建的字典的顺序可能会颠倒。此时键不能用引号。
  • dict(键='值'）

  • >>> dict2=dict(大大怪='将军',小小怪='下士')
    >>> dict2
    {'大大怪': '将军', '小小怪': '下士'}
    
    >>> dict2['小小怪']='可爱'
    >>> dict2
    {'大大怪': '将军', '小小怪': '可爱'}
    
    >>> dict2['开心超人']='高冷拽少'
    >>> dict2
    {'大大怪': '将军', '小小怪': '可爱', '开心超人': '高冷拽少'}

• 字典的内置方法

• • fromkeys(键)
  • dict.fromkeys(s,[v])，其中是为键，v为键对应的值，可选，默认为none
  • 不能单独更改键的值，v只能是一个参数，用他给每个键赋值
  • 不能修改其中某几个键的值，他只会自动创建一个新的字典
  • fromkeys方法是直接创建一个新的字典，不要试图使用它来修改一个原有的字典，因为它会直接无情的用把整个字典给覆盖掉。

  • >>> dict1={}
    >>> dict1.fromkeys((1,2,3))
    {1: None, 2: None, 3: None}
    >>> dict1.fromkeys((1,2,3),'numbers')
    {1: 'numbers', 2: 'numbers', 3: 'numbers'}
    >>> dict1.fromkeys((1,2,3),('one','two','three'))
    {1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}
    >>> dict1.fromkeys((1,3),('one','two','three'))
    {1: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

• • keys() 
  • 返回字典键的引用

  • >>> dict1=dict1.fromkeys(range(9),'赞')
    >>> dict1
    {0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞', 6: '赞', 7: '赞', 8: '赞'}
    >>> for eachkey in dict1.keys():
    	print(eachkey)
    
    0
    1
    2
    3
    4
    5
    6
    7
    8

• • values()
  • 返回字典键对应的值

  • >>> for eachkey in dict1.values():
    
    	print(eachkey)
        
    赞
    赞
    赞
    赞
    赞
    赞
    赞
    赞
    赞

  • items()
  • 以元组的形式打印字典的键值对

  • >>> for eachkey in dict1.items():
    
    	print(eachkey)
    
    	
    (0, '赞')
    (1, '赞')
    (2, '赞')
    (3, '赞')
    (4, '赞')
    (5, '赞')
    (6, '赞')
    (7, '赞')
    (8, '赞')

  • get()
  • 通过dict.get(键号，[返回])可以得到键对应的值，其中第二个参数默认为none，可以自行设置，当要访问的键不存在时返回该值

  • >>> dict1.get(9,'不存在')
    '不存在'
    >>> dict1.get(8,'不存在')
    '赞'

  • 可以用成员资格操作符in/not in判断键是否在字典中

    >>> 8 in dict1
    True
    >>> 9 in dict1
    False

  • clear()
  • 清除字典
  • 注意不可用空字典覆盖的方法清除字典，因为只是创建了一个新的同名空字典，原来字典还在，很容易被窃取数据。

  • >>> dict1.clear()
    >>> dict1
    {}
    
    >>> dict1=dict1.fromkeys(range(9),'赞')
    >>> dict2=dict1
    >>> dict1={}
    >>> dict2
    {0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞', 6: '赞', 7: '赞', 8: '赞'}
    >>> dict1=dict2
    >>> dict1.clear()
    >>> dict2
    {}

• •  copy()  浅拷贝

  • 注意赋值和浅拷贝的关系，赋值是给数据起了另外一个标签在相同数据上，浅拷贝是对对象表层的拷贝，所得结果和原来数据不是同一个，地址也不同。通过赋值的两个标签指向同一个数据，会相互影响，而copy的两个不会相互影响。

  • >>> dict1=dict1.fromkeys(range(6),'哈')
    >>> dict1
    {0: '哈', 1: '哈', 2: '哈', 3: '哈', 4: '哈', 5: '哈'}
    >>> dict2=dict1
    >>> dict3=dict1.copy()
    >>> id(dict1)
    1895730658304
    >>> id(dict2)
    1895730658304
    >>> id(dict3)
    1895765883840
    
    >>> dict1[0]='嘿'
    >>> dict1
    {0: '嘿', 1: '哈', 2: '哈', 3: '哈', 4: '哈', 5: '哈'}
    >>> dict2
    {0: '嘿', 1: '哈', 2: '哈', 3: '哈', 4: '哈', 5: '哈'}
    >>> dict3
    {0: '哈', 1: '哈', 2: '哈', 3: '哈', 4: '哈', 5: '哈'}

• •  pop()、popitem()

  • dict.pop(键），弹出相应键的值；dict.popitem( ),无参数，随机弹出任意位置键值对，在字典中是没有一定顺序的

  • >>> dict1.pop(2)
    '哈'
    >>> dict1
    {0: '嘿', 1: '哈', 3: '哈', 4: '哈', 5: '哈'}
    >>> dict1.popitem()
    (5, '哈')
    >>> dict1
    {0: '嘿', 1: '哈', 3: '哈', 4: '哈'}

  • setdefault()
  • dict.setdefault(键，'值')，存在就不添加值
  • 与get（）类似，当字典中找不到对应值时会自行进行添加，添加位置也是随机的

  • >>> dict1
    {0: '嘿', 1: '哈', 3: '哈', 4: '哈'}
    >>> dict1.setdefault(0)
    '嘿'
    >>> dict1.setdefault(2,'芜湖')
    '芜湖'
    >>> dict1
    {0: '嘿', 1: '哈', 3: '哈', 4: '哈', 2: '芜湖'}

  • update()
  • update(字典或映射）
  • 用一个字典或映射关系去更新另外一个字典

    >>> dict1
    {0: '嘿', 1: '哈', 3: '哈', 4: '哈', 2: '芜湖'}
    >>> a={'小羊':'咩咩'}
    >>> dict1.update(a)
    >>> dict1
    {0: '嘿', 1: '哈', 3: '哈', 4: '哈', 2: '芜湖', '小羊': '咩咩'}

集合（set)

• 用{}括起来的一组没有映射关系的数据称为集合
• 集合中所有的元素都是唯一的，可用于剔除重复元素
• 集合是无序的，不能索引集合中的某个元素

  >>> s={1,2,3,4,5}
  >>> type(s)
  
  
  >>> s={1,2,3,3,6,6,6,6}
  >>> s
  {1, 2, 3, 6}
  
  >>> s[2]
  Traceback (most recent call last):
    File "", line 1, in 
      s[2]
  TypeError: 'set' object is not subscriptable

• 创建集合 

• • 直接把一堆元素用花括号{}括起来

  • >>> s={1,2,3,4,5}
    >>> type(s)

• • 使用set()工厂函数 
  • set(列表|元组|字符串)，其中元组需要用( )
  • 使用set()创建的集合是无序的

  • >>> set1=set([11,2,3,3,5,6])
    >>> set1
    {2, 3, 5, 6, 11}
    >>> set2=set(1,1,2,3,3,5)
    Traceback (most recent call last):
      File "", line 1, in 
        set2=set(1,1,2,3,3,5)
    TypeError: set expected at most 1 argument, got 6
    >>> set2=set((1,1,2,3,3,5))
    >>> set2
    {1, 2, 3, 5}
    >>> set3=set('123455677')
    >>> set3
    {'7', '6', '4', '2', '3', '1', '5'}

• 访问集合 
  • 利用for循环读取集合中的数据

  • >>> set1=set([1,2,3,4,5])
    >>> for each in set1:
    	print(each)
    
    1
    2
    3
    4
    5

  • 通过in和not in判断是否在集合中

  • >>> set1
    {1, 2, 3, 4, 5}
    >>> 1 in set1
    True
    >>> 0 in set1
    False

• 不可变集合

• • 不可变集合中的数据有一定稳定性，不可随意修改
  • 可用frozenset() 定义不可变集合

  • >>> s=frozenset([1,2,3,4,5,5])
    >>> s
    frozenset({1, 2, 3, 4, 5})
    >>> s.add(6)
    Traceback (most recent call last):
      File "", line 1, in 
        s.add(6)
    AttributeError: 'frozenset' object has no attribute 'add'

习题：

1、尝试一下将数据（'F':70,'C':67,'h':104,'i':105,'s':115）创建为一个字典并访问键‘C’对应的值。

• >>> 第一种方法
  >>> MyDict_1 = dict((('F',70),('C',67),('h',104),('i',105),('s',115)))
  >>> MyDict_1['C']
  67
  >>> 第二种方法
  >>> MyDict_2 = {'F':70,'C':67,'h':104,'i':105,'s':115}
  >>> MyDict_2['C']
  67
  >>> 第三种方法
  >>> MyDict_3 = dict(F = 70, C = 67, h = 104, i = 105, s = 115)
  >>> MyDict_3['C']
  67
  >>> 第四种方法
  >>> MyDict_4 = dict([('F',70),('C',67),('h',104),('i',105),('s',115)])
  >>> MyDict_4['C']
  67
  >>> 第五种方法
  >>> MyDict_5 = dict({'F':70,'C':67,'h':104,'i':105,'s':115})
  >>> MyDict_5['C']
  67
  >>> 第六种方法
  >>> MyDict_6 = dict(zip(['F', 'C', 'h', 'i', 's'], [70, 67, 104, 105, 115]))
  >>> MyDict_6['C']
  67

2、编写通讯录

• def Menu():
      print('|--- 欢迎进入通讯录程序 ---|')
      print('|--- 1:查询联系人资料 ---|')
      print('|--- 2:插入新的联系人 ---|')
      print('|--- 3:删除已有的联系人 ---|')
      print('|--- 4:查看所有通讯录 ---|')
      print('|--- 5:退出通讯录程序 ---|')
  
  def Search():
      name=input("请输入要查询联系人姓名：")
      if name in P.keys():
          print(P[name])
      else:
          print("查询失败,联系人不存在！")
      return
      
  
  def Sert():
      name=input("请输入联系人姓名：")
      tel=input("请输入联系人电话：")
      P.setdefault(name,tel)
      print("添加成功！")
      return
  
  
  def Clear():
      t=input("确认清空请输入1，否则输入0：")
      if t==1:
          P.clear()
      else:
          return
  
  
  def Show():
      for i in P.items():
          print(i)
      return
  
  
  P={'yyl':1111,'xr':222,'ll':333}
  Menu()
  while True:
      n=int(input("请选择操作(1、2、3、4、5）："))
  
      if n==1:
          Search()
      elif n==2:
          Sert()
      elif n==3:
          Clear()
      elif n==4:
          Show()
      else:
          break
  print("已退出通讯录！")
  

3、编写登录程序

• def create():
      name=input("请输入用户名：")
      if name in user.keys():
          print("该用户已存在！")
          return
      else:
          pswd=int(input("请输入密码："))
          user.setdefault(name,pswd)
          print("成功添加用户!")
          return
          
  
  def logn():
      name=input("请输入用户名：")
      if name not in user.keys():
          print("用户名不存在！")
          return
      else:
          pswd=int(input("请输入密码："))
          if pswd==user[name]:
              print("登录成功！")
              return
          else:
              print("密码错误！")
              return
  
  def ex():
      print("感谢使用，已退出登录！")
  
  
  
  
  user={'yyl':111,'xr':222}
  while True:
      x=input('''|--- 新建用户：N/n ---|
  |--- 登录帐号：E/e ---|
  |--- 退出程序：Q/q ---|
  |--- 请输入指令代码：''')
      if x.lower() =='n':
          create()
      elif x.lower()=='e':
          logn()
      elif x.lower()=='q':
          ex()
          break
      else:
          print("输入有误，请重新输入！")
  

总结：

• 访问字典的方法：
  1）dict1.keys() 返回键
  2） dict1.value() 返回值
  3）dict1.items() 返回键值对（也就是项）
  4）dict1.get() 对应键的值不存在的话返回一个None，这样程序就不会报错
  5）key in dict1 查找的是键，而不是值
  6）dict1.clear() 清空字典，不建议使用直接赋空值的方法：dict1 = {}
  7）dict1.copy()：浅拷贝（见练习题5）
  8）dict1.pop()：给定键弹出相应值
  9）dict1.popitem()：给定键弹出相应项（包括键和值）
  10）dict1.setdefault()：找不到给定键对应的值话会自动在字典中创建一个基于该键的项（区别于dict1.get()的结果）
  11）dict1.update()：根据一个字典或映射关系去更新另一个字典