Python面试题,第一部分:基础篇(80题)

第一部分 Python基础篇(80题)

1、为什么学习Python?

高层语言 :无需考虑如何管理你的程序使用的内存一类的底层细节等。

可移植性 :由于Python的开源本质,它已经被移植在许多平台上。

面向对象 :Python既支持面向过程的编程也支持面向对象的编程。

可扩展性 :Python编辑的程序中可以直接调用部分C或C++ 开发的程序。

可嵌入性 :可以把Python嵌入C/C++程序,从而向程序用户提供脚本功能。

丰富的库 : Python庞大的标准库可以帮助处理各种工作,几乎无所不能。

规范的代码 : Python不需要编译成二进制代码的强制缩进方式,使得代码具有较好的可读性。

自己说:来自某培训机构的宣传。

当然,不管我们通过什么渠道,方式开始学习Python,我们都应当坚持下去。

2、通过什么途径学习的Python?

参考下面两篇知乎文章:
1,关于 Python 的经典入门书籍有哪些?
2,怎么用最短时间高效而踏实地学习 Python?
自己说:Python确实是门语法简洁优美,入门简单的语言,但如何写出极具Pythonic风格的代码,是需要耐心学习,刻苦练习的,
如果有其他语言基础的话,自己觉得看书的效率更高,当然,通过视频当然更适合理解晦涩难懂的概念,虽然Python中并不多。

3、Python和Java、PHP、C、C#、C++等其他语言的对比?

 C语言,它既有高级语言的特点,又具有汇编语言的特点,它是结构式语言。C语言应用指针:可以直接进行靠近硬件的操作,
 但是C的指针操作不做保护,也给它带来了很多不安全的因素。C++在这方面做了改进,在保留了指针操作的同时又增强了安全性,
 受到了一些用户的支持,但是,由于这些改进增加语言的复杂度,也为另一部分所诟病。Java则吸取了C++的教训,取消了指针操作,
 也取消了C++改进中一些备受争议的地方,在安全性和适合性方面均取得良好的效果,但其本身解释在虚拟机中运行,运行效率低于C++/C。
 一般而言,C,C++,java被视为同一系的语言,它们长期占据着程序使用榜的前三名。

C语言的优点:简洁紧凑、灵活方便;运算符丰富;数据类型丰富;表达方式灵活实用;允许直接访问物理地址,对硬件进行操作;
生成目标代码质量高,程序执行效率高;可移植性好;表达力强;

C语言的缺点:C语言的缺点主要表现在数据的封装性上,这一点使得C在数据的安全性上有很大缺陷,这也是C和C++的一大区别。
C语言的语法限制不太严格,对变量的类型约束不严格,影响程序的安全性,对数组下标越界不作检查等。从应用的角度,
C语言比其他高级语言较难掌握。也就是说,对用C语言的人,要求对程序设计更熟练一些。


C#语言,C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。
C#看起来与Java有着惊人的相似;它包括了诸如单一继承、接口、与Java几乎同样的语法和编译成中间代码再运行的过程。
但是C#与Java有着明显的不同,它借鉴了Delphi的一个特点,与COM(组件对象模型)是直接集成的,
而且它是微软公司 .NET windows网络框架的主角。首先,C# 和JAVA一样,简直就是照搬了C++的部分语法,
因此,对于数量众多的C++程序员学习起来很容易上手,另外,对于新手来说,比C++要简单一些。
其次,Windows是占垄断地位的平台,而开发Windows应用,当然微软的声音是不能忽略的。最重要的是,
相对于C++,用C# 开发应用软件可以大大缩短开发周期,同时可以利用原来除用户界面代码之外的C++代码。


Java语言,Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaSE, JavaEE, JavaME)的总称。
Java 技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网,
同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下,Java更具备了显著优势和广阔前景。
Java的优势,与传统程序不同,Sun 公司在推出 Java 之际就将其作为一种开放的技术。全球数以万计的 Java 开发公司被要求所设计的 Java软件必须相互兼容。
“Java 语言靠群体的力量而非公司的力量”是Sun公司的口号之一,并获得了广大软件开发商的认同。这与微软公司所倡导的注重精英和封闭式的模式完全不同。

Sun 公司对 Java 编程语言的解释是:Java 编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言。

php语言,PHP(PHP: Hypertext Preprocessor的缩写,中文名:“PHP:超文本预处理器”)是一种通用开源脚本语言。语法吸收了C语言、Java和Perl的特点,
入门门槛较低,易于学习,使用广泛,主要适用于Web开发领域。

特性:PHP 独特的语法混合了 C、Java、Perl 以及 PHP 自创新的语法;PHP可以比CGI或者Perl更快速的执行动态网页——动态页面方面,
与其他的编程语言相比,PHP是将程序嵌入到HTML文档中去执行,执行效率比完全生成htmL标记的CGI要高许多,PHP具有非常强大的功能,
所有的CGI的功能PHP都能实现; PHP支持几乎所有流行的数据库以及操作系统;最重要的是PHP可以用C、C++进行程序的扩展。

python语言,是一种面向对象、直译式计算机程序设计语言,Python语法简洁而清晰,具有丰富和强大的类库。它常被昵称为胶水语言,
它能够很轻松的把用其他语言制作的各种模块(尤其是C/C++)轻松地联结在一起。
常见的一种应用情形是,使用python快速生成程序的原型(有时甚至是程序的最终界面),然后对其中有特别要求的部分,用更合适的语言改写。

Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承,有益于增强源代码的复用性。
Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言,Python对函数式设计只提供了有限的支持。
有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。Python本身被设计为可扩充的。
并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和工具,以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。
Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此,很多人还把Python作为一种“胶水语言”(glue language)使用。
使用Python将其他语言编写的程序进行集成和封装
自己说:内容来自C、C++、C#、Java、php、python语言的内在特性及区别
参考阅读:
编程语言拟人化(1):Java、C++、Python、Ruby、PHP、C#、JS
趣文:编程语言拟人化(第二弹)

