python字符串類型

python中的字符串

python中的字符串類型爲str，也是平時操做的類型。但除了str類型，還有一個專門的名爲"string"的模塊(導入便可知)，是很早之前沒有str類型的時候用的，如今幾乎不用。

在python 3.x中，字符串的類型str是Unicode的。除此以外還有byte類型、bytearray類型。關於byte和bytearray，參考bytes和bytearray、編碼和解碼。

一些和字符相關的官方手冊：

1. string模塊
   
2. str類型詳細說明
   
3. 字面常量
   
4. byte和bytearray
   
5. byte和bytearray操做

字符串常量

下面是幾個字符串：

'malong'
'malong\'s girl friend'  # 包含了單引號
'malong\n'               # \n換行了
"malong\n"               # 換行了
'malong
girl friend'             # 換行了
'malong\\n'              # 沒換行
'''malong's girl'''      # 包含了單引號
"""malong
shuai"""                 # 換行了

python中可使用單引號、雙引號、三引號包圍字符串，並可使用反斜線轉義特殊字符：

• 單、雙引號是徹底一致的，不像其餘語言同樣有強、弱引用之分
  
• 三引號('''xxx'''或"""xxx""")包圍的字符徹底是字面符號，包圍什麼就獲得什麼，包括換行，且不會進行任何轉義、替換等
  • 使用這種塊字符串的方式，在輸入須要換行的字符串時很是方便
    
  • 並且能夠做爲塊註釋符註釋一段代碼。這表示這段被包圍的代碼解釋爲字符串，但由於沒有賦值給變量，因此直接丟棄了
    
• 反斜線\能夠轉義特殊字符，例如在字符串中保留單引號"a\'b"

可是python在輸出字符串的時候，老是傾向於使用單引號，除非字符串中包含了單引號。對於那些非打印字符，將老是使用十六進制的方式輸出。

例如：

>>> "aaa",'aaa'
('aaa', 'aaa')

>>> print("aa\na")
aa
a
>>> print('aa\na')
aa
a

>>> '''aaaa
... aaa
... '''
'aaaa\naaa\n'

>>> '\001'    # 二進制字符，十六進制格式輸出
'\x01'

raw字符串

雖然能夠經過反斜線\轉義去調整字符串，但帶上反斜線有時候會嚴重影響可讀性。若是不想使用反斜線轉義，能夠考慮使用三引號包圍，也可使用r來聲明後面的字符串是raw字符串，這裏面的全部字符都是字面意義的，不會進行任何轉義。

例如：

>>> 'abc\nd'
'abc\nd'
>>> len('abc\nd')
5

>>> r'abc\nd'
'abc\\nd'
>>> len(r'abc\nd')
6

常常在open()函數打開Windows文件的時候會使用raw字符串。例以下面三種方式：

open('d:\new\test.txt')   # (1)
open('d:\\new\\test.txt') # (2)
open(r'd:\new\test.txt')  # (3)

(1)中解釋字符串的時候，發現裏面有\n和\t，它們會分別解釋爲換行符和製表符，這顯然不多是想要打開的文件。因此，在(2)中，使用反斜線將反斜線自身進行了轉義。而(3)中使用r聲明這是一個raw字符串，裏面的轉義序列不會進行轉義，而是做爲普通字符，因此這裏的\表示的是路徑的分隔符號。

固然，考慮到可移植性的問題，open()函數中直接使用斜線也能夠表示windows中的路徑分隔符。因此下面是有效的：

open('d:/new/test.txt')

注意，raw字符串不能以反斜線結尾，除非對其轉義。例如r'abc\ndef\'是錯誤語法，但r'abc\ndef\\'是正確的語法，它表示後面有兩個反斜線字符。

>>> r'abc\nd\a\\'
'abc\\nd\\a\\\\'

>>> print(r'abc\nd\a\\')
abc\nd\a\\

>>> r'abc\nd\a\'
  File "<stdin>", line 1
    r'abc\nd\a\'
               ^
SyntaxError: EOL while scanning string literal

字符串轉換

數值和字符串類型不能直接放在一塊兒操做，例如9 + "9"是錯誤的。要將一個數值類型轉換成字符串類型，可使用str()方法或repr()方法。

>>> str(8)
'8'
>>> repr(8)
'8'

它們都表示返回字符串類型的數據。

當使用print()輸出str()或repr()轉換的內容，它們的結果會不同：

>>> print(str('a'))
a
>>> print(repr('a'))
'a'

通常來講使用str()便可，在學習到__str__()和__repr__()以前，不必去區分str()和repr()。

操做字符串

在python中，操做字符串的方式有多種，大概歸納有：

1. 字符串是一個序列，且是不可變序列，因此序列的通用操做和不可變序列的操做都能應用在str上
   
2. string對象自身實現了不少方法，好比大小寫轉換、子串搜索、截斷等等
   
3. 字符串鏈接，如"abc" "def"或"abc" + "def"是等價的，都是"abcdef"，"a" * 3獲得"aaa"
   
4. 字符串格式化(本文不介紹，由於內容太長，見後面的文章)

例如：

