python常用的数据结构

一、列表

1、列表的定义:

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

2、列表的使用

  • 1)通过构造方法创建列表,list()
# 通过构造函数创建,构造方法
a = list() # 空列表
print(type(a), a)
a1 = list("today")
print(type(a1), a1)
  • 2)通过中括号填充元素
# 通过中括号填充元素
b = [1, 2, 3, "hello", "world"]
print(type(b),b)
  • 3)列表推导式
# 列表推导式,循环中打印出来的i放在循环前面,作为列表元素
c = [i for i in range(1, 10) if i% 2 == 0]
print(type(c), c)

3、列表的索引

  • start>0:从左向右
  • start<0:从右向左
# 列表的索引
a = [1, 2, 3, 4, 5, "hello", "world", "a", "b", "c"]
# 正向索引
print(a[2])
# 反向索引
print(a[-2])

4、列表的切片

①切片的步长:step不能为0,默认为1,step
②step>0:从左向右切,start必须小于stop才有结果,否则为空
③step<0:从右向左切,start必须大于stop才有结果,否则为空
# 列表的切片[star:stop:step]
# 切片的步长:step不能为0,默认为1
# step>0:从左向右切,start必须小于stop才有结果,否则为空
# step<0:从右向左切,start必须大于stop才有结果,否则为空
print(a[2:6:2])
print(a[1:7:3])
print(a[2::2])
# 步长为负数
print(a[8:2:-2])

5、列表的运算符

# 加法
a1 = [1, 2, 3]
a2 = ["hello"]
# print(a1+a2)
a3 = a1+a2
print(a3)
# 乘法
b1 = ['hello']
print(b1*3)
# b2 = b1 * 3
# print(b2)

6、列表成员的检测

①in:检测成员是否在列表中,是返回True,否返回False
②not in:检测列表是否不包含某一个元素,不包含返回True,包含返回False
# 列表的成员检测
# in 检测成员是否在列表中,是返回True,否返回False
# not in 检测列表是否不包含某一个元素,不包含返回True,包含返回False
a = [1, 2, 3, 'hello', 'world']
print(1 in a)
print(4 in a)
print("ok" not in a)

7、列表方法:

(1)append(item)方法
  • 将一个对象 item 添加到列表的末尾。
# append()方法,添加元素
a = []
a.append(1)
a.append('哈哈')
print(len(a), a) # len()查询当前列表元素个数
(2)extend()方法
  • 将一个可迭代对象的所有元素,添加到列表末尾;入参为可迭代对象
# extend()方法,批量添加元素
a.extend("hello")
print(len(a), a)
b = ['a', 'b', 'c']
a.extend(b)
print(a)
(3)insert(index, item)方法
  • 将一个对象插入到指定的索引位置。index为索引值,item为对象
# insert()方法
a = [1, 2, 3, 4, 5]
a.insert(0, "hello")
a.insert(3, "world")
print(a)
(4)pop()方法
弹出并返回所指定索引的元素。入参索引值 index,可不传,传返回指定索引的元素,不传未指定索引则返回末尾元素;索引值不正确,或者列表已经为空,则引发 IndexError 错误
# pop()方法
a = [1, 2, 3, 4, 5, 6, 7]
a.pop() # 不输入默认从最后一个移出
list_a = a.pop(3) # 移出的元素赋值给list_a
print(list_a, a)
# 索引值不存在
b = [1, 2, 3, 4, 5, 6, 7]
b.pop(7)
print(b)
(5)remove(item)方法
  • 移除列表中第一个等于 item 的元素
# remove(item)方法,目标元素在列表中要存在,否则会报错
a = ['a', 'b', 'c']
a.remove('c')
print(a)
(6)sort()方法
  • 对列表进行原地排序,只使用 < 来进行各项间比较;sort(key=None, reverse=False)支持2个关键字参数;

    • key:指定带有一个参数的函数,用于从每个列表元素中提取比较键。
    • reverse:默认值为 False 表示升序,为 True 表示降序,返回None
