python 試題

1、現有兩元祖 (('a'),('b'),('c'),('d') ) ,請使用Python中的匿名函數生成列表 [ {'a':'c'｝,{'c':'d'}]

答案：v = list(map(lambda x,y:{x:y},data[0:2],data[2:4]))
data = (('a'),('b'),('c'),('d') )
v = list(map(lambda x,y:{x:y},data[0:2],data[2:4]))
data[0:2] = ('a'),('b')
data[2:4] = ('c'),('d')
匿名函數 傳進去  參數(x,y)  返回 {x:y}
map(func,iterable) # 對於iterable 依次 傳遞給 func ，返回的是可迭代對象
關於map函數的使用,可以理解為  map(f,iterable) >> [f(x) for x in iterable]    ,
　　　　　　　　　　　　　　　map(f,list1,list2,list3) >> 
result = [] 
for a in list1: 
 for b in list2:
 for c in list3: 
 result.append(abc(abc))
詳細使用方式,如果回憶不起來了,可以參看博客:
https://my.oschina.net/zyzzy/blog/115096

2、看代碼 寫結果

def multipliters(): return [lambda x:i * x for i in range(4)] print([m(2) for m in multipliters()])

 

# 第一種是 將生成器對象生成的匿名函數轉化成列表 ，匿名函數使用的是相同的內存空間。
# 轉換成列表后，循環結束，命名空間里的i都為3
def multipliters():
    return [lambda x:i * x for i in range(4)]

print([m(2) for m in multipliters()])

# 以下是依次返回 生成器生成的每個匿名函數，每次調用i都在變化

#首先通過列表生成式生成了4個函數,為 [lambda x:3*x,lambda x:3*x,lambda x:3*x,lambda x:3*x]
# 打印結果就為6666
def multipliters2():
    return (lambda x: i*x for i in range(4))
print([m(2) for m in multipliters2()])

 

3、  1 or 2   和   1 and 2 分別輸出什么？

 

# 1     2  
# 0 "" [] {} set() None False 放入判斷表達式都為假
# or 或  and 與
# 整個式子 不斷去向右查看，直到能確定為真就停下來
關於  and  和  or  的計算規則:

其一, 在不加括號時候, and優先級大於

其二, x or y 的值只可能是x或y. x為真就是x, x為假就是y

第三, x and y 的值只可能是x或y. x為真就是y, x為假就是x

 

4、看代碼 寫結果

value = "B" and "A" or "C" print(value)

# A
# 整個式子 不斷去向右查看，直到能確定為真就停下來
# 解釋同上一題

 

5、看代碼寫結果

v1 = [i % 2 for i in range(10)] v2 = (i % 2 for i in range(10)) print(v1,v2

 

# v1 = [i % 2 for i in range(10)] 為列表生成式
# v2 = (i % 2 for i in range(10)) 為<generator object <genexpr> at 0x00E4F990>為生成器   

 

6、看代碼，寫結果

 

def extendList(val,li=[]): li.append(val) return li list1 = extendList(10) list2 = extendList(123,[]) list3 = extendList('a') print(list1) print(list2) print(list3)

 

 

# [10, 'a']
# [123]
# [10, 'a']
# 參數變量在編譯會生成，而且只會生成一次，其內存地址的指向不發生變化
# 所以會有默認的 []
# 1、3都會使用默認的 編譯生成同一個[]
# 2 新生成一個 []
list1=[].append(10)
list2=[].append(123)
list3=[10].append('a')
list=[] 都指向同一個內存地址,第三次的時候 [] 內存地址相同,但插入值了,所以答案如上

 

7、下面代碼誰報錯？

v1 = {} v2 = {3:5} v3 = {[11,23]:5} v4 = {(11,23):5}

v3錯誤，字典元素的鍵不能為可變對象

8、輸出以下結果

for i in range(5,0,1): print(i)

# range(起始元素,結束元素（不包含）,每次的變化)
# 從5到0每次加1
# 打印不出來任何東西

9、請說出range和xrange的區別

 

# from collections import Iterable,Iterator
# Iterable 可迭代對象
# Iterator 迭代器 
# print(isinstance(xrange(10),Iterator))
# print(isinstance(xrange(10),Iterable))

# python2 中 range(start, stop[, step]) 和 range(stop) 會生成-> range object,,返回是列表，是可迭代對象，全部放在內存里  產生列表
# python2 中 xrange(start, stop[, step]) 和 range(stop)會生成-> xrange object，返回是可迭代對象，每次調用時才會生成     產生生成器
#    要生成很大的數字序列的時候，用xrange會比range性能優很多，因為不需要一上來就開辟一塊很大的內存空間。

# python3 沒有xrange，只有range，也是可迭代對象，每次調用時才會生成

 

10、請將 "1,2,3"，變成 ["1","2","3"]

 

"1,2,3".split(',')

 

11、一行代碼生成 [1,4,9,16,25,36,49,64,81,100]

 

[i*i for i in range(11)]

 

12、一行生成 9 * 9乘法表

 

[ x for x in range(1,10)]

[ x*y for y in range(1,x+1)]

[ ([ x*y for y in range(1,x+1)]) for x in range(1,10)]

[ ([ '{}*{} = {}'.format(x,y,x*y) for y in range(1,x+1)]) for x in range(1,10)]

'\n'.join([ str(x) for x in range(1,10)])

print('\n'.join([ ' '.join( [ '{}*{} = {}'.format(x,y,x*y) for y in range(1,x+1)] ) for x in range(1,10)]) )

 

13、map(str,[1,2,3,4,5,6,7,8,9])輸出什么？Python2 和Python3輸出的結果一樣嗎？

 

print(isinstance(map(str,[1,2,3,4,5,6,7,8,9]),Iterable))
print(isinstance(map(str,[1,2,3,4,5,6,7,8,9]),Iterator))
# python 3 <map object at 0x00D359F0> 是 Iterator
# python 2 ['1', '2', '3', '4', '5', '6', '7', '8', '9'] ,是可迭代對象，但不是Iterator

 

14、Django如何在Model保存前做一定的固定操作，比如寫一條日志

 

利用Django的Model的Signal Dispatcher, 通過django.db.models.signals.pre_save()方法，在事件發生前，發射觸發信號，這一切都被調度中的receiver方法深藏功與名的保存了。
信號的處理一般都寫在Model中，舉個例子：
import logging
from django.db import models
from django.db.models.signals import pre_save
from django.dispatch import receiver
 
class Order(models.Model):
    # ...
 
logger = logging.getLogger(__name__)
 
@receiver(pre_save, sender=Order)
def pre_save_handler(sender, **kwargs):
 
    # 我們可以在Order這個Model保存之前盡情調戲了：）
    logger.debug("{},{}".format(sender, **kwargs))

參考：http://python.jobbole.com/81871/

15、1,2,3,4,5能組成多少個互不相同的無重復的三位數

5 * 4 * 3

 

16、什么是lambda函數？它有什么好處？另外python在函數編程方面提供了些什么函數和語法？

lambda是Python中的匿名函數。它語法簡單，簡化代碼，不會產生命名沖突，污染命名空間。Python提供了map，reduce，filter等函數方法，提供了裝飾器，閉包等語法

17、詳細說說tuple、list、dict的用法，它們的特點；

tuple 元祖，固定長度不可變的順序容器，訪問效率高，是和存儲一些常量數據，可以作為字典的鍵使用
list 列表，是長度可變有序的數據存儲容器，。可以通過下標索引取到相應的數據
dict 字典，長度可變的hash字典容器。存儲的方式為鍵值對，可以通過相應的鍵獲取相應的值，key支持多種類型

18、說說python中裝飾器、迭代器的用法；描述下dict 的 items() 方法與 iteritems() 方法的不同；

裝飾器是指對函數執行過程，做一些擴展，甚至可以更改本身函數的執行
迭代器是指遵循迭代器協議的對象，這類對象在被for循環時，每次迭代生成下一個項，不用一開始就生成整個列表
在python中 不存在iteritems，items方法返回可迭代對象
在python3中 items()返回[(key,value)]的列表對象，iteritems()返回迭代器對象，iteritems()循環時不可以增刪dict的內容

19、講講對unicode, gbk, utf-8等的理解，python2.x是如何處理編碼問題？

unicode編碼：為了解決各個國家的語言的存儲，引進的unicode碼，包括UCS2,UCS4,UTF-8,UTF-7等
gbk：和unicode不一樣的編碼方式 ，常用的為 gbk-2312
utf-8: UTF-8 使用 1-4 個字節來存儲單個字符，應該是目前最流行的字符集。Linux 默認字符集就是UTF-8。既解決了大多數語言的編碼方式，又避免了簡單字符存儲對空間的浪費

python 2.x 需要在文件上方聲明文件的編碼方式# -*- coding: utf8 -*-，可以通過str.decode/str.encode處理字符串的文本編碼
保證 python 編輯器的編碼正確，或使用 u’中文’保證被轉換成 unicode 編碼，推薦使用
sys.setdefaultencoding('utf-8')來保證我們的編碼

20、Python 是如何進行內存管理的？python 的程序會內存泄露嗎？說說有沒有什么方面防止或檢測內存泄露？

Python GC主要使用 引用計數 來跟蹤和回收垃圾。在引用計數的基礎上，通過“標記-清除”解決容器對象可能產生的循環引用問題。通過分代
以空間換時間的方法提高垃圾回收效率
1、引用計數： 每個對象中都有ob-refcnt來做引用計數。當一個對象...,ob-refcnt就會增加，當引用的對象刪除，那么ob-refcnt就會減少當ob-refcnt為零，就會釋放該對象的內存空間
2、標記清除： 解決循環引用的問題。先按需分配，等到沒有空閑內存的時候，從寄存器和程序棧上的引用出發，遍歷所有對象和引用把所有能訪問的打標記，最后將沒有標記的對象釋放掉
3、分代技術： 提高效率，提高垃圾回收的效率，按照存活時間，分成不同的集合。將內存塊按照其存活時間划分為不同的集合。每個集合就稱為一個“代”，垃圾回收的頻率隨代的存活時間增大而減小。。Python默認定義分代對象集合，引用數越大，對象的存活時間越長

Python也會內存泄露，Python本身的垃圾回收機制無法回收重寫了__del__的循環引用的對象

程序員管理好每個python對象的引用，盡量在不需要使用對象的時候，斷開所有引用
盡量少通過循環引用組織數據，可以改用weakref做弱引用或者用id之類的句柄訪問對象
通過gc模塊的接口可以檢查出每次垃圾回收有哪些對象不能自動處理，再逐個逐個處理

21、關於 python 程序的運行性能方面，有什么手段能提升性能？

1、使用多進程，充分利用機器的多核性能
2、對於性能影響較大的部分代碼，可以使用C或C++編寫
3、對於IO阻塞造成的性能影響，可以使用IO多路復用來解決
4、盡量使用python的內建函數
5、盡量使用局部變量

22、list 對象 alist [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]， 請按 alist 中元素的age 由大到小排序；

def sort_by_age(list1):
    return sorted(alist,key=lambda x:x['age'],reverse=True)
參看關鍵  sorted  函數  key用來比較

23、兩個 list 對象 alist ['a','b','c','d','e','f'], blist ['x','y','z','d','e','f']，請用簡潔的方法合並這兩個 list，並且 list 里面的元素不能重復；

alist = ['a','b','c','d','e','f']
blist = ['x','y','z','d','e','f']

def merge_list(*args):
    s = set()
    for i in args:
        s = s.union(i)
    return list(s)

24、打亂一個排好序的 list 對象 alist；

import random
random.shuffle(alist)

將元素隨機排序

25、簡單實現一個stack

# 需要實現：初始化，迭代，出棧，進棧，是否為空，大小，返回棧頂元素
class Stack:
    def __init__(self):
        self.items = []

    def __iter__(self):
        return self.items.__iter__()

    def pop(self):
        return self.items.pop()

    def top(self):
        if len(self.items) > 0:
            return self.items[len(self.items) - 1]

    def push(self, item):
        self.items.append(item)

    def empty(self):
        self.items = []

    def size(self):
        return len(self.items)

26、輸入某年某月某日，判斷這一天是這一年的第幾天？(可以用 python 標准庫)　　

import datetime
def dayofyear():
    year = input("請輸入年份：")
    month = input("請輸入月份：")
    day = input("請輸入天：")
    date1 = datetime.date(year=int(year),month=int(month),day=int(day))
    date2 = datetime.date(year=int(year),month=1,day=1)
    return (date1 -date2).days+1

27、將字符串："k:1|k1:2|k2:3|k3:4"，處理成 python 字典：{k:1, k1:2, ... }

str1 = "k:1|k1:2|k2:3|k3:4"
def str2dict(str1):
    dict1 = {}
    for iterms in str1.split('|'):
        key,value = iterms.split(':')
        dict1[key] = value
    return dict1

 

28.請完成一個程序，並能按步驟實現以下功能：

1. 下載https://en.wikipedia.org/wiki/Machine_translation 頁面的內容並保存為mt.html

       需要編寫代碼來下載頁面。

2. 統計mt.html中<p>標簽內下所有單詞以及數目並存儲到mt_word.txt中。

       mt_word.txt有如下幾點要求：

       a) 每個單詞一行。單詞在前，單詞出現的次數在后，中間用Tab(\t)進行分隔。

       b) 單詞要按照單詞數目從多到少的順序進行排列。比如說單詞a出現了100次，單詞b出現了10次，則單詞a要在單詞b的前面。

