第5章 列表、元組和字串-下

原文再續，書接上一回

5.2 元組:戴上了枷鎖的列表

5.2.1 關於元組的一些常用的操作

元組和列表最大的區別:

列表	元組
你可以任意修改列表的中的元素,可以任意插入或者刪除一個元素,也就是可以增刪查改。	元組是不可改變的
建立列表使用中括號[]	建立元組大部分的時候使用小括號()

可以對元組作一些操作

下面是程式碼展示,是直接一步一步往下去的,要親自一個一個在IDLE上輸入。

操作	程式碼展示
建立元組	tuple1 = (1,2,3,4,5,6,7,8)
訪問元組	tuple1[1]
分片元組	tuple1[5:],tuple1[:5],
複製整個元組	tuple2 = tuple1[:]

試圖修改元組的一個元素,Python會很不開心

>>> tuple1 = (1,2,3,4,5,6,7,8)
>>> tuple1[1] = 1
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    tuple1[1] = 1
TypeError: 'tuple'
 
 object does not support item assignment

元組的標誌性符號是小括號?當然不是,我一開始也是這樣想得,但是結果往往出乎意料。

通過type()這個BIF返回引數的型別,下面的執行返回的是int整數型別

>>> temp = (1)
>>> type(temp)
<class 'int'>

沒有小括號,temp還是元組型別,所以逗號(,)才是元組的關鍵,通過下面的例子可以得出:

>>> temp = 1,2,3
>>> type(temp)
<class
 
 'tuple'>
>>> temp2 = (1,)
>>> type(temp2)
<class 'tuple'>

所以建立元組的方法總結如下,tuple1是變數名,自己可以改的:

建立元組的方法
tuple1 = ()
tuple1 = (1,2,3,4,5,6,7,8)
tuple1 = 1,2,3
tuple1 = (1,)

逗號(,)起到了決定性作用

>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)

5.2.2 更新和刪除元組

直接在同一個元組上更新是不可行的,所以我們採取相對含蓄的方法:

向元組裡面加入一些元素,可以通過分片的方法拆分兩部分,然後再使用連線操作符(+)合併成一個新的元組

下面展示一下我的錯誤的做法,逗號不能放在前面:

>>> temp = ("小雞","小鴨","小豬")
>>> temp = temp[:2] +(,"小甲魚") + temp[2:]
SyntaxError: invalid syntax

間接刪除一個/多個元素

>>> temp = temp[:2] + temp[3:]
>>> temp
('小雞', '小鴨', '小豬')

刪除整個元組,使用del語句,但是在日常使用中,很少使用del去刪除整個元組,因為Python的回收機制會在這個元組不再使用到的時候自動刪除:

>>> del temp
>>> temp
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    temp
NameError: name 'temp' is not defined

關係操作符,邏輯操作符,成員關係操作符也可以應用到元組裡面

5.3 字串

操作	程式碼提示
建立字串	str1 = “I love fishC .com”
訪問字串的一個字元	str1[5]
修改字串(含蓄間接的修改)	str2 = str1[:6] + “我是一個字串” +str1[6:]

這種通過拼接舊的字串的各個部分得到新的字串的方式並不是真的意義上的改變原始的字串,原來的那個”傢伙”還在,知識將變數指向了新的字串(就餓得字串一旦失去變數的引用,就會被Python的垃圾回收機制釋放掉)

關係操作符,邏輯操作符,成員關係操作符也可以應用到字串裡面

5.3.1 各種內建的方法

常用的內建方法:

casefold()作用:將字串的所有字元變為小寫

>>> str1 = "FishC"
>>> str1.casefold()
'fishc'

count(sub[,start[,end]]):查詢sub字串出現的次數,可選引數(注:在Python文件中,用方括號[]括起來表示為可選)

>>> str1 = "abcabcabcabcabc"
>>> str1.count("ab",0,15)
5

find(sub[,start[,end]]):檢測 str (子字串)是否包含在 mystr(該字串)中，如果是返回開始的索引值，否則返回-1

>>> str1 =  "I love fishC .com">>> str1 =  "I love fishC .com"
>>> str1.find('fishC')
7
>>> str1.find('d')
-1
>>> str1.find('fishC')
7

index(sub[,start[,end]]):跟find()方法一樣，只不過如果str(子字串)不在 mystr(該字串)中會報一個異常.

>>> str1.index('fishC')
7
>>> str1.index('good')
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    str1.index('good')
ValueError: substring not found

join():是以字串作為哦分隔符,插入到sub字串中所有的字元之間:

>>> 'x'.join("Test")
'Txexsxt'

通常我們都是建議使用join()來連線字串,因為當使用連線符號(+)去拼接大量的字串時是非常低效率的,加號連線會引起記憶體複製以及垃圾回收機制操作。使用join()方法的效率更好。

