一.關(guān)于python序列的簡介。

python里面的序列大部分都可以執(zhí)行，索引，切片，加，乘，檢查長度，以及檢查某個(gè)成員是否存在，甚至還可以找出這個(gè)序列中最小的元素和最大的元素，并且序列都是可迭代的。

解釋下個(gè)人理解的迭代，迭代（iteration），序列中的迭代就是對(duì)序列中的每個(gè)元素重復(fù)執(zhí)行某些操作／

具體的迭代方式后面會(huì)說到。

下面就說說python序列的共有特點(diǎn)。

1.索引

一個(gè)序列中，所有的元素都有自己的編號(hào)，這個(gè)編號(hào)是從0開始的，這個(gè)編號(hào)就是所謂的索引，這些元素可以通過索引來依次訪問。下面就拿字符串類型舉個(gè)例子，字符串在python中也是序列的一種。

test = "suhaozhi"

print test[0] （打印序列中的第一個(gè)元素，也就是打印字符串的第一個(gè)字符。）

s

根據(jù)上面的示例就可以看出，python中的字符串就是由字符組成的序列，索引0指向了序列中的第一個(gè)元素，在這個(gè)例子中就是s。

python中幾乎所有的序列都可以使用這種索引，如果索引是負(fù)數(shù)時(shí)，python會(huì)從右邊，也就是最后一個(gè)元素開始計(jì)數(shù)，如果想直接取序列中最后一個(gè)元素的話，可以直接使用－1。

test = "suhaozhi"

print test[-1]

i

2.分片

如果說索引一次只能訪問序列中的一個(gè)元素，那么分片就可以通過索引一次訪問序列中的一段（一個(gè)范圍的）元素。

分片操作通過冒號(hào)隔開兩個(gè)索引來實(shí)現(xiàn)。

假如說現(xiàn)在定義了一個(gè)變量，這個(gè)變量里是個(gè)字符串，字符串的內(nèi)容是www.baidu.com，現(xiàn)在要通過分片取出前面的三個(gè)字符‘www’，操作方法如下。

url = 'www.baidu.com'

print url[0:3]

www

第一個(gè)索引“0”是要提取的第一個(gè)元素編號(hào)（開頭）而最后一個(gè)索引“3”責(zé)是分片之后！剩余部分！的第一個(gè)元素號(hào)。

分片操作的視線是需要兩個(gè)索引作為邊界，第1個(gè)索引的元素是包含在分片內(nèi)的，第二個(gè)不包含在分片內(nèi)。

那么假如說這個(gè)字符串的長度未知，我只想取最后三個(gè)字符，該如何操作呢？

print url[-3:]

com

如果分片獲取到的部分需要包括結(jié)尾的元素，那么后面的索引就需要為空。

這種方法也可以用在開始的元素上。

url = 'www.baidu.com'

print url[:3]

www

3.分片之步長。

在對(duì)序列進(jìn)行分片的時(shí)候，開始和結(jié)束都需要指定，而另一個(gè)參數(shù)“步長”，這個(gè)參數(shù)是隱藏的，默認(rèn)值是1，我們的分片操作就是按照步長來逐個(gè)遍歷序列中的元素，然后返回開始和結(jié)束點(diǎn)之間所有的元素。

比如說以下面這個(gè)列表為例：

我們對(duì)下面這個(gè)列表做一個(gè)分片操作。

l1 = [1,2,3,4,5,6,7,8,9,10]

現(xiàn)在要取這個(gè)列表中的1到9。

print l1[0:9:1]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

其中0:9:1前面的0:9前面已經(jīng)解釋過了，是開始和結(jié)束的位置，最后一個(gè)1就是步長參數(shù)，不管這個(gè)參數(shù)寫不寫，默認(rèn)就是1。

如果步長被設(shè)置為比1大的數(shù)，那么就會(huì)跳過某些元素，比如說將步長設(shè)置為2，就會(huì)出現(xiàn)以下效果。

l1 = [1,2,3,4,5,6,7,8,9,10]

print l1[0:9:2]

[1, 3, 5, 7, 9]

每取一個(gè)元素都會(huì)跳過一個(gè)元素。

補(bǔ)充一點(diǎn)！：步長不可以為0，但是可以為負(fù)數(shù)！如果步長設(shè)置為負(fù)數(shù)，那么就會(huì)從右向左開始取元素。

l1 = [1,2,3,4,5,6,7,8,9,10]

print l1[::-1]

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

如果說開始的元素包括在結(jié)果之中，結(jié)束的元素，不能在分片之內(nèi)，當(dāng)使用一個(gè)負(fù)數(shù)作為步長的時(shí)候，開始的索引節(jié)點(diǎn)必須大于結(jié)束的索引！！！！對(duì)于一個(gè)正數(shù)的步長，python會(huì)從序列的頭部（左）向右開始提取元素，但是對(duì)于負(fù)數(shù)的步長，則是從序列的尾部（右）開始向左提取元素！！所以說，如果要使用負(fù)數(shù)作為步長，那么開始的索引要大于結(jié)束的索引。

4.序列之間的相加。

相同類型的序列之間是可以合并拼接起來的，只要通過＋加號(hào)就可以做到。

比如說現(xiàn)在拼接兩個(gè)列表。

print [1,2,3] + [4,5,6]

[1, 2, 3, 4, 5, 6]

這樣，兩個(gè)相同類型的序列就拼接起來了。

字符串也是如此。

print "hamasaki" + "ayumi"

hamasakiayumi

不過需要注意，不同類型的序列是不可以拼接在一起的，比如說列表和字符串，雖然說都是序列，但是它們屬于不同的類型！！！

5.關(guān)于序列與乘法。

