1、合併字典： a1.update(a2)
2、列表去重：a = [11,22,33,44,11,22] print(list(set(a)))
3、python2和python3的range(100) 區別
python 2返回列表，python 3返回迭代器，節約內存
4、列表[1,2,3,4,5]，請用map()函數輸出(1,4,9,16,25)，並使用列表推導式提取出大於10的屬，最終輸出[16,25]
a = [1,2,3,4,5]
b=map(lambda x:x*x,a)
res=[i for i in b if i >10]
print(res)
5、 python隨機生成整數，隨機小數，0-1之間小數
import random
import numpy
import string
res1=random.randint(1,100)#隨機整數
print(res1)
res2=numpy.random.randn(8)#8個隨機小數
print(res2)
res3=random.random()#0-1之間小數
print(res3)
res4= random.sample(range(1,100),9) #隨機生成9個 1-100之間的不重複整數
print(res4)
res5=numpy.random.choice(range(1000),9,replace=False) #隨機生成9個 1-1000之間的不重複整數，當需要生成的數很多時，效率比random.sample高很多
print(res5)
for i in range(10): #隨機生成10個，長度爲8的不重複字符串
str_list=random.sample(string.digits + string.ascii_letters,8)
random_str="".join(str_list)
print(random_str)
6、< div class=‘nam’>國家< /div> 用正則匹配出標籤裏面的內容(“國家”)，其中class的類型是不確定的
import re
res=re.findall(r'<div class=".*">(.*?)</div>',str)
print(res)#返回的是列表 ['國家']
re.match('',str) #只匹配字符串開頭，.span（）打印匹配到的索引，group(1)打印匹配到的值
re.search('',str) #匹配整個字符串，其它同match
7、數據表student有id,name,score,city字段，其中name中的名字可有重複，需要消除重複行，sql語句；
select distinct name from student
8、s = “ajldjlajfdljfddd”, 去重並從小到大排序輸出"adfjl
s = "ajldjlajfdljfddd"
s=list(set(s))
s.sort() #sort只對列表排序
print("".join(s)) #列表合併成爲字符串
s = "-+abacsdadjhfjab="
print(s.strip()) #刪除字符串左右兩邊的空字符
print(s.strip('-=+')) #刪除字符串左右兩邊的-+=號
new_s=s[:2]+s[3:] #刪除單個固定位置字符：切片+拼接
print(new_s)
res1=s.replace('ab',"") #刪除任意位置字符，ab,可以用於刪除字符串的字串
print(res1) #acsdadjhfj
res=s.translate(str.maketrans('','','ab')) #同時刪除多種不同的字符a和b
print(res) #第三個參數爲把參數直接替換爲None
#第一個參數爲要替換的字符組成的字符串，第二個參數爲映射，即把字符串中的a換成1，b換成2.
str.maketrans('aeiou','12345')
9、用lambda函數實現兩個數相乘
multipy=lambda x,y:x*y
print(multipy(5,4))
10、字典按照鍵 從小到大排序
import collections
dict = {"name":"西瓜","age":18,"city":"shenzhen","tel":12345}
s=sorted(dict.items(),key=lambda x: x[0])#dicts.items()返回列表嵌套的 字典的鍵值對元組 x[0]是按照鍵排序，x[1]是按照值排序
new_dic=collections.OrderedDict() #創建有序字典，保持排序後的順序
for i in s:
new_dic[i[0]]=i[1]
print(new_dic)
#方法二 用zip+字典推導式
dict = {"name":"zs","sex":"man", "city":"bj"}
foo=zip(dict.keys(),dict.values()) #字典轉列表嵌套元組 或dict.items()
b=sorted(foo,key=lambda x:x[0])
print(b)#[('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
new_dict={i[0]:i[1] for i in b} #字典推導式構造新字典
print(new_dict) #{'city': 'bj', 'name': 'zs', 'sex': 'man'}
11、利用collections庫的Counter方法統計字符串每個單詞出現的次數
from collections import Counter
a = "kjalfj;ldsjsfl;hdsllfdhg;lahfbl;hl;ahlf;h"
res=Counter(a) #以鍵值對方式 從大到小返回print(res)
12、字符串a = “not 404 found 張三 99 深圳”，每個詞中間都是空格，用正則過濾掉英文和數字，最終輸出"張三 深圳"
import re
a = "not 404 found 張三 99 深圳"
list_a=a.split(" ") #split對字符串切片，若後面有num參數，則分割num+1個子字符串 a.split(" ",3)
s=re.findall(r"\d+|[a-zA-Z]+",a) #\d匹配數字[0-9],+匹配前面一個表達式1次或多次，|連接多個匹配方式#s返回的是 匹配到的 英文和數字的列表
res=[i for i in list_a if i not in s] #過濾出漢字列表
print(" ".join(res))
13、filter方法求出列表所有奇數並構造新列表，a = [1,2,3,4,5,6,7,8,9,10]
# filter()函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。
# 接收兩個參數，第一個爲函數，第二個爲序列
a = [1,2,3,4,5,6,7,8,9,10]
def f(a):
return a%2==1 #篩選出奇數
new_list=filter(f,a) #返回的是裝飾器
print([i for i in new_list])
#方法二 列表生成式
new_list1=[i for i in a if i%2==1]
print(new_list1)
14、列表添加元素
a = [1,2,3,4,5,6,7,8,9,10]
a.append(11) #末尾添加
a.insert(3,11)#z指定位置索引爲3處添加11
a.extend([12,13]) #末尾追加列表
b=[14,15]
c=a+b #末尾追加 注意不是相加，等價於extend
15、用python刪除文件和linux命令刪除文件方法
import os
import shutil
root_dir=os.path.dirname(os.path.abspath(__file__))
os.remove(root_dir+'/rrrt.py') #刪除目錄下的文件os.rmdir(path)#刪除空目錄文件
shutil.rmtree(path) #刪除空目錄，也可以刪除含有文件或子目錄的目錄
print('目錄刪除後:%s'%os.listdir(root_dir))
rm -rf /var/log/ #刪除/var/log/下所有的文件、文件夾
rm -rf /var/log/access.log #刪除access.log文件
16、log日誌中，我們需要用時間戳記錄error，warning等的發生時間，請用datetime模塊打印當前時間戳"2018-04-01 11:38:54"
import datetime
print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') + ' 星期：'+str(datetime.datetime.now().isoweekday()))
17、統計列表中各個元素出現了多少次，並且取出重複次數最多的元素，或者按照元素重複次數進行元素排序
from collections import Counter
lst1=['hello','hello','world','test','test','test']
counter_obj=Counter(lst1)
print(counter_obj) # Counter({'test': 3, 'hello': 2, 'world': 1})
most= counter_obj.most_common() #不傳參，則返回所有元素# [('test', 3), ('hello', 2)]
print(counter_obj.most_common(2)) #在lst1中出現次數最多的前2個元素，並且降序排列# [('test', 3), ('hello', 2), ('world', 1)]
#根據元素大小升序排列
most.sort(key=lambda x:x[0]) #按key排序
print(most)
most.sort(key=lambda x:x[1],reverse=True) #按照出現次數降序排列
print(most)
18、[1, 2],[3, 4],[5, 6]一行代碼展開該列表，得出[1,2,3,4,5,6]
#列表生成式
a=[1,2],[3,4],[5,6]
x=[j for i in a for j in i]
print(x) #[1,2,3,4,5,6]
#還可以將列表轉成numpy矩陣，通過numpy的flatten()方法,將矩陣摺疊成一維的數組
import numpy as np
a=[1,2],[3,4],[5,6]
b=np.array(a).flatten().tolist()
print(b)
19、正則表達式匹配中，(. *)和(. *?)匹配區別？
(.*)是貪婪匹配，會把滿足正則的儘可能多的往後匹配
(.*？)是非貪婪匹配，會把滿足正則的儘可能少匹配
s = '<a>哈哈</a><a>呵呵</a>'
import re
res1=re.findall('<a>(.*)</a>',s) #貪婪匹配
print(res1) # ['哈哈</a><a>呵呵']
res2=re.findall('<a>(.*?)</a>',s) #非貪婪匹配
print(res2) #['哈哈', '呵呵']
20、x=“abc”,y=“def”,z=[“de”,“de”,“f”]分別求出x.join(y)和x.join(z)返回結果
x='abc'
y='def'
z=["de","de","f"]
# join()括號裏面的是可迭代對象，x插入可迭代對象中間，形成字符串
print(x.join(y)) #dabceabcf
print(x.join(z)) #deabcdeabcf
21、舉例說明異常模塊中try except else finally的相關意義
try...else 沒有捕獲到異常，執行else語句
try...finally 不管是否捕獲到異常，都執行finally語句
try:
content=input('請輸入1-100內的整數')
if not isinstance(int(content),int) or int(content)>100:
raise Exception("輸入的不是整數或數值大於100") #自定義拋出異常
except Exception as e:
print("輸入錯誤:%s" %e)
else:
print("輸入正確")
finally:
print("完畢")
22、python中交換兩個數的值：
a=3
b=2
a=a+b
b=a-b
a=a-b
#方法二
a,b=b,a
23、舉例說明zip()函數用法
# zip()函數在運算時，會以一個或多個序列（可迭代對象）作爲參數，返回一個元祖的列表。同時將這些序列中並排的元素配對
# zip()參數可以接受任何類型的序列，同時也可以有兩個以上的參數；當傳入的參數的長度不同時，zip能自動以最短序列長度爲準進行截取，獲得元祖
a=[1,2]
b=[3,4]
res1=[i for i in zip(a,b)]
print(res1) #[(1, 3), (2, 4)]
a=(1,2)
b=(3,4)
res2=[i for i in zip(a,b)]
print(res2) #[(1, 3), (2, 4)]
a='ab'
b='xyzer'
res3=[i for i in zip(a,b)]
print(res3) #[('a', 'x'), ('b', 'y')]
#創建字典：
a=zip(('a','b','c','d','e'),(1,2,3,4,5))
print(dict(a)) #{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
dic={k:random.randint(4,9) for k in ["a",'b','c','d']} #字典推導式
print(dict) ##{'a': 4, 'b': 8, 'c': 6, 'd': 5}
#求列表元素的最長公共前綴
lst=["flower","flowe","float","flat"]
result=""
sub_str=[i for i in zip(*lst)] #*lst爲解包，返回flower flowe float flat
for x in sub_str:
if len(set(x))==1:
result+=x[0]
print(result)
24、a = “張明 98分”，將98替換爲100
a = "張明 98分" #字符串的replace函數
res1=a.replace('98','100')
print(res1)#張明 100分
import re #使用正則表達式
res2=re.sub(r"\d+","100",a)
print(res2)#張明 100分
25、寫5條常用sql語句
show databases;
show tables;
select * from 表名;
delete from 表名 where id=5;
update student set gender=0,homework="OK" where id=6;
26、簡述mysql和redis區別
# redis：內存型非關係數據庫，數據保存在內存中，速度快
# mysql：關係型數據庫，數據保存在磁盤中，檢索的話，會有一定的IO操作，訪問速度相對慢
27、遇到bug如何處理
# 1、細節上的錯誤，通過print()打印，能執行到print(),說明一般上面的代碼沒有問題，分段檢測程序是否有問題；如果是js的話，可以aler或console.log
# 2、如果涉及一些第三方框架，會去查官方文檔或者一些技術博客
# 3. 對於bug的管理與歸類總結，一般測試將測試出的bug用teambin等bug管理工具進行記錄（vsts，testlink用例），然後回一條條進行修改，修改的過程# 也是理解業務邏輯和提高自己邏輯縝密性的方法，我都會收藏做一些筆記記錄#
4. 導包問題、城市定位多音字造成的顯示錯誤問題
28、 正則匹配，匹配日期2018-03-20#
url = 'https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1?dataRange=2018-03-20%7c2018-03-20%date&123464646464'
import re
res=re.findall(r"dataRange=(.*?)%7c(.*?)%",url)
print(res)
29、list = [2,3,5,4,9,6],從小到大排序，不許用sort，輸出[2,3,4,5,6,9]（sorted和快速排序法）
list = [2,3,5,4,9,6]
b=sorted(list)
print(b) #[2, 3, 4, 5, 6, 9]
def quickSort(list):
if len(list)<2:
return list
else:
basevalue=list[0]
greater=[i for i in list[1:] if i >basevalue]
equal=[i for i in list if i == basevalue]
less=[i for i in list[1:] if i < basevalue]
return quickSort(less)+equal+quickSort(greater)print(quickSort(list))
print(quickSort(list)) #[2, 3, 4, 5, 6, 9]
30、利用min()方法求出最小值，原列表刪除最小值，新列表加入最小值，遞歸調用獲取最小值的函數，反覆操作
list = [2,3,5,4,9,6]
new_list=[]
def get_min(list):
a=min(list)
list.remove(a)
new_list.append(a)
if len(list)>0:
get_min(list)
return new_list
new_list1=get_min(list)
print(new_list1) #[2, 3, 4, 5, 6, 9]
print(list) #[]
31、保留兩位小數
a='%0.2f'%1.335
print(a,type(a)) # 1.33 <class 'str'>
b=round(float(a),1) #返回浮點數的四捨五入值，保留1位小數
print(b,type(b))#1.3 <class 'float'>
備註：浮點數運算是不精確的，只能估算，精算時先乘以1W，相加後再除以1W
32、求三個方法打印結果
def fn(k,v,dict={}):
dict[k]=v
print(dict)
fn('one',1) #{'one': 1} 直接i將鍵值對傳給字典
fn('two',2) #{'one': 1, 'two': 2}因爲字典在內存中是可變數據類型，所以指向同一個地址，傳了新的參數後，會相當於給字典增加鍵值對
fn('three',3,{}) #{'three': 3}因爲傳了一個新字典，所有不再是原先默認參數的字典
33、列出常見的HTTP狀態碼和意義
200： OK
204：No Content 請求成功處理，沒有實體返回
301: 永久移動，資源已永久分配新的uri
302: 臨時移動
304：not modified
400：請求報文語法錯誤或參數錯誤
401: Unauthorized 當前請求需要用戶驗證或認證失敗
403: Forbidden 服務器已經理解請求，但是拒絕執行，注意與401的區別：身份驗證不能提供任何幫助，且請求不一樣被重複提交
404:請求失敗，not found
500：服務器故障或web應用故障
503：服務器超負載或停機維護
34、分別從前端、後端、數據庫闡述web項目的性能優化
前端優化：
1、減少http請求、例如製作精靈圖
2、html和CSS放在頁面上部，javascript放在頁面下面，因爲js加載比HTML和Css加載慢，所以要優先加載html和css,以防頁面顯示不全，性能差，也影響用戶體驗
後端優化：
1、緩存存儲讀寫次數高，變化少的數據，比如網站首頁的信息、商品的信息等。應用程序讀取數據時，一般是先從緩存中讀取，如果讀取不到或數據已失效，再訪問磁盤數據庫，並將數據再次寫入緩存。redis
2、異步方式，如果有耗時操作，可以採用異步，比如MQ
3、代碼優化，避免循環和判斷次數太多，如果多個if else判斷，優先判斷最有可能先發生的情況
數據庫優化：1、如有條件，數據可以存放於redis，讀取速度快
2、建立索引、外鍵等
35、使用pop和del刪除字典中的"name"字段，dic={“name”:“zs”,“age”:18}
dict = {"name": "zs", "age": 18}
dict.pop("name")
del dict['name']
36、dict（）創建字典新方法
s=dict([['name','zs'],['age',18]])#列表嵌套列表
print(s) # {'name': 'zs', 'age': 18}
s1=dict([('name','zs'),('age',18)]) #列表嵌套元組
print(s1)#{'name': 'zs', 'age': 18}
A=zip(('a','b','c','d','e'),(1,2,3,4,5)) #zip創建字典
A0=dict(A) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
A1=range(10)
A2=[i for i in A1 if i in A0] #[] A0的鍵abcde不在range(10)內
A3=[A0[s] for s in A0] #返回字典的值[1,2,3,4,5]
37、簡述同源策略
需同時滿足：
1、協議相同(http和https是不同的)
2、域名完全相同
3、端口相同
38、簡述cookie和session的區別
1、session在服務器端，cookie在客戶端
2、session的運行依賴session id，session 的運行依賴 session id，而 session id 是存在 cookie 中的，也就是說，如果瀏覽器禁用了 cookie ，同時 session 也會失效，存儲Session時，鍵與Cookie中的sessionid相同，值是開發人員設置的鍵值對信息，進行了編碼，過期時間由開發人員設置
3、cookie安全性比session差
39、簡述多線程、多進程
進程：
1、操作系統進行資源分配和調度的基本單位，多個進程之間相互獨立
2、穩定性好，如果一個進程崩潰，不影響其他進程，但是進程消耗資源大，開啓的進程數量有限制
線程：
1、CPU進行資源分配和調度的基本單位，線程是進程的一部分，是比進程更小的能獨立運行的基本單位，一個進程下的多個線程可以共享該進程的所有資源
2、如果IO操作密集，則可以多線程運行效率高，缺點是如果一個線程崩潰，都會造成進程的崩潰
應用：
IO密集的用多線程，在用戶輸入，sleep 時候，可以切換到其他線程執行，減少等待的時間
CPU密集的用多進程，因爲假如IO操作少，用多線程的話，因爲線程共享一個全局解釋器鎖，當前運行的線程會霸佔GIL，其他線程沒有GIL，就不能充分利用多核CPU的優勢
40、python 中什麼元素爲假， 列表的複製
0、空字符串、空列表、空字典、空元組、None、False
a=['xx','yy','zz']
b=[] #使用append方法依次添加
for i in a:
b.append(i)
print(b)
c=a.copy() #使用內置的copy方法
print(c)
d=a[:] #切片
print(d)
e=a #不能直接複製，a和b是一樣的（id一樣），做增刪改會相互影響
print(e)
41、python中copy和deepcopy的區別
# 不可變數據類型：數值、字符串、元組的深拷貝和淺拷貝 和賦值運算= 是一樣的，id也是一樣；不會改變拷貝前和拷貝後的值，相當於重新定義了一個變量；
# 可變數據類型：列表、字典、集合，copy會改變拷貝前和拷貝後的值，deepcopy不會改變拷貝後的值
import copy
a = [11, 12]
b = [21, 22]
num = 555
c = [a, b,num] #[[11, 12], [21, 22], 555]
c1=copy.copy(c) #[[11, 12], [21, 22], 555]
a[0]=16 #可變元素修改，會修改c和c1的值
c[2]=666 #不可變元素修改，只會修改原來的值，複製後的值不會修改
num=777 #不會改變c1和c2的值，相當於重新定義了一個變量num
print(c) #[[16, 12], [21, 22], 666]
print(c1) #[[16, 12], [21, 22], 555]
#c1=copy.deepcopy(c)
#print(c1) #[[11, 12], [21, 22], 555]
42、對foo排序，輸出結果爲=[0,2,4,8,8,9,-2,-4,-4,-5,-20],正數從小到大，負數從大到小
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
a=sorted(foo,key=lambda x:(x<0,abs(x)))
print(a) #[0,2,4,8,8,9,-2,-4,-4,-5,-20]
43、列表排序
# 列表嵌套字典的排序，分別根據年齡和姓名排序
foo = [{"name":"zs","age":19},{"name":"II","age":54},{"name":"wa","age":17},{"name":"df","age":23}]
a=sorted(foo,key=lambda x:x['name'])
b=sorted(foo,key=lambda x:x['age'])
print(a)#[{'name': 'II', 'age': 54}, {'name': 'df', 'age': 23}, {'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}]
print(b)#[{'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}, {'name': 'df', 'age': 23}, {'name': 'II', 'age': 54}]
#列表嵌套元祖，分別根據字母和數字排序
foo = [("age",19), ("ll",54), ("wa",17), ("df",23)]
a=sorted(foo,key=lambda x:x[0])#字母
b=sorted(foo,key=lambda x:x[1])#數字
print(a)#[('age', 19), ('df', 23), ('ll', 54), ('wa', 17)]
print(b)#[('wa', 17), ('age', 19), ('df', 23), ('ll', 54)]
#列表嵌套列表，年齡數字相同怎麼辦？
foo = [["age",19], ["ll",54], ["wa",17], ["df",23],["xf",23]]
a = sorted(foo, key=lambda x:(x[1],x[0])) # 添加參數，按字母排序
print(a)#[['wa', 17], ['age', 19], ['df', 23], ['xf', 23], ['ll', 54]]
44、根據字符串長度排序
s=['ab','abc','a','djhfdh']
b=sorted(s,key=lambda x:len(x))
print(b)
#方法二
s.sort(key=len)
print(s) #['a', 'ab', 'abc', 'djhfdh']
45、舉例說明SQL注入和解決方法
當以字符串格式化書寫方式的時候，如果用戶輸入的有;+SQL語句，後面的SQL語句會執行，比如例子中的SQL注入會刪除數據庫demo
input_name = 'zs'
sql = 'select * from demo where name="%s"' %(imput_name)
print('正常的SQL語言', sql)
# input_name = 'zs;drop database demo'
sql = 'select * from demo where name="%s"' %(imput_name)
print('SQL注入語句', sql)
# 解決方法：通過傳參數方式解決SQL注入
find_name = input("請輸入物品名稱：")
# 創建Connection連接
conn = connect(host='localhost',port=3306,user='root',password='mysql',database='jing_dong',charset='utf8')
# 獲得Cursor對象
cs1 = conn.cursor()
# 安全的方式
# 構造參數列表
params = [find_name]
# 執行select語句，並返回受影響的行數：查詢所有數據
count = cs1.execute('select * from demo where name="%s"' ,params)
# 注意：
# 如果要是有多個參數，需要進行參數化
# 那麼params = [數值1, 數值2....]，此時sql語句中有多個%s即可
# 打印受影響的行數
print(count)
46、s =‘info:xiaoZhang 33 shandong’,用正則切分字符串輸出[‘info’,‘xiaoZhang’，‘33’，‘shandong’]
s ='info:xiaoZhang 33 shandong'
import re
res=re.split(r':| ',s)
print(res)
47、正則匹配以163.com結尾的郵箱
email_list = ['[email protected]','[email protected]','[email protected]']
import re
for email in email_list:
res=re.match(r'[\w]{4,20}@163\.com$',email)
if res:
print('{}是符合規則的郵箱地址，匹配的結果是：{}'.format(email,res.group()))
else:
print('{} 不符合要求'.format(email))
48、遞歸求和 完成1+2+3+…+10的和
def get_sum(num):
if num >=1:
res=num + get_sum(num-1)
else:
res=0
return res
res=get_sum(10)
print(res) #55
49、python字典和json字符串相互轉化方法
import json
dic = {"name":"zs"}
res=json.dumps(dic)
print(res,type(res)) #字典轉字符串 {"name": "zs"} <class 'str'>
ret=json.loads(res)
print(ret,type(ret))#字符串轉字典 {'name': 'zs'} <class 'dict'>
50、正則匹配不是以4和7結尾的手機號
tels = ['13100001234','18912344321','10086','18800007777']
import re
for tel in tels:
ret = re.match('1\d{9}[0-3,5-6,8-9]',tel) # \d 匹配一個數字字符 {9} 匹配確定的N次 [0-3,5-6,8-9] 匹配除4 7以外的數字#
if ret:
print('想要的結果',ret.group())
else:
print('{} 不是想要的手機號'.format(ret))
51、簡述python引用計數機制
# python垃圾回收主要以引用計數爲主，標記-清除和分代清除爲輔的機制，其中標記-清除和分代回收主要是爲了處理循環引用的難題
# 引用計數算法
# 當有1個變量保存了對象的引用時，此對象的引用計數就會加1
# 當使用del刪除變量指向的對象時，如果對象的引用計數不爲1，比如3，那麼此時只會讓這個引用計數減1，即變爲2，當再次調用del時，變爲1，
# 如果再調用1次del，此時會真的把對象進行刪除
52、求兩個列表的交集、差集、並集
a = [1, 2, 3, 4]
b = [4, 3, 5, 6]
jj1 = [i for i in a if i in b] # 在a中的i，並且也在b中，就是交集print('交集', jj1) # [3, 4]
jj2 = list(set(a).intersection(set(b)))
print('交集', jj2) # [3, 4]
bj1 = list(set(a).union(set(b))) # 並集用union方法print('並集', bj1) # [1, 2, 3, 4, 5, 6]
cj1 = list(set(a).difference(set(b))) # a中有而b中沒有的
cj2 = list(set(b).difference(set(a))) # b中有而a中沒有的
print('差集', cj1) # [1, 2]
print('差集', cj2) # [5, 6]
53、正則表達式匹配第一個URL
s = '<img src="https://image.playerauctions.com/GameOfferbanner/20180816020146_10_1_anner2.jpg" ' \ 'class="account-fifa-coins" alt="wow eu gold">,' \ '<img alt=" Lowest Price. Anywhere you see lower Price, Any Items, Message me for Discount - All Servers delivery!" ' \ 'src="https://image.playerauctions.com/P/S/20190308/a6b42434a9bc94b74cc5e64bf0137317.jpg">'
import re
res=re.findall(r'https://.*?\.jpg',s)[0]# 提取的是一個列表
print(res)
res2=re.search(r'https://.*?\.jpg',s)
print(res2.group()) #search需要加group()提取
54、Linux重定向> 和>>
# Linux命令重定向 >和 >>
# Linux允許將命令執行結果 重定向到一個文件
# 將本應顯示在終端的內容，輸出/追加 到指定文件中
# > 表示輸出，會覆蓋文件原有的內容
# >> 表示追加，會將內容追加到已有文件的末尾
# 將 echo 輸出的信息保存到 1.txt 裏 echo Hello Python > 1.txt
# 將 echo 輸出的信息追加到 1.txt 文件的末尾 echo Hello Python >> 1.txt
55、r、r+、rb、rb+文件打開模式區別
56、HTTP中請求get個post區別
Get產生一個TCP包，瀏覽器把http header和data一起發送，服務器響應200
POST產生2個TCP包，瀏覽器先把 http header 發送，瀏覽器返回100 continue， 瀏覽器再次發送 data，服務器響應200 ok
57、 python讀取excel方法
import pandas as pd
df = pd.read_excel('33.xlsx')
print(df)
58、給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和爲目標值的那 兩個 整數，並返回他們的數組下標。你可以假設每種輸入只會對應一個答案。但是，你不能重複利用這個數組中同樣的元素。二分查找
def halfSearch(nums, target):
low=0 #起始索引
high=len(nums)#末索引
while low<high:
mid=int((low+high) /2) #中間索引
guess=nums[mid] #中間索引的值
if guess==target:
return mid
if guess > item:
high=mid-1
else:
low=mid+1
return None
nums=[2, 7, 11, 15]
target=11
print(halfSearch(nums,target)) #2
59、在當前目錄以及當前目錄的所有子目錄下查找文件名包含指定字符串的文件，並且打印出相對路徑
import os
def search_file(dir, sname=None):
if sname==None:
return os.listdir(dir)
if sname in os.path.split(dir)[1]:#檢驗文件名裏是否包含sname
print(os.path.relpath(dir))#打印相對路徑，相對指相對於當前路徑
if os.path.isfile(dir): # 如果傳入的dir直接是一個文件目錄 他就沒有子目錄，就不用再遍歷它的子目錄了
return None
for dire in os.listdir(dir): #遍歷子目錄 這裏的dire爲當前文件名
search_file(os.path.join(dir,dire),sname) ##jion一下就變成了當前文件的絕對路徑
dir=os.getcwd() #獲取當前路徑
print(search_file(dir,'.lnk'))
60、簡述樂觀鎖和悲觀鎖
悲觀鎖
總是假設最壞的情況，每次去拿數據的時候都認爲別人會修改，所以每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖（共享資源每次只給一個線程使用，其它線程阻塞，用完後再把資源轉讓給其它線程）。
傳統的關係型數據庫裏邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。
悲觀鎖使用場景
比較適合寫入操作比較頻繁的場景，如果出現大量的讀取操作，每次讀取的時候都會進行加鎖，這樣會增加大量的鎖的開銷，降低了系統的吞吐量。
樂觀鎖
總是假設最好的情況，每次去拿數據的時候都認爲別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，可以使用版本號機制和CAS算法實現。
樂觀鎖適用於多讀的應用類型，這樣可以提高吞吐量，像數據庫提供的類似於write_condition機制，其實都是提供的樂觀鎖。
樂觀鎖使用場景
比較適合讀取操作比較頻繁的場景，如果出現大量的寫入操作，數據發生衝突的可能性就會增大，爲了保證數據的一致性，應用層需要不斷的重新獲取數據，這樣會增加大量的查詢操作，降低了系統的吞吐量。