python文字處理函數(shù) python寫文字方法

python字典操作函數(shù)

字典是一種通過名字或者關(guān)鍵字引用的得數(shù)據(jù)結(jié)構(gòu)，其鍵可以是數(shù)字、字符串、元組，這種結(jié)構(gòu)類型也稱之為映射。字典類型是Python中唯一內(nèi)建的映射類型，基本的操作包括如下：

吉林網(wǎng)站建設(shè)公司創(chuàng)新互聯(lián)公司,吉林網(wǎng)站設(shè)計制作，有大型網(wǎng)站制作公司豐富經(jīng)驗。已為吉林上1000+提供企業(yè)網(wǎng)站建設(shè)服務(wù)。企業(yè)網(wǎng)站搭建\成都外貿(mào)網(wǎng)站建設(shè)要多少錢，請找那個售后服務(wù)好的吉林做網(wǎng)站的公司定做！

(1)len()：返回字典中鍵—值對的數(shù)量；

(2)d[k]:返回關(guān)鍵字對于的值；

(3)d[k]=v:將值關(guān)聯(lián)到鍵值k上；

(4)del d[k]:刪除鍵值為k的項；

(5)key in d:鍵值key是否在d中，是返回True，否則返回False。

(6)clear函數(shù)：清除字典中的所有項

(7)copy函數(shù)：返回一個具有相同鍵值的新字典；deepcopy()函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題

(8)fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對應(yīng)的值為None

(9)get函數(shù)：訪問字典成員

(10)has_key函數(shù)：檢查字典中是否含有給出的鍵

(11)items和iteritems函數(shù):items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

(13)pop函數(shù)：刪除字典中對應(yīng)的鍵

(14)popitem函數(shù)：移出字典中的項

(15)setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值

(16)update函數(shù)：用一個字典更新另外一個字典

(17)?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素

一、字典的創(chuàng)建

1.1 直接創(chuàng)建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通過dict創(chuàng)建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的內(nèi)容:'

printitems

printu'利用dict創(chuàng)建字典，輸出字典內(nèi)容:'

d=dict(items)

printd

printu'查詢字典中的內(nèi)容:'

printd['one']

printd['three']

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的內(nèi)容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict創(chuàng)建字典，輸出字典內(nèi)容:

{'four':4,'three':3,'two':2,'one':1}

查詢字典中的內(nèi)容:

或者通過關(guān)鍵字創(chuàng)建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'輸出字典內(nèi)容:'

printd

printu'查詢字典中的內(nèi)容:'

printd['one']

printd['three']

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出字典內(nèi)容:

{'three':3,'two':2,'one':1}

查詢字典中的內(nèi)容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1?clear函數(shù)：清除字典中的所有項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

請看下面兩個例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關(guān)聯(lián)到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空后，字典dd里面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內(nèi)容，clear是一個原地操作的方法，使得d中的內(nèi)容全部被置空，這樣dd所指向的空間也被置空。

3.2?copy函數(shù)：返回一個具有相同鍵值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X復(fù)制到Y(jié)：'

y=x.copy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，觀察輸出：'

printy

printx

printu'刪除Y中的值，觀察輸出'

y['test'].remove('c')

printy

printx

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X復(fù)制到Y(jié)：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，觀察輸出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

刪除Y中的值，觀察輸出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在復(fù)制的副本中對值進行替換后，對原來的字典不產(chǎn)生影響，但是如果修改了副本，原始的字典也會被修改。deepcopy函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'輸出：'

printy

printz

printu'修改后輸出：'

x['test'].append('e')

printy

printz

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后輸出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3?fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對應(yīng)的值為None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默認(rèn)的對應(yīng)值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4?get函數(shù)：訪問字典成員

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注：get函數(shù)可以訪問字典中不存在的鍵，當(dāng)該鍵不存在是返回None

3.5?has_key函數(shù)：檢查字典中是否含有給出的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6?items和iteritems函數(shù):items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7?keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

printx

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

3.8?pop函數(shù)：刪除字典中對應(yīng)的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9?popitem函數(shù)：移出字典中的項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10?setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

運算結(jié)果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11?update函數(shù)：用一個字典更新另外一個字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

運算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

Python 數(shù)據(jù)處理（三十五）—— 文本數(shù)據(jù)處理