4、简述解释型和编译型编程语言?

概念:

    编译型语言:把做好的源程序全部编译成二进制代码的可运行程序。然后,可直接运行这个程序。
    解释型语言:把做好的源程序翻译一句,然后执行一句,直至结束!

区别:

    编译型语言,执行速度快、效率高;依赖编译器、跨平台性差些。如C、C++、Delphi、Pascal,Fortran。
    解释型语言,执行速度慢、效率低;依赖解释器、跨平台性好。如Java、Basic.

通俗的讲,编译语言是在编译后可以直接运行,而解释语言的执行需要一个解释环境。

 java很特殊,java程序也需要编译,但是没有直接编译称为机器语言,而是编译称为字节码,然后用解释方式执行字节码。

**********************************************************************************************

计算机不能直接理解高级语言,只能直接理解机器语言,所以必须要把高级语言翻译成机器语言,计算机才能值型高级语言编写的程序。

翻译的方式有两种,一个是编译,一个是解释。两种方式只是翻译的时间不同。编译型语言写的程序执行之前,
需要一个专门的编译过程,把程序编译成为机器语言的文件,比如exe文件,
以后要运行的话就不用重新翻译了,直接使用编译的结果就行了(exe文件),因为翻译只做了一次,
运行时不需要翻译,所以编译型语言的程序执行效率高。

解释则不同,解释性语言的程序不需要编译,省了道工序,解释性语言在运行程序的时候才翻译,
比如解释性basic语言,专门有一个解释器能够直接执行basic程序,
每个语句都是执行的时候才翻译。这样解释性语言每执行一次就要翻译一次,效率比较低。

编译型与解释型,两者各有利弊。前者由于程序执行速度快,同等条件下对系统要求较低,
因此像开发操作系统、大型应用程序、数据库系统等时都采用它,像C/C++、Pascal/Object Pascal(Delphi)等都是编译语言,
而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、
对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言,如JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等等。
详细介绍:
编译型与解释型、动态语言与静态语言、强类型语言与弱类型语言的区别
简述编译型与解释型编程语言

5、Python解释器种类以及特点?

当我们编写Python代码时,我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码,就需要Python解释器去执行.py文件。

由于整个Python语言从规范到解释器都是开源的,所以理论上,只要水平够高,任何人都可以编写Python解释器来执行Python代码(当然难度很大)。
事实上,确实存在多种Python解释器。
1,CPython

当我们从Python官方网站下载并安装好Python 3.5后,我们就直接获得了一个官方版本的解释器:CPython。
这个解释器是用C语言开发的,所以叫CPython。在命令行下运行python就是启动CPython解释器。
CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

2,IPython
IPython是基于CPython之上的一个交互式解释器,也就是说,IPython只是在交互方式上有所增强,但是执行Python代码的功能和CPython是完全一样的。
好比很多国产浏览器虽然外观不同,但内核其实都是调用了IE。
CPython用>>>作为提示符,而IPython用In [序号]:作为提示符。

3,PyPy

PyPy是另一个Python解释器,它的目标是执行速度。PyPy采用JIT技术,对Python代码进行动态编译(注意不是解释),
所以可以显著提高Python代码的执行速度。绝大部分Python代码都可以在PyPy下运行,
但是PyPy和CPython有一些是不同的,这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。
如果你的代码要放到PyPy下执行,就需要了解PyPy和CPython的不同点。

4,Jython
Jython是运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行。

5,IronPython
IronPython和Jython类似,只不过IronPython是运行在微软.Net平台上的Python解释器,可以直接把Python代码编译成.Net的字节码。

小结:
Python的解释器很多,但使用最广泛的还是CPython。如果要和Java或.Net平台交互,最好的办法不是用Jython或IronPython,
而是通过网络调用来交互,确保各程序之间的独立性。

6、位和字节的关系?

最小的存储单位称为位(bit):
只能容纳两个值(0或1)之一,不能在一个位中存储更多的信息。位是计算机存储的基本单位。
字节(byte)是常用的计算机存储单位。
字节的标准定义:一个字节均为8位。由于上述所讲每个位或者是0或者是1,所以一个8位的字节包含256种可能的0,1组合

7、b、B、KB、MB、GB 的关系?

1024B=1KB,1024KB=1MB,
1024MB=1GB,1024GB=1TB.
他们是计算机中表示容量的单位。都是2的10次方进制的。
他们可以用来表示内存、硬盘等的容量。

8、请至少列举5个 PEP8 规范(越多越好)。

代码规范主要是以下几点:

一 代码编排

二 文档编排

三 空格的使用

四 注释

五 文档描述

六 命名规范

详细介绍:
PEP 8 – Style Guide for Python Code
PEP8 Python 编码规范整理

9、通过代码实现如下转换:

二进制转换成十进制:v = “0b1111011”

十进制转换成二进制:v = 18

八进制转换成十进制:v = “011”

十进制转换成八进制:v = 30

十六进制转换成十进制:v = “0x12”

十进制转换成十六进制:v = 87

参考阅读:
Python各进制间的转换
Python实现任意进制之间的转换

10、请编写一个函数实现将IP地址转换成一个整数。


 如 10.3.9.12 转换规则为:



  10           00001010

  3            00000011

  9            00001001

  12           00001100

再将以上二进制拼接起来计算十进制结果:00001010 00000011 00001001 00001100 = ?

def ipTodec(ip):
    """
    :param ip: char IP地址:192.168.1.1
    :return:
    """
    dec_ips = ip.split('.')
    bin_ips = " "

    for decnum in dec_ips:
        bin_ele = bin(int(decnum))[2::]
        bin_ips += bin_ele

    print(bin_ips)
    print(int(bin_ips, 2))
自己说:自己写的,可能不太好。

11、python递归的最大层数?

