python字符串、字符串處理函數及字符串相關操作

阿新 • • 發佈：2018-09-01

pep hat 導入模塊 ssi 字符串分割分組 pre 實用 big

python字符串、字符串處理函數及字符串相關操作

字符串介紹

python字符串表示

Python除處理數字外還可以處理字符串，字符串用單撇號或雙撇號包裹：

>>> ‘spam eggs‘
‘spam eggs‘
>>> ‘doesn/‘t‘
"doesn‘t"
>>> "doesn‘t"
"doesn‘t"
>>> ‘"Yes," he said.‘
‘"Yes," he said.‘
>>> "/"Yes,/" he said."
‘"Yes," he said.‘
>>> ‘"Isn/‘t," she said.‘
‘"Isn/‘t," she said.‘

字符串輸出格式與輸入的樣子相同，都是用撇號包裹，撇號和其它特殊字符用用反斜杠轉義。如果字符串中有單撇號而沒有雙撇號則用雙撇號包裹，否則應該用單撇號包裹。後面要介紹的print語句可以不帶撇號或轉義輸出字符串。

多行的長字符串也可以用行尾反斜杠續行，續行的行首空白不被忽略，如

        hello = "This is a rather long string containing/n        several lines of text just as you would do in C./n            Note that whitespace at the beginning of the line is         significant./n"
        print hello

結果為　

        This is a rather long string containing
        several lines of text just as you would do in C.
            Note that whitespace at the beginning of the line is significant.

