python 探索（三） Python CookBook 文本处理 笔记

Python 文本处理，看完本博文对python cookbook的笔记，足够了。

请善用目录。

更多的，详细的会更新。

每次处理一个字符

每次处理一个字符的方法：list，for，列表推导，map()，sets.Set()

列表推导和map() 比较推荐，简洁。至于效率高不高，这里不知。

# -*- coding: cp936 -*-import setsmystr = "abcdefghijklmn"def do_sth_with(c):    print c#method 1#直接内建list，然后for遍历list的每个cprint "method 1"list1 = list(mystr)for c in list1:    do_sth_with(c)#method 2#不创建list也能for遍历字符串的每个cprint "method 2"for c in mystr:    do_sth_with(c) #method 3#列表推导print "method 3"res = [do_sth_with(c) for c in mystr]#method 4#map映射print "method 4"res = map(do_sth_with,mystr)#method 5#set操作，也就set有& | - ^这些操作magic_chars = sets.Set('abracadabra')print "magic_chars : " + str(magic_chars)poppins_chars = sets.Set('supercalifragilisticexpialidocious')print "poppins_chars : "+str(poppins_chars)print 'magic_chars和poppins_chars的交集：'+''.join(magic_chars & poppins_chars)

结果：

#1 ~4 都是打印a到nmethod 5:acrd

拓展阅读：

Python的函数参数传递：传值？引用？

Python 学习笔记 02 – List 推导式-zhoukeli2005-ChinaUnix博客

python内置函数map/reduce/filter - 云计算架构师-解占辉 - 51CTO技术博客

Python Sets.Set 的& | - ^ 等操作

字符和字符值之间的转换

关键函数：ord,chr,unichr,利用好map()。

# -*- coding: cp936 -*-#asciiprint ord('a')print chr(97)#unicodeprint ord(u'\u2020')print repr(unichr(8224))#把字符串变成各个字符的值的列表print map(ord,'Hello Wolrd')#反过来print ''.join(map(chr,range(97,100)))

结果：

97a8224u'\u2020'[72, 101, 108, 108, 111, 32, 87, 111, 108, 114, 100]abc

拓展阅读：

str()和 repr() (及 `` 操作符) - 51CTO.COM

测试一个对象是否是类字符串

推荐使用isStringLike()方法，这里被python的鸭子判断法逗笑了。

# -*- coding: cp936 -*-#最傻的方法，连unicode对象都无法通过，自己的str子类也无法通过def isExactlyAString(anobj):    return type(anobj) is type('')#接近完美的方法,basestring是str和unicode的共同基类#用户自定义类型也是应该从basestring派生#美中不足的是python标准库的UserString无法通过，因为它不是从basestring派生def isAString(anobj):    return isinstance(anobj,basestring)#退而求其次的方法，虽慢，但有效。行为判断！#python的鸭子判断法，走路像鸭子，叫声像鸭子，那么我们就认为它是鸭子！def isStringLike(anobj):    try: anobj.lower() + anobj + ''    except: return False    else: return Trueprint isExactlyAString('a')print isExactlyAString(u'a')print isAString('a')print isAString(u'a') #暂时找不到UserString使用教程print isStringLike('a')print isStringLike(u'a')

结果：

TrueFalseTrueTrueTrueTrue

字符串对齐

python处理文本对齐：ljust，rjust，center

# -*- coding: cp936 -*-#共生成20个字符print '|','hej'.ljust(20),'|','hej'.rjust(20),'|','hej'.center(20),'|'#还可以指定分隔字符print '|','hej'.ljust(20,'#'),'|','hej'.rjust(20,'#'),'|','hej'.center(20,'#'),'|'

结果：

| hej                  |                  hej |         hej          || hej################# | #################hej | ########hej######### |

结果看到的首尾的空格是print , 造成的。 

去除字符串两端的空格

关键函数：lstrip(),rstrip(),strip() ，他们还能指定要去掉的字符（字符串）

# -*- coding: cp936 -*-x = '                hej                 'print '|',x.lstrip(),'|',x.rstrip(),'|',x.strip(),'|'y = 'ababab xx bababa'print '|',y.lstrip('ab'),'|',y.rstrip('ab'),'|',y.strip('ab'),'|'

