深信服Python面试题整理

[TOC]

1.网关的作用

网关(协议转换器;网间转换器)能够实现跨网络传输(跨网是指不同体系结构的网络或者不同协议之间网络)。
网关可以实现协议转化,路由选择,数据交换等网络兼容功能的设施。
不同协议网络/不同体系结构的网络不能通信的原因在于数据格式,语言,通信协议不同,因此需要一种翻译器进行翻译,网关就是起到这样的作用。
网关收到传输的信息后,会对信息重新打包,达到目的系统的需求。
什么是网关:一般来说LAN接口或者路由器的默认ip地址就是网关,它界定了域网与其他空间网路之间的界限。
在同一局域网内,网络地址相同,则不需要网关进行跨网转化。而对于不同的域网之间的通信,则需要网关

2.python正则表达式

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
27
28
29
30
31
32
33
34
35
36
#模块 re
re.match(pattern,string,flags)
#pattern :要匹配字符串的模式
#string: 被匹配的字符串‘
#flags: 控制匹配方式
#返回:一个匹配对象 否则None
#使用.group 获得匹配对象

re.(parttern,str,flags).group()/,group(1)
line = “Cats are smarter than dogs”
matchObj = re.match( r’(.) are (.?) .*’, line, re.M|re.I)
#r:表示非转义的原始字符

#第一个.表示匹配第一组除了换行符之外的字符
#第二个.?采用贪婪模式匹配第二组除了换行符之外的字符
#第三个 .*没有括号,和第一个的作用一样但是结果不计入匹配结果中。

