07-初识散列类型

初识散列类型

• 数值类型：存储一个数值数据
  • int – 整形，整数
  • float – 浮点型，小数
  • bool – 布尔类型
• 序列类型
  • str – 字符串用引号包裹起来保存
  • list – 列表，用中括号包裹起来的数据，里面的数据可以修改
  • tuple – 元祖，用小括号包裹起来的数据，里面的数据不能修改
• 散列类型：

​ 1.可以存放多个数据

​ 2.内部是无序的 无下标

​ 3.内部数据不重复

集合(set)

集合：表现形式为用大括号包裹起来的数据，里面对数据用逗号隔开，

并且里面的数据 无序、会去重

语法：

​ 集合名 = {数据1，数据2，数据3}

animal = {'mouse','cat','mouse','pig','dog','mouse','cat'}
print(animal)
# {'mouse', 'pig', 'cat', 'dog'}
# {'dog', 'cat', 'mouse', 'pig'}
# {'pig', 'cat', 'dog', 'mouse'}
'''里面的数据表现为无序状态，并且数据不重复'''

print(animal[2])
# TypeError: 'set' object is not subscriptable
''' 集合没有下标，会报错'''

如果集合里有重复的数据，不会报错只不过重复的数据不会存入集合的内存数据中。

集合可以进行简单的逻辑运算，交并差集

​ 集合1 & 集合2 ---- 获取交集 --> 一个数据，两个集合里都有它

​ 集合1 | 集合2 ---- 获取并集 --> 两个集合里的所有数据(去重)

​ 集合1 - 集合2 ----- 获取差集 --> 两个集合之间，自己独有的数据

set1 = {1,2,3,4,5}
set2 = {2,3,4,5,6}
print(set1 & set2)
# {2, 3, 4, 5}

print(set1 | set2)
# {1, 2, 3, 4, 5, 6}

print(set1 - set2)
# {1}

print(set2 - set1)
# {6}

集合里面不能放列表，可以放元祖，因为列表可以修改。

集合的本质：

​ 1.存储非重复数据 – > 去重

​ 2.进行逻辑判断，进行交并补差集运算

li = [1,23,3,54,1,2,3,4,2,3,1,23,1,True,1,1,1,24,]
print(set(li))
# {1, 2, 3, 4, 54, 23, 24}

li = set(li) 
''' 把列表转换为集合，实现去重'''
li = list(li)
'''把去重后的了数据，重新转为列表'''
print(li)
# [1, 2, 3, 4, 54, 23, 24]

li = list(set(li))
'''快速语法'''
print(li)
# [1, 2, 3, 4, 54, 23, 24]

集合的方法

增加的语法

​ add：添加一个数据

​ 集合名.add(数据)

​ update：把一个序列类型打散后添加到集合里

​ 集合名.update(数据)

animal = {'mouse','cat','dog','pig'}
animal.add('monkey')
print(animal)
# {'pig', 'cat', 'dog', 'mouse', 'monkey'}

animal = {'mouse','cat','dog','pig'}
animal.update('monkey')
print(animal)
# {'mouse', 'cat', 'k', 'e', 'pig', 'm', 'y', 'o', 'dog', 'n'}
# {'m', 'o', 'cat', 'y', 'dog', 'mouse', 'pig', 'n', 'k', 'e'}
# {'e', 'dog', 'y', 'pig', 'mouse', 'n', 'k', 'cat', 'o', 'm'}

删除的语法

​ pop：删除一个数据，最后一位开始删

​ 集合名.pop()

​ remove：删除指定的数据

​ 集合.remove()

animal = {'mouse','cat','dog','pig'}
animal.pop()
print(animal)
# {'cat', 'pig', 'dog'}

animal.remove('cat')
print(animal)
# {'mouse', 'dog', 'pig'}

字典

字典(dict) ：表现形式用大括号包裹起来的数据，里面的数据用键值对的方式来保存

键值对： key : value

​ 左边是键值对，右边是数据

键名一般是用字符串或整形表示，

值里面什么都可以放，放变量，函数，都可以。

• 使用语法：

​ 字典名 = {键1：值1，键2：值2}

info = {
    'name': 'BIgmouse',
    'age' : 18,
    'sex' : '男'
}

注意点：每个键值对用逗号隔开

用字典类型保存的数据的优点：

​ 比起用列表/元祖存储的数据，更加清晰明了。

​ 如果需要用对数据有明显的对应关系，就可以用字典来保存。

• 输出语法

  ​ print(字典名) # 输出字典

  ​ print(字典名[键名]) # 输出指定的键的值

print(info)
# {'name': 'BIgmouse', 'age': 18, 'sex': '男'}

