剛開始學習Python，看了一天的字符串內部方法，現在來總結一下。

capitalize(self)?將一句話的首字母變大寫,其他字母都變小

1 name = "love PyThon"

2 #capitalize(self)

3 result1 = name.capitalize() #將一句話的首字母變大寫,其他字母都變小

4 print('result1:%s'%result1)

打印結果：

1 result1:Love python

casefold(self)?官方解釋比較霸道,確實是比較霸道,所有的字母都變成小寫,不過好像用的不多

1 #casefold(self)

2 name = 'HELLo Python My Name IS RookieJX'

3 result2 =name.casefold()4 print('result2:%s'%result2)

打印結果：

1 result2:hello python my name is rookiejx

center(self, width, fillchar=None)?這個是將原字符串居中,如果self長度小于width，那么多余的部分就用 fillchar 字符填充并,默認為空格，如果多余的是奇數，那么最后多余的一個就填充到左邊。其中fillchar只能為單個字符。

1 #center(self, width, fillchar=None)

2 name = 'Python'

3 result3 = name.center(9,"H")

4 print('result3:%s'%result3)

打印結果：

1 result3:HHPythonH

count(self, sub, start=None, end=None)?查詢某個字符或者字符串在self中出現的次數，默認是在整個self上查詢，也可以自定義位置

1 #count(self, sub, start=None, end=None)

2 name = 'Hello Python'

3 result4 = name.count("lo",0,40)

4 print('result4:%s'%result4)

打印結果：

1 result4:1

encode(self, encoding='utf-8', errors='strict')?編碼為utf-8格式編碼,如果出錯使用嚴格,其他還有'ignore', 'replace' 等

1 #encode(self, encoding='utf-8', errors='strict')

2 name = 'Hello Python'

3 result5 = name.encode('utf-8','strict')

4 print('result5:%s'%result5)

打印結果：

1 result5:b'Hello Python'

endswith(self, suffix, start=None, end=None)?以什么為結束,默認是整個字符串,可以自己選擇長度

1 #endswith(self, suffix, start=None, end=None)

2 name = 'Hello Python'

3 result6 = name.endswith('o',0,3)4 print('result6:%s'%result6)

打印結果：

1 result6:False

expandtabs(self, tabsize=8)?將字符串中所有的tab鍵轉換成空格鍵,默認為8

1 #expandtabs(self, tabsize=8)

2 result7 = 'hate\tPython'

3 print('origin result7:%s'%result7)4 result8 = result7.expandtabs() #將字符串中所有的tab鍵轉換成空格鍵,默認為8

5 print('result8:%s'%result8)6 result9 = result7.expandtabs(20) #更改默認值

7 print('result9:%s'%result9)

打印結果：

1 origin result7:hate Python2 result8:hate Python3 result9:hate Python

find(self, sub, start=None, end=None)?查找某個字符或者字符串在字符串中的下標,默認為查找全部字符串

1 #find(self, sub, start=None, end=None)

2 name = 'Hello Python'

3 result10 = name.find('P') #查找某個字符或者字符串在字符串中的下標,默認為查找全部字符串

4 print('result10:%s'%result10)5 result11 = name.find('P',0,4) #可以自定義查找范圍,如果沒有就返回 -1

6 print('result11:%s'%result11)

打印結果：

1 result10:6

2 result11:-1

format(*args, **kwargs)?好像很暴力的樣子,格式化字符串,有很多用法

1 #format(*args, **kwargs)

2 #好像很暴力的樣子,格式化字符串,有很多用法

3 #1.可以使用 {} 用作占位符 這里分割的時候需要使用 . 不是用 , 這點需要注意

4 print('I am {},I {}'.format('rookieJX','Love Python'))5 #2.也可以使用 {0} {1}等樣式的占位符

6 print('I am {1},I {0}'.format('Love Python','rookieJX'))7 #3.還可以使用變量形式的占位符

8 print('My job is {job}'.format(job = 'IT'))9 #4.還可以混合使用

10 print('I am {1},My job is {job}'.format('haha','rookieJX',job = 'IT'))

打印結果：

1 I am rookieJX,I Love Python2 I am rookieJX,I Love Python3 My job isIT4 I am rookieJX,My job is IT

format_map(self, mapping)?暫時了解的還不多

index(self, sub, start=None, end=None)?類似于find方法,但是當要查找的字符串不在查找的字符串中的話會報錯

1 #index(self, sub, start=None, end=None)

2 name = 'Hello Python'

3 result12 = name.index('P') #類似于find方法,但是當要查找的字符串不在查找的字符串中的話會報錯

