Python列表操作

内容简介：

• 了解列表的基本概念
• 掌握列表的常用操作
• 理解列表的常见算法原理与代码实现
• 了解多维列表的操作及使用场景

列表

• 认识列表

  • 列表是Python中的一种可变数据类型
  • 列表可以存储任意大小的数据集合
  • 列表是一个用list类定义的序列，包括了创建、操作和处理列表的方法

• 列表的使用

  • 列表中的数据元素可以通过下标来访问

  • 列表中既可以包含同类型元素，也可以包含不同类型元素：

    list1 = [1, “大乔”, 2, “小乔”, 3, “寸金莲”, 4, “寸腰”]

    list2 = [“pi”, 3.1415, “e”, 2.7182]

  • 提示： Python中的列表一般不用考虑最大容量

    32位python的限制是 536870912 个元素。
    64位python的限制是 1152921504606846975 个元素

• 创建列表

  my_list1 = list()               			# 实例化一个列表对象/创建一个空的列表对象
  my_list2 = list("金木水火土")    			# 创建一个带有5个字符元素的列表，元素个数就是字符串中的字符个数
  my_list3 = list([9, 5, 2, 7])   			# 创建一个带有4个整数元素的列表
  my_list4 = list(range(10))      			# 通过一个可迭代对象创建对应元素的列表
  my_list5 = []                   			# 创建一个空列表
  my_list6 = ["金木水火土"]        			# 创建一个元素的列表
  my_list7 = ["金", "木", "水", "火", "土"]    # 创建五个元素的列表
  # 推导式
  """
  my_list_iterator = []
  for i in range(10):
      my_list_iterator.append(i)  			# 向列表中追加元素
  """
  my_list_iterator1 = [element for element in range(10)]       # 向列表中追加元素
  my_list_iterator2 = [10 for element in range(10)]            # 使用推导式创建带有10个10的元素列表
  my_list_iterator3 = [str(i) for i in range(10)]              # 使用推导式创建字符元素列表
  

元组和列表的区别

• 元组和列表都属于序列

• 列表属于可变序列，它的元素可以随时修改或者删除，而元组属于不可变序 列，其中的元素是不能修改的，除非整体重新赋值

• 列表可以使用多种方法实现添加和修改列表元素，而元组没有办法，因为不能想元组中添加或修改元素，同样也不能删除元素

• 列表可以使用切片方法访问和修改列表中的元素，元组也支持切片，但是它只支持通过切片访问元组中的元素，不支持修改

• 元组比列表中的访问和处理速度更快，所以如果只需要对其中的元素进行访问，而不进行任何修改，建议使用元组

• 列表不能作为字典类型中的键，而元组是可以的

序列的常用操作

• Python中的字符串和列表都是序列类型

