Python中的容器--列表

一、认识列表

1、列表（list）

列表是python内置的课变并且有序的容器类数据类型（序列）

列表的特性：

• 有序：说明可以通过下标获取元素
• 可变：指的是列表中的元素的个数 元素的值以及元素的位置可变（列表支持增删改）

2、列表的字面量：

中括号括起来，里面有多个元素，元素之间用逗号隔开。
语法：[元素1, 元素2, 元素3…]
元素：可以是任何数据，同一个列表，不同的类型可以不一样。

二、列表元素的增删查改

1、查（获取列表的元素）

• a.获取单个元素
  列表[下标] - 获取指定下标对用的元素

• 注意：列表一旦确定，列表中的每个元素都对应一个下标。
  下标范围：0 ~ 列表长度，或者是 -1 ~ - 列表长度，并且下标不能越界。

• b.获取多个元素（切片） - 结果是列表
  列表[开始下标:结束下标:步长]
  列表[开始下标:结束下标]

2、增（增加元素）

两种方式：

• a.列表.append(元素) - 在指定列表的末尾添加指定的元素
• b.列表.insert(下标, 元素) - 在指定的下标前插入指定的元素
• c.遍历列表（将列表中的元素一个一个地取出来）
  方法一：直接获取列表元素
  for 变量 in 列表 ->用变量获取列表中的元素
  方法二：通过遍历下标获取列表元素

3、删（删除列表元素）

• a.del 列表[下标] - 删除列表中指定下标对应的元素
  del - 关键字 可以删除任何内容
• b.列表.remove(元素) - 删除指定列表中指定的元素
  **注意：**如果指定的元素在列表中有多个，只会删除列表中最先出现的那一个。
• c.pop方法只是把元素从列表中取出来 并不是从列表中删除（销毁），但列表中还是不会出现这个元素
  列表.pop() - 取出列表中最后一个元素
  列表.pop(下标) - 取出列表中指定下标对应的元素

4、改（修改列表元素的值）

列表[下边] = 新值 - 将列表中指定下标对应的元素修改成指定的值

三、列表相关运算

1、加法：

列表1 + 列表2 - 使用两个列表中的元素产生一个新的列表

2、乘法：

列表 * n（正整数） - 将列表中的元素重复n次，产生一个新的列表

3、in 和 not in

• 元素 in 列表 判断指定的元素是否在列表中
• 元素 not in 列表 判断指定的元素是否不在列表中

4、len

len(列表) - 获取列表元素的个数
###5、list
list(数据) - 将其他的数据转换成列表
注意：这儿的数据只能是数列（所有的序列都能转换成列表 - 将序列中的元素作为列表的元素）

6、max 和 min

max(列表) - 获取列表中元素的最大值
min(列表) - 获取列表中元素的最小值
**注意：**列表有一下要求：

• a.列表中的元素的类型必须一样
• b.元素中的元素的类型必须支持比较运算符

四、列表相关方法

1、列表赋值

• a.直接使用一个列表变量给另一个列表变量赋值，赋的是地址，赋完值之后 对其中一个列表进行增删改，会影响另一个列表。
• b.如果赋值的时候 赋的是列表的切片或者拷贝，会产生新的地址，然后使用新的地址赋值，赋完值后，两个列表相互之间不影响。

2、列表中的方法

list.append() - 将括号中的变量添追加到列表中
list.count(元素) - 获取指定元素在列表中出现的次数
list1.extend(序列) - 把序列中的元素都添加(追加)到列表list1中
list.index(元素) - 获取指定的元素的下标
注意：a.如果元素在列表中有多个，只取第一个的下标
b.如果元素在列表中不存在 会报错（ValueError）
list.insert(index, seq) - 将元素seq插入到列表中索引为index的元素前
list.pop(元素) - 取出列表中指定元素
list.remove(元素) - 删除列表中指定元素（如果有多个，只会删除第一个）
list.reverse() - 反向列表（将列表中的元素倒序）
list.sort(key=None, reverse=False) - 括号中不写表示默认排序（升序排序 从小到大）
​ reverse为False表示从小到大 reverse为True表示从大到小
​ 注意：列表的要求：a.列表中元素类型必须一样 b.元素必须支持比较运算符
list.clear() - 清空列表
​ 注意：清空列表时尽量使用clear 而不是给列表赋新的空列表（会额外消耗cpu资源）
list.copy() - 将列表中的元素直接复制一份产生一个新的列表，和列表[:]效果一样
​ 注意：这个拷贝是浅拷贝