用數(shù)字去乘以一個(gè)序列，會(huì)生成一個(gè)新的序列，在新的序列中，原來的序列會(huì)被重復(fù)n次。

比如說：

print "suhaozhi" * 5

suhaozhisuhaozhisuhaozhisuhaozhisuhaozhi

suhaozhi被重復(fù)了5遍。

print '*' * 50

**************************************************

*號(hào)被重復(fù)了50遍。

這事關(guān)于字符串的示范，列表也是一樣。

print [1,2,3] * 10

[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

那么這種蛋疼的序列乘法永在什么位置呢？

個(gè)人理解，這種序列乘法可以用來占用序列里面元素的空間，也就是初始化，創(chuàng)建一個(gè)空列表［］可以用中括號(hào)來表示，但是這個(gè)列表中什么都沒有，假如說這時(shí)需要?jiǎng)?chuàng)建一個(gè)占用是個(gè)元素的空間，但是這個(gè)列表中不能有任何內(nèi)容（每個(gè)元素必須是空值），這時(shí)候序列乘法就可以發(fā)揮作用了。

每個(gè)元素都需要為空，就意味著列表不可以有任何元素，這種情況就需要使用None了，None是python的內(nèi)建值，就是什么都沒有的意思，因此，如果想要初始化一個(gè)長度為10的列表，但是這個(gè)列表中什么都不可以放，就可以使用下面的例子來實(shí)現(xiàn)。

test = [None] * 10

print test

[None, None, None, None, None, None, None, None, None, None]

6.檢查某個(gè)成員在序列中是否存在。

檢查一個(gè)元素是否在指定的序列中，可以使用in來進(jìn)行檢測(cè)（關(guān)于in運(yùn)算符，在前面的運(yùn)算符介紹中講過了，可以查看前面的文章～），當(dāng)要檢查的元素存在于這個(gè)序列中，責(zé)返回True否則返回False，下面是使用in來檢查元素是否存在于序列的例子。

比如說檢查linux／unix文件的權(quán)限(rwx)。

permissions = ''rw"

print 'w' in permissions

True

在說一個(gè)通俗易懂的例子，檢查一個(gè)用戶的名字是否在列表上。l1 = ['linhaifeng','suhaozhi','andy']

print "suhaozhi" in l1

True

名字存在于列表中就返回了True。接著在查一個(gè)列表中沒有的。l1 = ['linhaifeng','suhaozhi','andy']

print "ayumi"

沒有的元素，就直接返回了一個(gè)False

7.計(jì)算序列長度，取出序列中的最大元素和最小元素。

python中內(nèi)置了len(),min(),max()這三個(gè)特別有用的函數(shù)，其中l(wèi)en函數(shù)可以返回序列中元素的數(shù)量，也就是這個(gè)序列的長度，min可以返回這個(gè)序列中最小的元素，max則可以返回這個(gè)序列中最大的元素。

下面演示下這三個(gè)常用函數(shù)的用法。Username = ["linhaifeng","suhaozhi","andy","tony"]

現(xiàn)在有個(gè)列表，需要計(jì)算這個(gè)列表中有多少個(gè)元素。print len(Username)

4

最后返回的結(jié)果是4，就說明這個(gè)列表中有4個(gè)元素。

計(jì)算序列長度的這個(gè)函數(shù)還可以永在字符串上，因?yàn)樽址彩切蛄械囊环N啊。print len("Hello")

5

返回的結(jié)果是5，就說明這個(gè)字符串中有5個(gè)字符。

len說完了，在簡單演示min和max函數(shù)。test = [1,2,3,4,5,6]

min(test)

1

查找test這個(gè)列表中最小的元素，這個(gè)最小的元素就是1。

再試試max函數(shù)。test = [1,2,3,4,5,6]

max(test)

6

min和max函數(shù)，一般情況下，用來查找序列中的數(shù)字，如果是英文字符串的話，是按照首字母排序去進(jìn)行查找的。

補(bǔ)充！：在這補(bǔ)充一點(diǎn)，min和max函數(shù)不只可以用于單個(gè)序列中找出最大值和最小值，這兩個(gè)函數(shù)可以同時(shí)接收多個(gè)參數(shù)，在多個(gè)參數(shù)中找出最大值和最小值。print min(1,2,3,4,5,6)

1print max(1,2,3,4,5,6)

6

二.細(xì)說python列表（list）。

基本序列所具有的功能，列表都具備，索引，分片，連接，乘法列表都可以，和字符串不同的是，列表是可以修改的，列表支持，添加元素，插入元素， 刪除元素，甚至還可以分片賦值,然而前面說的那些列表支持的功能，字符串都不能做。

1.修改列表中的元素。

想要修改列表中的某個(gè)元素，需要借助元素的索引才可以去修改，想去修改一個(gè)元素，必須明確這個(gè)元素的位置，索引。test_list = ["aaa","bbb","ccc"]

假如說，現(xiàn)在要給上面那個(gè)列表中的第0個(gè)元素“aaa”替換為“suhaozhi”，下面就是操作方法。test_list[0] = "suhaozhi"

print test_list

['suhaozhi', 'bbb', 'ccc']

這個(gè)列表中的第0個(gè)元素就被成功修改為“suhaozhi”了。

2.列表之分片賦值。

個(gè)人覺得列表的分片賦值功能做的特別的屌，分片賦值就是把修改列表中元素和分片聯(lián)合起來使用。

前面介紹了，字符串雖然也是序列的一種，但是字符串這種序列是不支持修改的，那怎么讓這種序列變得可以修改呢？這個(gè)時(shí)候就可以用到列表的分片賦值功能，其實(shí)分片賦值就是通過索引分片，然后在通過索引去修改列表中的元素，下面來做個(gè)演示～～name = "perl"