• 列表是任何元素的序列，字符串是一个字符序列
  

  # @function: 列表的基本概念
  # @Description:
  
  # 列表是一个用list类定义的序列，包括了创建、操作和处理列表的方法
  my_list1 = list()               # 实例化一个列表对象/创建一个空的列表对象
  my_list2 = list("金木水火土")    # 创建一个带有5个字符元素的列表，元素个数就是字符串中的字符个数
  my_list3 = list([9, 5, 2, 7])   # 创建一个带有4个整数元素的列表
  my_list4 = list(range(10))      # 通过一个可迭代对象创建对应元素的列表
  my_list5 = []                   # 创建一个空列表
  my_list6 = ["金木水火土"]        # 创建一个元素的列表
  my_list7 = ["金", "木", "水", "火", "土"]    # 创建五个元素的列表
  # 推导式
  """
  my_list_iterator = []
  for i in range(10):
      my_list_iterator.append(i)  # 向列表中追加元素
  """
  my_list_iterator1 = [element for element in range(10)]       # 向列表中追加元素
  my_list_iterator2 = [10 for element in range(10)]            # 使用推导式创建带有10个10的元素列表
  my_list_iterator3 = [str(i) for i in range(10)]              # 使用推导式创建字符元素列表
  
  
  # 列表的常用操作
  # 1. in / not
  list1 = [num for num in range(101) if num % 2 == 0]
  list2 = [num for num in range(0, 101, 2)]
  print(55 in list1, 55 not in list2)
  # 2. 列表的加法和乘法
  print(list1 + list2)        # 列表的相加实际上就是返回连接的两个列表
  list3 = [var for var in range(5)]
  print(list3 * 10)           # 列表乘以整数时，返回n个列表的连接
  # 3.取出列表中的元素或某个区间的元素（列表的切片）
  list3 *= 10
  print(list3[45])            # 取某个下标的元素，要求下标处于正确的范围内
  list4 = [num for num in range(101) if num % 2 == 1]
  print("取[20-36]之间的列表片段：", list4[24:36])
  # 进阶：下标实际上可以为负数
  # 原理： list4[-1] = list4[len(list4) - 1]     # 列表总长度减去下标
  print(list4[-1])            # 实际上返回的是倒数第一个元素
  print(list4[25: -1])        # 取列表切片时，若范围是start>= end，则返回空列表
  print(list4[25: 99])        # 如果end大于列表的最大下标，那么默认是列表的最大下标
  # 4. 列表的求和、最大值和最小值
  list5 = [x for x in range(101)]
  print("1-100之和为：", sum(list5))
  import random
  random.shuffle(list5)
  print("乱序后的列表：", list5)
  print("最大值：", max(list5), "\t最小值：", min(list5))
  print("平均值：", sum(list5) / len(list5))
  
  # 列表的比较
  list6 = [x for x in range(10)]
  list7 = [x for x in range(0, 10)]
  # 比较逻辑： 首先比较前两个元素，如果不同则确定比较结果；如果相同，继续比较后面的两个元素，重复这个操作
  print("list6:", list6, "\n", "list7:", list7)
  print(list6 == list7)
  print(list6 > list7)
  print(list6 < list7)
  

列表的方法

• 列表被创建还可以使用list类的方法简化操作
  

书写Python程序模拟洗牌的过程（52张牌）

