Python學習之109道面試題（下）

 

51、正則匹配，匹配日期2018-03-20

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'
result=re.findall(r'dateRange=(.*?)&',url)
print(result)
輸出：
['2018-03-20%7C2018-03-20']

52、list=[2,3,5,4,9,6]，從小到大排序，不許用sort，輸出[2,3,4,5,6,9]

#利用min()方法求出最小值，原列表刪除最小值，新列表加入最小值，遞歸調用獲取最小值的函數，反復操作
li=[2,3,5,4,9,6]
new_li=[]
def get_min(li):
    a=min(li)
    li.remove(a)
    new_li.append(a)
    if len(li)>0:
        get_min(li)
    return new_li
new_li=get_min(li)
print(new_li)          ==》[2, 3, 4, 5, 6, 9]

53、寫一個單列模式

（因為創建對象時__new__方法執行，並且必須return 返回實例化出來的對象所cls.__instance是否存在，不存在的話就創建對象，存在的話就返回該對象，來保證只有一個實例對象存在（單列），打印ID，值一樣，說明對象同一個）
class Singleton(object):
  __instance =None
  def  __new__  (cls, age,  name ):
  #如果類屬性__instance的值為None,
  #那么就創建一個對象，並且賦值為這個對象的引用，保證下次調用這個方法時能夠知道之前已經創建過對象了，這樣就保證了只有1個對象
     if not cls.__instance:
         cls.__instance =object.__new__ (cls)
     return cls.__instance
a = Singleton(18, "dongGe" )
b = Singleton(8, "dongGe")
print(id(a))
print(id(b))
a.age=19#給a指向的對象添加一個屬性
print(b. age)#獲取b指向的對象的age屬性

54、保留兩位小數

#為了擴充保留小數的思路，提供round方法（數值，保留位數）
a="%.03f"%1.3335
print(a, type(a))
b=round(float(a),1)
print(b)
b=round(float(a),2)
print(b)
輸出：
1.333 <class 'str'>
1.3
1.33

55、求三個方法打印結果