结果：

| hej                  |                 hej | hej ||  xx bababa | ababab xx  |  xx  |

合并字符串

以后再用+或者+=就剁手吧！因为字符串是不可改变对象，所以在用+或+=的时候，会产生大量的中间对象，它们不断被创建和丢弃，效率不高。

reduce其实和+或+=一样。

原则是：避免中间对象!用join！！

# -*- coding: cp936 -*-l = ['a','b','c','d','e','f','g']largeString = ''.join(l)print largeString

结果：

abcdefg

 

拓展阅读：

Python print函数用法，print 格式化输出

将字符串逐字符或逐词反转

对于逐字符：很喜欢[::-1]这种靠步长来整的。

对于逐词汇：reverse 和 [::-1] 也有用！

最后的正则：(\s+) 匹配不是空白字符的字符串。

re.split(r('\s+'),s) 能够保留原来的空格。

# -*- coding: cp936 -*-import res = 'Hello  World'#步长为-1，表示从尾开始复制print s[::-1]#逐词revwords = s.split()revwords.reverse()print ' '.join(revwords)#逐词简约版revwords = ' '.join(s.split()[::-1])print  revwords#正则版本，保留空格revwords = re.split(r'(\s+)',s)revwords.reverse()revwords = ''.join(revwords)print revwords#正则简约版revwords = ''.join(re.split(r'(\s+)',s)[::-1])print revwords#reversed 代替 [::-1]revwords = ' '.join(reversed(s.split( )))print revwordsrevwords = ''.join(reversed(re.split(r'(\s+)',s)))print revwords

检查字符串中是否包含某字符集合中的字符

这一节收获最大的是学会了一个思路：集合set，difference！

学会了一个装的艺术：maketrans 和 translate。

maketrans 和 translate的用法，简单说就是：

s = 'abcdefg-1234567' #原始字符

table = string.maketrans('abc', 'ABC') #把字符串中的abc字符集合映射成ABC字符集合

deltable = 'bc123' #待删除字符集合

s.translate(table,deltable) #s删除掉deltable的字符后，对着table映射

结果是：Adefg-4567

Ps：这两个货，仅仅限于普通字符串，连Unicode都不行

在判断str1是否包含str2某些元素的时候：

import string

notrans = string.maketrans('','') #意思是不做映射

def containsAny(str1,str2):

return len(str1) != len(str1.translate(notrans,str2))  #str1删除str2中元素后，若len值发生改变，返回True，被删除的是共同元素

在判断str1是否完全包含str2的时候：

import string

notrans = string.maketrans('','')

def containsAll(str1,str2):

return not str2.translate(notrans,str1)

如果str1完全包含str2，str2.translate(notrans,str1)会是一个空集合，not {} 就是True

如果str1不能全含str2，str2.translate(notrans,str1)会是一个非空集合{},，非空为True，not 非空就是False

# -*- coding: cp936 -*-import itertoolsimport string'''aset包含seq任意字符即可'''#method 1 这是最朴素简单实用的短路法。def containsAny(seq,aset):    for c in seq:        if c in aset: return True    return False#method 2 装逼写法，依旧短路法def containsAny2(seq,aset):    for item in itertools.ifilter(aset.__contains__,seq):        return True    return False#method 3 装的艺术 - maketrans和translatenotrans = string.maketrans('','')def containsAny3(astr,strset):    return len(astr) != len(astr.translate(notrans,strset))'''seq包含aset全部字符'''#method 4 这也是最朴素简单实用的短路法def containsAll(seq,aset):    for c in aset:        if c not in seq: return False    return True#method 5 set集合 difference 不是短路法，效率没3高def containsAll2(seq,aset):    return  not set(aset).difference(seq)#method 6 装的艺术 - maketrans和translatenotrans = string.maketrans('','')def containsAll3(astr,strset):    return not strset.translate(notrans,astr)str1 = 'abcdefg'str2 = 'ghijklm'str3 = 'abcdef'str4 = 'abcd'L1 = [1,2,3,3]L2 = [1,2,3,4]print containsAny(str1,str2)       #str1 contains any of str2 True print containsAny2(str1,str2)      #str1 contains any of str2 Trueprint containsAll(str3,str4)       #str3 contains all of str4 True print containsAll(str4,str3)       #str4 contains all of str3 Falseprint containsAll2(L1,L2)           #L1 contains aLL of L2 Falseprint containsAll2(L2,L1)           #L2 contains all of L1 Trueprint containsAny3(str1,str2)      #str1 contains any of str2 True print containsAll3(str3,str4)      #str3 contains all of str4 True  print containsAll3(str4,str3)      #str4 contains all of str3 False 

