一.反射（自省）

首先通過一個例子來看一下本文中可能用到的對象和相關概念。

import sys # 模塊，sys指向這個模塊對象
import inspect
def foo(): pass # 函數，foo指向這個函數對象

class Cat(object): # 類，Cat指向這個類對象
def __init__(self, name='kitty'):
self.name = name
def sayHi(self): # 實例方法，sayHi指向這個方法對象，使用類或實例.sayHi訪問
print(self.name), 'says Hi!' # 訪問名為name的字段，使用實例.name訪問

cat = Cat()#cat 是Cat類的實例對象
print(Cat.sayHi) # 使用類名訪問實例方法時，方法是未綁定的(unbound)
>>> <function Cat.sayHi at 0x101478378>
print(cat.sayHi) # 使用實例訪問實例方法時，方法是綁定的(bound)
>>> <bound method Cat.sayHi of <__main__.Cat object at 0x101178e48>>

?有時候我們會碰到這樣的需求，需要執行對象的某個方法，或是需要對對象的某個字段賦值，而方法名或是字段名在編碼代碼時并不能確定，需要通過參數傳遞字符串的形式輸入。舉個具體的例子：當我們需要實現一個通用的DBM框架時，可能需要對數據對象的字段賦值，但我們無法預知用到這個框架的數據對象都有些什么字段，換言之，我們在寫框架的時候需要通過某種機制訪問未知的屬性。

這個機制被稱為反射（反過來讓對象告訴我們他是什么），或是自省（讓對象自己告訴我們他是什么，好吧我承認括號里是我瞎掰的- -#），用于實現在運行時獲取未知對象的信息。反射是個很嚇唬人的名詞，聽起來高深莫測，在一般的編程語言里反射相對其他概念來說稍顯復雜，一般來說都是作為高級主題來講；但在Python中反射非常簡單，用起來幾乎感覺不到與其他的代碼有區別，使用反射獲取到的函數和方法可以像平常一樣加上括號直接調用，獲取到類后可以直接構造實例；不過獲取到的字段不能直接賦值，因為拿到的其實是另一個指向同一個地方的引用，賦值只能改變當前的這個引用而已。

1. 訪問對象的屬性

以下列出了幾個內建方法，可以用來檢查或是訪問對象的屬性。這些方法可以用于任意對象而不僅僅是例子中的Cat實例對象；Python中一切都是對象。

def foo(): pass # 函數，foo指向這個函數對象class Cat(object): # 類，Cat指向這個類對象def __init__(self, name='kitty'):self.name = namedef sayHi(self): # 實例方法，sayHi指向這個方法對象，使用類或實例.sayHi訪問print(self.name), 'says Hi!' # 訪問名為name的字段，使用實例.name訪問 cat = Cat('kitty')print(cat.name) # 訪問實例屬性 >>>kitty cat.sayHi() # 調用實例方法 >>>kitty print(dir(cat)) # 獲取實例的屬性名，以列表形式返回 >>>['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'sayHi'] if hasattr(cat, 'name'): # 檢查實例是否有這個屬性setattr(cat, 'name', 'tiger') # same as: a.name = 'tiger' print(getattr(cat, 'name')) # same as: print a.name >>>tiger getattr(cat, 'sayHi')() # same as: cat.sayHi() >>>tiger

• ?dir([obj]):?

　　調用這個方法將返回包含obj大多數屬性名的列表（會有一些特殊的屬性不包含在內）。obj的默認值是當前的模塊對象。?

• hasattr(obj, attr):?

　　這個方法用于檢查obj是否有一個名為attr的值的屬性，返回一個布爾值。?

• getattr(obj, attr):?

　　調用這個方法將返回obj中名為attr值的屬性的值，例如如果attr為'bar'，則返回obj.bar。?

• setattr(obj, attr, val):?

　　調用這個方法將給obj的名為attr的值的屬性賦值為val。例如如果attr為'bar'，則相當于obj.bar = val。