首先我們定義了一個(gè)變量，這個(gè)變量中存的是個(gè)字符串“perl”，現(xiàn)在要對(duì)這個(gè)字符串序列的最后三個(gè)字母進(jìn)行修改，把這個(gè)字符串變成python，操作方法如下。name = list("perl")

＃首先使用list()工廠函數(shù)，將perl這個(gè)字符串強(qiáng)制轉(zhuǎn)換成列表的格式，轉(zhuǎn)換后，我們先在屏幕上輸出下這個(gè)轉(zhuǎn)換后的列表看看。print name

['p', 'e', 'r', 'l']

轉(zhuǎn)換成功后，通過之前說的分片和索引，去修改列表中的元素。name[1:] = list("ython")

print name

＃然后我們來打印一下這個(gè)列表看下。

['p', 'y', 't', 'h', 'o', 'n']

＃列表中的元素已經(jīng)替換完成了，接下來需要做的就是，使用join()方法，把列表中的每個(gè)元素合并為一個(gè)字符串。print "".join(name)

python

3.刪除一個(gè)元素。

從列表中刪除一個(gè)元素，可以使用del語句來實(shí)現(xiàn)。test_list = ["aaa","bbb","ccc"]

現(xiàn)在需要?jiǎng)h除這個(gè)列表中的第二個(gè)元素（從第0個(gè)開始數(shù)）。del test_list[2]

print test_list

['aaa', 'bbb']

第二個(gè)元素“ccc”就被刪掉了。

關(guān)于del語句～在這里需要特別補(bǔ)充一下！！

del語句不只可以刪除列表中的元素，甚至還可以刪除其他元素，還可以刪除變量！！

4.python中列表中常用方法介紹。

在介紹列表的常用方法之前，先說一個(gè)關(guān)于函數(shù)和方法的概念，方法這個(gè)東西確實(shí)和函數(shù)看起來有點(diǎn)類似，但是是不一樣的，但是“方法”是需要“類”去調(diào)用的，這個(gè)“類”可能是數(shù)字，也可能是字符串，列表，活著其他對(duì)象，但是函數(shù)是可以直接使用的，這就是它們的不同，舉個(gè)例子。

當(dāng)函數(shù)被加載到內(nèi)存后，直接 函數(shù)名后面加上括號(hào)就可以使用了，就像這樣 func_name()。

而方法呢是需要通過對(duì)象去調(diào)用的，比如 對(duì)象名.方法(參數(shù))。

下面開始正式介紹列表的常用方法啦。

4.1 append用于在列表的尾部追加一個(gè)新的元素。l1= [1,2,3]＃在列表尾部添加一個(gè)新的元素4

l1.append(4)print test

[1, 2, 3, 4]

注意！！！在這里有個(gè)特別注意事項(xiàng)，就是append方法并不是簡單的返回一個(gè)修改過的新列表，而逝把原來的舊列表直接進(jìn)行操作！！！！

4.2 count 統(tǒng)計(jì)一個(gè)元素在列表中出現(xiàn)的次數(shù)。

列表中的元素是可以重復(fù)的，count方法可以統(tǒng)計(jì)一個(gè)元素在這個(gè)列表里重復(fù)出現(xiàn)了多少次。

下面是例子。test = ["suhaozhi","linhaifeng","linhaifeng"]

這個(gè)列表中有一個(gè)“suhaozhi”兩個(gè)“l(fā)inhaifeng”，用count方法就可以找出這個(gè)列表中有多少個(gè)linhaifeng。print test.count("linhaifeng")

2

返回的數(shù)值是2，就說明有2個(gè)。

4.3 extend 拓展列表，可以一次性在列表的末尾追加n個(gè)值，還可以用一個(gè)新的列表去拓展原有的列表。lia= [1,2,3]

lib = [4,5,6]

現(xiàn)在有l(wèi)ia和lib兩個(gè)列表，現(xiàn)在要將lib列表中的所有元素全部添加到lia的尾部。lia.extend(lib)

添加完成后，我們?cè)賮砜纯磍ia列表。print lia

[1, 2, 3, 4, 5, 6]

關(guān)于extend方法有個(gè)很重要的知識(shí)點(diǎn)需要補(bǔ)充！！！！！

還記得之前說的使用＋加號(hào)去連接兩個(gè)相同的序列嗎？[1,2,3] + [4,5,6] extend方法和這種拼接的加號(hào)看起來作用很相像，但是本質(zhì)上完全不同！！！！！extend方法會(huì)修改原有的列表！！！而加號(hào)拼接則不回修改原列表，會(huì)返回一個(gè)全新的列表！！！！這兩個(gè)地方千萬不要弄混！！

4.4 index 返回指定元素的索引。

index方法用于從列表中找出第一個(gè)匹配的元素的索引位置。lia = [1,2,3,"suhaozhi","andy","suhaozhi"]print lia.index("suhaozhi")

3

在搜索suhaozhi的時(shí)候，就會(huì)發(fā)現(xiàn)它在索引為3號(hào)的位置，這個(gè)列表中有兩個(gè)“suhaozhi”但是index方法會(huì)從列表的左側(cè)開始找，如果找到了，直接返回結(jié)果，不在向下匹配了。

如果找不到指定的元素，那么index方法就會(huì)拋出一個(gè)異常。

4.5 insert 將指定的對(duì)象按照指定的位置插入到列表中。li1 = [1,3,5,7,9]

這有個(gè)列表，現(xiàn)在想把字符串“two”，插入到索引為1的位置，也就是1和3的中間。li1.insert(1,"two")print li1

[1, 'two', 3, 5, 7, 9]

4.6 pop 彈出，從列表中彈出一個(gè)元素，默認(rèn)彈出最后一個(gè)，但是可以通過索引來指定具體彈出哪個(gè)元素。

