Python學習筆記（五）——字符串

字符串

Python字符串——一個有序字符的集合，用于存儲和表現基于文本的信息。

Python中沒有單個字符的類型，只有使用一個字符的字符串。

字符串被劃分為不可變序列，意味著這些字符串所包含的字符存在從左往右的位置程序，并且不可以在原處修改。

常見字符串常量和表達式：

#

字符串常量：

? 單引號：'Yert"s'
? 雙引號："Yert's"
? 三引號："....................Yert................................"
? 轉義字符：’\tp’
? Raw字符串：r"C:w\test.com"
? Python3.0中的Byte字符串：b’sp\x01
? 只在Python2.6出現的Unicode字符串：u’egg\suu’

單雙引號的作用相同：

>>> 'Yert',"Yert"
('Yert', 'Yert')

Python自動合并相鄰的字符串常量：

>>> title="The truth "  'of' "life"
>>>
>>> title
'The truth oflife'

三重引號編寫多行字符串塊：

>>>
>>> longfile='''
...
...
... a
... a
... a
... a
... a
... '''
>>>
>>>
>>> longfile
'\n\n\na\na\na\na\na\n'
>>>
>>> print(longfile)

a
a
a
a
a

>>>

轉義字符序列：

通過反斜杠轉義字符嵌入引號：

>>> 'today\'s',"yesterday\"s"
("today's", 'yesterday"s')

轉義序列插入絕對的二進制值：

>>>
>>> s = 'a\0b\0c'
>>>
>>> s
'a\x00b\x00c'
>>>
>>> len(s)
5
>>>

Python會在內存中保持了整個字符串的長度和文本，Python沒有字符會結束一個字符串。

>>>
>>> s = '\001\002\003'
>>>
>>> s
'\x01\x02\x03'
>>>
>>> len(s)
3
>>>

如果Python沒有作為一個合法的轉義編碼識別出在“\”后的字符，它就直接在最終的字符串中保留反斜杠。

>>> x = "C:\py\code"
>>>
>>> x
'C:\\py\\code'

raw字符串抑制轉義

Raw字符串：如果字母r（大寫或小寫）出現在字符串的第一引號的前面，它將會關閉轉義機制。Python將反斜杠作為常量來保持，就像普通字符串，為了避免錯誤，在Windows系統中必須增加字母r。

>>> myfile=open(r'D:test\test.txt','w')
>>>
>>> text="I'm Yert,the word would been wroten in text."
>>>
>>> myfile.write(text)
44
>>>
>>> myfile.close()

索引和分片：

索引：
字符串在Python中被定義為字符的有序集合，可以通過位置偏移值獲取字符。在Python中，字符串中的字符是通過索引（通過在字符串之后的方括號中提供所需要的元素的數字偏移量）提取的。

Python的偏移量是從0開始，并比字符串的長度小1，還支持在字符串中使用負偏移的方法從序列中獲取因素。從技術上講，一個負偏移與這個字符串長度相加可以得到它的正偏移值。

>>> S='YertAlan'
>>>
>>> S[0]
'Y'
>>> S[-1]
'n'
>>>
>>> len(S)
8
>>> S[len(S)-1]
'n'

分片：
當使用一對以冒號分隔的偏移來索引字符串時，Python將會返回一個新的對象，其中包含了以這對偏移所標識的連續內容。

>>> S[1:3]
'er'
>>> S[1:]
'ertAlan'
>>>
>>> S[::]
'YertAlan'
>>>
>>> S[-4:-1]
'Ala'
>>>
>>> S[:-2]
'YertAl'

拓展分片：第三個限制值
分片表達式增加一個可選的第三個索引，用作步進。步進添加到每個提取的元素的索引中。完×××式的分片為string[X:Y:Z]，表示“索引字符串string對象中的元素，從偏移X直到偏移為Y-1，每隔Z元素索引一次”。第三個限制沒人為1，所以通常在一個切片中從左至右提取每一個元素的原因。