4 print('result12:%s'%result12)5 result13 = name.index('P',0,10) #還可以自定義限制查找的范圍

6 print('result13:%s'%result13)

打印結果：

1 result12:6

2 result13:6

isalnum(self)?字符串中至少有一個字符,并且所有的字符都是字母或者數字返回為True 否則返回為 False (空格也返回False)

1 #isalnum(self)

2 name = 'Hello Python'

3 result14 = name.isalnum() #字符串中至少有一個字符,并且所有的字符都是字母或者數字返回為True 否則返回為 False (空格也返回False)

4 print('result14:%s'%result14)

打印結果：

1 result14:False

isalpha(self)?字符串中至少有一個是字符,并且所有的字符都是字母返回為 True 否則返回為 False (空格也返回False)

1 #isalpha(self)

2 name = 'Hello Python'

3 result15 =name.isalpha()4 print('result15:%s'%result15) #字符串中至少有一個是字符,并且所有的字符都是字母返回為 True 否則返回為 False (空格也返回False)

打印結果：

1 result15:False

isdecimal(self)?判斷字符串是否是十進制整數,如果不是返回為 False ,如果不是字符串就會報錯

1 #isdecimal(self)

2 namedeclimal = "324.2" #判斷字符串是否是十進制整數,如果不是返回為 False ,如果不是字符串就會報錯

3 result16 =namedeclimal.isdecimal()4 print('result16:%s'%result16)

打印結果：

1 result16:False

isdigit(self)?判斷字符串中是否只包含數字

1 #isdigit(self)

2 namedeclimal = "324.2"

3 result17 = namedeclimal.isdigit() #判斷字符串中是否只包含數字

4 print('result17:%s'%result17)

打印結果：

1 result17:False

isidentifier(self)?判斷字符串是否是關鍵字

1 #isidentifier(self)

2 result18 = 'str'.isidentifier() #判斷字符串是否是關鍵字

3 print('result18:%s'%result18)

打印結果：

1 result18:True

islower(self)?字符串中至少有一個字符,字符全部為小寫就返回 True

1 #islower(self)

2 name = 'Hello Python'

3 result19 = name.islower() #字符串中至少有一個字符,字符全部為小寫就返回 True

4 print('result19:%s'%result19)

打印結果：

1 result19:False

isnumeric(self)?字符串中如果全部都是數字字符返回 True 貌似跟 isdecimal 差不多,暫時還沒有發現有什么不同的用法

1 #isnumeric(self)

2 result20 = '4232'.isnumeric() #字符串中如果全部都是數字字符返回 True 貌似跟 isdecimal 差不多,暫時還沒有發現有什么不同的用法

3 print('result20:%s'%result20)

打印結果：

1 result20:True

isprintable(self)?判斷字符串中所有字符是否是可見狀態

1 #isprintable(self)

2 result21 = 'I\aPython'.isprintable() #判斷字符串中所有字符是否是可見狀態

3 print('result20:%s'%result21)

打印結果：

1 result20:False

isspace(self)?字符串中如果只至少有一個字符,并且全部為空格時 返回為True

1 #isspace(self)

2 result22 = ' '.isspace() #字符串中如果只至少有一個字符,并且全部為空格時 返回為True

3 print('result22:%s'%result22)

打印結果：

1 result22:True

istitle(self)?字符串是否為標題格式 就是每個單詞首字母都是大寫

1 #istitle(self)

2 result23 = 'This Is Python'.istitle() #字符串是否為標題格式 就是每個單詞首字母都是大寫

3 print('result23:%s'%result23)

打印結果：

1 result23:True

isupper(self)?字符串至少有一個字符 判斷字符是否是大寫 如果是大寫就返回 True (只會判斷其中的英文字符,特殊符號,數字不會判斷)

1 #isupper(self)

2 result24 = 'NAME.803'.isupper() #字符串至少有一個字符 判斷字符是否是大寫 如果是大寫就返回 True (只會判斷其中的英文字符,特殊符號,數字不會判斷)

3 print('result24:%s'%result24)

打印結果：

1 result24:True

join(self, iterable)?將self字符串用iterable打散,每個兩個字符串之間插入 iterable?字符串

1 #join(self, iterable)

2 name = 'Hello Python'

3 result25 = name.join('Hello World') #將iterable字符串打散,每個兩個字符串之間插入 string 字符串

4 print('result25:%s'%result25)

打印結果：

1 result25:HHello PythoneHello PythonlHello PythonlHello PythonoHello Python Hello PythonWHello PythonoHello PythonrHello PythonlHello Pythond