3. 提取出mt.html中所有的年份信息（比如說頁面中的1629, 1951這些的四位數字就是年份）存儲到mt_year.txt中。

       mt_year.txt有如下幾點要求：

       a) 每個年份是一行。

       a) 年份需要從過去到現在的順序進行排列。比如說文章中出現了2007和1997，則1997需要排在2007的前面。

 

要求：

1. 僅限python編程，而且僅僅可以使用python自帶的函數或庫。

2. 提交可執行的程序以及mt.html, mt_word.txt, mt_year.txt。

3. 限定在一個小時內完成。

# 1. 下載https://en.wikipedia.org/wiki/Machine_translation 頁面的內容並保存為mt.html需要編寫代碼來下載頁面。
session = requests.session()
response = session.get(url="https://en.wikipedia.org/wiki/Machine_translation")
with open('mt.html','wb') as f:
    f.write(response.content)


# 2、統計mt.html中<p>標簽內下所有單詞以及數目並存儲到mt_word.txt中

# 解析頁面，拿到所有的p標簽中的文本
soup = BeautifulSoup(response.text,features="lxml")
tag2 = soup.find_all(name='p')
list_p = []
for i in tag2:
    list_p.append(i.get_text())

# 將所有的文本合並成一個字符串
str_p = ' '.join(list_p)
word_set = set()
for word in str_p.split():
    word = word.strip(',.()""/; ')
    word_set.add(word)
# word_dict = {}
word_list = []
for word in word_set:
    if word == '':
        continue
    # word_dict[word] = str_p.count(word)
    dict2 = {word:str_p.count(word)}
    word_list.append(dict2)