拓展阅读：

Python：itertools模块

python之maketrans translate_阿雅菲菲儿_新浪博客

简化字符串的translate方法的使用

首次接触：工厂函数，闭包。

定义不说，直接上实例：

def line_conf(a,b):
    def line(x):
        return a*x + b
    return line

line1 = line_conf(1,1)
line2 = line_conf(4,5)
print line1(5),line2(5) #6 25

其中line_conf 这个函数为一个工厂函数，也可以称为闭包工厂，强调它创建并返回闭包（类似于C++函数指针？）。

说到这里，你应该猜到了，内层函数line()，由一个变量line来指代，这内层函数就是一个闭包。

博客园的Vamei这么说：一个函数和它的环境变量在一起，就可以被称为闭包。这里函数为line()，它的环境变量时a,b。

引入上面的概念是为了说一件事，Fred L.Drake,Jr 认为，translate 和 maketrans 很好用，但是老在用的时候想不起细节，耽误时间，所以自己写一个工厂函数，可以方便许多。

import string#这是由Fred L.Drake,Jr 提供的 闭包工厂#我觉得特别不错！！！忽略delete和keep同时存在的情况，因为那不科学#如果真要同时存在，我认为分两次处理，才是科学的def translator(frm='',to='',delete='',keep=None):    if len(to) == 1:        to = to * len(frm)    trans = string.maketrans(frm,to)    if keep is not None:        allchars = string.maketrans('','')        #delete = allchars.translate(allchars,keep)        delete = allchars.translate(allchars,keep.translate(allchars,delete))    def translate(s):        return s.translate(trans,delete)    return translatedigits_only = translator(keep=string.digits)print digits_only('aaaaa11111111aaaaa') #11111111no_digits = translator(delete=string.digits)print no_digits('aaaaa11111111aaaaa') #aaaaaaaaaa#用字符替换某个集合的字符digits_to_hash = translator(frm=string.digits,to='#')print digits_to_hash('aaaaa11111111aaaaa') #aaaaa########aaaaa

拓展阅读：

Python深入04 闭包 - Vamei - 博客园

过滤字符串中不属于指定集合的字符

关键：我又找到一个给字符去重和排序的方法了。

又一次闭包工厂！

import string#这个只要translate取反keep即可allchars = string.maketrans('','')def makefilter(keep):    delchars = allchars.translate(allchars,keep)    def thefilter(s):        return s.translate(allchars,delchars)    return thefilter#准备阶段keep = makefilter('abc')#执行阶段print keep('abcdefgaaa') # abcaaa#规整字符串，无重，排好序def canonicform(s):    return makefilter(s)(allchars)s = 'aaaaaaaaaasldkfjgh'print canonicform(s) #adfghjkls#等同于aa = makefilter(s)print aa(allchars) #adfghjkls

可是！Unicode，不行！Unicode的translate 反而更加简单。

import string#unicode translate 反而更加简单，就一个table，映射即可tb = dict([ (ord(ch), None) for ch in u" aeiou"])s = u'four score and seven years ago'print s.translate(tb) #frscrndsvnyrsg#本任务中考虑到str要被keep，而不是被del#要有一个巨大的dict来标记想要的和不想要的！#Fred L.Drake,Jr提供了一个特不错的方法(大神就是大神)：import setsclass Keeper(object):    def __init__(self,keep): #构造函数        self.keep = sets.Set(map(ord,keep))    def __getitem__(self,n):  #重载[]        if n not in self.keep:            return None        return unichr(n)    def __call__(self,s): #被调用触发        return unicode(s).translate(self)makefilter = Keeper #重命名下 if __name__ == '__main__':    just_vowels = makefilter('aeiouy')    print just_vowels(u'four score and seven years ago')