對於特別長的字符串（比如包含說明的幾段文字），如果用上面的方式每行都用/n/結尾是很麻煩的，特別是這樣無法用象Emacs這樣的功能強大的編輯器重新編排。對這種情況，可以使用三重撇號，例如

        hello = """
　
            This string is bounded by triple double quotes (3 times ").
        Unescaped newlines in the string are retained, though         it is still possible/nto use all normal escape sequences.
　
            Whitespace at the beginning of a line is
        significant.  If you need to include three opening quotes
        you have to escape at least one of them, e.g. /""".
　
            This string ends in a newline.
        """

三重撇號字符串也可以用三個單撇號，沒有任何語義差別。

多行的字符串常量可以直接連接起來，字符串常量之間用空格分隔則在編譯時可以自動連接起來，這樣可以把一個長字符串連接起來而不需要犧牲縮進對齊或性能，不象用加號連接需要運算，也不象字符串串內的換行其行首空格需要保持。

字符串連接和重復

　字符串可以用+號連接起來，用*號重復：

>>> word = ‘Help‘ + ‘A‘
>>> word
‘HelpA‘
>>> ‘<‘ + word*5 + ‘>‘
‘<HelpAHelpAHelpAHelpAHelpA>‘

字符串連接的幾種不同方式

def concat1(): 
    z = x + y 
    return z 

 def concat2(): 
    z = "%s%s" % (x, y) 
    return z 

def concat3(): 
    z = "{}{}".format(x, y) 
    return z 

def concat4(): 
    z = "{0}{1}".format(x, y) 
    return z

[Python中實現快速字符串連接]

字符串索引

字符串可以象在C中那樣用下標索引，字符串的第一個字符下標為0。

Python沒有單獨的字符數據類型，一個字符就是長度為一的字符串。象在Icon語言中那樣，可以用片段(slice)記號來指定子串，片段即用冒號隔開的兩個下標。

>>> word[4]
‘A‘
>>> word[0:2]
‘He‘
>>> word[2:4]
‘lp‘

片段有很好的缺省值：第一下標省略時缺省為零，第二下標省略時缺省為字符串的長度。

>>> word[:2]    # 前兩個字符
‘He‘
>>> word[2:]    # 除前兩個字符串外的部分
‘lpA‘

註意s[:i] + s[i:] 等於 s 是片段運算的一個有用的恒等式。

>>> word[:2] + word[2:]
‘HelpA‘
>>> word[:3] + word[3:]
‘HelpA‘

不合理的片段下標可以很好地得到解釋：過大的下標被換成字符串長度，上界小於下界時返回空串。

>>> word[1:100]
‘elpA‘
>>> word[10:]
‘‘
>>> word[2:1]
‘‘

下標允許為負數，這時從右向左數。例如：

>>> word[-1]     # 最後一個字符
‘A‘
>>> word[-2]     # 倒數第二個字符
‘p‘
>>> word[-2:]    # 最後兩個字符
‘pA‘
>>> word[:-2]    # 除最後兩個字符外的部分
‘Hel‘
但要註意的是 -0 實際還是 0，所以它不會從右向左數！

>>> word[-0]     # (因為 -0 等於 0)
‘H‘

超出範圍的片段下標被截斷，但在非片段的情況下不要這樣：

>>> word[-100:]
‘HelpA‘
>>> word[-10]    # 錯誤
Traceback (innermost last):
  File "<stdin>", line 1
IndexError: string index out of range

記住片段意義的最好方法是把下標看成是字符之間的點，第一個字符的左邊界號碼為0。有n個字符的字符串的最後一個字符的右邊界下標為n，例如：

 +---+---+---+---+---+ 
 | H | e | l | p | A |
 +---+---+---+---+---+ 
 0   1   2   3   4   5 
-5  -4  -3  -2  -1
第一行數字給出字符串中下標0到5的位置，第二行給出相應的負下標。從i到j的片段由在邊界i和j之間的字符組成。

對於非負下標，如果下標都在界內，則片段的長度為下標的差。例如，word[1:3] 的長度為 2。

字符串的分片

定義一個字符串以後，我們可以截取其中的任意部分形成新串。這種操作被稱作字符串的分片(slice)。字符串分片跟列表的分片(slicing lists)原理是一樣的，從直觀上也說得通，因為字符串本身就是一些字符序列。

>>> a_string = "My alphabet starts where your alphabet ends."
>>> a_string[3:11]
"alphabet"
>>> a_string[3:-3]
"alphabet starts where your alphabet en"
>>> a_string[0:2]
"My"
>>> a_string[:18]
"My alphabet starts"
>>> a_string[18:]
" where your alphabet ends."

我們可以通過指定兩個索引值來獲得原字符串的一個slice。該操作的返回值是一個新串，依次包含了從原串中第一個索引位置開始，直到但是不包含第二個索引位置之間的所有字符。
就像給列表做分片一樣，我們也可以使用負的索引值來分片字符串。
字符串的下標索引是從0開始的，所以a_string[0:2]會返回原字符串的前兩個元素，從a_string[0]開始，直到但不包括a_string[2]。
如果省略了第一個索引值，Python會默認它的值為0。所以a_string[:18]跟a_string[0:18]的效果是一樣的，因為從0開始是被Python默認的。
同樣地，如果第2個索引值是原字符串的長度，那麽我們也可以省略它。所以，在此處a_string[18:]跟a_string[18:44]的結果是一樣的，因為這個串的剛好有44個字符。這種規則存在某種有趣的對稱性。在這個由44個字符組成的串中，a_string[:18]會返回前18個字符，而a_string[18:]則會返回除了前18個字符以外字符串的剩余部分。事實上a_string[:n]總是會返回串的前n個字符，而a_string[n:]則會返回其余的部分，這與串的長度無關。

字符串長度

　內置函數len()返回字符串的長度：

>>> s = ‘supercalifragilisticexpialidocious‘
>>> len(s)
34

皮皮Blog

Python內置的字符串處理函數

python字符串子串

python沒有substring函數，因為直接使用str[start:end]就可以啦。

字母處理

全部大寫：str.upper()
全部小寫：str.lower()
大小寫互換：str.swapcase()
首字母大寫，其余小寫：str.capitalize()
首字母大寫：str.title()
print ‘%s lower=%s‘ % (str,str.lower())
print ‘%s upper=%s‘ % (str,str.upper())
print ‘%s swapcase=%s‘ % (str,str.swapcase())
print ‘%s capitalize=%s‘ % (str,str.capitalize())
print ‘%s title=%s‘ % (str,str.title())

格式化相關

獲取固定長度，右對齊，左邊不夠用空格補齊：str.ljust(width)
獲取固定長度，左對齊，右邊不夠用空格補齊：str.ljust(width)
獲取固定長度，中間對齊，兩邊不夠用空格補齊：str.ljust(width)
獲取固定長度，右對齊，左邊不足用0補齊
print ‘%s ljust=%s‘ % (str,str.ljust(20))
print ‘%s rjust=%s‘ % (str,str.rjust(20))
print ‘%s center=%s‘ % (str,str.center(20))
print ‘%s zfill=%s‘ % (str,str.zfill(20))

字符串搜索相關

搜索指定字符串，沒有返回-1：str.find(‘t‘)

python字符串查找指定多個子字符串的所有位置：

a = "dhvka,feovj.dlfida?dfka.dlviaj,dlvjaoid,vjaoj?"
b = [i for i, j in enumerate(a) if j in [‘,‘, ‘.‘, ‘?‘]]
print(b)

[5, 11, 18, 23, 30, 39, 45]

指定起始位置搜索：str.find(‘t‘,start)
指定起始及結束位置搜索：str.find(‘t‘,start,end)
從右邊開始查找：str.rfind(‘t‘)
搜索到多少個指定字符串：str.count(‘t‘)
上面所有方法都可用index代替，不同的是使用index查找不到會拋異常，而find返回-1
print ‘%s find nono=%d‘ % (str,str.find(‘nono‘))
print ‘%s find t=%d‘ % (str,str.find(‘t‘))
print ‘%s find t from %d=%d‘ % (str,1,str.find(‘t‘,1))
print ‘%s find t from %d to %d=%d‘ % (str,1,2,str.find(‘t‘,1,2))
#print ‘%s index nono ‘ % (str,str.index(‘nono‘,1,2))
print ‘%s rfind t=%d‘ % (str,str.rfind(‘t‘))

print ‘%s count t=%d‘ % (str,str.count(‘t‘))

python判斷字符串是否包含子串的方法

1. if ‘abcde‘.__contains__("abc")

2. if "abc" in ‘abcde‘

3.‘abcde‘.find(‘bcd‘) >= 0

4.‘abcde‘.count(‘bcd‘) > 0

5.try:
string.index(ls,ss)
print ‘find it‘
except(ValueError):
print ‘fail‘

[http://blog.csdn.net/elvis_kwok/article/details/7405083]

[Python字符串操作]

字符串替換相關

替換old為new：str.replace(‘old‘,‘new‘)
替換指定次數的old為new：str.replace(‘old‘,‘new‘,maxReplaceTimes)
print ‘%s replace t to *=%s‘ % (str,str.replace(‘t‘, ‘*‘))

print ‘%s replace t to *=%s‘ % (str,str.replace(‘t‘, ‘*‘,1))

字符串一次替換多個不同字符

將字符串中的[ ] ‘替換成空格

methon1: tags = re.sub("

|

|‘", "", str(music_tag[music_name]))

methon3: [一次完成多個字符串的替換]

字符串去空格及去指定字符

去兩邊空格：str.strip()
去左空格：str.lstrip()
去右空格：str.rstrip()

去兩邊字符串（支持正則）：s.strip(‘{|}‘)

按指定字符分割字符串為數組：str.split(‘ ‘)
默認按空格分隔
指定分隔符str,str.split(‘-‘)

字符串判斷相關

是否以start開頭：str.startswith(‘start‘)
是否以end結尾：str.endswith(‘end‘)
是否全為字母或數字：str.isalnum()
是否全字母：str.isalpha()
是否全數字：str.isdigit()
是否全小寫：str.islower()
是否全大寫：str.isupper()

str=‘python String function‘

[Python內置的字符串處理函數整理]

皮皮Blog

字符串相關操作

repr(反引號)操作

在Python 2裏，為了得到一個任意對象的字符串表示，有一種把對象包裝在反引號裏(比如`x`)的特殊語法。在Python 3裏，這種能力仍然存在，但是你不能再使用反引號獲得這種字符串表示了。你需要使用全局函數repr()。

Notes	Python 2	Python 3
①	`x`	repr(x)
②	`‘PapayaWhip‘ + `2``	repr(‘PapayaWhip‘+ repr(2))

記住，x可以是任何東西 — 一個類，函數，模塊，基本數據類型，等等。repr()函數可以使用任何類型的參數。
在Python 2裏，反引號可以嵌套，導致了這種令人費解的(但是有效的)表達式。2to3足夠智能以將這種嵌套調用轉換到repr()函數。

字符串分割

使用多個界定符分割字符串

解決方案1：【http://python3-cookbook.readthedocs.org/zh_CN/latest/c02/p01_split_string_on_multiple_delimiters.html】

string對象的 split() 方法只適應於非常簡單的字符串分割情形，它並不允許有多個分隔符或者是分隔符周圍不確定的空格。當你需要更加靈活的切割字符串的時候，最好使用re.split() 方法：

>>> line = ‘asdf fjdk; afed, fjek,asdf, foo‘
>>> import re
>>> re.split(r‘[;,\s]\s*‘, line)
[‘asdf‘, ‘fjdk‘, ‘afed‘, ‘fjek‘, ‘asdf‘, ‘foo‘]

解決方案2：

s = ‘Hello!This?Is!What?I!Want‘
for i in (‘!‘, ‘?‘):
    s = s.replace(i,‘ ‘)

list1 = s.split()

解決方案3：

def my_split(s, seps): res = [s] for sep in seps: s, res = res, [] for seq in s: res += seq.split(sep) return res

my_split(s, [‘!‘, ‘?‘])

格式化字符串

自python2.6開始，新增了一種格式化字符串的函數str.format()，可謂威力十足。跟之前的%型格式化字符串相比是優越的存在。

語法

它通過{}和:來代替%。

“映射”示例

通過位置

In [1]: ‘{0},{1}‘.format(‘kzc‘,18)  
Out[1]: ‘kzc,18‘  
In [2]: ‘{},{}‘.format(‘kzc‘,18)  
Out[2]: ‘kzc,18‘  
In [3]: ‘{1},{0},{1}‘.format(‘kzc‘,18)  
Out[3]: ‘18,kzc,18‘

字符串的format函數可以接受不限個參數，位置可以不按順序，可以不用或者用多次，不過2.6不能為空{}，2.7才可以。
通過關鍵字參數

In [5]: ‘{name},{age}‘.format(age=18,name=‘kzc‘)  
Out[5]: ‘kzc,18‘

通過對象屬性

class Person:  
    def __init__(self,name,age):  
        self.name,self.age = name,age  
        def __str__(self):  
            return ‘This guy is {self.name},is {self.age} old‘.format(self=self)

In [2]: str(Person(‘kzc‘,18))  
Out[2]: ‘This guy is kzc,is 18 old‘

通過下標

In [7]: p=[‘kzc‘,18]
In [8]: ‘{0[0]},{0[1]}‘.format(p)
Out[8]: ‘kzc,18‘

有了這些便捷的“映射”方式，我們就有了偷懶利器。基本的python知識告訴我們，list和tuple可以通過“打散”成普通參數給函數，而dict可以打散成關鍵字參數給函數（通過和*）。所以可以輕松的傳個list/tuple/dict給format函數。非常靈活。

格式限定符

它有著豐富的的“格式限定符”（語法是{}中帶:號），比如：

填充與對齊
填充常跟對齊一起使用
^、<、>分別是居中、左對齊、右對齊，後面帶寬度；:號後面帶填充的字符，只能是一個字符，不指定的話默認是用空格填充。
比如

In [15]: ‘{:>8}‘.format(‘189‘)
Out[15]: ‘     189‘
In [16]: ‘{:0>8}‘.format(‘189‘)
Out[16]: ‘00000189‘
In [17]: ‘{:a>8}‘.format(‘189‘)
Out[17]: ‘aaaaa189‘
print(‘{:*^60}‘.format(‘ 每個TERMINALNO 數據記錄數 ‘)) 
******************** 每個TERMINALNO 數據記錄數 ******************** （中文字符居然只算1個字符，所以有中文字符時候輸出不同行還是對不齊）

Note: 如果是使用{：>20}格式化列表，要先將列表轉化成str()，否則報錯TypeError: unsupported format string passed to list.__format__．

精度與類型f
精度常跟類型f一起使用

In [44]: ‘{:.2f}‘.format(321.33345)
Out[44]: ‘321.33‘

其中.2表示長度為2的精度，f表示float類型。

其他類型
主要就是進制了，b、d、o、x分別是二進制、十進制、八進制、十六進制。

In [54]: ‘{:b}‘.format(17)
Out[54]: ‘10001‘
In [55]: ‘{:d}‘.format(17)
Out[55]: ‘17‘
In [56]: ‘{:o}‘.format(17)
Out[56]: ‘21‘
In [57]: ‘{:x}‘.format(17)
Out[57]: ‘11‘

設置二進制輸出位寬：32位輸出，前面不足的補0。

print(‘{:032b}‘.format(i)) # bin(i)

用，號還能用來做金額的千位分隔符。

In [47]: ‘{:,}‘.format(1234567890)
Out[47]: ‘1,234,567,890‘

【http://blog.csdn.net/handsomekang/article/details/9183303】

【String的Format格式規約函數及實例】

格式化字符串

字符串可以使用單引號或者雙引號來定義。

我們再來看一看humansize.py：

SUFFIXES = {1000: ["KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"], 1024: ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]}def approximate_size(size, a_kilobyte_is_1024_bytes=True): """Convert a file size to human-readable form. Keyword arguments: size -- file size in bytes a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024 if False, use multiples of 1000 Returns: string """ if size < 0: raise ValueError("number must be non-negative") multiple = 1024 if a_kilobyte_is_1024_bytes else 1000 for suffix in SUFFIXES[multiple]: size /= multiple if size < multiple: return "{0:.1f} {1}".format(size, suffix) raise ValueError("number too large")

"KB", "MB", "GB"… 這些是字符串。
函數的文檔字符串(docstring)也是字符串。當前的文檔字符串占用了多行，所以它使用了相鄰的3個引號來標記字符串的起始和終止。
這3個引號代表該文檔字符串的終止。
這是另外一個字符串，作為一個可讀的提示信息傳遞給異常。
瓦哦…那是什麽？

Python 3支持把值格式化(format)成字符串。可以有非常復雜的表達式，最基本的用法是使用單個占位符(placeholder)將一個值插入字符串。

>>> username = "mark"
>>> password = "PapayaWhip"
>>> "{0}"s password is {1}".format(username, password)
"mark"s password is PapayaWhip"

不，PapayaWhip真的不是我的密碼。
這裏包含了很多知識。首先，這裏使用了一個字符串字面值的方法調用。字符串也是對象，對象則有其方法。其次，整個表達式返回一個字符串。最後，{0}和{1}叫做替換字段(replacement field)，他們會被傳遞給format()方法的參數替換。

復合字段名

在前一個例子中，替換字段只是簡單的整數，這是最簡單的用法。整型替換字段被當做傳給format()方法的參數列表的位置索引。即，{0}會被第一個參數替換（在此例中即username），{1}被第二個參數替換（password），&c。可以有跟參數一樣多的替換字段，同時你也可以使用任意多個參數來調用format()。但是替換字段遠比這個強大。

>>> import humansize
>>> si_suffixes = humansize.SUFFIXES[1000]
>>> si_suffixes
["KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
>>> "1000{0[0]} = 1{0[1]}".format(si_suffixes)
"1000KB = 1MB"

不需要調用humansize模塊定義的任何函數我們就可以抓取到其所定義的數據結構：國際單位制(SI, 來自法語Système International)的後綴列表（以1000為進制）。
這一句看上去有些復雜，其實不是這樣的。{0}代表傳遞給format()方法的第一個參數，即si_suffixes。註意si_suffixes是一個列表。所以{0[0]}指代si_suffixes的第一個元素，即"KB"。同時，{0[1]}指代該列表的第二個元素，即："MB"。大括號以外的內容 -- 包括1000，等號，還有空格等 -- 則按原樣輸出。語句最後返回字符串為"1000KB = 1MB"。

{0}會被format()的第1個參數替換，{1}則被其第2個參數替換。

這個例子說明格式說明符可以通過利用（類似）Python的語法訪問到對象的元素或屬性。這就叫做復合字段名(compound field names)。以下復合字段名都是有效的。

使用列表作為參數，並且通過下標索引來訪問其元素（跟上一例類似）
使用字典作為參數，並且通過鍵來訪問其值
使用模塊作為參數，並且通過名字來訪問其變量及函數
使用類的實例作為參數，並且通過名字來訪問其方法和屬性
以上方法的任意組合

為了使你確信的確如此，下面這個樣例就組合使用了上面所有方法：

>>> import humansize
>>> import sys
>>> "1MB = 1000{0.modules[humansize].SUFFIXES[1000][0]}".format(sys)
"1MB = 1000KB"

下面是描述它如何工作的：

sys模塊保存了當前正在運行的Python實例的信息。由於已經導入了這個模塊，因此可以將其作為format()方法的參數。所以替換域{0}指代sys模塊。
sys.modules is a dictionary of all the modules that have been imported in this Python instance. The keys are the module names as strings; the values are the module objects themselves. So the replacement field{0.modules} refers to the dictionary of imported modules.sys.modules是一個保存當前Python實例中所有已經導入模塊的字典。模塊的名字作為字典的鍵；模塊自身則是鍵所對應的值。所以{0.modules}指代保存當前己被導入模塊的字典。
sys.modules["humansize"]即剛才導入的humansize模塊。所以替換域{0.modules[humansize]}指代humansize模塊。請註意以上兩句在語法上輕微的不同。在實際的Python代碼中，字典sys.modules的鍵是字符串類型的；為了引用它們，我們需要在模塊名周圍放上引號（比如"humansize"）。但是在使用替換域的時候，我們在省略了字典的鍵名周圍的引號（比如humansize）。在此，我們引用PEP 3101：字符串格式化高級用法，解析鍵名的規則非常簡單。如果名字以數字開頭，則它被當作數字使用，其他情況則被認為是字符串。
sys.modules["humansize"].SUFFIXES是在humansize模塊的開頭定義的一個字典對象。{0.modules[humansize].SUFFIXES}即指向該字典。
sys.modules["humansize"].SUFFIXES[1000]是一個SI（國際單位制）後綴列表：["KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]。所以替換域{0.modules[humansize].SUFFIXES[1000]}指向該列表。
sys.modules["humansize"].SUFFIXES[1000][0]即SI後綴列表的第一個元素："KB"。因此，整個替換域{0.modules[humansize].SUFFIXES[1000][0]}最後都被兩個字符KB替換。

格式說明符

但是，還有一些問題我們沒有講到！再來看一看humansize.py中那一行奇怪的代碼：

if size < multiple: return "{0:.1f} {1}".format(size, suffix)

{1}會被傳遞給format()方法的第二個參數替換，即suffix。但是{0:.1f}是什麽意思呢？它其實包含了兩方面的內容：{0}你已經能理解，:.1f則不一定了。第二部分（包括冒號及其後邊的部分）即格式說明符(format specifier)，它進一步定義了被替換的變量應該如何被格式化。

格式說明符的允許你使用各種各種實用的方法來修飾被替換的文本，就像C語言中的printf()函數一樣。我們可以添加使用零填充(zero-padding)，襯距(space-padding)，對齊字符串(align strings)，控制10進制數輸出精度，甚至將數字轉換成16進制數輸出。

在替換域中，冒號(:)標示格式說明符的開始。.1的意思是四舍五入到保留一們小數點。f的意思是定點數（與指數標記法或者其他10進制數表示方法相對應）。因此，如果給定size為698.24，suffix為"GB"，那麽格式化後的字符串將是"698.2 GB"，因為698.24被四舍五入到一位小數表示，然後後綴"GB"再被追加到這個串最後。

>>> "{0:.1f} {1}".format(698.24, "GB")
"698.2 GB"

想了解格式說明符的復雜細節，請參閱Python官方文檔關於格式化規範的迷你語言。

python判斷字符串是否由純數字組成

import re

def IsFloatStr(s):
    ‘‘‘
    浮點數判斷
    ‘‘‘
    try:
        float(s)
        # s.isdigit()  # 這個是錯的，不能判斷
        # 正則表達式實現
        # return True if re.match(r‘[-+]*\d+?\.{0,1}\d*$‘, s) else False
        return True
    except:
        return Falsedef IsIntStr(s):
    ‘‘‘
    整數判斷
    ‘‘‘
    try:
        int(s)
        # s.isdigit()#這個是錯的，不能判斷
        # return True if re.match(r‘[-+]*\d+$‘, s) else False
        return True
    except:
        return False
for s in [‘123‘, ‘-123‘, ‘+123‘, ‘-12.3‘, ‘-1.2.3‘, ‘123hello‘]:
    print(‘s is a num str‘ if IsFloatStr(s) else ‘s is not a num str‘)
    print(‘s is a num str‘ if IsIntStr(s) else ‘s is not a num str‘)

python刪除字符串中空白字符：換行、空格、制表符

print(‘ ‘.join("Please \n don‘t \t hurt me.".split()))
輸出：
Please don‘t hurt me.

Python字符串逐字符或逐詞反轉方法

把字符串逐字符或逐詞反轉 1. revchars=astring[::-1]

x=‘abcd‘
In [66]: x[::-1]
Out[66]: ‘dcba‘

2. 采用reversed()，註意它返回的是一個叠代器，可以用於循環或傳遞給其它的“累加器”，不是一個已完成的字符串。 revchars=‘‘.join(reversed(astring))

y=reversed(x)
In [57]: y
Out[57]: <reversed object at 0x058302F0>
In [58]: ‘‘.join(y)
Out[58]: ‘dcba‘

逐詞反轉
1. 創建一個列表，將列表反轉，用join方法合並

s=‘Today is really a good day‘

rev=‘ ‘.join(s.split()[::-1])

2. 可以不改變原先的空格，采用正則式來做

revwords=‘ ‘.join(reversed(s.split()))
revwords=‘‘.join(reversed(re.split(r‘(\s+)‘,s)))

[Python字符串逐字符或逐詞反轉方法]

其他常用字符串技巧

除了格式化，關於字符串還有許多其他實用的使用技巧。

>>> s = """Finished files are the re-... sult of years of scientif-... ic study combined with the... experience of years.""">>> s.splitlines()["Finished files are the re-", "sult of years of scientif-", "ic study combined with the", "experience of years."]>>> print(s.lower())finished files are the re-sult of years of scientif-ic study combined with theexperience of years.>>> s.lower().count("f")6

我們可以在Python的交互式shell裏輸入多行(multiline)字符串。一旦我們以三個引號標記多行字符串的開始，按ENTER鍵，Python shell會提示你繼續這個字符串的輸入。連續輸入三個結束引號以終止該字符串的輸入，再敲ENTER鍵則會執行該條命令（在當前例子中，把這個字符串賦給變量s）。
splitlines()方法以多行字符串作為輸入，返回一個由字符串組成的列表，列表的元素即原來的單行字符串。請註意，每行行末的回車符沒有被包括進去。
lower()方法把整個字符串轉換成小寫的。（類似地，upper()方法執行大寫化轉換操作。）
count()方法對串中的指定的子串進行計數。是的，在那一句中確實出現了6個字母f。

還有一種經常會遇到的情況。比如有如下形式的鍵-值對列表 key1=value1&key2=value2，我們需要將其分離然後產生一個這樣形式的字典{key1: value1, key2: value2}。

>>> query = "user=pilgrim&database=master&password=PapayaWhip">>> a_list = query.split("&")>>> a_list["user=pilgrim", "database=master", "password=PapayaWhip"]>>> a_list_of_lists = [v.split("=", 1) for v in a_list]>>> a_list_of_lists[["user", "pilgrim"], ["database", "master"], ["password", "PapayaWhip"]]>>> a_dict = dict(a_list_of_lists)>>> a_dict{"password": "PapayaWhip", "user": "pilgrim", "database": "master"}

split()方法使用一個參數，即指定的分隔符，然後根據這個分隔符將串分離成一個字符串列表。此處，分隔符即字符&，它還可以是其他的內容。
現在我們有了一個字符串列表，其中的每個串由三部分組成：鍵，等號和值。我們可以使用列表解析來遍歷整個列表，然後利用第一個等號標記將每個字符串再分離成兩個子串。（理論上，值也可以包含等號標記，如果執行"key=value=foo".split("=")，那麽我們會得到一個三元素列表["key", "value", "foo"]。）
最後，通過調用dict()函數Python會把那個包含列表的列表(list-of-lists)轉換成字典對象。

上一個例子跟解析URL的請求參數(query parameters)很相似，但是真實的URL解析實際上比這個復雜得多。如果需要處理URL請求參數，我們最好使用urllib.parse.parse_qs()函數，它可以處理一些不常見的邊緣情況。

python 2.x和3.x中的字符串編碼區別

String vs. Bytes

python string對象和bytes對象的區別

字節即字節；字符是一種抽象。一個不可變(immutable)的Unicode編碼的字符序列叫做string。

bytes對象：一串由0到255之間的數字組成的序列。

by = b"abcde"
len(by)
5
by += b"?"
by
b"abcde?"
by[0]
97
by[0] = 102
<samp class="traceback">Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: "bytes" object does not support item assignment

使用byte字面值語法b""來定義bytes對象。byte字面值裏的每個字節可以是ASCII字符或者是從到?編碼了的16進制數。bytes對象的類型是bytes。
使用+操作符可以連接bytes對象。操作的結果是一個新的bytes對象。連接5個字節的和1個字節的bytes對象會返回一個6字節的bytes對象。
如列表和字符串，可以使用下標記號來獲取bytes對象中的單個字節。對字符串做這種操作獲得的元素仍為字符串，而對bytes對象做這種操作的返回值則為整數。確切地說，是0–255之間的整數。
bytes對象是不可變的；我們不可以給單個字節賦上新值。如果需要改變某個字節，可以組合使用字符串的切片和連接操作(效果跟字符串是一樣的)，或者我們也可以將bytes對象轉換為bytearray對象。
by = b"abcde"
barr = bytearray(by)
barr
bytearray(b"abcde")
barr[0] = 102
barr
bytearray(b"fbcde")

所有對bytes對象的操作也可以用在bytearray對象上。
有一點不同的就是，我們可以使用下標標記給bytearray對象的某個字節賦值。並且，這個值必須是0–255之間的一個整數。

不能混用bytes和strings

by = b"d"
s = "abcde"
by + s
Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: can"t concat bytes to str
s.count(by)
Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: Can"t convert "bytes" object to str implicitly
s.count(by.decode("ascii"))
1

不能連接bytes對象和字符串。他們兩種不同的數據類型。
也不允許針對字符串中bytes對象的出現次數進行計數，因為串裏面根本沒有bytes。字符串是一系列的字符序列。也許你是想要先把這些字節序列通過某種編碼方式進行解碼獲得字符串，需要顯式地指明它。Python 3不會隱含地將bytes轉換成字符串，或者進行相反的操作。

print(‘pro‘ == b‘pro‘)
flase

字符串與字節數組之間的聯系

bytes對象有一個decode()方法，它使用某種字符編碼作為參數，然後依照這種編碼方式將bytes對象轉換為字符串，對應地，字符串有一個encode()方法，它也使用某種字符編碼作為參數，然後依照它將串轉換為bytes對象。

在上一個例子中，解碼的過程相對直觀一些 -- 使用ASCII編碼將一個字節序列轉換為字符串。同樣的過程對其他的編碼方式依然有效 -- 傳統的（非Unicode）編碼方式也可以，只要它們能夠編碼串中的所有字符。

a_string = "深入 Python"
len(a_string)
9
by = a_string.encode("utf-8")
by
b"?·±?…￥ Python"
len(by)
13
by = a_string.encode("gb18030")
by
b"é?è? Python"
len(by)
11
by = a_string.encode("big5")
by
b"2`¤J Python"
len(by)
11
roundtrip = by.decode("big5")
roundtrip
"深入 Python"
a_string == roundtrip
True

Note:roundtrip是一個字符串，共有9個字符。它是通過對by使用Big5解碼算法得到的一個字符序列。並且，從執行結果可以看出，roundtrip與a_string是完全一樣的。

[python字符串編碼及區別]

from:http://blog.csdn.net/pipisorry/article/details/42085723

ref: Python 的內置字符串方法（收藏專用）

python字符串、字符串處理函數及字符串相關操作

pep hat 導入模塊 ssi 字符串分割分組 pre 實用 big python字符串、字符串處理函數及字符串相關操作字符串介紹 python字符串表示 Python除處理數字外還可以處理字符串，字符串用單撇號或雙撇號包裹： >>&g

python字符串、字符串處理函數及字符串相關操作

python字符串、字符串處理函數及字符串相關操作

python字符串表示

字符串連接和重復

字符串索引

字符串的分片

字符串長度

Python內置的字符串處理函數

python字符串子串

字母處理

格式化相關

字符串搜索相關

python判斷字符串是否包含子串的方法

字符串替換相關

字符串一次替換多個不同字符

字符串去空格及去指定字符

字符串判斷相關

字符串相關操作

repr(反引號)操作

字符串分割

使用多個界定符分割字符串

格式化字符串

語法

“映射”示例

格式限定符

格式化字符串

復合字段名

格式說明符

python判斷字符串是否由純數字組成

python刪除字符串中空白字符：換行、空格、制表符

Python字符串逐字符或逐詞反轉方法

其他常用字符串技巧

python 2.x和3.x中的字符串編碼區別

String vs. Bytes

相關推薦