re.search(parttern,str,flags)
扫描整个字符串并返回第一个成功的匹配
返回:第一个成功匹配字符的位置(元组)
re.match 与re.search的区别
re.match 只匹配字符串的开始位置,开始不符合则直接返回None
而re.search则是整个字符串匹配
re.sub(pattern,repl,string,count=0,flags=0)
repel :是用于替换的字符串,也可以是一个函数
count:模式匹配的最大次数
re.sub(r’\D’,’ ‘,string)
repel 是函数的情况:
def double(matched):
value = int(matched.group(“value”))
return str(value*2)
A = “A23G4HFD567”
print(re.sub(’(?p\d+)’,double,s)
re.compile():编译正则化表达式,生成正则对象,可被match() 和search()两个函数使用
pattern = re.compile(r’\d+’) 用于匹配至少一个数字
m = pattern.match(“23234ddnn”)[第一个字符为2匹配则返回,若不匹配则None]

3. A,B网站的访问速度

  1. 使用ping 命令:ping +URL:ping 命令检测目标网站是否联通,方法是向目标网站发送数据包,并返回数据包的平均送达时间和丢包率情况
  2. tracert:用于追踪从本地到目标网站服务器的过程中途径的一系列网络节点,和每个节点的访问速度,支持显示30个。

4.TCP和UDP的区别

  • 1.TCP 是面向连接的,UDP是面向无连接
    由于TCP有三次握手机制,因此也更容易产生安全问题。
    比如说在完成两次握手,接受端等待发送端的第三次握手确认信息时,没有收到确认信息的服务器会一直处于等待状态。大量虚假的ip 伪造请求攻击接受端,此时接受端接受请求后向虚假ip 发送报文信息并等待确认,由于是假ip 因此无法获得确认信息,服务器资源被浪费,甚至造成系统瘫痪。这就是Distributed Denial of Service (DDOS攻击;分布式拒绝服务:让目标服务器停止服务和资源访问 防御方法:过滤掉不必要的服务和端口;清洗异常流量)

  • 2.TCP 的首部为20字节,UDP的首部8字节

  • 3.TCP是可靠传输,数据按序到达无差错,不丢失,不重复;
    UDP 是不可靠的传输,只保证尽可能交付

  • 4.TCP是面向字节流的,将数据看为一串无结构的字节流,UDP数据以报文形式传输

  • 5.TCP连接是点对点,UDP是一对一,一对多,多对一,多对多。

  • 6.TCP 是全双工通信,UDP是不可信道。

————————————————
原文链接:https://blog.csdn.net/nana13628679472/article/details/108801753

正则表达式,写一个对ip地址的正则表达式

1
2
3
4
import re
ip ='192.168.1.1'
trueIp =re.search(r'(([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])\.){3}([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])',ip)
print(trueIp)

字符串操作:字符串的匹配问题 正则 ?

有个字符串数组,匹配一个子串是否在这个字符串里面,
比如abcddacabadsa,匹配abc是否在字符串中,而且中间可以有阻隔,
比如说afdbsdc中间有fd和sd阻隔但是也是存在abc的,
然后我就用下标索引的方法匹配,只需要O(n)的时间复杂度就可以.

字符串操作:文章中统计单词的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def word_count():
txt = '''To be successful in a job interview or in almost any interview situation, the applicants houlddemonstrate certain personal and professional qualities.
  Most likely, the first and often a lasting impression of a person is determined by the clotheshe wears. The job applicant should take care to appear well-groomed and modestly dressed, avoiding the extremes of too pompous or too casual attire .
  Besides care for personal appearance, he should pay close attention to his manner of speaking, which should be neither ostentatious nor familiar but rather straight forward, grammaticallyaccurate, and in a friendly way.
  In addition, he should be prepared to talk knowledgeably about the requirements of theposition, for which he is applying in relation to his own professional experience and interests.
  And finally, the really impressive applicant must convey a sense of self-confidence andenthusiasm for work, as these are factors all interviewers value highly.
  If the job seeker displays the above-mentioned characteristics, he, with a little luck, willcertainly succeed in the typical personnel interview.'''
  
for s in ',.\n ':
txt = txt.replace(s, ' ')

txt = txt.lower()
list = txt.split()
print(list)

count = dict()

for word in list:
count[word] = count.get(word, 0) + 1
print(count)

sort = sorted(count.items(), key=lambda item: item[1], reverse=True)
print(sort)

PYython排序算法有哪些

如果将一个特别长的一个数字进行逆序,应该怎么做.然后就这样过了第一次面试,

写字符串匹配的问题,
大数据中排序的问题
网络中tcp和udp的区别,
如果用户使用你的网站,有时候感觉到很卡,你认为会是什么样的问题
问了我贪婪算法,
————————————————

原文链接:https://blog.csdn.net/qq_40229995/article/details/101197918

1.extern 用法;

2.虚函数与纯虚函数的区别;

3.两个浮点数如何做比较;

4.结构体能直接使用memcmp比较吗;

5.Printf如何实现可变参的;

6.如果判断单链表是否有环;如何判断两个单链表是否相交,如果找到相交节点。

7.说说单链表和双向链表;

8.如何查找字串最大公共前缀;

9.如何把二叉树变成完全二叉树;

10.进程和线程的区别;

11.进程间通信方式,大概介绍一下;

12.TCP与UDP区别,说说TCP为什么可靠;

13.僵尸进程;

14.自旋锁和互斥锁;

15.会GDB调试吗?

16.内存泄漏你是怎么查找错误的;

2.说说你做的最好的项目(被问到你不会为止);

3.给你的项目增加了点难度(比如:你的uboot没有任何打印信息,uboot启动死掉了。串口还不让用,问你怎么解决)。

5.Malloc 如果申请了8M的内存实际只写了1字节,实际使用的内存。(当时已经懵了,但是后来知道有虚拟内存映射这回事)。

6.Open和fopen的区别,一直再问你问什么有open还需要fopen;

7.你觉得你还哪方面比较熟悉。(已经被怼到不行,但是还是硬着头皮说操作系统)把自己会的都说了然后结束。(不排除有压力面的因素)。

1.手写memcpy(内存重叠的问题);

2.手写快速排序;

3.问了些字符串出现异常错误的问题,具体忘记了

4.哈希碰撞如何解决;

————————————————

原文链接:https://blog.csdn.net/weixin_36431535/article/details/114020901

1·生成器和迭代器说说

2·线程和协程。怎么用的,这里问的很多,包括占用资源为啥线程比协程大等

3·闭包。衍生到装饰器

4·tcp 和udp,为啥3次握手,4次挥手等

5.随机报了个http端口号问是什么情况-

6·基本排序知道哪几种,时间复杂度,快排怎么实现

7.init __new__方法说说

1·链表就地逆置

2·项目说明,各个模块作用,你做的主要是什么

3·redis怎么搭建的?

————————————————

原文链接:https://blog.csdn.net/weixin_40039686/article/details/114707160

redis+消息队列怎么实现的,可以说下过程吗?

队列编号是怎么定义的?
redis+消息队列实现邮件怎么做的?
除此之外,还有什么地方用到redis?
redis宕机怎么处理?redis最大并发量?
redis+事务机制+乐观锁实现订单生成过程?除了乐观锁还知道什么锁?
(答:悲观锁),乐观锁和悲观锁的区别是什么?

事务+回滚怎么实现?版本号如何控制?
在创建订单时,如果此刻redis宕机,如何采用事务+回滚?具体实现?
MySQL事务了解吗?事务是如何执行的?

redis+消息队列怎么实现?你们就拿redis做了个这!!?你还知道redis的其它用法吗?
redis能做缓存,你知道还有什么能做缓存么?
OAuth2.0实现第三方授权登录,实现流程?

道题吧,有一个ip组,分别存有很多IP段,如何将一个IP插入这个组中?如果该ip组存在和这个待插入IP一样的IP,就不在插入,如果没有,将它插在合适位置,怎么实现?(我回答的是现将这个IP组放到一个set中,然后查找set中有没有待插入IP,如果找到,就不插入,如果没找到,就插入该IP,最后做排序即可)这个回答,他好像不满意。

————————————————

原文链接:https://blog.csdn.net/dai_wen/article/details/113746058

提问: 字符串拼接,说方法,以及每个方法的优缺点

1.直接通过(+)进行连接;

优缺点:
使用这种方式进行字符串连接的操作效率低下,因为python中使用 + 拼接两个字符串时会生成一个新的字符串,生成新的字符串就需要重新申请内存,当拼接字符串较多时自然会影响效率。

2.通过str.join()方法拼接

优缺点:
这种方式一般常使用在将集合转化为字符串,“join()”其中可以是空字符,也可以是任意其他的字符,当是其他字符时,集合中字符串会被该字符隔开。

3.通过str.format()方法拼接

优缺点:
通过这种方式拼接字符串需要注意的是字符串中{}的数量要和format方法参数数量一致,否则会报错。

4.通过(%)操作符拼接

优缺点:
这种方式与str.format()使用方式基本一致。

5.通过()多行拼接

优缺点:
python中遇到未闭合的小括号,自动将多行拼接为一行。

6.通过string模块中的Template对象拼接

优缺点:
Template的实现方式是首先通过Template初始化一个字符串。这些字符串中包含了一个个key。通过调用substitute或safe_subsititute,将key值与方法中传递过来的参数对应上。从而实现在指定的位置导入字符串。这种方式的好处是不需要担心参数不一致引发异常。

7.通过F_strings拼接

优缺点:
在python3.6.2版本中,PEP 498 提出一种新型字符串格式化机制,被称为“字符串插值”或者更常见的一种称呼是F-strings,F-strings提供了一种明确且方便的方式将python表达式嵌入到字符串中来进行格式化;

1
2
3
4
5
6
7
8
9
10
11
s1 = 'Hello'
s2 = 'World'
print (f'{s1}{s2}!')
输出结果:Hello World!

在F-strings中,我们也可以执行函数:
def power(x):
return x*x
x = 4
print (f'{x}*{x} = {power(x)}')
输出结果:4*4 = 16

优缺点:F-strings的运行速度很快,比%-string和str.format()这两种格式化方法都快很多。

正则表达式的反向引用

1
2
3
4
m = re.match(r'(?P<user>\w+)@(?P<website>\w+)\.(?P<extension>\w+)','myname@hackerrank.com')
m.groupdict()

#输出: {'website': 'hackerrank', 'user': 'myname', 'extension': 'com'}

写一个函数实现字符串的左移,要求不开辟额外空间

手写的继承,要求子类和父类有相同的属性,改变子类属性的同时改变父类的属性
有一个文件,这个文件只能被同时打开一个。也就是线程的单单例模式
爬虫怎么破解对方网站上的反爬虫。
比如对方网站上设有检测文件非正常读取的插件。

说说flask-sqlalchemy和pymysql的区别

python字符串常用操作

  • python字符串常用操作——首字母大写:capitslize()
  • python字符串常用操作——在一个字符串中计算特定字符的个数:count()
  • python字符串常用操作——让一个字符串在一行中以特定字符填充使居中:center(num,’-’)
  • python字符串常用操作——判断一个字符串是否以特定的字符结尾,并返回True或False:endswith()
  • python字符串常用操作——以列表形式寻找字符串中连续特定字符在字符串中的位置,返回所找字符串在列表的首字母的下标值:find()
  • python字符串常用操作——字符串格式化,为字符串中的变量赋值,填充字符串:format()
  • python字符串常用操作——判断一个字符串的格式,结果返回True或False:
  • 全是阿拉伯数字 isalnum() 方法
  • 全是英文字符 isalpha() 方法
  • 全是十进制数 isdecimal() 方法
  • 全是整数 isdigit() 方法
  • python字符串常用操作——以首字符首字母是否为大写判断字符串是否为文章标题,返回True()或False():istitle()方法
  • Python字符常用操作—–获取字符串输出流并按照特定字符拼接字符串:join() 方法
1
2
3
4
name = "my name is Echo "
print(’+’.join( [‘1’,‘2’,‘3’]) )
#输出
1+2+3

10、Python字符常用操作—–按照规定长度为字符串的左或右填充特定字符:ljust() 、

1
2
3
4
5
6
7
rjust()
name = "my name is Echo "
print( name.ljust(50,’*’) )
print( name.rjust(50,’-’) )
#输出
my name is Echo **********************************
----------------------------------my name is Echo

11、Python字符常用操作—–将字符输出为小写———lower()方法、大写——— upper()方法

1
2
print( ‘Echo’.lower() )
print( ‘Echo’.upper() )

12、Python字符常用操作—–字符串常用操作——
去掉左边的空格和回车:lstrip()方法
去掉右边的空格和回车:rstrip()方法、
去掉两边的空格和回车:strip()方法

1
2
3
print( ‘\nEcho’.lstrip() )
print( ‘Echo\n’.rstrip() )
print(’\nEcho\n’.strip() )
1
2
3
4
#输出
Echo
Echo
Echo

13、Python字符常用操作—–替换字符串的特定字符并指定替换次数:replace() 方法

1
2
3
print(‘Echo Echo li’.replace(‘E’,‘e’,2))
#输出
echo echo li

14、Python字符常用操作—–以特定字符切割字符串,并以列表的形式返回:split() 方法

1
2
3
print(‘1+2+3+4’.split(’+’))
#输出
[‘1’, ‘2’, ‘3’, ‘4’]

15、Python字符常用操作—–以换行符切割字符串:splitlines() 方法

1
2
3
print(‘1+2\n+3+4’.splitlines())
#输出
[‘1+2’, ‘+3+4’]

16、Python字符常用操作—–指定字符填充字符串以达到指定的长度和形式:zfill() 方法

1
2
3
print(‘Echo li’.zfill(50))
#输出
0000000000000000000000000000000000000000000Echo li

————————————————

原文链接:https://blog.csdn.net/qq_41891803/article/details/82787112

1python怎么样

3算法,跳台阶,斐波那契数列和dp方式都说了。

4tcp的四次挥手中的time—wait状态何时出现,有什么意义。

5操作系统的fork进程返回什么,应该是子进程号吧。

2为什么选这个岗位

3了解hadoop的哪些组件,全部说了一遍。

4讲一下hdfs的写入过程,发请求给namenode,返回一个地址进行写入,写入完告诉namenode,namenode完成副本备份。

5讲一下项目中的难点,多线程,并发工具,并发容器。

6讲一下如何设计一个高并发的秒杀系统

7python了解么,讲一下线程和协程

协程自带上下文,切换不需要刷新cpu上下文和寄存器。更适合并发。

协程和线程适用场景的区别。
转载于:https://www.cnblogs.com/nowcoder2018/p/9315995.html

Python基础加数据结构:两个数组合并去重,数组迭代删除异常,冒泡排序… ,然后是字符串比较(暗示kmp算法,写思路和next数组)

字典和列表的实现原理(哈希表,链表和数组)

链表和数组的区别

深浅拷贝

孤儿进程 僵尸进程

  • 孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作。

  • 僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或waitpid获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。

  

如何终止孤儿进程

如何终止进程(linux下kill-9 进程id) 为什么要-9

(kill pid) 、( kill -15 pid)
系统会发送一个SIGTERM的信号给对应的程序。当程序接收到该signal后,将会发生以下的事情

程序立刻停止
当程序释放相应资源后再停止
程序可能仍然继续运行
大部分程序接收到SIGTERM信号后,会先释放自己的资源,然后在停止。但是也有程序可以在接受到信号量后,做一些其他的事情,并且这些事情是可以配置的。如果程序正在等待IO,可能就不会立马做出相应。

也就是说,SIGTERM多半是会被阻塞的、忽略。

kill  -9 pid

你不是可以不响应 SIGTERM吗??那好,我给你下一道必杀令,我看你还不乖乖的。多半admin会用这个命令,用来强制尽快终止一个进程。

概率题:一分钟有车的概率为p,三分钟内有车的概率为?

B+树

B+树和平衡树的区别

平衡树的应用

OSI模型哪七层

TCP/UDP

TCP三次握手

python手写折半查找

mysql引擎
还问了mysql有什么印象深刻的吗?我回答了优化select语法树。

1.闭包

2.lambda

3.迭代器

4.修饰器

5.Python垃圾回收机制,让讲讲原理

6.udp应用场景

7.TCP关闭连接的时候,一般是4次握手,但很多情况下是三次握手,这是什么场景呢

8.算法题:两个链表,每个节点相加,相加结果如果不是一位数,就拆成多个节点

10.逻辑题:10个人分金币,每个人出一个方案,大于等于5个人赞同,则通过该方案,你是第一个人,你的方案是?

前五个人一人2个

python基础

深拷贝和浅拷贝

通常来讲不可变元素包含:
int,float,complex,long,str,unicode,tuple

is和==在操作整形数有什么区别

GIL是什么

答:在Python中GIL是Global Interpreter Lock,即全局解释锁的缩写,保证了同一时刻只有一个线程在一个CPU上执行字节码,无法将多个线程映射到多个CPU上。这是CPython解释器的缺陷,由于CPython是大部分环境下默认的Python执行环境,而很多库都是基于CPython编写的,因此很多人将GIL归结为Python的问题。

标准版本的Python并不能实现真正的多线程并发的直接原因。
简单来说就是,一个Python进程永远不能在同一时刻使用多个CPU核心。GIL被设计来保护线程安全,由于多线程共享变量,如果不能很好的进行线程同步,多线程非常容易将线程改乱。

线程与协程的区别

垃圾回收机制

list和tuple的区别

怎样修改tuple

数据结构

数组和链表的区别

说一下常见排序 哪个排序比较快 时间复杂度是多少

操作系统

3 进程通信

怎么使用共享内存

堆和栈的区别

怎么用堆 多次free会发生什么

网络

http状态码

http在哪一层

说一下五层网络协议

网际层有什么协议

tcp和udp的区别

看我简历写了django: django怎样做用户登录

2.说一下python中的数据结构。可变不可变?

3.知道GIL吗?为什么需要GIL呢?GIL为什么一次只允许解释执行1个线程呢?

4.知道多线程,多进程吗?介绍一下怎样创建多线程,多进程?请问与java的区别是?

5.tcp3次握手?第三次握手失败后会怎样?

6.数据结构都知道哪些?说一下平衡二叉树。怎么构建平衡二叉树呢?

7.看你的简历,你还会做web前端?

8.python装饰器知道吗?装饰器的原理是什么?本质是?闭包?

9.Mysql与MongoDB的区别是?

10.python中的socket?

11.hash算法知道吗?介绍一下你知道的hash算法。hash冲突知道吗?怎么解决hash冲突呢?

12.poll,select,epoll.

13linux指令知道哪些?(这个我说我学过一些,但是背不下来,看笔记的话能够使用)

14.操作系统了解吗?(我不是科班出身,所以这些不会,但是确实有计划要学习)

15.python的内存处理机制有哪些?分别介绍一下。

遇到的重大问题,怎么解决的?

python的深浅拷贝?

往1-100里面放1个重复的数字怎么快速找出来这个重复的

编程题: 报数出列,最后一个人是哪个?

linux信号

linux的进程通信(五种)

linux僵尸进程怎么解决

对分布式的理解(项目涉及)

打开浏览器输入一个网址,发生了啥子?(balabala讲一堆,到tcp三次握手的时候

二叉平衡树和数组的查询对比

数组和链表对比

野指针如何解决

c语言操作字符串的方法(回答了strcmp那些)

python的线程同步问题。(详细讲解了GIL的原理)

又问了进程在实际应用中如何通信的(由15问回答多进程替代多线程引申出来的)

问了如何测试程序运行时间(脱口而出print大法哈哈哈,还回答了用装饰器包装函数的效果比较好)

在一个很长的字符串中找出一个字符第一次出现的位置(回答了用正则表达式)

接着问正则表达式

二叉平衡树的查找时间复杂度

原文链接:https://blog.csdn.net/weixin_30925435/article/details/113519836

现在有一个日志表,表中存在n条日志,每条日志是一条字符串,该字符串仅包含小写。当字符串中顺序出现’s’、‘w’、’r’时,视为一次可能存在的攻击,请统计出总共有多少条攻击?

示例1:
输入
2
sawara
rws
输出
1
0
示例2:
输入
wsswrrw
sswwrr
输出
4
8
思路:
统计每个w之前所有的s和之后所有的r的数量。
题解:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
lines = int(input())
for line in range(lines):
log_txt = input()
dp_s = [0] * (len(log_txt) + 1)
dp_w = [0] * (len(log_txt) + 1)
dp_r = [0] * (len(log_txt) + 2)
count = 0
#dp = [0] * (len(log_txt))
for i in range(1, len(log_txt) + 1):
dp_s[i] = dp_s[i - 1]
if log_txt[i - 1] == 's':
dp_s[i] += 1
if log_txt[i - 1] == 'w':
dp_w[i] = 1
dp_r[len(log_txt) - i + 1] = dp_r[len(log_txt) - i + 2]
if log_txt[len(log_txt) - i] == 'r':
dp_r[len(log_txt) - i + 1] += 1
for i in range(1,len(log_txt) + 1):
if dp_w[i] == 1:
count += dp_r[i] * dp_s[i]
count = count % 1000000007
#print(count, dp_s, dp_w, dp_r)
print(count)

问题二:小强一次可以跳1级、2级、3级,但如果一次跳3级,那么往后k次都不能再跳3级,比如k = 10 ,那么一次跳3级台阶后,接下来的10次都不能再跳3级。

1
2
3
4
5
6
7
8
9
10
11
12
13
输入描述:
第一行一个正整数T(T <= 10),表示T个测试样例;对于每个测试样例,输入两个整数N(1 < N < 10000)、K(0 <= K <= 100)。
输出描述:
输出T行,每行一个总数,表示跳法的总数。
结果请对100007取值。
示例1
输入
2
3 0
6 1
输出
4
23

思路:去掉k次限制,就是很简单的爬楼梯问题,但这个k次限制,没有思路。大佬们有想法的话欢迎交流。
————————————————

原文链接:https://blog.csdn.net/AI414010/article/details/109149717

  1. 数据库CRUD操作/查询优化以及数据库知识量

  2. 框架的对比和了解/项目具体模块的业务逻辑描述

  3. 常见排序算法

  4. Linux系统的常用命令和Linux系统了解程度考核

  5. 项目部署用到的服务器的配置和了解程度

  6. 数据库基本功必须掌握但同时更重要的是理解为什么和是如何实现的,拓展自己知识面

  7. Linux系统的底层原理和了解程度

  8. 目前Golang在后端中也逐渐流行,有时间还是需要去掌握

  9. 技术没有终点,保持乐于学习和接受新技术的心态,面试官看重技术能力同时也更看重你的心态

Python相关

  1. 实现一个单例模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Singleton(object):
_instance_lock = threading.Lock()

def __init__(self):
pass

def __new__(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):

with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
Singleton._instance = object.__new__(cls)

return Singleton._instance

  1. 实现一个装饰器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 使用装饰器
def Singleton(cls):
_instance = {}

def _singleton(*args, **kwargs):
_instance[cls] = cls(*args, **kwargs)
return _instance[cls]

return _singleton

@Singleton
class A(object):
a = 1
def __init__(self):
pass

  1. 用Python实现快排
  2. 如果系统中需要很多个Python版本,如何进行Python版本的管理
  3. 如何实现一个全局变量?(除了global,还可以通过单例模式)

数据库相关

  1. 数据库的数据是实时更新的吗?每点击一次,数据库数据修改一次?
  2. Redis hash的个数
  3. 如何修改Redis数据库的库的个数?
  4. Redis数据库如何实现持久化
  5. Redis数据库支持的数据类型
  6. Redis使用AOF方式持久化,aof文件不断增大,如何处理?
  7. Redis数据库如何设置密码
  8. hash表是如何生成的
  9. MySQL数据库如何使用sql语句插入一条数据
  10. MySQL数据库的慢查询有了解过吗
  11. MySQL数据库如何进行查询优化
  12. 如何很多请求同时对Redis的同一个键进行访问,如何保证数据安全
  13. 说说Redis的淘汰机制
  14. 我的MySQL数据库每天晚上12点进行全备份。第二天有员工在9点钟误删除了一个数据库,但在10点钟才被发现。问如何进行恢复被误删除的数据库并同时保留9点到10点钟新增的数据同时不影响业务的正常运行?
  15. 当数据越来越多,如何避免hash槽中key出现相同的情况?
  16. MongoDB在哪些场合使用过?

    项目部署相关

  17. 大家都说Nginx快?快的原因是什么?
  18. 对RPC了解吗?
  19. 如何在服务器上设置业务进程数?
  20. 说说正向代理和反向代理

    Linux相关

  21. 如何查看剩余内存
  22. 如何查看端口是否被占用
  23. 如何查看一个程序的PID以及它的所有子进程
  24. 如何为一个目录下的所有文件添加权限
  25. 如果你对一个目录具有写权限,那么你是否具有对这个目录下的所有文件具有删除权限?
  26. 对Linux多路复用的理解
  27. 修改IP地址的方法

前端相关

  1. 对前端HTML CSS 和 JS了解多少?熟悉吗?
  2. 对React和bootstrap了解吗?
  3. 如何进行http优化?(响应头设置Content-Encoding: gzip)

网络编程相关

1.说一下实现TCP建立连接的过程以及当时进入了什么状态?为什么建立连接只需要3次,断开连接需要4次?为什么断开连接时第二次和第三次要分开,不能合在一起吗?

项目相关

  1. 说一下一个请求过来到返回response的过程
  2. 如何实现单点登录
  3. JWT token是如何进行生成和校验的
  4. 了解过哪些后端框架?Tornado了解吗?
  5. 了解过webapp2吗
  6. Django如何实现csrf攻击保护
  7. 说说你项目中遇到的困难以及如何解决
  8. 说说你认为自己最有成就感或最深刻的项目
  9. 对KAFKA了解吗?用过哪些消息队列?使用过RabbitMQ吗?
  10. 项目团队几个人?开发多长时间?

    版本控制相关

  11. 如何从远程仓库拉取分支到本地
  12. 如何进行版本回退

1. Celery的原理和应用场景

2. Elasticsearch 的原理

3. 平时是如何学习的?有关注哪些技术?

4. Docker的了解,常用命令,如何暴露端口

5. 对ERP了解吗?Odoo了解吗?

问的包括计算机网络、数据结构、python魔法方法tcp/ip、python装饰器等,填空题涉及操作系统(线程进程)

编程题第一个签到题:判断一个数是否能被2,5,7整除,三个while搞定 (100%)

第二个消消乐,给定字符串context和爆炸数bolm,两个连续相同字符的可以消除,如果消除的文字是爆炸数,可以额外消掉左边右边各一个字符,返回最后剩余字符。(这个一开始看错题了,最后只通过了80%)

谈谈对python中包的了解,用过哪些包(把常用的time、datetime、json、request、os、re…都说了)

谈谈python的import,pyc是什么,具体怎么实现的

哈希表,哈希冲突如何处理

GIL锁,Cpython

谈谈对进程、线程、协程的了解,(信号量,进程池、线程池,最后谈到了aiohttp与asyncio)

算法题:求一篇论文中最频繁出现的10个单词(我答的是用字典存储,再用通过sorted以dict.values排序,面试官不是很满意,正确答案是小顶堆)

插排、快排、选排、冒泡的时间复杂度与优缺点

智力题:烧绳子。N多跟绳子,每一根燃烧的时间都是1小时,如何计算1小时15分钟(面试官点了一下,然后飞快写出来了,感觉挺满意的)

一上来先给了个编程题,求字符串最大回文,然后就关视频去忙去了

GIL锁,
什么时候用多线程、什么时候用多进程、协程是干嘛的
多线程适合io操作密集型的任务(如socket server ,网络并发请求);
多进程适合cpu密集操作型的任务,主要使用cpu来计算,如大量的数学计算。

I/O多路复用,select epoll,poll的区别
python内存管理,
python内存泄露如何处理

网站测试数据的来源,追问:能否获取一些加密数据
答:会简单的逆向分析,
继续追问:为啥不能获取付费的XX   
答:没有什么参考案例,技术也不太行(感觉再说下去我要直接变网安工程师了)
————————————————

原文链接:https://blog.csdn.net/Swing0_0/article/details/109231696

2.数据结构基础

(1)请简述数组与链表的区别链表是一种上一个元素的引用指向下一个元素的存储结构,链表通过指针来连接元素与元素;

链表是线性表的一种,所谓的线性表包含顺序线性表和链表,顺序线性表是用数组实现的,在内存中有顺序排列,通过改变数组大小实现。而链表不是用顺序实现的,用指针实现,在内存中不连续。意思就是说,链表就是将一系列不连续的内存联系起来,将那种碎片内存进行合理的利用,解决空间的问题。
所以,链表允许插入和删除表上任意位置上的节点,但是不允许随即存取。链表有很多种不同的类型:单向链表、双向链表及循环链表。
单向链表包含两个域,一个信息域,一个指针域。单向链表的节点有两部分组成,一部分保存节点本身的信息(信息域),另一部分保存下一个节点的地址(指针域),最后一个节点的指针域为空。
双向链表,每个节点的指针域包含两个指针 ,分别保存当前指针的前一个节点地址和后一个节点地址。
循环链表,末尾节点的指针域的指针指向首节点。

数组与链表的区别:

链表是链式存储结构,数组是顺序存储结构。
链表通过指针来连接元素与元素,数组则是把所有元素按次序依次存储。
链表的插入删除元素相对数组较为简单,不需要移动元素,且较为容易实现长度扩充,但是寻找某个元素较为困难;
数组寻找某个元素较为简单,但插入与删除比较复杂,由于最大长度需要在编程一开始时指定,故当达到最大长度时,扩充长度不如链表方便。
相同:两种结构均可实现数据的顺序存储,构造出来的模型呈线性结构。

(2)将两个有序链表合并为一个新的有序链表

解答:设两个有序链表为A和B,若A为空链表则返回B,若B为空链表,则返回A。
新链表头节点为headC,初始为空,给定指针变量r始终指向新链表的末尾节点。
第一步,找到A和B中较小的节点,将其值给headC,将已被取出的列表的指针下移到指向下一个节点,如此遍历完两个链表。
实际算法题:
给定长度为n的数组,找出其中出现次数大于等于n/2的元素,并分析所用方法的时间复杂度。(假设改元素 一定存在)leetcode原题
如不考虑任何因素,单纯通过python实现,你会如何实现?(面试官解释通过列表的count方法)

给定一个列表,列表中的元素是二元组,该二元组的含义是ip段,形如(“223.98.208.0”, “223.98.223.255”),ip段之间不相交。

问:给定ip,如何快速定位所属ip段?
答:将ip转换为数字,对列表按左端点排序之后,使用二分查找进行定位。
既然了解将ip转换为数字,是否了解网络字节序与主机字节序的区别。

网络知识:

描述tcp三次握手的过程。

是否了解io多路复用?select与epoll()区别?

python语言考察

如何定义一个类,使得该类支持with语法?

如何在python类中定义私有变量?

  1. python是不含有private关键字的,因此在定义私有变量时,只需要在变量的前面加上双横杠。
  2. 虽然加上get,set函数后,可以设置和访问私有属性,但使用起来不是很方便,能否像c#里的语法糖那样方便的对私有属性进行访问呢?当然可以,借助property即可。

python中单下划线与双下划线的区别?

python中线程的缺陷是什么?

python支持协程,请简要描述协程以及应用。

是否了解pep8,请描述一下。

————————————————

原文链接:https://blog.csdn.net/qq_36562999/article/details/106044515

题目大意为  给定一个字符串列表,请输出其字符串元素中第n长字符串的长度,若没有第n长,则返回最长字符串元素的长度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def num_of_car(lyst, n):
dic = {}
for i in lyst:
dic[len(i)] = i
new_dic = dict(sorted(dic.items(),key=lambda dic:dic[0],reverse=False)) # 字典按键值从小到大排序
# print(new_dic)
if n > len(dic):
return len(dic[max(dic)])
else:
return len(new_dic[list(new_dic.keys())[::-1][n - 1]])
def main():
lyst = ['abcd', 'ab', 'ab']
n = 2
length = num_of_car(lyst, n)
print(length)
if __name__ == '__main__':
main()

————————————————

原文链接:https://blog.csdn.net/jerryz2017/article/details/101000968

2 sizeof(类) 大小 包含虚函数时呢? 两个虚函数时呢?每个对象都有一个虚函数指针吗? 每个对象都有一个虚函数吗?

3 多态 : 面试官描述, 让你判断会不会形成多态

4 问我什么是纯虚函数?纯虚函数的作用,具有纯虚函数的类能实例化出对象吗? 为什么?

5问我什么是接口? 我扯的多了,扯到接口继承,和实现继承了。

6 容器? 都知道哪些容器?平时都用哪些容器? 怎么用?(序列式+ 关联式bulabula)

7 模拟实现STL reverse算法(简单哦)

8 问我 map, 怎么遍历map?

我说:借助迭代器,问我怎么定义迭代器?
我说 :可以借助C++11提供的auto 关键字来接收,auto 关键字会让编译器自己推导迭代器类型, 代替了我们一长串类型的定义
9 情景模拟: 一篇英文文章(文件):问我将来想知道文章中所有单词出现的频率, 问我怎么做?
答 : 选用数据结构 unordered_map<string, int> + 文件指针 +boost库中 boost::splite()函数进行使用,
问我: 选哪个文件流? open ? fopen? sstrean?
我选的fopen()
问我 fopen()的参数是什么? 我说 文件的path 和 打开的方式 。 因为只读,所以选取 ‘r’ 的方式 又问我为什么选 r ?
我说因为已知是英语文章, 所以字符将来都是ASIIC表中的, 所以不会出现 unicode/UTF-8 所以不必用 rb方式 当然 用rb方式 也没错
问我 r 跟 rb方式的底层实现有什么区别?
我说具体不清楚,但我觉得应该是分两方面:
一:ASIIC部分不做处理
二:非ASICC的unicode 编码 应该是安源码情况进行编译。
问我: 假如不选取rb方式: 会不会出什么错?
我说: 如果出现了非ASIIC字符,那么到时候可能会出错的。
问我 怎么读取文件?读多长?怎么处理?
fgets() 读一行 ,先进行处理 处理采用splite 函数进行切割,将切割的结果保存在一个容器里,一般情况下,单词之间应该是以空格进行分割的
他又说:一篇文章肯定不会只有一个空格切分啊,我一个空格的话就模糊了吧。
(汗,其实我忘了splite是不是可以定义一组字符方式,我记得好像可以 ), 我就直说说,我记得splite函数好像是可以定义一组划分方式的,用的时候我可以直接man一下确定下。

10 为什么选用 unordered_map(他一直说ordered_map 我纠正了两次unordered_map ,他还是ordered 汗,懒得纠正 )

我就说 因为是一篇文件 ,所以说数据量可能很大,选用 unordered_map可以快速查询到相应单词是否出现,时间复杂度为O(1), 代价是底层维护一段比较大的内存空间. (string作为key其实底层通过 哈希函数进行处理过后才存储的)

————————————————

原文链接:https://blog.csdn.net/weixin_44030580/article/details/106590990

shell编程,数据库三范式

b 设计模式,工厂,单例
c 数据库事务的四个特性
d 数据库事务的一致性怎么实现,乐观锁,悲观锁
f 乐观锁的具体实现
g mysql数据表特别大的时候,怎么优化
h mysql数据库使用的引擎

一般会面式2个项目
面试:python自动化运维,

问细节
a python连mysql用的是什么模块
b redis 怎么连接的
c mysql用的什么版本
d linux常用的指令 查内存指令,指定端口的命令
f git指令
g githup印象最深的项目

直接面试:
a 介绍项目
b 多线程,多进程区别
c 项目中用到的异步,我答的是celery
d celery 的工作机制
f 异步中的互斥锁
g 解释互斥锁的死锁

最后直接给了一道题,当面做
需求:提供两个列表,一个是ip,一个是对应的权重值
要求随机返回一个ip,返回的ip机率要根据权重值
做完之后直接喊hr过来谈,要的13k,hr砍到11k,第二天就
发offer,效率很高,但是是驻外地,所以放弃

面试:
b python相对于其他语言得优势
c 变量的生命周期
d 线程得生命周期
f 变量作用域及调用优先级
g 引入得模块和内置模块及自己写得模块,调用的优先级
h 匿名函数,优点,平时怎么用的 我答的是map函数中用到
i map函数 第一个参数有什么限制 给自己挖坑了。。
j with 上下文管理 为什么不用关,内部怎么实现,优势是什么
k redis 内部运行机制 用redis实现异步队列
l 单例不用new方法怎么实现,说出四种 。。。
n 数据库的锁

————————————————

原文链接:https://blog.csdn.net/weixin_43094478/article/details/82289499

深拷贝与浅拷贝

浅拷贝:只是对另外一个变量的内存地址的拷贝,这两个变量指向同一个内存地址的变量值。
深拷贝: 一个变量对另外一个变量的值拷贝。 所以当一个变量改变时候,另一个对象也会改变。

Python中的数据结构

列表list
列表中的每个元素都可变的,意味着可以对每个元素进行修改和删除;
列表是有序的,每个元素的位置是确定的,可以用索引去访问每个元素
元组tuple
Tuple一经初始化,就不能修改,没有List中的append(), insert(), pop()等修改的方法,只能对元素进行查询
字典dict
字典中的数据必须以键值对的形式出现。 key 必须是可哈希的值。其插入和删除的时间复杂度为O(1)。
集合set
集合中每个元素都是无序的、不重复的任意对象。

Python中线程与协程

进程是OS进行资源分配和调度的独立单位;
线程是进程的实体,是CPU调度和分派的基本单位;
协程也是线程,称微线程,自带CPU上下文,是比线程更小的执行单元;
线程执行开销小,但不利于资源的管理和保护;而进程正相反
get和post的区别
GET参数通过URL传递,POST放在Request body中。
Python垃圾回收
Python垃圾回收主要以引用计数为主,分代回收为辅

当你在浏览器地址栏输入一个URL后回车,将会发生的事情?

浏览器向DNS服务器查找输入URL对应的IP地址。
DNS服务器返回网站的IP地址。
浏览器根据IP地址与目标web服务器在80端口上建立TCP连接
浏览器获取请求页面的html代码。
浏览器在显示窗口内渲染HTML。
窗口关闭时,浏览器终止与服务器的连接。

is和==的区别

1
2
is和==都是对对象进行比较判断作用的
is 判断id是否相同,==是判断值

————————————————
版权声明:本文为CSDN博主「wfanyue」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

原文链接:https://blog.csdn.net/wfy_1999/article/details/106865722

1、Linux的进程通信方式

管道、信号量、消息队列、信号、共享内存、套接字
参考:https://www.cnblogs.com/liugh-wait/p/8533003.html

2、红黑树

R-B Tree,全称是Red-Black Tree,又称为“红黑树”,它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色,可以是红(Red)或黑(Black)。
每个节点或者是黑色,或者是红色。
根节点是黑色。
每个叶子节点(NIL)是黑色。
如果一个节点是红色的,则它的子节点必须是黑色的。
从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
红黑树的时间复杂度为: O(lgn)。
红黑树一种特殊的二叉查找树。
红黑树是相对是接近平衡的二叉树。
完全二叉树、满二叉树。
参考:https://www.cnblogs.com/xuxinstyle/p/9556998.html

3、HTTP状态码(403)

403 Forbidden是HTTP协议中的一个状态码(Status Code)。可以简单的理解为没有权限访问此站。
参考:https://www.sohu.com/a/162171065_763273

4、压栈

先进后出。

5、给出先序和中序,写出后续

先序确定根中序分左右。

6、阻塞、就绪、异常、运行、退出、僵尸、不可中断、孤儿、死亡进程。

  • 孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。
  • 僵尸进程:一个子进程在其父进程还没有调用wait()或waitpid()的情况下退出。这个子进程就是僵尸进程。
  • 不可中断状态:为了保证进程数据与硬件状态一致,并且正常情况下,不可中断状态在很短时间内就会结束。
  • 阻塞状态:正在执行的进程,由于等待某个事件发生而无法执行时,便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种,例如,等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。
  • 就绪状态:当进程已分配到除CPU以外的所有必要的资源,只要获得处理机便可立即执行,这时的进程状态称为就绪状态。
  • 执行状态:当进程已获得处理机,其程序正在处理机上执行,此时的进程状态称为执行状态。

7、列表推导式、filter() 、zip()。

1
2
3
4
5
#列表推导式
array1 = [x for x in range(6) if x % 2 == 0]
print(array1)

[0, 2, 4]

filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

1
2
3
# filter(function, iterable)
# function -- 判断函数。
# iterable -- 可迭代对象。
1
2
3
4
5
6
def is_odd(n):
return n % 2 == 1
array3 = list(filter(is_odd, array2))
print(array3)

[1, 3, 5]

参考:https://www.runoob.com/python/python-func-filter.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#
#zip()函数
#函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。

#如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

a = [1, 2, 3]
b = {4, 5, 6}
zipped = list(zip(a, b))
print(zipped)
up_zip = list(zip(*zipped))
print(up_zip)

[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]

参考:https://www.runoob.com/python/python-func-zip.html

8、__init__和__new__的区别?

用法不同:new()在__init__()在之前被调用,用于创建实例,是类级别的方法,是静态方法。init()在创建实例后调用,用于初始化实例,是实例级别的方法,用于设置对象属性的一些初始值。
传入参数不同:new()至少有一个参数cls,init()至少有一个参数self。
返回值不同:new()必须有返回值,返回实例对象。init()不需要返回值。
作用不同:__new__是用来创造一个类的实例,__init__是用来初始化实例的。

编程题1:有随机数m,一桌有n个程序员,从0号程序员开始报数,到第m-1个程序员唱歌。然后从第m个程序员继续报数,直到只剩一个程序员时,输出程序员的编号。

解题思路:循环队列

编程题2:给定字符串context和爆炸数bolm,两个连续相同字符的可以消除,如果消除的文字是爆炸数,可以额外消掉左边右边各一个字符,返回最后剩余字符。

解题思路:字符串对比及切片拼接。
技术一面
正则表达式(纯汉字)

1
2
3
4
5
 #用 '[\u4e00-\u9fa5]‘ 匹配中文
import re
s = input()
answer = re.findall(r'[\u4e00-\u9fa5]', s)
print(answer)

参考:https://www.jb51.net/article/187420.htm

Python的垃圾回收机制

Python垃圾回收主要以引用计数为主,分代回收为辅。
引用计数器**+1**
对象被创建  a=14
对象被引用  b=a
对象被作为参数,传到函数中   func(a)
对象作为一个元素,存储在容器中   List={a,”a”,”b”,2}
引用计数器**-1**
当该对象的别名被显式销毁时  del a
当该对象的引别名被赋予新的对象   a=26
一个对象离开它的作用域,例如 func函数执行完毕时,函数里面的局部变量的引用计数器就会减一(但是全局变量不会)
将该元素从容器中删除时,或者容器被销毁时。
当指向该对象的内存的引用计数器为0的时候,该内存将会被Python虚拟机销毁

参考:https://blog.csdn.net/xiongchengluo1129/article/details/80462651

Python装饰器

1
2
3
4
5
6
7
8
9
10
11
12
# 装饰器
def fun(func):
def wrapper():
print("Hello", end=" ")
func()
return func
return wrapper

@fun
def hello_world():
print("World")
hello_world()

参考:https://www.cnblogs.com/lianyingteng/p/7743876.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 带参数的装饰器
def outer(out_args):
def middle(func):
def wrapper(*args, **kwargs):
print(out_args)
wrapper_result = func(*args, **kwargs)
print(wrapper_result)
return wrapper_result
return wrapper
return middle
@outer("hello")
def foo(a, b):
return a + b
foo(2, 3)

参考:https://blog.csdn.net/e15273/article/details/78617498

python内置的数据结构

列表、元组、字符串、集合、字典、数字

字符串间隔逆序输出z

1
2
a = "123456789"
print(a[::-2])
1
2
3
4
5
6
# 字典输出所有的值
dict1 = {"Beijing": 1, "Nanjing": 2, "Dongjing": 3}
# 打印所有的键
print(dict1.keys())
# 打印所有的值
print(dict1.values())
  • str(a)和print(a)的区别
  • str():用于将对象转化为适于人阅读的字符串的形式;
  • repr():用于将对象转化为可供解释器读取的字符串形式;
  • print():将对象打印并输出,省去引号;

python最吸引你的地方

  • 语法优美
  • 丰富强大的库
  • 开发效率高

wsgi,写一个符合wsgi的接口

1
2
3
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return '<h1>Hello, web!</h1>'

上面的application()函数就是符合WSGI标准的一个HTTP处理函数,它接收两个参数:
environ:一个包含所有HTTP请求信息的dict对象;
start_response:一个发送HTTP响应的函数。
参考:https://www.liaoxuefeng.com/wiki/897692888725344/923057027806560

python容器有哪些

  • 字符串容器
  • 列表容器
  • 元组容器
  • 字典容器

http状态码
类别 原因
1XX Informational(信息性状态码) 接收的请求正在处理
2XX Success(成功状态码) 请求正常处理完毕
3XX Redirection(重定向状态码) 需要进行附加操作以完成请求
4XX Client Error(客户端错误) 服务器无法处理请求
5XX Server Error(服务端错误) 服务器处理请求出错
2XX成功

参考:https://blog.csdn.net/hualf/article/details/78989618
————————————————

原文链接:https://blog.csdn.net/qq_29537269/article/details/108801488

————————————————

原文链接:https://blog.csdn.net/weixin_39829166/article/details/111425372

自我介绍(包含工作中参与的项目,主要负责模块(我介绍的是参与度比较高的Web端网站项目)

工程师推荐的书籍和资料:

  • Python核心编程(第2版)
  • Python源代码

最后推荐一下我看的书:
python入门:网易云课堂、python高效开发实战(还有一些杂牌书)
python进阶:流畅的python、python网络编程、python核心编程
框架:官网 Django 1.8手册、B站黑马程序员、git上各路神仙的源码
网络:图解HTTP、计算机网络、网络协议分析
操作系统:学校教材
mysql:mysql深入浅出、mysql必知必会
redis: redis设计与实现
前端:锋利的Jquery 、 JavaScript DOM编程艺术、Head First HTML与CSS