检查一个字符串是文本还是二进制

我这个直接拓展成，检查一个文件是文本文件还是二进制文件！

在istextfile中，切记，用"rb"打开。

Fred的想法好奇特：用启发式探索法来判断。最高位为1的概率，超过阈值%30就判断为二进制。

from __future__ import division #Fred说，这兼容未来？import stringtext_characters = "".join(map(chr,range(32,127))) + "\n\r\t\b"_null_trans = string.maketrans("","")def istext(s,text_characters=text_characters,threshold = 0.30):    #threshold 阈值     #s包含了空值，不是文本，空值是文本的结束标志    if "\0" in s:        return False    #逻辑判定：空字符串是文本    if not s:        return True    print 'aa'       t = s.translate(_null_trans,text_characters)    print len(t),len(s),len(t) / len(s)    return  len(t) / len(s) <= thresholddef istextfile(filename,blocksize=512):    return istext(open(filename,"rb").read(blocksize))print istext("123123123123") #Trueprint istextfile('1.bin') #Falseprint istextfile('1.txt') #True

拓展阅读：

[Python学习]判断一个文件是文本还是二进制的 - limodou的学习记录

控制大小写

upper()            THIS IS OUYANG

lower()             this is ouyang

capitalize()      This is ouyang

title()                This Is Ouyang

哈，又看到喜闻乐见的鸭子判断法。

#检查字符串是不是符合 开头大写，其余小写的情况import stringnotrans = string.maketrans('','')def containsAny(str,strset):    return len(str) != len(str.translate(notrans,strset))#还记得鸭子判断法吗？叫声像(能capitalize)+长得像(containsAny)。def isCapitaliezd(s):    return s == s.capitalize() and containsAny(s,string.letters)s1 = 'This is ouyang...'s2 = 'this is ouyang...'print isCapitaliezd(s1) #Trueprint isCapitaliezd(s2) #False

拓展阅读：

Python String capitalize() Method

访问子字符串

本节接触了：

struct.unpack() 

zip()

封装 和 memoizing思想

python不会溢出

三元运算符 flag and 's' or 'x'  == flag?'s':'x'

yield (请看拓展阅读)

import structtheline = 'abcdefghijklmnopqrstuvwxyz1234567890'#struct.unpack()按照指定格式baseformat = "5s 3x 8s 8s"numremain = len(theline) - struct.calcsize(baseformat)format = "%s %ds" % (baseformat,numremain)l,s1,s2,t = struct.unpack(format,theline)print l,s1,s2,t#struct.unpack()这么优秀的东西 - 封装def fields(baseformat,theline,lastfield = False):    numremain = len(theline) - struct.calcsize(baseformat)    #lastfield and 's' or 'x' == lastfield ? 's':'x'    format = "%s %d%s" % (baseformat,numremain,lastfield and 's' or 'x')    return struct.unpack(format,theline)print 'lastField == True : ',fields(baseformat,theline,True)print 'lastField == False : ',fields(baseformat,theline,False)#struct.unpack()这么优秀的东西 - 封装 - memoizing 版本 - 字典做缓存def fields_memoizing(baseformat,theline,lastfield = False,_cache={}):    key = baseformat,len(theline),lastfield    format = _cache.get(key)    if format == None:        numremain = len(theline) - struct.calcsize(baseformat)        _cache[key] = format = "%s %d%s" % (baseformat,numremain,lastfield and 's' or 'x')    return struct.unpack(format,theline)print 'lastField == True : ',fields_memoizing(baseformat,theline,True)print 'lastField == False : ',fields_memoizing(baseformat,theline,False)#5字节一组,最后不足5字节也不会越界fivers = [theline[k:k+5] for k in xrange(0,len(theline),5)]print fivers#5字节一组,最后不足5字节也不会越界 - 封装def split_by(theline,n,lastfield):    pieces = [theline[k:k+n] for k in xrange(0,len(theline),5)]    #如果最后一段太短或不需要，丢弃    if not lastfield and len(pieces[-1]) < n:        pieces.pop()    return piecesprint 'split_by lastField == True : ',split_by(theline,5,True)print 'split_by lastField == False : ',split_by(theline,5,False)#指定长度的切片,zip()打包成元组cuts = [8,14,20,26,30]pieces = [theline[i:j] for i,j in zip([0]+cuts,cuts+[None])]print pieces#指定长度的切片,zip()打包成元组 - 封装def split_at(theline,cuts,lastfield):    pieces = [theline[i:j] for i,j in zip([0]+cuts,cuts+[None])]    #若不要最后一段，丢弃    if not lastfield :        pieces.pop()    return piecesprint 'split_at lastField == True : ',split_at(theline,cuts,True)print 'split_at lastField == False : ',split_at(theline,cuts,False)

