python 常用数据结构-列表

python 常用数据结构-列表

常用数据结构

• list 列表
• tuple 元组
• set 集合
• dict 字典

list 列表

• 列表定义与使用
• 列表常用方法
• 列表嵌套
• 列表推导式

列表定义

• 列表是有序的可变元素的集合，使用中括号[]包围，元素之间用逗号分隔
• 列表是动态的 ，可以随时扩展和收缩
• 列表是异构的 ，可以同时存放不同类型的对象
• 列表中允许出现重复元素

列表使用：创建

-创建列表
-通过构造函数创建list()
-中括号创建并填充[]
-列表推导式

#1、通过构造函数创建 list()
li1 = list() # 空列表
li1 = list(‘hogwarts’) # 字符串
li1 = list((1, 2, 3)) # 元组
li1 = list({4, 5, 6}) # 集合
li1 = list({‘a’: 7, ‘b’: 8}) # 字典
print(type(li1), li1)

#2、中括号创建并填充元素[]
li2 = [] # 空列表
li2 = [1, 2, 3] # 直接填充对象
li3 = [‘hogwarts’,‘hello’]
li4 = [1,3.14,‘hogwarts’,[5,6,7]]
print(type(li2), li2)
print(li4)

#3、列表推导式
li5 = [i for i in range(1,10) if i%2 == 0]
print(type(li5), li5)
输出结果为：
<class ‘list’> [‘a’, ‘b’]
<class ‘list’> [1, 2, 3]
[1, 3.14, ‘hogwarts’, [5, 6, 7]]
<class ‘list’> [2, 4, 6, 8]

列表使用：索引

• 索引
• 默认正向索引，编号从 0 开始。
• 支持反向索引，编号从-1 开始。
  li6 = [1,2,3,4,5]
  #1、正向索引
  print(li6[2])
  #2、反向索引
  print(li6[-3])
  输出结果为：
  3
  3

列表使用：切片

• 切片 [start: stop: step]
• start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
• stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
• step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。
• 三个值都是可选的，非必填

列表使用：切片实例