#sort(key=None, reverse=False)方法
a = [1, 6, 2, 8, 9]
a.sort() # 不输入默认为升序
print(a)
a.sort(reverse=True) # 默认值为 False 表示升序,为 True 表示降序
print(a)
b = ['C', 'python', 'java', 'go']
#b.sort(key=len) # 根据长度进行排序,此处reverse默认为False升序
b.sort(key=len, reverse=True)
print(b)
(7)reverse()方法:
  • 将列表中的元素顺序反转,反转只是针对索引值,元素之间不相互比较。
#reverse()方法
a = ['a', 'b', 'c']
a.reverse()
print(a)

8、列表嵌套

  • 嵌套列表是指在列表里存放列表
  • 列表的常用方法都适用于嵌套列表
a = [[1, 2, 3], ['a', 'b', 'c']]
print(a[1][2]) # a[第一个列表对象][列表对象里的第2个元素]
#第一个列表对象添加一个元素
a[0].append('go')
print(a)

9、列表推导式

  • 列表推导式是指循环创建列表,相当于 for 循环创建列表的简化版
  • 语法:[x for x in li if x …]
#列表推导式
list_a = [i for i in range(1, 11) if i % 2 == 0] # 提取元素i,放在for循环前面
#if判断条件可不加
list_a1 = [i for i in range(1, 11)]
list_b = [j ** 2 for j in range(1, 11) if j % 2 == 0]
print(list_a)
print(list_a1)
print(list_b)

二、元组

1、元组的定义:

①元组是有序的不可变对象集合
②元组使用小括号包围,各个对象之间使用逗号分隔
③元组是异构的,可以包含多种数据类型

2、元组的创建

  • 使用逗号分隔创建元组
t1 = 1, 2, 3
print(type(t1), t1)
  • 通过小括号填充元素
t2 = (1, 2, 3, 'a')
print(type(t2), t2)
  • 通过构造方法tuple(iterable)
t3 = tuple([1, 2, 3, 'hello']) # 可以赋值为一个列表对象
t4 = tuple() # 空元组
t5 = tuple('ok')
print(type(t3), t3)
print(type(t4), t4)
print(type(t5), t5)
#注意单元素元组,逗号不可或缺
t6 = 1,
t7 = (1,)
print(t6)
print(t7)

3、元组索引

①可以通过索引值来访问对应的元素。
②正向索引,默认编号从 0 开始
③反向索引,默认编号从-1 开始
#元组索引
tup1 = ('hello')
#正向索引
print(tup1[1])
#反向索引
print(tup1[-2])

4、元组切片

①切片[start: stop: step],三个值都是可选的,非必填
②start 值: 指示开始索引值,如果没有指定,则默认开始值为 0;
③stop 值:指示到哪个索引值结束,但不包括这个结束索引值。如果没有指定,则取元组允许的最大索引值;
④step 值:步长值指示每一步大小,如果没有指定,则默认步长值为 1。
#元组切片 [star:stop:step]
tup = tuple('abcdefghijk')
print(tup)
print(tup[-3])
print(tup[2:10])
print(tup[2:9:2])
print(tup[9:2:-2])

5、元组方法

  • index(item) 方法

      ①返回与目标元素相匹配的首个元素的索引。
      ②目标必须在元组中存在的,否则会报错
    
#index(),目标元素必须存在元组中
tup = tuple('hello')
print(tup.index('l'))
print(tup.index('o'))
  • count(item)方法

      ①返回某个元素出现的次数。
    
#count()方法
tup1 = tuple('environment')
print(tup1.count('n'))

6、元组解包

  • 元组解包:把一个可迭代对象里的元素,一并赋值到由对应的变量组成的元组中。
#元组解包
tup1 = 1, 2, 3
#1、传统逐个赋值方式
a = tup1[0]
b = tup1[1]
c = tup1[2]
print(a, b, c)
#2、解包平行赋值,注意两边的元素个数相同
#写法1
a, b, c = tup1
#写法2
a, b, c = [1, 2, 3]
print(a, b, c)
    

三、集合

1、集合的定义:

①无序的唯一对象集合
②用大括号{}包围,对象相互之间使用逗号分隔
③集合是动态的,可以随时添加或删除元素
④集合是异构的,可以包含不同类型的数据

2、集合的创建

  • 通过使用大括号{}填充元素
s1 = {1, 2, 3, 'a', 'b', 'c'}
print(type(s1), s1)
  • 使用构造方法创建集合
