120 道 Python 面試筆試題彙總（上篇）

首先這篇文章在個人《Python數據結構》公衆號已經說起，可是本篇文章提供了更爲高級的解法，來發散你們的思惟；同時爲你們提供個人草稿py文件，你們能夠關注《Python數據結構》公衆號後恢復 120 獲取源代碼。

一、一行代碼實現1--100之和？

sum(range(0, 100))

二、如何在一個函數內部修改全局變量？

num = 5
def func():
    global num
    num = 4
func()
print(num)

三、 列出5個經常使用Python標準庫？

os：提供了很多與操做系統相關聯的函數
sys：一般用於命令行參數
re：正則匹配
math：數學運算
datetime：處理日期時間

4 、如何合併兩個字典？

name = {'name': 'Gage'}
age = {'age': 25}
name.update(age)
print(name)

五、談下Python的GIL？

GIL是Python的全局解釋器鎖，同一進程中假若有多個線程運行，一個線程在運行Python程序的時候會霸佔Python解釋器（加了一把鎖即GIL），使該進程內的其餘線程沒法運行，等該線程運行完後其餘線程才能運行。若是線程運行過程當中遇到耗時操做，則解釋器鎖解開，使其餘線程運行。因此在多線程中，線程的運行還是有前後順序的，並非同時進行。
多進程中由於每一個進程都能被系統分配資源，至關於每一個進程有了一個Python解釋器，因此多進程能夠實現多個進程的同時運行，缺點是進程系統資源開銷大。

六、Python實現列表去重的方法？

num_list = [1, 3, 1, 5, 3, 6, 1]
print([num for num in set(num_list)])

七、fun(args,kwargs)中的args,kwargs什麼意思？

若是你有其餘語言基礎的話，你應該據說太重載的概念，對，Python爲了不這種繁瑣的狀況發送，引入了args和kwargs；args用來接受非鍵值對的數據，即元組類型，而kwargs則用來接受鍵值對數據，即字典類

八、Python2和Python3的range（100）的區別？

Python2返回列表，Python3返回迭代器，節約內存。

九、生成一個16位的隨機字符串？

