共计 16033 个字符，预计需要花费 41 分钟才能阅读完成。
1、为什么学习 Python？
人生苦短？人间不值得？想想自己的初心吧！
2、通过什么途径学习的 Python？
官网、网上视频、学习网站、论坛、大牛的辅导
3、Python 和 Java、PHP、C、C#、C++ 等其他语言的对比？
（1）、python 代码，简介，明确，优雅，简单易懂
（2）、开发效率高
（3）、可扩展性强
4、简述解释型和编译型编程语言？
解释型：在执行程序时，计算机才一条一条的将代码解释成机器语言给计算机来执行
编译型：是把源程序的每一条语句都编译成机器语言，并保存成二进制文件，这样计算机运行该程序时可以直接以机器语言来运行此程序，运行速度很快。
5、Python 解释器种类以及特点？
Cpython，IPython，Jpython，pypy，Ironpython
Python 是一门解释器语言，代码想运行，必须通过解释器执行，Python 存在多种解释器，分别基于不同语言开发，每个解释器有不同的特点，但都能正常运行 Python 代码，以下是常用的五种 Python 解释器：
CPython：当 从 Python 官方网站下载并安装好 Python2.7 后，就直接获得了一个官方版本的解
释器：Cpython，这个解释器是用 C 语言开发的，所以叫 CPython，在命名行下运行 python，就是启动 CPython 解释器，CPython 是使用最广的 Python 解释器。IPython：IPython 是基于 CPython 之上的一个交互式解释器，也就是说，IPython 只是在交互方
式上有所增强，但是执行 Python 代码的功能和 CPython 是完全一样的，好比很多国产浏览器
虽然外观不同，但内核其实是调用了 IE。PyPy：PyPy 是另一个 Python 解释器，它的目标是执行速度，PyPy 采用 JIT 技术，
对 Python 代进行动态编译，所以可以显著提高
Python 代码的执行速度。Jython：Jython 是运行在 Java 平台上的 Python 解释器，可以直接把 Python 代码编译成 Java 字节码执行。
IronPython：IronPython 和 Jython 类似，只不过 IronPython 是运行在微软.Net 平台上的 Python 解释器，
可以直接把 Python 代码编译成.Net 的字节码。在 Python 的解释器中，使用广泛的是 CPython，对于 Python 的编译，除了可以采用以上解释器
进行编译外，技术高超的开发者还可以按照自己的需求自行编写 Python 解释器来执行 Python 代码，十分的方便！
6、位和字节的关系？
一个字节 = 8 位
7、b、B、KB、MB、GB 的关系？
1B(字节) = 8b(位)
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
8、请至少列举 5 个 PEP8 规范
（1）、缩进：每一级 4 个缩进。连续跨行应该使用圆括号或大括号或者使用悬挂缩进。
（2）、代码长度约束
一行列数：PEP8 规定最大为 79 列，如果拼接 url 很容易超限
一个函数：不可以超过 30 行；直观来讲就是完整显示一个函数一个屏幕就够了，不需要上下拖动
一个类：不要超过 200 行代码，不要超过 10 个方法
一个模块：不要超过 500 行（3）、import
不要在一句 import 中引用多个库（4）、命名规范
（5）、注释
总体原则，错误的注释不如没有注释。所以当一段代码发生变化时，第一件事就是要修改注释！9、通过代码实现如下转换：
答案：二进制转换成十进制：v =“0b1111011”
print(int('0b1111011',2))
十进制转换成二进制：v = 18
print(bin(18))
八进制转换成十进制：v =“011”print(int('011',8))
十进制转换成八进制：v = 30
print(oct(30))
十六进制转换成十进制：v =“0x12”print(int('0x12',16))
十进制转换成十六进制：v = 87
print(hex(87))
10、请编写一个函数实现将 IP 地址转换成一个整数。
如 10.3.9.12 转换规则为：
10 00001010
3 00000011
9 00001001
12 00001100
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 =？
答案：
def func(x):
lis = x.strip().split('.')
li = [bin(int(i)) for i in lis]
li2 = [i.replace('0b',(10-len(i))*'0') for i in li]
return int(''.join(li2),2)
ret = func('10.3.9.12')
print(ret)
11、python 递归的最大层数？
一般计算机默认的最大递归深度在 1000 左右，python 最大递归深度一般在 4000 左右，跟计算
机的性能有关系，这个数不是一个定数，可通过一下方式测试
import sys
print(sys.getrecursionlimit())
print(sys.setrecursionlimit(10000))
12、求结果：
v1 = 1 or 3 ————–>1
v2 = 1 and 3————–>3
v3 = 0 and 2 and 1——–>0
v4 = 0 and 2 or 1———>1
v5 = 0 and 2 or 1 or 4—->1
v6 = 0 or Flase and 1—–>False
13、ascii、unicode、utf-8、gbk 区别？
ASCII 码：使用一个字节编码，所以它的范围基本是只有英文字母、数字和一些特殊符号，只有 256 个字符。
Unicode：能够表示全世界所有的字节
GBK：是只用来编码汉字的，GBK 全称《汉字内码扩展规范》，使用双字节编码。
UTF-8：是一种针对 Unicode 的可变长度字符编码，又称万国码。
14、字节码和机器码的区别？
机器码：是电脑 CPU 直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂
字节码：是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。
15、三元运算规则以及应用场景？
规则：为真时的结果 if 判定条件 else 为假时的结果 ` 应用场景：在赋值变量的时候，可以直接加判断，然后赋值 `
16、列举 Python2 和 Python3 的区别？
1、默认编码：2–>ascii，3–>utf-8
2、print 的区别：python2 中 print 是一个语句，不论想输出什么，直接放到 print 关键字后面即可。python3 里，print()是一个函数，
像其他函数一样，print()需要你将要输出的东西作为参数传给它。3、input 的区别：
python2 有两个全局函数，用在命令行请求用户输入。第一个叫 input()，它等待用户输入一个 python 表达式(然后返回结果)。第二个叫做 raw_input(), 用户输入什么他就返回什么。python3 通过 input 替代了他们。4、字符串：python2 中有两种字符串类型：Unicode 字符串和非 Unicode 字符串。Python3 中只有一种类型：Unicode 字符串。
5、xrange()
python2里，有两种方法获得一定范围内的数字：range(), 返回一个列表，还有 xrange(), 返回一个迭代器。python3 里，range()返回迭代器，xrange()不再存在。17、用一行代码实现数值交换：
a = 1
b = 2答案：a = 1
b = 2
a,b = b,a
18、Python3 和 Python2 中 int 和 long 的区别？
python2 有非浮点数准备的 int 和 long 类型。int 类型最大
值不能超过 sys.maxint，而且这个最大值是平台相关的。
可以通过在数字的末尾附上一个L来定义长整型，显然，它比 int 类型表示的数字范围更大。在 python3 里，
只有一种整数类型 int, 大多数情况下，和 python2中的长整型类似。
学习过程中会遇到很多问题，你可以到我们的 python 学习 -q-u-n-784758214，基础，进阶。好友都会在里面交流，分享一些学习的方法和需要注意的小细节，每天也会准时讲一些项目实战案例。
19、xrange 和 range 的区别？
python2里，有两种方法获得一定范围内的数字：range(), 返回一个列表，还有 xrange(), 返回一个迭代器。
python3 里，range()返回迭代器，xrange()不再存在。
20、文件操作时：xreadlines 和 readlines 的区别？
readlines 返回一个 list，xreadlines 方法返回一个生成器
21、列举布尔值为 False 的常见值？
0, [] , () , {} , ” , False , None
22、字符串、列表、元组、字典每个常用的 5 个方法？
字符串：repleace,strip,split,reverse,upper,lower,join…..
列表：append,pop,insert,remove,sort,count,index…..
元组：index,count,__len__(),__dir__()
字典：get,keys,values,pop,popitems,clear,update,items…..
23、lambda 表达式格式以及应用场景？
表达式格式：lambda 后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式。冒号前是参数，冒号后是返回值。例如：lambda x : 2x
应用场景：经常与一些内置函数相结合使用，比如说 map(),filter(),sorted(),reduce()等
24、pass 的作用？
1、空语句 do nothing
2、保证格式完整
3、保证语义完整
25、arg 和 *kwarg 作用？
万能参数，解决了函数参数不固定的问题
*arg：会把位置参数转化为 tuple
**kwarg：会把关键字参数转化为 dict
26、is 和 == 的区别？
is: 判断内存地址是否相等
==：判断数值是否相等
27、简述 Python 的深浅拷贝以及应用场景？
copy()：浅 copy，浅拷贝指仅仅拷贝数据集合的第一层数据
deepcopy(): 深 copy, 深拷贝指拷贝数据集合的所有层
28、Python 垃圾回收机制？
python 采用的是引用计数机制为主，标记 - 清除和分代收集 (隔代回收、分代回收) 两种机制为辅的策略
计数机制
Python 的 GC 模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记 - 清除”解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。标记 - 清除：
标记 - 清除的出现打破了循环引用，也就是它只关注那些可能会产生循环引用的对象
缺点：该机制所带来的额外操作和需要回收的内存块成正比。隔代回收
原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。29、python 的可变类型和不可变类型？
不可变类型（数字、字符串、元组、不可变集合）
可变类型（列表、字典、可变集合）
30、求结果：
v = dict.fromkeys([‘k1′,’k2’],[])
v[‘k1’].append(666)
print(v)
v[‘k1’] = 777
print(v)
答案：{'k1':[666],'k2':[666]}
{'k1':777,'k2':[666]}
解析：formkeys()默认参数为可变数据类型时有坑
31、求结果：
def num():
return [lambda x: i*x for i in range(4)]
print([m(2) for m in num()])
答案：[6, 6, 6, 6]
解析：问题的本质在与 python 中的属性查找规则，LEGB（local，enclousing，global，bulitin），在上面的例子中，i 就是在闭包作用域（enclousing），而 Python 的闭包是 迟绑定，这意味着闭包中用到的变量的值，是在内部函数被调用时查询得到的
所以：[lambda x: i*x for i in range(4)]打印出来是含有四个内存地址的列表，每个内存地址中的 i
在在本内存中都没有被定义，而是通过闭包作用域中的 i 值，当 for 循环执行结束后，i 的值等于 3，所以
再执行 [m(2) for m in num()] 时，每个内存地址中的 i 值等于 3，当 x 等于 2 时，打印出来的结果都是 6，从而得到结果[6, 6, 6, 6]。32、列举常见的内置函数？
map,filter,zip,len,bin,oct,hex,int,float,bool,sum,min,max,str,list,tuple,dict,range,next,hash,help,id…..
33、filter、map、reduce 的作用？
filter(function，iterable)过滤函数
map(function，iterable) 循环函数
reduce(function, iterable) 累积函数
34、一行代码实现 9 * 9 乘法表。
lis = [‘%s%s=%s’%(i,j,ij) for i in range(1,10) for j in range(i,10)]
35、如何安装第三方模块？以及用过哪些第三方模块？
pip3 imstall 模块名
django，Matplotlib，Tornado，PyGame
36、至少列举 8 个常用模块都有那些？
os,sys,time,random,re,hashlib,logging,json,pickle….
37、re 的 match 和 search 区别？
match: 从字符串的开头位置匹配，必须以此为开头
search: 从开头开始查，找到符合的就返回结果
38、什么是正则的贪婪匹配？
正则表达式一般趋向于最大长度匹配
39、求结果：
a. [i % 2 for i in range(10) ] ===>[0,1,0,1,0,1,0,1,0,1]
b. (i % 2 for i in range(10) )===> 返回一个生成器的内存地址
40、求结果：
a. 1 or 2 =========>1
b. 1 and 2 ========>2
c. 1 < (2==2)======>false
d. 1 < 2 == 2======>ture
41、def func(a,b=[]) 这种写法有什么坑？
def func(a,b=[]):
b.append(a)
print(b)函数的第二个默认参数是一个 list，当第一次执行的时候实例化了一个 list，
第二次执行还是用第一次执行的时候实例化的地址存储，以后每次实例化都是
学习过程中会遇到很多问题，你可以到我们的 python 学习 -q-u-n-784758214，基础，进阶。好友都会在里面交流，分享一些学习的方法和需要注意的小细节，每天也会准时讲一些项目实战案例。
42、如何实现 “1,2,3” 变成 [‘1′,’2′,’3’] ?
a = “1,2,3”
li = a.split(‘,’)
43、如何实现 [‘1’,’2’,’3’] 变成[1,2,3] ?
li = [‘1′,’2′,’3’]
lis = list(map(lambda x:int(x) li))
44、比较：a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？
a = [1,2,3]正常的列表
b = [(1),(2),(3)] 虽然列表的每个元素加上了括号，但是当括号内只有一个元素并且没有逗号时，其数据类型是元素本身的数据类型
b = [(1,),(2,),(3,)] 列表中的元素类型都是元组类型
45、如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
li = [x*x for x in range(1,11)]
46、一行代码实现删除列表中重复的值 ?
li = [1, 1, 1, 23, 3, 4, 4]
new_li = list(set(li))
new_li.sort(key=li.index)
47、如何在函数中设置一个全局变量 ?
使用 python 的内置语法 globals 全局变量
48、logging 模块的作用？以及应用场景？
logging 模块的作用：
1、程序调试
2、了解软件程序运行情况，是否正常
3、软件程序运行故障分析与问题定位
应用场景：网站的运维工作，程序实时监控
49、请用代码简答实现 stack。
def Stack(object):
def __init__(self):
self.stack = []
def push(self,value):
# 进栈
self.stack.append(value)
def pop(self):
# 出栈
if self.stack:
self.stack.pop()
else:
raise LookupError('stack is empty!')
def is_empty(self):
# 查看 stack 是否为空
reture bool(self.stack)
def top(self):
# 取出 stack 中最新的值
return self.stack[-1]
50、常用字符串格式化哪几种？
1、%s %d
2、format 格式化输出
3、print(f’ 内容{变量名}’)
51、简述 生成器、迭代器、可迭代对象 以及应用场景？
生成器：在 Python 中，一边循环一边计算的机制，称为 生成器（generator），
通过 next()取值，两种表现形式 1、将列表生成式的 [] 改为()2、含有 yield 关键字的函数
应用场景：优化代码，节省内存迭代器：是访问集合元素的一种方式。迭代器同时实现了__iter__和__next__方法
可迭代对象：只要实现了__iter__方法的对象就是可迭代对象
52、用 Python 实现一个二分查找的函数。
lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17]
def two_find(x, lis, start=0, end=None):
if end == None:end = len(lis) - 1
num = (end - start) // 2 + start
if end > start:
if lis[num] > x:
return two_find(x, lis, start=start, end=num)
elif lis[num] < x:
return two_find(x, lis, start=num + 1, end=end)
elif lis[num] == x:
return num
elif lis[end] == x:return end
else:return None
print(two_find(17, lis))
53、谈谈你对闭包的理解？
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。
但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
54、os 和 sys 模块的作用？
os 模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;
sys 模块负责程序与 python 解释器的交互，提供了一系列的函数和变量，用于操控 python 的运行时环境。
55、如何生成一个随机数？
import random
def rdm(n):
lis = []
for i in range(n):
n = random.randint(1,9)
lis.append(str(n))
s = ''.join(lis)
return int(s)
56、如何使用 python 删除一个文件？
import os
os.remove(r’path’)
57、谈谈你对面向对象的理解？
面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，
不存在的也可以创造出来。对象是特征和技能的结合，其中特征和技能分别对应对象的数据属性和方法属性。
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，
面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。
58、Python 面向对象中的继承有什么特点？
1：在继承中基类的构造 (__init__() 方法)不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。
区别于在类中调用普通函数时并不需要带上 self 参数3：Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
(先在本类中查找调用的方法，找不到才去基类中找)。59、面向对象深度优先和广度优先是什么？
Python 的类可以继承多个类，那么其寻找类方法的方式有两种：
当类是经典类时(主要在 python2 版本中的没有主动继承 object 的类)，多继承情况下，会按照深度优先方式查找
当类是新式类时(python3 版本中的所有类和 python2 中主动继承 object 的类)，多继承情况下，会按照广度优先方式查找
简单点说就是：经典类是纵向查找，新式类是横向查找
60、面向对象中 super 的作用？
1、super 在面向对象继承类中代指父类，书写方法 super(类名,self). 属性或者方法或 super(). 属性或者方法
2、super 方法可以增加类之间调用的灵活性，当父类名发生变化时不必修改
3、super 方法在类的多继承时可以简化代码，避免代码冗余
4、super 机制里可以保证公共父类仅被执行一次，执行的顺序遵循 MRO，广度优先查询方法
61、是否使用过 functools 中的函数？其作用是什么？
functools 用于高阶函数：指那些作用于函数或者返回其他函数的函数。通常情况下，只要是
可以被当做函数调用的对象就是这个模块的目标。
62、列举面向对象中带双下划线的特殊方法，如：new、init
__new__：构造方法，创建一个对象，实例化时第一个被执行，返回一个创建好的对象及__init__(self)的 self，
只有继承了 object 的类才会有这个方法__init__：初始化方法，__init__在__new__的基础上完成一些其它初始化的动作，__init__没有返回值
63、如何判断是函数还是方法？
函数和方法都封装了一些独立的功能，如果在类中定义的函数那就是方法(对象或者类名点方法名调用)，
否则就是函数 (函数名() 直接调用)
64、静态方法和类方法区别？
静态方法：是既不是用类中的属性又不使用对象中的属性，由类或者对象调用的方法，依赖 python 装饰器 @staticmethod 来实现
类方法：只使用类中的静态变量，一般都是由类调用，依赖 python 装饰器 @classmethod 来实现
65、列举面向对象中的特殊成员以及应用场景？
__call__：对象的构造方法，对象加上()，可以触发这个类的__call__方法。
__len__：内置函数的 len 函数是依赖类中的__len__方法
__eq__：判断值是否相等的时候依赖__eq__方法
__hash__: 判断 hash 值是否相等的时候依赖__hash__方法(拓展：set 的去重机制其实就是根据__hash__和__eq__方法实现的)
__str__：和 str() print() %s 都是息息相关的，返回值一定是字符串类型
__repr__：和 repr() %r 都是息息相关的，在没有__str__方法时，__repr__可以完全取代__str__。
del 析构方法，对应着一个对象的删除之前执行的内容
66、1、2、3、4、5 能组成多少个互不相同且无重复的三位数
count = 0
for i in range(1,6):
for j in range(1,6):
for k in range(1,6):
if (i != j) and (i != k) and (j != k):
count += 1
if count % 6:
print(f'{i}{j}{k}', end='|')
else:
print(f'{i}{j}{k}')print(count)
67、什么是反射？以及应用场景？
定义：通过用字符串数据类型的变量名来访问这个变量的值，在 python 面向对象中的反射, 通过字符串的形式操作对象相关的属性或方法.
应用场景：用于处理通过用户输入，文件读取，或者网络传输所得到的字符串形式的指令来完成对应的操作
68、metaclass 作用？以及应用场景？
metaclass，直译为元类，简单的解释就是：当我们定义了类以后，就可以根据这个类创建出实例，
所以：先定义类，然后创建实例。但是如果我们想创建出类呢？那就必须根据 metaclass 创建出类，
所以：先定义 metaclass，然后创建类。换句话说，你可以把类看成是 metaclass 创建出来的“实例”
69、用尽量多的方法实现单例模式。
1、基于__new__()方法
class Person:
def __new__(cls, *args, **kwargs):
if not hasattr(cls,cls._instance):
# cls._instance = object.__new__(cls)
cls._instance = super().__new__(cls)
return cls._instance2、基于模块导入方式，现在一个 py 文件中写好一个类，实例化一个对象。以后用这个类直接导入这个模块就是单例模式。
3、基于装饰器方法实现
def singleton(cls, *args, **kwargs):
instance_dic = {}
def inner(*args, **kwargs):
if cls not in instance_dic:
instance_dic['cls'] = cls(*args, **kwargs)
return instance_dic['cls']
return inner
@singleton
class Person:
pass
70、装饰器的写法以及应用场景。
装饰器的写法：
def wrapper(func):
def inner(*args,**kwargs):
'被装饰之前的操作'
ret = func(*args,**kwargs)
'被装饰之后的操作'
return ret
return inner
装饰器的应用场景：
比如注册登录、插入日志，性能测试，事务处理，缓存等等场景
71、异常处理写法以及如何主动跑出异常（应用场景）
异常处理的常规写法：
try:
执行的主体函数
except Exception as e:
print(str(e))
主动抛出异常：raise TypeError('出现了不可思议的异常')#TypeError 可以是任意的错误类型
72、什么是面向对象的 mro
MRO(Method Resolution Order 方法解析顺序)是面向对象中用于查询类的多继承的继承顺序的方法，它是基于算法来实现的，不同的算法实现的 MRO 的顺序不同
73、isinstance 作用以及应用场景？
isinstance 作用是来判断一个对象是否是一个已知的类型
74、写代码并实现：
Given an array of integers, return indices of the two numbers such that they add up to a specific target.
You may assume that each input would have exactly one solution, and you may not use the same element twice.
Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1]
代码实现
def func(li,target):
try:
for i in range(0,len(li)):
num = target-li[i]
if num in li:
return [i,li.index(num)]
except:print('li 类型为数组类型，内的元素需是整型，target 也为整型，请检查')
else:return None
75、json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？
1、可以处理的数据类型是 string、int、list、tuple、dict、bool、null
2、定制支持 datetime 类型
————————– 官方文档的 memo———————————————–
>>> import json
>>> class ComplexEncoder(json.JSONEncoder):
... def default(self, obj):
... if isinstance(obj, complex):
... return [obj.real, obj.imag]
... return json.JSONEncoder.default(self, obj)
...
>>> dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
>>> list(ComplexEncoder().iterencode(2 + 1j))
['[', '2.0', ',', '1.0', ']']import json
import datetime
ret = datetime.datetime.now()
class CJsonEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime.date):
return obj.strftime('%Y-%m-%d %H:%M:%S')
else:
return json.JSONEncoder.default(self, obj)
print(json.dumps(ret,cls=CJsonEncoder))
76、json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？
在序列化是将 json.dumps 中的默认参数 ensure_ascii 改为 False 就可以保留中文了
json.dumps(obj,ensure_ascii=False)
学习过程中会遇到很多问题，你可以到我们的 python 学习 -q-u-n-784758214，基础，进阶。好友都会在里面交流，分享一些学习的方法和需要注意的小细节，每天也会准时讲一些项目实战案例。
77、什么是断言？应用场景？
assert 条件,’ 自定义错误提示 (可有可无)’ 例：assert 1 == 0,’ 这是一个低级的错误 ’
合约式设计是断言的经典应用，在一个正确的程序里，所有的前置条件和后置条件都将得到处理。
78、使用代码实现查看列举目录下的所有文件。
方法一：递归处理
import os
url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\ 前段学习'
def check_file(url,li = []):
if os.path.isdir(url):
file_list = os.listdir(url)
for ret in file_list:
base_url = os.path.join(url,ret)
if os.path.isfile(base_url):
li.append(ret)
else: check_file(base_url)
return li
else:return os.path.basename(url)
方法二：堆栈的思想处理
import os
url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\python 基础'
lis = [url]
while lis:
url = lis.pop()
ret_list = os.listdir(url)
for name in ret_list:
abs_path = os.path.join(url,name)
if os.path.isdir(abs_path):
lis.append(abs_path)
else:print(name)
79、简述 yield 和 yield from 关键字。
yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器当你调用这个函数的时候，
函数内部的代码并不立马执行，这个函数只是返回一个生成器对象，当你使用 for 进行迭代的时候，
函数中的代码才会执行
yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来，
这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。
有了这个结构，协程可以通过以前不可能的方式委托职责。
80、代码实现六位随机验证码
import random
s = ''
for i in range(6):
num = random.randint(0,9)
alpha1 = chr(random.randint(65,90))
alpha2 = chr(random.randint(97,122))
ret = random.choice([num,alpha1,alpha2])
s += str(ret)
print(s)
81、代码实现随机发红包功能
import random
def red_packge(money,num):
li = random.sample(range(1,money*100),num-1)
li.extend([0,money*100])
li.sort()
return [(li[index+1]-li[index])/100 for index in range(num)]
ret = red_packge(100,10)
print(ret)
-------------------------- 生成器版 -------------------------------------------
import random
def red_packge(money,num):
li = random.sample(range(1,money*100),num-1)
li.extend([0,money*100])
li.sort()
for index in range(num):
yield (li[index+1]-li[index])/100
ret = red_packge(100,10)
print(ret)
82、请尽可能列举 python 列表的成员方法，并给出列表操作的答案：
（1）a=[1, 2, 3, 4, 5], a[::2]=？a[-2:]=？a[::2]=[1,3,5],
a[-2:] = [4,5]（2）一行代码实现对列表 a 中的偶数位置的元素进行加 3 后求和？sum([i+3 for i in a[::2]])（3）将列表 a 的元素顺序打乱，再对 a 进行排序得到列表 b，然后把 a 和 b 按元素顺序构造一个字典 d。import random
random.shuffle(a)
b=a.sort()
d={}
for i in range(len(a)):d[a[i]] = b[i]83、Python 自省
自省就是面向对象的语言所写的程序在运行时，就能知道对象的类型。也就是程序运行时能够获得对象的类型。比如 type()，dir()，getattr()，hasattr()，isinstance()。
84、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，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。
85、介绍一下 except 的用法和作用？
try…except…except…else…
— 执行 try 下的语句，如果引发异常，则执行过程会跳到 except 语句。对每个 except 分支顺序尝试执行，如果引发的异常与 except 中的异常组匹配，执行相应的语句。如果所有的 except 都不匹配，则异常会传递到下一个调用本代码的最高层 try 代码中。
— try 下的语句正常执行，则执行 else 块代码。如果发生异常，就不会执行
— 如果存在 finally 语句，最后总是会执行。
86、如何用 Python 来进行查询和替换一个文本字符串？
可以使用 re 模块中的 sub()函数或者 subn()函数来进行查询和替换，比 replace 的功能更强大！！！
格式：sub(replacement, string[,count=0])（replacement 是被替换成的文本，string 是需要被替换的文本，count 是一个可选参数，指最大被替换的数量）
import re
p=re.compile("blue|white|red")
print(p.sub('colour','blue socks and red shoes'))
print(p.sub('colour','blue socks and red shoes',count=1))subn()方法执行的效果跟 sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量
87、有没有一个工具可以帮助查找 python 的 bug 和进行静态的代码分析？
PyChecker 是一个 python 代码的静态分析工具，它可以帮助查找 python 代码的 bug, 会对代码的复杂度和格式提出警告
Pylint 是另外一个工具可以进行 codingstandard 检查