>>> len("abc")
3

>>> 'abc' 'def'
'abcdef'
>>> 'abc' + 'def'
'abcdef'

>>> 'abc' * 3
'abcabcabc'
>>> 3 * 'abc'
'abcabcabc'

經過字符串的乘法"*"操做，能夠輕鬆地重複給定數量的字符。例如：

>>> print("-" * 20)
--------------------
>>> print("-" * 20)
--------------------

輕鬆地就能獲得長度同樣的分割線。

注意，這兩個符號不能操做數值、字符串的混合表達式，由於python不會自動轉換隱式轉換數據類型。

>>> "3" + 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be str, not int

由於python中的字符串是一種序列類型，因此可使用in來測試字符串中是否包含某個字符或子串。

>>> 'o' in "hello"
True
>>> 'a' in "hello"
False
>>> 'll' in "hello"
True

一樣，由於是序列類型，可使用for來遍歷整個字符串：

>>> str = "longshuai"

>>> for i in str:
...     print(i, end=",")
...
l,o,n,g,s,h,u,a,i,

在for遍歷字符串的過程當中，控制變量i會取得字符串中的每一個字符。

字符串的索引和分片操做

字符串是一種序列，能夠應用序列的一種很是方便的分片操做。關於序列的相關操做(包括分片)，詳細內容見python序列操做，此處介紹一些基本的操做。

必須注意，由於字符串是不可變對象，沒法原處修改，因此不管是索引取值仍是分片操做，都會建立新字符串對象。

索引取單個元素

例如，經過索引從字符串中取元素：

>>> str = "malong"
>>> str[0]
'm'
>>> str[1]
'a'

索引位能夠是負數，表示從尾部開始取元素，-1表示倒數第一個元素，-2表示倒數第二個元素。

>>> str[-1]
'g'
>>> str[-2]
'n'

因此，-i的索引位等價於len() - i的索引位。

>>> str[-1]
'g'
>>> str[len(str) - 1]
'g'

分片取多個元素

分片的方式是使用[i:j]或[i:j:k]的方式，表示從索引位i開始取到索引位j(不包含j)，i或j均可以省略。若是指定了k，則表示每隔k個元素取一次，也就是取一次元素以後跳過(k-1)一個元素。i、j、k均可以使用負數。

例如：

>>> str = 'malong'
>>> str[1:3] 
'al'

[1:3]表示從索引位1取到索引位3，不包括3的元素。

可使用負數的索引位。下面的表示從第3個元素取到倒數第2個元素，但不包含倒數第二個。

>>> str[2:-2]
'lo'

i和j均可以使用負數。

>>> str[-4:-2]
'lo'

能夠省略i或j，或都省略。[:j]表示從頭取到索引位爲j的元素(不包含j)，[i:]表示從索引位i開始取到結尾，[:]表示從頭取到尾，也就是拷貝一份字符串。

>>> str[:3]
'mal'
>>> str[:-1]
'malon'

>>> str[1:]
'along'
>>> str[-4:]
'long'

>>> str[:]
'malong'

指定k時，能夠跳過指定間隔的元素。默認爲1，表示每隔一個元素取一次，也就是不跳過任何元素。指定爲2時表示取1次跳過一個元素。

>>> str
'malong'

>>> str[::1]
'malong'

>>> str[::2]
'mln'

因此，取奇數位的字符和偶數位的字符就很簡單了。

>>> str[::2]   # 取奇數位
'mln'
>>> str[1::2]  # 取偶數位
'aog'

若是k爲負數，則表示反序取元素。例如：

>>> 'abcde'[::-1]
'edcba'
>>> 'abcde'[::-2]
'eca'

再看下面反序輸出的例子。

>>> 'abcdefgh'[5:0:-1]
'fedcb'

表示反序0-5的元素abcdef，但不包含0位，即獲得fedcb。也就是說獲得索引位1-5的反序結果。

因此：

>>> 'abcdefgh'[5:0:-2]
'fdb'

字符串方法

由於內容較多，本人已從官方手冊翻譯並整理成單獨的文章，見python字符串方法整理

修改字符串

字符串是不可變數據類型，要修改字符串，只能經過分片新建字符串對象並進行合併，或者直接使用字符串方法。

例如：

>>> s = "hello"
>>> s[0] = "H"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

要修改第一個元素，能夠從原始字符串中切片取出後面的字符，並結合修改的目標字符構建一個新的字符串，並賦值給原始變量。

>>> s = "hello"
>>> s = "H" + s[1:]
>>> s
'Hello'

再例如，將一個新字符串追加到源字符串的尾部：

>>> s = "hello"
>>> s = s + " world"
>>> s
'hello world'

>>> s = "hello world"
>>> s = s[:6] + "your " + s[6:]
>>> s
'hello your world'

>>> s = "hello world"
>>> where = s.find("world")
>>> where
6
>>> s = s[:where] + "your " + s[where:]
>>> s
'hello your world'

由於會建立新對象，因此會建立新內存空間。但這並不必定意味着效率會有多差，python對於不使用的內存空間會自動回收，在有可能的狀況下python會當即重用這段空間。