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

利用sum()函式求和

sum(range(0, 101))

2、如何在一個函式內部修改全域性變數？

利用global 修改全域性變數

3、列出5個Python標準庫？

os：提供了不少與作業系統相關聯的函式

sys：通常用於命令列引數

re：正則匹配

math：數學運算

datetime：處理日期時間

4、字典如何刪除鍵和合並兩個字典？

del和update方法

In [1]: dict1 = {"name": "zhangsan", "age": 18}                                                                     

In [2]: dict2 = {"gender": "man", "height": 1.82}                                                                   

In [3]: del dict1["age"]                                                                                           

In [4]: dict1                                                                                                      
Out[4]: {'name': 'zhangsan'}

In [5]: dict1.update(dict2)                                                                                        

In [6]: dict1                                                                                                      
Out[6]: {'gender': 'man', 'height': 1.82, 'name': 'zhangsan'}
 

5、談下Python的GIL？

GIL是Python的全域性直譯器鎖，同一程序中假如有多個執行緒執行，一個執行緒在執行Python程式的時候會霸佔Python直譯器（加了一把鎖即GIL），使該程序內的其他執行緒無法執行，等該執行緒執行完後其他執行緒才能執行。如果執行緒執行過程中遇到耗時操作，則直譯器鎖解開，使其他執行緒執行。所以在多執行緒中，執行緒的執行仍是有先後順序的，並不是同時進行。

多程序中因為每個程序都能被系統分配資源，相當於每個程序有了一個Python直譯器，所以多程序可以實現多個程序的同時執行，缺點是程序系統資源開銷大

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

先通過集合去重，在轉列表

In [1]: li = [1, 2, 2, 3, 3, 3]                                                                                    

In [2]: a = set(li)                                                                                                

In [3]: a                                                                                                          
Out[3]: {1, 2, 3}

In [4]: [x for x in a]                                                                                             
Out[4]: [1, 2, 3]
 

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

*args和**kwargs主要用於函式定義。你可以將不定數量的引數傳遞給一個函式。這裡的不定的意思是：預先並不知道函式使用者會傳遞多少個引數給你，所以在這個場景下使用這兩個關鍵字。

*args是用來發送一個非鍵值對的可變數量的引數列表給-一個函式，這裡有個例子幫你理解這個概念：

def demo(a, *args):
    print("輸出：")
    print(a)
    print("------")
    print(args)
    print("------")
    for data in args:
        print(data)


demo(1, 2, 3, 4, 5)

"""
輸出：
1
------
(2, 3, 4, 5)
------
2
3
4
5
"""

**kwargs允許你將不定長度的鍵值對，作為引數傳遞給一個函式。如果你想要在一個函式裡處理帶名字的引數，你應該使用**kwargs。這裡有個例子幫你理解這個概念：

def demo(**kwargs):
    print("輸出：")
    for k, v in kwargs.items():
        print(k, v)


demo(name='apollo', gender="man")

"""
輸出：
name apollo
gender man
"""

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

Python2返回列表，Python3返回迭代器，節約記憶體。

9、一句話解釋什麼樣的語言能夠用裝飾器?

函式可以作為引數傳遞的語言，可以使用裝飾器。

10、Python內建資料型別有哪些？

整型   --->   int

布林型   --->   bool

字串   --->   str

列表   --->   list

元組   --->   tuple

字典   --->   dict

11、簡述面向物件中__init__和__new__區別？

__init__是初始化方法，建立物件後，就立刻被預設呼叫了，可接收引數，如圖

1）__new__至少要有一個引數cls，代表當前類，此引數在例項化時由Python直譯器自動識別。

2）__new__必須要有返回值，返回例項化出來的例項，這點在自己實現__new__時要特別注意，可以return父類（通過super(當前類名, cls)）__new__出來的例項，或者直接是object的__new__出來的例項。

3）__init__有一個引數self，就是這個__new__返回的例項，__init__在__new__的基礎上可以完成一些其它初始化的動作，__init__不需要返回值。

