第六章 序列：字符串、列表、元組

一、序列

(1)序列類型操作符

seq[ind] 獲得下標為 ind 的元素

seq[ind1:ind2] 切片操作

seq * expr 　　序列重復 expr 次

seq1 + seq2 　　連接序列

obj in seq 　　判斷 obj 元素是否包含在 seq 中

obj not in seq 　　判斷 obj 元素是否不包含在 seq 中(2)內建函數

類型轉換(工廠)函數：

list(iter) 把可迭代對象轉換為列表

str(obj) 把 obj 對象轉換成字符串(對象的字符串表示法)

unicode(obj) 把對象轉換成 Unicode 字符串(使用默認編碼)

basestring() 抽象工廠函數,其作用僅僅是為 str 和 unicode 函數提供父類，所以不能被實例化，也不能被調用

tuple(iter) 把一個可迭代對象轉換成一個元組對象

操作函數：

enumerate(iter) ?接受一個可迭代對象作為參數，返回一個 enumerate 對象(同時也是一個迭代器),該對象生成由 iter 每個元素的 index 值 和 item 值組成的元組(PEP 279)

len(seq) 返回 seq 的長度

max(iter,key=None) or max(arg0,arg1...,key=None) ?返回 iter 或(arg0,arg1,...)中的最大值，如果指定了 key, 這個 key 必須是一個可以傳給 sort()方法的,用于比較的回調函數

min(iter, key=None) or min(arg0, arg1.... key=None) ?返回 iter 里面的最小值;或者返回(arg0,arg2,...)里面的最小值;若指定了 key,這個 key 必須是一個可以傳給 sort()方法的,用于比較的回調函數

reversed(seq) ?接受一個序列作為參數,返回一個以逆序訪問的迭代器

sorted( iter, func=None, key=None, reverse=False ) ?接受一個可迭代對象作為參數，返回一個有序的列表;可選參數 func,key 和 reverse 的含義跟 list.sort()內建函數的參數含義一 樣.

sum(seq, init=0) ?返 回 seq 和 可 選 參 數 init 的 總 和 , 效果等同于reduce(operator.add,seq,init)

zip([it0, it1,... itN]) ?返回一個列表，其第一個元素是 it0,it1,...這些元素的第一個元素組成的一個元組，第二個...,類推.

二、字符串

1 字符串操作符

索引操作符：

正向索引

反向索引：索引從-1開始，向字符串開始的方向計數！

成員操作符：

in

not in

格式化操作符%

字符串模板

舉例：

>>> from string import Template

>>> s = Template('There are ${howmany} ${lang} Quotation Symbols')

>>> print s.substitute(lang='Python', howmany=3)

打印出：

There are 3 Python Quotation Symbols

原始字符串操作符(r/R):

>>> '\n'

'\n'

>>> r'\n'

'\\n'

>>> print '\n'

>>> print r'\n'

\n

2 內建函數

cmp()

len()

max() 和 min()

enumerate():

>>> s='foobar'

>>> for i, t in enumerate(s):

print i, t

0 f

1 o

...

zip():

>>> s, t = 'foa', 'obr'

>>> zip(s, t)

[('f', 'o'), ('o', 'b'), ('a', 'r')]

isinstance():

>>>isinstance( 'hello world', str )

True

>>>isinstance( 'hello world', unicode )

False

chr(),unichr(),ord():

chr() 整數做參數，返回對應的ASCII字符

unichr() 整數做參數，返回對應的unicode字符

ord() 是上面兩個函數的配對函數，反作用

字符串類型內建函數：

string.capitalize() 把字符串的第一個字符大寫

string.center(width) 返回一個原字符串居中,并使用空格填充至長度 width 的新字符串

string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數

string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式解碼 string，如果出錯默認報一個ValueError的異常，除非errors指定的是 'ignore'或者'replace'

string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式編碼 string，如果出錯默認報一個 ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'

string.endswith(obj, beg=0, end=len(string))　　檢查字符串是否以 obj 結束，如果 beg 或者 end 指定則檢查指 定的范圍內是否以 obj 結束，如果是返回 True,否則返回 False.

string.expandtabs(tabsize=8)把字符串 string 中的 tab 符號轉為空格， 默認的空 格數 tabsize 是 8.