例子：

自定義模塊commons.py如下

#!/usr/bin/env python # -*- coding:utf-8 -*- # Author: Jason Wangdef login():print('登錄界面')def logout():print('注銷界面')def home():print('home界面')

?在另外一個index腳本中導入commons模塊，具體如下所示

import commonsdef run():inp = input('輸入你要執行的函數名')#inp 字符串類型 eg. inp = 'login'# delattr()# setattr() #利用字符串對模塊進行操作（增加，刪除，修改，查詢）if hasattr(commons,inp):#判斷commons是否存在inp函數，如果存在獲取此函數，否則404func = getattr(commons,inp)#獲取commons下的inp對應的函數func()#執行對應的函數else:print('404')

通過__import__字符串方式導入函數，需要輸入模塊名和此模塊下的函數名

def run():inp = input('account/function')m,f = inp.split('/')obj = __import__(m)#導入包及if hasattr(obj,f):func = getattr(obj,f)func()else:print('404') if __name__ == '__main__':run()

?

?*模塊內置參數補充說明*

• __doc__: 文檔字符串。如果模塊沒有文檔，這個值是None。
• *__name__: 始終是定義時的模塊名；即使你使用import .. as 為它取了別名，或是賦值給了另一個變量名。
• *__dict__: 包含了模塊里可用的屬性名-屬性的字典；也就是可以使用模塊名.屬性名訪問的對象
• __file__: 包含了該模塊的文件路徑。需要注意的是內建的模塊沒有這個屬性，訪問它會拋出異常！

commons.py

#!/usr/bin/env python # -*- coding:utf-8 -*- # Author: Jason Wang
# commons.py """ document for fanshe """ def login():print('登錄界面')def logout():print('注銷界面')def home():print('home界面')
##運行結果 print(__name__) >>>__main__

index腳本導入commons?

#!/usr/bin/env python # -*- coding:utf-8 -*- # Author: Jason Wang import commons as com print(com.__doc__)#commons的說明文檔
>>>document for fanshe
print(com.__name__)# commons腳本名
>>>commons
print(com.__file__) >>>/Users/JasonWang/PycharmProjects/sd13/day6/commons.py #print(com.__dict__.items())

?二.hashlib模塊　　

用于加密相關的操作，3.x里代替了md5模塊和sha模塊，主要提供?SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlibm = hashlib.md5() m.update(b"Hello") m.update(b"It's me") print(m.digest()) m.update(b"It's been a long time since last time we ...")print(m.digest()) #2進制格式hash print(len(m.hexdigest())) #16進制格式hash ''' def digest(self, *args, **kwargs): # real signature unknown""" Return the digest value as a string of binary data. """passdef hexdigest(self, *args, **kwargs): # real signature unknown""" Return the digest value as a string of hexadecimal digits. """pass''' import hashlib# ######## md5 ########hash = hashlib.md5() hash.update('admin') print(hash.hexdigest())# ######## sha1 ########hash = hashlib.sha1() hash.update('admin') print(hash.hexdigest())# ######## sha256 ########hash = hashlib.sha256() hash.update('admin') print(hash.hexdigest())# ######## sha384 ########hash = hashlib.sha384() hash.update('admin') print(hash.hexdigest())# ######## sha512 ########hash = hashlib.sha512() hash.update('admin') print(hash.hexdigest())

?還不夠吊？python 還有一個 hmac 模塊，它內部對我們創建 key 和 內容 再進行處理然后再加密

import hmac h = hmac.new('Jason') h.update('hellowo') print h.hexdigest()

?更多關于md5,sha1,sha256等介紹的文章看這里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html?

三.正則表達式

字符串是編程時涉及到的最多的一種數據結構，對字符串進行操作的需求幾乎無處不在。比如判斷一個字符串是否是合法的Email地址，雖然可以編程提取@前后的子串，再分別判斷是否是單詞和域名，但這樣做不但麻煩，而且代碼難以復用。 正則表達式是一種用來匹配字符串的強有力的武器。它的設計思想是用一種描述性的語言來給字符串定義一個規則，凡是符合規則的字符串，我們就認為它“匹配”了，否則，該字符串就是不合法的。 下面這張圖展示了使用正則表達式匹配的流程

