show-me-the-code: 文本處理

第 0004 題：任一個英文的純文本文件，統計其中的單詞出現的個數。

第 0006 題：你有一個目錄，放了你一個月的日記，都是 txt，爲了不分詞的問題，假設內容都是英文，請統計出你認爲每篇日記最重要的詞。

第 0007 題：有個目錄，裏面是你本身寫過的程序，統計一下你寫過多少行代碼。包括空行和註釋，可是要分別列出來。

第 0011 題： 敏感詞文本文件 filtered_words.txt，裏面的內容爲如下內容，當用戶輸入敏感詞語時，則打印出 Freedom，不然打印出 Human Rights。

北京
程序員
公務員
領導
牛比
牛逼
你娘
你媽
love
sex
jiangge

第 0012 題： 敏感詞文本文件 filtered_words.txt，裏面的內容 和 0011題同樣，當用戶輸入敏感詞語，則用 星號 * 替換，例如當用戶輸入「北京是個好城市」，則變成「**是個好城市」。

 

re

    正則表達式設計之初，就是爲了處理字符串的，是一個強大的工具，擁有本身獨特的語法以及一個獨立的處理引擎，功能十分強大，基本全部的開發語言都支持正則表達式，語法基本相同，區別在於不一樣的編程語言實現的語法數量的不一樣；

    正則表達式都是通過正則表達式引擎編譯以後生成正則表達式對象，而後用生成的正則表達式對象去跟須要匹配的文本進行匹配，得出匹配結果，匹配過程包含了此次成功匹配的信息（匹配的到的字符串、分組以及在文本中的索引）

詳細可參考博客：http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html

其中寫的很詳細

    簡單的過濾敏感詞可用 re 模塊匹配，而後替換爲 *

 

glob

    Python 中 glob 模塊能夠查找特定規則的文件路徑名， 查找文件可用到三個匹配符：

# *：匹配 0 個或多個字符
# ?：匹配單個字符
# []：匹配指定範圍內的字符（[0-9] 匹配數字）

glob.glob

    返回全部匹配的文件路徑列表，glob.glob(pathname)，參數 pathname 定義了文件路徑匹配規則：

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

improt glob 

# 獲取當前目錄下全部以 .py 結尾的文件
filelist = glob.glob('./*.py')

glob.iglob

    獲取一個可遍歷的對象，可逐個獲取匹配的文件路徑名，iglob 一次獲取一個匹配路徑，glob 同時獲取全部匹配路徑

 

with

    with 語句是在 Python 2.5 版本引入的，從 2.6 版本開始成爲缺省的功能，with 語句做爲 try/finally 編碼範式的一種替代，用於對資源訪問進行控制的場合，使用 with 須要明報上下文管理器的概念，有了上下文管理器，with 語句才能工做。

上下文管理協議

    包含方法 __enter__() 和 __exit__()，支持該協議的對象要實現這兩個方法

上下文管理器

    支持上下文管理協議的對象，這種對象實現了 __enter__() 和 __exit__() 方法，上下文管理器定義執行 with 語句時要創建的運行時上下文，負責執行 with 語句塊上下文中的進入與退出操做，一般使用 with 語句調用上下文管理器，也能夠經過直接調用方法來使用。

運行時上下文

    由上下文管理器建立，經過上下文管理器的 __enter__() 和 __exit__() 方法實現，__enter__() 方法在語句體執行以前進入運行時上下文，__exit__() 在語句體執行完後從運行時上下文退出。with 語句支持運行時上下文這一律念。

上下文表達式

    with 語句中跟在關鍵字 with 以後的表達式，該表達式要返回一個上下文管理器對象。

語句體

    with 語句包裹起來的代碼塊，在執行語句體以前會調用上下文管理器的 __enter__() 方法，執行完語句體以後會執行 __exit__() 方法。

 

基本語法和工做原理

# with 語法格式

with context_expression [as target(s)]:
    with-body

    context_expression 返回一個上下文管理器對象，該對象並不賦值給 as 語句中的 target(s)，若是指定了 as，會將上下文管理器的 __enter__() 方法的返回值賦值給 target(s)，target(s) 能夠是單個變量，或者有「（）」括起來的元組。

    Python 對一些內建對象進行改進，加入了對上下文管理器的支持，能夠用於 with 語句中，例如能夠自動關閉文件、線程鎖的自動獲取和釋放。

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

# with 操做文件對象
with open(r'fileName') as somefile:
    for line in somefile:
        print(line)

    當使用了 with 語句，無論在處理文件過程當中是否發生了異常，都能保證 with 語句執行完畢後已經關閉了打開的文件句柄，傳統 try/finally：

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

somefile = open(r'fileName')
try:
    for line in somefile:
        print(line)
finally:
    somefile.close()

    還有 threading、decimal 等模塊也加入了對上下文管理協議的支持

with 語句執行過程

context_manager = context_expression
    exit = type(context_manager).__exit__  
    value = type(context_manager).__enter__(context_manager)
    exc = True   # True 表示正常執行，即使有異常也忽略；False 表示從新拋出異常，須要對異常進行處理
    try:
        try:
            target = value  # 若是使用了 as 子句
            with-body     # 執行 with-body
        except:
            # 執行過程當中有異常發生
            exc = False
            # 若是 __exit__ 返回 True，則異常被忽略；若是返回 False，則從新拋出異常
            # 由外層代碼對異常進行處理
            if not exit(context_manager, *sys.exc_info()):
                raise
    finally:
        # 正常退出，或者經過 statement-body 中的 break/continue/return 語句退出
        # 或者忽略異常退出
        if exc:
            exit(context_manager, None, None, None) 
        # 缺省返回 None，None 在布爾上下文中看作是 False


