Python训练营Python基础练习学习笔记

一、学习知识点概要

Task2主要的内容是学习python的数据结构，主要的知识内容有：

1. 列表（增删查改，操作符，常用的方法）
2. 元组（增删查改，操作符，常用的方法）
3. 字符串（增删查改，操作符，常用的方法）
4. 字典（增删查改，操作符，常用的方法）
5. 集合（增删查改，操作符，常用的方法）
6. 序列通用的方法

二、学习内容

1. 列表

定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。

x = [a] * 4操作中，如果a是容器类型，则4个a只会有同一个指针，所以修改a里面的内容，其他三个a都会随之改变。

x = [[1] * 3] * 4
# [[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]]

x[0][0] = 2
# [[2, 1, 1], [2, 1, 1], [2, 1, 1], [2, 1, 1]]

创建列表

1. 利用range()和list创建列表

   x = list(range(10))
   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   

2. 利用推导式创建列表

   x = [0 for i in range(5)]
   # [0, 0, 0, 0, 0]
   

添加元素

1. list.append(obj)

   在列表末尾添加新的对象，参数可以是任何数据类型。

   x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
   x.append('Thursday')
   # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
   

2. list.extend(seq)

   在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

   x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
   x.extend(['Thursday', 'Sunday'])
   # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
   

3. list.insert(index, obj)

   在编号 index 位置插入 obj。

   x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
   x.insert(2, 'Sunday')
   # ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
   

删除元素

1. list.remove(obj)

   移除列表中某个值的第一个匹配项

2. list.pop([index=-1])

   移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

3. del var1[, var2 ……]

   删除单个或多个对象。

   x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
   del x[0:2]
   print(x)  
   # ['Wednesday', 'Thursday', 'Friday']
   

   如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

获取元素

1. 通过元素的索引值，从列表获取单个元素。

2. 通过切片

   通用写法是 start : stop : step，所有指定stop的切片都不会切到stop的位置。

   • start :

     以 step 为 1 (默认) 从编号 start 往列表尾部切片

   • : stop

     以 step 为 1 (默认) 从列表头部往编号 stop 切片。

   • start : stop

     以 step 为 1 (默认) 从编号 start 往编号 stop 切片。

   • start : stop : step

     以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。

   • :

     复制列表中的所有元素（浅拷贝）。

     week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
     print(week[:])  
     # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
     

列表常用的操作符

1. 等号操作符：==

   只有成员、成员位置都相同时才返回True。

   list1 = [123, 456]
   list2 = [456, 123]
   list3 = [123, 456]
   
   print(list1 == list2)  # False
   print(list1 == list3)  # True
   

2. 连接操作符 +

   相当于extend()

   list4 = list1 + list2  # extend()
   print(list4)  # [123, 456, 456, 123]
   

   前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

3. 重复操作符 *

   复制拼接

   list5 = list3 * 3
   print(list5)  # [123, 456, 123, 456, 123, 456]
   

4. 成员关系操作符 in、not in

其他方法

1. list.count(obj)

   统计某个元素在列表中出现的次数

2. list.index(x[, start[, end]])

   从列表中找出某个值第一个匹配项的索引位置

3. list.reverse()

   反向列表中元素

4. list.sort(key=None, reverse=False)

   对原列表进行排序。

   • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
   • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

   # 获取列表的第二个元素
   def takeSecond(elem):
       return elem[1]
   
   x = [(2, 2), (3, 4), (4, 1), (1, 3)]
   x.sort(key=takeSecond)
   print(x)
   # [(4, 1), (2, 2), (1, 3), (3, 4)]
   

2. 元组

定义

与列表相似，不同之处元组（tuple）被创建后不能修改类似于字符串

创建元组

1. 可以用小括号 ()，也可以什么都不用

   t1 = (1, 10.31, 'python')
   t2 = 1, 10.32, 'python'
   # (1, 10.31, 'python') <class 'tuple'>
   # (1, 10.32, 'python') <class 'tuple'>
   

2. 一个元素的元组后面需要添加逗号，否则括号会被当做运算符使用

   x = (1,)
   print(type(x))  # <class 'tuple'>
   

修改元组

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但如果元素（list）可更改 (mutable)，那就可以更改其元素