replace(old,new[,count]):替換指定的字串

>>> str1 = "I love you"
>>> str1.replace('you','fishC.com')
'I love fishC.com'

split(sep=None,maxsplit =-1):拆分字串

>>> str1 = ' '.join(['I','love','fishc.com'])
>>> str1
'I love fishc.com'
>>> str1.split()
['I', 'love', 'fishc.com']

5.3.2格式化

還沒寫好,我後面還沒有搞懂,所以先在上傳,明天一定補充完整

1.format():

format()方法接受位置引數和關鍵字引數,二者均傳遞到一個叫做replacement欄位。而這個replacement欄位在字串內有大括號({})表示。’

下面有個例子:

>>> '{0} love {1}.{2}'.format('I','FishC','com')
'I love FishC.com'

上面這個字串中的{0},{1}和{2}應該跟位置有關,依次被format()的三個引數替換,那麼format()的三個引數叫叫做位置引數。

關鍵字引數,通過下面的例子解析:

>>> '{a} love {b}.{c}'.format(a = 'I',b = 'FishC',c = 'com')
'I love FishC.com'

上面這個字串中的{a},{b}和{c}相當於是三個標籤,被format()的三個引數替換,簡單來說,這個字串上面有三個坑,format()的三個引數把那些坑填上去。

PS.如果將位置引數和關鍵字引數綜合在一起使用,那麼位置引數必須在關鍵字引數之前,否則就會報錯,所以位置引數一定放在關鍵字之前。

>>> '{a} love {b}.{0}'.format(a = 'I',b = 'FishC', 'com')
SyntaxError: positional argument follows keyword argument

把大括號打印出來,只需要用多一層大括號包起來即可,因為{0}的特殊功能被外層的大括號({})剝奪,因此沒有欄位輸出,這並不是一個錯誤啊。

>>> '{{0}}'.format('不列印')
'{0}'

最後一個例子:

>>> '{0} : {1:.2f}'.format('圓周率',3.14159)
'圓周率 : 3.14'

位置引數{1}跟平常有些不同,後邊多了個冒號。在替換域中,冒號表示格式化的開始,”.2”的意思是四捨五入到保留兩位小數點,而f的意思是定點數,所以結果是打印出3.14。

2.格式化操作符:%

當%的左右均為數字的時候,那麼它表示求餘數的操作;但當它出現在字串中的時候,它表示的是格式化操作符。

Python格式化符號及含義

符號	含義
%c	格式化字元及其ASCII碼
%s	格式化字串
%d	格式化整數
%o	格式化無符號八進位制數
%x	格式化無符號十六進位制數
%X	格式化無符號十六進位制數(大寫)
%f	格式化浮點數字,可指定小數點後的精度
%e	用科學計數法格式化浮點數
%E	作用同%e,用科學計數法格式化浮點數
%g	根據值的大小決定使用%f或%e
%G	作用同%g,根據值的大小決定使用%f或%e

下面舉幾個例子:

>>> '%c %c %c'%(97,98,99)
'a b c'
>>> '%d轉換為八進位制是:%o'%(123,123)
'123轉換為八進位制是:173'
>>> '%f用科學計數法表示為:%e'%(149500000,149500000)
'149500000.000000用科學計數法表示為:1.495000e+08'

其實把一些常用的記住就好笑臉.jpg

Python還提供了格式化操作的輔助指令:

符號	含義
m.n	m是顯示的最小總寬度,n是小數點後的位數
-	結果左對齊
+	在正數前面顯示加號(+)
#	在八進位制前面顯示’0o’,在十六進位制數前面顯示’0x64’或’0X64’
0	顯示的數字掐面填充的’0’代替空格

下面舉幾個例子僅供參考:

>>> '%5.1f'%27.658
' 27.7'
>>> str1 = ' 27.7'
>>> len(str1)
5
>>> '%.2e'%27.658
'2.77e+01'
>>> '%10d' %5
'         5'
>>> '%010d'%5
'0000000005'
>>> '%#X'%100
'0X64'

你會發現上面如果不夠寬度的話,會使用空格代替它。

3.Python的轉義字元及含義

符號	說明
\'	單引號
\"	雙引號
\a	發出系統響鈴聲
\b	退格符
\n	換行符
\t	橫向製表符(Tab)
\v	縱向製表符
\r	回車符
\f	換頁符
\o	八進位制代表的字元
\x	十六進位制代表的字元
\0	表示一個空字元
\\	反斜槓

5.4 序列

列表、元組、字串統稱為序列。它們之間有很多共同點:

