1.一行代码实现1--100之和
>>> >>> sum(range(1,101)) 5050 >>>
2.Python是如何进行内存管理的？
从三个方面来说，主要有方面的措施：对象的引用计数机制、垃圾回收机制、内存池机制。
一、对象的引用计数机制
Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。
引用计数增加的情况：
1、一个对象分配一个新名称
2、将其放入一个容器中（如列表、元组或字典）
引用计数减少的情况：
1、使用del语句对对象别名显示的销毁
2、引用超出作用域或被重新赋值
sys.getrefcount( )函数可以获得对象的当前引用计数
多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。
二、垃圾回收
1、当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
2、当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。
三、内存池机制
Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
1、Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
2、Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
3、对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。
3.如何在一个函数内部修改全局变量
a=1 def change(): global a a=10 print(a) change() print(a)
输出
macname@MacdeMBP ~ % python3 test.py 1 10 macname@MacdeMBP ~ %
4.列出5个python标准库
os：提供了不少与操作系统相关联的函数
sys: 通常用于命令行参数
re: 正则匹配
math: 数学运算
datetime:处理日期时间
5.字典如何删除键和合并两个字典
a={"key1":"v1","key2":"v2"}
b={"key3":"v3","key4":"v4"}
print(a)
del a["key1"]
print(a)
a.update(b)
print(a)
输出
macname@MacdeMBP ~ % python3 test.py
{'key1': 'v1', 'key2': 'v2'}
{'key2': 'v2'}
{'key2': 'v2', 'key3': 'v3', 'key4': 'v4'}
macname@MacdeMBP ~ %
6.谈下python的GIL
GIL 是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加了一把锁即GIL），使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作，则解释器锁解开，使其他线程运行。所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。
多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个python解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大
7.python实现列表去重的方法
a=[1,2,3,4,1,2,3] tmp=list(set(a)) print(tmp)
输出
macname@MacdeMBP ~ % python3 test.py [1, 2, 3, 4] macname@MacdeMBP ~ %
8.fun(*args,**kwargs)中的*args,**kwargs什么意思？
def test(*args,**kwargs):
print(args)
print(kwargs)
test("a","b","c",d="aaa")
输出
macname@MacdeMBP ~ % python3 test.py
('a', 'b', 'c')
{'d': 'aaa'}
macname@MacdeMBP ~ %
9.python2和python3的range（100）的区别
python2返回列表，python3返回迭代器，节约内存
10.一句话解释什么样的语言能够用装饰器?
函数可以作为参数传递的语言，可以使用装饰器
11.python内建数据类型有哪些
整型--int
布尔型--bool
字符串--str
列表--list
元组--tuple
字典--dict
12.简述with方法打开处理文件帮我们做了什么？
打开文件在进行读写的时候可能会出现一些异常状况，如果按照常规的f.open
写法，我们需要try,except,finally，做异常判断，并且文件最终不管遇到什么情况，都要执行finally f.close()关闭文件，with方法帮我们实现了finally中f.close
（当然还有其他自定义功能，有兴趣可以研究with方法源码）
13.列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，
并使用列表推导式提取出大于10的数，最终输出[16,25]
list=[1,2,3,4,5]
def fn(x):
return x**2
tmp=map(fn,list)
res2=[i for i in tmp if(i>10)]
print(res2)
输出
macname@MacdeMBP ~ % python3 test.py [16, 25] macname@MacdeMBP ~ %
14.python中生成随机整数、随机小数、0--1之间小数方法
import random import numpy as np r_int=random.randint(1,3) r_float_n=np.random.randn(3) r_zero_to_one=random.random() print(r_int) print(r_float_n) print(r_zero_to_one)
输出
macname@MacdeMBP ~ % python3 test.py 1 [-0.52377838 1.60751491 -1.95764946] 0.6880865102049251 macname@MacdeMBP ~ %
15.避免转义给字符串加哪个字母表示原始字符串？
r , 表示需要原始字符串，不转义特殊字符
16.10个Linux常用命令
ls pwd cd touch rm mkdir tree cp mv cat more grep echo
17.数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句
select distinct name from student;
18.python中断言的使用
a=3 assert(a==3) b=4 assert(b==2)
输出
macname@MacdeMBP ~ % python3 test.py
Traceback (most recent call last):
File "/Users/macname/Desktop/py/test.py", line 7, in <module>
assert(b==2)
AssertionError
macname@MacdeMBP ~ %
19.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()函数
20.列出python中可变数据类型和不可变数据类型，并简述原理
不可变数据类型：数值型、字符串型string和元组tuple
不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址），如下图用id()方法可以打印对象的id
可变数据类型：列表list和字典dict；
允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
a=3 print(id(a)) b=3 print(id(b)) c=[1,2] print(id(c)) d=[1,2] print(id(d))
输出
macname@MacdeMBP ~ % python3 test.py 4305280192 4305280192 4396034312 4396271688 macname@MacdeMBP ~ %
21.去重，并且升序输出字符串
a="cbdeafhgikljkcdcd" tmp=list(set(a)) tmp.sort() res="".join(tmp) print(res)
输出
macname@MacdeMBP ~ % python3 test.py abcdefghijkl macname@MacdeMBP ~ %
22.使用lambda实现两个数相加
sum_test=lambda a,b:a+b print(sum_test(1,5))
输出
macname@MacdeMBP ~ % python3 test.py 6 macname@MacdeMBP ~ %
23.字典根据键升序排列
dic={"name":"xiaoming","age":12,"city":"beijing","tel":13123212321}
tmp=sorted(dic.items(),key=lambda i:i[0])
print(tmp)
输出
macname@MacdeMBP ~ % python3 test.py
[('age', 12), ('city', 'beijing'), ('name', 'xiaoming'), ('tel', 13123212321)]
macname@MacdeMBP ~ %
24.统计字符出现的频次
from collections import Counter a="i am xiaoming,do you know who is xiaoming?" res=Counter(a) print(res)
输出
macname@MacdeMBP ~ % python3 test.py
Counter({' ': 7, 'i': 6, 'o': 6, 'a': 3, 'm': 3, 'n': 3, 'x': 2, 'g': 2, 'w': 2, ',': 1, 'd': 1, 'y': 1, 'u': 1, 'k': 1, 'h': 1, 's': 1, '?': 1})
macname@MacdeMBP ~ %
25.使用filter过滤出列表中的所有奇数
a=[1,2,3,4,5,6,7,8,9,10] tmp=filter(lambda x:x%2!=0,a) res=[i for i in tmp] print(res)
输出
macname@MacdeMBP ~ % python3 test.py [1, 3, 5, 7, 9] macname@MacdeMBP ~ %
26.使用列表推导式过滤出奇数
a=[1,2,3,4,5,6,7,8,9,10] res=[i for i in a if(i%2!=0)] print(res)
输出
macname@MacdeMBP ~ % python3 test.py [1, 3, 5, 7, 9] macname@MacdeMBP ~ %
27.re.compile的作用？
将正则表达式编译为一个对象，加快访问速度，重复使用
28.a=(1,),a=(1),a=("1"),分别是什么类型的数据？
元组，数字，字符串
29.合并列表，并且排序
a=[1,5,7,9] b=[2,2,6,8] a.extend(b) a.sort() print(a)
输出
macname@MacdeMBP ~ % python3 test.py [1, 2, 2, 5, 6, 7, 8, 9] macname@MacdeMBP ~ %
30.用python删除文件和用linux命令删除文件方法
python：os.remove(文件名)
linux: rm 文件名
31.数据库优化查询的方法
外键，索引，联合查询
32.正则表达式匹配中，（.*）和（.*?）匹配区别？
（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配
（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配
import re
s="<a>haha</a><a>hehe</a>"
res1=re.findall("<a>(.*)</a>",s)
print("贪婪匹配",res1)
res2=re.findall("<a>(.*?)</a>",s)
print("非贪婪匹配",res2)
输出
macname@MacdeMBP ~ % python3 test.py 贪婪匹配 ['haha</a><a>hehe'] 非贪婪匹配 ['haha', 'hehe'] macname@MacdeMBP ~ %
33.x="abc"，y="def"，z=["d","e","f"]，分别求出x.join(y)，x.join(z)的结果
x="abc" y="def" z=["d","e","f"] m=x.join(y) n=x.join(z) print(m) print(n)
输出
macname@MacdeMBP ~ % python3 test.py dabceabcf dabceabcf macname@MacdeMBP ~ %
34.交换两个数值
a=1 b=2 print(a,b) a,b=b,a print(a,b)
输出
macname@MacdeMBP ~ % python3 test.py 1 2 2 1 macname@MacdeMBP ~ %
35.举例说明zip（）函数用法
a=["a","b"]
b=["v1","v2"]
res={i[0]:i[1] for i in zip(a,b)}
print(res)
a=("a","b")
b=("v1","v2")
res={i[0]:i[1] for i in zip(a,b)}
print(res)
a="abc"
b="def"
res={i[0]:i[1] for i in zip(a,b)}
print(res)
输出
macname@MacdeMBP ~ % python3 test.py
{'a': 'v1', 'b': 'v2'}
{'a': 'v1', 'b': 'v2'}
{'a': 'd', 'b': 'e', 'c': 'f'}
macname@MacdeMBP ~ %
36.a="小明 98 分"，用re.sub替换98为100
import re a="小明 98 分" res=re.sub(r"\d+","100",a) print(res)
输出
macname@MacdeMBP ~ % python3 test.py 小明 100 分 macname@MacdeMBP ~ %
37.写5条常用sql语句
show databases;
show tables;
desc 表名;
select * from 表名;
delete from 表名 where id=5;
update students set gender=0,hometown="北京" where id=5；
38.a="hello"和b="你好"编码成bytes类型
a="hello" b="你好".encode() print(a,b) print(type(a),type(b)) a=b"hello" b="你好".encode() print(a,b) print(type(a),type(b))
输出
macname@MacdeMBP ~ % python3 test.py hello b'\xe4\xbd\xa0\xe5\xa5\xbd' <class 'str'> <class 'bytes'>
b'hello' b'\xe4\xbd\xa0\xe5\xa5\xbd' <class 'bytes'> <class 'bytes'> macname@MacdeMBP ~ %
39.[1,2,3]+[4,5,6]的结果是什么？
a=[1,2,3] b=[4,5,6] tmp=a+b print(tmp)
输出
macname@MacdeMBP ~ % python3 test.py [1, 2, 3, 4, 5, 6] macname@MacdeMBP ~ %
40.提高python运行效率的方法
1、使用生成器，因为可以节约大量内存 2、循环代码优化，避免过多重复代码的执行 3、核心模块用Cython PyPy等，提高效率 4、多进程、多线程、协程 5、多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率
41.简述mysql和redis区别
redis： 内存型非关系数据库，数据保存在内存中，速度快
mysql：关系型数据库，数据保存在磁盘中，检索的话，会有一定的Io操作，访问速度相对慢
42.遇到bug如何处理
1、细节上的错误，通过print（）打印，能执行到print（）说明一般上面的代码没有问题，分段检测程序是否有问题，如果是js的话可以alert或console.log
2、如果涉及一些第三方框架，会去查官方文档或者一些技术博客。
3、对于bug的管理与归类总结，一般测试将测试出的bug用teambin等bug管理工具进行记录，然后我们会一条一条进行修改，修改的过程也是理解业务逻辑和提高自己编程逻辑缜密性的方法，我也都会收藏做一些笔记记录。
4、导包问题、城市定位多音字造成的显示错误问题
43.list=[2,3,5,4,9,6],从小到大排序，不用sort，输出为[2,3,4,5,6,9]
a=[2,3,5,4,9,6]
b=[]
while(a):
m=min(a)
b.append(m)
a.remove(m)
print(b)
输出
macname@MacdeMBP ~ % python3 test.py [2, 3, 4, 5, 6, 9] macname@MacdeMBP ~ %
44.写一个单列模式
class single_ob(object):
__instance=None
def __new__(cls,age,name):
if(not cls.__instance):
cls.__instance=object.__new__(cls)
return cls.__instance
def __init__(self,age,name):
self.age=age
self.name=name
a=single_ob(12,"xiaoming")
print(id(a))
print(a.age,a.name)
b=single_ob(8,"xiaohong")
print(id(b))
print(a.age,a.name)
输出
macname@MacdeMBP ~ % python3 test.py 4342543360 12 xiaoming 4342543360 8 xiaohong macname@MacdeMBP ~ %
45.保留两位小数
a=1.332135 print(a) b=round(a,2) print(b)
输出
macname@MacdeMBP ~ % python3 test.py 1.332135 1.33 macname@MacdeMBP ~ %
46.列出常见的状态码和意义
200 OK
请求正常处理完毕
204 No Content
请求成功处理，没有实体的主体返回
206 Partial Content
GET范围请求已成功处理
301 Moved Permanently
永久重定向，资源已永久分配新URI
302 Found
临时重定向，资源已临时分配新URI
303 See Other
临时重定向，期望使用GET定向获取
304 Not Modified
发送的附带条件请求未满足
307 Temporary Redirect
临时重定向，POST不会变成GET
400 Bad Request
请求报文语法错误或参数错误
401 Unauthorized
需要通过HTTP认证，或认证失败
403 Forbidden
请求资源被拒绝
404 Not Found
无法找到请求资源（服务器无理由拒绝）
500 Internal Server Error
服务器故障或Web应用故障
503 Service Unavailable
服务器超负载或停机维护
47.分别从前端、后端、数据库阐述web项目的性能优化
该题目网上有很多方法，我不想截图网上的长串文字，看的头疼，按我自己的理解说几点
前端优化：
1、减少http请求、例如制作精灵图
2、html和CSS放在页面上部，javascript放在页面下面，因为js加载比HTML和Css加载慢，所以要优先加载html和css,以防页面显示不全，性能差，也影响用户体验差
后端优化：
1、缓存存储读写次数高，变化少的数据，比如网站首页的信息、商品的信息等。应用程序读取数据时，一般是先从缓存中读取，如果读取不到或数据已失效，再访问磁盘数据库，并将数据再次写入缓存。
2、异步方式，如果有耗时操作，可以采用异步，比如celery
3、代码优化，避免循环和判断次数太多，如果多个if else判断，优先判断最有可能先发生的情况
数据库优化：
1、如有条件，数据可以存放于redis，读取速度快
2、建立索引、外键等
48.使用pop和del删除字典中的"name"字段
dic={"name":"xiaoming","age":19}
dic.pop("name")
print(dic)
dic2={"name":"xiaohong","age":12}
del dic2["name"]
print(dic2)
输出
macname@MacdeMBP ~ % python3 test.py
{'age': 19}
{'age': 12}
macname@MacdeMBP ~ %
49.列出常见MYSQL数据存储引擎
InnoDB：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。
MyISAM：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比 较低，也可以使用。
MEMORY：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。所以，这类数据库只使用在相对较小的数据库表。
50.通过列表创建字典
a=[["name1","xiaoming"],["age1",12]]
b=[("name2","xiaohong"),("age2",18)]
dic1=dict(a)
print(dic1)
dic2=dict(b)
print(dic2)
输出
macname@MacdeMBP ~ % python3 test.py
{'name1': 'xiaoming', 'age1': 12}
{'name2': 'xiaohong', 'age2': 18}
macname@MacdeMBP ~ %
51.简述同源策略
同源策略需要同时满足以下三点要求：
1）协议相同
2）域名相同
3）端口相同
http:www.test.com与https:www.test.com 不同源——协议不同
http:www.test.com与http:www.admin.com 不同源——域名不同
http:www.test.com与http:www.test.com:8081 不同源——端口不同
只要不满足其中任意一个要求，就不符合同源策略，就会出现“跨域”
52.简述cookie和session的区别
1，session 在服务器端，cookie 在客户端（浏览器）
2、session 的运行依赖 session id，而 session id 是存在 cookie 中的，也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效，存储Session时，键与Cookie中的sessionid相同，值是开发人员设置的键值对信息，进行了base64编码，过期时间由开发人员设置
3、cookie安全性比session差
53.简述多线程、多进程
进程：
1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立
2、稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制
线程：
1、CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源
2、如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃
应用：
IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，减少等待的时间
CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势
54.python中什么元素为假？
答案：（0，空字符串，空列表、空字典、空元组、None, False）
55.简述any()和all()方法
a=[True,False] print(any(a)) print(all(a))
输出
macname@MacdeMBP ~ % python3 test.py True False macname@MacdeMBP ~ %
56.IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什么异常
IOError：输入输出异常
AttributeError：试图访问一个对象没有的属性
ImportError：无法引入模块或包，基本是路径问题
IndentationError：语法错误，代码没有正确的对齐
IndexError：下标索引超出序列边界
KeyError:试图访问你字典里不存在的键
SyntaxError:Python代码逻辑语法出错，不能执行
NameError:使用一个还未赋予对象的变量
57.python中copy和deepcopy区别
import copy #----------------------- #可变类型 a=[1,2,3,[4,5,6]] b=copy.copy(a) c=copy.deepcopy(a) print(a) print(b) print(c) a[0]=111 a[3][0]=123 b[1]=7 b[3][2]=222 c[3][1]=9 print(a) print(b) print(c) #----------------------- #不可变类型 d="hello world" b2=copy.copy(d) c2=copy.deepcopy(d) print(d) print(b2) print(c2) d="heihei" print(d) print(b2) print(c2) b2="haha" print(d) print(b2) print(c2) c2="hehe" print(d) print(b2) print(c2)
输出
macname@MacdeMBP ~ % python3 test.py [1, 2, 3, [4, 5, 6]] [1, 2, 3, [4, 5, 6]] [1, 2, 3, [4, 5, 6]] [111, 2, 3, [123, 5, 222]] [1, 7, 3, [123, 5, 222]] [1, 2, 3, [4, 9, 6]] hello world hello world hello world heihei hello world hello world heihei haha hello world heihei haha hehe macname@MacdeMBP ~ %
58.列出几种魔法方法并简要介绍用途
__init__:对象初始化方法
__new__:创建对象时候执行的方法，单列模式会用到
__str__:当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
__del__:删除对象执行的方法
59.列表表达式 改为 生成器
#列表表达式 改为 生成器 a=[i for i in range(5)] b=(i for i in range(5)) print(type(a)) print(type(b))
输出
macname@MacdeMBP ~ % python3 test.py <class 'list'> <class 'generator'> macname@MacdeMBP ~ %
60.python 获取文件输入参数
import sys print(sys.argv)
输出
macname@MacdeMBP ~ % python3 test.py hello xiaoming ['test.py', 'hello', 'xiaoming'] macname@MacdeMBP ~ %
61.去掉字符串尾部空格
a=" hello wolrd " print(a.rstrip())
输出
macname@MacdeMBP ~ % python3 test.py hello wolrd macname@MacdeMBP ~ %
62.举例sort 和 sorted 对列表排序的区别
a=[1,3,5,2,9,-1] #无返回值 a.sort() print(a) #返回值为列表 b=sorted(a) print(b)
输出
macname@MacdeMBP ~ % python3 test.py [-1, 1, 2, 3, 5, 9] [-1, 1, 2, 3, 5, 9] macname@MacdeMBP ~ %
62.[2,3,4,5,12,3,4,-1]，使用lambda 函数从小到大排序
a=[2,3,4,5,12,3,4,-1] b=sorted(a,key=lambda x:x) print(b)
输出
macname@MacdeMBP ~ % python3 test.py [-1, 2, 3, 3, 4, 4, 5, 12] macname@MacdeMBP ~ %
a=[2,3,4,5,12,3,4,-8,-1,-3,-5,-7] b=sorted(a,key=lambda x:(x<0,abs(x))) print(b)
输出
macname@MacdeMBP ~ % python3 test.py [2, 3, 3, 4, 4, 5, 12, -1, -3, -5, -7, -8] macname@MacdeMBP ~ %
64.列表元素为字典时，分别根据年龄和姓名排序
a=[{"name":"biaoming","age":17},{"name":"ciaohong","age":15},{"name":"aiaodong","age":19}]
b=sorted(a,key=lambda x:x["name"])
c=sorted(a,key=lambda x:x["age"])
print(b)
print(c)
输出
macname@MacdeMBP ~ % python3 test.py
[{'name': 'aiaodong', 'age': 19}, {'name': 'biaoming', 'age': 17}, {'name': 'ciaohong', 'age': 15}]
[{'name': 'ciaohong', 'age': 15}, {'name': 'biaoming', 'age': 17}, {'name': 'aiaodong', 'age': 19}]
macname@MacdeMBP ~ %
65.列表元素为元组时，进行排序
a=[("axiaoming",12),("cxiaoming",15),("bxiaoming",9)]
b=sorted(a,key=lambda x:x[0])
c=sorted(a,key=lambda x:x[1])
print(b)
print(c)
输出
macname@MacdeMBP ~ % python3 test.py
[('axiaoming', 12), ('bxiaoming', 9), ('cxiaoming', 15)]
[('bxiaoming', 9), ('axiaoming', 12), ('cxiaoming', 15)]
macname@MacdeMBP ~ %
66.根据值排序，值相同时，根据键排序
a=[["axiaoming",12],["fxiaoming",10],["kxiaoming",16],["bxiaoming",10]] b=sorted(a,key=lambda x:(x[1],x[0])) print(b)
输出
macname@MacdeMBP ~ % python3 test.py [['bxiaoming', 10], ['fxiaoming', 10], ['axiaoming', 12], ['kxiaoming', 16]] macname@MacdeMBP ~ %
67.举例，列表推导式，字典推导式，生成器
import random
a=[i for i in range(10)]
print(a)
b=(i for i in range(10))
print(b)
c={k:random.randint(1,5) for k in ["a","b","c","d"]}
print(c)
输出
macname@MacdeMBP ~ % python3 test.py
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
<generator object <genexpr> at 0x102c783b8>
{'a': 3, 'b': 4, 'c': 5, 'd': 1}
macname@MacdeMBP ~ %
68.字符串列表，根据字符串长素排序
a=["abcde","kbced","f","vf"] b=sorted(a,key=lambda x:len(x)) print(b)
输出
macname@MacdeMBP ~ % python3 test.py ['f', 'vf', 'abcde', 'kbced'] macname@MacdeMBP ~ %
69.python字典和json字符串相互转化方法
import json
a={"name":"xiaoming"}
res1=json.dumps(a)
print(res1,type(res1))
res2=json.loads(res1)
print(res2,type(res2))
输出
macname@MacdeMBP ~ % python3 test.py
{"name": "xiaoming"} <class 'str'>
{'name': 'xiaoming'} <class 'dict'>
macname@MacdeMBP ~ %
70.MyISAM 与 InnoDB 区别：
1、InnoDB 支持事务，MyISAM 不支持，这一点是非常之重要。事务是一种高
级的处理方式，如在一些列增删改中只要哪个出错还可以回滚还原，而 MyISAM
就不可以了；
2、MyISAM 适合查询以及插入为主的应用，InnoDB 适合频繁修改以及涉及到
安全性较高的应用；
3、InnoDB 支持外键，MyISAM 不支持；
4、对于自增长的字段，InnoDB 中必须包含只有该字段的索引，但是在 MyISAM
表中可以和其他字段一起建立联合索引；
5、清空整个表时，InnoDB 是一行一行的删除，效率非常慢。MyISAM 则会重
建表。
71.统计字符串中某字符出现次数
a="xiaoming abc xiaohong xiaoming xigua"
b=a.count("xiaoming")
print(b)
输出
macname@MacdeMBP ~ % python3 test.py 2 macname@MacdeMBP ~ %
72.列举3条以上PEP8编码规范
1、顶级定义之间空两行，比如函数或者类定义。
2、方法定义、类定义与第一个方法之间，都应该空一行
3、三引号进行注释
4、使用Pycharm、Eclipse一般使用4个空格来缩进代码
73.int("1.4"),int(1.4)输出结果？
int("1.4")报错，int(1.4)输出1
74.Linux命令重定向 > 和 >>
Linux 允许将命令执行结果 重定向到一个 文件
将本应显示在终端上的内容 输出／追加 到指定文件中
> 表示输出，会覆盖文件原有的内容
>> 表示追加，会将内容追加到已有文件的末尾
用法示例：
将 echo 输出的信息保存到 1.txt 里echo Hello Python > 1.txt
将 tree 输出的信息追加到 1.txt 文件的末尾tree >> 1.txt
75.常见的网络传输协议
UDP、TCP、FTP、HTTP、SMTP等等
76.单引号、双引号、三引号用法
1、单引号和双引号没有什么区别，不过单引号不用按shift，打字稍微快一点。表示字符串的时候，单引号里面可以用双引号，而不用转义字符,反之亦然。
'She said:"Yes." ' or "She said: 'Yes.' "
2、但是如果直接用单引号扩住单引号，则需要转义，像这样：
' She said:\'Yes.\' '
3、三引号可以直接书写多行，通常用于大段，大篇幅的字符串
""" hello world """
77.python垃圾回收机制
python垃圾回收主要以引用计数为主，标记-清除和分代清除为辅的机制，其中标记-清除和分代回收主要是为了处理循环引用的难题。
引用计数算法
当有1个变量保存了对象的引用时，此对象的引用计数就会加1
当使用del删除变量指向的对象时，如果对象的引用计数不为1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
78.HTTP请求中get和post区别
1、GET请求是通过URL直接请求数据，数据信息可以在URL中直接看到，比如浏览器访问；而POST请求是放在请求头中的，我们是无法直接看到的；
2、GET提交有数据大小的限制，一般是不超过1024个字节，而这种说法也不完全准确，HTTP协议并没有设定URL字节长度的上限，而是浏览器做了些处理，所以长度依据浏览器的不同有所不同；POST请求在HTTP协议中也没有做说明，一般来说是没有设置限制的，但是实际上浏览器也有默认值。总体来说，少量的数据使用GET，大量的数据使用POST。
3、GET请求因为数据参数是暴露在URL中的，所以安全性比较低，比如密码是不能暴露的，就不能使用GET请求；POST请求中，请求参数信息是放在请求头的，所以安全性较高，可以使用。在实际中，涉及到登录操作的时候，尽量使用HTTPS请求，安全性更好。
79.简述多线程、多进程
进程：
1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立
2、稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制
线程：
1、CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源
2、如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃
应用：
IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，减少等待的时间
CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势
80.python正则中search和match
import re
a="小明年龄18岁，工资每个月1000000美元"
#匹配第一个数字
res=re.search(r"\d+",a).group()
print(res)
#匹配所有数字
res=re.findall(r"\d+",a)
print(res)
#只从开头匹配
res=re.match("小明",a).group()
print(res)
输出
macname@MacdeMBP ~ % python3 test.py 18 ['18', '1000000'] 小明 macname@MacdeMBP ~ %
81.Python的主要功能是什么？
Python是一种解释型语言。与C语言等语言不同，Python不需要在运行之前进行编译。 Python是动态语言，当您声明变量或类似变量时，您不需要声明变量的类型。 Python适合面向对象的编程，因为它允许类的定义以及组合和继承。Python没有访问说明（如C ++的public，private）。 在Python中，函数是第一类对象。它们可以分配给变量。类也是第一类对象 编写Python代码很快，但运行比较慢。Python允许基于C的扩展，例如numpy函数库。 Python可用于许多领域。Web应用程序开发，自动化，数学建模，大数据应用程序等等。它也经常被用作“胶水”代码。
82.列表和元组的区别
列表可变，元组不可变
列表比元组慢
83.Python是通用编程语言吗？
Python能够编写脚本，但从一般意义上讲，它被认为是一种通用编程语言。
84.Python是如何解释语言的？
Python在运行之前不需要对程序进行解释。因此，Python是一种解释型语言。
85.什么是pep？
PEP代表Python Enhancement Proposal。它是一组规则，指定如何格式化Python代码以获得最大可读性。
86.如何在Python中管理内存？
python中的内存管理由Python私有堆空间管理。所有Python对象和数据结构都位于私有堆中。程序员无权访问此私有堆。python解释器负责处理这个问题。
Python对象的堆空间分配由Python的内存管理器完成。核心API提供了一些程序员编写代码的工具。
Python还有一个内置的垃圾收集器，它可以回收所有未使用的内存，并使其可用于堆空间。
87.Python中的命名空间是什么？
命名空间是一个命名系统，用于确保名称是唯一性，以避免命名冲突。
88.什么是PYTHONPATH？
它是导入模块时使用的环境变量。每当导入模块时，也会查找PYTHONPATH以检查各个目录中是否存在导入的模块。解释器使用它来确定要加载的模块。
89.什么是python模块？Python中有哪些常用的内置模块？
Python模块是包含Python代码的.py文件。此代码可以是函数类或变量。一些常用的内置模块包括：sys、math、random、datatime、json。
90.Python中的局部变量和全局变量是什么？
全局变量：在函数外或全局空间中声明的变量称为全局变量。这些变量可以由程序中的任何函数访问。
局部变量：在函数内声明的任何变量都称为局部变量。此变量存在于局部空间中，而不是全局空间中。
91.python是否区分大小写？
区分
92.什么是Python中的类型转换？
类型转换是指将一种数据类型转换为另一种数据类型。
int（） - 将任何数据类型转换为整数类型
float（） - 将任何数据类型转换为float类型
ord（） - 将字符转换为整数
hex（） - 将整数转换为十六进制
oct（） - 将整数转换为八进制
tuple（） - 此函数用于转换为元组。
set（） - 此函数在转换为set后返回类型。
list（） - 此函数用于将任何数据类型转换为列表类型。
dict（） - 此函数用于将顺序元组（键，值）转换为字典。
str（） - 用于将整数转换为字符串。
complex（real，imag） - 此函数将实数转换为复数（实数，图像）数。
93.如何在Windows上安装Python并设置路径变量？
要在Windows上安装Python，请按照以下步骤操作：
从以下链接安装python：https：//http://www.python.org/downloads/
下载之后，将其安装在您的PC上。在命令提示符下使用以下命令查找PC上安装PYTHON的位置：cmd python。
然后转到高级系统设置并添加新变量并将其命名为PYTHON_NAME并粘贴复制的路径。
查找路径变量，选择其值并选择“编辑”。
如果值不存在，请在值的末尾添加分号，然后键入％PYTHON_HOME％
94.python中是否需要缩进？
缩进是Python必需的。它指定了一个代码块。循环，类，函数等中的所有代码都在缩进块中指定。通常使用四个空格字符来完成。如果您的代码没有必要缩进，它将无法准确执行并且也会抛出错误。
95.Python数组和列表有什么区别？
Python中的数组和列表具有相同的存储数据方式。但是，数组只能包含单个数据类型元素，而列表可以包含任何数据类型元素。
96.Python中的函数是什么？
函数是一个代码块，只有在被调用时才会执行。要在Python中定义函数，需要使用def关键字。
97.什么是__init__?
__init__是Python中的方法或者结构。在创建类的新对象/实例时，将自动调用此方法来分配内存。所有类都有__init__方法。
98.什么是lambda函数？
lambda函数也叫匿名函数，该函数可以包含任意数量的参数，但只能有一个执行操作的语句。
99.Python中的self是什么？
self是类的实例或对象。在Python中，self包含在第一个参数中。但是，Java中的情况并非如此，它是可选的。它有助于区分具有局部变量的类的方法和属性。init方法中的self变量引用新创建的对象，而在其他方法中，它引用其方法被调用的对象。
100.区分break，continue和pass？
break 跳出循环
continue 跳过本次循环
pass 空语句，占位符
101.[:: - 1}表示什么？
[:: - 1]用于反转数组或序列的顺序。
102.如何在Python中随机化列表中的元素？
>>> from random import shuffle >>> x=["keep","hello","blue"] >>> shuffle(x) >>> x ['blue', 'hello', 'keep'] >>>
103.什么是python迭代器？
迭代器是可以遍历或迭代的对象。
104.如何在Python中生成随机数？
random模块是用于生成随机数的标准模块。
105.如何在python中写注释？
Python中的注释以＃字符开头。也可以使用doc-strings（三重引号中包含的字符串）进行注释。
106.什么是pickling和unpickling？
Pickle模块接受任何Python对象并将其转换为字符串表示形式，并使用dump函数将其转储到文件中，此过程称为pickling。从存储的字符串中检索原始Python对象的过程称为unpickling。
107.python中的生成器是什么？
返回可迭代项集的函数称为生成器。
108.你如何把字符串的第一个字母大写？
在Python中，capitalize()函数可以将字符串的第一个字母大写。如果字符串在开头已经包含大写字母，那么它将返回原始字符串。
109.如何将字符串转换为全小写？
要将字符串转换为小写，可以使用lower()函数。
110.如何在python中注释多行？
注释多行代码时。所有要注释的行都要在开头前加#。还可以使用快捷方式来注释多行，就是按住Ctrl键并在每个想要包含＃字符的地方左键单击并键入一次＃。
111.什么是Python中的文档Docstrings？
Docstrings实际上不是注释，它们是文档字符串。这些文档字符串在三引号内。它们没有分配给任何变量，因此有时也用于注释。
112.operators中的is、not和in各有什么功能？
Operators是特殊函数，它们比较一个或多个值并产生相应的结果。其中is：当2个操作数为true时返回true（例如：“a”是'a'）
not：返回布尔值的倒数
in：检查某个元素是否存在于某个序列中
113.当Python退出时，为什么不清除所有分配的内存？
当Python退出时，尤其是那些对其他对象具有循环引用的Python模块或者从全局名称空间引用的对象并没有被解除分配或释放。
无法解除分配C库保留的那些内存部分。
退出时，由于拥有自己的高效清理机制，Python会尝试取消分配/销毁其他所有对象。
114.Python中的字典是什么？
Python中的内置数据类型称为字典。它定义了键和值之间的一对一关系。字典包含一对键及其对应的值。字典由键索引。
115.如何在python中使用三元运算符？
三元运算符是用于显示条件语句的运算符。这包含true或false值，并且必须为其评估语句。其基本语法为：
三元运算符是用于显示条件语句的运算符。这包含true或false值，并且必须为其评估语句。其基本语法为：
[on_true] if [expression] else [on_false] x，y = 25,50big = x if x <y else y
116.为什么使用* args，** kwargs？
当我们不确定将多少个参数传递给函数，或者我们想要将存储的列表或参数元组传递给函数时，我们使用* args。**当我们不知道将多少关键字参数传递给函数时使用kwargs，或者它可以用于将字典的值作为关键字参数传递。标识符args和kwargs是一个约定，你也可以使用* bob和** billy。
117.len()函数有什么作用？
len()函数可用于确定字符串，列表，数组等的长度。
118.在Python中split()，sub()，subn()功能。
如果要修改字符串，Python的“re”模块提供了3种方法。他们是：
split() - 使用正则表达式模式将给定字符串“拆分”到列表中。
sub() - 查找正则表达式模式匹配的所有子字符串，然后用不同的字符串替换它们
subn() - 它类似于sub()，并且还返回新字符串。
119.什么是负指数，功能是什么？
Python中的序列是索引的，它由正数和负数组成。积极的数字使用'0'作为第一个索引，'1'作为第二个索引，进程继续使用。
负数的索引从'-1'开始，表示序列中的最后一个索引，' - 2'作为倒数第二个索引，序列像正数一样前进。
负索引用于从字符串中删除任何换行符，并允许该字符串除了作为S [： - 1]给出的最后一个字符。负索引还用于显示索引以正确的顺序表示字符串。
120.什么是Python包？
Python包是包含多个模块的命名空间。
121.如何在Python中删除文件？
要在Python中删除文件，您需要导入OS模块。之后，您需要使用os.remove()函数。
122.什么是python的内置类型？
Python中的内置类型如下：整型、浮点型、复数、字符串、布尔等。
123.NumPy中有哪些操作Python列表的函数？
Python的列表是高效的通用容器。它们支持（相当）有效的插入，删除，追加和连接，Python的列表推导使它们易于构造和操作。
它们有一定的局限性：它们不支持像素化加法和乘法等“向量化”操作，并且它们可以包含不同类型的对象这一事实意味着Python必须存储每个元素的类型信息，并且必须执行类型调度代码在对每个元素进行操作时。
NumPy不仅效率更高; 它也更方便。你可以免费获得大量的向量和矩阵运算，这有时可以避免不必要的工作。它们也得到有效实施。
NumPy数组更快，你可以使用NumPy，FFT，卷积，快速搜索，基本统计，线性代数，直方图等内置。
124.如何将值添加到python数组？
可以使用append()，extend()和insert(i，x)函数将元素添加到数组中。
125.如何删除python数组的值？
可以使用pop()或remove()方法删除数组元素。这两个函数之间的区别在于前者返回已删除的值，而后者则不返回。
126.Python有OOps概念吗？
Python是一种面向对象的编程语言。这意味着可以通过创建对象模型在python中解决任何程序。同时Python可以被视为程序语言和结构语言。
127.深拷贝和浅拷贝有什么区别？
在创建新实例类型时使用浅拷贝，并保留在新实例中复制的值。浅拷贝用于复制引用指针，就像复制值一样。这些引用指向原始对象，并且在类的任何成员中所做的更改也将影响它的原始副本。浅拷贝允许更快地执行程序，它取决于所使用的数据的大小。
深拷贝用于存储已复制的值。深拷贝不会将引用指针复制到对象。它引用一个对象，并存储一些其他对象指向的新对象。原始副本中所做的更改不会影响使用该对象的任何其他副本。由于为每个被调用的对象创建了某些副本，因此深拷贝会使程序的执行速度变慢。
128.如何在Python中实现多线程？
Python有一个多线程库，但是用多线程来加速代码的效果并不是那么的好，
Python有一个名为Global Interpreter Lock（GIL）的结构。GIL确保每次只能执行一个“线程”。一个线程获取GIL执行相关操作，然后将GIL传递到下一个线程。
虽然看起来程序被多线程并行执行，但它们实际上只是轮流使用相同的CPU核心。
所有这些GIL传递都增加了执行的开销。这意味着多线程并不能让程序运行的更快。
129.super 是干嘛用的？在 Python2 和 Python3 使用，有什么区别？为什么要使用 super？请举例说明。
-
super 用于继承父类的方法、属性。
-
super 是新式类中才有的，所以 Python2 中使用时，要在类名的参数中写 Object。Python3 默认是新式类，不用写，直接可用。
-
使用 super 可以提高代码的复用性、可维护性。修改代码时，只需修改一处。
code
class sonClass(baseClass):
def test2(self):
super().test1(num)
son = sonClass()
son.test1(11)
130.L = [1, 2, 3, 11, 2, 5, 3, 2, 5, 3]，用一行代码得出 [11, 1, 2, 3, 5]
list(set(L))
131.L = [1, 2, 3, 4, 5]，L[10:]的结果是？
>>> a=[1,2,3,4,5] >>> a[10:] [] >>> a[9] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range >>>
132.L = [1, 2, 3, 5, 6]，如何得出 '12356'？
s = ''
for i in L:
s = s + str(i)
print(s) # 12356
print(type(s)) # <class 'str'>
133.列表和字典有什么区别？
一般都是问列表和元组有什么不同。
（1）获取元素的方式不同。列表通过索引值获取，字典通过键获取。
（2）数据结构和算法不同。字典是 hash 算法，搜索的速度特别快。
（3）占用的内存不同。
134.如何结束一个进程？
（1）调用 terminate 方法。
（2）使用 subProcess 模块的 Popen 方法。使用简单，具体用法，这里不展开。
135.进程、线程有什么区别？什么情况下用进程？什么情况下用线程？
（1）区别：
- ① 地址空间和其它资源（如打开文件）：进程之间相互独立，同一进程的各线程之间共享。某进程内的线程在其它进程不可见。
- ② 通信：进程间通信 IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
- ③ 调度和切换：线程上下文切换比进程上下文切换要快得多。
- ④ 在多线程操作系统中，进程不是一个可执行的实体。
（2）使用场景：同时操作一个对象的时候，比如操作的是一个全局变量，我用线程，因为全局变量是所有线程共享的。
136.什么是ORM？为什么要用ORM？不用ORM会带来什么影响？
-
ORM 框架可以将类和数据表进行对应，只需要通过类和对象就可以对数据表进行操作。
-
通过类和对象操作对应的数据表，类的静态属性名和数据表的字段名一一对应，不需要写 SQL 语句。
-
ORM 另外一个作用，是根据设计的类生成数据库中的表。
137.写一段代码，ping 一个 ip 地址，并返回成功、失败的信息。
答： 使用 subProcess 模块的 Popen 方法(使用简单，具体用法，这里不展开)。
138.说说接口测试的流程，介绍一下request有哪些内容。
（1）流程：获取接口文档，依据文档设计接口参数，获取响应，解析响应，校验结果，判断测试是否通过。
（2）request 内容：
① 封装了各种请求类型，get、post 等；
② 以关键字参数的方式，封装了各种请求参数，params、data、headers、token 等；
③ 封装了响应内容，status_code、json()、cookies、url 等；
④ session 会话对象，可以跨请求。
139.UI 自动化，如何做集群？
答： Selenium Grid。
140.移动端 UI 自动化，经常会自动安装 2 个程序，你知道那两个程序是什么东西不？
答： 守护精灵，和 Python 并发编程中的 daemon 原理一样，父进程/父线程的代码执行完毕，它就终止，要写在 start 方法前面。另外，要找到配置文件，注释掉两行代码。
141
