python面试考题精华集中整理

面试题一：
写出python的10个内置函数：
len()
sum()
min()
abs()
bin()
range()
pow()
str()
list()
tuple()
set()
filter()
eval()
dict()
del()
bool()
oct()
open()
-------------------------------------------------------------
python的数据结构
list
set
dict
tuple
队列
栈
------------------------
数据的常见5种基本运算：
删除
插入
修改
查找
排序
-------------------------------------------------------------
数据库：
mysql
redis
-------------------------------------------------------------
python常见模块
random
math
time
datetime
re
os
sys
正则表达式
字符串的运算
线程
进程
网络套接字
闭包-》计数器

面向对象的相关内容
贪婪模式
生产消费者模式
单例模式
工厂模式
映射
-------------------------------------------------------------
面试题整理：
1、
字典的删除与合并：
del
update
------------------------
2、谈下python的GIL
GIL叫python的全局解释器锁，当系统资源中分配一个进程，而进程中存在多个线程去完成此项被分配
的任务时，此进程中的一个线程执行的时候会霸占python解释器，其它线程会受到这把锁锁住暂不能进行，当此线程完成或者进入耗时操作时
才能打开，进入下一个线程的执行，也即是同一个进程中多个线程不能同时进行，而是有先后顺序的执行任务;
多进程中因为每个进程被系统分配资源，相当于每一个进程中有一个python解释器，所以多进程可以实现多进程的同时执行操作，但是同时会耗费系统资源的开销大；
3、
python2和python3的range（100）的区别

python2返回列表，python3返回迭代器，节约内存

4、一句话解释什么样的语言能够用装饰器?
函数可以作为参数传递的语言，可以使用装饰器

5、简述with方法打开处理文件帮我我们做了什么？
打开文件在进行读写的时候可能会出现一些异常状况，如果按照常规的f.open
写法，我们需要try,except,finally，做异常判断，并且文件最终不管遇到什么情况，
都要执行finally f.close()关闭文件，with方法帮我们实现了finally中f.close;

6、python中生成随机整数、随机小数、0--1之间小数方法
random.randint(1,100)
random.random()
random.uniform(1,100)

7、map函数的使用

li = [1,2,3,4,5,6]
def fn(i):
    return i**2
if __name__ == "__main__":
    res = map(fn,li)
    print(res)
    ress = [ i for i in res if i>4]
    print(ress)
    
8、转义字符 r
print(r"\n")

9、

中国

，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的
pattern = r"

(.*?)

"  [.代表可有可无，*代表任意字符]
re.findall(pattern,str)

10、assert()
断言测试
if __name__ == "__main__":
    a = 1;
    assert(a>0)
    print("断言成功，程序继续执行")
    b = 10
    assert(b==10)
    print("断言失败")
11、数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句
select  distinct  name  from  student

12、python2和python3区别？列举5个

1、Python3 使用 print 必须要以小括号包裹打印内容，比如 print('hi')
Python2 既可以使用带小括号的方式，也可以使用一个空格来分隔打印内容，比如 print 'hi'
2、python2 range(1,10)返回列表，python3中返回迭代器，节约内存
3、python2中使用ascii编码，python中使用utf-8编码
4、python2中unicode表示字符串序列，str表示字节序列
      python3中str表示字符串序列，byte表示字节序列
5、python2中为正常显示中文，引入coding声明，python3中不需要
6、python2中是raw_input()函数，python3中是input()函数
7、python2中的/与python3中的/有区别
python2中：3/2 = 1 
python3中：3/2 = 1.5

12、python中可变与不可变数据类型；
可变数据类型：set list dict
不可变数据类型：tuple、string、数值类型

13、s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"
set去重
s1 = set(s)
li = sorted(s1,reverse=False)
s = str(li)

14、用lambda函数实现两个数相乘
res = lambda a,b:a*b
print(res(1,2))

