字符串類型在Python中是十分重要的類型，他一般用引號中間添加字符的形式表達(dá)，不同于其他語言的是，Python中雙引號（” “）與單引號（’ ‘）是不予區(qū)分的。都可以用來表示字符串

創(chuàng)建、賦值和訪問

1. 兩種創(chuàng)建方式

(1) 直接賦值

s?=?"abcdef"

(2) 通過str()函數(shù)

str()函數(shù)的作用，相當(dāng)于是通過傳入的參數(shù)，生成一個string型的對象，這個傳入的參數(shù)可能是整型，浮點(diǎn)型，也能是列表，元組，字典等。

s?=?str(21)?#?>>>?"21"
s?=?str(12.3)?#?>>>?"12.3"
s?=?str([1,?2,?3])?#?>>>?"[1,?2,?3]"

需要注意的是，“傳入的是什么，得到的就是什么”比如我們傳一個列表進(jìn)去的話，得到的字符串的第一個字符可不是列表的第一個元素，而是"["，同理 , 也被看做是字符串的一部分

2. 訪問字符串

(1) 訪問單個字符

s?=?"1234567"
print(s[1])?#?>>>?"2"
print(s[-1])?#?>>>?"7"
print(s[-7])?#?>>>?"1"

字符串當(dāng)然也是序列，所以也滿足每一個元素（也就是其中的每一個字符）都對應(yīng)一個索引，索引的設(shè)計與其他語言一樣，從0開始。

此外，Python還提供了“負(fù)索引”，就是令最后一個元素的索引為-1，倒數(shù)第二個元素的索引為-2，以此類推，第一個元素的索引就是-n（其中，n為序列的長度）

(2) 訪問切片

s?=?"1234567"
print(s[1:4])?#?>>>?"234"

切片是Python中非常有特色的語法，當(dāng)然，切片應(yīng)用的對象是序列（字符串，列表，元組），他可以用來非常方便的表示序列的一部分。切片有3個參數(shù)控制，他的形式可以如下表示：

[begin: end: step]

中間由 : 隔開，begin 表示要得到的序列的起始位置，并且包含這個位置，而 end 則表示要得到序列的結(jié)束位置，但是不能包含這個位置的元素。例如：

s?=?"1234567"

s1 = s[2:5] # >>> 取的是s中第2個位置開始，一直到第4個位置的數(shù)，也就是"345"

如果我們不明確給出begin和end的相應(yīng)參數(shù)，那么，begin會默認(rèn)為0，end會默認(rèn)為n（序列長度），比如：

s?=?"1234567"
s1?=?s[:5]?#?>>>?s1?=?"12345"
s2?=?s[2:]?#?>>>?s2?=?"34567"
s3?=?s[:]?#?>>>?復(fù)制了整個s

而切片的最后一個參數(shù)step則表示“步長”，比如：

s = "1234567"

s1 = s[1:6:2] # >>> 從第1個位置開始，直到第5個位置結(jié)束，每次“跳”2步，得到"246"

可以理解為，每取一個元素后，向后“跳”的步數(shù)為step，比如上面的例子就是跳了2步。但是step這個參數(shù)不是一定要給出的，他默認(rèn)值為1，而且當(dāng)使用默認(rèn)值1時，step之前的那個 : 如果沒有特殊的需求，也是可以省略不寫的。

(3) 負(fù)切片

有一種比較特殊的切片使用方式，那就是“負(fù)切片”，通俗地講，就是令step為負(fù)數(shù)的切片，既然我們上面已經(jīng)說過Python提供“負(fù)索引”，那么根據(jù)相同的道理，負(fù)切片自然就是從后開始，每次向前跳相應(yīng)的步數(shù)，比如：

s = "1234567"

print(s[6:1:-1]) # >>> 依次取6,5,4,3,2位置的元素， 結(jié)果是"76543"

print(s[-2:-4:-1]) # >>> 依次取-2,-3位置的元素，結(jié)果是"65"

不論是正切片，還是負(fù)切片，begin 和 end 都滿足“左閉右開”的原則。只不過正切片是從左往右（或者叫從前往后），而負(fù)切片是相反的方向。

與正切片同理，如果

不可變性

我之前說過，像整型，字符串等等，這些類型的數(shù)據(jù)是不可變的（詳見我的博文：Python–內(nèi)存管理），也就是說，一旦給這些類型的數(shù)據(jù)分配了內(nèi)存，那么就不可更改了。比如，執(zhí)行以下的操作會引發(fā)異常：

s?=?"1234567"
s[0]?=?"e"