>>> string='ABCDEFGHIJKLMNOPQRST'
>>>
>>> string[1:8]
'BCDEFGH'
>>>
>>> string[1:8:2]
'BDFH'
>>>
>>> string[1:12]
'BCDEFGHIJKL'
>>> string[1:12:3]
'BEHK'

負數步進：

>>> string[1:10]
'BCDEFGHIJ'
>>>
>>> string[1:10:-1]
''
>>> string[10:1:-1]
'KJIHGFEDC'
>>>
>>> string[10:1]
''
>>> string[10:1:-2]
'KIGEC'

字符串轉換工具

>>>#將以字符串形式出現的數字進行轉換：
>>> int('55'),str(55)
(55, '55')
>>> repr(55)
'55'

注意：Repr函數可以將一個對象轉換為其字符串形式，然而這些返回的對象作為代碼的字符串，可以重新創建對象。

>>> print(str('Yert'),repr('Yert'))
Yert 'Yert'

>>>#浮點數轉換字符串：
>>> str(3.1415),float("1.5")
('3.1415', 1.5)
>>>
>>> text="1.234E-10"
>>>
>>> float(text)
1.234e-10

字符串代碼轉換：
單個字符可以通過將其傳給內置的ord函數轉換為其對應的ASCII碼——則個函數實際返回的是這個字符在內存中對應的字符的二進制值。而chr函數將會執行相反的操作，獲取ASCII碼并將其轉換為對應的字符：

>>> ord('s')
115
>>>
>>> chr(115)
's'

>>>#執行基于字符串的數學運算：
>>> S='a'
>>> S=chr(ord(S)+1)
>>> S
'b'
>>> S=chr(ord(S)+1)
>>>
>>> S
'c'

>>> int('5')
5
>>>
>>> ord('5') - ord('0')
5

與循環語句結合，進行整數的處理：
將二進制字符串轉換為整數，并將當前值乘以2，并加上下一位數字值。

>>> B = '1101'
>>> I = 0
>>> while B != '':
...     I = I * 2 + (ord(B[0])-ord('0'))
...     B = B[1:]
...
>>>
>>> I
13
>>>

修改字符串

>>>#使用合并、分片：
>>> S='Yert'
>>>
>>> S = 'Yert'
>>> S = S + 'Alan'
>>> S
'YertAlan'
>>> S = S[:4] + '·D·' + S[4:]       #D之一族
>>>
>>> S
'Yert·D·Alan' 

使用replace函數修改（索引到字符串，將其改為指定字符串）：

>>> S=S.replace('Alan','King')
>>> S
'Yert·D·King'

通過字符串格式化表達式來創建新字符串：

>>> "March %sst,I'm a apple,I'm have a %s" % (1,'pencil')
"March 1st,I'm a apple,I'm have a pencil"
>>>
>>> "March {0}st,I'm a apple,I'm have a {1}".format(1,'pencil')
"March 1st,I'm a apple,I'm have a pencil"

使用find方法進行修改：

>>> S = '13658934230'  #實現修改號碼，保護隱私
>>>
>>> node = S.find('5893')
>>>
>>> node
3
>>> S = S[:node] + 'XXXX' + S[(node+4):]
>>>
>>> S
'136XXXX4230'

使用合并操作和replace方法每次運行產生新的字符串對象，會消耗性能，所以在對超長文本進行多處修改時，需要將字符串轉換為一個支持原處修改的對象。

>>> S = 'yert'
>>>
>>> L = list(S)
>>>
>>> L
['y', 'e', 'r', 't']

內置的list函數（或一個對象構造函數調用）以任意序列中的元素創立一個新的列表，可以將字符串中的字符分解為一個列表。

Join函數可以將列表合成為一個字符串：

>>> D = ''.join(L)
>>>
>>> D
'yert'