五、浅拷贝和深拷贝（了解）

• copy.copy(对象) - 浅拷贝 （直接拷贝元素的值 产生一个新的地址）
• copy.deepcopy(对象) - 深拷贝 （不会直接复制地址 而是将地址对应的值拷贝一份 产生新的地址）

详解：
copy.copy()方法在进行拷贝的时候：
首先，在对一个多维数列进行复制时，copy.copy()方法会将数列一维的所有非子对象的数据（如：字符串、数字等非变量），但是对于其中的子对象（列表、字典等）会保存其地址，在对原列表进行操作时，改变一维中的非子对象，复制的列表不会发生改变；当对子对象进行操作时，复制的列表会相应进行变化。例如：

import copy
lis1 = [1, 2, 3, [11, 12, 13]]
lis2 = copy.copy(lis1)  # 将lis1中的内容浅拷贝至lis2中
lis1.append(4)  # 对lis1进行操作
lis1[3].append(14)  # 对lis1中的子对象进行操作
print('lis1:', lis1)
print('lis2:', lis2)

>> lis1: [1, 2, 3, [11, 12, 13, 14], 4]
>> lis2: [1, 2, 3, [11, 12, 13, 14]]

copy.deepcopy()方法在进行拷贝时：
在复制一个列表时，不管列表中是否有子对象（列表、字典等），其都会将对象复制出来，保存新的地址；当对原列表进行操作时，复制的列表不会做出任何相应的变化。

import copy
lis1 = [1, 2, 3, [11, 12, 13]]
lis2 = copy.deepcopy(lis1)  # 将lis1中的内容深拷贝至lis2中
lis1.append(4)  # 对lis1进行操作
lis1[3].append(14)  # 对lis1中的子对象进行操作
print('lis1:', lis1)
print('lis2:', lis2)

>> lis1: [1, 2, 3, [11, 12, 13, 14], 4]
>> lis2: [1, 2, 3, [11, 12, 13]]

六、元组

1、什么是元组（tuple）

元组就是不可变的列表（有序 不可变）

• 有序 - 可以通过下标获取元素
• 不可变 - 不支持增删改

2、元组的字面量

通过小括号将多个元素括起来 多个元素之间用逗号隔开

a.如果只有一个元素的元组，小括号中的元素后面必须加一个逗号，如：tuple1 = (10, )
b.在赋值的时候还可以直接将多个数据用逗号隔开 不用括号括起来，如：tuple2 = 1, 2, 3, 4, ‘abc’
c.获取元组元素的时候可以：直接使用下标获取 还可以（通过变量个数和元组元素个数保持一致来获取元组中的每个元素）：

• tuple3 = 10, 20
• x, y = tuple3

可以通过在变量名前加* 获取没有*的变量获取到的元素剩下的部分，以列表的形式返回。

3、获取元组元素和列表获取列表元素一模一样

三种方式：
	单个获取
	多个获取
	遍历

4、相关运算和列表一样

相关的运算符号（方法）有：+、*、in、not in、len()、tuple()、 max()、 min()

5、元组相关的方法：

tuple.count() - 统计元素在tuple中出现的次数
tuple.index() - 查找元素在tuole中第一个索引值

七、字典

1、什么是字典(dict)

字典是Python中内置的容器类的数据类型、可变、无序的，字典的元素是键值对。

2、字典的字面量：使用大括号括起来 大括号重视键值对 多个键值对之间用逗号隔开

• 键值对 - 键:值

• 键(key) - 不可变的；唯一的（一般使用字符串作为key）

• 值(value) - 任何类型的数据

注意：列表和字典不能作为key，key是唯一的。
什么时候使用字典：
​ 如果一个容器里面存储的数据是不同意义的数据（数据之间需要区分），就使用字典。

八、字典的增删改查

1、查（获取字典的值）

a.直接查一个

• 字典[key] - 获取字典中key对应的值（注意：如果key不存在 会报错：KeyError）
• 字典.get(key) - 获取字典中key对应的值（如果key不存在 不会报错 并且会返回一个默认值None）
• 注意：None是Python中的关键字，表示一个特殊值（没有 空的意思）

b.遍历

• 直接遍历字典拿到的是字典中所有key

for key in dict1:
​ print(key, dict1[key])

• 同时获取key和value（看着方便但是性能差、内存消耗多）

