python练手基础

Python相关文档
0.1. Python标准文档
0.2. Python实用大全
0.3. 迷人的Python
0.4. 深入理解Python
0.5. Python扩展库网址 http://pypi.python.org/
     Python官方网址 http://www.python.org/

列表

　　用[]括起来，里面可以是数值或bool或字符串

　　L = [95.5,85,59,True,"Last"]
　　print L[0]
　　print L[2]
　　print L[1]
　　print L

　　插入：L.insert(pos, Data)

　　追加：L.append(Data)

　　删除：L.pop(pos)

　　字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。

元组

　　用()括起来，里面可以是数值或bool或字符串；

　　tuple一旦创建完毕，就不能修改了；

　　创建tuple和创建list唯一不同之处是用( )替代了[ ]；

　　单元素 tuple 要多加一个逗号“,”，避免做为函数处理的歧义；

　　空元组 t = ()

　　一个元素的元组 t = (12421,)

　　可变元组：元组中的一个元素是列表（列表的内容可变，类型不能变）

切片

　　L[0:3:1]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

　　L[:]实际上复制出了一个新list。

　　第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。

　　把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

可以对list tuple 字符串切片

字典，映射

　　Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下：

　　d = {
    　　'Adam': 95,
    　　'Lisa': 85,
    　　'Bart': 59
　　}

　　我们把名字称为key，对应的成绩称为value，dict就是通过key 来查找 value。

　　花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

　　由于dict也是集合，len() 函数可以计算任意集合的大小

　　list 必须使用索引返回对应的元素，而dict使用key

　　dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。

　　dict的第二个特点就是存储的key-value序对是没有顺序的！

　　dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

　　遍历字典：

　　for key in d:

　　　　print key,d[key]

　　dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

　　items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

　　>>> for key, value in d.items():
　　...     print key, ':', value

for in 可以遍历列表，元组，集合和字典，使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。

　　列表生成式的 for 循环后面还可以加上 if 判断

　　def toUppers(L):
　　　　return [x.upper() for x in L if isinstance(x, str)]

　　print toUppers(['Hello', 'world', 101])

　　例如：利用 3 层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为从右到左倒过来还是 121。

　　print [x*100+y*10+z for x in range(1,10) for y in range(0,10) for z in range(1,10) if x == z]

　　zip()函数可以把两个 list 变成一个 list：

　　>>> zip([10, 20, 30], ['A', 'B', 'C'])
　　[(10, 'A'), (20, 'B'), (30, 'C')]

集合Set

　　set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

　　创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：

　　([])表示一个集合

　　>>> s = set(['A', 'B', 'C'])
  用in操作符判断是否在集合里面。
  增加和删除：add/remove

函数

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
print map(format_name, ['adam', 'LISA', 'barT'])
reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

装饰器：

　　相当于Java里面的AOP切面。

1. if,python中没有switch语句
    if(a+1==b):
        print("if");
    elif(a+1>b):
        print("elif");
    else:
        print("else");

2.while语句有else部分,while/for语句中出现break时,else不执行
    running=True;
    while(running):
        if(i>10):
            running=False;
        print(i);
        i+=1;
    else:
        print("end while");

3.Boolean的值有 True 和 False

4.for ..in 语句,range(start,end,step)
    for i in range(0,10):
        print (i);
    else:
        print("end for");

5.continue和,break语句从for或while循环中结束，循环的else块将不执行

6.标准输入
    s=input("Enter a string:");
    6.1.格式化字符串
        a=10
        b='string'
        c='a:%d,b:%s'%(a,b)

7.函数 有关键字def定义
    #define function say()
    def say():
        print("function say()");
    #call the function
    say();

7.1.函数形参
        #define function say(a,b)
        def say(a,b):
            print("function say()",a,b);
        #call the function
        say(a,b);

7.2.默认参数值
        #define function say(a,b)
        def say(a,b=0):
            print("function say()",a,b);