string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定范圍， 則檢查是否包含在指定范圍內，如果是返回開始的索引值，否則 返回-1

string.index(str, beg=0, end=len(string)) 跟 find()方法一樣，只不過如果 str 不在 string 中會報一個異常.

string.isalnum() 如果 string 至少有一個字符并且所有字符都是字母或數字則返 回 True,否則返回 False

string.isalpha() ?如果 string 至少有一個字符并且所有字符都是字母則返回 True, 否則返回 False

string.isdecimal() 如果 string 只包含十進制數字則返回 True 否則返回 False.

string.isdigit() 如果 string 只包含數字則返回 True 否則返回 False.

string.islower() 如果 string 中包含至少一個區分大小寫的字符，并且所有這些(區分 大小寫的)字符都是小寫，則返回 True，否則返回 False

string.isupper() 如果 string 中包含至少一個區分大小寫的字符， 并且所有這些(區分 大小寫的)字符都是大寫，則返回 True，否則返回 False

string.isnumeric() 如果 string 中只包含數字字符，則返回 True，否則返回 False

string.isspace() 如果 string 中只包含空格，則返回 True，否則返回 False.

string.istitle() 如果 string 是標題化的(見 title())則返回 True，否則返回 False

string.join(seq) Merges (concatenates)以 string 作為分隔符，將 seq 中所有的元素 (的字符串表示)合并為一個新的字符串

string.ljust(width) 返回一個原字符串左對齊,并使用空格填充至長度 width 的新字符串

string.lower() 轉換 string 中所有大寫字符為小寫.

string.upper() 轉換 string 中的小寫字母為大寫

string.lstrip() 截掉 string 左邊的空格

string.partition(str) 有點像 find()和 split()的結合體,從str出現的第一個位置起, 把string分成一個3元素的元組(string_pre_str,str,string_post_str),若string中不包含str則string_pre_str == string.

string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.

string.rfind(str, beg=0,end=len(string)) ?類似于 find()函數， 不過是從右邊開始查 找.

string.rindex( str, beg=0,end=len(string)) 類似于 index()， 不過是從右邊開始.

string.rjust(width)返回一個原字符串右對齊,并使用空格填充至長度 width 的新字符串

string.rpartition(str) ?類似于 partition()函數,不過是從右邊開始查找.

string.rstrip() ?刪除 string 字符串末尾的空格.

string.split(str="", num=string.count(str)) 以 str 為分隔符切片 string，如果 num 有指定值，則僅分隔 num 個子字符串

string.splitlines(num=string.count('\n')) 按照行分隔， 返回一個包含各行作為元素 的列表， 如果 num 指定則僅切片 num 個 行.

string.startswith(obj, beg=0,end=len(string)) ?檢查字符串是否是以 obj 開頭，是則 返回 True，否則返回 False。如果 beg 和 end 指定值，則在指定范圍內檢查

string.strip([obj]) 在 string 上執行 lstrip()和 rstrip()

string.swapcase() 翻轉 string 中的大小寫

string.title() 返回"標題化"的 string,就是說所有單詞都是以大寫開始，其余 字母均為小寫(見 istitle())