Python确实有递归次数限制,默认最大次数为1000
但可以使用下面的方法来指定次数。
sys.setrecursionlimit(limit)

Set the maximum depth of the Python interpreter stack to limit. This limit prevents infinite recursion from causing an overflow of the C stack and crashing Python.

The highest possible limit is platform-dependent. A user may need to set the limit higher when she has a program that requires deep recursion and a platform that supports a higher limit. This should be done with care, because a too-high limit can lead to a crash.

参考阅读:
28.1. sys — System-specific parameters and functions

12、求结果:

 v1 = 1 or 3

 v2 = 1 and 3

 v3 = 0 and 2 and 1

 v4 = 0 and 2 or 1

 v5 = 0 and 2 or 1 or 4

 v6 = 0 or False and 1

1
3
0
1
1
False
参考阅读:
python中and-or语法

13、ascii、unicode、utf-8、gbk 区别?

最早只有127个字母被编码到计算机里,也就是大小写英文字母、数字和一些符号,这个编码表被称为ASCII编码,

比如大写字母A的编码是65,小写字母z的编码是122。

但是要处理中文显然一个字节是不够的,至少需要两个字节,而且还不能和ASCII编码冲突,

所以,中国制定了GB2312编码,用来把中文编进去。

你可以想得到的是,全世界有上百种语言,日本把日文编到Shift_JIS里,韩国把韩文编到Euc-kr里,

各国有各国的标准,就会不可避免地出现冲突,

结果就是,在多语言混合的文本中,显示出来会有乱码。

因此,Unicode应运而生。Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。

Unicode标准也在不断发展,但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符,就需要4个字节)。

现代操作系统和大多数编程语言都直接支持Unicode。新的问题又出现了:如果统一成Unicode编码,乱码问题从此消失了。

但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。

所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。

UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,

常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。

如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间。

UTF-8编码有一个额外的好处,就是ASCII编码实际上可以被看成是UTF-8编码的一部分,

所以,大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。
详细介绍:
ASCII,Unicode 和 UTF-8 的故事
字符串和编码

14、字节码和机器码的区别?

什么是机器码
机器码

机器码(machine code),学名机器语言指令,有时也被称为原生码(Native Code),是电脑的CPU可直接解读的数据。

通常意义上来理解的话,机器码就是计算机可以直接执行,并且执行速度最快的代码。

用机器语言编写程序,编程人员要首先熟记所用计算机的全部指令代码和代码的涵义。手编程序时,
程序员得自己处理每条指令和每一数据的存储分配和输入输出,
还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作,
编写程序花费的时间往往是实际运行时间的几十倍或几百倍。
而且,编出的程序全是些0和1的指令代码,直观性差,还容易出错。
现在,除了计算机生产厂家的专业人员外,绝大多数的程序员已经不再去学习机器语言了。

    机器语言是微处理器理解和使用的,用于控制它的操作二进制代码。
    8086到Pentium的机器语言指令长度可以从1字节到13字节。
    尽管机器语言好像是很复杂的,然而它是有规律的。
    存在着多至100000种机器语言的指令。这意味着不能把这些种类全部列出来。

总结:机器码是电脑CPU直接读取运行的机器指令,运行速度最快,但是非常晦涩难懂,也比较难编写,一般从业人员接触不到。

什么是字节码
字节码

字节码(Bytecode)是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码,
它比机器码更抽象,需要直译器转译后才能成为机器码的中间代码。

通常情况下它是已经经过编译,但与特定机器码无关。字节码通常不像源码一样可以让人阅读,而是编码后的数值常量、引用、指令等构成的序列。

字节码主要为了实现特定软件运行和软件环境、与硬件环境无关。字节码的实现方式是通过编译器和虚拟机器。编译器将源码编译成字节码,
特定平台上的虚拟机器将字节码转译为可以直接执行的指令。字节码的典型应用为Java bytecode。

字节码在运行时通过JVM(JAVA虚拟机)做一次转换生成机器指令,因此能够更好的跨平台运行。

总结:字节码是一种中间状态(中间码)的二进制代码(文件)。需要直译器转译后才能成为机器码。
参考阅读:
机器码和字节码
Python 源码剖析 - 字节码和虚拟机

15、三元运算规则以及应用场景?

三元运算符就是在赋值变量的时候,可以直接加判断,然后赋值
格式:[on_true] if [expression] else [on_false]
res = 值1 if 条件 else 值2
1.举例说明:
a =1
b = 2

c= a if a>1 else b #如果a大于1的话,c=a,否则c=b

16、列举 Python2和Python3的区别?

     一、python2  的代码混乱 重复较多 冗余  因为当时来编写的人有C 语言的大牛 和 java的大牛等各种大神 
     所以里面都含有各种语言的影子
     python3  经过龟叔的一个暑假的整理 终于在2008年11月 统一了代码  源码规范 清晰 简单优美。 

    二、python3  print("内容")
           python2 ptint()   或者print '内容'

   三、python3 编码:utf-8
          python2编码: 默认编码:ascii     解决办法:在首行 #    -*- ending:utf-8-*-

   四、用户交互 input
          python2:  raw-input()

          python3:input ()  

五、python2x  :unicode 默认2个字节表示一个字符  可以在LINUX 编译安装时做调整
      python3x:unicode 默认是4个字节表示一个字符 

六、python2x  没有nonlocal
      python3x   加入的

七 、python3x  新建的包里面的init文件如果你删除该文件  包照样可以被调用
        python2x  新建的包如果没有init文件 则包不能够被调用 直接报错

八、python2 中的经典类 遍历方法是以深度优先    新式类是以广度优先 
      python3 中不存在经典类  所有的类都是新式类  所以都是广度优先
详细介绍:
Python2和Python3的差异

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

a = 1

b = 2

a, b = b, a

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