#call the function
        say(a,b);
        say(a)

7.3.关键参数 指定其中一部分参数
        #define function say(a,b,c,d)
        def say(a,b=0,c=1,d=2):
            print("function say()",a,b,c,d);

#call the function
        say(a,c=100);
        say(a,b=2,d=3)

7.4.return语句
        def max(a,b):
            if(a>b):
                return a;
            else:
                return b;

#call
        print max(a,b);

7.5.元组,列表,字典作为函数的参数
        元组或列表
        def powersum(power, *args):
            total=0
            for i in args:
                total+=pow(i,power)
            return total

print (powersum(2,3,4))
        print (powersum(2,10))

　　可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

8.全局变量与局部变量
    def func():
        global x;
        print ("x is",x);
        x=100;
    #call the func()
    x=200;
    func();
    print (x);

9.DocStrings文档字符串
    def docs():
        '''this is a description of
        function docs()'''
        print ("docs()");

print (docs.__doc__);

10.命令行参数
    import sys;

#sys.argv[0] 为命令本身,for语句从sys.argv[0]开始
    #sys.argv为命令行参数列表
    for i in sys.argv:
        print (i);

11.模块
  11.1.模块的__name__
  if (__name__=='__main__'):
      print ("main");
  else:
      print ("be imported from another module");

11.2.模块的创建
    #!user/bin/python
    #filename:mymodule.py

if (__name__=='__main__'):
        print ('my module main');
    else:
        print ('my module is imported');

def func():
        print ('my module func()');
    version='0.0.1';

#import in another py file
    import mymodule;
    mymodule.func();
    print (mymodule.version)

#or
    from mymodule import func,version;
    func();
    print ('Version:',version);

11.3.模块函数dir() 列出此模块中定义的函数,类和变量
    import sys
    for i in dir(sys):
        print (i)

12.数据结构 列表list, 通过中括号中逗号分隔的item定义
    yourlist=['y1','y2','y3','y4','y5']
    mylist=list();
    mylist.append('1');
    mylist.append('2');
    mylist.append('3');
    mylist.append('4');

mylist.insert(mylist.count('1'),'5')
    mylist.extend('6');
    print (mylist.index('5'))
    print (mylist[1])
    #mylist.reverse();
    #mylist.sort(key=None, reverse=True)
    for i in mylist:
        print (i)

12.1.序列 - 代表倒数第几个index
        #all items in list
        mylist[0:-1]
        mylist[:]
        mylist[0:]

#除最后一个的所有序列
        mylist[:-1]

13.数据结构 元组tuple,和字符串一样值不可变,通过圆括号中用逗号分隔的项目定义
    mytuple=('1','2','3','4','5','4')

print (mytuple.count('4'))
    print (mytuple.index('5'))
    print (mytuple[1])
    for i in mytuple:
        print (i)

14.数据结构 字典dict, 类似于map,键值对在字典中的标记方式
    d={ key1 : value1,
       key2 : value2,
       key2 : value3,
       key2 : value4
    } 键/值对用 : 分隔，各个对用 , 分隔 所有这些都包含在花括号里面
    d = {
    'w1' : 'w1@xx.com',
    'w2' : 'w2@xx.com',
    'w3' : 'w3@xx.com',
    'w4' : 'w4@xx.com',
    'w5' : 'w5@xx.com' }

#add an item
    d['w6'] = 'w6@yy.cn'

#delete an item
    del d['w3']

#access an item
    print (d['w4'])

#key and values
    for i, j in d.items():
        print (i, ':', j)
    #values
    print (d.copy().values())

15.class类 如下的代码中__init__()为构造函数, self为this指针, __del__()为析构函数
  Python不会自动调用基本类的constructor(__init__())和destructor(__del__())，你得亲自专门调用它。