string.translate(str, del="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符, 要過濾掉的字符放到 del 參數中

string.zfill(width) 返回長度為 width 的字符串，原字符串 string 右對齊，前面填充 0

3 字符串的獨特特性

(1)三引號

Python 的三引號就是為了解決這個問題的， 它允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符：

>>> hi = '''hello

... there'''

>>> hi

'hi\nthere'

(2)字符串不變性

因為python解釋器替你管理內存，所以你根本不需要知道底層發生了什么，每次當你修改一個字符串或者改變字符串內容時，python都會為你分配一個新串

4 Unicode

三、列表

1 列表基礎

創建： aList = [1,2,3,'abc']

訪問：下標或切片

更新：下標、append()追加

刪除列表元素：del aList[1]、 remove(某個元素值)、pop()

2 操作符

標準類型操作符：

> < ==

序列類型操作符：

下標、切片：list[1]、list[1:3]

成員關系操作：in、not in

連接操作符：+

等效果函數：extend():

兩種方式的區別在于+實際上是新建了一個列表而extend()函數是把新列表添加到原有的列表里面了

重復操作符：*

注：python的列表也支持符合賦值操作符

列表類型操作符和列表解析：

>>>[ i*2 for i in [8,-2,5] ]

[16,-4,10]

>>>[ i for i in range(8) if i%2==0 ]

[0,2,4,6]

3 內建函數

cmp()

len()

max() min()

sorted() reversed()

例子 ：

>>> s = ['They', 'stamp', 'them', 'when', "they're", 'small']

>>> sorted(s)

['They', 'small', 'stamp', 'them', "they're", 'when']

解釋：字符串排序使用的是字典序,而非字母序(字母'T'的ASCII碼值比字母'a'靠前)

enumerate() 和 zip()

>>> albums = ['tales', 'robot', 'pyramid']

>>> for i, album in enumerate(albums):

0 tales

1 robot

2 pyramid

sum()

list() 和 tuple(): 列表和元組之間的轉換函數

4 列表類型的內建函數

list.append(obj) 向列表中添加一個對象 obj

list.count(obj) 返回一個對象 obj 在列表中出現的次數

list.extend(seq) 把序列 seq 的內容添加到列表中

list.index(obj, i=0, j=len(list)) 返回 list[k] == obj 的 k 值,并且 k 的范圍在 i<=k

list.insert(index, obj) 在索引量為 index 的位置插入對象 obj.

list.pop(index=-1)a 刪除并返回指定位置的對象,默認是最后一個對象

list.remove(obj) 從列表中刪除對象 obj

list.reverse() 原地翻轉列表

list.sort(func=None,key=None,reverse=False) 以指定的方式排序列表中的成員,如果 func 和 key 參數指定, 則按照指定的方式比較各個元素,如果 reverse 標志被置為 True,則列表以反序排列.

四、元組

1 元組基礎

創建：aTuple = (1,2,'abc')

訪問： 下標、切片

更新：元組同字符串一樣是不可變類型！不能更新或者改變元組的元素，只能構造一個新元組

刪除：不能刪除元組元素，但可以重組或者再造！

2 操作符和內建函數

創建，重復*，連接+，in not in，切片， < > ==

len() max() min() cmp() list() tuple() str()

3 元組的特殊特性

(1)元組也不是那么地“不可變”

雖然元組對象本身是不可變的，但這并不意味著元組包含的可變對象也不可變了：

>>> t = (['xyz', 123], 23, -103.4)

>>> t

(['xyz', 123], 23, -103.4)

>>> t[0][1]

123

>>> t[0][1] = ['abc', 'def']

>>> t

(['xyz', ['abc', 'def']], 23, -103.4)

(2)默認集合類型　　>>> 'abc', -4.24e93, 18+6.6j, 'xyz'

('abc', -4.24e+093, (18+6.6j), 'xyz')

(3)單元組元組

創建一個只有一個元素的元組是行不通的：

>>> ('xyz')

'xyz'

>>> type(('xyz')) # a string, not a tuple

#是一個字符串而非一個元組 ！

因為：由圓括號包裹的一個單一元素首 先被作為分組操作，而不是作為元組的分界符

(4)字典的關鍵字

不可變對象的值是不可改變的。這就意味著它們通過 hash 算法得到的值總是一個值。這是 作為字典鍵值的一個必備條件。鍵值必須是可哈希的對象，元組變量符合此標準，而列表變量不行

五、深拷貝與淺拷貝

序列類型對象的淺拷貝是默認類型拷貝,并可以以下幾種方式實施：

(1)完全切片操作[:],

(2) 利用工廠函數,比如 list(),dict()等,

(3)使用 copy 模塊的 copy 函數.

深拷貝：需要copy.deepcopy()函數！

幾點關于拷貝操作的警告：

第一：非容器類型(比如數字,字符串和其他"原子"類型的 對象,像代碼,類型和 xrange 對象等)沒有被拷貝一說,淺拷貝是用完全切片操作來完成的.

第二：如果元組變量只包含原子類型對象,對它的深拷貝將不會進行

超強干貨來襲 云風專訪：近40年碼齡，通宵達旦的技術人生

總結

以上是生活随笔為你收集整理的python读取序列5之后的数据_Python核心编程读笔 5： python的序列的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。