总结 - 容器类型

一、列表补充

• 列表(list) - 有序、可变
  [12, 34, 56]
  列表元素的要求：任何类型的数据都可以作为列表元素
  获取单个元素、获取部分元素(切片)、遍历
  相关运算: +, *, ==/!=, in / not in, len(), list(), max(), min()
• == 和 is
  == - 判断两个数据的值是否相等
  is - 判断地址是否相等
  python数据存储：

1.给变量赋值的时候，如果数据的类型是数字或者字符串，不会直接开辟空间存数据，
而是现在数字字符串对应的缓存区里面去查看是否已经存储过对应的数据。如果已经存了，
直接将之前的数据对应的地址赋给变量。如果没有存储才会开辟空间存储数据。
其他类型的数据，都是直接开辟空间存储数据。然后再把地址返回
2.容器类型中的元素，在容器中不是直接存的值，而是元素值对应的地址

二、列表相关方法

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

list1 = [1, 2, 3]
list2 = list1
list2.append(66)
print(list1)

list3 = list1[:]
list3.append(100)
print(list3)
>>>>
[1, 2, 3, 66]
[1, 2, 3, 66, 100]

• 2.列表.count(元素) - 获取指定元素在列表中出现的次数

nums = [1, 23, 45, 56, 5, 45]
print(nums.count(45))
>>>>
2

• 3.列表.extend(序列) - 将序列中所有的元素都添加到列表中

