python基礎——字符串

Python的核心數據類型——字符串

常見字符串常量和表達式

操作	解釋
s = ‘’	空字符串
s = “dodo’s”	雙引號和單引號
s = ‘d\no\p\td\x00o’	轉義序列
s = “””….”””	三重引號字符串塊
s = r’\temp\dodo’	Raw字符串
s = b’dodo’	字節字符串
s = u’dodo’	unicode字符串（僅在2.0+使用）
s1 + s2，s * 3	合並，重復
s[i],s[i:j],len(s)	索引，分片，長度
“a %s parrot” % kind	字符串格式化表達式
“a {0} parrot”.format(kind)	字符串格式化方法
s.find(‘ao’)	字符串方法調用：搜索
s.rstrip()	移除空格
s.replace(‘pa’,’xx’)	替換
s.split(“,”)	用展位符分隔為列表
s.isdigit()	內容判斷
s.lower()	所有字符轉換為小寫
s.endswith(‘do’)	判斷s字符串是否以do結束
‘dodo’.join(strlist)	在strlist中的每個元素之間插入dodo字符串
s.encode(‘latin-1’)	Unicode編碼等
for x in s : print(x)	迭代，成員關系
‘dodo’in s	判斷dodo是否為字符串s的成員
[c * 2 for c in s]	迭代字符串s中每個字符重復一次至列表
map(ord,s)	迭代s中每個字符的ASCII代碼

就像任意字符的集合一樣，字符串是用來記錄文本信息的。ASCII是Unicode文本的一種簡單形式。Python通過包含各種不同的對象類型，解決文本和二進制數據之間的區別：

• 3.0+中，有3種字符串類型：str用於Unicode文本（ASCII或其他），bytes用於二進制數據（包括編碼的文本），bytearray是bytes的一種可變的變體。
• 2.0+中，Unicode字符串便是寬Unicode文本，str字符串處理8位文本和二進制數據。

bytearray類型在2.6+以后的版本中可用，更早的版本就不可用了，3.0+與二進制數據緊密相連。

字符串常量

• 單引號：’spa”m’
• 雙引號：”spa’m”
• 三引號：”””…spam…”””,’’’…spam…’’’
• 轉義字符：”s\tp\na\0m”
• Raw字符串：r”c:\new\test.xxx”
• Python3.0+中的Byte字符串：b’sp\x01am’
• 僅在2.6中使用的Unicode字符串：u’eggs\u0020spam’

單雙引號字符串是一樣的

在Python字符串中，單引號和雙引號是可以互換的。字符串常量表達式可以用兩個單引號或兩個雙引號來表述——兩種形式返回相同的類型對象。可以在雙引號字符包含字符串中嵌入一個單引號字符（單引號則為字符串的一部分），反之亦然。

注意：字符串之間增加都好會創建一個元組，而不是字符串。

>>> "a",'b',"c",'d'
('a', 'b', 'c', 'd')

用轉義字符代表特殊字節

轉義序列讓我們能夠在字符串中嵌入不容易通過鍵盤輸入的字節。字符串常量中字符”\“,以及在它后邊的一個或多個字符，在最終的字符對象中會被一個單個字符所替代，這個字符通過轉義序列定義了一個二進制值。

字符串反斜杠字符

轉義	意義
\newline	忽視（連續）
\\	反斜杠(保留\)
\’	單引號（保留’）
\”	雙引號（保留”）
\a	響鈴
\b	倒退
\f	換頁
\n	換行（新行）
\r	返回
\t	水平制表符
\v	垂直制表符
\N{id}	Unicode數據庫ID
\uhhhh	Unicode16位的十六進制值，4個16進制數字
\Uhhhhhhhh	Unicode32位的十六進制值，八個16進制數字
\xhh	十六進制值
\ooo	八進制值
\0	Null(不是字符串結尾)
\other	不轉義（保留）

python以十六進制顯示非打印的字符。

>>> s = '\001\002\x03'
>>> s
'\x01\x02\x03'
>>> len(s)
3
>>> s = 's\tp\na\x00m'
>>> s
's\tp\na\x00m'
>>> len(s)
7
>>> print(s)
s       p
a
>>> x = 'c:\py\code'
>>> x
'c:\\py\\code'
>>> len(x)
10

raw字符串抑制轉義

轉義字符序列用來處理嵌入在字符串中的特殊字節編碼是很合適的。有時候，為了引入轉義字符而使用適應的反斜杠的處理會帶來一些麻煩。例如：使用文件名參數來打開一個文件：

