字符串屬于標量存儲、不可改變、順序訪問的數據類型。字符串屬于序列的一種，因此對字符串可行的序列操作對類似元組和列表同樣適用。
1. 字符串的創建
類似于數字類型的創建，直接將字符串賦值給變量即可創建一個新的字符串對象。
>>> a = 'string' # 使用單引號
>>> a = "string" # 使用雙引號，在 Python 中，單引號和雙引號沒有區別
>>> a = '''
... a
... string
... block ''' # 使用三引號，字符串塊（三引號在某些情況下可以起到注釋掉不需要執行的代碼的作用）
>>> a
'\na\nstring\nblock '
>>> a = ''
'' # 空字符
對變量重新賦值一個新的字符串即可 “ 更新 ” 變量
>>> a = 'string1'
>>> a
'string1'
>>> a = 'string2'
>>> a
'string2'
2. 轉義字符
一個反斜線加一個單一字符，可以表示一些通常情況下不可打印的字符，這種組合稱為轉義字符。
>>> a = 'string1\nstring2' # \n 代表換行符，雖然由兩個字符組成，但在最終表示中會被一個單一字符替代
>>> print a
string1
string2
常用的轉義字符包括：
| 轉義字符 | 代表含義 |
|---|---|
| \n | 換行 |
| \t | 橫向制表符（tab） |
| \\ | 反斜線（ \ ） |
| ' | 單引號 |
| " | 雙引號 |
| \u | 后跟四位十六進制數，表示 Unicode 字符串 |
當我們不需要對字符進行轉義時，可以使用原始字符串操作符 raw 字符串。在原始字符串中，所有的字符都是直接按照輸入的字符來使用，沒有轉義或不能打印的字符。使用 raw 只需要在字符串前加 r/R 即可。
>>> a = r'string1\nstring2'
>>> print a
string1\nstring2 # 輸出的結果和輸入一樣，沒有進行轉義
>>> a
'string1\\nstring2' # Python 自身在顯示 '\' 時也會使用轉義字符 '\\'
- 注：在交互模式下
print a和直接顯示a的區別：使用print可以顯示變量格式化以后的顯示效果，而直接輸入變量名則會顯示變量的值在 Python 內部的表示形式。
3. Unicode 字符串
如果需要使用 Unicode 字符串時，可以在字符串前加 u/U 即可使用 Unicode 字符串
>>> a = u'abc'
>>> a
u'abc'
>>> a = u'\u1234' # 使用 \u 轉義字符，\u 后為十六進制
>>> print a
?
4. 基本操作（適用于所有序列對象）
-
比較操作
字符串進行比較操作時按照在 ASCII 或 Unicode 中的數值大小進行比較
-
連接操作
可以使用 ' +' 操作符對字符串進行連接
a = 'a'
b = 'b'
a + b
'ab'
```
-
重復操作
使用 '*' 操作符將字符串重復 N 次
a = 'a'
a * 7
'aaaaaaa'
```
-
成員操作
in / not in 可以用于判斷一個字符或字符串是否出現在另一個字符串中
'ab' in 'abcd'
True
'ac' in 'abcd'
a = 'string1'
>>> a
'string1'
>>> a = 'string2'
>>> a
'string2'
### 2. 轉義字符 一個反斜線加一個單一字符，可以表示一些通常情況下不可打印的字符，這種組合稱為轉義字符。
>>> a = 'string1\nstring2' # \n 代表換行符，雖然由兩個字符組成，但在最終表示中會被一個單一字符替代
>>> print a
string1
string2
常用的轉義字符包括： | 轉義字符 | 代表含義 | | ------------ | ------------ | | \n | 換行 | | \t | 橫向制表符（tab）| | \\\ | 反斜線（ \ ）| | \' | 單引號 | | \" | 雙引號 | | \u | 后跟四位十六進制數，表示 Unicode 字符串 | 當我們不需要對字符進行轉義時，可以使用原始字符串操作符 raw 字符串。在原始字符串中，所有的字符都是直接按照輸入的字符來使用，沒有轉義或不能打印的字符。使用 raw 只需要在字符串前加 r/R 即可。
>>> a = r'string1\nstring2'
>>> print a
string1\nstring2 # 輸出的結果和輸入一樣，沒有進行轉義
>>> a
'string1\nstring2' # Python 自身在顯示 '' 時也會使用轉義字符 '\'
- 注：在交互模式下 `print a` 和直接顯示 `a` 的區別：使用 `print` 可以顯示變量格式化以后的顯示效果，而直接輸入變量名則會顯示變量的值在 Python 內部的表示形式。 ### 3. Unicode 字符串 如果需要使用 Unicode 字符串時，可以在字符串前加 u/U 即可使用 Unicode 字符串
>>> a = u'abc'
>>> a
u'abc'
>>> a = u'\u1234' # 使用 \u 轉義字符，\u 后為十六進制
>>> print a
?
### 4. 基本操作（適用于所有序列對象） - 比較操作 字符串進行比較操作時按照在 ASCII 或 Unicode 中的數值大小進行比較 - 連接操作 可以使用 ' +' 操作符對字符串進行連接
>>> a = 'a'
>>> b = 'b'
>>> a + b
'ab'
- 重復操作 使用 '*' 操作符將字符串重復 N 次
>>> a = 'a'
>>> a * 7
'aaaaaaa'
- 成員操作 in / not in 可以用于判斷一個字符或字符串是否出現在另一個字符串中
>>> 'ab' in 'abcd'
True
>>> 'ac' in 'abcd'
False
'ac' not in 'abcd'
True
```
5. 索引和切片（適用于所有的列表和對象）
序列對象從 0 開始進行索引，通過指定元素索引或切片對序列對象中的元素進行訪問，語法如下：squence[index]
>>> a = 'string'
>>> a[0]
's' # 序列的索引從 0 開始
>>> a[5]
'g' # 序列索引的最大值比序列的長度小 1
除此之外，還可以使用 負索引，范圍是 -1 到序列的負長度。正負索引的區別在于正索引以序列的開始為起點（ 0 ），負索引以序列的結束為起點（ -1 ）。負索引 + 序列長度 = 正索引
>>> a[-1]
'g' # 負索引從 -1 開始
>>> a[-6]
'a' # 負索引的最大值是序列的負長度，正索引的最大值是長度 len(squence) - 1
如果在訪問序列的索引越界會引發一個異常：
>>> a[6] # 正索引的最大值應該是長度 - 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
通過索引可以訪問指定偏移量的某一個元素，而切片操作則可用來訪問序列中指定的多個元素。切片操作只需要給出切片的開始和結束的索引值，中間用 ' : ' 分隔開即可: squence [ start_index : end_index ]
>>> a[1:3]
'tr' # 切片會截取從起始索引到結束索引，但不包括結束索引
>>> a[:3]
'str' # 如果不指定起始索引，默認為序列的開始
>>> a[1:]
'tring' # 如果不指定結束索引，默認到序列的結束
>>> a[:]
'string' # 需要指出的是，所有字符串的操作都相當于創建了一個新的字符串，通過這種方法可以對字符串進行拷貝
>>> a[1:-1]
'trin' # 在切片中同樣可以使用負索引
切片操作還有第三個參數，起到類似步長的作用。不指定時默認為 1
>>> a[::2]
'srn'
>>> a[::-1]
'gnirts' # 可以通過這樣來獲得一個序列的倒序
切片不同于索引，不存在越界引起的異常
>>> a[-100:100]
'string' # 在切片中當起始或結束索引越界會使用默認值
在切片中使用 None
>>> a[:0]
'' # 在結束索引使用 0 時會返回空字符串
>>> a[:None]
'string' # 使用 None 則會返回整個字符串
>>> a[None:]
'string'
>>> a[None:None]
'string'
6. 序列的一些內建函數
對序列對象有一些通用且常用的內建函數：
- len()：返回序列中元素的長度
>>> len(a)
6 # 返回字符串的長度
- max() 和 min()：返回序列中的最大值和最小值
>>> max(a)
't' # 返回字符串元素中的最大值
>>> min(a)
'g' # 返回字符串元素中的最小值
- sorted()：對序列中的對象進行排序
>>> sorted(a)
['g', 'i', 'n', 'r', 's', 't']
- reversed()：對列表中的所有元素反序輸出
>>> for i in reversed(a):
... print i,
g n i r t s
- enumerate()：生成一個 enumerate 對象，該對象為每個元素的索引和值組成的元組
>>> for i in enumerate(a):
... print i
...
(0, 's')
(1, 't')
(2, 'r')
(3, 'i')
(4, 'n')
(5, 'g')
- zip()：接受兩個序列參數，生成一個列表，列表中的元素分別為由兩個參數按順序的兩個元素所組成的元組
>>> zip(a, a)
[('s', 's'), ('t', 't'), ('r', 'r'), ('i', 'i'), ('n', 'n'), ('g', 'g')]
7. 字符串類型函數
- raw_input()：可以使用給定的字符串提示用戶輸入并將輸入返回賦值給變量。
>>> a = raw_input("Please input something: ") # 函數接受的字符串參數即為輸出在屏幕上提示用戶輸入的字符串
Please input something: string # 輸入字符串：string
>>>
>>> print a # 上邊的輸入 string 已經賦值給變量 a
string
chr() 和 unichr()：chr 接受一個ASCII 碼，即 0-255 之間的整數，返回對應的字符。unichr 則接受一個 Unicode 碼，返回對應的 Unicode 字符
ord()：ord 作為 chr 和 unichr 的對應函數，返回一個字符的 ASCII 或 Unicode 數值
>>> chr(97)
'a' # 接受一個 0-255 的整數，返回對應的ASCII 字符
>>> unichr(1234)
u'\u04d2' # 接受一個 0-65535 的整數，返回對應的Unicode 碼
>>> print unichr(1234)
?
>>> ord('a')
97 # 接受一個 ASCII 字符，返回對應的數值
>>> ord(u'\u04d2')
1234 # 接受一個 Unicode 字符，返回對應的數值
- str() 和 unicode()：將參數轉換為字符串或 unicode 字符串
>>> str(123)
'123' # 將數字 123 轉換為字符串
>>> unicode(123)
u'123' # 將數字轉換為 unicode 字符串
8. 字符串內建函數
-
string.strip()：刪除 sting 字符串開頭和末尾的空格
a = '\tstring\n'
a.strip()
'string' # 將字符串前后空格都刪除，lstrip() 和 rstrip() 分別刪除開頭和結尾的空格
```
-
string.split(str)：以 str 為分隔符將字符串進行分隔
a = 's t r i n g'
a.split(' ')
['s', 't', 'r', 'i', 'n', 'g'] # 以空格為分隔符將字符串進行分隔
```
-
string.join(seq)：以 string 為分隔符，將 seq 中的所有元素合并為一個新的字符串
a = ['s', 't', 'r', 'i', 'n', 'g']
' '.join(a)
>>> print a # 上邊的輸入 string 已經賦值給變量 a
string
- __chr()__ 和 __unichr()__：chr 接受一個ASCII 碼，即 0-255 之間的整數，返回對應的字符。unichr 則接受一個 Unicode 碼，返回對應的 Unicode 字符 - __ord()__：ord 作為 chr 和 unichr 的對應函數，返回一個字符的 ASCII 或 Unicode 數值
>>> chr(97)
'a' # 接受一個 0-255 的整數，返回對應的ASCII 字符
>>> unichr(1234)
u'\u04d2' # 接受一個 0-65535 的整數，返回對應的Unicode 碼
>>> print unichr(1234)
?
>>> ord('a')
97 # 接受一個 ASCII 字符，返回對應的數值
>>> ord(u'\u04d2')
1234 # 接受一個 Unicode 字符，返回對應的數值
- __str()__ 和 __unicode()__：將參數轉換為字符串或 unicode 字符串
>>> str(123)
'123' # 將數字 123 轉換為字符串
>>> unicode(123)
u'123' # 將數字轉換為 unicode 字符串
### 8. 字符串內建函數 - __string.strip()__：刪除 sting 字符串開頭和末尾的空格
>>> a = '\tstring\n'
>>> a.strip()
'string' # 將字符串前后空格都刪除，lstrip() 和 rstrip() 分別刪除開頭和結尾的空格
- __string.split(str)__：以 str 為分隔符將字符串進行分隔
>>> a = 's t r i n g'
>>> a.split(' ')
['s', 't', 'r', 'i', 'n', 'g'] # 以空格為分隔符將字符串進行分隔
- __string.join(seq)__：以 string 為分隔符，將 seq 中的所有元素合并為一個新的字符串
>>> a = ['s', 't', 'r', 'i', 'n', 'g']
>>> ' '.join(a)
's t r i n g' # 用空格將 a 中的元素合并成新的字符串
''.join(a)
'string' # 當不指定 string 時，直接合并
```
-
string.find(sr)：檢測 str 是否在字符串中，如果時返回索引，否則返回 -1
a = 'strings'
a.find('s')
0 # 結果總是返回第一個找到的索引
a.find('a')
-1 # 沒有找到時返回 -1
```
-
string.index(str)：與 find 類似，但不存在時引發一個異常
a = 'strings'
a.index('s')
0 # 同樣返回第一個 str 的索引
a.index('a') # 與 find 不同，str 不存在時引發一個異常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
```
-
string.count(str)：返回 str 在字符串中出現的次數
a = 'strings'
a.count('s')
2
```
- string.upper() 和 string.lower()：分別將字符串字符轉換為大寫和小寫
>>> a = 'String123'
>>> a.upper()
'STRING123' # 將字符串 a 中的所有字母大寫，非字母不變
>>> a.lower()
'string123' # 將字符串 a 中的所有字母小寫，非字母不變
-
string.partition(str)：find() 和 split() 的結合，從 str 出現的第一個位置起，將 string 分成三元組 (string_pre_str, str, string_post_str)， 如果不包含 str，string_pre_str = string
a = 'string'
a.partition('r')
('st', 'r', 'ing')
a.partition('a')
('string', '', '')
```
-
string.replace(str1,str2) ：把 str1 替換為 str2
a = 'strings'
a.replace('s', 'x')
'xtringx' # 把 string 中所有的 str1 替換為 str2，可以指定替換的次數參數
a.replace('a', 'x')
'string' # string 中不包含 str1 時，不做任何操作
```
更多關于字符串的內建函數參考：String Method
9.字符串格式化
Python 中的字符串格式化操作，類似于 C 語言中的 printf() 函數的字符串格式化，語法如下：
在 % 操作符的左側放置一個需要進行格式化的字符串，這個字符串帶有一個或多個嵌入的轉換目標，都以 % 開頭。
在 % 操作符的右側放置一個或多個（元組）對象，這些對象會插入到左側需要進行格式化的一個或多個轉換目標的位置上去。
>>> "That is %d %s bird!" % (1, 'little')
That is 1 little bird!
在上邊這個例子中，整數 1 替換在格式化字符串左側的 %d， 字符串 'little' 替換 %s，從而得到一個新的格式化了的字符串。
如果不使用格式化字符串，我們可以使用多次字符串的合并和轉換來達到目的，但十分麻煩。
>>> "That is " + str(1) + " little " "bird !"
That is 1 little bird!
通常根據需要轉換的目標不同，左側 % 操作符后邊的符號也不相同，常見的格式化代碼如下
| 代碼 | 意義 |
|---|---|
| %s | 字符串 |
| %r | 使用 repr 的字符串 |
| %d | 十進制整數 |
| %i | 整數 |
| %f | 浮點十進制數 |
從高級的應用來說，表達式左側的轉換目標有一套完整的語法：
`%[(name)][flag][width][.precision]typecode`
上表中的字符碼出現在目標字符串的尾部，在 % 和字符碼之間，可以有以下操作：
- 放置一個字典的鍵
[(name)] - 列出左對齊
-、正號+和補零0的標志位[flag] - 給出數字的整體長度和小數點后的位數等
[width] [.precision]
>>> "***%d***%-6d***%06d***%+d***" % (123, 123, 123， 123)
'***123***123 ***000123***+123***' # %-6d 表示左對齊，%06d 表示補零
>>> "***%.2f***" % (123.456)
***123.46*** # %.2f 表示保留浮點數小數點后2位
>>> "That is %(number)d little %(name)s !" % {'number':1, 'name':'bird'}
That is 1 little bird ! # 使用字典進行格式化
format() 方法：在 Python 2.6 和 3.0 以后的版本引入了一種新的格式化方法，format() 函數
>>> "That is {0} little {1} !".format(1, 'bird')
That is 1 little bird !
格式化總是會返回新的字符串作為結果而不是對左側的字符串進行修改，如果需要的話，必須將格式化字符串賦值給一個變量來保存結果。
更多關于字符串格式化的參考：String format
更多關于字符串的參考：Sequence Type