1、Python支持的正則表達式元字符和語法

語法	說明	表達式實例	完整匹配的字符串
字符
一般字符	匹配自己	abc	abc
.	匹配任意字符“\n”除外 DOTALL模式中（re.DOTALL）也能匹配換行符	a.b	abc或abc或a1c等
[...]	字符集[abc]表示a或b或c，也可以-表示一個范圍如[a-d]表示a或b或c或d	a[bc]c	abc或adc
[^...]	非字符集，也就是非[]里的之外的字符	a[^bc]c	adc或aec等
預定義字符集（也可以系在字符集[...]中）
\d	數字：[0-9]	a\dc	a1c等
\D	非數字：[^0-9]或[^\d]	a\Dc	abc等
\s	空白字符：[<空格>\t\n\f\v]	a\sc	a b等
\S	非空白字符：[^s]	a\Sc	abc等
\w	字母數字（單詞字符）[a-zA-Z0-9]	a\wc	abc或a1c等
\W	非字母數字（非單詞字符）[^\w]	a\Wc	a.c或a_c等
數量詞（用在字符或(...)分組之后）
*	匹配0個或多個前面的表達式。（注意包括0次）	abc*	ab或abcc等
+	匹配1個或多個前面的表達式。	abc+	abc或abcc等
?	匹配0個或1個前面的表達式。（注意包括0次）	abc?	ab或abc
{m}	匹配m個前面表達式（非貪婪）	abc{2}	abcc
{m,}	匹配至少m個前面表達式（m至無限次）	abc{2,}	abcc或abccc等
{m,n}	匹配m至n個前面的表達式	abc{1,2}	abc或abcc
邊界匹配（不消耗待匹配字符中的字符）
^	匹配字符串開頭，在多行模式中匹配每一行的開頭	^abc	abc或abcd等
$	匹配字符串結尾，在多行模式中匹配每一行的結尾	abc$	abc或123abc等
\A	僅匹配字符串開頭	\Aabc	abc或abcd等
\Z	僅匹配字符串結尾	abc\Z	abc或123abc等
\b	匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。	?	?
\B	匹配非單詞邊界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。	?	?
邏輯、分組
|	或左右表達式任意一個（短路）如果|沒有在()中表示整個正則表達式（注意有括號和沒括號的區別）	abc|def ab(c|d)ef	abc或def abcef或abdef
(...)	分組，可以用來引用，也可以括號內的被當做一組進行數量匹配后接數量詞	(abc){2}a	abcabca
(?P<name>...)	分組別名，給分組起個名字，方便后面調用	?	?
\<number>	引用編號為<number>的分組匹配到的字符串（注意是配到的字符串不是分組表達式本身）	(\d)abc\1	1ab1或5ab5等
(?=name)	引用別名為name的分組匹配到的字符串（注意是配到的字符串不是分組表達式本身）	(?P<id>\d)abc(?P=id)	1ab1或5ab5等
?	?	?	?

正則表達式通常用于在文本中查找匹配的字符串。Python里數量詞默認是貪婪的（在少數語言里也可能是默認非貪婪），總是嘗試匹配盡可能多的字符；非貪婪的則相反，總是嘗試匹配盡可能少的字符。例如：正則表達式"ab*"如果用于查找"abbbc"，將找到"abbb"。而如果使用非貪婪的數量詞"ab*?"，將找到"a"。

一簡介：
就其本質而言，正則表達式（或 RE）是一種小型的、高度專業化的編程語言，
（在Python中）它內嵌在Python中，并通過 re 模塊實現。正則表達式模式被
編譯成一系列的字節碼，然后由用 C 編寫的匹配引擎執行。