fp = open（‘c:\new\text.dat’,’w’）

問題是這有”\n“,他會識別為一個換行字符，並且”\t”會被一個制表符所替代，結果就是調用嘗試打開一個名為c:（換行）ew(制表符)ext.dat的文件，而不是我們需要的結果。

這正是使用raw字符串所要解決的問題。如果字母r（大寫或小寫）出現在字符串的第一個引號的前面，它將會關閉轉義機制。因此為了避免這種文件名的錯誤，記得在windows中增加字母r：

fp = open(r’c:\new\text.dat’,’w’)

>>> path = r'c:\new\text.dat'
>>> path
'c:\\new\\text.dat'
>>> print(path)
c:\new\text.dat
>>> len(path)
15

除了windows文件夾路徑，raw字符串也在正則表達式（文本模式匹配）中常見。

>>> x = r'1\nb\t\c\\'[:-1]
>>> x
'1\\nb\\t\\c\\'
>>> x = r'1\nb\t\c\\'
>>> x
'1\\nb\\t\\c\\\\'

注意：盡管有用，一個raw字符串也不能以單個的反斜杠結尾，因為反斜杠會轉義后續引用的字符，仍然必須轉義外圍引號字符以將其嵌入到該字符串中。也就是說，r”…\”不是一個有效的字符串常量，一個raw字符串不能以奇數個反斜杠結束。如果需要用單個反斜杠結束一個raw字符串，可以使用兩個反斜杠並分片掉第二個反斜杠（r’1\nb\t\c\\’[:-1]）\手動添加一個反斜杠（r’1\nb\tc’+’\\’）,或者忽略raw字符串語法在常規字符串中把反斜杠改為雙反斜杠（‘1\\nb\\tc\\’）。以上三種形式都會創建同樣的8個字符的字符串，其中包含3個反斜杠。

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

Python中還有一種三重引號內的字符串常量格式，稱作塊字符串，這是一種編寫多行文本數據的便捷語法。這個形式是以三重引號開始（單引號和雙引號都可以），並緊跟任意行數的文本，以開始時同樣的三重引號結尾。

• 三重引號字符串在程序需要出入多行文本的任何時候都何有用的。例如：嵌入多行錯誤信息或源文件中編寫html和xml代碼等。
• 三重引號字符串常用於文檔字符串，當它出現在文件的特定地點時，被當做注釋一樣的字符串常量。這並非只能使用三重引號的文本塊，但是他們往往是可以用作多行注釋的。
• 三重引號字符串經常在開發中飛出一些代碼。如果希望讓一些代碼不工作，之后再運行代碼，可以簡單地在這幾行前、后加入三重引號。

實際應用中的字符串

 

序列的操作

從嚴格意義上來說，字符串是單個字符的字符串的序列，其他類型的序列還包括列表和元組。

作為序列，字符串支持其中各個元素包含位置順序的索引操作。

>>> s = 'yexiaodong'
>>> len(s) #長度
10
>>> s[0] #第一個字符
'y'
>>> s[1]#第二個字符
'e'
>>> s[-1] #倒數第一個字符
'g'
>>> s[-2] #倒數第二個字符
'n'
>>> s[len(s) - 1] #倒數第一個字符，同s[-1]
'g'

同樣，也支持分片(slice)，合並以及重復等操作。

偏移和分片：位置偏移從左至右（偏移0位第一個元素），而負偏移是有末端右側開始計算（偏移-1位最后一個元素）。

索引（s[i]）獲取特定偏移的元素：

• 第一個元素的偏移位0
• 負偏移索引意味着從最后或右邊反向進行計數
• s[0]獲取第一個元素
• s[-2]獲取了倒數第二個元素(就像s[len(s)-2]一樣)

分片（s[i:j]）提取對應的部分作為一個序列：

• 上邊界並不包含在內
• 分片的邊界默認為0和序列的長度，如果沒有給出的話
• s[1:3]獲取了從偏移位1的元素，直到但不包括偏移為3的元素。
• s[1:]獲取了偏移為1直到末尾（偏移為序列長度）之間的元素。
• s[:3]獲取了從偏移為0直到但是不包括偏移為3之間的元素。
• s[:-1]獲取了從偏移為0直到但是不包括最后一個元素之間的元素。
• s[:]獲取了從偏移為0到末尾之間的元素，這有效地實現完全的頂層的序列s的拷貝——一個有相同值得序列。

