51、正則比對，比對日期2018-03-20？
url='https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&dateType=recent1&device=1&token=ff25b109b&_=1521595613462'
仍有同學問正則，其實比對并不難，提取一段特征語句，用（.*?）比對即可。
import re
url='https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&dateType=recent1&device=1&token=ff25b109b&_=1521595613462'
ret = re.findall(r"dateRange=(.+?)%7C(.+?)&", url)
print(ret)
52、list=[2,3,5,4,9,6]，從小到大排序，不許用sort，輸出[2,3,4,5,6,9]？
利用min()方法求出最小值，原清單删除最小值，新清單加入最小值，遞歸調用擷取最小值的函數，反複操作。
list = [2, 3, 5, 4, 9, 6]
new_list = []
def get_min(L):
# 擷取清單最小值
x = min(L)
# 删除最小值
L.remove(x)
# 将最小值加入到新清單
new_list.append(x)
# 判斷原清單中是否還有值
# 有值，進行遞歸，否則傳回新清單
if len(L):
get_min(L)
return new_list
new_list = get_min(list)
print(new_list)
53、寫一個單列模式
單例模式複習：python中實作單例模式
因為建立對象時__new__方法執行，并且必須return 傳回執行個體化出來的對象所cls.__instance是否存在，不存在的話就建立對象，存在的話就傳回該對象，來保證隻有一個執行個體對象存在（單列），列印ID，值一樣，說明對象同一個。
class Singleton(object):
__instance = None
def __new__(cls, age, name):
# 如果類屬性__instance的值為None.
# 那麼就建立一個對象，并且指派為這個對象的引用，保證下次調用這個方法時
# 能夠知道之前已經建立過對象了，這樣就保證了隻有一個對象
if not cls.__instance:
cls.__instance = object.__new__(cls)
return cls.__instance
a = Singleton(18, "Apollo")
b = Singleton(8, "Apollo")
print(id(a)) # 42960880
print(id(b)) # 42960880
a.age = 20
print(b.age) # 20
54、保留兩位小數？
題目本身隻有a="%.03f"%1.3335，讓計算a的結果，為了擴充保留小數的思路，提供round方法（數值，保留位數）。
# 保留兩位小數
a = "%.03f" % 1.3335
print(a, type(a)) # 1.333 <class 'str'>
b = round(float(a), 1)
print(b) # 1.3
b = round(float(a), 2)
print(b) # 1.33
55、求三個方法列印結果？
def fn(k, v, dict={}):
dict[k] = v
print(dict)
fn("one", 1) # {'one': 1}
fn("two", 2) # {'one': 1, 'two': 2}
fn("three", 3, {}) # {'three': 3}
fn("one",1）直接将鍵值對傳給字典；
fn("two",2)因為字典在記憶體中是可變資料類型，是以指向同一個位址，傳了新的額參數後，會相當于給字典增加鍵值對；
fn("three",3,{})因為傳了一個新字典，是以不再是原先預設參數的字典。
56、列出常見的狀态碼和意義？
了解更多狀态碼：常見的狀态碼：HTTP Status Code
200 OK
請求正常處理完畢
204 No Content
請求成功處理，沒有實體的主體傳回
206 Partial Content
GET範圍請求已成功處理
301 Moved Permanently
永久重定向，資源已永久配置設定新URI
302 Found
臨時重定向，資源已臨時配置設定新URI
303 See Other
臨時重定向，期望使用GET定向擷取
304 Not Modified
發送的附帶條件請求未滿足
307 Temporary Redirect
臨時重定向，POST不會變成GET
400 Bad Request
請求封包文法錯誤或參數錯誤
401 Unauthorized
需要通過HTTP認證，或認證失敗
403 Forbidden
請求資源被拒絕
404 Not Found
無法找到請求資源（伺服器無理由拒絕）
500 Internal Server Error
伺服器故障或Web應用故障
503 Service Unavailable
伺服器超負載或停機維護
57、分别從前端、後端、資料庫闡述web項目的性能優化？
前端優化：
- 減少http請求、例如制作精靈圖。
- html和CSS放在頁面上部，javascript放在頁面下面，因為js加載比HTML和Css加載慢，是以要優先加載html和css，以防頁面顯示不全，性能差，也影響使用者體驗差。
端優化：
- 緩存存儲讀寫次數高，變化少的資料，比如網站首頁的資訊、商品的資訊等。應用程式讀取資料時，一般是先從緩存中讀取，如果讀取不到或資料已失效，再通路磁盤資料庫，并将資料再次寫入緩存。
- 異步方式，如果有耗時操作，可以采用異步，比如celery。
- 代碼優化，避免循環和判斷次數太多，如果多個if else判斷，優先判斷最有可能先發生的情況。
資料庫優化：
- 如有條件，資料可以存放于redis，讀取速度快。
- 建立索引、外鍵等。
58、使用pop和del删除字典中的"name"字段，dic={"name":"zs","age":18}？
dic = {"name": "zs", "age": 18}
dic.pop("name")
print(dic)
dic = {"name": "zs", "age": 18}
del dic["name"]
print(dic)
59、列出常見MYSQL資料存儲引擎？
InnoDB：支援事務處理，支援外鍵，支援崩潰修複能力和并發控制。如果需要對事務的完整性要求比較高（比如銀行），要求實作并發控制（比如售票），那選擇InnoDB有很大的優勢。如果需要頻繁的更新、删除操作的資料庫，也可以選擇InnoDB，因為支援事務的送出（commit）和復原（rollback）。
MyISAM：插入資料快，空間和記憶體使用比較低。如果表主要是用于插入新記錄和讀出記錄，那麼選擇MyISAM能實作處理高效率。如果應用的完整性、并發性要求比 較低，也可以使用。
MEMORY：所有的資料都在記憶體中，資料的處理速度快，但是安全性不高。如果需要很快的讀寫速度，對資料的安全性要求較低，可以選擇MEMOEY。它對表的大小有要求，不能建立太大的表。是以，這類資料庫隻使用在相對較小的資料庫表。
60、計算代碼運作結果。
A = zip(("a", "b", "c", "d", "e"), (1, 2, 3, 4, 5))
A0 = dict(A)
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
print(A) # <zip object at 0x00000000028CD8C8>
print(list(zip(("a", "b", "c", "d", "e"), (1, 2, 3, 4, 5))))
# [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
print("A0", A0) # A0 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(A1) # range(0, 10)
for i in A1:
print(i, end=", ") # 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
print() # 換行
print(A2) # []
print(A3) # [1, 2, 3, 4, 5]
dict()建立字典新方法
a = [('a', 1), ('b', 2), ('c', 3)]
b = dict(a)
print(b)
a = [['a', 1], ['b', 2], ['c', 3]]
b = dict(a)
print(b)
61、簡述同源政策？
同源政策需要同時滿足以下三點要求：
1）協定相同
http:www.test.com與https:www.test.com 不同源——協定不同
2）域名相同
http:www.test.com與http:www.admin.com 不同源——域名不同
3）端口相同
http:www.test.com與http:www.test.com:8081 不同源——端口不同
隻要不滿足其中任意一個要求，就不符合同源政策，就會出現“跨域”
62、簡述cookie和session的差別？
1、session 在伺服器端，cookie 在用戶端（浏覽器）。
2、session 的運作依賴 session id，而 session id 是存在 cookie 中的，也就是說，如果浏覽器禁用了 cookie ，同時 session 也會失效，存儲Session時，鍵與Cookie中的session id相同，值是開發人員設定的鍵值對資訊，進行了base64編碼，過期時間由開發人員設定。
3、cookie安全性比session差。
63、簡述多線程、多程序？
程序：
- 作業系統進行資源配置設定和排程的基本機關，多個程序之間互相獨立。
- 穩定性好，如果一個程序崩潰，不影響其他程序，但是程序消耗資源大，開啟的程序數量有限制。
線程：
- CPU進行資源配置設定和排程的基本機關，線程是程序的一部分，是比程序更小的能獨立運作的基本機關，一個程序下的多個線程可以共享該程序的所有資源。
- 如果IO操作密集，則可以多線程運作效率高，缺點是如果一個線程崩潰，都會造成程序的崩潰。
應用：
- IO密集的用多線程，在使用者輸入，sleep 時候，可以切換到其他線程執行，減少等待的時間。
- CPU密集的用多程序，因為假如IO操作少，用多線程的話，因為線程共享一個全局解釋器鎖，目前運作的線程會霸占GIL，其他線程沒有GIL，就不能充分利用多核CPU的優勢。
64、簡述any()和all()方法？
any()：隻要疊代器中有一個元素為真就為真。
all()：疊代器中所有的判斷項傳回都是真，結果才為真。
附加題：python中什麼元素為假？
答案：（0、空字元串、空清單、空字典、空元組、None、 False）
測試all()和any()方法
# 0、空字元串、空清單、空字典、空元組、None、 False
if any([0, "", [], {}, (), None, False]):
print("[0、空字元串、空清單、空字典、空元組、None、 False]至少有一個為真")
else:
print("[0、空字元串、空清單、空字典、空元組、None、 False]均為假")
if all([1, "0", [0], {0}, (0,), True]):
print('[1, "0", [0], {0}, (0,), True]均為真')
else:
print('[1, "0", [0], {0}, (0,), True]至少有一個為假')
"""
[0、空字元串、空清單、空字典、空元組、None、 False]均為假
[1, "0", [0], {0}, (0,), True]均為真
"""
65、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什麼異常？
IOError：輸入輸出異常
AttributeError：試圖通路一個對象沒有的屬性
ImportError：無法引入子產品或包，基本是路徑問題
IndentationError：文法錯誤，代碼沒有正确的對齊
IndexError：下标索引超出序列邊界
KeyError：試圖通路你字典裡不存在的鍵
SyntaxError：Python代碼邏輯文法出錯，不能執行
NameError：使用一個還未賦予對象的變量
66、python中copy和deepcopy差別？
複習：Python 提高 - 1
1、複制不可變資料類型
不管copy還是deepcopy，都是同一個位址，當淺複制的值是不可變對象（數值，字元串，元組）時和=“指派”的情況一樣，對象的id值與淺複制原來的值相同。
2、複制的值是可變對象（清單和字典）
淺拷貝copy有兩種情況：
第一種情況：複制的 對象中無 複雜 子對象，原來值的改變并不會影響淺複制的值，同時淺複制的值改變也并不會影響原來的值。原來值的id值與淺複制原來的值不同。
第二種情況：複制的對象中有 複雜 子對象 （例如清單中的一個子元素是一個清單）， 改變原來的值 中的複雜子對象的值 ，會影響淺複制的值。
深拷貝deepcopy：完全複制獨立，包括内層清單和字典。
67、列出幾種魔法方法并簡要介紹用途？
複習：python 提高 - 2
__init__：對象初始化方法
__new__：建立對象時候執行的方法，單列模式會用到
__str__：當使用print輸出對象的時候，隻要自己定義了__str__(self)方法，那麼就會列印從在這個方法中return的資料
__del__：删除對象執行的方法
68、C:\Users\ry-wu.junya\Desktop>python 1.py 22 33指令行啟動程式并傳參，print(sys.argv)會輸出什麼資料？
檔案名和參數構成的清單
69、請将 [i for i in range(3)] 改成生成器？
生成器是特殊的疊代器
1、清單表達式的 [] 改為 () 即可變成生成器；
2、函數在傳回值得時候出現yield就變成生成器，而不是函數了；
中括号換成小括号即可，有沒有驚呆了
a = [i for i in range(3)]
print(type(a)) # <class 'list'>
print(a) # [0, 1, 2]
a = (i for i in range(3))
print(type(a)) # <class 'generator'>
print(a) # <generator object <genexpr> at 0x0000000002167258>
70、a = " hehheh "，去除首尾空格？
71、舉例sort和sorted對清單排序，list=[0,-1,3,-10,5,9]？
sort 與 sorted 差別：
sort 是應用在 list 上的方法，sorted 可以對所有可疊代的對象進行排序操作。
list 的 sort 方法傳回的是對已經存在的清單進行操作，而内建函數 sorted 方法傳回的是一個新的 list，而不是在原來的基礎上進行的操作。
# 對清單排序
list = [0, -1, 3, -10, 5, 9]
list.sort(reverse=False)
print("list.sort在list的基礎上修改，無傳回值：", list)
# list.sort在list的基礎上修改，無傳回值： [-10, -1, 0, 3, 5, 9]
list = [0, -1, 3, -10, 5, 9]
ret = sorted(list, reverse=False)
print("sorted有傳回值，是新的list，傳回值：", ret)
# sorted有傳回值，是新的list，傳回值： [-10, -1, 0, 3, 5, 9]
72、對list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]，使用lambda函數從小到大排序？
sorted 文法：
sorted(iterable, key=None, reverse=False)
參數說明：
- iterable -- 可疊代對象。
- key -- 主要是用來進行比較的元素，隻有一個參數，具體的函數的參數就是取自于可疊代對象中，指定可疊代對象中的一個元素來進行排序。
- reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（預設）。
foo = [-5, 8, 0, 4, 9, -4, -20, -2, 8, 2, -4]
a = sorted(foo, key=lambda x: x)
print(a) # [-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9]
73、使用lambda函數對list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]，輸出結果為[0,2,4,8,8,9,-2,-4,-4,-5,-20]，正數從小到大，負數從大到小？
（傳兩個條件，x<0和abs(x)）
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]
附加題：
s = 'asdf234GDSdsf23' # 排序：小寫-大寫-奇數-偶數
print("".join(sorted(s, key=lambda x: (x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x))))
原理：先比較元組的第一個值，FALSE<TRUE，如果相等就比較元組的下一個值，以此類推。
先看一下Boolean value 的排序：
print(sorted([True, False])) # 結果[False, True]
Boolean 的排序會将 False 排在前，True排在後。
x.isdigit() 的作用是把數字放在後邊，字母放在前邊。
x.isdigit() and int(x) % 2 == 0的作用是保證奇數在前，偶數在後。
x.isupper()的作用是在前面基礎上，保證字母小寫在前大寫在後。
最後的x表示在前面基礎上，對所有類别數字或字母排序。
最後結果：addffssDGS33224
74、清單嵌套字典的排序，分别根據年齡和姓名排序？
foo = [{"name":"zs","age":19},{"name":"ll","age":54},{"name":"wa","age":17},{"name":"df","age":23}]
foo = [{"name": "zs", "age": 19}, {"name": "ll", "age": 54}, {"name": "wa", "age": 17}, {"name": "df", "age": 23}]
print(sorted(foo, key=lambda x: x["name"], reverse=False)) # 按姓名從小到大排序
# [{'name': 'df', 'age': 23}, {'name': 'll', 'age': 54}, {'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}]
print(sorted(foo, key=lambda x: x["age"], reverse=True)) # 按年齡從大到小排序
# [{'name': 'll', 'age': 54}, {'name': 'df', 'age': 23}, {'name': 'zs', 'age': 19}, {'name': 'wa', 'age': 17}]
75、清單嵌套元組，分别按字母和數字排序？
foo = [("zs", 19), ("ll", 54), ("wa", 17), ("df", 23)]
print(sorted(foo, key=lambda x: x[0], reverse=False)) # 按字母從小到大排序
# [('df', 23), ('ll', 54), ('wa', 17), ('zs', 19)]
print(sorted(foo, key=lambda x: x[1], reverse=True)) # 按數字從大到小排序
# [('ll', 54), ('df', 23), ('zs', 19), ('wa', 17)]
76、清單嵌套清單排序，年齡數字相同怎麼辦？
foo = [["zs", 19], ["ll", 54], ["es", 23], ["wx", 23], ["wa", 17], ["df", 23]]
print(sorted(foo, key=lambda x: x[0], reverse=False)) # 按字母從小到大排序
# [['df', 23], ['es', 23], ['ll', 54], ['wa', 17], ['wx', 23], ['zs', 19]]
print(sorted(foo, key=lambda x: x[1], reverse=True)) # 按數字從大到小排序
# [['ll', 54], ['es', 23], ['wx', 23], ['df', 23], ['zs', 19], ['wa', 17]]
print(sorted(foo, key=lambda x: (x[1], x[0]), reverse=True)) # 按數字從大到小排序，年齡相同可以參加參數，按字母進行排序
# [['ll', 54], ['wx', 23], ['es', 23], ['df', 23], ['zs', 19], ['wa', 17]]
77、根據鍵對字典排序（方法一，zip函數）？
dic = {"name": "Apollo", "gender": "man", "height": 1.82, "city": "bj"}
foo = zip(dic.keys(), dic.values())
foo = [x for x in foo]
print("字典轉成清單嵌套元組", foo)
# 字典轉成清單嵌套元組 [('name', 'Apollo'), ('gender', 'man'), ('height', 1.82), ('city', 'bj')]
b = sorted(foo, key=lambda x: x[0])
print("根據鍵排序", b)
# 根據鍵排序 [('city', 'bj'), ('gender', 'man'), ('height', 1.82), ('name', 'Apollo')]
new_dic = {i[0]: i[1] for i in b}
print("字典推導式構造新字典", new_dic)
# 字典推導式構造新字典 {'city': 'bj', 'gender': 'man', 'height': 1.82, 'name': 'Apollo'}
78、根據鍵對字典排序（方法二，不用zip)？
有沒有發現dic.items和zip(dic.keys(),dic.values())都是為了構造清單嵌套字典的結構，友善後面用sorted()構造排序規則
dic = {"name": "Apollo", "gender": "man", "height": 1.82, "city": "bj"}
b = sorted(dic.items(), key=lambda x: x[0])
print("根據鍵排序", b)
# 根據鍵排序 [('city', 'bj'), ('gender', 'man'), ('height', 1.82), ('name', 'Apollo')]
new_dic = {i[0]: i[1] for i in b}
print("字典推導式構造新字典", new_dic)
# 字典推導式構造新字典 {'city': 'bj', 'gender': 'man', 'height': 1.82, 'name': 'Apollo'}
79、清單推導式、字典推導式、生成器？
import random
td_list = [i for i in range(10)]
print("清單推導式", td_list, type(td_list))
# 清單推導式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
td_dict = {k: random.randint(2, 7) for k in ("a", "b", "c", "d")}
print("字典推導式", td_dict, type(td_dict))
# 字典推導式 {'a': 3, 'b': 2, 'c': 3, 'd': 7} <class 'dict'>
get_list = (i for i in range(10)) # 将清單推導式的“[]”改為“()”
print("生成器", get_list, type(get_list))
# 生成器 <generator object <genexpr> at 0x00000000026A15C8> <class 'generator'>
80、最後出一道檢驗題目，根據字元串長度排序，看排序是否靈活運用？
a = ["ab", "abc", "a", "defg"]
b = sorted(a, key=lambda x: len(x))
print(a, "排序後", b)
# ['ab', 'abc', 'a', 'defg'] 排序後 ['a', 'ab', 'abc', 'defg']
a.sort(key=len)
print(a)
# ['a', 'ab', 'abc', 'defg']
81、舉例說明SQL注入和解決辦法？
當以字元串格式化書寫方式的時候，如果使用者輸入的有;+SQL語句，後面的SQL語句會執行，比如例子中的SQL注入會删除資料庫demo
# SQL注入
# 假如一條SQL語句是：input_con
input_con = 'zs'
sql = 'select * from demo where name="%s"' % input_con
print("正常SQL語句", sql)
# 正常SQL語句 select * from demo where name="zs"
input_con = 'zs";drop database demo;"'
sql = 'select * from demo where name="%s"' % input_con
print("注入SQL語句", sql)
# 注入SQL語句 select * from demo where name="zs";drop database demo;""
解決方式：通過傳參數方式解決SQL注入
# 通過參數化方式解決
params = [input_con]
count = cs1.execute('select * from demo where name=%s', params)
82、s="info:xiaoZhang 33 shandong"，用正則切分字元串輸出['info', 'xiaoZhang', '33', 'shandong']？
|表示或，根據冒号或者空格切分
import re
s = "info:xiaoZhang 33 shandong"
res = re.split(r":| ", s)
print(res)
# ['info', 'xiaoZhang', '33', 'shandong']
83、正則比對以163.com結尾的郵箱？
import re
email_list = ["[email protected]", "[email protected]", "[email protected]"]
for email in email_list:
ret = re.match(r"\[email protected]$", email)
if ret:
print("%s 是163郵箱，比對後的結果是 %s" % (email, ret.group()))
else:
print("%s 不是163郵箱" % email)
"""
[email protected] 是163郵箱，比對後的結果是 [email protected]
[email protected] 不是163郵箱
[email protected] 不是163郵箱
"""
84、遞歸求和？
# 遞歸完成1+2+3+4+5+...+n
def add_num(num):
if num > 0:
return num + add_num(num - 1)
return 0
res = add_num(10)
print(res)
85、Python字典和json字元串互相轉化方法？
json.dumps()字典轉json字元串，json.loads()json轉字典
import json
dic = {"name": "zs", "age": 19}
ret = json.dumps(dic)
print(ret, type(ret)) # {"name": "zs", "age": 19} <class 'str'>
ret = json.loads(ret)
print(ret, type(ret)) # {'name': 'zs', 'age': 19} <class 'dict'>
86、MyISAM 與 InnoDB 差別？
1、InnoDB 支援事務，MyISAM 不支援，這一點是非常之重要。事務是一種高
級的處理方式，如在一些列增删改中隻要哪個出錯還可以復原還原，而 MyISAM
就不可以了；
2、MyISAM 适合查詢以及插入為主的應用，InnoDB 适合頻繁修改以及涉及到
安全性較高的應用；
3、InnoDB 支援外鍵，MyISAM 不支援；
4、對于自增長的字段，InnoDB 中必須包含隻有該字段的索引，但是在 MyISAM
表中可以和其他字段一起建立聯合索引；
5、清空整個表時，InnoDB 是一行一行的删除，效率非常慢。MyISAM 則會重
建表。
87、統計字元串中某字元出現次數？
str = "abd*gtha*bdgd*tbah*dab"
count = str.count("*")
print(count) # 4
88、字元串轉化大小寫？
str = "abdGFYDJKDSBdtbahKHGab"
str_upper = str.upper()
print("轉大寫", str_upper) # 轉大寫 ABDGFYDJKDSBDTBAHKHGAB
str_lower = str.lower()
print("轉小寫", str_lower) # 轉小寫 abdgfydjkdsbdtbahkhgab
89、用兩種方法去空格？
str = "hello world, my name is apollo!"
ret = str.replace(" ", "")
print(ret)
str_list = str.split(" ")
ret = "".join(str_list)
print(ret)
90、正則比對不是以4和7結尾的手機号？
import re
mobile_list = ["18811110000", "18811110004", "18811110006", "10086"]
for mobile in mobile_list:
ret = re.match(r"1[3-9]\d{8}[0-35689]$", mobile)
if ret:
print("不是以4和7結尾的手機号", ret.group())
else:
print("不想要的結果", mobile)
"""
不是以4和7結尾的手機号 18811110000
不想要的結果 18811110004
不是以4和7結尾的手機号 18811110006
不想要的結果 10086
"""
91、簡述Python引用計數機制？
python垃圾回收主要以引用計數為主，标記-清除和分代清除為輔的機制，其中标記-清除和分代-回收主要是為了處理循環引用的難題。
引用計數算法
當有1個變量儲存了對象的引用時，此對象的引用計數就會加1。
當使用del删除變量指向的對象時，如果對象的引用計數不為1，比如3，那麼此時隻會讓這個引用計數減1，即變為2，當再次調用del時，變為1，如果再調用1次del，此時會真的把對象進行删除。
92、int("1.4"),int(1.4)輸出結果？
int("1.4")報錯，int(1.4)輸出1
93、列舉3條以上PEP8編碼規範？
點選檢視 ☞ PEP8 Python 編碼規範
1、頂級定義之間空兩行，比如函數或者類定義。
2、方法定義、類定義與第一個方法之間，都應該空一行
3、三引号進行注釋
4、使用Pycharm、Eclipse一般使用4個空格來縮進代碼
94、正規表達式比對第一個URL？
findall結果無需加group()，search需要加group()提取
import re
str = '<img alt="筱沫沫愛吃魚的直播" data-original="https://rpic.douyucdn.cn/live-cover/appCovers/2018/11/12/2978708_20181112170936_small.jpg" src="https://rpic.douyucdn.cn/live-cover/appCovers/2018/11/12/2978708_20181112170936_small.jpg" width="283" height="163" class="JS_listthumb" style="display: block;">'
ret = re.findall(r"https://.+?\.jpg", str)[0]
print(ret)
# https://rpic.douyucdn.cn/live-cover/appCovers/2018/11/12/2978708_20181112170936_small.jpg
ret = re.search(r"https://.+?\.jpg", str)
print(ret.group())
# https://rpic.douyucdn.cn/live-cover/appCovers/2018/11/12/2978708_20181112170936_small.jpg
95、正則比對中文？
import re
str = '你好，hello，世界'
pattern = re.compile(r"[\u4e00-\u9fa5]+")
ret = pattern.findall(str)
print(ret) # ['你好', '世界']
96、簡述樂觀鎖和悲觀鎖？
悲觀鎖,，就是很悲觀，每次去拿資料的時候都認為别人會修改，是以每次在拿資料的時候都會上鎖，這樣别人想拿這個資料就會block直到它拿到鎖。傳統的關系型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。
樂觀鎖，就是很樂觀，每次去拿資料的時候都認為别人不會修改，是以不會上鎖，但是在更新的時候會判斷一下在此期間别人有沒有去更新這個資料，可以使用版本号等機制，樂觀鎖适用于多讀的應用類型，這樣可以提高吞吐量。
97、r、r+、rb、rb+檔案打開模式差別？
模式較多，比較下背背記記即可
| 讀寫模式 | 資料讀寫基本機關 | 操作權限 | 注意事項 |
| rb | 位元組 | 讀 | 讀取資訊，如果檔案不存在報錯 |
| wb | 位元組 | 寫 | 寫入資訊覆寫原始資訊，如果檔案不存在建立 |
| ab | 位元組 | 追加寫 | 寫入資訊到原資訊末尾，如果檔案不存在建立 |
| rb+ | 位元組 | 讀、寫 | 讀取資訊，如果檔案不存在報錯 |
| wb+ | 位元組 | 讀、寫 | 寫入資訊覆寫原始資訊，如果檔案不存在建立 |
| ab+ | 位元組 | 讀、追加寫 | 寫入資訊到原資訊末尾，如果檔案不存在建立 |
| r | 字元 | 讀 | 讀取資訊，如果檔案不存在報錯 |
| w | 字元 | 寫 | 寫入資訊覆寫原始資訊，如果檔案不存在建立 |
| a | 字元 | 追加寫 | 寫入資訊到原資訊末尾，如果檔案不存在建立 |
| r+ | 字元 | 讀、寫 | 讀取資訊，如果檔案不存在報錯 |
| w+ | 字元 | 讀、寫 | 寫入資訊覆寫原始資訊，如果檔案不存在建立 |
| a+ | 字元 | 讀、追加寫 | 寫入資訊到原資訊末尾，如果檔案不存在建立 |
98、Linux指令重定向 > 和 >>？
Linux 允許将指令執行結果重定向到一個檔案
将本應顯示在終端上的内容輸出或追加到指定檔案中
> 表示輸出，會覆寫檔案原有的内容
>> 表示追加，會将内容追加到已有檔案的末尾
用法示例：
将 echo 輸出的資訊儲存到 1.txt 裡echo Hello Python > 1.txt
将 tree 輸出的資訊追加到 1.txt 檔案的末尾tree >> 1.txt
99、正規表達式比對出<html><h1>www.itcast.cn</h1></html>？
前面的<>和後面的<>是對應的，可以用此方法
import re
str_list = ["<html><h1>www.baidu.com</h1></html>", "<html><h1>www.baidu.com</html></h1>"]
for str in str_list:
# ret = re.match(r"<(?P<html>\w+)><(?P<h1>\w+)>.+?</(h1)></(html)>", str)
ret = re.match(r"<(\w+)><(\w+)>.+?</(\2)></(\1)>", str)
if ret:
print("符合HTML标簽：", ret.group())
else:
print("不符合HTML标簽：", str)
"""
符合HTML标簽： <html><h1>www.baidu.com</h1></html>
不符合HTML标簽： <html><h1>www.baidu.com</html></h1>
"""
100、Python傳參數是傳值還是傳址？
Python中函數參數是引用傳遞（注意不是值傳遞）。對于不可變類型（數值型、字元串、元組），因變量不能修改，是以運算不會影響到變量自身；而對于可變類型（清單字典）來說，函數體運算可能會更改傳入的參數變量。
def SelfAdd(x):
x += x
x = 1
print("不可變類型", x)
SelfAdd(x)
print("調用函數後", x)
x = [1, 2]
print("可變類型", x)
SelfAdd(x)
print("調用函數後", x)
"""
不可變類型 1
調用函數後 1
可變類型 [1, 2]
調用函數後 [1, 2, 1, 2]
"""
101、求兩個清單的交集、差集、并集？
# 擷取兩清單的交集、并集、差集
a = [1, 2, 3, 4]
b = [3, 4, 5, 6]
jj1 = [i for i in a if i in b]
jj2 = list(set(a).intersection(set(b)))
print("交集", jj1)
print("交集", jj2)
bj = list(set(a).union(set(b)))
print("并集", bj)
cj1 = [i for i in a if i not in b]
cj2 = list(set(a).difference(set(b))) # 效率高
print("a-b差集", cj1)
print("a-b差集", cj2)
cj1 = [i for i in b if i not in a]
cj2 = list(set(b).difference(set(a))) # 效率高
print("b-a差集", cj1)
print("b-a差集", cj2)
"""
交集 [3, 4]
交集 [3, 4]
并集 [1, 2, 3, 4, 5, 6]
a-b差集 [1, 2]
a-b差集 [1, 2]
b-a差集 [5, 6]
b-a差集 [5, 6]
"""
102、生成0-100的随機數？
random.random()生成0-1之間的随機小數，是以乘以100。
import random
ret1 = random.random() * 100
ret2 = random.choice(range(1, 101))
ret3 = random.randint(1, 100)
print(ret1) # 35.374903822851444
print(ret2) # 40
print(ret3) # 66
103、lambda匿名函數好處？
精簡代碼，lambda省去了定義函數，map省去了寫for循環過程
str = ["中國", "北京", "", "天津", "", "上海"]
new_str = list(map(lambda x: "主動填充" if x == "" else x, str))
print(new_str)
# ['中國', '北京', '主動填充', '天津', '主動填充', '上海']
104、常見的網絡傳輸協定？
UDP、TCP、FTP、HTTP、SMTP等等
105、單引号、雙引号、三引号用法？
1、單引号和雙引号沒有什麼差別，不過單引号不用按shift，打字稍微快一點。表示字元串的時候，單引号裡面可以用雙引号，而不用轉義字元，反之亦然。
'She said:"Yes." ' or "She said: 'Yes.' "
2、但是如果直接用單引号擴住單引号，則需要轉義，像這樣：
' She said:\'Yes.\' '
3、三引号可以直接書寫多行，通常用于大段，大篇幅的字元串
"""
hello
world
"""
106、HTTP請求中get和post差別？
1、GET請求是通過URL直接請求資料，資料資訊可以在URL中直接看到，比如浏覽器通路；而POST請求是放在請求頭中的，我們是無法直接看到的；
2、GET送出有資料大小的限制，一般是不超過1024個位元組，而這種說法也不完全準确，HTTP協定并沒有設定URL位元組長度的上限，而是浏覽器做了些處理，是以長度依據浏覽器的不同有所不同；POST請求在HTTP協定中也沒有做說明，一般來說是沒有設定限制的，但是實際上浏覽器也有預設值。總體來說，少量的資料使用GET，大量的資料使用POST；
3、GET請求因為資料參數是暴露在URL中的，是以安全性比較低，比如密碼是不能暴露的，就不能使用GET請求；POST請求中，請求參數資訊是放在請求頭的，是以安全性較高，可以使用。在實際中，涉及到登入操作的時候，盡量使用HTTPS請求，安全性更好。
107、Python中讀取Excel檔案的方法？
應用資料分析庫pandas
108、python正則中search和match？