t1 = (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
# (1, 2, 3, [9, 5, 6])

操作符

==，+，*，in，not in，其作用都跟list一样。

内置方法

1. count

   记录该元素在元组中出现几次

   t = (1, 10.31, 'python')
   print(t.count('python'))  # 1
   

2. index

   返回该元素在元组的索引值

   print(t.index(10.31))  # 1
   

解压

解压也适用于其他容器类型

1. 解压元组（变量<=元组个数）

   # 一维
   t = (1, 10.31, 'python')
   (a, b, c) = t
   print(a, b, c)
   # 1 10.31 python
   
   # 二维
   t = (1, 10.31, ('OK', 'python'))
   (a, b, (c, d)) = t
   print(a, b, c, d)
   # 1 10.31 OK python
   

2. 解压元组其中几个元素，用通配符[*]

   t = 1, 2, 3, 4, 5
   a, b, *rest, c = t
   print(a, b, c)  # 1 2 5
   print(rest)  # [3, 4]  <class 'list'>
   

3. 字符串

定义

字符串具有不可修改性。使用成对的双引号和单引号定义单行字符串，使用成对的三引号（""" “”"）定义跨多行的字符串

转义字符

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符(TAB)
\r	回车

在字符串前加r，就能得到原始字符串

print(r'C:\Program Files\Intel\Wifi\Help')  
# C:\Program Files\Intel\Wifi\Help

内置方法

1. capitalize()

   将字符串的第一个字符转换为大写。

   str2 = 'xiaoxie'
   print(str2.capitalize())  # Xiaoxie
   

2. lower()

   转换字符串中所有大写字符为小写。

3. upper()

   转换字符串中的小写字母为大写。

4. swapcase()

   将字符串中大写转换为小写，小写转换为大写。

5. count(str[, start=0,end=len(string)])

   返回str在 string 里面出现的次数，start默认为0，end默认为字符串长度。同下。

6. endswith(suffix[, start=0, end=len(string)])

   检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。

7. startswith(substr[, start=0,end=len(string)])

   检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。

8. find(str[, start=0, end=len(string)])，rfind(str[, start=0,end=len(string)])

   find：检测 str 是否包含在字符串中，如果包含，返回开始的索引值，否则返回 -1。

   rfind：类似于 find() 函数，不过是从右边开始查找。

9. isnumeric()

   如果字符串中只包含数字字符，则返回 True，否则返回 False。

10. ljust(width[, fillchar])，rjust(width[, fillchar])

    ljust：使用fillchar（默认空格）从左到右填充至长度width的新字符串。

    rjust：使用fillchar（默认空格）从右到左填充至长度width的新字符串。

    str4 = '1101'
    print(str4.ljust(8, '0'))  # 11010000
    print(str4.rjust(8, '0'))  # 00001101
    

11. lstrip([chars])，rstrip([chars])，strip([chars])

    lstrip：删除字符串左边的空格或指定字符。

    rstrip：删除字符串右边的空格或指定字符。

    strip：执行lstrip()和rstrip()。

12. partition(sub)，rpartition(sub)

    partition：将字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。

    rpartition：类似于partition()方法，不过是从右边开始查找。

    str5 = ' I Love LsgoGroup '
    print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')
    print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')
    print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')
    

13. replace(old, new [, max])

    字符串中的old替换成new，如果max指定，则替换不超过max次。

14. split([str="", num])

    默认以空格分割字符串，返回分割后的子字符串列表。num表示分割次数。

    u = "www.baidu.com.cn"
    # 分割0次
    print((u.split(".", 0)))  # ['www.baidu.com.cn']
    # 分割一次
    print((u.split(".", 1)))  # ['www', 'baidu.com.cn']
    

15. splitlines([keepends])

    按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，keepends为 False，不包含换行符，如果为 True，则保留换行符。

    str6 = 'I \n Love \n LsgoGroup'
    print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
    print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']
    

16. maketrans(intab, outtab)，translate(table[, deletechars=""])

    maketrans：创建字符映射的转换表。intab表示需要转换的字符，outtab表示字符转换的目标。

    translate：根据参数table给出的表，转换字符串的字符；deletechars为过滤掉的字符。

    str7 = 'this is string example....wow!!!'
    intab = 'aeiou'
    outtab = '12345'
    trantab = str7.maketrans(intab, outtab)
    print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
    print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!
    

字符串格式化

1. format 格式化函数

   str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
   print(str8)  # I Love Lsgogroup
   
   str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
   print(str8)  # I Love Lsgogroup
   
   str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
   print(str8)  # I Love Lsgogroup
   
   str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
   print(str8)  # 27.66GB
   

2. Python 字符串格式化符号

   符 号	描述
   %c	格式化字符及其ASCII码
   %s	格式化字符串，用str()方法处理对象
   %r	格式化字符串，用rper()方法处理对象
   %d	格式化整数
   %o	格式化无符号八进制数
   %x, %X	格式化无符号十六进制数（X为大写）
   %f	格式化浮点数字，可指定小数点后的精度
   %e, %E	用科学计数法格式化浮点数
   %g, %G	根据值的大小决定使用%f或%e

   print('%c' % 97)  # a
   print('%c %c %c' % (97, 98, 99))  # a b c
   print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
   print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
   print('%o' % 10)  # 12
   print('%x' % 10)  # a
   print('%X' % 10)  # A
   print('%f' % 27.658)  # 27.658000
   print('%e' % 27.658)  # 2.765800e+01
   print('%E' % 27.658)  # 2.765800E+01
   print('%g' % 27.658)  # 27.658
   text = "I am %d years old." % 22
   print("I said: %s." % text)  # I said: I am 22 years old..
   print("I said: %r." % text)  # I said: 'I am 22 years old.'
   

3. 格式化操作符辅助指令

   符号	功能
   m.n	m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
   -	用作左对齐
   +	在正数前面显示加号( + )
   #	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
   0	显示的数字前面填充’0’而不是默认的空格

   print('%5.1f' % 27.658)  # ' 27.7'
   print('%.2e' % 27.658)  # 2.77e+01
   print('%10d' % 10)  # '        10'
   print('%-10d' % 10)  # '10        '
   print('%+d' % 10)  # +10
   print('%#o' % 10)  # 0o12
   print('%#x' % 108)  # 0x6c
   print('%010d' % 5)  # 0000000005
   

4.字典

定义

字典 是无序的 键(key) : 值(value) 对集合。键是任意不可变类型，通常用字符串或数值。

如何分辨数据类型是不是可变类型？

1. id(X) 函数

   对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。

   i = 1
   print(id(i))  # 140732167000896
   i = i + 2
   print(id(i))  # 140732167000960
   
   l = [1, 2]
   print(id(l))  # 4300825160
   l.append('Python')
   print(id(l))  # 4300825160
   

2. hash(X)函数

   只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。

不可变类型：数值、字符和元组

可变类型：列表、集合、字典

创建字典

1. 构造函数dict() 创建一个空的字典。

   dic = dict()
   dic['a'] = 1
   dic['b'] = 2
   dic['c'] = 3
   
   print(dic)
   # {'a': 1, 'b': 2, 'c': 3}
   

2. dict(mapping)

   dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
   print(dic1)  # {'cherry': 4098, 'apple': 4139, 'peach': 4127}
   
   dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
   print(dic2)  # {'peach': 4127, 'cherry': 4098, 'apple': 4139}
   

3. dict(**kwargs)

   此方式键只能为字符串类型，并且不能加引号

   dic = dict(name='Tom', age=10)
   print(dic)  # {'name': 'Tom', 'age': 10}
   

内置方法

1. dict.fromkeys(seq[, value])

   用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

   seq = ('name', 'age', 'sex')
   dic1 = dict.fromkeys(seq)
   print(dic1)
   # {'name': None, 'age': None, 'sex': None}
   
   dic2 = dict.fromkeys(seq, 10)
   print(dic2)
   # {'name': 10, 'age': 10, 'sex': 10}
   
   dic3 = dict.fromkeys(seq, ('小马', '男'))
   print(dic3)
   # {'name': ('小马', '男'), 'age': ('小马', '男'), 'sex': ('小马', '男')}
   

2. dict.keys()

   返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。

3. dict.values()

   与dict.keys()不同的是，列表为字典中的所有值

4. dict.items()

   返回 (键, 值) 元组的可迭代对象

5. dict.get(key, default=None)

   返回指定键的值，如果值不在字典中返回默认值。

6. dict.setdefault(key, default=None)

   返回指定键的值，如果键不存在于字典中，将会添加键并将值设为默认值。

7. dict.pop(key[,default])，del dict[key]

   删除字典给定键 key 所对应的值，返回值为被删除的值。若key不存在，则返回 default 值。

8. dict.popitem()

   随机返回并删除字典中的一对键和值，如果字典已经为空，报KeyError异常。

9. dict.clear()

   用于删除字典内所有元素。

10. dict.copy()

    返回一个字典的浅复制。

    • 直接赋值和 copy 的区别

      dic1 = {'user': 'lsgogroup', 'num': [1, 2, 3]}
      
      # 引用对象
      dic2 = dic1  
      # 浅拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
      dic3 = dic1.copy()  
      
      print(id(dic1))  # 148635574728
      print(id(dic2))  # 148635574728
      print(id(dic3))  # 148635574344
      
      # 修改 data 数据
      dic1['user'] = 'root'
      dic1['num'].remove(1)
      
      # 输出结果
      print(dic1)  # {'user': 'root', 'num': [2, 3]}
      print(dic2)  # {'user': 'root', 'num': [2, 3]}
      print(dic3)  # {'user': 'runoob', 'num': [2, 3]}
      

11. dict.update(dict2)

    把字典参数 dict2 的 key:value对 更新到字典 dict 里。

    dic = {'Name': 'Lsgogroup', 'Age': 7}
    dic2 = {'Sex': 'female', 'Age': 8}
    dic.update(dic2)
    print(dic)  
    # {'Sex': 'female', 'Age': 8, 'Name': 'Lsgogroup'}
    

5. 集合

定义

集合中的元素没有重复值且是无序的，因此不能用索引和切片，也没有key来获取元素。

创建集合

创建空集合只能使用s = set()，因为s = {}创建的是空字典。

• 先创建对象再加入元素。用花括号括起来{元素1, 元素2, ..., 元素n}的重复元素会在set中自动过滤。

  num = {}
  print(type(num))  # <class 'dict'>
  num = {1, 2, 3, 4}
  print(type(num))  # <class 'set'>
  
  basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
  print(basket)  # {'banana', 'apple', 'pear', 'orange'}
  

• 使用set(value)工厂函数，把字符串、列表或元组转换成集合

  a = set('abracadabra')
  print(a)  
  # {'r', 'b', 'd', 'c', 'a'}
  
  b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
  print(b)  
  # {'Taobao', 'Lsgogroup', 'Google'}
  # 利用列表转换成集合再转换成列表，可以去除列表中的重复值
  c = set(["Google", "Lsgogroup", "Taobao", "Google"])
  print(c)  
  # {'Taobao', 'Lsgogroup', 'Google'}
  

访问集合中的值

• 使用for把集合中的数据一个个读取出来。

  s = set(['Google', 'Baidu', 'Taobao'])
  for item in s:
      print(item)
      
  # Baidu
  # Google
  # Taobao
  

内置方法

1. set.add(elmnt)

   向集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

2. set.update(set)

   用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

3. set.remove(item)

   移除集合中的指定元素。如果元素不存在，则会发生错误。

4. set.discard(value)

   用于移除指定的集合元素。如果元素不存在，不会发生错误。

5. set.pop()

   用于随机移除一个元素。

6. set.intersection(set1, set2)、set1 & set2

   返回两个集合的交集。

7. set.intersection_update(set1, set2)

   在原始的集合上移除不重叠的元素。

8. set.union(set1, set2)、set1 | set2

   返回两个集合的并集。

9. set.difference(set)、set1 - set2

   返回集合的差集。

   a = set('abracadabra')
   b = set('alacazam')
   print(a)  # {'r', 'a', 'c', 'b', 'd'}
   print(b)  # {'c', 'a', 'l', 'm', 'z'}
   
   c = a.difference(b)
   print(c)  # {'b', 'd', 'r'}
   print(a - b)  # {'d', 'b', 'r'}
   

10. set.difference_update(set)

    在原始的集合上移除重叠的元素。

    a.difference_update(b)
    print(a)  # {'d', 'r', 'b'}
    

11. set.symmetric_difference(set)、set1 ^ set2

    返回集合的异或。

    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'a', 'c', 'b', 'd'}
    print(b)  # {'c', 'a', 'l', 'm', 'z'}
    
    c = a.symmetric_difference(b)
    print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}
    print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}
    

12. set.symmetric_difference_update(set)

    在当前集合中移除重叠的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

    a.symmetric_difference_update(b)
    print(a)  # {'r', 'b', 'm', 'l', 'z', 'd'}
    

13. set.issubset(set)、set1 <= set2

    判断当前集合是否为另一个集合的子集，是返回true，否则返回false。

    x = {"a", "b", "c"}
    y = {"f", "e", "d", "c", "b", "a"}
    z = x.issubset(y)
    print(z)  # True
    print(x <= y)  # True
    

14. set.issuperset(set)、set1 >= set2

    判断当前集合是否为另一个集合的父集，是返回true，否则返回false。

    x = {"f", "e", "d", "c", "b", "a"}
    y = {"a", "b", "c"}
    z = x.issuperset(y)
    print(z)  # True
    print(x >= y)  # True
    

15. set.isdisjoint(set)

    用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

    x = {"f", "e", "d", "c", "b"}
    y = {"a", "b", "c"}
    z = x.isdisjoint(y)
    print(z)  # False
    
    x = {"f", "e", "d", "m", "g"}
    y = {"a", "b", "c"}
    z = x.isdisjoint(y)
    print(z)  # True
    

不可变的集合

frozenset，不能改变的集合，即不能增加或删除元素。frozenset仍然可以进行集合操作，只是不能用带有update的方法。

6. 序列

1. list(sub)

   把一个可迭代对象转换为列表。

2. tuple(sub)

   把一个可迭代对象转换为元组。

3. str(obj)

   把obj对象转换为字符串

4. len(s)

   返回对象（字符、列表、元组等）长度或元素个数。

5. max(sub)

   返回序列或者参数集合中的最大值

   print(max(1, 2, 3, 4, 5))  # 5
   print(max([-8, 99, 3, 7, 83]))  # 99
   print(max('IloveLsgoGroup'))  # v
   

6. min(sub)

   返回序列或参数集合中的最小值

   print(min(1, 2, 3, 4, 5))  # 1
   print(min([-8, 99, 3, 7, 83]))  # -8
   print(min('IloveLsgoGroup'))  # G
   

7. sum(iterable[, start=0])

   返回序列iterable与可选参数start的总和。

   print(sum([1, 3, 5, 7, 9]))  # 25
   print(sum([1, 3, 5, 7, 9], 10))  # 35
   

8. sorted(iterable, key=None, reverse=False)

   对所有可迭代的对象进行排序操作。

   key – 可以指定可迭代对象中的一个元素来进行排序。

   reverse – reverse = True 降序 ， reverse = False 升序（默认）。

   x = [-8, 99, 3, 7, 83]
   print(sorted(x))  # [-8, 3, 7, 83, 99]
   
   t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
   x = sorted(t, key=lambda a: a["age"])
   print(x)
   

9. reversed(seq)

   函数返回一个反转的迭代器。

   seq – 要转换的序列，可以是 tuple, string, list 或 range。

10. enumerate(sequence, [start=0])

    将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列

    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    a = list(enumerate(seasons))
    print(a)  
    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    

11. zip(iter1 [,iter2 [...]])

    • 将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

    • 可以使用 list() 转换来输出列表。

    • 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

    a = [1, 2, 3]
    b = [4, 5, 6]
    c = [4, 5, 6, 7, 8]
    zipped = zip(a, b)
    print(zipped)  # <zip object at 0x000000C5D89EDD88>
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    zipped = zip(a, c)
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    

三、学习问题与解答

无

四、学习思考与总结

task2主要讲了python的数据结构以及操作方法，认识到了浅复制和深复制的区别，如何判断什么是可变和不可变数据类型，序列数据类型的转换。总得来说task2的内容很生动，学到了很多python的数据结构知识。