擴展分片：第三個限制值：完整形式的分片變成s[i:j:k]。這表示索引s對象中的元素，從偏移為i直到偏移為j-1，每隔k元素索引一次。第三個限制值k，默認為1。

• s[1:10:2]會取出s中偏移1-9之間，間隔了一個元素的元素，也就是手機偏移值為1、3、5、7、9之處的元素。
• s[::2]會取出序列從頭到尾、每隔一個元素的元素。
• s[::-1]表示步進為-1的分片會從右至左進行。例如:”hello”[::-1]是返回一個新的字符串”olleh“。
• s[5:1:-1]以反轉的順序獲取從2到5的元素（結果是偏移5、4、3、2），例如：’abcdefg’[5:1:-1]的值為‘fdec’

>>> s[1:] #從第二個字符到最后進行分片
'exiaodong'
>>> s
'yexiaodong'
>>> s[0:3] #從第一個字符到第三個字符進行分片
'yex'
>>> s[:-1]#從第一個字符到倒數第二個字符進行分片
'yexiaodon'
>>> s[:] #復制
'yexiaodong'
>>> s + 'xyz' #字符串連接
'yexiaodongxyz'
>>> s
'yexiaodong'
>>> s * 3 #字符串重復
'yexiaodongyexiaodongyexiaodong'

類型的特定方法

除了一般的序列操作，字符串還有獨有的一些操作作為方法存在。例如find方法是一個基本的字符串查找（返回一個傳入子字符串的偏移量，或者沒有找到返回-1），而replace方法將對全局進行搜索和替換。

>>> s = 'yexiaodong'
>>> s
'yexiaodong'
>>> s.find('ao') #找到返回偏移量
4
>>> s.replace('ao','XYZ') #替換為新的字符串
'yexiXYZdong'
>>> s
'yexiaodong'
>>> line = "aaa,bbb,cc,dddd"
>>> line.split(',')  #轉換為列表
['aaa', 'bbb', 'cc', 'dddd']
>>> s = 'yexiaodong'
>>> s.upper() #所有字符大寫
'YEXIAODONG'
>>> s.isalpha() #判斷格式，isalpha,isdigit等
True
>>> line = 'aaa,bbb,cc,dddd\n'
>>> line
'aaa,bbb,cc,dddd\n'
>>> line = line.rstrip() #移除右邊的特殊字符
>>> line
'aaa,bbb,cc,dddd'
>>> '%s,eggs,and %s' % ('apple','banana') #格式化輸出
'apple,eggs,and banana'
>>> '{0},eggs,and {1}'.format('apple','banana')#格式化輸出
'apple,eggs,and banana'

>>> x = 'A\nB\tC' #\n為換行符，\t為tab 字符長度都為1
>>> x
'A\nB\tC'
>>> len(x)
5
>>> ord('a') #a在ASCII中的代碼
97
>>> ord('\n')#\n在ASCII中的代碼
10
>>> x = 'A\0B\0C'  #\0，二進制0
>>> len(x)
5
>>> len('\0')
1
>>> msg = """ aaaaaa
... bbb'''bbbbbbbb""bbbbb'bbbb
... ccccccccccccccccc"""
>>> msg    #多行輸入，可以看到被轉義的字符
' aaaaaa\nbbb\'\'\'bbbbbbbb""bbbbb\'bbbb\n\nccccccccccccccccc'

不可變性

一旦字符串被創建就不能對原始的字符串進行改變。其他核心類型中，數字、元組也是不可變的。

>>> s
'yexiaodong'
>>> s[0] = 'A'    #不能對某一字符進行改變，否則會報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = 'A' + s[1:]   #除非創建新的字符串被引用
>>> s
'Aexiaodong'

字符串轉換

• python不能夠將數字和字符串相加，甚至是看起來像數字的也不可以（如全數字的字符串）
• int函數將字符串格式表達式轉換為數字，而str函數將數字轉換為字符串表達形式，repr函數（3.0+刪除）也可以把數字轉換為字符串。
• str函數可以把浮點數轉換為字符串，同樣float函數也可以把字符串格式表達式轉換為浮點數。
• 字符串代碼轉換：ord函數轉換為單個字符對應的ASCII碼，chr函數將會獲取ASCII碼轉換為字符。