ljust(self, width, fillchar=None)?原字符串左對齊,總字符串長度為自定義長度,右邊填充字符 默認為空格 如果定義長度小于元字符串長度,則不會進行操作

1 #ljust(self, width, fillchar=None)

2 name = 'Hello Python'

3 result26 = name.ljust(23,'H') #原字符串左對齊,總字符串長度為自定義長度,右邊填充字符 默認為空格 如果定義長度小于元字符串長度,則不會進行操作

4 print('result26:%s'%result26)

打印結果：

1 result26:Hello PythonHHHHHHHHHHH

lower(self)?拷貝一份原有的字符串,并將之變為小寫 貌似跟casefold效果一樣的

1 #lower(self)

2 name = 'Hello Python'

3 result27 = name.lower() #拷貝一份原有的字符串,并將之變為小寫 貌似跟casefold效果一樣的

4 print('result27:%s'%result27)

打印結果：

1 result27:hello python

lstrip(self, chars=None)?默認截掉字符串左邊的空格,如果自定義字符,那么字符必須是從字符串的開始才能截取成功

1 #lstrip(self, chars=None)

2 result28 = 'Hello'.lstrip() #默認截掉字符串左邊的空格,如果自定義字符,那么字符必須是從字符串的開始才能截取成功

3 print('result28:%s'%result28)4

5 result29 = 'Hello'.lstrip('H') #默認截掉字符串左邊的空格,如果自定義字符,那么字符必須是從字符串的開始才能截取成功

6 print('result29:%s'%result29)

打印結果：

1 result28:Hello2 result29:ello

maketrans(self, *args, **kwargs)?構建替換映射表,首先構建映射對應表格,映射前為intab,映射后為outtab.然后構建對應表格maketrans,最后開始轉換

1 #maketrans(self, *args, **kwargs)

2 intab = "aeiou"

3 outtab = "12398"

4 intro = "hello python in my heart"

5 result29 =str.maketrans(intab,outtab)6 result30 = intro.translate(result29) #構建替換映射表,首先構建映射對應表格,映射前為intab,映射后為outtab.然后構建對應表格maketrans,最后開始轉換

7 print('intro:%s'%result30)

打印結果：

1 intro:h2ll9 pyth9n 3n my h21rt

partition(self, sep)?根據指定字符串來分割原字符串,如果原字符串存在指定字符串,結果為 分割左邊原字符串,指定字符串,分割后右字符串...如果不存在指定字符串則返回原字符串,只會分割出現的第一個位置

1 #partition(self, sep)

2 test = 'Hello Python , Hello Python ,Hello World'

3 result31 = test.partition('P') #根據指定字符串來分割原字符串,如果原字符串存在指定字符串,結果為 分割左邊原字符串,指定字符串,分割后右字符串...如果不存在指定字符串則返回原字符串,只會分割出現的第一個位置

4 print('result31:',result31)

打印結果：

1 result31: ('Hello', 'P', 'ython , Hello Python ,Hello World')

replace(self, old, new, count=None)?替換字符串.最大不超過多少次

1 #replace(self, old, new, count=None)

2 result32 = 'love python love python love python love python love python'.replace('love','hate',3) #替換字符串.最大不超過多少次

3 print('result32:%s'%result32)

打印結果：

1 result32:hate python hate python hate python love python love python

rfind(self, sub, start=None, end=None)?查找指定字符串在原字符串中最右邊的位置,默認為整個字符串

1 #rfind(self, sub, start=None, end=None)

2 result33 = 'love python love'.rfind('lo') #查找指定字符串在原字符串中最右邊的位置,默認為整個字符串

3 print('result33:%s'%result33)

打印結果：

1 result33:12

rindex(self, sub, start=None, end=None)?查找指定字符串在原字符串中最右邊的位置,默認為整個字符串,跟rfind效果差不多,但是如果找不到就會報錯

1 #rindex(self, sub, start=None, end=None)

2 result34 = 'love python love'.rindex('lo') #查找指定字符串在原字符串中最右邊的位置,默認為整個字符串,跟rfind效果差不多,但是如果找不到就會報錯

3 print('result34:%s'%result34)

打印結果：

1 result34:12

rjust(self, width, fillchar=None)?返回一個右邊對其的原字符串,默認用空格對其,可以自定義字符,但是如果是自定義字符串的話,那么自定義的字符串必須能被多余的空格整除,否則就會報錯

1 #rjust(self, width, fillchar=None)

2 name = "love PyThon"

