1.Python和Java、PHP、C、C#、C++等其他语言的对比？
python是一种脚本语言，它的运行需要python解释器，属于解释型的语言，python本身就是由C语言开发出来的，而且是开源的，由此可见C语言的强大，；C语言属于中级语言，它介于高级和低级语言之间，C是编译型的语言，它的运行必须经过编译器的处理才能形成最终的执行代码，C语言的应用非常广泛，C语言最主要的用途就是系统底层的应用。
简单的说，它们都是编程语言。是在第三代和第四代编程语言。 都和C有关系。 底层解释器都是C写的。都存在进程管理和数据交换。都支持网络编程，数据库编程。 相互之间可以通讯。
php相对最容易。是函数式编程， java虽然是面向对象的，使用特定的模式后，也可以支持类函数式编程。 C语言是函数式的。 python也是。 但是原则上，它们都同时支持面向对象的编程思维。只是表达方式比较特别。
java的工具强大，是一个工程语言。容易学，学精难，工具丰富 ，大多数人在用。是目前最主流的网络服务编程语言。
python仍然是脚本语言之王。 易学，易用，难精通。接口非常丰富。无所不能。

2.简述解释型和编译型编程语言？
解释型语言编写的程序不需要编译，在执行的时候，专门有一个解释器能够将VB语言翻译成机器语言，每个语句都是执行的时候才翻译。这样解释型语言每执行一次就要翻译一次，效率比较低。
用编译型语言写的程序执行之前，需要一个专门的编译过程，通过编译系统，把源高级程序编译成为机器语言文件，翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高，但也不能一概而论，
部分解释型语言的解释器通过在运行时动态优化代码，甚至能够使解释型语言的性能超过编译型语言。
3.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代码，十分的方便！

4.位和字节的关系？
8位(bit)=1字节,1024字节=1KB
5.b、B、KB、MB、GB 的关系？
6.请至少列举5个 PEP8 规范（越多越好）。

1、缩进，4个空格的缩进（编译器都可以完成此功能），不适用Tab，更不能混合使用Tab和空格；
2、每行最大长度为79，换行可以使用反斜杠。最好使用圆括号，换行点再操作符的后边敲回车；
3、不要再一句import中多个库。比如import os，sys（不推荐）；
4、模块命名尽量短小，使用全部小写的方式，可以使用下划线；
5、包命名尽量短小，使用全部小写的方式。不可以使用下划线；
6、类的命名使用CapWords的方式，模块内部使用的类采用--CapWords的方式；
7、函数命名使用全部小写的方式，可以使用下划线；
8、异常命名使用CapWords+Error后缀的方式；
9、常量命名使用全部大写的方式，可以使用下划线；
10、类的属性（方法和变量）命名使用全部小写的方式，可以使用下划线；
11、类方法第一个参数必须是self，而静态方法第一个参数必须是cls；

7.通过代码实现如下转换

#二进制转换成十进制：v = “0b1111011”
#十进制转换成二进制：v = 18
#八进制转换成十进制：v = “011”
#十进制转换成八进制：v = 30
#十六进制转换成十进制：v = “0x12”
#十进制转换成十六进制：v = 87
print(int('0b1111011', 2)) # 123
print(bin(18)) # 0b10010
print(int('011', 8)) # 9
print(oct(30)) # 0o36
print(int('0x12', 16)) # 18
print(hex(87)) # 0x57

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

如 10.3.9.12 转换规则为：
10            00001010    
3            00000011
 9            00001001
12            00001100
#再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

def func(s):
    l = s.split('.')
    ret = []
    for item in l:
        item = str(bin(int(item)))[2:]
        if len(item) < 8:
            n = 8 - len(item)
            item = ''.join(['0'*n, item])
        ret.append(item)
    print(ret)

    temp = ''.join(ret)
    print(temp)
    print(int(temp, 2))
    return ret

func('10.3.9.12')

运行结果：
['00001010', '00000011', '00001001', '00001100']
00001010000000110000100100001100
167971084

9.python递归的最大层数？

#代码说话：
def foo(n):
    print(n)
    n += 1
    foo(n)

foo(1) # 998左右，998以后就会报错

import sys
sys.setrecursionlimit(100000)

