整理python中一些常用的，容易忘记的知识点，持续更新。。。
1. is == 区别
简单来说is是比较两个对象的占用内存地址是否相同，而==是比较两个对象的值是否相等
参考：https://www.cnblogs.com/kiko0o0/p/8135184.html
2. 深复制与浅复制
浅复制仅仅是赋值了对象的最外面一层，对象中嵌套的可变对象没有被赋值。深复制就是赋值对象中所有的元素。
注：切片操作与copy都是浅复制，deepcopy是深复制
参考：https://www.cnblogs.com/pinpin/p/9865228.html
3. 常用的一些数据结构
3.1 栈与队列
3.1.1 用python中的列表来实现栈与队列
list = []
for i in range(1, 4):
list.append(i) #LIFO 后进先出，相当于栈
a = list.pop() #等价于 a = list.pop(-1)
print(list, a)
b = list.pop(0) #FIFO 先进后出，相当于队列
print(list, b)
3.1.2 python中自带的数据结构Queue
# Queue.Queue(maxsize=0) #创建队列，FIFO， 如果maxsize小于1就表示队列长度无限。
# Queue.LifoQueue(maxsize=0) #创建栈，LIFO， 如果maxsize小于1就表示队列长度无限。
# Queue.qsize() #返回队列的大小
# Queue.empty() #如果队列为空，返回True,反之False
# Queue.full() #如果队列满了，返回True,反之False
# Queue.get([block[, timeout]]) #出队，读队列，timeout等待时间。非阻塞get_nowait()，相当于get(block=False)
# Queue.put(item, [block[, timeout]]) #入队，写队列，timeout等待时间。非阻塞put_nowait()，相当于put("xxx",block=False)
# Queue.queue.clear() #清空队列
from queue import Queue
from queue import LifoQueue
q = Queue() #FIFO 队列
for i in range(1, 4):
q.put(i)
while not q.empty():
print(q.get())
s = LifoQueue() #LIFO 栈
for i in range(1, 4):
s.put(i)
while not s.empty():
print(s.get())
3.2 列表
list = []
list.append(1) #添加元素
list.index(1) #返回指定元素的下标,如果该元素不存在会报错
val = list.pop() #去掉列表中的最后一个值，等价于list.pop(-1)
val = list.pop(0) #去掉列表中的第一个值
list.remove(val) #移除列表中值为val的元素
list.insert(index, val) #在下标index之前插入val
cnt = list.count(val) #返回列表中值为val的元素个数
3.3 字典dict
dict = {1:'a', 2:'b', 3:'c', 4:'d'}
dict.get(1, 'not found') #在dict查找key为1的value，找不到返回'not found'
del dict[4] #删除dict中key为4的那个元素
dict.clear() #清空字典
#判断key是否存在与字典中
key in dict #或者key in dict.keys()
3.4 set集合
s = set(['a', 'b', 'c', 1, 2, 3])
s.add(4) #添加元素
s.clear() #清空集合
s1 = s.copy() #复制，改变s1不会影响s
s.remove(1) #移除元素，如果要移除的元素不存在则会报错
s.discard(1) #移除元素，如果要移除的元素不存在不会报错
s1 = set('acac')
s1 & s #交集
s1 | s #并集
s1 - s #差集
3.5 字符串
s = "abcde"
s.find('abc', 0, len(s)) #在s中从[0,len(s))查找子串'abc', 返回子串在s中第一次出现的起始位置，找不到返回-1
s.index('abc', 0, len(s)) #在s中从[0,len(s))查找子串'abc', 返回子串在s中第一次出现的起始位置，找不到抛出异常
s.rfind('abc', 0, len(s)) #在s中从[0,len(s))查找子串'abc', 返回子串在s中最后一次出现的起始位置，找不到抛出异常
4. * ** zip的用法
星号的用法相当于解压，与zip相反
在列表前面加*相当于将列表中的元素解开为独立的变量传入函数之中，同样适用于numpy中的array
list = [1, 2]
print(*list)
def f(a, b):
print(a+b)
f(*list)
在字典前加**相当于将字典的各个value传入函数
data = {'a' : 4, 'b' : 3}
print(*data) #输出key
def f(a, b):
print(a+b)
f(**data)
zip将可迭代的对象作为参数，返回这些对象元素依次组成的元组
a = [1, 2, 3]
b = [4, 5, 6]
print(list(zip(a, b)))
print(list(zip(*zip(a, b))))
同样适用于字典，对于字典用的是字典的key
a= {1: 1, 2: 2}
b = {3: 3, 4: 4}
c = {5: 5, 6: 6}
print(list(zip(a, b, c)))
print(list(zip(*zip(a, b, c))))
用于循环语句
a = [2, 3, 4]
b = [4, 5, 6]
for x, y in zip(a, b):
print(x, y)
参考：
https://www.cnblogs.com/wushuaishuai/p/7766470.html
https://blog.csdn.net/weixin_40877427/article/details/82931899
https://blog.csdn.net/breeze_blows/article/details/90475922
https://blog.csdn.net/liuweizj12/article/details/79893673
