列表中每个元素都加一个特定的字符_第二章：列表、元组和字典

第一节：序列、列表、元组的关系和创建

• 了解Python序列
  • 序列概念：所谓序列，指的是一种包含多项数据的数据结构，序列包含多个数据项(也叫成员)按顺序排列，可通过索引(也就是下标)来查找成员
  • 常见的序列：字符串、字节串、元组、列表等，还有后面要说的namedtuple也是序列
• 创建列表和元组
  • 列表和元组的区别：列表是可变的，元组是不可变的
  • 如何区分列表和元组：
    • 方括号是列表，圆括号是元组
    • 列表用list()创建，元组用tuple()创建
• 创建列表和元组方式一
  • 创建列表：[ele1,ele2,ele3,...]
  • 创建元组：(ele1,ele2,ele3,...)
    • 程序示例
    • 创建元组的注意点：由于圆括号在Python是一个很普通的符号，因此如果创建只包含一个元素的元组，需要在元素后放一个逗号

# 创建列表用方括号# 列表创建后，它所包含的元素是可以改变的my_list = [2,3,'Python',3.4]# 创建元组用圆括号# 元组一旦创建，它所包含的元素是不可改变的my_tuple = (3,4,100,'Python')# 如果创建元组只有一个元素，元素后要加一个逗号single_tuple = ('jave',)

• 创建列表和元组方式二
  • 创建列表：list()函数
  • 创建元组：tuple()函数
  • 本质上，list和tuple是Python的内置类型，因此list()、tuple()其实是他们的构造器

# 用list函数创建列表my_list = list(range(2,10))# 用tuple函数创建元组my_tuple = tuple(range(4,8))# 将元组装换成列表list2 = list(my_tuple)# 将列表装换成元组tuple2 = tuple(my_list)

第二节：列表和元组的简单使用

• 通过索引访问元素
  • 正向访问：从左向右，索引从0开始，第一个元素的索引为0，第二个元素的索引为1，以此类推
  • 反向访问：从右向左，索引从-1开始，倒数第一个元素的索引为-1，倒数第二个元素的索引为-2，以此类推

列表索引示例图

my_tuple = tuple(range(3,10))print(my_tuple)# len()函数可用于访问列表的长度print(len(my_tuple))# 访问第三个元素print(my_tuple[2])# 访问倒数第二个元素print(my_tuple[-2])my_list = ['python', 'swift', 'kotlin', 'java', 'cc', 'go']# 访问同一个元素Javaprint(my_list[3])print(my_list[-3])# 当用索引访问元素的时候，索引范围在-len~len-1之间，不然程序会报错，越界了！# 越界出错index out of rangeprint(my_list[6]) print(my_list[-7])

• 子序列
  • 与前面介绍的字符串操作类似，列表和元组也同样可以使用索引获取中间的一段，这种用法被称为slice(分片或切片)
  • slice语法格式：[start:end:step]起始索引:结束索引:步长

my_tuple = ('java', 'js', 20, 100, 'kotlin', 'oc')# 获取子序列print(my_tuple[2:5])print(my_tuple[-5:-2])print(my_tuple[3:-1])# 获取子序列，指定步长print(my_tuple[2:-1：2])print(my_tuple[2:-1：3])

• 序列运算
  • 序列的加法
    • 加法的和就是把两个列表或元组所包含的元素的总和
    • 列表只能和列表相加，元组只能和元组相加，元组不能直接和列表相加

# 列表加运算list1 = [20, 'python']list2 = list(range(4))# 加法运算就是把两个列表的元素拼接到一起print(list1 + list2)# 元组加运算tuple1 = (20, 'python')tuple2 = tuple(range(4))# 加法运算就是把两个元组的元素拼接到一起print(tuple1 + tuple2)# 列表和元组不能直接相加print(list1 + tuple1) # 会报错# 如果想让列表与元组相加可以进行装换print(list1 + list(tuple1)) print(tuple(list1) + tuple1) 

• • 序列的乘法
    • 列表与元组乘法的意义：把他们包含的元素重复N次 N就是被乘的倍数
    • 可以列表、元组同时进行加法、乘法运算
    • 示例：日期翻译程序

# 列表相乘list1 = ['python', 29, -2]# 序列只能与整数相乘，就是把元素重复N次print(list1 * 3)# 字符串也属于序列，也可以与整数进行乘法，把字符串重复N次s = 'fkjava'print(s * 5)# 元组相乘tuple1 = tuple(range(5))print(tuple1 * 5)# in用于判断列表或者元组是否包含某个元素list1 = [20, 'python']print(20 in list1) # trueprint(30 in list1) # false