print(info['name'])
# BIgmouse

print(info['sex'])
# 男

• 修改语法

  ​ 字典名[键名] = 值 # 修改指定键的值

字典的特性：

​ 1.字典是通过键值的方式来获取数据，而不是下标。

​ 2.字典里的数据是可以修改的，还可以嵌套(字典里面还可以放字典）

​ 3.字典里的键是唯一的

声明空变量

• animal = [ ] 声明一个空列表
• animal = ( ) 声明一个空元祖
• animal = ’ ’ 声明一个空字符串
• animal = { } 声明一个空字典
• animal = set( ) 声明一个空集合

字典的方法

• 增加的方法

  • setdefault：给字典添加一个键值对，如果已经有这个键了，就不会添加，而是输出,如果咩有这个键的话会输出一个None

  语法：

  ​ 字典名.setdefault(健名)

  ​ 字典名.setdefault(健名,值)

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  info.setdefault('name')
  print(info)
  # {'name': 'BIgmouse', 'age': 18, 'sex': '男'}
  
  info.setdefault('hobby')
  print(info)
  # {'name': 'BIgmouse', 'age': 18, 'sex': '男', 'hobby': None}
  
  info.setdefault('hobby','打球')
  print(info)
  # {'name': 'BIgmouse', 'age': 18, 'sex': '男', 'hobby': '打球'}
  

• 删除的方法

  • pop：通过键名删除指定的数据

  语法：

  ​ 字典名.pop(健名)

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  info.pop('name')
  print(info)
  # {'age': 18, 'sex': '男'}
  

  • popitem：删除一个键值对，从最后一个开始删

  语法：

  ​ 字典名.popitem()

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  info.popitem()
  print(info)
  # {'name': 'BIgmouse', 'age': 18}
  

  • clear：清空整个字典

  语法：

  ​ 字典名.clear()

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  info.clear()
  print(info)
  # {}
  

• 修改的方法

  • update：修改键的值可如果没有这个键，就新增一个

  语法：

  ​ 字典名.update({键:值})

  ​ 字典名.update({键1：值1，键2，值2})

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  info.update({'name':'hamster'})
  print(info)
  # {'name': 'hamster', 'age': 18, 'sex': '男'}
  
  info.update({'hobby':'打球'})
  print(info)
  # {'name': 'BIgmouse', 'age': 18, 'sex': '男', 'hobby': '打球'}
  
  info.update({'name':'hamster','age':19,'hobby':'健身'})
  print(info)
  # {'name': 'hamster', 'age': 19, 'sex': '男', 'hobby': '健身'}
  

• 查询的方法

  • get：通过健名，获取键的值，如果没有这个键，不会报错而是输出一个None

    语法：

    ​ 字典名.get(健名)

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  print(info['hobby'])
  # KeyError: 'hobby'
  
  print(info.get('name'))
  # BIgmouse
  print(info.get('hobby'))
  # None
  

  • keys：获取所有的键

    ​ 字典名.key()

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  
  print(info.keys())
  # dict_keys(['name', 'age', 'sex'])
  

  • values：获取所有的值

    字典名.values()

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  print(info.values)
  # dict_values(['BIgmouse', 18, '男'])
  

  • items：获取所有的键值对

    字典名.items()

  info = {
      'name': 'BIgmouse',
      'age' : 18,
      'sex' : '男'
  }
  print(info.items())
  # dict_items([('name', 'BIgmouse'), ('age', 18), ('sex', '男')])
  

总结

散列类型：

​ 1.可以保存多个数据

​ 2.内部是无序的(没有下标)

​ 3.去重(不会保存重复的内容)

集合 -set ：用大括号包裹起来的数据，里面的数据会自动去重。

set1 = {6, 2.3, True, 'mouse', 'cat', 6}
print(set1)
print(set1)
# {True, 2.3, 6, 'mouse', 'cat'}
# {True, 2.3, 'cat', 6, 'mouse'}
'''输出的时候没有重复值并且是无序的'''

字典 -dict：用大括号包裹起来的数据，里面的数据是用键值对的方式来保存，这样保存的数据理解起来更加清晰。值里面可以放很多的东西(数值类型，序列类型，散列类型，函数)

info = {
    'name': 'BIgmouse',
    'age':18,
    'sex':'男',
    'height':180.4,
    'hobby':'打球'
}
print(info)
# {'name': 'BIgmouse', 'age': 18, 'sex': '男', 'height': 180.4, 'hobby': '打球'}
'''注意，键值对要用逗号隔开'''

集合主要用于去重以及进行简单的逻辑处理

字典主要用来保存一些有明显对应关系的数据。