4）如果__new__建立的是當前類的例項，會自動呼叫__init__函式，通過return語句裡面呼叫的__new__函式的第一個引數是cls來保證是當前類例項，如果是其他類的類名，那麼實際建立返回的就是其他類的例項，其實就不會呼叫當前類的__init__函式，也不會呼叫其他類的__init__函式。

12、簡述with方法開啟處理檔案幫我我們做了什麼？

開啟檔案在進行讀寫的時候可能會出現一些異常狀況，如果按照常規的f.open寫法，我們需要try、except、finally，做異常判斷，並且檔案最終不管遇到什麼情況，都要執行finally f.close()關閉檔案，with方法幫我們實現了finally中f.close（當然還有其他自定義功能，有興趣可以研究with方法原始碼）。

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

map()函式第一個引數是fun，第二個引數一般是list，第三個引數可以寫list，也可以不寫，根據需求。

li = [1, 2, 3, 4, 5]

def func(x):
    return x ** 2

a = map(func, li)
b = [x for x in a if x > 10]
print(b)  # [16, 25]

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

隨機整數：random.randint(a, b)，生成區間內的整數

隨機小數：習慣用numpy庫，利用np.random.randn(5)生成5個隨機小數

0-1隨機小數：random.random()，括號中不傳參

import random
import numpy as np

x = random.randint(1, 20)
print("隨機整數：", x)  # 隨機整數： 15

x = np.random.randn(5)
print("隨機小數：", x)  # 隨機小數： [ 0.92587753  0.35187744 -1.96555253  0.33319831 -1.85219944]

x = random.random()
print("0-1隨機小數：", x)  # 0-1隨機小數： 0.9007093018571225

15、避免轉義給字串加哪個字母表示原始字串？

r , 表示需要原始字串，不轉義特殊字元

16、<div class="nam">中國</div>，用正則匹配出標籤裡面的內容（“中國”），其中class的類名是不確定的。

import re

str = '<div class="nam">中國</div>'
ret = re.findall(r'<div class=".*">(.*)</div>', str)  # (.*)提取文字
print(ret)  # ['中國']

17、Python中斷言方法舉例？

assert（）方法，斷言成功，則程式繼續執行，斷言失敗，則程式報錯。

x = 4
assert(x > 2)
print("斷言成功，程式繼續執行")

assert(x > 8)
print("斷言失敗，則程式報錯")

18、資料表student有id,name,score,city欄位，其中name中的名字可有重複，需要消除重複行，請寫sql語句？

select distinct name from student

19、10個Linux常用命令？

ls  pwd  cd  touch  rm  mkdir  tree  cp  mv  cat  more  grep  echo 

20、Python2和Python3區別？列舉5個

1、Python3 使用 print 必須要以小括號包裹列印內容，比如 print('hi')

Python2 既可以使用帶小括號的方式，也可以使用一個空格來分隔列印內容，比如 print 'hi'

2、Python2 range(1,10)返回列表，python3中返回迭代器，節約記憶體

3、Python2中使用ascii編碼，python中使用utf-8編碼

4、Python2中unicode表示字串序列，str表示位元組序列

     Python3中str表示字串序列，byte表示位元組序列

5、Python2中為正常顯示中文，引入coding宣告，python3中不需要

6、Python2中是raw_input()函式，python3中是input()函式

21、列出python中可變資料型別和不可變資料型別，並簡述原理

不可變資料型別：數值型、字串型string和元組tuple

不允許變數的值發生變化，如果改變了變數的值，相當於是新建了一個物件，而對於相同的值的物件，在記憶體中則只有一個物件（一個地址），用id()方法可以列印物件的id。

a = 1
b = a
print(id(a))  # 10919424
print(id(b))  # 10919424
b = b + 1
print(id(b))  # 10919456

可變資料型別：列表list和字典dict；