Python 2有为非浮点数准备的int和long类型。int类型的最大值不能超过sys.maxint,而且这个最大值是平台相关的。
可以通过在数字的末尾附上一个L来定义长整型,显然,它比int类型表示的数字范围更大。在Python 3里,
只有一种整数类型int,大多数情况下,它很像Python 2里的长整型。由于已经不存在两种类型的整数,
所以就没有必要使用特殊的语法去区别他们。

Notes      Python 2              Python 3

①     x =1000000000000L       x =1000000000000

②     x =0xFFFFFFFFFFFFL       x =0xFFFFFFFFFFFF

③         long(x)                 int(x)

④       type(x)is long          type(x)is int

⑤     isinstance(x,long)     isinstance(x,int)

在Python 2里的十进制长整型在Python 3里被替换为十进制的普通整数。
在Python 2里的十六进制长整型在Python 3里被替换为十六进制的普通整数。
在Python 3里,由于长整型已经不存在了,自然原来的long()函数也没有了。
为了强制转换一个变量到整型,可以使用int()函数。
检查一个变量是否是整型,获得它的数据类型,并与一个int类型(不是long)的作比较。
你也可以使用isinstance()函数来检查数据类型;再强调一次,使用int,而不是long,来检查整数类型。

19、xrange和range的区别?

range产生的是一个列表,而xrange产生的是一个生成器器的。

所以对于较大的集合时候,xrange比range性能好。

因为range一次把所以数据都返回,而xrange每次调用返回其中的一个值

20、文件操作时:xreadlines和readlines的区别?

原理同19题一样。

21、列举布尔值为False的常见值?

False  None  0 ‘’ “” [] {} ()

22、字符串、列表、元组、字典每个常用的5个方法?

str   .join()  .split()  .lower()  .upper()  .strip()
list   .append()  .pop()  .reverse() .sort()  .remove()
tuple  .index()  .count()  len(atuple)  max(atuple)  min(tuple)
dict   .get()  .keys()  .values()  .iters()  .update()

23、lambda表达式格式以及应用场景?

python 使用 lambda 表达式来创建匿名函数

lambda只是一个表达式,函数体比def简单很多
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
lambda函数拥有自己的名字空间,且不能访问自有参数列表之外或全局名字空间里的参数
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,
后者的目的是调用小函数时不占用栈内存从而增加运行效率

lambda函数的语法只包含一个语句: lambda [arg1 [,arg2,…..argn]]:expression 

lambda 函数与Python的函数式编程有很大联系,比如:map(), reduce(), filter()
参考阅读:
python中lambda表达式应用

24、pass的作用?

Python pass是空语句,是为了保持程序结构的完整性。

pass 不做任何事情,一般用做占位语句。

25、*arg和**kwarg作用?

可变参数 *args 允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple,

而 关键字参数 **kwargs 允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。

26、is和==的区别?

Python中的对象包含三要素:id、type、value
其中id用来唯一标识一个对象,type标识对象的类型,value是对象的值
is判断的是a对象是否就是b对象,是通过id来判断的
==判断的是a对象的值是否和b对象的值相等,是通过value来判断的

简单说就是:
is 对比地址   ==  对比值

27、简述Python的深浅拷贝以及应用场景?

= 赋值:数据完全共享(=赋值是在内存中指向同一个对象,如果是可变(mutable)类型,
比如列表,修改其中一个,另一个必定改变, 
如果是不可变类型(immutable),比如字符串,修改了其中一个,另一个并不会变

浅拷贝:数据半共享(复制其数据独立内存存放,但是只拷贝成功第一层)

深拷贝:数据完全不共享(复制其数据完完全全放独立的一个内存,完全拷贝,数据不共享)
参考阅读:
Python深浅拷贝

28、Python垃圾回收机制?

Python GC主要使用引用计数(reference counting)来跟踪和回收垃圾。在引用计数的基础上,
通过“标记-清除”(mark and sweep)解决容器对象可能产生的循环引用问题,
通过“分代回收”(generation collection)以空间换时间的方法提高垃圾回收效率。

1 引用计数

PyObject是每个对象必有的内容,其中ob_refcnt就是做为引用计数。
当一个对象有新的引用时,它的ob_refcnt就会增加,
当引用它的对象被删除,它的ob_refcnt就会减少.
引用计数为0时,该对象生命就结束了。

优点:

    简单
    实时性

缺点:

    维护引用计数消耗资源
    循环引用

2 标记-清除机制

基本思路是先按需分配,等到没有空闲内存的时候从寄存器和程序栈上的引用出发,
遍历以对象为节点、以引用为边构成的图,把所有可以访问到的对象打上标记,
然后清扫一遍内存空间,把所有没标记的对象释放。
3 分代技术

分代回收的整体思想是:将系统中的所有内存块根据其存活时间划分为不同的集合,每个集合就成为一个“代”,
垃圾收集频率随着“代”的存活时间的增大而减小,存活时间通常利用经过几次垃圾回收来度量。

Python默认定义了三代对象集合,索引数越大,对象存活时间越长。

举例: 当某些内存块M经过了3次垃圾收集的清洗之后还存活时,我们就将内存块M划到一个集合A中去,
而新分配的内存都划分到集合B中去。
当垃圾收集开始工作时,大多数情况都只对集合B进行垃圾回收,
而对集合A进行垃圾回收要隔相当长一段时间后才进行,
这就使得垃圾收集机制需要处理的内存少了,效率自然就提高了。
在这个过程中,集合B中的某些内存块由于存活时间长而会被转移到集合A中,
当然,集合A中实际上也存在一些垃圾,这些垃圾的回收会因为这种分代的机制而被延迟。

29、Python的可变类型和不可变类型?

Python的每个对象都分为可变和不可变,
主要的核心类型中,
不可变 : 数字、字符串、元组
可变 : 列表、字典

对不可变类型的变量重新赋值,实际上是重新创建一个不可变类型的对象,
并将原来的变量重新指向新创建的对象(如果没有其他变量引用原有对象的话(即引用计数为0),原有对象就会被回收)。

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]}
该题上面的几道题的综合考察,请仔细思考一下。