在拓展阅读第二篇，南柯一梦介绍了利用zip()以指定概率获取元素，我觉得不错。

在拓展阅读第四篇，讲解了yield的用法，他让我明白了为什么引入yield。

#指定长度的切片,zip()打包成元组 - 封装 - yield 迭代对象#这已经不是一个fun()了，而是一个generator()，返回一个迭代器对象def split_at_yeild(theline,cuts,lastfield = True):    last = 0    for cut in cuts:        yield theline[last:cut]        last = cut    if  lastfield:        yield theline[last:]    for i in split_at_yeild(theline,cuts,True):    print i

拓展阅读：

Python模块学习 ---- struct 数据格式转换

Python中zip()函数用法举例 | 南柯一梦

字典和元组——菜鸟的Python笔记

Python yield 使用浅析

改变多行文本字符串的缩进

关键：str.splitlines(False or True) ,为True的时候保留'\n'

#对齐def reinent(s,numSpaces):    leading_space = numSpaces * ' '    lines = [leading_space + line.strip() for line in s.splitlines()]    return '\n'.join(lines)def addSpaces(s,numAdd):    white = " "*numAdd    return white + white.join(s.splitlines(True))def numSpaces(s):    return [len(line) - len(line.lstrip()) for line in s.splitlines()]def delSpaces(s,numDel):    if numDel > min(numSpaces(s)):        raise ValueError,"删的空格比最小空格数大"    return '\n'.join(line[numDel:] for line in s.splitlines())x = """    line one    line two    and line three """print xprint reinent(x,4)print addSpaces(x,4)print delSpaces(x,3)

拓展和压制制表符

关键词：enumerate() 是同时去index索引，和内容list[index]的内置函数。

关键词：expandtabs() 把tab转成空格

我认为，tab和空格的互转，一般是tab转空格，一个expandtabs()就足够了，空格转tab可能只出在考试题中。

#把tab转成空格s = "a\t aaaaa\t         aaaa"s1 = s.expandtabs()print s,len(s)  print s1,len(s1)#把空格转成tabdef unexpand(s,tablen = 8):    import re    #切分成空格和非空格    pieces = re.split(r'( +)',s.expandtabs())    #记录当前字符串总长度    lensofar = 0    for i,piece in enumerate(pieces):        thislen = len(piece)        lensofar += thislen        if piece.isspace():            #把每个空格序列改成tab+spaces            numtabs = (thislen-numblanks+tablen-1)/tablen            print numblanks,numtabs            pieces[i]='\t'*numtabs +' '*numblanks    return ''.join(pieces)s2 = unexpand(s1)print s1,len(s1)print s2,len(s2)

差点被路过的真相：python下用expandtabs()，会发现有的'\t'占8个，有的占4个，有的3个，总之很乱，我还以为是IDLE的问题。

刚刚手里吃着玉米，也不能编码，就谷歌：python expandtabs ，出现了拓展阅读的第二篇。解答了我的疑惑。 

其实这都和拓展位有关。感谢同事和他递过来的玉米。

拓展阅读：

