基本 Python 面试问题

1、为什么学习Python？

人生苦短....哈哈,自己想吧！！！

emmm。。。来真的

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()

    python２里，有两种方法获得一定范围内的数字：range(),返回一个列表，还有xrange(),返回一个迭代器。

    python3　里，range()返回迭代器，xrange()不再存在。

更多不同：https://www.cnblogs.com/weikunzz/p/6857971.html

17、用一行代码实现数值交换：

a = 1

b = 2

答案：a = 1

b = 2

a,b = b,a

18、Python3和Python2中 int 和 long的区别？

python2有非浮点数准备的int和long类型。int类型最大值不能超过sys.maxint，而且这个最大值是平台相关的。`

可以通过在数字的末尾附上一个Ｌ来定义长整型，显然，它比int类型表示的数字范围更大。在python3里，`

只有一种整数类型int,大多数情况下，和python２中的长整型类似。

19、xrange和range的区别？

python２里，有两种方法获得一定范围内的数字：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,i*j) 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，

第二次执行还是用第一次执行的时候实例化的地址存储，以后每次实例化都是

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 = []
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">push</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,value)</span></span>:

    <span class="hljs-comment"># 进栈</span>

    <span class="hljs-keyword">self</span>.stack.append(value)

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">pop</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span>:

    <span class="hljs-comment"># 出栈</span>

    <span class="hljs-keyword">if</span> <span class="hljs-keyword">self</span>.<span class="hljs-symbol">stack:</span>

        <span class="hljs-keyword">self</span>.stack.pop()

    <span class="hljs-symbol">else:</span>

        raise LookupError(<span class="hljs-string">'stack is empty!'</span>)

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">is_empty</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span>:

    <span class="hljs-comment"># 查看stack是否为空</span>

    reture bool(<span class="hljs-keyword">self</span>.stack)

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">top</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span>:

    <span class="hljs-comment"># 取出stack中最新的值</span>

    <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.stack[-<span class="hljs-number">1</span>]</code></pre>


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 binary_search(li, val):


low = 0


high = len(li)-1


while low <= high:


mid = (low + high) // 2


if li[mid] < val:


low = mid + 1


elif li[mid] > val:


high = mid - 1


else:


return mid


return None
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._instance

2、基于模块导入方式，现在一个py文件中写好一个类，实例化一个对象。以后用这个类直接导入这个模块就是单例模式。

3、基于装饰器方法实现

    def singleton(cls, *args, **kwargs):

        instance_dic = {}
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">inner</span><span class="hljs-params">(*args, **kwargs)</span>:</span>

        <span class="hljs-keyword">if</span> cls <span class="hljs-keyword">not</span> <span class="hljs-keyword">in</span> instance_dic:

            instance_dic[<span class="hljs-string">'cls'</span>] = cls(*args, **kwargs)

        <span class="hljs-keyword">return</span> instance_dic[<span class="hljs-string">'cls'</span>]

    <span class="hljs-keyword">return</span> 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))</code></pre>


76、json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？
在序列化是将json.dumps中的默认参数ensure_ascii改为False就可以保留中文了

json.dumps(obj,ensure_ascii=False)
77、什么是断言？应用场景？
assert 条件,'自定义错误提示(可有可无)' 例：assert 1 == 0,'这是一个低级的错误'

合约式设计是断言的经典应用，在一个正确的程序里，所有的前置条件和后置条件都将得到处理。
78、使用代码实现查看列举目录下的所有文件。
方法一：递归处理

    import os

    url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\前段学习'
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">check_file</span><span class="hljs-params">(url,li = [])</span>:</span>

    <span class="hljs-keyword">if</span> os.path.isdir(url):

        file_list = os.listdir(url)

        <span class="hljs-keyword">for</span> ret <span class="hljs-keyword">in</span> file_list:

            base_url = os.path.join(url,ret)

            <span class="hljs-keyword">if</span> os.path.isfile(base_url):

                li.append(ret)

            <span class="hljs-keyword">else</span>: check_file(base_url)

        <span class="hljs-keyword">return</span> li

    <span class="hljs-keyword">else</span>:<span class="hljs-keyword">return</span> os.path.basename(url)


方法二：堆栈的思想处理


import os


url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\python基础'
lis = [url]

<span class="hljs-keyword">while</span> lis:

    url = lis.pop()

    ret_list = os.listdir(url)

    <span class="hljs-keyword">for</span> name <span class="hljs-keyword">in</span> ret_list:

        abs_path = os.path.join(url,name)

        <span class="hljs-keyword">if</span> os.path.isdir(abs_path):

            lis.append(abs_path)

        <span class="hljs-keyword">else</span>:print(name)</code></pre>


79、简述 yield和yield from关键字。
yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器当你调用这个函数的时候，

函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，当你使用for进行迭代的时候，

函数中的代码才会执行

yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来，


这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。


有了这个结构，协程可以通过以前不可能的方式委托职责。


更多解析详见：http://blog.gusibi.com/post/python-coroutine-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,money100),num-1)


li.extend([0,money100])


li.sort()


for index in range(num):


yield (li[index+1]-li[index])/100

ret = red_packge(100,10)


print(ret)
补充
1、请尽可能列举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]
2、 Python自省
自省就是面向对象的语言所写的程序在运行时，就能知道对象的类型。也就是程序运行时能够获得对象的类型。比如type()，dir()，getattr()，hasattr()，isinstance()。
3、Python是如何进行内存管理的？

从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制

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))