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面试题详解（一）（附带详细答案（持续更新））的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。