第三节：序列相关函数与封包解包

• 最大值、最小值、长度
  • len() 、max() 、min()函数可获取元组、列表的长度、最大值和最小值
  • 字符串也能比较大小
    • 字符串比较大小时，会依次按照字符串中的每个字符对应的编码来比较大小
    • 先比较第一个字符，如果第一个字符相同则比较第二个字符，以此类推

mylist = ['python', 'swift', 'kotlin', 'java', 'go']# len可以获取序列包含多少个元素print(len(mylist))# 字符串比较大小：先比较第一个字符，如果第一个相等，比较第二个，以此类推print(max(mylist))print(min(mylist))

• 序列解包与封包
  • 序列封包：把多个值赋给一个变量时，Python会自动将多个值封装成元组，这种功能被称为序列的封包

# python 会先将多个值封装成元组，然后将元组存入变量中mydata = 25,  30, 'python'print(mydata)print(type(mydata))

• • 序列解包：序列(元组或者列表等)可被直接赋值给多个变量，此时序列的各个元素会被依次赋值给每个变量(要求序列的元素个数和变量个数相等)，这种功能被称为序列的解包

mylist = [20, 'fkjava', 3.4]# 自动解包 将列表中的三个值自动赋值给三个变量a, b, c = mylistprint(a)print(b)print(c)# 所有序列(甚至包括range)都支持自动解包a, b, c, d = range(30, 34)print(a)print(b)print(c)print(d)mytuple = ('python', 'swift', 'kotlin', 'java', 'go', 'spring', 'swx')# 如果你只要解包某一个值 剩下的值可用一个带*的变量(列表)来接收first, *rest = mytupleprint(first)print(rest)# 如果你只要解包某几个值 剩下的值可用一个带*的变量(列表)来接收first, *rest, last = mytupleprint(first)print(rest)print(last)# 字符串也是序列，因此也支持解包a, b, *c = 'fkjava.org'print(a)print(b)print(c)

• • 多变量同时赋值：Python的赋值运算符支持同时将多个值赋值给多个变量 这是因为同时运用了序列封包和序列解包

序列封包和解包示例图

# 先将右边的多个值封装成一个元组，然后元组又被解包依次给三个变量赋值a, b, c = 30, 'python', 3.4print(a)print(b)print(c)

第四节：列表的用法及操作列表元素

• 添加、删除、替换元素
  • 增加元素
    • append()方法：会把传入的参数追加到列表的最后面，追加一个列表(序列)时，列表被当成一个元素
    • extend()方法：用于追加另一个列表(序列)，它会将列表(序列)中的元素追加进来
    • insert()方法：将元素插入指定位置

my_list = ['python', 'swift']my_list.append('kotlin')print(my_list)# 为列表append元组，元组将被当做一个整体my_list.append(tuple(range(3, 6)))print(my_list)# extend 方法是将序列中的元素添加进来my_list.extend(range(20,25))print(my_list)# 字符串也是序列，会将每一个字符加进来my_list.extend('fkjava')print(my_list)# 将lua插入到第四个元素的位置my_list.insert(3, 'lua')print(my_list)

• • 删除元素
    • 删除列表元素使用del语句
    • del语句，专门用于执行删除操作，不仅可用于删除列表的元素，也可用于删除变量等
    • del语句即可删除列表中的单个元素，也可直接删除列表的中间一段
    • 列表提供了remove()方法来删除元素，remove()方法不根据索引删除元素，而是删除第一个找到的元素

my_list = ['python', 'swift', 'lua', 'kotlin', 'js']# 删除第三个元素del my_list[2]print(my_list)# 追加30 31 32 33 34 my_list.extend(range(30,35))print(my_list)# 删除第5个到第7个del my_list[4: 7]print(my_list)# 每隔两个删除一个元素 指定步长del my_list[2: 6: 2]print(my_list)

• • 替换元素
    • 对列表中的元素赋值即可修改列表中的元素
    • 利用slice语法对列表中的一部分赋值，赋值时并不要求新赋值的元素个数与原元素个数相同，这种方式既可以为列表增加元素，也可以为列表删除元素
    • 对列表的slice语法赋值时，不能使用单个值，如果使用字符串赋值，Python会自动把字符串当做序列处理