在 pandas 中，存儲文本主要有兩種方式

但一般建議使用 StringDtype 類型存儲文本數(shù)據(jù)。都是由于各種原因，現(xiàn)在字符串?dāng)?shù)據(jù)的默認(rèn)存儲類型還是 object 。

要存儲為 string 類型，需要顯式的設(shè)置 dtype 參數(shù)

或者在創(chuàng)建 Series 或 DataFrame 之后，使用 astype 轉(zhuǎn)換類型

也可以使用 StringDtype/"string" 轉(zhuǎn)換其他非字符串類型的數(shù)據(jù)

轉(zhuǎn)換現(xiàn)有數(shù)據(jù)的類型

StringDtype 類型對象與 object 類型之間存在一些差異

兩個結(jié)果的輸出都是 Int64 類型。將其與 object 類型比較

當(dāng)存在 NA 值時，輸出為 float64 。類似地，對于返回布爾值的方法

Series 和 Index 有一套字符串處理方法，可以方便地對數(shù)組的每個元素進行操作，最重要的是，這些方法會自動忽略缺失值。

這些方法可以通過 str 屬性訪問，通常具有與內(nèi)置字符串方法相匹配的名稱

Index 上的字符串方法對于清理或轉(zhuǎn)換 DataFrame 的列特別有用。

例如，您可能有帶有前導(dǎo)或后置空格的列

因為 df.columns 是一個 Index 對象，所以我們可以使用 .str 訪問器

我們可以根據(jù)需要對列名進行處理，然后重新設(shè)置列名。

例如，我們刪除列名的前后空格，并將其改為小寫字母，同時用 _ 替換剩余的空格

split 方法會返回一個值為 list 的 Series

可以使用 get 或 [] 訪問拆分后的列表中的元素

更簡單的方法是設(shè)置 expand 參數(shù)，返回一個 DataFrame

當(dāng)原來的 Series 包含 StringDtype 類型的數(shù)據(jù)時，輸出列也將全部為 StringDtype

當(dāng)然，也可以設(shè)置切割次數(shù)

它還有個對應(yīng)的 rsplit 方法，從右邊起始對字符串進行拆分

replace 參數(shù)支持使用正則表達(dá)式，前兩個參數(shù)是 pat (匹配模式) 和 repl (替換字符串)

如果只是想要替換字符串字面值，可以將 regex 參數(shù)設(shè)置為 False ，而不需要對每個特殊字符進行轉(zhuǎn)義。此時 pat 和 repl 參數(shù)必須是字符串

此外， replace 方法還接受一個可調(diào)用的替換函數(shù)，會使用 re.sub() 方法在每個匹配的模式上調(diào)用該函數(shù)

該函數(shù)需要傳入一個正則對象作為位置參數(shù)，并返回一個字符串。例如

replace 方法的 pat 參數(shù)還接受 re.compile() 編譯的正則表達(dá)式對象。所有的 flags 需要在編譯正則對象時設(shè)置

如果在 replace 中設(shè)置 flags 參數(shù)，則會拋出異常

有幾種方法可以將一個 Series 或 Index 與自己或其他的 Series 或 Index 相連接，所有這些方法都是基于 cat() 方法

可以連接一個 Series 或 Index 的內(nèi)容

如果未指定 sep 參數(shù)，則默認(rèn)為空字符串

默認(rèn)會跳過缺失值，也可以使用 na_rep 指定缺失值的表示方式

cat() 的第一個參數(shù) others 可以是類似列表的對象，但是其長度需要和調(diào)用對象一致

只要兩個對象中存在缺失值，對應(yīng)的結(jié)果中也是缺失值，除非指定了 na_rep

others 參數(shù)也可以是二維的，但是得保證其行數(shù)必須與調(diào)用的對象一致

對于 Series 或 DataFrame 的連接，可以通過設(shè)置 join 參數(shù)指定對齊方式

通常 join 可選范圍為： 'left' , 'outer' , 'inner' , 'right' 。此時，不再要求兩個對象長度一致

當(dāng) others 參數(shù)是 DataFrame 時，也可以使用

可以將一些類似數(shù)組的對象（如 Series ， Index 等）放在一個類似列表的容器中，然后傳遞給 cat