在這解釋下彈出是什么意思，彈出就是從列表中刪除一個(gè)元素，在這個(gè)元素被刪除時(shí)，被刪除的這個(gè)元素會(huì)作為執(zhí)行這個(gè)方法的返回值。

下面是關(guān)于pop方法的操作：li1 = [1,2,3,4]

l11.pop()

print li1

[1, 2, 3]

這個(gè)列表最末尾的元素4被彈出了。

接下來我們手動(dòng)指定彈出第0個(gè)元素。l1 = [1,2,3]

l1.pop(0)

print l11

[2, 3]

第0個(gè)元素就從列表中被彈出了。

這個(gè)pop方法在什么情況下會(huì)使用呢？

在實(shí)現(xiàn)后進(jìn)先出（LIFO）隊(duì)列的時(shí)候，pop方法就發(fā)揮出它的用處了。

在這介紹下什么是LIFO后進(jìn)先出隊(duì)列，后進(jìn)先出隊(duì)列，也被稱為，“堆棧”，就好像堆盤子，在拿盤子的時(shí)候，一次只能從頂部拿一個(gè)盤子，也就是說最后放的盤子，會(huì)被最先拿走，同樣，最后被放入隊(duì)列，最先從隊(duì)列中移除，這就是堆棧，LIFO后進(jìn)先出隊(duì)列。

接下來我們驗(yàn)證下pop是否具有彈出的功能，能否實(shí)現(xiàn)“堆棧”。l1 = [1,2,3]

l1.append(l1.pop())

print l1

[1, 2, 3]

li1.pop()先被執(zhí)行，最末尾的元素3被彈出，被彈出后作為返回值被li1.append()方法又一次放回到了li1列表的尾部，這樣就實(shí)現(xiàn)了“堆棧”，以后在需要后進(jìn)先出隊(duì)列的時(shí)候，就可以使用列表的pop方法來實(shí)現(xiàn)。

4.7 remove移除，從列表中移除一個(gè)元素，但是沒有返回值～

remove方法可以用來移除列表中第一個(gè)匹配到的元素。l1 = ['linhaifeng','suhaozhi','linhaifeng']

l1.remove('linhaifeng')

['suhaozhi', 'linhaifeng']

從上面的例子就可以看到，只有第一次被匹配到的元素被刪除了。

當(dāng)使用remove刪除一個(gè)不存在的元素，則會(huì)直接拋出異常！

remove和pop最大的區(qū)別就是，remove刪除一個(gè)元素是沒有任何返回值的。

4.8 reverse 倒序，將列表中存放的元素，按照和原來相反的順序進(jìn)行排序。test = [1,2,3]

test.reverse()

[3, 2, 1]

特別注意！！！如果需要做反向的迭代操作，有個(gè)專門做反向迭代的函數(shù)，也叫reverse()這個(gè)reverse函數(shù)和列表中帶的reverse方法是有區(qū)別的，如果需要做反向迭代操作，強(qiáng)烈推薦reverse函數(shù)，這個(gè)函數(shù)返回的不是一個(gè)列表，而是一個(gè)迭代器（iterator）對(duì)象，直接放到循環(huán)中進(jìn)行反向迭代。

（經(jīng)過測(cè)試，直接使用list()函數(shù)強(qiáng)制把返回的迭代器轉(zhuǎn)換成列表也是可以的。）

4.9 sort 排序。

使列表中的元素按照一定順序去排列，sort方法也是直接就該列表本身的。test = [2,1,3]

test.sort()

[1, 2, 3]

關(guān)于sort方法也需要額外的補(bǔ)充一下，如果不想對(duì)原列表進(jìn)行修改，想生成一個(gè)排序后的新的副本，那么sorted()函數(shù)是最好的選擇，sorted()函數(shù)會(huì)將排序后的列表生成一個(gè)新的列表。

sorted函數(shù)雖然可以針對(duì)各種序列進(jìn)行排序，但是返回值卻永遠(yuǎn)都是以列表的形式print sorted("dcba")

['a', 'b', 'c', 'd']

＃python中列表中元素的排序方式還可以自己指定，本篇文章主要是說明，列表，元組，字典之類的使用方法，關(guān)于排序后面會(huì)單獨(dú)有一篇文章做介紹。

三.python元組(tuple)的使用。

元組合列表非常類似，但是它們最大的區(qū)別就是元組是不可變的，不能做任何修改，生成元組的方法特別簡單，只要使用逗號(hào)（，）分隔了一些值，就自動(dòng)創(chuàng)建了元組。t1 = 1,2,3,4

print type(t1)

print t1

(1, 2, 3, 4)

元組也支持分片，方法和列表一模一樣，這個(gè)就不多介紹啦。

元組分片后還是元組。

既然列表比元組的功能還多，那么要元組有毛用？

上網(wǎng)找了好多資料，終于知道元組為什么不可替代了。

元組可以在創(chuàng)建字典時(shí)作為key使用，列表卻不行。

四.python字符串的基本使用（str）。

在本篇文章中，不對(duì)字符串格式化做介紹，只介紹關(guān)于字符串的一些常用方法，關(guān)于字符串格式化，后面會(huì)單獨(dú)寫一篇文章。

下面介紹一些比較常用的字符串方法（字符串的方法實(shí)在太多了，在這里說些常用的吧。）

1.find（）在字符串中，查找想要找的子串。

它會(huì)返回子串從左數(shù)第一個(gè)位置的索引，如果沒有找到對(duì)應(yīng)的子串則會(huì)返回－1。

s1 = 'maybe you to'

print s1.find("you")

6

find方法不會(huì)返回布爾值，如果返回值是0，責(zé)說明了在第0位置的索引找到了子串。