其他字符串方法：

>>>#通過分片的方式將數據從原始字符串中分離，稱為解析。
>>> S
'yert'
>>>
>>> J = S[1:3]
>>>
>>> J
'er'
>>>#如果分隔符分開了數據組件，可以使用split方法提取組件。
>>> date = 'My name is Yert'
>>>
>>> cols = date.split()
>>>
>>> cols
['My', 'name', 'is', 'Yert']
>>>
>>> long_str = 'My name is Yert, I am a computer engineer,I am studing Python'
>>>
>>> cols = long_str.split(',')
>>>
>>> cols
['My name is Yert', ' I am a computer engineer', 'I am studing Python']

>>> line = 'The dog is Sam which it is yellow ! \n'
>>>#清除每行末尾空白
>>> line.rstrip()
'The dog is Sam which it is yellow !'
>>>#全部轉換大寫
>>> line.upper()
'THE DOG IS SAM WHICH IT IS YELLOW ! \n'
>>>#測試內容
>>> line.isalpha()
False
>>>
>>>#檢測末尾內容字符串
>>> line.endswith('! \n')
True
>>>#檢測開始內容字符串
>>> line.startswith('The')
True
>>> line[-len('! \n'):] == '! \n'
True
>>>
>>> line[:len('The ')] == 'The '
True

字符串格式化表達式
格式化字符串：

1. 在%操作符的左側放置一個需要進行格式化的字符串，這個字符串帶有一個或多個嵌入的轉換目標，都以%開頭。
2. 在%操作符右側放置也（或多個，嵌入到元組中）對象，這些對象將會插入到左側想讓Python進行格式化字符串的一個（或多個）轉換目標的位置上去。

>>> '%d years later,I have became a %s!' % (3,'engineer')
'3 years later,I have became a engineer!'

高級字符串格式化表達式：

轉換目標通用結構：
%[ (name) ] [flags] [width] [.precision] typecode

表中的字節碼出現在目標字符串的尾部，在%和字符碼只間：可以放置一個字典的鍵；羅列出左對齊（-）、正負號（+）和補零（0）的標志位；給出數字的整體長度和小數點后的位數等。Width和precision都可編碼為一個*，以指定它們應該從輸入值的下一項中取值。

>>>#%d對整數進行默認，%-6d進行6位的左對齊格式化，%06d進行6位補零的格式化
>>> M = 24
>>>
>>> resu = "result: %d %-6d %06d" % (M,M,M)
>>>
>>> resu
'result: 24 24     000024'

>>>#可以在格式化字符串中用一個*來指定通過計算得出width和precision，從而迫使它們的值從%運算符右邊的輸出中的下一項獲取，元組中的4指定為precision。
>>> '%f,%.2f,%.*f' % (1/3.0,1/3.0,4,1/3.0)
'0.333333,0.33,0.3333'

基于字典字符串格式化

>>>#通過字典的鍵來提取對應的值：
>>> "%(a)d %(x)s" % {'a':1,'x':'Yert'}
'1 Yert'

>>>#Format方法格式化字符串：
>>> date = '{0},{1} and {2}'
>>>
>>> date.format('Python','PHP','Go')
'Python,PHP and Go'
>>>
>>> date = '{a},{b} and {c}'
>>>
>>> date.format(a='Python',b='PHP',c='Go')
'Python,PHP and Go'
>>>
>>>
>>> date = '{a},{0} and {c}'
>>>
>>> date.format('PHP',a='Python',c='Go')
'Python,PHP and Go'

格式化字符串可以指定對象屬性和字典鍵。

>>> import sys
>>>
>>> 'The machine {1[name]} runs {0.platform}'.format(sys,{'name':'Yert'})
'The machine Yert runs win32'
>>>
>>> 'The machine {config[name]} runs {sys.platform}'.format(sys=sys,config={'name':'Yert'})
'The machine Yert runs win32'