Python核心資料型別之序列型別及其運算（字元、列表、元組運算及其深淺拷貝）
Python核心資料型別之序列型別及其運算（列表、元組運算及其拷貝）
序列：序列表示索引為非負整數的有序物件集合，包括字串、列表和元組，所有序列都支援迭代；
序列型別：
字串（strings）：字串也屬於序列型別，不可變型別；
字串字面量：把文字放入單引號、雙引號或三引號中；''', """
如果要使用unicode編碼，則在字元之前使用字元u進行標識，如u"fieldyang"
文件字串：模組、類或函式的第一條語句是一個字元的話，該字串就成為文件字串，可以使用__doc__屬性引用；
列表：（list），可變型別，使用[]建立，如['My','name','is','Field']，支援插入、刪除和替換元素；
元組:（tuple），不可變型別，使用()建立，如("one","two")
注意：列表和元組均不真正儲存資料，而是存放物件應用
例1：字串使用unicode編碼
In [44]: str1=u"hello world"
In [45]: type(str1)
Out[45]: Unicode
例2：文件字串引用
In [46]: def printName():
....: "Function Test!"
....: print "hellofieldyang!"
....:
In [47]: printName()
hello fieldyang!
In [48]: printName.__doc__
Out[48]: 'Function Test!'
序列通用操作：
運算子：
索引運算子：[i]
切片運算子：[i:j]
擴充套件切片符：[i:j:stride]
所有序列都支援的操作和方法：
s[i]
s[i:j]
s[i:j:stride]
len(s)
min(s)
max(s)
sum(s)
all(s)：檢查s中的所有項是否為true
any(s)：檢查s中的任意項是否為true
s1+ s2: 連線
s1* N: 重複
objin s1: 成員關係判斷
objnot in s1:
支援操作：
常用物件的自有的方法：
str1.capitalize():首字母大寫
str1.isupper()：是否為大寫
str1.index(x, {,start [, stop]})：返回指定字串索引範圍中x首次出現的位置，否則報錯
str1.join(t)：使用str1作為分隔符連線序列t中字串
str1.count()：計數
str1.lower()：轉換為小寫形式
str1.islower()：是否為小寫
str1.split([sep [,maxreplace]]):使用sep作為分隔符劃分，maxreplace為最大劃分次數
str1.upper()：轉換為大寫形式
str1.replace(old, new [,maxreplace])：替換一個子字串
例1：序列運算子的應用
[[email protected] ~]# ipython
In [1]: str1 = 'www.field.com'
In [2]: str1[2:]
Out[2]: 'w.field.com'
In [3]: str1[0:6]
Out[3]: 'www.fi'
In [4]: str1[0:8:2]
Out[4]: 'wwfe'
In [5]: str1[8:0:-1]
Out[5]: 'dleif.ww'
In [6]: str1[0]
Out[6]: 'w'
In [7]: len(str1)
Out[7]: 13
In [8]: str1[-2]
Out[8]: 'o'
In [9]: str1[-3:]
Out[9]: 'com'
In [10]: str1[-3::-1]
Out[10]: 'c.dleif.www'
In [11]: str1[-3:2:-1]
Out[11]: 'c.dleif.'
例2：序列常見操作和方法
In [12]: max(str1)
Out[12]: 'w'
In [13]: min(str1)
Out[13]: '.'
In [14]: l1=[1,2,3,4,5]
In [15]: sum(l1)
Out[15]: 15
In [16]: print str1
www.field.com
In [17]: all(str1)
Out[17]: True
例3：字元物件內建方法的使用
In [18]: str1.
str1.capitalize str1.format str1.isupper str1.rindex str1.strip
str1.center str1.index str1.join str1.rjust str1.swapcase
str1.count str1.isalnum str1.ljust str1.rpartition str1.title
str1.decode str1.isalpha str1.lower str1.rsplit str1.translate
str1.encode str1.isdigit str1.lstrip str1.rstrip str1.upper
str1.endswith str1.islower str1.partition str1.split str1.zfill
str1.expandtabs str1.isspace str1.replace str1.splitlines
str1.find str1.istitle str1.rfind str1.startswith
In [18]: str1.islower()
Out[18]: True
In [19]: str1.upper()
Out[19]: 'WWW.FIELD.COM'
In [20]: str1.isupper()
Out[20]: False
In [21]: str1.capitalize()
Out[21]: 'Www.field.com'
In [22]: str1.index('i')
Out[22]: 5
In [24]: str1.index('w',2)
Out[24]: 2
In [25]: str1.index('w')
Out[25]: 0
In [26]: str1.index('w',2,5)
Out[26]: 2
In [27]: l2=list(str1)
In [28]: print l2
['w', 'w', 'w', '.', 'f', 'i', 'e', 'l','d', '.', 'c', 'o', 'm']
In [29]: ''.join(l2)
Out[29]: 'www.field.com'
In [30]: str1.replace('field','FIELD')
Out[30]: 'www.FIELD.com'
In [31]: str1.replace('m','M')
Out[31]: 'www.field.coM'
In [32]: str1.split(str1)
Out[32]: ['', '']
In [33]: str1.split('.')
Out[33]: ['www', 'field', 'com']
In [34]: str1.split('e')
Out[34]: ['www.fi', 'ld.com']
In [35]: str2 = " hello "
In [36]: print str2
hello
In [37]: str2.strip()
Out[37]: 'hello'
In [38]: str2.strip('')
Out[38]: ' hello '
In [39]: str2.strip('o')
Out[39]: ' hello '
In [40]: str2 = " hello"
In [41]: str2.strip('o')
Out[41]: ' hell'
序列型別及其支援的操作和方法
1）、列表
其為容器型別，任意物件的有序集合。可以通過索引訪問其中的元素，是可變物件，其長度可變且支援異構，即任意巢狀
例1：列表的構建及使用
In [1]: l1 = []
In [2]: print l1
[]
In [3]: id(l1)
Out[3]: 18293032
In [4]: l2 = [1,2,3,4,5]
In [5]: print l2
[1, 2, 3, 4, 5]
In [6]: l3 = [1,'b',['x','y'],('w','z')]
In [7]: print l3
[1, 'b', ['x', 'y'], ('w', 'z')]
列表修改、內容刪除
列表支援在原處修改，可以修改指定的索引元素，也可以修改指定的分片，內建刪除語句
s[i] = v ：專案賦值
s[1:j] = t ：切片賦值
s[i:j:stride] = t ：擴充套件切片賦值
del s[i] ：刪除專案
del s[1:j] ：刪除切片
del s[i:j:stride] ：刪除擴充套件切片
例2：列表物件修改及刪除
In [8]: print l2
[1, 2, 3, 4, 5]
In [9]: l2[2] = 'sss'
In [10]: print l2
[1, 2, 'sss', 4, 5]
In [11]: l2[1:3]
Out[11]: [2, 'sss']
In [12]: l2[1:3] = []
In [13]: print l2
[1, 4, 5]
In [14]: del l2[1]
In [15]: print l2
[1, 5]
In [16]: del l2[0:]
In [17]: print l2
[]
In [18]: l3 = [1,2,3,4,5,6]
列表內建方法：
list(l)：將l轉換為一個列表
l.append(x)：將一個新元素x追加到列表末尾
l.extend(t)：將一個新列表t追加到列表末尾
l.insert(i,x)：在索引i處插入x,必須為整型
l.remove(x)：移除列表中x元素
l.sort()：正向排序
l.count(x)：計算列表中x出現次數
l.index(x, {,start [, stop]})：返回列表索引範圍中x的位置索引
l.pop([i])：返回元素i並移除，i省略時移除最後一個元素
l.reverse()：逆序排序
列表解析：[]
例3：列表內建方法使用示例
In [19]: l3.
l3.append l3.extend l3.insert l3.remove l3.sort
l3.count l3.index l3.pop l3.reverse
In [19]: l3.append('www')
In [20]: print l3
[1, 2, 3, 4, 5, 6, 'www']
In [21]: id(l3)
Out[21]: 18311792
In [22]: l3.append('666')
In [23]: id(l3)
Out[23]: 18311792
In [24]: l4 = ['a','b','c']
In [25]: l3.append(l4)
In [26]: id(l3)
Out[26]: 18311792
In [27]: print l3
[1, 2, 3, 4, 5, 6, 'www', '666', ['a', 'b','c']]
In [28]: l3.count(2)
Out[28]: 1
In [29]: l3.count(6)
Out[29]: 1
In [31]: l3.extend(l4)
In [32]: print l3
[1, 2, 3, 4, 5, 6, 'www', '666', ['a', 'b','c'], 'a', 'b', 'c']
In [33]: id(l3)
Out[33]: 18311792
In [34]: l3.index('www')
Out[34]: 6
In [35]: l3.insert(6,888)
In [36]: print l3
[1, 2, 3, 4, 5, 6, 888, 'www', '666', ['a','b', 'c'], 'a', 'b', 'c']
In [39]: l3.pop()
Out[39]: 'c'
In [40]: l3.pop()
Out[40]: 'b'
In [41]: l3.pop()
Out[41]: 'a'
In [42]: l3.pop()
Out[42]: ['a', 'b', 'c']
In [43]: print l3
[1, 2, 3, 4, 5, 6, 888, 'www', '666']
In [44]: l3.remove(3)
In [45]: print l3
[1, 2, 4, 5, 6, 888, 'www', '666']
In [46]: l3.reverse()
In [47]: print l3
['666', 'www', 888, 6, 5, 4, 2, 1]
In [48]: l3.sort()
In [49]: print l3
[1, 2, 4, 5, 6, 888, '666', 'www']
列表間操作：
l1 + l2: 合併兩個列表，返回一個新的列表；不會修改原列表；
l1 * N: 把l1重複N次，返回一個新列表;
in: 成員關係判斷字元, 用法 obj incontainer
not in: obj not in container
例4：列表間操作示例
In [50]: str1 = 'hello'
In [51]: str2 = 'field'
In [53]: str1+str2
Out[53]: 'hellofield'
In [54]: str1 * 3
Out[54]: 'hellohellohello'
In [56]: l1 = [1,2,3]
In [57]: l1 * 3
Out[57]: [1, 2, 3, 1, 2, 3, 1, 2, 3]
In [58]: 2 in l1
Out[58]: True
In [59]: 22 in l1
Out[59]: False
In [60]: range(10)
Out[60]:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
列表複製：
深淺複製都是對源物件的複製，佔用不同的記憶體空間；如果源物件只有一級目錄的話，源做任何改動，不影響深淺複製物件；如果源物件不止一級目錄的話，源做任何改動，都要影響淺複製，但不影響深複製。
列表複製方式：
變數複製：l2 = l1，引用同一物件
import copy
深複製：拷貝所有物件，頂級物件及其巢狀物件。包括：父級物件及其子物件
l2 = copy.deepcopy(l1)
淺複製：只拷貝頂級的物件，即只包括：父級物件
切片複製：l2 = l1[:]
l2 = copy.copy(l1)
例5：列表的複製
In [68]: l1 = [1,2,3]
In [69]: id(l1)
Out[69]: 18311576
In [70]: l2 = l1
In [71]: id(l2)
Out[71]: 18311576
#“=”複製只是使用不同變數名引用同意物件，id不變
In [72]: l1.append(4)
In [73]: print l2
[1, 2, 3, 4]
In [74]: id(l2)
Out[74]: 18311576
In [75]: l3 = l1[:]
# “切片”複製只是複製頂級的物件，相當於淺複製(copy.copy)，父級元素改變，源資料不變，其父級元素的內層元素改變，源資料會改變，id會改變
In [76]: id(l3)
Out[76]: 19455224
In [77]: print l3
[1, 2, 3, 4]
In [78]: l1.append(5)
In [79]: print l3
[1, 2, 3, 4]
In [80]: print l1
[1, 2, 3, 4, 5]
In [81]: import copy
In [82]: id(l1)
Out[82]: 18311576
In [83]: l5 = copy.deepcopy(l1)
#深複製，複製一個容器物件，以及它裡面的所有元素(包含元素的子元素)，內建的任一元素改變均不會影響源資料。
In [84]: id(l5)
Out[84]: 16402480
In [85]: copy.
copy.Error copy.deepcopy copy.name
copy.PyStringMap copy.dispatch_table copy.t
copy.copy copy.error copy.weakref
2）、元組:（tuple）
不可變型別，使用()建立，如("one","two")
表示式符號：()
容器型別:任意物件的有序集合，通過索引訪問其中的元素，不可變物件，長度固定，支援異構和巢狀
常見操作：
()
(1,)
(1,2)
t1 + t2:
t1 * N:
in:
not in:
雖然元組本身不可變，但如果元組內嵌套了可變型別的元素，那麼此類元素的修改不會返回新元組；
例1：元組建立及方法使用
In [1]: t1=(1,2,2,3,4,7,7,7)
In [2]: t1.
t1.count t1.index
In [2]: t1.count(2)
Out[2]: 2
In [3]: t1.count(7)
Out[3]: 3
In [4]: t1.index(7)
Out[4]: 5
In [5]: 7 in t1
Out[5]: True
In [6]: 77 in t1
Out[6]: False
In [7]: print t1
(1, 2, 2, 3, 4, 7, 7, 7)
In [8]: print t1[2:]
(2, 3, 4, 7, 7, 7)
In [9]: len(t1)
Out[9]: 8
In [10]: t2 = 'a','b','c'
In [11]: print t2
('a', 'b', 'c')
例2：元組間操作
In [12]: t1+t2
Out[12]: (1, 2, 2, 3, 4, 7, 7, 7, 'a', 'b','c')
In [13]: t1 * 3
Out[13]: (1, 2, 2, 3, 4, 7, 7, 7, 1, 2, 2,3, 4, 7, 7, 7, 1, 2, 2, 3, 4, 7, 7, 7)
In [14]: 'a' in t2
Out[14]: True
In [15]: 1 in t2
Out[15]: False
In [16]: 1 not in t2
Out[16]: True
In [22]: id(t3)
Out[22]: 140455260108832
In [23]: t3[2].append(6)
In [24]: print t3
(1, 2, [3, 4, 6])
In [25]: id(t3)
Out[25]: 140455260108832
相關推薦
Python核心資料型別之序列型別及其運算（字元、列表、元組運算及其深淺拷貝）
Python核心資料型別之序列型別及其運算（列表、元組運算及其拷貝）序列：序列表示索引為非負整數的有序物件集合，包括字串、列表和元組，所有序列都支援迭代；序列型別：字串（strings）：字串也屬於序列型別，不可變型別； 字串字面量：把文字放入單引號、雙引號或
資料結構之二叉樹應用（哈夫曼樹及哈夫曼編碼實現）（C++）
一、哈夫曼樹1.書上用的是靜態連結串列實現，本文中的哈夫曼樹用 排序連結串列 實現；2.實現了從 字元頻率統計、構建權值集合、建立哈夫曼樹、生成哈夫曼編碼，最後對 給定字串的編碼、解碼功能。3.使用到的 “SortedList.h”標頭檔案，在上篇博文：資料結構之排序單鏈表。
第五章 序列：字符串、列表和元組
logs exp ron 進制數 com 有符號 .cn 技術分享 soft 5.1 序列類型操作符 seq[ind]：獲得下標為ind的元素 seq[ind1：ind2]：獲得下標ind1到ind2間的元素集合，不能獲得seq[ind2]的值 seq*expr：序列重復e
python 資料型別 之 數字型別
數字型別 python數字型別有三種： 整數型別、浮點數型別、複數型別。 一、整數型別int() 十進位制：1010 , 99 , -217 十六進位制：0x9a , 0X89 ( 0x , 0X 開頭表示十六進位制) 二進位制：0b010，-0B101 ( 0b , 0B 開頭表示二進
Python—資料型別之Integral型別
Integral型別 Python提供了兩種內建的Integral型別，即int與bool 整型int 整數的大小隻受限於機器的記憶體大小 二進位制用0b表示，八進位制用0o表示，十六進位制用0x表示 算術操作符 +、-、*、/、//、%、** #'/'結果是
Python—資料型別之decimal型別
十進位制型別 要建立Decimals，必須先匯入decimal模組 decimal的精度可以由我們自己指定 函式 decimal.Decimal(x) #x可以是一個整數或字串，但不能是
python資料結構之序列及其操作
序列 在Python中最基本的資料結構是序列（sequence）。序列中的每個元素被分配一個序號----即元素的位置，也稱索引。索引從0開始，0,1,2,3，...。也可以從最後一個數開始，標記為-1，依次為-1，-2，-3.... 列表與元組的區別
數值型別和序列型別 Python入門 Python基本資料型別
Python入門 Python是一門很貼身、智慧的語言。面面俱到、簡單易學，只有你想不到，用上它你會喜歡它的。 學Python並不需要對計算機硬體有太多的瞭解，主要是學習它能替你做什麼，是一門面向物件的語言。 面向物件：你去下館子，到了
python資料型別之數值型別
1.變數 變數是記憶體中的一塊區域，變數名用字母，數字，下劃線組成。python地址變數與C語言剛好相反，一個數據包含多個標籤。 2.算術運算子 +（加），-（減），*（乘），/（除），%（取餘），//（取整） 3.賦值運算子 =（賦值），+=
Python學習之路（２）——標準資料型別續——列表，元組，字典，集合
０．Python之禪 可以通過在python直譯器中輸入import this 檢視python應該注意的一些規範與原則，如下： １．列表 元素用方括號括起，元素之間用逗號隔開,如[1,2,3,4] 三大特點： （1）異構性 列表裡想裝啥就裝啥，即：他可以包含不同種類、
Python核心資料型別——元祖、檔案及其他
最後一個Python集合型別——元組（tuple） 屬性如下： 任意物件的有序集合 通過偏移存取 屬於不可變序列型別 固定長度、異構、任意巢狀 物件引用的陣列 實際應用中的元組： >>> (1,2)+(3,4) (1, 2, 3, 4) >>
python資料型別之int型別
python提供了兩種內建的int型別，即int與bool*。整數與布林型值都是固定的。在布林表示式中，0與False表示False,其他任意整數與true都表示true。在數字表達式中，True表示1，False表示0。 整數 整數的大小隻受於機器的記憶體
Python核心資料型別——字串(1)
實際上，字串是即將學習的從屬於稍大一些的物件類別——序列的第一個代表。要格外留意這裡介紹的序列操作，因為它在今後要學習的其他序列型別（例如列表和元祖）中也同樣適用。 ======================================================
Python基本語法_基本資料型別_序列型別詳解
目錄 序列 序列是一類基本資料型別(字串/列表/元組)的統稱，這些資料型別都含有一些共同的特性。例如：資料型別物件可以包含有若干個元素，這些元素有序排列，並且可以通過下標索引來訪問到其中的一個或幾個元素。 序列型別包含了： String 字串
[python學習手冊-筆記]002.python核心資料型別
python核心資料型別 ❝ 本系列文章是我個人學習《python學習手冊（第五版）》的學習筆記，其中大部分內容為該書的總結和個人理解，小部分內容為相關知識點的擴充套件。 非商業用途轉載請註明作者和出處；商業用途請聯絡本人（[email protected]）獲取許可。 ❞ 先來解決一個書上沒搞懂
python基礎—基本資料型別二（set 集合,深淺拷貝）
1、基礎資料型別彙總補充 str int list bool dict tuple 2、集合 set {} 可變的資料型別，（不可雜湊）裡面的元素必須是不可變的資料型別，無序，不重複 以下是集合最重要的兩點： 去重，把一個列表變成集合，就自動去重了。 關係測試，測試兩組資料之前的
Python資料型別（2）列表和元組
列表和元組 列表和元組都屬於序列型別（sequence）。序列物件中的元素都是有序存放的，可以通過編號訪問其元素。兩者最大的區別在於列表是一種可變序列支援修改其元素，而元組是一種不可變序列，不能修改其元素。 列表 列表（list)是一種可變序列。列表用方括號定義，元素間用逗號隔開。列
Python資料型別——整型、布林型、列表、元祖、字典
Python直譯器可以自動識別使用者輸入的資料型別。建立物件的資料型別，可以通過type檢視。需要注意的是：使用者通過input輸入的資料，其型別均為字串 num1 = input("please input num1: ") num2 = input("please input num2: ") prin
Python資料型別：列表和元組
列表 列表的常用操作 list.append() 追加成員 list.count(x) 計算列表中的引數x出現的次數 list.extend(L)向列表中追加另一個列表L list.index(
Cris 複習Python日記（四）：Python 資料結構之序列和列表
1. 簡單認識序列和列表 # 序列 # 序列是Python 中最基本的資料結構，用於儲存一組有序的資料，所有資料都在序列中擁有一個唯一索引，並且按照元素新增的順序來指定序列 # 序列的分類 # 1.