# 將單詞按照數目反序排列，然后寫入文件
blist = sorted(word_list,key = lambda x:list(x`.values())[0],reverse =True)
with open('mt_word.txt','w') as f:
    for item in blist:
        for k,v in item.items():
            line = k + '\t' + str(v) + '\n'
            f.write(line)
            
# 3、提取出mt.html中所有的年份信息（比如說頁面中的1629, 1951這些的四位數字就是年份）存儲到mt_year.txt中
year = re.compile(r'\d{4}')
years_list = re.findall(year,response.text)
years_list = sorted(list(set(years_list)))
with open('mt_year.txt','w') as f:
    for year in years_list:
        line = year + '\n'
        f.write(line)

 

29、試列出至少三種目前流行的大型數據庫的名稱:________、_________、__________,其中您最熟悉的是__________,從__________年開始使用。

Oracle，Mysql，SQLServer   Oracle 根據自己情況

30、有表List，並有字段A、B、C，類型都是整數。表中有如下幾條記錄：

A	B	C
2	7	9
5	6	4
3	11	9

現在對該表一次完成以下操作：

1. 查詢出B和C列的值，要求按B列升序排列

2. 寫出一條新的記錄，值為{7,9,8}

3. 查詢C列，要求消除重復的值，按降序排列

寫出完成完成以上操作的標准的SQL語句，並且寫出操作3的結果。

create table List2(A int ,B int,C int)
select B,C from List order by B
insert into List values(7,9,8)
select distinct(C) from List order by 1 desc;
9 8 4

31、請簡要說明視圖的作用

1. 數據庫視圖隱藏了數據的復雜性。
2. 數據庫視圖有利於控制用戶對表中某些列的訪問。
3. 數據庫視圖使用戶查詢變得簡單。

32、列舉您使用過的python網絡爬蟲所用到的網絡數據包（最熟悉的在前）：

requests、urllib、urllib2、httplib2

33、列舉您使用過的python網絡爬蟲所用到的解析數據包（最熟悉的在前）：

BeautifulSoup、pyquery、Xpath、lxml

34、列舉您使用過的python中的編碼方式（最熟悉的在前）：

UTF-8，ASCII，gbk

35、python3.5語言中enumerate的意思是_______________________

對於一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它可以同時獲得索引和值
enumerate多用於在for循環中得到計數

36、99的八進制表示是_______________________

143

37、請舉出三種常用的排序算法

冒泡、選擇、快速

38、列出比較熟悉的爬蟲框架

Scrapy

39、     用4、 9 、 2、 7四個數字，可以使用+、-、*和/，每個數字使用一次，使表達式的結果為24，表達式是_____________________________

（9+7-4）*2

40、     對你最有影響的或是您認為最有價值的軟件方面的幾本書是？

十三、     您最熟悉的Unix環境是_____________.Unix下查詢環境變量的命令是________,查詢腳本定時任務的命令是____________________

1 AIX ， env  crontab

十四、     寫出在網絡爬蟲爬取數據的過程中，遇到的防爬蟲問題的解決方案

 通過headers反爬蟲：解決策略，偽造headers
 基於用戶行為反爬蟲：動態變化去爬取數據，模擬普通用戶的行為
 基於動態頁面的反爬蟲：跟蹤服務器發送的ajax請求，模擬ajax請求

十五、     閱讀以下Python程序

for i in range(5,0,-1):

      print(i)

請在下面寫出打印結果

5 4 3 2 1

1、 post、get有什么區別？

1. 根據HTTP規范，GET一般用於獲取/查詢資源信息，應該是安全的和冪等。而POST一般用於更新資源信息
2. get是在url中傳遞數據，數據放在請求頭中。 post是在請求體中傳遞數據
3. get傳送的數據量較小，只能在請求頭上發送數據。post傳送的數據量較大，一般被默認為不受限制。
5. get安全性非常低，post安全性較高。但是執行效率卻比Post方法好。
建議：
1、get方式的安全性較Post方式要差些，包含機密信息的話，建議用Post數據提交方式；
2、在做數據查詢時，建議用Get方式；而在做數據添加、修改或刪除時，建議用Post方式；

2、 http、https協議有什么區別？

http協議是超文本傳輸協議，被用於在web瀏覽器和網站服務器之間傳遞信息。http協議工作是以明文方式發送內容，不提供任何形式的數據加密，而這也是很容易被黑客利用的地方，如果黑客截取了web瀏覽器和網站服務器之間的傳輸信息，就可以直接讀懂其中的信息，因此http協議不適合傳輸一些重要的、敏感的信息，比如信用卡密碼及支付驗證碼等。
安全套接字層https協議就是為了解決http協議的這一安全缺陷而出生的，為了數據傳輸的安全，https在http的基礎上加入了ssl協議，ssl依靠證書來驗證服務器的身份，為瀏覽器和服務器之間的通信加密，這樣的話即使黑客借去了發送過程中的信息，也無法破解讀懂它，我們網站及用戶的信息便得到了最大的安全保障。

https協議需要到ca申請證書，一般免費證書很少，需要費用。
http是超文本傳輸協議，信息是明文傳輸，https 則是具有安全性的ssl加密傳輸協議
http和https使用的是完全不同的連接方式用的端口也不一樣,前者是80,后者是443。
http的連接很簡單,是無狀態的， HTTPS協議是由SSL+HTTP協議構建的可進行加密傳輸、身份認證的網絡協議 要比http協議安全

3、 域名和IP之間有什么關系，如何查看某個域名對應的所有IP？

國際互聯網(Internet)上有成千百萬台主機（host），為了區分這些主機，人們給每台主機都分配了一個專門的“地址”作為標識，稱為IP地址
由於IP地址全是些的數字，為了便於用戶記憶，Internet上引進了域名服務系統DNS（Domain Name System）。
當您鍵入某個域名的時候，這個信息首先到達提供此域名解析的服務器上，再將此域名解析為相應網站的IP地址。完成這一任務的過程就稱為域名解析。

1.ping  2.nslookup 3.使用站長工具等

4、 http協議頭中，keep-alive字段有什么作用？

HTTP協議采用“請求-應答”模式，當使用普通模式，即非KeepAlive模式時，每個請求/應答客戶和服務器都要新建一個連接，完成 之后立即斷開連接（HTTP協議為無連接的協議）；
當使用Keep-Alive模式（又稱持久連接、連接重用）時，Keep-Alive功能使客戶端到服 務器端的連接持續有效，當出現對服務器的后繼請求時，Keep-Alive功能避免了建立或者重新建立連接。
通過使用keep-alive機制，可以減少tcp連接建立次數，也意味着可以減少TIME_WAIT狀態連接，以此提高性能和提高httpd服務器的吞吐率(更少的tcp連接意味着更少的系統內核調用,socket的accept()和close()調用)。

5、 robots協議是什么？

Robots協議（也稱為爬蟲協議、爬蟲規則、機器人協議等）也就是robots.txt，網站通過robots協議告訴搜索引擎哪些頁面可以抓取，哪些頁面不能抓取。
Robots協議是網站國際互聯網界通行的道德規范，其目的是保護網站數據和敏感信息、確保用戶個人信息和隱私不被侵犯。因其不是命令，故需要搜索引擎自覺遵守。

6、 列出幾種常見的關系型數據庫和非關系型數據庫？（每種至少兩個）

Oracle、Mysql、SQLServer、DB2           Redis MongoDB Cassandra

7、 內存泄露是什么？如何避免？

指由於疏忽或錯誤造成程序未能釋放已經不再使用的內存的情況。
內存泄漏並非指內存在物理上的消失，而是應用程序分配某段內存后，由於設計錯誤，失去了對該段內存的控制，因而造成了內存的浪費。
導致程序運行速度減慢甚至系統崩潰等嚴重后果。

有 __del__() 函數的對象間的循環引用是導致內存泄漏的主凶。

不使用一個對象時使用:del object 來刪除一個對象的引用計數就可以有效防止內存泄漏問題.
通過 Python 擴展模塊 gc 來查看不能回收的對象的詳細信息
可以通過 sys.getrefcount(obj) 來獲取對象的引用計數，並根據返回值是否為 0 來判斷是否內存泄漏

Python的內存管理機制
1.引用計數：通過引用計數來保持對內存中的變量跟蹤，Python內部記錄中所有在使用對象各有多少個引用。
Python中有個內部跟蹤變量叫做引用計數器，每個變量有多少個引用，簡稱引用計數。當對象被創建時就創建了一個引用計數。
當某個對象的引用計數為0時，對象就不在需要，就列入了垃圾回收隊列。
引用計數增加：1.對象被創建：x=4;2.另外的別人被創建：y=x;3.被作為參數傳遞給函數：foo(x);4.作為容器對象的一個元素：a=[1,x,'33'];
引用計數減少時：1.一個本地引用離開了它的作用域。比如上面的foo(x)函數結束時，x指向的對象引用減1;
                2.對象的別名被顯式的銷毀：del x ；或者del y;
                3.對象的一個別名被賦值給其他對象：x=789
                4.對象從一個窗口對象中移除：myList.remove(x)
                5.窗口對象本身被銷毀：del myList，或者窗口對象本身離開了作用域。

2.垃圾回收
1.引用計數： 每個對象中都有ob-refcnt來做引用計數。當一個對象...,ob-refcnt就會增加，當引用的對象刪除，那么ob-refcnt就會減少當ob-refcnt為零，就會釋放該對象的內存空間
2.標記清除： 解決循環引用的問題。先按需分配，等到沒有空閑內存的時候，從寄存器和程序棧上的引用出發，遍歷所有對象和引用把所有能訪問的打標記，最后將沒有標記的對象釋放掉
3.分代技術： 提高效率，提高垃圾回收的效率，按照存活時間，分成不同的集合。將內存塊按照其存活時間划分為不同的集合。每個集合就稱為一個“代”，垃圾回收的頻率隨代的存活時間增大而減小。。Python默認定義分代對象集合，引用數越大，對象的存活時間越長

3.內存池機制
在Python中，大多數申請的都是小塊的內存，會執行大量的malloc和free操作。Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放，即Pymalloc機制。
它將不用的內存放到內存池而不是返回給操作系統。
1. 當申請的內存小於256字節時，PyObject_Malloc會在內存池中申請內存；當申請的內存大於256字節時，PyObject_Malloc的行為將蛻化為malloc的行為。當然，通過修改Python源代碼，我們可以改變這個默認值，從而改變Python的默認內存管理行為。
2. 對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。

8、 列舉幾個常用的dom解析項目、插件

xml、libxml2 、lxml 、xpath

10、如何提高爬取效率？

1. 爬取方面，利用異步io。
2.處理方面，利用消息隊列做生產者消費者模型

 

1、樓梯問題

　　1.1、給一個樓梯，從最下面往上走，每次可以走1到n步，求總共有多少種走法？

　　1.2、給一個樓梯，從最下面往上走，每次可以走1步或2步，求總共有多少種走法？

　　1.3、給一個樓梯，從最下面往上走，每次可以走1步或2步或3步，求總共有多少種走法？

# 1、 給一個樓梯，從最下面往上走，每次可以走1或2步，求總共有多少種走法？
# 假設只有一個台階，那么只有一種跳法，那就是一次跳一級，f(1)=1；如果有兩個台階，那么有兩種跳法，第一種跳法是一次跳一級，第二種跳法是一次跳兩級,f(2)=2。
# 如果有大於2級的n級台階，那么假如第一次跳一級台階，剩下還有n-1級台階，有f(n-1)種跳法，假如第一次條2級台階，剩下n-2級台階，有f(n-2)種跳法。這就表示f(n)=f(n-1)+f(n-2)。
def walk_stairs(stairs):
    if stairs == 1:
        return 1
    if stairs == 2:
        return 2
    else:
        return walk_stairs(stairs-1) + walk_stairs(stairs-2)

# 2、給一個樓梯，從最下面往上走，每次可以走1到n步，求總共有多少種走法？
# 上1個台階 1
# 上2個台階 2
# 上3個台階 4
# 上4個台階 8
# 上n個台階 2^(n-1)

# 3、給一個樓梯，從最下面往上走，每次可以走1步或2步或3步，求總共有多少種走法？
# 上1個台階 2^(1-1)
# 上2個台階 2^(2-1)
# 上3個台階 2^(3-1)

# f(n) = f(n-1) + f(n-2) + f(n-3)

2、 給一個字符數組，字符包含a-z、1-9，比如：a b c 4 b 2 a c 1 1 3，求只出現一次的第一次出現的字符

str_list = ['a', 'b', 'c', 4, 'b', 2, 'a', 'c', 1, 1, 3]


def find_only_one(alist):
    for string in alist:
        count = alist.count(string)
        if count == 1:
            return string
    return None

3、 有一個html文本字符串，讓我取出<a href="提示我這個鏈接地址">sflkj</a>這個a標簽里面的href的鏈接地址？

from bs4 import BeautifulSoup
text = "<a href='提示我這個鏈接地址'>sflkj</a>"
the_html = BeautifulSoup(text,features='lxml')
print(the_html.find('a').attrs['href'])

xpath('a[@href]')

4、 下面是一個單線程的代碼，請改寫成多線程的：

 

start = "http://google.com" queue = [start] visited = {start} while queue: url = queue.pop(0) print(url) for next_url in extract_url(url): if next_url not in visited: queue.append(next_url) visited.add(next_url)

 

 

from concurrent.futures import ThreadPoolExecutor

start = "http://google.com"
queue = [start]
visited = {start}
pool = ThreadPoolExecutor(10)

def func(url):
    for next_url in extract_url(url):
        if next_url not in visited:
            queue.append(next_url)
        visited.add(next_url)

while queue:
    url = queue.pop(0)
    pool.submit(func,url)
pool.shutdown(wait=True)

 

1、 獲取list的元素個數，向list的末尾追加元素所用的方法分別是( ),( )

count ，append

2、 判斷dict有沒有某個key用的方法是( )

in

3、 L = range(100) ，取第一到第三個元素用（），取倒數第二個元素（），取后十個元素（）

L[:3]
L[-2]
L[-10:]

4、 把L復制給L1用（） 注意：非引用傳遞

L1 = L.copy()

5、d = {'a':1,'b':2,'c':3}請打印出key，value對

for k,v in d.items():
    print(k,v)

6、 如何判斷一個變量是不是字符串

isinstance(a,str)

 

9、 ‘1,2,3’如何變成[‘1’,’2’,’3’] ?  [‘1’,’2’,’3’]如何變成 [1,2,3]

s1 = "1,2,3"
s2 = list(s1.split(','))
s3 = list(map(int,s2))

10、請回答以下問題？

def add_end(L= []): L.append('END') return L print(add_end()) # 輸出什么？ print(add_end()) # 再次調用輸出什么？為什么？

["END"] ["END","END"] 函數的默認參數在編譯時，分配內存空間。沒有給予參數都是使用默認的參數，是同一段內存地址的同一對象。

11、[36,5,12,9,21]怎么排序？

a = [36,5,12,9,21]
a.sort()

12、請回答以下問題：

def func(a,b,c=0,*args,**kwargs): pass *args,**kwargs的作用是什么？

當函數的參數不確定時，可以使用*args 和**kwargs來 傳遞可變參數。
*args儲存可變的位置參數，它會接收任意多個參數並把這些參數作為元組傳遞給函數。**kwargs存儲可變的關鍵字參數，允許你使用沒有事先定義的參數名，將接收到任意多個關鍵字參數作為字典傳遞給函數。
注意函數的參數的順序：args必須在kwargs前面，調用函數傳遞參數也必須依照此順序

13、is和==的區別是？

Python中的對象包含三要素：id、type、value
其中id用來唯一標識一個對象，type標識對象的類型，value是對象的值
is判斷的是a對象是否就是b對象，是通過id來判斷的
==判斷的是a對象的值是否和b對象的值相等，是通過value來判斷的

14、如何生成[1,4,9,16,25,36,49,64,81,100]？盡量用一行實現

[x*x for x in range(1,11)]

15、生成器是什么？有什么作用？請寫出一個生成器

a = ( i for i in range(11))

 

16、map(str,[1,2,3,4,5,6,7,8,9])輸出什么？

# 　生成的是map對象
print(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
# ['1', '2', '3', '4', '5', '6', '7', '8', '9']

17、請寫出log的實現（主要功能是打印函數名）

 

@log def now(): print('2013-12-25') now() # 輸出： # call now() # 2013-12-25

 

 

import functools

def log(func):
    @functools.wraps(func)
    def inner():
        print('call '+ func.__name__ + '()')
        func()
    return inner

 

一、單項選擇

(一)   以下敘述正確的是：

1. continue語句的作用是結束整個循環的執行

2. 只能在循環體內和switch語句體中使用break語句

3. 在循環體內使用break語句或continue語句的 作用相同

4. 從多層循環嵌套中退出時，只能使用goto語句　

# B

(二) Python如何定義一個函數(

# 3

)

1. class <name> (<Type> arg1 , <Type> arg 2, ... , <Type> argN)

2. function <name> (arg1 ,arg2 ,… , argN)

3. def <name> (arg1 ,arg2 ,… , argN)

4. def <name> (<Type> arg1 , <Type> arg 2, ... , <Type> argN)

(三) 下面哪個函數能夠在Linux環境下創建一個子進程：

1. os.popen

2. os.fork

3. os.system

4. os.link

# 2

 

(四) 已知x=43，ch = 'A' ,y = 1，則表達式(x > y and ch< ‘B’ and y)的值是 

1. 0

2. 1

3. 出錯

4. True(“真”)

# 2

(五) 下面的語句哪個會無限循環下去

         啟動range函數原型為range([start],stop[,step])

      1、for a in range(10):

                 time.sleep(10)

　　2、while 1 < 10:

　　　　　　time.sleep(10)

　　3、while True:

　　　　　　break;

　　4、a = [3,-1, 5 , 7]

　　　　for I in a[:]

         　　if a > 10:

          　　 break;

# 2

 

(六) 下列表達式中返回為True的是：

         A. 3 > 2 >2

         B. ‘abc’ > ‘xyz’

         C. 0x56 < 56

         D. (3,2) < (‘a’,’b’)

# D

(七) Python不支持的數據類型有

1. char

2. int

3. float

4. list

# 1

二、不定選項

(一)   下面的函數，那些會輸出1,2,3三個數字

1. for I in range(3)

　　　　print i

　　2. aList = [0,1,2]

          for I in aList:

                print i+1

　　3. I = 1

　　while I < 3:

         print i

         I = I +1

　　4.for I in range(3):

　　　　print I + 1

# 2,4

 

三、填空題

(一)   以下函數需要調用在其中引用一個全局變量k，請填寫語句：

def func():

         ___________

         k = k +1

global k

 

(二) 請把以下函數轉化為Python lambda匿名函數

         def add(x,y):

                  return x+y

lambda x,y:x+y

 

(三) 請簡單解釋Python中static method（靜態方法）和class method（類方法）

請將以下代碼填寫完整

 

 

class A(object): def foo(self,x): print("executing foo(%s,%s)" % (self,x)) @classmethod def class_foo(cls,x): print("executing class_foo(%s,%s)" % (cls,x)) @staticmethod def static_foo(x): print("executing static_foo(%s)" % (x)) a = A()

 

# 調用 foo函數，參數傳入1
a.foo(1)
# 調用class_foo函數，參數傳入1
a.class_foo(1)
A.class_foo(1)
# 調用靜態方法，傳入參數1
a.static_foo(1)
A.static_foo(1)

 

四、程序題

1、 請書寫一個函數，用於替換某個字符串的一個或某幾個字串

函數原型 strreplace(str,oldString,newString);

例如：

pstr = “Hello World!”

afterReplaceStr = strreplace(pstr,”World”,”Tom”)

那么afterReplaceStr的值為”Hello Tom”

def strreplace(str,oldString,newString):
    return str.replace(oldString,newString)

2、 平衡點問題：

假如一個數組中的元素，其前面的部分等於后面的部分，那么這個點的位序就是平衡點

比如一個列表 numbers = [1,3,20,2,18,6]，2前面的總和為24，2 后面的總和也是24，那么2就是平衡點

要求編寫程序，尋找並返回任意一個列表的平衡點

 

def balance_num(numbers):
    for i in range(0,len(numbers)):
        if sum(numbers[:i]) == sum(numbers[i+1:]):
            return numbers[i]
    return None

 

• Python如何實現單例模式？

• 什么是lambda函數？

• 請寫出一段Python代碼實現刪除list里面的重復元素？

• 如何用Python刪除一個文件？os.remove

• Python里面如何生成隨機數？random

• 請用Python寫出一個獲取用戶輸入數字，並根據數字大小輸出不同信息的腳本？input

• 解釋生成器（generator）與函數的不同，並實現和使用簡單generator

• 輸入一個字符串，返回倒序排列的結果；如’abcdef’，返回’fedcba’

  str1 = 'abcdefg'
  str2 = str1[::-1]
  
  str3 = list(str1)
  str3.reverse()
  str4 = ''.join(str3)

• 請使用自己的算法，按升序合並如下兩個list，並去除重復的元素：

　　list1 = [2,3,8,4,9,5,6]

　　list2 = [5,6,10,17,11,2]

• 11.Django如何在Model保存前做一定的固定操作，比如寫一句日志:   信號量

1、淺談你對python編碼規范的認識，並寫出你知道的編碼規范

 

2、淺談你對python安全編碼的認識，並舉例說明

 

 

1、圖書管理系統是對圖書進行錄入、借閱的系統，請用django框架實現新增、查看圖書的功能，分別寫出model.py、urls.py、views.py的邏輯

 

 

2、設有一個背包能承受重量s(s>0)，又有n（n>=1）件物品，其質量列表為 w = [w1,w2....,wn]，要從物品中挑選若干件放入背包，使得放入的圖書質量之和正好是s。請設計遞歸函數f(w,s,n):

當有解時，返回True，並顯示所選物品是那些？無解時返回False。提示：[遞歸之處在於f(w,s-wn,n-1) or f(w,s,n-1)]

• Python中基本數據結構的操作

	元組	列表	字典	集合
定義	與列表類型比，只不過[]換成()	[]內可以有多個任意類型的值，逗號分隔	key必須是不可變類型，value可以是任意類型	可以包含多個元素，用逗號分割，
新增	創建（）	append	dict['key']=v	add  ,update
更改	不能	list[2]=xxx	dict['key']=vv	不能、
刪除	不能，可刪除整個	del list[2]	del dict['key']	remove

 

 

 

 

 

 

 

 

　

　2.請盡可能列舉python列表的成員方法，並給出一下列表操作的答案：

　　（1）a=[1, 2, 3, 4, 5], a[::2]=？, a[-2:] = ？

（1）1 3 5
（2）4 5

 

　　（2） 一行代碼實現對列表a中的偶數位置的元素進行加3后求和？

 

sums = sum(map(lambda x: x + 3, a[1::2]))

 

 

　　3.List = [-2, 1, 3, -6]，如何實現以絕對值大小從小到大將 List 中內容排序。

sorted(list1,key = abs)

　　　　(1) 列表的sort方法和 sorted的區別是什么？

 

sort 是list的方法，改變list對象的順序，返回值為None
sorted是Python的內置方法，適用iterable對象，返回值是新列表，不影響原來的iterable的順序

 

　　4.有一篇英文文章保存在 a.txt 中，請用python實現統計這篇文章內每個單詞的出現頻率，並返回出現頻率最高的前10個單詞及其出現次數（只考慮空格，標點符號可忽略）

from collections import Counter
    c = Counter()
with open('a.txt','r',encoding='utf-8') as f:
    for line in f.readlines():
        words = line.split()
        c1 = Counter(words)
        c.update(c1)

（1）追加需求：引號內元素需要算作一個單詞，如何實現？

以"分割，轉換成列表，取其奇數分割，其偶數不做處理

 

 

　　6.Python中的變量作用域（變量查找順序）。

 

LEGB
local 局部變量--->enclosed 閉包作用域 ----> Global 全局---->built-in變量

 

　　7.下面這段代碼的輸出結果將是什么？請解釋。

 

# 1 1 1 繼承自父類的類屬性x，所以都一樣，指向同一塊內存地址
# 1 2 1 更改Child1，Child1的x指向了新的內存地址
# 3 2 3 更改Parent，Parent的x指向了新的內存地址

 

　　8.描述Python GIL的概念， 以及它對python多線程的影響？編寫一個多線程抓取網頁的程序，並闡明多線程抓取程序是否可比單線程性能有提升，並解釋原因。

 Guido的聲明：http://www.artima.com/forums/flat.jsp?forum=106&thread=214235

he language doesn't require the GIL -- it's only the CPython virtual machine that has historically been unable to shed it.
Python語言和GIL沒有半毛錢關系。僅僅是由於歷史原因在Cpython虛擬機(解釋器)，難以移除GIL。
GIL：全局解釋器鎖。每個線程在執行的過程都需要先獲取GIL，保證同一時刻只有一個線程可以執行字節碼。
線程釋放GIL鎖的情況：
在IO操作等可能會引起阻塞的system call之前,可以暫時釋放GIL,但在執行完畢后,必須重新獲取GIL
Python 3.x使用計時器（執行時間達到閾值后，當前線程釋放GIL）或Python 2.x，tickets計數達到100

Python使用多進程是可以利用多核的CPU資源的。

多線程爬取比單線程性能有提升，因為遇到IO阻塞會自動釋放GIL鎖

　　9.Python中如何動態獲取和設置對象的屬性。

if hasattr(Parent,'x'):
    print(getattr(Parent,'x'))
    setattr(Parent,'x',3)
    print(getattr(Parent,'x'))

　　10.(前端基礎)

(1)    用CSS如何隱藏一個元素

dispaly:none

(2)    一行CSS實現padding上下左右分別為 1px，2px，3px，4px

padding:1 4 2 3

(3)    JavaScript(或jQuery)如何選擇一個id為main的容器

$('#main')

(4)    JavaScript(或jQuery)如何選擇一個class為menu的容器

$('.menu')

 

1、Python中list、tuple、dict、set有什么區別，主要應用在什么樣的場景？並用for語句分別進行遍歷

 

定義:
list:列表,有序的項目, 通過索引進行查找,使用方括號”[]”;
tuple:元組,元組將多樣的對象集合到一起,不能修改,通過索引進行查找, 使用括號”()”;
dict:字典,字典是一組鍵(key)和值(value)的組合,通過鍵(key)進行查找,沒有順序, 使用大括號”{}”;
set:集合,無序,元素只出現一次, 自動去重,使用”set([])”
應用場景:
list, 簡單的數據集合,可以使用索引;
tuple, 把一些數據當做一個整體去使用,不能修改;
dict,使用鍵值和值進行關聯的數據;
set,數據只出現一次,只關心數據是否出現, 不關心其位置;

test_list = [1, 2, 3, 4, 4]
test_tuple = (1, 2, 3, 4, 5)
test_dict = {'a': 1, 'b': 2}
test_set = {12, 4, 5, 6}
for items in test_list:
    print('list:', items)
for items in test_tuple:
    print('tuple:', items)

for key, value in test_dict.items():
    print('dict:', key, value)

for items in test_set:
    print('set:', items)

 

2、Python中靜態函數、類函數、成員函數的區別？各寫出一個實例。

 

class Animal(object):
    planet = 'earth'

    def __init__(self,name):
        self.name = name

    @staticmethod
    def eat():
        print("An animal is eating.....")

    @classmethod
    def live_on(cls):
        print("The Animal live on earth!")

    def print_name(self):
        print('The name of animal is',self.name)
Cat = Animal('Cafe')

Animal.eat()
Cat.eat()

Animal.live_on()
Cat.live_on()

Cat.print_name()

 

3、用Python語言寫一個函數，輸入一個字符串，返回倒序排列的結果：如：string_reverse('abcdefg')，返回'gfedcba'

 

def string_reverse(input_str):
    return input_str[::-1]


print(string_reverse('nice'))

 

4、介紹一下Python的異常處理機制和自己開發過程中的體會

 

python主要是用try except語句來捕獲異常
使用raise來引發異常
使用try...finally來處理（無論是否發生異常）都要處理的內容
assert來觸發斷言異常

個人感悟：
    1、觸發異常，一定要帶上完整的異常信息：raise MyException('Error message')
    2、創建一個異常模塊，創建一些異常基類和子類，觸發不同的異常
    3、除了特殊情況不要，捕捉所有的異常
    4、減少try except中代碼，只對出現異常的語句進行處理
    5、捕捉異常盡量使用as語句

 

5、jQuery中的$()是什么？網頁上有5個<div>元素，如何使用jQuery來選擇他們？

 

1、$()是一個標簽選擇器
2、$()可以是一個特定的DOM元素
3、$()是$(function)定義一個函數

$("div")

 

6、寫一個Bash Shell腳本來得到當前的日期、時間、用戶名和當前文件目錄

 

`date +%Y%m%d-%H-%M-%S`
`whoami`
`pwd`

 

7、Django中使用memcached作為緩存的具體使用方法？優缺點說明？

 

1、在setting里配置cache
CACHE_BACKEND = 'memcached://127.0.0.1:11211/'
2、緩存的方法：
A.整個站點緩存：
    django.middleware.cache.UpdateCacheMiddleware（放在最前）
    django.middleware.cache.FetchFromCacheMiddleware（放在最后）   


B.視圖函數裝飾器緩存：
    from django.views.decorators.cache import cache_page
    @cache_page(60 * 15)
    def my_view(request):
    ....
    其中cache_page的參數為超時時間，單位為秒。
C.在函數中調用cache來緩存
    from django.core.cache import cache
    def heavy_view(request):
        cache_key = 'my_heavy_view_cache_key'
        cache_time = 1800 # time to live in seconds
        result = cache.get(cache_key)
        if not result:
            result = # some calculations here
            cache.set(cache_key, result, cache_time)
        return result

D.在url中配置緩存
    urlpatterns = ('',
        (r'^foo/(\d{1,2})/$', cache_page(60 * 15)(my_view)),
    

memcached將數據放在內存中，無法持久化，數據庫宕機會導致數據的丟失

 

8、給定一個紅包的數額屬組gifts以及它的大小n，請返回是否有某個金額出現的次數超過總紅包數的一半。若存在返回該紅包金額，不存在請返回0

 

def select_most_often_gift(gifts):
    gift_items = set(gifts)
    n = len(gifts)
    for gift in gift_items:
        num = gifts.count(gift)
        if num > n/2:
            return gift
    return 0

print(select_most_often_gift([2,3,6,2,24,5,56]))

 

1、利用Python執行shell腳本取得返回結果

import subprocess
result = subprocess.getoutput('dir')

 

2、用Python將"123456"轉換成"654321"

a = '123456'
a[::-1]

3、利用Python打印前一天的本地時間，格式為"2017-03-24 16:24:34"

 

import datetime
yesterday_datetime = datetime.datetime.now() - datetime.timedelta(days=1)
yesterday_str = datetime.datetime.strftime(yesterday_datetime, '%Y/%m/%d %H:%M:%S')

4、python中search和match的區別

search ：會掃描整個字符串並返回第一個成功的匹配
match ： 從字符串的頭部開始匹配

 

6、什么是lambda函數，有什么好處？

7、請用python實現socket非阻塞通信

9、Django的MTV分別代表什么？

10、在Django中定義了兩個模型，書籍和作者，書籍有三個字段，分別為title、author，publish_time：作者有三個字段，分別為name，age，address，其中的書籍和作者是多對多的關系，查看一本書籍的所有作者和某個作者的全部書籍

11、簡述你的web框架是如何實現MVC模式的

12、簡述你熟悉的ORM的使用機制和實現原理

13、CBV如何實現用戶@login_required

 

1、下面代碼會輸出什么？

map(lambda x:x*x,[y for y in range(3)])

[0, 1, 4]

 

2、下面代碼會輸出什么?

def f(x, l = [] )

　　for i in range(x):

　　　　l.append(i*i)

　　print l

f(2)

f(3,[3,2,1])

f(3)

1、[0, 1]
2、[3, 2, 1, 0, 1, 4]
3、[0, 1, 0, 1, 4]

 

3、樹是數據結構中非常重要的一種，主要的用途是用來提高效率，對於要重復查找的情況效果更佳，二叉樹是其中最常見的結構之一，示例如下：

 

層級遍歷： 0 1 2 3 4 5 6 7 8 9

 先序遍歷：0 1 3 7 8 4 9 2 5 6

中序遍歷：7 3 8  1 9 4 0 5 2 6

后序排列：7 8 3 9 4 1 5 6 2 0

 

class Node(object): def __init__(self, data, left=None, right=None): self.data = data self.left = left self.right = right

r為Node類型的根節點

實現函數traverse(r)輸出先序遍歷結果，輸出部分使用print r.data即可

node7 = Node(7)
node8 = Node(8)
node9 = Node(9)
node3 = Node(3,node7,node8)
node4 = Node(4,node9)
node5 = Node(5)
node6 = Node(6)
node1 = Node(1,node3,node4)
node2 = Node(2,node5,node6)
node0 = Node(0,node1,node2)


def traverse(r):
    print(r.data)
    if r.left:
        traverse(r.left)
    if r.right:
        traverse(r.right)

 

 

4、有一個3G大小的文件，文件每行一個string，內容為酒店的id和一個圖片的名字，使用“\t”分割

示例：ht_1023134 + "\t" + hidfadsfadsfdfadsf2r234523,jpg

表示的是一個酒店包含的一張圖片，統計含有圖片數量為[20,無窮大]的酒店id，含有圖片數量為[10,20]的酒店id、含有圖片數量為[10,5]的酒店id，含有圖片數量為[0，5]的酒店id，並將結果輸出到文件中

0-5 + “\t” + id1 +  “\t” + id2 + .....

5-10 + “\t” + id1 +  “\t” + id2 + .....

10-20 + “\t” + id1 +  “\t” + id2 + .....

20-無窮大 + “\t” + id1 +  “\t” + id2 + .....

from collections import Counter
count_dict = {}
cou = Counter()
with open('a.txt', encoding='utf-8') as f:
    for line in f:
        hotel, image = line.split()
        hotel_id = hotel.split('_')[1]
        cou.update({hotel_id,1})
        if hotel_id in count_dict:
            count_dict[hotel_id] += 1
        else:
            count_dict[hotel_id] = 1
del cou[1]
zero_five = ['0-5']
five_ten = ['5-10']
ten_twenty = ['10-20']
twenty_infinite = ['10-去窮大']
for hotel_id,count in count_dict.items():
    if count < 5 :
        zero_five.append(hotel_id)
    elif count < 10 :
        five_ten.append(hotel_id)
    elif count < 20:
        ten_twenty.append(hotel_id)
    else:
        twenty_infinite.append(hotel_id)
with open('b.txt','w',encoding='utf-8') as b:
    b.write('\t'.join(zero_five))
    b.write('\n')
    b.write('\t'.join(five_ten))
    b.write('\n')
    b.write('\t'.join(ten_twenty))
    b.write('\n')
    b.write('\t'.join(twenty_infinite))

 

2、Python如何捕獲異常，如何在程序執行過程中拋出異常機制？

Python中使用try ... except SomeException as e: ...來捕獲異常
raise SomeException("Some Message")來拋出異常

3、什么是lambda函數？它有什么好處？

4、*args和**kwargs的使用方法，請簡述一下？

5、簡要介紹下python里面的裝飾器？

6、Http請求中GET和POST有什么區別？Cookies和Session有什么區別？

7、a = 1，b = 2，不用中間變量交換a和b的值？

b, a = a, b
Python支持不使用中間變量交換兩個變量的值

 

8、編寫一個函數刪除list里的重復元素，用兩種方式實現？

9、請簡要概括django測試工具？

10、如何擴展auth_user的字段

11、請給出Profile的實現實例

12、如何替換auth_user

13、django的繼承的方式有哪些？

14、請簡要描述django-admin.py makemessages的作用

 

1、取出兩個升序數組中的最小的一半的元素組成一個新的升序數組。

map(lambda x, y: x if x < y else y, a, b)

 

2、用至少2種不同的方式刪除一個list里面的重復元素

a = [1, 2, 2, 4, 34, 3, 4, 56, 65, 456, 5, 6456, 456, 54, 45, 6, 464, 564]
# 方法一
new_list3 = list(set(a))

# 方法二
new_list = []
for num in a:
    if num not in new_list:
        new_list.append(num)

# 方法三
dict1 = dict.fromkeys(a)
new_list2 = dict1.keys()

 

3、利用線程池（10個線程）實現一個並行打印10行信息的程序，打印This is thread xx.(注：xx為線程id)

 

4、關系型數據庫的事務隔離級別有哪些，分別有什么影響？

1、未提交讀(Read Uncommitted) 
    直譯就是"讀未提交",意思就是即使一個更新語句沒有提交,但是別的事務可以讀到這個改變.這是很不安全的。允許任務讀取數據庫中未提交的數據更改，也稱為臟讀。 
2、提交讀(Read Committed) 
   直譯就是"讀提交",可防止臟讀，意思就是語句提交以后即執行了COMMIT以后別的事務就能讀到這個改變. 只能讀取到已經提交的數據。Oracle等多數數據庫默認都是該級別 
3、可重復讀(Repeatable Read)： 
   直譯就是"可以重復讀",這是說在同一個事務里面先后執行同一個查詢語句的時候,得到的結果是一樣的.在同一個事務內的查詢都是事務開始時刻一致的，InnoDB默認級別。在SQL標准中，該隔離級別消除了不可重復讀，但是還存在幻象讀 
4、串行讀(Serializable) 
   直譯就是"序列化",意思是說這個事務執行的時候不允許別的事務並發執行. 完全串行化的讀，每次讀都需要獲得表級共享鎖，讀寫相互都會阻塞
 
四，隔離級別對事務並發的控制 
下表是各隔離級別對各種異常的控制能力:


丟失更新    臟讀    非重復讀    二類丟失更新(覆蓋更新)    幻像讀
未提交讀     Y    Y    Y    Y    Y
提交讀     N    N    Y    Y    Y
可重復讀     N    N    N    N    Y
串行讀     N    N    N    N    N

 

5、請用python編寫函數find_string，從文本中搜索並打印內容，要求支持通配符星號和問號。

例子：

>>>find_string('hello\nworld\n','wor')

['wor']

>>>find_string('hello\nworld\n','l*d')

['ld']

>>>find_string('hello\nworld\n','o?')

['or']

 

6、請為find_string編寫單元測試

7、已有一個字典列表，如下：

 

li = [ {'id': '1.1', 'content': "14"}, {'id': '1.2', 'content': "15"}, {'id': '1.3', 'content': "16"}, {'id': '1.4', 'content': "17"}, {'id': '1.5', 'content': "18"}, ]

 

請寫一個類：

abc = x() >>abc['1.1'] 14

class x(UserDict):

    def __init__(self):
        super().__init__()
        for dic in li:
            # print(dic)
            self.data.update({dic['id']:dic['content']})

abc = x()
print(abc['1.1'])

 8、如何快速對學生的成績進行評級:(源自Fluent Python)

　　60分以下評為F

　　60-70評為D

　　...

　　90分以上為A

import bisect
import sys


def grade(score, breakpoint=[60, 70, 80, 90], grades = 'FDCBA'):
    i = bisect.bisect(breakpoint, score)
    return grades[i]

if __name__ == '__main__':
    level = grade(64)
    print(level)

 

　3期面試題：

1.下面這段代碼這樣寫有什么意義？

from contextlib import cotextmanager @contextmanager def filename(path,mode): f=open(path,mode) yield f f.close()

 7.django orm 如何進行數據庫訪問優化，談談你的見解？

 

1. 習慣隔離代碼並記錄產生的查詢

2. 不要在循環中查詢

3. 了解 ORM 是怎么緩存數據的

4. 知道 Django 何時會做查詢

5. 不要以犧牲清晰度為代價過度優化

8.redis 有哪幾種數據結構，分別應用什么場景？

 Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

 

9.如何理解csrf，xss攻擊？

xss:用戶過分信任網站，放任來自瀏覽器地址欄代表的那個網站代碼在自己本地任意執行。如果沒有瀏覽器的安全機制限制，xss代碼可以在用戶瀏覽器為所欲為；

csrf：網站過分信任用戶，放任來自所謂通過訪問控制機制的代表合法用戶的請求執行網站的某個特定功能。

 

10.http協議中的request頭  的cache-control:max-age<=0的時候，客戶端會進行什么操作?

 代表強制要求服務器返回最新的文件內容

 

1.有一個list L=[2,1,1,23,4],對L進行降序排序並輸出，如L輸出[1,1,2,4,23]

 print(sorted(L))

2.字符串 a=‘12345’，對a進行逆序並輸出A

 print(a[::-1])

3.給你一個字符串，將a中的大寫字母轉換成小寫，其他字符不變，輸出

 print(a.lowwer())

4.python中函數和生成器，迭代器有什么區別？

　　 http://python.jobbole.com/81881/

5.python中多線程有什么缺點？和多進程有什么區別？和協程有什么區別？

 　　http://www.jb51.net/article/87145.htm?pc

6.lambda函數是什么？有什么好處？

 　Lambda 函數又稱匿名函數，匿名函數就是沒有名字的函數，不想污染命名空間。好處：將只被使用一次 – 只從應用程序中的一個地方調用。可以把它定義在你想使用它的地方。

7、如何把gbk編碼，轉為utf-8編碼

  decode('gbk').encode('utf-8')

8.@的用法是什么?舉例說明

 '@'符號用作函數修飾符，修飾符必須出現在函數定義前一行，不允許和函數定義在同一行。 只可以在模塊或類定義層內對函數進行修飾，不允許修修飾一個類。一個修飾符就是一個函數，它將被修飾的函數做為參數，並返回修飾后的同名函數或其它可調用的東西。 　　

本質上講，裝飾符@類似於回調函數，把其它的函數（暫且稱為目的參數）作為自己的入參，在目的函數執行前，執行一些自己的操作，然后返回目的函數。

9.tcp黏包是什么？怎么處理？

 一般所謂的TCP粘包是在一次接收數據不能完全地體現一個完整的消息數據。TCP通訊為何存在粘包呢？主要原因是TCP是以流的方式來處理數據，再加上網絡上MTU的往往小於在應用處理的消息數據，所以就會引發一次接收的數據無法滿足消息的需要，導致粘包的存在。處理粘包的唯一方法就是制定應用層的數據通訊協議，通過協議來規范現有接收的數據是否滿足消息數據的需要。在應用中處理粘包的基礎方法主要有兩種分別是以4節字描述消息大小或以結束符，實際上也有兩者相結合的如HTTP,redis的通訊協議等。

10.表A與表B聯表，其中相連的字段為userid，sql語句怎么寫？

 select * from A inner join B on A.userid=B.userid

11.13個球一個天平，現知道只有一個和其他的質量不同，問怎樣稱才能用三次就找到那個求？

 13個球也是可以做的。就是分成4個、4個、5個，先拿兩個四個上去，如果平衡，則問題出在5個那組，就在5個里任拿三個設為C1C2C3，再拿三個正常的，分別放兩邊，若平衡就簡單啦，若不平衡，就出現C1C2C3重，或C1C2C3輕，相當於就知道那個特別的球是比較重或者比較輕啦，接下就不用說了
如果不平衡，假設現在是A重B輕，
取A1+A2+B1放天平一邊(設為左邊)，
再取A3+A4+B2放另一邊（右），
若平衡，就在B3/B4任拿一個跟C1上去稱就行了，
如果不平衡，那么假設
情況一：左重
則是A1/A2/B2有問題
直接把A1A2放兩邊稱，重的那個有問題，如果平
衡就是B2有問題
情況二：右重
就是 A3/A4/B1有問題，方法同上

12.一個高度為N的由正整數組成的數字三角形，從上走到下，求經過的數字和的最大值，每次只能走到下一層相鄰的數上，例如從第三層的6向下走，只能走到第4層的2或9上。

例子中的最優方案是： 5+8+6+9=28 input 第一行：N,N為數塔的高度。（2《=N《=500） 第2-N+1行：每行包括1層數塔的數字，第2行1個數，第3行2個數，數與數之間用空格分隔，（0<=A【i】<=10^5）. output 輸出最大值 input示例

5
8 4
3 6 9
7 2 9 5

 

output示例

28

 

 

 

1.請分別闡述迭代器與生成器的含義，並舉例說明。

 迭代器是一種支持next()操作的對象。它包含一組元素，當執行next()操作時，返回其中一個元素；當所有元素都被返回后，生成一個StopIteration異常。iter()可以接受多種Python對象為參數，比如list，tuple, dict, set等，並將其轉化為迭代器。

生成器是一種迭代器，是一種特殊的函數，使用yield操作將函數構造成迭代器。普通的函數有一個入口，有一個返回值；當函數被調用時，從入口開始執行，結束時返回相應的返回值。生成器定義的函數，有多個入口和多個返回值；對生成器執行next()操作，進行生成器的入口開始執行代碼，yield操作向調用者返回一個值，並將函數掛起；掛起時，函數執行的環境和參數被保存下來；對生成器執行另一個next()操作時，參數從掛起狀態被重新調用，進入上次掛起的執行環境繼續下面的操作，到下一個yield操作時重復上面的過程。

 

2.請分別闡述參數*args，**kwargs的含義和作用，並舉例說明

*args表示任何多個無名參數，它是一個tuple

**kwargs表示關鍵字參數，它是一個dict

 

測試代碼如下：

 

def foo(*args,**kwargs): print 'args=',args print 'kwargs=',kwargs print '**********************' if __name__=='__main__': foo(1,2,3) foo(a=1,b=2,c=3) foo(1,2,3,a=1,b=2,c=3) foo(1,'b','c',a=1,b='b',c='c')

 

執行結果如下：

 

args= (1, 2, 3) kwargs= {} ********************** args= () kwargs= {'a': 1, 'c': 3, 'b': 2} ********************** args= (1, 2, 3) kwargs= {'a': 1, 'c': 3, 'b': 2} ********************** args= (1, 'b', 'c') kwargs= {'a': 1, 'c': 'c', 'b': 'b'} **********************

 

3.請簡要闡述下多進程和多線程的區別，並解釋GIL鎖

 

4.請簡要描述python的垃圾回收機制

1.引用計數： 每個對象中都有ob-refcnt來做引用計數。當一個對象...,ob-refcnt就會增加，當引用的對象刪除，那么ob-refcnt就會減少當ob-refcnt為零，就會釋放該對象的內存空間

2.標記清除： 解決循環引用的問題。先按需分配，等到沒有空閑內存的時候，從寄存器和程序棧上的引用出發，遍歷所有對象和引用把所有能訪問的打標記，最后將沒有標記的對象釋放掉

3.分代技術： 提高效率，提高垃圾回收的效率，按照存活時間，分成不同的集合。將內存塊按照其存活時間划分為不同的集合。每個集合就稱為一個“代”，垃圾回收的頻率隨代的存活時間增大而減小。。Python默認定義分代對象集合，引用數越大，對象的存活時間越長

5.請簡要闡述一下os與，sys模塊在功能方面的不同之處

os就是一個普通的python庫，用來向Python程序提供運行環境，特別是在文件系統、創建新進程、獲取操作系統本身的一些信息（比如uname)，並屏蔽各種不同操作系統之間的細節差異。

sys模塊則是python程序用來請求解釋器行為的接口。比如關於調試類的（trace, frames，except）等，profiling類（stats， getsizeof)，運行時環境類（python path, stderr, stdout)，解釋器本身（如version）。inspect某種程度上可以看成是在sys提供的功能上的一個包裝。

6.請使用python編碼實現單例模式

 http://blog.csdn.net/karldoenitz/article/details/23467221

7.請用python進行編碼，實現快速排序

 

8.請編碼實現兩個字符串是否為“相同字母異序此”（所有字母，個數均相同，金前后順序不一樣，例如abcd和bcad為異序詞，abcd和abc不是）

def fun(str1.str2): if str1[::-1]==str2: return True else: return False

 

9.請簡要敘述“進銷存”的設計方法

 

10請求解兩個鏈表的交點

 

 

眾祿金融：

1.請寫出下面代碼的輸出結果

2.請寫出下面代碼的輸出結果

a = 1 def fun(a): a = 2 fun(a) print (a) a=[] def fun(a): a.append(1) fun(a) print (a)

 1
[1]

3.如何判斷一個郵箱是否合法

 正則，

4.請實現一個裝飾器，限制該函數被調用的頻率，如10秒一次

 http://blog.csdn.net/u011510825/article/details/57408011

5.請說一說lambda函數的作用，請用lambda和reduce實現1到100的累加

 from functools import reduce
a=reduce( lambda x,y:x+y,range(1,101))
print(a)

6.請描述一下tuple,list,dict,set的特點

 https://www.cnblogs.com/shengulong/p/7149832.html

7.請說一下staticmethod和classmethod的區別

 

8.請說一說迭代器與生成器的理解

 

9.請用python實現單例模式，至少兩種方式

 

10.就你熟悉的web框架，講一講如何維護用戶的登錄狀態

 session

 

高瓴資本：

1.MYSQL有哪些存儲引擎，優化MYSQL數據庫的方法有哪些？

 MyISAM、InnoDB、Heap(Memory)、NDB..

2.WEB開發中session與cookie的作用與區別？

 

3.WE開發中有哪些技術手段防止SQL注入？

 https://www.cnblogs.com/baizhanshi/p/6002898.html

4.編寫快速排序或者冒泡排序

 

5.寫一個base62encode函數，62進制即：0123456789AS..Zab..z（10個數字+26個大寫字母+26個小寫字母），

base62encode(1)=1, base62encode(61)=z,  base62encode(62)=10

def base62encode(num): if isinstance(num,int): straa='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' temp = num//62 yushu = num%62 print(temp) if temp > 0: return str(temp)+straa[yushu] else: return straa[yushu] else: raise Exception('類型錯誤') print(base62encode(138))

 

 

飛行者：

1.什么是lambda函數？它有什么好處？

 

2.解釋一下python 的and - or 語法

 

python 中的and從左到右計算表達式，若所有值均為真，則返回最后一個值，若存在假，返回第一個假值。

or也是從左到有計算表達式，返回第一個為真的值。

3.python是如何進行類型轉換的？

 

4.請寫出一段python代碼實現一個刪除list里面的重復元素。

 l1=list(set(l))
print(l1)

5python中類方法、類實例方法、靜態方法有何區別？

 

6、python中pass語句的作用是什么？

 

Python pass是空語句，是為了保持程序結構的完整性。

pass 不做任何事情，一般用做占位語句。

7、介紹一下python下range() 和xange（）函數的用法?

 # from collections import Iterable,Iterator # Iterable 可迭代對象 # Iterator 迭代器 # print(isinstance(xrange(10),Iterator)) # print(isinstance(xrange(10),Iterable)) # python2 中 range(start, stop[, step]) 和 range(stop) 會生成-> range object,,返回是列表，是可迭代對象，全部放在內存里 產生列表 # python2 中 xrange(start, stop[, step]) 和 range(stop)會生成-> xrange object，返回是可迭代對象，每次調用時才會生成 產生生成器
# 要生成很大的數字序列的時候，用xrange會比range性能優很多，因為不需要一上來就開辟一塊很大的內存空間。
# python3 沒有xrange，只有range，也是可迭代對象，每次調用時才會生成

8。用python匹配html tag的時候 ，<.*>和<.*?>的用法？

 

9.python中如何拷貝一個對象？

 

10.如何用python來進行查詢和替換一個文本字符串？

 

11.寫出正則表達式從一個字符串中提取鏈接地址，如以下字符串<a href="http://ap.kaimu.tv/promotion/caxx">Hot</a>需要提取的鏈接為http://ap.kaimu.tv/promotion/caxx

 

12.Django里QuerySet的get和filter方法的區別？

 

用get方法查詢的時候，查詢不到內容的時候會拋出異常，同樣查詢結果多余1條的時候也會拋出異常

Exp：fresh.models.DoesNotExist: Cart matching query does not exist.

filer若是查詢不到數據，會返回一個空的查詢集，[]  type類型是：Queryset。查詢到多余一條的時候會返回一個包含多個對象的查詢集。

13。簡述Django對HTTP請求的執行流程

 https://www.cnblogs.com/liubiao/p/5594515.html

14.簡述Django下的（內建的）緩存機制

 

15.Django中MODEL的SlugField類型字段有什么用途？

 https://www.cnblogs.com/ohmydenzi/p/5584846.html

16.Django中如何加載初始數據？

 

高思教育：

1、python中 單引號，雙引號，三引號的區別？

 

（1）單引號中可以使用雙引號，中間的會當作字符串輸出

（2）雙引號中可以使用單引號，中間的會當作字符串輸出

（3）三單引號和三雙引號中間的字符串在輸出時保持原來的格式。

 

2.在python中，list,tuple,dict,set有什么區別？主要應用在什么樣的場景？

 

3.請打印出結果？

x = [0,1] i = o i,x[i]=1,2 print (x) 打印結果[0, 2]

4。請用自己的算法，按升序合並如下兩個list，並去除重復的元素：

list1=[2,3,8,4,9,5,6]

list2=[5,6,10,17,11,2]

 L=sorted(set(list1+list2))
print(L)

5.有一個多層嵌套的列表A = [1，2,[3,4,['434',[...]]]],請寫出一段代碼遍歷A中的每一個元素並打印出來

 

def fun(A): for i in A: if isinstance(i ,list): fun(i) else: print(i) fun(A)

 

6.關系型數據庫中，表與表之間有左連接，內鏈接，外連接。分別解釋下他們的含義及區別？

 

 

內連接：把兩個表中數據對應的數據查詢出來。

外連接：以某個表為基礎把對應數據查詢出來（全連接是以多個表為基礎），其中又包括左連接和右連接兩種。

還沒完，但是我不想查了

 

 

極客通智慧：

 

（一） 單項選擇

1.下列噶個語句在Python中是非法的？ a) x = y = z = 1 b) x = (y = z + 1) c) x, y = y, x d) x += y

2.關於Python內存管理，下列說法錯誤的是 a) 變量不必事先聲明 b) 變置無須先創建和賦值而直接使用 c) 變量無須指定類型 d) 可以使用del釋放資源

3•下面哪個不是Python合法的標識符 a) int32 b) 40XL c) self d) __name__

4.下列哪種說法是錯誤的 a) 除字典類型外，所有標准對象均可以用於布爾測試 b) 空字符串的布爾值是False c) 空列表對象的布爾值是False d) 值為0的任何數字對象的布爾值是False

5.下列表達式的值為True的是 a) (2**=3) <(2*=3) b) 3>2>2 c) 1==1 and 2!=1 d) not(1==l and 0!=1)

6. Python不支持的數據類型有 a) char b) int c) float d) list
7.關於字符串下列說法錯誤的是

a) 字符應該視為長度為1的字符串

b) 字符串以\0標志字符串的結束

c) 既可以用單引號，也可以用雙引號創建字符串

d) 在三引號字符串中可以包含換行回車等特殊字符

 8.以下不能創建一個字典的語句是

a) dictl = {}

b) dict2 ={3:5}

c) dict3 ={ [1,2,3] : "usetc"}

d) dict4 ={ (1,2,3): "usetc"}

9.下列python語句正確的是

a) min = x  if  x < y else y

b) max = x > y ? x:y

c) if (x>y) print x

d) while  1>2: print ("hello")

10.以下不能創建一個字典的語句是

a) dictl = ｛｝

h) dict2 = ｛3 : 5 }

c) dict3 = dict( [2 , 5] , [ 3 , 4 ])

d) dict4 = dict( ( [1,2], [3,4]))

1l.下面關於網絡七層和四層的描述，哪條是錯誤的？ a) SNMP工作在四層 b) 四層是指網絡的傳輸層.主要包括IP和端口信息 c) 七層是指網絡的應用層(協議層），比如http協議就工作在七層 d) 四層主要應用於TCP和UDP的代理，七層主要應用於HTTP等協議的代理

12•以下代碼輸出什么？ iist= [’a，，’b，，’c，，’d’，’e’] print list[10:] a) [] b) 程序異常 c) [，a，，，b，，，c，，，d，，，e，] d) 輸出空

13. 10、Python語言什么那些類型的數據才能作為字典的key? a) 沒有限制 b) 字母，數字，下划線
c)　　　　字母 d)　　　　可被hash的的類型

14.從DELETE語句中省略WHERE子句，將產生什么結果？ a) DELETE語句將失敗因為沒有記錄可刪除 b) DELETE語句將從表中刪除所有的記錄 c) DELETE語句將提示用戶進入刪除的標准 d) DELETE語句將失敗，因為語法錯誤

15. traceroute —般使用的是哪種網絡層協議？ a) VRRP b) UDP c) ARP d) ICMP

(二)多項選擇題（每題4分，共20分） 1. Python Web開發常用的開發框架有哪些？（多選） a) Node b) Django c) Flask d) tornado

　2.以下關於端口的描述哪些是正確的？（多選）

a) FTP使用TCP20端口 b) FTP使用TCP21端口 c) DNS使用TCP53端口 d) DNS使用UDP53端口

3.下面關於http協議中的GET和POST方式的區別，哪些是錯誤的？（多選）

a) 他們都可以被收藏，以及緩存 b) GET請求參數放在URL中 c) GET只用於查詢請求，不能用於請求數據
d) GET不應該處理敏感數據的請求

4. 以下哪些是常見的TCP Flags?(多選） a) SYN b) RST c) ACK d) URG

5、 關於Python類的繼承不正確的說法是？（多選） a) python類無法繼 b) 可以繼承但是，無法執行父類的構建函數 c) 可以有多個父類

d) 只能有一個父類

(三)填空題（每題2分.共10分） 1. Python使用符號____標示單行注釋：以____划分語句塊。 2. Python序列類型包括____、_______,_________、三種；___是Python中唯一種映射類型。 3. Python序列中的可變數據類型有________不可變數據類型有________。 4. 設 L=[a, b，c, d, e, f, g]，L[3:5]值是____，L[ : :2]值是____，L[::-l]值是________, L [-2: _5]值是___________。 5. Python的傳統除法運算符是______，地板除法運算符是__________。
https://wenku.baidu.com/view/90bb99e5e2bd960591c67725.html

(四） 問答題（每題8分，共40分） 1.解釋Python腳本程序的“__name__”變量及其作用。 __name__ 是模塊在上下文中的名字，其直接由Python解釋器運行時，等於字符"__main__"，否則（被其他文件import進來時）等於模塊名 2.簡單解釋Python的字符串駐留機制。 '''Python支持短字符串駐留機制，對於短字符串，將其賦值給多個不同的對象時，內存中只有一個副本，多個對象共享該副本,與其他類型數具有相同的特點。然而這一特點並不適用於長字符串，長字符串不遵守駐留機制''' 3.簡述什么是瀏覽器事件流。 4•解釋下HTTP常見響應狀態碼 5. Python是如何進行內存管理的？

 首信科技

1. Python中list、tuple、diet、set有什么區別，主要應用在什么樣的場景？並用 for語句分別進行遍歷。 2. Python中靜態函數，類函數，成員函數的區別？並各寫一個示例。 3. 用Python語言寫一個函數，輸入一個字符串，返回倒序排列的結果：如： string—reverse(‘abcdefg’)，返回：‘gfedeba’。 4. 介紹一下Python的異常處理機制和自己開發過程中的體會。 5. jQuery庫中的$()是什么？網頁上有5個<div>元素，如何使用jQuerv 來選擇它們？ 6.寫一個BashShell腳本來得到當前的日期、時間、用戶名和當前工作目錄。
7. Django中使用memcached作為緩存的具體方法？優缺點說明？



智慧星光

l,請下列語句是否有錯誤，如果無錯誤，請寫出該語句執行結果，如果有錯誤，請說明原因 1) 　　　a = 11; b = 2; a/b= 2) 　　　a =11.0 ; b = 2; a/b= 3) a = None; b = 2; a/b= 4) a = None; b = 2; a/b= 5) a = None; b = 2; a+b= 6) a = None; a is True = 7) a = None; a is False = 6)　　　　a = None; not a is True = 2.如下代碼段 a=[l, 2,3,[4,5],6] b = a cs copy.copy(a) d = copy.deepcopy(a) b.append(lO) c[3].append(ll) d[3].append(12) 請問，a,b,c,d的值為: 3.現有字典 d = {'a':26, ‘g':20,'e':22, 'c':24,'d‘:23, 'f‘:21,‘b':2S} 請按照字段中的value字段進行排序

4.用正則表達式實現匹配手機號（包含手機號碼前帶86或是+86的情況）

5

class A(): 　　def func(self):
　　　　print "A.func"
class B(A): 　　pass class C(A); 　　def func(self)： 　　　　print "C.func" class D(B,C): 　　pass　　 d = D() d.func() class A(object): 　　def func(seif): 　　　　print "A.func" class B(A): 　　pass class C(A):
　　def func(seLf): 　　　　print "C.func"class D(B, C): 　　pass d = D() d.func()

 

 

承興盛世

 

 

1、用最簡潔的方式初始化這樣一個變量：foo = [4,16,36,64,100]

[i*i for i in range(2,12,2)]

 

2、使用生成器編寫fib函數，函數聲明為fib(max)輸入一個參數max的值，使得該函數可以這樣調用

並產生如下結果（斐波那契數列），1,1,2,3,5,8,13,21

def fib(max): a = 0 b = 1 while b<max: yield b b,a = a+b,b for i in fib(1000): print(i,end=' ')

 

3、有如下數組list = range(10) 我想取以下幾個數組，應該如何切片？

（1）[1,2,3,4,5,6,7,8,9] 

（2）[1,2,3,4,5,6]

（3）[3,4,5,6]

（4）[9]

（5）[1,3,5,7,9]

1、[1:]
2、[1:7] 3、[3:7] 4、[-1] 5、[1::2]

 

4、有這樣一段代碼

a = 10

b = 20

c = [a]

a = 15

print c 會輸出什么，為什么？

對於字符串、數字，傳遞是相應的值 10

 

5、for i in range(1):print i

for i in xrange(1):print i 這兩段代碼輸出一樣么，占用系統資源一樣么，什么時候要用xrange代替range？

 

6、有這樣一個url，foobar/homework/2009-10-20/xiaoming，其中2009-10-20和小明是變量，請用正則表達式捕獲這個url，要求盡量准確

str1 = 'foobar/homework/2009-10-20/xiaoming' url_compile = re.compile('foobar/homework/(?P<date>\d{4}-\d{1,2}-\d{1,2})/(?P<username>\w+)') result = re.search(url_compile,str1) print(result.group('date')) print(result.group('username'))

 

7、有這樣一個文本文件，他的路徑為baseDir，他的名字test.txt，要求with方式打開，並打印每一行文本，並要求文件路徑考慮跨平台問題

 

import os baseDir = r'C:\Users\haora' filename = 'test.txt' file_path = os.path.join(baseDir,filename) with open(file_path,'r') as f: for line in f.readlines(): print(line)

 

8、有processFunc變量，初始化為processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)

調用上下文如下

collapse = True

processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)

print processFunc('I\tam\ntest\tobject!')

collapse = False

processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)

print processFunc('I\tam\ntest\tobject!')

 

I am test object!
I    am
test    object!

 

 

 

 

 

1、is 和 ==的區別

Python中對象包含的三個基本要素，分別是：id(身份標識)、type(數據類型)和value(值)

==是python中的比較運算符，用來比較兩個對象的value(值)是否相等

 

       is也被叫做同一性運算符，這個運算符比較判斷的是對象間的唯一身份標識，也就是id是否相同

 

#只有數值型和字符串型的情況下，a is b才為True，當a和b是tuple，list，dict或set型時，a is b為False

 

2、類中的@classmethod、@staticmethod和@@property的用法和效果。

@classmethod :類方法

@staticmethod:靜態方法

@property:屬性方法

 

3、python的自省

自省是指這種能力：檢查某些事物以確定它是什么、它知道什么以及它能做什么。

如：type(),dir(),getattr(),hasattr(),isinstance()，callable(obj)等。

 

4、python的各種推導式（列表推導式、字典推導式、集合推導式）

     參考：http://www.cnblogs.com/tkqasn/p/5977653.html

 

5、*args和**kwargs

當你不確定你的函數里將要傳遞多少參數時你可以用

*args.可以傳遞任意數量的位置參數:    以元組形式存儲

**kwargs可以傳遞任意數量的關鍵字參數： 以字典形式存儲

 

*args和**kwargs可以同時在函數的定義中,但是*args必須在**kwargs前面

 

6、單例模式（__new__和裝飾器）

參考：http://ghostfromheaven.iteye.com/blog/1562618

記住__new__和裝飾器即可

7、什么是lambda函數？

通常是在需要一個函數，但是又不想費神去命名一個函數的場合下使用，也就是指匿名函數。

8、可變對象和不可變對象：

元組（tuple)、數值型（number)、字符串(string)均為不可變對象,

 

字典型(dictionary)和列表型(list)的對象是可變對象。

可以通過查看id 體現

def test(a=[]):

    a.append(1)

    Print(a)

連續多次調用test函數，輸出什么？

參考：http://www.cnblogs.com/evening/archive/2012/04/11/2442788.html

函數.__defaults__函數對象的默認參數

 

9、祛除一個列表中的重復內容，原順序不變。

a = ['a','b','b','c','c','d']

b = list(set(a))

b.sort(key=a.index)

或者

c = sorted(set(a),key=a.index)

10、一個列表里套着字典，以字典的某個k的值排序。

l=[{"a":1","b":2},{"a":1","b":8},{"a":1","b":5},{"a":1","b":3}]

以"a"的值排序

sorted(l,key=lamdba k:k["a"])

 

11、django中的CSRF_TOKEN和XSS攻擊，原因，防御

非模版跨站如ajax如何避免csrf_token。

請求頭：{'X-CSRFToken':token}    記住鍵值

數據：{'csrfmiddlewaretoken':csrf}  記住鍵值

 

視圖中添加csrf_token裝飾器（FBV，CBV）

from django.views.decorators.csrf import csrf_exempt，csrf_protect

 

12、django中MTV、MVC、CBV、FBV都是什么。

MTV：models、templates、views

MVC: models 、views、Controller

CBV:Class-based views

FBV:Function-based views

13、ForeignKey，ManyToManyField與OneToOneField

ForeignKey：多對一

ManyToManyField：多對多

OneToOneField：一對一

14、中間件工作流程

 

15、算法：基礎算法手寫

 

16、socket客戶端和服務端