Some Interview Questions About Python
一大波超链接即将袭来
Django认证流程
Python实现阶乘
Python文件处理
Python统计日志文件IP出现次数
JSON数据解析
JSON数据解析2
买卖股票的最佳时期
读取一个大文件比如500M，计算出每一个字的频率，分别把前十频率的求出来。
def str_count(filename):
f = open(filename,'r',encoding='utf-8')
dic = {}
while True:
line = f.readline()
if line:
for s in line:
if s in dic:
dic[s]+=1
else:
dic[s]=1
else:
break
result = sorted(dic.items(), key=lambda k: k[1], reverse=True)
print(dic)
print(result)
str_count(r'C:\Users\Administrator\Desktop\text.txt')
----------------------英文单词频率
def word_count(filename):
f = open(filename,'r')
dic = {}
while True:
line = f.readline()
if line:
line = line.replace(',','')
line = line.replace('.','')
line = line.replace('!','')
line = line.replace(';','')
line = line.replace('-','')
str_list = line.split()
for s in str_list:
if s.lower() in dic:
dic[s.lower()]+=1
else:
dic[s.lower()] = 1
else:
break
result = sorted(dic.items(), key=lambda k: k[1], reverse=True)
print(result)
word_count(r'C:\Users\Administrator\Desktop\abc'
r'.txt')
线程之间如何进行通信？
1、通过queue(队列)，基于queue共享数据，使用 put() 和 get() 操作来向队列中添加或者删除元素，实现线程之间的通信。
2、可以自己通过创建自己的数据结构(例如一个列表)来实现线程间通信，
如：threading.Condition()的notify方法，以及通过threading.Event对象
3、基于生产者、消费者实现线程之间的通信
三次登录
count = 0 #计数器
username = "aaa" #登录用户名
userpassword = "asd" #登录密码
f = open("aaa.txt","r")
file_list = f.readlines()
f.close()
lock= []
name = input("登录用户名：")
for i in file_list:1
line = i.strip("\n")
lock.append(line)
if name in lock:
print("你的账户已锁定，请联系管理员。")
else:
if name == username:
#如果密码连续输错了三次，锁定账号
while count <3:
password = input("登录密码：")
if name == username and password == userpassword:
print("欢迎%s!"%name)
break
else:
print("账号和密码不匹配")
count +=1
else:
print("对不起，您的账号连续输错三次密码已被锁定，请联系管理员。")
f = open("aaa.txt","w+")
li = ['%s'%username]
f.writelines(li)
f.close()
else:
print("用户名不存在，请输入正确的用户名。")
计算N天后的日期
import datetime
def get_day(y,m,d,n):
the_date =datetime.datetime(y,m,d)
result_date = the_date + datetime.timedelta(days=n)
d = result_date.strftime("%Y-%m-%d")
return d
print(get_day(2018,3,25,1))
计算给定日期是该年的第多少天
def count(year, month, day):
count = 0
# 判断该年是平年还是闰年
if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
print('%d年是闰年，2月份有29天！' % year)
li1 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
for i in range(month - 1):
count += li1[i]
return count + day
else:
print('%d年是平年，2月份有29天！' % year)
li2 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
for i in range(month - 1):
count += li2[i]
return count + day
if __name__ == "__main__":
year = int(input('请输入年份：'))
month = int(input('请输入月份：'))
day = int(input('请输入日期：'))
count = count(year, month, day)
print('%d年%d月%d日是今年的第%d天！' % (year, month, day, count))
循环和递归实现二分查找
while 循环实现二分查找
def bin_search(data_list, val):
low = 0 # 最小数下标
high = len(data_list) - 1 # 最大数下标
while low <= high:
mid = (low + high) // 2 # 中间数下标
if data_list[mid] == val: # 如果中间数下标等于val, 返回
return mid
elif data_list[mid] > val: # 如果val在中间数左边, 移动high下标
high = mid - 1
else: # 如果val在中间数右边, 移动low下标
low = mid + 1
return # val不存在, 返回None
ret = bin_search(list(range(1, 100)), 66)
print(ret)
递归实现二分查找
def bin_search(li, val, low, high):
if low <= high:
mid = (low + high) // 2
if li[mid] == val:
return mid
elif li[mid] > val:
return bin_search(li, val, low, mid - 1)
else:
return bin_search(li, val, mid + 1, high)
else:
return
li = list(range(1000))
ret = bin_search(li, 555, 0, len(li) - 1)
print(ret)
Python上下文管理器（Context Manager）
当我们需要创建一个上下文管理器类型的时候，就需要实现__enter__和__exit__方法，这对方法就称为上下文管理协议（Context Manager Protocol），定义了一种运行时上下文环境。
在Python中，可以通过with语句来方便的使用上下文管理器，with语句可以在代码块运行前进入一个运行时上下文（执行__enter__方法），并在代码块结束后退出该上下文（执行__exit__方法）。
http://python.jobbole.com/82289/
括号匹配问题,把list维护成一个栈
SYMBOLS = {'}':'{', ']':'[', ')':'('}
SYMBOLS_L, SYMBOLS_R = SYMBOLS.values(), SYMBOLS.keys()
def check(s):
arr = []
for c in s:
if c in SYMBOLS_L:
# 左符号入栈
arr.append(c)
elif c in SYMBOLS_R:
# 右符号要么出栈，要么匹配失败
if arr and arr[-1] == SYMBOLS[c]:
arr.pop()
else:
return False
return not arr
print(check("3 * {3 +[(2 -3) * (4+5)]}"))
print(check("3 * {3+ [4 - 6}]"))
常用正则表达式
邮箱
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
手机号
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
IP地址
\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b
生成器相关习题
1.生成器函数：
def demo():
for i in range(4):
yield i
g=demo() # 生成器
g1=(i for i in g) #生成器
g2=(i for i in g1) #g2 生成器
print(list(g1)) #[0,1,2,3]
print(list(g2)) #[]
2.计算生成器函数返回值
def add(n,i):
return n+i
def test():
for i in range(4):
yield i
g=test()
for n in [1,10]:
g=(add(n,i) for i in g)
print(list(g)) #[20, 21, 22, 23]
生产者消费者模型
程序中有两类角色：一类负责生产数据（生产者），一类负责处理数据（消费者）；引入生产者消费者模型为了解决的问题是：平衡生产者与消费者之间的工作能力，从而提高程序整体处理数据的速度；如何实现：生产者<-->队列<——>消费者；生产者消费者模型实现类程序的解耦和。
如何防止sql注入
sql注入：在sql语句中，如果存在'--'字符，则执行sql语句时会注释掉--字符后面的内容。凡有SQL注入漏洞的程序，
都是因为程序要接受来自客户端用户输入的变量或URL传递的参数，并且这个变量或参数是组成SQL语句的一部分。放置方式有：
1、使用预编译绑定变量的SQL语句 如execute()
2.严格加密处理用户的机密信息
3.不要随意开启生产环境中Webserver的错误显示
4.使用正则表达式过滤传入的参数
5.字符串过滤
6.检查是否包函非法字符
连表操作的区别
1、交叉连接：不使用任何匹配条件生成笛卡尔积
select * from employee,department
2、内连接：只连接匹配的行
selcet employee.name,employee.age,department.name from employee inner join department on employee.dep_id = department.id
3、外连接之左连接：优先显示左表全部内容
selcet employee.name,employee.age,department.name from employee left join department on employee.dep_id = department.id
4、外连接之右连接：优先显示右表全部内容
selcet employee.name,employee.age,department.name from employee right join department on employee.dep_id = department.id
5、全外连接：显示左右两个表全部记录(mysql不支持full join)，实现方式如下：
select * from employee left join department on employee.dep_id = department.id
union
select * from employee right join department on employee.dep_id = department.id
如何求二进制中1 的个数
def count1(a):
'''
整数的二进制表达里有多少个1，复杂度为a的二进制长度。
'''
num = 0
while a != 0:
num += a & 1
a >>= 1
return num
def count2(a):
'''
整数的二进制表达里有多少个1，复杂度仅为1的个数
'''
num = 0
while a != 0:
a = a & (a - 1) # 就是这个操作，需要掌握，它的本质含义是抹去了0不考虑
num += 1
return num
运算符说明:http://www.runoob.com/python/python-operators.html
https://blog.csdn.net/dongrixinyu/article/details/78877489
统计出现频率最高的词
import os
from collections import Counter
sumsdata=[]
for fname in os.listdir(os.getcwd()):
if os.path.isfile(fname) and fname.endswith('.txt'):
with open(fname,'r') as fp:
data=fp.readlines()
fp.close()
sumsdata+=[line.strip().lower() for line in data]
cnt=Counter()
for word in sumsdata:
cnt[word]+=1
cnt=dict(cnt)
for key,value in cnt.items():
print(key+":"+str(value))
子网掩码有什么用
子网掩码（subnet mask）的作用实际上只是用来标识出某个IP地址哪部分是网络位的一段地址。
map等使用实例
map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) # 提供了两个列表，对相同位置的列表数据进行相加
[3, 7, 11, 15, 19]
list去重
1、直观方法
li=[1,2,3,4,5,1,2,3]
new_li=[]
for i in li:
if i not in new_li:
new_li.append(i)
print(new_li)
先建立一个新的空列表，通过遍历原来的列表，再利用逻辑关系not in 来去重。
总结：这样可以做出来，但是过程不够简单。但是此方法保证了列表的顺序性。
2、利用set的自动去重功能
li=[1,2,3,4,5,1,2,3]
li=list(set(li))
print(li)
将列表转化为集合再转化为列表，利用集合的自动去重功能。简单快速。缺点是：使用set方法无法保证去重后的顺序。
modle中slugfield字段的用途
1、slug：用于生成一个有意义（valid, meaninful）URL 参考（http://stackoverflow.com/questions/427102/what-is-a-slug-in-django）
比如：http://stackoverflow.com/questions/427102/what-is-a-slug-in-django 后面的“what-is-a-slug-in-django”就是经过slug后的产物
如何使用：
需要使用slugify功能：from django.utils.text import slugify
例子：slugify(value) If value is "Joel is a slug", the output will be "joel-is-a-slug".
2、SlugField：也是起到类似作用，只不过这个一般是后台直接添加时使用，比如：slug = models.SlugField(unique=True) 这样在后台就有个slug框，填写后，URL中就包含slug中的内容。
https://www.cnblogs.com/ohmydenzi/p/5584846.html
SVN和git
1. Git是分布式的，SVN是集中式的，好处是跟其他同事不会有太多的冲突，自己写的代码放在自己电脑上，一段时间后再提交、合并，也可以不用联网在本地提交；
2. Git下载下来后，在本地不必联网就可以看到所有的log，很方便学习，SVN却需要联网；
3. Git鼓励分Branch，而SVN，说实话，我用Branch的次数还挺少的，SVN自带的Branch merge我还真没用过，有merge时用的是Beyond Compare工具合并后再Commit的；
4. Tortoise也有出Git版本，真是好东西；
5. SVN在Commit前，我们都建议是先Update一下，跟本地的代码编译没问题，并确保开发的功能正常后再提交，这样其实挺麻烦的，有好几次同事没有先Updata，就
Commit了，发生了一些错误，耽误了大家时间，Git可能这种情况会少些。
cookie和session区别
cookie是把用户的数据写在用户本地浏览器上, 其他网站也可以扫描使用你的cookie，容易泄露自己网站用户的隐私，而且一般浏览器对单个网站站点有cookie数量与大小的限制。Session是把用户的数据写在用户的独占session上，存储在服务器上，一般只将session的id存储在cookie中。但将数据存储在服务器对服务器的成本会高。session是由服务器创建的，开发人员可以在服务器上通过request对象的getsession方法得到session一般情况，登录信息等重要信息存储在session中，其他信息存储在cookie中
Cookie Session
储存位置 客户端 服务器端
目的 跟踪会话，保存用户偏好设置或用户名密码等 跟踪会话
安全性 不安全 安全
session技术是要使用到cookie的，之所以出现session技术，主要是为了安全。
apache和nginx的区别
https://www.cnblogs.com/wangzhipeng/p/7850717.html
常用推导式
列表推导式
字典推导式
集合推导式
https://www.cnblogs.com/cenyu/p/5718410.html
闭包代码
闭包函数的实例
outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
b = 10
# inner是内函数
def inner():
#在内函数中 用到了外函数的临时变量
print(a+b)
# 外函数的返回值是内函数的引用
return inner
if __name__ == '__main__':
# 在这里我们调用外函数传入参数5
#此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
# 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
demo = outer(5)
# 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
# demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
demo() # 15
demo2 = outer(7)
demo2()#17
https://www.cnblogs.com/Lin-Yi/p/7305364.html
python读取大文件20G
with open(filename, 'r') as flie:
for line in file:
....
--------------
text = linecache.getline(filename, 2) # 使用linecache模块
https://www.cnblogs.com/wulaa/p/7852592.html
数据库引擎特点
MyISAM:
有存储限制，表的定义语句，数据，索引分文件存储，分别为.frm文件，.MYD（MyDate），.MYI文件（MyIndex），存储方式分静态表（默认），动态表，压缩表。静态表中表字段定长，存储速度快，容易缓存，出现故障容易恢复，但是空间浪费严重。动态表中表字段不定长，空间浪费小，但是崩溃不易恢复，频繁的删除和更新会产生大量的碎片，可以使用OPTIMIZE TABLE命令定期清理碎片。同时MyISAM存储殷勤不支持外键，也不支持事务处理，但是其优势为访问速度快，在使用中中，如果对事务完整性没有要求，或者数据库操作主要以Select或者Insert为主的应用基本上可以使用这种存储引擎，而且MyISAM存储殷勤在也是5.5版本之前MySQL默认的存储引擎。
InnoDB:
提供回滚，提交，崩溃恢复的事务安全，唯一支持外键，表中的自动增长列必须是索引，如果是组合索引，必须是组合索引的第一列，并且自动增长列支持手动插入，但是如果插入值为空或者0，则实际值为增长后的值。创建外键时，要求父表必须有对应的索引，子表在创建外键的时候，也会自动创建对应的索引。如果某个表被其他表创建了外键参照，那么该表的对应索引或者主键禁止被删除。但是在创建索引时，可以指定在对父表进行删除或者更新时，子表所对应的操作，这些操作包括以下几种：
RESTRICT,CASCADE,SET NULL,NO ACTION，其实RESTRICT和NO ACTION作用相同，是指在子表有关联记录的时候，父表不允许更新，CASCADE是指在父表执行更新或者删除操作时，更新或者删除子表对应的记录，SET NULL是指在父表执行删除或者更新操作时，子表相应字段设置为NULL。
InnoDB在存储方式上，分为共享表空间和使用多表空间存储。
https://blog.csdn.net/qq_34985719/article/details/78637119
select和epoll原理和区别
其实所有的I/O都是轮询的方法,只不过实现的层面不同罢了.
这个问题可能有点深入了,但相信能回答出这个问题是对I/O多路复用有很好的了解了.其中tornado使用的就是epoll的.
selec,poll和epoll区别总结
基本上select有3个缺点:
连接数受限
查找配对速度慢
数据由内核拷贝到用户态
poll改善了第一个缺点
epoll改了三个缺点.
关于epoll的: http://www.cnblogs.com/my_life/articles/3968782.html
dict转列表
a = {'a' : 1, 'b': 2, 'c' : 3}
key_value = list(a.keys()) #字典中的key转换为列表
print('字典中的key转换为列表：', key_value)
value_list = list(a.values()) #字典中的value转换为列表
print('字典中的value转换为列表：', value_list)
XSS攻击
XSS 攻击，全称是“跨站点脚本攻击”（Cross Site Scripting），之所以缩写为 XSS，主要是为了和“层叠样式表”（Cascading StyleSheets，CSS）区别开，以免混淆。XSS 是一种经常出现在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。这些代码包括HTML代码和客户端脚本。对于跨站脚本攻击，黑客界共识是：跨站脚本攻击是新型的“缓冲区溢出攻击”，而JavaScript是新型的“ShellCode”。
线程安全
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。
1+2+3+...+n用python怎么用递归实现?
for
while
https://blog.csdn.net/fang_zz/article/details/51530796
斐波那契数列不同版本
while循环版
a=0
b=1
while b < 1000:
print(b)
a, b = b, a+b
递归版
lis = []
for i in range(20):
if i == 0 or i == 1: # 第1,2项 都为1
lis.append(1)
else:
lis.append(lis[i - 2] + lis[i - 1]) # 从第3项开始每项值为前两项值之和
print(lis)
for循环版
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return b
init()和__new__()的区别
__init__ 只是单纯的对实例进行某些属性的初始化，以及执行一些需要在新建对象时的必要自定义操作，无返回值。而 __new__ 返回的是用户创建的实例，这个才是真正用来创建实例的，所以 __new__ 是在 __init__ 之前执行的，先创建再初始化。
利用Python实现栈和队列
# 后进先出
class Stack():
def __init__(self, size):
self.size = size
self.stack = []
self.top = -1
# 入栈之前检查栈是否已满
def push(self, x):
if self.isfull():
raise exception("stack is full")
else:
self.stack.append(x)
self.top = self.top + 1
# 出栈之前检查栈是否为空
def pop(self):
if self.isempty():
raise exception("stack is empty")
else:
self.top = self.top - 1
self.stack.pop()
def isfull(self):
return self.top + 1 == self.size
def isempty(self):
return self.top == '-1'
def showStack(self):
print(self.stack)
s = Stack(10)
for i in range(6):
s.push(i) # 入栈
s.showStack() # [0, 1, 2, 3, 4, 5]
for i in range(2):
s.pop() # 出栈
s.showStack() # [0, 1, 2, 3]
-------------------
# 先进先出
class Queue():
def __init__(self,size):
self.size=size
self.front=-1
self.rear=-1
self.queue=[]
def enqueue(self,ele): # 入队操作
if self.isfull():
raise exception("queue is full")
else:
self.queue.append(ele)
self.rear=self.rear+1
def dequeue(self): # 出队操作
if self.isempty():
raise exception("queue is empty")
else:
self.queue.pop(0)
self.front=self.front+1
def isfull(self):
return self.rear-self.front+1 == self.size
def isempty(self):
return self.front == self.rear
def showQueue(self):
print(self.queue)
q=Queue(10)
for i in range(6):
q.enqueue(i)
q.showQueue()
for i in range(3):
q.dequeue()
q.showQueue()
print(q.isempty())
Python 中的 GIL 是什么？举个例子说说其具体体现。
GIL 全称 Global Interpreter Lock（全局解释器锁），任何 Python 线程执行前，必须先获得 GIL 锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。要避免这种“现象”利用操作系统的多核优势可以有下面几种方法：
使用 C 语言编写扩展，创建原生线程，摆脱 GIL，但是即使是扩展，在 Python 代码内，任意一条Python 代码还是会有 GIL 限制
使用多进程代替多线程，使用多进程时，每个进程都有自己的 GIL。故不存在进程与进程之间的 GIL 限制。但是多进程不能共享内存。