補(bǔ)充一個(gè)find方法的用法，find方法還支持按字符串的指定范圍查找子串。

比如說查找字符串y，如果不傳任何參數(shù)的話，直接在maybe中就可以找到y(tǒng)。s1 = 'maybe you to'

print s1.find('y')

2

在第2個(gè)索引的位置，找到了y，然后就不在繼續(xù)找了，接著我們指定下索引的范圍讓find從第6個(gè)索引開始找,找到第9個(gè)索引。

s1 = 'maybe you to'

print s1.find('y',6,9)

6

我們可以手動(dòng)指定find方法的查找范圍，從哪個(gè)索引的字符串開始，從哪個(gè)索引的字符串結(jié)束。

‘y’是要從字符串中查找的子串，6指從第6個(gè)索引開始，9是指從第9個(gè)索引開始結(jié)束。

2.join 拼接，是字符串中非常非常重要和常用的方法。

主要的功能是用來拼接序列中的元素，讓序列中的元素使用指定的字符串連接起來。

注意！join方法只可以拼接字符串！！！其他的序列是無法拼接的，數(shù)字也不行！！

l1 = ['1','2','3','4','5','6']

這個(gè)列表中所有的數(shù)字已經(jīng)使用單引號(hào)轉(zhuǎn)換成了字符串。

現(xiàn)在需要做的就是使用＋－將l1列表里所有的元素連接成一個(gè)字符串。

print "+-".join(l1)

1+-2+-3+-4+-5+-6

3.lower小寫，將字符串中所有的字符全部轉(zhuǎn)換為小寫。

如果想要做這種“不區(qū)分大小寫”的功能的話，這個(gè)方法就派上用場(chǎng)了，無論大寫小寫，全部轉(zhuǎn)換為小寫。

在python中，是嚴(yán)格區(qū)分大小寫的，假如想要在列表中查找一個(gè)元素是否存在，比如說在列表中找到字符串為“guilty“的元素，但是用戶輸入的是GUILTY，由于python會(huì)嚴(yán)格區(qū)分大小寫，就會(huì)導(dǎo)致指定的元素找不到。

下面是關(guān)于大小寫的測(cè)試代碼。

name = "GUILTY"

test = ["suhaozhi","guilty"]

if name in test:

print "ok"

else:

print "not found!"

not found

列表中命名有g(shù)uilty這個(gè)元素，因?yàn)榇笮懙膯栴}，現(xiàn)在找不到。

接下來就使用lower方法，對(duì)字符串做個(gè)轉(zhuǎn)換。

name = "GUILTY".lower()

test = ["suhaozhi","guilty"]

if name in test:

print "ok"

else:

print "not found!"

ok

這樣，指定的元素就找到了。

print "GUILTY".lower()

guilty

在這里看到字符串成功的被轉(zhuǎn)換成小寫。

4.replace 替換，替換字符串中指定的子串。

這個(gè)方法，沒有什么好說的，功能就是字符串替換，下面是例子。

s1 = "i have a pen"

print s1.replace("pen","apple")

i have a apple

5.split 拆分，也是特別重要和常用的一個(gè)字符串方法，將字符串按照指定的格式進(jìn)行拆分，并且以列表的方式返回。

s1 = '1+-2+-3+-4+-5+-6+-7'

將上面的字符串以+-為分隔符拆分。

s1 = '1+-2+-3+-4+-5+-6+-7'

print s1.split('+-')

['1', '2', '3', '4', '5', '6', '7']

補(bǔ)充～在使用split做拆分的時(shí)候，如果不指定分隔符，默認(rèn)責(zé)會(huì)使用空格，制表符，換行符作為分隔符。

split方法中，還可以指定最大的拆分次數(shù)，做多可以拆多少次，假如說，最多只拆分兩次，可以在加個(gè)參數(shù)2

s1 = '1+-2+-3+-4+-5+-6+-7'

print s1.split('+-',2)

['1', '2', '3+-4+-5+-6+-7']

上面那個(gè)字符串被拆成了三個(gè)元素，前兩個(gè)+-被當(dāng)作拆分符拆了兩次。

6.strip脫掉...去除字符串兩側(cè)的字符，一般情況下，經(jīng)常用這個(gè)方法來去掉換行符和空格。

s1 = "+aaa+"

print s1.strip('+')

aaa

字符串兩邊的＋加號(hào)被去掉了。

strip只能去掉字符串兩邊的多余字符，對(duì)字符串中間的字符不生效。

這個(gè)方法也很常用，用來去掉空格和換行符特別管用！！！！

五.python字典（dict）的基本使用方法。

當(dāng)數(shù)字索引不好用的時(shí)候，就可以考慮使用字典啦。

字典是python中唯一的映射類型，字典中的值沒有特殊的順序，都是存儲(chǔ)在特定的key下，key可以是數(shù)字，可以是字符串，也可以是元組。

下面是字典的創(chuàng)建和使用字典。

字典是由多個(gè)鍵值對(duì)組成的，每個(gè)key（鍵）和它的value（值）都是用：冒號(hào)分隔，每個(gè)鍵值對(duì)之間都使用逗號(hào)分隔，最外層使用大括號(hào)括起來｛｝。

下面是python字典的結(jié)構(gòu)。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

python字典的創(chuàng)建方法。

方法1:最常規(guī)的字典創(chuàng)建方式。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

方法2:使用元組影射。

items = [('name','suhaozhi'),('age',22)]

d1 = dict(items)

print d1

{'age': 22, 'name': 'suhaozhi'}

方法3:通過關(guān)鍵字來創(chuàng)建字典。

d1 = dict(name = 'suhaozhi',age = 22)

print d1

{'age': 22, 'name': 'suhaozhi'}