允許變數的值發生變化，即如果對變數進行append、+=等這種操作後，只是改變了變數的值，而不會新建一個物件，變數引用的物件的地址也不會變化，不過對於相同的值的不同物件，在記憶體中則會存在不同的物件，即每個物件都有自己的地址，相當於記憶體中對於同值的物件儲存了多份，這裡不存在引用計數，是實實在在的物件。

list1 = [1, 2]
list2 = list1
print(id(list1))  # 139906662832712
print(id(list2))  # 139906662832712
list2.append(3)
print(id(list2))  # 139906662832712

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

set去重，去重轉成list，利用sort方法排序，reverse=False是從小到大排。

list是不變資料型別，s.sort時候沒有返回值。

s = "ajldjlajfdljfddd"
l = list(s)  # 將字串轉化為列表
x = set(l)  # 將列表轉化為集合，目的是去重
l = list(x)  # 再將集合轉化為列表
l.sort(reverse=False)  # 進行排序， reverse=False 從小到大排序，是預設狀態
s = "".join(l)  # 將列表轉化為字串
print(s)  # adfjl

23、用lambda函式實現兩個數相乘？

sum = lambda a, b: a * b  # 函式名 = lambda 引數: 表示式
print(sum(4, 5))  # 20

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

dict={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}

dict = {"name": "zs", "age": 18, "city": "深圳", "tel": "1362626627"}
list = sorted(dict, key=lambda i: i[0], reverse=False)  # dict的結果為字典的鍵（key）
print("根據字典鍵排序的鍵：", list)  # 根據字典鍵排序的鍵： ['age', 'city', 'name', 'tel']
new_dict = {}
for key in list:
    new_dict[key] = dict[key]
print("新字典：", new_dict)
# 新字典： {'age': 18, 'city': '深圳', 'name': 'zs', 'tel': '1362626627'}

sorted 語法：
    sorted(iterable[, cmp[, key[, reverse]]])

引數說明：
    iterable -- 可迭代物件。
    cmp -- 比較的函式，這個具有兩個引數，引數的值都是從可迭代物件中取出，此函式必須遵守的規則為，大於則返回1，小於則返回-1，等於則返回0。
    key -- 主要是用來進行比較的元素，只有一個引數，具體的函式的引數就是取自於可迭代物件中，指定可迭代物件中的一個元素來進行排序。
    reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（預設）。

返回值：
    返回重新排序的列表。

25、利用collections庫的Counter方法統計字串每個單詞出現的次數"kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"？

from collections import Counter

str = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
res = Counter(str)
print(res)
# Counter({'l': 9, ';': 6, 'h': 6, 'f': 5, 'a': 4, 'j': 3, 'd': 3, 's': 2, 'k': 1, 'g': 1, 'b': 1})

26、字串a = "not 404 found 張三 99 深圳"，每個詞中間是空格，用正則過濾掉英文和數字，最終輸出"張三  深圳"？

import re

a = "not 404 found 張三 99 深圳"
list = a.split(" ")
ret = re.findall(r"\d+|[a-zA-Z]+", a)  # | 連線多個匹配方式，兩邊不能有空格
print(ret)  # ['not', '404', 'found', '99']
for data in ret:
    if data in list:
        list.remove(data)
print(list)  # ['張三', '深圳']
new_a = " ".join(list)
print(new_a)  # 張三 深圳

27、filter方法求出列表所有奇數並構造新列表a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]？

filter() 函式用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。該接收兩個引數，第一個為函式，第二個為序列，序列的每個元素作為引數傳遞給函式進行判，然後返回 True 或 False，最後將返回 True 的元素放到新列表。

def fn(x):
    return x % 2 == 1

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = filter(fn, a)  # filter()返回值是一個物件 <filter object at 0x00000000027F8048>
c = [x for x in b]
print(c)  # [1, 3, 5, 7, 9]

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

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [x for x in a if x % 2 == 1]
print(b)  # [1, 3, 5, 7, 9]

