01.Python基础-3.集合容器

1 列表list

1.1 列表介绍

1. Python内置的一种数据类型是列表：list。
2. 有序的集合，可随时添加和删除其中的元素。
3. 每个元素都分配一个数字 ——它的位置，或索引。0,1,2,3……
4. 可存放各种类型的数据

1.2 定义列表

列表名 = [值1,值2,值3.......]

1.3 列表-查 index count len max min

1. 根据下标查找值 值 = xxx[index]

name = ['a', 'b', 'c']
# 下标从0开始
n1 = name[0] # 'a'
n2 = name[1] # 'b'

2. 从列表中找出某个值第一个匹配项的索引位置 xxx = 列表.index(值)

'''
通过值获取下标，只能获取第一次出现的位置
如果这个值不存在，则报错 VakueError
'''
nums = [1, 11, 88, 43]
where = nums.index(88) # 2

3. 统计某个元素在列表中出现的次数 xxx = 列表.count(值)

'''
nums.count()，获取此值在list中的个数
如果没有就是0
'''
nums = [1, 11, 88, 43]
num = nums.count(999) # 0

4. 查询列表的长度，元素的个数 xxx = len(列表)

# len(列表名)可以获取集合、字符串的长度
nums = [1, 11, 88, 43]
nums_len = len(nums) # 4

5. 查看列表中元素的最大值，最小值 max() min()

nums = [1, 11, 88, 43]
a = max(nums) # 88
b = min(nums) # 1

1.4 列表增 append insert extend

1. xxx.append(值)
   作用：新增到末尾

nums = [1, 11, 88, 43]
nums.append(22)
print(nums) # [1, 11, 88, 43, 22]

2. xxx.insert(下标,值)
   作用：插入到指定位置

nums = [1, 11, 88, 43]
nums.insert(2, 22)
print(nums) # [1, 11, 22, 88, 43]
nums.insert(-1, 33) # 插入至倒数第二个的位置
print(nums) # [1, 11, 22, 88, 33, 43]

3. xxx.extend(列表)
   作用：列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

a = ['aa', 'bb']
b = [1 , 2]
a.extend(b)
print(a) # ['aa', 'bb', 1 , 2]

1.5 列表-改

xxx[下标] = 值

a = ['aa', 'bb']
a[0] = 111
print(a) # [111, 'bb']

1.6 列表-删

1.删除末尾元素，并返回此元素 xxx.pop()

'''
如果不写下标，删除最后一个
如果写下标，就删除对应下标的内容
'''
nums = [110, 120, 119]
num = nums.pop() # 119
print(nums) # [110, 120]

nums = [110, 120, 119]
num = nums.pop(1) # 120
print(nums) # [110, 119]

2. 根据元素下标删除 del xxx[下标]

# del 删除指定下标的值，无返回值！
nums = [110, 120, 119]
del nums(1)
print(nums) # [110, 119]

3. 根据元素的值删除 xxx.remove(值)

# remove()根据值进行删除，无返回值！
nums = [110, 120, 119]
nums.remove(120)
print(nums) # [110, 119]

1.7 列表-判断

1. in（存在）

如果存在那么结果为True，否则为False

2. not in（不存在）

如果不存在那么结果为True，否则False

1.8 列表-脚本操作

num1 = [1, 2, 3]
num2 = [4, 5, 6]
ret = num1 + num2 # [1, 2, 3, 4, 5, 6]

num1 = [1, 2, 3]
ret = num1 * 2 # [1, 2, 3, 1, 2, 3]

1.9 列表-排序

1. 反向列表中元素 xxx.reverse()

nums = [110, 120, 119]
nums.reverse() # [119, 120, 110]

2. 排序 xxx.sort()

1.10 列表-切片

列表[num1:num2:num3]

num1,num2都是列表的下标, num3是间隔, 返回一个新的列表

1.11 遍历（循环）

1.12 传递

1. 可变的值 list列表

如果这个变量存储的是可变的值，然后传递给另外一个变量，此时变量指向同一块内存空间，然后任意一方做了修改，都会影响这个变量

比如 在一个酒店中的一个房间居住，只有一台电视，任何一个人换台都会影响另一个人