>>> int("42"),str(42)
(42, '42')
>>> s = '42'
>>> i = 1
>>> s + i
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>> int(s) + i
43
>>> s + str(i)
'421'
>>> str(3.1415),float('1.5')
('3.1415', 1.5)
>>> text = "1.2345E-10"
>>> float(text)
1.2345e-10
>>> ord('s')
115
>>> chr(115)
's'
>>> s = '5'
>>> s = chr(ord(s) + 1)
>>> s
'6'
>>> s = chr(ord(s) + 1)
>>> s
'7'
>>> int('5')
5
>>> ord('5') - ord('0')
5
>>> b = '1101'   
>>> i = 0
>>> while b != '':   #將一個二進制數的字符串轉換為等值的整數，即每次將當前值乘以2，並加上下一位數字的整數值。
...     i = i * 2 + (ord(b[0]) - ord('0'))
...     b = b[1:]
>>> i
13
>>> int('1101',2) #二進制轉十進制
13
>>> bin(13) #十進制轉二進制
'0b1101'

修改字符串

由於字符串是不可變，不能再原地修改一個字符串。

• 若要改變一個字符串，需要利用合並，分片這樣的工具來建立並賦值給一個新的字符串，倘若有必要的話，可以將結果賦值給字符串最初的變量名。
• 可以通過像replace函數修改

>>> s = 'spam'
>>> s = s + 'SPAM!'
>>> s
'spamSPAM!'
>>> s = s[:4] + 'Burger' + s[-1]
>>> s
'spamBurger!'
>>> s = 'splot'
>>> s = s.replace('pl','pamal')
>>> s
'spamalot'

字符串方法

除表達式運算符以外，字符串還提供了一系列的方法去實現更復雜的文本處理任務。

python3.0+中的字符串方法

 