class per:
        age=0
        def __init__(self, name):
            self.name=name
            print ("init name:%s"%self.name)
        def say(self):
            print ("per::say()")
        def set(self,age):
            self.age=age
        def get(self):
            return self.age
        def __del__(self):
            self.age=0
            print ("__del__()%d"%self.age)

person=per('person')
    person.say()
    person.set(100)
    print (person.get())

15.1.类的继承 class subclass(baseclass1,baseclass2,...,baseclassn)
    class base:
        name=''
        age=0
        def __init__(self,name,age):
            self.name=name
            self.age=age
            print ('base::__init__():name:%s,age:%d' \
                    %(self.name,self.age))
        def tell(self):
            print ('base::name:%s,age:%d'%(self.name,self.age))
        def __del__(self):
            self.name=''
            self.age=0
            print ('base::__del__()')

class suba(base):
        sex=''
        def __init__(self,name,age,sex='man'):
            self.sex=sex
            base.__init__(self,name,age)
            print ('suba::__init__():name:%sage:%dsex:%s' \
                    %(self.name,self.age,self.sex))
        def __del__(self):
            base.__del__(self)
            print ('suba::__del__()')

a=suba('wangyf',25,'man')
    a.tell()

16.异常处理 try...except
    import sys

try:
        s=input('Enter ctrl+c to test EOFError:')
        Print ('Print is not defined')
    except EOFError:
        print ('EOF is Entered')
    except Exception:
        print ('default Exception')
    else:
        print ('no Exception happened')

16.1.引发异常 raise 相当于在可能异常的地方调用异常类，相当于throw
  可以引发的错误或异常应该分别是一个Error或Exception类的直接或间接导出类

class InputException(Exception):
        def __init__(self,x):
            self.x=x
            print ('InputException::__init__():x:[%d]'%self.x)
        def __del__(self):
            print ('InputException::__del__()')
    try:
        s=input('Enter some word:')
        if(len(s) < 5):
            print ('string len is:%d'%(len(s)))
            #throw a exception
            raise InputException(len(s))
    except EOFError:
        print ('EOF is Entered')
    except Exception:
    #上面的异常此处也会捕获到
        print ('except')
    else:
        print ('else')

16.2.try...finally异常处理
    无论异常发生与否的情况下,finally范围里的语句都会被执行
    try:
        s=input('Enter string:')
    finally:
        print ('str s is:%s'%s)

17.exec和eval执行引号里面的语句
    exec ('print ('this is exec command')')
    eval ('print ('this is eval command')')

18.lambda形式
    lambda语句被用来创建新的函数对象，并且在运行时返回它们。
    def repeater(n):
        return lambda s:s*n