31、求结果:

32、列举常见的内置函数?

abs()     divmod()     input()     open()     staticmethod()
all()     enumerate()     int()     ord()     str()
any()     eval()     isinstance()     pow()     sum()
basestring()     execfile()     issubclass()     print()     super()
bin()     file()     iter()     property()     tuple()
bool()     filter()     len()     range()     type()
bytearray()     float()     list()     raw_input()     unichr()
callable()     format()     locals()     reduce()     unicode()
chr()     frozenset()     long()     reload()     vars()
classmethod()     getattr()     map()     repr()     xrange()
cmp()     globals()     max()     reverse()     zip()
compile()     hasattr()     memoryview()     round()     __import__()
complex()     hash()     min()     set()     
delattr()     help()     next()     setattr()     
dict()     hex()     object()     slice()     
dir()     id()     oct()     sorted()

33、filter、map、reduce的作用?

filter(function, sequence):对sequence中的item依次执行function(item),将执行结果为True的item组成一个List/String/Tuple(取决于sequence的类型)。

filter(function or None, sequence) -> list, tuple, or string:入参为函数和列表/元组/字符串,返回值为item列表/元组/字符串。

map(function, sequence) :对sequence中的item依次执行function(item),将执行结果function(item)组成一个List返回。

map(function, sequence[, sequence, ...]) -> list:入参是为函数和列表/元组/字符串,返回值为function(item)列表。

reduce(function, sequence, starting_value):对sequence中的item顺序迭代调用function,如果有starting_value,还可以作为初始值调用。function接收的参数个数只能为2,先把sequence中第一个值和第二个值当参数传给function,再把function的返回值和第三个值当参数传给function,然后只返回一个结果。

reduce(function, sequence[, initial]) -> value:入参是为函数和列表/元组/字符串和初始值,返回值为数值。
参考阅读:不得不知的python高阶函数(Map、Reduce、Filter)

34、一行代码实现9*9乘法表?

print("\n".join("\t".join(["%s*%s=%s" % (x, y, x * y) for y in range(1, x + 1)]) for x in range(1, 10)))
自己说:看起来不是那么好理解。

35、如何安装第三方模块?以及用过哪些第三方模块?

参考阅读:安装第三方模块

36、至少列举8个常用模块都有哪些?

os , sys, time, random, logging

37、re的match和search区别?

re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。

re模块中research(pattern,string[,flags]),在string搜索pattern的第一个匹配值。

38、什么是正则的贪婪匹配?

如:String str="abcaxc";

Patter p="ab*c";

贪婪匹配:正则表达式一般趋向于最大长度匹配,也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str,结果就是匹配到:abcaxc(ab*c)。
非贪婪匹配:就是匹配到结果就好,就少的匹配字符。如上面使用模式p匹配字符串str,结果就是匹配到:abc(ab*c)。

编程中如何区分两种模式

默认是贪婪模式;在量词后面直接加上一个问号?就是非贪婪模式。
参考阅读:Python 正则表达式之三:贪婪

39、求结果:

a: [ i % 2 for i in range(10) ]

b: ( i % 2 for i in range(10) )

a: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
b: <generator object <genexpr> at 0x011A3E40>
自己说:对于a就是个列表表达式,b则是个元组生成器
参考阅读:python之字典、列表、元组生成器的使用

40、求结果:

a. 1 or 2

b. 1 and 2

c. 1 < (2==2)

d. 1 < 2 == 2

1
2
False
True
参考阅读:python中and-or语法

41、def func(a,b=[]) 这种写法有什么坑?

Pycharm的语法警告:
Default argument value is mutable less... (Ctrl+F1) 
This inspection detects when a mutable value as list or dictionary is detected in a default value for an argument.
Default argument values are evaluated only once at function definition time, which means that 
modifying the default value of the argument will affect all subsequent calls of the function
最后一句的翻译:这意味着修改参数的默认值将影响函数的所有后续调用
网友解释:
b=[] 不是空的意思 就是默认创建了一个长度为0的list 这个在定义函数的时候就创建了 
又因为创建的b是一个变量 而且是不可变的对象 
也就是始终指向同一地址 所以每次调用函数得到的b都会改变
所以:建议b的默认值为None

42、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?

astring = “1,2,3”
list(astring.split(','))

43、如何实现[‘1’,’2’,’3’]变成[1,2,3] ?

map(int, [‘1’,’2’,’3’])

44、比较: a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别?

自己说:能力有限,但可以看出,a, b相同,a, b都是list,所包含的元素都为int, 最后边的b包含的元素是tuple

45、如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?

[x*x for x in range(1, 11)]

46、一行代码实现删除列表中重复的值 ?

alist = [6,9,3,6,5,4,78,5,4,4,4]
list(set(alsit))

47、如何在函数中设置一个全局变量 ?

global var

48、logging模块的作用?以及应用场景?

Python的logging模块提供了通用的日志系统,可以方便第三方模块或者是应用使用。
这个模块提供不同的日志级别,并可以采用不同的方式记录日志,
比如文件,HTTP GET/POST,SMTP,Socket等,甚至可以自己实现具体的日志记录方式。

日志是一种可以追踪某些软件运行时所发生事件的方法。软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情。
一个事件可以用一个可包含可选变量数据的消息来描述。此外,事件也有重要性的概念,这个重要性也可以被称为严重性级别(level)。

1.日志的作用