python天天进步(7)--enumerate用法 - 久月 - 博客园

字符串方法expandtabs和制表位(tabstops) | Shine.IT

替换字符串中的子串

任务要求是：某字符串中被标记的字符串要被按照字典，替换掉。

比如说：str = 'just "a" test'   dict = {'a':'one'} ，那么结果是：'just one test'

关键词：偶数项就是要替换的子字符串。

Ps：增加一个安全模式感觉很专业。

def expand(format,d,marker='"',safe = False):    if safe:        #dict.get(key[, default])        def lookup(w):return d.get(w,w.join(marker*2))    else:        def lookup(w):return d[w]    parts = format.split(marker)    #偶数项 就是要替换的子字符串    parts[1::2] = map(lookup,parts[1::2])    return ''.join(parts)format = 'just  a "a" "b" test 'print expand(format,{'a':'one','b':'two'})#>>> #just  a one two test  #>>>

还有个更加专业的做法：

Tem = string.Template('$thing')

Tem.substitute({'thing':5})

local() 内置函数，存储了本地变量

import stringnew_style = string.Template('this is $thing')print new_style.substitute({'thing':5})print new_style.substitute({'thing':'test'})print new_style.substitute(thing = 5)print new_style.substitute(thing = 'test')#local() 本地变量msg = string.Template('the square of $number is $square')for number in range(10):    square = number * number    print msg.substitute(locals())

一次完成多个替换

sub( pattern, repl, string[, count]) :用repl替换pattern匹配到的string，最多count次

其中，repl可以是string，也可以是func()

当repl是函数的时候，对每一个在string内的，不重叠的，匹配pattern的子串，调用repl（substring），然后用返回值替换substring。

对于上述的黑体字，本人做了个小实验，实验代码：

import readict = {'a':'1','b':'2'}s = 'abacabc'print  '|'.join(map(re.escape,adict))def multiple_replaces(text,adict):    robj = re.compile('|'.join(map(re.escape,adict)))    def one_xlat(match):        print '###',match.group(0)        return adict[match.group(0)]    return robj.sub(one_xlat,text)print multiple_replaces(s,adict)

实验结果：

>>> a|b### a### b### a### a### b121c12c>>> 

明显发现：

（1）我们调用一次sub()，sub()内部就调用了5次one_xlat()。
（2）顺序是 a b a a b ，和s='abacabc'中a,b出现的顺序一致。

我猜测，按照s从左到右顺序，s被'a|b'匹配一次就替换一次，然后重头再匹配，所以s的生成历程是：

1bacabc

12acabc

121cabc

121c1bc

121c12c

match.gourp(0) ：匹配整个表达式的字符串，group(i) 就表示第i个括号表达式匹配到的字符串

考虑到以后很多情况下，dict是固定的，其实我们只要做一次准备工作就够了。而上面的版本是用一次，准备一次。

很自然的想到闭包工厂！（在前几节有提到这概念）

我们就准备一次transalte，然后就能用translate去无限匹配替换text了。

import redef make_xlat(*args,**kwds):    adict = dict(*args,**kwds)    rx = re.compile('|'.join(map(re.escape,adict)))    def one_xlat(match):        return adict[match.group(0)]    def xlat(text):        return rx.sub(one_xlat,text)    return xlatadict = {"a":"1","b":"2"}translate = make_xlat(adict)print translate('abacacb')                

如果老板让处理单词的替代（正则中单词：r'\b\S+\b' ）：

rx = re.compile(r'\b%s\b' % r'\b|\b'.join(map(re.escape,adict))) #单词版本

如果用函数，这两个版本得重复代码，为了追求专业和优秀，就编码一次！

你说函数传入rx？还是传入compile的内容？oh，天啊，还得在函数外定义些玩意，不够优秀。

alex说，可以用class，以后想要rx就重载make_rx()。

