python其他

# -*- coding: utf-8 -*-

# ====================

#File: python

#Author: python

#Date: 2014

#====================

__author__ = ‘Administrator‘

#第6章unicode

#unicode支持超过9000个字符

#怎么使用unicode

print u‘中国‘

print unicode(‘abc‘)

class A(object):

    @classmethod

    def f(cls,a):

          print cls,a

a=A()

a.f(‘a‘)

A.f(‘a‘)

a=‘abc‘

print a.decode(‘utf-8‘)

print a.encode(‘gbk‘)

#元类:__metaclass__

#经典类:types.ClassType

class C:

    pass

class CC:pass

print type(CC)

import types

print type(CC) is types.ClassType

#什么时候使用元类

#顺序：会先查找类属性__metaclass__,如果存在，就把这个属性赋值给类作为它的元类，如果赴存在，它向上查找

#父类中的__metaclass__,所有新式类如果没有任何父类，会从对象或者类中继承，如果还未发现__metaclass__属性，那会检查全局变量的 __metaclass

#如果存在，就使用它作为元类，否则只能是传统类，并使用types.ClassType作为此类的元类

#如果定义了一个传统类，并且设置了__metaclass__=type,那么其实它就变成了新式类

#元类三个参数:类名，从基类继承的元组和属性字典

#元类例子

import time

print

print

class M(type):

    def __init__(self,a,b,c):

        super(M,self).__init__(a,b,c)

        print ‘%r at:%s‘%(a,time.ctime())

class F(object):

    __metaclass__=M

    def __init__(self):

        print self.__class__.__name__,time.ctime()

print ‘\t you‘

f=F()

print ‘\t inta‘

#正则表达式

#流程

"""

   正则表达式引擎

文本  编译

   正则表达式对象

匹配的文本 匹配

      结果

"""

"""

语法        说明                        实例           匹配字符串（完整）

一般字符     匹配自身                   abc            abc

.            匹配任意除换行符\n外的字符  a.c           abc

\            转义字符，使后一个字符改变原来的意思a\.c       a.c

             如果字符串有字符*需要匹配，可以使用\*或者字符集[*]a\\c a\c

[...]        字符集，对应的位置可以是字符集任何字符，也可以给出

             范围，比如[abc]或者[a-c]，第一个字符如果是^则取反,如[^abc]表示不是abc其他字符 a[bcd]e abe ace ade

\d or \D \d数字[0-9]  a\dc  a1c  \D非这数字[^\d]    a\Dc   abc

\s  or \S  \s空白字符:[<空格>\t\r\n\f\v] a\sc a c

\S 非空白字符[^\s]      a\Sv  abb

\w单词字符[a-zA-Z0-9_] a\wc   abc

\W非字符[^\W] a\Wc  ac

&表示匹配一个字符0次或者无限次

+匹配1次或者无限次

?匹配0次或者1次

{m}匹配一个字符m次

{m,n}m,n可以省略，如果省略m，则匹配0到n次，如果省略n，则匹配m到无限次

*? +? ??

{m,n}? 使用*,+,?{m,n}非贪婪模式

^匹配开头

$匹配结尾

\A仅匹配开头

\Z仅匹配末尾  abc\Z           abc

\b匹配\w和\W之间  a\b!bc     abc

\B[^\B]

"""

#search()和match()的区别？

"""

match（）函数只检测RE是不是在string的开始位置匹配，search()会扫描整个string查找匹配,

也就是说match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none

search()会扫描整个字符串并返回第一个成功的匹配

"""

import re

#compike(obj[,flag])

p=re.compile(‘hello world‘)#编译成p对象

m=p.match(‘hello world!‘)#使用p匹配文本，获得匹配结果，无法匹配时，则返回None

if m:

    print m.group()#使用m.group()获得分组信息

#结果

#hello world

"""

re.compile(strPattern[, flag]):

这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符‘|‘表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile(‘pattern‘, re.I | re.M)与re.compile(‘(?im)pattern‘)是等价的。

可选值有：

re.I(re.IGNORECASE)忽略大小写（括号内完整写法）

re.M(MULTILINE)多行模式，改变^和$行为

re.S(DOTALL)点任何匹配模式 ，改变.的行为

re.L(LOCDE)使预定字符\w \W \b \B \s \S 取决于当前区域设定

U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性

X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的

"""

#例子

a = re.compile(r"""\d +  # the integral part

                   \.    # the decimal point

                   \d *  # some fractional digits""", re.X)

b=re.compile(r‘\d\.\d*‘)

#re提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用Pattern实例的相应方法替代，唯一的好处是少写一行re.compile()代码，但同时也无法复用编译后的Pattern对象。这些方法将在Pattern类的实例方法部分一起介绍。如上面这个例子可以简写为：

m=re.match(‘h‘,‘h w‘)

print m.group()

#re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。

"""

 Match

Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。

属性：

string: 匹配时使用的文本。

re: 匹配时使用的Pattern对象。

pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。

endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。

lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。

lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。

方法：

group([group1, …]):

获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。

groups([default]):

以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。

groupdict([default]):

返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。

start([group]):

返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。

end([group]):

返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。

span([group]):

返回(start(group), end(group))。

expand(template):用到组里面

将匹配到的分组代入template中然后返回。template中可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。\id与\g<id>是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符‘0‘，只能使用\g<1>0。

"""

m = re.match(r‘(\w+) (\w+)(?P<sign>.*)‘, ‘hello world!‘)

print m.string#string: 匹配时使用的文本。

print m.re#re: 匹配时使用的Pattern对象。

print m.pos#pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。

print m.endpos#endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。

print m.lastindex#lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。

print m.lastgroup# 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。

print m.group(1,2)

print m.groups()

print m.groupdict()

print m.start(2)

print m.end(2)

print m.span(2)

print m.expand(r‘\2 \1\3‘)

"""

Pattern

Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。

Pattern不能直接实例化，必须使用re.compile()进行构造。

Pattern提供了几个可读属性用于获取表达式的相关信息：

pattern: 编译时用的表达式字符串。

flags: 编译时用的匹配模式。数字形式。

groups: 表达式中分组的数量。

groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。

"""

p = re.compile(r‘(\w+) (\w+)(?P<sign>.*)‘, re.DOTALL)

print p.pattern

print p.flags

print p.groups

print p.groupindex

#更多请访问

#http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html

#or

#官方文档:https://docs.python.org/2.7/search.html?q=re&check_keywords=yes&area=default

python其他,古老的榕树,5-wow.com