二
字符匹配（普通字符，元字符）：
普通字符：大多數字符和字母都會和自身匹配
>>> re.findall('alex','yuanaleSxalexwupeiqi')
['alex']

2元字符：. ^ $ * + ? { } [ ] | ( ) \

?

我們首先考察的元字符是"[" 和 "]"。它們常用來指定一個字符類別，所謂字符類
別就是你想匹配的一個字符集。字符可以單個列出，也可以用“-”號分隔的兩個給定
字符來表示一個字符區間。例如，[abc] 將匹配"a", "b", 或 "c"中的任意一個字
符；也可以用區間[a-c]來表示同一字符集，和前者效果一致。如果你只想匹配小寫
字母，那么 RE 應寫成 [a-z].
元字符在類別里并不起作用。例如，[akm$]將匹配字符"a", "k", "m", 或 "$" 中
的任意一個；"$"通常用作元字符，但在字符類別里，其特性被除去，恢復成普通字
符。

():
#!python
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

[]:元字符[]表示字符類，在一個字符類中，只有字符^、-、]和\有特殊含義。
字符\仍然表示轉義，字符-可以定義字符范圍，字符^放在前面，表示非.

+ 匹配+號前內容1次至無限次
? 匹配?號前內容0次到1次
{m} 匹配前面的內容m次
{m,n} 匹配前面的內容m到n次
*?,+?,??,{m,n}? 前面的*,+,?等都是貪婪匹配，也就是盡可能匹配，后面加?號使其變成惰性匹配

從前面的描述可以看到'*'，'+'和'*'都是貪婪的，但這也許并不是我們說要的，
所以，可以在后面加個問號，將策略改為非貪婪，只匹配盡量少的RE。示例，
體會兩者的區別：
>>> re.findall(r"a(\d+?)","a23b") # 非貪婪模式
['2']
>>> re.findall(r"a(\d+)","a23b")
['23']

>>> re.search('<(.*)>', '<H1>title</H1>').group()
'<H1>title</H1>'
re.search('<(.*?)>', '<H1>title</H1>').group()
'<H1>'

?

注意比較這種情況：
>>> re.findall(r"a(\d+)b","a23b")
['23']
>>> re.findall(r"a(\d+?)b","a23b") #如果前后均有限定條件，則非匹配模式失效
['23']


\:
反斜杠后邊跟元字符去除特殊功能，
反斜杠后邊跟普通字符實現特殊功能。
引用序號對應的字組所匹配的字符串
re.search(r"(alex)(eric)com\2","alexericcomeric")

\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_]
\b: 匹配一個單詞邊界，也就是指單詞和空格間的位置。
匹配單詞邊界（包括開始和結束），這里的“單詞”，是指連續的字母、數字和
下劃線組成的字符串。注意，\b的定義是\w和\W的交界，
這是個零寬界定符（zero-width assertions）只用以匹配單詞的詞首和詞尾。
單詞被定義為一個字母數字序列，因此詞尾就是用空白符或非字母數字符來標
示的。
>>> re.findall(r"abc\b","dzx &abc sdsadasabcasdsadasdabcasdsa")
['abc']
>>> re.findall(r"\babc\b","dzx &abc sdsadasabcasdsadasdabcasdsa")
['abc']
>>> re.findall(r"\babc\b","dzx sabc sdsadasabcasdsadasdabcasdsa")
[]

例如， 'er/b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\b只是匹配字符串開頭結尾及空格回車等的位置, 不會匹配空格符本身
例如"abc sdsadasabcasdsadasdabcasdsa",
\sabc\s不能匹配,\babc\b可以匹配到"abc"
>>> re.findall("\babc\b","abc sdsadasabcasdsadasdabcasdsa")
[]
>>> re.findall(r"\babc\b","abc sdsadasabcasdsadasdabcasdsa")
['abc']
\b 就是用在你匹配整個單詞的時候。 如果不是整個單詞就不匹配。 你想匹
配 I 的話，你知道，很多單詞里都有I的，但我只想匹配I，就是“我”，這個時
候用 \bI\b
************************************************
函數：