29、正則re.complie作用？

re.compile是將正則表示式編譯成一個物件，加快速度，並重復使用。

30、a=（1，）b=(1)，c=("1") 分別是什麼型別的資料？

a = (1,)
b = (1)
c = ("1")
print(type(a))  # <class 'tuple'>
print(type(b))  # <class 'int'>
print(type(c))  # <class 'str'>

31、兩個列表[1,5,7,9]和[2,2,6,8]合併為[1,2,2,5,6,7,8,9]？

extend可以將另一個集合中的元素逐一新增到列表中，區別於append整體新增。

a = [1, 5, 7, 9]
b = [2, 2, 6, 8]
a.extend(b)
print(a)  # [1, 5, 7, 9, 2, 2, 6, 8]
a.sort(reverse=False)
print(a)  # [1, 2, 2, 5, 6, 7, 8, 9]

32、用Python刪除檔案和用linux命令刪除檔案方法？

python：os.remove (檔名)

linux：rm 檔名

33、log日誌中，我們需要用時間戳記錄error,warning等的發生時間，請用datetime模組列印當前時間戳 “2018-04-01 11:38:54”？

順便把星期的程式碼也貼上了

import datetime

t = datetime.datetime.now()
print(t)  # 2018-11-09 19:06:19.259846
t1 = t.strftime("%Y-%m-%d %H:%M:%S")
print(t1)  # 2018-11-09 19:06:19
w = t.isoweekday()
print(w)  # 5
time = str(t1) + "  星期：" + str(w)
print(time)  # 2018-11-09 19:06:19  星期：5

34、資料庫優化查詢方法？

外來鍵、索引、聯合查詢、選擇特定欄位等等。

35、請列出你會的任意一種統計圖（條形圖、折線圖等）繪製的開源庫，第三方也行？

pychart、matplotlib

36、寫一段自定義異常程式碼？

自定義異常用raise丟擲異常

# raise 自定義異常
def fn():
    try:
        for i in range(5):
            if i > 2:
                raise Exception("數字大於2")
    except Exception as e:
        print(e)

fn()

37、正則表示式匹配中，（.*）和（.*?）匹配區別？

（.*）是貪婪匹配，會把滿足正則的儘可能多的往後匹配。

（.*?）是非貪婪匹配，會把滿足正則的儘可能少匹配。

import re

str = '<a>abc</a><a>def</a>'

ret = re.findall(r"<a>(.*)</a>", str)
print("貪婪匹配：", ret)  # 貪婪匹配： ['abc</a><a>def']

ret = re.findall(r"<a>(.*?)</a>", str)
print("非貪婪匹配：", ret)  # 非貪婪匹配： ['abc', 'def']

38、簡述Django的orm？

ORM，全拼Object-Relation Mapping，意為物件-關係對映。

實現了資料模型與資料庫的解耦，通過簡單的配置就可以輕鬆更換資料庫，而不需要修改程式碼，只需要面向物件程式設計，orm操作本質上會根據對接的資料庫引擎，翻譯成對應的sql語句，所有使用Django開發的專案無需關心程式底層使用的是MySQL、Oracle、sqlite....，如果資料庫遷移，只需要更換Django的資料庫引擎即可。

39、[[1,2],[3,4],[5,6]]一行程式碼展開該列表，得出[1,2,3,4,5,6]？

列表推導式的騷操作 ​ ​ ​

執行過程：for y in a，每個y是[1,2]，[3,4]，[5,6]，for x in y，每個x就是1,2,3,4,5,6，合併後就是結果。

a = [[1, 2], [3, 4], [5, 6]]
new_a = [x for y in a for x in y]
print(new_a)  # [1, 2, 3, 4, 5, 6]

還有更騷的方法，將列表轉成numpy矩陣，通過numpy的flatten()方法，程式碼永遠是隻有更騷，沒有最騷 ​ ​ ​

