Python學習筆記整理(四)Python中的字串..

標籤：

字串是一個有序的字元集合，用於儲存和表現基於文本的資訊。
常見的字串常量和運算式
T1=‘’ Null 字元串
T2="diege‘s" 雙引號
T3="""...""" 三重引號塊
T4=r‘\temp\diege‘ Raw字串 抑制（取消）轉義，完全列印\tmp\diege，而沒有定位字元
T5=u’diege‘ Unicode字串
T1+T2     合并
T1*3    重複
T2[i]    索引
T2[i:j] 分區
len(T2)  求長
"a %s parrot "% type 字串格式化
T2.find(‘ie‘) 字串方法調用：搜尋
T2.rstrip() 字串方法調用：移除空格
T2.replace(‘ie‘,‘efk‘) 字串方法調用：替換
T2.split(‘,‘) 字串方法調用：分割
T2.isdigit() 字串方法調用：內容測試
T2.lower() 字串方法調用：大寫轉換為小寫
for x in T2:  迭代
‘ie‘ in T2 成員關係
一、字串常量
1、單雙引號字串是一樣
Python自動在任意運算式中合并相鄰的字串常量。儘管可以在他們之間增加+操作符來明確表示這是一個合併作業。
>>> T2="Test " ‘for ‘ "diege"
>>> T2
‘Test for diege‘
>>> T2="Test "+‘for ‘+"diege" 
>>> T2
‘Test for diege‘
不能在字串之間增加逗號來串連，這樣會建立一個元組而不是字串。python傾向於列印所有這些形式字串為單引號，除非字串內有了單引號。
不過也可以通過反斜線轉義嵌入引號
>>> T2="Test "+‘for ‘+"diege‘s"
>>> T2
"Test for diege‘s"
>>> ‘diege\‘s‘
"diege‘s"
2、用逸出序列代表特殊位元組
\newline     忽視（連續）
\\        反斜線（保留\)
\‘        單引號（保留‘)
\"        雙引號（保留”)
\n         換行
\f        換頁
\t         水平定位字元
\v         垂直定位字元
\b        倒退 前的字元沒有了
\a        響鈴
\r        返回 前面的字元沒有了
\N{id}        Unicode資料庫ID
\uhhhh        Unicode16位的十六進位值
\Uhhhh        Unicode32位的十六進位值
\xhh        十六進位值
\ooo        八進位值
\0        NULL (不是字串結尾）
\other        不轉義（保留）
3、字串抑制轉義
myfile=open(‘C:\new\text.data‘,‘w‘)
這個調用會嘗試開啟C:（換行）ew(定位字元)ext.data的檔案，而不是期待的結果。
解決辦法，使用raw字串。如果字母r(大寫或者小寫）出現在字串的第一個引號前面，它會關閉轉義機制。
myfile=open(r‘C:\new\text.data‘,‘w‘)‘
另外一個辦法就是把\轉義
myfile=open(‘C:\\new\\text.data‘,‘w‘)‘
4、三重引號編寫多行字串塊
塊字串，編寫多行文本資料便捷文法。
這個形式以三重引號開始（單雙引號都可以），並緊跟任意行的數的代碼，並且以開頭同樣的三重引號結尾。嵌入這個字串文本中的單引號雙引號也會但不是必須轉義。三重引號字串也常用在開發過程中作為一個種駭客風格的方法去廢除一些代碼。如果希望讓一些代碼不工作，之後再次運行代碼，可以簡單地在這幾行前，後加入三重引號
X=10
"""
import os
print os.getcwd()
"""
Y=19
5、字串編碼更大的字元集
Unicode字串有時稱為“寬”字串。因為每個字串也許在記憶體會佔用大於一個位元組的空間。
Unicode字串典型的應用於支援國際化的應用(i18)
通過在開頭的引號前增加字母u(大小寫都可以）編寫一個Unicode字串。
>>> T9=u‘diege‘  #這種文法產生了一個unicode字串對象。
>>> T9
u‘diege‘
>>> type(T9)
<type ‘unicode‘>
Python中允許運算式自由地混合Unicode字串和一般字串。並將混合類型的結果轉為Unicode。
Unicode字串也可以合并，索引，分區。通過re模組進行匹配，並且不能夠進行實地修改。和一般字串一樣。
python同等對待一般字串和Unicode字串
如果需要在一般字串和Unicode字串中轉換，可以使用內建的str和unicode函數
>>> str(u‘diege‘)
‘diege‘
>>> unicode(‘diege‘)
u‘diege‘
unicode是用來處理多位元組字元的，所以能夠使用特殊的"\u","\U"逸出字元串去編碼大於8bit的二進位值
u‘ab\x20cd‘
sys模組包含了預設Unicode編碼方案的擷取以及設定的調用（預設往往是ASCII）
可以混合raw和Unicode字串
二、實際應用的字串
1、基本操作
字串長度擷取方法: 內建函數len()
>>> len(‘test‘)
4
字串串連：+
>>> ‘test‘+‘diege‘
‘testdiege‘
python不允許+運算式混合字串和數字。
字串重複：*
>>> ‘test‘*3
‘testtesttest‘
用在分割提示
>>> print ‘-‘*80
迭代:使用for語句在一個字串中進行迭代
>>> for s in myname: print s
...
d
i
e
g
e
for 迴圈指派了一個變數去擷取一個序列其中的的元素，並對每一個元素執行一個或多個語句。
成員關係測試:使用in運算式操作符進行成員關係測試。
>>> ‘g‘ in myname
True
>>> ‘k‘ in myname
False
2、索引和分區
字串中的字元是通過索引（通過在字串之後的方括弧中提供所需的元素的數字位移量提取的）將獲得在特定位置的一個字元的字串。
Ptyhon位移量是從0開始的。支援負位移量。
索引
>>> T[0],T[-2]
(‘d‘, ‘g‘)
分區
T[開始：結束] 包含開始的位置，不包含結束的位置
>>> T[1:3],T[1:],T[:3],T[-1],T[0:-1]
(‘ie‘, ‘iege‘, ‘die‘, ‘e‘, ‘dieg‘)
>>> T[:] 
‘diege‘
簡單總結：
*索引（S[i])擷取特定位移的元素。
——第一個元素位移為0
——（S[0])擷取第一個元素。
——負位移索引意味著從最後或右邊反向進行計數
——（S[-2])擷取倒數第二個元素（就像S[len(s)-2]一樣
*分區[S[i:j]提取對應的部分作為一個序列
——右邊界不包含在內
——分區的邊界預設為0和序列的長度，如果沒有給出的話S[:]
——（S[1:3])擷取了從位移為1，直到但不包括位移為3的元素
——（S[1:])擷取從位移為1到末尾之間的元素
——（S[:3])擷取從位移為0直到但不包括位移為3的元素
——（S[:-1])擷取從位移為0直到但不包括最後一個元素之間的元素
——（S[:])擷取從位移為0到末尾之間的元素,這有效地實現了頂層S拷貝
拷貝了一個相同值，但是是不同記憶體地區的對象。對象字串這樣不可變的對象不是很有用，但是對於可以實地修改的對象來說很有用。
比如列表。
3、擴充分區：第三個限制值 步進
完整形式：X[I:J:K]:這標識索引X對象的元素，從位移為I直到J-1，每隔K元素索引一次。第三個限制值，K，預設為1
執行個體
>>> S=‘abcdefghijk‘
>>> S[1:10]
‘bcdefghij‘
>>> S[1:10:2]
‘bdfhj
也可以使用負數作為步進。
分區運算式
>>> "hello"[::-1]
‘olleh‘
通過負數不盡，兩個邊界的意義實際上進行了反轉。
import sys
print sys.argv
# python echo.py -a -b -c
[‘echo.py‘, ‘-a‘, ‘-b‘, ‘-c‘]
echo.py內容
import sys
print sys.argv[1:]
# python echo.py -a -b -c
[‘-a‘, ‘-b‘, ‘-c‘]
4、字串轉換工具
Pyhon的設計座右銘之一是拒絕猜測的誘惑
Python中不能夠讓數字和字串相加，甚至即時字串看起來像是數字也不可以。
>>> ‘55‘+1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate ‘str‘ and ‘int‘ objects
+可以加法運算也可以進行合併作業，這種會話選擇會模稜兩可。要避免這樣的文法。