1
match：re.match(pattern, string, flags=0)
flags 編譯標志位，用于修改正則表達式的匹配方式，如：是否區分大小寫，
多行匹配等等。
re.match('com', 'comwww.runcomoob').group()

re.match('com', 'Comwww.runComoob',re.I).group()

2
search：re.search(pattern, string, flags=0)
re.search('\dcom', 'www.4comrunoob.5com').group()

注意：
re.match('com', 'comwww.runcomoob')
re.search('\dcom', 'www.4comrunoob.5com')
一旦匹配成功，就是一個match object 對象，而match object 對象擁有以下方法：
group() 返回被 RE 匹配的字符串
start() 返回匹配開始的位置
end() 返回匹配結束的位置
span() 返回一個元組包含匹配 (開始,結束) 的位置
group() 返回re整體匹配的字符串，可以一次輸入多個組號，對應組號匹配的字符串。
1. group（）返回re整體匹配的字符串，
2. group (n,m) 返回組號為n，m所匹配的字符串，如果組號不存在，則返回indexError異常
3.groups（）groups() 方法返回一個包含正則表達式中所有小組字符串的元組，從 1 到
所含的小組號，通常groups（）不需要參數，返回一個元組，元組中的元就是正則
表達式中定義的組。
import re
a = "123abc456"
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0) #123abc456,返回整體
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1) #123
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2) #abc
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3) #456

group(1) 列出第一個括號匹配部分，group(2) 列出第二個括號匹配部分，group(3)
列出第三個括號匹配部分。

-----------------------------------------------
3
findall：
re.findall 以列表形式返回所有匹配的字符串
　　re.findall可以獲取字符串中所有匹配的字符串。如：

p = re.compile(r'\d+')
print p.findall('one1two2three3four4')

re.findall(r'\w*oo\w*', text)；獲取字符串中，包含'oo'的所有單詞。

import re
text = "JGood is a handsome boy,he is handsome and cool,clever,and so on ...."
print re.findall(r'\w*oo\w*',text) #結果：['JGood', 'cool']
#print re.findall(r'(\w)*oo(\w)*',text) # ()表示子表達式 結果：[('G', 'd'), ('c', 'l')]

finditer():

>>> p = re.compile(r'\d+')
>>> iterator = p.finditer('12 drumm44ers drumming, 11 ... 10 ...')
>>> for match in iterator:
match.group() , match.span()

4
sub subn：

re.sub(pattern, repl, string, max=0)
re.sub("g.t","have",'I get A, I got B ,I gut C')

5
split：
p = re.compile(r'\d+')
p.split('one1two2three3four4')

re.split('\d+','one1two2three3four4')

6
re.compile(strPattern[, flag]):
這個方法是Pattern類的工廠方法，用于將字符串形式的正則表達式編譯為
Pattern對象。 第二個參數flag是匹配模式，取值可以使用按位或運算符'|'
表示同時生效，比如re.I | re.M
　　可以把正則表達式編譯成一個正則表達式對象。可以把那些經常使用的正則
表達式編譯成正則表達式對象，這樣可以提高一定的效率。下面是一個正則表達式
對象的一個例子：

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
regex = re.compile(r'\w*oo\w*')
print regex.findall(text) #查找所有包含'oo'的單詞

question：

1 findall能不能返回全組匹配的列表，而不是優先捕獲組的列表：yes,
import re

a = 'abc123abv23456'
b = re.findall(r'23(a)?',a)
print b
b = re.findall(r'23(?:a)?',a)
print b

>>> re.findall("www.(baidu|xinlang)\.com","www.baidu.com")
['baidu']
>>> re.findall("www.(?:baidu|xinlang)\.com","www.baidu.com")
['www.baidu.com']
>>> re.findall("www.(?:baidu|xinlang)\.com","www.xinlang.com")
['www.xinlang.com']