創(chuàng)建空字典：

d1 = {}

d1 = dict()

1.字典的基本操作。

字典不屬于序列，但是它的操作方法和序列很類似。

1.1查看字典有多少鍵值對(duì)。

如果想要查看一個(gè)字典里有多少鍵值對(duì)，使用len()函數(shù)就可以查到。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

print len(dict1)

1.2獲取字典中某個(gè)key對(duì)應(yīng)的value。

print dict1['k1']

v1

注意！這種獲取vlaue的方式不推薦，因?yàn)橐坏┱也坏街付ǖ膋ey，程序又會(huì)拋出異常，推薦使用字典中的get方法去獲取vlaue，get方法后面會(huì)介紹！！

1.3對(duì)字典中指定的key賦值。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

dict1['k4'] = 'v4'

print dict1

{'k3': 'v3', 'k2': 'v2', 'k1': 'v1', 'k4': 'v4'}

1.4刪除字典中指定的鍵值對(duì)。

要?jiǎng)h除字典中的某個(gè)鍵值對(duì)，只需要指定鍵（key）就可以刪除了。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

del dict1["k1"]

print dict1

{'k3': 'v3', 'k2': 'v2'}

1.5檢查字典中是否存在指定的key。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

print 'k3' in dict1

True

2. 關(guān)于創(chuàng)建字典的一些注意事項(xiàng)。

key的類型，需要注意，字典的key可以是任意的不可變類型，可以是字符串，可以是浮點(diǎn)數(shù)，也可以是數(shù)字，也可以是元組，只要是不可變的類型都可以做字典的key。

字典的鍵值對(duì)是可以自動(dòng)添加的，即使某個(gè)key在字典中并不存在，只要直接給key賦值，python就會(huì)去創(chuàng)建這個(gè)key（所以字典沒有append方法就是因?yàn)檫@個(gè)原因）。

3.字典（dict）的常用方法。

3.1 clear清除，該方法可以清除字典中所有的項(xiàng)，無任何返回值。

dict1 = {"k1":"v1","k2":"v2","k3":"v3"}

dict1.clear()

print dict1

注意啦！！其實(shí)clear方法看起來很普通，清空了字典里所有的key和value，這些定義一個(gè)空字典也可以做到，但這并非真正的刪除，clear可以做到真正意義上的刪除！下面是示例。

第一種情況：

d1 = {}

＃首先創(chuàng)建了一個(gè)空字典。

d2 = d1

＃創(chuàng)建了一個(gè)d2變量，把內(nèi)存地址指向d1

d1['k1'] = 'v1'

＃給d1字典創(chuàng)建了一個(gè)鍵值對(duì)

print d2

{'k1': 'v1'}

＃新創(chuàng)建的那個(gè)鍵值對(duì)在變量d2上也可以看到，這是因?yàn)?#xff0c;d1和d2使用了指向了同一個(gè)內(nèi)存地址，不相信的話，可以使用id()函數(shù)去查看！

d1 = {}

＃從新給d1變量賦值了一個(gè)空字典，注意！！這并不是刪除，而是改變了d1變量原來的內(nèi)存地址！！！

d1的新內(nèi)存地址指向了一個(gè)空字典。

print d2

{'k1': 'v1'}

＃然而d2的內(nèi)存地址沒有像d1那樣發(fā)生變化，指向的還是原來的那個(gè)位置，所以，之前的鍵值對(duì)并沒有刪除，還在內(nèi)存空間中沒有釋放，如果想真正的刪除，就需要使用clear方法。

下面是使用clear方法去清空字典，和上面那種所謂的“刪除”做個(gè)比較。

d1 = {}

d2 = d1

d1['k1'] = 'v1'

print d2

{'k1': 'v1'}

d1.clear()

print d2

｛｝

所以說，clear才是真的清除。

3.2 copy 淺復(fù)制，返回一個(gè)具有相同鍵值對(duì)的新字典。

首先先舉一個(gè)不使用copy方法，直接靠變量之間賦值實(shí)現(xiàn)所謂的“復(fù)制”！

d1 = {'k1':'v1','k2':'v2'}

d2 = d1

print d1

{'k2': 'v2', 'k1': 'v1'}

print d2

{'k2': 'v2', 'k1': 'v1'}

看起來像是通過變量間賦值的方式，實(shí)現(xiàn)了一個(gè)類似“復(fù)制”的效果，其實(shí)這并不是真正的復(fù)制，具體原因，看下面的操作就明白了。

接下來，我們給d1增加一個(gè)鍵值對(duì)。

d1['k3'] = 'v3'

雖然改變的是d1變量中的字典，但是！d2中的字典也會(huì)發(fā)生同樣的改變！！

print d1

{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}

print d2

{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}

修改了d1，d2也發(fā)生了同樣的改變，這是因?yàn)閐1和d2同時(shí)指向了一個(gè)內(nèi)存地址，這兩個(gè)變量使用的是相同的內(nèi)存空間，這一點(diǎn)是可以通過id函數(shù)看到的。

print id(d1)

4481913472

print id(d2)

4481913472

這兩個(gè)變量使用的內(nèi)存地址是一模一樣的！！！

下面是copy方法的使用示例。

d1 = {'k1':'v1','k2':'v2'}

d2 = d1.copy()

＃使用copy方法，去復(fù)制字典

d2['k3'] = 'v3'

＃修改復(fù)制后的字典，給新字典增加一個(gè)鍵值對(duì)。

print d1

{'k2': 'v2', 'k1': 'v1'}

print d2

{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}

＃從這可以看出，修改了新字典后，對(duì)新字典進(jìn)行修改，完全沒有影響到d1變量。

