摘要：所以在多線程中，線程的運行仍是有先后順序的，并不是同時進行。哈希函數的目的是使鍵均勻地分布在數組中。由于不同的鍵可能具有相同的哈希值，即可能出現沖突，高級的哈希函數能夠使沖突數目最小化。

首先這篇文章在我的《Python數據結構》公眾號已經提及，但是本篇文章提供了更為高級的解法，來發散大家的思維；同時為大家提供我的草稿py文件，大家可以關注《Python數據結構》公眾號后恢復 120 獲取源代碼。

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

sum(range(0, 100))

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

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

3、 列出5個常用Python標準庫？

os：提供了不少與操作系統相關聯的函數
sys：通常用于命令行參數
re：正則匹配
math：數學運算
datetime：處理日期時間

4 、如何合并兩個字典？

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

5、談下Python的GIL？

GIL是Python的全局解釋器鎖，同一進程中假如有多個線程運行，一個線程在運行Python程序的時候會霸占Python解釋器（加了一把鎖即GIL），使該進程內的其他線程無法運行，等該線程運行完后其他線程才能運行。如果線程運行過程中遇到耗時操作，則解釋器鎖解開，使其他線程運行。所以在多線程中，線程的運行仍是有先后順序的，并不是同時進行。
多進程中因為每個進程都能被系統分配資源，相當于每個進程有了一個Python解釋器，所以多進程可以實現多個進程的同時運行，缺點是進程系統資源開銷大。

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

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

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

如果你有其他語言基礎的話，你應該聽說過重載的概念，對，Python為了避免這種繁瑣的情況發送，引入了args和kwargs；args用來接受非鍵值對的數據，即元組類型，而kwargs則用來接受鍵值對數據，即字典類

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

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

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

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

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

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

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

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

12、簡述面向對象中__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__函數。

13、簡述with方法打開處理文件幫我我們做了什么？

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

14、列表[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])

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

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

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

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

17、

import re
s = "
Python
"
print(re.findall(r"
(.*?)
", s))

18、Python中斷言方法舉例？

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

19、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))

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

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

22、列出Python中可變數據類型和不可變數據類型，為什么？

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

23、dict的內部實現？

在Python中，字典是通過哈希表實現的。也就是說，字典是一個數組，而數組的索引是鍵經過哈希函數處理后得到的。哈希函數的目的是使鍵均勻地分布在數組中。由于不同的鍵可能具有相同的哈希值，即可能出現沖突，高級的哈希函數能夠使沖突數目最小化。

24、s = "ajldjlajfdljfffffd"，去重并從小到大排序輸出"adfjl"？

s1 = "ajldjlajfdljfffffd"
print("".join(sorted(set(s1))))

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

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

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

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

27、Python獲取當前日期？

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

28、獲取請求頭的參數？

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

29、例舉五條PEP8 規范

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

30、Python語言的運行機制

31、Fibonacci數列

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

32、Python三目運算

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

33、單例模式

 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

34、正則匹配優先級

35、遞歸

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

36、統計字符串每個單詞出現的次數

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

37、正則re.complie作用

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

38、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)))

39、列表推導式求列表所有奇數并構造新列表，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

41、兩個列表[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)

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

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

43、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")

44、寫一段自定義異常代碼

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

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

#（.*）是貪婪匹配，會把滿足正則的盡可能多的往后匹配
#（.*?）是非貪婪匹配，會把滿足正則的盡可能少匹配
s = "哈哈呵呵"
import re
res1 = re.findall("(.*)", s)
print("貪婪匹配", res1)
res2 = re.findall("(.*?)", s)
print("非貪婪匹配", res2)
-------------------------
輸出：
貪婪匹配 ["哈哈呵呵"]
非貪婪匹配 ["哈哈", "呵呵"]

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

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

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

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

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)]

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

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

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

1、使用生成器，因為可以節約大量內存
2、循環代碼優化，避免過多重復代碼的執行
3、核心模塊用Cython  PyPy等，提高效率
4、多進程、多線程、協程
5、多個if elif條件判斷，可以把最有可能先發生的條件放到前面寫，這樣可以減少程序判斷的次數，提高效率

1、細節上的錯誤，通過print（）打印，能執行到print（）說明一般上面的代碼沒有問題，分段檢測程序是否有問題，如果是js的話可以alert或console.log
2、如果涉及一些第三方框架，會去查官方文檔或者一些技術博客。
3、對于bug的管理與歸類總結，一般測試將測試出的bug用teambin等bug管理工具進行記錄，然后我們會一條一條進行修改，修改的過程也是理解業務邏輯和提高自己編程邏輯縝密性的方法，我也都會收藏做一些筆記記錄。
4、導包問題、城市定位多音字造成的顯示錯誤問題

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])

print(round(5/3, 2))

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)|1d|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"))

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

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