import numpy as np
a = [[1, 2], [3, 4], [5, 6]]
new_a = np.array(a).flatten().tolist()
print(new_a)  # [1, 2, 3, 4, 5, 6]

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

join()括號裡面的是可迭代物件，x插入可迭代物件中間，形成字串，結果一致 

x = "abc"
y = "def"
z = ["d", "e", "f"]
m = x.join(y)
n = x.join(z)
print(m)  # dabceabcf
print(n)  # dabceabcf

順便建議大家學下os.path.join()方法，拼接路徑經常用到

41、舉例說明異常模組中try except else finally的相關意義？

try..except..else沒有捕獲到異常，執行else語句。

try..except..finally不管是否捕獲到異常，都執行finally語句。

a = 1
b = int(input("請輸入一個數字："))
try:
    x = a / b
except Exception as e:
    print("產生錯誤：", e)
else:
    print("沒有捕獲到異常，執行該語句")
finally:
    print("不管是否捕獲異常，都執行該語句")

42、Python中交換兩個數值？

a, b = 1, 2
print("a =", a)  # a = 1
print("b =", b)  # b = 2
a, b = b, a
print("a =", a)  # a = 2
print("b =", b)  # b = 1

43、舉例說明zip（）函式用法？

zip()函式在運算時，會以一個或多個序列（可迭代物件）做為引數，返回一個元組的列表。同時將這些序列中並排的元素配對。

zip()引數可以接受任何型別的序列，同時也可以有兩個以上的引數；當傳入引數的長度不同時，zip能自動以最短序列長度為準進行擷取，獲得元組。

a = [1, 2]
b = [5, 6]
ret = [i for i in zip(a, b)]
print(ret)  # [(1, 5), (2, 6)]

a = (1, 2)
b = (5, 6)
ret = [i for i in zip(a, b)]
print(ret)  # [(1, 5), (2, 6)]

a = "ab"
b = "xyz"
ret = [i for i in zip(a, b)]
print(ret)  # [('a', 'x'), ('b', 'y')]

44、a="張明 98分"，用re.sub，將98替換為100？

import re

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

45、寫5條常用sql語句？

show databases;

show tables;

desc 表名;

select * from 表名;

delete from 表名 where id=5;

update students set gender=0,hometown="北京" where id=5

46、a="hello"和b="你好"編碼成bytes型別？

a = "hello"
b = "你好"
a = a.encode()
b = b.encode()
print(a)  # b'hello'
print(b)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

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

兩個列表相加，等價於extend。

a = [1, 2, 3]
b = [4, 5, 6]
print(a + b)  # [1, 2, 3, 4, 5, 6]
a.extend(b)
print(a)  # [1, 2, 3, 4, 5, 6]

48、提高Python執行效率的方法？

1、使用生成器，因為可以節約大量記憶體；

2、迴圈程式碼優化，避免過多重複程式碼的執行；

3、核心模組用Cython  PyPy等，提高效率；

4、多程序、多執行緒、協程；

5、多個if elif條件判斷，可以把最有可能先發生的條件放到前面寫，這樣可以減少程式判斷的次數，提高效率。

49、簡述mysql和redis區別？

redis： 記憶體型非關係資料庫，資料儲存在記憶體中，速度快。

mysql：關係型資料庫，資料儲存在磁碟中，檢索的話，會有一定的Io操作，訪問速度相對慢。

50、遇到bug如何處理？

1、細節上的錯誤，通過print()列印，能執行到print()說明一般上面的程式碼沒有問題，分段檢測程式是否有問題，如果是js的話可以alert或console.log。

2、如果涉及一些第三方框架，會去查官方文件或者一些技術部落格。

3、對於bug的管理與歸類總結，一般測試將測試出的bug用teambin等bug管理工具進行記錄，然後一條一條進行修改，修改的過程也是理解業務邏輯和提高自己程式設計邏輯縝密性的方法，也都會收藏做一些筆記記錄。

4、導包問題、城市定位多音字造成的顯示錯誤問題。