＃這是因?yàn)閐2現(xiàn)在是一個(gè)獨(dú)立的個(gè)體，d1和d2復(fù)制后內(nèi)容雖然一樣，但是分別使用的是不同的內(nèi)存空間，下面使用id函數(shù)去查看一下

print id(d1)

4537868928

print id(d2)

4538835584

注意！！字典中的copy方法只是淺拷貝，只會(huì)拷貝父級(jí)對(duì)象，如果字典中有子對(duì)象（字典中嵌套了字典，或者嵌套了列表，就是子對(duì)象。）

下面來測(cè)試一下。

d1 = {'k1':'v1','k2':'v2','k3':[1,2,3]}

d2 = d1.copy()

print d1

{'k3': [1, 2, 3], 'k2': 'v2', 'k1': 'v1'}

print d2

{'k3': [1, 2, 3], 'k2': 'v2', 'k1': 'v1'}

＃k3這個(gè)key對(duì)應(yīng)的值是一個(gè)列表，這個(gè)列表在字典中就是個(gè)子對(duì)象，現(xiàn)在在這個(gè)列表中追加一個(gè)元素。

d2['k3'].append(4)

＃這時(shí)，我們查看一下d1和d2字典都發(fā)生了哪些變化。

print d1

{'k3': [1, 2, 3, 4], 'k2': 'v2', 'k1': 'v1'}

print d2

{'k3': [1, 2, 3, 4], 'k2': 'v2', 'k1': 'v1'}

＃修改了一個(gè)字典中的子對(duì)象后，副本的子對(duì)象也發(fā)生了變化。

這說明了一個(gè)問題，就是copy方法只會(huì)復(fù)制字典中的父級(jí)對(duì)象，子對(duì)像其實(shí)并沒有復(fù)制，而是兩個(gè)字典中的key同時(shí)指定了同一個(gè)內(nèi)存空間！！

如果想要使字典中的子對(duì)象也得到獨(dú)立的復(fù)制，則可以使用copy模塊中的deep copy（深度復(fù)制）。

想要做這種深度復(fù)制，需要導(dǎo)入一個(gè)copy模塊中的deepcopy函數(shù)。

from copy import deepcopy

d1 = {'k1':'v1','k2':'v2','k3':[1,2,3]}

d2 = deepcopy(d1)

d2['k3'].append(4)

print d1

{'k3': [1, 2, 3], 'k2': 'v2', 'k1': 'v1'}

print d2

{'k3': [1, 2, 3, 4], 'k2': 'v2', 'k1': 'v1'}

3.3 fromkeys()使用指定的鍵，建立一個(gè)新的字典，并且給每個(gè)key賦予一個(gè)默認(rèn)的value，如果不指定value，默認(rèn)為None。

d1 = dict.fromkeys(['name','age'])

print d1

{'age': None, 'name': None}

我們還可以手動(dòng)指定默認(rèn)值。

d1 = dict.fromkeys(['name','age'],"aaa")

print d1

{'age': 'aaa', 'name': 'aaa'}

＃每建立了一個(gè)鍵值對(duì)，值默認(rèn)等于aaa。

3.4 get()用于訪問字典key對(duì)應(yīng)的值，d2['k3']和這種取值方式很類似，但是get這種方法在取值時(shí)，如果遇到了找不到的key，則不會(huì)拋出任何異常。

如果遇到了在字典中找不到的key，默認(rèn)會(huì)返回None,我們還可以手動(dòng)去指定get方法的返回值。

d1 = {'name':'suhaozhi','age':22}

print d1.get('name')

suhaozhi

d1 = {'name':'suhaozhi','age':22}

#接下來查找一個(gè)字典中不存在的key，看看會(huì)返回什么。

print d1.get('aaaa')

None

＃當(dāng)找不到指定的key時(shí)，默認(rèn)會(huì)返回None,我們還可以手動(dòng)指定返回值。

＃當(dāng)現(xiàn)在需要指定，去找一個(gè)不存在的key，如果找不到返回字符串null。

d1 = {'name':'suhaozhi','age':22}

print d1.get('aaaa','null')

null

3.5 has_key 檢查key，檢查字典中是否存在指定的key，也可以使用in去檢測(cè)，這兩個(gè)是一模一樣的。

3.6 items 將字典所有的項(xiàng)，以列表的方式返回，列表中嵌套的是元組，每一個(gè)鍵值對(duì)都包含在同一個(gè)元組中。

d1 = {'name':'suhaozhi','age':22}

print d1.items()

[('age', 22), ('name', 'suhaozhi')]

3.7 iteritems 和items方法類似，但是iteritems方法返回的是個(gè)迭代器，不是列表。

如果需要做迭代操作的話，強(qiáng)烈推薦iteritems方法！因?yàn)樗咝?#xff01;！！。

3.8 keys 返回一個(gè)字典中所有的key，以列表的形式返回。

d1 = {'name':'suhaozhi','age':22}

print d1.keys()

['age', 'name']

3.9 iteritems 和key類似，返回的也是一個(gè)字典中所有的key，以迭代器的方式返回。

3.10 pop 彈出，彈出字典中指定鍵值對(duì)，通過key來指定。

（之前在list里面說過了，這里的彈出指的就是刪除，并返回。）

d1 = {'name':'suhaozhi','age':22}

print d1.pop('name')

suhaozhi

print d1

{'age': 22}

3.11 popitem 隨機(jī)彈出，隨機(jī)彈出字典的鍵值對(duì)，以元組的方式返回，刪除的順序是隨機(jī)的！

d1 = {'name':'suhaozhi','age':22}

print d1.popitem()

('age', 22)

print d1

{'name': 'suhaozhi'}

3.12 setdefault 和get方法很像，用來獲取指定key對(duì)應(yīng)的值，當(dāng)key不存在時(shí)，默認(rèn)返回None,也可以手動(dòng)指定返回值，基本上功能和get一樣，不演示了。