findall如果使用了分組，則輸出的內容將是分組中的內容而非find到的結果，
為了得到find到的結果，要加上問號來啟用“不捕捉模式”，就可以了。

2 re.findall('\d*', 'www33333')

3 re.split("[bc]","abcde")

4 source = "1 - 2 * ( (60-30 +(-9-2-5-2*3-5/3-40*4/2-3/5+6*3) * (-9-2-5-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )"

re.search('\([^()]*\)', source).group()regular='\d+\.?\d*([*/]|\*\*)[\-]?\d+\.?\d*'
re.search('\d+\.?\d*([*/]|\*\*)[\-]?\d+\.?\d*', string).group()

add_regular='[\-]?\d+\.?\d*\+[\-]?\d+\.?\d*'
sub_regular='[\-]?\d+\.?\d*\-[\-]?\d+\.?\d*'
re.findall(sub_regular, "(3+4-5+7+9)")

4 檢測一個IP地址：
re.search(r"(([01]?\d?\d|2[0-4]\d|25[0-5])\.){3}([01]?\d?\d|2[0-4]\d|25[0-5]\.)","192.168.1.1")

?

?

-----------------------------------------------------------

re.I 使匹配對大小寫不敏感
re.L 做本地化識別（locale-aware）匹配
re.M 多行匹配，影響 ^ 和 $
re.S 使 . 匹配包括換行在內的所有字符
>>> re.findall(".","abc\nde")
>>> re.findall(".","abc\nde",re.S)
re.U 根據Unicode字符集解析字符。這個標志影響 \w, \W, \b, \B.
re.X 該標志通過給予你更靈活的格式以便你將正則表達式寫得更易于理解。

re.S：.將會匹配換行符，默認.逗號不會匹配換行符
>>> re.findall(r"a(\d+)b.+a(\d+)b","a23b\na34b")
[]
>>> re.findall(r"a(\d+)b.+a(\d+)b","a23b\na34b",re.S)
[('23','34')]
>>>
re.M：^$標志將會匹配每一行，默認^只會匹配符合正則的第一行；默認$只會匹配符合正則的末行
>>> re.findall(r"^a(\d+)b","a23b\na34b")
['23']
>>> re.findall(r"^a(\d+)b","a23b\na34b",re.M)
['23','34']
但是，如果沒有^標志，
>>> re.findall(r"a(\d+)b","a23b\na34b")
['23','43']
可見，是無需re.M

import re

n='''12 drummers drumming,
11 pipers piping, 10 lords a-leaping'''

p=re.compile('^\d+')
p_multi=re.compile('^\d+',re.MULTILINE) #設置 MULTILINE 標志
print re.findall(p,n) #['12']
print re.findall(p_multi,n) # ['12', '11']
============================
import re
a = 'a23b'
print re.findall('a(\d+?)',a) #['2']
print re.findall('a(\d+)',a) #['23']
print re.findall(r'a(\d+)b',a) #['23']
print re.findall(r'a(\d+?)b',a) # ['23']
============================
b='a23b\na34b'
''' . 匹配非換行符的任意一個字符'''

re.findall(r'a(\d+)b.+a(\d+)b',b) #[]

re.findall(r'a(\d+)b',b,re.M) # ['23', '34']

re.findall(r'^a(\d+)b',b,re.M) # ['23', '34']

re.findall(r'a(\d+)b',b) #['23','34'] 可以匹配多行

re.findall(r'^a(\d+)b',b) # ['23'] 默認^只會匹配符合正則的第一行

re.findall(r'a(\d+)b$',b) # ['34'] 默認$只會匹配符合正則的末行

re.findall(r'a(\d+)b',b,re.M) #['23', '34']

re.findall(r'a(\d+)b.?',b,re.M) # ['23', '34']

re.findall(r"a(\d+)b", "a23b\na34b") # ['23', '34']
---------------------------------------------------------------

推薦：http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html

?