解決指令檔和使用者介面得到一個作為字串出現的數字該這麼辦？
解決辦法 使用轉換工具預先處理，把字串當做數字，或者把數字當做字串。
數字轉換為字串的方法
>>> str(55)
‘55‘
>>> ‘55‘
‘55
>>> T=repr(55)
>>> type(T)
<type ‘str‘>
字串轉換為數字
>>> int(‘66‘)
66
>>> D=int(‘66‘)
>>> type(D)
<type ‘int‘>
這些操作為重新建立對象。
>>> S=‘55‘
>>> x=1
>>> int(S)+x
56
類似的內建函數可以把浮點數轉換為字串，或者把字串轉換為浮點數
>>> str(3.1415),float("1.5")
(‘3.1415‘, 1.5)
>>> text=‘1.234E-10‘
>>> float(text)
1.234e-10
內建eval函數，它將會運行一個包含了python運算式代碼的字串，並能夠將一個字串轉換為任意類型對象。
函數int和float只能對數字進行轉換。
**字串代碼轉換**
同樣是轉換，單個的字元也可以通過將其傳給內建的ord函數轉換為其對應的ASCII碼--這個函數實際上返回的是這個字元在記憶體中對應字元的二進位。
內建chr函數則將二進位轉為字元。
>>> ord(‘t‘)     
116
>>> chr(116)
‘t‘
5、修改字串
不可變序列，不能實地修改一個字串（如給一個索引進行賦值）
如果需要改變一個字串，需要利用合并，分區等工具來建立並賦值給一個新的字串，倘若必要的話，之後將這個結果賦值給字串最初的變數名。
>>> S=‘diege‘
>>> S=‘My name is‘+ S  
>>> S
‘My name isdiege‘
這樣的修改原來的對象沒有改變，只是建立了新的字串對象，用原來的變數名串連到新的對象而已。
>>> T=‘diege‘
>>> S=T[:3] + ‘bad‘+T[:-1]
>>> S
‘diebaddieg’
每一次修改字串就是生產一個新的字串對象。

