python面試題搜集：史上最全python面試題詳解（一）

python基礎題（53道題詳解）

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 是 \u4f60\u597d
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'\xe7\x88\xac\xe8\x99\xab'
• 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 "\n".join("\t".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()

and

critical() 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')           

複制