*****關于rawstring以及\:

\n是換行，ASCLL碼是10
\r是回車，ASCLL碼是13

re.findall("\","abc\de")

f=open("C:\abc.txt")
\a是 轉義字符 007，響鈴符 BEL。
f=open(r"D:\abc.txt")
>>>>>>python自己也需要轉義，也是通過\轉義

>>> re.findall(r"\d","ww2ee")
['2']
>>> re.findall("\d","ww2ee")
['2']

>>強烈建議用raw字符串來表述正則

?

你可能已經看到前面關于原始字符串用法的一些例子了。原始字符串的產生正是由于有正則表
達式的存在。原因是ASCII 字符和正則表達式特殊字符間所產生的沖突。比如，特殊符號“\b”在
ASCII 字符中代表退格鍵，但同時“\b”也是一個正則表達式的特殊符號，代表“匹配一個單詞邊界”。
為了讓RE 編譯器把兩個字符“\b”當成你想要表達的字符串，而不是一個退格鍵，你需要用另一個
反斜線對它進行轉義，即可以這樣寫：“\\b”。
但這樣做會把問題復雜化，特別是當你的正則表達式字符串里有很多特殊字符時，就更容
易令人困惑了。原始字符串就是被用于簡化正則表達式的復雜程度。
事實上，很多Python 程序員在定義正則表達式時都只使用原始字符串。
下面的例子用來說明退格鍵“\b” 和正則表達式“\b”(包含或不包含原始字符串)之間的區別：
>>> m = re.search('\bblow', 'blow') # backspace, no match #退格鍵,沒有匹配

>>> re.search('\\bblow', 'I blow').group() # escaped \, now it works #用\轉義后，現在匹
配了

>>> re.search(r'\bblow', 'I blow').group() # use raw string instead #改用原始字符串

你可能注意到我們在正則表達式里使用“\d”，沒用原始字符串，也沒出現什么問題。那是因為
ASCII 里沒有對應的特殊字符，所以正則表達式編譯器能夠知道你指的是一個十進制數字

######################

re模塊的常用方法

?re.compile(strPattern[, flag])

參數： strPattern：正則表達式 flag：匹配模式，可選值有 re.I(re.IGNORECASE): 忽略大小寫（括號內是完整寫法，下同） M(MULTILINE): 多行模式，改變'^'和'$'的行為（參見上圖） S(DOTALL): 點任意匹配模式，改變'.'的行為 L(LOCALE): 使預定字符類 \w \W \b \B \s \S 取決于當前區域設定 U(UNICODE): 使預定字符類 \w \W \b \B \s \S \d \D 取決于unicode定義的字符屬性 X(VERBOSE): 詳細模式。這個模式下正則表達式可以是多行，忽略空白字符，并可以加入注釋。 返回值：Pattern對象是一個編譯好的正則表達式，通過Pattern提供的一系列方法可以對文本進行匹配查找 以下的方法既可以是Pattern對象的實例方法也可以是re模塊的方法，語法稍有不同

match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])

這個方法將從string的pos下標處起嘗試匹配pattern；如果pattern結束時仍可匹配，則返回一個Match對象；如果匹配過程中pattern無法匹配，或者匹配未結束就已到達endpos，則返回None。? pos和endpos的默認值分別為0和len(string)；re.match()無法指定這兩個參數，參數flags用于編譯pattern時指定匹配模式。? 注意：這個方法并不是完全匹配。當pattern結束時若string還有剩余字符，仍然視為成功。想要完全匹配，可以在表達式末尾加上邊界匹配符'$'。? 參數： string：要匹配的字符串 pos：匹配的開始下標 endpos：匹配的結束下標 pattern：正則表達式 flags：匹配模式 返回值：如果匹配成功返回match對象，否則返回None

search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])

