元组简介

  • 元组表现形式tuple
  • 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
  • 使用()创建元素
  • 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
  • 元组解包指将元组当中的每一个元素都赋值给一个变量
  • 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
  • 所谓元组的不可变指的是元组所指向的内存中的内容不可变。


  1. # 元组的表达形式  （）  tuple
  2. # 元组的创建与访问
  3. tuple1 = (1, 2, 3, 4, 5)
  4. print(tuple1, type(tuple1))
  5. print(tuple1[2])
  6. print(tuple1[2::])
  8. tup2 = ('Google', 'Runoob', 1997, 2000)
  9. tup3 = "a", "b", "c", "d"   #  不需要括号也可以
  10. print(tup2)
  11. print(tup3, type(tup3))
  12. -------------------
  13. (1, 2, 3, 4, 5) <class 'tuple'>
  14. 3
  15. (3, 4, 5)
  16. ('Google', 'Runoob', 1997, 2000)
  17. ('a', 'b', 'c', 'd') <class 'tuple'>
  18. =========================================
  19. # 如果元组不是一个空元祖，那么它必须得有一个逗号, 否则括号会被当作运算符使用
  20. tuple2 = 10,
  21. tuple3 = (10)
  22. print(tuple2, type(tuple2))
  23. print(tuple3, type(tuple3))
  24. ---------------
  25. (10,) <class 'tuple'>
  26. 10 <class 'int'>
  27. ===========================================
  28. #元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
  29. tup1 = (12, 34.56)
  30. tup2 = ('abc', 'xyz')
  32. # 以下修改元组元素操作是非法的。
  33. # tup1[0] = 100
  35. # 创建一个新的元组
  36. tup3 = tup1 + tup2
  37. print(tup3)
  38. ---------------------
  39. (12, 34.56, 'abc', 'xyz')
  40. =========================================================
  41. # 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
  42. tup = ('Google', 'Runoob', 1997, 2000)
  44. print(tup)
  45. del tup
  46. print("删除后的元组 tup : ")
  47. print(tup)
  48. ------------------
  49. NameError: name 'tup' is not defined
  50. ('Google', 'Runoob', 1997, 2000)
  51. 删除后的元组 tup : 
  53. 进程已结束,退出代码1
  54. ===============================================
  55. 元组的运算
  56. print(len((1, 2, 3)))
  57. print((1, 2, 3) + (4, 5, 6))
  58. print(('Hi!',) * 4)
  59. print(3 in (1, 2, 3))
  60. for x in (1, 2, 3):
  61.     print(x,)
  62. -----------------------------
  63. 3
  64. (1, 2, 3, 4, 5, 6)
  65. ('Hi!', 'Hi!', 'Hi!', 'Hi!')
  66. True
  67. 1
  68. 2
  69. 3
  70. ========================================
  71. 元组内置函数
  72. len(tuple) #计算元组元素个数
  73. max(tuple) #返回元组中元素最大值
  74. min(tuple) #返回元组中元素最小值
  75. tuple(iterable) #将可迭代系列转换为元组
  77. list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
  78. tuple1=tuple(list1)
  79. print(tuple1)
  80. -----------------------------
  81. ('Google', 'Taobao', 'Runoob', 'Baidu')
  82. ==================================
  83. 元组不可变
  85. tup = ('r', 'u', 'n', 'o', 'o', 'b')
  86. #tup[0] = 'g'     # 不支持修改元素
  88. print(id(tup))     # 查看内存地址
  90. tup = (1,2,3)
  91. print(id(tup))
  92. -------------------
  93. 2956170277600
  94. 2956170819008


字典简介

