1 is和==
==：判断两个数据的值是否相等
is:判断地址是否相等
1.2 python数据存储
1.给变量赋值的时候，如果数据的类型是数字或者字符串，不会直接开辟空间存数据；而是先在数字、字符串对应的缓冲区里面去查看是否已经存储过对应的数据，如果已经存了，直接将之前的数据对应的地址赋给变量。如果没有存储才会开辟空间存储数据。
2.其他类型的数据，都是直接开辟空间存储数据。然后再把地址返回
3.容器类型中的元素，在容器中不是直接存储的值，而是元素值对应的地址。然后将地址的集合的地址赋给容器变量
2 列表相关方法
2.1 列表赋值
2.1.1直接用一个列表变量给另一个列表变量赋值
.直接使用一个列表变量给另一个列表变量赋值，赋的是地址。赋完之后，对其中一个列表进行增删改，会影响另一个列表。（两个列表都是指向的同一个数值区）
list1 = [1, 2, 3]
list2 = list1
list2.append(100)
print(list1) # [1, 2, 3, 100]
2.1.2用切片或者拷贝赋值
如果赋值的时候赋的是列表的切片或者拷贝，会产生新的地址，然后使用新的地址赋值。赋完值之后，两个列表相互之间不影响。
list1 = [1, 2, 3]
list2 = list1[:]
list2.append(100)
print(list1) # [1, 2, 3]
2.2 列表中的相关方法
2.2.1 统计指定元素出现的次数。
列表.count（） - 获取指定元素在列表中出现的次数。
numbers = [1, 2, 89, 2, 3, 2]
print(numbers.count(2)) # 3
2.2.2 添加元素
列表.extend（序列） - 将序列中所有的元素都添加到列表中。
numbers = [1, 2, 3]
numbers.extend(['abc', 'hello']) # [1, 2, 3, 'abc', 'hello']
print(numbers)
numbers.extend('world') # [1, 2, 3, 'abc', 'hello', 'w', 'o', 'r', 'l', 'd']
print(numbers)
numbers.extend(range(3)) # [1, 2, 3, 'abc', 'hello', 'w', 'o', 'r', 'l', 'd', 0, 1, 2]
print(numbers)
2.2.3 获取元素
列表.index（列表） - 获取指定元素的下标
注意：如果元素有多个，只取第一个的下标
如果元素不存在，会报错（ValueError）
numbers = [1, 2, 3, 2, 5]
print(numbers.index(2)) # 1
2.2.4 倒序
列表.reverse() - 反向列表（将列表元素倒序）
numbers=[19,89,2,8,98,10,32]
numbers.reverse()
print(numbers) # [32, 10, 98, 8, 2, 89, 19]
2.2.5 排序
列表.sort（） - 对列表进行升序排序（从小到大）
列表.sort(reverse=True) - 对列表进行降序排序（从大到小）
注意： 列表的要求：
a.列表的元素类型一样
b.元素支持比较运算符
numbers=[19,89,2,8,98,10,32]
numbers.sort() # 从小到大
print(numbers) # [2, 8, 10, 19, 32, 89, 98]
numbers=[19,89,2,8,98,10,32]
numbers.sort(reverse=True) # 从大到小
print(numbers) # [98, 89, 32, 19, 10, 8, 2]
2.2.6 清空列表
列表.clear() - 清空列表
names = [1,2,3,4,5,6,7,8]
names.clear()
print(names) # []
2.2.7 列表复制
列表.copy（） - 将列表中元素直接复制一份产生一个新的列表。和列表全切片[:]效果一样。
注意：这儿的拷贝是浅拷贝。
# 拷贝
list1=[1,2,3]
list2=list1.copy()
print(list2) # [1, 2, 3]
print(list1 is list2,id(list1),id(list2)) # False 2161729485768 2161728287816
# 全切片
list1=[1,2,3]
list2=list1[:]
print(list2) # [1, 2, 3]
print(list1 is list2) # False
3 copy
copy分浅拷贝（copy(对象)）和深拷贝（deepcopy(对象)）两种。
3.1 浅拷贝
浅拷贝：直接拷贝元素的值产生一个新的地址。若元素由列表构成，则通过修改被copy的列表来对其中的子列表修改，则copy后的新列表也将跟随一起被修改。
num1=[1,2,3]
num2=[10,20,30]
list1=[num1,num2]
list2=list1.copy()
list1.append(111)
list1[0].append(100)
print(list2,'++',list1) # [[1, 2, 3,100], [10, 20, 30]] ++ [[1, 2, 3,100], [10, 20, 30], 111]
list1[0].append(111)
print('修改后list1：',list1) # 修改后list1： [[1, 2, 3, 100, 111], [10, 20, 30], 111]
print('修改后list2：',list2)# 修改后list2： [[1, 2, 3, 100, 111], [10, 20, 30]]
3.2 深拷贝
深拷贝：不会直接复制地址，而是将地址对应的值拷贝一份产生新的地址。不管对被copy的列表进行如何操作都不会影响新列表。
numb1=[1,2,3]
numb2=[10,20,30]
list1=[numb1,numb2]
list2=copy.deepcopy(list1)
list1.append(111)
list1[0].append(100)
print(list2,'++',list1) # [[1, 2, 3], [10, 20, 30]] ++ [[1, 2, 3, 100], [10, 20, 30], 111]
list1[0].append(111)
print('修改后list1：',list1) # 修改后list1： [[1, 2, 3, 100, 111], [10, 20, 30], 111]
print('修改后list2：',list2) # 修改后list2： [[1, 2, 3], [10, 20, 30]]
4 元祖
4.1 什么是元祖（tuple）
元祖就是不可变的列表。（有序，不可变）
有序 - 可以利用下标获取元素
不可变 - 不支持增、删、改
4.2 元祖的字面量：
元祖的字面量： 通过小括号将多个元素括起来，多个元素之间用逗号隔开
a.只有一个元素的元祖：在元素的后面必须加一个逗号
tuple1=(1,True,'abc',[1,2],1)
print(tuple1)
a.只有一个元素的元祖
b.直接将多个数据用逗号隔开，不用括号括起来，还是一个元祖值
tuple2=(10,)
tuple3=1,2,3,'abc'
print(tuple3,type(tuple3)) # (1, 2, 3, 'abc')
4.2.1获取元祖元素
4.2.1.1直接通过下标获取
tuple4=(10,20)
print(tuple4[0],tuple4[-2]) # 10 10
4.2.1.2可以通过变量个数和元祖个数保持一致来获取元祖中的每个元素
x,y=tuple4
print(x,y) # 10 20
4.2.1.3通过在变量名前加*，获取没有*的变量获取到的元素的剩下的部分。以列表的形式返回。
tuple5=('小明',98,90,99,87,78)
num1,*list2,num2=tuple5
print(num1,num2,list2) # 小明 78 [98, 90, 99, 87]
在列表元祖等变量名前加*，相当于直接将列表、元祖等容器展开，取出里面的元素
list1=['aa','bb','cc']
print(*list1) # aa bb cc
4.3 获取元祖元素和列表获取列表元素方法一模一样
tuple1=0,1,2,3
print(tuple1[:2]) # (0, 1)
4.4. 相关运算和列表一样
+，*，in/not in ，len（），tuple（），max（），min（）
print((1,2)+('a','n')) # (1, 2, 'a', 'n')
print((1,2)*3) # (1, 2, 1, 2, 1, 2)
print(1 in (1,2)) # True
print(len((1,2,3))) # 3
print(tuple([1,2,3,4])) # (1, 2, 3, 4)
print(max((1,2,5))) # 5
4.5.元祖相关的方法，只有列表中的count和index适用
5 认识字典
5.1 什么是字典（dict）
字典是python中内置的容器类的数据类型，可变（支持增删改）但无序（不支持通过下标查），字典的元素是键值对。
5.2. 字典的字面量：
字面量：使用大括号括起来，大括号中是键值对，多个键值对之间用逗号隔开
键值对 - 键：值
键(key) - 不可变的；唯一的；一般使用字符串(列表和字典都不能作为key，因为它们可变)；（对值进行说明和用来获取值）
值（value） - 任何类型的数据.
dict2={{'aa':1}:100,[1,2]:10} # TypeError: unhashable type: 'dict'
dict2={'aa':100,'aa':200,'bb':300}
print(dict2) # {'aa': 200, 'bb': 300}
5.2.1什么时候使用字典：
如果一个容器里面存储的数据是不同意义的数据（数据之间需要区分）就使用字典.
6 字典的增删改查
6.1 查（获取字典的值）
6.1.1.获取单个值
6.1.1.1 字典[key]
字典[key] - 获取字典中key对应的值(如果key不存在，会报错：KeyError)
6.1.1.2 字典.get（key）
字典.get（key） - 获取字典中key对应的值(如果key不存在，不会报错，并且会返回一个默认值None)
None是python中的关键字，表示一个特殊值（没有，空的意思）
当确定key存在时，一般用第一种，不确定key存在否，一般用第二种.
dog1={'name':'旺财','age':3,'color':'黄色','type':'土狗'}
print(dog1['name']) # 旺财
print(dog1.get('age')) # 3
6.1.2 遍历
直接遍历字典拿到的是字典中所有的key。
方法一：通过key遍历（常用）
for key in dog1:
print(key) # name age color type
for key in dog1: # 常用
print(key,dog1[key]) # name 旺财, age 3.....
方法二：通过类型转换
该方法常见但不常用，能同时获取key和value（看着方便但是性能差，因为会先把键值对转成元祖，元祖再转列表，消耗内存）
print(dog1.items()) # dict_items([('name', '旺财'), ('age', 3), ('color', '黄色'), ('type', '土狗')])
for key,value in dog1.items():
print(key,value)
6.2 增（增加键值对）
6.2.1方法一
字典[key] = 值 - 当key不存在时，就是在字典中添加键值对。
dict1={'a':100}
dict1['b']=200
print(dict1) # {'a': 100, 'b': 200}
6.2.2方法二
字典1.update（序列） - 将序列中的元素转换成键值对，然后再添加到字典1中。
这儿的序列要求是能够转换成字典的序列。序列中的元素是只有两个元素的小序列（列表，元祖，字典）。
当key值有重名的时候，会用序列中键值对对应的值，更新原字典的key对应的值。
dict1={'a':100,'b':200}
dict1.update({'aa':10,'bb':20,'a':'abc'})
print(dict1) # {'a': 'abc', 'b': 200, 'aa': 10, 'bb': 20}
dict1.update([[1,2],['a',2],(2,'b')])
print(dict1) # {'a': 2, 'b': 200, 'aa': 10, 'bb': 20, 1: 2, 2: 'b'}
6.3改（修改key对应的值）
字典[key] = 值 - 当key存在的时候，就是修改key对应的值。
dict1={'a':10,'b':20}
dict1['a']=100
print(dict1) # {'a': 100, 'b': 20}
6.4.删（删除键值对）
6.4.1 del
del 字典[key] - 删除字典中key对应的键值对。
person ={'name':'张三','age':30,'sex':'男'}
del person['sex']
print(person) # {'name': '张三', 'age': 30}
6.4.2 pop
字典.pop（key） - 取出字典中key对应的值（删除整个键值对）。
person ={'name':'张三','age':30,'sex':'男'}
sex=person.pop('sex')
print(person) # {'name': '张三', 'age': 30}
print(sex) # 男
popitem：
删除最后一个键值对（取出最后一个键值对，以元祖的形式返回） - 无意义，了解即可。
person ={'name':'张三','age':30,'sex':'男'}
value=person.popitem()
print(person,value) # {'name': '张三', 'age': 30} ('sex', '男')