import string
print(''.join((random.choice(string.printable)) for i in range(16)))
-------------------------------------------------
X{|op?_gSM-ra%N\

十、一句話解釋什麼樣的語言可以用裝飾器?

函數能夠做爲參數傳遞的語言，可使用裝飾器。

十一、Python內建數據類型有哪些？

整型--int
布爾型--bool
字符串--str
列表--list
元組--tuple
字典--dict

十二、簡述面向對象中__new__和__init__區別？

一、__new__至少要有一個參數cls，表明當前類，此參數在實例化時由Python解釋器自動識別。
二、__new__必需要有返回值，返回實例化出來的實例，這點在本身實現__new__時要特別注意，能夠return父類（經過super(當前類名, cls)）__new__出來的實例，或者直接是object的__new__出來的實例。
三、__init__有一個參數self，就是這個__new__返回的實例，__init__在__new__的基礎上能夠完成一些其它初始化的動做，__init__不須要返回值。
四、若是__new__建立的是當前類的實例，會自動調用__init__函數，經過return語句裏面調用的__new__函數的第一個參數是cls來保證是當前類實例，若是是其餘類的類名，；那麼實際建立返回的就是其餘類的實例，其實就不會調用當前類的__init__函數，也不會調用其餘類的__init__函數。

1三、簡述with方法打開處理文件幫我咱們作了什麼？

打開文件在進行讀寫的時候可能會出現一些異常情況，若是按照常規的f.open寫法，咱們須要try,except,finally，作異常判斷，而且文件最終無論遇到什麼狀況，都要執行finally f.close()關閉文件，with方法幫咱們實現了finally中f.close（固然還有其餘自定義功能，有興趣能夠研究with方法源碼）。

1四、列表[1,2,3,4,5],請使用map()函數輸出[1,4,9,16,25]，並使用列表推導式提取出大於10的數，最終輸出[16,25]？

num_list = [1, 2, 3, 4, 5]
print([x for x in list(map(lambda x: x * x, num_list)) if x > 10])

1五、python中生成隨機整數、隨機小數、0--1之間小數方法？

import random
print(random.randint(1, 10))  # 隨機整數
print(random.random())  # 0-1隨機小數
print(random.uniform(2, 6)) # 指定隨機小數

1六、避免轉義給字符串加哪一個字母表示原始字符串？

b'input\n' # bytes字節符，打印以b開頭。
輸出：
b'input\n'
-------
r'input\n' # 非轉義原生字符，經處理'\n'變成了'\\'和'n'。也就是\n表示的是兩個字符，而不是換行。
輸出：
'input\\n'
-------
u'input\n' # unicode編碼字符，python3默認字符串編碼方式。
輸出：
'input\n'

1七、<div class="nam">Python</div>，用正則匹配出標籤裏面的內容（「中國」），其中class的類名是不肯定的。

import re
s = '<div class="nam">Python</div>'
print(re.findall(r'<div class=".*">(.*?)</div>', s))

1八、Python中斷言方法舉例？

age = 10
assert 0 < age < 10
--------------------
 Traceback (most recent call last):
  File "F:/MxOnline/110/exam.py", line 69, in <module>
    assert 0 < age < 10
AssertionError

1九、dict中fromkeys的用法

keys = ('info',)
print(dict.fromkeys(keys, ['Gage', '25', 'man']))

20、請用正則表達式輸出漢字

import re
a = "not 404 found 中國 2018 我愛你"
r1 = '[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>?@，。?★、…【】《》？「」‘’！[\\]^_`{|}~]+\s?'
print(re.sub(r1, '', a))

2一、Python2和Python3區別？列舉5個

1.去除了<>，所有改用!=
 2.xrange() 更名爲range()
 3.內存操做cStringIO改成StringIO
 4.加入nonlocal 做用：能夠引用外層非全局變量
 5.zip()、map()和filter()都返回迭代器，而不是生成器，更加節約內存

2二、列出Python中可變數據類型和不可變數據類型，爲何？

一、可變數據類型：list、dict、set
 二、不可變數據類型：int/float、str、tuple
 三、原理：可變數據類型即公用一個內存空間地址，不可變數據類型即每產生一個對象就會產生一個內存地址

2三、dict的內部實現？

在Python中，字典是經過哈希表實現的。也就是說，字典是一個數組，而數組的索引是鍵通過哈希函數處理後獲得的。哈希函數的目的是使鍵均勻地分佈在數組中。因爲不一樣的鍵可能具備相同的哈希值，便可能出現衝突，高級的哈希函數可以使衝突數目最小化。

2四、s = "ajldjlajfdljfddd"，去重並從小到大排序輸出"adfjl"？

s1 = "ajldjlajfdljfddd"
print(''.join(sorted(set(s1))))

2五、用lambda函數實現兩個數相乘？

mul = lambda x, y: x*y
print(mul(2, 4))

2六、字典根據鍵從小到大排序？

info = {'name': 'Gage', 'age': 25, 'sex': 'man'}
print(sorted(info.items(), key=lambda x: x[0]))

2七、Python獲取當前日期？

import time
import datetime
print(datetime.datetime.now())
print(time.strftime('%Y-%m-%d %H:%M:%S'))

2八、獲取請求頭的參數？

from urllib.parse import urlparse, parse_qs
s2 = "/get_feed_list?version_name=5.0.9.0&device_id=12242channel_name=google"
def spiltline(value):
    url = {'site': urlparse(value).path}
    url.update(parse_qs(urlparse(value).query))
    return url

2九、例舉五條PEP8 規範

不要在行尾加分號, 也不要用分號將兩條命令放在同一行
不要使用反斜槓鏈接行
不要在返回語句或條件語句中使用括號
頂級定義之間空2行, 方法定義之間空1行，頂級定義之間空兩行
若是一個類不繼承自其它類, 就顯式的從object繼承

30、Python語言的運行機制

3一、Fibonacci數列

def fab(n):
    a, b = 0, 1
    while n:
        yield b
        a, b = b, a+b
        n -= 1

3二、Python三目運算

# 若果 a>b 成立  就輸出  a-b  不然 a+b
h = a-b if a>b else a+b

3三、單例模式

class Single(object):
    __isstance = None
    __first_init = False
    def __new__(cls, *args, **kwargs):
        if not cls.__isstance:
            cls.__isstance = object.__new__(cls)
        return cls.__isstance
    def __init__(self, name):
        if not self.__first_init:
            self.name = name
            Singleton.__first_init = True

3四、正則匹配優先級

3五、遞歸

def digui(n):
    if n == 1:
        return 1
    else:
        return (n * digui(n-1))

3六、統計字符串每一個單詞出現的次數

from collections import Counter
s3 = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
print(Counter(s3))

3七、正則re.complie做用

re.compile是將正則表達式編譯成一個對象，加快速度，並重復使用

3八、filter方法求出列表全部奇數並構造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(filter(lambda x: x % 2, a)))

3九、列表推導式求列表全部奇數並構造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print([x for x in a if x % 2])

40、a=（1，）b=(1)，c=("1") 分別是什麼類型的數據？

print(type((1, ))) # tuple
print(type((1))) # int
print(type(("1"))) # str

4一、兩個列表[1,5,7,9]和[2,2,6,8]合併爲[1,2,2,3,6,7,8,9]

l1 = [1, 5, 7, 9]
l2 = [2, 2, 6, 8]
l1.extend(l2)

4二、用python刪除文件和用linux命令刪除文件方法

python：os.remove(文件名)
linux: rm 文件名

4三、logging模塊的使用？

import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

4四、寫一段自定義異常代碼