字典的基本介绍

  • 字典属于一种新的数据结构称为映射(mapping)
  • 字典的作用和列表类似，都是用来存储对象的容器
  • 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
  • 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
  • 这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
  • 字典我们也称之为键值对(key-value)结构
  • 字典的每个键值 key-value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中
  • 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)

  • 创建一个有数据的字典 语法 {key:value}, 例如 

    1. d = {key1 : value1, key2 : value2, key3 : value3 }

  • 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple….)

  • 字典的键是不能重复的，如果出现重复的后面的会替换前面的 ```python

    字典的创建

    1. 用{}创建

dict2 = { ‘name’: ‘郭靖’, ‘age’: 18, ‘sex’: ‘男’, ‘name’: ‘欧阳锋’, ‘skill’: ‘蛤蟆功’ } print(dict2, type(dict2))

获取value， 直接用 dict[key]

print(dict2[‘skill’])

{‘name’: ‘欧阳锋’, ‘age’: 18, ‘sex’: ‘男’, ‘skill’: ‘蛤蟆功’}

蛤蟆功

2. 使用dict类去创建字典

dict1 = dict(name=’郭靖’, age=18, sex=’男’)

print(dict1, type(dict1))

{‘name’: ‘郭靖’, ‘age’: 18, ‘sex’: ‘男’}

3. 使用dict去创建

python2 有序字典 orderdict 无序字典

需要dict（）括号里的数据是属于一种双值子序列的形式

双值序列 [1, 2]

子序列 （’a’）

双值子序列： [(1, 2), (3, 4)]

dict2 = dict([(‘name’, ‘郭靖’), (‘age’, 18), (‘sex’, ‘男’)])

print(dict2, type(dict2))

{‘name’: ‘郭靖’, ‘age’: 18, ‘sex’: ‘男’} 

  1. <a name="RtAIz"></a>
  2. ### 字典的使用
  4. - dict()函数来创建字典
  5. - get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
  6. - update() 将其他字典的key-value添加到当前的字典当中
  7. - del 删除字典中的key-value
  8. - popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回
  9. - pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
  10. - in, not in  检测的是key
  11. ```python
  12. # in, not in
  13. dict1 = dict(name='郭靖', age=18, sex='男')
  14. # print(len(dict1))
  15. # in, not in  检测的是key
  16. print('name' in dict1)
  17. print(18 in dict1)
  18. ----------------------------
  19. True
  20. False
  21. ================================
  22. # 获取值得方式
  23. # 使用key获取value  dict[key] 如果不存在key则会报错
  24. dict1 = dict(name='郭靖', age=18, sex='男')
  25. print(dict1.get('name')) 
  26. print(dict1.get('skill'))#如果key不存在，不会报错
  27. -----------------
  28. 郭靖
  29. None
  30. ====================================
  31. # 修改字典
  32. # dict[key] = value
  33. dict1 = dict(name='郭靖', age=18, sex='男')
  34. dict1['name'] = '欧阳锋'
  35. print(dict1)
  36. ------------------
  37. {'name': '欧阳锋', 'age': 18, 'sex': '男'}
  38. =============================================
  39. # dict.setdefault(key, [default])  向字典中添加key-value
  40. # 如果这个key已经存在于字典中，不会对字典有影响, 如果不存在，则向字典中添加这个key，并设置value， 返回value
  41. dict1 = dict(name='郭靖', age=18, sex='男')
  42. result = dict1.setdefault('name', '欧阳锋')
  43. result = dict1.setdefault('skill', '降龙十八掌')
  44. print(result)
  45. print(dict1)
  46. -----------------------------
  47. 降龙十八掌
  48. {'name': '郭靖', 'age': 18, 'sex': '男', 'skill': '降龙十八掌'}
  49. ==================================================
  50. # dict.update() 将其他字典中的key—value添加到当前字典中
  51. d1 = {'1': 1}
  52. d2 = {'2': 2}
  53. d1.update(d2)
  54. print(d1)
  55. ------------------
  56. {'1': 1, '2': 2}
  57. ==========================================
  58. # 删除
  59. # del 关键字删除，则删除key-value对
  60. dict1 = dict(name='郭靖', age=18, sex='男')
  61. print(dict1)
  62. del dict1['name']
  63. print(dict1)
  64. --------------------------
  65. {'name': '郭靖', 'age': 18, 'sex': '男'}
  66. {'age': 18, 'sex': '男'}
  67. =============================================
  68. # dict.popitem() 随机删除一个键值对，一般都会删除最后一个, 有一个返回值，就是你删除的对象，结果是一个元组
  69. dict1 = dict(name='郭靖', age=18, sex='男')
  70. result = dict1.popitem()
  71. print(result)
  72. print(dict1)
  73. ----------------------
  74. ('sex', '男')
  75. {'name': '郭靖', 'age': 18}
  76. ===================================================
  77. # dict.pop(key，[default])  根据key来删除键值对, 返回值就是你删除key对应的value
  78. dict1 = dict(name='郭靖', age=18, sex='男')
  79. result1 = dict1.pop('sex')
  80. result2 = dict1.pop('skill', '你删除的这个不存在') # 没有键值，也返回要删的值
  81. print(result1)
  82. print(result2)
  83. print(dict1)
  84. ---------------------
  85. 男
  86. 你删除的这个不存在
  87. {'name': '郭靖', 'age': 18}
  88. ====================================================
  89. # dict.clear（） 清空字典
  90. dict1 = dict(name='郭靖', age=18, sex='男')
  91. print(dict1)
  92. dict1.clear()
  93. print(dict1)
  94. -----------------------------------
  95. {'name': '郭靖', 'age': 18, 'sex': '男'}
  96. {}
  97. ================================================
  98. # list.clear() 清空列表
  99. list1 = [1, 2, 3, 4, 5]
  100. print(list1)
  101. list1.clear()
  102. print(list1)
  103. ----------------------------------
  104. [1, 2, 3, 4, 5]
  105. []

