文章目录
- 序列概念
- 序列
- 列表
- 列表的创建和下标访问
- 创建
- 下标
- 列表的切片操作
- 列表的遍历
- 列表的插入操作
- 列表的查找和删除
- 列表的拼接
- 元组
- 元组的相关操作
- 字典概念
- 字典的创建
- 查找字典中的key，value
- 字典的增删改
- 字典的遍历
序列概念
包含若干个元素, 元素有序排列, 可以通过下标访问到一个或者多个元素. 这样的对象, Python中统一称为序列
(Sequence).
Python中以下三种都属于序列：
- 字符串
- 元组
- 列表
序列
列表
列表可以理解为其他语言中的数组
列表的创建和下标访问
创建
字面值创建
# [] 表示一个 空的列表
a = []
print(type(a)) # <class 'list'>
# 创建列表时指定初始值
a = [1, 2, 3, 4]
print(a) # [1, 2, 3, 4]
# 可以在同一个列表中放不同类型的变量
a = [1, 'hello', True, [4, 5, 6]]
print(a)
list()创建
b = list()
print(type(b)) # <class 'list'>
下标
访问修改
# 使用下标来访问列表元素
a = [1, 2, 3, 4]
print(a[2]) # 3
# 使用下标来修改列表元素
a[2] = 100
print(a) # 100
下标越界 && 为负
- 超出下标有效范围, 出现异常报错
a = [1, 2, 3, 4]
a[4] = 0 #只能访问到a[3]
print(a)
- python中的下标可以写成负数：-1 等价于 len(a) - 1
- 即a[-1]就是倒数第一个元素
a = [1, 2, 3, 4]
print(a[len(a) - 1]) # 4
print(a[-1]) # 4
列表的切片操作
基本使用
1:3 为左闭右开，即[1,3]范围，打印出的结果为[2, 3]
a = [1, 2, 3, 4]
print(a[1:3])
省略边界
# 省略边界.
# a = [1, 2, 3, 4]
# # 省略后边界, 即从开始位置, 一直取到整个列表结束
print(a[1:]) # [2, 3, 4]
# 省略前边界, 即从列表的 0 号元素开始取, 一直取到结束的后边界
print(a[:2]) # [1, 2]
# 切片下标使用负数，即打印到倒数第一个之前
print(a[:-1]) # [1, 2, 3]
# 把开始边界和结束边界都省略掉 得到的还是列表自身
print(a[:]) # [1, 2, 3, 4]
带步长的切片操作
::2 即步长为2，每两个打印一个（隔一个打印）
1::-1::2 [-1, 1)的范围内步长为二输出
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::1]) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::2]) # [1, 3, 5, 7, 9]
print(a[1:-1:2]) # [2, 4, 6, 8]
- 步长为负数，即从后向前取
print(a[::-1]) # [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(a[::-2]) # [0, 8, 6, 4, 2]
- 切片范围越界，不报错
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[1:100]) # [2, 3, 4, 5, 6, 7, 8, 9, 0]
列表的遍历
for循环遍历
- for循环直接遍历，不能更改其元素值
a = [1, 2, 3, 4, 5]
for elem in a:
print(elem)
elem = elem + 10
print(a) #[1, 2, 3, 4, 5]
相当于将列表里的元素赋给elem，对elem操作并不会影响列表的内容
- for循环通过下标遍历
a = [1, 2, 3, 4, 5]
for i in range(0, len(a)):
# print(a[i])
a[i] = a[i] + 10
print(a) # [11, 12, 13, 14, 15]
while循环遍历
a = [1, 2, 3, 4, 5]
i = 0
while i < len(a):
print(a[i])
i += 1
print(a) # [1, 2, 3, 4, 5]
列表的插入操作
append()
- 即尾插操作，可以对列表插入任意类型的元素
a = [1, 2, 3, 4]
a.append(5)
a.append('hello')
print(a) # [1, 2, 3, 4, 5, 'hello']
insert()
- 在列表的任意位置插入元素
a = [1, 2, 3, 4]
a.insert(1, 'hello')
a.insert(100, 'python') #越界不会报错
print(a) # [1, 'hello', 2, 3, 4, 'python']
列表的查找和删除
查找
- 使用
in / not in判断一个元素是否在 / 不在 一个列表中
a = [1, 2, 3, 4, 5]
print(1 in a) # True
print(100 in a) # False
print(3 not in a) # False
print(300 not in a) # True
- 使用
index查找一个元素在列表中的位置，返回下标
a = [1, 2, 3, 4]
print(a.index(2)) # 1
print(a.index(3)) # 2
print(a.index(0)) # 报错，0不在列表中
删除
- 使用
pop进行尾删 / 删除指定位置
# 尾删
a = [1, 2, 3, 4]
a.pop()
print(a) # [1, 2, 3]
# 传下标删除指定元素
a = [1, 2, 3, 4]
a.pop(1)
print(a) # [1, 3, 4]
- 使用
remove通过元素内容进行删除
a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a) # ['aa', 'bb', 'dd']
列表的拼接
- 使用
+针对两个列表进行拼接
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = b + a
print(c) # [5, 6, 7, 8, 1, 2, 3, 4]
print(a) # [1, 2, 3, 4]
print(b) # [5, 6, 7, 8]
- 使用
extend进行拼接
需要注意的是extend不能只添加一个元素（），如a.extend(9),可以使用a.extend([9])
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = a.extend(b)
print(a) # [1, 2, 3, 4, 5, 6, 7, 8]
print(b) # [5, 6, 7, 8]
print(c) # None
None就是没有元素的意思，extend将b拼接给a，用c去接收不会得到什么
- 使用
+=拼接
+= 操作符可以用于向列表末尾添加单个元素，也可以用于向列表末尾追加另一个列表中的所有元素。
a = [1, 2, 3]
a += [4, 5, 6]
print(a) # 输出 [1, 2, 3, 4, 5, 6]
元组
元组和列表最本质的区别是：元组是不可变的数据类型，而列表是可变的。
元组的操作跟列表的基本操作相差不大，这里简单举例
元组的相关操作
- 创建元组
# 1. 创建元组
a = ()
print(type(a)) # 输出 <class 'tuple'>
b = tuple()
print(type(b)) # 输出 <class 'tuple'>
- 创建元组的时候, 设置初始值
# 2. 创建元组的时候, 设置初始值
a = (1, 2, 3, 4)
print(a)
- 元组中的元素也可以是任意类型的
# 3. 元组中的元素也可以是任意类型的.
a = (1, 2, 'hello', True, [])
print(a)
- 通过下标来访问元组中的元素, 下标也是从 0 开始, 到 len - 1 结束
# 4. 通过下标来访问元组中的元素, 下标也是从 0 开始, 到 len - 1 结束
a = (1, 2, 3, 4)
print(a[1])
print(a[-1])
# print(a[100]) # 超出元组范围访问会报错
- 通过切片来获取元组中的一个部分
# 5. 通过切片来获取元组中的一个部分
a = (1, 2, 3, 4)
print(a[1:3])
- 同样可以用 for 循环等方式来进行遍历元素 / 下标方式遍历 / while循环遍历
# 6. 同样可以用 for 循环等方式来进行遍历元素 / 下标方式遍历 / while循环遍历
a = (1, 2, 3, 4)
for elem in a:
print(elem)
- 可以使用 in 来判定元素是否存在, 使用 index 查找元素的下标.
# 7. 可以使用 in 来判定元素是否存在, 使用 index 查找元素的下标
a = (1, 2, 3, 4)
print(3 in a)
print(a.index(3))
- 可以使用 + 来拼接两个元组
# 8. 可以使用 + 来拼接两个元组
a = (1, 2, 3)
b = (4, 5, 6)
print(a + b) # 输出 (1, 2, 3, 4, 5, 6)
- 元组只是支持 “读” 操作, 不能支持 “修改” 类操作
# 9. 元组只是支持 "读" 操作, 不能支持 "修改" 类操作
# a = (1, 2, 3, 4)
# a[0] = 100 # 报错
# 报错 ↓
# a.append(5)
# a.pop(0)
# a.extend()
- 当进行多元赋值的时候, 其实本质上是按照元组的方式来进行工作的
# 10. 当进行多元赋值的时候, 其实本质上是按照元组的方式来进行工作的
def getPoint():
x = 10
y = 20
return x, y
x, y = getPoint()
print(type(getPoint())) # <class 'tuple'>
字典概念
Python的字典是一种映射类型数据. 里面的数据是 键值对 .
Python的字典是基于hash表实现的。
- 键(key): 字典的键是唯一的(一个字典对象中不能有两个相同的键). 同时字典的键必须是可hash的(能够计算出一个固定的hash值
- 值(value)：任意类型的值
字典的创建
# 1. 创建字典
a = {}
print(type(a)) # <class 'dict'>
b = dict()
print(type(b)) # <class 'dict'>
# 2. 创建字典的同时设置初始值.
a = {'id': 1, 'name': 'zhangsan'}
a = {
'id': 1,
'name': 'zhangsan',
}
print(a) # 输出 {'id': 1, 'name': 'zhangsan'}
查找字典中的key，value
- 形如
'id': 1称为一个键值对，左边的为key，右边为value - 使用
in / notin 判断一个元素是否是字典中的key（不能用来查找value）
# 使用 in 来判定某个 key 是否在字典中存在
a = {
'id': 1,
'name': 'zhangsan'
}
print('id' in a) # True
print('classId' in a) # False
# in 只是判定 key 是否存在, 和 value 无关
print('zhangsan' in a) # False
# not in 来判定 key 在字典中不存在
print('id' not in a) # False
print('classId' not in a) #True
- 通过
[key]的方式查找value
# 使用 [ ] 来根据 key 获取到 value
a = {
'id': 1,
'name': 'zhangsan',
100: 'litiansuo'
}
print(a['id']) # 输出 1
print(a['name']) # 输出 zhangsan
print(a[100]) # 输出litiansuo
# print(a['classId']) # 不存在，报错
字典的增删改
对于下面的一个字典：
a = {
'id': 1,
'name': 'zhangsan'
}
插入键值对
a['score'] = 90
print(a) # 输出 {'id': 1, 'name': 'zhangsan', 'score': 90}
根据key修改value
a['score'] = 100
print(a) # 输出 {'id': 1, 'name': 'zhangsan', 'score': 100}
根据key删除键值对
a.pop('name')
print(a) # 输出 {'id': 1, 'score': 100}
字典的遍历
对于下面的字典：
a = {
'name': 'zhangsan',
'id': 1,
'score': 90
}
- 用for循环遍历
for key in a:
print(key, a[key])
for key, value in a.items():
print(key, value)
这两种方式输出结果都是图示结果
- 利用相关函数打印
print(a.keys())
print(a.values())
print(a.items())
输出结果：