• 扑克牌程序说明
  

  # @function:书写Python程序模拟洗牌的过程（52张牌）
  # @Description:
  import random       # 引入随机方法
  
  # 生成52个元素，表示一副牌
  cards = [card for card in range(52)]
  types = ["黑桃", "红心", "方块", "梅花"]                 # 花色
  values = ["ACE"]                                        # 牌面
  values += [str(value) for value in range(2, 11)]        # 字符串只能和字符串拼接
  values += ["JACK", "QUEEN", "KING"]
  
  # print(cards[24])
  # print("元素24对应的花色", types[cards[24] // 13])         # 得到对应花色的下标
  # print("元素24对应的牌面", values[cards[24] % 13])         # 得到对应牌面的下标
  
  random.shuffle(cards)                                      # 洗牌
  for i in range(len(cards)):
      card_type = types[cards[i] // 13]
      card_value = values[cards[i] % 13]
      print("[{:2}]:{}-{:6}".format(cards[i], card_type, card_value), end="")
      if (i + 1) % 13 == 0:
          print()
  

线性查找法

demon

list_names = ["刘备", "关羽", "张飞", "孙权", "黄盖", "鲁肃", "曹操", "曹丕", "曹植"]
search_name = input("请输入要查找的英雄名称：")
index = -1
for i in range(len(list_names)):
    if search_name == list_names[i]:
        index = i
        break
if index == -1:
    print("没有找到英雄", search_name, "，请检查输入后重试！")
else:
    print("{}的下标为：{}".format(search_name, index))

二分查找法

更新操作

# @function:二分查找法
# @Description: 一只萤火虫

import random
lst = []
# 使用循环生成一个不重复的列表
for i in range(20):
    rand_num = random.randint(1, 101)
    while rand_num in lst:
        rand_num = random.randint(1, 101)
    lst.append(rand_num)
print("生成的随机列表：", lst)
lst.sort()
print("排序后的列表:", lst)
# 二分查找法
search_num = int(input("请输入要查找的数字："))
search_index = -1
low = 0                         # 最小边界的下标
high = len(lst) - 1             # 最大边界的下标
while high >= low:
    mid = (low + high) // 2
    if search_num == lst[mid]:
        search_index = mid
        break
    elif search_num < lst[mid]:
        high = mid - 1
    else:
        low = mid + 1
if search_index == -1:
    print("查找失败，列表中中没有这个元素！")
else:
    print("查找元素的下标是：", search_index)

冒泡排序

# @function:冒泡排序、
# @Description:一只萤火虫

# 冒泡排序
import random
lst = [random.randint(1, 100) for i in range(5)]
print("排序前：", lst)
for i in range(len(lst) - 1):
    flag = True
    for j in range(len(lst) - i - 1):
        if lst[j] > lst[j + 1]:
            lst[j], lst[j + 1] = lst[j + 1], lst[j]
            flag = False
    if flag:                    # 如果在内循环中，一次都没有交换，实际上列表已经有序了
        break
print("排序后：", lst)

选择排序

• 算法原理
  假设对列表升序排列：
  1.首先找到列表中的最小元素并将它和第一个元素交换
  2.找到剩余元素中值最小的元素并和剩余列表的第一个元素交换
  3.一次类推，直到只剩一个元素
  

  # @function: 选择排序
  # @Description:一只萤火虫
  
  # 选择排序
  import random
  lst = [random.randint(1, 100) for i in range(5)]
  print("排序前：", lst)
  for i in range(len(lst) - 1):
      min_index = i
      for j in range(i + 1, len(lst)):        # 内循环中求出剩下元素的最小值下标
          if lst[j] < lst[min_index]:
              min_index = j                   # 如果某个元素比最小值还小，那么最小值下标就更新为j
      lst[i], lst[min_index] = lst[min_index], lst[i]
  print("选择排序后：", lst)
  

插入排序

• 算法原理:
  将一个新元素重复插入到一个已排序的子列表中
  
  第一轮插入之后，再将18插入到[51， 18]构成的列表中
  

  # @function:插入排序
  # @Description:一只萤火虫
  import time
  import random
  
  lst = [random.randint(1, 100) for i in range(5000)]
  start = time.time()
  print("插入排序前：", lst)
  for i in range(1, len(lst)):
      curr_element = lst[i]               # 记录下待插元素
      j = i - 1                           # 需要从子列表的第一个元素开始循环
      while j >= 0 and lst[j] > curr_element:     # 找到子列表中比待插入元素还小的位置
          lst[j + 1] = lst[j]
          j -= 1                          # 内循环条件更新
      lst[j + 1] = curr_element       # 在插入位置之前保存的待查元素
  print("插入排序后：", lst)
  print("选择排序耗时：{}".format(time.time() - start))
  

二维列表

• 二维列表是将其他列表作为元素的列表

  score1 = [89, 87, 76]
  score2 = [76, 86, 78]
  score3 = [89, 90, 92]
  scores = [score1, score2, score3]

• 操作二维列表

  # @function:二维列表
  # @Description:一只萤火虫
  scores = []                         # 创建一个空列表
  names = ["刘备", "关羽", "张飞"]
  courses = ["语文", "数学", "英语"]
  for row in range(len(names)):
      scores.append([])               # 添加一个列表类型的元素
      for col in range(len(courses)):
          score = eval(input("请输入{}的{}成绩：".format(names[row], courses[col])))
          scores[row].append(score)
  print("{:16}{:8}{:8}{:8}".format(" ", "语文", "数学", "英语"))
  for row in range(len(scores)):
      for col in range(len(scores[0])):
          print("{}的{}成绩为：{:.2f}".format(names[row], courses[col], scores[row][col]), end="\t")
      print()
  

运行结果：python3.8解释器