# 一、執行 context_expression，生成上下文管理器 context_manager
# 二、調用上下文管理器的 __enter__() 方法；若是使用了 as 子句，則將 __enter__() 方法的返回值賦值給 as 子句中的 target(s)
# 三、執行語句體 with-body
# 四、不論是否執行過程當中是否發生了異常，執行上下文管理器的 __exit__() 方法，__exit__() 方法負責執行「清理」工做，如釋放資源等。若是執行過程當中沒有出現異常，或者語句體中執行了語句 break/continue/return，則以 None 做爲參數調用 __exit__(None, None, None) ；若是執行過程當中出現異常，則使用 sys.exc_info 獲得的異常信息爲參數調用 __exit__(exc_type, exc_value, exc_traceback)
# 五、出現異常時，若是 __exit__(type, value, traceback) 返回 False，則會從新拋出異常，讓with 以外的語句邏輯來處理異常，這也是通用作法；若是返回 True，則忽略異常，再也不對異常進行處理

詳細可參考：http://www.ibm.com/developerworks/cn/opensource/os-cn-pythonwith/

 

collections

    collections 是 Python 內建的一個集合模塊，提供了不少有用的集合類

namedtuple

    tuple（元組） 能夠表示不變集合，例如一個座標能夠表示爲：

p = (1, 2)

    可是看到 （1，2）又很難知道這是一個座標點，而定義一個 class 又顯得有點隆重了，這時候就可使用 namedtuple ：

bpython version 0.16 on top of Python 3.5.1 /usr/local/opt/python3/bin/python3.5
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

# namedtuple 是一個函數，能夠用來建立一個自定的 tuple 對象，而且規定了 tuple 元素的個數
# 並能夠用屬性而不是索引來引用 tuple 的某個元素
>>> isinstance(p, Point)
True
>>> isinstance(p, tuple)
True

# 相似用座標和半徑表示一個圓
>>> Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

    使用 list 存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了，由於 list 是線性存儲，數據量大的時候，插入和刪除效率很低。

    deque 是爲了高效實現插入和刪除操做的雙向列表，適用於隊列和棧：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])
>>>

     deque 除了實現 list 的 append() 和 pop() 外，還支持 appendleft() 和 popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。

defaultdict

    使用 dict 時，若是引用的 Key 不存在，就會拋出 KeyErro，若是但願 key 不存在時，返回一個默認值，就可使用 defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1']
'abc'
>>> dd['key2']
'N/A'
>>>

    默認值是調用函數返回的，函數在建立 defaultdict 對象時傳入；

OrderedDict

    使用 dict 時，Key 是無序的，在對 dict 作迭代時，沒法肯定 Key 的順序，而保持 Key 順序，能夠用 OrderedDict

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d
{'c': 3, 'b': 2, 'a': 1}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# OrdereDict 的 Key 按照插入的順序排列，而不是 Key 自己排序

    使用 OrderedDict 還能夠實現一個 FIFO（先進先出）的 dict，當超出限制時，先刪除最先添加的 Key：

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

# 先進先出的 dict
from collections import OrderedDict

# 子類 LastUpdateOrderdDict 繼承自父類 OrderedDict
class LastUpdateOrderdDict(OrderedDict):

    def __init__(self, capacity):
        # 繼承父類的 __init__() 方法
        super(LastUpdateOrderdDict, self).__init__()
        self._capacity = capacity

    def __setitem__(self, key, value):
        containsKey = 1 if key in self else 0
        if len(self) - containsKey >= self._capacity:
            last = self.popitem(last=False)
            print("remove:", last)
        if containsKey:
            del self[key]
            print('set:', (key, value))
        else:
            print("add:", (key, value))
        OrderedDict.__setitem__(self, key, value)

md = LastUpdateOrderdDict(2)
md['a'] = 1
md['b'] = 2
md['c'] = 3
print(md)



# 運行結果
/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/bin/python3.5 /Users/pengchao/PycharmProjects/untitled3/fifo.py
add: ('a', 1)
add: ('b', 2)
remove: ('a', 1)
add: ('c', 3)
LastUpdateOrderdDict([('b', 2), ('c', 3)])

Process finished with exit code 0

 

Counter

    Counter 是一個簡單的計數器，能夠用來統計字符出現的個數：

>>> from collections import Counter
>>> c = Counter()
>>> for ch in 'programming':
...     c[ch] = c[ch] + 1
...
>>> c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})
>>> Counter('programming').most_common()
[('g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

 

super

    在 Python 類方法中，要想調用父類的某個方法，在 Python 2.2 以前，一般須要定義出來，這樣當父類發生變化時，子類須要從新遍歷整個類的定義，這樣對代碼的維護來講是災難性的。

    從 Python 2.2 開始，引入了一個關鍵字 super 用來解決這個問題

super(type[, object-or-type])
  Return the superclass of type. If the second argument is omitted the super object
  returned is unbound. If the second argument is an object, isinstance(obj, type) 
  must be true. If the second argument is a type, issubclass(type2, type) must be 
  true. super() only works for new-style classes.
  A typical use for calling a cooperative superclass method is:
   class C(B):
       def meth(self, arg):
           super(C, self).meth(arg)
  New in version 2.2.

    當子類須要使用父類中的某個方法時：

class A(object):    # A must be new-style class
  def __init__(self):
   print "enter A"
   print "leave A"

class B(A):     
  def __init__(self):
   print "enter B"
   # 調用父類 A 中的 __init__() 方法
   super(B, self).__init__()
   print "leave B"

 

習題代碼上傳至 github