#自定義異經常使用raise拋出異常
def fn():
    try:
        for i in range(5):
            if i>2:
                raise Exception("數字大於2了")
    except Exception as ret:
        print(ret)
fn()            ==》數字大於2了

4五、正則表達式匹配中，（.）和（.?）匹配區別？

#（.*）是貪婪匹配，會把知足正則的儘量多的日後匹配
#（.*?）是非貪婪匹配，會把知足正則的儘量少匹配
s = "<a>哈哈</a><a>呵呵</a>"
import re
res1 = re.findall("<a>(.*)</a>", s)
print("貪婪匹配", res1)
res2 = re.findall("<a>(.*?)</a>", s)
print("非貪婪匹配", res2)
-------------------------
輸出：
貪婪匹配 ['哈哈</a><a>呵呵']
非貪婪匹配 ['哈哈', '呵呵']

4六、[[1,2],[3,4],[5,6]]一行代碼展開該列表，得出[1,2,3,4,5,6]

a=[[1,2],[3,4],[5,6]]
print([j for i in a for j in i])

4七、x="abc",y="def",z=["d","e","f"],分別求出x.join(y)和x.join(z)返回的結果

#join()括號裏面的是可迭代對象，x插入可迭代對象中間，造成字符串，結果一致
x="abc"
y="def"
z=["d","e","f"]
a=x.join(y)
b=x.join(z)
print(a)
print(b)
均輸出：
dabceabcf

4八、舉例說明異常模塊中try except else finally的相關意義

try..except..else沒有捕獲到異常，執行else語句
try..except..finally無論是否捕獲到異常，都執行finally語句

4九、python中交換兩個數值

a,b=1,2
a,b=b,a

50、舉例說明zip()函數用法

list1 = [1, 2, 3, 5]
list2 = [4, 5, 6]
zipped = zip(list1, list2)
# print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
# print(list(zip(*zipped)))  # [(1, 2, 3), (4, 5, 6)]

5一、a="張明 98分"，用re.sub，將98替換爲100

import re
a="張明 98分"
ret=re.sub(r"\d+","100",a)
print(ret)

5二、a="hello"和b="你好"編碼成bytes類型

a=b"hello"        
b="你好".encode()
print(a,b)
print(type(a),type(b))

5三、[1,2,3]+[4,5,6]的結果是多少？

print([1,2,3]+[4,5,6]) # [1, 2, 3, 4, 5, 6]

5四、提升python運行效率的方法

一、使用生成器，由於能夠節約大量內存
二、循環代碼優化，避免過多重複代碼的執行
三、核心模塊用Cython  PyPy等，提升效率
四、多進程、多線程、協程
五、多個if elif條件判斷，能夠把最有可能先發生的條件放到前面寫，這樣能夠減小程序判斷的次數，提升效率

5五、遇到bug如何處理

一、細節上的錯誤，經過print（）打印，能執行到print（）說明通常上面的代碼沒有問題，分段檢測程序是否有問題，若是是js的話能夠alert或console.log
二、若是涉及一些第三方框架，會去查官方文檔或者一些技術博客。
三、對於bug的管理與歸類總結，通常測試將測試出的bug用teambin等bug管理工具進行記錄，而後咱們會一條一條進行修改，修改的過程也是理解業務邏輯和提升本身編程邏輯縝密性的方法，我也都會收藏作一些筆記記錄。
四、導包問題、城市定位多音字形成的顯示錯誤問題

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

def quicksort(list):
    if len(list)<2:
        return list
    else:
        midpivot = list[0]
        lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]
        biggerafterpivot = [i for i in list[1:] if i > midpivot]
        finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)
        return finallylist

print quicksort([2,3,5,4,9,6])

5七、兩數相除保留兩位小數

print(round(5/3, 2))

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

import re
print(re.findall('((?:(?:[2468][048]00|[13579][26]00|[1-9]\d0[48]|[1-9]\d[2468][048]|[1-9]\d[13579][26])/(?:0?2/(?:0[1-9]|0?[1-9](?=\D)|[12]\d)))|(?:(?:[12]\d{3})/(?:(?:0?2/(?:0[1-9]|0?[1-9](?=\D)|1\d|2[0-8]))|(?:0?[3578]/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|3[01]))|(?:0?[469]/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|30))|(?:1[02]/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|3[01]))|(?:11/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|30))|(?:0?1/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|3[01])))))', 'Date：2018/03/20'))

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

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

60、簡述多線程、多進程

進程是資源（CPU、內存等）分配的基本單位，它是程序執行時的一個實例。
線程是程序執行時的最小單位，它是進程的一個執行流。
進程有本身的獨立地址空間，每啓動一個進程，系統就會爲它分配地址空間，創建數據表來維護代碼段、堆棧段和數據段，這種操做很是昂貴
線程是共享進程中的數據的，使用相同的地址空間，所以CPU切換一個線程的花費遠比進程要小不少，同時建立一個線程的開銷也比進程要小不少