三、字串格式化
格式化字串的方法：
1)、在%操作符的左側放置一個需要進行格式化的【字串】，這個字串帶有一個或者多個嵌入的轉換目標，都以%開頭（如%d)
2)、在%操作符右側放置一個對象（或多個，在括弧內），這些對象將會插入到左側想讓Python進行格式化字串的（或多個）轉換目標的位置上去。
>>> name=‘diege‘
>>> "My name is:%s" % name
‘My name is:diege‘
>>> name=‘diege‘         
>>> age=18
>>> "My name is:%s my age is %d" % (name,age)
‘My name is:diege my age is 18‘
>>> "%d %s %d you" % (1,‘diege‘,4)
‘1 diege 4 you
>>> "%s--%s--%s" % (42,3.1415,[1,2,4])
‘42--3.1415--[1, 2, 4]
這個例子插入三個值，一個整數，一個浮點數，一個表對象，但是注意到所有的左側目標都是%s,這就表示要把他們轉換為字串。由於任何對象都可以轉換為字串（列印時所使用的），每一個與%s一同參與操作的物件類型都可以轉碼。正因如此，除非你要做特殊的格式化，一般你只需要記得用%s這個代碼來格式化運算式。
格式化總會是返回新的字串作為結果而不是對左側的字串進行修改。由於字串是不可變的，所以只能這樣操作。如果需要，可以分配一個變數名來儲存結果。
1、更進階的字串格式化
Python字串格式化支援C語言中所有常規的printf格式的代碼（但是並不像printf那樣顯示結果，而是返回結果）。表中的一些格式化代碼為同一類型的格式化提供了不同的選擇。
代碼    意義
%s    字串（或任何對象）
%r    s,但是用repr，而不是str
%c    字元
%d    十進位(整數)
%i    整數
%u    無號（整數)
%o    八進位整數
%x    十六進位整數
%X    x,但列印大寫
%e    浮點指數
%E    浮點，但列印大寫
%f    浮點十進位
%g    浮點e或f
%G    浮點E或f
%%    常量%
運算式左側的轉換目標支援多種轉換操作。這些操作自有一套相當嚴謹的文法。轉換目標的通用結構看上去是這樣的：
$[(name)][flags][width][.precision]code

引用字典的索引鍵，填充的標誌，寬度
負號 靠左對齊
正號 靠右對齊

>>> x=1234
>>> res="test:...%d...%-6d...%06d" % (x,x,x)
>>> res
‘test:...1234...1234  ...001234‘
 res="test:...%d...%6d...%-06d" % (x,x,x)