2. 不可变的值 数字、字符串、bool、None、元组

如果这个变量存储的是不可变的值，然后传递给另外一个变量，此时，二者变量指向同一块内存空间，然后，任何一方做了修改，该变量都会被重新复制，不会影响另一个变量

比如 在一个酒店中的两个房间居住，每个房间都有一台电视，任何一个屋中换台均不影响他人

2 元组tuple

1. Python的元组与列表类似，只是一点，元组里的值不能修改。
2. 元组使用小括号，列表使用方括号。
3. 元组的功能 = 列表不修改的功能

3 列表和元素相互转换

1. ls = list(元组)
   元组转列表

2. tu = tuple(列表)
   列表转元组

注意：这两个方法都是得到一个新的，不会修改原来的

4 字典dict

4.1 字典介绍

Python内置了字典，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，唯一定位一个值，查找速度快。

4.2 字典定义

1. 格式

字典 = {key1 : value1, key2 : value2 ......}

2. 键和值

• 键必须是唯一的，但值则不必
• 值可以取任何数据类型，如字符串，数字或元组

4.3 增/改 字典[键] = 值

如果次key不存在，就是往字典里新增一个键值对；否则，就是修改

一个key只能对应一个value，多次对一个key放入value，后面的值会把前面的值覆盖

student1 = {'id': 1, 'name': '老王'}
# 新增
student1['age'] = 22
print(student1) # {'id': 1, 'name': '老王', 'age': 22}
# 修改
student1['id'] = 10
student1['id'] = 7
print(student1) # {'id': 7, 'name': '老王', 'age': 22}

4.4 删

1. 字典.pop(键)

根据键，删除指定的值，并将此值返回

2. del 字典[键]

根据键，删除指定的值，无返回值

3. 字典.clear()

清空字典里的键值对

4.5 查

1. 值 = 字典[键] 根据键查询值

student1 = {'id': 1, 'name': '老王'}
sid = student1['id'] # 1
# 如果键不存在，则报错 KeyError

2. 字典.get(键[,默认值]) 如果key不存在，可以返回None，或者自己指定的value

student1 = {'id': 1, 'name': '老王'}
sid = student1.get('id') # 1

sid = student1.get('ids') # None

sid = student1.get('ids', '未知') # 未知

4.6 判断

key in dict
如果键在字典中存在，返回True
否则，返回False

4.7 遍历（循环）

使用for循环遍历的三种方式

for key in dict:
    print('%s:%s'%(key,dict[key]))

# dict.keys() 以列表形式返回一个字典所有的键
# dict.values() 以列表形式返回一个字典所有的值
for key in dict.keys():
    print('%s:%s'%(key,dict[key]))

# 推荐
# dict.items() 以列表形式返回可遍历的(键, 值) 元组数组
for k,v in dict.items():
    print('%s:%s'%(k,v)

4.8 其他

1. dict.copy()

• 返回一个新的字典，内容一样，地址不同!!!

2. dict.fromkeys(seq[, val]))

• 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有值对应的初始值

d1 = dict.fromkeys(['a','b','c'],'老王')
print(d1) # {'a': '老王', 'b': '老王', 'c': '老王'}

3. dict.setdefault(key, default=None)

• 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
• 如果键在字典中，返回这个键所对应的值。
• 如果键不在字典中，向字典中插入这个键，并且以default为这个键的值，并返回 default。default的默认值为None

4. dict.update(dict2)

• 把字典dict2的键/值对更新到dict里

4.9 字典与列表对比

1. 语法上

• ls = [v1, v2 ...]
• dict = {k1:v1, k2:v2 ...}

2. 速度上：dict>list
3. 内存：list占用相对dict较小
4. 存储内容：都可以存储任意类型的变量
5. 获取方式：list-下标 dict-键

5 集合set

set是一个无序，不能重复的集合容器，所以可以用来过滤重复元素。

1. add(obj) 新增
2. remove(obj) 移除
3. | 并集
4. & 交集
5. • 差集

列表，元组，字典，集合 的比较

1. list 可变，有序，可重复
2. tuple 将list的[]变成()，不可变，有序，可重复
3. set 可变，无序，不可重复
4. dict 键值对，可变

list() tuple() set()三者可相互转换