史上最全python面试题详解（一）（附带详细答案（持续更新））
1、簡述解釋型和編譯型編程語言？
概念：
編譯型語言：把做好的源程序全部編譯成二進制代碼的可運行程序。然后，可直接運行這個程序。
解釋型語言：把做好的源程序翻譯一句，然后執行一句，直至結束！
區別：
編譯型語言，執行速度快、效率高；依賴編譯器、跨平臺性差些。如C、C++、Delphi、Pascal，Fortran。
解釋型語言，執行速度慢、效率低；依賴解釋器、跨平臺性好。如Java、Basic.
2、Python解釋器種類以及特點
CPython
c語言開發的 使用最廣的解釋器
IPython
基于cpython之上的一個交互式計時器 交互方式增強 功能和cpython一樣
PyPy
目標是執行效率 采用JIT技術 對python代碼進行動態編譯，提高執行效率
JPython
運行在Java上的解釋器 直接把python代碼編譯成Java字節碼執行
IronPython
運行在微軟 .NET 平臺上的解釋器，把python編譯成. NET 的字節碼
3、python常見的PEP8規范
每級縮進用4個空格
Python 3中不允許混合使用Tab和空格縮進。
限制所有行的最大行寬為79字符。
在核心Python發布的代碼應該總是使用UTF-8(ASCII在Python 2)。
推薦絕對路徑導入，因為它們通常更可讀
4、通過代碼實現如下進制轉換：
1 hex() 2 轉換一個整數對象為十六進制的字符串 3 4 >>> hex(16) 5 '0x10' 6 >>> hex(18) 7 '0x12' 8 >>> hex(32) 9 '0x20'
1 oct() 2 轉換一個整數對象為八進制的字符串 3 4 >>> oct(8) 5 '0o10' 6 >>> oct(166) 7 '0o246'
1 bin() 2 轉換一個整數對象為二進制字符串 3 4 >>> bin(10) 5 '0b1010' 6 >>> bin(255) 7 '0b11111111'
1 chr() 2 轉換一個[0, 255]之間的整數為對應的ASCII字符 3 4 >>> chr(65) 5 'A' 6 >>> chr(67) 7 'C' 8 >>> chr(90) 9 'Z' 10 >>> chr(97) 11 'a'
1 ord()
2 將一個ASCII字符轉換為對應整數
3
4 >>> ord('A')
5 65
6 >>> ord('z')
7 122
1 16進制轉10進制
2 >>> int('10', 16)
3 16
4 >>> int('0x10', 16)
5 16
6
7 8進制轉10進制
8 >>> int('0o10', 8)
9 8
10 >>> int('10', 8)
11 8
12
13 2進制轉10進制
14 >>> int('0b1010', 2)
15 10
16 >>> int('1010', 2)
17 10
5、python遞歸的最大層數
1 import sys 2 sys.setrecursionlimit(100000) 3 4 def foo(n): 5 print(n) 6 n += 1 7 foo(n) 8 9 if __name__ == '__main__': 10 foo(1)
得到的最大數字在3925-3929之間浮動，這個是和計算機有關系的，不然也不會是一個浮動的數字了（數學邏輯講求嚴謹）
6、三元運算規則以及應用場景
三元運算符就是在賦值變量的時候，可以直接加判斷，然后賦值
三元運算符的功能與'if....else'流程語句一致，它在一行中書寫，代碼非常精煉，執行效率更高
格式：[on_true] if [expression] else [on_false]
res = 值1 if 條件 else 值2
7、列舉 Python2和Python3的區別
print
input
1 問題：如何獲取編碼方式的信息？
2 獲取目標bytes的編碼方式
3 這一情況可以通過chardet模塊的detect()函數來獲取信息，chardet是第三方庫，可以通過pip來安裝
4
5 b是待檢測的bytes變量
6
7 import chardet
8 print(chardet.detect(b))
9 ######output####
10 {'confidence': 1.0, 'encoding': 'ascii'}
11 1
12 2
13 3
14 4
15 5
16 confidence是指匹配程度，encoding是指可能的編碼方式
17
18 獲取當前環境的編碼方式
19 這一情況可以使用sys模塊下的getdefaultencoding()函數來獲取信息
20
21 import sys
22 print(sys.getdefaultencoding())
23
24 ######## output#####
25 utf-8
問題在控制臺上看到的到底是什么
1 寫上面的東西的時候產生了一個疑問，現在已經知道Python內部存儲str的方式是使用unicode字符集，但是我們在屏幕上看到的并不是unicode字符集 3 s = "你好" 4 print(s) 6 #########output############# 7 你好 13 s的 unicode 是 u4f60u597d 14 1 15 那么，這中間應該是進行了某種轉換 16 實際上，在執行print(str)的時候，python內部執行了encoding操作，控制臺拿到的其實是一個bytes變量 17 之后，控制臺又根據環境內部的編碼方式，將所得到的bytes內容進行decoding的操作，就顯示了原先str的內容
打開文件不再支持 file 方法，只能用 open
range不再返回列表，而是一個可迭代的range對象
除法 / 不再是整除，而是得到浮點數，整除需要用雙斜杠 //
urllib和urllib2合并成了urllib，常用的urllib2.urlopen()變成了urllib.request.urlopen()
字符串及編碼相關有大變動，簡單來說就是原來的str變成了新的bytes，原來的unicode變成了新的str。
8、xrange和range的區別
python2中 xrange用法與 range 完全相同，所不同的是生成的不是一個list對象，而是一個生成器。
9、python的read() 、readline()、readlines()、xreadlines()
read()會讀取整個文件，將讀取到底的文件內容放到一個字符串變量，返回str類型。
readline()讀取一行內容，放到一個字符串變量，返回str類型。
readlines() 讀取文件所有內容，按行為單位放到一個列表中，返回list類型。
xreadlines()返回一個生成器，來循環操作文件的每一行。
10、列舉布爾值為False的常見值
None、""、0、[]、()、{}
11、字符串、列表、元組、字典每個常用的5個方法（整型，浮點，字符串，布爾型，列表、元組、字典、集合、日期）
字符串：
# encoding:utf-8
__author__ = 'Fioman'
__date__ = '2018/11/19 15:10'
# 1. 去掉空格和特殊符號
name = " abcdefgeyameng "
name1 = name.strip() # 并不會在原來的字符串上操作,返回一個去除了兩邊空白的字符串
print(name1, len(name1), name, len(name))
# abcdefgeyameng 14 abcdefgeyameng 17
# 去掉左邊的空格和換行符
name2 = name.lstrip()
print(name2, len(name2))# print(name2, len(name2))#
# 去掉右邊的空格和換行符
name3 = name.rstrip()
print(name3, len(name3)) # abcdefgeyameng 15
# 2.字符串的搜索和替換
name.count('e') # 查找某個字符在字符串中出現的次數
name.capitalize() # 首字母大寫
name.center(100,'-') # 把字符串方中間,兩邊用-補齊,100表示占位多少
name.find('a') # 找到這個字符返回下標,多個時返回第一個,不存在時返回-1
name.index('a') # 找到這個字符返回下標,多個時返回第一個,不存在時報錯
print(name.replace(name,'123')) # 字符串的替換
name.replace('abc','123') # 注意字符串的替換的話,不是在原來的字符串上進行替換.而是返回一個替換后的字符串.
# 3.字符串的測試和替換函數
name.startswith("abc") # 是否以abc開頭
name.endswith("def") # 是否以def結尾
name.isalnum() # 是否全是字母和數字,并且至少包含一個字符
name.isalpha() # 是否全是字母,并至少包含一個字符
name.isdigit() # 是否全是數字,并且至少包含一個字符
name.isspace() # 是否全是空白字符,并且至少包含一個字符
name.islower() # 是否全是小寫
name.isupper() # 是否全是大寫
name.istitle() # 是否是首字母大寫
# 4.字符串的分割
name.split('') # 默認按照空格進行分隔,從前往后分隔
name.rsplit() # 從后往前進行分隔
# 5.連接字符串
'.'.join(name) # 用.號將一個可迭代的序列拼接起來
name = 'geyameng'
# 6.截取字符串(切片)
name1 = name[0:3] # 第一位到第三位的字符,和range一樣不包含結尾索引
name2 = name[:] # 截取全部的字符
name3 = name[6:] # 截取第6個字符到結尾
name4 = name[:-3] # 截取從開頭到最后一個字符之前
name5 = name[-1] # 截取最后一個字符
name6 = name[::-1] # 創造一個與原字符串順序相反的字符串
name7 = name[:-5:-1] # 逆序截取
列表：
# encoding:utf-8
__author__ = 'Fioman'
__date__ = '2018/11/19 16:26'
# 1.創建一個列表
list1 = ['1', '2', '3', '4']
list2 = list("1234")
print(list1, list2)
print(list1 == list2)
# 以上創建的兩個列表是等價的,都是['1', '2', '3', '4']
# 2.添加新元素
# 末尾追加
a = [1, 2, 3, 4, 5]
a.append(6)
print(a)
# 指定位置的前面插入一個元素
a.insert(2, 100) # 在下標為2的前面插入一個元素100
print(a)
# 擴展列表list.extend(iterable),在一個列表上追加一個列表
a.extend([10, 11, 12])
print(a)
# 3.遍歷列表
# 直接遍歷
for i in a:
print(i)
# 帶索引的遍歷列表
for index, i in enumerate(a):
print(i, index)
# 4.訪問列表中的值,直接通過下標取值.list[index]
print(a[2])
# 從list刪除元素
# List.remove() 刪除方式1:參數object 如果重復元素,只會刪除最靠前的.
a = [1,2,3]
a.remove(2) # 返回值是None
# List.pop() 刪除方式2:pop 可選參數index,刪除指定位置的元素 默認為最后一個元素
a = [1,2,3,4,5]
a.pop()
print(a)
a.pop(2)
print(a)
# 終極刪除,可以刪除列表或指定元素或者列表切片,list刪除后無法訪問
a = [1,2,3,4,5,6]
del a[1]
print(a) # 1, 3, 4, 5, 6]
del a[1:]
print(a) # 1
del a
# print(a) # 出錯,name a is not defined
# 排序和反轉代碼
# reverse 反轉列表
a = [1,2,3,4,5]
a.reverse()
print(a)
# sort 對列表進行排序,默認升序排列.有三個默認參數cmp = None,key = None,reverse = False
# 7.Python的列表的截取與字符串操作類型相同,如下所示
L = ['spam','Spam','SPAM!']
print(L[-1]) # ['SPAM']
# 8.Python列表操作的函數和方法
len(a) # 列表元素的個數
max(a) # 返回列表元素最大值
min(a) # 返回列表元素最小值
list(tuple) #將一個可迭代對象轉換為列表
# 列表常用方法總結
a.append(4)
a.count(1)
a.extend([4,5,6])
a.index(3)
a.insert(0,2)
a.remove()
a.pop()
a.reverse()
a.sort()
元組：
1.用一個可迭代對象生成元組
T = tuple('abc')
對元組進行排序
注意
當對元組進行排序的時候,通常先得將它轉換為列表并使得它成為一個可變對象.或者使用sorted方法,它接收任何序列對象.
T = ('c','a','d','b')
tmp = list(T)
tmp.sort() ==> ['a','b','c','d']
T = tunple(tmp)
sorted(T)
字典：
以下實例展示了 fromkeys()函數的使用方法：
實例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
seq = ('Google', 'Runoob', 'Taobao')
dict = dict.fromkeys(seq)
print "新字典為 : %s" % str(dict)
dict = dict.fromkeys(seq, 10)
print "新字典為 : %s" % str(dict)
以上實例輸出結果為：
新字典為 : {'Google': None, 'Taobao': None, 'Runoob': None}
新字典為 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}
通過zip函數構建字典 D = dict(zip(keyslist,valueslist))
通過賦值表達式元組構造字典(鍵必須是字符串,因為如果不是字符串,構造的時候也會當成是字符串處理)
D = dict(name='Bob',age=42) ==> {'name':'Bob,'age':42}
列出所有的鍵,值.注意得到的是一個可迭代對象,而不是列表.用的時候需要轉換 D.keys() D.values() D.items() --> 鍵 + 值
刪除字典(根據鍵)以及長度 D.pop(key) len(D) del D[key]
新增或者是修改鍵對應的值 D[key] = value # 如果key已經存在則修改,如果不存在就創建.
字典推導式 D = [x:x**2 for x in range(10) if x %2 == 0]
12、lambda表達式格式以及應用場景
1、lambda函數與list的結合使用
list = lambda:x for x in range(10) print (list[0]) >>>9 list = lambda x:x for x in range(10) print (list[0]) >>>0
2、map,filter,reduce函數
例子：
a = [('a',1),('b',2),('c',3),('d',4)]
a_1 = list(map(lambda x:x[0],a))
如上例子，map函數第一個參數是一個lambda表達式，輸入一個對象，返回該對象的第一個元素。第二個就是需要作用的對象，此處是一個列表。Python3中map返回一個map對象，我們需要人工轉為list，得到的結果就是[‘a’,’b’,’c’,’d’]
例子：
a = [1,2,3,4]
b = [2,3,4,5]
a_1 = list(map(lambda x,y:x+y,a,b))
上邊這個例子是為了說明,lambda表達式參數可以是多個。返回結果是[3,5,7,9]
例子： a = [1,2,3,4,5,6,7] a_1 = filter(lambda x:x<4,a) 如上例子，定義lambda表達式，篩選a列表中小于4的元素，結果為[1,2,3]。filter函數直接返回一個列表，無需再進行轉換，第三個是初始值，我們沒給初始值，那么開始操作的兩個元素就是序列的前兩個。否則將使用我們給出的初始值和序列第一個元素操作，然后結果再與第三個元素操作，以此類推。上個例子結果是28
例子： from functools import reduce #python3需要導入此模塊 a = [1,2,3,4,5,6,7] a_1 = reduce(lambda x,y:x+y,a) reduce中使用的lambda表達式需要兩個參數，reduce函數共三個參數， 第一個是就是lambda表達式，第二個是要累計的序列，第三個是初始值， 我們沒給初始值，那么開始操作的兩個元素就是序列的前兩個。否則將使 用我們給出的初始值和序列第一個元素操作，然后結果再與第三個元素操 作，以此類推。上個例子結果是28
3、字典多條件排序
例子：
dict = {'a':1,'b':2,'c':3,'d':4,'e':3,'f':1,'g':7}
sorted_dict_asc = sorted(dict.items(),key=lambda item:item[0])
sorted_dict_dsc = sorted(dict.items(),key=lambda item:item[0],reverse=True)
輸出（第一個升序，第二個降序）：
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 3), ('f', 1), ('g', 7)]
[('g', 7), ('f', 1), ('e', 3), ('d', 4), ('c', 3), ('b', 2), ('a', 1)]]
13、pass的作用
pass是空語句占位符，是為了保持程序結構的完整性。
14、*arg和**kwarg作用
定義函數時，使用*arg和**kwarg
*arg和**kwarg 可以幫助我們處理上面這種情況，允許我們在調用函數的時候傳入多個實參
def exmaple2(required_arg, *arg, **kwarg):
if arg:
print "arg: ", arg
if kwarg:
print "kwarg: ", kwarg
exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")
>> arg: (1, 2, 3)
>> kwarg: {'keyword2': 'foo', 'keyword1': 'bar'}
從上面的例子可以看到，當我傳入了更多實參的時候
*arg會把多出來的位置參數轉化為tuple
**kwarg會把關鍵字參數轉化為dict
15、is和==的區別
Python中對象包含的三個基本要素，分別是：id(身份標識)、type(數據類型)和value(值)。
==是python標準操作符中的比較操作符，用來比較判斷兩個對象的value(值)是否相等
is也被叫做同一性運算符，這個運算符比較判斷的是對象間的唯一身份標識，也就是id是否相同。
只有數值型和字符串型的情況下，a is b才為True，當a和b是tuple，list，dict或set型時，a is b為False。
16、簡述Python的深淺拷貝以及應用場景
深淺拷貝用法來自copy模塊。
導入模塊：import copy
淺拷貝：copy.copy
深拷貝：copy.deepcopy
對于 數字 和 字符串 而言，賦值、淺拷貝和深拷貝無意義，因為其永遠指向同一個內存地址。
字面理解：淺拷貝指僅僅拷貝數據集合的第一層數據，深拷貝指拷貝數據集合的所有層。所以對于只有一層的數據集合來說深淺拷貝的意義是一樣的，比如字符串，數字，還有僅僅一層的字典、列表、元祖等.
字典（列表）的深淺拷貝
賦值：
import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n2 = n1
淺拷貝：
import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n3 = copy.copy(n1)
深拷貝：
import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n4 = copy.deepcopy(n1)
深拷貝的時候python將字典的所有數據在內存中新建了一份，所以如果你修改新的模版的時候老模版不會變。相反，在淺copy 的時候，python僅僅將最外層的內容在內存中新建了一份出來，字典第二層的列表并沒有在內存中新建，所以你修改了新模版，默認模版也被修改了。
17、Python是如何進行內存管理的
答:從三個方面來說,一對象的引用計數機制,二垃圾回收機制,三內存池機制
一、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。
引用計數增加的情況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減少的情況：
1，使用del語句對對象別名顯示的銷毀
2，引用超出作用域或被重新賦值
Sys.getrefcount( )函數可以獲得對象的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對于不可變數據（如數字和字符串），解釋器會在程序的不同部分共享內存，以便節約內存。
二、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，并銷毀用于引用底層對象的名稱。然而由于每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。（從而導致內存泄露）。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環并刪除它們。
三、內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用于管理對小塊內存的申請和釋放。
2，Python中所有小于256個字節的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對于Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用于緩存這些整數的內存就不能再分配給浮點數。
18、Python的可變類型和不可變類型
數字、字符串、元組是不可變的，列表、字典是可變的。
對象池：
小整數對象池
[-5, 256] 這些小整數被定義在了一個整數對象池里，當引用小整數時會自動引用整數對象池里的對象，所以這些小整數不會重復創建，當多個變量指向同一個小整數時，實質上它們指向的是同一個對象。
字符串對象池
字符串對象是不可變對象，python有個intern機制，簡單說就是維護一個字典，這個字典維護已經創建字符串(key)和它的字符串對象的地址(value)，每次創建字符串對象都會和這個字典比較，沒有就創建，重復了就用指針進行引用就可以了。intern機制處理字符串長度小于等于20且僅由數字字母下劃線構成的，只創建一次。
19、列舉常見的內置函數
數學相關
abs(a) : 求取絕對值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list長度,len([1,2,3])
divmod(a,b): 獲取商和余數。 divmod(5,2) >>> (2,1)
pow(a,b) : 獲取乘方數。pow(2,3) >>> 8
round(a,b) : 獲取指定位數的小數。a代表浮點數，b代表要保留的位數。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一個a到b的數組,左閉右開。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]
類型轉換
int(str) : 轉換為int型。int('1') >>> 1
float(int/str) : 將int型或字符型轉換為浮點型。float('1') >>> 1.0
str(int) : 轉換為字符型。str(1) >>> '1'
bool(int) : 轉換為布爾類型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一個字符串，與所要編碼的格式，返回一個字節流類型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬蟲', 'utf-8') >>> b'xe7x88xacxe8x99xab'
list(iterable) : 轉換為list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一個可迭代的對象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 轉換為dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一個枚舉對象。
tuple(iterable) : 轉換為tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 轉換為set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 轉換為16進制。hex(1024) >>> '0x400'
oct(int) : 轉換為8進制。 oct(1024) >>> '0o2000'
bin(int) : 轉換為2進制。 bin(1024) >>> '0b10000000000'
chr(int) : 轉換數字為相應ASCI碼字符。 chr(65) >>> 'A'
ord(str) : 轉換ASCI字符為相應的數字。 ord('A') >>> 65
相關操作
eval() : 執行一個表達式，或字符串作為運算。 eval('1+1') >>> 2
exec() : 執行python語句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通過判斷函數fun，篩選符合條件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
map(func, *iterable) : 將func用于每個iterable對象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 將iterable分組合并。返回一個zip對象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一個對象的類型。
id()： 返回一個對象的唯一標識值。
hash(object)：返回一個對象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：調用系統內置的幫助系統。
isinstance()：判斷一個對象是否為該類的一個實例。
issubclass()：判斷一個類是否為另一個類的子類。
globals() : 返回當前全局變量的字典。
next(iterator[, default]) : 接收一個迭代器，返回迭代器中的數值，如果設置了default，則當迭代器中的元素遍歷后，輸出default內容。
reversed(sequence) ： 生成一個反轉序列的迭代器。 reversed('abc') >>> ['c','b','a']
20、Python寫9*9乘法表的兩種簡單方法
1 for i in range(1,10):
2 for j in range(1,i+1):
3 print("%s * %s = %s" %(j,i,i*j),end="")
4 print("")
print "
".join(" ".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10))
21、如何安裝第三方模塊？以及用過哪些第三方模塊？
pip install 模塊名
一、Python爬蟲
1. 請求
requests（第三方模塊）
2. 解析：
bs4（即beautifulsoup，第三方模塊）
3. 儲存：
pymongo（第三方模塊）：
把數據寫入MongoDB
MySQL-python（第三方模塊）：
把數據寫入MySQL里面。
協程：gevent（第三方模塊）
二、Python數據分析&科學計算
numpy（第三方模塊，C拓展）：
Copy了MATLAB的數據結構。很多數據分析和科學計算庫的底層模塊。提供了良好的數組數據結構和C拓展接口。
pandas（第三方模塊，C拓展）：
Copy了R的data frame的數據結構。
22、常用模塊都有那些？
1 import time
2 import datetime
3
4 print(time.asctime()) # 返回時間格式：Sun May 7 21:46:15 2017
5 print(time.time()) # 返回時間戳 ‘1494164954.6677325’
6 print(time.gmtime()) # 返回本地時間 的struct time對象格式，time.struct_time(tm_year=2017, tm_mon=5, tm_mday=7, tm_hour=22, tm_min=4, tm_sec=53, tm_wday=6, tm_yday=127, tm_isdst=0)
7 print(time.localtime()) # 返回本地時間 的struct time對象格式，time.struct_time(tm_year=2017, tm_mon=5, tm_mday=7, tm_hour=22, tm_min=4, tm_sec=53, tm_wday=6, tm_yday=127, tm_isdst=0)
8 print(time.gmtime(time.time()-800000)) # 返回utc時間的struc時間對象格式
9 print(time.asctime(time.localtime())) # 返回時間格式Sun May 7 22:15:09 2017
10 print(time.ctime()) # 返回時間格式Sun May 7 22:15:09 2017
11 print(time.strftime('%Y-%m-%d')) #默認當前時間 2017-05-07
12 print(time.strftime('%Y-%m-%d',time.localtime())) #默認當前時間 2017-05-07
13
14 string_struct = time.strptime("2016/05/22","%Y/%m/%d") # 將日期字符串 轉成 struct時間對象格式
15 print(string_struct) # 返回struct time對象格式 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=143, tm_isdst=-1)
16
17 # 將日期字符串轉成時間戳
18 struct_stamp = time.mktime(string_struct) # 將struct time時間對象轉成時間戳
19 print(struct_stamp) # 返回時間戳 ‘1463846400.0’
20
21 # 將時間戳轉為字符串格式
22 print(time.gmtime(time.time()-86640)) # 將utc時間戳轉換成struct_time格式
23 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) # 將utc struct_time格式轉成指定的字符串格式
24
25
26 # 時間加減
27 print(datetime.datetime.now()) # 返回當前時間 2017-05-07 22:36:45.179732
28 print(datetime.date.fromtimestamp(time.time())) # 時間戳直接轉換成日期格式 2017-05-07
29 print(datetime.datetime.now() + datetime.timedelta(3)) # 返回時間在當前日期上 +3 天
30 print(datetime.datetime.now() + datetime.timedelta(-3)) # 返回時間在當前日期上 -3 天
31 print(datetime.datetime.now() + datetime.timedelta(hours= 3)) # 返回時間在當前時間上 +3 小時
32 print(datetime.datetime.now() + datetime.timedelta(minutes= 30)) # 返回時間在當前時間上 +30 分鐘
33
34 c_time = datetime.datetime.now()
35 print(c_time) # 當前時間為 2017-05-07 22:52:44.016732
36 print(c_time.replace(minute=3,hour=2)) # 時間替換 替換時間為‘2017-05-07 02:03:18.181732’
37
38 print(datetime.timedelta) # 表示時間間隔，即兩個時間點之間的長度
39 print (datetime.datetime.now() - datetime.timedelta(days=5)) # 返回時間在當前時間上 -5 天
40
41 # python 日歷模塊
42 import calendar
43
44 print(calendar.calendar(theyear= 2017)) # 返回2017年整年日歷
45 print(calendar.month(2017,5)) # 返回某年某月的日歷，返回類型為字符串類型
46
47 calendar.setfirstweekday(calendar.WEDNESDAY) # 設置日歷的第一天(第一天以星期三開始）
48 cal = calendar.month(2017, 4)
49 print (cal)
50
51 print(calendar.monthrange(2017,5)) # 返回某個月的第一天和這個月的所有天數
52 print(calendar.monthcalendar(2017,5)) # 返回某個月以每一周為元素的序列
53
54 cal = calendar.HTMLCalendar(calendar.MONDAY)
55 print(cal.formatmonth(2017, 5)) # 在html中打印某年某月的日歷
56
57 print(calendar.isleap(2017)) # 判斷是否為閏年
58 print(calendar.leapdays(2000,2017)) # 判斷兩個年份間閏年的個數
1 import random 2 3 # 隨機數 4 print(random.random()) # 返回一個隨機小數'0.4800545746046827' 5 print(random.randint(1,5)) # 返回（1-5）隨機整型數據 6 print(random.randrange(1,10)) # 返回（1-10）隨機數據 7 8 # 生成隨機驗證碼 9 code = '' 10 for i in range(4): 11 current = random.randrange(0,4) 12 if current != i: 13 temp = chr(random.randint(65,90)) 14 else: 15 temp = random.randint(0,9) 16 code += str(temp) 17 18 print(code)
import os
print(os.getcwd()) # 獲得當前工作目錄
print(os.chdir("dirname")) # 改變當前腳本的工作路徑，相當于shell下的cd
print(os.curdir) # 返回當前目錄‘.'
print(os.pardir) # 獲取當前目錄的父目錄字符串名‘..'
print(os.makedirs('dirname1/dirname2')) # 可生成多層遞歸目錄
print(os.removedirs('dirname1/dirname2')) # 若目錄為空，則刪除，并遞歸到上一級目錄，如若也為空，則刪除，依此類推
print(os.mkdir('test4')) # 生成單級目錄；相當于shell中mkdir dirname
print(os.rmdir('test4')) # 刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當于shell中rmdir dirname
print(os.listdir('/pythonStudy/s12/test')) # 列出指定目錄下的所有文件和子目錄，包括隱藏文件，并以列表方式打印
print(os.remove('log.log')) # 刪除一個指定的文件
print(os.rename("oldname","newname")) # 重命名文件/目錄)
print(os.stat('/pythonStudy/s12/test')) # 獲取文件/目錄信息
print(os.pathsep) # 輸出用于分割文件路徑的字符串';'
print(os.name) # 輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
print(os.system(command='bash')) # 運行shell命令，直接顯示
print(os.environ) # 獲得系統的環境變量
print(os.path.abspath('/pythonStudy/s12/test')) # 返回path規范化的絕對路徑
print(os.path.split('/pythonStudy/s12/test')) # 將path分割成目錄和文件名二元組返回
print(os.path.dirname('/pythonStudy/s12/test')) # 返回path的目錄。其實就是os.path.split(path)的第一個元素
print(os.path.basename('/pythonStudy/s12/test')) # 返回path最后的文件名。如果path以／或結尾，那么就會返回空值。即os.path.split(path)的第二個元素
print(os.path.exists('test')) # 判斷path是否存在
print(os.path.isabs('/pythonStudy/s12/test')) # 如果path是絕對路徑，返回True
print(os.path.isfile('test')) # 如果path是一個存在的文件，返回True。否則返回False
print(os.path.isdir('/pythonStudy/s12/test')) # 如果path是一個存在的目錄，則返回True。否則返回False
print(os.path.getatime('/pythonStudy/s12/test')) # 返回path所指向的文件或者目錄的最后存取時間
print(os.path.getmtime('/pythonStudy/s12/test')) # 返回path所指向的文件或者目錄的最后修改時間
import sys print(sys.argv) # 命令行參數List，第一個元素是程序本身路徑 print(sys.exit(n)) # 退出程序，正常退出時exit(0) print(sys.version) # 獲取python的版本信息 print(sys.path) # 返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值 print(sys.platform) # 返回操作平臺的名稱
# xml的格式如下，就是通過<>節點來區別數據結構的:
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
#遍歷xml文檔
for child in root:
print(child.tag, child.attrib)
for i in child:
print(i.tag,i.text)
#只遍歷year 節點
for node in root.iter('year'):
print(node.tag,node.text)
# 修改和刪除xml文檔內容
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
#修改
for node in root.iter('year'):
new_year = int(node.text) + 1
node.text = str(new_year)
node.set("updated","yes")
tree.write("xmltest.xml")
#刪除node
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)
tree.write('output.xml')
# 自己創建xml文檔
import xml.etree.ElementTree as ET
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})
age = ET.SubElement(name, "age", attrib={"checked": "no"})
age = ET.SubElement(name, "age")
age.text = '33'
name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
age = ET.SubElement(name2, "age")
age.text = '19'
et = ET.ElementTree(new_xml) # 生成文檔對象
et.write("test.xml", encoding="utf-8", xml_declaration=True)
ET.dump(new_xml) # 打印生成的格式
python的logging模塊提供了標準的日志接口，你可以通過它存儲各種格式的日志，logging的日志可以分為debug(),info(),warning(),error()andcritical()5個級別。
import logging
# %(message)s 日志信息
# %（levelno)s 日志級別
# datefmt 設置時間格式
# filename 設置日志保存的路徑
# level=loggin.INFO意思是，把日志紀錄級別設置為INFO，也就是說，只有比日志是INFO或比INFO級別更高的日志才會被紀錄到文件里，
# 在這個例子， 第一條日志是不會被紀錄的，如果希望紀錄debug的日志，那把日志級別改成DEBUG就行了。
logging.basicConfig(format='%(asctime)s %(message)s %(levelno)s', datefmt='%m/%d/%Y %I:%M:%S %p',filename='example.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this')
Copyright ?2018 確認沉默
總結
以上是生活随笔為你收集整理的史上最全python面试题详解（一）（附带详细答案（持续更新））的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： ImageIO类说明
- 下一篇： 怎样选购适合自己的汽车？