copye()

copy() 方法用来对字典进行潜复制
注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的

  1. # 浅拷贝
  2. # 做拷贝的对象必须是可变类型
  3. # 浅拷贝只能对第一层的数据进行拷贝，如果，第一层的数据也是个可变类型，那么浅拷贝无法将这个数据重新拷贝一份形成新的id
  5. dict1 = {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]}
  6. dict2 = dict1.copy()
  7. print(id(dict1), id(dict2))
  8. print(id(dict1['list1']), id(dict2['list1']))
  9. -----------------------
  10. 2847754889472 2847756270784
  11. 2847756293568 2847756293568
  12. ==========或者==========
  13. import copy
  14. dict1 = {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]}
  15. dict2 = copy.copy(dict1)
  16. print(id(dict1), id(dict2))
  17. print(id(dict1['list1']), id(dict2['list1']))
  18. ----------------
  19. 2979608865088 2979610246528
  20. 2979610277504 2979610277504
  21. ==========================================================
  22. # 深拷贝
  23. # 深拷贝可以对所有的数据全部进行拷贝，形成一个新的id
  26. dict1 = {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]}
  27. dict3 = copy.deepcopy(dict1)
  28. print(id(dict1), id(dict3))
  29. print(id(dict1['list1']), id(dict3['list1']))
  30. -----------------------
  31. 2205928008000 2205929466176
  32. 2205929420288 2205929389824

遍历字典

我们主要可以通过3种方式对字典进行遍历

  • keys() 该方法返回字典所有的key
  • values() 该方法返回一个序列 序列中保存有字典的值
  • items() 该方法会返回字典中所有的项 它返回一个序列，序列中包含有双值子序列 双值分别是 字典中的key和value ```python

    通过key来遍历 dict.keys()，获取的是value

    dict1 = dict(name=’郭靖’, age=18, sex=’男’) for k in dict1.keys(): print(dict1[k])

郭靖 18

男

通过value来遍历 dict.values()

dict1 = dict(name=’郭靖’, age=18, sex=’男’) for v in dict1.values():

  1. print(v)

郭靖 18

男

通过一项来进行遍历 dict.items()

dict1 = dict(name=’郭靖’, age=18, sex=’男’) for k, v in dict1.items():

  1. print(k, '=', v)

name = 郭靖 age = 18 sex = 男

  1. <a name="L7RW7"></a>
  2. ### 集合简介
  4. - 集合表现形式set 集合和列表非常相似
  5. - 不同点
  6.    - 集合只能存储不可变对象
  7.    - 集合中存储的对象是无序的
  8.    - 集合不能出现重复元素
  9. - 使用{}来创建集合
  10. - 可以通过set()来将序列和字典转换成集合
  11. - len() 使用len()来获取集合中元素的数量
  12. - add()像集合中添加元素
  13. - update()将一个集合中的元素添加到另一个集合当中
  14. - pop()随机删除集合中的一个元素一般是删除最后一个元素
  15. - remove() 删除集合中指定的元素
  16. - clear() 清空集合
  17. ```python
  18. # set表示集合  {}
  19. # 集合只能存储不可变对象
  20. # s1 = {1, 'abc', [1, 2, 3]}
  21. # print(s1, type(s1))
  23. # 集合中存储的对象是无序的
  24. # s2 = {6, 8, 9, 10}
  25. # print(s2)
  26. # 集合不能出现重复元素 通过这一特性，我们可以来做一个数据去重的效果
  27. # s3 = {1, 2, 3, 4, 1, 2, 3, 4}
  28. # print(s3)
  29. # list1 = [1, 1, 2, 3, 3]
  30. # s4 = set(list1)
  31. # print(s4)
  33. dict1 = {'1': 1}
  34. print(set(dict1))
  37. # s = {}  # 创建空集合， 需要用到set()
  38. # s = set()
  39. # print(type(s))

