MOOC python筆記(三) 序列容器：字符串、列表、元組

容器概念

容器是Python中的重要概念，分爲有序與無序。
有序容器也稱爲序列類型容器，如：字符串、列表。

通用序列容器操做

容器鏈接+

加號能夠把兩個序列鏈接成一個更大的容器，相加後兩個序列的值並不改變

>>> s1='abc'
>>> s2='def'
>>> s3=s1+s2
>>> s3
'abcdef'
>>> s1
'abc'
>>> s2
'def'
>>> l1=[1,2,3]
>>> l2=[4,5,6]
>>> l3=l1+l2
>>> l3
[1, 2, 3, 4, 5, 6]
>>> l1
[1, 2, 3]
>>> l2
[4, 5, 6]

數乘

一個序列容器乘以一個整數，把序列重複整數遍。相乘後原序列依然不發生變化。

>>> s1='ab'
>>> s2=s1*3
>>> s2
'ababab'
>>> l1=[1,2]
>>> l2=l1*3
>>> l2
[1, 2, 1, 2, 1, 2]

in與not in

in判斷一個元素是否在序列容器中，not in判斷是否再也不序列容器中，返回值爲布爾類型。

>>> s1='abc'
>>> 'a'in s1
True
>>> 'ab'in s1
True
>>> 'd' in s1
False
>>> l1=[1,2,3]
>>> 1 in l1
True
>>> [1,2] in l1#錯誤由於[1,2]不在[1,2]中
False`
>>> [1,2] in [[1,2],3]#正確
True

索引[]

取單個元素，從0開始計數。
咱們一個稱第一個元素爲第一個，第零號。
最大下標爲長度減一，超過此範圍會報錯。
咱們也能夠倒着數，最後一個元素爲-1，第一個元素爲長度的負數。
列表的索引支持從新賦值，字符串不支持

>>> l=[1,2,3]
>>> l[1]=3
>>> l
[1, 3, 3]
>>> s="abc"
>>> s[1]="c"
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    s[1]="c"
TypeError: 'str' object does not support item assignment

切片[]

在一個序列容器l中，有l[a:b]其中a<b，（若a>b，l[a:b]爲空串）
l[a:b]=l[a]+l[a+1]+......+l[b-1]。（若a=0，a能夠省略）
在切片中依然能夠只用負數索引，而且有時能夠作到一些直接索引很差作的操做。
如，咱們要把一個數字+一個字符的串中的最後一個字符去掉，直接使用切片彷佛不太好處理，由於咱們沒法肯定數字的長度。
這時咱們可使用[0:-1]，咱們切刀的第一個元素到倒數第二個元素。巧妙地解決了這個問題。

>>> s="25c"
>>> s[:-1]
'25'

(注意，若是序列容器中，咱們能夠在切片中使用長度（這彷佛看上去並不合理），這是爲了解決沒法切片獲得最後一個元素的問題，但咱們一般不推薦這麼作，咱們一般使用省略最後一個切片範圍的方法來使得切片取到最後一個字符)

通用序列容器函數

len函數

得到序列容器的長度。

min函數

得到序列容器中最小的元素。

max函數

得到序列容器中的最大元素。

sort函數

排序函數，按照ASC碼順序排序。

字符串特性

字符串中的引號與轉義

若是須要在字符串中使用單引號，咱們可使用雙引號包裹。
若是須要在字符串中使用雙引號，咱們可使用單引號包裹。

>>> a="'a'+'b'"
>>> a
"'a'+'b'"
>>> a='"a"+"b"'
>>> a
'"a"+"b"'

也可使用反斜槓（左上到右下）作轉義。

>>> a="\'a\'+\'b\'"
>>> a
"'a'+'b'"

三個單引號或者三個雙引號，可使字符串保留回車。

>>> """
a
cacad
casdw
,
"""
'\na\ncacad\ncasdw\n,\n'

若是想在輸出時在多行書寫，但同時最後的結果不會換行，能夠在行末加反斜槓。

>>> s="adad\
vasd\
avasddaw\
,\
"
>>> print(s)
adadvasdavasddaw,

若是想使輸入時的字符，不被識別成轉義字符，咱們能夠在引號前面加一個r。

>>> s=r'a\ndjwaid\tdad'
>>> s
'a\\ndjwaid\\tdad'
>>> print(s)
a\ndjwaid\tdad

字符串特有函數（方法）

lower和upper

把大寫變成小寫，不會改變原來字符串

>>> s="ADADWDADS"
>>> s.lower()
'adadwdads'
>>> s
'ADADWDADS'

upper是把小寫變成大寫，使用方法與lower一致。

find

find("s",a,b)從左往右數第一次在字符串的[a,b-1]範圍中出現的位置。
若是找不到則返回-1

>>> s.find("p",0,2)
-1
>>> s.find("p",0,3)
2

count

count('s')計算s在字符串中出現的次數。

>>> s="hello,world"
>>> s.count('l')
3

strip、lstrip、rstrip

strip去掉左右兩邊空格，lstrip去掉左邊空格，rstrip去掉右邊空格。

>>> s=' hello world    '
>>> s.strip()
'hello world'
>>> s.lstrip()
'hello world    '
>>> s.rstrip()
' hello world'

replace

replace('s1','s2')把字符串中的's1'替換成's2'

>>> s=' hello world '
>>> s.replace(' ','-')
'-hello-world-'

%

字符串的格式化，相似於C/C++中，不一樣的是後面也要用%，如print("%d+%f"%(1,1.2))，這裏略。

列表特性

列表的字面是能夠是表達式

>>> a=6
>>> b=8
>>> [a,b]
[6, 8]
>>> [a+2,b-a]
[8, 2]

list函數能夠將其餘類型轉換成列表

>>> s="this is a string"
>>> list(s)
['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 't', 'r', 'i', 'n', 'g']

若是列表的元素仍是一個列表，就造成了廣義表

>>> t=[[1,2,3],[4,5,6],[7,8,9]]
>>> len(t)
3
>>> t[0]
[1, 2, 3]
>>> t[0][0]
1

列表的賦值並不重分配空間

列表的賦值並不重分配空間，只是把新變量的指針也指向原來的變量指向的地址。這致使了，改變被賦值的變量會致使原變量被修改，這與其餘變量的賦值不一樣。

>>> t=[1,2,3]
>>> t[0]
1
>>> l=t
>>> l[0]
1
>>> l[0]=2
>>> l
[2, 2, 3]
>>> t
[2, 2, 3]

如圖：

列表切片的其餘應用

爲了解決上面的問題，咱們可使用切片
若是想要從新分配一個空間來讓新變量擁有可使用切片的方法。

>>> t1=[1,2,3]
>>> t2=t1[:]#省略開頭結尾，表示從0開始一直到結束
>>> t2[0]=0
>>> t1
[1, 2, 3]
>>> t2
[0, 2, 3]

如圖：

使用切片時，若是切片在賦值號右邊，那麼它會給左邊的變量分配新的空間，
若是在左邊，那麼它指向的是原來的空間，因此能夠經過改變切片的值來改變原來的空間。

>>> t=[1,2,3,4,5,6,7,8,9,10]
>>> ts=t[2:4]
>>> t[2:4]=[10,20]
>>> ts
[3, 4]
>>> t
[1, 2, 10, 20, 5, 6, 7, 8, 9, 10]

如圖：

甚至能夠賦與切片中元素個數不一樣的列表。

>>> t[2:4]=[10,20,30]
>>> t
[1, 2, 10, 20, 30, 5, 6, 7, 8, 9, 10]

咱們也能夠利用這一特性來刪除元素
python >>> t[2:4]=[]#刪除第二個第三個元素。 >>> t [1, 2, 30, 5, 6, 7, 8, 9, 10]python

del運算符

在del後面加上要刪除的元素，便可在列表中刪除這一元素。
若是要刪除整個列表，能夠直接del+列表名便可。

>>> t=[1,2,3,4,5,6]
>>> del t[2]
>>> t
[1, 2, 4, 5, 6]
>>> del t
>>> t
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    t
NameError: name 't' is not defined

列表的函數

append

至關於C++中STL的push_back，把一個新的元素添加的列表的最後。

extend

至關容器鏈接運算符+，把兩個列表鏈接起來。
（注意：append與extend看似內容類似，實際上功能上仍是有着很大的差別，append是添加元素，它的參數應該爲一個字面量或者表達式，而extend的做用是擴展列表，鏈接兩個列表，後面的參數必須也是一個列表）

>>> t=[1,2,3,4,5,6,7,8]
>>> t.append(10)
>>> t
[1, 2, 3, 4, 5, 6, 7, 8, 10]
>>> t.extend([1,2,3])
>>> t
[1, 2, 3, 4, 5, 6, 7, 8, 10, 1, 2, 3]
>>> t.append([1,2,3])#這是正確的由於列表也是一個字面量
>>> t
[1, 2, 3, 4, 5, 6, 7, 8, 10, 1, 2, 3, [1, 2, 3]]
>>> t.extend(1)#下面報錯，由於參數不爲列表
Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    t.extend(1)
TypeError: 'int' object is not iterable

insert函數

insert函數有兩個參數，第一個參數指定在哪一個元素前面插入(0~INF)，第二個元素指定要插入的元素（字面量或者表達式）

>>> t=[1,2,3,4,5,6,7]
>>> t.insert(0,0)
>>> t
[0, 1, 2, 3, 4, 5, 6, 7]
>>> t.insert(0,[1,2])
>>> t
[[1, 2], 0, 1, 2, 3, 4, 5, 6, 7]

當insert的第一個參數超過了列表的最大下標時，咱們會把元素添加到列表尾部。

>>> t=[1,2,3,4,5,6]
>>> t.insert(100,1)
>>> t
[1, 2, 3, 4, 5, 6, 1]

remove函數

刪除元素，與del運算符不一樣的是，del是刪除指定位置的元素，remove是刪除指定值(第一個)的元素。
若是有不少指定值，那麼刪除第一個。

>>> t=[1,2,3,4,5,6,2]
>>> t.remove(2)
>>> t
[1, 3, 4, 5, 6, 2]

pop函數

與數據結構中堆棧的pop一致，即彈出最後一個元素，函數的返回值爲該元素的值。
若是該函數帶有參數，那麼彈出的值爲該位置元素的值。

>>> t=[1,2,3,4,5,6,7,8]
>>> t.pop()
8
>>> t.pop(2)
3
>>> t
[1, 2, 4, 5, 6, 7]

reverse函數

翻轉列表，沒有什麼好說的。

>>> t=[1,2,3]
>>> t.reverse()
>>> t
[3, 2, 1]

index函數

與字符串的find函數一致，返回指定元素在列表中的位置，若是有多個就返回第一個。
與find函數基本一致

>>> t=[1,3,4,5,7,3,4,24]
>>> t.index(4,3,9)
6
>>> t.index(4)
2
>>> t.index(4,3)
6

列表推導式

列表推導式（又稱列表解析式）提供了一種簡明扼要的方法來建立列表。
它能夠將循環和條件判斷結合，從而避免語法冗長的代碼，同時提升程序性能。
基本格式：
[expression for item in iterable]
如，咱們要產生2,4,6,8,10的列表可使用n1=[2*n for n in [1,2,3,4,5]]

待條件的列表解析

[expression for item in iterable if condition] or
[expression if condition else expression for item in iterable]

>>> l=[n for n in range(1,8) if n%2==1]
>>> l
[1, 3, 5, 7]

例如：求1-1/2+...-1/20之和

>>> a=sum([1/i if i%2==1 else -1/i for i in range(1,21)])
>>> a
0.6687714031754279

列表與字符串的轉換

split函數

默認無參時把字符串按空格分隔成列表。

>>> s="this is a string"
>>> s.split()
['this', 'is', 'a', 'string']

帶參數時按照參數分隔。

>>> s="12:35"
>>> s.split(":")
['12', '35']

join函數

把一個列表按照某個字符串來做爲鏈接，格式爲s.join(l)，其中s爲鏈接的字符串，l爲列表。

>>> l=["hello","world"]
>>> "-".join(l)
'hello-world'

元組

與列表基本同樣，可是元組是用圓括號'('包裹的。而且元組中的元素不能被改變（能夠看出C/C++中的const string）！
元組與字符串一致都不支持元素的從新賦值。
元組可使用除了修改元素的全部的列表的函數。
通常不加括號的容器默認爲元組。

>>> a,b=3,4
>>> a
3
>>> b
4
>>> p=3,4
>>> p
(3, 4)

tuple函數

能夠用tuple函數把其餘容器轉化爲元組。

隨機庫random

使用隨機函數前須要import random。

shuffle函數

random.shuffle(t)
把容器t隨機打亂。

>>> import random
>>> t=["zyk","zjc","ysy","xhm"]
>>> random.shuffle(t)
>>> t
['ysy', 'xhm', 'zyk', 'zjc']
>>> random.shuffle(t)
>>> t
['xhm', 'zjc', 'zyk', 'ysy']

其餘函數詳見:python--隨機函數（random,uniform,randint,randrange,shuffle,sample）

隨機數種子

seed(int a)，每一個種子得到的隨機數是相同的，能夠藉此來完成一些特殊的任務。