%6d 靠右對齊 寬度6 不夠空格補全
%-06d 靠左對齊 寬度6 不夠0補全

2、基於字典的字串格式化
字串的格式化同時也允許左邊的轉換目標來引用右邊字典中的鍵來提取對應的值。
>>> "%(n)d %(x)s" % {"n":1,"x":‘diege‘}
‘1 diege‘
(n) (x) 引用了右邊字典中的鍵，並提取他們相應的值。產生類似HTML或者XML的程式往往利用這一技術。
>>> reply="""
... Greetings.
... Hello %(name)s!
... Your age is %(age)s
... """
>>> values={‘name‘:‘diege‘,‘age‘:18}
>>> print reply % values

Greetings.
Hello diege!
Your age is 18
這樣的小技巧也常與內建函數vars聯起來一同使用，這個函數返回的字典包含了所有在本函數調用時存在的變數。
>>> name=‘diege‘
>>> age=‘18‘
>>> vars()
{‘S‘: ‘diebaddieg‘, ‘res‘: ‘test:...1234...  1234...  1234‘, ‘D‘: 66, ‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘text‘: ‘1.234E-10‘, ‘age‘: ‘18‘,

‘myname‘: ‘diege‘, ‘__package__‘: None, ‘s‘: ‘e‘, ‘values‘: {‘age‘: 18, ‘name‘: ‘diege‘}, ‘T‘: ‘diege‘, ‘x‘: 1234, ‘reply‘: ‘\nGreetings.\nHello %(name)s!\nYour

age is %(age)s\n‘, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘name‘: ‘diege‘}
>>> "My name is %(name)s age is %(age)s" % vars()            
‘My name is diege age is 18‘

四、字串方法
除運算式運算子外，字串還提供了一系列的方法去實現更複雜的文本處理任務。方法就是與特定的對象相關聯在一些的函數。從技術的角度講，他們附屬於對象的屬性，而這些屬性不過是些可調用函數罷了。在Python中，對不同的物件類型有不同的方法。字串方法僅限於字串對象。函數也就是程式碼封裝，方法調用同時進行了兩次操作（一次擷取屬性和一次函數調用）
屬性讀取
具有object.attribute格式的運算式可以理解為“讀取object對象的屬性attribute的值".
函數調用運算式
具有函數（參數）格式的運算式意味著”調用函數代碼，傳遞零或者更多逗號隔開的參數對象，最後返回函數的傳回值”。

將兩者合并可以讓我們調用一個對象方法。方法調用運算式對象，方法（參數）從左至右運行，也就是說Python首先讀取對象方法，然後調用它，傳遞參數。如果一個方法計算出一個結果，它將會作為整個方法調用運算式的結果被返回。

絕大多數對象都可調用的方法。而且所有對象都可以通過同樣的方法調用的文法來訪問。為了調用對象的方法，必須確保這個對象是存在的。

1、字串方法執行個體：修改字串
字串方法
>>> dir(S)
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘,

‘__getslice__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘,

‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘_formatter_field_name_split‘, ‘_formatter_parser‘,

‘capitalize‘, ‘center‘, ‘count‘, ‘decode‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘, ‘find‘, ‘format‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdigit‘, ‘islower‘, ‘isspace‘,

‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘partition‘, ‘replace‘, ‘rfind‘, ‘rindex‘, ‘rjust‘, ‘rpartition‘, ‘rsplit‘, ‘rstrip‘, ‘split‘,

‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]
可以通過help()函數查看方法如何使用
>>> help(S.isupper())
1)替換
替換第3,4個字元
>>> S=‘namediege‘     
>>> S=S[:3] +‘XX‘+S[5:]
>>> S
‘namXXiege‘
僅僅替換一個子字串的話，可以使用replace方法實現
>>> S=‘aabbccdd‘
>>> S=S.replace(‘bb‘,‘gg‘)
>>> S
‘aaggccdd‘
replace 第一個參數是原始字串（任意長度），第二個參數替換原始字串的字串（任意長度）
2）尋找
find方法返回在子字串出現處的位移（預設從前向後開始搜尋）或者未找到時返回-1.
3)打散 list()
list方法
>>> S=‘diege‘
>>> list(S)
[‘d‘, ‘i‘, ‘e‘, ‘g‘, ‘e‘]
會打散成一個列表
4）合成jion()方法
>>> S=‘diege‘
>>> list(S)
[‘d‘, ‘i‘, ‘e‘, ‘g‘, ‘e‘]
>>> T=list(S)
>>> T
[‘d‘, ‘i‘, ‘e‘, ‘g‘, ‘e‘]
>>> T[0]=‘P‘
>>> T[3]=‘G‘ 
>>> T
[‘P‘, ‘i‘, ‘e‘, ‘G‘, ‘e‘]
>>> S=‘‘.join(T)  #使用Null 字元串分割把字元列錶轉換為字串
>>> S
‘PieGe‘
>>> Y=‘|‘.join(T)
>>> Y
‘P|i|e|G|e‘ #使用|分割把字串列錶轉換為字串

