Python內(nèi)置函數(shù)/方法詳解—字符串str
字符串是Python中最常用的數(shù)據(jù)類型
1、創(chuàng)建字符串
1.1 使用 ’ ’ 或 " " 創(chuàng)建字符串
創(chuàng)建字符串很簡(jiǎn)單，我們可以使用引號(hào)（’ ’ 或 " "）來創(chuàng)建字符串，只需為變量分配一個(gè)值即可。
str1 = 'Hello Python'
str2 = "hello python"
1.2 使用 str()函數(shù) 轉(zhuǎn)換為字符串
當(dāng)然，除了使用引號(hào)直接創(chuàng)建字符串之外，我們還可以使用 str() 函數(shù)將其他數(shù)據(jù)類型或?qū)ο筠D(zhuǎn)換為字符串，其具體用法見下方內(nèi)置函數(shù)。
2、訪問字符串
和列表、元組一樣，我們既可以使用下標(biāo)索引訪問字符串中的某個(gè)元素（得到是一個(gè)字符），也可以使用切片訪問字符串中的一組元素（得到是子字符串）。
2.1 下標(biāo)索引訪問
下標(biāo)索引訪問字符串分為兩大類，即正向索引和反向索引，格式為 str_name[i] ，其中，str_name 表示字符串名，i表示索引值，i可以是正數(shù)（正向索引）也可以是負(fù)數(shù)（反向索引）。
可以得知，str_name[0]表示字符串的第一個(gè)字符，str_name[-1]則表示字符串的最后一個(gè)字符。
str1 = 'Hello Py'
print(str1[0])
print(str1[-1])
H
y
正向索引：從第一個(gè)（下標(biāo)0）開始、第二個(gè)（下標(biāo)1）…
反向索引：從倒數(shù)第一個(gè)（下標(biāo)-1）、倒數(shù)第二個(gè)（下標(biāo)-2）…
2.2 切片訪問
如若對(duì)上方描述不太理解，可參考下表：
| 字符串值 | H | e | l | l | o | P | y | |
|---|---|---|---|---|---|---|---|---|
| 正向索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 反向索引 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
Python訪問子字符串，可以使用中括號(hào) [ ] 來截取字符串，即切片訪問。
使用切片訪問字符串的格式為 str_name[strat : end : step] ，其中，start 表示起始索引，end 表示結(jié)束索引，step 表示步長(zhǎng)。
str1 = 'Hello Py'
print(str1[0:5])
print(str1[-8:-1])
print(str1[:])
print(str1[::2])
Hello
Hello P
Hello Py
HloP
截取字符串的一部分，遵循左閉右開原則，str[0:2] 是不包含第 3 個(gè)字符的。
2.3 for循環(huán)遍歷字符串
使用 for 循環(huán)遍歷字符串時(shí)，將會(huì)輸出字符串中的每一個(gè)字符。
str_h = 'Hi Py'
for char in str_h:
print(char)
H
i
P
y
2.4 檢查元素是否存在
如果我們需要確定在一個(gè)字符串中，是否存在相同的字符或者子字符串，可以使用成員運(yùn)算符中的 in 和 not in 關(guān)鍵字。
| 關(guān)鍵字 | 描述 |
|---|---|
| in | 如果字符串中包含給定的字符返回 True。 |
| not in | 如果字符串中不包含給定的字符返回 True。 |
str1 = 'Hello Python'
print('H' in str1)
print('Python' not in str1)
True
False
3、字符串基礎(chǔ)知識(shí)
3.1 字符串更新
我們可以截取字符串的一部分并與其他字段拼接，如下實(shí)例：
str1 = 'Hello World'
print(str1[:6] + 'Python')
Hello Python
3.2 字符串連接(合并)/復(fù)制(重復(fù))
同列表和元組一樣，字符串之間可以使用 + 號(hào)和 * 號(hào)分別實(shí)現(xiàn)字符串的連接（合并）和復(fù)制（重復(fù)），這意味著它們可以生成一個(gè)新的字符串。
1、+連接（合并）
a = 'Hello'
b = 'Python'
print(a + b)
HelloPython
2、*復(fù)制（重復(fù)）
c = 'Hello'
print(c * 5)
HelloHelloHelloHelloHello
3.3 轉(zhuǎn)義字符
如果需要在字符中使用特殊字符時(shí)，則使用反\斜杠 \ 轉(zhuǎn)義字符，如下表：
3.4 打印原始字符 r / R
原始字符串：所有的字符串都是直 接按照字面的意思來使用，沒有轉(zhuǎn)義特殊或不能打印的字符。
原始字符串除在字符串的第一個(gè)引號(hào)前加上字母 r / R （可以大小寫）以外，與普通字符串有著幾乎完全相同的語法。
print(r'\n')
print(R'\n')
print(r'\t')
print(r'\a')
\n
\n
\t
\a
3.5 格式字符串
Python支持格式化字符串的輸出。盡管這樣可能會(huì)用到非常復(fù)雜的表達(dá)式，但最基本的用法是將一個(gè)值插入到一個(gè)有字符串格式符 %s 的字符串中。
print('我叫 %s ,今年 %d 歲！' % ('pink', 21))
我叫 pink ,今年 21 歲！
在Python中，字符串格式化使用與 C語言 中 printf() 函數(shù)一樣的用法。
Python字符串格式化符號(hào)如下表所示：
| 符 號(hào) | 描述 |
|---|---|
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串 |
| %d | 格式化整數(shù) |
| %u | 格式化無符號(hào)整型 |
| %o | 格式化無符號(hào)八進(jìn)制數(shù) |
| %x | 格式化無符號(hào)十六進(jìn)制數(shù) |
| %X | 格式化無符號(hào)十六進(jìn)制數(shù)（大寫） |
| %f | 格式化浮點(diǎn)數(shù)字，可指定小數(shù)點(diǎn)后的精度 |
| %e | 用科學(xué)計(jì)數(shù)法格式化浮點(diǎn)數(shù) |
| %E | 作用同%e，用科學(xué)計(jì)數(shù)法格式化浮點(diǎn)數(shù) |
| %g | %f和%e的簡(jiǎn)寫 |
| %G | %f 和 %E 的簡(jiǎn)寫 |
| %p | 用十六進(jìn)制數(shù)格式化變量的地址 |
格式化操作符輔助指令：
| 符號(hào) | 功能 |
|---|---|
| * | 定義寬度或者小數(shù)點(diǎn)精度 |
| - | 用做左對(duì)齊 |
| + | 在正數(shù)前面顯示加號(hào)( + ) |
| <sp> | 在正數(shù)前面顯示空格 |
| # | 在八進(jìn)制數(shù)前面顯示零(‘0’)，在十六進(jìn)制前面顯示’0x’或者’0X’(取決于用的是’x’還是’X’) |
| 0 | 顯示的數(shù)字前面填充’0’而不是默認(rèn)的空格 |
| % | ‘%%‘輸出一個(gè)單一的’%’ |
| (var) | 映射變量(字典參數(shù)) |
| m.n. | m 是顯示的最小總寬度,n 是小數(shù)點(diǎn)后的位數(shù)(如果可用的話) |
Python2.6 開始，新增了一種格式化字符串的函數(shù) str.format()，它增強(qiáng)了字符串格式化的功能。
3.6 三引號(hào)
Python三引號(hào)允許一個(gè)字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。實(shí)例如下：
str1 = """這是一個(gè)多行字符串
多行字符串可以使用制表符
TAB[\t]
也可以使用換行符[\n]
"""
print(str1)
這是一個(gè)多行字符串
多行字符串可以使用制表符
TAB[ ]
也可以使用換行符[
]
三引號(hào)讓程序員從引號(hào)和特殊字符串的泥潭里面解脫出來，自始至終保持一小塊字符串的格式是所謂的WYSIWYG（所見即所得）格式的。
當(dāng)你需要一塊HTML或者SQL時(shí)，這時(shí)用字符串組合，特殊字符串轉(zhuǎn)義將會(huì)非常的繁瑣。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
3.7 f-string
f-string 是 python3.6 之后版本添加的，稱之為字面量格式化字符串，是新的格式化字符串的語法。
之前我們習(xí)慣用百分號(hào) (%):
name = 'pink'
print('Hello %s' % name)
f-string 格式化字符串以 f 開頭，后面跟著字符串，字符串中的表達(dá)式用大括號(hào) {} 包起來，它會(huì)將變量或表達(dá)式計(jì)算后的值替換進(jìn)去，實(shí)例如下：
name = 'pink'
print(f'Hello {name}')
print(f'{1 + 2}')
baidu = {'name': 'Baidu', 'url': 'https://www.baidu.com'}
print(f'{baidu["name"]}:{baidu["url"]}')
Hello pink
3
Baidu:https://www.baidu.com
用了這種方式明顯更簡(jiǎn)單了，不用再去判斷使用 %s，還是 %d。
在 Python 3.8 的版本中可以使用 = 符號(hào)來拼接運(yùn)算表達(dá)式與結(jié)果：
x = 1
print(f'{x + 1}')
y = 1
print(f'{x + 1 = }')
2
x + 1 = 2
3.8 Unicode 字符串
在Python2中，普通字符串是以8位ASCII碼進(jìn)行存儲(chǔ)的，而Unicode字符串則存儲(chǔ)為16位unicode字符串，這樣能夠表示更多的字符集。使用的語法是在字符串前面加上前綴 u。
在Python3中，所有的字符串都是Unicode字符串。
4、內(nèi)置函數(shù)
4.1 打印輸出 print()
1、print()函數(shù)
print() 函數(shù)的功能我們已經(jīng)非常熟悉了，就是打印輸出。
str1 = 'Hello Python'
print(str1)
Hello Python
4.2 確定字符串長(zhǎng)度 len()
2、len()函數(shù)
當(dāng)我們要確定一個(gè)字符串中有多少個(gè)字符時(shí)，我們可以使用 len() 函數(shù)。
str2 = 'Hello Python'
print(len(str2))
12
4.3 返回變量類型 type()
3、type()函數(shù)
使用 type() 函數(shù)可以確定變量是什么類型（字符串、列表、元組、字典或集合）。
str3 = 'Hello Python'
print(type(str3))
<class 'str'>
當(dāng)對(duì) str3 使用 type() 確定變量類型時(shí)，會(huì)返回
<class 'str'>，表明這是一個(gè)字符串。
4.4 轉(zhuǎn)換為字符串 str()
4、str()函數(shù)
我們可以使用 str() 函數(shù)將列表、元組、字典、集合和區(qū)間等對(duì)象轉(zhuǎn)換為字符串，以下將會(huì)一一介紹：
- 將列表轉(zhuǎn)換為字符串
list1 = ['a', 'b', 'c']
print(type(str(list1)))
print(str(list1))
<class 'str'>
['a', 'b', 'c']
- 將元組轉(zhuǎn)換為字符串
tuple1 = ('A', 'B', 'C')
print(type(str(tuple1)))
print(str(tuple1))
<class 'str'>
('A', 'B', 'C')
- 將字典轉(zhuǎn)換為字符串
dict1 = {'name': 'pink'}
print(type(str(dict1)))
print(str(dict1))
<class 'str'>
{'name': 'pink'}
- 將集合轉(zhuǎn)換為字符串
set1 = {'name', 'gender'}
print(type(str(set1)))
print(str(set1))
<class 'str'>
{'name', 'gender'}
- 將區(qū)間轉(zhuǎn)換為字符串
range1 = range(0, 10)
print(type(str(range1)))
print(str(range1))
<class 'str'>
range(0, 10)
4.5 字符串最大/小字符 max()、min()
5、max()函數(shù)和min()函數(shù)
max() 函數(shù)的作用是返回字符串中最大的字符。min() 函數(shù)的作用是返回字符串中最小的字符。
str_m = 'AazZ'
print(max(str_m))
print(min(str_m))
z
A
4.6 刪除字符串 del
在Python中，del 函數(shù)并不支持刪除字符串中的單個(gè)字符，但我們可以使用 del 函數(shù)刪除整個(gè)字符串：
str1 = 'Hello Python'
del str1
print(str1)
當(dāng)我們使用 del 函數(shù)刪除某字符串后，如果再使用 print() 函數(shù)打印輸出時(shí)，會(huì)報(bào)錯(cuò)
NameError: name 'str1' is not defined，表明該字符串未被定義。
5、內(nèi)置方法
5.1 轉(zhuǎn)換
5.1.1 字符(串)轉(zhuǎn)換 capitalize()、casefold()、lower()、upper()、title()、swapcase()
1、 capitalize()方法
capitalize() 將字符串的第一個(gè)字母變成大寫，其他字母變小寫。
語法
string.capitalize()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'hello python'
print(str1.capitalize())
Hello python
2、casefold()方法
casefold() 方法返回一個(gè)字符串，其中所有字符均為小寫。
語法
string.casefold()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'Hello Python'
print(str1.casefold())
hello python
此方法與 lower() 方法相似，但是 casefold() 方法更強(qiáng)大，更具攻擊性，這意味著它將更多字符轉(zhuǎn)換為小寫字母，并且在比較兩個(gè)用 casefold() 方法轉(zhuǎn)換的字符串時(shí)會(huì)找到更多匹配項(xiàng)。
3、lower()方法
lower() 方法轉(zhuǎn)換字符串中所有大寫字符為小寫（符號(hào)和數(shù)字將被忽略）。
語法
string.lower()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'Hello Python'
print(str1.lower())
hello python
4、upper()方法
upper() 方法將字符串中的小寫字母轉(zhuǎn)為大寫字母（符號(hào)和數(shù)字將被忽略）。
語法
string.upper()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'Hello Python'
print(str1.upper())
HELLO PYTHON
5、title()方法
title() 方法返回"標(biāo)題化"的字符串,就是說所有單詞的首個(gè)字母轉(zhuǎn)化為大寫，其余字母均為小寫。
語法
string.title()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'HELLO Python'
print(str1.title())
Hello Python
6、swapcase()方法
swapcase() 方法用于對(duì)字符串的大小寫字母進(jìn)行轉(zhuǎn)換，即將大寫字母轉(zhuǎn)換為小寫字母，小寫字母會(huì)轉(zhuǎn)換為大寫字母。
語法
string.swapcase()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'Hello Python'
print(str1.swapcase())
hELLO pYTHON
5.1.2 判斷大小寫 islower()、isupper()、istitle()
1、islower()方法
islower() 方法檢測(cè)字符串是否由小寫字母組成。
語法
string.islower()
參數(shù)值
無參數(shù)
str1 = 'Hello Python'
print(str1.islower())
False
如果所有字符均為小寫，則 islower() 方法返回 True，否則返回 False。不檢查數(shù)字、符號(hào)和空格，僅檢查字母字符。
2、isupper()方法
isupper() 方法檢測(cè)字符串中所有的字母是否都為大寫。
語法
string.isupper()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'Hello Python'
print(str1.isupper())
False
如果所有字符均大寫，則 isupper() 方法返回 True，否則返回 False。不檢查數(shù)字、符號(hào)和空格，僅檢查字母字符。
3、istitle()方法
istitle() 方法檢測(cè)字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫。
語法
string.istitle()
參數(shù)值
無參數(shù)
實(shí)例
str1 = 'Hello Python'
print(str1.istitle())
True
如果文本中的所有單詞均以大寫字母開頭，而單詞的其余部分均為小寫字母，則 istitle() 方法返回 True。否則返回 False。符號(hào)和數(shù)字將被忽略。
5.2 搜索值
5.2.1 返回出現(xiàn)次數(shù) count()
count()方法
count() 方法用于統(tǒng)計(jì)字符串里某個(gè)字符出現(xiàn)的次數(shù)?？蛇x參數(shù)為在字符串搜索的開始與結(jié)束位置。
語法
string.count(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。字符串。要檢索的字符串。 |
| start | 可選。整數(shù)。開始檢索的位置。默認(rèn)是 0。 |
| end | 可選。整數(shù)。結(jié)束檢索的位置。默認(rèn)是字符串的結(jié)尾。 |
實(shí)例
txt = "I love apples, apple are my favorite fruit"
print(txt.count("apple", 10, 24))
1
5.2.2 從左搜索并返回 find()、index()
1、find()方法
find() 方法檢測(cè)字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結(jié)束） 范圍，則檢查是否包含在指定范圍內(nèi)，如果指定范圍內(nèi)如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回 -1。
語法
string.find(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。要檢索的值。 |
| start | 可選。開始檢索的位置。默認(rèn)是 0。 |
| end | 可選。結(jié)束檢索的位置。默認(rèn)是字符串的結(jié)尾。 |
實(shí)例
- 字母 “e” 在文本總首次出現(xiàn)的位置：
txt = "Hello, welcome to my world."
x = txt.find("e")
print(x)
1
- 如果只搜索位置 5 到 10 時(shí)，字母 “e” 在文本總首次出現(xiàn)的位置：
txt = "Hello, welcome to my world."
x = txt.find("e", 5, 10)
print(x)
8
- 如果找不到該值，則 find() 方法返回 -1，但是 index() 方法將引發(fā)異常：
txt = "Hello, welcome to my world."
print(txt.find("q"))
print(txt.index("q"))
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 4, in <module>
print(txt.index("q"))
ValueError: substring not found
-1
2、index()方法
index() 方法檢測(cè)字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結(jié)束） 范圍，則檢查是否包含在指定范圍內(nèi)，該方法與 find() 方法一樣，只不過如果str不在 string中會(huì)報(bào)一個(gè)異常。
語法
string.index(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。要檢索的值。 |
| start | 可選。在哪里開始檢索。默認(rèn)是 0。 |
| end | 可選。在哪里結(jié)束檢索。默認(rèn)是字符串的末尾。 |
實(shí)例
- 字母 “e” 在文本中首次出現(xiàn)在哪里？
txt = "Hello, welcome to my world."
x = txt.index("e")
print(x)
1
- 如果只在位置 5 和 10 之間搜索時(shí)，字母 "e"首次首先在哪里？
txt = "Hello, welcome to my world."
x = txt.index("e", 5, 10)
print(x)
8
- 如果找不到該值，則 find() 方法返回 -1，但是 index() 方法將引發(fā)異常：
txt = "Hello, welcome to my world."
print(txt.find("q"))
print(txt.index("q"))
-1
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>
print(txt.index("q"))
ValueError: substring not found
3、find() 和 index() 區(qū)別
find() 方法與 index() 方法幾乎相同，唯一的區(qū)別是，如果找不到該值，index() 方法將引發(fā)異常，則 find() 方法將返回 -1。
5.2.3 從右搜索并返回 rfind()、rindex()
1、rfind()方法
rfind() 返回字符串最后一次出現(xiàn)的位置，如果沒有匹配項(xiàng)則返回 -1 。
語法
string.rfind(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。要檢索的值。 |
| start | 可選。從何處開始檢索。默認(rèn)是 0。 |
| end | 可選。在何處結(jié)束檢索。默認(rèn)是到字符串的末尾。 |
實(shí)例
- 在哪里最后出現(xiàn)文本中的字母 “e”？
txt = "Hello, welcome to my world."
x = txt.rfind("e")
print(x)
13
- 如果只在位置 5 和位置 10 之間搜索，文本中最后出現(xiàn)的字母 “e” 在何處？
txt = "Hello, welcome to my world."
x = txt.rfind("e", 5, 10)
print(x)
8
- 如果找不到該值，則 rfind() 方法返回 -1，但是 rindex() 方法將引發(fā)異常：
txt = "Hello, welcome to my world."
print(txt.rfind("q"))
print(txt.rindex("q"))
-1
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>
print(txt.rindex("q"))
ValueError: substring not found
2、rindex()方法
rindex() 返回子字符串 str 在字符串中最后出現(xiàn)的位置，如果沒有匹配的字符串會(huì)報(bào)異常，你可以指定可選參數(shù)[beg:end]設(shè)置查找的區(qū)間。
語法
string.rindex(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。要檢索的值。 |
| start | 可選。從何處開始檢索。默認(rèn)是 0。 |
| end | 可選。在何處結(jié)束檢索。默認(rèn)是到字符串的末尾。 |
實(shí)例
- 在哪里最后出現(xiàn)文本中的字母 “e”？
txt = "Hello, welcome to my world."
x = txt.rindex("e")
print(x)
13
- 如果只在位置 5 和位置 10 之間搜索，文本中最后出現(xiàn)的字母 “e” 在何處？
txt = "Hello, welcome to my world."
x = txt.rindex("e", 5, 10)
print(x)
8
- 如果找不到該值，則 rfind() 方法返回 -1，但是 rindex() 方法將引發(fā)異常：
txt = "Hello, welcome to my world."
print(txt.rfind("q"))
print(txt.rindex("q"))
-1
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>
print(txt.rindex("q"))
ValueError: substring not found
3、rfind() 和 rindex() 區(qū)別
rfind() 和 rindex() 都是查找指定值的最后一次出現(xiàn)。如果找不到該值，則 rfind() 方法將返回 -1，而 rindex() 方法將引發(fā)異常。
5.3 以 str 開頭/結(jié)束 startswith()、endswith()
1、startswith()方法
startswith() 方法用于檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數(shù) beg 和 end 指定值，則在指定范圍內(nèi)檢查。
語法
string.startswith(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。檢查字符串是否以其開頭的值。 |
| start | 可選。整數(shù)，規(guī)定從哪個(gè)位置開始搜索。 |
| end | 可選。整數(shù)，規(guī)定結(jié)束搜索的位置。 |
實(shí)例
檢查位置 7 到 20 是否以字符 “wel” 開頭：
txt = "Hello, welcome to my world."
x = txt.startswith("wel", 7, 20)
print(x)
True
如果字符串以指定的值開頭，則 startswith() 方法返回 True，否則返回 False。
2、endswith()方法
endswith() 方法用于判斷字符串是否以指定后綴結(jié)尾，如果以指定后綴結(jié)尾返回 True，否則返回 False?？蛇x參數(shù) “start” 與 “end” 為檢索字符串的開始與結(jié)束位置。
語法
string.endswith(value, start, end)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。檢查字符串是否以之結(jié)尾的值。 |
| start | 可選。整數(shù)。規(guī)定從哪個(gè)位置開始檢索。 |
| end | 可選。整數(shù)。規(guī)定從哪個(gè)位置結(jié)束檢索。 |
實(shí)例
- 檢查字符串是否以短語 “my world.” 結(jié)尾：
txt = "Hello, welcome to my world."
x = txt.endswith("my world.")
print(x)
True
- 檢查位置 5 至 11 是否以短語 “my world.” 結(jié)尾：
txt = "Hello, welcome to my world."
x = txt.endswith("my world.", 5, 11)
print(x)
False
如果字符串以指定值結(jié)尾，則 endswith() 方法返回 True，否則返回 False。
5.4 編/解碼 encode()、decode()
encode()和 decode()
encode() 方法以指定的編碼格式編碼字符串，decode() 方法以指定的解碼格式解碼字符串。
errors參數(shù)可以指定不同的錯(cuò)誤處理方案。
語法
string.encode(encoding=encoding, errors=errors)
string.decode(decoding=decoding, errors=errors)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| encoding / decoding | 可選。字符串。規(guī)定要使用的編碼/解碼。默認(rèn)是 UTF-8。 |
| errors | 可選。字符串。規(guī)定錯(cuò)誤方法。合法值是： ‘backslashreplace’ - 使用反斜杠代替無法編碼的字符 ‘ignore’ - 忽略無法編碼的字符 ‘namereplace’ - 用解釋字符的文本替換字符 ‘strict’ - 默認(rèn)值，失敗時(shí)引發(fā)錯(cuò)誤 ‘replace’ - 用問號(hào)替換字符 ‘xmlcharrefreplace’ - 用 xml 字符替換字符 |
實(shí)例
str = 'pink老師'
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
print("UTF-8 編碼：", str_utf8)
print("GBK 編碼：", str_gbk)
print("UTF-8 解碼：", str_utf8.decode('UTF-8', 'strict'))
print("GBK 解碼：", str_gbk.decode('GBK', 'strict'))
UTF-8 編碼： b'pink\xe8\x80\x81\xe5\xb8\x88'
GBK 編碼： b'pink\xc0\xcf\xca\xa6'
UTF-8 解碼： pink老師
GBK 解碼： pink老師
5.5 填充對(duì)齊 center()、ljust()、rjust()、zfill()
1、center()方法
center() 方法返回一個(gè)指定的寬度 width 居中的字符串，fillchar 為填充的字符，默認(rèn)為空格。
語法
string.center(length, character)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| length | 必需。所返回字符串的長(zhǎng)度。 |
| character | 可選。填補(bǔ)兩側(cè)缺失空間的字符。默認(rèn)是 " "（空格）。 |
實(shí)例
使用字母 “O” 作為填充字符：
txt = "banana"
x = txt.center(20, "O")
print(x)
OOOOOOObananaOOOOOOO
2、ljust()方法
ljust() 方法返回一個(gè)原字符串左對(duì)齊,并使用空格填充至指定長(zhǎng)度的新字符串。如果指定的長(zhǎng)度小于原字符串的長(zhǎng)度則返回原字符串。
語法
string.ljust(length, character)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| length | 必需。所返回字符串的長(zhǎng)度。 |
| character | 可選。用于填充缺少空間（在字符串的右側(cè)）的字符。默認(rèn)值為 " "（空格）。 |
實(shí)例
使用字母 “O” 作為填充字符：
txt = "banana"
x = txt.ljust(20, "O")
print(x)
bananaOOOOOOOOOOOOOO
3、rjust()方法
rjust() 返回一個(gè)原字符串右對(duì)齊,并使用空格填充至長(zhǎng)度 width 的新字符串。如果指定的長(zhǎng)度小于字符串的長(zhǎng)度則返回原字符串。
語法
string.rjust(length, character)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| length | 必需。所返回字符串的長(zhǎng)度。 |
| character | 可選。用于填充缺失空間（在字符串的左側(cè)）字符。默認(rèn)值為 " "（空格）。 |
實(shí)例
使用字母 “O” 作為填充字符：
txt = "banana"
x = txt.rjust(20, "O")
print(x)
OOOOOOOOOOOOOObanana
4、zfill()方法
zfill() 方法返回指定長(zhǎng)度的字符串，原字符串右對(duì)齊，前面填充0。
語法
string.zfill(len)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| len | 必需。數(shù)字，規(guī)定要?jiǎng)h除的元素的位置。 |
實(shí)例
用零填充字符串，直到它們長(zhǎng)為 10 個(gè)字符：
a = "hello"
b = "welcome to my world"
c = "10.000"
print(a.zfill(10))
print(b.zfill(10))
print(c.zfill(10))
00000hello
welcome to my world
000010.000
zfill() 方法在字符串的開頭添加零（0），直到達(dá)到指定的長(zhǎng)度。如果 len 參數(shù)的值小于字符串的長(zhǎng)度，則不執(zhí)行填充。
5.6 刪除左/右指定字符 lstrip()、rstrip()、strip()
1、lstrip()方法
lstrip() 方法用于截掉字符串左邊的空格或指定字符。
語法
string.lstrip(characters)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| characters | 可選。一組作為前導(dǎo)字符要?jiǎng)h除的字符。 |
實(shí)例
刪除前導(dǎo)字符：
txt = ",,,,,ssaaww.....banana"
x = txt.lstrip(",.asw")
print(x)
banana
2、rstrip()方法
rstrip() 刪除 string 字符串末尾的指定字符，默認(rèn)為空白符，包括空格、換行符、回車符、制表符。
語法
string.rstrip(characters)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| characters | 可選。一組作為結(jié)尾字符要?jiǎng)h除的字符。 |
實(shí)例
刪除結(jié)尾字符：
txt = "banana,,,,,ssaaww....."
x = txt.rstrip(",.asw")
print(x)
banan
3、strip()方法
strip() 方法用于移除字符串頭尾指定的字符（默認(rèn)為空格）或字符序列。
語法
string.strip(characters)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| characters | 可選。一組字符，要?jiǎng)h除的前導(dǎo)/尾隨字符的字符。 |
實(shí)例
刪除前導(dǎo)和尾隨字符：
txt = ",,,,,rrttgg.....banana....rrr"
x = txt.strip(",.grt")
print(x)
banana
5.7 判斷字符(串)
5.7.1 空白字符 isspace()
1、isspace()方法
isspace() 方法檢測(cè)字符串是否只由空白字符組成。
語法
string.isspace()
參數(shù)值
無參數(shù)
實(shí)例
txt = " s "
x = txt.isspace()
print(x)
False
如果字符串中的所有字符都是空格，則 isspace() 方法將返回 True，否則返回 False。
5.7.2 可打印 isprintable()
2、isprintable()方法
isprintable() 方法檢查文本中的所有字符是否可打印。
語法
string.isprintable()
參數(shù)值
無參數(shù)
實(shí)例
txt = "Hello!\nAre you #1?"
x = txt.isprintable()
print(x)
False
如果所有字符都是可打印的，則 isprintable() 方法返回 True，否則返回 False。不可打印的字符可以是回車和換行符。
5.7.3 標(biāo)識(shí)符 isidentifier()
3、isidentifier()方法
isidentifier() 方法檢查字符串是否是有效標(biāo)識(shí)符。
語法
string.isidentifier()
參數(shù)值
無參數(shù)
實(shí)例
a = "MyFolder"
b = "Demo002"
c = "2bring"
d = "my demo"
print(a.isidentifier())
print(b.isidentifier())
print(c.isidentifier())
print(d.isidentifier()
True
True
False
False
如果字符串是有效標(biāo)識(shí)符，則 isidentifier() 方法返回 True，否則返回 False。
如果字符串僅包含字母數(shù)字字母（a-z）和（0-9）或下劃線（_），則該字符串被視為有效標(biāo)識(shí)符。有效的標(biāo)識(shí)符不能以數(shù)字開頭或包含任何空格。
5.7.4 字母/數(shù)字 isalnum()
4、isalnum()方法
isalnum() 方法檢測(cè)字符串是否由字母和數(shù)字組成。
語法
string.isalnum()
參數(shù)值
無參數(shù)
實(shí)例
檢查文本中的所有字符是否都是字母數(shù)字：
txt = "Company 12"
x = txt.isalnum()
print(x)
False
如果所有字符均為字母數(shù)字，即字母（a-z）和數(shù)字（0-9），則 isalnum() 方法返回 True。
非字母數(shù)字的例子：(space)!#%&? 等等。
5.7.5 字母/中文 isalpha()
5、isalpha()方法
isalpha() 方法檢測(cè)字符串是否只由字母或文字組成。
語法
string.isalpha()
參數(shù)值
無參數(shù)
實(shí)例
檢查文本中的所有字符是否都是字母：
txt = "Company10"
x = txt.isalpha()
print(x)
False
如果所有字符都是字母（a-z），則 isalpha() 方法將返回 True。
非字母的字符例子：(space)!#%&? 等等。
5.7.6 數(shù)字 isdigit()、isnumeric()、isdecimal()
6.1、isdigit()方法
isdigit() 方法檢測(cè)字符串是否只由數(shù)字組成。
語法
string.isdigit()
參數(shù)值
無參數(shù)
實(shí)例
檢查文本中的所有字符是否都是字母：
a = "\u0030" # unicode for 0
b = "\u00B2" # unicode for 2
print(a.isdigit())
print(b.isdigit())
True
True
如果所有字符都是數(shù)字，則 isdigit() 方法將返回 True，否則返回 False。
指數(shù)（例如2）也被視作數(shù)字。
6.2、isnumeric()方法
isnumeric() 方法檢測(cè)字符串是否只由數(shù)字組成，數(shù)字可以是： Unicode 數(shù)字，全角數(shù)字（雙字節(jié)），羅馬數(shù)字，漢字?jǐn)?shù)字。
指數(shù)類似 2 與分?jǐn)?shù)類似 ? 也屬于數(shù)字。
語法
string.isnumeric()
參數(shù)值
無參數(shù)
實(shí)例
檢查字符是否為數(shù)字：
a = "\u0030" # unicode for 0
b = "\u00B2" # unicode for 2
c = "10km2"
print(a.isnumeric())
print(b.isnumeric())
print(c.isnumeric())
True
True
False
如果所有字符均為數(shù)字（0-9），則 isumeric() 方法返回 True，否則返回 False。
指數(shù)（比如 2 和 ?）也被視為數(shù)字值。
6.3、isdecimal()方法
isdecimal() 方法檢查 unicode 對(duì)象中的所有字符是否都是小數(shù)。
語法
string.isdecimal()
參數(shù)值
無參數(shù)
實(shí)例
檢查 unicode 中的所有字符是否都是小數(shù)：
a = "\u0030" # unicode for 0
b = "\u0047" # unicode for G
print(a.isdecimal())
print(b.isdecimal())
True
False
如果所有字符均為小數(shù)（0-9），則 isdecimal() 方法將返回 True。
此方法用于 unicode 對(duì)象。
5.8 格式字符串中指定值 format()、format_map()
1、format()方法
format() 方法格式化指定的值，并將其插入字符串的占位符內(nèi)，占位符使用大括號(hào) {} 定義。
語法
string.format(value1, value2...)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value1, value2… | 必需。一個(gè)或多個(gè)應(yīng)該格式化并插入字符串的值。值可以是數(shù)字，用于指定要?jiǎng)h除的元素的位置。 這些值可以是用逗號(hào)分隔的值列表、鍵=值列表，或兩者的組合。 這些值可以是任何數(shù)據(jù)類型。 |
占位符
可以使用命名索引 {price}、編號(hào)索引{0}、甚至空的占位符 {} 來標(biāo)識(shí)占位符。
實(shí)例
使用不同的占位符值：
txt1 = "My name is {fname}, I'am {age}".format(fname="Bill", age=64)
txt2 = "My name is {0}, I'am {1}".format("Bill", 64)
txt3 = "My name is {}, I'am {}".format("Bill", 64)
print(txt1)
print(txt2)
print(txt3)
My name is Bill, I'am 64
My name is Bill, I'am 64
My name is Bill, I'am 64
格式化類型
在占位符內(nèi)，您可以添加格式化類型以格式化結(jié)果：
| 格式化類型 | 描述 |
|---|---|
| :< | 左對(duì)齊結(jié)果（在可用空間內(nèi)） |
| :> | 右對(duì)齊結(jié)果（在可用空間內(nèi)） |
| :^ | 居中對(duì)齊結(jié)果（在可用空間內(nèi)） |
| := | 將標(biāo)志放置在最左側(cè) |
| :+ | 使用加號(hào)指示結(jié)果是正數(shù)還是負(fù)數(shù) |
| :- | 負(fù)號(hào)僅用于負(fù)值 |
| : | 使用空格在正數(shù)之前插入一個(gè)多余的空格（在負(fù)數(shù)之前使用減號(hào)） |
| :, | 使用逗號(hào)作為千位分隔符 |
| :_ | 使用下劃線作為千位分隔符 |
| :b | 二進(jìn)制格式 |
| :c | 將值轉(zhuǎn)換為相應(yīng)的 unicode 字符 |
| :d | 十進(jìn)制格式 |
| :e | 科學(xué)格式，帶有小寫字母 E |
| :E | 科學(xué)格式，帶有大寫字母 E |
| :f | 定點(diǎn)數(shù)字格式 |
| :F | 定點(diǎn)數(shù)字格式，以大寫形式顯示（將 inf 和 nan 顯示為 INF 和 NAN） |
| :g | 通用格式 |
| :G | 通用格式（將大寫 E 用作科學(xué)計(jì)數(shù)法） |
| ?? | 八進(jìn)制格式 |
| :x | 十六進(jìn)制格式，小寫 |
| :X | 十六進(jìn)制格式，大寫 |
| :n | 數(shù)字格式 |
| :% | 百分比格式 |
2、format_map()方法
format_map() 方法格式化字符串中的指定值。
語法
str.format_map(mapping)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| mapping | 字典類型的數(shù)據(jù)。 |
實(shí)例
str_a = '我是 {name} 老師 {gender} {age} 歲'
dict_1 = {'name': 'pink', 'gender': '男', 'age': 21}
print(str_a.format_map(dict_1))
我是 pink 老師 男 21 歲
5.9 拆分/截取字符串 split()、rsplit()、splitlines()
1、split()方法
split() 通過指定分隔符從左側(cè)對(duì)字符串進(jìn)行切片，如果第二個(gè)參數(shù) num 有指定值，則分割為 num+1 個(gè)子字符串。
語法
string.split(separator, max)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| separator | 可選。規(guī)定分割字符串時(shí)要使用的分隔符。默認(rèn)值為空白字符。 |
| max | 可選。規(guī)定要執(zhí)行的拆分?jǐn)?shù)。默認(rèn)值為 -1，即“所有出現(xiàn)次數(shù)”。 |
實(shí)例
- 使用逗號(hào)后跟空格作為分隔符，分割字符串：
txt = "hello, my name is Bill, I am 63 years old"
x = txt.split(", ")
print(x)
['hello', 'my name is Bill', 'I am 63 years old']
- 使用 # 號(hào)字符作為分隔符：
txt = "apple#banana#cherry#orange"
x = txt.split("#")
print(x)
['apple', 'banana', 'cherry', 'orange']
- 將字符串拆分為最多 2 個(gè)項(xiàng)目的列表：
txt = "apple#banana#cherry#orange"
# 將 max 參數(shù)設(shè)置為 1，將返回包含 2 個(gè)元素的列表！
x = txt.split("#", 1)
print(x)
['apple', 'banana#cherry#orange']
split() 方法將字符串拆分為列表。
您可以指定分隔符，默認(rèn)分隔符是任何空白字符。
**注釋：**若指定 max，列表將包含指定數(shù)量加一的元素。
2、rsplit()方法
rsplit() 通過指定分隔符從右側(cè)對(duì)字符串進(jìn)行切片，如果第二個(gè)參數(shù) num 有指定值，則分割為 num+1 個(gè)子字符串。
語法
string.rsplit(separator, max)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| separator | 可選。規(guī)定分割字符串時(shí)要使用的分隔符。默認(rèn)值為空白。 |
| max | 可選。指定要執(zhí)行的拆分?jǐn)?shù)。默認(rèn)值為 -1，即“所有出現(xiàn)次數(shù)”。 |
實(shí)例
將字符串拆分為最多 2 個(gè)項(xiàng)目的列表：
txt = "apple, banana, cherry"
# 將 max 參數(shù)設(shè)置為 1，將返回包含 2 個(gè)元素的列表！
x = txt.rsplit(", ", 1)
print(x)
['apple, banana', 'cherry']
rsplit() 方法從右側(cè)開始將字符串拆分為列表。
如果未指定 “max”，則此方法將返回與 split() 方法相同的結(jié)果。
注釋： 若指定 max，列表將包含指定數(shù)量加一的元素。
3、splitlines()方法
splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一個(gè)包含各行作為元素的列表，如果參數(shù) keepends 為 False，不包含換行符，如果為 True，則保留換行符。
語法
string.splitlines(keeplinebreaks)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| keeplinebreaks | 可選。規(guī)定是否應(yīng)包含換行符（True）或不包含（False）。默認(rèn)值不包含（False）。 |
實(shí)例
拆分字符串，但保留換行符：
txt = "Thank you for your visiting\nWelcome to China"
x = txt.splitlines(True)
print(x)
['Thank you for your visiting\n', 'Welcome to China']
5.10 拆分字符串(返回元組) partition()、rpartition()
1、partition()方法
partition() 方法搜索指定的字符串，并將該字符串拆分為包含三個(gè)元素的元組。
第一個(gè)元素包含指定字符串之前的部分，第二個(gè)元素包含指定的字符串，第三個(gè)元素包含字符串后面的部分。
注釋：此方法搜索指定字符串的第一個(gè)匹配項(xiàng)。
語法
string.partition(value)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。要檢索的字符串。 |
實(shí)例
- 搜索單詞 “bananas”，并返回包含三個(gè)元素的元組：
- 1 - “匹配”之前的所有內(nèi)容
- 2 - “匹配”
- 3 - “匹配”之后的所有內(nèi)容
txt = "I could eat bananas all day"
x = txt.partition("bananas")
print(x)
('I could eat ', 'bananas', ' all day')
- 如果找不到指定的值，則 partition() 方法將返回一個(gè)元組，其中包含：1 - 整個(gè)字符串，2 - 空字符串，3 - 空字符串：
txt = "I could eat bananas all day"
x = txt.partition("apples")
print(x)
('I could eat bananas all day', '', '')
2、rpartition()方法
rpartition() 方法搜索指定字符串的最后一次出現(xiàn)，并將該字符串拆分為包含三個(gè)元素的元組。
第一個(gè)元素包含指定字符串之前的部分，第二個(gè)元素包含指定的字符串，第三個(gè)元素包含字符串之后的部分。
語法
string.rpartition(value)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| value | 必需。要檢索的字符串。 |
實(shí)例
- 搜索單詞 “bananas” 的最后一次出現(xiàn)，并返回包含三個(gè)元素的元組：
- 1 - “匹配”之前的所有內(nèi)容
- 2 - “匹配”
- 3 - “匹配”之后的所有內(nèi)容
txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("bananas")
print(x)
('I could eat bananas all day, ', 'bananas', ' are my favorite fruit')
- 如果找不到指定的值，則 rpartition() 方法將返回一個(gè)元組，其中包含：1 - 整個(gè)字符串，2 - 一個(gè)空字符串，3 - 一個(gè)空字符串：
txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("apples")
print(x)
('', '', 'I could eat bananas all day, bananas are my favorite fruit')
5.11 字符串轉(zhuǎn)換 maketrans()、translate()
1、maketrans()方法
maketrans() 方法用于創(chuàng)建字符映射的轉(zhuǎn)換表，對(duì)于接受兩個(gè)參數(shù)的最簡(jiǎn)單的調(diào)用方式，第一個(gè)參數(shù)是字符串，表示需要轉(zhuǎn)換的字符，第二個(gè)參數(shù)也是字符串表示轉(zhuǎn)換的目標(biāo)。
兩個(gè)字符串的長(zhǎng)度必須相同，為一一對(duì)應(yīng)的關(guān)系。
語法
string.maketrans(x[, y[, z]])
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| x | 必需，字符串中要替代的字符組成的字符串。 |
| y | 可選，相應(yīng)的映射字符的字符串。 |
| z | 可選，要?jiǎng)h除的字符。 |
2、translate()方法
translate() 返回被轉(zhuǎn)換的字符串。
實(shí)例
- 字母 B 替換為 b
txt = "www.Baidu.com"
url = txt.maketrans('B', 'b')
print(txt.translate(url))
www.baidu.com
- 使用字符串設(shè)置要替換的字符，一一對(duì)應(yīng)
x = "aeiou"
y = "12345"
trans = str.maketrans(x, y)
str1 = "this is a string"
print(str1.translate(trans))
th3s 3s 1 str3ng
- 設(shè)置要?jiǎng)h除的字符參數(shù)：
txt = "baidu z alibaba Z tencent"
x = "bat"
y = "BAT"
z = "zZ" # 設(shè)置刪除的字符
trans = txt.maketrans(x, y, z)
print(txt.translate(trans))
print(trans)
BAidu AliBABA TencenT
{98: 66, 97: 65, 116: 84, 122: None, 90: None
5.12 元組項(xiàng)目連接到字符串 join()
join()方法
join() 方法用于將序列中的元素以指定的字符連接生成一個(gè)新的字符串。
語法
string.join(iterable)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| iterable | 必需。所有返回值均為字符串的任何可迭代對(duì)象。 |
實(shí)例
- 使用哈希字符作為分隔符，將元組中的所有項(xiàng)目連接到字符串中：
tuple_1 = ("baidu", "alibaba", "tencent")
x = "#".join(tuple_1)
print(x)
baidu#alibaba#tencent
- 使用單詞 “TEST” 作為分隔符，將字典中的所有項(xiàng)目連接成一個(gè)字符串：
dict_1 = {"name": "Bill", "country": "USA"}
separator = "TEST"
x = separator.join(dict_1)
print(x)
nameTESTcountry
5.13 字符串替換 replace()
replace()方法
replace() 方法把字符串中的 old（舊字符串） 替換成 new(新字符串)，如果指定第三個(gè)參數(shù)max，則替換不超過 max 次。
語法
string.replace(oldvalue, newvalue, count)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| oldvalue | 必需。要檢索的字符串。 |
| newvalue | 必需。替換舊值的字符串。 |
| count | 可選。數(shù)字，指定要替換的舊值出現(xiàn)次數(shù)。默認(rèn)為所有的出現(xiàn)。 |
實(shí)例
- 替換單詞 “bananas”：
txt = "I like bananas"
x = txt.replace("bananas", "apples")
print(x)
I like apples
- 替換所有出現(xiàn)的單詞 “one”：
txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three")
print(x)
three three was a race horse, two two was three too.
- 替換前兩次出現(xiàn)的單詞 “one”：
txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three", 2)
print(x)
three three was a race horse, two two was one too.
5.14 字符串 Tab 轉(zhuǎn)換 expandtabs()
expandtabs()方法
expandtabs() 方法把字符串中的 tab 符號(hào) \t 轉(zhuǎn)為空格，tab 符號(hào) \t 默認(rèn)的空格數(shù)是 8，在第 0、8、16…等處給出制表符位置，如果當(dāng)前位置到開始位置或上一個(gè)制表符位置的字符數(shù)不足 8 的倍數(shù)則以空格代替。
語法
string.exandtabs(tabsize)
參數(shù)值
| 參數(shù) | 描述 |
|---|---|
| tabsize | 可選。規(guī)定制表符大小的數(shù)字。默認(rèn)的 tabsize 是 8。 |
實(shí)例
- 將制表符大小設(shè)置為 2 個(gè)空格：
txt = "H\te\tl\tl\to"
x = txt.expandtabs(2)
print(x)
H e l l o
- 請(qǐng)看看不同制表符大小的結(jié)果：
txt = "H\te\tl\tl\to"
print(txt)
print(txt.expandtabs())
print(txt.expandtabs(2))
print(txt.expandtabs(4))
print(txt.expandtabs(10))
H e l l o
H e l l o
H e l l o
H e l l o
H e l l o
6、總結(jié)
| 函數(shù) | 描述 |
|---|---|
| print() | 打印輸出 |
| len() | 確定字符串長(zhǎng)度 |
| type() | 返回變量類型 |
| str() | 轉(zhuǎn)換為字符串 |
| max() | 字符串最大字符 |
| min() | 字符串最小字符 |
| del | 刪除字符串 |
| 方法 | 描述 |
|---|---|
| capitalize() | 把首字符轉(zhuǎn)換為大寫 |
| casefold() | 把字符串轉(zhuǎn)換為小寫（處理其他語言且存在大小寫） |
| lower() | 把字符串轉(zhuǎn)換為小寫 |
| islower() | 如果字符串中的所有字符都是小寫，則返回 True |
| upper() | 把字符串轉(zhuǎn)換為大寫 |
| isupper() | 如果字符串中的所有字符都是大寫，則返回 True |
| title() | 返回"標(biāo)題化"字符串：所有單詞都以大寫開始，其余字母均為小寫 |
| istitle() | 如果字符串遵循標(biāo)題規(guī)則，則返回 True |
| swapcase() | 將字符串中大寫轉(zhuǎn)換為小寫，小寫轉(zhuǎn)換為大寫 |
| count(str, beg, end) | 返回str出現(xiàn)的次數(shù)，beg和end指定范圍 |
| find(str, beg, end) | 搜索指定的值并返回該位置，beg 和 end 指定范圍，不存在返回-1 |
| index(str, beg, end) | 搜索指定的值并返回該位置，beg 和 end 指定范圍，不存在報(bào)異常 |
| rfind(str, beg, end) | 類似于 find() ，不過是從右邊開始 |
| rindex( str, beg, end) | 類似于 index()，不過是從右邊開始 |
| startswith(str, beg, end) | 檢查是否以 str 開頭，beg 和 end 指定范圍，如果是，返回 True，否則返回 False |
| endswith(str, beg, end) | 檢查是否以 str 結(jié)束，beg 和 end 指定范圍，如果是，返回 True，否則返回 False |
| encode(‘UTF-8’, ‘strict’) | 編碼，出錯(cuò)默認(rèn)報(bào) ValueError 異常，除非 errors 指定的是’ignore’或者’replace’ |
| decode(‘UTF-8’, ‘strict’) | 解碼，出錯(cuò)默認(rèn)報(bào) ValueError 異常，除非 errors 指定的是’ignore’或者’replace’ |
| center(width, fillchar) | 返回一個(gè)指定的寬度width居中的字符串，fillchar為填充的字符，默認(rèn)為空格 |
| ljust(width, fillchar) | 字符串左對(duì)齊,并使用 fillchar 填充至長(zhǎng)度 width 的新字符串，fillchar 默認(rèn)為空格 |
| rjust(width, fillchar) | 字符串右對(duì)齊,并使用 fillchar 填充至長(zhǎng)度 width 的新字符串，fillchar 默認(rèn)為空格 |
| zfill (width) | 返回長(zhǎng)度為 width 的字符串，原字符串右對(duì)齊，前面填充0 |
| lstrip() | 刪除字符串左邊的空格或指定字符 |
| rstrip() | 刪除字符串末尾的空格或指定字符 |
| strip() | 在字符串上執(zhí)行 lstrip()和 rstrip()，返回字符串的剪裁版本 |
| isspace() | 如果字符串中的所有字符都是空白字符，則返回 True |
| isprintable() | 如果字符串中的所有字符都是可打印的，則返回 True |
| isidentifier() | 如果字符串是標(biāo)識(shí)符，則返回 True |
| isalnum() | 如果字符串至少有一個(gè)字符并且所有字符都是字母或數(shù)字則返回 True，否則返回 False |
| isalpha() | 如果字符串至少有一個(gè)字符并且所有字符都是字母或中文字則返回 True, 否則返回 False |
| isdigit() | 如果字符串只包含數(shù)字則返回 True ，否則返回 False |
| isnumeric() | 如果字符串中的所有字符都是數(shù)字，則返回 True |
| isdecimal() | 檢查所有字符是否都是十進(jìn)制數(shù)（0~9），是則返回 True, 否則返回 False |
| format() | 格式化字符串中的指定值 |
| format_map() | 格式化字符串中的指定值（字典） |
| split(str, num) | 以 str 為分隔符截取，若 num 指定，則截取 num+1 個(gè)子字符串，并返回列表（從左） |
| rsplit() | 以 str 為分隔符截取，若 num 指定，則截取 num+1 個(gè)子字符串，并返回列表（從右） |
| splitlines() | 在換行符處拆分字符串并返回列表 |
| partition() | 返回元組，其中的字符串分為三部分（搜索 str 第一次出現(xiàn)） |
| rpartition() | 返回元組，其中的字符串分為三部分（搜索 str 最后出現(xiàn)） |
| maketrans(x[, y[, z]]) | x – 必需，要替代的字符串， y – 可選，相應(yīng)映射的字符串， z – 可選，要?jiǎng)h除的字符 |
| translate() | 返回被轉(zhuǎn)換的字符串 |
| join() | 使用字符作為分隔符，將元組中的所有項(xiàng)目連接到字符串中 |
| replace(old, new [, max]) | 將字符串中的 old 替換成 new,如果 max 指定，則替換不超過 max |
| expandtabs(tabsize) | 把字符串 string 中的 tab 符號(hào)轉(zhuǎn)為空格，tab 符號(hào)默認(rèn)的空格數(shù)是 8 |
以上就是本文的全部?jī)?nèi)容啦！如果對(duì)您有幫助，麻煩點(diǎn)贊啦！收藏啦！歡迎各位評(píng)論區(qū)留言?。?！文章來源：http://www.zghlxwxcb.cn/news/detail-632907.html
最后編輯于：2022/7/31 16:27文章來源地址http://www.zghlxwxcb.cn/news/detail-632907.html
到了這里，關(guān)于Python 字符串str詳解（超詳細(xì)）的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