通过log的分析,可以方便用户了解系统或软件、应用的运行情况;如果你的应用log足够丰富,
也可以分析以往用户的操作行为、类型喜好、地域分布或其他更多信息;如果一个应用的log同时也分了多个级别,
那么可以很轻易地分析得到该应用的健康状况,及时发现问题并快速定位、解决问题,补救损失。
简单来讲就是,我们通过记录和分析日志可以了解一个系统或软件程序运行情况是否正常,
也可以在应用程序出现故障时快速定位问题。比如,做运维的同学,在接收到报警或各种问题反馈后,
进行问题排查时通常都会先去看各种日志,大部分问题都可以在日志中找到答案。再比如,做开发的同学,
可以通过IDE控制台上输出的各种日志进行程序调试。对于运维老司机或者有经验的开发人员,
可以快速的通过日志定位到问题的根源。可见,日志的重要性不可小觑。日志的作用可以简单总结为以下3点:

    程序调试
    了解软件程序运行情况,是否正常
    软件程序运行故障分析与问题定位

如果应用的日志信息足够详细和丰富,还可以用来做用户行为分析,
如:分析用户的操作行为、类型洗好、地域分布以及其它更多的信息,
由此可以实现改进业务、提高商业利益。
参考阅读: Python之logging模块

49、请用代码解答实现stack 。

Python: 3.x

class stack(object):


    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):
        return self.items[-1]

    def size(self):
        return len(self.items)

50、常用字符串格式化哪几种?

1.最方便的
    print 'hello %s and %s' % ('df', 'another df')  

但是,有时候,我们有很多的参数要进行格式化,这个时候,一个一个一一对应就有点麻烦了,于是就有了第二种,字典形式的。上面那种是tuple形式的。

2.最好用的
    print 'hello %(first)s and %(second)s' % {'first': 'df', 'second': 'another df'}  

这种字典形式的字符串格式化方法,有一个最大的好处就是,字典这个东西可以和json文件相互转换,所以,当配置文件使用字符串设置的时候,就显得相当方便。

3.最先进的
    print 'hello {first} and {second}'.format(first='df', second='another df')  
自己说:内容来自python的三种字符串格式化方法
参考阅读:Python字符串格式化的两种方式

51、简述 生成器、迭代器、可迭代对象 以及应用场景?

一:语法糖
从字面上看应该是一种语法。“糖”,可以理解为简单、简洁。其实我们也已经意识到,
没有这些被称为“语法糖”的语法,我们也能实现相应的功能,而 “语法糖”使我们可以更加简洁、快速的实现这些功能。
只是Python解释器会把这些特定格式的语法翻译成原本那样复杂的代码逻辑而已,没有什么太高深的东西。
像列表推导式,字典推导式,元组生成器,以及生成器,迭代器应该都是语法糖。

二:生成器(generator)
生成器是构造迭代器的最简单有力的工具,与普通函数不同的只有在返回一个值的时候使用yield来替代return,
然后yield会自动构建好next()和iter()。

三:迭代器(iterator)
迭代器是通过next()来实现的,每调用一次他就会返回下一个元素,当没有下一个元素的时候返回一个StopIteration异常,
所以实际上定义了这个方法的都算是迭代器。

四:可迭代对象(iterable)
Python中经常使用for来对某个对象进行遍历,此时被遍历的这个对象就是可迭代对象,
像常见的list,tuple都是。如果给一个准确的定义的话,就是只要它定义了可以返回一个迭代器的__iter__方法,
或者定义了可以支持下标索引的__getitem__方法(这些双下划线方法会在其他章节中全面解释),
那么它就是一个可迭代对象。
值得一提的是,这就是Python中的多态,而且Python非常推崇鸭子类型。
参考阅读:Python迭代器,可迭代对象,生成器

52、用Python实现一个二分查找的函数。

def binary_search(alist, key)

    low, high = 0, 0
    mid = len(alist) - 1
    time = 0

    while low < high:
        time += 1
        mid = (low + high) // 2
        if alist[mid] < key:
            low = mid + 1
        elif alist[mid] > key:
            high = mid - 1
        else:
            print("Search {} times!\n".format(time))
            return mid

    print("No Search {} times!\n".format(time))
    return False

53、谈谈你对闭包的理解?

闭包需要满足的条件:

    1. 必须有一个内嵌函数
    2. 内嵌函数必须引用外部函数中的变量
    3. 外部函数的返回值必须是内嵌函数

闭包的概念不太好理解,自己也似懂非懂。请参考下面的阅读。
参考阅读:闭包_百度百科
Python 中的闭包 - Python - 伯乐在线
谈谈自己的理解:python中闭包,闭包的实质 - 稀里糊涂林老冷 - 博客园

54、os和sys模块的作用?

两者的主要区别:
os模块负责程序与操作系统的交互,提供了访问操作系统底层的接口,
sys模块负责程序与Python解释器的交互,提供了一系列的函数和变量,用于操控python的运行时环境。

参考阅读:os和sys模块-君醉-博客园

55、如何生成一个随机数?

Python中使用Random模块来生成随机数
常用的方法有:.randint(), .random(), .randrange(), .sample(), .seed(), .uniform()

56、如何使用python删除一个文件?

使用os模块中的remove方法,注意判断文件是否存在,是否具有权限。