集合的运算

  • & 交集运算
  • | 并集运算
    • 差集运算
  • ^ 亦或集
  • <= 检查一个集合是否是另一个集合的子集
  • < 检查一个集合是否是另一个集合的真子集

  • =检查一个集合是否是另一个集合的超集

  • 检查一个集合是否是另一个集合的真超集 ```python

    集合只能存储不可变对象

    s1 = {1, ‘abc’, [1, 2, 3]} # 报错，列表不能作为集合的元素 print(s1, type(s1))

TypeError: unhashable type: ‘list’

集合中存储的对象是无序的

s2 = {6, 8, 9, 10}

print(s2)

{8, 9, 10, 6} # 无序输出

集合不能出现重复元素 通过这一特性，我们可以来做一个数据去重的效果

s3 = {1, 2, 3, 4, 1, 2, 3, 4} print(s3) list1 = [1, 1, 2, 3, 3] s4 = set(list1)

print(s4)

{1, 2, 3, 4} {1, 2, 3}

====================== dict1 = {‘1’: 1} # 字典转集合 print(set(dict1))

{‘1’}

s = {} # 创建空集合， 需要用到set() s = set()

print(type(s))

==================== set1 = {1, 2, 3, 4} print(len(set1)) # 使用len()来获取集合中元素的数量 set1.add(5) print(set1)# add()像集合中添加元素

set2 = {6, 7} set1.update(set2)

print(set1) # update()将一个集合中的元素添加到另一个集合当中

4 {1, 2, 3, 4, 5}

{1, 2, 3, 4, 5, 6, 7}

set1 = {4, 3, 1, 2} print(set1) set1.pop() #pop()随机删除集合中的一个元素一般是删除最开始一个元素 set1.pop()

print(set1)

{1, 2, 3, 4}

{3, 4}

remove() 删除集合中指定的元素

set1 = {4, 3, 1, 2} set1.remove(3) print(set1)

clear() 清空集合

set1.clear()

print(set1)

{1, 2, 4} set()

集合的运算

s1 = {1, 2, 3, 7, 8} s2 = {4, 5, 6, 7, 8} print(‘s1 = ‘, s1) print(‘s2 = ‘, s2)

& 交集运算

print(‘s1 & s2 =’, s1 & s2)

| 并集运算

print(‘s1 | s2 =’, s1 | s2)

- 差集运算

print(‘s1 - s2 = ‘, s1 - s2)

^ 亦或集

print(‘s1 ^ s2 =’, s1 ^ s2)

s1 = {1, 2, 3, 7, 8} s2 = {4, 5, 6, 7, 8} s1 & s2 = {8, 7} s1 | s2 = {1, 2, 3, 4, 5, 6, 7, 8} s1 - s2 = {1, 2, 3} s1 ^ s2 = {1, 2, 3, 4, 5, 6}

  1. <a name="Yhr7P"></a>
  2. ### 字符串，列表，元组，字典, 集合比较
  3. ```python
  4. #!D:\pythonProject
  5. # -*- coding: utf-8 -*-
  6. # @Time    : 2021/1/28 21:58
  7. # @Author  : J. Ding
  8. # @File    : 字符串，列表，元组，字典， 集合比较.py
  10. str1 = 'abcdef'
  11. str2 = 'GHIJ'
  12. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
  13. list2 = ['G', 'H', 'I', 'J']
  14. tuple1 = ('a', 'b', 'c', 'd', 'e', 'f')
  15. tuple2 = ('G', 'H', 'J', 'J')
  16. dict1 = {0 : 'a', 1 : 'b', 2 : 'c', 3 : 'd', 4 : 'e', 5 : 'f'}
  17. dict2 = {6 : 'G', 7 : 'H', 8 : 'I', 9 : 'J'}
  18. set1 = {1, 5, 4, 3, 2}
  19. set2 = {6, 7, 4, 5}
  21. print("str1 = 'abcdef'")
  22. print("str2 = 'GHIJ'")
  23. print("list1 = ['a', 'b', 'c', 'd', 'e', 'f']")
  24. print("list2 = ['G', 'H', 'I', 'J']")
  25. print("tuple1 = ('a', 'b', 'c', 'd', 'e', 'f')")
  26. print("tuple2 = ('G', 'H', 'J', 'J')")
  27. print("dict1 = {0 : 'a', 1 : 'b', 2 : 'c', 3 : 'd', 4 : 'e', 5 : 'f'}")
  28. print("dict2 = {6 : 'G', 7 : 'H', 8 : 'I', 9 : 'J'}")
  29. print('set1 = {1, 5, 4, 3, 2}')
  30. print('set2 = {6, 7, 4, 5}')
  33. #取值
  34. print ('========取值比较========')
  35. print('str1[0] = ', str1[0])
  36. print('list1[0] = ', list1[0])
  37. print('tuple1[0] = ', tuple1[0])
  38. print('dict1.get(0) = ', dict1.get(0))
  39. print('# 集合无序，无法按位取值')
  40. #长度 len()
  41. print('========元素个数比较========')
  42. print('len(str1) = ', len(str1))
  43. print('len(list1) = ', len(list1))
  44. print('len(tuple1) = ', len(tuple1))
  45. print('len(dict1) = ', len(dict1))
  46. print('len(set1) = ', len(set1))
  47. # in, not in
  48. print('========in 操作比较========')
  49. print("'a' in str1 = ", 'a' in str1)
  50. print("'a' in list1 = ", 'a' in list1)
  51. print("'a' in tuple1 = ", 'a' in tuple1)
  52. print('0 in dict1 = ', 0 in dict1) # check if key is in the dict
  53. print('1 in set1 =', 1 in set1)
  54. # + (合并)
  55. print('========加法比较========')
  56. print('str1 + str2 = ', str1 + str2)
  57. print('list1 + list2 = ', list1 + list2)
  58. print('tuple1 + tuple2 = ', tuple1 + tuple2)
  59. dict1.update(dict2)
  60. print('在 dict1.update(dict2) 操作之后, dict1 = ', dict1)
  61. set1.update(set2)
  62. print('在 set1.update(set2) 操作之后, set1 = ', set1)
  63. # *
  64. print('========乘法比较========')
  65. print('str1 * 2 = ', str1 * 2)
  66. print('list1 * 2 = ', list1 * 2)
  67. print('tuple1 * 2 = ', tuple1 * 2)
  68. print('dict 没有乘法操作')
  69. print('set 没有乘法操作')
  70. # max / min
  71. print('========max比较========')
  72. print('max(str2) = ', max(str2))
  73. print('max(list2) = ', max(list2))
  74. print('max(tuple2) = ', max(tuple2))
  75. print('max(dict2) = ', max(dict2))
  76. print('max(set2) = ', max(set2))
  77. # 切片
  78. print('========切片比较========')
  79. print('str1[0:5:2] = ', str1[0:5:2])
  80. print('list1[0:5:2] = ', list1[0:5:2])
  81. print('tuple1[0:5:2] = ', tuple1[0:5:2])
  82. print('# 字典没有切片操作') # 字典没有切片操作
  83. print('# 集合没有切片操作') # 集合没有切片操作
  85. # 增加
  86. print('========增加比较========')
  87. list2 = ['G', 'H', 'I', 'J']
  88. dict2 = {6 : 'G', 7 : 'H', 8 : 'I', 9 : 'J'}
  89. set2 = set2 = {6, 7, 4, 5}
  90. print('# 字符串不可变，不支持修改元素') # 字符串不可变，不支持增加元素
  91. print("list2.append('K')")
  92. list2.append('K')
  93. print('list2 = ', list2)
  94. print('# 元组不可变，不支持修改元素') # 元组不可变，不支持修改元素
  95. print("dict2.update({10: 'K'})")
  96. dict2.update({10 : 'K'})
  97. print('dict2 =', dict2)
  98. set2.add(8)
  99. print('set2 =', set2)
  101. # 删除
  102. print('========删除比较========')
  103. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
  104. dict1 = {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f'}
  105. set1 = {1, 5, 4, 3, 2}
  106. print('#字符串不支持删除元素，除非空格')
  107. print('list1.pop(2) = ', list1.pop(2))
  108. print('# 元组不可变，不支持删除元素')
  109. print('dict1.pop(2) =', dict1.pop(2))
  110. del dict1[3] # 删除键值为3的key-value对
  111. print('del dict1[3] =', dict1, '#删除键值为3的key-value对')
  112. print('set1.pop() =', set1.pop(), '# pop()随机删除集合中的一个元素, 一般是第一个元素') # pop()随机删除集合中的一个元素, 一般是第一个元素
  113. set1.remove(3)
  114. print('set1.remove(3) =', set1, '# pop(3)删除集合中的一个元素 3') # pop(3)删除集合中的一个元素 3
  116. #修改
  117. print('========修改比较========')
  118. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
  119. dict1 = {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f'}
  120. print('#字符串不支持修改元素')
  121. list1[0] = 'x'
  122. print("list1[0] = 'x'")
  123. print(list1)
  124. print('# 元组不可变，不支持修改元素')
  125. dict1[0] = 'x'
  126. print("dict1[0] = 'x'")
  127. print(dict1)
  128. print('# 集合不可变，不支持修改元素')
  130. #遍历
  131. print('========遍历比较========')
  132. str1 = 'abcdef'
  133. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
  134. tuple1 = ('a', 'b', 'c', 'd', 'e', 'f')
  135. dict1 = {0 : 'a', 1 : 'b', 2 : 'c', 3 : 'd', 4 : 'e', 5 : 'f'}
  136. set1 = {1, 5, 4, 3, 2}
  138. print('字符串遍历:')
  139. for i in str1:
  140.     print(i)
  141. print('列表遍历:')
  142. for i in list1:
  143.     print(i)
  144. print('元组遍历:')
  145. for i in tuple1:
  146.     print(i)
  147. print('字典遍历:')
  148. for i in dict1.keys():
  149.     print(i, dict1.get(i))
  150. print('集合遍历: #自动排序列出')
  151. for i in set1:
  152.     print(i)
  154. #清空
  155. print('========清空比较========')
  156. print('# 字符串没有清空方法') # 字符串没有清空方法
  157. list1.clear()
  158. print('list1.clear() =', list1)
  159. print('# 元组没有清空方法') # 元组没有清空方法
  160. dict1.clear()
  161. print('dict1.clear() =', dict1)
  162. set1.clear()
  163. print('set1.clear() =', set1)
  165. --------------输出-----------------------
  167. str1 = 'abcdef'
  168. str2 = 'GHIJ'
  169. list1 = ['a', 'b', 'c', 'd', 'e', 'f']
  170. list2 = ['G', 'H', 'I', 'J']
  171. tuple1 = ('a', 'b', 'c', 'd', 'e', 'f')
  172. tuple2 = ('G', 'H', 'J', 'J')
  173. dict1 = {0 : 'a', 1 : 'b', 2 : 'c', 3 : 'd', 4 : 'e', 5 : 'f'}
  174. dict2 = {6 : 'G', 7 : 'H', 8 : 'I', 9 : 'J'}
  175. set1 = {1, 5, 4, 3, 2}
  176. set2 = {6, 7, 4, 5}
  177. ========取值比较========
  178. str1[0] =  a
  179. list1[0] =  a
  180. tuple1[0] =  a
  181. dict1.get(0) =  a
  182. # 集合无序，无法按位取值
  183. ========元素个数比较========
  184. len(str1) =  6
  185. len(list1) =  6
  186. len(tuple1) =  6
  187. len(dict1) =  6
  188. len(set1) =  5
  189. ========in 操作比较========
  190. 'a' in str1 =  True
  191. 'a' in list1 =  True
  192. 'a' in tuple1 =  True
  193. 0 in dict1 =  True
  194. 1 in set1 = True
  195. ========加法比较========
  196. str1 + str2 =  abcdefGHIJ
  197. list1 + list2 =  ['a', 'b', 'c', 'd', 'e', 'f', 'G', 'H', 'I', 'J']
  198. tuple1 + tuple2 =  ('a', 'b', 'c', 'd', 'e', 'f', 'G', 'H', 'J', 'J')
  199. 在 dict1.update(dict2) 操作之后, dict1 =  {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'G', 7: 'H', 8: 'I', 9: 'J'}
  200. 在 set1.update(set2) 操作之后, set1 =  {1, 2, 3, 4, 5, 6, 7}
  201. ========乘法比较========
  202. str1 * 2 =  abcdefabcdef
  203. list1 * 2 =  ['a', 'b', 'c', 'd', 'e', 'f', 'a', 'b', 'c', 'd', 'e', 'f']
  204. tuple1 * 2 =  ('a', 'b', 'c', 'd', 'e', 'f', 'a', 'b', 'c', 'd', 'e', 'f')
  205. dict 没有乘法操作
  206. set 没有乘法操作
  207. ========max比较========
  208. max(str2) =  J
  209. max(list2) =  J
  210. max(tuple2) =  J
  211. max(dict2) =  9
  212. max(set2) =  7
  213. ========切片比较========
  214. str1[0:5:2] =  ace
  215. list1[0:5:2] =  ['a', 'c', 'e']
  216. tuple1[0:5:2] =  ('a', 'c', 'e')
  217. # 字典没有切片操作
  218. # 集合没有切片操作
  219. ========增加比较========
  220. # 字符串不可变，不支持修改元素
  221. list2.append('K')
  222. list2 =  ['G', 'H', 'I', 'J', 'K']
  223. # 元组不可变，不支持修改元素
  224. dict2.update({10: 'K'})
  225. dict2 = {6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K'}
  226. set2 = {4, 5, 6, 7, 8}
  227. ========删除比较========
  228. #字符串不支持删除元素，除非空格
  229. list1.pop(2) =  c
  230. # 元组不可变，不支持删除元素
  231. dict1.pop(2) = c
  232. del dict1[3] = {0: 'a', 1: 'b', 4: 'e', 5: 'f'} #删除键值为3的key-value对
  233. set1.pop() = 1 # pop()随机删除集合中的一个元素, 一般是第一个元素
  234. set1.remove(3) = {2, 4, 5} # pop(3)删除集合中的一个元素 3
  235. ========修改比较========
  236. #字符串不支持修改元素
  237. list1[0] = 'x'
  238. ['x', 'b', 'c', 'd', 'e', 'f']
  239. # 元组不可变，不支持修改元素
  240. dict1[0] = 'x'
  241. {0: 'x', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f'}
  242. # 集合不可变，不支持修改元素
  243. ========遍历比较========
  244. 字符串遍历:
  245. a
  246. b
  247. c
  248. d
  249. e
  250. f
  251. 列表遍历:
  252. a
  253. b
  254. c
  255. d
  256. e
  257. f
  258. 元组遍历:
  259. a
  260. b
  261. c
  262. d
  263. e
  264. f
  265. 字典遍历:
  266. 0 a
  267. 1 b
  268. 2 c
  269. 3 d
  270. 4 e
  271. 5 f
  272. 集合遍历: #自动排序列出
  273. 1
  274. 2
  275. 3
  276. 4
  277. 5
  278. ========清空比较========
  279. # 字符串没有清空方法
  280. list1.clear() = []
  281. # 元组没有清空方法
  282. dict1.clear() = {}
  283. set1.clear() = set()
  285. 进程已结束,退出代码0

作业

  • a = {“name”:”123”,”data”:{“result”:[{“src”:”python1”},{“src”:”python2”},{“src”:”python3”}]}} 找到python1/python2/python3 ```python a = {“name”:”123”,”data”:{“result”:[{“src”:”python1”},{“src”:”python2”},{“src”:”python3”}]}} for i in a[‘data’][‘result’]: print(i[‘src’])

python1 python2 python3

  2. - 有如下值列表[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。
  3. ```python
  4. list1 = [11,22,33,44,55,66,77,88,99,90]
  5. list3 = []
  6. list4 = []
  7. dict1 = {'大于66' : list3, '小于66' : list4}
  8. for i in list1:
  9.     if i > 66:
  10.         dict1.setdefault('大于66', list3.append(i))
  11.     if i < 66:
  12.         dict1.setdefault('小于66', list4.append(i))
  13. print(dict1)
  14. ---------------------------------------
  15. {'大于66': [77, 88, 99, 90], '小于66': [11, 22, 33, 44, 55]}