for key, value in dict1.items():
​ print(key, value)

2、增（添加键值对）

字典[key] = 值 - 当key不存在时，就是在字典中添加键值对。

• 字典1.update(序列) - 将序列中的元素转换成键值对 然后在添加到字典1中
• 当key值有重名的时候 会用序列中键值对对应的值 更新原字典的key对应的值

dict1 = {‘a’: 100, ‘b’: 200}
dict1.update({‘aa’: 10, ‘bb’: 20, ‘a’: ‘abc’})
print(dict1)

3、改（修改key对应的值）

字典[key] = 值 - 当key存在时，就是修改key对应的值。

4、删（删除键值对）

• a. del 字典[key] - 删除字典中key对应的键值对
• b.字典.pop(key) - 取出字典中key对应的值（删除这个键值对）
  ​ 字典.popitem(key) - 删除最后一个键值对（取出最后一个键值对，以元组的形式返回）

九、字典的相关方法

• 1、dict.clear() - 清空字典（删除字典中所有的键值对）
• 2、dict.copy() - 复制字典中的所有的键值对，产生一个新的字典
• 3、dict.fromkeys(序列, 值) - （静态方法 用类型名来调用）以序列中的元素做为key 值作为所有key对应的默认值，创建一个新的字典

	print(dict.fromkeys([1, 2, 3], [1, 2, 3]))
    >> {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}

• 4、dict.get(key) - 获取key对应的值，如果key不存在，返回None
  dict.get(key, 值) - 获取key对应的值，如果key不存在，返回指定的值
• 5、key in/not in dict - 判断key是否在字典中
• 6、字典.keys() 、字典.values()、字典.items()
  字典.keys() - 获取字典所有的key（返回一个序列，序列中的元素就是字典中所有的key）
  字典.values() - 获取字典所有的值（返回一个序列，序列中的元素就是字典中所有的值）
  字典.items() - 获取字典所有的键值对（返回一个序列，序列中的元素是元组 元组中的元素有两个 分别是key和value）
  注意：keys返回的是一个序列 类型为dict_keys，不是一个普通的序列，在取值的时候不能单纯用下标取值
  values返回的是一个序列，类型为dict_values，不是一个普通的序列，在取值的时候不能单纯用下标取值。
  items返回的是一个序列，类型为dict_items，不是一个普通的序列，在取值的时候不能单纯用下标取值。
• 7、dict.setdefault(key, value) - 给字典添加键值对（注意：key本来就存在 不会修改这个key的值 即对原字典没有影响）
• 8、dict.update()
• 9、dict.pop()
• 10、dict.popitem()

十、集合的基本操作

1、什么是集合（set）

• a.集合是Python内置的容器类的数据类型 是可变的 无序的
• b.字面量 - 使用{}括起来 里面有多个元素，多个元素之间用逗号隔开
  {元素1, 元素2, 元素3…}
• c.元素 - 不是键值对，必须是不可变的而且是唯一的
  注意：空的{}是一个空的字典，而不是一个空的集合
  set1 = set() # 创建一个新的集合

2、集合的增删改查

• a.查（获取集合元素）
  不能直接获取集合中单独的某个元素 只能遍历

set1 = set('hello,world')
for item in set1:
	print(item)

• b.增（添加元素）
  • set.add(元素) - 将指定的元素添加到集合中
  • set.update(序列) - 将序列中的元素添加到集合中（序列中的元素不可变）
• c.删（删除元素）
  set.remove(元素) - 删除集合中指定的元素
• d.改（改变元素） - 集合不能修改元素的值

3、集合相关运算

in、not in、max()、min()、len()、set()

十一、数学集合运算

Python中的集合支持数学相关的集合运算。

1、包含关系

• 集合1 >= 集合2 - 判断集合1中是否包含集合2（判断集合2是否是集合1的子集）
• 集合1 <= 集合2 - 判断集合1是否包含于集合2（判断集合1是否是集合2的子集）

2、求并集

集合1 | 集合2 - 将两个集合中的元素合并在一起产生一个新的集合

3、求交集

集合1 & 集合2 - 使用两个集合中公共的元素，创建一个新的集合

4、求差集

集合1 - 集合2 - 使用集合1中除了集合2的部分以外的元素，创建一个新的集合

5、求补集

集合1 ^ 集合2 - 使用两个集合中除了公共部分以外的元素，创建一个新的集合