目录
1. 序列基本知识
- 序列概念
- 序列分类
- 可变对象
2. 列表
- 列表修改
- 列表函数
- 列表遍历
3. 元组与字典
- 元组
- 字典
4. 集合
- 集合方法
- 集合运算
课堂笔记
1. 序列基本知识
1.1 序列概念
- 序列，是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
- 数据结构指计算机中数据存储的方式
1.2 序列分类
- 可变序列（序列中的元素可以改变）：例如 列表（list），字典(dict)
- 不可变序列（序列中的元素不能改变）：例如 字符串（str），元组（tuple）
1.3 可变对象
- Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。 ⽽列表list、字典dict、集合set是可变类型
- 可变对象中都保存了三个数据
- id(标识)
- type(类型)
- value(值)
2. 列表
- 列表（list） ，python中的一个对象，可用于存储一组有序的对象
# 定义一个列表
# lst = ['P', 'Y', 'T', 'H', 'O', 'N']
# print('修改前：', lst) # 输出['P', 'Y', 'T', 'H', 'O', 'N']
# 通过索引修改元素
# lst[0] = 'A' # 输出['A', 'Y', 'T', 'H', 'O', 'N']
# del 删除元素
# del lst[0] # 输出['Y', 'T', 'H', 'O', 'N']
# 通过切片修改元素 [起始:结束:步长]，步长默认为1，可为负数，但不能为0
# lst[0:6:2] # 输出['P','T','O', 'N']
# lst[0:2] = 'ASDF' # 输出['A', 'S', 'D', 'F', 'T', 'H', 'O', 'N']
# 给切片赋值，须传递一个序列，且序列长度与被修改序列长度一致
# lst[0:2] = 123 # 报错 TypeError: can only assign an iterable
# lst[::2] = 'A' # 报错 ValueError: attempt to assign sequence of size 1 to extended slice of size 3
# lst[::2] = 'A' * 3 # 起始与结束省略，默认整个列表，输出['A', 'Y', 'A', 'H', 'A', 'N']
# 切片[0:0]再列表头部插入序列
# lst[0:0] = 'A' # 输出['A', 'P', 'Y', 'T', 'H', 'O', 'N']
# 切片逆序
# print(lst[::-1]) # 输出['N', 'O', 'H', 'T', 'Y', 'P']2.2 列表函数
# 定义一个列表
# lst = ['P', 'Y', 'T', 'H', 'O', 'N']
# lst.index('H', 1, 7) # 获取列表中元素'H'位置，从1开始，到7结束，起始于结束参数可省略
# lst.count('T') # 获取列表中'T'的个数
# lst.append('Z') # 向列表最后添加一个元素'Z'
# lst.insert(0, 'A') # 向列表第0个元素前插入一个元素'A'
# lst.extend('X', 'Y') # 对列表进行扩展，等同于 lst += ['X', 'Y']
# lst.clear() # 清空列表
# lst.pop(2) # 弹出列表中下标为2的元素，并返回
# lst.pop() # 参数可省略，默认弹出最后一个元素
# remove() # 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
# lst.reverse() # 反转列表，等同于lst[::-1]
# lst.sort(reverse=False) # 降序排序列表2.3 列表的遍历
# range(st, ed, step)常用于for循环，st起始位置，ed结束位置，step步长
# 定义一个列表
# lst = ['P', 'Y', 'T', 'H', 'O', 'N']
# 普通for循环遍历 'PYTHON'
for item in range(6):
print(lst[i], end='')
print()
# 迭代器式遍历 'PYTHON'
for item in lst:
print(item, end='')
print()
# 获取0-100以内3的倍数
print(list(range(0, 100, 3)))
# 打印 [0, 3, 6, 9, ..., 99]3. 元组与字典
3.1 元组
- 元组（tuple），⼀个不可变序列(⼀般当我们希望数据不改变时，我们使⽤元组，其他 情况下基本都⽤列表)
- 非空元组至少包含一个 逗号(,)，一般使用()创建，非空时括号()可省略
- 元组解包，将元组中每个元素都赋值给一个变量
- 基本应用
# 非元组
my_tuple = 20
print(my_tuple, type(my_tuple)) # 输出 20 <class 'int'>
# 创建一个元组，包含一个元素
my_tuple = 20,
print(my_tuple, type(my_tuple)) # 输出 (20,) <class 'tuple'>
# 新建一个元组
my_tuple = 20, 30, 40, 50 # 等价于 my_tuple = (20, 30, 40, 50)
print(my_tuple, type(my_tuple)) # 输出 (20, 30, 40, 50) <class 'tuple'>
# 元组解包
a, b, c, d = my_tuple
print(a, b, c, d) # 输出 20 30 40 50
# 变量与元素个数不对等的元素解包，加*表示一个列表
*a, b, c = my_tuple
print(a, b, c) # 输出 [20, 30] 40 50
# *位置可任意存在，除去非序列变量对应的元素，元组会将剩余元素以列表形式返回
a, *b, c = my_tuple
print(a, b, c) # 输出 20 [30, 40] 50
# 元组方法 index(target, start, end), count(target)
my_tuple.index(20, 0, 4) # 从下标[0, 4)查找元素20
my_tuple.count(20) # 统计元素个数3.2 字典
- 字典（dict），用键值对（key-value）存储对象的一种数据结构，也称为映射（mapping）
- 字典中元素都具有唯一名称，字典的值是任意可变对象，而键是任意不可变对象，每一对键值对称为一个项（item）
- 基本操作
# 创建一个字典
d = {'book':'Python入门到放弃', 'price':55} # 等价于d = dict(book='Python入门到放弃', price=55)
print(d, type(d)) # 输出{'book': 'Python入门到放弃', 'price': 55} <class 'dict'>
# 双值子序列
# 双值序列 序列中仅含两个值，形如('a', 5), 'xy', [10, 20]
d = dict([('book', 'Python入门到放弃'), ('price', 55)])
print(d, type(d)) # {'book': 'Python入门到放弃', 'price': 55} <class 'dict'>
# 根据字典键值获取元素值
print(d['book']) # 输出 Python入门到放弃
tmp = 'book'
print(d[tmp]) # 输出 Python入门到放弃
# print(d['tmp']) # KeyError: 'tmp'，值不存在，直接报错
# 通过字典对象方法获取值
print(d.get('book')) # get(key, default)，default可省略
print(d.get('python', '该值不存在')) # 输出 该值不存在，当获取元素不存在时返回default内容
# 修改字典对象
# 1.通过索引键值修改
d['book'] = 'Java EE 轻量级'
d['price'] = 49.9
print(d, type(d)) # 输出{'book': 'Java EE 轻量级', 'price': 49.9} <class 'dict'>
# 2.对象方法修改
res = d.setdefault('python', '123') # 当key存在，则直接返回字典中key的值，否则在字典尾部添加该key-value
print(res, d) # 输出 123 {'book': 'Java EE 轻量级', 'price': 49.9, 'python': '123'}- 常用方法
# 字典常用方法
# 创建两个字典对象
d = dict(a=1, b=2,c=3)
d1 = dict(d=5, f=7, a=9)
# d.update(d1) # 更新后 {'a': 9, 'b': 2, 'c': 3, 'd': 5, 'f': 7}，有重复值覆盖，无重复值追加
# d1 = d # d与d1指向同一个对象
# del d['a'] # d与d1相同{'b': 2, 'c': 3}
# res = d.popitem() # 删除字典最后一个元素，返回一个key-value的元组 ('c', 3)
# res = d.pop('d', '不存在') # 删除指定key并返回该值，若不存在返回default pop(key, default)- 浅复制
# 浅复制，第一层开辟新地址，而第二次共用相同地址
d = dict(a=1, b=2,c=3)
# d1 = d.copy()
# d1['a'] = 11 # 复制后对象与原对象独立，修改一个不会影响另一个
# print(d, d1) # {'a': 1, 'b': 2, 'c': 3} {'a': 11, 'b': 2, 'c': 3}
# 浅复制只会复制字典本身，如果字典中还有字典将不被复制，即共用相同物理地址
# d = {'a':{'book': 'Python入门到放弃', 'price': 49.9}, 'b':2, 'c':3}
# len(d) # 返回字典中键值对数
# d1 = d.copy()
# d1['a']['book'] = 'Java EE 轻量级'
# print(d, id(d)) # {'a': {'book': 'Java EE 轻量级', 'price': 49.9}, 'b': 2, 'c': 3} 2801800510784
# print(d1, id(d1)) # {'a': {'book': 'Java EE 轻量级', 'price': 49.9}, 'b': 2, 'c': 3} 2801800510784- 遍历
# keys()返回字典的所有key
for k in d.keys():
print(d[k])
# values返回一个序列，保存字典中所有值
for v in d.values():
print(v)
# items返回项，保存字典中所有key-value对
for k, v in d.items():
print(k, v)4. 集合
- 集合（set)，与列表类似，但其存储的对象序列无序，且不包含重复值，对象不可变
4.1 集合方法
s = {'a', 'b', 'c'} # 等价于s = set('abc')
# len(s) # 获取集合中元素数
# s.add('f') # 向set中添加元素
# s.update(set('df')) # 将一个集合中元素添加到另一个集合
# s.remove('b') # 删除指定元素
# s.pop() # 默认移除最后一个元素
# s.clear() # 清空4.2 集合运算
- & 交集运算
- | 并集运算
- - 差集运算
- ^ 异或集
- > 判断⼀个集合是否是另⼀个集合的真超集
- >=检查⼀个集合是否是另⼀个集合的超集
- < 检查⼀个集合是否是另⼀个集合的真⼦集
- <= 检查⼀个集合是否是另⼀个集合的⼦集
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
