前言
打算重新系统的温习一下基础，这一系列主要是温习一下python这门语言。不会涉及的太深的知识点，主要是一些基础性但是又容易忽视的东西，研一学的时候没怎么做笔记，也没好好总结一下，这里重新温习总结一下，方便后面用的时候就不用老是百度了。
这部分总结一下python常见的数据结构类型，主要是列表、字典、集合、元组这四类。
主要介绍下它们的区别和具体的操作。
下一节介绍String字符串。
一、列表：[]、list()
1.0、列表的特点和操作总览
列表的特点
序列类型：列表
- 是一个可变序列；
- 列表中的元素都是有序的；
- 列表中每一个元素都对应一个索引index，可以根据索引定位到对应的元素；
- 列表可以存储重复元素；
- 列表可以存储任意类型的元素；
- 列表没有固定长度，它可以根据元素个数实时动态分配内存空间；
操作总览
| 操作 | 描述 |
|---|---|
| []、list() | 创建列表 |
| x=ls.index(idx，start，end) | 根据index在start-end范围内查找列表 |
| ls.append(x) | 在列表ls末尾添加一个元素x |
| ls.insert(i，x) | 在列表ls的第i个位置添加元素x |
| ls.extend() | 在列表ls的末尾添加若干个元素，1个或多个 |
| ls.pop() | 删除指定索引位置上的元素，默认是删除最后一个-1，0表示删除第一个元素 |
| ls.remove(x) | 删除列表中出现的第一个x元素 |
| ls.clear() | 清空列表 |
| del ls | 彻底删除列表 |
| ls[idx] = new_value | 修改列表元素 |
| ls.sort() | 默认升序，原地((即列表本身被修改 返回None))且稳定的排序(保持两个相等元素的顺序不变)，reverse属性可以降序排序 |
| sorted(ls) | python内置函数，返回一个新列表，默认升序，reverse属性可以降序排序 |
1.1、列表创建
# 创建列表
# 1、[]创建列表
l1 = ['Hello', 'World', 'Python']
print(l1)
# 2、内置函数list创建列表
l2 = list(l1)
print(l2)
# 3、列表生成式
l3 = [i for i in range(1, 11)]
print(l3)
1.2、列表查找
因为列表中的每个元素都有一个索引index与之一一对应，所以根据元素找到对于的索引值。
如果列表有相同的元素，那么只返回相同元素的第一个元素的索引。
语法：列表.index('要获取索引的元素值'，起始位置，结束位置)
l1 = ['hello', 'world', 'python', 'hello', 'world', 'python']
print(l1.index('world')) # 1
print(l1.index('world', 2, 5)) # 4
1.3、列表添加
| 方法 | 描述 |
|---|---|
| ls.append(x) | 在列表ls末尾添加一个元素x |
| ls.insert(i，x) | 在列表ls的第i个位置添加元素x |
| ls.extend() | 在列表ls的末尾添加若干个元素，1个或多个 |
ls1 = [10, 20, 30]
ls2 = ['hello', 'world']
ls1.append(100)
print(ls1) # [10, 20, 30, 100]
ls1.extend(ls2)
print(ls1) # [10, 20, 30, 100]
ls1.insert(4, 'python')
print(ls1) # [10, 20, 30, 100, 'python', 'hello', 'world']
1.4、列表删除
| 方法 | 描述 |
|---|---|
| ls.pop() | 删除指定索引位置上的元素，默认是删除最后一个-1，0表示删除第一个元素 |
| ls.remove(x) | 删除列表中出现的第一个x元素 |
| ls.clear() | 清空列表 |
| del ls | 彻底删除列表 |
ls = [1, 2, 3, 2, 4, 5, 6, 7, 8, 9]
ls.remove(2)
print(ls) # [1, 3, 2, 4, 5, 6, 7, 8, 9]
ls.pop(7)
print(ls) # [1, 3, 2, 4, 5, 6, 7, 9]
ls.pop()
print(ls) # [1, 3, 2, 4, 5, 6, 7]
ls.pop(0)
print(ls) # [3, 2, 4, 5, 6, 7]
ls.clear()
print(ls) # []
del ls
# print(ls) # 报错
1.5、列表修改
列表是可变的，列表修改不需要什么方法，直接修改对应索引上的值即可。
ls = [1, 2, 3, 4]
ls[2] = 100
print(ls) # [1, 2, 100, 4]
1.6、列表排序
| 方法 | 描述 |
|---|---|
| ls.sort() | 默认升序，原地((即列表本身被修改 返回None))且稳定的排序(保持两个相等元素的顺序不变)，reverse属性可以降序排序 |
| sorted(ls) | python内置函数，返回一个新列表，默认升序，reverse属性可以降序排序 |
ls = [1, 3, 4, 2]
ls.sort()
print(ls) # [1, 2, 3, 4]
ls.sort(reverse=True)
print(ls) # [4, 3, 2, 1]
ls1 = [1, 3, 4, 2]
ls2 = sorted(ls1)
print(ls2) # [1, 2, 3, 4]
ls3 = sorted(ls1, reverse=True)
print(ls3) # [4, 3, 2, 1]
二、字典: {}、dict()
映射类型：字典
2.0、字典的特点和操作总览
字典的特点
- 也是一个可变的序列，以键值对的方式存储数据；
- 键值一一对应，键key不可以重复，值value可以重复；
- 字典中的元素都是无序的；
- 字典会浪费很大的内存，是一种用空间换时间的数据结构，但是查询速度很快；
操作总览
| 操作 | 描述 |
|---|---|
| {}、dict () | 创建字典 |
| zip() | 可创建字典，将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表 |
| d[key]、d.get(key，default) | 根据键key获取字典d的值val，返回对应的值，不存在就返回默认值 |
| d.keys() | 返回字典d所有键的信息 |
| d.values() | 返回字典d所有值的信息 |
| d.items() | 返回字典d所有键值对，这个函数可以配合用来遍历字典 |
| d[‘key’]=val | 添加/修改新的键值对 |
| del d[key] | 删除字典d的某个键值对 |
| val = d.pop(key, default) | 删除字典d的某个键值对，并返回这个键对应的值，如果不存在的话返回默认值 |
| key, val = d.popitem() | 删除并返回出 最后一个元素的键和值 |
| d.clear() | 清空整个字典 |
| len(d) | 字典d的元素个数 |
| max(d) | 字典d的键的最大值 |
| min(d) | 字典d的键的最小值 |
2.1、字典创建
# 1、使用花括号{}创建
scores = {'章三': 29, '李四': 10, '王五': 40}
print(scores) # {'章三': 29, '李四': 10, '王五': 40}
print(type(scores)) # <class 'dict'>
# 2、内置函数dict(键1=值1, 键2=值2)
people = dict(name='章三', age=20)
print(people) # {'name': '章三', 'age': 20}
# 3、zip() 将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
keys = ['fruits', 'books', 'others']
vals = [96, 78, 85]
d1 = {key: val for key, val in zip(keys, vals)}
print(d1) # {'fruits': 96, 'books': 78, 'others': 85}
d2 = dict(zip(keys, vals))
print(d2) # {'fruits': 96, 'books': 78, 'others': 85}
2.2、字典查找
# 1、使用[]直接查找
scores = {'章三': 29, '李四': 10, '王五': 40}
print(scores['李四']) # 10
# 2、使用get()方法查找 字典1.get(键1，值1) 在字典1中查找键1的值，如果不存在就返回值1
print(scores.get('李四')) # 10
print(scores.get('章三')) # 29
print(scores.get('麻子')) # None
print(scores.get('麻子', 100)) # 100
# 3、获取所有的键和值
print(scores.keys()) # dict_keys(['章三', '李四', '王五'])
print(list(scores.keys())) # ['章三', '李四', '王五']
print(scores.values()) # dict_values([29, 10, 40])
print(list(scores.values())) # [29, 10, 40]
print(scores.items()) # dict_items([('章三', 29), ('李四', 10), ('王五', 40)])
2.3、字典添加
scores = {'章三': 29, '李四': 10, '王五': 40}
scores['陈六'] = 20
print(scores) # {'章三': 29, '李四': 10, '王五': 40, '陈六': 20}
2.4、字典删除
# 1、删除某个键值对
scores = {'章三': 29, '李四': 10, '王五': 40, '老六': 99}
del scores['李四']
print(scores) # {'章三': 29, '王五': 40, '老六': 99}
# 2、d.pop(key,default=val) pop掉键key和对应的值 并返回对应的值 如果不存在返回默认值
val = scores.pop('章三', 100)
print(val) # 29
print(scores) # {'王五': 40, '老六': 99}
# d.popitem() pop出最后一个元素的键和值
key, val = scores.popitem()
print(key, val) # 老六 99
print(scores) # {'王五': 40}
# 3、清除整个字典
scores.clear()
print(scores) # {}
2.5、字典修改
scores = {'章三': 29, '李四': 10, '王五': 40}
scores['李四'] = 20
print(scores) # {'章三': 29, '李四': 20, '王五': 40}
2.6、字典遍历
for item in scores:
print(item, scores[item])
for key, value in scores.items():
print(key, value)
三、元组：()、tuple()
3.0、元组的特点和操作总览
元组的特点
- 元组是一个不可变序列，元组有增加操作，但是没有删、改的操作；
- 相较于列表，元组的读取速度更快，占用内存空间更小，并且可以作为字典的key去使用；
- （4）和（4，）是不一样的，前者是int类型，后者才是元组类型；
元组操作总览
| 操作 | 描述 |
|---|---|
| ()、tuple() | 创建元组 |
| t[idx] | 查找元组 |
3.1、元组创建
# 1、()创建 注意只包含一个元素的时候需要在最后加一个逗号
t1 = ('python', 'java')
print(t1) # ('python', 'java')
print(type(t1)) # <class 'tuple'>
t2 = ('python')
print(t2) # python
print(type(t2)) # <class 'str'>
t3 = ('python', )
print(t3) # ('python',)
print(type(t3)) # <class 'tuple'>
# 2、内置函数tuple()创建
t4 = tuple(('python', 'java'))
print(t4) # ('python', 'java')
print(type(t4)) # <class 'tuple'>
3.2、元组的查找和遍历
t = ('hello', 'world', 'python')
print(t[1]) # world
for item in t:
print(item, end=' ') # hello world python
3.3、元组添加
t1 = (1, 2, 3, 4)
t1 += (5, )
print(t1) # (1, 2, 3, 4, 5)
四、集合：{}、set()
4.0、集合的特点和操作总览
集合的特点
- 集合中的元素都是无序的，且元素都是不可重复的，所以{1，2，3} 和{3，2，1}是同一个集合；
- 集合是没用value的字典；
- 和列表、字典一样都是可变序列，但是集合是没法修改的，因为集合是无序的，无法根据index对集合进行修改，只能删除掉再重新添加；
操作总览
| 操作 | 描述 |
|---|---|
| {}、set() | 创建集合 |
| s.add(x) | 集合s添加一个元素x |
| s2.uptate(s1) | 集合s2添加多个元素s1 |
| s.remove(x) | 集合s删除元素x，不存在就报错 |
| s.discard(x) | 集合s删除元素x，不存在也不会报错 |
| s.pop() | 集合s删除任意一个元素，因为集合是无序的 |
| s.clear() | 清空集合s |
| len(s) | 集合s中的元素个数 |
4.1、集合创建
# 1、{}创建集合
s1 = {1, 2, 3, 4, 5, 6}
print(s1) # {1, 2, 3, 4, 5, 6}
# 2、内置函数set()创建集合
s2 = set([1, 2, 3, 4, 5, 6])
print(s2) # {1, 2, 3, 4, 5, 6}
s3 = set('python')
print(s3) # {'h', 'n', 'o', 'y', 'p', 't'}
4.2、集合添加
# 1、s.add(x) 添加一个元素x
s1 = {1, 2, 3, 4, 5, 6}
print(s1) # {1, 2, 3, 4, 5, 6}
s1.add(7)
print(s1) # {1, 2, 3, 4, 5, 6, 7}
# 2、s2.update(s1) 添加多个元素
s1.update((7, 8, 9))
print(s1) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
4.3、集合删除
# 1、s.remove(x) 一次删除一个元素x 不存在即报错
s1 = {1, 2, 3, 4, 5, 6}
s1.remove(3)
print(s1) # {1, 2, 4, 5, 6}
# s1.remove(7) 报错
# 2、s.discard(x) 一次删除一个元素x 不存在不会报错 不怎么用
s1.discard(4)
print(s1) # {1, 2, 5, 6}
s1.discard(7) # 不报错
print(s1) # {1, 2, 5, 6}
# 3、s.pop() 一次删除任一个元素
s1.pop()
print(s1)
# 4、s.clear() 清空集合
s1.clear()
print(s1) # set()
五、总结区别
| 项目 | 列表 | 集合 | 字典 | 元组(只读) |
|---|---|---|---|---|
| 创建 | []、list() | {}、set() | {}、dict() | ()、tuple |
| 存储方式 | 值 | 键（不能重复） | 键值对（键不可以重复） | 值 |
| 是否有序 | 有序 | 无序 | 无序 | 有序 |
| 查找元素 | value = ls[index] | 无 | value = d[key] | value = t[index] |
| 添加元素 | append、insert、extend | add、update | d[key] = value | t1 += t2 |
| 删除元素 | pop、remove | remove、discard | del d[key]、d.pop(key,default=val) 、d.popitem() | 无 |
| 修改元素 | ls[index]=new_value | 无 | d[key]=new_value | 无 |
Reference
CSDN: 【重温Python基础】最全Python基础知识点，加班熬夜花了三天终于总结出来了，非常详细
书籍：Python进阶编程