方法	描述
s.capitalize()	將字符串的第一個字母變成大寫,其他字母變小寫。
s.center(width[, fillchar])	返回一個原字符串居中,並使用空格填充至長度 width 的新字符串。默認填充字符為空格。width -- 字符串的總寬度，fillchar -- 填充字符。
s.count(sub[, start[, end]])	統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。sub -- 搜索的子字符串，start -- 字符串開始搜索的位置。默認為第一個字符,第一個字符索引值為0，end -- 字符串中結束搜索的位置。字符中第一個字符的索引為 0。默認為字符串的最后一個位置。
s.encode(encoding="utf-8", errors="strict")	返回轉換編碼后的字符串。參數s是要轉換內容的對象；encoding -- 要使用的編碼，如"UTF-8"；errors -- 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。
s.decode(encoding='UTF-8', errors='strict')	以 encoding 指定的編碼格式解碼字符串。默認編碼為字符串編碼。encoding -- 要使用的編碼，如"UTF-8"；errors -- 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError；其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。
s.endswith(suffix[, start[, end]])	判斷字符串是否以指定后綴結尾，如果以指定后綴結尾返回True，否則返回False。可選參數"start"與"end"為檢索字符串的開始與結束位置。suffix -- 該參數可以是一個字符串或者是一個元素。start -- 字符串中的開始位置。end -- 字符中結束位置。
s.expandtabs(tabsize=8)	把字符串中的 tab 符號('\t')轉為空格，tab 符號('\t')默認的空格數是 8。tabsize -- 指定轉換字符串中的 tab 符號('\t')轉為空格的字符數。
s.find(str, beg=0, end=len(s))	檢測字符串中是否包含子字符串str，如果指定beg（開始）和end（結束）范圍，則檢查是否包含在指定范圍內，如果包含子字符串返回開始的索引值，否則返回-1。str -- 指定檢索的字符串，beg -- 開始索引，默認為0，end -- 結束索引，默認為字符串的長度。
s.index(str, beg=0, end=len(s))	檢測字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，該方法與 python find()方法一樣，只不過如果str不在 s中會報一個異常。str -- 指定檢索的字符串。beg -- 開始索引，默認為0。end -- 結束索引，默認為字符串的長度。
s.isalnum()	檢測字符串是否由字母和數字組成。如果s至少有一個字符並且所有字符都是字母或數字則返回 True，否則返回 False。
s.isalpha()	檢測字符串是否只由字母組成。如果字符串至少有一個字符並且所有字符都是字母則返回 True,否則返回 False。
s.isdecimal()	檢查字符串是否只包含十進制字符。這種方法只存在於unicode對象。注意:定義一個十進制字符串，只需要在字符串前添加 'u' 前綴即可。如果字符串是否只包含十進制字符返回True，否則返回False。
s.isdigit()	檢測字符串是否只由數字組成。如果字符串只包含數字則返回 True 否則返回 False。
s.islower()	檢測字符串是否由小寫字母組成。如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False
s.isnumeric()	檢測字符串是否只由數字組成。這種方法是只針對unicode對象。注：定義一個字符串為Unicode，只需要在字符串前添加 'u' 前綴即可。如果字符串中只包含數字字符，則返回 True，否則返回 False。
s.isspace()	檢測字符串是否只由空格組成。如果字符串中只包含空格，則返回 True，否則返回 False。
s.istitle()	檢測字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫。如果字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫則返回 True，否則返回 False.
s.isupper()	檢測字符串中所有的字母是否都為大寫。如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False
s.join(seq)	以 s作為分隔符，將 seq 中所有的元素(的字符串表示)合並為一個新的字符串。
s.ljust(width)	返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串。width -- 指定字符串長度。fillchar -- 填充字符，默認為空格。
s.lower()	返回將字符串中所有大寫字符轉換為小寫后生成的字符串。
s.lstrip([chars])	返回截掉字符串左邊的空格或指定字符后生成的新字符串。chars --指定截取的字符，默認為空格。
string.maketrans(intab, outtab])	創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。注：兩個字符串的長度必須相同，為一一對應的關系。返回字符串轉換后生成的新字符串。通過from string import maketrans調用
max(s)	返回字符串中最大的字母。
min(s)	返回字符串中最小的字母。
s.partition(str)	用來根據指定的分隔符將字符串進行分割。如果字符串包含指定的分隔符，則返回一個3元的元組，第一個為分隔符左邊的子串，第二個為分隔符本身，第三個為分隔符右邊的子串。
s.replace(old, new[, max])	返回字符串中的 old（舊字符串） 替換成 new(新字符串)后生成的新字符串，如果指定第三個參數max，則替換不超過 max 次。old -- 將被替換的子字符串。new -- 新字符串，用於替換old子字符串。max -- 可選字符串, 替換不超過 max 次
s.rfind(str, beg=0,end=len(s) )	返回字符串最后一次出現的位置，如果沒有匹配項則返回-1。str -- 查找的字符串。beg -- 開始查找的位置，默認為0。end -- 結束查找位置，默認為字符串的長度。
s.rindex( str, beg=0,end=len(s))	返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常，你可以指定可選參數[beg:end]設置查找的區間。str -- 查找的字符串。beg -- 開始查找的位置，默認為0。end -- 結束查找位置，默認為字符串的長度。
s.rjust(width[, fillchar])	返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。width -- 指定填充指定字符后中字符串的總長度。fillchar -- 填充的字符，默認為空格。
s.rpartition(str)	類似於 partition()函數，不過是從右邊開始查找。
s.rstrip([chars])	刪除 string 字符串末尾的指定字符（默認為空格）。chars -- 指定刪除的字符（默認為空格）
s.split(str=""[, num])	通過指定分隔符對字符串進行切片，如果參數num 有指定值，則僅分隔 num 個子字符串，返回分割后的字符串列表。str -- 分隔符，默認為空格。num -- 分割次數。
s.splitlines([keepends])	按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。keepends -- 在輸出結果里是否去掉換行符('\r', '\r\n', \n')，默認為 False，不包含換行符，如果為 True，則保留換行符。
s.startswith(str,beg=0,end=len(string))	檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 beg 和 end 指定值，則在指定范圍內檢查。str -- 檢測的字符串。beg -- 可選參數用於設置字符串檢測的起始位置。end -- 可選參數用於設置字符串檢測的結束位置。
s.strip([chars])	返回移除字符串頭尾指定的字符（默認為空格換行等空字符）生成的新字符串。chars -- 移除字符串頭尾指定的字符。
s.swapcase()	返回大小寫字母轉換后生成的新字符串。
s.title()	返回"標題化"的字符串,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle())。
s.translate(table[, deletechars])	根據參數table給出的表(包含 256 個字符)轉換字符串的字符, 要過濾掉的字符放到 del 參數中，返回翻譯后的字符串。。able -- 翻譯表，翻譯表是通過maketrans方法轉換而來。deletechars -- 字符串中要過濾的字符列表。
s.upper()	返回小寫字母轉為大寫字母的字符串。
s.zfill(width)	返回指定長度的字符串，原字符串右對齊，前面填充0。width -- 指定需要返回字符串的長度。原字符串右對齊，前面填充0。

