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

創建、賦值和訪問

1. 兩種創建方式

(1) 直接賦值

s?=?"abcdef"

(2) 通過str()函數

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

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

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

2. 訪問字符串

(1) 訪問單個字符

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

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

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

(2) 訪問切片

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

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

[begin: end: step]

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

s?=?"1234567"

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

如果我們不明確給出begin和end的相應參數，那么，begin會默認為0，end會默認為n（序列長度），比如：

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

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

s = "1234567"

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

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

(3) 負切片

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

s = "1234567"

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

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

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

與正切片同理，如果

不可變性

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

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

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

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

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

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

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

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

字符串的操作符

1. 成員

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

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

2. 連接

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

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

3. 重復

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

* 表達的意思其實跟數學上是一樣的，多個相加嘛。

4. 比較

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

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

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

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

字符串的內建函數

1. 字符串長度

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

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

2. 字符串最大最小值

其實就所對應的ascii編碼最大最小的字符

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

3. enumerate and zip

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

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")

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

4. 字符串查找

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

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

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

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

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

5. 字符串判別

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

(1) string.isalnum() 當字符串中的字符都是字母或數字，返回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中所有字符都是數字，返回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() 函數實現字符串替換

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

基本參數有兩個，舊的在前，新的在后

7. 字符串分割

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

(1) string.split()：

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

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

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

東西構成列表的一個元素，就得到我們上面的結果。

(2) string.partition()：

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

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

(3) string.join()：?

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

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

8. 大小寫轉換

主要介紹三個函數：

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

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

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

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

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

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

9. 字符串簡化

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

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

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

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

http://haohuigou.com/73198.html