15、字典根据键从小到大排序
dict={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
d = sorted(dict)
s = {}
for i in range(len(d)):
    s[d[i]] = dict.get(d[i])
16、利用collections库的Counter方法统计字符串每个单词出现的次数"kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
a = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
c = Counter(a)

17、a=（1，）b=(1)，c=("1") 分别是什么类型的数据？
a是元组
b是int
c是字符串

18、filter方法求出列表所有奇数并构造新列表，a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fn(i):
    return i%2==1
if __name__ == "__main__":
    a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    d = filter(fn,a)
    print(d)
    
19、collections类中deque/Counter()
d = deque()
d.append()
d.extend(list[])
d.extendleft(list[])
d.pop()
d.popleft()
len(d)

20、列表推导式求列表所有奇数并构造新列表，a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = [i for i in a if i%2==1]
print(new_list)

21、正则re.complie作用
re.compile是将正则表达式编译成一个对象，加快速度，并重复使用

22、正则表达式匹配中，（.*）和（.*?）匹配区别？
（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配
（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配
if __name__ == "__main__":
    a="哈哈呵呵"
    li1 = re.findall(r".*",a)#贪婪模式
    print(li1)
    li2 = re.findall(r".*?",a)#非贪婪模式
    print(li2)
23、简述Django的orm
对象关系型映射,根据Django中models模型类，进行面向对象的相关操作如 save/delete/get/all，对应Django的数据库引擎
生成对应的sql语句，对其配置的sqlite/mysql/oracle进行操作

24、[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]
二维数组的列表推导式
new_list = [j for i in a for j in i]

25、x="abc",y="def",z=["d","e","f"],分别求出x.join(y)和x.join(z)返回的结果
    x="abc"
    y="def"
    z=["d","e","f"]
    print(x.join(y)) # -》dabceabcf
    print(x.join(z)) # -》dabceabcf
    即是使用join对字符串或者是列表操作生成字符串
    
26、举例说明异常模块中try except else finally的相关意义
try..except..else没有捕获到异常，执行else语句
try..except..finally不管是否捕获到异常，都执行finally语句

27、python中交换两个数值
a,b = 3,4
print(a,b)
a,b = b,a
print(a,b)

28、zip()函数
if __name__ == "__main__":
    a = [1,2]
    b = [3,4,5]
    li =[i for i in zip(a,b)]
    print(li)
    c = (5,6)
    d = (7,8)
    li =[ i for i in  zip(c,d)]
    print(li)
    e = "abc"
    f = "xy"
    li =[ i for i in  zip(e,f)]
    print(li)
    dictionary = dict(zip(a,b))
    print(dictionary)
    
29、a="张明 98分"，用re.sub，将98替换为100；
if __name__ == "__main__":
    a="张明 98分"
    new_a = re.sub(r"\d+","100",a)
    print(new_a)
    
30、写5条常用sql语句；
desc users;
show tables;
show databases;
drop 表名
delete from table where id = 1
select name from users 
update table set name="denglihua" where name="liwei"
trunc table
alter table add name varchar(20) not null default "none";
alter table1 rename to table2;

31、提高python运行效率的方法
1、使用生成器，因为可以节约大量内存
2、循环代码优化，避免过多重复代码的执行
3、核心模块用Cython  PyPy等，提高效率
4、多进程、多线程、协程
5、多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率

32、简述mysql和redis区别
redis： 内存型非关系数据库，数据保存在内存中，速度快
mysql：关系型数据库，数据保存在磁盘中，检索的话，会有一定的Io操作，访问速度相对慢

33、遇到bug如何处理
1、细节上的错误，通过print（）打印，能执行到print（）说明一般上面的代码没有问题，分段检测程序是否有问题，如果是js的话可以alert或console.log
2、如果涉及一些第三方框架，会去查官方文档或者一些技术博客。
3、对于bug的管理与归类总结，一般测试将测试出的bug用teambin等bug管理工具进行记录，然后我们会一条一条进行修改，修改的过程也是理解业务逻辑和提高自己编程逻辑缜密性的方法，我也都会收藏做一些笔记记录。
4、导包问题、城市定位多音字造成的显示错误问题

34、写一个单例模式；保证只有一个对象在运行
class SingleObj(object):
    __instance = None
    def __new__(cls,age,name):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

if __name__ == "__main__":
    #创建一个单例模式
    s1 = SingleObj(18,"d")
    s2 = SingleObj(20,"q")
    print(id(s1))
    print(id(s2))
    
35、分别从前端、后端、数据库阐述web项目的性能优化
前端优化：
1、一个页面减少http请求
2、js代码放在页面底部，js代码加载比html/css要慢
后端优化：
1、使用频率较高的数据先从缓存中读取，读取不到再向磁盘中读取
2、如果有耗时操作，则采用异步方式，如celery
3、对循环及条件分支语句进行优化
4、对代码中所采取的数据结构的使用进行优化以及算法上的优化、以及冗余的变量使用

数据库的优化：
1、如果有条件，使用频率高的数据存放在redis中
2、优化sql的查询语句
3、简历索引

36、mysql的数据存储引擎;
InnoDB:支持事务，支持外键，支持并发性
MYISAM    主要用于插入数据块
MEMORY  存放在内存中，访问效率高，安全性低，数据空间小

37、简述同源策略
1、协议相同
2、端口相同
3、域名相同
只要不满足其中任意一个要求，就不符合同源策略，就会出现“跨域”

38、简述cookie和session的区别
1，session 在服务器端，cookie 在客户端（浏览器）
2、session 的运行依赖 session id，而 session id 是存在 cookie 中的，也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效，存储Session时，键与Cookie中的sessionid相同，
值是开发人员设置的键值对信息，进行了base64编码，过期时间由开发人员设置
3、cookie安全性比session差

39、简述多线程、多进程
进程：
1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立
2、稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制
线程：
1、CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，
一个进程下的多个线程可以共享该进程的所有资源
2、如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃
应用：
IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，减少等待的时间
CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，
当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势

40、简述any()和all()方法
any():只要迭代器中有一个元素为真就为真
all():迭代器中所有的判断项返回都是真，结果才为真
python中什么元素为假？
答案：（0，空字符串，空列表、空字典、空元组、None, False）

41、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什么异常

IOError：输入输出异常
AttributeError：试图访问一个对象没有的属性
ImportError：无法引入模块或包，基本是路径问题
IndentationError：语法错误，代码没有正确的对齐
IndexError：下标索引超出序列边界
KeyError:试图访问你字典里不存在的键
SyntaxError:Python代码逻辑语法出错，不能执行
NameError:使用一个还未赋予对象的变量

42、列出几种魔法方法并简要介绍用途
__init__:对象初始化方法
__new__:创建对象时候执行的方法，单列模式会用到
__str__:当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
__del__:删除对象执行的方法

43、python中copy和deepcopy区别
浅拷贝和深拷贝
In [1]: a = [1,2,3]
In [2]: b = [4,5,6]
In [3]: c = [a,b]
In [4]: d = c
In [5]: id(c)
Out[5]: 140336567361408
In [6]: id(d)
Out[6]: 140336567361408
In [7]: d
Out[7]: [[1, 2, 3], [4, 5, 6]]
In [8]: c
Out[8]: [[1, 2, 3], [4, 5, 6]]
In [9]: a.append(123)
In [10]: a
Out[10]: [1, 2, 3, 123]
In [11]: c
Out[11]: [[1, 2, 3, 123], [4, 5, 6]]
In [12]: d
Out[12]: [[1, 2, 3, 123], [4, 5, 6]]
In [13]: import copy
In [14]: e = copy.copy(c)
In [15]: e
Out[15]: [[1, 2, 3, 123], [4, 5, 6]]
In [16]: b.append(456)
In [17]: b
Out[17]: [4, 5, 6, 456]
In [18]: d
Out[18]: [[1, 2, 3, 123], [4, 5, 6, 456]]
以上浅拷贝，拷贝的数据也会随之发生改变;浅拷贝拷贝的是表层的数据或者说拷贝的是引用，而不是内容的本身；
浅拷贝对不可变类型和可变类型的copy不同
copy.copy对于可变类型（列表、字典），会进行浅拷贝。
copy.copy对于不可变类型（元祖、数字、字符串），不会拷贝，仅仅是指向。
例如：比如：小明从冰箱里拿了一个苹果1。小马也想吃苹果，从冰箱里拿了一个和小明一样的苹果2。 
初始是一样的，小明吃了一口，小马的苹果没有吃。

深拷贝:
In [20]: import copy
In [21]: a = [1,2]
In [22]: b = [3,4]
In [23]: c = a
In [24]: id(a)
Out[24]: 140336567360544
In [25]: id(c)
Out[25]: 140336567360544
In [26]: d = [a,b]
In [27]: d
Out[27]: [[1, 2], [3, 4]]
In [28]: e = copy.deepcopy(c)
In [29]: e
Out[29]: [1, 2]
In [30]: e = copy.deepcopy(d)
In [31]: d
Out[31]: [[1, 2], [3, 4]]
In [32]: e
Out[32]: [[1, 2], [3, 4]]
In [33]: id(d)
Out[33]: 140336583151696
In [34]: id(e)
Out[34]: 140336590369208
In [35]: a.append(123)
In [36]: a
Out[36]: [1, 2, 123]
In [37]: d
Out[37]: [[1, 2, 123], [3, 4]]
In [38]: e
Out[38]: [[1, 2], [3, 4]]
基本上只要不是我们自已手动调用的deepcopy方法都是浅拷贝。

44、请将[i for i in range(3)]改成生成器
a = (i for i in range(3))

45、生成器、迭代器
1）可迭代对象包含迭代器。
2）如果一个对象拥有__iter__方法，其是可迭代对象；如果一个对象拥有next方法，其是迭代器。
3）定义可迭代对象，必须实现__iter__方法；定义迭代器，必须实现__iter__和next方法。
生成器是一种特殊的迭代器，生成器自动实现了“迭代器协议”（即__iter__和next方法），不需要再手动实现两方法。

46、使用匿名函数及sorted对多条件进行排序https://blog.csdn.net/zhusongziye/article/details/84484464

47、HTTP请求中get和post区别
1、get请求是通过url直接请求数据，post看不到
2、请求中携带的数据量：get较小，post较大
3、从安全性上讲，get的参数暴露在url中，而post的参数在请求头中，post相对较安全

48、单引号、双引号、三引号用法
1、单引号里用双引号或者双引号里用单引号不用转义
2、单引号里用单引号就需要转义
 ' She said:\'Yes.\' '
3、三引号可以直接书写多行，通常用于大段，大篇幅的字符串
"""
hello
world
"""

49、转义的两种方式
print(r"\n")
print("\\n")

50、常见网络传输协议
http/tcp/udp/stmp/ftp

51、python中函数传参是传地址还是传值

52、列举3条以上PEP8编码规范
1、方法定义、类定义与第一个方法之间，都应该空一行
2、三引号进行注释
3、使用Pycharm、Eclipse一般使用4个空格来缩进代码

53、简述wsgi与uwsgi
假设我们使用 python 的 Django 框架写了一个网站，现在要将它挂在网上运行，我们一般需要：
nginx 做为代理服务器：负责静态资源发送（js、css、图片等）、动态请求转发以及结果的回复；
uWSGI 做为后端服务器：负责接收 nginx 请求转发并处理后发给 Django 应用以及接收 Django 
应用返回信息转发给 nginx；
Django 应用收到请求后处理数据并渲染相应的返回页面给 uWSGI 服务器。
nginx通过接受前端的请求，然后通过uwsgi协议传送给UWSGIweb服务器，通过wsgi协议最终直达DjangoApp中;
wsgi:是为 Python 语言定义的 Web 服务器和 Web 应用程序或框架之间的一种简单而通用的接口
uwsgi是服务器和服务端应用程序的一种协议，规定了怎么把请求转发给应用程序和返回; 
uwsgi是一种线路协议而不是通信协议，在此常用于在uWSGI服务器与其他网络服务器的数据通信。
https://www.cnblogs.com/new-rain/p/10089941.html

54、使用os模块对文件的操作

pass

55、文件打开模式 r/b/a/w
r
a
rb
wb
rb+
wb+
a+
ab
ab+

56、python字典和json字符串相互转化方法;
dictionary = {k1:v1,k2:v2}
ss = json.dumps(dictionary)
dicts = json.loads(ss)

57、举例说明SQL注入和解决办法；
sql注入:
inputs = "zs;drop databases demo;"
sql = "select * from demo where name=%s"%inputs
db.excute(sql)
#通过参数化解决方式:
params = [input_name]
sql = cs1.execute("select * from demo name=%s",params)
db.excute(sql)

58、设计模式:
单例模式
贪婪模式
生产消费者模式
工厂模式

59、redis/mysql主从配置

60、理解分布式缓存
分布式缓存系统是为了解决数据库服务器和web服务器之间的瓶颈。
如果一个网站的流量很大，这个瓶颈将会非常明显，每次数据库查询耗费的时间将会非常可观。
对于更新速度不是很快的网站，我们可以用静态化来避免过多的数据库查询。
对于更新速度以秒计的网站，静态化也不会太理想，可以用缓存系统来构建。
如果只是单台服务器用作缓存，问题不会太复杂，如果有多台服务器用作缓存，就要考虑缓存服务器的负载均衡。

61、理解负载均衡
负载均衡解决高并发问题;