對于沒有索引的對象，其長度必須與調(diào)用 cat 的對象相同。但是 Series 和 Index 可以是任意的，除非設(shè)置了 json=None 。

如果在 others 參數(shù)上包含不同索引的對象，且設(shè)置了 join='right' ，則最后的結(jié)果將會是這些索引的并集

Python常用的正則表達(dá)式處理函數(shù)詳解

正則表達(dá)式是一個特殊的字符序列，用于簡潔表達(dá)一組字符串特征，檢查一個字符串是否與某種模式匹配，使用起來十分方便。

在Python中，我們通過調(diào)用re庫來使用re模塊：

import re

下面介紹Python常用的正則表達(dá)式處理函數(shù)。

re.match函數(shù)

re.match 函數(shù)從字符串的起始位置匹配正則表達(dá)式，返回match對象，如果不是起始位置匹配成功的話，match()就返回None。

re.match(pattern, string, flags=0)

pattern：匹配的正則表達(dá)式。

string：待匹配的字符串。

flags：標(biāo)志位，用于控制正則表達(dá)式的匹配方式，如：是否區(qū)分大小寫，多行匹配等等。具體參數(shù)為：

re.I：忽略大小寫。

re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴于當(dāng)前環(huán)境。

re.M：多行模式。

re.S：即 . ，并且包括換行符在內(nèi)的任意字符（. 不包括換行符）。

re.U：表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依賴于 Unicode 字符屬性數(shù)據(jù)庫。

re.X：為了增加可讀性，忽略空格和 # 后面的注釋。

import?re #從起始位置匹配 r1=re.match('abc','abcdefghi') print(r1) #不從起始位置匹配 r2=re.match('def','abcdefghi') print(r2)

運行結(jié)果：

其中，span表示匹配成功的整個子串的索引。

使用group(num) 或 groups() 匹配對象函數(shù)來獲取匹配表達(dá)式。

group(num)：匹配的整個表達(dá)式的字符串，group() 可以一次輸入多個組號，這時它將返回一個包含那些組所對應(yīng)值的元組。

groups()：返回一個包含所有小組字符串的元組，從 1 到 所含的小組號。

