学Python划重点二(列表、元组、字典、集合)

前言：
这些知识点内容都是老师上课内容，我只是总结一下，方便自己学习查阅！

序列 是一种可迭代的、元素有序、可以重复出现的数据结构，序列可以通过索引访问元素 。
序列 包括的结构有：字符串(str) 、字节(bytes) 、范围(range) 、元组(tuple) 、列表(list) 。

一、列表

列表(list) 也是一种序列结构，但与元组不同，列表具有 可变性 ，可以追加、插入、删除和替换列表中的元素。

1. 常用列表操作

a_list.sort(key = lambda x:len(str(x))) #按转换成字符串的长度排序
lst.sort(reverse=True) ---------- 永久性排序
sorted(lst,reverse=True) ---------- 临时排序
len(lst) -------- 列表长度
del lst[0] ---------- 删除元素

2. 遍历列表

for item in lst:
	print(item)

>>> a_list = [3, 5, 7]
>>> a_list = aList * 3
>>> a_list
[3, 5, 7, 3, 5, 7, 3, 5, 7]

3. 创建列表

a_list = [] # 创建空 列表
b = list() # 创建空
c_list = ['a', 'b', 'mpilgrim', 'z', 'example']
d_list = list((3,5,7,9,11))
list(range(1,10,2))
list('hello world')

4. 列表推导式

根据数据结构的不同可分为 列表推导式 、 集合推导式 和 字典推导式

举例：

>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = [num for elem in vec for num in elem]
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]

5. 切片

切片 操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性 。切片 作用于列表时 功能 非常 强大 。可以使用切片来截取列表中的任何部分，得到一
个新 列表 ； 也 可以通过切片来修改和删除列表中部分 元素 ； 甚至 可以通过切片操作为列表对象增加元素。

>>> a_list = [3, 5, 7]
>>> a_list[len(a_list):] = [9] # 在尾部追加 元素
>>> a_list
[3, 5, 7, 9]

>>> a_list[:3] = [1, 2, 3]  # 替换前3 个 元素
>>> a_list
[1, 2, 3, 9]

>>> a_list[:3] = []  # 删除前3 个 元素
>>> a_list
[9]