>>> s = 'goodpython'
>>> s.capitalize()
'Goodpython'
>>> s.center(50,'_')
'____________________goodpython____________________'
>>> s.count('o')
3
>>> s.count('o',2)
2
>>> s.count('o',3,9) 
1
>>> x = '你好'
>>> a = x.encode('utf-8','strict')
>>> a.decode('utf-8','strict')
'你好'
>>> s.endswith('on')
True
>>> b = 'hello\tworld!'
>>> b
'hello\tworld!'
>>> b.expandtabs(tabsize=8)
'hello   world!'
>>> b.expandtabs(tabsize=2)
'hello world!'
>>> s
'goodpython'
>>> s.find('py')
4
>>> s.index('py')
4
>>> s.isalnum()
True
>>> s.isalpha()
True
>>> s.isdecimal()
False
>>> x = u'5644'
>>> x.isdecimal()
True
>>> s.isdigit()
False
>>> x.isdigit()
True
>>> s.islower()
True
>>> x.isnumeric()
True
>>> y = b'444'#非Unicode會報錯
>>> y.isnumeric()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'bytes' object has no attribute 'isnumeric'
>>> y.isdigit()
True
>>> str = '-'
>>> seq = ('a','b','c')
>>> str.join(seq)
'a-b-c'
>>> s = 'http://www.cnblogs.com/dodoye/'
>>> s.partition('://')
('http', '://', 'www.cnblogs.com/dodoye/')
>>> str1 = 'ab c\n\nde fg\rkl\r\n'
>>> print(str1.splitlines())
['ab c', '', 'de fg', 'kl']
>>> print(str1.splitlines(True))
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

字符串格式化表達式

Python中的字符串格式化可以以兩種形式實現：

• 字符串格式化表達式：這是從Python誕生的時候就有的最初的技術；基於C語言的”printf“模型，並且在大多數現有的代碼中使用。
• 字符串格式化方法調用：這是2.6+和3.0+新增加的技術，這是Python獨有的方法，並且和字符串格式化表達式的功能有很大重疊。

格式化字符串：

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

>>> 'That is %d %s bird!' % (1,'dead')
'That is 1 dead bird!'
>>> x = 'Ni'
>>> "The knights whow say %s!" % x
'The knights whow say Ni!'
>>> "%d %s %d you" % (1,'spam',4)
'1 spam 4 you'
>>> "%s---%s----%s"  % (42,3.14159,[1,2,3])
'42---3.14159----[1, 2, 3]'

字符串格式化代碼：

代碼	意義
s	字符串（或任何對象）
r	s,但使用repr，而不是str
c	字符
d	十進制（整數）
i	整數
u	無號（整數）
o	八進制整數
x	十六進制整數
X	十六進制整數，但打印大寫
e	浮點指數
E	浮點指數，但打印大寫
f	浮點十進制
F	浮點十進制
g	浮點e或f
G	浮點E或F
%	常量%

事實上，在格式化字符串中，表達式左側的轉換目標支持多種轉換操作，這些操作自有一套相當嚴謹的語法。通用結構看上去如下：

%[(name)][flags][width][.percision]typecode

在%和字符碼之間，你可以進行以下的任何操作：放置一個字典的鍵；羅列出左對齊（-）、正負號（+）和補零（0）的標志位，給出數字的整體長度和小數點后的位數等。width和percision都可以編碼為一個*，以指定它們應該從輸入值的下一項中取值。

>>> x = 1234
>>> res = "integers:...%d...%-10d...%06d" %(x,x,x)
>>> res
'integers:...1234...1234      ...001234'

%e,%f,%g格式對浮點數的標示方法有所不同。

>>> x = 1.23456789
>>> x
1.23456789
>>> '%e | %f | %g' %(x,x,x)
'1.234568e+00 | 1.234568 | 1.23457'
>>> '%E' % x
'1.234568E+00'

對於浮點數來講，通過指定左對齊、補零、正負號、數字位數和小數點后的位數，可以得到各種各樣的格式化結果。

>>> '%-6.2f | %05.2f | %+06.1f' % (x,x,x)
'1.23   | 01.23 | +001.2'
>>> "%s" % x,str(x)
('1.23456789', '1.23456789')

基於字典的字符串格式化