但是，現(xiàn)實(shí)中，確實(shí)有很多情況需要我們改變字符串本身的內(nèi)容。那么，在Python中，我們通用的做法是重新建立一個string型的對象，比如：

s?=?"1234567"
s?=?s[0:3]?+?"Python"?#?>>>?s?=?"123Python"

雖然看上去的結(jié)果像是把s改變了，其實(shí)只是重新建立了一個由之前s的切片s[0:3]和字符串“Python”連接后構(gòu)成的新字符串，并被名字s引用了。

同理，我們當(dāng)然也可以用這種方法刪除字符串中的某些元素，比如：

s?=?"1234567"
s?=?s[0:3]?+?s[4:]?#?>>>?s?=?"123567"?刪除了4

其實(shí)一樣的，還是新建了字符串類型的對象。

字符串的操作符

1. 成員

我們用操作符in 和 not in 來判斷一個字符，或者一個字符串是否在另一個字符串當(dāng)中。

s?=?"abcdef"
print("ef"?in?s)?#?>>>?True
print("ac"?in?s)?#?>>>?False
print("d"?not?in?s)?#?>>>?False

2. 連接

用 + 表示兩個字符串的連接，其實(shí)前面我們也已經(jīng)見過這樣的例子了。

s1?=?"I?wrote"
s2?=?"Python"
print(s1?+?"?"?+?s2)?#?>>>?"I?wrote?Python"

3. 重復(fù)

s?=?"123"
print(s?*?3)?#?>>>?"123123123"

* 表達(dá)的意思其實(shí)跟數(shù)學(xué)上是一樣的，多個相加嘛。

4. 比較

字符串之間的比較，是以兩個字符串間，第一個不同的字符所對應(yīng)的ascii碼的大小為根據(jù)的。

s1?=?"abcde"
s2?=?"abce"
print(s1?>?s2)?#?>>>?False

而當(dāng)兩個字符串前面相同時，則以較長的字符串為大

s1?=?"abcd"
s2?=?"abc"
print(s1?>?s2)?#?>>>?True

字符串的內(nèi)建函數(shù)

1. 字符串長度

用 len(str) 的形式求取一個字符串的長度

print(len("1234567"))?#?>>>?7

2. 字符串最大最小值

其實(shí)就所對應(yīng)的ascii編碼最大最小的字符

print(max("abcd"))?#?>>>?"d"
print(min("1234"))?#?>>>?"1"

3. enumerate and zip

將字符串作為參數(shù)傳入 enumerate() 和 zip() 函數(shù)，生成相應(yīng)的enumerate型的對象和zip型的對象，然后我們在通過循環(huán)將這些對象按照我們的需要輸出即可。比如：

enum_obj?=?enumerate("abcd")?#?>>>?新建了一個enumerate型的對象
for?index,?ele?in?enum_obj:
????print(index,?ele)????????#?>>>?依次輸出:?1?"a",?2?"b",?3?"c",?4?"d"
for?i?in?zip("abcd",?"1234"):
????print(i)?????????????????#?>>>?依次輸出：("a",?"1"),?("b",?"2"),?("c","3"),?("d","4")

這樣的函數(shù)能為我們提供更加便捷的處理數(shù)據(jù)的方法。

4. 字符串查找

除了前面說的成員操作符能判斷一個字符串是否在另一個字符串當(dāng)中，函數(shù) find() 和 index() 也能做類似的工作。

s?=?"Python"
print(s.find("Py"))?#?>>>?0
print(s.find("hy"))?#?>>>?-1

find() 函數(shù)的功能是若找的見，則返回匹配部分最開始的那個位置；若找不見，則返回-1，當(dāng)然，find() 函數(shù)中還可以設(shè)置尋找的開始和結(jié)束位置。不過字符串的內(nèi)建函數(shù)實(shí)在太多，很多函數(shù)的參數(shù)設(shè)置也很細(xì)，所以我只是“拋磚引玉”，就不一 一列舉了。

index() 函數(shù)實(shí)現(xiàn)的是類似的功能，不過如果找不到的話，引發(fā)異常。所以要使用index() 函數(shù)最好用成員操作符事先加一條判斷語句，若在內(nèi)，再使用 index() 返回匹配字段的起始位置。

s?=?"Python"
print(s.index("yth"))?#?>>>?1
print(s.index("hy"))?#?>>>?引發(fā)異常

5. 字符串判別

Python還提供了很多字符串的判別函數(shù)。

(1) string.isalnum() 當(dāng)字符串中的字符都是字母或數(shù)字，返回True，否則返回False

s1?=?"123asd"
s2?=?"as,?123"
print(s1.isalnum())?#?>>>?True
print(s2.isalnum())?#?>>>?False

