字典的常用操作

  • 字典由key和value组成

    1. dict = {}
    2. dict = {'name': "李明"}

  • key必须是可哈希的(不可变）

    1. dict = {}
    2. dict['name'] = 'xiaoxiao'
    3. dict[(1, 'JackMa')] = 'Alibaba'
    4. dict["['houhou']"] = "houhou"
    5. print(dict)
    6. {"['houhou']": 'houhou', (1, 'JackMa'): 'Alibaba', 'name': 'xiaoxiao'}
    7. # 第一个元素的key是一个列表组成的字符串，也是不可变的元素

  • 字典的增删改查 ```python ‘’’增加元素’’’ dict = {}

    方式一

    dict[‘name’] = “liming”

    方式二

    dict.setdefault(‘age’, 18)

    setdefault(key, value)添加元素

    dict.setdefault(‘age’, 19)

    如果字典中key已经存在，setdefault再设定value将不再继续保存

    print(dict) dict.setdefault(‘age’) print(dict) {‘age’: None}

    当setdefault方法只给key的时候，value默认为None

‘’’删除元素’’’

方式一：pop

dict = {‘gender’: ‘male’, ‘age’: 19, ‘name’: ‘李明’} dict.pop() Traceback (most recent call last): File ““, line 1, in TypeError: pop expected at least 1 arguments, got 0 dict.pop(‘name’) ‘李明’ print(dict) {‘gender’: ‘male’, ‘age’: 19}

pop方式删除和列表中的pop有一个很大的区别，字典中必须把指定的key传入pop中才能找到并删除，否则会报上边的错误。

方式二：del

del dict[‘age’] print(dict) {‘gender’: ‘male’}

方式三：popitem

dict = {‘gender’: ‘male’, ‘age’: 18, ‘name’: ‘lizhen’} print(dict.popitem()) 返回值：(‘gender’, ‘male’)

popitem()不传递任何参数，随机删除

方式四：clear

dict.clear() print(dict) {}

清空字典

‘’’修改字典’’’

方式一：update

dict = {‘age’: 100, ‘name’: ‘xiaoxiao’} dict1 = {‘gender’: ‘male’, ‘age’: 150} print(dict1) {‘gender’: ‘male’, ‘age’: 150} dict.update(dict1) print(dict) {‘gender’: ‘male’, ‘age’: 150, ‘name’: ‘xiaoxiao’} dict.update({‘level’: ‘five’}) print(dict) {‘gender’: ‘male’, ‘age’: 150, ‘name’: ‘xiaoxiao’, ‘level’: ‘five’}

这种方式是以另外一个字典中的元素来替换掉已有的元素，括号内必须是字典，新字典中不包括的元素，愿字典不做更改，依旧保留，原字典中没有的元素将被添加

方式二

dict[‘age’] = 101 print(dict) {‘gender’: ‘male’, ‘age’: 101, ‘name’: ‘xiaoxiao’, ‘level’: ‘five’}

这种方式既可以添加也可以修改某个key的值，setdefault只能添加不存在的key，并不能修改已存在的key的值。

‘’’查询方式’’’

方式一：方括号

dict[‘age’] 101

方式二：get

dict.get(‘age’) dict.get(‘course’, ‘’) 101 ‘’

注意get方式查询的话可以设定两个参数，第一个是key，第二个自定义，如果有值返回值，如果没有返回为第二个参数

方式三：setdefault

dict.setdefault(‘age’) dict.setdefault(‘age’, 1000) 101 101

注意： setdefault如果只输入已有的key或者输入key和任意的value，那么将返回对应的value值

setdefault首先查看是否存在key，如果不存在，添加元素，如果存在返回对应key的value值

  2. - 字典的其他操作
  3. ```python
  4. # 查询所有的key值，返回的是伪列表, 可以进行迭代循环，注意：在python3中是伪列表不是真正的列表， 在python2解释器中是列表类型。
  5.   dict.keys()
  6.   ['gender', 'age', 'name', 'level']
  7.   dict = {'k1': 100, 'k2': 1001, 'k3': 200}
  8.   print(type(dict.keys()))
  9.   print(type(dict.values()))
  10.   # 结果是：
  11.   <class 'dict_keys'>
  12.     <class 'dict_values'>
  13.   for i in keys:
  14.       print(dict[i])
  15.   male
  16.   101
  17.   xiaoxiao
  18.   five
  20.   --------------------
  21.   # 查询所有的values, 返回的也是伪列表，可以进行迭代循环
  22.   values = dict.values()
  23.   values
  24.   ['male', 101, 'xiaoxiao', 'five']
  25.   --------------------
  26.   # 查询key、value值,组成列表, 也可以迭代循环，相当于上边两个的功能的合并
  27.   list1 = dict.items()
  28.   list1
  29.   [('gender', 'male'), ('age', 101), ('name', 'xiaoxiao'), ('level', 'five')]
  30.   for key, value in list1:
  31.       print(key, value) 
  32.   ('gender', 'male')
  33.   ('age', 101)
  34.   ('name', 'xiaoxiao')
  35.   ('level', 'five')
  37.   for i in list1:
  38.       key, value = i
  39.       print(key, value)
  40.   ('gender', 'male')
  41.   ('age', 101)
  42.   ('name', 'xiaoxiao')
  43.   ('level', 'five')
  • items()返回的是由key和value对应的元组组成的列表。注意遍历循环两个方式，方式一直接是遍历key和value，第二种方式是把元组作为一个变量，在把元组中的内容赋值给两个对应的变量，进行输出。key, value = (1, 2)这种方式在python中被称为解构或者解包，即把一个完整的对象中的值分解并赋值给多个变量， 解构需要注意的是变量个数必须和元组中的value元组个数一致。列表也可以解构，用法一样，但是字典的解构需要注意的是解构出来的值是字典中的每一个key，并不包含value 
  2. * 字典的嵌套
  4. ```python
  5. dict = {
  6.     'name': 'xiaoxiao', 
  7.     'gender': 'female', 
  8.     'age': 19,
  9.     'record': {
  10.         '语文': 100,
  11.         '数学': 80
  12.     },
  13.     'hobby': [
  14.         {
  15.             'name': 'fitness',
  16.             'year': 3
  17.         },
  18.         {
  19.             'name': 'football',
  20.             'year': 1        
  21.         }
  22.     ]
  23. }
  24. print(dict)
  25. # 结果是：
  26. {'name': 'xiaoxiao', 'gender': 'female', 'age': 19, 'record': {'语文': 100, '数学': 80}, 'hobby': [{'name': 'fitness', 'year': 3}, {'name': 'football', 'year': 1}]}
  27. # 字典中可以嵌套字典、列表，可以进行多层嵌套
  28. print(dict['hobby'][0].get('name'))
  29. # 结果是:fitness

  • 字典的嵌套

    1. '''数字的比较'''
    2. n1 = 1
    3. n2 = 1
    4. id(n1)
    5. 140419597884856
    6. id(n2)
    7. 140419597884856
    8. print(n1==n2)
    9. print(n1 is n2)
    10. # 结果是： True, True
    12. a = -6
    13. b = -6
    14. id(a)
    15. 140419599119512
    16. id(b)
    17. 140419599999240
    18. print(a==b)
    19. True
    20. print(a is b)
    21. False
    22. # 值相等，但是内存地址不同
    23. ------------------
    24. '''字符串的比较'''
    25. a= 'alexx'
    26. id(a)
    27. 4316628048
    28. b = 'alexx'
    29. id(a)
    30. 4316628048
    31. print(a=b)
    32. print(a is b)
    33. # 结果是： True, True
    35. str1 = '!12'
    36. str2 = '!12'
    37. id(str1)
    38. 4316659304
    39. id(str2)
    40. 4316656944
    41. print(str1==str2)
    42. True
    43. print(str1 is str2)
    44. False
    45. # 值相等，但是内存地址不同
    47. str1 = 'sdd'* 21
    48. str1
    49. 'sddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsdd'
    50. str2 = 'sdd' * 21
    51. str2
    52. 'sddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsdd'
    53. id(str1) == id(str2)
    54. False
    55. # 值相等，但是内存不同

    is和==的比较

  • 数字和字符串 ```python ‘’’数字的比较’’’ n1 = 1 n2 = 1 id(n1) 140419597884856 id(n2) 140419597884856 print(n1==n2) print(n1 is n2)

    结果是： True, True

a = -6 b = -6 id(a) 140419599119512 id(b) 140419599999240 print(a==b) True print(a is b) False

值相等，但是内存地址不同

‘’’字符串的比较’’’ a= ‘alexx’ id(a) 4316628048 b = ‘alexx’ id(a) 4316628048 print(a=b) print(a is b)

结果是： True, True

str1 = ‘!12’ str2 = ‘!12’ id(str1) 4316659304 id(str2) 4316656944 print(str1==str2) True print(str1 is str2) False

值相等，但是内存地址不同

str1 = ‘sdd’ 21 str1 ‘sddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsdd’ str2 = ‘sdd’ 21 str2 ‘sddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsdd’ id(str1) == id(str2) False

值相等，但是内存不同

  2. - 列表的比较
  3. ```python
  4. list = [1,2,3]
  5. list1 = [1,2,3]
  6. id(list)
  7. 4316616680
  8. id(list1)
  9. 4316614736
  10. print(list ==list1)
  11. True
  12. print(list is list1)
  13. False
  14. # 值相等，但是不共用一个内存空间

  • 元组的比较

    1. tu1 = (1,2,3)
    2. tu2 = (1,2,3)
    3. id(tu1)
    4. 4316412096
    5. id(tu2)
    6. 4316277888
    7. print(tu1==tu2)
    8. True
    9. print(tu1 is tu2)
    10. False
    11. # 值相等，但是不共用一个内存空间

  • 字典的比较

    1. dict = {'name': "xiaoxiao"}
    2. dict1 = {'name': 'xiaoxiao'}
    3. id(dict)
    4. 4316618832
    5. id(dict1)
    6. 4316609064
    7. print(dict==dict1)
    8. True
    9. print(dict is dict1)
    10. False
    11. # 值相等，但是不共用一个内存空间

Note 小数据池： 小数据池是python中专门为字符串和数字设置的存储

  • 数字的小数据池的规则：当数字是-5～256之间的时候，只要值相等时变量共用一个内存地址
  • 字符串的小数据池的规则： 如果有特殊字符，那么即使值相等，对应的内存地址也是不一样的, 空格也是特殊字符
  • 字符串单个 * 20以内的字符串值相等内存相同，超过20则内存不同
  • 如果字符串和数字符合上述的规则，那么值和内存地址都是一样的

==是比较变量的值是否相等，is比较的是变量对应的内存地址是否相同

集合的操作

  • 集合是python的基本数据类型，一般不常用，set中的元素是不重复的、无序的，并且必须是可哈希的(int, str, tuple, bool)，可以这样来记：set就是dict类型的数据，但是不保存value，只保存key， set也用{}表示。需要注意的是：set中的元素必须是可哈希的，但是set本身是不可哈希的，即可变的。

  • set集合具有元素不可重复放入特性，可以用于数据的去重操作

    1. lst = ['liuyang', 'liuyang', 'lili']
    2. print(lst)
    3. ['liuyang', 'liuyang', 'lili']
    4. s = set(lst)
    5. print(s)
    6. set(['lili', 'liuyang'])
    7. # 转变成set集合，去掉重复的元素
    8. lst1 = list(s)
    9. print(lst1)
    10. ['lili', 'liuyang']
    11. # 再把集合变量转换成列表，即完成去重工作

  • 集合的增删改查

    1. '''添加元素'''
    2. s.add('楷书')
    3. '''迭代更新元素'''
    4. s = {'lil', 'wwf', 'sdfd'}
    5. s.update('麻花腾')
    6. # 结果是:
    7. {'麻', '花', '腾', 'lil', 'wwf', 'sdfd'}
    8. # 即更新的元素被迭代输入，并不影响原来的集合中的元素
    9. '''删除元素'''
    10. s.remove('麻')
    11. # 没有则会报错
    12. '''需改元素'''
    13. s.remove('刘嘉玲')
    14. s.add('赵本山')
    15. # set集合没有索引，也没有key，所以无法通过这些找到元素，如果要修改，必须先删除，在添加
    16. '''查询元素'''
    17. for s in s:
    18.   print(s)
    19. # 结果是： 
    20. s
    21. m
    22. saf
    23. dfsd
    24. # set集合是可迭代对象，所以通过遍历来获取元素

  • 其他操作

    1. s1 = {'刘洋', '李明', '张毅', '李爽'}
    2. s2 = {'刘洋', '张胜', '李镇'}
    3. '''交集操作'''
    4. print(s1&s2)
    5. print(s1.intersection(s2))
    6. # 结果是：
    7. {'刘洋'}
    8. {'刘洋'}
    9. '''并集操作'''
    10. print(s1|s2)
    11. print(s1.union(s2))
    12. # 结果是:
    13. {'李明', '刘洋', '张毅', '张胜', '李镇', '李爽'}
    14. {'李明', '刘洋', '张毅', '张胜', '李镇', '李爽'}
    15. '''差集操作：第一个中存在，第二个中不存在'''
    16. print(s1-s2)
    17. print(s1.difference(s2))
    18. # 结果是：
    19. {'李爽', '张毅', '李明'}
    20. {'李爽', '张毅', '李明'}
    21. '''反交集操作：交集的反面'''
    22. print(s1^s2)
    23. print(s1.symmetric_difference(s2))
    24. # 结果是：
    25. {'李明', '张毅', '张胜', '李爽', '李镇'}
    26. {'李明', '张毅', '张胜', '李爽', '李镇'}
    27. '''子集操作'''
    28. print(s1<s2)
    29. print(s1.issubset(s2))
    30. # 结果是：
    31. False
    32. False
    33. '''超集操作'''
    34. print(s1>s2)
    35. print(s1.issuperset(s2))
    36. # 结果是：
    37. False
    38. False

  • set本身是不可哈希的，是可以改变的，我们可以通过frozenset()来冻结数据，frozenset()后的数据是可哈希的，可以把新的到的数据作为元素传递给新的set

    1. s = {'name', 'dsfd', 'qr3'}
    2. # 结合中的每一个元素都是可哈希的
    3. s = frozenset(s)
    4. print(s)
    5. frozenset(['dsfd', 'qr3', 'name'])
    6. s1 = {1, s}
    7. print(s)
    8. frozenset(['dsfd', 'qr3', 'name'])
    9. print(s1)
    10. set([1, frozenset(['dsfd', 'qr3', 'name'])])
    11. # frozenset既可以去重，也可以不可哈希的数据/对象变成可哈希的数据/对象