# 多行模式
>>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match

>>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match

<_sre.SRE_Match object at ...>

 如：String str="abcaxc";

 　　Patter p="ab.*c";

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

 　　非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab.*c)。

def func(a,b=[]):

    b.append(a)

    print(b)

func(1)

func(1)

func(1)

func(1)

 # encoding: utf-8

 a = "1,2,3"

 b = a.split(",")

 print b

 >>>a = ['', '', '']

 >>>b = [int(i) for i in a]

 >>>b

 b = [1,2,3,2,3,4,1,2]

 print [i  for i in b if b.count(i)==1]

 >>>4

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

 一、使用%

 %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岁了'

 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

 #!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不存在指定列表中

 #闭包函数的实例

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

 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版本

在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。

面向对象有三大特性，封装、继承和多态。

封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。

继承则是进一步将一类事物共有的属性和行为抽象成一个父类，而每一个子类是一个特殊的父类--有父类的行为和属性，也有自己特有的行为和属性。这样做扩展了已存在的代码块，进一步提高了代码的复用性。

如果说封装和继承是为了使代码重用，那么多态则是为了实现接口重用。多态的一大作用就是为了解耦--为了解除父子类继承的耦合度。如果说继承中父子类的关系式IS-A的关系，那么接口和实现类之之间的关系式HAS-A。简单来说，多态就是允许父类引用(或接口)指向子类(或实现类)对象。很多的设计模式都是基于面向对象的多态性设计的。

总结一下，如果说封装和继承是面向对象的基础，那么多态则是面向对象最精髓的理论。掌握多态必先了解接口，只有充分理解接口才能更好的应用多态。