{fn("one",1）直接將鍵值對傳給字典；fn("two",2)因為字典在內存中是可變數據類型，所以指向同一個地址，傳了新的參數后，會相當於給字典增加鍵值對；fn("three",3,{})因為傳了一個新字典，所以不再是原先默認參數的字典}

def fn(k,v,dic={}):
    dic[k] = v
    print(dic)
fn("one",1)
fn("two",2)
fn("three",3,{})
輸出：
{'one': 1}
{'one': 1, 'two': 2}
{'three': 3}

56、列出常見的狀態碼和意義

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項目的性能優化

前端優化：
1、減少http請求、例如制作精靈圖
2、html和CSS放在頁面上部，javascript放在頁面下面，因為js加載比HTML和Css加載慢，所以要優先加載html和css,以防頁面顯示不全，性能差，也影響用戶體驗差
后端優化：
1、緩存存儲讀寫次數高，變化少的數據，比如網站首頁的信息、商品的信息等。應用程序讀取數據時，一般是先從緩存中讀取，如果讀取不到或數據已失效，再訪問磁盤數據庫，並將數據再次寫入緩存。
2、異步方式，如果有耗時操作，可以采用異步，比如celery
3、代碼優化，避免循環和判斷次數太多，如果多個if else判斷，優先判斷最有可能先發生的情況
數據庫優化：
1、如有條件，數據可以存放於redis，讀取速度快
2、建立索引、外鍵等

58、使用pop和del刪除字典中的"name"字段，dic={"name":"zs","age":18}

#pop（）
dic = {"name":"zs","age" :18}
dic.pop("name" )
print(dic)
#del
dic = {"name":"zs","age" :18}
del dic["name"]
print(dic)

均輸出：
{'age': 18}

59、列出常見MYSQL數據存儲引擎

InnoDB：支持事務處理，支持外鍵，支持崩潰修復能力和並發控制。如果需要對事務的完整性要求比較高（比如銀行），要求實現並發控制（比如售票），那選擇InnoDB有很大的優勢。如果需要頻繁的更新、刪除操作的數據庫，也可以選擇InnoDB，因為支持事務的提交（commit）和回滾（rollback）。 
MyISAM：插入數據快，空間和內存使用比較低。如果表主要是用於插入新記錄和讀出記錄，那么選擇MyISAM能實現處理高效率。如果應用的完整性、並發性要求比 較低，也可以使用。
MEMORY：所有的數據都在內存中，數據的處理速度快，但是安全性不高。如果需要很快的讀寫速度，對數據的安全性要求較低，可以選擇MEMOEY。它對表的大小有要求，不能建立太大的表。所以，這類數據庫只使用在相對較小的數據庫表。

60、計算代碼運行結果，zip函數歷史文章已經說了，得出[("a",1),("b",2)，("c",3),("d",4),("e",5)]

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('A0',A0)
print(list(zip(("a","b","c","d","e"),(1,2,3,4,5))))
print(A2)
print(A3)
輸出：
A0 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
[]
[1, 2, 3, 4, 5]

61、簡述同源策略

同源策略需要同時滿足以下三點要求： 
1）協議相同 
2）域名相同 
3）端口相同 
 http:www.test.com與https:www.test.com 不同源——協議不同 
 http:www.test.com與http:www.admin.com 不同源——域名不同 
 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中的sessionid相同，值是開發人員設置的鍵值對信息，進行了base64編碼，過期時間由開發人員設置
3、cookie安全性比session差

63、簡述多線程、多進程

進程：
1、操作系統進行資源分配和調度的基本單位，多個進程之間相互獨立
2、穩定性好，如果一個進程崩潰，不影響其他進程，但是進程消耗資源大，開啟的進程數量有限制
線程：
1、CPU進行資源分配和調度的基本單位，線程是進程的一部分，是比進程更小的能獨立運行的基本單位，一個進程下的多個線程可以共享該進程的所有資源
2、如果IO操作密集，則可以多線程運行效率高，缺點是如果一個線程崩潰，都會造成進程的崩潰
應用：
IO密集的用多線程，在用戶輸入，sleep 時候，可以切換到其他線程執行，減少等待的時間
CPU密集的用多進程，因為假如IO操作少，用多線程的話，因為線程共享一個全局解釋器鎖，當前運行的線程會霸占GIL，其他線程沒有GIL，就不能充分利用多核CPU的優勢

64、簡述any()和all()方法

any():只要迭代器中有一個元素為真就為真
all():迭代器中所有的判斷項返回都是真，結果才為真

python中什么元素為假？
答案：（0，空字符串，空列表、空字典、空元組、None, False）

 65、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分別代表什么異常

IOError：輸入輸出異常
AttributeError：試圖訪問一個對象沒有的屬性
ImportError：無法引入模塊或包，基本是路徑問題
IndentationError：語法錯誤，代碼沒有正確的對齊
IndexError：下標索引超出序列邊界
KeyError:試圖訪問你字典里不存在的鍵
SyntaxError:Python代碼邏輯語法出錯，不能執行
NameError:使用一個還未賦予對象的變量

66、python中copy和deepcopy區別

1、復制不可變數據類型，不管copy還是deepcopy,都是同一個地址當淺復制的值是不可變對象（數值，字符串，元組）時和=“賦值”的情況一樣，對象的id值與淺復制原來的值相同。
2、復制的值是可變對象（列表和字典）
淺拷貝copy有兩種情況：
第一種情況：復制的 對象中無 復雜 子對象，原來值的改變並不會影響淺復制的值，同時淺復制的值改變也並不會影響原來的值。原來值的id值與淺復制原來的值不同。
第二種情況：復制的對象中有 復雜 子對象 （例如列表中的一個子元素是一個列表）， 改變原來的值 中的復雜子對象的值  ，會影響淺復制的值。
深拷貝deepcopy：完全復制獨立，包括內層列表和字典

67、列出幾種魔法方法並簡要介紹用途

__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 'generator'>

70、a = "  hehheh  ",去除首尾空格

a="  hehheh  "
print(a.strip())

hehheh

71、舉例sort和sorted對列表排序，list=[0,-1,3,-10,5,9]

li=[0,-1,3,-10,5,9]
li.sort()
print(li)     ==>[-10, -1, 0, 3, 5, 9]


li=[0,-1,3,-10,5,9]
res=sorted(li)
print(li)               ==>[0, -1, 3, -10, 5, 9]
print(res)            ==>[-10, -1, 0, 3, 5, 9]

{sort()與sorted()的不同在於，sort是在原位重新排列列表，而sorted()是產生一個新的列表。sorted(L)返回一個排序后的L，不改變原始的L；L.sort()是對原始的L進行操作，調用后原始的L會改變，沒有返回值。【所以a = a.sort()是錯的啦！a = sorted(a)才對！
sorted()適用於任何可迭代容器，list.sort()僅支持list（本身就是list的一個方法）
基於以上兩點，sorted使用頻率比list.sort()更高些，所以Python中更高級的排序技巧便通過sorted()來演示。}

72、對list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4],使用lambda函數從小到大排序

foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
res=sorted(foo,key=lambda x:x)      
print(res)             ==》[-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]，正數從小到大，負數從大到小

foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
res=sorted(foo,key=lambda x:(x<0,abs(x)))      #abs()函數返回絕對值,傳兩個條件，x<0和abs(x)
print(res)      ==>[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]

74、列表嵌套字典的排序，分別根據年齡和姓名排序

foo = [{"name":"zs","age":19},{"name":"ll","age":54},{"name":"wa","age":17},{"name":"df","age":23}]
a=sorted(foo,key=lambda x:x['age'],reverse=True)            #年齡從大到小
print(a)
b=sorted(foo,key=lambda x:x['name'])                        #姓名從小到大
print(b)

輸出：
[{'name': 'll', 'age': 54}, {'name': 'df', 'age': 23}, {'name': 'zs', 'age': 19}, {'name': 'wa', 'age': 17}]
[{'name': 'df', 'age': 23}, {'name': 'll', 'age': 54}, {'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}]

75、列表嵌套元組，分別按字母和數字排序

foo = [("zs", 19), ("ll", 54),("wa",17), ("df", 23)]
a = sorted(foo, key=lambda x: x[1], reverse = True )  #按數字由大到小
print(a)
a = sorted(foo, key=lambda x: x[0])                   #按字母由小到大
print(a)

輸出：
[('ll', 54), ('df', 23), ('zs', 19), ('wa', 17)]
[('df', 23), ('ll', 54), ('wa', 17), ('zs', 19)]

76、列表嵌套列表排序，年齡數字相同怎么辦？

foo = [["zs", 19], ["ll", 54],["wa",23], ["df", 23],["xf",23]]
a = sorted(foo, key=lambda x: (x[1],x[0] ) )  #年齡相同，添加參數按字母排序
print(a)
a = sorted(foo, key=lambda x: x[0])                   #按字母由小到大
print(a)

輸出：
[['zs', 19], ['df', 23], ['wa', 23], ['xf', 23], ['ll', 54]]
[['df', 23], ['ll', 54], ['wa', 23], ['xf', 23], ['zs', 19]]

77、根據鍵對字典排序（方法一，zip函數）

dic = {"name":"zs","sex":"man" ,"city":"bj"}
foo=zip(dic.keys(), dic.values())      #字典轉列表嵌套元組
foo = [i for i in foo ]
print("字典轉成列表嵌套元組",foo)
b= sorted(foo,key= lambda x:x[0])        #字典嵌套元組排序
print("根據鍵排序",b)
new_dic = {i[0]:i[1] for i in b}         #排序完構造新字典
print("字典推導式構造新字典",new_dic)

輸出：
字典轉成列表嵌套元組 [('name', 'zs'), ('sex', 'man'), ('city', 'bj')]
根據鍵排序 [('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
字典推導式構造新字典 {'city': 'bj', 'name': 'zs', 'sex': 'man'}

78、根據鍵對字典排序（方法二,不用zip)

dic = {"name":"zs","sex":"man" ,"city":"bj"}
print(dic.items())
b= sorted(dic.items(),key= lambda x:x[0])
print("根據鍵排序",b)
new_dic = {i[0]:i[1] for i in b}
print("字典推導式構造新字典",new_dic)
輸出：
dict_items([('name', 'zs'), ('sex', 'man'), ('city', 'bj')])
根據鍵排序 [('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
字典推導式構造新字典 {'city': 'bj', 'name': 'zs', 'sex': 'man'}

{dic.items和zip(dic.keys(),dic.values())都是為了構造列表嵌套字典的結構，方便后面用sorted()構造排序規則}

79、列表推導式、字典推導式、生成器

import random
td_list=[i for i in range(10)]
print("列表推導式", td_list, type(td_list))
ge_list = (i for i in range(10))
print("生成器", ge_list)
dic = {k:random.randint(4, 9)for k in ["a", "b", "c", "d"]}
print("字典推導式",dic,type(dic))

輸出：
列表推導式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
生成器 <generator object <genexpr> at 0x000000E284F78AF0>
字典推導式 {'a': 4, 'b': 8, 'c': 7, 'd': 9} <class 'dict'>

80、最后出一道檢驗題目，根據字符串長度排序，看排序是否靈活運用

#根據字符串長度排序
a=['ab','abc','a','djkj']
b=sorted(a,key=lambda x:len(x))      #sorted有返回值，不改變a本身
print(a,b)
a.sort(key=len)                      #sort無返回值，在a自身修改
print(a)

輸出：
['ab', 'abc', 'a', 'djkj'] ['a', 'ab', 'abc', 'djkj']
['a', 'ab', 'abc', 'djkj']

81、舉例說明SQL注入和解決辦法

#當以字符串格式化書寫方式的時候，如果用戶輸入的有;+SQL語句，后面的SQL語句會執行，比如例子中的SQL注入會刪除數據庫demo
input_name=" zs"
sql='select * from demo where name="%s"'% input_name
print("正常sql語句" , sql)
input_name=" zs;drop database demo"
sql='select * from  demo where name= "%s"' % input_name
print("SQL注入語句" ,sql)
輸出：
正常sql語句 select * from demo where name=" zs"
SQL注入語句 select * from  demo where name= " zs;drop database demo"

#解決方式：通過傳參數方式解決SQL注入
params= [input_name]
count = csl.execute( 'select from goods where name=%s ' , params )

？？？解決方式中csl？？暫不明確

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= ["[e-mail]","[e-mail]", "[e-mail]" ]
for email in email_list:
    ret = re.match("[\w]{4,20}@163\.com$",email)
    if ret:
        print("%s 是符合規定的郵件地址，匹配后結果是:%s" % (email,ret.group()))
    else:
        print("%s 不符合要求" % email)

輸出：
[e-mail] 是符合規定的郵件地址，匹配后結果是:[e-mail]
[e-mail] 不符合要求
[e-mail] 不符合要求

84、遞歸求和

#遞歸完成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

85、python字典和json字符串相互轉化方法　　

#json.dumps()字典轉json字符串，json.loads()json轉字典
import json
dic = {"name":"zs"}
res = json.dumps(dic)
print(res,type(res))
ret = json.loads(res)
print(ret,type(ret))

輸出：
{"name": "zs"} <class 'str'>
{'name': 'zs'} <class 'dict'>

86、MyISAM 與 InnoDB 區別：

1、InnoDB 支持事務，MyISAM 不支持，這一點是非常之重要。事務是一種高
級的處理方式，如在一些列增刪改中只要哪個出錯還可以回滾還原，而 MyISAM
就不可以了；
2、MyISAM 適合查詢以及插入為主的應用，InnoDB 適合頻繁修改以及涉及到
安全性較高的應用；
3、InnoDB 支持外鍵，MyISAM 不支持；
4、對於自增長的字段，InnoDB 中必須包含只有該字段的索引，但是在 MyISAM
表中可以和其他字段一起建立聯合索引；
5、清空整個表時，InnoDB 是一行一行的刪除，效率非常慢。MyISAM 則會重
建表；

87、統計字符串中某字符出現次數 

str="張三 哈哈 張三 呵呵 張三"
res=str.count("張三")
print(res)                 ==》3

88、字符串轉化大小寫

str="HHaa"
print(str.upper())
print(str.lower())

輸出：
HHAA
hhaa

89、用兩種方法去空格

str="hello world ha ha"
res=str.replace(" ","")
print(res)

list=str.split(" ")
res="".join(list)
print(res)

均輸出：
helloworldhaha

90、正則匹配不是以4和7結尾的手機號

import re
tels=["13100001234","18912344321","10086","18800007777"]
for tel in tels:
    ret=re.match("1\d{9}[0-3,5-6,8-9]",tel)
    if ret:
        print("結果是：",ret.group())
    else:
        print("%s不是想要的手機號" % tel)

輸出：
13100001234不是想要的手機號
結果是： 18912344321
10086不是想要的手機號
18800007777不是想要的手機號

91、簡述python引用計數機制

python垃圾回收主要以引用計數為主，標記-清除和分代清除為輔的機制，其中標記-清除和分代回收主要是為了處理循環引用的難題。
引用計數算法
當有1個變量保存了對象的引用時，此對象的引用計數就會加1
當使用del刪除變量指向的對象時，如果對象的引用計數不為1，比如3，那么此時只會讓這個引用計數減1，即變為2，當再次調用del時，變為1，如果再調用1次del，此時會真的把對象進行刪除

92、int("1.4"),int(1.4)輸出結果？

print(int("1.4"))   #報錯ValueError
print(int(1.4))        # 1

93、列舉3條以上PEP8編碼規范

1、頂級定義之間空兩行，比如函數或者類定義。
2、方法定義、類定義與第一個方法之間，都應該空一行
3、三引號進行注釋
4、使用Pycharm、Eclipse一般使用4個空格來縮進代碼

94、正則表達式匹配第一個URL

findall結果無需加group(),search需要加group()提取

95、正則匹配中文

import re
title="你好，hello，世界"
res=re.compile(r'[\u4e00-\u9fa5]+')
result=res.findall(title)
print(result)

輸出：
['你好', '世界']

96、簡述樂觀鎖和悲觀鎖

悲觀鎖, 就是很悲觀，每次去拿數據的時候都認為別人會修改，所以每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會block直到它拿到鎖。傳統的關系型數據庫里邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。
樂觀鎖，就是很樂觀，每次去拿數據的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，可以使用版本號等機制，樂觀鎖適用於多讀的應用類型，這樣可以提高吞吐量

97、r、r+、rb、rb+文件打開模式區別

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
labels=["<html><h1>www.itcast.cn</h1></html>","<html><h1>www.itcast.cn</h2></html>"]
for label in labels:
    ret=re.match(r"<(\w*)><(\w*)>.*?</\2></\1>",label)
    if ret:
        print("%s是符合要求的標簽"%ret.group())
    else:
        print("%s不符合要求"%label)
輸出：
<html><h1>www.itcast.cn</h1></html>是符合要求的標簽
<html><h1>www.itcast.cn</h2></html>不符合要求

100、python傳參數是傳值還是傳址？

Python中函數參數是引用傳遞（注意不是值傳遞）。對於不可變類型（數值型、字符串、元組），因變量不能修改，所以運算不會影響到變量自身；而對於可變類型（列表字典）來說，函數體運算可能會更改傳入的參數變量。

101、求兩個列表的交集、差集、並集

a= [1,2,3,4]
b= [4,3,5,6]
jj1=[i for i in a if i in b]   #在a中的i，並且也在b中，就是交集
jj2=list(set(a).intersection(set(b)))
bj1=list(set(a).union(set(b)))
cj1=list(set(b).difference(set(a)))
cj2=list(set(a).difference(set(b)))
print("交集" ,jj1)
print("交集",jj2)
print("並集",bj1)
print("差集" ,cj1)
print("差集" ,cj2)
輸出：
交集 [3, 4]
交集 [3, 4]
並集 [1, 2, 3, 4, 5, 6]
差集 [5, 6]
差集 [1, 2]

102、生成0-100的隨機數

import random
res1=100* random. random( )   #隨機小數 random.random()生成0-1之間的隨機小數，所以乘以100
res2= random.choice( range(0,101))   #隨機整數
res3= random.randint(1,100)          #隨機整數
print(res1)
print(res2)
print(res3)
輸出：
70.52071953376354
21
13

103、lambda匿名函數好處

精簡代碼，lambda省去了定義函數，map省去了寫for循環過程

104、常見的網絡傳輸協議

UDP:User Datagram Protocol,用戶數據報協議.
主要作用：將網絡數據壓縮成數據包的形式。
數據包：一個二進制數據的傳輸單位
工作機制：蠻干型。它想傳送時就簡單地去抓取來自應用程序的數據，並盡可能快地把它扔到網絡上。因此，在發送端，UDP傳送數據的速度僅僅是受應用程序生成數據的速度、計算機的能力和傳輸帶寬的限制；在接收端，UDP把每個消息段放在隊列中，應用程序每次從隊列中讀一個消息段。
優勢：速度快，較安全。劣勢：可靠性差。
TCP:Transmission Control Protocol 傳輸控制協議
主要作用：把數據流分割成適當長度的報文段之后
工作機制：緊小細微型。面向連接意味着兩個使用TCP的應用（通常是一個客戶和一個服務器）在彼此交換數據包之前必須先建立一個TCP連接。這一過程與打電話很相似，先撥號振鈴，等待對方摘機說“喂”，然后才說明是誰。在一個TCP連接中，僅有兩方進行彼此通信。而UDP更像是發短信，將發送方所有的信息，將所有信息一股腦兒全扔到網絡中。
優勢：可靠性好  劣勢：速度慢，占用系統資源高，易被攻擊
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文件的方法

108、簡述多線程、多進程

進程：
1、操作系統進行資源分配和調度的基本單位，多個進程之間相互獨立
2、穩定性好，如果一個進程崩潰，不影響其他進程，但是進程消耗資源大，開啟的進程數量有限制
線程：
1、CPU進行資源分配和調度的基本單位，線程是進程的一部分，是比進程更小的能獨立運行的基本單位，一個進程下的多個線程可以共享該進程的所有資源
2、如果IO操作密集，則可以多線程運行效率高，缺點是如果一個線程崩潰，都會造成進程的崩潰
應用：
IO密集的用多線程，在用戶輸入，sleep 時候，可以切換到其他線程執行，減少等待的時間
CPU密集的用多進程，因為假如IO操作少，用多線程的話，因為線程共享一個全局解釋器鎖，當前運行的線程會霸占GIL，其他線程沒有GIL，就不能充分利用多核CPU的優勢

109、python正則中search和match

class Parent(object):
    x = 1
class Child1(Parent):
    pass
class Child2(Parent):
    pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
 輸出結果：
1 1 1
1 2 1
3 2 3  ------------為什么不是3 3 3？？？？
這個主要考察繼承父類屬性的賦值問題： 如果子類沒有重新賦值，那以父類的默認值為最終結果，如果子類賦值了，以子類的為最終輸出結果，如果父類的值改變了同時子類沒有重新賦值的情況下，以父類為最終輸出結果，如果子類也改變了值則以子類為最終結果，所以child1改變過x的直為2 那 最終結果就不是父類的3了
*************************************************
def extendList(val, list=[]):
    list.append(val)
    return list

list1 = extendList(10)
list2 = extendList(123 ,[])
list3 = extendList('a')

print ("list1 = %s" % list1)
print ("list2 = %s" % list2)
print ("list3 = %s" % list3)
結果：
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']                    
此處考察的是參數傳遞和列表的賦值，第一個extendList(10) ，賦值后list的值為10，用的list為extendList 定義的list、，list2 = extendList(123 ,[])帶了一個空【】List過去 這個時候的list是一個 空的list 而不是 list1引用 的list了 所以這個時候他的值就是 123，list3的時候 因為沒有傳自己的list參數，所以和list1用的是同一個list ，那這樣的打印結果，就是 和list1一樣了

>>> int('12',8)    #把八進制數12轉化為十進制
10
>>> int('f',16)    #把十六進制數f轉化為十進制數
15
>>> int('1010',2)    #把二進制數1010轉化為十進制數
10
int（）均是轉換成10進制數，用內置函數hex(),oct(),bin(),對應的數字表示為0x，0o，0b，功能是把十進制數字轉化為其他進制的數
*************************************************
'''在python中，and自左向右掃描布爾表達式，如果所有值為真，則返回最后一個為真的表達式，如果為假，則返回第一個為假的表達式
or的使用與and正好相反，自左向右計算整個布爾表達式，如果有為真的值，那么立刻返回第一個為真的值，如果整個表達式為假，則返回最后一個為假的值'''
v1 = 1 or 3
print(v1)   #1
v2 = 1 and 3
print(v2)   #3
v3 = 0 and 2 and 1
print(v3)  #0
v4 = 0 and 2 or 1
print(v4)  #1
v5 = 0 and 2 or 1 or 4
print(v5)  #1
v6 = 0 or False and 1
print(v6) #False
print(2 and 1 and 3) #這種情況下打印的值為3,即整個表達式中最后一個為真的部分 
print(1 and 3 and 0 and 4) #這種情況下打印第一個為假的部分 0
print(1 and 0 and 3/0)#注意這個地方會執行短路規則，一旦計算得出表達式是假，則直接返回第一個為假的值，不繼續進行運算。
（https://blog.csdn.net/sinat_34328764/article/details/79055753）
**********************************************
def multipliers(): 
return [lambda x : i*x for i in range(4)] 
print [m(2) for m in multipliers()] 
output: # [6, 6, 6, 6]
（因為匿名函數中的i並不是立即引用后面循環中的i值的，而是在運行嵌套函數的時候，才會查找i的值，這個特性也就是延遲綁定）
以下添加默認參數方法可以輸出0246：
def num():
    # 添加了一個默認參數i=i
    return [lambda x,i=i: i * x for i in range(4)]

print([m(2) for m in num()])  #[0, 2, 4, 6]
（https://blog.csdn.net/xie_0723/article/details/53925076）
*************************************************
>>>1 < (2==2) 
...False         #先算（） true是1 ，所以1<1是false
>>>1 < 2 == 2
...True

面試題1：
def func(arg,li=[]):
    li.append(arg)
    return li

v1 = func(1)
print(v1)  # [1]
v2 = func(2,[])
print(v2)  # [2]
v3 = func(3)
print(v3)  # [1,3]
'''v2自創建新列表,開辟新內存,v3和v1用的同一塊空間'''
                    
面試題2：
n1 = [11,22,33,44,55]
n2 = n1
n3 = n1[:]   #[11, 22, 33, 44, 55]
n1[0] = 666
n3[1] = 999
print(n1) #[666,22,33,44,55]
print(n2) #[666,22,33,44,55]
print(n3) #[11,999,33,44,55]
'''n2=n1指向同一塊內存，改哪個n1與n2都是一樣；n3 = n1[:]切片就會重新復制一份，指向另外一塊內存'''