import reclass make_xlat:    def __init__(self,*args,**kwds):        self.adict = dict(*args,**kwds)        self.rx = self.make_rx()    def make_rx(self):        return re.compile('|'.join(map(re.escape,self.adict)))    def one_xlat(self,match):        return self.adict[match.group(0)]    def __call__(self,text):        return self.rx.sub(self.one_xlat,text)#重载！class make_xlat_by_whole_words(make_xlat):    def make_rx(self):        return re.compile(r'\b%s\b' % r'\b|\b'.join(map(re.escape,self.adict)))adict = {"a":"1","b":"2","xyz":"456"}translate = make_xlat(adict)translate_by_whole_words = make_xlat_by_whole_words(adict)print translate('aba xyz cacb')print translate_by_whole_words('aba xyz cacb')''' 结果：            >>> 121 456 c1c2aba 456 cacb>>>'''

Ps：本节重新洗脑了：闭包工厂的思想。同时给我的大脑，加入一个神经发射：当代码重复的时候，就不美丽了，改用class以及重载了。

拓展阅读：

python正则表达式学习 百变贝贝

检查字符串中的结束标记

我需要先介绍下 itertools.imap（选自Python API）：

def imap(function, *iterables):    # imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000    iterables = map(iter, iterables)    while True:        args = [next(it) for it in iterables]        if function is None:            yield tuple(args)        else:            yield function(*args)

1、先把参数都变成iter对象，iter是个funciton

2、循环调用func来处理iter对象

3、如果看不懂yield，请看拓展阅读第二篇

检查字符串中的结束标记：

Ps：s.endswith 是个function

import itertools,osdef anyTrue(predicate,sequence):    return True in itertools.imap(predicate,sequence)def endswith(s,*endings):    return anyTrue(s.endswith,endings)for f in os.listdir('.'):    if endswith(f,'.jpg','.png','.jepg'):        print f'''>>> psu.jpgQQ图片20130927105447.jpg>>> '''

本节还引入了一个概念：被绑定办法（Bound Method）

L = ['a','b','c']x = L.appendx('d')print L

这里的x('d') == L.append('d')，x也就是L的一个被绑定办法
这么操作，x是List类型的一个被绑定方法：

x = List.appendx(L,'d') == L.append('d')

拓展阅读：

iter API

Python yield 使用浅析（第二次介绍了）

使用Unicode来处理国际化文本

为什么用utf8，因为它通用：

german_ae = unicode('\xc3\xa4','utf8')print german_ae'''>>> ä>>>'''

实际上，如果不转换的话，'\xc3\xa4'它就既不是unicode，又不是ascii（高位为1）。python拒绝猜测，所以会报错。

这里也是接触到了几条Python原则：

1、在模糊面前拒绝猜测

2、在IO动作的关口做转换

好吧，在任何一个Python交互式shell输入import this：

>>> import thisThe Zen of Python, by Tim PetersBeautiful is better than ugly.Explicit is better than implicit.Simple is better than complex.Complex is better than complicated.Flat is better than nested.Sparse is better than dense.Readability counts.Special cases aren't special enough to break the rules.Although practicality beats purity.Errors should never pass silently.Unless explicitly silenced.In the face of ambiguity, refuse the temptation to guess.There should be one-- and preferably only one --obvious way to do it.Although that way may not be obvious at first unless you're Dutch.Now is better than never.Although never is often better than *right* now.If the implementation is hard to explain, it's a bad idea.If the implementation is easy to explain, it may be a good idea.Namespaces are one honking great idea -- let's do more of those!>>> 

在Unicode和普通字符串之间转换

这里放下预言：将来某一天一定会被这个Unicode和str搞死的。

拓展阅读：

str和unicode解析（这是一段有趣的对话，明白encode和decode的真正意义）

在标准输出中打印Unicode字符

pass

对Unicode数据编码并用于XML和HTML

pass

让某些字符串大小写不敏感

pass

将HTML文档转化为文本显示到UNIX终端上

tty是终端设备的统称，isatty应该是is attached tty？：

if sys.stdout.isatty():    # You're running in a real terminalelse:    # You're being piped or redirected

拓展阅读：

Linux中tty、pty、pts的概念区别 - 小苗 - 51CTO技术博客

python - How do I detect whether sys.stdout is attached to terminal or not? - Stack Overflow

formatter的相关资料