23、re的match和search区别？
re.match()从开头开始匹配string。
re.search()从anywhere 来匹配string。
# 多行模式
>>> re.match('X', 'A\nB\nX', re.MULTILINE) # No match
>>> re.search('^X', 'A\nB\nX', re.MULTILINE) # Match
<_sre.SRE_Match object at ...>
24、什么是正则的贪婪匹配
如：String str="abcaxc";
Patter p="ab.*c";
贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(ab.*c)。
非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab.*c)。
25、def func(a,b=[]) 这种写法有什么坑？
def func(a,b=[]):
b.append(a)
print(b)
func(1)
func(1)
func(1)
func(1)
看下结果
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，第二次执行还是用第一次执行的时候实例化的地址存储，所以三次执行的结果就是 [1, 1, 1] ，想每次执行只输出[1] ，默认参数应该设置为None。
26、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?
# encoding: utf-8
a = "1,2,3"
b = a.split(",")
print b
27、如何实现[‘1’,’2’,’3’]变成[1,2,3]？
>>>a = ['', '', '']
>>>b = [int(i) for i in a]
>>>b
28、a = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ]的区别?
a里面的元素都是int类型，b中的元素都是元组。
元组只有一个元素，必须要加逗号结尾
29、一行代码选出列表里面的不重复元素
b = [1,2,3,2,3,4,1,2]
print [i for i in b if b.count(i)==1]
>>>4
30、logging模块的作用？以及应用场景
日志是一种可以追踪某些软件运行时所发生事件的方法。
不同的应用程序所定义的日志等级可能会有所差别，分的详细点的会包含以下几个等级：
- DEBUG
- INFO
- NOTICE
- WARNING
- ERROR
- CRITICAL
- ALERT
- EMERGENCY
31、请用代码简答实现stack
stack的实现代码（使用python内置的list），实现起来是非常的简单，就是list的一些常用操作 class 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): # 如果栈为空
return bool(self.stack) def top(self):
#取出目前stack中最新的元素
return self.stack[-1]
定义一个头结点，左边指向队列的开头，右边指向队列的末尾，这样就可以保证我们插入一个元素和取出一个元素都是O(1)的操作，使用这种链表实现stack也是非常的方便。实现代码如下： class Head(object):
def __init__(self):
self.left = None
self.right = None class Node(object):
def __init__(self, value):
self.value = value
self.next = None class Queue(object):
def __init__(self):
#初始化节点
self.head = Head() def enqueue(self, value):
#插入一个元素
newnode = Node(value)
p = self.head
if p.right:
#如果head节点的右边不为None
#说明队列中已经有元素了
#就执行下列的操作
temp = p.right
p.right = newnode
temp.next = newnode
else:
#这说明队列为空，插入第一个元素
p.right = newnode
p.left = newnode def dequeue(self):
#取出一个元素
p = self.head
if p.left and (p.left == p.right):
#说明队列中已经有元素
#但是这是最后一个元素
temp = p.left
p.left = p.right = None
return temp.value
elif p.left and (p.left != p.right):
#说明队列中有元素，而且不止一个
temp = p.left
p.left = temp.next
return temp.value else:
#说明队列为空
#抛出查询错误
raise LookupError(‘queue is empty!‘) def is_empty(self):
if self.head.left:
return False
else:
return True def top(self):
#查询目前队列中最早入队的元素
if self.head.left:
return self.head.left.value
else:
raise LookupError(‘queue is empty!‘)
32、常用字符串格式化哪几种？
一、使用%
%s 字符串
%c 字符
%d 十进制（整数）
%i 整数
%u 无符号整数
%o 八进制整数
%x 十六进制整数
%X 十六进制整数大写
%e 浮点数格式1
%E 浮点数格式2
%f 浮点数格式3
%g 浮点数格式4
%G 浮点数格式5
%% 文字%
>>> print("我叫%s，今年%d岁了" % ("小李", 20))
我叫小李，今年20岁了
二、通过{}替代%
1、正常使用
>>> print("我叫{}，今年{}岁了".format("小李", 20))
我叫小李，今年20岁了
2、还可以通过在括号里填写数字，修改格式化的顺序
>>> print("我叫{1}，今年{0}岁了".format("小李", 20))
我叫20，今年小李岁了
3、通过key取变量
>>> print("我叫{name}，今年{age}岁了".format(name="小李", age=20))
我叫小李，今年20岁了
4、传入对象
>>> class Person:
... def __init__(self,name,age):
...
... self.name,self.age = name,age
... def __str__(self):
...
... return '我叫{self.name}, 今年{self.age}岁了'.format(self=self)
>>> str(Person('小李',20))
'我叫小李, 今年20岁了'
5、通过下标
>>> person=['小李',20]
>>> '我叫{0[0]}, 今年{0[1]}岁了'.format(person)
'我叫小李, 今年20岁了'
33、简述 生成器、迭代器、可迭代对象 以及应用场景？
Python可迭代对象（Iterable）
Python中经常使用for来对某个对象进行遍历，此时被遍历的这个对象就是可迭代对象，像常见的list,tuple都是。如果给一个准确的定义的话，就是只要它定义了可以返回一个迭代器的__iter__方法，或者定义了可以支持下标索引的__getitem__方法(这些双下划线方法会在其他章节中全面解释)，那么它就是一个可迭代对象。
Python迭代器（iterator）
迭代器是通过next()来实现的，每调用一次他就会返回下一个元素，当没有下一个元素的时候返回一个StopIteration异常，所以实际上定义了这个方法的都算是迭代器。可以用通过下面例子来体验一下迭代器：
生成器（Generators）
生成器是构造迭代器的最简单有力的工具，与普通函数不同的只有在返回一个值的时候使用yield来替代return，然后yield会自动构建好next()和iter()
因为迭代器如此普遍，python专门为for关键字做了迭代器的语法糖。在for循环中，Python将自动调用工厂函数iter()获得迭代器，自动调用next()获取元素，还完成了检查StopIteration异常的工作。
1.3 定义迭代器
下面一个例子——斐波那契数列
# -*- coding: cp936 -*-
class Fabs(object):
def __init__(self,max):
self.max = max
self.n, self.a, self.b = 0, 0, 1 #特别指出：第0项是0，第1项是第一个1.整个数列从1开始
def __iter__(self):
return self
def next(self):
if self.n < self.max:
r = self.b
self.a, self.b = self.b, self.a + self.b
self.n = self.n + 1
return r
raise StopIteration() print Fabs(5)
for key in Fabs(5):
print key 结果
<__main__.Fabs object at 0x01A63090>
1
1
2
3
5
34、用Python实现一个二分查找的函数
#!usr/bin/env python
#encoding:utf-8
def binary_search(num_list, x):
'''
二分查找
'''
num_list=sorted(num_list)
left, right = 0, len(num_list)
while left < right:
mid = (left + right) / 2
if num_list[mid] > x:
right = mid
elif num_list[mid] < x:
left = mid + 1
else:
return '待查元素{0}在列表中下标为：{1}'.format(x, mid)
return '待查找元素%s不存在指定列表中'%x if __name__ == '__main__':
num_list = [34,6,78,9,23,56,177,33,2,6,30,99,83,21,17]
print binary_search(num_list, 34)
print binary_search(num_list, 177)
print binary_search(num_list, 21)
print binary_search(num_list, 211)
print binary_search(num_list, 985)
》》》
待查元素34在列表中下标为：9
待查元素177在列表中下标为：14
待查元素21在列表中下标为：5
待查找元素211不存在指定列表中
待查找元素985不存在指定列表中
35、谈谈你对闭包的理解。
#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
b = 10
# inner是内函数
def inner():
#在内函数中 用到了外函数的临时变量
print(a+b)
# 外函数的返回值是内函数的引用
return inner if __name__ == '__main__':
# 在这里我们调用外函数传入参数5
#此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
# 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
demo = outer(5)
# 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
# demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
demo() # demo2 = outer(7)
demo2()#
36、os和sys模块的作用
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;
sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。
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() 是否为文件 sys 常用方法 sys.argv 命令行参数List，第一个元素是程序本身路径 sys.modules.keys() 返回所有已经导入的模块列表 sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息 sys.exit(n) 退出程序，正常退出时exit(0) sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0 sys.version 获取Python解释程序的版本信息 sys.maxint 最大的Int值 sys.maxunicode 最大的Unicode值 sys.modules 返回系统导入的模块字段，key是模块名，value是模块 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 sys.platform 返回操作系统平台名称 sys.stdout 标准输出 sys.stdin 标准输入 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版本
37、谈谈你对面向对象的理解？
在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。面向对象有三大特性，封装、继承和多态。封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。继承则是进一步将一类事物共有的属性和行为抽象成一个父类，而每一个子类是一个特殊的父类--有父类的行为和属性，也有自己特有的行为和属性。这样做扩展了已存在的代码块，进一步提高了代码的复用性。如果说封装和继承是为了使代码重用，那么多态则是为了实现接口重用。多态的一大作用就是为了解耦--为了解除父子类继承的耦合度。如果说继承中父子类的关系式IS-A的关系，那么接口和实现类之之间的关系式HAS-A。简单来说，多态就是允许父类引用(或接口)指向子类(或实现类)对象。很多的设计模式都是基于面向对象的多态性设计的。总结一下，如果说封装和继承是面向对象的基础，那么多态则是面向对象最精髓的理论。掌握多态必先了解接口，只有充分理解接口才能更好的应用多态。