my_list = ['python', 'swift', 'lua', 'kotlin', 'js']# 对单个元素赋值my_list[-2] = 'java'print(my_list)# 被替换的部分只有两个元素，替换成四个元素，实际上是增加了元素my_list[2: 4] = ['lua', 'java', 'go', 'erlang']print(my_list)# 被替换的部分只有3个元素，替换成1个元素，实际上是删除了元素my_list[2: 5] = ['objective-c']print(my_list)# 当列表中一段赋值时，程序会自动把字符串当成列表处理my_list[1: 3] = 'fkjava'print(my_list)

• 列表常用方法
  • 通过dir(list)可查看列表支持的方法
  • count()：统计列表中某个元素出现的次数
  • index()：判断列表中某个元素在列表中出现的位置
  • pop():该方法用于将列表当成“栈”使用，实现元素出栈功能
  • reverse()：用于将列表中的元素方向存放
  • sort()：用于对列表元素排序

my_list = ['python', 'swift', 'lua', 'kotlin', 'js']#判断元素的位置print(my_list.index('swife')) #反转列表元素my_list.reverse()print(my_list)#排序my_list.sort()print(my_list)

第五节：字典入门

• 创建字典
  • 字典的概念：字典用于保存具有映射关系的数据，相当于保存了两组数据，其中一组数据是关键数据，被称为key；另一组数据可通过key来访问，成为value
  • 字典中的key和value关系如图，key不允许重复

字典key-value示例图

• • 创建字典的方法
    • 花括号法：花括号应包含多组key-value对，key与value之间用英文冒号隔开，多组key-value对之间用英文逗号隔开
    • dict构造法：可以传入多个列表或者元组参数作为key-value对；也可为dict指定关键字参数创建字典，此时字典的key不允许使用表达式
    • 字典的key必须是不可变的，因此列表不能作为dict的key

# 字典中的数据就是key:value成对出现socres = {'语文': 85, '数学': 92, '英语': 78}print(socres)# 要求每个元素只能有两个元素，其中一个元素是key，一个元素是valuemy_dict = dict([('语文', 85), ('数学', 92), ('英语', 78)])print(my_dict)# 用关键字参数来创建dict，此时不允许使用表达式my_dict2 = dict(语文=85, 数学=92, 英语=78)print(my_dict2)

• 操作字典key-value对
  • 在方括号中放的是key，即可通过key来访问value
  • 对不存在的key赋值，就是添加key-value对
  • 使用del语句就是删除key-value对，注意：将指定key赋值为none不能删除key-value对
  • 判断是否包含指定的key，使用in和not in

# 字典dict是可变的，列表是可变的# 列表中的元素可以增删改，字典中的key-value对也可以增删改socres = {'语文': 85, '数学': 92, '英语': 78}# 通过key来访问valueprint(scores['语文'])print(scores['数学'])print(scores['英语'])# 对不存在的key赋值，就是添加key-value对socres['生物'] = 91print(socres)# 对已经有的key赋值，就是替换key-value对socres['数学'] = 95print(socres)# 删除key-value对del socres['数学'] # 判断是否包含的时候，只要判断key就行了print('数学' in socres)

• 理解dict与list的关系
  • 字典相当于索引是任意不可变类型的列表；而列表则相当于key只能是整数的字典。如果程序中要使用的字典的key都是整数类型，则可以考虑能不能换成列表
  • 列表的索引总是从0开始，连续增大；但字典的索引即使是整数类型，也不需要从0开始，也不需要连续。因此列表不允许对不存在的索引赋值；但是字典允许直接对不存在的key赋值，这样就会为字典增加一组key-value对

第六节：字典高级用法

• 字典常用的方法
  • 调用dir(dict)可查看字典的所有方法
  • clear()用于清空字典中所有的key-value对
  • get()根据key来获取value
  • update()可使用一个字典所包含的key-value对来更新已有的字典

socres = {'语文': 86, '数学': 92, '英语': 91}# 用一个(字典、序列、关键字参数)来更新原有的字典：# 对于已有的key是更新value，对于不存在的key，就是添加key-valuesocres.update({'语文': 89, '生物': 91})print(socres)# 使用序列作为一个参数 此时序列的每个元素都只能有2个元素，第一个是key，第二个是valuesocres.update([('语文', 80), ('物理', 93)])print(socres)# 使用关键字作为一个参数，不支持用表达式socres.update(语文=79, 化学=93)print(socres)

• • items()、key()、values()分别用于获取字典中所有的key-value对，所有的key、所有的value