def bar(n):
    print(n)
    n += 1
    bar(n)

bar(1) # python3中在8663左右

10.求结果:

v1 = 1 or 3
v2 = 3 or 1
v3 = 1 and 3
v4 = 3 and 1 # 短路原则
v5 = 0 and 2 and 1
v6 = 0 and 2 or 1
v7 = 0 and 2 or 1 or 4
v8 = 0 or False and 1

print(v1, v2, v3, v4, v5, v6, v7,v8)
结果：
1 3 1 0 1 1 False

11.ascii、unicode、utf-8、gbk 区别？
ascii 只支持英文字符 1字符1字节
unicode 通用编码，支持大部分语言，但比较占空间
utf-8 可变长编码，节省内存，ascii码是其子集
gbk 支持中文字符的编码

12.字节码和机器码的区别？
机器码是电脑CPU直接读取运行的机器指令，是电脑的CPU可直接解读的数据，运行速度最快，但是非常晦涩难懂，也比较难编写，一般从业人员接触不到；
字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。

13.三元运算规则以及应用场景？
i = A if condition else B，主要运用与结构简单的条件语句，这样可以节省代码
eg: result = a if a > 10 else b

14.列举 Python2和Python3的区别？

  1. 1.print函数
  2. xrange和range
  3. .raw_input和input
  4. 字符串编码： py2字符串其实是byte(默认已编码)
  5. 除法运算

15.用一行代码实现数值交换：

a = 1
b = 2
a, b = b, a

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

17.xrange和range的区别？
在Python 2里，有两种方法来获得一定范围内的数字：range()，它返回一个列表，还有xrange()，它返回一个迭代器。在Python 3里，range()返回迭代器，xrange()不再存在了。

18.文件操作时：xreadlines和readlines的区别？
在Python 2里，文件对象有一个xreadlines()方法，它返回一个迭代器，一次读取文件的一行。这在for循环中尤其有用。
在Python 3里，xreadlines()方法不再可用了，可改为for line in a_file。

19.列举布尔值为False的常见值？
主要有：0，空字符串，空元组，空列表，空字典等。

20.字符串、列表、元组、字典每个常用的5个方法？
str:
find() 查找
replace() 替换
spilit() 分割
join() 拼接
strip() 去空值
…
list:
append() 添加
remove() 删除
pop() 抛出
reverse() 反转
sort() 排序

tupe:
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。

dict:

items()，获取字典中所有的键值对的数据
keys()， 获取字典中所有的key组成的数据
values() 获取字典中所有的value组成的数据
del() #删除数据
pop() 删除

21.lambda表达式格式以及应用场景？