57、谈谈你对面向对象的理解?

    面向对象编程,即OOP,是一种编程范式,满足面向对象编程的语言,
    一般会提供类、封装、继承等语法和概念来辅助我们进行面向对象编程。

    面向对象是基于万物皆对象这个哲学观点. 所谓的面向对象就是将我们的程序模块化,对象化,
    把具体事物的特性属性和通过这些属性来实现一些动作的具体方法放到一个类里面

    面向对象的三大特征 继承,封装,多态

    一 继承
        继承概念:一个类继承另一个类,则称继承的类为子类,被继承的类为父类。
        目的:实现代码的复用。
        理解:子类与父类的关系并不是日常生活中的父子关系,子类与父类而是一种特殊化与一般化的关系,
        是is-a的关系,子类是父类更加详细的分类。如 class dog 继承于 animal,
        就可以理解为dog is a animal.注意设计继承的时候.

        结果:继承后子类自动拥有了父类的属性和方法,子类可以写自己特有的属性和方法,
        目的是实现功能的扩展,子类也可以复写父类的方法即方法的重写。

    二 封装

        概念:封装也称为信息隐藏,是指利用抽象数据类型将数据和基于数据的操作封装在一起,
        使其构成一个不可分割的独立实体,数据被保护在抽象数据类型的内部,尽可能地隐藏内部的细节,
        只保留一些对外接口使之与外部发生联系。
        系统的其他部分只有通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。
        也就是说,用户无需知道对象内部方法的实现细节,但可以根据对象提供的外部接口(对象名和参数)访问该对象。

        好处:(1)实现了专业的分工。将能实现某一特定功能的代码封装成一个独立的实体后,
        各程序员可以在需要的时候调用,从而实现了专业的分工。
        (2)隐藏信 息,实现细节。通过控制访问权限可以将可以将不想让客户端程序员看到的信息隐藏起来,
        如某客户的银行的密码需要保密,只能对该客户开发权限。

    三、多态
        概念:相同的事物,调用其相同的方法,参数也相同时,但表现的行为却不同。
        理解:子类以父类的身份出现,但做事情时还是以自己的方法实现。
        子类以父类的身份出现需要向上转型(upcast),其中向上转型是由JVM自动实现的, 
        是安全的,但向下转型(downcast)是不安全的,需要强制转换。
        子类以父类的身份出现时自己特有的属性和方法将不能使用。

    “面向过程”和“面向对象”的区别
        面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,
        使用的时候一个一个依次调用就可以了;面向对象是把构成问题事务分解成各个对象,
        建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为
        。 
        可以拿生活中的实例来理解面向过程与面向对象,例如五子棋,面向过程的设计思路就是首先分析问题的步骤:
            1、开始游戏,2、黑子先走,3、绘制画面,4、判断输赢,5、轮到白子,6、绘制画面,7、判断输赢,
            8、返回步骤 2,9、输出最后结果。把上面每个步骤用不同的方法来实现。

            如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来 解决问题。
            整个五子棋可以分为
            1、黑白双方,这两方的行为是一模一样的,
            2、棋盘系统,负责绘制画面,
            3、规则系统,负责判定诸如犯规、输赢等。第一类对 象(玩家对象)负责接受用户输入,
            并告知第二类对象(棋盘对象)棋子布局的变化,棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化,
            同时利用 第三类对象(规则系统)来对棋局进行判定。
参考阅读:我对面向对象的理解-往事亦如风

58、Python面向对象中的继承有什么特点?

自己简单知道Pytho能多重继承,即继承多个父类,由此也存在MRO(方法解析顺序)问题,多重继承往往与super()方法一起提及 
参考阅读:Python继承概念的这些优缺点你知道吗?

59、面向对象深度优先和广度优先是什么?

这个涉及到经典类与新式类中的MRO(方法解析顺序)问题,请看下面的参考阅读。
参考阅读:你真的理解Python中MRO算法吗?

60、面向对象中super的作用?

super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,
但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
参考阅读:Python super()函数
Python: 你不知道的 super

61、是否使用过functools中的函数?其作用是什么?

这个自己也不太清楚,请参考下面的参考阅读。
Python标准模块–functools
Python-进阶-functools模块小结

62、列举面向对象中带爽下划线的特殊方法,如:newinit

_init__(self,...) 、__del__(self) 、__call__(self, *args) 、__str__(self, 方法)
__add__、__dic__、__getitem__、__setitem__、__delitem__、__iter__
参考阅读:Python面向对象5:特殊方法

63、如何判断是函数还是方法?

通过type()可以知道对象所属的类型,函数是<class 'function'>,方法是<class 'method'>

64、静态方法和类方法区别?

实例方法只能被实例对象调用,静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法),可以被类或类的实例对象调用。
实例方法,第一个参数必须要默认传实例对象,一般习惯用self。
静态方法,参数没有要求。
类方法,第一个参数必须要默认传类,一般习惯用cls。
参考阅读:python类的静态方法和类方法区别

65、列举面向对象中的特殊成员以及应用场景?

1.__doc__ :打印类的描述信息

2.__module__:表示当前操作的对象在那个模块

3.__class__:表示当前操作的对象的类是什么

4. __init__ :构造方法,通过类创建对象时,自动触发执行

5.__del__:析构方法,当对象在内存中被释放时,自动触发执行

6.__call__:对象后面加括号,触发执行

7.__dict__:查看类或对象中的所有成员

8.__str__:如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值

9.__getitem__、__setitem__、__delitem__:

注:用于索引操作,如字典。以上分别表示获取、设置、删除数据

10.__new__\__metaclass__ *(自定义类)

__new__:是用来创建实例的,对类实例化之前进行定制,可以用到。

__metaclass__:定义一个类如何被创建
参考阅读:Python 类的特殊成员方法

66、1、2、3、4、5 能组成多少个互不相同且无重复的三位数?

5 X 5 X 5 = 125

67、什么是反射?以及应用场景?

解释一: python的反射,它的核心本质其实就是利用字符串的形式去对象(模块)中操作(查找/获取/删除/添加)成员,一种基于字符串的事件驱动。

解释二: 需要执行对象里的某个方法,或需要调用对象中的某个变量,但是由于种种原因我们无法确定这个方法或变量是否存在,
这是我们需要用一个特殊的方法或机制要访问和操作这个未知的方法或变量,这中机制就称之为反射。

几个重要方法:

hasattr: 判断对象中是否有这个方法或变量

getattr: 获取对象中的方法或变量的内存地址

setattr: 为对象添加变量或方法

delattr: 删除对象中的变量。注意:不能用于删除方法
参考阅读:python的反射机制
Python-反射的用法

68、metaclass作用?以及应用场景?

这个很难理解,自己也不太懂。请参考下面的文章。
参考阅读:使用元类 - 廖雪峰的官方网站
深刻理解Python中的元类(metaclass)

69、用尽量多的方法实现单例模式。

