python主要数据类型有哪些,那些是可变的,那些是不可变的？
数字(int) 不可变类型
字符串(str) 不可变类型
列表(list) 可变类型
元祖 (tuple) 不可变类型
字典(dict) 可变类型
集合(set) 可变类型
什么是可变数据类型,什么是不可变数据类型？
id: 内存地址
value: 值
1.可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典
- 不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间）
list和tuple有什么不同
1.list是可变数据类型,不能做字典的key,tuple是不可变数据类型，可以当做字典的key
2.list具有添加，删除，修改的方法，tuple没有
3.定义tuple时如果只有一个元素,那么元素后面得加,（1，）
python是如何进行内存管理的？
https://www.cnblogs.com/wangyuhangboke/p/7802253.html
python如何实现单例
https://www.cnblogs.com/ctztake/p/8076048.html
cookie和session有什么区别？
1.cookie数据存放在客户的浏览器上(客户端),session会在一定时间内保存在服务器上
2.由于cookie是存放在浏览器客户端的,所以cookie不是很安全,别人可以分析存放在本地的cookie并进行cookie 欺骗,，session放在客户端,比较安全,如果主要考虑到安全应当使用session
3.session保存在服务器上.当访问增多,会比较占用你服务器的性能,如果主要考虑到减轻服务器性能方面,应当使用cookie
4.session不能区分路径,同一个用户在访问一个网站期间,所有的session在任何一个地方都可以访问到.而cookie中如果设置了路径参数,那么同一个网站中不同路径下的cookie互相是访问不到的.cookie只能是子路径访问父路径设置的cookie
5.cookie本身最大支持4096字节,相对于cookie,session能存放更多字节
给定一个整数数组,返回两个数的索引,使得他们相加和目标值相等,可以假定每个输入都有且只有一个解例如：nums=[2,7,11,15]，目标值是9，因为2+7=9所以返回[0,1]
def f(l,aim):
for i in range(len(l)):
for j in range(i,len(l)):
if l[i]+l[j]==aim:
print('[%s，%s]'%(i,j))
nums=[2,7,11,15]
f(nums,17)
写出常用的HTTP 请求方法
GET 请求指定的页面信息，并返回实体主体。
POST 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
PUT 从客户端向服务器传送的数据取代指定的文档的内容。
CONNECT HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
DELETE 请求服务器删除指定的页面。
HEAD 类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头
OPTIONS 允许客户端查看服务器的性能。
TRACE 回显服务器收到的请求，主要用于测试或诊断
python2 和Python3 有那些显著的区别
https://www.runoob.com/python/python-2x-3x.html
1.print函数
2.Unicode
Python 2 有 ASCII str() 类型，unicode() 是单独的，不是 byte 类型。
现在， 在 Python 3，我们最终有了 Unicode (utf-8) 字符串，以及一个字节类：byte 和 bytearrays。
由于 Python3.X 源码文件默认使用utf-8编码，这就使得以下代码是合法的：
>>> 中国 = 'china'
>>>print(中国)
china
3.除法运算
对于'/':
python 2.x中:整数相除的结果是一个整数，把小数部分完全忽略掉，浮点数除法会保留小数点的部分得到一个浮点数的结果。
python 3.x中:对于整数之间的相除，结果也会是浮点数。
对于'//':
python 2.x和python 3.x中是一致的。
4.异常处理:
在 Python 3 中处理异常也轻微的改变了，在 Python 3 中我们现在使用 as 作为关键词。
捕获异常的语法由 except exc, var 改为 except exc as var。
使用语法except (exc1, exc2) as var可以同时捕获多种类别的异常。 Python 2.6已经支持这两种语法。
- 在2.x时代，所有类型的对象都是可以被直接抛出的，在3.x时代，只有继承自BaseException的对象才可以被抛出。
- 2.x raise语句使用逗号将抛出对象类型和参数分开，3.x取消了这种奇葩的写法，直接调用构造函数抛出对象即可。
在2.x时代，异常在代码中除了表示程序错误，还经常做一些普通控制结构应该做的事情，在3.x中可以看出，设计者让异常变的更加专一，只有在错误发生的情况才能去用异常捕获语句来处理。
5.不等运算符
Python 2.x中不等于有两种写法 != 和 <>
Python 3.x中去掉了<>, 只有!=一种写法
6.去掉了repr表达式Python 2.x 中反引号相当于repr函数的作用
Python 3.x 中去掉了``这种写法，只允许使用repr函数
7.多个模块被改名
StringIO模块现在被合并到新的io模组内。 new, md5, gopherlib等模块被删除。 Python 2.6已经支援新的io模组。
httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib被合并到http包内。
取消了exec语句，只剩下exec()函数。 Python 2.6已经支援exec()函数。
8.数据类型
1）Py3.X去除了long类型，现在只有一种整型——int，但它的行为就像2.X版本的long
2）新增了bytes类型，对应于2.X版本的八位串
3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函数都被废弃。同时去掉的还有 dict.has_key()，用 in替代它吧 。
如何理解迭代器和生成器？
可以直接作用于for循环的对象统称为可迭代对象：Iterable。含有iter方法
迭代器：含有iter和next的对象就是迭代器
生成器:生成器其实是一种特殊的迭代器，不过这种迭代器更加优雅。它不需要再像上面的类一样写iter()和next()方法了，只需要一个yiled关键字。是可迭代对象,实现了延迟计算,生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处
闭包
闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。
当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点:
必须有一个内嵌函数
内嵌函数必须引用外部函数中的变量
外部函数的返回值必须是内嵌函数
什么是装饰器
装饰器的本质 ：闭包函数
功能：就是在不改变原函数调用方式的情况下，在这个函数前后加上扩展功能
实际上是一种设计模式，开放封闭原则，对扩展是开放的，对修改是封闭的
请写一个装饰器打印输出一个函数执行的时间
#装饰器的本质就是一个闭包函数，在不改变原函数的调用方式和源代码的情况下，在这个函数前后加上扩展功能
import time
def wrapepr(fun):
def inner(*args,**kwargs):
start=time.time()
fun()
end=time.time()
print('执行时间%s'%(end-start))
return inner
@wrapepr
def aa():
time.sleep(1)
print('aa.....')
aa()
什么是进程，线程,协程？
进程:正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。
线程:程序执行流的最小操作，每个进程有一个地址空间，而且默认就有一个控制线程，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。
协程:是单线程下的并发，又称微线程，纤程协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的,
如何在Python中拷贝一个对象，并说说他们的区别
https://www.cnblogs.com/ctztake/p/8194275.html
赋值:只是创建一个变量，该变量指向原来内存地址
浅拷贝:，在内存中只额外创建第一层数据 copy.copy()
深拷贝:在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化） copy.deepcopy()
请简单解释python中的staticmethod(静态方法)和classmethod(类方法)
普通方法 默认有一个self对象传进来，并且只能被对象调用——绑定到对象
类方法 用@classmethod装饰，默认有一个cls传进来表示本类，并且可以被类和对象（不推荐）调用——绑定到类
静态方法 用@staticmethod装饰，没有默认参数，并且可以被类和对象（不推荐）调用——非绑定
对列表元素去重并保持原先顺序
l=[1,2,3,4,1,2,5,7,8,4,6]
s=set(l)
l1=list(s)
l1.sort(key=l.index)
print(l1)
*args和**kwargs分别代表什么,举例说明**kwargs的用法
*args:表示按照位置传值多出来的值都给args,且以元祖的方式呈现
**kwargs:表示按照关键字传值把多余的传值都给kwargs以字典的方式呈现
def f(*args,**kwargs):
print(args) # ('xm', 21)
print(kwargs) # {"addr": "sz", "school": "qh"}
f('xm',21,addr='sz',school='qh')
什么是lambda函数？它有什么好处?
lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数
lambda函数：首要用途是指点短小的回调函数
lambda [arguments]:expression
>>> a=lambdax,y:x+y
>>> a(3,11)
>>>14
Python中pass语句的作用是什么？
pass语句不会执行任何操作，一般作为占位符或者创建占位程序，
whileFalse:
pass
Python 正则模块re里面的match()和search()的区别？
re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。
re模块中search(pattern,string[,flags]),在string搜索pattern的第一个匹配值。
>>>print(re.match(‘super’, ‘superstition’).span())
(0, 5)
>>>print(re.match(‘super’, ‘insuperable’))
None
>>>print(re.search(‘super’, ‘superstition’).span())
(0, 5)
>>>print(re.search(‘super’, ‘insuperable’).span())
(2, 7)
下面代码会输出什么：
def f(x,l=[]):
for i in range(x):
l.append(i*i)
print l
f(2)
f(3,[3,2,1])
f(3)
答案：
[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]
谈谈python类的继承
经典类: 没有继承object类的类都叫做经典类
新式类: 继承object类的类叫做新式类
python3中统一都是新式类,pyhon2中才分新式类与经典类
python允许多继承
class A(object):
def test(self):
print('from A')
class B(A):
def test(self):
print('from B')
class C(A):
def test(self):
print('from C')
class D(B):
def test(self):
print('from D')
class E(C):
def test(self):
print('from E')
class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类
阅读下面的代码，它的输出结果是什么？
class A(object):
def go(self):
print "go A go!"
def stop(self):
print "stop A stop!"
def pause(self):
raise Exception("Not Implemented")
class B(A):
def go(self):
super(B, self).go()
print "go B go!"
class C(A):
def go(self):
super(C, self).go()
print "go C go!"
def stop(self):
super(C, self).stop()
print "stop C stop!"
class D(B,C):
def go(self):
super(D, self).go()
print "go D go!"
def stop(self):
super(D, self).stop()
print "stop D stop!"
def pause(self):
print "wait D wait!"
class E(B,C): pass
a = A()
b = B()
c = C()
d = D()
e = E()
说明下列代码的输出结果
a.go()
b.go()
c.go()
d.go()
e.go()
a.stop()
b.stop()
c.stop()
d.stop()
e.stop()
a.pause()
b.pause()
c.pause()
d.pause()
e.pause()
答案
输出结果以注释的形式表示：
a.go()
# go A go!
b.go()
# go A go!
# go B go!
c.go()
# go A go!
# go C go!
d.go()
# go A go!
# go C go!
# go B go!
# go D go!
e.go()
# go A go!
# go C go!
# go B go!
a.stop()
# stop A stop!
b.stop()
# stop A stop!
c.stop()
# stop A stop!
# stop C stop!
d.stop()
# stop A stop!
# stop C stop!
# stop D stop!
e.stop()
# stop A stop!
a.pause()
# ... Exception: Not Implemented
b.pause()
# ... Exception: Not Implemented
c.pause()
# ... Exception:
Not Implemented
d.pause()
# wait D wait!
e.pause()
# ...Exception: Not Implemented
描述对super、pass、yield、lambda关键字修饰的理解
super:在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用 super 来实现,
事实上，super 和父类没有实质性的关联。
super(cls, inst) 获得的是 cls 在 inst 的 MRO 列表中的下一个类。
pass 不做任何事情，一般用做占位语句
yield 是一个类似 return 的关键字，他不会终止当前函数,只是这个函数返回的是个生成器。yield可以保存状态,当下次执行时会从上次执行玩的地方开始执行
lamda表达式就是定义一个匿名函数,数据结构简单,可作为函数的参数
大致描述一下python GIL的机制
GIL全局解释器锁,本质也是互斥锁，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全，有了GIL的存在，同一时刻同一进程中只有一个线程被执行
GIL对性能的影响：
对于计算密集性来说,开多线程不能提高效率，甚至可能不如串行(因为要来回切换)，
但对于io密集性来说,开启多线程可以明显提高效率,因为遇到io得阻塞,阻塞时间远大于程序执行时间,所欲GIL对IO密集来说,影响不是很大
python中多线程和多进程的区别
- 线程共享创建它的进程的地址空间; 进程有自己的地址空间。
2.线程可以直接访问其进程的数据; 进程具有自己的父进程的数据的副本。
3.线程可以直接与其进程的其他线程通信; 进程必须使用进程间通信来与兄弟进程进行通信。
4.新线程很容易创建; 新进程需要父进程的副本。线程创建开销小
5.线程可以对相同进程的线程进行相当的控制; 进程只能控制子进程。
6.对主线程的更改（取消，优先级更改等）可能会影响进程的其他线程的行为; 对父进程的更改不会影响子进程。
请用两个队列来实现一个栈
class Stock:
def __init__(self):
self.queueA=[]
self.queueB=[]
def push(self, node):
self.queueA.append(node)
def pop(self):
if len(self.queueA)==0:
return None
while len(self.queueA)!=1:
self.queueB.append(self.queueA.pop(0))
self.queueA,self.queueB=self.queueB,self.queueA #交换是为了下一次的pop
return self.queueB.pop()
请用两个栈实现一个队列
class Queue:
def __init__(self):
self.stockA=[]
self.stockB=[]
def push(self, node):
self.stockA.append(node)
def pop(self):
if self.stockB==[]:
if self.stockA==[]:
return None
else:
for i in range(len(self.stockA)):
self.stockB.append(self.stockA.pop())
return self.stockB.pop()