必威-必威-欢迎您

必威,必威官网企业自成立以来,以策略先行,经营致胜,管理为本的商,业推广理念,一步一个脚印发展成为同类企业中经营范围最广,在行业内颇具影响力的企业。

通过id来看引用a的内存地址可以比较理解,Pyth

2019-11-22 05:16 来源:未知

网络

风流罗曼蒂克、 三回握手

  1. 顾客端通过向服务器端发送八个SYN来创立二个积极打开,作为一回握手的豆蔻梢头局地。客商端把这段连接的序号设定为随便数 A。
  2. 劳动器端应当为五个法定的SYN回送贰个SYN/ACK。ACK 的确认码应该为A+1,SYN/ACK 包本人又有一个无约束序号 B。
  3. 最终,客商端再发送二个ACK。当服务端受到那么些ACK的时候,就成功了三路握手,并步入了三番五次创造状态。那时候包序号被设定为接纳的确认号 A+1,而响应则为 B+1。

二、七回挥手

小心: 中断连接端能够是客商端,也能够是服务器端. 上边仅以客商端断开连接举例, 反之亦然.

  1. 客商端发送三个数据分段, 个中的 FIN 标志设置为1. 客商端步入 FIN-WAIT 状态. 该情况下顾客端只选择数据, 不再发送数据.
  2. 服务器收到到含有 FIN = 1 的数额分段, 发送带有 ACK = 1 的剩下数量分段, 确认收到用户端发来的 FIN 音信.
  3. 服务器等到具有数据传输停止, 向客商端发送多个包罗 FIN = 1 的多少分段, 并步入 CLOSE-WAIT 状态, 等待顾客端发来含有 ACK = 1 的认可报文.
  4. 顾客端收到服务器发来含有 FIN = 1 的报文, 再次来到 ACK = 1 的报文确认, 为了幸免服务器端未接到需求重发, 进入 TIME-WAIT 状态. 服务器收到到报文后关闭连接. 客户端等待 2MSL 后未选用回复, 则以为服务器成功关闭, 顾客端关闭连接.

三、ARP协议