3 result35 = name.rjust(50,'O') #返回一個右邊對其的原字符串,默認用空格對其,可以自定義字符,但是如果是自定義字符串的話,那么自定義的字符串必須能被多余的空格整除,否則就會報錯

4 print('result35:%s'%result35)

打印結果：

1 result35:OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOlove PyThon

rpartition(self, sep)?類似于partition 只不過是從右邊開始查找

1 #rpartition(self, sep)

2 test2 = 'Hello Python ,Hello Python , Hello WoPrld'

3 result36 = test2.rpartition('P') #類似于partition 只不過是從右邊開始查找

4 print('result36:',result36)

打印結果：

1 result36: ('Hello Python ,Hello Python , Hello Wo', 'P', 'rld')

split(self, sep=None, maxsplit=-1)?根據指定字符串來分割字符串,如果指定最大分割字符串,那么久分割指定次數,如果不指定默認為-1也就是最大

1 #split(self, sep=None, maxsplit=-1)

2 test3 = 'Hello Python ,Hello Python , Hello WoPrld'

3 result37 = test3.split('P',2) #根據指定字符串來分割字符串,如果指定最大分割字符串,那么久分割指定次數,如果不指定默認為-1也就是最大

4 print('result37:',result37)

打印結果：

1 result37: ['Hello', 'ython ,Hello', 'ython , Hello WoPrld']

splitlines(self, keepends=None)?按照行('\r', '\r\n', \n')分隔,返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符.默認為False

1 #splitlines(self, keepends=None)

2 test4 = 'Hello\r Pyth\non ,Hel\r\nlo Python , Hello WoPrld'

3 result38 = test4.splitlines(True) #按照行('\r', '\r\n', \n')分隔,返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符.默認為False

4 print('result38:',result38)

打印結果：

1 result38: ['Hello\r', 'Pyth\n', 'on ,Hel\r\n', 'lo Python , Hello WoPrld']

startswith(self, prefix, start=None, end=None)?查看是否 以指定字符串為開頭 并可以指定范圍

1 #startswith(self, prefix, start=None, end=None)

2 test5 = 'Hello\r Pyth\non ,Hel\r\nlo Python , Hello WoPrld'

3 result39 = test5.startswith('ell',0,30) #查看是否 以指定字符串為開頭 并可以指定范圍

4 print('result39:',result39)

打印結果：

1 result39: False

strip(self, chars=None)?對字符串執行 去掉左右兩邊的空格,默認為取消空格,可以設置為指定字符

1 #strip(self, chars=None)

2 test6 = 'H Hello Python ,Hello Python , Hello WoPrld H'

3 result40 = test6.strip('H') #對字符串執行 去掉左右兩邊的空格,默認為取消空格,可以設置為指定字符

4 print('result40:',result40)

打印結果：

1 result40: Hello Python ,Hello Python , Hello WoPrld

swapcase(self)?翻轉字符串中的大小寫

1 #swapcase(self)

2 test7 = 'H Hello Python ,Hello Python , Hello WoPrld H'

3 result41 = test7.swapcase() #翻轉字符串中的大小寫

4 print('result41:',result41)

打印結果：

1 result41: h hELLO pYTHON ,hELLO pYTHON , hELLO wOpRLD h

title(self)?將字符串中每個單詞首字母置為大寫

1 #title(self)

2 test8 = 'H hello python ,hello python , hello woPrld H'

3 result42 = test8.title() #將字符串中每個單詞首字母置為大寫

4 print('result42:',result42)

打印結果：

1 result42: H Hello Python ,Hello Python , Hello Woprld H

translate(self, table)??與maketrans(self, *args, **kwargs)配合使用

upper(self)?將字符串改變為大寫

1 #upper(self)

2 test9 = 'H hello python ,hello python , hello woPrld H'

3 result43 = test9.upper() #將字符串改變為大寫

4 print('result43:',result43)

打印結果：

1 result43: H HELLO PYTHON ,HELLO PYTHON , HELLO WOPRLD H

zfill(self, width)?右邊對齊,左邊填充數字0,長度為自定義

1 #zfill(self, width)

2 test10 = 'H hello python ,hello python , hello woPrld H'

3 result44 = test10.zfill(70) #右邊對齊,左邊填充數字0,長度為自定義

4 print('result44:',result44)

打印結果：

1 result44: 0000000000000000000H hello python ,hello python , hello woPrld H

暫未符號

myString = 'Python'number= 1

print('%s is best! is %d'%(myString,number))

打印結果

Python is best! is 1

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的python内点法_Python_Day_02 str内部方法总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。