#切片基本用法
li = [‘h’, ‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
print(li[0:5:2]) # 打印[‘h’, ‘g’, ‘a’]
print(li[2:4]) # 省略了step，打印[‘g’, ‘w’]
print(li[:4]) # 省略了start和step，打印[‘h’, ‘o’, ‘g’, ‘w’]
print(li[2:]) # 省略了stop和step，打印[‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
print(li[::2]) # 省略start和stop，打印[‘h’, ‘g’, ‘a’, ‘t’]
print(li[::-1]) # 特殊的切片写法：逆序打印[‘s’, ‘t’, ‘r’, ‘a’, ‘w’, ‘g’, ‘o’, ‘h’]

列表使用：运算符

重复：使用 * 运算符可以重复生成列表元素。
合并：使用 + 加号运算符，可以将两个列表合二为一。
#1、* 号
li7 =[1]
print(li7 * 5)
#2、+ 号
li8 = [1,2,3]
li9 = [4,5,6]
print(li8 + li9)
输出结果为：
[1, 1, 1, 1, 1]
[1, 2, 3, 4, 5, 6]

列表使用：成员检测

• in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。
• not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。
  li = [1, 2, 3]
  #in
  print(1 in li) # 返回True
  print(100 in li) # 返回False

#not in
print(1 not in li) # 返回False
print(100 not in li) # 返回True

列表方法

• append()
• extend()
• insert()
• pop()
• remove()
• sort()
• reverse()

列表方法 append()

append 附加

• append(item)：将一个对象 item 添加到列表的末尾。
• 入参：对象 item
• 返回：None
  #添加元素
  li = []
  li.append(1)
  li.append(3.14)
  li.append(“hogwarts”)
  li.append([6, 6, 6])
  li.append((1.2, 1.5))
  li.append({‘msg’: “Hello”})

print(li) # 打印列表
print(len(li)) # 获取列表元素个数
输出结果为：
[1, 3.14, ‘hogwarts’, [6, 6, 6], (1.2, 1.5), {‘msg’: ‘Hello’}]
6

列表方法 extend()

extend 扩展

• extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。
• 入参：可迭代对象 iterable
• 返回：None
  #extend()的用法
  li = []
  li.extend(‘hogwarts’) # 添加的是字符串的所有字母
  li.extend([1, 2, 3]) # 接收列表的所有元素
  li.extend((4, 5, 6)) # 接收元组的所有元素
  li.extend({‘a’: 1, ‘b’: 2}) # 接收字典的所有key值
  print(len(li),li)
  输出结果为：
  16 [‘h’, ‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’, 1, 2, 3, 4, 5, 6, ‘a’, ‘b’]

列表方法 insert()

• insert(index, item)：将一个对象插入到指定的索引位置
• 入参：索引值 index ，一个对象 item
• 返回：None
• 原索引位置及后面的元素后移一位
  li = [0, 1, 2]
  print("插入前: ", li) # 打印 [0, 1, 2]

#在索引0的位置插入元素
li.insert(0, ‘hogwarts’)
print("插入后: ", li) # 打印 [‘hogwarts’, 0, 1, 2]
li.insert(2,“hello”)
print(“插入中间：”,li)
输出结果为：
插入前: [0, 1, 2]
插入后: [‘hogwarts’, 0, 1, 2]
插入中间： [‘hogwarts’, 0, ‘hello’, 1, 2]

列表方法 pop()

• pop(index) 或 pop() 弹出并返回所指定索引的元素。
• 入参：索引值 index，可不传
• 返回：指定索引的元素
• 返回：未指定索引则返回末尾元素
• 如果索引值不正确，或者列表已经为空，则引发 IndexError 错误
  letters = [‘h’, ‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
  kong = []
  #传入索引3，弹出元素 w
  n1 = letters.pop(3)
  print(n1) # 打印 w

#不传参数，默认弹出末尾元素
n2 = letters.pop()
print(n2) # 打印 s
print(letters.pop(0))
print(letters.pop(99))
print(kong.pop(0))
输出结果为：
w
s
h
IndexError: pop index out of range
IndexError: pop from empty list

列表方法 remove()

• remove(item)
• 移除列表中第一个等于 item 的元素
• 入参：指定元素 item
• 返回：None
• 目标元素必须已存在，否则会报 ValueError
  li = [‘h’, ‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
  print(len(li)) # 打印 8

#1、删除指定元素’h’
li.remove(‘h’)
print(li) # 打印 [‘o’, ‘g’, ‘w’, ‘a’, ‘r’, ‘t’, ‘s’]
print(len(li)) # 打印 7

#2、移除第一个2
li = [1, 2, 3, 2, 1]
li.remove(2)
print(li) # 打印 [1, 3, 2, 1]

#3、删除不存在的元素，会报ValueError错误
li = [1, 2, 3]
li.remove(100) # ValueError: list.remove(x): x not in list

列表方法 sort()

• sort(key=None, reverse=False)
  -对列表进行原地排序，只使用 < 来进行各项间比较。
• 入参：支持 2 个关键字参数：
• key
• reverse
• 返回：None
  nums.sort() = nums.sort(reverse=False) 从小到大排序
  nums.sort(reverse=True) 从大到小排序
  words.sort(key=len) 按元素长度从小到大排序

nums = [2, 4, 3, 1, 5]
#1、不传参数，默认升序，数字从小到大排列
nums.sort()
print(nums) # 打印 [1, 2, 3, 4, 5]

#2、指定key=len，按元素的长度排序
words = [‘Python’, ‘Java’, ‘R’, ‘Go’]
words.sort(key=len)
print(words) # 打印 [‘R’, ‘Go’, ‘Java’, ‘Python’]

#3、指定reverse=True，降序
nums = [2, 4, 3, 1, 5]
nums.sort(reverse=True)
print(nums) # 打印 [5, 4, 3, 2, 1]
nums.sort(reverse=False)
print(nums) # 打印 [1, 2, 3, 4, 5]

列表方法 reverse()

• reverse()
• 参数：无
• 返回：None
• 反转只是针对索引值，元素之间不相互比较。
  #反转顺序
  nums = [8, 1, 5, 2, 77]
  nums.reverse()
  print(nums) # 打印[77, 2, 5, 1, 8]

列表嵌套

• 嵌套列表是指在列表里存放列表
• 列表的常用方法都适用于嵌套列表
  li_2d = [[‘a’, ‘b’, ‘c’], [1, 2, 3]]
  print(type(li_2d)) # 打印<class ‘list’>
  print(len(li_2d)) # 打印 2

#2、访问嵌套列表中的元素
print(li_2d[0][2]) # 打印 ‘c’
li_2d[0].append(“hello”) # 在第1个列表元素后添加
print(li_2d) # 打印 [[‘a’, ‘b’, ‘c’, ‘hello’], [1, 2, 3]]

li_2d[1].insert(1,“hello”) # 在第2个列表第2个元素前插入
print(li_2d) # 打印 [[‘a’, ‘b’, ‘c’, ‘hello’], [1, ‘hello’, 2, 3]]

列表推导式

• 列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
• 语法：
  [x for x in li if x …]
  #实例：将 1-10 中的所有偶数平方后组成新的列表

#1、传统解决方案
result = []
for ele in range(1, 11):
if ele % 2 == 0:
result.append(ele ** 2) # 平方
print(result) # 打印 [4, 16, 36, 64, 100]

#2、使用列表推导式
result = [ele ** 2 for ele in range(1, 11) if ele % 2 == 0]
print(result) # 打印 [4, 16, 36, 64, 100]