>>> ‘X‘.join([‘eggs‘,‘toast‘,‘moa‘])
‘eggsXtoastXmo

2、字串方法執行個體：文本解析
1)使用分區做文本解析
>>> line="aaa bbb ccc"
>>> cols1=line[0:3]
>>> cols2=line[8:]
>>> cols1
‘aaa‘
>>> cols2
‘ccc。
在組資料出現在固定位移處，因此有可能通過分區從原始字串分出來。這一技術可以被認為是解析，只要所需的資料群組鍵有固定的位移。
2)split方法提取組件
當所需資料沒有固定的位移時，使用split方法提取組件.在字串中，資料出現在任意位置，這種方法都能夠工作。
>>> line=‘aaa bbb ccc‘
>>> cols=line.split()
>>> cols
[‘aaa‘, ‘bbb‘, ‘ccc‘]
字串的split方法用分割符將一個字串分割為一個子字串的列表。預設的分隔字元為空白格--這個字串被一個或多個空格，定位字元或者分行符號分成多個組，之後我們得到了一個最終子字串的列表。
>>> names=‘diege,kelly,lily‘
>>> names.split() 
[‘diege,kelly,lily‘]
>>> names.split(‘,‘)
[‘diege‘, ‘kelly‘, ‘lily‘]
3、實際應用中的其他常見的字串方法
其他的字串方法都有更專註的角色
清除每行末尾的空白，執行大小寫轉換，以及檢測末尾的子字串.
>>> line=‘The python is running!\n‘
>>> line.rstrip()                 
‘The python is running!
>>> line.upper()
‘THE PYTHON IS RUNNING!\n
>>> line.isalpha()
False
>>> line.endswith(‘ing!\n‘)
True
>>> line.find(‘ing‘)!=-1
True
注意沒有字串支援模式---對於基於模式的文本處理，必須使用Python的re標準庫模組。字串方法有時與re模組的工具比較起來，有運行速度方面的優勢
4、最初的字串模組
最初的字串模組為string模組，其中包含的函數大約相當於目前的字串方法集。而今應該只使用字串方法，而不是最初的string模組
五、通常意義下的類型分類
1、同樣分類的類型共用其操作集合
字串是不可改變的序列，不能在原處改變，是位置相關排序好的集合。Python中對所有序列型資料類型-都支援序列的操作--合并，索引，迭代。類似於序列操作，在Ptyhon中有三個類型（以及操作)的分類、
*數字
支援加法，乘法等
*序列
支援索引，分區和合并等
*映射
支援通過鍵的索引等。
例如對於任意序列對象X和Y：
X+Y 將會建立一個包含兩個操作對象內容的新的序列對象
X*N 將會包含操作對象X內容的N份拷貝的新的序列對象
換句話說，這些操作工作起來對於任意一種序列對象都一樣,包括字串，列表，元組以及使用者定義物件類型。對象的類型將會告訴Python去執行什麼樣的任務。
2、可變類型能夠在原處修改
不可變的分類是需要特別注意的約束。如果一個對象是不可變的，那麼就不能再原處修改它的值。替代方法，必須運行代碼來建立一個新的對象來包含這個新的值。不可變類型有某種完整性，保證這個對象不會被程式的其他部分改變。
可變的類型能在原處修改，可以根據需要修改原資料。

關於方法和運算式小總結：
方法是類型特定的，不具有通用性
運算式是通用的，可以用於多種類型。比如切片在支援序列的物件類型：字串，列表，元組中通用。

 

  

Python學習筆記整理(四)Python中的字串..