1.python数据存储

• 1.给变量赋值的时候，如果数据的类型是数字或者字符串，
  不会直接开辟空间存储数据 而是先在数字、字符串对应的
  缓存区里面查看是否已经存储过对应的数据
  如果已经存了，直接将之前数据对应的地址赋给变量
  如果没有存储，才会开辟空间

其他类型的数据都是直接开辟空间存储
然后再把地址返回

• 2.容器类型中的元素，在容器中不是直接存的值，而是元素值对应的地址

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2)
print(list1 is list2)
print(list1 is list3)
print(list1[0] is list2[0])

2.列表相关的方法

• 1.列表赋值

a.直接使用一个列表变量给另一个列表变量赋值，赋的是地址
赋完值之后，对其中一个列表进行增删改查，会影响另一个列表

b.如果赋值的时候赋的是列表的切片或者拷贝会产生新的地址
然后使用新的地址赋值。 赋完值之后，两个列表相互之间不影响

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

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

• 2.count和extend

1.列表.count(元素) 获取指定元素在列表中出现的次数
2.列表.extend(序列) 将序列中的所有元素都添加到列表中

numbers = [1, 2, 3]
numbers.extend(['abc', 'hello'])
print(numbers)
numbers.extend('world')
print(numbers)

3.列表.index(元素) 获取指定元素的下标
如果元素有多个只取第一个的下标
如果元素不存在 会报错

4.列表.reverse() 将列表元素反向

numbers = [1, 2, 3]
numbers.reverse()
print(numbers)

5.列表.sort() 对列表进行升序排序（从小到大）
列表.sort(reverse=True) 从大到小排序

注意：列表元素类型必须一样，元素支持比较运算

numbers = [1, 0, 45, 34, 24, 3]
numbers.sort()
print(numbers)
numbers.sort(reverse=True)
print(numbers)

6.列表.clear() 清空列表 返回空列表
注意：推荐使用clear

numbers = [1, 0, 45, 34, 24, 3]
numbers.clear()
print(numbers)

numbers = [1, 0, 45, 34, 24, 3]
numbers = []
print(numbers)

7.列表.copy() 将列表中的元素直接复制一份产生一个新的列表。
和列表[:]效果一样
注意：这个拷贝是浅拷贝 切片也是

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

3.浅拷贝和深拷贝

import copy 导入模块
copy.copy(对象) 浅拷贝 重新开辟一个容器，其他不变
copy.deepcopy(对象) 深拷贝 重新开辟一个容器，容器内部地址对应的元素也会重新生成，值不变，新地址重新保存到容器中

import copy
numbers1 = [2, 2, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
list2 = list1.copy()
list2.append(100)
print(list1, list2, '', sep='\n')

numbers1 = [2, 2, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
list2 = list1.copy()
list2[0].append(10)
print(list1, list2, '', sep='\n')

numbers1 = [2, 2, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
list2 = copy.deepcopy(list1)
list2.append(10)
print(list1, list2, '', sep='\n')

numbers1 = [2, 2, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
list2 = copy.deepcopy(list1)
list2[0].append(10)
print(list1, list2, '', sep='\n')

运行：

image.png

4.元组

1.什么是元组(tuple)
元组是有序不可变的
不支持增、删、改
2.元组的字面量：通过小括号将多个元素括起来，多个元素之间用逗号隔开
只有一个元素的元组,必须在元素后面加一个括号
去掉小括号，将多个数据用逗号隔开，还是一个元组

可以通过变量个数和元组元素个数保持一致来获取元组中的每个元素
可在变量前加 * 获取另一个变量获取后剩下的元素
只能加在一个变量前 并且至少有两个变量，加 * 变量后不能再放变量

*tuple *list *set *str将元素全部取出

tuple1 = (10)
print(tuple1, type(tuple1))
tuple1 = (10,)
print(tuple1)

tuple1 = 1, 2, 3
print(tuple1)

tuple1 = (1, 2, 3)
x, y, z = tuple1
print(x, y, z)
x, *y = tuple1
print(x, y)

tuple1 = ('aa', 'bb', 'cc')
print(*tuple1)

3.获取元组元素和列表获取元素一样
+,*,in/not in,len(),max(),min()

4.元组相关的方法：只有列表中的count和index可用
"""

5.字典

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

什么时候用字典，就使用字典
如果一个容器里面存储的数据是不同意义的数据

aa = input()
dict1 = {aa: 100, 10: 'abc', (10, 20): 'hello'}
print(dict1)

6.字典的增删改查

dict(序列) 将序列转换成字典
序列-([1, 2], (1, 2),[1, 2])
len函数有多少个键值对
max、min函数取得是字典key的最大值和最小值
key值类型一致，支持比较大小

• 1.查（获取字典的值）

a.获取单个值
字典[key] 获取key对应的值(如果key不存在会报错)
字典.get(key) 获取字典中key对应的值 (如果key不存在，不会报错，并且返回一个默认值None)

None是python中的关键字，表示一个特殊值（没有，空）

• 用一个变量来存储一个学生的信息：姓名、年龄、电话、成绩、学号
  dict_student = {'name': '小明', '年龄': 18, '电话': 18999999999, '成绩': 99, '学号': 98}

print(dict_student['name'])
print(dict_student['年龄'])
print(dict_student.get('电话'))
print(dict_student.get('sex'))

字典的遍历

• 直接遍历字典 获取的是字典中所有的key
  for x in dict_student:
  print(x, dict_student[x])

• 通过遍历字典.items() 获取键和值 两个变量（一般不用,性能差，内存消耗多）
  print(dict_student.items())
  for key, value in dict_student.items():
  print(key, value, end=' ')

• 2.增（添加键值对）

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

dict_student = {'name': '小明', '年龄': 18, '电话': 18999999999, '成绩': 99, '学号': 98, 'python': 1808}
print(dict_student)

字典1.update(序列) 将序列中的元素转换成键值对，再添加进字典1中
当key值有重名的时候，会用序列中的键值对对应的值，更新原来字典的key对应的值
序列 - 可以转换成字典的序列才可以

dict1 = {'a': 100, 'b': 20}
dict1.update({'c': 30, 'a': 10})
print(dict1)

dict1.update([(1, 2)])
print(dict1)

dict1.update([[1, 2], [2, 3]])
print(dict1)

dict1.update([(1, 2), [2, 3]])
print(dict1)

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

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

dict1 = {'a': 10, 'b': 20}
print(dict1)

• 4.删（删除键值对）

del 字典[key] 删除键为key对应的键值对
字典.pop(key) 取出key对应的值，删除整个键值对 key为空会报错
字典.clear() 清空字典

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

dict1 = {'a': 100, 'b': 20}
value_a = dict1.pop('a')
print(dict1, value_a)

• 删除最后一个键值对（取出最后一个键值对，以元组的形式返回）
  dict1 = {'a': 100, 'b': 20}
  tuple1 = dict1.popitem()
  print(dict1, tuple1)