(2) string.isalpha() string中所有字符都是字母，返回True，否則返回False

s1?=?"Python"
s2?=?"C++"
print(s1.isalpha())?#?>>>?True
print(s2.isalpha())?#?>>>?False

(3) string.isdigit() string中所有字符都是數(shù)字，返回True，否則返回False

s1?=?"0106584376"
s2?=?"010-7487345"
print(s1.isdigit())?#?>>>?True
print(s2.isdigit())?#?>>>?False

(4) string.isupper() string中所有字母都是大寫，返回True，否則返回False?

? ? ? string.islower() string中所有字母都是小寫，返回True，否則返回False

s1?=?"SELECT"
s2?=?"Python3.5"
print(s1.isupper())?#?>>>?True
print(s2.islower())?#?>>>?False

6. 字符串替換

string.replace() 函數(shù)實(shí)現(xiàn)字符串替換

s?=?"123456"
s.replace("456",?"abc")?#?>>>?s?=?"123abc"

基本參數(shù)有兩個，舊的在前，新的在后

7. 字符串分割

常用的分割的相關(guān)函數(shù)有三個：string.split(); string.partition(); string.join()

(1) string.split()：

s?=?"I?love?you"
s.split("?")?#?>>>?以空格為分隔符，將字符串s分割成一個列表：["I",?"love",?"you"]

需要注意的是這種分割的手法實(shí)際上是以字符串的開頭為一個點(diǎn)，結(jié)尾為一個點(diǎn)，然后每個分隔符為一個點(diǎn)，若相鄰兩點(diǎn)之間又字符串，則這個字符串為列表的一個元素，若相鄰兩點(diǎn)間沒有東西，則返回一個空字符（不是空格，是空字符 ""），比如還是上面的例子，我們改一下：

s?=?"I?love?you?"
s.split("?")?#?>>>?以空格為分隔符，將字符串s分割成一個列表：["I",?"",?"love",?"you",?"",?""]
實(shí)際上，我們用點(diǎn)表示，是這樣的：s?=?".I..love.you..."?注意開頭和結(jié)尾各有一個點(diǎn)，取每兩個相鄰點(diǎn)之間的

東西構(gòu)成列表的一個元素，就得到我們上面的結(jié)果。

(2) string.partition()：

s?=?"I?love?you"
s.partition("?")?#?>>>?以空格為分隔符，從分隔符出現(xiàn)的第一個位置起，將字符串s分割成一個三個元素的列表：["I",?"?",?"love?you"]

partition() 的作用和split() 類似，只不過結(jié)果一定是三個元素的列表，且分隔符一定是第二個元素

(3) string.join()：?

這實(shí)際上是一個連接函數(shù)，但我還是把它放在分割里面講了。它的作用是以string為分隔符，將括號里面的字符串序列連接起來（注意，一定是字符串形式的序列，比如由字符串構(gòu)成的列表等等），構(gòu)成新的字符串。

print(",".join(["I",?"wrote",?"Python"]))?#?>>>?"I,wrote,Python"
print("**".join("123"))?#?>>>?"1**2**3"

8. 大小寫轉(zhuǎn)換

主要介紹三個函數(shù)：

(1) string.upper() ：將所有小寫字符轉(zhuǎn)換成大寫，但是需要注意的是，這其實(shí)只是生成了一個新的對象，而原對象并未發(fā)生改變

s?=?"bupt"
print(s.upper())?#?>>>?"BUPT"
print(s)?#?>>>?"bupt"

(2) string.lower() ：與 string.upper() 同理，只不過是大寫轉(zhuǎn)換為小寫

s?=?"Python3"
print(s.lower())?#?>>>?"Python3"

(3) string.swapcase() ：大寫換成小寫，小寫換成大寫

s?=?"I?Need?You"
print(s.swapcase())?#?>>>?"i?nEED?yOU"

9. 字符串簡化

有時候，會遇到一個字符串最左端和最右端有空格的情況，而這些空格會影響我們對字符串做處理，所以，如果有函數(shù)能化簡字符串，去除這些兩段的空格，就會讓我們十分的便捷。string.strip() 函數(shù)就是做這件事情的。

s?=?"?I?Need?You?"
s.strip()?#?>>>?"I?Need?You"

需要注意的是，字符串中間的空格不會受到影響

當(dāng)然，除了我上面介紹的9個方面之外，其實(shí)Python中關(guān)于字符串的內(nèi)建函數(shù)還有很多。當(dāng)然，常用的基本都在這里了，其他就先不介紹了。大家需要用到時，自己百度，一定會有相關(guān)的答案。

http://www.vfuj.cn/73198.html