s2 = set('hello')
print(type(s2),s2)
s3 = set()   # 空集合
print(type(s3),s3)
  • 使用集合推导式
s4 = {i for i in range(1, 10) if i % 2 == 0}
s5 = {i for i in range(1, 10)}
print(type(s4), s4)
print(type(s5), s5)
#注意不要单独使用 { }来创建空集合,这是字典类型
s = {}
print(type(s), s)

3、集合成员检测

①in:判断元素是否在集合中存在
②not in:判断元素是否在集合中不存在
s = {1, 2, 3, 'a', 'b', 'c'}
print('a' in s)
print(3 not in s)

4、集合的方法

  • ①add(item):
    • 将单个对象添加到集合中
#add() 添加单个对象到集合中
s = {1, 2, 3}
s.add('a')
s.add('hello')
print(s)
  • ②update(iterable):
    • 批量添加来自可迭代对象中的所有元素,入参为可迭代对象iterable
#update()方法,批量添加来自可迭代对象中的所有元素
l1 = [1, 2, 3]
t1 = ('a', 'b', 'c')
s1 = {'hello', 'world'}
s2 = {'happy'}
#批量添加列表中的元素
s1.update(l1)
print(type(s1), s1)
#批量添加元组中的元素
s1.update(t1)
print(type(s1), s1)
#批量添加集合中的元素
s1.update(s2)
print(type(s1), s1)
  • ③remove(item):
    • 从集合中移除指定元素 item,如果item不存在于集合 中 则会引发 KeyError
#remove()方法,从集合中移出指定元素,指定元素必须在集合里
s3 = {1, 2, 3, 4, 'a', 'b', 'c'}
s3.remove(4)
print(s3)
#删除不存在的元素
s3.remove('d')
print(s3)
  • ④discard(item):
    • 从集合中移除指定对象 item,元素 item 不存在没影响, 不会抛出 KeyError 错误。
#discard(),从集合中移出指定元素,指定元素可以不在集合里
s4 = {1, 2, 3, 4, 'a', 'b', 'c'}
s4.discard(4)
print(s4)
#删除不存在的元素
s4.discard('d')
print(s4)
  • ⑤pop():
    • 随机从集合中移除并返回一个元素
    • 无入参,返回被移除的元组;如果集合为空则会引发KeyError。
#pop(),随机从集合中移出并返回一个元素,集合不能为空
s5 = {1, 2, 3, 4, 'a', 'b', 'c'}
s5.pop()
print(s5)
  • ⑥clear()
    1)清空集合,移除所有元素,无入参
#clear(),清空集合,移出所有元素,无入参,集合可为空
s6 = {1, 2, 3, 4, 'a', 'b', 'c'}
s6.clear()
print(s6)

5、集合运算

  • 交集运算
#交集运算intersection(),操作符:&
s7 = {1, 2, 3, 5}
s8 = {1, 2, 6, 8}
print(s7.intersection(s8))
print(s7 & s8)
  • 并集运算
#并集运算union(),操作符:|
print(s7.union(s8))
print(s7 | s8)
  • 差集运算
#差集运算difference,操作符:-
print(s7.difference(s8))
print(s7 - s8)
print(s8.difference(s7))
print(s8 - s7)

6、集合推导式

①类似列表推导式,同样集合支持集合推导式
②语法:{x for x in ... if ...}
s9 = {i for i in range(1, 10)}
#有判断条件
s10 = {i for i in range(1, 10) if i % 2 != 0}
print(s9)
print(s10)

四、字典

1、字典定义

  • 字典是无序的键值对集合
  • 字典用大括号{}包围
  • 每个键/值对之间用一个逗号分隔
  • 各个键与值之间用一个冒号分隔
  • 字典是动态的

2、字典使用

(1)创建字典
  • 使用大括号填充键值对
  • 通过构造方法 dict()
  • 使用字典推导式