>>> a_list = list(range(10))
>>> a_list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a_list[::2] = [0] * 5  # 替换偶数位置上的 元素
>>> a_list
[0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
>>> a_list[::2] = [1] * 3 # 切片不连续，两个元素个数必须一样 多
ValueError: attempt to assign sequence of size 3 to
extended slice of size 5

# 使用del 与切片结合来删除列表元素 。
>>> a_list = [3, 5, 7, 9, 11]
>>> del a_list[:3]  # 删除前3 个 元素
>>> a_list
[9, 11]
>>> a_list = [3, 5, 7, 9, 11]
>>> del a_list[::2]  # 删除偶数位置上的 元素
>>> a_list
[5, 9]

---

二、元组

当 一个元组只有一个元素时，后面的逗号不能省略。

接收拆包元素的变量个数 应该小于等于 元组个数。可以使用下画线指定哪些元素不取值。

a = ('Hello', 'World', 1, 2, 3)
str1, _, n1, n2, _ = a
str1, str2, *n = a

---

三、字典

字典(dict) 是可迭代的、可变的数据结构，通过键来访问元素。字典结构比较复杂，包含两部分：键和值。定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“{}” 中。

1. 创建字典

>>> x = dict() # 空 字典
>>> x
{}
>>> x = {}  # 空 字典
>>> x
{}
>>> a_dict = {'a':11, 'b':31}
>> a_dict
{'a': 11, 'b': 31}

>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> x = dict(zip(keys, values))
>>> x
{'a': 1, 'c': 3, 'b': 2, 'd': 4}

>>> x = dict(name='Dong', age=37)
>>> x
{'age': 37, 'name': 'Dong'}
以 给定内容为键，创建值为空的字典。例如 ：
>>> x = dict.fromkeys(['name', 'age', 'sex'])
>>> x
{'age': None, 'name': None, 'sex': None}

2. 访问字典

1. students[“Ning”]
2. get(key[, default]) ：通过键返回值，如果键不存在返回默认值。
3. items() ：返回字典的所有键- 值对。
4. keys() ：返回字典的键。
5. values() ：返回字典的值。

setdefault() 方法，x.setdefault(‘color’, ‘black’)第一个参数是要检查的键；第二个参数，是如果该键不存在时要设置的值。如果要检查的键存在，该方法就会返回键的值

3. 遍历列表

1. for k,v in students: ------ 遍历键值对
2. for k in students.keys(): --------- 遍历所有键
3. for k in students: ----------------遍历所有键
4. for v in students.values(): -----------遍历所有值

4. 字典转换为列表

>>> d = {'name':'Zara','age':7,'class':'First'}
>>> print(list(d))
['name', 'age', 'class']
>>> print(list(d.keys()))
['name', 'age', 'class']
>>> print(list(d.values()))
['Zara', 7, 'First']
>>> print(list(d.items()))
[('name', 'Zara'), ('age', 7), ('class', 'First')]

5. 字典中找最大值、最小值 所对应的键

>>> dog = {'dog-dog': 33, 'dog-cat': 36,
'dog-car': 41, 'dog-bird': 42}
>>> min(dog, key=dog.get)
'dog-dog'
>>> max(dog, key=dog.get)
'dog-bird'

6. 字典推导式

>>> {i: str(i) for i in range(1, 5)}
{1: '1', 2: '2', 3: '3', 4: '4'}
>>> dict1 = {'one':1, 'two':2, 'three':3, 'four':4}
>>> dict2 = {k:v for k, v in dict1.items() if v %2 == 0}
>>> dict2
{'two': 2, 'four': 4}
>>> dict2 = {k:v for k, v in dict1.items() if v %2 == 0}
>>> dict2
{'two': 2, 'four': 4}

---

四、集合

集合(set) 是一种可迭代的、无序的、不能包含重复元素的数据结构。集合又分为可变集合(set) 和不可变集合(frozenset) 。集合不是序列，序列强调的是有序，集合强调的是不重复。

1. 创建可变集合

创建不可变集合：a_set = frozenset({'a', 'b', 'c', 'd'})

>>> a_set = set(range(8,14))
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set = {3, 5}
>>> b_set
{3, 5}
>>> c_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8])
>>> c_set
{0, 1, 2, 3, 7, 8}
>>> d_set = set()  # 空集合
>>> d_set
set()

2. 修改可变集合

1 ．add(obj) ：增加元素。如果元素已经存在，则不能增加，但不会抛出错误 。

>>> a_set = {3, 7, 10, 5, 13}
>>> a_set.add(20)

2 ．update(obj) ：增加的对象可以是列表、字典等，且可以是多个，用逗号隔开 。

>>> a_set.update((-1, 40), [11, 23])

3 ．remove(obj) ：删除元素。如果元素不存在 ，抛 出错误 。
4 ．discard(obj) ：删除元素。如果元素不存在，不会抛出错误。
5 ．pop() ：随机删除一个元素。
6 ．clear()

3. 集合推导式

>>> input_list = [2, 3, 2, 4, 5, 6, 6, 6]
>>> n_set = {x ** 2 for x in input_list}
>>> n_set
{4, 36, 9, 16, 25}

4. 集合操作

Python 集合支持并集、交集、差集等运算 。
>>> a_set = set([8, 9, 10, 11, 12, 13])
>>> b_set = {0, 1, 2, 3, 7, 8}
>>> a_set | b_set  # 并集
>>> a_set.union(b_set) # 并集
>>> a_set & b_set # 交集
>>> a_set.intersection(b_set) # 交集
>>> a_set - b_set # 差集
>>> a_set.difference(b_set)  #

---