格式：`lambda x: x+1
场景：配合map、reduce等高阶函数使用，或作为列表元素排序的key。
法一：
def func(x):
    return x+1
print(list(map(func,range(1,5))))
结果：
[2, 3, 4, 5]

法二：
print(list(map(lambda x:x+1,range(1,5))))
结果：
[2, 3, 4, 5]

#计算从1加到100：
from functools import reduce
print(reduce(lambda x,y:x+y,range(1,101)))
结果：
5050

根据列表中元组第二个值排序
a = [(10,3),(20,2),(30,1)]
b = sorted(a,key=lambda x:x[1])
print(b)
[(30, 1), (20, 2), (10, 3)]
结果：

22.pass的作用？
空语句，什么也不做，占坑；
保证结构的完整性，可以以后实现。

23.arg和*kwarg作用
实现了不定长传参，其中args为可变长参数，允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple；*kwargs为关键字参数，允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
注意：不定长参数和关键字参数要放在其他参数后，即放在传参的最后一个位置！

24.is和“==”的区别
is对比内存地址是否一致； == 对比值是否相等。

25.简述Python的深浅拷贝以及应用场景？
浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字，还有仅仅一层的字典、列表、元祖等。
对于 数字和字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。
场景: 数据完整备份（隔离）

26.Python垃圾回收机制？
Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题。通过“分代回收”（generation collection）以空间换取时间来进一步提高垃圾回收的效率。
参考本文：python垃圾回收详解

27.Python的可变类型和不可变类型？
数值类型（int和float）、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型。
不可变对象，变量对应内存的值不允许被改变，当变量要改变时，实际上是把原来的值复制一份后再改变，开辟一个新的地址，旧的地址上的数据被垃圾回收。

28.求结果：

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v)  # >>> {'k1': [666], 'k2': [666]}
v['k1'] = 777
print(v)  # >>> {'k1': 777, 'k2': [666]}

29.求结果：

def num():
    return [lambda x:i*x for i in range(4)]

print([m(2) for m in num()])  # >>> [6, 6, 6, 6]
 匿名函数m中，i只是一个变量，在匿名函数执行时才去查找，而这个时候，i已经变成3了；
 若不想这样搞，可以让匿名函数中的i提升为函数的参数，这样在生成匿名函数时就绑定了每个i的值：
 def num():
     return [lambda x, i=i:i*x for i in range(4)]
 print([m(2) for m in num()])

改写：
print([m(2) for m in [lambda x:i*x for i in range(4)]]) 
print([m(2) for m in [lambda x, i=i:i*x for i in range(4)]])
结果：
[6, 6, 6, 6]
[0, 2, 4, 6]

30.列举常见的内置函数？
max，min,sum,sqrt,sorted

31.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：入参是为函数和列表/元组/字符串和初始值，返回值为数值。

32.一行代码实现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)]))

33.如何安装第三方模块？以及用过哪些第三方模块？
在Python中，安装第三方模块，是通过setuptools这个工具完成的。Python有两个封装了setuptools的包管理工具：easy_install和pip。目前官方推荐使用pip。

34.至少列举8个常用模块都有那些？
numpy，pandas，pyqt、pymql、pygame、Django、Flask、opencv-python、pillow-python、Scrappy……

35.re的match和search区别？
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配，否则也返回None。

36.什么是正则的贪婪匹配？
重复运算符在默认条件下是贪婪的。

import re

pattern1 = r'\*(.+)\*'
r1 = re.findall(pattern1, r'*hello * *world!*')
print(r1)

pattern2 = r'\*(.+?)\*'
r2 = re.findall(pattern2, r'*hello * *world!*')
print(r2)
>>> ['hello * *world!']
>>> ['hello ', 'world!']
 可见贪婪模式匹配了开始星号到结束星号间的全部内容，包括中间两个星号。
 用(.+?)代替(.+)得到非贪婪模式，它会匹配尽可能少的内容。

37.求结果：

print([i % 2 for i in range(10)])
print((i % 2 for i in range(10)))
#######################################
 一个是列表，一个是生成器：
#[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
#<generator object <genexpr> at 0x0000014F8B419410>

38.求结果：

print(1 or 2)  # 1 短路原则
print(1 and 2)  # 2
print(1 < (2==2))  # False
print(1 < 2 == 2)  # True !!!!!!
 注意最后一个！

39.def func(a,b=[]) 这种写法有什么坑？
将可变对象作为默认参数，若多次调用时使用默认参数，默认参数会保留上次调用时的状态！
函数体内最好加上判断：if not b: b = []

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

print("1,2,3".split(','))

41.如何实现[‘1’,’2’,’3’]变成[1,2,3] ?

法一：
print(list(map(lambda x:int(x), ['1', '2', '3']))) 
法二：
print(list(map(int, ['1', '2', '3'])))

42.比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别？
a,b 均为整型列表， c为元组列表。

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

法一：
print([i**2 for i in range(1,11)]) 
法二：
print(list(map(lambda x:pow(x,2),range(1,11))))

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

print(list(set(l)))

45.如何在函数中设置一个全局变量 ?

def f():
    global x
    x = 1

f()
print(x)

46.logging模块的作用？以及应用场景？
日志记录，可以更好的管理我们的日志，并且可以将标准输入输出保存到日志文件，而且利用logging模块可以部分代替debug的功能，给程序排错。
场景：登录日志，错误日志等等

47.请用代码简单实现stack

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

    def isEmpty(self):
        return not len(self.items)

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

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

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

    def clear(self):
        self.items.clear()

48.常用字符串格式化哪几种？
%s 字符，%d 数字，%f 浮点数
{} format格式化

49.简述 生成器、迭代器、可迭代对象 以及应用场景？
生成器应用场景：
在结果集比较大的情况下，可返回生成器以节省内存。如读取文件时….
迭代器对象就是实现了iter() 和 next()方法的对象.其中iter()返回迭代器本身,而next()返回容器的下一个元素,在结尾处引发StopInteration异常.
参考本文：python装饰器

50.用Python实现一个二分查找的函数。
二分查找是在有序表的前提下进行查找的

l = list(range(10000))

def binary_search(seq, target_num):
    if len(seq) > 1:
        mid = int(len(seq)/2)
        if seq[mid] == target_num:
            print('find target number: %s'%target_num)
        elif seq[mid] < target_num:
            binary_search(seq[mid+1:], target_num)
        else:
            binary_search(seq[0:mid], target_num)
    else:
        if seq[0] == target_num:
            print('find target number: %s'%target_num)
        else:
            print('There is no such number!')


binary_search(l,111)

51.谈谈你对闭包的理解？
闭包 = 代码块 + 执行环境
函数声明的时候，会生成一个独立的作用域
同一作用域的对象可以互相访问
作用域呈层级包含状态，形成作用域链，子作用域的对象可以访问父作用域的对象，反之不能；另外子作用域会使用最近的父作用域的对象

52.os和sys模块的作用？
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;
sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

  1. os模块常用方法
    os.remove(‘path/filename’) 删除文件
    os.rename(oldname, newname) 重命名文件
    os.walk() 生成目录树下的所有文件名
    os.chdir(‘dirname’) 改变目录
    os.mkdir/makedirs(‘dirname’)创建目录/多层目录
    os.rmdir/removedirs(‘dirname’) 删除目录/多层目录
    os.listdir(‘dirname’) 列出指定目录的文件
    os.getcwd() 取得当前工作目录
    os.chmod() 改变目录权限
    os.path.basename(‘path/filename’) 去掉目录路径，返回文件名
    os.path.dirname(‘path/filename’) 去掉文件名，返回目录路径
    os.path.join(path1[,path2[,…]]) 将分离的各部分组合成一个路径名
    os.path.split(‘path’) 返回( dirname(), basename())元组
    os.path.splitext() 返回 (filename, extension) 元组
    os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间
    os.path.getsize() 返回文件大小
    os.path.exists() 是否存在
    os.path.isabs() 是否为绝对路径
    os.path.isdir() 是否为目录
    os.path.isfile() 是否为文件
  2. sys模块常用方法
    sys.argv #命令行参数List，第一个元素是程序本身路径
    sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
    sys.modules.keys() #返回所有已经导入的模块列表
    sys.modules #返回系统导入的模块字段，key是模块名，value是模块
    sys.exc_info() #获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
    sys.exit(n) #退出程序，正常退出时exit(0)
    sys.hexversion #获取Python解释程序的版本值，16进制格式如：0x020403F0
    sys.version #获取Python解释程序的版本信息
    sys.platform #返回操作系统平台名称
    sys.maxint # 最大的Int值
    sys.stdout #标准输出
    sys.stdout.write(‘aaa’) #标准输出内容
    sys.stdout.writelines() #无换行输出
    sys.stdin #标准输入
    sys.stdin.read() #输入一行
    sys.stderr #错误输出
    sys.exc_clear() #用来清除当前线程所出现的当前的或最近的错误信息
    sys.exec_prefix #返回平台独立的python文件安装的位置
    sys.byteorder #本地字节规则的指示器，big-endian平台的值是’big’,little-endian平台的值是’little’
    sys.copyright #记录python版权相关的东西
    sys.api_version #解释器的C的API版本
    sys.version_info #'final’表示最终,也有’candidate’表示候选，表示版本级别，是否有后继的发行
    sys.getdefaultencoding() #返回当前你所用的默认的字符编码格式
    sys.getfilesystemencoding() #返回将Unicode文件名转换成系统文件名的编码的名字
    sys.builtin_module_names #Python解释器导入的内建模块列表
    sys.executable #Python解释程序路径
    sys.getwindowsversion() #获取Windows的版本
    sys.stdin.readline() #从标准输入读一行，sys.stdout.write(a) 屏幕输出a
    sys.setdefaultencoding(name) #用来设置当前默认的字符编码(详细使用参考文档)
    sys.displayhook(value) #如果value非空，这个函数会把他输出到sys.stdout(详细使用参考文档)

53.如何生成一个随机数？
使用random模块

import random
print(random.randint(1,10))

54.如何使用python删除一个文件？

os.remove('path/filename') # 删除文件

55.谈谈你对面向对象的理解？
面向对象编程是种具有对象概念的程序编程范型，同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。对象则指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的可重用性、灵活性和可扩展性，对象里的程序可以访问及修改对象相关联的数据。在面向对象编程里，计算机程序会被设计成彼此相关的对象。
面向对象程序设计可以看作一种在程序中包含各种独立而又互相调用的对象的思想，这与传统的思想刚好相反：传统的程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对计算机下达的指令。面向对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象，因此它们都可以被看作一个小型的“机器”，即对象。
优点:
能和真实的世界交相辉映，符合人的直觉。
面向对象和数据库模型设计类型，更多地关注对象间的模型设计。
强调于“名词”而不是“动词”，更多地关注对象和对象间的接口。
根据业务的特征形成一个个高内聚的对象，有效地分离了抽象和具体实现，增强了可重用性和可扩展性。
有大量非常优秀的设计原则和设计模式。
S.O.L.I.D（单一功能、开闭原则、里氏替换、接口隔离以及依赖反转，是面向对象设计的五个基本原则）、IoC/DIP……
缺点:
代码都需要附着在一个类上，从一侧面上说，其鼓励了类型。
代码需要通过对象来达到抽象的效果，导致了相当厚重的“代码粘合层”。
因为太多的封装以及对状态的鼓励，导致了大量不透明并在并发下出现很多问题。

56.Python面向对象中的继承有什么特点？
继承更多了是为了多态，也可提升代码的复用程度。
特点：
在继承中基类的构造（init()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用；
Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）；

57.面向对象深度优先和广度优先是什么？
当出现多重继承并产生菱形交叉时查找属性或方法路径顺序。

58…面向对象中super的作用？
super() 函数是用于调用父类(超类)的一个方法。
　　super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
　　Python3.x 和 Python2.x 的一个区别是: Python 3 可以直接使用 super().xxx 代替 super(Class, self).xxx
　　
59.是否使用过functools中的函数？其作用是什么？
functools用于高阶函数：指那些作用于函数或者返回其他函数的函数。通常情况下，只要是可以被当做函数调用的对象就是这个模块的目标。

60、列举面向对象中带双下划线的特殊方法，如：new、init
__init__初始化魔术对象，当一个对象被实例化是自动触发
new 当一个对象被实例化前自动触发，通过传递参数判断对象是否被创建或其他
__del__当一个对象没有任何引用是被触发，回收内存
__call__将对象当作函数调用时触发

61、如何判断是函数还是方法？
函数：
函数是封装了一些独立的功能，可以直接调用，python内置了许多函数，同时可以自建函数来使用。
方法：
方法和函数类似，同样封装了独立的功能，但是方法是需要通过对象来调用的，表示针对这个对象要做的操作，使用时采用的方法。

62、静态方法和类方法区别？
实例方法，类方法，静态方法都可以通过实例或者类调用，只不过实例方法通过类调用时需要传递实例的引用（python 3可以传递任意对象，其他版本会报错）。
三种方法从不同层次上来对方法进行了描述：实例方法针对的是实例，类方法针对的是类，他们都可以继承和重新定义，而静态方法则不能继承，可以认为是全局函数。

63、列举面向对象中的特殊成员以及应用场景
魔术方法 用于在某一时刻调用时

  1. doc 描述类的信息

  2. call 对象后面加括号，触发执行

  3. dict 查看类或对象中的所有成员

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

  5. getitem 、 setitem 、delitem 用于索引操作，如字典。分别表示获取、设置、删除数据

  6. new 、metaclass

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

for x in range(1, 6):
    for z in range(1, 6):
        for i in range(1,6):
            if i != x and i != z  and x != z :
                print(i, x, z)

65、什么是反射？以及应用场景？
本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

66、metaclass作用？以及应用场景？
元类就是创建类这种对象的东西

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

class Earth(object):
    __instance=None #定义一个类属性做判断
    def __new__(cls):
        if cls.__instance==None:
            #如果__instance为空证明是第一次创建实例
            #通过父类的__new__(cls)创建实例
            cls.__instance==object.__new__(cls)
            return  cls.__instance
        else:
            #返回上一个对象的引用
            return cls.__instance

a = Earth()
print(id(a))
b = Earth()

68、装饰器的写法以及应用场景。
装饰器是一个工厂函数，接受一个函数作为参数，然后返回一个新函数，其闭包中包含被装饰的函数。有了装饰器，可以提取大量函数中与本身功能无关的类似代码 ( 这块在Flask中用于定义路由的@app.route，就是一个很好的例子)，达到代码重用的目的。可应用于插入日志、性能测试、事务处理等方面。

def deco(func):
    def warpper(*args, **kwargs):
        print(‘start‘)
        func(*args, **kwargs)
        print(‘end‘)
    return warpper

@deco
def myfunc(parameter):
    print("run with %s" % parameter)

myfunc("something")

69、异常处理写法以及如何主动弹出异常（应用场景）

try:
    pirnt('123')    
except:
    print('456')
通过raise 异常对象主动抛出异常

70、什么是面向对象的MRO

Method Realtion Order 用来制作一个继承关系的列表
MRO列表的制作原则：
1.子类永远在父类的前面
2.如果继承了多个父类，那么按照()中的顺序在列表中摆放
3.如果多个类同时继承了一个父类，孙子类中只会选取第一个父类中的父类的该方法

71、isinstance作用以及应用场景？
检测一个数据是否由指定的类型创建

class A():
    pass
a = A()
print(isinstance(a,A))

72、写代码并实现：
给定一个由编码器组成的数组，返回两个数字的索引，使它们加起来成为一个特定的目标。你可以假设每一个输入都会
只有一个解决方案，您可能不会使用相同的元素两次。
例子:
给定nums =[2,7,11,15]，目标= 9，
因为nums[0] + nums[1] = 2+ 7= 9，
返回[0,1]

def func(mylist,key):
    for i in mylist:
        for j in range(mylist.index(i),len(mylist)):
            if i + mylist[j] == key:
                print(i,mylist[j],  mylist.index(i),j)
a = [1,2,3,4,5,6,7,8]
func(a,9)
运行结果：
1 8 0 7
2 7 1 6
3 6 2 5
4 5 3 4

73、json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？
可以处理数组、对象
定制datetime类型

import json
from datetime import *

class ComplexEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        elif isinstance(obj, date):
            return obj.strftime('%Y-%m-%d')
        else:
            return json.JSONEncoder.default(self, obj)

a = json.dumps({'now':datetime.now()},cls=ComplexEncoder)
print(a)

74、json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？
json.dumps(jsonData,ensure_ascii=False);

75、什么是断言？应用场景？
在没完善一个程序之前，我们不知道程序在哪里会出错，与其让它在运行最崩溃，不如在出现错误条件时就崩溃，这时候就需要assert断言的帮助
python assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达式为假。可以理assert断言语句为raise-if-not，用来测试表示式，其返回值为假，就会触发异常。

76、有用过with statement吗？它的好处是什么？
with语句的作用是通过某种方式简化异常处理
自动管理文件关闭：with open(filename) as f

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

import os

for i in os.listdir():
	print(i)

78、简述 yield和yield from关键字。
yield 的作用就是把一个函数变成一个生成器，生成器本质上就是一个函数，带有yield的函数不再是一个普通的函数。python解释器会将其视为一个generator。yield from是什么，简单地说，yield from generator 。实际上就是返回另外一个生成器。作用是让生成器能够在其他函数中被调用，如下所示：

yield from 后跟的是可迭代对象
def generator1():
    item = range(10)
    for i in item:
        yield i
 
def generator2():
    yield 'a'
    yield 'b'
    yield 'c'
    yield from generator1() #yield from iterable本质上等于 for item in iterable: yield item的缩写版
    yield from [11,22,33,44]
    yield from (12,23,34)
    yield from range(3)
 
for i in generator2() :
    print(i)
  
运行结果：
a b c 0 1 2 3 4 11 22 33 44 12 23 34 0 1 2

参考链接，商业用途请联系原作者。

更多推荐

python基础试题（2）