# 使用大括号填充键值对
d1 = {'name': 'a', 'age': 1}
print(type(d1), d1)
# 通过构造方法dict()
d2 = dict(name='b', age=2)   # 关键字参数赋值
print(type(d2), d2)
d3 = dict([('name', 'ab'), ('age', 3)])   # 传入由元组组成的列表
print(type(d3), d3)
d4 = dict()    # 空字典
print(type(d4), d4)
# 使用字典推导式
d5 = {i: j for i, j in [('name', 'ab'), ('age', 3)]}   # 字典由键和值,所以需要取两个,从列表中取值作为键和值
print(type(d5), d5)
(2)访问元素
  • 与字典也支持中括号记法[key]。
  • 字典使用键来访问其关联的值。
  • 访问时对应的 key 必须要存在
(3)操作元素
  • 语法:dict[key] = value
  • 添加元素
    • 键不存在
  • 修改元素
    • 键已经存在
(4)嵌套字典
  • 字典的值可以是字典对象
# 字典,访问元素,访问的key要存在
d6 = {'name': 'angle', 'age': 19}
print(d6['name'])
# 添加元素,键(key)不存在,字典['key']= value
d6['phone'] = 123
print(d6)
# 修改元素,键(key)已存在
d6['age'] = 2
print(d6)
# 嵌套字典,字典的值可以是字典的对象
d7 = {'name': 'angle', 'age': 19, 'course': {'music': 100, 'math': 90}}
# 获取music的分数
print(d7['course']['music'])
# 修改math的分数为99
d7['course']['math'] = 99
print(d7)
(5)字典的方法
  • keys():返回由字典键组成的一个新视图对象,无入参
  • values():返回由字典值组成的一个新视图对象,无入参
  • items():返回由字典项((键,值)对)组成的一个新视图对象,无入参
  • get(key):获取指定key关联的值,入参为key,即字典的键,必传,区别于直接使用获取值,key存在,返回值,反之返回None,不存在的key也不会报错
  • update(dict):使来自dict的键/值对更新字典,添加键值对、覆盖原有的键和值,入参必传
  • pop(key):删除指定key的键值对,并返回对value值,入参key必传,且key要存在于字典中,否则会报错
# 字典的方法
"""keys()"""
d8 = {'name': 'angle', 'age': 19}
print(d8.keys())
# print(list(d8.keys()))  # 转换成列表,更直观

"""values()"""
print(d8.values())
# print(list(d8.values()))    # 转换成列表

"""items()"""
print(d8.items())   # 每个键值对组成一个元组
# print(list(d8.items()))     # 转换成元组组成的列表

"""get()"""
d9 = {'name': 'angle', 'age': 19}
# 访问存在的key
print(d9.get('name'))
# 访问不存在的key
print(d9.get('course'))

"""update()"""
d10 = {'name': 'angle', 'age': 19}
data = {'age': 16, 'hobby': 'music'}
d10.update(data)
print(d10)

"""pop()"""
d11 = {'name': 'angle', 'age': 19, 'course': 'math'}
val = d11.pop('course')  # 删除的值
print(val)
print(d11)
(6)字典推导式
  • 可以从任何以键值对作为元素的可迭代对象中构建出字典。

  • 练习:

"""字典的推导式{i: j for i, j in...由元组组成的列表}"""
# 例1
d12 = {i: j for i, j in [('name', 'angle'), ('age', 18)]}
print(d12)

# 例2,将key的value值>1的进行平方运算,且返回新的字典对象
d13 = {'a': 1, 'b': 2, 'c': 3}
# 传统方式
data1 = dict()   # 定义空字典
for i, j in d13.items():
    if j > 1:
        data1[i] = j ** 2
print(data1)

# 推导式
data2 = {i: j ** 2 for i, j in d13.items() if j > 1}
print(data2)

# 更新原有的字典对象
# 传统方式
data3 = {'a': 1, 'b': 2, 'c': 3}
for i, j in data1.items():
    if j > 1:
        data1[i] = j ** 2
print(data3)

# 推导式
data3 = {i: j ** 2 for i, j in data3.items() if j > 1}
print(data3)

"""
给定一个字典对象,请使用字典推导式,将它的key和value分别进行交换。也就是key变成值,值变成key。
输入: {'a': 1, 'b': 2, 'c': 3}
输出: {1: 'a', 2: 'b', 3: 'c'}
"""
data = {'a': 1, 'b': 2, 'c': 3}
new_data = {j: i for i, j in data.items()}
print(data)
print(new_data)