整理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