? 单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。
通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,
从而方便对实例个数的控制并节约系统资源。
如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。

__new__()在__init__()之前被调用,用于生成实例对象。
利用这个方法和类的属性的特点可以实现设计模式的单例模式。
单例模式是指创建唯一对象,

1 使用__new__方法

class Singleton(object):
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance

class MyClass(Singleton):
    a = 1

2 共享属性

创建实例时把所有实例的__dict__指向同一个字典,这样它们具有相同的属性和方法.

class Borg(object):
    _state = {}
    def __new__(cls, *args, **kw):
        ob = super(Borg, cls).__new__(cls, *args, **kw)
        ob.__dict__ = cls._state
        return ob

class MyClass2(Borg):
    a = 1

3 装饰器版本

def singleton(cls):
    instances = {}
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance

@singleton
class MyClass:
  ...

4 import方法

作为python的模块是天然的单例模式

# mysingleton.py
class My_Singleton(object):
    def foo(self):
        pass

my_singleton = My_Singleton()

# to use
from mysingleton import my_singleton

my_singleton.foo()
参考阅读:Python 中的单例模式

70、装饰器的写法以及应用场景。

装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,
较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,
有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。
概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。

def decorator(func):
    def wapper(*args, **kwargs):
        print("This is a defcorator!")
        reture func(*args, **kwargs)
    return wapper
参考阅读:Python中如何在一个函数中加入多个装饰器?

71、异常处理写法以及如何主动跑出异常(应用场景)

try:
    <语句>        #运行别的代码
except <名字>:
    <语句>        #如果在try部份引发了'name'异常
except <名字>,<数据>:
    <语句>        #如果引发了'name'异常,获得附加的数据
else:
    <语句>        #如果没有异常发生
finally:
    <语句>        #语句无论是否发生异常都将执行最后的代码。


raise语句自动触发异常

raise语法格式如下:

raise [Exception [, args [, traceback]]]

语句中 Exception 是异常的类型(例如,NameError)参数标准异常中任一种,args 是自已提供的异常参数。

最后一个参数是可选的(在实践中很少使用),如果存在,是跟踪异常对象。
参考阅读:Python 异常处理

72、什么是面向对象的mro?

上面58,59题有提及,请查看。

73、isinstance作用以及应用场景?

描述:
isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。

    isinstance() 与 type() 区别:

        type() 不会认为子类是一种父类类型,不考虑继承关系。

        isinstance() 会认为子类是一种父类类型,考虑继承关系。

    如果要判断两个类型是否相同推荐使用 isinstance()。

语法:

以下是 isinstance() 方法的语法:

isinstance(object, classinfo)

参数:

    object -- 实例对象。
    classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值

如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False。。
参考阅读:Python 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]

class Solution():

def twoSum(self, nums, targets):
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    dct = {}

    for index, value in enumerate(nums):
        j = target - value
        if j in dct:
            return [ dct[j], index]
        else:
            dct[value] = index

75、json序列化时,可以处理的数据类型有哪些?如何定制支持datetime类型?

JSON格式支持的数据类型有以下:
 类型            描述
Number     在JavaScript中的双精度浮点格式 

String     双引号的反斜杠转义的Unicode

Boolean     true 或 false

Array         值的有序序列

Value     它可以是一个字符串,一个数字,真的还是假(true/false),空(null )等

Object        无序集合键值对

Whitespace      可以使用任何一对中的令牌

null             empty


自定义时间序列化转换器
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        else:
            return super(ComplexEncoder,self).default(obj)
d = { 'name':'alex','data':datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))
# {"name": "alex", "data": "2018-05-18 19:52:05"}

76、json序列化时,默认遇到中文会转换成unicode,如果想要保留中文怎么办?

import json
a=json.dumps({"ddf":"你好"},ensure_ascii=False)
print(a) #{"ddf": "你好"}

77、什么是断言?应用场景?

请参考下面的阅读。
参考阅读: Python 中何时使用断言?

78、有用过with statement吗?它的好处是什么?

Python中的有关上下文管理器的部分。
参考阅读:with statement - CSDN博客

79、使用代码实现查看列举目录下的所有文件。

提供4个方法理出文件夹内的所有内容

Python
#方法1:使用os.listdir
import os
for filename in os.listdir(r'c:\windows'):
    print filename

#方法2:使用glob模块,可以设置文件过滤
import glob
for filename in glob.glob(r'c:\windows\*.exe'):
    print filename

#方法3:通过os.path.walk递归遍历,可以访问子文件夹
import os.path
def processDirectory ( args, dirname, filenames ):
    print 'Directory',dirname
    for filename in filenames:
        print ' File',filename

os.path.walk(r'c:\windows', processDirectory, None )

#方法4:非递归
import os
for dirpath, dirnames, filenames in os.walk('c:\\winnt'):
    print 'Directory', dirpath
    for filename in filenames:
        print ' File', filename
#该代码片段来自于: http://www.sharejs.com/codes/python/211

80、简述 yield和yield from关键字。

请参考下面的文章。
参考阅读:python3中的yield from语句

 上一篇
Python面试题,第二部分:网络编程和并发(34题) Python面试题,第二部分:网络编程和并发(34题)
第二部分 网络编程和并发(34题)1、简述 OSI 七层协议。应用层: 与其它计算机进行通讯的一个应用,它是对应应用程序的通信服务的。 例如,一个没有通信功能的字处理程序就不能执行通信的代码, 从事字处理工作的程序员也不关心OSI的第7层。
2018-07-07
本篇 
Python面试题,第一部分:基础篇(80题) Python面试题,第一部分:基础篇(80题)
第一部分 Python基础篇(80题)1、为什么学习Python?高层语言 :无需考虑如何管理你的程序使用的内存一类的底层细节等。 可移植性 :由于Python的开源本质,它已经被移植在许多平台上。 面向对象 :Python既支持面向过
2018-07-07