import?re s='This?is?a?demo' r1=re.match(r'(.*)?is?(.*)',s) r2=re.match(r'(.*)?is?(.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())

運行結(jié)果：

上述代碼中的(.*)和(.*?)表示正則表達(dá)式的貪婪匹配與非貪婪匹配。

re.search函數(shù)

re.search函數(shù)掃描整個字符串并返回第一個成功的匹配，如果匹配成功則返回match對象，否則返回None。

re.search(pattern, string, flags=0)

pattern：匹配的正則表達(dá)式。

string：待匹配的字符串。

flags：標(biāo)志位，用于控制正則表達(dá)式的匹配方式，如：是否區(qū)分大小寫，多行匹配等等。

import?re #從起始位置匹配 r1=re.search('abc','abcdefghi') print(r1) #不從起始位置匹配 r2=re.search('def','abcdefghi') print(r2)

運行結(jié)果：

使用group(num) 或 groups() 匹配對象函數(shù)來獲取匹配表達(dá)式。

group(num=0)：匹配的整個表達(dá)式的字符串，group() 可以一次輸入多個組號，這時它將返回一個包含那些組所對應(yīng)值的元組。

groups()：返回一個包含所有小組字符串的元組，從 1 到 所含的小組號。

import?re s='This?is?a?demo' r1=re.search(r'(.*)?is?(.*)',s) r2=re.search(r'(.*)?is?(.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())

運行結(jié)果：

從上面不難發(fā)現(xiàn)re.match與re.search的區(qū)別：re.match只匹配字符串的起始位置，只要起始位置不符合正則表達(dá)式就匹配失敗，而re.search是匹配整個字符串，直到找到一個匹配為止。

re.compile 函數(shù)

compile 函數(shù)用于編譯正則表達(dá)式，生成一個正則表達(dá)式對象，供 match() 和 search() 這兩個函數(shù)使用。

re.compile(pattern[, flags])

pattern：一個字符串形式的正則表達(dá)式。

flags：可選，表示匹配模式，比如忽略大小寫，多行模式等。

import?re #匹配數(shù)字 r=re.compile(r'\d+')? r1=r.match('This?is?a?demo') r2=r.match('This?is?111?and?That?is?222',0,27) r3=r.match('This?is?111?and?That?is?222',8,27) ? print(r1) print(r2) print(r3)

運行結(jié)果：

findall函數(shù)

搜索字符串，以列表形式返回正則表達(dá)式匹配的所有子串，如果沒有找到匹配的，則返回空列表。

需要注意的是，match 和 search 是匹配一次，而findall 匹配所有。

findall(string[, pos[, endpos]])

string：待匹配的字符串。

pos：可選參數(shù)，指定字符串的起始位置，默認(rèn)為0。

endpos：可選參數(shù)，指定字符串的結(jié)束位置，默認(rèn)為字符串的長度。

import?re #匹配數(shù)字 r=re.compile(r'\d+')? r1=r.findall('This?is?a?demo') r2=r.findall('This?is?111?and?That?is?222',0,11) r3=r.findall('This?is?111?and?That?is?222',0,27) ? print(r1) print(r2) print(r3)

運行結(jié)果：

re.finditer函數(shù)

和 findall 類似，在字符串中找到正則表達(dá)式所匹配的所有子串，并把它們作為一個迭代器返回。

re.finditer(pattern, string, flags=0)

pattern：匹配的正則表達(dá)式。

string：待匹配的字符串。

flags：標(biāo)志位，用于控制正則表達(dá)式的匹配方式，如是否區(qū)分大小寫，多行匹配等。

import?re? r=re.finditer(r'\d+','This?is?111?and?That?is?222') for?i?in?r:? ?print?(i.group())

運行結(jié)果：

re.split函數(shù)

將一個字符串按照正則表達(dá)式匹配的子串進行分割后，以列表形式返回。

re.split(pattern, string[, maxsplit=0, flags=0])

pattern：匹配的正則表達(dá)式。

string：待匹配的字符串。

maxsplit：分割次數(shù)，maxsplit=1分割一次，默認(rèn)為0，不限次數(shù)。

flags：標(biāo)志位，用于控制正則表達(dá)式的匹配方式，如：是否區(qū)分大小寫，多行匹配等。

import?re? r1=re.split('\W+','This?is?111?and?That?is?222')? r2=re.split('\W+','This?is?111?and?That?is?222',maxsplit=1)? r3=re.split('\d+','This?is?111?and?That?is?222')? r4=re.split('\d+','This?is?111?and?That?is?222',maxsplit=1)? print(r1) print(r2) print(r3) print(r4)

運行結(jié)果：

re.sub函數(shù)

re.sub函數(shù)用于替換字符串中的匹配項。

re.sub(pattern, repl, string, count=0, flags=0)

pattern：正則中的模式字符串。

repl：替換的字符串，也可為一個函數(shù)。

string：要被查找替換的原始字符串。

count：模式匹配后替換的最大次數(shù)，默認(rèn)0表示替換所有的匹配。

import?re? r='This?is?111?and?That?is?222' #?刪除字符串中的數(shù)字 r1=re.sub(r'\d+','',r) print(r1) #?刪除非數(shù)字的字符串? r2=re.sub(r'\D','',r) print(r2)

運行結(jié)果：

到此這篇關(guān)于Python常用的正則表達(dá)式處理函數(shù)詳解的文章就介紹到這了，希望大家以后多多支持！

Python處理字符串必備方法

字符串是Python中基本的數(shù)據(jù)類型，幾乎在每個Python程序中都會使用到它。

▍1、Slicing

slicing切片，按照一定條件從列表或者元組中取出部分元素（比如特定范圍、索引、分割值）

▍2、****strip()

strip()方法用于移除字符串頭尾指定的字符（默認(rèn)為空格或換行符）或字符序列。

在使用strip()方法時，默認(rèn)去除空格或換行符，所以#號并沒有去除。

可以給strip()方法添加指定字符，如下所示。

此外當(dāng)指定內(nèi)容不在頭尾處時，并不會被去除。

第一個\n前有個空格，所以只會去取尾部的換行符。

最后strip()方法的參數(shù)是剝離其值的所有組合，這個可以看下面這個案例。

最外層的首字符和尾字符參數(shù)值將從字符串中剝離。字符從前端移除，直到到達(dá)一個不包含在字符集中的字符串字符為止。

在尾部也會發(fā)生類似的動作。

▍3、****lstrip()

移除字符串左側(cè)指定的字符（默認(rèn)為空格或換行符）或字符序列。

同樣的，可以移除左側(cè)所有包含在字符集中的字符串。

▍4、rstrip()

移除字符串右側(cè)指定的字符（默認(rèn)為空格或換行符）或字符序列。

▍5、****removeprefix()

Python3.9中移除前綴的函數(shù)。

和strip()相比，并不會把字符集中的字符串進行逐個匹配。

▍6、removesuffix()

Python3.9中移除后綴的函數(shù)。

▍7、****replace()

把字符串中的內(nèi)容替換成指定的內(nèi)容。

▍8、****re.sub()

re是正則的表達(dá)式，sub是substitute表示替換。

re.sub則是相對復(fù)雜點的替換。

和replace()做對比，使用re.sub()進行替換操作，確實更高級點。

▍9、****split()

對字符串做分隔處理，最終的結(jié)果是一個列表。

當(dāng)不指定分隔符時，默認(rèn)按空格分隔。

此外，還可以指定字符串的分隔次數(shù)。

▍10、****rsplit()

從右側(cè)開始對字符串進行分隔。

▍11、****join()

string.join(seq)。以string作為分隔符，將seq中所有的元素(的字符串表示)合并為一個新的字符串。

▍12、****upper()

將字符串中的字母，全部轉(zhuǎn)換為大寫。

▍13、****lower()

將字符串中的字母，全部轉(zhuǎn)換為小寫。

▍14、capitalize()

將字符串中的首個字母轉(zhuǎn)換為大寫。

▍15、****islower()

判斷字符串中的所有字母是否都為小寫，是則返回True，否則返回False。

▍16、isupper()

判斷字符串中的所有字母是否都為大寫，是則返回True，否則返回False。

▍17、****isalpha()

如果字符串至少有一個字符并且所有字符都是字母，則返回 True，否則返回 False。

▍18、isnumeric()

如果字符串中只包含數(shù)字字符，則返回 True，否則返回 False。

▍19、isalnum()

如果字符串中至少有一個字符并且所有字符都是字母或數(shù)字，則返回True，否則返回 False。

▍20、count()

返回指定內(nèi)容在字符串中出現(xiàn)的次數(shù)。

▍21、****find()

檢測指定內(nèi)容是否包含在字符串中，如果是返回開始的索引值，否則返回-1。

此外，還可以指定開始的范圍。

▍22、rfind()

類似于find()函數(shù)，返回字符串最后一次出現(xiàn)的位置，如果沒有匹配項則返回 -1。

▍23、startswith()

檢查字符串是否是以指定內(nèi)容開頭，是則返回 True，否則返回 False。

**

**

▍24、****endswith()

檢查字符串是否是以指定內(nèi)容結(jié)束，是則返回 True，否則返回 False。

▍25、****partition()

string.partition(str)，有點像find()和split()的結(jié)合體。

從str出現(xiàn)的第一個位置起,把字符串string分成一個3 元素的元組(string_pre_str,str,string_post_str)，如果string中不包含str則 string_pre_str==string。

▍26、center()

返回一個原字符串居中，并使用空格填充至長度width的新字符串。

▍27、ljust()

返回一個原字符串左對齊，并使用空格填充至長度width的新字符串。

▍28、rjust()

返回一個原字符串右對齊，并使用空格填充至長度width的新字符串。

▍29、f-Strings

f-string是格式化字符串的新語法。

與其他格式化方式相比，它們不僅更易讀，更簡潔，不易出錯，而且速度更快！

▍30、swapcase()

翻轉(zhuǎn)字符串中的字母大小寫。

▍31、zfill()

string.zfill(width)。

返回長度為width的字符串，原字符串string右對齊，前面填充0。

參考文獻：

本文名稱：python文字處理函數(shù) python寫文字方法
文章網(wǎng)址：http://www.muchs.cn/article16/hjeigg.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站設(shè)計、小程序開發(fā)、電子商務(wù)、虛擬主機、網(wǎng)站改版、微信小程序

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)