Some Interview Questions About Python
一大波超連接即將襲來
Django認證流程
Python實現階乘
Python文件處理
Python統計日誌文件IP出現次數
JSON數據解析
JSON數據解析2
買賣股票的最佳時期html
讀取一個大文件好比500M，計算出每個字的頻率，分別把前十頻率的求出來。
def str_count(filename):
f = open(filename,'r',encoding='utf-8')
dic = {}
while True:
line = f.readline()
if line:
for s in line:
if s in dic:
dic[s]+=1
else:
dic[s]=1
else:
break
result = sorted(dic.items(), key=lambda k: k[1], reverse=True)
print(dic)
print(result)
str_count(r'C:\Users\Administrator\Desktop\text.txt')
----------------------英文單詞頻率
def word_count(filename):
f = open(filename,'r')
dic = {}
while True:
line = f.readline()
if line:
line = line.replace(',','')
line = line.replace('.','')
line = line.replace('!','')
line = line.replace(';','')
line = line.replace('-','')
str_list = line.split()
for s in str_list:
if s.lower() in dic:
dic[s.lower()]+=1
else:
dic[s.lower()] = 1
else:
break
result = sorted(dic.items(), key=lambda k: k[1], reverse=True)
print(result)
word_count(r'C:\Users\Administrator\Desktop\abc'
r'.txt')
線程之間如何進行通訊？
一、經過queue(隊列)，基於queue共享數據，使用 put() 和 get() 操做來向隊列中添加或者刪除元素，實現線程之間的通訊。 二、能夠本身經過建立本身的數據結構(例如一個列表)來實現線程間通訊， 如：threading.Condition()的notify方法，以及經過threading.Event對象 三、基於生產者、消費者實現線程之間的通訊
三次登陸
count = 0 #計數器
username = "aaa" #登陸用戶名
userpassword = "asd" #登陸密碼
f = open("aaa.txt","r")
file_list = f.readlines()
f.close()
lock= []
name = input("登陸用戶名：")
for i in file_list:1
line = i.strip("\n")
lock.append(line)
if name in lock:
print("你的帳戶已鎖定，請聯繫管理員。")
else:
if name == username:
#若是密碼連續輸錯了三次，鎖定帳號
while count <3:
password = input("登陸密碼：")
if name == username and password == userpassword:
print("歡迎%s!"%name)
break
else:
print("帳號和密碼不匹配")
count +=1
else:
print("對不起，您的帳號連續輸錯三次密碼已被鎖定，請聯繫管理員。")
f = open("aaa.txt","w+")
li = ['%s'%username]
f.writelines(li)
f.close()
else:
print("用戶名不存在，請輸入正確的用戶名。")
計算N天后的日期
import datetime
def get_day(y,m,d,n):
the_date =datetime.datetime(y,m,d)
result_date = the_date + datetime.timedelta(days=n)
d = result_date.strftime("%Y-%m-%d")
return d
print(get_day(2018,3,25,1))
計算給定日期是該年的第多少天
def count(year, month, day):
count = 0
# 判斷該年是平年仍是閏年
if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
print('%d年是閏年，2月份有29天！' % year)
li1 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
for i in range(month - 1):
count += li1[i]
return count + day
else:
print('%d年是平年，2月份有29天！' % year)
li2 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
for i in range(month - 1):
count += li2[i]
return count + day
if __name__ == "__main__":
year = int(input('請輸入年份：'))
month = int(input('請輸入月份：'))
day = int(input('請輸入日期：'))
count = count(year, month, day)
print('%d年%d月%d日是今年的第%d天！' % (year, month, day, count))
循環和遞歸實現二分查找
while 循環實現二分查找
def bin_search(data_list, val):
low = 0 # 最小數下標
high = len(data_list) - 1 # 最大數下標
while low <= high:
mid = (low + high) // 2 # 中間數下標
if data_list[mid] == val: # 若是中間數下標等於val, 返回
return mid
elif data_list[mid] > val: # 若是val在中間數左邊, 移動high下標
high = mid - 1
else: # 若是val在中間數右邊, 移動low下標
low = mid + 1
return # val不存在, 返回None
ret = bin_search(list(range(1, 100)), 66)
print(ret)
遞歸實現二分查找
def bin_search(li, val, low, high):
if low <= high:
mid = (low + high) // 2
if li[mid] == val:
return mid
elif li[mid] > val:
return bin_search(li, val, low, mid - 1)
else:
return bin_search(li, val, mid + 1, high)
else:
return
li = list(range(1000))
ret = bin_search(li, 555, 0, len(li) - 1)
print(ret)
Python上下文管理器（Context Manager）
當咱們須要建立一個上下文管理器類型的時候，就須要實現__enter__和__exit__方法，這對方法就稱爲上下文管理協議（Context Manager Protocol），定義了一種運行時上下文環境。
在Python中，能夠經過with語句來方便的使用上下文管理器，with語句能夠在代碼塊運行前進入一個運行時上下文（執行__enter__方法），並在代碼塊結束後退出該上下文（執行__exit__方法）。
http://python.jobbole.com/82289/
括號匹配問題,把list維護成一個棧
SYMBOLS = {'}':'{', ']':'[', ')':'('}
SYMBOLS_L, SYMBOLS_R = SYMBOLS.values(), SYMBOLS.keys()
def check(s):
arr = []
for c in s:
if c in SYMBOLS_L:
# 左符號入棧
arr.append(c)
elif c in SYMBOLS_R:
# 右符號要麼出棧，要麼匹配失敗
if arr and arr[-1] == SYMBOLS[c]:
arr.pop()
else:
return False
return not arr
print(check("3 * {3 +[(2 -3) * (4+5)]}"))
print(check("3 * {3+ [4 - 6}]"))
經常使用正則表達式
郵箱
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
手機號
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
IP地址
\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b
生成器相關習題
1.生成器函數：
def demo():
for i in range(4):
yield i
g=demo() # 生成器
g1=(i for i in g) #生成器
g2=(i for i in g1) #g2 生成器
print(list(g1)) #[0,1,2,3]
print(list(g2)) #[]
2.計算生成器函數返回值
def add(n,i):
return n+i
def test():
for i in range(4):
yield i
g=test()
for n in [1,10]:
g=(add(n,i) for i in g)
print(list(g)) #[20, 21, 22, 23]
生產者消費者模型
程序中有兩類角色：一類負責生產數據（生產者），一類負責處理數據（消費者）；引入生產者消費者模型爲了解決的問題是：平衡生產者與消費者之間的工做能力，從而提升程序總體處理數據的速度；如何實現：生產者<-->隊列<——>消費者；生產者消費者模型實現類程序的解耦和。
如何防止sql注入
sql注入：在sql語句中，若是存在'--'字符，則執行sql語句時會註釋掉--字符後面的內容。凡是有SQL注入漏洞的程序，
都是由於程序要接受來自客戶端用戶輸入的變量或URL傳遞的參數，而且這個變量或參數是組成SQL語句的一部分。放置方式有：
一、使用預編譯綁定變量的SQL語句 如execute()
2.嚴格加密處理用戶的機密信息
3.不要隨意開啓生產環境中Webserver的錯誤顯示
4.使用正則表達式過濾傳入的參數
5.字符串過濾
6.檢查是否包函非法字符
連表操做的區別
一、交叉鏈接：不使用任何匹配條件生成笛卡爾積
select * from employee,department
二、內鏈接：只鏈接匹配的行
selcet employee.name,employee.age,department.name from employee inner join department on employee.dep_id = department.id
三、外鏈接之左鏈接：優先顯示左表所有內容
selcet employee.name,employee.age,department.name from employee left join department on employee.dep_id = department.id
四、外鏈接之右鏈接：優先顯示右表所有內容
selcet employee.name,employee.age,department.name from employee right join department on employee.dep_id = department.id
五、全外鏈接：顯示左右兩個表所有記錄(mysql不支持full join)，實現方式以下：
select * from employee left join department on employee.dep_id = department.id
union
select * from employee right join department on employee.dep_id = department.id
如何求二進制中1 的個數
def count1(a):
'''
整數的二進制表達裏有多少個1，複雜度爲a的二進制長度。
'''
num = 0
while a != 0:
num += a & 1
a >>= 1
return num
def count2(a):
'''
整數的二進制表達裏有多少個1，複雜度僅爲1的個數
'''
num = 0
while a != 0:
a = a & (a - 1) # 就是這個操做，須要掌握，它的本質含義是抹去了0不考慮
num += 1
return num
運算符說明:http://www.runoob.com/python/python-operators.html
https://blog.csdn.net/dongrixinyu/article/details/78877489
統計出現頻率最高的詞
import os
from collections import Counter
sumsdata=[]
for fname in os.listdir(os.getcwd()):
if os.path.isfile(fname) and fname.endswith('.txt'):
with open(fname,'r') as fp:
data=fp.readlines()
fp.close()
sumsdata+=[line.strip().lower() for line in data]
cnt=Counter()
for word in sumsdata:
cnt[word]+=1
cnt=dict(cnt)
for key,value in cnt.items():
print(key+":"+str(value))
子網掩碼有什麼用
子網掩碼（subnet mask）的做用實際上只是用來標識出某個IP地址哪部分是網絡位的一段地址。
map等使用實例
map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函數
[1, 4, 9, 16, 25]
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) # 提供了兩個列表，對相同位置的列表數據進行相加
[3, 7, 11, 15, 19]
list去重
一、直觀方法
li=[1,2,3,4,5,1,2,3]
new_li=[]
for i in li:
if i not in new_li:
new_li.append(i)
print(new_li)
先創建一個新的空列表，經過遍歷原來的列表，再利用邏輯關係not in 來去重。
總結：這樣能夠作出來，可是過程不夠簡單。可是此方法保證了列表的順序性。
二、利用set的自動去重功能
li=[1,2,3,4,5,1,2,3]
li=list(set(li))
print(li)
將列表轉化爲集合再轉化爲列表，利用集合的自動去重功能。簡單快速。缺點是：使用set方法沒法保證去重後的順序。
modle中slugfield字段的用途
一、slug：用於生成一個有意義（valid, meaninful）URL 參考（http://stackoverflow.com/questions/427102/what-is-a-slug-in-django）
好比：http://stackoverflow.com/questions/427102/what-is-a-slug-in-django 後面的「what-is-a-slug-in-django」就是通過slug後的產物
如何使用：
須要使用slugify功能：from django.utils.text import slugify
例子：slugify(value) If value is "Joel is a slug", the output will be "joel-is-a-slug".
二、SlugField：也是起到相似做用，只不過這個通常是後臺直接添加時使用，好比：slug = models.SlugField(unique=True) 這樣在後臺就有個slug框，填寫後，URL中就包含slug中的內容。
https://www.cnblogs.com/ohmydenzi/p/5584846.html
SVN和git
1. Git是分佈式的，SVN是集中式的，好處是跟其餘同事不會有太多的衝突，本身寫的代碼放在本身電腦上，一段時間後再提交、合併，也能夠不用聯網在本地提交；
2. Git下載下來後，在本地沒必要聯網就能夠看到全部的log，很方便學習，SVN卻須要聯網；
3. Git鼓勵分Branch，而SVN，說實話，我用Branch的次數還挺少的，SVN自帶的Branch merge我還真沒用過，有merge時用的是Beyond Compare工具合併後再Commit的；
4. Tortoise也有出Git版本，真是好東西；
5. SVN在Commit前，咱們都建議是先Update一下，跟本地的代碼編譯沒問題，並確保開發的功能正常後再提交，這樣其實挺麻煩的，有好幾回同事沒有先Updata，就
Commit了，發生了一些錯誤，耽誤了你們時間，Git可能這種狀況會少些。
cookie和session區別
cookie是把用戶的數據寫在用戶本地瀏覽器上, 其餘網站也能夠掃描使用你的cookie，容易泄露本身網站用戶的隱私，並且通常瀏覽器對單個網站站點有cookie數量與大小的限制。Session是把用戶的數據寫在用戶的獨佔session上，存儲在服務器上，通常只將session的id存儲在cookie中。但將數據存儲在服務器對服務器的成本會高。session是由服務器建立的，開發人員能夠在服務器上經過request對象的getsession方法獲得session通常狀況，登陸信息等重要信息存儲在session中，其餘信息存儲在cookie中
Cookie Session
儲存位置 客戶端 服務器端
目的 跟蹤會話，保存用戶偏好設置或用戶名密碼等 跟蹤會話
安全性 不安全 安全
session技術是要使用到cookie的，之因此出現session技術，主要是爲了安全。
apache和nginx的區別
https://www.cnblogs.com/wangzhipeng/p/7850717.html
經常使用推導式
列表推導式
字典推導式
集合推導式
https://www.cnblogs.com/cenyu/p/5718410.html
閉包代碼
閉包函數的實例
outer是外部函數 a和b都是外函數的臨時變量
def outer( a ):
b = 10
# inner是內函數
def inner():
#在內函數中 用到了外函數的臨時變量
print(a+b)
# 外函數的返回值是內函數的引用
return inner
if __name__ == '__main__':
# 在這裏咱們調用外函數傳入參數5
#此時外函數兩個臨時變量 a是5 b是10 ，並建立了內函數，而後把內函數的引用返回存給了demo
# 外函數結束的時候發現內部函數將會用到本身的臨時變量，這兩個臨時變量就不會釋放，會綁定給這個內部函數
demo = outer(5)
# 咱們調用內部函數，看一看內部函數是否是能使用外部函數的臨時變量
# demo存了外函數的返回值，也就是inner函數的引用，這裏至關於執行inner函數
demo() # 15
demo2 = outer(7)
demo2()#17
https://www.cnblogs.com/Lin-Yi/p/7305364.html
python讀取大文件20G
with open(filename, 'r') as flie:
for line in file:
....
--------------
text = linecache.getline(filename, 2) # 使用linecache模塊
https://www.cnblogs.com/wulaa/p/7852592.html
數據庫引擎特色
MyISAM:
有存儲限制，表的定義語句，數據，索引分文件存儲，分別爲.frm文件，.MYD（MyDate），.MYI文件（MyIndex），存儲方式分靜態表（默認），動態表，壓縮表。靜態表中表字段定長，存儲速度快，容易緩存，出現故障容易恢復，可是空間浪費嚴重。動態表中表字段不定長，空間浪費小，可是崩潰不易恢復，頻繁的刪除和更新會產生大量的碎片，可使用OPTIMIZE TABLE命令按期清理碎片。同時MyISAM存儲殷勤不支持外鍵，也不支持事務處理，可是其優點爲訪問速度快，在使用中中，若是對事務完整性沒有要求，或者數據庫操做主要以Select或者Insert爲主的應用基本上可使用這種存儲引擎，並且MyISAM存儲殷勤在也是5.5版本以前MySQL默認的存儲引擎。
InnoDB:
提供回滾，提交，崩潰恢復的事務安全，惟一支持外鍵，表中的自動增加列必須是索引，若是是組合索引，必須是組合索引的第一列，而且自動增加列支持手動插入，可是若是插入值爲空或者0，則實際值爲增加後的值。建立外鍵時，要求父表必須有對應的索引，子表在建立外鍵的時候，也會自動建立對應的索引。若是某個表被其餘表建立了外鍵參照，那麼該表的對應索引或者主鍵禁止被刪除。可是在建立索引時，能夠指定在對父表進行刪除或者更新時，子表所對應的操做，這些操做包括如下幾種：
RESTRICT,CASCADE,SET NULL,NO ACTION，其實RESTRICT和NO ACTION做用相同，是指在子表有關聯記錄的時候，父表不容許更新，CASCADE是指在父表執行更新或者刪除操做時，更新或者刪除子表對應的記錄，SET NULL是指在父表執行刪除或者更新操做時，子表相應字段設置爲NULL。
InnoDB在存儲方式上，分爲共享表空間和使用多表空間存儲。
https://blog.csdn.net/qq_34985719/article/details/78637119
select和epoll原理和區別
其實全部的I/O都是輪詢的方法,只不過實現的層面不一樣罷了.
這個問題可能有點深刻了,但相信能回答出這個問題是對I/O多路複用有很好的瞭解了.其中tornado使用的就是epoll的.
selec,poll和epoll區別總結
基本上select有3個缺點:
鏈接數受限
查找配對速度慢
數據由內核拷貝到用戶態
poll改善了第一個缺點
epoll改了三個缺點.
關於epoll的: http://www.cnblogs.com/my_life/articles/3968782.html
dict轉列表
a = {'a' : 1, 'b': 2, 'c' : 3}
key_value = list(a.keys()) #字典中的key轉換爲列表
print('字典中的key轉換爲列表：', key_value)
value_list = list(a.values()) #字典中的value轉換爲列表
print('字典中的value轉換爲列表：', value_list)
XSS攻擊
XSS 攻擊，全稱是「跨站點腳本攻擊」（Cross Site Scripting），之因此縮寫爲 XSS，主要是爲了和「層疊樣式表」（Cascading StyleSheets，CSS）區別開，以避免混淆。XSS 是一種常常出如今web應用中的計算機安全漏洞，它容許惡意web用戶將代碼植入到提供給其它用戶使用的頁面中。這些代碼包括HTML代碼和客戶端腳本。對於跨站腳本攻擊，黑客界共識是：跨站腳本攻擊是新型的「緩衝區溢出攻擊」，而JavaScript是新型的「ShellCode」。
線程安全
線程安全就是多線程訪問時，採用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其餘線程不能進行訪問直到該線程讀取完，其餘線程纔可以使用。不會出現數據不一致或者數據污染。 線程不安全就是不提供數據訪問保護，有可能出現多個線程前後更改數據形成所獲得的數據是髒數據。
1+2+3+...+n用python怎麼用遞歸實現?
for
while
https://blog.csdn.net/fang_zz/article/details/51530796
斐波那契數列不一樣版本
while循環版
a=0
b=1
while b < 1000:
print(b)
a, b = b, a+b
遞歸版
lis = []
for i in range(20):
if i == 0 or i == 1: # 第1,2項 都爲1
lis.append(1)
else:
lis.append(lis[i - 2] + lis[i - 1]) # 從第3項開始每項值爲前兩項值之和
print(lis)
for循環版
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return b
init()和__new__()的區別
__init__ 只是單純的對實例進行某些屬性的初始化，以及執行一些須要在新建對象時的必要自定義操做，無返回值。而 __new__ 返回的是用戶建立的實例，這個纔是真正用來建立實例的，因此 __new__ 是在 __init__ 以前執行的，先建立再初始化。
利用Python實現棧和隊列
# 後進先出
class Stack():
def __init__(self, size):
self.size = size
self.stack = []
self.top = -1
# 入棧以前檢查棧是否已滿
def push(self, x):
if self.isfull():
raise exception("stack is full")
else:
self.stack.append(x)
self.top = self.top + 1
# 出棧以前檢查棧是否爲空
def pop(self):
if self.isempty():
raise exception("stack is empty")
else:
self.top = self.top - 1
self.stack.pop()
def isfull(self):
return self.top + 1 == self.size
def isempty(self):
return self.top == '-1'
def showStack(self):
print(self.stack)
s = Stack(10)
for i in range(6):
s.push(i) # 入棧
s.showStack() # [0, 1, 2, 3, 4, 5]
for i in range(2):
s.pop() # 出棧
s.showStack() # [0, 1, 2, 3]
-------------------
# 先進先出
class Queue():
def __init__(self,size):
self.size=size
self.front=-1
self.rear=-1
self.queue=[]
def enqueue(self,ele): # 入隊操做
if self.isfull():
raise exception("queue is full")
else:
self.queue.append(ele)
self.rear=self.rear+1
def dequeue(self): # 出隊操做
if self.isempty():
raise exception("queue is empty")
else:
self.queue.pop(0)
self.front=self.front+1
def isfull(self):
return self.rear-self.front+1 == self.size
def isempty(self):
return self.front == self.rear
def showQueue(self):
print(self.queue)
q=Queue(10)
for i in range(6):
q.enqueue(i)
q.showQueue()
for i in range(3):
q.dequeue()
q.showQueue()
print(q.isempty())
Python 中的 GIL 是什麼？舉個例子說說其具體體現。
GIL 全稱 Global Interpreter Lock（全局解釋器鎖），任何 Python 線程執行前，必須先得到 GIL 鎖，而後，每執行100條字節碼，解釋器就自動釋放GIL鎖，讓別的線程有機會執行。要避免這種「現象」利用操做系統的多核優點能夠有下面幾種方法：
使用 C 語言編寫擴展，建立原生線程，擺脫 GIL，可是即便是擴展，在 Python 代碼內，任意一條Python 代碼仍是會有 GIL 限制
使用多進程代替多線程，使用多進程時，每一個進程都有本身的 GIL。故不存在進程與進程之間的 GIL 限制。可是多進程不能共享內存。
相關文章
- 1. some questions and tips about java
- 2. python interview questions
- 3. Microsoft Interview Questions
- 4. Data Structure Interview Questions Data Structure Interview Questions
- 5. android interview questions
- 6. Java Interview Questions (1)
- 7. DSA Interview Questions
- 8. SAP ABAP Interview Questions
- 9. Front-end Job Interview Questions
- 10. interview questions
- 更多相關文章...
- • SQLite - Python - SQLite教程
- • Docker 安裝 Python - Docker教程
- • YAML 入門教程
- • Git五分鐘教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. some questions and tips about java
- 2. python interview questions
- 3. Microsoft Interview Questions
- 4. Data Structure Interview Questions Data Structure Interview Questions
- 5. android interview questions
- 6. Java Interview Questions (1)
- 7. DSA Interview Questions
- 8. SAP ABAP Interview Questions
- 9. Front-end Job Interview Questions
- 10. interview questions