1：為什么學習Python
家里有在這個IT圈子里面，也想讓我接觸這個圈子，然后給我建議學的Python，然后自己通過百度和向有學過Python的同學了解了Python，Python這門語言，入門比較簡單，它簡單易學，生態圈比較強大，涉及的地方比較多，特別是在人工智能，和數據分析這方面。在未來我覺得是往自動化，人工智能這方面發展的，所以學習了Python
2：通過什么途徑學習Python
剛開始接觸Python的時候，到網上里面跟著視頻學基礎，再后來網上到看技術貼，然后看到有人推薦廖雪峰的Python教程，練項目到GitHub上面找一些小項目學習。
3：談談對Python和其他語言的區別
優點
Python屬于解釋型語言，當程序運行時，是一行一行的解釋，并運行，所以調式代碼很方便，開發效率高，Python 語法簡潔優美，功能強大，標準庫與第三方庫都非常強大，而且應用領域也非常廣；
還有龜叔給Python定位是任其自由發展、優雅、明確、簡單；
Python 易于學習;
用少量的代碼構建出很多功能;（高效的高級數據結構）
Python完全支持面向對象;
Python 是跨平臺且開源的。可移植性，可擴展性，可嵌入性都很強
動態類型:
? ?
缺點：運行速度慢，Python的運行速度相較與C，肯定是慢了
Python弱類型（強類型是指不允許隱式變量類型轉換，弱類型則允許隱式類型轉換）與其他語言相比：
- 與java相比：在很多方面，Python比Java要簡單，比如java中所有變量必須聲明才能使用，而Python不需要聲明,用少量的代碼構建出很多功能;（高效的高級數據結構）
- 與php相比：python標準包直接提供了工具，并且相對于PHP代碼更易于維護;
- Python與c相比：Python 和 C Python這門語言是由C開發而來
4：簡述解釋型和編譯型編程語言
解釋型：就是邊解釋邊執行（Python，php）
編譯型：編譯后再執行（c、java、c#）
5：Python的解釋器種類以及相關特點？
CPython?
官方版本的解釋器。使用C語言開發的，所以叫CPython。在命令行下運行python就是啟動CPython解釋器。CPython是使用最廣的Python解釋器。教程的所有代碼也都在CPython下執行。IPython
IPython是基于CPython之上的一個交互式解釋器，也就是說，IPython只是在交互方式上有所增強，但是執行Python代碼的功能和CPython是完全一樣的。CPython用>>>作為提示符，而IPython用In [序號]:作為提示符。PyPy
由Python寫的解釋器，它的執行速度是最快。PyPy采用JIT技術，對Python代碼進行動態編譯（注意不是解釋），絕大部分Python代碼都可以在PyPy下運行，但是PyPy和CPython有一些是不同的，這就導致相同的Python代碼在兩種解釋器下執行可能會有不同的結果。Jython
Jython是運行在Java平臺上的Python解釋器，可以直接把Python代碼編譯成Java字節碼執行。IronPython
IronPython和Jython類似，只不過IronPython是運行在.Net平臺上的Python解釋器，可以直接把Python代碼編譯成.Net的字節碼。小結：
Python的解釋器很多，但使用最廣泛的還是CPython。
如果要和Java或.Net平臺交互，最好的辦法不是用Jython或IronPython，而是通過網絡調用來交互，確保各程序之間的獨立性。
6：位和字節的關系
1字節 = 8 位
位（bit，又名“比特”，簡寫為b）：數據傳輸是以大多是以“位”（bit）為單位
字節（Byte，簡寫為B）：數據存儲是以“字節”（Byte）為單位，字節是最小一級的信息單位
一個位就代表一個0或1（即一個二進制），二進制是構成存儲器的最小單位，每8個位（bit）組成一個字節（Byte）
7：b、B、KB、MB、GB的關系
b --->位(bit)????
B --->字節??????一個字節等于8位
1B = 8 bit
1kb = 1024 B
1 MB = 1024 KB
1 GB = 1024 MB
8：PE8規范
1、使用4個空格而不是tab鍵進行縮進。
2、每行長度不能超過79
3、使用空行來間隔函數和類，以及函數內部的大塊代碼
4、必要時候，在每一行下寫注釋
5、使用文檔注釋，寫出函數注釋
6、在操作符和逗號之后使用空格，但是不要在括號內部使用
7、命名類和函數的時候使用一致的方式，比如使用CamelCase來命名類，
? ? ? 使用lower_case_with_underscores來命名函數和方法
8、在類中總是使用self來作為默認
9、盡量不要使用魔法方法
10、默認使用UTF-8，甚至ASCII作為編碼方式
11、換行可以使用反斜杠，最好使用圓括號。
12、不要在一句import中多個庫，
13、空格的使用
? ? 各種右括號前不要加空格。
? ? 逗號、冒號、分號前不要加空格。
? ? 函數的左括號前不要加空格。如Func(1)
? ? 序列的左括號前不要加空格。如list[2]
? ? 操作符左右各加一個空格，不要為了對齊增加空格
? ? 函數默認參數使用的賦值符左右省略空格
? ? 不要將多句語句寫在同一行，盡管使用‘；’允許14、if/for/while語句中，即使執行語句只有一句，也必須另起一行
15、函數命名使用全部小寫的方式，常量命名使用大寫，類屬性（方法和變量）使用小寫
16、類的命名首字母大寫
9：通過代碼實現如下轉換(進制之間轉換）
#? 二進制轉換成十進制-->int
v = "0b1111011"
b = int(v,2)
print(b) ?# 123# 十進制轉換成二進制--->bin
v2 = 18
print(bin(int(v2)))? # 0b10010# 八進制轉換成十進制
v3 = "011"
print(int(v3, 8))? # 11# 十進制轉換成八進制：---> oct
v4 = 30
print(oct(int(v4)))? # 0o36# 十六進制轉換成十進制：
v5 = "0x12"
print(int(v5,16))? # 18# 十進制轉換成十六進制：---> hex
v6 = 87
print(hex(int(v6)))? # 0x57
10:請編寫一個函數實現將IP地址轉換成一個整數
如 10.3.9.12 轉換規則為：
? ? ? ? 10 ? ? ? ? ? 00001010
?? ? ? ? ?3 ? ? ? ? ? ?00000011?
? ? ? ? ?9 ? ? ? ? ? ?00001001
?? ? ? ? 12 ? ? ? ? ? 00001100?
再將以上二進制拼接起來計算十進制結果：00001010 00000011 00001001 00001100 = ？
# 第一種
ip_addr = '192.168.2.10'
# transfer ip to int
def ip2long(ip):ip_list = ip.split('.')result = 0for i in range(4): # 0,1,2,3result = result + int(ip_list[i]) * 256 ** (3 - i)return result
long = 3232236042# transfer int to ip
def long2ip(long):floor_list = []yushu = longfor i in reversed(range(4)): # 3,2,1,0res = divmod(yushu, 256 ** i)floor_list.append(str(res[0]))yushu = res[1]return '.'.join(floor_list)a = long2ip(long)
print(a)# 第二種
def v1(addr):# 取每個數id = [int(x) for x in addr.split(".")]print(id)return sum(id[i] << [24, 16, 8, 0][i] for i in range(4))print(v1("127.0.0.1"))# [127, 0, 0, 1]
# 213070643311、python遞歸的最大層數？
Python中默認的遞歸層數約為998左右(會報錯) 和計算機性能有關系，
12：求結果(and or or)
v1 = 1 or 3 ?-- 1
v2 = 1 and 3 ?-- 3
v3 = 0 and 2 and 1 ?-- 0
v4 = 0 and 2 or 1 ?-- 1
v5 = 0 and 2 or 1 or 4 ?-- 1
v6 = 0 or Flase and 1 ?-- False
總結：
# x or y ?如果 x 為真，則值為 x，否則為 y
? ? ? ?# x and y 如果 x 為真，則值為 y，否則為 x
? ? ? ?# 優先級：()>not>and>or?
? ? ? ?# 同等優先級下，從左向右
1. 求結果：2 & 5
print(2 & 5) ?# 10 & 101 => 000 => 0
2. 求結果：2 ^ 5
print(2 ^ 5) ?# 10 ^ 101 => 111 => 1*2**0+1*2**1+1*2**2=1+2+4=7
13 ：ascii、unicode、utf-8、gbk 區別
python2 內容進行編碼默認ascii,而python3對內容進行編碼的默認為utf-8。
ascii ? 最多只能用8位來表示（一個字節），即：2**8 = 256，所以，ASCII碼最多只能表示 256 個符號。
unicode 萬國碼 ? ?任何一個字符==兩個字節
utf-8 ? 萬國碼的升級版 ? ?一個中文字符==三個字節 ? 英文是一個字節 ?歐洲的是 2個字節
gbk ? ? 國內版本 ? ?一個中文字符==2個字節 ? 英文是一個字節
gbk 轉 utf-8 ?需通過媒介 unicode
14:字節碼和機器碼的區別
什么是機器碼
機器碼(machine code)，學名機器語言指令，有時也被稱為原生碼（Native Code），是電腦的CPU可直接解讀的數據。
通常意義上來理解的話，機器碼就是計算機可以直接執行，并且執行速度最快的代碼。
總結：機器碼是電腦CPU直接讀取運行的機器指令，運行速度最快，但是非常晦澀難懂，也比較難編寫什么是字節碼
字節碼（Bytecode）是一種包含執行程序、由一序列 op 代碼/數據對 組成的二進制文件。
字節碼是一種中間碼，它比機器碼更抽象，需要直譯器轉譯后才能成為機器碼的中間代碼。
總結：字節碼是一種中間狀態（中間碼）的二進制代碼（文件）。需要直譯器轉譯后才能成為機器碼。
簡述變量命名規范?
#1、以字母，數字，下劃線任由結合
#2、不能以命名太長，不使用拼音，中文
#3、不能以數字開頭
#4、不能用關鍵詞
15:三元運算寫法和應用場景？
應用場景：簡化if語句
# 條件成立時的結果 + if ?+ 條件 ?+ else + 條件不成立時的結果，例：
result = 'gt' if 1>3 else 'lt'
print(result) ? ? ? # lt
# 理解：如果條件為真，把if前面的值賦值給變量，否則把else后面的值賦值給變量。
16:Python3和Python2的區別？
鏈接：Python2 和 Python3 的區別
1：打印時，py2需要可以不需要加括號，python3 必須加括號
python 2 ：print ('lili') ? 或 ?print 'lili'
python 3 ：print ('lili') ??exec語句被python3廢棄，統一使用exec函數
2：內涵
Python2 ：1，臃腫，源碼的重復量很多。
? ? ? ? ? ? 2，語法不清晰，摻雜著C，php，Java，的一些陋習。
Python3 ：幾乎是重構后的源碼，規范，清晰，優美。3、輸出中文的區別
python2 ：要輸出中文 需加 # -*- encoding:utf-8 -*-
Python3 ：直接搞4：input不同
python2 ：raw_input
python3 ：input 統一使用input函數5：指定字節
python2在編譯安裝時，可以通過參數-----enable-unicode=ucs2 或-----enable-unicode=ucs4分別用于指定使用2個字節、4個字節表示一個unicode；
python3無法進行選擇，默認使用 ucs4
查看當前python中表示unicode字符串時占用的空間：impor sys
print（sys.maxunicode）
#如果值是65535，則表示使用usc2標準，即：2個字節表示
#如果值是1114111，則表示使用usc4標準，即：4個字節表示6：
py2：xrange
?range
py3：range ?統一使用range，Python3中range的機制也進行修改并提高了大數據集生成效率7：在包的知識點里
包：一群模塊文件的集合 + __init__
區別：py2 ： 必須有__init__
py3：不是必須的了8：不相等操作符"<>"被Python3廢棄，統一使用"!="
9：long整數類型被Python3廢棄，統一使用int
10：迭代器iterator的next()函數被Python3廢棄，統一使用next(iterator)
11：異常StandardError 被Python3廢棄，統一使用Exception
12：字典變量的has_key函數被Python廢棄，統一使用in關鍵詞
13：file函數被Python3廢棄，統一使用open來處理文件，可以通過io.IOBase檢查文件類型
17：用一行代碼實現數值交換
a = 1
b = 2
a, b = b, a
20：文件操作時：xreadlines和readlines的區別？
readlines????返回一個列表
xreadlines???返回一個生成器
python3 中只有readlines
21：?列舉布爾值為False的常見值？
0，“”，{}，[],（），set（） False ?負數 不成立的表達式 ?None 等
22. 字符串、列表、元組、字典每個常用的5個方法？
參考鏈接：Python 之數據類型
字符串：字符串用單引號(')或雙引號(")括起來，不可變
? ? 1，find通過元素找索引，可切片，找不到返回-1
? ? 2，index，找不到報錯。
? ? 3，split 由字符串分割成列表，默認按空格。
? ? 4，captalize 首字母大寫，其他字母小寫。
? ? 5，upper 全大寫。
? ? 6，lower 全小寫。
? ? 7，title，每個單詞的首字母大寫。
? ? 8，startswith 判斷以什么為開頭，可以切片，整體概念。
? ? 9，endswith 判斷以什么為結尾，可以切片，整體概念。
? ? 10，format格式化輸出，三種玩法
? ? ? ? ?res='{} {} {}'.format('egon',18,'male') ?==> ?egon 18 male
? ? ? ? ?res='{1} {0} {1}'.format('egon',18,'male') ?==> 18 egon 18
? ? ? ? ?res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
? ? 11，strip 默認去掉兩側空格，有條件
? ? 12，lstrip,rstrip?
? ? 14，center 居中，默認空格。?
? ? 15，count查找元素的個數，可以切片，若沒有返回0?
? ? 16，expandtabs 將一個tab鍵變成8個空格，如果tab前面的字符長度不足8個，則補全8個，
? ? 17，replace（old，new,次數）?
? ? 18，isdigit 字符串由字母或數字組成 isalpha, 字符串只由字母組成 isalnum 字符串只由數字組成?
? ? 19，swapcase 大小寫翻轉?
? ? 20，for i in 可迭代對象。字典：1無序（不能索引）2：數據關聯性強3:鍵值對，鍵值對。唯一一個映射數據類型。
# 字典的鍵必須是可哈希的 ? 不可變類型。
# 在同一個字典中，鍵(key)必須是唯一的。
# 列表是有序的對象集合，字典是無序的對象集合。兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取
? ? key： 輸出所有的鍵
? ? clear：清空 ? ? ? ? ? ? ? ? ? ? ??
? ? dic：刪除的鍵如果沒有則報錯
? ? pop：鍵值對刪，有返回，沒有原來的鍵會報錯（自行設置返回鍵就不會報錯）
? ? popitem：隨機刪鍵值對
? ? del：刪除的鍵如果沒有則報錯
? ? update：改?
? ? 查 ?用get時，不會報錯，沒有可以返回設定的返回值
注意：
? ? 1、字典是一種映射類型，它的元素是鍵值對。
? ? 2、字典的關鍵字必須為不可變類型，且不能重復。
? ? 3、創建空字典使用 { }。列表：
索引，切片，加，乘，檢查成員。
增加：有三種，
? ? append：在后面添加。
? ? insert按照索引添加，
? ? expend：迭代著添加。
? ? list.extend(seq) - 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）
? ? pop 刪除 ? (pop 有返回值)
? ? remove 可以按照元素去刪
? ? clear ?清空列表
? ? del 1、可以按照索引去刪除 2、切片 3、步長（隔著刪）
改 ?1、索引 ?2、切片：先刪除，再迭代著添加
? ? list.count(obj) - 統計某個元素在列表中出現的次數
? ? list.index(obj) - 從列表中找出某個值第一個匹配項的索引位置
? ? list.reverse() - 反向列表中元素
? ? list.sort([func]) - 對原列表進行排序
注意：
1、List寫在方括號之間，元素用逗號隔開。
2、和字符串一樣，list可以被索引和切片。
3、List可以使用+操作符進行拼接。
4、List中的元素是可以改變的。元組：
（）元組的元素不能修改
1、cmp(tuple1, tuple2)：比較兩個元組元素。
2、len(tuple)：計算元組元素個數。
3、max(tuple)：返回元組中元素最大值。
4、min(tuple)：返回元組中元素最小值。
5、tuple(seq)：將列表轉換為元組。
注意
1、與字符串一樣，元組的元素不能修改。
2、元組也可以被索引和切片，方法一樣。
3、注意構造包含0或1個元素的元組的特殊語法規則。
4、元組也可以使用+操作符進行拼接。
Set（集合）
集合（set）是一個無序不重復元素的序列。
可以使用大括號 { } 或者 set() 函數創建集合，
注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
23、?lambda表達式格式以及應用場景？
匿名函數：為了解決那些功能很簡單的需求而設計的一句話函數
函數名 = lambda 參數 ：返回值# 參數可以有多個，用逗號隔開
# 匿名函數不管邏輯多復雜，只能寫一行，且邏輯執行結束后的內容就是返回值
# 返回值和正常的函數一樣可以是任意數據類型temp = lambda x,y:x+y
print(temp(4,10)) ? # 14可替代：
def foo(x,y):
? ? return x+y
print(foo(4,10)) ? ?# 14
24. pass的作用
pass是空語句，是為了保持程序結構的完整性。pass 不做任何事情，一般用做占位語句。
25. *arg和**kwarg作用
*args代表位置參數，它會接收任意多個參數并把這些參數作為元祖傳遞給函數。
**kwargs代表的關鍵字參數，返回的是字典，位置參數一定要放在關鍵字前面
26. is和==的區別
a = 'lishi'
str1 = "li"
str2 = "shi"
str3 = str1 + str2
print("a == str3",a == str3) ? ?# a == str3 True ? == ---> 只需要內容相等
print("a is str3",a is str3) ? ? ? ?# a is str3 False ?is ---> 只需要內存地址相等
print("id(a)",id(a)) ? ? ? ? ? ? ? ? ? # id(a) 38565848
print("id(str3)",id(str3)) ? ? ? ? # id(str3) 39110280
is 比較的是兩個實例對象是不是完全相同，它們是不是同一個對象，占用的內存地址是否相同。
== 比較的是兩個對象的內容是否相等，即內存地址可以不一樣，內容一樣就可以了。默認會調用對象的 __eq__()方法。
# 對于int 小數據池
? 范圍：-5 到 256 創建的相間的數字，都指向同一個內存地址# 對于字符串 （面試）
1、小數據池 如果有空格，那指向兩個內存地址，
2、長度不能超過 20
3、不能用特殊字符i = 'a'*20
j = 'a'*20
print(i is j) ? # Truei = "a"*21
j = "a"*21
print(i is j) ? # False
27：談談Python的深淺拷貝？以及實現方法和應用場景。
淺拷貝只是增加了一個指針指向一個存在的地址，
而深拷貝是增加一個指針并且開辟了新的內存，這個增加的指針指向這個新的內存，
采用淺拷貝的情況，釋放內存，會釋放同一內存，深拷貝就不會出現釋放同一內存的錯誤
# 一層的情況：
import copy# 淺拷貝
li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2) ?# [1, 2, 3, 4] [1, 2, 3]
# 深拷貝
li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2) ?# [1, 2, 3, 4] [1, 2, 3]# 多層的情況：
import copy# 淺拷貝 指向共有的地址
li1 = [1, 2, 3,[4,5],6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2) ?# [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]
# 深拷貝 重指向
li1 = [1, 2, 3,[4,5],6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2) ?# [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]28. Python垃圾回收機制？
參考：Python內存管理以及垃圾回收機制
Python垃圾回收機制,主要使用'引用計數'來跟蹤和回收垃圾。
在'引用計數'的基礎上，通過'標記-清除'（mark and sweep）解決容器對象可能產生的循環引用問題.
通過'分代回收'以空間換時間的方法提高垃圾回收效率。'引用計數'
PyObject是每個對象必有的內容，其中ob_refcnt就是做為引用計數。
當一個對象有新的引用時，它的ob_refcnt就會增加，當引用它的對象被刪除，
它的ob_refcnt就會減少.引用計數為0時，該對象生命就結束了。
優點:1.簡單 2.實時性
缺點:1.維護引用計數消耗資源 2.存在循環引用的話，不能刪除'標記-清楚機制'
基本思路是先按需分配，等到沒有空閑內存的時候從寄存器和程序棧上的引用出發，
遍歷以對象為節點、以引用為邊構成的圖，把所有可以訪問到的對象打上標記，
然后清掃一遍內存空間，把所有沒標記的對象釋放。'分代技術'
分代回收的整體思想是：
將系統中的所有內存塊根據其存活時間劃分為不同的集合，每個集合就成為一個“代”，
垃圾收集頻率隨著“代”的存活時間的增大而減小，存活時間通常利用經過幾次垃圾回收來度量。
29. Python的可變類型和不可變類型？
可變數據類型：列表、字典、可變集合
不可變數據類型：數字、字符串、元組、不可變集合
30、求結果
print([i*i for i in [1,2,3]]) # [1, 4, 9]
def multipliers():
? ? return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
# 解釋：
# 函數返回值為一個列表表達式，經過4次循環結果為包含四個lambda函數的列表，?
# 由于函數未被調用，循環中的i值未被寫入函數，經過多次替代，循環結束后i值為3，?
# 故結果為：6,6,6,6# 請修改multipliers的定義來產生期望的結果（0,2,4,6）。
def multipliers():
? ? return （lambda x:i*x for i in range(4)） ? ? ? ? # 返回一個生成器表達式
print([m(2) for m in multipliers()])
現有兩個元組(('a'),('b')),(('c'),('d'))，請使用python中匿名函數生成列表[{'a':'c'},{'b':'d'}]
# 匿名函數形式：
l1=(('a'),('b'))
l2=(('c'),('d'))
ret=map(lambda n:{n[0]:n[1]},zip(l1,l2))
print(list(ret))
# 列表表達式形式：
l1=(('a'),('b'))
l2=(('c'),('d'))
print([{n[0]:n[1]} for n in zip(l1,l2)])
v = dict.fromkeys(['k1', 'k2'], [])
v['k1'].append(666)
print(v)
v['k1'] = 777
print(v)結果：
{'k1': [666], 'k2': [666]}
{'k1': 777, 'k2': [666]}解釋：
dict.fromkeys(seq[, value]) 函數用于創建一個新字典，
以序列seq中元素做字典的鍵，value為字典所有鍵對應的初始值，默認為None。v1 = dict.fromkeys(['k1', 'k2'])
print(v1) ?# {'k1': None, 'k2': None}
?
v2 = dict.fromkeys(['k1', 'k2'], [])
print(v2) ?# {'k1': [], 'k2': []}
32、列舉常見的內置函數
abs() # 返回數字的絕對值
map() # 根據函數對指定序列做映射，函數接收兩個參數，一個是函數，一個是可迭代對象，map將傳入的函數依次作用到序列的每個元素，并把結果作為新的list返回。
# 返回值：
Python2 ?返回列表
Python3 ?返回迭代器
# 例子1：
def mul(x):
? ? return x*x
n = [1,2,3,4,5]
res = list(map(mul,n))
print(res) ? ? ? ? # [1, 4, 9, 16, 25]# 例子2：abs() ?返回數字的絕對值
ret = map(abs,[-1,-5,6,-7])
print(list(ret)) ? ?# [1, 5, 6, 7]filter() # 函數接收一個函數 f(函數)和一個list（可迭代對象），這個函數 f的作用是對每個元素進行判斷，
返回 True或 False，根據判斷結果自動過濾掉不符合條件的元素，返回由符合條件元素組成的新list。
def is_odd(x):
? ? return x % 2 == 1
v=list(filter(is_odd, [1, 4, 6, 7, 9, 12, 17]))
print(v) ? ? ?# [1, 7, 9, 17]
map與filter總結
# 相同點
? ? # 參數: 都是一個函數名 + 可迭代對象
? ? # 返回值: 都是返回可迭代對象
# 區別:
? ? # filter 是做篩選的，結果還是原來就在可迭代對象中的項
? ? # map 是對可迭代對象中每一項做操作的，結果不一定是原來就在可迭代對象中的項
isinstance\type
isinstance() 函數來判斷一個對象是否是一個已知的類型，類似 type()。
isinstance() 與 type() 區別：
? ? type() 不會認為子類是一種父類類型，不考慮繼承關系。
? ? isinstance() 會認為子類是一種父類類型，考慮繼承關系。
如果要判斷兩個類型是否相同推薦使用 isinstance()。
# 例一
a = 2
print(isinstance(a,int)) ? # True
print(isinstance(a,str)) ? # False# type() 與 isinstance() 區別
class A:
? ? pass
class B(A):
? ? passprint("isinstance",isinstance(A(),A)) ? ?# isinstance True
print("type",type(A()) ?== A) ? ? ? ? ? ?# type Trueprint('isinstance',isinstance(B(),A) ) ? # isinstance True
print('type',type(B()) == A) ? ? ? ? ? ? # type False
zip 拉鏈函數，用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。
? 將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表迭代器。
? 如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同。
print(list(zip([0,1,3],[5,6,7],['a','b']))) ? ?# [(0, 5, 'a'), (1, 6, 'b')]
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) ? ? # 打包為元組的列表 ?[(1, 4), (2, 5), (3, 6)]
zip(a,c) ? ? ? ? ? ? ?# 元素個數與最短的列表一致 ?[(1, 4), (2, 5), (3, 6)]
zip(*zipped) ? ? ? ? ?# 與 zip 相反，可理解為解壓，返回二維矩陣式 ?[(1, 2, 3), (4, 5, 6)]reduce # 函數會對參數序列中元素進行累積，函數將一個數據集合(鏈表、元組等)中的所有數據進行下列操作
注意：Python3已經將reduce() 函數從全局名字空間里移除了，它現在被放置在 fucntools 模塊里，如果想要使用它，則需要通過引入 functools 模塊來調用 reduce() 函數：from functools import reduce
def add(x,y):
? ? return x + yprint(reduce(add,[1,2,3,4,5])) ?# ?15
print(reduce(lambda x, y: x+y, [1,2,3,4,5])) ?# 15
print(reduce(add,range(1,101))) ?# ?5050
33.?filter、map、reduce的作用？
見上題
34、?一行代碼實現9*9乘法表
print('\n'.join([' '.join(['%s*%s=%-2s' % (j, i, i * j) for j in range(1, i + 1)]) for i in range(1, 10)]))
35. 如何安裝第三方模塊？以及用過哪些第三方模塊？
1：pip包管理器
2：源碼下載
? ? -下載
? ? -解壓
-python setup.py build
-python setup.py install
用過的第三方模塊：requests,pymysql,DbUtils,SQLAlchemy等
36、?常用模塊都有那些？
re：正則
os：提供了一種方便的使用操作系統函數的方法。
sys：可供訪問由解釋器使用或維護的變量和與解釋器進行交互的函數。
random：隨機數
json：序列化
time：時間
datatime
logging
hlib
math，
爬蟲里面的requests/beautifulsoup4（bs4）
37. re的match和search區別？
re.match 嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()就返回none。
re.search 掃描整個字符串并返回第一個成功的匹配。
38. 什么是正則的貪婪匹配？
匹配一個字符串沒有節制，能匹配多少就去匹配多少，直到沒有匹配的為止
39. 求結果：
print([ i % 2 for i in range(10) ]) ?# [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
print([ i ?for i in range(10) ]) ? ? # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([ 10 % 2]) ? # [0]
# %是個運算符。print(( i % 2 for i in range(10) ))
# ?<generator object <genexpr> at 0x00000000020CEEB8> 生成器
# 在Python中，有一種自定義迭代器的方式，稱為生成器（Generator）。
# 定義生成器的兩種方式：
# 1.創建一個generator，只要把一個列表生成式的[]改成()，就創建了一個generator：
# generator保存的是算法，每次調用next()，就計算出下一個元素的值，直到計算到最后一個元素，
沒有更多的元素時，拋出StopIteration的錯誤。
# 2.定義generator的另一種方法。如果一個函數定義中包含yield關鍵字，那么這個函數就不再是一個普通函數，
而是一個generator
40. 求結果：
1 or 2 ? ? ?# 1
1 and 2 ? ? # 2
1 < (2==2) ?# False
1 < 2 == 2 ?# True
41、def func(a,b=[]) 這種寫法有什什么坑？
# 函數傳參為列表陷阱，列表是可變數據類型，可能會在過程中修改里面的值
def func(a,b = []):
? ? b.append(1)
? ? print(a,b)func(a=2)
func(2)
func(2)
'''
? ? 2 [1]
? ? 2 [1, 1]
? ? 2 [1, 1, 1]
? ? 函數的默認參數是一個list 當第一次執行的時候實例化了一個list?
? ? 第二次執行還是用第一次執行的時候實例化的地址存儲?
? ? 所以三次執行的結果就是 [1, 1, 1] 想每次執行只輸出[1] ，默認參數應該設置為None
'''
42、如何實現 “1,2,3” 變成 [‘1’,’2’,’3’]
list("1,2,3".split(','))
43. 如何實現[‘1’,’2’,’3’]變成[1,2,3]
[int(x) for x in ['1','2','3']]
44.?a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c?= [(1,),(2,),(3,) ] 的區別？
一個是數字類型，一個是元祖類型
補充1：
a=[1,2,3,4,5]，b=a和b=a[:]，有區別么？a = [1,2,3,4,5]
b = a
b1 = a[:]
print(b) ? ?# ?[1, 2, 3, 4, 5]
# print(b1) ? # ?[1, 2, 3, 4, 5]b.append(6)
print("a",a) ?# a [1, 2, 3, 4, 5, 6]
print("b",b) ?# b [1, 2, 3, 4, 5, 6] ?傳遞引用
print("b1",b1) # b1 [1, 2, 3, 4, 5] ? 拷貝# 補充2
一個列表A=[2，3，4]，Python如何將其轉換成B=[(2,3),(3,4),(4,2)]？
B = zip(A, A[1:]+A[:1])
45. 如何用一行代碼生成[1,4,9,16,25,36,49,64,81,100]
[i*i for i in range(1,11)]
46. 一行代碼實現刪除列表中重復的值
list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))
47.?如何在函數中設置一個全局變量
python中的global語句是被用來聲明全局變量的。
x = 2
def func():
? ? global x
? ? x = 1
? ? return x
func()
print(x) ?# 1
48. logging模塊的作用？以及應用場景？
logging?
模塊定義的函數和類為應用程序和庫的開發實現了一個靈活的事件日志系統作用：可以了解程序運行情況，是否正常
在程序的出現故障快速定位出錯地方及故障分析DEBUG：詳細的信息,通常只出現在診斷問題上
INFO：確認一切按預期運行
WARNING：一個跡象表明,一些意想不到的事情發生了,或表明一些問題在不久的將來(例如。磁盤空間低”)。這個軟件還能按預期工作。
ERROR：更嚴重的問題,軟件沒能執行一些功能
CRITICAL：一個嚴重的錯誤,這表明程序本身可能無法繼續運行
49. 請用代碼簡答實現stack
- Stack() 創建一個新的空棧
- push(item) 添加一個新的元素item到棧頂
- pop() 彈出棧頂元素
- peek() 返回棧頂元素
- is_empty() 判斷棧是否為空
- size() 返回棧的元素個數
# 實現一個棧stack,后進先出'''
class Stack:def __init__(self):self.items = []def is_empty(self):# 判斷是否為空return self.items == []def push(self,item):# 加入元素self.items.append(item)def pop(self):# 彈出元素return self.items.pop()def peek(self):# 返回棧頂元素return self.items[len(self.items)-1]def size(self):# 返回棧的大小return len(self.items)if __name__ == "__main__":stack = Stack()stack.push("H")stack.push("E")stack.push("L")print(stack.size()) ?# 3print(stack.peek()) ?# L?print(stack.pop()) ? # Lprint(stack.pop()) ? # Eprint(stack.pop()) ? # H
50. 常用字符串格式化哪幾種？
1.占位符%
%d 表示那個位置是整數；%f 表示浮點數；%s 表示字符串。print('Hello,%s' % 'Python')
print('Hello,%d%s%.2f' % (666, 'Python', 9.99)) # 打印：Hello,666Python10.002.format
print('{k} is {v}'.format(k='python', v='easy')) ?# 通過關鍵字
print('{0} is {1}'.format('python', 'easy')) ? ? ?# 通過關鍵字
51. 簡述 生成器、迭代器、可迭代對象 以及應用場景？
迭代器：含有__iter__和__next__方法 (包含__next__方法的可迭代對象就是迭代器)
生成器：包括含有yield這個關鍵字，生成器也是迭代器，調動next把函數變成迭代器。
應用場景：
1、range/xrange
? ? - py2： range(1000000) 會立即創建，xrange(1000000)生成器
? ? - py3：range（10000000）生成器?2、 redis獲取值hscan_iter用到了
conn = Redis(...)def hscan_iter(self, name, match=None, count=None):
? ? cursor = '0'
? ? while cursor != 0:
? ? ? ? # 去redis中獲取數據：12
? ? ? ? # cursor，下一次取的位置
? ? ? ? # data：本地獲取的12條數數據
? ? ? ? cursor, data = self.hscan(name, cursor=cursor,match=match, count=count)
? ? ? ? for item in data.items():
? ? ? ? ? ? ?yield item
3、stark組件
def index(request):
data = [
{'k1':1,'name':'alex'},
{'k1':2,'name':'老男孩'},
{'k1':3,'name':'小男孩'},
]
new_data = []
for item in data:
item['email'] = "xxx@qq.com"
new_data.append(item)return render(request,'xx.html',{'data':new_data})
可迭代對象：一個類內部實現__iter__方法且返回一個迭代器。
應用場景：?
? ? - wtforms中對form對象進行循環時候，顯示form中包含的所有字段。
? ? ? ? class LoginForm(Form):
? ? ? ? ? ? name = simple.StringField(
? ? ? ? ? ? ? ? label='用戶名',
? ? ? ? ? ? ? ? validators=[
? ? ? ? ? ? ? ? ? ? validators.DataRequired(message='用戶名不能為空.'),
? ? ? ? ? ? ? ? ? ? validators.Length(min=6, max=18, message='用戶名長度必須大于%(min)d且小于%(max)d')
? ? ? ? ? ? ? ? ],
? ? ? ? ? ? ? ? widget=widgets.TextInput(),
? ? ? ? ? ? ? ? render_kw={'class': 'form-control'}
? ? ? ? ? ? )
? ? ? ? ? ? pwd = simple.PasswordField(
? ? ? ? ? ? ? ? label='密碼',
? ? ? ? ? ? ? ? validators=[
? ? ? ? ? ? ? ? ? ? validators.DataRequired(message='密碼不能為空.'),
? ? ? ? ? ? ? ? ? ? validators.Length(min=8, message='用戶名長度必須大于%(min)d'),
? ? ? ? ? ? ? ? ? ? validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? message='密碼至少8個字符，至少1個大寫字母，1個小寫字母，1個數字和1個特殊字符')? ? ? ? ? ? ? ? ],
? ? ? ? ? ? ? ? widget=widgets.PasswordInput(),
? ? ? ? ? ? ? ? render_kw={'class': 'form-control'}
? ? ? ? ? ? )?? ?
? ? ? ? form = LoginForm()
? ? ? ? for item in form:
? ? ? ? ? ? print(item)
? ? ? ? ? ??
? ? - 列表、字典、元組裝飾器
能夠在不修改原函數代碼的基礎上，在執行前后進行定制操作，閉包函數的一種應用
場景：
? ?- flask路由系統
? ?- flask before_request
? ?- csrf
? ?- django內置認證
? ?- django緩存
# 手寫裝飾器；
import functools
def wrapper(func):
? ?@functools.wraps(func) ?#不改變原函數屬性
? ?def inner(*args, **kwargs):
? ? ? 執行函數前
? ? ? return func(*args, **kwargs)
? ? ? 執行函數后
? ?return inner
1. 執行wapper函數，并將被裝飾的函數當做參數。 wapper(index)
2. 將第一步的返回值，重新賦值給 ?新index = ?wapper(老index)
@wrapper ? ?#index=wrapper(index)
def index(x):
? ?return x+100調用裝飾器其實是一個閉包函數，為其他函數添加附加功能，不修改被修改的源代碼和不修改被修飾的方式，裝飾器的返回值也是一個函數對象。
比如：插入日志、性能測試、事物處理、緩存、權限驗證等，有了裝飾器，就可以抽離出大量與函數功能本身無關的雷同代碼并繼續重用。
52. 用Python實現一個二分查找的函數。
二分查找算法：簡單的說，就是將一個列表先排序好，比如按照從小到大的順序排列好，當給定一個數據，比如3，查找3在列表中的位置時，可以先找到列表中間的數li[middle]和3進行比較，當它比3小時，那么3一定是在列表的右邊，反之，則3在列表的左邊，比如它比3小，則下次就可以只比較[middle+1, end]的數，繼續使用二分法，將它一分為二，直到找到3這個數返回或者列表全部遍歷完成（3不在列表中）
優點：效率高，時間復雜度為O(logN)；
缺點：數據要是有序的，順序存儲。
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]def search(someone, li):l = -1h = len(li)while l + 1 != h:m = int((l + h) / 2)if li[m] < someone:l = melse:h = mp = hif p >= len(li) or li[p] != someone:print("元素不存在")else:str = "元素索引為%d" % pprint(str)search(3, li) ?# 元素索引為253. 談談你對閉包的理解？
判斷閉包函數的方法：__closure__，輸出的__closure__有cell元素說明是閉包函數?
閉包的意義與應用：延遲計算：
bar在foo函數的代碼塊中定義。我們稱bar是foo的內部函數。
在bar的局部作用域中可以直接訪問foo局部作用域中定義的m、n變量。
簡單的說，這種內部函數可以使用外部函數變量的行為，就叫閉包。def foo():
? ? m=3
? ? n=5
? ? def bar():
? ? ? ? a=4
? ? ? ? return m+n+a
? ? return bar
??
bar = ?foo()
bar() ? ? ? ?# 12
54. os和sys模塊的作用？
os模塊負責程序與操作系統的交互，提供了訪問操作系統底層的接口;
sys模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用于操控python的運行時環境。os與sys模塊的官方解釋如下：
os: This module provides a portable way of using operating system dependent functionality.
這個模塊提供了一種方便的使用操作系統函數的方法。
sys: This module provides access to some variables used or maintained by the interpreter and to?
functions that interact strongly with the interpreter.
這個模塊可供訪問由解釋器使用或維護的變量和與解釋器進行交互的函數。
os 常用方法
os.remove() 刪除文件
os.rename() 重命名文件
os.walk() 生成目錄樹下的所有文件名
os.chdir() 改變目錄
os.mkdir/makedirs 創建目錄/多層目錄
os.rmdir/removedirs 刪除目錄/多層目錄
os.listdir() 列出指定目錄的文件
os.getcwd() 取得當前工作目錄
os.chmod() 改變目錄權限
os.path.basename() 去掉目錄路徑，返回文件名
os.path.dirname() 去掉文件名，返回目錄路徑
os.path.join() 將分離的各部分組合成一個路徑名
os.path.split() 返回( dirname(), basename())元組
os.path.splitext() 返回 (filename, extension) 元組
os.path.getatime\ctime\mtime 分別返回最近訪問、創建、修改時間
os.path.getsize() 返回文件大小
os.path.exists() 是否存在
os.path.isabs() 是否為絕對路徑
os.path.isdir() 是否為目錄
os.path.isfile() 是否為文件
sys 常用方法
sys.argv 命令行參數List，第一個元素是程序本身路徑
sys.modules.keys() 返回所有已經導入的模塊列表
sys.exc_info() 獲取當前正在處理的異常類,exc_type、exc_value、exc_traceback當前處理的異常詳細信息
sys.exit(n) 退出程序，正常退出時exit(0)
sys.hexversion 獲取Python解釋程序的版本值，16進制格式如：0x020403F0
sys.version 獲取Python解釋程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.modules 返回系統導入的模塊字段，key是模塊名，value是模塊
sys.path 返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform 返回操作系統平臺名稱
sys.stdout 標準輸出
sys.stdin 標準輸入
sys.stderr 錯誤輸出
sys.exc_clear() 用來清除當前線程所出現的當前的或最近的錯誤信息
sys.exec_prefix 返回平臺獨立的python文件安裝的位置
sys.byteorder 本地字節規則的指示器，big-endian平臺的值是'big',little-endian平臺的值是'little'
sys.copyright 記錄python版權相關的東西
sys.api_version 解釋器的C的API版本
總結：
os模塊負責程序與操作系統的交互，提供了訪問操作系統底層的接口;
sys模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用于操控python的運行時環境。
55. 如何生成一個隨機數？
import randomprint(random.random()) ? ? ? ? ?# 用于生成一個0到1的隨機符點數: 0 <= n < 1.0
print(random.randint(1, 1000)) ?# 用于生成一個指定范圍內的整數56. 如何使用python刪除一個文件？
import os
os.remove('文件名以及路徑')57. 談談你對面向對象的理解
三大特性以及解釋？
面對對象是一種編程思想，以類的眼光來來看待事物的一種方式。將有共同的屬性和方法的事物封裝到同一個類下面。
繼承：將多個類的共同屬性和方法封裝到一個父類下面，然后在用這些類來繼承這個類的屬性和方法
封裝：將有共同的屬性和方法封裝到同一個類下面
第一層面：創建類和對象會分別創建二者的名稱空間，我們只能用類名.或者obj.的方式去訪問里面的名字，這本身就是一種封裝
第二層面：類中把某些屬性和方法隱藏起來(或者說定義成私有的)，只在類的內部使用、外部無法訪問，或者留下少量接口（函數）供外部訪問。
多態：Python天生是支持多態的。指的是基類的同一個方法在不同的派生類中有著不同的功能
58. Python面向對象中的繼承有什么特點
繼承概念的實現方式主要有2類：實現繼承、接口繼承。
? ? 實現繼承是指使用基類的屬性和方法而無需額外編碼的能力；
? ? 接口繼承是指僅使用屬性和方法的名稱、但是子類必須提供實現的能力(子類重構爹類方法)；
python 兩種類：經典類 新式類
python3 新式類 —— 都默認繼承object class Animal(object): == class Animal:
python2 經典類和新式類 并存
? ? ? ? class Animal: ?經典類 —— 繼承順序 個別使用方法
? ? ? ? class Animal(object): ?新式類繼承分為單繼承和多繼承，Python是支持多繼承的
如果沒有指定基類，python的類會默認繼承object類，object是所有python類的基類，它提供了一些常見方法（如__str__）的實現。
補充繼承的應用（面試題）1、對象可以調用自己本類和父類的所有方法和屬性， 先調用自己的 自己沒有才調父類的。誰（對象）調用方法，方法中的self就指向誰
class Foo:
? ? def __init__(self):
? ? ? ? self.func()? ? def func(self):
? ? ? ? print('Foo.func')class Son(Foo):
? ? def func(self):
? ? ? ? print('Son.func')s = Son() ? ? # Son.func
========================================================
class A:
? ? def get(self):
? ? ? ? self.say()? ? def say(self):
? ? ? ? print('AAAAA')class B(A):
? ? def say(self):
? ? ? ? print('BBBBB')b = B()
b.get() ? #輸出結果為：BBBBB
59. 面向對象深度優先和廣度優先是什么？
Python的類可以繼承多個類，Python的類如果繼承了多個類，那么其尋找方法的方式有兩種
當類是經典類時，多繼承情況下，會按照深度優先方式查找
當類是新式類時，多繼承情況下，會按照廣度優先方式查找 ?
簡單點說就是：經典類是縱向查找，新式類是橫向查找
經典類和新式類的區別就是，在聲明類的時候，新式類需要加上object關鍵字。在python3中默認全是新式類
60. 面向對象中super的作用？
# 用于子類繼承基類的方法
class FooParent(object):def __init__(self):self.parent = 'I\'m the parent.'print('Parent')print('1111')def bar(self, message):print("%s from Parent" % message)class FooChild(FooParent):def __init__(self):# super(FooChild,self) 首先找到 FooChild 的父類（就是類 FooParent），然后把類FooChild的對象轉換為類 FooParent 的對象super(FooChild, self).__init__()print('Child')# def bar(self, message):# ? ? # super(FooChild, self).bar(message)# ? ? print('Child bar fuction')# ? ? print(self.parent)if __name__ == '__main__':fooChild = FooChild()fooChild.bar('HelloWorld')61. 是否使用過functools中的函數？其作用是什么？
# 用于修復裝飾器import functoolsdef deco(func):@functools.wraps(func) ?# 加在最內層函數正上方def wrapper(*args, **kwargs):return func(*args, **kwargs)return wrapper@deco
def index():'''哈哈哈哈'''x = 10print('from index')print(index.__name__)
print(index.__doc__)# 加@functools.wraps
# index
# 哈哈哈哈# 不加@functools.wraps
# wrapper
# None62. 列舉面向對象中帶雙下劃線的特殊方法，如：__new__、__init__
__iter__：用于迭代器，之所以列表、字典、元組可以進行for循環，是因為類型內部定義了 __iter__。
__doc__：表示類的描述信息。
__new__：生成實例
__init__：生成實例的屬性，構造方法，通過類創建對象時，自動觸發執行。
__call__：實例對象加( )會執行def __call__:... 方法里邊的內容。
__del__：析構方法，當對象在內存中被釋放時，自動觸發執行。如當 del obj 或者應用程序運行完畢時，執行該方法里邊的內容。
__enter__和__exit__：出現with語句,對象的__enter__被觸發,有返回值則賦值給as聲明的變量；with中代碼塊執行完畢時執行__exit__里邊的內容。
__module__：表示當前操作的對象在那個模塊???obj.__module__
__class__ ：表示當前操作的對象的類是什么?????obj.__class____doc__：類的描述信息，該描述信息無法被繼承
__str__：改變對象的字符串顯示 print函數 --->obj.__str__()如果一個類中定義了__str__方法，那么在打印對象時，默認輸出該方法的返回值。
__repr__：改變對象的字符串顯示 交互式解釋器 --->obj.__repr__()
__format__：自定制格式化字符串__slots__:一個類變量 用來限制實例可以添加的屬性的數量和類型
__dict__：類或對象中的所有成員。
__setitem__,__getitem,__delitem__:用于索引操作，如字典。以上分別表示獲取、設置、刪除數據。
class Foo:def __init__(self,name):self.name=namedef __getitem__(self, item):print(self.__dict__[item])def __setitem__(self, key, value):self.__dict__[key]=valuedef __delitem__(self, key):print('del obj[key]時,我執行')self.__dict__.pop(key)def __delattr__(self, item):print('del obj.key時,我執行')self.__dict__.pop(item)f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)
__get__():調用一個屬性時,觸發
__set__():為一個屬性賦值時,觸發
__delete__():采用del刪除屬性時,觸發63. 如何判斷是函數還是方法？
# 看他的調用者是誰，如果是類，就需要傳入一個參數self的值，這時他就是一個函數，
# 如果調用者是對象，就不需要給self傳入參數值，這時他就是一個方法class Foo(object):def __init__(self):self.name = 'lcg'def func(self):print(self.name)obj = Foo()
print(obj.func) ?# <bound method Foo.func of <__main__.Foo object at 0x000001ABC0F15F98>>
print(Foo.func) ?# <function Foo.func at 0x000001ABC1F45BF8>from types import FunctionType, MethodType
print(isinstance(obj.func, FunctionType)) ?# False
print(isinstance(obj.func, MethodType)) ? ?# Trueprint(isinstance(Foo.func, FunctionType)) ?# True
print(isinstance(Foo.func, MethodType)) ? ?# False"""
注意：方法，無需傳入self參數函數，必須手動傳入self參數
"""64. 靜態方法和類方法區別？
盡管 classmethod 和 staticmethod 非常相似，但在用法上依然有一些明顯的區別。classmethod 必須有一個指向類對象的引用作為第一個參數，而 staticmethod 可以沒有任何參數。舉個栗子:
class Num:# 普通方法：能用Num調用而不能用實例化對象調用 ??def one(): ?print ('1')# 實例方法：能用實例化對象調用而不能用Num調用def two(self):print ('2')# 靜態方法：能用Num和實例化對象調用@staticmethod?def three(): ?print ('3')# 類方法：第一個參數cls長什么樣不重要，都是指Num類本身，調用時將Num類作為對象隱式地傳入方法 ??@classmethod?def go(cls):?cls.three()?Num.one() ? ? ? ? ?# 1
#Num.two() ? ? ? ? # TypeError: two() missing 1 required positional argument: 'self'
Num.three() ? ? ? ?# 3
Num.go() ? ? ? ? ? # 3i=Num() ? ? ? ? ? ? ? ?
#i.one() ? ? ? ? ? # TypeError: one() takes 0 positional arguments but 1 was given ? ? ? ??
i.two() ? ? ? ? ? ?# 2 ? ? ?
i.three() ? ? ? ? ?# 3
i.go() ? ? ? ? ? ? # 365. 列舉面向對象中的特殊成員以及應用場景
見上題。
66. 1、2、3、4、5 能組成多少個互不相同且無重復的三位數
import itertools
print(len(list(itertools.permutations('12345',3))))
# 60個題意理解：組成后的數值不相同，且組合的三個位數之間數字不重復。
使用python內置的排列組合函數（不放回抽樣排列）
? ? product 笛卡爾積 （有放回抽樣排列）
? ? permutations 排列 （不放回抽樣排列）
? ? combinations 組合,沒有重復 （不放回抽樣組合）
? ? combinations_with_replacement 組合,有重復 （有放回抽樣組合）
67. 什么是反射？以及應?用場景？
反射的核心本質就是以字符串的形式去導入個模塊，利用字符串的形式去執行函數。
Django中的 CBV就是基于反射實現的。
68. metaclass作用？以及應用場景？
metaclass用來指定類是由誰創建的。
類的metaclass 默認是type。我們也可以指定類的metaclass值。在python3中：
class MyType(type):
? ? def __call__(self, *args, **kwargs):
? ? ? ? return 'MyType'
??
??
class Foo(object, metaclass=MyType):
? ? def __init__(self):
? ? ? ? return 'init'
??
? ? def __new__(cls, *args, **kwargs):
? ? ? ? return cls.__init__(cls)
??
? ? def __call__(self, *args, **kwargs):
? ? ? ? return 'call'
??
??
obj = Foo()
print(obj) ?# MyType
69. 用盡量多的方法實現單例模式。
一個類可以有多個位置參數和多個命名參數，而在實例化開始之后，在調用 init()方法之前，Python首先調用new()方法：
def __new__(cls, *args, **kwargs):第一個參數cls是當前正在實例化的類。?
如果要得到當前類的實例，應當在當前類中的new()方法語句中調用當前類的父類 的new()方法。?
例如，如果當前類是直接繼承自object，那當前類的new()方法返回的對象應該為：
def __new__(cls, *args, **kwargs):
? ? ...
? ? return object.__new__(cls)
事實上如果（新式）類中沒有重寫new()方法，即在定義新式類時沒有重新定義new()時 ，
Python默認是調用該類的直接父類的new()方法來構造該類的實例，如果該類的父類也沒有重寫 new()，
那么將一直按此規矩追溯至object的new()方法，因為object是所有新式類的基類。?
而如果新式類中重寫了new()方法，那么你可以自由選擇任意一個的其他的新式類（必定要是 新式類，只有新式類必定都有new()，
因為所有新式類都是object的后代，而經典類則沒有new() 方法）的new()方法來制造實例，
包括這個新式類的所有前代類和后代類，只要它們不會造成遞歸死 循環
# 單例模式
'''單例模式是一種常用的軟件設計模式。在它的核心結構中只包含一個被稱為單例類的特殊類。
通過單例模式可以保證系統中一個類只有一個實例而且該實例易于外界訪問，從而方便對實例個數的控制并節約系統資源。
如果希望在系統中某個類的對象只能存在一個，單例模式是最好的解決方案。'''
# 1、使用__new__方法class Singleton(object):def __new__(cls, *args, **kw):if not hasattr(cls, '_instance'):orig = super(Singleton, cls) # 其實就是objectcls._instance = orig.__new__(cls, *args, **kw)return cls._instanceclass MyClass(Singleton):a = 1
# 2、共享屬性
# 創建實例時把所有實例的__dict__指向同一個字典,這樣它們具有相同的屬性和方法.class Borg(object):_state = {}def __new__(cls, *args, **kw):ob = super(Borg, cls).__new__(cls, *args, **kw)ob.__dict__ = cls._statereturn obclass MyClass2(Borg):a = 1
# 3、裝飾器版本def singleton(cls, *args, **kw):instances = {}def getinstance():if cls not in instances:instances[cls] = cls(*args, **kw)return instances[cls]return getinstance@singletonclass MyClass:...
# 4、import方法
# 作為python的模塊是天然的單例模式# mysingleton.pyclass My_Singleton(object):def foo(self):passmy_singleton = My_Singleton()# to usefrom mysingleton import my_singletonmy_singleton.foo()70. 裝飾器的寫法以及應用場景。
含義：裝飾器本質就是函數，為其他函數添加附加功能
原則：不修改被修飾函數的代碼，不修改被修飾函數的調用方式
應用場景：無參裝飾器在用戶登錄 認證中常見，有參裝飾器在flask的路由系統中見到過
import functools
def wrapper(func):
? ? @functools.wraps(func)
? ? def inner(*args, **kwargs):
? ? ? ? print('我是裝飾器')
? ? ? ? return func
return inner@wrapper
def index():
? ? print('我是被裝飾函數')
? ? return None
index()# 應用場景
? ? - 高階函數
? ? - 閉包
? ? - 裝飾器?
? ? - functools.wraps(func)
71. 異常處理寫法以及如何主動拋出異常（應用場景）
# 觸發異常
def temp_convert(var):try:return int(var)except ValueError as Argument:print ("參數沒有包含數字%s"%Argument)# 調用函數
temp_convert("xyz")
# 以10為基數的int()的無效文字:“xyz”----------------------------------------------------------------------------
# raise語法
# raise [Exception [, args [, traceback]]]
# 語句中 Exception 是異常的類型，args 是自已提供的異常參數。class Networkerror(RuntimeError):def __init__(self, arg):self.args = arg
try:raise Networkerror("Bad hostname")
except Networkerror as e:print(e.args)72、什么是面向對象的mro
mro就是方法解析順序
73. isinstance作用以及應用場景？
isinstance(對象，類)??判斷這個對象是不是這個類或者這個類的子類的實例化
# # 判斷a 屬不屬于A這個類（可以判斷到祖宗類）
class A:
? ? passclass B(A):
? ? pass
a = A()
b = B()
print(isinstance(b,A)) # ===> True ?判斷到祖宗類# 任何與object都是True,內部都繼承object
class A:pass
a = A() ?# 實例化
print(isinstance(a,object)) ?# ?True
應用場景：rest framework 認證的流程scrapy-redis
74. 寫代碼并實現
Given an array of integers, return?indices?of the two numbers such that they add up to a
specific target.You may assume that each input would have?exactly?one solution, and you may
not use the?same?element twice.
Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1]
class Solution:def twoSum(self, nums, target):""" :type nums: List[int] :type target: int :rtype: List[int] """# 用len()方法取得nums列表長度 n = len(nums)# x從0到n取值（不包括n） for x in range(n):a = target - nums[x]# 用in關鍵字查詢nums列表中是否有a if a in nums:# 用index函數取得a的值在nums列表中的索引 y = nums.index(a)# 假如x=y,那么就跳過,否則返回x,y if x == y:continueelse:return x, ybreakelse:continue75. json序列化時，可以處理的數據類型有哪些？如何定制支持datetime類型？
# 可序列化數據類型：
字典、列表、數字、字符串、元組；如果是元組，自動轉成列表（再轉回去的話也是列表）
# 自定義時間序列化轉換器
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):def default(self, obj):if isinstance(obj, datetime):return obj.strftime('%Y-%m-%d %H:%M:%S')else:return super(ComplexEncoder,self).default(obj)
d = { 'name':'alex','data':datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))
# {"name": "alex", "data": "2018-05-18 19:52:05"}
76. json序列化時，默認遇到中文會轉換成unicode，如果想要保留中文怎么辦？
import json
a=json.dumps({"xxx":"你好"},ensure_ascii=False)
print(a) #{"xxx": "你好"}77. 什么是斷言？應用場景？
assert 的作用？斷言
條件成立（布爾值為True）則繼續往下，否則拋出異常，一般用于：滿足某個條件之后，才能執行，否則拋出異常。寫API的時候，繼承GenericAPIViewclass GenericAPIView(views.APIView):"""Base class for all other generic views."""# You'll need to either set these attributes,# or override `get_queryset()`/`get_serializer_class()`.# If you are overriding a view method, it is important that you call# `get_queryset()` instead of accessing the `queryset` property directly,# as `queryset` will get evaluated only once, and those results are cached# for all subsequent requests.queryset = Noneserializer_class = None# If you want to use object lookups other than pk, set 'lookup_field'.# For more complex lookup requirements override `get_object()`.lookup_field = 'pk'lookup_url_kwarg = None# The filter backend classes to use for queryset filteringfilter_backends = api_settings.DEFAULT_FILTER_BACKENDS# The style to use for queryset pagination.pagination_class = api_settings.DEFAULT_PAGINATION_CLASSdef get_queryset(self):assert self.queryset is not None, ("'%s' should either include a `queryset` attribute, ""or override the `get_queryset()` method."% self.__class__.__name__)queryset = self.querysetif isinstance(queryset, QuerySet):# Ensure queryset is re-evaluated on each request.queryset = queryset.all()return queryset78. 有用過with statement嗎？它的好處是什么？
with語句適用于對資源進行訪問的場合，確保不管使用過程中是否發生異常都會執行必要的“清理”操作， 釋放資源，比如文件使用后自動關閉、線程中鎖的自動獲取和釋放等。
79. 使用代碼實現查看列舉目錄下的所有文件。
import os
path = os.listdir('.') #查看列舉目錄下的所有文件。
# path = os.listdir(os.getcwd())
print(path)80. 簡述 yield和yield from關鍵字
1、yield使用?
1）函數中使用yield，可以使函數變成生成器。一個函數如果是生成一個數組，就必須把數據存儲在內存中，如果使用生成器，則在調用的時候才生成數據，可以節省內存。
2）生成器方法調用時，不會立即執行。需要調用next()或者使用for循環來執行。2、yield from的使用
1）為了讓生成器（帶yield函數），能簡易的在其他函數中直接調用，就產生了yield from。
python是傳值還是傳引用
python不允許程序員選擇采用傳值還是傳引用。Python參數傳遞采用的肯定是“傳對象引用”的方式。這種方式相當于傳值和傳引用的一種綜合。如果函數收到的是一個可變對象（比如字典或者列表）的引用，就能修改對象的原始值－－相當于通過“傳引用”來傳遞對象。如果函數收到的是一個不可變對象（比如數字、字符或者元組）的引用，就不能直接修改原始對象－－相當于通過“傳值'來傳遞對象
(顏色代碼完整版))
![python調用matlab環境配置、非常詳細!!!_[python][matlab]使用python調用matlab程序](http://pic.xiahunao.cn/python調用matlab環境配置、非常詳細!!!_[python][matlab]使用python調用matlab程序)