numbers = [100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello']
numbers.extend(['abc', 'hello'])
print(numbers)
numbers.extend('world')
print(numbers)
numbers.extend(range(11, 15))
print(numbers)
>>>>
[100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello']
[100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello', 'w', 'o', 'r', 'l', 'd']
[100, 34, 90, 89, 100, 7, 100, 18, 'abc', 'hello', 'w', 'o', 'r', 'l', 'd', 11, 12, 13, 14]

• 4.列表.index(元素) - 获取指定元素的下标
  注意：a.如果元素有多个，只获取第一个的下标
  b.如果元素不存在，会报错

numbers = [3, 1, 2, 3, 4, 5, 3]
print(numbers.index(3))
>>>>
0

• 5.列表.reverse() - 反向列表（将列表元素倒序）

nums = [1, 5, 45, 8, 2, 9, 2, 59]
nums.reverse()
print(nums)

• 6.列表.sort() - 对列表进行升序排序（从小到大）
  列表.sort(reverse=True) - 对列表进行降序排列（从大到小）
  注意：列表的要求：a.列表的元素类型必须一样 b.元素支持比较运算符

nums.sort()
print(nums)
nums.sort(reverse=True)
print(nums)
>>>>
[59, 2, 9, 2, 8, 45, 5, 1]
[1, 2, 2, 5, 8, 9, 45, 59]

• 7. 列表.clear() - 清空列表
     注意：清空列表尽量使用clear()

names = ['路飞', '娜美', '山治', '罗宾', '弗兰克', '乔巴', '佐罗']
names.clear()
print(names)
>>>>
[]

• 8.列表.copy - 将列表中元素直接赋值一份产生一个新的列表
  和列表.[:]效果一样
  注意：这里的是浅拷贝

list1 = [1, 2, 3]
list2 = list1.copy()
print(list2)
print(list1 is list2)
>>>>
[1, 2, 3]
False

什么时候使用字典：
如果一个容器里面储存的数据是不同意义的数据（数据之间需要区分）就使用字典

三、浅拷贝和深拷贝

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

import copy

numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
list2 = list1.copy()  # 浅拷贝
print("1.浅拷贝")
print("修改前list1:", list1)
print("修改前list2:", list2)
print("对list1进行修改")
list1.append(66)
list1[0].append(666)
print("修改后list1:", list1)
print("修改后list2:", list2)


numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
list2 = copy.deepcopy(list1)  # 浅拷贝
print("2.深拷贝拷贝")
print("修改前list1:", list1)
print("修改前list2:", list2)
print("对list1进行修改")
list1.append(66)
list1[0].append(666)
print("修改后list1:", list1)
print("修改后list2:", list2)
>>>>
1.浅拷贝
修改前list1: [[1, 2, 3], [10, 20, 30]]
修改前list2: [[1, 2, 3], [10, 20, 30]]
对list1进行修改
修改后list1: [[1, 2, 3, 666], [10, 20, 30], 66]
修改后list2: [[1, 2, 3, 666], [10, 20, 30]]
2.深拷贝拷贝
修改前list1: [[1, 2, 3], [10, 20, 30]]
修改前list2: [[1, 2, 3], [10, 20, 30]]
对list1进行修改
修改后list1: [[1, 2, 3, 666], [10, 20, 30], 66]
修改后list2: [[1, 2, 3], [10, 20, 30]]

四、元组

• 1.元组
  元祖就是不可变的列表(有序，不可变)
  有序 - 可以通过下标获取元素
  不可变 - 不支持增、删、改
• 2.元组的字面量
  通过小括号将多个元素括起来，元素之间用逗号隔开
  a.只有一个原的元组：在元素的后面必须加一个逗号
  b.直接将多个数据用逗号隔开，括号可以省略
  c.获取元组元素
  d.可以通过变量个数和元组元素保持一致来获取元组中的每一个元素
  元组相关的方法：只有列表中的count和index

tuple1 = (1, True, "abc", [1, 2])
print(tuple1)

tuple2 = (10)
tuple3 = (10,)
print(type(tuple2), type(tuple3))

tuple4 = 1, 2, "abc"
print(type(tuple4))
>>>>
(1, True, 'abc', [1, 2])
<class 'int'> <class 'tuple'>
<class 'tuple'>

五、字典

• 1.字典（dict）
  字典是python中内置的容器类的数据类型，可变，无序的。字典的元素是键值对
• 2.字典的字面量：使用大括号括起来，大括号中的是键值对，多个键值对之间用
  逗号隔开
  键值对 - 键：值
  键(key) - 不可变的；唯一的
  列表和字典不能作为key
  值(value) - 任何类型的数据

student = {'name': '小明', 'age': 28, 'tel': '1627399992', 'score': 30, '学号':'1982001'}
print(student)
print(student['name'])
>>>>
{'name': '小明', 'age': 28, 'tel': '1627399992', 'score': 30, '学号': '1982001'}
小明

六、字典的增删改查

1.查（获取字典的值）

• a.获取单个值
  字典[key] - 获取字典中key对应的值
  字典.get(key) - 获取字典中对应的值（如果key不存在，不会报错）
  None 是python中的关键字，表示一个特殊值（没有，空的意思）

zhangsan = {"name": "张三", "age": 89, "gender": "男", "hobby": "play"}
print(zhangsan["name"])

print(zhangsan.get("age"))
print(zhangsan.get("hobby"))
print(zhangsan.get("hahahhahhaha"))

# 直接遍历字典拿到的是字典中所有的key值
for key in zhangsan:
    print(key)

for key, value in zhangsan.items():
    print(key, value)
>>>>
张三
89
play
None
name
age
gender
hobby
name 张三
age 89
gender 男
hobby play

2.增（添加键值对）

• 字典[key] = 值 - 当key不存在的时候，就是在字典中添加键值对
• 字典1.update(序列) - 将字典中的元素转换为键值对，然后再添加到字典1中
  当key值有重名的时候，会用序列中键值对对应的值，更新原字典key对应的值
  注意：update(序列)要求能够转换成字典的序列。 序列中的元素是自由两个元素的
  小序列

dict3 = {'a': 1, 'b': 2, "c": 3}
dict3.update({'a': 10, 'b': 20})
print(dict3)
>>>>
{'a': 1, 'b': 2}

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

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

dict1 = {'a': 10, 'b': 20}
dict1['a'] = 100
print(dict1)
>>>>
{'a': 100, 'b': 20}

4.删（删除键值对）

• a.del 字典[key] - 删除字典中key值对应的键值对
• b.字典.pop(key) - 取出字典中key对应的值(删除整个键值对)
  • 字典.popitem() - 取出“最后”一个键值对，一元组的形式返回
  • 字典popitem()方法作用是：随机返回并删除字典中的一对键和值（项）。
  • 为什么是随机删除呢？因为字典是无序的，没有所谓的“最后一项”或是其它顺序。
    在工作时如果遇到需要逐一删除项的工作，用popitem()方法效率很高

# a
person = {'name': '张三', 'age': 30, 'sex': '男'}
del person['sex']
print(person)
# b
person = {'name': '张三', 'age': 30, 'sex': '男'}
age = person.pop('age')
print(person, age)

person = {'name': '张三', 'age': 30, 'sex': '男'}
# 删除最后一个键值对(取出最后一个键值对, 以元祖的形式返回) - 无意义
value = person.popitem()
print(person, value)
>>>>
{'name': '张三', 'age': 30}
{'name': '张三', 'sex': '男'} 30
{'name': '张三', 'age': 30} ('sex', '男'

七、字典相关运算和方法

• 1.字典不支持+和*
• 2. in 和not in
     判断字典中是否存在指定的key
• 3.clear
  字典.clear（） - 清空字典（删除字典中所有的键值对）
• 4.copy
  字典.copy() - 复制字典中所有的键值对，产生一个新的字典
• 5.fromkeys
  dict.fromkeys(序列,值) - 以序列中的元素作为key，值作为所有key对应的默认值，创建一个字典

dict.fromkeys(序列, 值) - 以序列中的元素作为key，值作为所有key对应的默认值，创建一个字典
"""
dict3 = dict.fromkeys('xyzp', 100)
print(dict3)   
dict3 = dict.fromkeys(['name', 'age', 'height'], 100)
print(dict3)    
>>>>
{'x': 100, 'y': 100, 'z': 100, 'p': 100}
{'name': 100, 'age': 100, 'height': 100}

• 6.keys、values、items

字典.keys() - 获取字典所有的key（返回一个序列，序列中所有的元素就是字典的key）
字典.values() - 获取字典所有的值（返回一个序列，序列中所有的元素就是字典的值）
字典.items() - 获取字典所有的键值对(返回一个序列，序列中的元素是元组，元组元素有两个分别是key和值）

dict1 = {"x": 89, "y": 45, "z": 56}
keys = dict1.keys()
print(keys, type(keys))
values = dict1.values()
print(values, type(values))
print(list(values))
items = dict1.items()
print(items, type(items))
print(list(items), dict(items))
>>>>
dict_keys(['x', 'y', 'z']) <class 'dict_keys'>
dict_values([89, 45, 56]) <class 'dict_values'>
[89, 45, 56]
dict_items([('x', 89), ('y', 45), ('z', 56)]) <class 'dict_items'>
[('x', 89), ('y', 45), ('z', 56)] {'x': 89, 'y': 45, 'z': 56}

• 7.setdefault
  字典.setdefault(key,value) - 给字典添加键值对（注意：如果key值本来存在，就不会影响字典）

八、集合

1.集合（set）

• a.集合是python内置的一个容器类的数据类型，是可变、无序的
• b.字面量 - 使用{}括起来，里面有多个元素，多个元素之间用逗号隔开
  {1,2,3}
• c.元素 - 不是键值对；必须是不可变，而且是唯一的

set1 = {1, 2, 1, "sdj", "手机打开"}
print(set1)  # 会自动去重

set2 = {}   # 表示一个空字典
print(type(set2))
set3 = set()   # 创建一个空集合
print(type(set3))
>>>>
{1, 2, 'sdj', '手机打开'}
<class 'dict'>
<class 'set'>

2.集合的增删改查

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

• b.增（添加元素）
  集合.add(元素) - 将指定的元素添加到集合中
  集合.update(序列) - 将序列中的元素添加到集合

• c.删（删除元素）
  集合.remove（元素） - 删除集合中指定的元素

• d.改 - 集合不能修改元素的值

3.数学集合运算

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

• 1.包含关系
  集合1 >= 集合2 判断集合1中是否包含集合2(判断集合2是否是集合1的子集)
  集合1 <= 集合2 判断集合2中是否包含集合1(判断集合1是否是集合2的子集)

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

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

• 4.差集
  集合1 - 集合2

• 5.补集
  集合1 ^ 集合2 - 使用两个结合中出了公共部分以外的元素，创建一个新的集合

set1 = {1, 2, 3, 4}
set2 = {2, 4, 5, 6, 9}
print(set1 | set2)

print(set1 & set2)

print(set1 - set2)

print(set1 ^ set2)
>>>>
{1, 2, 3, 4, 5, 6, 9}
{2, 4}
{1, 3}
{1, 3, 5, 6, 9}