3.13 update 使用一個(gè)字典更新另外一個(gè)字典，舊字典的內(nèi)容會(huì)更新到新字典中，如果有相同的key，對(duì)應(yīng)的值會(huì)被覆蓋！！

d1 = {'name':'suhaozhi','age':22}

d2 = {'k1':'v1','k2':'v2','age':130}

d1.update(d2)

print d1

d2字典中的鍵值對(duì)，被更新到了d1字典中，相同的key被覆蓋了。

3.14 values 獲取字典中所有的值 ，以列表的方式返回。

d1 = {'name':'suhaozhi','age':22}

print d1.values()

3.15 itervalues 獲取字典中所有的值，返回的是迭代器。

六.python集合（set）。

set集合中，每一個(gè)元素都是可hash的，在這個(gè)集合中是唯一的，不能重復(fù)，而且每個(gè)元素之間是無序的。

如何可以體現(xiàn)出set集合中每個(gè)元素的唯一性。

首先定義一個(gè)列表

[1,1,2,2,3,3,4,4,5,5,6,6]

將這個(gè)列表轉(zhuǎn)換為set集合。

print set([1,1,2,2,3,3,4,4,5,5,6,6])

set([1, 2, 3, 4, 5, 6])

轉(zhuǎn)換成集合之后，重復(fù)的元素被去掉了。

1.python集合中常用的方法。

1.1 add 在集合中添加一個(gè)元素。

s1 = set()

s1.add("suhaozhi")

print s1

set(['suhaozhi'])

1.2 update 將一個(gè)序列進(jìn)行拆分，然后分別傳入到集合中。

s1 = ｛"suhaozhi"｝

s1.update([1,2,3,4,5])

print s1

set([1, 2, 3, 4, 5, 'suhaozhi'])

1.3 remove 移除一個(gè)元素。

s1 = {'suhaozhi',1,2,3,4,5,6}

s1.remove('suhaozhi')

print s1

set([1, 2, 3, 4, 5, 6])

集合中的suhaozhi被移除了。

1.4 issubset 用來測(cè)試，本集合中的每個(gè)元素是否都在另外一個(gè)集合中，也可以理解為另外一個(gè)集合是否包含本集合的所有元素。（以本集合為基準(zhǔn)）

s1 = {'suhaozhi',1,2,3,4,5,6}

s2 = {6,5,4,3,2,1,'suhaozhi',222}

print s1.issubset(s2)

True

s2 中之要包含s1中所有的元素，返回結(jié)果就為真。

這個(gè)方法還可以使用兩個(gè)符號(hào)代替，個(gè)人認(rèn)為符號(hào)更容易記住。

s1.issubset(s2)可以寫成這樣 s1 <= s2

這兩種語法的作用一模一樣。

1.5 issuperset 和issubset方法類似，只不過方向上是相反的，另外一個(gè)集合中的每個(gè)元素是否包含在本集合中，也可以理解為本集合是否包含另外一個(gè)集合的所有元素。(以另外一個(gè)元素為基準(zhǔn))

s1 = {'suhaozhi',1,2,3,4,5,6}

s2 = {6,5,4,3,2,1,'suhaozhi',222}

print s1.issuperset(s2)

False

s1.issuperset(s2) 可以寫成這樣 s1 >= s2

這兩種語法的作用也是一模一樣的。

1.6 union 返回一個(gè)新的集合，這個(gè)集合中包含了兩個(gè)集合中所有的元素，就是將兩個(gè)元素融合。

s1 = {1,2,3}

s2 = {2,3,4}

print s1.union(s2)

set([1, 2, 3, 4])

union方法還可以使用｜豎線代替。

s1 | s2 和 s1.union(s2) 功能是一樣的。

1.7 intersection交集，取兩個(gè)集合共同存在的元素。

s1 = {1,2,3}

s2 = {2,3,4}

print s1.intersection(s2)

set([2, 3])

s1.intersection(s2) 可以寫成s1 & s2

1.8 difference差集，以本集合為中心，返回本集合有，但另一個(gè)集合沒有的元素。

s1 = {1,2,3}

s2 = {2,3,4}

print s1.difference(s2)

set([1])

s1.difference(s2) 可以寫成 s1-s2

1.9 symmetric_difference 返回一個(gè)新的集合，這個(gè)集合中，包含本集合和另一個(gè)集合不重復(fù)的元素。

s1 = {1,2,3}

s2 = {2,3,4}

print s1.symmetric_difference(s2)

s1.symmetric_difference(s2) 可以寫成s1 ^ s2

1.10 copy 集合的淺復(fù)制，和字典的用法一樣，在這就不做演示了。

1.11discard 如果存在就刪除，如果當(dāng)前集合中存在某個(gè)元素，發(fā)現(xiàn)存在就移除。

s2 = {2,3,4}

s2.discard(4)

print s2

set([2, 3])

1.12 pop 彈出集合中的一個(gè)元素，如果集合中沒有元素可以彈出了，則拋出一個(gè)異常。

這個(gè)和列表的pop很類似，在這就不做演示了。

1.13 clear 真正意義上清空集合中的所有元素。

1.14 剩余的一些方法的補(bǔ)充。

intersection_update ，difference_update，symmetric_difference_update這些方法和intersection ，difference，symmetric_difference，基本上都是一樣的，只不過帶有update字樣的方法會(huì)對(duì)原有集合進(jìn)行操作，不帶update的會(huì)生成一個(gè)新的集合。

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)

總結(jié)

以上是生活随笔為你收集整理的python列表添加字符串_2.python基础之—列表，元组，字典，集合，字符串的使用方法...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。