地址深入分析左券(Address Resolution Protocol),其幼功用为经过指标设备的IP地址,查询指标的MAC地址,以确认保证通讯的顺遂举行。它是IPv4网络层不可贫乏的磋商,然则在IPv6中已不再适用,并被邻居开采左券(NDP卡塔尔所取代。

四、urllib和urllib2的区别

其一面试官确实问过,那时答的urllib2能够Post而urllib不能.

  1. urllib提供urlencode方法用来GET查询字符串的发生,而urllib2未有。那是为啥urllib常和urllib2一齐行使的原因。
  2. urllib2能够承担三个Request类的实例来安装UEscortL乞求的headers,urllib仅能够担任U君越L。那表示,你无法装作你的User Agent字符串等。

五、Post和Get

GET和POST有如何差异?及为啥互连网的大多数答案都以错的 新浪回答

get: RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1 post: RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1

六、Cookie和Session

CookieSession积累地点顾客端服务器端目标追踪会话,也足以保存客商偏疼设置或许封存客户名密码等追踪会话安全性不安全无恙

session能力是要选择到cookie的,之所以现身session技巧,首借使为着安全。

七、apache和nginx的区别

nginx 相对 apache 的优点:

  • 轻量级,同样起web 服务,比apache 占用越来越少的内部存款和储蓄器及财富
  • 抗并发,nginx 管理央浼是异步非堵塞的,辅助更加多的面世连接,而apache 则是拥塞型的,在高并发下nginx 能保持低财富低消耗高品质
  • 布局简洁
  • 中度模块化的布置,编写模块相对轻松
  • 社区活泼

apache 相对nginx 的优点:

  • rewrite ,比nginx 的rewrite 强大
  • 模块超级多,基本想到的都足以找到
  • 少bug ,nginx 的bug 相对很多
  • 超稳定

八、 网站顾客密码保存

  1. 青霄白日保存
  2. 明文hash后保存,如md5
  3. MD5+Salt格局,这么些salt能够随便
  4. 微博使用了Bcrypy(好像)加密

九、 HTTP和HTTPS

景况码定义1xx 报告吸收接纳到诉求,继续进度2xx 成功步骤成功接受,被领悟,并被选取3xx 重定向为了做到乞请,必得使用特别措施4xx 顾客端出错央求饱含错的各类或无法实现5xx 服务器出错服务器不能做到明显有效的央浼

403: Forbidden 404: Not Found

HTTPS握手,对称加密,非对称加密,TLS/SSL,智跑SA

十、 XSRF和XSS

  • CS汉兰达F(Cross-site request forgery)跨站央求虚构
  • XSS(克罗斯 Site Scripting)跨站脚本攻击

CS福睿斯F注重在号召,XSS入眼在本子

十一、幂等 Idempotence

HTTP方法的幂等性是指二遍和频仍伏乞某多少个财富应该有着同样的副成效。(注意是副成效)

不会转移财富的情形,无论调用一遍照旧N次都还未有副效能。请小心,这里强调的是二次和N次具备同等的副功能,实际不是每趟GET的结果意气风发律。

本条HTTP央求大概会每一遍得到不一样的结果,但它自个儿并不曾产生此外副功用,由此是满意幂等性的。

DELETE方法用于删除能源,有副成效,但它应有满意幂等性。

调用一回和N次对系统爆发的副功能是如出意气风发辙的,即删掉id为4231的帖子;因而,调用者可以频仍调用或刷新页面而不要顾虑引起错误。

POST所对应的URAV4I并不是创设的能源本人,而是财富的选用者。

HTTP响应中应包蕴帖子的创办状态以致帖子的U奥德赛I。两遍相仿的POST乞请会在劳动器端创设两份财富,它们具有差异的U帕杰罗I;所以,POST方法不有所幂等性。

PUT所对应的U奥迪Q5I是要开创或更新的能源本身。比如:PUT

十二、RESTful架构(SOAP,RPC)

详见教程能够在网络查找一下

十三、 SOAP

SOAP(原为Simple Object Access Protocol的首字母缩写,即简单对象访问合同卡塔 尔(阿拉伯语:قطر‎是换到数据的豆蔻梢头种左券正式,使用在Computer网络Web服务(web service卡塔 尔(英语:State of Qatar)中,沟通带结构新闻。SOAP为了简化网页服务器(Web Server卡塔 尔(英语:State of Qatar)从XML数据库中提取数据时,节省去格式化页面时间,以至差别应用程序之间依照HTTP通讯左券,信守XML格式实践资料沟通,使其抽象于言语完成、平台和硬件。

十四、RPC

RPC(Remote Procedure Call Protocol卡塔 尔(英语:State of Qatar)——远程进度调用合同,它是意气风发种通过网络从远程Computer程序上号令服务,而无需了然底层网络工夫的商谈。RPC商量即使有些传输协议的存在,如TCP或UDP,为通信程序之间指导消息数据。在OSI互连网通讯模型中,RPC超过了传输层和应用层。RPC使得开荒包蕴网络遍布式多程序在内的应用程序特别轻易。

计算:服务提供的两大流派.守旧意义以艺术调用为导向通称RPC。为了公司SOA,若干商家联结推出webservice,制定了wsdl接口定义,传输soap.当网络时期,痴肥SOA被简化为http+xml/json.但是简化现身各样混乱。以财富为导向,任何操作无非是对资源的增加和删除改查,于是统生机勃勃的REST现身了.

发展的相继: RPC -> SOAP -> RESTful

十五、CGI和WSGI

CGI是通用网关接口,是连连web服务器和应用程序的接口,顾客通过CGI来收获动态数据或文件等。 CGI程序是叁个独门的程序,它可以用差不离全体语言来写,包蕴perl,c,lua,python等等。

WSGI, Web Server Gateway Interface,是Python应用程序或框架和Web服务器之间的后生可畏种接口,WSGI的中间叁个目标正是让顾客能够用统大器晚成的言语(Python)编写前后端。

官方认证:PEP-3333

十八、中间人攻击

在GFW里见惯司空的,呵呵.

高级中学档人攻击(Man-in-the-middle attack,平日缩写为MITM卡塔 尔(阿拉伯语:قطر‎是指攻击者与报纸发表的双方分别创造独立的牵连,并调换其所收取的数额,使通信的三头感觉他俩正在通过三个私密的接连几天与对方直接对话,但实际上整个会话都被攻击者完全调控。

十七、 c10k问题

所谓c10k难题,指的是服务器相同的时间支持广大个顾客端的标题,也正是concurrent 10 000 connection(那也是c10k那几个名字的缘故卡塔 尔(阿拉伯语:قطر‎。

十八、socket

详细教程小编就不风姿浪漫一列举了,大家能够活动检索一下。

十六、浏览器缓存

详细教程小编就超小器晚成一列举了,大家能够活动物检疫索一下。

304 Not Modified

二十、 HTTP1.0和HTTP1.1

  1. 必要头Host字段,四个服务器多个网址
  2. 长链接
  3. 文件断点续传
  4. 地点评释,状态管理,Cache缓存

HTTP伏乞8种艺术介绍 HTTP/1.1会谈中国共产党定义了8种HTTP央求方法,HTTP乞求方法也被叫作“须求动作”,分歧的主意规定了差异的操作钦命的能源格局。服务端也会依据不一样的乞求方法做分裂的响应。

GET

GET恳求会展现诉求钦定的财富。日常的话GET方法应该只用于数据的读取,而不应有用于会生出副功效的非幂等的操作中。

GET会办法诉求钦点的页面音讯,并赶回响应宗旨,GET被以为是不安全的不二诀要,因为GET方法会被互连网蜘蛛等随便的拜候。

HEAD

HEAD方法与GET方法相同,都以向服务器发出钦定财富的央浼。不过,服务器在响应HEAD乞求时不会回传能源的内容部分,即:响应中央。那样,我们能够不传输全部内容的情事下,就足以获得服务器的响应头新闻。HEAD方法常被用于顾客端查看服务器的属性。

POST

POST供给会 向钦定能源提交数据,央浼服务器进行管理,如:表单数据交由、文件上传等,央求数据会被含有在央求体中。POST方法是非幂等的方式,因为这一个央求恐怕会创设新的能源或/和退换现存财富。

PUT

PUT供给会身向钦定能源职分上传其最新内容,PUT方法是幂等的章程。通过该方法客商端能够将钦命财富的新颖数据传送给服务器代替钦命的财富的原委。

DELETE

DELETE哀求用于诉求服务器删除所央求UENVISIONI(统一财富标记符,Uniform Resource Identifier卡塔尔国所标记的能源。DELETE诉求后钦命能源会被剔除,DELETE方法也是幂等的。

CONNECT

CONNECT方法是HTTP/1.1共谋预先流出的,能够将三番四次改为管道形式的代理服务器。日常用于SSL加密服务器的链接与非加密的HTTP代理服务器的通讯。

OPTIONS

OPTIONS哀告与HEAD相仿,平日也是用以客户端查看服务器的习性。 那几个方法会伏乞服务器重临该财富所扶助的装有HTTP乞求方法,该格局会用’*’来顶替财富名称,向服务器发送OPTIONS乞请,能够测量检验服务器功效是不是正常。JavaScript的XMLHttpRequest对象开展COGL450S跨域能源分享时,正是运用OPTIONS方法发送嗅探央浼,以判定是还是不是有对点名能源的拜访权限。 允许

TRACE

TRACE诉求服务器回显其吸收的呼吁音讯,该形式重要用于HTTP央浼的测量试验或确诊。

HTTP/1.1从今以往扩展的章程

在HTTP/1.1专门的工作拟订之后,又断断续续扩张了有的情势。在那之中使用中比较多的是 PATCH 方法:

PATCH

PATCH方法现身的较晚,它在二〇〇六年的HighlanderFC 5789专门的学问中被定义。PATCH哀告与PUT须求相同,相似用于能源的改正。二者有以下两点差异:

但PATCH平时用于能源的部分更新,而PUT平日用来能源的生机勃勃体化立异。 当财富空中楼阁时,PATCH会创立叁个新的财富,而PUT只会对已在财富实行翻新。

二十一、Ajax

AJAX,Asynchronous JavaScript and XML(异步的 JavaScript 和 XML卡塔 尔(阿拉伯语:قطر‎, 是与在不另行加载整个页面包车型地铁景况下,与服务器交流数据并更新部分网页的技能。

Itertools你的好死党

itertools模块包括了有的破例的函数能够操作可迭代对象.有未有想过复制贰个生成器?链接四个生成器?把嵌套列表里的值组织成三个列表?Map/Zip还不用制造另一个列表?

来吧import itertools

来叁个事例?让大家看看4匹马竞赛有稍微个排行结果:

>>> horses = [1, 2, 3, 4]
>>> races = itertools.permutations(horses)
>>> print(races)
<itertools.permutations object at 0xb754f1dc>
>>> print(list(itertools.permutations(horses)))
[(1, 2, 3, 4),
 (1, 2, 4, 3),
 (1, 3, 2, 4),
 (1, 3, 4, 2),
 (1, 4, 2, 3),
 (1, 4, 3, 2),
 (2, 1, 3, 4),
 (2, 1, 4, 3),
 (2, 3, 1, 4),
 (2, 3, 4, 1),
 (2, 4, 1, 3),
 (2, 4, 3, 1),
 (3, 1, 2, 4),
 (3, 1, 4, 2),
 (3, 2, 1, 4),
 (3, 2, 4, 1),
 (3, 4, 1, 2),
 (3, 4, 2, 1),
 (4, 1, 2, 3),
 (4, 1, 3, 2),
 (4, 2, 1, 3),
 (4, 2, 3, 1),
 (4, 3, 1, 2),
 (4, 3, 2, 1)]

理解迭代的个中机制

迭代是可迭代对象(对应iter()方法)和迭代器(对应next()方法)的三个进程.可迭代对象就是其他你能够迭代的靶子(废话啊).迭代器正是足以让您迭代可迭代对象的指标(有一点点绕口,意思正是其一意思)

今昔第一介绍的是自小编个人采撷的python面试的黄金时代对习以为常的必要和应掌握的文化,上边只是内部有的,越多的请看大家

3 矩形覆盖

大家得以用2*1的小矩形横着依然竖着去隐讳更加大的矩形。请问用n个2*1的小矩形无重叠地覆盖叁个2*n的大矩形,总共有个别许种艺术?

2*n个矩形的隐蔽措施等于第2*(n-1)加上第2*(n-2)的方法。

Python

f = lambda n: 1 if n < 2 else f(n - 1) + f(n - 2)

1
f = lambda n: 1 if n < 2 else f(n - 1) + f(n - 2)

 

这一定于

def say():
return "hello"
say = makebold(makeitalic(say))

print say()

[PSC开源组GitHub]() 地址 ,里面有详细的python面试应调整的装有地点的文化(最终是python后台和python服务器相关的卡塔 尔(阿拉伯语:قطر‎以致个人书籍推荐,能够留邮箱发送

Python语言特征

1 Python的函数参数字传送递

2 Python中的元类(metaclass)

3 @staticmethod和@classmethod

4 类变量和实例变量

5 Python自省

6 字典推导式

7 Python中单下划线和双下划线

8 字符串格式化:%和.format

9 迭代器和生成器

10*argsand**kwargs

11 面向切面编制程序AOP和装饰器

12 绿头鸭类型

13 Python中重载

14 新式类和旧式类

15__new__和__init__的区别

16 单例形式

1 使用__new__方法

2 分享属性

3 装饰器版本

4 import方法

17 Python中的功用域

18 GIL线程全局锁

19 协程

20 闭包

21 lambda函数

22 Python函数式编制程序

23 Python里的正片

24 Python垃圾回笼机制

1 引用计数

2 标识-清除机制

3 分代技能

25 Python的List

26 Python的is

27 read,readline和readlines

28 Python2和3的区别

29 super.init()

30 range-and-xrange

操作系统

1 select,poll和epoll

2 调节算法

3 死锁

4 程序编译与链接

1 预处理

2 编译

3 汇编

4 链接

5 静态链接和动态链接

6 设想内部存款和储蓄器手艺

7 分页和分层

分页与分支的严重性区别

8 页面置换算法

9 边际触发和水平触发

数据库

1 事务

2 数据库索引

3 Redis原理

4 乐观锁和悲观锁

5 MVCC

6 MyISAM和InnoDB

网络

1 一回握手

2 陆回挥手

3 ARP协议

4 urllib和urllib2的区别

5 Post和Get

6 Cookie和Session

7 apache和nginx的区别

8 网站客商密码保存

9 HTTP和HTTPS

10 XSRF和XSS

11 幂等 Idempotence

12 RESTful架构(SOAP,RPC)

13 SOAP

14 RPC

15 CGI和WSGI

16 中间人抨击

17 c10k问题

18 socket

19 浏览器缓存

20 HTTP1.0和HTTP1.1

21 Ajax

*NIX

unix进度间通讯情势(IPC)

数据结构

1 红黑树

编程题

1 台阶难点/斐波纳挈

2 卓殊台阶难题

3 矩形覆盖

4 杨氏矩阵查找

5 去除列表中的重复元素

6 链表成对沟通

7 创造字典的章程

1 直接创设

2 工厂方法

3 fromkeys()方法

8 归并八个不改变列表

9 交叉链表求交点

10 二分查找

11 快排

12 找零难点

13 广度遍历和深度遍历二叉树

14 二叉树节点

15 档期的顺序遍历

16 深度遍历

17 前中后序遍历

18 求最大树深

19 求两棵树是或不是相近

20 前序中序求后序

21 单链表逆置

Python语言特征

1 Python的函数参数字传送递

看七个例子:

a=1deffun(a):    a=2fun(a)printa#1

a=[]deffun(a):    a.append(1)fun(a)printa#[1]

不无的变量都足以清楚是内部存款和储蓄器中三个目的的“援用”,或许,也得以看似c中void*的感觉。

通过id来看援用a的内存地址能够比较通晓:

a=1deffun(a):print"func_in",id(a)#func_in 41322472a=2print"re-point",id(a),id(2)#re-point 41322448 41322448print"func_out",id(a),id(1)#func_out 41322472 41322472fun(a)printa#1

注:具体的值在分化计算机上运维时恐怕差别。

可以见见,在实行完a = 2之后,a援引中保存的值,即内部存款和储蓄器地址产生变化,由原先1目的的到处之处形成了2这一个实体对象的内部存储器地址。

而第三个例子a引用保存的内部存款和储蓄器值就不会发生变化:

a=[]deffun(a):print"func_in",id(a)#func_in 53629256a.append(1)print"func_out",id(a)#func_out 53629256fun(a)printa#[1]

此间记住的是体系是归于对象的,实际不是变量。而指标有三种,“可纠正”(mutable卡塔 尔(阿拉伯语:قطر‎与“不可改造”(immutable卡塔尔国对象。在python中,strings, tuples, 和numbers是不足改过的靶子,而list,dict等则是足以改进的目的。(那便是其生龙活虎题指标根本)

当三个引用传递给函数的时候,函数自动复制后生可畏份援引,那几个函数里的援引和外边的援用未有半毛关系了.所以第2个例子里函数把援用指向了叁个不可变对象,当函数重回的时候,外面的援引没半毛认为.而第二个例证就不切合了,函数内的引用指向的是可变对象,对它的操作就和稳固了指针地址相似,在内部存款和储蓄器里展开改进.

万一还不知道的话,这里有越来越好的解释:http://stackoverflow.com/questions/986006/how-do-i-pass-a-variable-by-reference

2 Python中的元类(metaclass)

以此特别的有时用,但是像ORM这种复杂的布局如故会供给的,实际情况请看:http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python

3 @staticmethod和@classmethod

Python其实有3个章程,即静态方法(staticmethod),类措施(classmethod)和实例方法,如下:

deffoo(x):print"executing foo(%s)"%(x)classA(object):deffoo(self,x):print"executing foo(%s,%s)"%(self,x)@classmethoddefclass_foo(cls,x):print"executing class_foo(%s,%s)"%(cls,x)@staticmethoddefstatic_foo(x):print"executing static_foo(%s)"%xa=A()

此间先明了下函数参数里面包车型客车self和cls.这一个self和cls是对类只怕实例的绑定,对于常常的函数来讲大家能够这么调用foo(x),这么些函数便是最常用的,它的干活跟此外事物(类,实例)非亲非故.对于实例方法,我们精通在类里每一次定义方法的时候都急需绑定这一个实例,正是foo(self, x),为何要那样做啊?因为实例方法的调用离不开实例,大家供给把实例自身传给函数,调用的时候是如此的a.foo(x)(其实是foo(a,

x)).类方法黄金时代致,只可是它传递的是类并不是实例,A.class_foo(x).注意这里的self和cls能够轮流别的参数,可是python的预定是那俩,依旧不要改的好.

对于静态方法其实和平凡的办法大器晚成致,无需对什么人举办绑定,唯豆蔻梢头的分别是调用的时候须求选择a.static_foo(x)或者A.static_foo(x)来调用.

实例方法类措施静态方法

a = A()a.foo(x)a.class_foo(x)a.static_foo(x)

A不可用A.class_foo(x)A.static_foo(x)

越多关于那几个题目:http://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python

4 类变量和实例变量

classPerson:    name="aaa"p1=Person()p2=Person()p1.name="bbb"printp1.name#bbbprintp2.name#aaaprintPerson.name#aaa

类变量便是供类使用的变量,实例变量正是供实例使用的.

此地p1.name="bbb"是实例调用了类变量,那实际上和下面第八个难题相仿,就是函数传参的难题,p1.name意气风发最早是指向的类变量name="aaa",可是在实例的作用域里把类变量的援用更换了,就成为了三个实例变量,self.name不再援用Person的类变量name了.

能够看看上边包车型客车例证:

classPerson:    name=[]p1=Person()p2=Person()p1.name.append(1)printp1.name#[1]printp2.name#[1]printPerson.name#[1]

参考:http://stackoverflow.com/questions/6470428/catch-multiple-exceptions-in-one-line-except-block

5 Python自省

本条也是python彪悍的本性.

反思正是面向对象的语言商量所写的程序在运作时,所能知道对象的类型.轻便一句便是运维时能够获得对象的类型.譬喻type(),dir(),getattr(),hasattr(),isinstance().

6 字典推导式

可能您见过列表推导时,却从不见过字典推导式,在2.7中才进入的:

d={key: valuefor(key, value)initerable}

7 Python中单下划线和双下划线

>>>classMyClass():...def__init__(self):...self.__superprivate="Hello"...self._semiprivate=", world!"...>>>mc=MyClass()>>>printmc.__superprivateTraceback (most recent call last):  File"", line1,inAttributeError: myClass instance has no attribute'__superprivate'>>>printmc._semiprivate, world!>>>printmc.__dict__{'_MyClass__superprivate':'Hello','_semiprivate':', world!'}

__foo__:生龙活虎种约定,Python内部的名字,用来差异别的客商自定义的命名,防止冲突.

_foo:豆蔻梢头种约定,用来钦命变量私有.程序员用来钦点个人变量的生机勃勃种方式.

__foo:那一个有实在的意义:解析器用_classname__foo来代替这一个名字,以分别和其它类雷同的命名.

详情见:http://stackoverflow.com/questions/1301346/the-meaning-of-a-single-and-a-double-underscore-before-an-object-name-in-python

或者:http://www.zhihu.com/question/19754941

8 字符串格式化:%和.format

.format在广大上边看起来更便利.对于%最烦人的是它无法同不经常候传递叁个变量和元组.你或者会想上边包车型大巴代码不会有何难题:

"hi there %s" % name

而是,如果name恰巧是(1,2,3),它将会抛出三个TypeError至极.为了有限扶植它连接不错的,你不能不这么做:

"hi there %s" % (name,)  # 提供八个单成分的数组实际不是三个参数

只是有个别丑..format就未有那几个难点.你给的第二个难点也是这么,.format美观多了.

你为何不用它?

不理解它(在读这么些前边)

为了和Python2.5协作(举个例子logging库建议使用%(issue #4))

http://stackoverflow.com/questions/5082452/python-string-formatting-vs-format

9 迭代器和生成器

以此是stackoverflow里python排名第生龙活虎的题材,值得少年老成看:http://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do-in-python

那是粤语版:http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/1/README.html

10*argsand**kwargs

用*args和**kwargs只是为了有援助并从未强制行使它们.

当您不明确你的函数里就要传递多少参数时你能够用*args.比如,它能够传递大肆数量的参数:

>>>defprint_everything(*args):forcount, thinginenumerate(args):...print'{0}.{1}'.format(count, thing)...>>>print_everything('apple','banana','cabbage')0. apple1. banana2. cabbage

相似的,**kwargs允许你使用未有事先定义的参数名:

>>>deftable_things(**kwargs):...forname, valueinkwargs.items():...print'{0}={1}'.format(name, value)...>>>table_things(apple='fruit',cabbage='vegetable')cabbage=vegetableapple=fruit

你也得以混着用.命名参数首先拿到参数值然后有着的任何参数都传送给*args和**kwargs.命名参数在列表的最前端.比如:

def table_things(titlestring, **kwargs)

*args和**kwargs可以同不时间在函数的概念中,可是*args必须在**kwargs前面.

当调用函数时你也足以用*和**语法.例如:

>>>defprint_three_things(a,b,c):...print'a ={0}, b ={1}, c ={2}'.format(a,b,c)...>>>mylist=['aardvark','baboon','cat']>>>print_three_things(*mylist)a=aardvark, b=baboon, c=cat

就好像你见到的相通,它能够传递列表(大概元组)的每大器晚成项并把它们解包.注意必得与它们在函数里的参数相适合.当然,你也能够在函数定义只怕函数调用时用*.

http://stackoverflow.com/questions/3394835/args-and-kwargs

11 面向切面编程AOP和装饰器

其风姿洒脱AOP后生可畏听上去有一点点懵,同学面Ali的时候就被问懵了...

装饰器是叁个很知名的设计形式,平常被用于有切面须要的气象,较为优质的有插入日志、性能测量试验、事务管理等。装饰器是消除那类难题的绝佳设计,有了装饰器,大家就足以分离出大气函数中与函数成效本人毫无干系的大同小异代码并无冕起用。归纳的讲,装饰器的魔法正是为早就存在的靶子增添额外的机能。

其一难题非常的大,推荐:http://stackoverflow.com/questions/739654/how-can-i-make-a-chain-of-function-decorators-in-python

中文:http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/3/README.html

12 红鸭类型

“当见到三头鸟走起来像秋沙鸭、游泳起来像红鸭、叫起来也像树鸭,那么那只鸟就能够被称呼栖鸭。”

我们并不保养对象是如何类型,到底是否绒鸭,只关心行为。

比方说在python中,有过多file-like的东西,譬如StringIO,GzipFile,socket。它们有不菲一直以来的格局,我们把它们作为文件使用。

又例如list.extend()方法中,大家并不关怀它的参数是否list,只要它是可迭代的,所以它的参数能够是list/tuple/dict/字符串/生成器等.

秋沙鸭类型在动态语言中不经常使用,特别灵活,使得python不想java这样特意去弄一大堆的设计形式。

13 Python中重载

引自乐乎:http://www.zhihu.com/question/20053359

函数重载首若是为了消除三个难题。

可变参数类型。

可变参数个数。

别的,七个基本的安排标准是,仅仅当几个函数除了参数类型和参数个数区别以外,其成效是完全雷同的,那个时候才使用函数重载,要是四个函数的职能实在不如,那么不应有利用重载,而应该利用二个名字区别的函数。

好啊,那么对于景况 1 ,函数作用相符,不过参数类型分化,python 如什么地点理?答案是历来没有必要管理,因为 python 能够担任其余类型的参数,假若函数的功用相通,那么不一样的参数类型在 python 中很大概是如出意气风发辙的代码,未有要求做成七个例外函数。

这正是说对于情况 2 ,函数功效左近,但参数个数分化,python 如什么地点理?咱们精晓,答案正是缺省参数。对那个贫乏的参数设定为缺省参数就能够缓和难点。因为您假使函数功效相通,那么那么些贫乏的参数究竟是必要用的。

好了,鉴于情形 1 跟 情形 2 都有了化解方案,python 自然就无需函数重载了。

14 新式类和旧式类

以此面试官问了,我说了老半天,不知道他问的真的意图是什么.

stackoverflow

那篇作品很好的介绍了新式类的表征:http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html

新颖类很早在2.2就涌出了,所以旧式类完全部都以非常的难题,Python3里的类全都以新式类.这里有多个MRO难题得以明白下(新式类是广度优先,旧式类是深浅优先),里讲的也超多.

15__new__和__init__的区别

这个__new__的确少之甚少见到,先做摸底吧.

__new__是三个静态方法,而__init__是三个实例方法.

__new__方法会重返贰个创设的实例,而__init__怎么着都不重返.

只有在__new__重回八个cls的实例时前面包车型客车__init__技术被调用.

当创立一个新实例时调用__new__,早先化二个实例时用__init__.

stackoverflow

ps:__metaclass__是创设类时起功能.所以大家能够分别使用__metaclass__,__new__和__init__来分别在类成立,实例创立和实例初阶化的时候做一些小手脚.

16 单例形式

这一个相对常考啊.必须求铭记在心1~2个方式,当时面试官是让手写的.

1 使用__new__方法

classSingleton(object):def__new__(cls,*args,**kw):ifnothasattr(cls,'_instance'):            orig=super(Singleton,cls)cls._instance=orig.__new__(cls,*args,**kw)returncls._instanceclassMyClass(Singleton):    a=1

2 分享属性

成立实例时把持有实例的__dict__针对同三个字典,那样它们有着相近的品质和方法.

classBorg(object):    _state={}def__new__(cls,*args,**kw):        ob=super(Borg,cls).__new__(cls,*args,**kw)        ob.__dict__=cls._statereturnobclassMyClass2(Borg):    a=1

3 装饰器版本

defsingleton(cls,*args,**kw):    instances={}defgetinstance():ifclsnotininstances:            instances[cls]=cls(*args,**kw)returninstances[cls]returngetinstance@singletonclassMyClass:...

4 import方法

用作python的模块是资质的单例方式

#mysingleton.pyclassMy_Singleton(object):deffoo(self):passmy_singleton=My_Singleton()#to usefrommysingletonimportmy_singletonmy_singleton.foo()

17 Python中的成效域

Python 中,三个变量的效能域总是由在代码中被赋值的地点所决定的。

当 Python 蒙受一个变量的话他会根据那样的顺序举行查找:

地点作用域(Local卡塔 尔(阿拉伯语:قطر‎→当前成效域被安置的地点成效域(Enclosing locals卡塔 尔(阿拉伯语:قطر‎→全局/模块功效域(Global卡塔尔→内置效率域(Built-in卡塔尔

18 GIL线程全局锁

线程全局锁(Global Interpreter Lock),即Python为了确定保证线程安全而选取的独立线程运营的范围,说白了正是三个核只可以在同时运营三个线程.

见Python 最难的主题素材

解决办法正是多进度和上面包车型客车协程(协程也只是单CPU,然而能减小切换代价升高品质).

19 协程

乐乎被问到了,呵呵哒,跪了

简易点说协程是经过和线程的进级版,进程和线程都直面着内核态和客户态的切换难点而消耗无尽切换时间,而协程正是客商自个儿决定切换的机缘,不再要求陷入系统的基业态.

Python里最布满的yield正是协程的合计!能够查看第九个难题.

20 闭包

闭包(closure)是函数式编制程序的首要的语法结构。闭包也是风姿浪漫种集体代码的组织,它相近拉长了代码的可另行使用性。

当一个内嵌函数援引其外界作作用域的变量,大家就能够赢得一个闭包. 总括一下,创造八个闭包必得满意以下几点:

总得有多少个内嵌函数

内嵌函数必得援引外界函数中的变量

表面函数的再次回到值必得是内嵌函数

认为闭包依旧有难度的,几句话是说不知情的,照旧印证相关资料.

主假若函数运营后并不会被撤销,就如16题的instance字典同样,当函数运转完后,instance并不被销毁,而是继续留在内存空间里.这几个功用肖似类里的类变量,只可是迁移到了函数上.

闭包就如个空心球同样,你精晓外面和内部,但你不知底中间是怎样.

21 lambda函数

实际正是二个佚名函数,为啥叫lambda?因为和前面的函数式编制程序有关.

推荐:知乎

22 Python函数式编制程序

其生龙活虎须求适宜的垂询一下吧,终究函数式编制程序在Python中也做了引用.

推荐:酷壳

python中函数式编制程序扶持:

filter 函数的功用也等于过滤器。调用三个布尔函数bool_func来迭代遍历每一个seq中的成分;再次来到叁个使bool_seq重返值为true的成分的行列。

>>>a=[1,2,3,4,5,6,7]>>>b=filter(lambdax: x>5, a)>>>printb>>>[6,7]

map函数是对四个行列的种种项依次实施函数,上边是对三个队列种种项都乘以2:

>>>a=map(lambdax:x*2,[1,2,3])>>>list(a)[2,4,6]

reduce函数是对叁个队列的种种项迭代调用函数,下边是求3的阶乘:

>>>reduce(lambdax,y:x*y,range(1,4))6

23 Python里的正片

引用和copy(),deepcopy()的区别

importcopya=[1,2,3,4, ['a','b']]#原有对象b=a#赋值,传对象的引用c=copy.copy(a)#对象拷贝,浅拷贝d=copy.deepcopy(a)#指标拷贝,深拷贝a.append(5)#改正对象aa[4].append('c')#更改对象a中的['a', 'b']数组对象print'a =', aprint'b =', bprint'c =', cprint'd =', d输出结果:a=[1,2,3,4, ['a','b','c'],5]b=[1,2,3,4, ['a','b','c'],5]c=[1,2,3,4, ['a','b','c']]d=[1,2,3,4, ['a','b']]

24 Python垃圾回笼机制

Python GC首要采取引用计数(reference counting卡塔 尔(阿拉伯语:قطر‎来追踪和回笼废料。在援引计数的根底上,通过“标识-毁灭”(mark and sweep卡塔 尔(阿拉伯语:قطر‎消除容器对象大概发生的轮回援引难题,通过“分代回收”(generation collection卡塔 尔(阿拉伯语:قطر‎以空间换时间的章程升高垃圾回毛利率。

1 援引计数

PyObject是各类对象必有的内容,此中ob_refcnt就是做为援引计数。当一个目的有新的援用时,它的ob_refcnt就能够扩张,当引用它的对象被去除,它的ob_refcnt就能收缩.援用计数为0时,该目的生命就归西了。

优点:

简单

实时性

缺点:

尊崇引用计数消耗财富

循环援引

2 标志-覆灭机制

基本思路是先按需分配,等到未有空余内存的时候从寄放器和程序栈上的援引出发,遍历以指标为节点、以引用为边构成的图,把具有可以访谈到的目的打上标记,然后清扫三回内部存款和储蓄器空间,把具备没标志的靶子释放。

3 分代手艺

分代回笼的全部考虑是:将系统中的全体内部存款和储蓄器块依据其现成时间分开为不相同的集结,各类集结就成为三个“代”,垃圾搜罗频率随着“代”的共处时间的增大而减小,存活时间日常使用经过五遍垃圾回笼来衡量。

Python默断定义了三代对象集合,索引数越大,对象共处时间越长。

譬世尊讲:当一些内部存款和储蓄器块M经过了3次垃圾搜集的洗濯之后还存世时,我们就将内部存款和储蓄器块M划到三个集合A中去,而新分配的内部存款和储蓄器都划分到群集B中去。当废品搜集起来职业时,大大多情景都只对集结B进行垃圾回笼,而对集结A进行垃圾回笼要隔不长生龙活虎段时间后才开展,那就使得垃圾搜聚体制亟待管理的内部存储器少了,成效自然就加强了。在这里个进程中,群集B中的有些内部存款和储蓄器块由于现存时间长而会被转移到集合A中,当然,集结A中实际上也存在一些软骨头,这几个杂质的回笼会因为这种分代的编写制定而被延缓。

25 Python的List

推荐:http://www.jianshu.com/p/J4U6rR

26 Python的is

is是相比地址,==是相比值

27 read,readline和readlines

read 读取整个文件

readline 读取下后生可畏行,使用生成器方法

readlines 读取整个文件到二个迭代器以供大家遍历

28 Python2和3的区别

推荐:Python 2.7.x 与 Python 3.x 的首要分裂

29 super init

super() lets you avoid referring to the base class explicitly, which can be nice. But the main advantage comes with multiple inheritance, where all sorts of fun stuff can happen. See the standard docs on super if you haven't already.

Note that the syntax changed in Python 3.0: you can just say super().init() instead of super(ChildB, self).init() which IMO is quite a bit nicer.

http://stackoverflow.com/questions/576169/understanding-python-super-with-init-methods

30 range and xrange

都在循环时使用,xrange内部存款和储蓄器品质越来越好。for i in range(0, 20):for i in xrange(0, 20):What is the difference between range and xrange functions in Python 2.X? range creates a list, so if you do range(1, 10000000) it creates a list in memory with 9999999 elements. xrange is a sequence object that evaluates lazily.

http://stackoverflow.com/questions/94935/what-is-the-difference-between-range-and-xrange-functions-in-python-2-x

操作系统

1 select,poll和epoll

实质上具备的I/O都以轮询的格局,只不超过实际现的规模分裂罢了.

以此主题素材可能有一点长远了,但相信能应对出这些难题是对I/O多路复用有很好的打听了.此中tornado使用的就是epoll的.

selec,poll和epoll分化总括

基本上select有3个缺点:

连接数受限

寻找配成对速度慢

多少由基本拷贝到客商态

poll改过了第一个破绽

epoll改了四个劣势.

关于epoll的:http://www.cnblogs.com/my_life/articles/3968782.html

2 调解算法

先来先服务(FCFS, First Come First Serve)

短作业优先(SJF, Shortest Job First)

高高的优先权调解(Priority Scheduling)

时光片轮转(奥迪Q3Tucson, Round 罗布in)

漫天掩地反馈队列调节(multilevel feedback queue scheduling)

实时调解算法:

最初甘休时间优先 EDF

最低松弛度优先 LLF

3 死锁

原因:

角逐能源

前后相继推进各种不当

需要条件:

互斥条件

央求和保证标准

不剥夺条件

环路等待条件

拍卖死锁基本情势:

防止死锁(摈弃除1以外的标准)

幸免死锁(银行家算法)

检验死锁(财富分配图)

免除死锁

剥夺财富

撤废进度

4 程序编写翻译与链接

推荐:http://www.ruanyifeng.com/blog/2014/11/compiler.html

Bulid进程能够分解为4个步骤:预管理(Prepressing), 编写翻译(Compilation)、汇编(Assembly)、链接(Linking)

以c语言为例:

1 预处理

预编写翻译进度首要管理那个源文件中的以“#”开始的预编译指令,首要管理法规有:

将装有的“#define”删除,并扩充所用的宏定义

拍卖全体法规预编译指令,举个例子“#if”、“#ifdef”、 “#elif”、“#endif”

处理“#include”预编写翻译指令,将被含有的文本插入到该编写翻译指令的职分,注:此进度是递归举行的

除去全体注释

增多行号和文书名标记,以便于编写翻译时编译器爆发调节和测量试验用的行号消息以至用于编写翻译时发出编写翻译错误或警告时可展现行号

保留全部的#pragma编译器指令。

2 编译

编译进程正是把预管理完的文件举办后生可畏连串的词法分析、语法深入分析、语义深入分析及优化后转移对应的汇编代码文件。那些历程是全体程序创设的基本部分。

3 汇编

汇编器是将汇编代码转产生机器能够实行的吩咐,每一条汇编语句差十分少都以一条机器指令。经过编写翻译、链接、汇编输出的公文成为指标文件(Object File)

4 链接

链接的重大内容正是把各样模块之间交互作用援引的有的处理好,使各样模块可以准确的拼接。链接的重要性进程包块 地址和空中的分红(Address and Storage Allocation卡塔尔国、符号决议(Symbol Resolution)和重定位(Relocation)等步骤。

5 静态链接和动态链接

静态链接方法:静态链接的时候,载入代码就能够把程序会用到的动态代码或动态代码的地点分明下来静态库的链接能够接受静态链接,动态链接库也得以使用这种方法链接导入库

动态链接方法:使用这种办法的主次并不在后生可畏初叶就实现动态链接,而是直到真正调用动态库代码时,载入程序才计算(被调用的那部分)动态代码的逻辑地址,然后等到有些时候,程序又需求调用此外某块动态代码时,载入程序又去总计那有的代码的逻辑地址,所以,这种情势使程序最初化时间相当短,但运转时期的性质不如静态链接的顺序

6 设想内部存款和储蓄器本领

设想存款和储蓄器是指具有央浼调入效率和调换效能,能从逻辑上对内部存款和储蓄器体量加以增添的意气风发种存款和储蓄系统.

7 分页和分层

分页: 顾客程序的地点空间被分割成几何牢固大小的区域,称为“页”,相应地,内存空间分成若干个物理块,页和块的轻重相当于。可将顾客程序的任生龙活虎页放在内部存款和储蓄器的任一块中,完结了离散分配。

分段: 将客商程序地址空间分成若干个大小不等的段,每段能够定义大器晚成组相对完整的逻辑新闻。存款和储蓄分配时,以段为单位,段与段在内存中能够不相邻接,也落实了离散分配。

分页与分支的要害分化

页是新闻的物理单位,分页是为了促成非延续分配,以便化解内部存款和储蓄器碎片难题,或然说分页是出于系统管理的急需.段是新闻的逻辑单位,它饱含风流浪漫组意义相对完好的音讯,分段的指标是为着更加好地完毕分享,知足客商的必要.

页的深浅固定,由系统分明,将逻辑地址划分为页号和页本省址是由机器硬件完毕的.而段的尺寸却不稳固,决议于客商所编纂的程序,经常由编译程序在对源程序开展编写翻译时依照消息的习性来划分.

分页的作业地址空间是大器晚成维的.分段之处空间是二维的.

8 页面置换算法

最棒置换算法OPT:不恐怕完结

先进先出FIFO

近年最久未使用算法LRU:如今黄金年代段时间里最久未有接收过的页面予以置换.

clock算法

9 边际触发和品位触发

边缘触发是指每当状态变化时发生二个 io 事件,条件触发是大器晚成旦满意条件就生出八个 io 事件

数据库

1 事务

数据库事务(Database Transaction) ,是指作为单个逻辑职业单元实施的一文山会海操作,要么完全地执行,要么完全地不推行。

2 数据库索引

推荐:http://tech.meituan.com/mysql-index.html

MySQL索引背后的数据结构及算法原理

聚焦索引,非集中索引,B-Tree,B+Tree,最左前缀原理

3 Redis原理

4 乐观锁和消极锁

自找麻烦锁:假定会时有爆发并发冲突,屏蔽一切恐怕违反数据完整性的操作

明朗锁:如若不会时有产生并发矛盾,只在交付操作时检查是或不是违反数据完整性。

5 MVCC

6 MyISAM和InnoDB

MyISAM 适合于有个别亟待大批量询问的选择,但其对于有大批量写操作并非很好。以至你只是急需update二个字段,整个表都会被锁起来,而其他进度,就终于读进度都无法儿操作直到读操作实现。其它,MyISAM 对于 SELECT COUNT(*) 那类的计量是非常的慢无比的。

InnoDB 的大方向会是三个特别复杂的寄存引擎,对于有些小的行使,它会比 MyISAM 还慢。他是它帮衬“行锁” ,于是在写操作超级多的时候,会更不错。并且,他还支持越来越多的高级级应用,比方:事务。

网络

1 二次握手

顾客端通过向服务器端发送五个SYN来成立二个继续努力张开,作为三路握手的一片段。顾客端把这段连接的序号设定为私行数 A。

劳务器端应当为二个官方的SYN回送一个SYN/ACK。ACK 的确认码应该为A+1,SYN/ACK 包本身又有贰个即兴序号 B。

末段,顾客端再发送叁个ACK。当服务端受到那一个ACK的时候,就完了了三路握手,并跻身了连接创设状态。那时包序号被设定为接到的确认号 A+1,而响应则为 B+1。

2 陆回挥手

3 ARP协议

地方解析左券(Address Resolution Protocol): 依据IP地址获取物理地址的一个TCP/IP左券

4 urllib和urllib2的区别

其一面试官确实问过,那个时候答的urllib2可以Post而urllib不能.

urllib提供urlencode方法用来GET查询字符串的发生,而urllib2未有。那是为啥urllib常和urllib2一同行使的原故。

urllib2能够肩负一个Request类的实例来设置USportageL央求的headers,urllib仅能够选取UXC90L。那表示,你不得以装作你的User Agent字符串等。

5 Post和Get

GET和POST有如何分歧?及为啥英特网的大超多答案都以错的和讯回答

get:RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1post:RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1

6 Cookie和Session

CookieSession

仓库储存地方客商端服务器端

指标追踪会话,也得以保留顾客偏疼设置可能封存客商名密码等追踪会话

安全性不安全无恙

session技术是要动用到cookie的,之所以现身session才干,首若是为着安全。

7 apache和nginx的区别

nginx 相对 apache 的优点:

轻量级,同样起web 服务,比apache 占用更加少的内部存款和储蓄器及财富

抗并发,nginx 管理央浼是异步非梗塞的,协理更加多的面世连接,而apache 则是拥塞型的,在高并发下nginx 能保持低财富低消耗高性能

布署简洁

可观模块化的规划,编写模块绝对简便易行

社区活泼

apache 相对nginx 的优点:

rewrite ,比nginx 的rewrite 强大

模块超级多,基本想到的都足以找到

少bug ,nginx 的bug 相对超级多

超稳定

8 网址顾客密码保存

当着保存

明文hash后保存,如md5

MD5+Salt形式,这么些salt能够放肆

乐乎使用了Bcrypy(好像)加密

9 HTTP和HTTPS

场合码定义

1xx 报告吸收接纳到须求,继续进度

2xx 成功步骤成功接到,被掌握,并被选拔

3xx 重定向为了达成需要,必需使用进一层措施

4xx 顾客端出错央浼包含错的依次或不能够成功

5xx 服务器出错服务器无法成功显明有效的乞请

403: Forbidden404: Not Found

HTTPS握手,对称加密,非对称加密,TLS/SSL,昂CoraSA

10 XSRF和XSS

CSPAJEROF(Cross-site request forgery)跨站乞请杜撰

XSS(克罗斯 Site Scripting)跨站脚本攻击

CS福特ExplorerF重视在号令,XSS注重在本子

11 幂等 Idempotence

HTTP方法的幂等性是指壹次和高频伸手某八个财富应该负有相仿的副作用。(注意是副效能)

GET

DELETE方法用于删除财富,有副成效,但它应该满意幂等性。比方:DELETE

POST所对应的U兰德PRADOI并非成立的财富本人,而是财富的收信人。例如:POST

PUT所对应的U凯雷德I是要创建或更新的财富本身。举例:PUT

12 RESTful架构(SOAP,RPC)

推荐:http://www.ruanyifeng.com/blog/2011/09/restful.html

13 SOAP

SOAP(原为Simple Object Access Protocol的首字母缩写,即简单对象访谈公约卡塔尔是换来数据的豆蔻梢头种左券正式,使用在微型机互连网Web服务(web service卡塔尔国中,交流带结构音信。SOAP为了简化网页服务器(Web Server卡塔 尔(阿拉伯语:قطر‎从XML数据库中提取数据时,节省去格式化页面时间,以致分裂应用程序之间依据HTTP通讯合同,据守XML格式执行资料调换,使其抽象于言语完成、平台和硬件。

14 RPC

RPC(Remote Procedure Call Protocol卡塔尔——远程进度调用合同,它是大器晚成种通过互连网从远程Computer程序上呼吁服务,而无需驾驭底层互联网技能的合计。RPC共同商议假设某个传输公约的存在,如TCP或UDP,为通讯程序之间携带消息数据。在OSI互连网通讯模型中,RPC高出了传输层和应用层。RPC使得开辟富含网络布满式多程序在内的应用程序特别便于。

计算:服务提供的两大流派.古板意义以艺术调用为导向通称RPC。为了公司SOA,若干厂家合伙推出webservice,制订了wsdl接口定义,传输soap.当互连网时代,痴肥SOA被简化为http+xml/json.不过简化现身各样混乱。以财富为导向,任何操作无非是对财富的增加和删除改查,于是统风华正茂的REST现身了.

进步的依次: RPC -> SOAP -> RESTful

15 CGI和WSGI

CGI是通用网关接口,是三回九转web服务器和应用程序的接口,客户通过CGI来得到动态数据或文件等。CGI程序是三个独自的程序,它能够用大概具有语言来写,富含perl,c,lua,python等等。

WSGI, Web Server Gateway Interface,是Python应用程序或框架和Web服务器之间的大器晚成种接口,WSGI的内部贰个目标即是让顾客能够用统风度翩翩的语言(Python)编写前后端。

法定认证:PEP-3333

16 中间人攻击

在GFW里见怪不怪的,呵呵.

中档人攻击(Man-in-the-middle attack,日常缩写为MITM卡塔 尔(英语:State of Qatar)是指攻击者与报导的相互分别创建独立的关系,并沟通其所接收的多少,使通信的两方感到他俩正在通过叁个私密的总是与对方直接对话,但实则整个会话都被攻击者完全调节。

17 c10k问题

所谓c10k难题,指的是服务器同期协理广大个顾客端的难题,也正是concurrent 10 000 connection(那也是c10k那么些名字的原委卡塔尔国。推荐:http://www.kegel.com/c10k.html

18 socket

推荐:http://www.360doc.com/content/11/0609/15/5482098_122692444.shtml

Socket=Ip address+ TCP/UDP + port

19 浏览器缓存

推荐:http://www.cnblogs.com/skynet/archive/2012/11/28/2792503.html

304 Not Modified

20 HTTP1.0和HTTP1.1

推荐:http://blog.csdn.net/elifefly/article/details/3964766

乞求头Host字段,一个服务器三个网址

长链接

文本断点续传

地方验证,状态管理,Cache缓存

21 Ajax

AJAX,Asynchronous JavaScript and XML(异步的 JavaScript 和 XML卡塔 尔(阿拉伯语:قطر‎, 是与在不重复加载整个页面包车型客车地方下,与服务器交流数据并立异部分网页的技术。

*NIX

unix进度间通讯方式(IPC)

管道(Pipe卡塔尔:管道可用于具备赤子情关系进度间的通讯,允许四个经过和另叁个与它有伙同祖先的进度之间开展通讯。

命名管道(named pipe卡塔 尔(阿拉伯语:قطر‎:命名管道克制了管道没盛名字的节制,由此,除具备管道所享有的效应外,它还同意无亲情关系进度间的通讯。命名管道在文件系统中有对应的文书名。命名管道通过命令mkfifo或系统调用mkfifo来创立。

随机信号(Signal卡塔 尔(英语:State of Qatar):时限信号是相比较复杂的通讯形式,用于文告选用进度有某种事件发生,除了用于进度间通讯外,进度还是能发送功率信号给进度本身;linux除了扶持Unix开始的生机勃勃段时代实信号语义函数sigal外,还支持语义切合Posix.1标准的功率信号函数sigaction(实际上,该函数是依赖BSD的,BSD为了完结可信赖数字信号机制,又能够联合对外接口,用sigaction函数重新达成了signal函数卡塔 尔(英语:State of Qatar)。

音讯(Message卡塔 尔(阿拉伯语:قطر‎队列:音讯队列是音信的链接表,满含Posix音信队列system V音讯队列。有丰盛权限的进度能够向队列中增多音讯,被给与读权限的经过则足以读走队列中的音讯。音讯队列制服了功率信号承载音讯量少,管道只可以承载无格式字节流以至缓冲区大大小小受限等缺

分享内部存款和储蓄器:使得多少个经过能够访谈同一块内存空间,是最快的可用IPC格局。是本着任何通讯机制运作功用超低而设计的。往往与任何通讯机制,如信号量结合使用,来实现进度间的一同及互斥。

内部存款和储蓄器映射(mapped memory卡塔尔:内部存款和储蓄器映射允许任何四个进度间通信,每一个选用该机制的历程经过把八个分享的文书映射到本身的长河地址空间来促成它。

非随机信号量(semaphore卡塔尔国:主要作为进程间以至相近进程分歧线程之间的一块儿花招。

套接口(Socket卡塔尔:更为雷同的过程间通讯机制,可用以区别机器之间的进度间通讯。伊始是由Unix系统的BSD分支开辟出来的,但现行反革命相似能够移植到别的类Unix系统上:Linux和System V的变种都扶植套接字。

数据结构

1 红黑树

红黑树与AVL的相比:

AVL是严格平衡树,由此在加码可能去除节点的时候,依据差别景色,旋转的次数比红黑树要多;

红黑是用非严加的平衡来换取增加和删除节点时候转动次数的大跌;

故而轻松说,固然您的运用中,找出的次数远远大于插入和删除,那么接纳AVL,借使搜索,插入删除次数差不离大概,应该采纳RB。

编程题

1 台阶难点/斐波纳挈

三头青蛙壹回能够跳上1级台阶,也能够跳上2级。求该引体向上上四个n级的阶梯总共有多少种跳法。

fib=lambdan: nifn<=2elsefib(n-1)+fib(n-2)

其次种纪念方法

defmemo(func):    cache={}defwrap(*args):ifargsnotincache:            cache[args]=func(*args)returncache[args]returnwrap@memodeffib(i):ifi<2:return1returnfib(i-1)+fib(i-2)

其三种方法

deffib(n):    a, b=0,1for_inxrange(n):        a, b=b, a+breturnb

2 反常台阶难题

一只青蛙一次能够跳上1级台阶,也得以跳上2级……它也得以跳上n级。求该引体向上上一个n级的阶梯总共有稍许种跳法。

fib=lambdan: nifn<2else2*fib(n-1)

3 矩形覆盖

我们得以用2*1的小矩形横着照旧竖着去掩没更加大的矩形。请问用n个2*1的小矩形无重叠地覆盖叁个2*n的大矩形,总共有些许种方式?

第2*n个矩形的覆盖格局等于第2*(n-1)加上第2*(n-2)的方法。

f=lambdan:1ifn<2elsef(n-1)+f(n-2)

4 杨氏矩阵查找

在叁个m行n列二维数组中,每风度翩翩行都依据从左到右依次增加的依次排序,每一列都固守从上到下依次增加的次第排序。请达成三个函数,输入那样的三个二维数组和三个卡尺头,判别数组中是或不是满含该整数。

接受Step-wise线性搜索。

defget_value(l,r,c):returnl[r][c]deffind(l,x):    m=len(l)-1n=len(l[0])-1r=0c=nwhilec>=0andr<=m:        value=get_value(l, r, c)ifvalue==x:returnTrueelifvalue>x:            c=c-1elifvalue

5 去除列表中的重复成分

用集合

list(set(l))

用字典

l1=['b','c','d','b','c','a','a']l2={}.fromkeys(l1).keys()printl2

用字典并保持顺序

l1=['b','c','d','b','c','a','a']l2=list(set(l1))l2.sort(key=l1.index)printl2

列表推导式

l1=['b','c','d','b','c','a','a']l2=[][l2.append(i)foriinl1ifnotiinl2]

面试官提到的,先排序然后删除.

6 链表成对交换

1->2->3->4转换成2->1->4->3.

classListNode:def__init__(self,x):self.val=xself.next=NoneclassSolution:#@param a ListNode#@return a ListNodedefswapPairs(self,head):ifhead!=Noneandhead.next!=None:next=head.next            head.next=self.swapPairs(next.next)next.next=headreturnnextreturnhead

7 创设字典的模式

1 直接成立

dict={'name':'earth','port':'80'}

2 工厂方法

items=[('name','earth'),('port','80')]dict2=dict(items)dict1=dict((['name','earth'],['port','80']))

3 fromkeys()方法

dict1={}.fromkeys(('x','y'),-1)dict={'x':-1,'y':-1}dict2={}.fromkeys(('x','y'))dict2={'x':None,'y':None}

8 合併三个不改变列表

乐乎远程面试要求编制程序

尾递归

def_recursion_merge_sort2(l1,l2,tmp):iflen(l1)==0orlen(l2)==0:        tmp.extend(l1)        tmp.extend(l2)returntmpelse:ifl1[0]

循环算法

def loop_merge_sort(l1, l2):

tmp = []

while len(l1) > 0 and len(l2) > 0:

if l1[0] < l2[0]:

tmp.append(l1[0])

del l1[0]

else:

tmp.append(l2[0])

del l2[0]

tmp.extend(l1)

tmp.extend(l2)

return tmp

9 交叉链表求交点

去何地的面试,没做出来.

classListNode:def__init__(self,x):self.val=xself.next=Nonedefnode(l1,l2):    length1, lenth2=0,0#求七个链表长度whilel1.next:        l1=l1.next        length1+=1whilel2.next:        l2=l2.next        length2+=1#长的链表先走iflength1>lenth2:for_inrange(length1-length2):            l1=l1.nextelse:for_inrange(length2-length1):            l2=l2.nextwhilel1andl2:ifl1.next==l2.next:returnl1.nextelse:            l1=l1.next            l2=l2.next

10 二分查找

defbinarySearch(l,t):    low, high=0,len(l)-1whilelowt:            high=midelifl[mid]

11 快排

defqsort(seq):ifseq==[]:return[]else:        pivot=seq[0]        lesser=qsort([xforxinseq[1:]ifx=pivot])returnlesser+[pivot]+greaterif__name__=='__main__':    seq=[5,6,78,9,0,-1,2,3,-65,12]print(qsort(seq))

12 找零难点

defcoinChange(values,money,coinsUsed):#values    T[1:n]数组#valuesCounts  钱币对应的门类数#money  寻找来的总钱数#coinsUsed  对应于最近货币总量i所使用的硬币数目forcentsinrange(1, money+1):        minCoins=cents#从第贰个起来到money的兼具景况开端forvalueinvalues:ifvalue<=cents:                temp=coinsUsed[cents-value]+1iftemp

13 广度遍历和深度遍历二叉树

给定三个数组,创设二叉树,并且按档期的顺序打字与印刷这几个二叉树

## 14 二叉树节点classNode(object):def__init__(self,data,left=None,right=None):self.data=dataself.left=leftself.right=righttree=Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))## 15 档案的次序遍历deflookup(root):    stack=[root]whilestack:        current=stack.pop(0)printcurrent.dataifcurrent.left:            stack.append(current.left)ifcurrent.right:            stack.append(current.right)## 16 深度遍历defdeep(root):ifnotroot:returnprintroot.data    deep(root.left)    deep(root.right)if__name__=='__main__':    lookup(tree)    deep(tree)

17 前中后序遍历

纵深遍历改造各类就OK了

18 求最大树深

defmaxDepth(root):ifnotroot:return0returnmax(maxDepth(root.left), maxDepth(root.right))+1

19 求两棵树是还是不是相似

defisSameTree(p,q):ifp==Noneandq==None:returnTrueelifpandq :returnp.val==q.valandisSameTree(p.left,q.left)andisSameTree(p.right,q.right)else:returnFalse

20 前序中序求后序

推荐:http://blog.csdn.net/hinyunsin/article/details/6315502

defrebuild(pre,center):ifnotpre:returncur=Node(pre[0])    index=center.index(pre[0])    cur.left=rebuild(pre[1:index+1], center[:index])    cur.right=rebuild(pre[index+1:], center[index+1:])returncurdefdeep(root):ifnotroot:returndeep(root.left)    deep(root.right)printroot.data

21 单链表逆置

classNode(object):def__init__(self,data=None,next=None):self.data=dataself.next=nextlink=Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))defrev(link):    pre=link    cur=link.next    pre.next=Nonewhilecur:        tmp=cur.next        cur.next=pre        pre=cur        cur=tmpreturnpreroot=rev(link)whileroot:printroot.data    root=root.next

10 二分查找

Python

def binarySearch(l, t): low, high = 0, len(l) - 1 while low < high: print low, high mid = (low + high) / 2 if l[mid] > t: high = mid elif l[mid] < t: low = mid + 1 else: return mid return low if l[low] == t else False if __name__ == '__main__': l = [1, 4, 12, 45, 66, 99, 120, 444] print binarySearch(l, 12) print binarySearch(l, 1) print binarySearch(l, 13) print binarySearch(l, 444)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def binarySearch(l, t):
    low, high = 0, len(l) - 1
    while low < high:
        print low, high
        mid = (low + high) / 2
        if l[mid] > t:
            high = mid
        elif l[mid] < t:
            low = mid + 1
        else:
            return mid
    return low if l[low] == t else False
 
if __name__ == '__main__':
    l = [1, 4, 12, 45, 66, 99, 120, 444]
    print binarySearch(l, 12)
    print binarySearch(l, 1)
    print binarySearch(l, 13)
    print binarySearch(l, 444)

操作系统

一、select,poll和epoll

骨子里具有的I/O都以轮询的艺术,只然而达成的层面不一致罢了.

本条主题素材大概有一些深远了,但相信能回应出那几个难题是对I/O多路复用有很好的掌握了.在那之中tornado使用的正是epoll的.

selec,poll和epoll区别总括

基本上select有3个缺点:

  1. 连接数受限
  2. 找寻配成对进程慢
  3. 数据由功底拷贝到客户态

poll订正了第二个缺欠

epoll改了三个劣点.

二、调节算法

  1. 先来先服务(FCFS, First Come First Serve)
  2. 短作业优先(SJF, Shortest Job First)
  3. 参天优先权调节(Priority Scheduling)
  4. 时刻片轮转(昂CoraTiguan, Round 罗布in)
  • 种类反馈队列调治(multilevel feedback queue scheduling)

实时调解算法:

  1. 最先结束时间优先 EDF
  2. 最低松弛度优先 LLF

三、死锁

原因:

  1. 竞争财富
  2. 前后相继推动各类不当

供给条件:

  1. 互斥条件
  2. 号召和保持标准
  3. 不剥夺条件
  4. 环路等待条件

拍卖死锁基本方法:

  1. 防护死锁(放任除1以外的规范化)
  2. 制止死锁(银行家算法)
  3. 检验死锁(财富分配图)
  4. 息灭死锁
  5. 剥夺能源
  6. 收回进度

死锁概念管理政策详细介绍的话,能够参见一下网络的。

四、程序编写翻译与链接

Bulid进度能够解释为4个步骤:预管理(Prepressing), 编译(Compilation)、汇编(Assembly)、链接(Linking)

python中的元类(metaclass)

以此极其的有时用,不过像ORM这种复杂的布局依然会要求的,实际情况请看:《深刻了解Python中的元类(metaclass)》

11 快排

Python

def qsort(seq): if seq==[]: return [] else: pivot=seq[0] lesser=qsort([x for x in seq[1:] if x<pivot]) greater=qsort([x for x in seq[1:] if x>=pivot]) return lesser+[pivot]+greater if __name__=='__main__': seq=[5,6,78,9,0,-1,2,3,-65,12] print(qsort(seq))

1
2
3
4
5
6
7
8
9
10
11
12
def qsort(seq):
    if seq==[]:
        return []
    else:
        pivot=seq[0]
        lesser=qsort([x for x in seq[1:] if x<pivot])
        greater=qsort([x for x in seq[1:] if x>=pivot])
        return lesser+[pivot]+greater
 
if __name__=='__main__':
    seq=[5,6,78,9,0,-1,2,3,-65,12]
    print(qsort(seq))

 

类变量和实例变量

class Person:
    name="aaa"

p1=Person() #类变量
p2=Person() #类变量
p1.name="bbb" #实例变量
print p1.name  # bbb
print p2.name  # aaa
print Person.name  # aaa

类变量便是供类使用的变量,实例变量正是供实例使用的.

此处p1.name="bbb"是实例调用了类变量,那实则和地方第二个难点相符,便是函数字传送参的主题素材,p1.name一发端是指向的类变量name="aaa",不过在实例的功用域里把类变量的援用改造了,就造成了贰个实例变量,self.name不再援引Person的类变量name了.

==能够看看下边包车型地铁例证: (need check)==
==python中list是mutable的类变量, 实例化之后也是mutable的, 所以对第二个实例的name操作, 也会唤起类变量以至其余的实例中list的转移==

==怎么着幸免==

class Person:
    name=[]

p1=Person()
p2=Person()
p1.name.append(1)
print p1.name  # [1]
print p2.name  # [1]
print Person.name  # [1]

参考:http://stackoverflow.com/questions/6470428/catch-multiple-exceptions-in-one-line-except-block

20 前序中序求后序

推荐:

Python

def rebuild(pre, center): if not pre: return cur = Node(pre[0]) index = center.index(pre[0]) cur.left = rebuild(pre[1:index + 1], center[:index]) cur.right = rebuild(pre[index + 1:], center[index + 1:]) return cur def deep(root): if not root: return deep(root.left) deep(root.right) print root.data

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def rebuild(pre, center):
    if not pre:
        return
    cur = Node(pre[0])
    index = center.index(pre[0])
    cur.left = rebuild(pre[1:index + 1], center[:index])
    cur.right = rebuild(pre[index + 1:], center[index + 1:])
    return cur
 
def deep(root):
    if not root:
        return
    deep(root.left)
    deep(root.right)
    print root.data

以c语言为例:

一、预处理

预编译进程首要管理这几个源文件中的以“#”开头的预编写翻译指令,首要管理准则有:

  1. 将装有的“#define”删除,并扩充所用的宏定义
  2. 管理全数条件预编写翻译指令,举例“#if”、“#ifdef”、 “#elif”、“#endif”
  3. 处理“#include”预编写翻译指令,将被含有的文本插入到该编写翻译指令的岗位,注:此进程是递归实行的
  4. 删除全数注释
  5. 加多行号和文书名标记,以便于编写翻译时编写翻译器发生调节和测验用的行号音信以至用于编写翻译时产生编写翻译错误或警报时可显示行号
  6. 封存全部的#pragma编写翻译器指令。

二、编译

编写翻译进程便是把预管理完的文件进行意气风发俯拾皆已的词法解析、语法解析、语义解析及优化后改动对应的汇编代码文件。那一个历程是后生可畏体程序塑造的大旨部分。

三、汇编

汇编器是将汇编代码转产生机器能够实践的授命,每一条汇编语句大约都以一条机器指令。经过编写翻译、链接、汇编输出的文件成为指标文件(Object File)

四、链接

链接的关键内容正是把各类模块之间人机联作援引的后生可畏对管理好,使各类模块能够正确的拼凑。 链接的严重性进程包块 地址和空间的分配(Address and Storage Allocation卡塔 尔(英语:State of Qatar)、符号决议(Symbol Resolution)和重定位(Relocation)等步骤。

五、静态链接和动态链接

静态链接方法:静态链接的时候,载入代码就能够把程序会用到的动态代码或动态代码的地址分明下来 静态库的链接能够行使静态链接,动态链接库也能够动用这种方法链接导入库

动态链接方法:使用这种方法的次第并不在风姿洒脱开头就形成动态链接,而是直到真正调用动态库代码时,载入程序才总结(被调用的这部分)动态代码的逻辑地址,然后等到有些时候,程序又需求调用其它某块动态代码时,载入程序又去总括这大器晚成都部队分代码的逻辑地址,所以,这种艺术使程序开始化时间比较短,但运转时期的质量不及静态链接的前后相继

六、虚拟内部存款和储蓄器本事

虚构存款和储蓄器是指装有诉求调入功效和交流成效,能从逻辑上对内部存款和储蓄器体积加以扩展的大器晚成种存款和储蓄系统.

七、分页和支行

分页: 客商程序的地点空间被分开成几何一定大小的区域,称为“页”,相应地,内部存款和储蓄器空间分成若干个物理块,页和块的尺寸也正是。可将客商程序的任风流倜傥页放在内部存款和储蓄器的任一块中,完毕了离散分配。

分层: 将顾客程序地址空间分成若干个大小不等的段,每段能够定义意气风发组相对完好的逻辑新闻。存款和储蓄分配时,以段为单位,段与段在内部存款和储蓄器中能够不相邻接,也完毕了离散分配。

分页与分支的根本差异

  1. 页是新闻的情理单位,分页是为了贯彻非三回九转分配,以便解决内部存款和储蓄器碎片难点,或然说分页是出于系统处理的供给.段是消息的逻辑单位,它含有豆蔻梢头组意义绝对完好的新闻,分段的指标是为着越来越好地落到实处分享,知足客户的要求.
  2. 页的大大小小固定,由系统明确,将逻辑地址划分为页号和页外省址是由机械硬件达成的.而段的长短却不定点,决计于客户所编写的顺序,日常由编写翻译程序在对源程序进行编写翻译时依照音信的品质来划分.
  3. 分页的课业地址空间是黄金时代维的.分段的地址空间是二维的.

八、页面置换算法

  1. 最棒置换算法OPT:无法完成
  2. 先进先出FIFO
  3. 前些天最久未利用算法LRU:方今一段时间里最久没有运用过的页面予以置换.
  4. clock算法

九、边沿触发和档案的次序触发

边缘触发是指每当状态变化时发生三个 io 事件,条件触发是假使满意条件就发出二个 io 事件

字符串格式化:%和.format

.format在大多地点看起来更便利.对于%最烦人的是它不只怕同临时候传递八个变量和元组.你或者会想下边包车型客车代码不会有何难题:

hi there %s" % name

不过,假使name赶巧是(1,2,3),它将会抛出多个TypeError极度.为了确认保证它连接不错的,你必须要这么做:

hi there %s" % (name,) # 提供一个单元素的数组而不是一个参数

可是有个别丑..format就不曾这几个问题.你给的第叁个难题也是如此,.format赏心悦目多了.

您干吗不要它?

不知底它(在读这么些以前)
为了和Python2.5精耕细作(例如logging库建议使用%(issue #4))

http://stackoverflow.com/questions/5082452/python-string-formatting-vs-format

6 链表成对沟通

1->2->3->4转换成2->1->4->3.

Python

class ListNode: def __init__(self, x): self.val = x self.next = None class Solution: # @param a ListNode # @return a ListNode def swapPairs(self, head): if head != None and head.next != None: next = head.next head.next = self.swapPairs(next.next) next.next = head return next return head

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
 
class Solution:
    # @param a ListNode
    # @return a ListNode
    def swapPairs(self, head):
        if head != None and head.next != None:
            next = head.next
            head.next = self.swapPairs(next.next)
            next.next = head
            return next
        return head

必威 1

python中单下划线和双下划线

那篇小说钻探Python中下划线_的施用。跟Python中众多用法相仿,下划线_的两样用法绝抢先58%(不全部都以卡塔 尔(英语:State of Qatar)都以风流倜傥种规矩约定。

9 交叉链表求交点

去何方的面试,没做出来.

Python

class ListNode: def __init__(self, x): self.val = x self.next = None def node(l1, l2): length1, lenth2 = 0, 0 # 求七个链表长度 while l1.next: l1 = l1.next length1 += 1 while l2.next: l2 = l2.next length2 += 1 # 长的链表先走 if length1 > lenth2: for _ in range(length1 - length2): l1 = l1.next else: for _ in range(length2 - length1): l2 = l2.next while l1 and l2: if l1.next == l2.next: return l1.next else: l1 = l1.next l2 = l2.next

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
def node(l1, l2):
    length1, lenth2 = 0, 0
    # 求两个链表长度
    while l1.next:
        l1 = l1.next
        length1 += 1
    while l2.next:
        l2 = l2.next
        length2 += 1
    # 长的链表先走
    if length1 > lenth2:
        for _ in range(length1 - length2):
            l1 = l1.next
    else:
        for _ in range(length2 - length1):
            l2 = l2.next
    while l1 and l2:
        if l1.next == l2.next:
            return l1.next
        else:
            l1 = l1.next
            l2 = l2.next

编程题

生机勃勃、台阶难点/斐波那契

二头青蛙二回能够跳上1级台阶,也得以跳上2级。求该仰卧起坐上叁个n级的台阶总共有稍许种跳法。

fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)

其次种记念方法

def memo(func):

cache = {}

def wrap(*args):

if args not in cache:

cache[args] = func(*args)

return cache[args]

return wrap

@memo

def fib(i):

if i < 2:

return 1

return fib(i-1) + fib(i-2)

其二种办法

def fib(n):

a, b = 0, 1

for _ in xrange(n):

a, b = b, a + b

return b

二、失常台阶难点

一只青蛙叁回能够跳上1级台阶,也足以跳上2级……它也能够跳上n级。求该立卧撑上叁个n级的台阶总共有微微种跳法。

fib = lambda n: n if n < 2 else 2 * fib(n - 1)

三、矩形覆盖

作者们能够用2*1的小矩形横着照旧竖着去掩瞒越来越大的矩形。请问用n个2*1的小矩形无重叠地覆盖多个2*n的大矩形,总共有个别许种艺术?

第2*n个矩形的覆盖情势等于第2*(n-1)加上第2*(n-2)的方法。

f = lambda n: 1 if n < 2 else f(n - 1) + f(n - 2)

四、杨氏矩阵查找

在三个m行n列二维数组中,每一行都根据从左到右依次增加的次第排序,每一列都固守从上到下递增的顺序排序。请达成一个函数,输入那样的叁个二维数组和三个板寸,剖断数组中是或不是含有该整数。

采取Step-wise线性找寻。

def get_value(l, r, c):

return l[r][c]

def find(l, x):

m = len(l) - 1

n = len(l[0]) - 1

r = 0

c = n

while c >= 0 and r <= m:

value = get_value(l, r, c)

if value == x:

return True

elif value > x:

c = c - 1

elif value < x:

r = r + 1

return False

五、去除列表中的重复成分

用集合

list(set(l))

用字典

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

l2 = {}.fromkeys(l1).keys()

print l2

用字典并维持顺序

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

l2 = list(set(l1))

l2.sort(key=l1.index)

print l2

列表推导式

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

l2 = []

[l2.append(i) for i in l1 if not i in l2]

sorted排序何况用列表推导式.

l = ['b','c','d','b','c','a','a'] [single.append(i) for i in sorted(l) if i not in single] print single

七、链表成对交流

1->2->3->4转换成2->1->4->3.

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

# @param a ListNode

# @return a ListNode

def swapPairs(self, head):

if head != None and head.next != None:

next = head.next

head.next = self.swapPairs(next.next)

next.next = head

return next

return head

七、成立字典的不二等秘书籍

1 直接创设

dict = {'name':'earth', 'port':'80'}

2 工厂方法

items=[('name','earth'),('port','80')]

dict2=dict(items)

dict1=dict((['name','earth'],['port','80']))

3 fromkeys()方法

dict1={}.fromkeys(('x','y'),-1)

dict={'x':-1,'y':-1}

dict2={}.fromkeys(('x','y'))

dict2={'x':None, 'y':None}

八、归总八个静止列表

搜狐远程面试须要编制程序

尾递归

def _recursion_merge_sort2(l1, l2, tmp):

if len(l1) == 0 or len(l2) == 0:

tmp.extend(l1)

tmp.extend(l2)

return tmp

else:

if l1[0] < l2[0]:

tmp.append(l1[0])

del l1[0]

else:

tmp.append(l2[0])

del l2[0]

return _recursion_merge_sort2(l1, l2, tmp)

def recursion_merge_sort2(l1, l2):

return _recursion_merge_sort2(l1, l2, [])

循环算法

思路:

概念叁个新的空驶列车表

相比八个列表的第一个因素

小的就插入到新列表里

把早就插入新列表的因素从旧列表删除

以至五个旧列表有一个为空

再把旧列表加到新列表前面

def loop_merge_sort(l1, l2):

tmp = []

while len(l1) > 0 and len(l2) > 0:

if l1[0] < l2[0]:

tmp.append(l1[0])

del l1[0]

else:

tmp.append(l2[0])

del l2[0]

tmp.extend(l1)

tmp.extend(l2)

return tmp

pop弹出

a = [1,2,3,7]

b = [3,4,5]

def merge_sortedlist(a,b):

c = []

while a and b:

if a[0] >= b[0]:

c.append(b.pop(0))

else:

c.append(a.pop(0))

while a:

c.append(a.pop(0))

while b:

c.append(b.pop(0))

return c

print merge_sortedlist(a,b)

九、交叉链表求交点

实则动脑能够依据从尾起先比较七个链表,若是相交,则从尾起始必然风流倜傥致,只要从尾发轫相比,直至分裂等的地点即为交叉点,如图所示

必威 2

 

# 使用a,b七个list来模拟链表,能够看见交叉点是 7这些节点

a = [1,2,3,7,9,1,5]

b = [4,5,7,9,1,5]

for i in range(1,min(len(a),len(b))):

if i==1 and (a[-1] != b[-1]):

print "No"

break

else:

if a[-i] != b[-i]:

print "交叉节点:",a[-i+1]

break

else:

pass

其余风流倜傥种比较标准的法子,构造链表类

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

def node(l1, l2):

length1, lenth2 = 0, 0

# 求几个链表长度

while l1.next:

l1 = l1.next

length1 += 1

while l2.next:

l2 = l2.next

length2 += 1

# 长的链表先走

if length1 > lenth2:

for _ in range(length1 - length2):

l1 = l1.next

else:

for _ in range(length2 - length1):

l2 = l2.next

while l1 and l2:

if l1.next == l2.next:

return l1.next

else:

l1 = l1.next

l2 = l2.next

校勘了弹指间:

#coding:utf-8

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

def node(l1, l2):

length1, length2 = 0, 0

# 求五个链表长度

while l1.next:

l1 = l1.next#尾节点

length1 += 1

while l2.next:

l2 = l2.next#尾节点

length2 += 1

#倘诺相交

if l1.next == l2.next:

# 长的链表先走

if length1 > length2:

for _ in range(length1 - length2):

l1 = l1.next

return l1#归来交点

else:

for _ in range(length2 - length1):

l2 = l2.next

return l2#回去交点

# 假设不相交

else:

return

十、二分查找

#coding:utf-8

def binary_search(list,item):

low = 0

high = len(list)-1

while low<=high:

mid = (low+high)/2

guess = list[mid]

if guess>item:

high = mid-1

elif guess<item:

low = mid+1

else:

return mid

return None

mylist = [1,3,5,7,9]

print binary_search(mylist,3)

十一、快排

#coding:utf-8

def quicksort(list):

if len(list)<2:

return list

else:

midpivot = list[0]

lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]

biggerafterpivot = [i for i in list[1:] if i > midpivot]

finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)

return finallylist

print quicksort([2,4,6,7,1,2,5])

更加的多排序难题凸现:数据结构与算法-排序篇-Python描述

十四、找零难题

#coding:utf-8

#values是硬币的面值values = [ 25, 21, 10, 5, 1]

#valuesCounts 钱币对应的体全面

#money 搜索来的总钱数

#coinsUsed 对应于当下货币总的数量i所使用的硬币数目

def coinChange(values,valuesCounts,money,coinsUsed):

#遍历出从1到money全体的钱数恐怕

for cents in range(1,money+1):

minCoins = cents

#把具备的硬币面值遍历出来和钱数做比较

for kind in range(0,valuesCounts):

if (values[kind] <= cents):

temp = coinsUsed[cents - values[kind]] +1

if (temp < minCoins):

minCoins = temp

coinsUsed[cents] = minCoins

print ('面值:{0}的最少硬币使用数为:{1}'.format(cents, coinsUsed[cents]))

十八、广度遍历和纵深遍历二叉树

给定三个数组,塑造二叉树,况兼按档案的次序打字与印刷这一个二叉树

十七、二叉树节点

class Node(object):

def __init__(self, data, left=None, right=None):

self.data = data

self.left = left

self.right = right

tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))

十六、 档期的顺序遍历

def lookup(root):

row = [root]

while row:

print(row)

row = [kid for item in row for kid in (item.left, item.right) if kid]

十八、深度遍历

def deep(root):

if not root:

return

print root.data

deep(root.left)

deep(root.right)

if __name__ == '__main__':

lookup(tree)

deep(tree)

十一、 前中后序遍历

纵深遍历更动种种就OK了

#coding:utf-8

#二叉树的遍历

#粗略的二叉树节点类

class Node(object):

def __init__(self,value,left,right):

self.value = value

self.left = left

self.right = right

#中序遍历:遍历左子树,访谈当前节点,遍历右子树

def mid_travelsal(root):

if root.left is None:

mid_travelsal(root.left)

#访谈当前节点

print(root.value)

if root.right is not None:

mid_travelsal(root.right)

#前序遍历:访谈当前节点,遍历左子树,遍历右子树

def pre_travelsal(root):

print (root.value)

if root.left is not None:

pre_travelsal(root.left)

if root.right is not None:

pre_travelsal(root.right)

#世襲遍历:遍历左子树,遍历右子树,访谈当前节点

def post_trvelsal(root):

if root.left is not None:

post_trvelsal(root.left)

if root.right is not None:

post_trvelsal(root.right)

print (root.value)

十一、求最大树深

def maxDepth(root):

if not root:

return 0

return max(maxDepth(root.left), maxDepth(root.right)) + 1

十五、求两棵树是或不是同样

def isSameTree(p, q):

if p == None and q == None:

return True

elif p and q :

return p.val == q.val and isSameTree(p.left,q.left) and isSameTree(p.right,q.right)

else :

return False

七十、前序中序求后序

def rebuild(pre, center):

if not pre:

return

cur = Node(pre[0])

index = center.index(pre[0])

cur.left = rebuild(pre[1:index + 1], center[:index])

cur.right = rebuild(pre[index + 1:], center[index + 1:])

return cur

def deep(root):

if not root:

return

deep(root.left)

deep(root.right)

print root.data

七十风度翩翩、单链表逆置

class Node(object):

def __init__(self, data=None, next=None):

self.data = data

self.next = next

link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))

def rev(link):

pre = link

cur = link.next

pre.next = None

while cur:

tmp = cur.next

cur.next = pre

pre = cur

cur = tmp

return pre

root = rev(link)

while root:

print root.data

root = root.next

八十一、 八个字符串是或不是是变位词

class Anagram:

"""

@:param s1: The first string

@:param s2: The second string

@:return true or false

"""

def Solution1(s1,s2):

alist = list(s2)

pos1 = 0

stillOK = True

while pos1 < len(s1) and stillOK:

pos2 = 0

found = False

while pos2 < len(alist) and not found:

if s1[pos1] == alist[pos2]:

found = True

else:

pos2 = pos2 + 1

if found:

alist[pos2] = None

else:

stillOK = False

pos1 = pos1 + 1

return stillOK

print(Solution1('abcd','dcba'))

def Solution2(s1,s2):

alist1 = list(s1)

alist2 = list(s2)

alist1.sort()

alist2.sort()

pos = 0

matches = True

while pos < len(s1) and matches:

if alist1[pos] == alist2[pos]:

pos = pos + 1

else:

matches = False

return matches

print(Solution2('abcde','edcbg'))

def Solution3(s1,s2):

c1 = [0]*26

c2 = [0]*26

for i in range(len(s1)):

pos = ord(s1[i])-ord('a')

c1[pos] = c1[pos] + 1

for i in range(len(s2)):

pos = ord(s2[i])-ord('a')

c2[pos] = c2[pos] + 1

j = 0

stillOK = True

while j<26 and stillOK:

if c1[j] == c2[j]:

j = j + 1

else:

stillOK = False

return stillOK

print(Solution3('apple','pleap'))

七十一、动态规划难点

可参照:动态规划(DP)的整合治理-Python描述

 

面向切面编制程序AOP和装饰器

以此AOP风流倜傥听上去有个别懵,同学面Ali的时候就被问懵了…

  • 装饰器便是把其余函数当参数的函数。
    装饰器是二个很著名的设计形式,平常被用来有切面必要的景色,较为杰出的有插入日志、品质测量试验、事务处理等。装饰器是缓慢解决这类难点的绝佳设计,有了装饰器,大家就能够分离出大量函数中与函数成效自身非亲非故的相近代码并三番四遍起用。回顾的讲,装饰器的作用便是为已经存在的目的增加额外的职能。

这几个难点超级大,推荐: http://stackoverflow.com/questions/739654/how-can-i-make-a-chain-of-function-decorators-in-python

中文: http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/3/README.html

  • 看二个简约的例证
# 字体变粗装饰器
def makebold(fn):
    # 装饰器将返回新的函数
    def wrapper():
        # 在之前或者之后插入新的代码
        return "<b>" + fn() + "</b>"
    return wrapper

# 斜体装饰器

def makeitalic(fn):
# 装饰器将回来新的函数
def wrapper():
# 在前边如故今后插入新的代码
return "<i>" + fn() + "</i>"
return wrapper

@makebold
@makeitalic
def say():
return "hello"

print say()

7 创立字典的法子

TAG标签:
版权声明:本文由必威发布于必威-编程,转载请注明出处:通过id来看引用a的内存地址可以比较理解,Pyth