socres = {'语文': 86, '数学': 92, '英语': 91}# 遍历keyfor key in socres.keys()：    print(key)    # 遍历valuefor value in socres.values()：    print(value)    # 遍历key和value(序列解包)for key,value in socres.items()：    print(key,value)

• • pop()用于获取并删除指定key对应的value
  • popitem()用于随机弹出字典的key-value对
  • setdefault()根据key来获取对应的value值，并为不存在的key设置默认值
  • fromkeys()使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value

socres = {'语文': 86, '数学': 92, '英语': 91}# setdefault用于获取指定key对应的value值print(socres.setdefault('语文', 60))# 如果获取的key不存在时，会为该key设置value，相当于增加一个key-value对print(socres.setdefault('生物', 60))print(socres)# 利用fromkeys创建字典,value值为Nonesc = dict.formkeys(['语文', '数学', '英语'])print(sc)# fromkeys可将序列转换成字典，使用固定的值作为valuesc2 = dict.formkeys(['语文', '数学', '英语'], 60)print(sc2)

• 使用字典格式化字符串
  • 可在字符串模板中按key指定变量，然后通过字典为字符串模板中key设置值

# 用元组来格式化字符串，所以它根据位置来填充占位符s1 = '图书名为： %s, 价格为： %10.2f'print(s1 % ("python", 128))# 用dict来格式化字符串，所以它根据key来填充占位符s2 = '图书名为： %(name)s, 价格为： %(price)10.2f'print(s2 % {'price': 128, 'name': "python"})

第七节：案例实操-随机大写字符存入列表

• 方法一
  • 创建列表
  • 生成指定范围的随机数
  • 随机数转字符
  • 字符存入列表

# 生成N个随机的大写字符存入列表NUM = 10import random# 创建空列表result = [];# 循环10次，生成10个随机数for i in range(NUM):    # 生成65-90(不包括)的随机数    n = random.randint(65, 90)    # 随机数转成字符，并添加到列表中    result.append(chr(n))print(result)

• 方法二
  • 使用列表推导式
  • range(10)控制循环10次，控制生成10个随机大写字符

# 生成N个随机的大写字符存入列表NUM = 10import random# 列表推导式result = [ chr(random.randint(65, 90)) for i in range(NUM)]print(result)

• 方法三
  • 使用列表推导式
  • 使用numpy模块一次生成N个随机数
  • [chr(a) for a in np.random.randint(65,90,[10,1])]

# 生成N个随机的大写字符存入列表NUM = 10import numpy# numpy.random.randint()函数可以生成一个随机数的矩阵，可生成多行多列的随机数# 列表推导式# numpy.random.randint(65, 90, [NUM, 1])生成一行，NUM列个随机数# 相当于一个包含NUM个随机数的列表result = [ chr(i) for i in numpy.random.randint(65, 90, [NUM, 1])]print(result)

第八节：案例实操-列表去重

• 新列表搜集法
  • 创建新列表
  • 遍历源列表中的所有元素，若该元素不在新列表中，将元素添加到新列表中
  • 这种方式可以保证元素的顺序

# 利用列表推导式创建一个包含重复元素的列表import randomsrc_list = [random.randint(20, 30) for i in range(15)]print(src_list)# 新列表搜集法# 创建空列表target_list = [] # 遍历源列表中的每个元素，for ele in src_list:    # 如果新列表不包含当前元素，新列表添加该元素即可    # 这样就保证重复的元素添加不进去了    if ele not in target_list:        target_list.append(ele)print(target_list)

• 使用set集合去重
  • set集合的特征：不允许重复的元素
  • 将列表元素传给set()，自动去重元素

# 利用列表推导式创建一个包含重复元素的列表import randomsrc_list = [random.randint(20, 30) for i in range(15)]print(src_list)# 将源列表传给set集合，自动去重元素# 再次恢复成一个列表target_list = list(set(src_list))print(target_list)

• 使用itertools模块的groupby函数去重
  • 该函数用于分组，相同的就分为同一组
  • 注意：这种方式必须先对列表进行排序

# 利用列表推导式创建一个包含重复元素的列表import randomimport itertoolssrc_list = [random.randint(20, 30) for i in range(15)]print(src_list)# 首先必须对列表进行排序src_list.sort()# 进行分组，相同的元素就分成同一组，it = itertools.groupby(src_list)# 遍历各组，因此得到的都是不同的元素(去重)for k, g in it:    print(k)    # 不希望换行的话，添加end等于空格    print(k, end=" ")