這個方法用于查找字符串中可以匹配成功的子串。從string的pos下標處起嘗試匹配pattern，如果pattern結束時仍可匹配，則返回一個Match對象；若無法匹配，則將pos加1后重新嘗試匹配；直到pos=endpos時仍無法匹配則返回None。? pos和endpos的默認值分別為0和len(string))；re.search()無法指定這兩個參數，參數flags用于編譯pattern時指定匹配模式。? 參數：同match 返回值：同match 我們通過一個實例來看一下兩個方法的區別 >>> import re >>> s = 'hello world' >>> print(re.match('ello', s)) None >>> print(re.search('ello',s )) <_sre.SRE_Match object; span=(1, 5), match='ello'>說明：可以看到macth只匹配開頭，開頭不匹配，就不算匹配到，search則可以從中間，只要能有匹配到就算匹配 findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])搜索string，以列表形式返回全部能匹配的子串。有點像search的擴展，把所有匹配的子串放到一個列表參數：同match返回值：所有匹配的子串，沒有匹配則返回空列表 >>> import re >>> s = 'one1two2three3four4' >>> re.findall('\d+', s) ['1', '2', '3', '4']

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):

按照匹配字子串將字符串進行分割，返回分割收的列表 參數： string：要分割的字符串 pattern：正則表達式 maxsplit：最大分割次數 返回值：分割后的列表 實例 >>> import re >>> s = 'one1two2three3four4' >>> re.split('\d+',s) ['one', 'two', 'three', 'four', '']

sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])

使用repl替換string中匹配的每一子串 參數： repl：替換的字符串或方法，這里需要說一下這個方法，方法接收macth對象，方法的返回值作為替換的字符串，換句話就是經過處理的字符串。 string：要進行替換的字符串 pattern：正則表達式 count：替換的次數 實例：對于repl是個方法的情況，正好這次作業用到，用來替換多個則很難過福號的情況。假設我們有一個四則運算表達式 '--(1.1+1+1-(-1)-(1+1+(1+1+2.2)))+-----111+--++--3-+++++++---+---1+4+4/2+(1+3)*4.1+(2-1.1)*2/2*3'，遵循奇數個負號等于正否則為負的原則進行替換，我們可以這樣 if __name__ == '__main__':import res = '--(1.1+1+1-(-1)-(1+1+(1+1+2.2)))+-----111+--++--3-+++++++---+---1+4+4/2+(1+3)*4.1+(2-1.1)*2/2*3'def replace_sign(expression):'''替換多個連續+-符號的問題，例如+-----，遵循奇數個負號等于正否則為負的原則進行替換:param expression: 表達式，包括有括號的情況:return: 返回經過處理的表達式'''def re_sign(m):if m:if m.group().count('-')%2 == 1:return '-'else:return '+'else:return ''expression = re.sub('[\+\-]{2,}', re_sign, expression)return expressions = replace_sign(s)print(s)

執行結果

24 +(1.1+1+1-(-1)-(1+1+(1+1+2.2)))-111+3-1+4+4/2+(1+3)*4.1+(2-1.1)*2/2*3

?

四.冒泡

它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。

? li = [1,2,33,55,2,77,6,88,9,25] l = len(li) 冒泡排序 print(l) for i in range(len(li)):# print(li[i])for j in range(l):if li[i] > li[j]:tmp = li[i]li[i] = li[j]li[j] = tmp print(li) #[88, 77, 55, 33, 25, 9, 6, 2, 1]

?

#選擇排序 # #index # max_index = 0 # for j in range(len(li)): # for i in range(len(li)-j): # # print(i,li[i]) # # for j in range(l): # if li[i] > li[max_index]: # max_index = i # print(max_index) # # print(l-i) # # tmp = li[len(li)-j-1] # li[len(li)-j-1] = li[max_index] # li[max_index] = tmp # print(li[len(li)-1]) # print(max_index) # print(li)

?

?

轉載于:https://www.cnblogs.com/jasonwang-2016/p/5591139.html

總結

以上是生活随笔為你收集整理的反射,hashlib模块,正则匹配,冒泡，选择，插入排序的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。