three=repeater(3)
    print (three('main')

19. others
  19.1. 引号'"在python中没有区别。即 '' == "", \''' ''' == \""" """指示多行的字符串。
  19.2. python中的标识符与c语言一样。
  19.3. pass语句在Python中表示一个空的语句块。
  19.4. from sys import * == import sys :即在模块sys中导入子模块。

20. python调用c的库文件文件
    20.1. c函数编译成动态库文件
    /* test.cpp */
    #include <stdio.h>

extern "C" {
        void display() {
            printf("This is Display Function\n");
        }
    }
    编译成动态库文件。
    g++ test.cpp -fPIC -shared -o libtest.so

20.1. python调用
    import ctypes
    so = ctypes.CDLL("./libtest.so")
    so.display()

21. python连接oracle数据库
  使用库文件cx_Oracle-5.1.tar.gz
  Python扩展库网址 http://pypi.python.org/获取库文件
  编译方式
  python setup.py build
  python setup.py install

#! /export/home/wangyf/tools/python2.7.2/bin/python
    #coding=UTF-8

import cx_Oracle

def hello():
        '''Hello cx_Oracle示例：

1)打印数据库版本信息.
        2)查询表数据.'''

conn = cx_Oracle.connect("obs61","obs61","tx8i.hp")
        cur = conn.cursor()
        try:
            print "Oracle Version:%s" % conn.version
            print "Table SUB_POLICY rows:"
            cur.execute('select * from wlan_future_event')
            for row in cur:
                print row
        finally:
            cur.close()
            conn.close()

hello()

22. python连接mysql数据库
  使用库文件MySQLdb MySQL-python-1.2.3.tar.gz
  Python扩展库网址 http://pypi.python.org/获取库文件
  基本的使用如上，还是很简单的，进一步使用还没操作，先从网上找点资料放上来，以备后续查看

# -*- coding: utf-8 -*-
    #mysqldb
    import time, MySQLdb

#连接
    conn=MySQLdb.connect(host="localhost",user="root",passwd="",db="test",charset="utf8")
    cursor = conn.cursor()

#写入
    sql = "insert into user(name,created) values(%s,%s)"
    param = ("aaa",int(time.time()))
    n = cursor.execute(sql,param)
    print n

#更新
    sql = "update user set name=%s where id=3"
    param = ("bbb")
    n = cursor.execute(sql,param)
    print n

#查询
    n = cursor.execute("select * from user")
    for row in cursor.fetchall():
    for r in row:
        print r

#删除
    sql = "delete from user where name=%s"
    param =("aaa")
    n = cursor.execute(sql,param)
    print n
    cursor.close()

#关闭
    conn.close()

22.1.引入MySQLdb库
    import MySQLdb

22.2.和数据库建立连接
     conn=MySQLdb.connect(host="localhost",user="root",passwd="sa",db="mytable",charset="utf8")
     提供的connect方法用来和数据库建立连接,接收数个参数,返回连接对象.

比较常用的参数包括
     host:数据库主机名.默认是用本地主机.
     user:数据库登陆名.默认是当前用户.
     passwd:数据库登陆的秘密.默认为空.
     db:要使用的数据库名.没有默认值.
     port:MySQL服务使用的TCP端口.默认是3306.
     charset:数据库编码.

更多关于参数的信息可以查这里
     http://mysql-python.sourceforge.net/MySQLdb.html

然后,这个连接对象也提供了对事务操作的支持,标准的方法
     commit() 提交
     rollback() 回滚

22.3.执行sql语句和接收返回值
     cursor=conn.cursor()
     n=cursor.execute(sql,param)
     首先,我们用使用连接对象获得一个cursor对象,接下来,我们会使用cursor提供的方法来进行工作.这些方法包括两大类:1.执行命令,2.接收返回值

cursor用来执行命令的方法:
     callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数
     execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数
     executemany(self, query, args):执行单条sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数
     nextset(self):移动到下一个结果集

cursor用来接收返回值的方法:
     fetchall(self):接收全部的返回结果行.
     fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
     fetchone(self):返回一条结果行.
     scroll(self, value, mode='relative'):移动指针到某一行.如果mode='relative',则表示从当前所在行移动value条,如果mode='absolute',则表示从结果集的第一行移动value条.

下面的代码是一个完整的例子.
     #使用sql语句,这里要接收的参数都用%s占位符.要注意的是,无论你要插入的数据是什么类型,占位符永远都要用%s
     sql="insert into cdinfo values(%s,%s,%s,%s,%s)"
     #param应该为tuple或者list
     param=(title,singer,imgurl,url,alpha)
     #执行,如果成功,n的值为1
     n=cursor.execute(sql,param)

#再来执行一个查询的操作
     cursor.execute("select * from cdinfo")
     #我们使用了fetchall这个方法.这样,cds里保存的将会是查询返回的全部结果.每条结果都是一个tuple类型的数据,这些tuple组成了一个tuple
     cds=cursor.fetchall()
     #因为是tuple,所以可以这样使用结果集
     print cds[0][3]
     #或者直接显示出来,看看结果集的真实样子
     print cds

#如果需要批量的插入数据,就这样做
     sql="insert into cdinfo values(0,%s,%s,%s,%s,%s)"
     #每个值的集合为一个tuple,整个参数集组成一个tuple,或者list
     param=((title,singer,imgurl,url,alpha),(title2,singer2,imgurl2,url2,alpha2))
     #使用executemany方法来批量的插入数据.这真是一个很酷的方法!
     n=cursor.executemany(sql,param)

23. python连接其他数据库
    23.1. python连接postgreSQL数据库 py-postgresql-1.0.4.tar
    23.2. python连接sybase数据库 python-sybase 0.39
    23.3. python连接sqlite数据库pysqlite 2.6.3
    23.4. python连接mongodb数据库pymongo-2.1.1.tar.gz

24. python调用c封装的python库
    //包含python的头文件
    #include <python2.7/Python.h>
    // 1 c/cpp中的函数
    int my_c_function(const char *arg) {
        int n = system(arg);
        return n;
    }
    // 2 python 包装
    static PyObject * wrap_my_c_fun(PyObject *self, PyObject *args) {
        const char * command;
        int n;
        if (!PyArg_ParseTuple(args, "s", &command))//这句是把python的变量args转换成c的变量command
            return NULL;
        n = my_c_function(command);//调用c的函数
        return Py_BuildValue("i", n);//把c的返回值n转换成python的对象
    }
    // 3 方法列表
    static PyMethodDef MyCppMethods[] = {
        //MyCppFun1是python中注册的函数名,可以注册多个函数被python脚本调用，wrap_my_c_fun是函数指针
        { "MyCppFun1", wrap_my_c_fun, METH_VARARGS, "Execute a shell command." },
        { "MyCppFun2", wrap_my_c_fun, METH_VARARGS, "Execute a shell command 2." },
        { NULL, NULL, 0, NULL }
    };
    // 4 模块初始化方法init后面必须为库名称initMyCppModule编译的库必须命名为MyCppModule.so
    PyMODINIT_FUNC initMyCppModule(void) {
        //初始模块，把MyCppMethods初始到MyCppModule中
        PyObject *m = Py_InitModule("MyCppModule", MyCppMethods);
        if (m == NULL)
            return;
    }

g++ -shared -fPIC pythonc.cpp -I/export/home/wangyf/tools/python2.7.2/include -o MyCppModule.so

# -*- coding: utf-8 -*-
    import MyCppModule
    #导入python的模块（也就是c的模块，注意so文件名是MyCppModule
    r = MyCppModule.MyCppFun1("ls -l")
    r = MyCppModule.MyCppFun2("ls -lrt")
    print r
    print "OK"

25. c调用python
    库文件需要放在python的库目录下
    若使用当前目录下的python库函数需要加载把当前目录加载到库目录下
    PyRun_SimpleString("import sys; sys.path.append('.')");
    # pytest.py
    def add(a,b):
        print "in python function add"
        print "a = " + str(a)
        print "b = " + str(b)
        print "ret = " + str(a+b)
        return a + b

// ccallp.cpp
    #include <stdio.h>
    #include <stdlib.h>
    #include <python2.7/Python.h>

int main(int argc, char** argv)
     {
         // 初始化Python
         //在使用Python系统前，必须使用Py_Initialize对其
         //进行初始化。它会载入Python的内建模块并添加系统路
         //径到模块搜索路径中。这个函数没有返回值，检查系统
         //是否初始化成功需要使用Py_IsInitialized。

PyObject *pName, *pModule, *pDict, *pFunc, *pArgs, *pRetVal;

Py_Initialize();
         // 检查初始化是否成功
         if ( !Py_IsInitialized() )
        {
             return -1;
         }

// 载入名为pytest的脚本(注意：不是pytest.py)
        // PyRun_SimpleString("import sys; sys.path.append('.')");
         pName = PyString_FromString("pytest");
         pModule = PyImport_Import(pName);
         if ( !pModule )
         {
             printf("can't find pytest.py");
             getchar();
             return -1;
         }
         pDict = PyModule_GetDict(pModule);
         if ( !pDict )
        {
             return -1;
         }

// 找出函数名为add的函数
         pFunc = PyDict_GetItemString(pDict, "add");
         if ( !pFunc || !PyCallable_Check(pFunc) )
         {
             printf("can't find function [add]");
             getchar();
             return -1;
         }

// 参数进栈
         pArgs = PyTuple_New(2);

// PyObject* Py_BuildValue(char *format, ...)
         // 把C++的变量转换成一个Python对象。当需要从
         // C++传递变量到Python时，就会使用这个函数。此函数
         // 有点类似C的printf，但格式不同。常用的格式有
         // s 表示字符串，
         // i 表示整型变量，
         // f 表示浮点数，
         // O 表示一个Python对象。

PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",3));
        PyTuple_SetItem(pArgs, 1, Py_BuildValue("l",4));

// 调用Python函数
        pRetVal = PyObject_CallObject(pFunc, pArgs);
        printf("function return value : %ld\r\n", PyInt_AsLong(pRetVal));

Py_DECREF(pName);
        Py_DECREF(pArgs);
        Py_DECREF(pModule);
        Py_DECREF(pRetVal);

// 关闭Python
        Py_Finalize();
        return 0;
    }
    // sunOS下编译需要指定库文件
    g++ ccallp.cpp -I/export/home/wangyf/tools/python2.7.2/include -o ccallp -lpython2.7 -ldl -lrt
    # 结果
    /export/home/wangyf/python/learn>% ccallp
    in python function add
    a = 3
    b = 4
    ret = 7
    function return value : 7

26. python正则表达式
    26.1. 元字符. ^ $ * + ? { [ ] \ | ( )
    ".":表示任意一个字符。
        匹配的扩展名不是 "bat" 的文件名
        .*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$
    "$":表示必须以指定字符结尾。
    "|":左右表达式任意匹配一个。
    "[]":常用来指定一个字符类别，
    所谓字符类别就是你想匹配的一个字符集。
    字符可以单个列出，也可以用“-”号分隔的两个给定字符来表示一个字符区间。
    例如，[abc] 将匹配"a", "b", 或"c"中的任意一个字符；
    也可以用区间[a-c]来表示同一字符集，和前者效果一致。如果你只想匹配小写字母，re写成 [a-z].

元字符在类别里并不起作用。例如，[akm$]将匹配字符"a", "k", "m", 或 "$" 中的任意一个；"$"通常用作元字符，但在字符类别里，其特性被除去，恢复成普通字符
    "^"字符本身。例如，[^5] 将匹配除 "5" 之外的任意字符。
    "*":指定前一个字符可以被匹配零次或更多次，而不是只有一次。
    "+":表示匹配一或更多次。
        请注意 * 和 + 之间的不同；"*"匹配零或更多次，所以根本就可以不出现，而 "+"要求至少出现一次.
    "?":表示匹配零或一次。
    "{}":重复限定符是 {m,n}，其中 m 和 n 是十进制整数。该限定符的意思是至少有 m 个重复，
        至多到 n 个重复。举个例子，a/{1,3}b 将匹配 "a/b"，"a//b" 和 "a///b"。
        {0,} 等同于 *，{1,} 等同于 +，而{0,1}则与 ?
    \d 匹配任何十进制数；它相当于类 [0-9]。
　　\D 匹配任何非数字字符；它相当于类 [^0-9]。
　　\s 匹配任何空白字符；它相当于类 [ "t"n"r"f"v]。
　　\S 匹配任何非空白字符；它相当于类 [^ "t"n"r"f"v]。
　　\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
　　\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]。
　　这样特殊字符都可以包含在一个字符类中。如，["s,.]字符类将匹配任何空白字符或","或"."。