字符串的個數化同時也允許左邊的轉換目標來引用右邊字典中的鍵來提取對應的值。

>>> "%(n)d %(x)s" % {"n":1,"x":"spam"}
'1 spam'

其中（n）和（x）引用了右邊字典中的鍵，並提取它們相應的值。生成類似HTML和XML的程序往往會利用這一技術。

>>> reply = """
... Greeting ...
... Hello %(name)s!
... Your age squared is %(age)s
... """
>>> values = {'name':'bob','age':40}
>>> print(reply % values)

Greeting ...
Hello bob!
Your age squared is 40

內置函數vars配合使用，這個函數返回的字典包含了所有在本函數電泳時存在的變量：

>>> food = 'spam'
>>> age = 40
>>> vars()
{'__builtins__': <module 'builtins' (built-in)>, 'food': 'spam', '__doc__': None
, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_imp
ortlib.BuiltinImporter'>, 'values': {'age': 40, 'name': 'bob'}, 'age': 40, 'x':
1.23456789, '__spec__': None, 'reply': '\nGreeting ...\nHello %(name)s!\nYour ag
e squared is %(age)s\n'}
>>> values
{'age': 40, 'name': 'bob'}
>>> "%(age)d %(food)s" % vars()
'40 spam'

字符串格式化調用方法

和格式化表達式不同，格式化方法調用不是緊密地基於C語言的”printf“模型，並且它們的意圖更詳細而明確。字符串對象的format方法使用主體字符串作為模板，並且接受任意多個表示將要根據模板替換的值得參數。在主體字符串中，花括號通過位置（如：{1}或關鍵字{food}）指出替換目標及將要插入的參數。

>>> template = '{0},{1} and {2}'
>>> template.format('spam','ham','eggs')
'spam,ham and eggs'
>>> template = '{motto},{pork},{food}'
>>> template.format(motto='spam',pork='ham',food='eggs')
'spam,ham,eggs'
>>> template = '{motto},{0},{food}'
>>> template.format('ham',motto='spam',food='eggs')
'spam,ham,eggs'
>>> '{motto},{0},{food}'.format(42,motto=3.14159,food=[1,2]) #可以臨時創建，並且任意對象類型都可以替換
'3.14159,42,[1, 2]'

添加鍵、屬性和偏移量

像%格式化表達式一樣，格式化調用可以變得更復雜以支持更多高級用途。例如，格式化字符串可以指定對象屬性和字典鍵——就像在常規的Python語法中一樣，方括號指定字典鍵，而點表示位置或關鍵字所引用的一項的對象屬性。

>>> import sys
>>> 'My {1[spam]} runs {0.platform}'.format(sys,{'spam':'laptop'})
'My laptop runs win32'
>>> 'My {config[spam]} runs {sys.platform}'.format(sys=sys,config={'spam':'lapto
p'})
'My laptop runs win32'
>>> somelist = list('SPAM')
>>> somelist
['S', 'P', 'A', 'M']
>>> 'first={0[0]},third={0[2]}'.format(somelist)
'first=S,third=A'
>>> 'first={0},third={0}'.format(somelist[0],somelist[-1])
'first=S,third=S'
>>> parts = somelist[0],somelist[-1],somelist[1:3]
>>> 'first={0},last={1},,middle={2}'.format(*parts)
"first=S,last=M,,middle=['P', 'A']"

添加具體格式化

可以在格式化字符串中添加額外的語法來實現更具體的層級。對於格式方法，我們在替換目標的標識之后使用一個冒號，后面跟着可以指定字段大小、對齊方式和一個特定類型編碼的格式化聲明。其形式結構：

{fieldname|coversionflag:formatspec}

語法是：

• fieldname是指定參數的一個數字或關鍵字，后面跟着可選的”.name“或”[index]“成分引用。
• Coversionflag可以r、s，或者a分別是在該值上對repr、str或ascii內置函數的一次調用。
• formatspec指定了如何表示該值，包括字段寬度、對齊方式、補零、小數點精度等細節，並且以一個可選的數據類型編碼結束。

冒號后的formatspec組成形式上的描述如下（方括號表示可選的組成，並且不能編寫為常量）：

[[fill]align][sign][#][0][width][.precision][typecode]

align可能是<、>、=、或^，分別表示左對齊、右對齊、一個標記字符后的補充或居中對齊。Formatspec也包含嵌套的，只帶有{}的格式化字符串，它從參數列表動態地獲取值（和格式化表達式中的*很相似）。

可用的類型編碼列表，它們幾乎與前面李處的以及%表達式中使用的那些完全重合，但是格式化方法還允許一個”b“類型編碼用來以二進制格式顯示整數（它等同於使用bin內置函數），允許一個”%“類型編碼來顯示百分比，並且使用唯一的”d“表示十進制的整數（而不是”i“或”u“）。

例如：{0：10}意味着一個10字符寬的字段中的第一個位置參數，{1：<10}意味着第二個位置參數在一個10字符寬度字段中左對齊，{0.platform：>10}意味着第一個參數的platform屬性在10字符寬度的字段中右對齊：

>>> '{0:10} = {1:10}'.format('spam',123.4567)
'spam       =   123.4567'
>>> '{0:10}={1:10}'.format('spam',123.4567)
'spam      =  123.4567'
>>> '{0:>10}={1:<10}'.format('spam',123.4567)
'      spam=123.4567  '
>>> '{0.platform:>10}={1[item]:<10}'.format(sys,dict(item='laptop'))
'     win32=laptop    '
>>> '{0:e},{1:.3e},{2:g}'.format(3.14159,3.14159,3.14159)#格式化浮點數
'3.141590e+00,3.142e+00,3.14159'
>>> '{0:f},{1:.2f},{2:06.2f}'.format(3.14159,3.14159,3.14159)
'3.141590,3.14,003.14'
>>> '{0:X},{1:o},{2:b}'.format(255,255,255)#格式化二進制、八進制、十六進制
'FF,377,11111111'
>>> bin(255),int('11111111',2),0b11111111
('0b11111111', 255, 255)
>>> hex(255),int('FF',16),0xFF
('0xff', 255, 255)
>>> oct(255),int('377',8),0o377
('0o377', 255, 255)
#硬編碼格式化字符串
>>> '{0:.2f}'.format(1/3.0)#默認顯示多少位
'0.33''
>>> '%.2f' % (1/3.0)
'0.33'
>>> '{0:.{1}f}'.format(1/3.0,4) #硬編碼顯示4位
'0.3333'
>>> '%.*f' % (4,1/3.0)
'0.3333'

python還提供了一種新的內置format函數，它可以用來格式化一個單獨的項。他是字符串格式化方法的一種更簡潔的替代方法。

>>> '{0:.2f}'.format(1.2345)
'1.23'
>>> format(1.2345,'.2f')
'1.23'
>>> '%.2f' % 1.2345
'1.23'

從技術上講，內置函數format運行主體對象的__format__方法，對於每個被格式化項目，str.format方法都是內部的。它仍然比最初的%表達式的對等體要冗長。

注意：字符串格式化方法擴展：添加針對數字的千分隔位法，它在3位一組之間插入逗號。

>>> '{0:d}'.format(999999999)
'999999999'
>>> '{0:,d}'.format(999999999)
'999,999,999'
>>> '{:,d} {:,d}'.format(999999999,8888888888)
'999,999,999 8,888,888,888'
>>> '{0:,.2f}'.format(99999.25646)
'99,999.26'

盡管格式化方法有時候需要更多的代碼，它還是：

• 擁有%表達式所沒有的一些額外功能
• 可以更明確地進行替代之引用
• 考慮到操作符會有一個更容易記憶的方法名
• 不支持用於單個和多個替代值大小寫的不同語法

>>> '{0:b}'.format((2**16)-1)
'1111111111111111'
>>> '%b' % ((2*816) - 1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: unsupported format character 'b' (0x62) at index 1
>>> bin((2**16) - 1)
'0b1111111111111111'
>>> '%s' % bin((2**16) - 1)[2:]
'1111111111111111'

 

可變類型能夠在原處修改

如果一個對象是不可變的，你就不能再原處修改它的值，否則Python會報錯。替代的辦法就是，你必須運行代碼來創建一個新的對象來包含這個新的值。Python中主要核心類型划分為如下兩類：

• 不可變類型（數字、字符串、元組、不可變集合）：不可變的分類沒有哪個對象類型支持原處修改，盡管我們總是可以運行表達式來創建新的對象並將其結果分配給變量。
• 可變類型（列表、字典、可變集合）：可變集合總是可以通過操作原處修改，而不是創建新的對象。盡管這樣的對象可以復制，但原處修改支持直接修改。

一般來說，不可變類型有某種完整性，保證這個對象不會被程序的其他部分改變。