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客户端和服务端