• 都可以通過索引值得到每一個元素
• 預設索引值總是從0開始(靈活的Python還支援負數索引)
• 可以通過分片的方法得到一個範圍內的元素的集合
• 有很多共同的操作符(重複操作符、拼接操作符、成員關係操作符)

常用BIF(內建方法)	說明
list([iterable])	把一個可迭代的物件轉換成列表(要麼不帶引數,要麼帶一個可迭代物件作為引數)
tuple([iterable])	把一個可迭代的物件轉換成元組
str(obj)	把一個obj物件轉換為一個字串
len(sub)	返回sub引數的長度
max(…)	返回序列或引數集合中最大值
min(…)	返回序列或引數集合中最小值
sum(iterable[,start])	返回序列的iterable的總和
sorted(iterable,key=None,reverse = Flase)	返回一個排序的新列表而列表的sort()是實現列表原地排序
reversed(sequence)	返回逆向迭代序列的值,返回一個返回後的迭代器物件,列表的內建犯法是原地翻轉
enumerate(iterable)	生成二元組(二元組就是元素數量為二的元組)構成的一個迭代物件
zip(iter1[,iter2[…])	返回由各個可迭代的引數共同組成的元組

迭代的解釋:

迭代是重複反饋過程的活動,其目的通常是為了接近到達所需的目標和結果。每一個對過程的重複被稱為一次”迭代”,而每一個迭代得到的結果會被用來下一次迭代的初始值。

1.list([iterable]):

把一個可迭代的物件轉換成列表(要麼不帶引數,要麼帶一個可迭代物件作為引數)

>>> a = list()
>>> a
[]
>>> #將字串的每個字元迭代存放到列表中
>>> b = list('FishC')
>>> b
['F', 'i', 's', 'h', 'C']
>>> c = list((1,2,3,4,5))
>>> c
[1, 2, 3, 4, 5]

2.len(sub):

返回sub引數的長度,sub可以是字串、列表、元組,列表頁類似。

>>> str1 = "I love FishC.com"
>>> len(str1)
16
>>> tuple1 = '這','是','一','個','元','組'
>>> len(tuple1)
6

3.max(…):

max()的引數可以是一個序列,返回值是該序列中的最大值,也可以是多個引數

>>> list1 = [1,2,3,4,5,62,147,82,748,213,189,3482]
>>> max(list1)
3482
>>> str1 = "I love FishC.com"
>>> max(str1)
'v'

PS.使用max()方法和min()方法都要保證序列或引數的資料型別統一,否則會出錯。

>>> list1 = [1,2,3,4,5,62,147,82,748,213,189,3482]
>>> list1.append('x')
>>> max(list1)
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    max(list1)
TypeError: unorderable types: str() > int()

錯誤是說不能拿字串和整型進行比較。max()和min()方法都是通過索引得到每一個元素,然後將各個元組進行對比。

4.sum(iterable[,start]):

sum()方法有一個可選的引數(start),如果設定改引數,表示從改值開始加起,預設值是0

>>> tuple1 = 1,2,3,4,5
>>> sum(tuple1)
15
>>> sum(tuple1,10)
25

5.sorted(iterable,key=None,reverse = Flase):

列表的內建方法sort()是實現列表原地排序,而sorted()是返回一個排序的新列表。

>>> list1 = [1,6,8,24,15,45,2,0]
>>> list2 = list1[:]
>>> list1.sort()
>>> list1
[0, 1, 2, 6, 8, 15, 24, 45]
>>> sorted(list2)
[0, 1, 2, 6, 8, 15, 24, 45]
>>> list2
[1, 6, 8, 24, 15, 45, 2, 0]

6.reversed(sequence):

區別是列表的內建方法是原地翻轉,而reversed()是返回一個翻轉後的迭代器物件。

>>> list1 = [1,6,8,24,15,45,2,0]
>>> reversed(list1)
<list_reverseiterator object at 0x05E645D0>
>>> for each in reversed(list1):
    print(each,end = ',')

0,2,45,15,24,8,6,1,

7.enumerate(iterable):

每個二元組是由可迭代引數的索引號及其對應的元素組成的。通過栗子,你應該可以弄懂的。

>>> str1 = 'FishC'
>>> for each in enumerate(str1):
    print(each)

(0, 'F')
(1, 'i')
(2, 's')
(3, 'h')
(4, 'C')

8.zip(iter1[,iter2[…]):

返回由各個可迭代的引數共同組成的元組

>>> list1 = [1,3,5,7,9]
>>> str1 = 'FishC'
>>> tuple1 = (2,4,6,8,10)
>>> for each in zip(list1,str1,tuple1):
    print(each)

(1, 'F', 2)
(3, 'i', 4)
(5, 's', 6)
(7, 'h', 8)
(9, 'C', 10)