4內置數據結構_元組_字符串

?

目錄

tuple元組：... 1

字符串：... 3

字符串定義、初始化：... 3

字符串元素訪問：... 3

字符串連接：... 4

字符串分割：... 5

字符串大小寫：... 7

字符串排版：... 7

字符串修改：... 8

字符串查找：... 8

字符串判斷：... 9

is系列：... 10

字符串格式化：... 10

?

?

?

內置數據結構

?

tuple元組：

一個有序的元素組成的集合；

使用()小括號表示；

元組是不可變對象；

?

tuple定義初始化：

tuple()-->empty tuple；

tuple(iterable)-->tuple initialized from iterables items；

?

例：

In [1]: t=tuple()?? #工廠方法

In [2]: t=()

In [3]: t=tuple(range(1,7,2))

In [4]: t=(2,4,6,8)

In [17]: t=(1,)?? #1個tuple元素的定義，若用t=(1)，該()為優先級

In [18]: t

Out[18]: (1,)

In [19]: type(t)

Out[19]: tuple

In [20]: t=(1)

In [21]: type(t)

Out[21]: int

In [23]: t=(1,)*5

In [24]: t

Out[24]: (1, 1, 1, 1, 1)

In [25]: t=(1,2,3)*6

In [26]: t

Out[26]: (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)

?

tuple元素訪問：

通過index訪問tuple，tuple[index]；

正索引，從左至右，從0開始，為列表中的每一個元素編號；

負索引，從右至左，從-1開始；

正負索引不可以超界，否則引發異常IndexError；

?

tuple查詢：

index(value,[start,[step]])，通過value，從指定區間內查找tuple內的元素是否匹配；匹配第一個就立即返回索引號；匹配不到，拋異常ValueError；

count(value)，返回tuple中匹配value的次數；

?

時間復雜度：

index()和count()都是O(n)，隨著tuple數據規模的增大而效率下降；

len(tuple)，返回元素的個數，在外面計數的屬性，O(1)；

?

tuple其它操作：

tuple只讀，所以增改刪方法都沒有；

?

namedtuple命名元組：

幫助文檔中，查閱namedtuple，有使用例程；

namedtuple(typename,field_names,verbose=False,rename=False)

命名元組，返回一個元組的子類，并定義了字段；

field_names可以是空格或逗號分割的字段的字符串，或字段的列表；

面向對象中的坐標用到namedtuple；

?

例：

In [5]: from collections import namedtuple

In [6]: Point=namedtuple('Point',['x','y'])

In [7]: type(Point)

Out[7]: type

In [8]: p=Point(11,22)

In [9]: p

Out[9]: Point(x=11, y=22)

In [10]: p.x

Out[10]: 11

In [11]: p.y

Out[11]: 22

?

In [12]: Student=namedtuple('Student','name age')

In [13]: tom=Student('tom',20)

In [14]: jerry=Student('jerry',18)

In [15]: tom.name

Out[15]: 'tom'

In [16]: jerry.age

Out[16]: 18

?

?

?

字符串：

一個個字符組成的有序的序列，是字符的集合；

使用單引號、雙引號、三引號引住的字符序列；

是不可變對象；

python3起，字符串就是unicode類型（utf-8），在網絡上傳輸時平均碼率很高效；

?

例：

In [1]: a='ab'

In [2]: id(a)

Out[2]: 139712705444752

In [3]: a='ab'+'c'

In [4]: id(a)

Out[4]: 139712709234168

?

字符串定義、初始化：

In [5]: s1='strting'

In [6]: s2='string2'

In [7]: s3='''this's a "string"'''

In [8]: s4='hello \nmagedu.com'

In [9]: s5=r'hello\nmagedu.com'?? #r用于不轉義引號中的轉義符，常用于路徑；

In [10]: s6='c:\windows\nt'

In [11]: s7=R'c:\windows\nt'

In [12]: s8='c:\windows\\nt'

In [13]: sql="""select * from user where name='tom'"""

In [14]: s5

Out[14]: 'hello\\nmagedu.com'

In [16]: print(s4)

hello

magedu.com

In [17]: print(s5)

hello\nmagedu.com

?

字符串元素訪問：

字符串支持使用索引訪問；

有序的字符集合，字符序列；

可迭代；

?

例：

In [18]: sql[4]

Out[18]: 'c'

In [19]: sql[4]='o'?? #不可以，只讀類型

---------------------------------------------------------------------------

TypeError???????????????????????????????? Traceback (most recent call last)

<ipython-input-19-3766fe2ede8f> in <module>()

----> 1 sql[4]='o'

TypeError: 'str' object does not support item assignment

In [21]: for c in sql:

??? ...:???? print(c)

??? ...:????

s

e

l

e

c

t

……

In [24]: type(c)

Out[24]: str

In [25]: lst=list(sql)

In [26]: type(lst)

Out[26]: list

In [27]: lst=tuple(sql)

In [28]: type(lst)

Out[28]: tuple

?

字符串連接：

"string".join(iterable)-->str，將可迭代對象連接起來，使用string作為分隔符；可迭代對象本身元素都是字符串；返回一個新字符串；

+-->str，+連接，將兩個字符串連接在一起；

*，序列都可用*；

?

例：

In [29]: lst=['1','2','3']

In [30]: print('\"'.join(lst))

1"2"3

In [31]: print(' '.join(lst))

1 2 3

In [32]: print('\n'.join(lst))

1

2

3

In [35]: lst=['1',['2','3'],'4']

In [36]: ' '.join(lst)?? #不可以是復雜結構

---------------------------------------------------------------------------

TypeError???????????????????????????????? Traceback (most recent call last)

<ipython-input-36-92a76fd33407> in <module>()

----> 1 ' '.join(lst)

TypeError: sequence item 1: expected str instance, list found

In [37]: a='abc'

In [38]: b=a*3

In [39]: b

Out[39]: 'abcabcabc'

?

字符串分割：

分兩類，split系和partition系；

?

區別如下：

In [1]: 'name:str'.split(':')?? #split返回除分隔符外，兩邊有的字符，若右邊沒有則不會為空字串，而是僅左邊單個元素

Out[1]: ['name', 'str']

In [2]: 'name:'.split(':')

Out[2]: ['name', '']

In [3]: 'name'.split(':')?? # 項目中這樣用會報錯，只返回id，取不到type，s2 = '/student/{name:}/xxx/{id}'，name, type = kv.strip('/{}').split(':')?

Out[3]: ['name']

?

In [4]: 'name:str'.partition(':')?? #partition始終返回三個元素，就算分隔符沒有也返回空字串

Out[4]: ('name', ':', 'str')

In [5]: 'name:'.partition(':')

Out[5]: ('name', ':', '')

In [6]: 'name'.partition(':')

Out[6]: ('name', '', '')

?

?

split系，將字符串按照分隔符分割成若干字符串，并返回列表；

split(sep=None,maxsplit=-1)-->list of strings，sep指定分割字符串，默認以空白字符作為分隔符；maxsplit指定分割的次數，-1表示遍歷整個字符串；

rsplit(sep=None,maxsplit=-1)-->list of strings，reverse split，從右向左（找的順序是從右向左，輸出的順序不變）；

splitlines([keepends])-->list of strings，按照行來切分字符串；keepends指是否保留行分隔符；行分隔符包括\n,\r'n,\r等；

?

inputlist = input('>>> ').split(',')

print(inputlist)

?

例：

In [40]: s1="I'm\ta super sutdent."

In [41]: s1.split()

Out[41]: ["I'm", 'a', 'super', 'sutdent.']

In [42]: s1.split('s')

Out[42]: ["I'm\ta ", 'uper ', 'utdent.']

In [43]: s1.split('super')

Out[43]: ["I'm\ta ", ' sutdent.']

In [44]: s1.split(' ')

Out[44]: ["I'm\ta", 'super', 'sutdent.']

In [45]: s1.split('\t',2)

Out[45]: ["I'm", 'a super sutdent.']

In [46]: s1.rsplit('super',1)

Out[46]: ["I'm\ta ", ' sutdent.']

In [47]: str1='ab c\n\n de fg\rhijk\rl\n'

In [48]: str1.splitlines()

Out[48]: ['ab c', '', ' de fg', 'hijk', 'l']

In [49]: str1.splitlines(True)

Out[49]: ['ab c\n', '\n', ' de fg\r', 'hijk\r', 'l\n']

In [50]: s1='''I'm a super student.

??? ...: You're a super teacher.'''

In [51]: s1.splitlines()

Out[51]: ["I'm a super student.", "You're a super teacher."]

In [52]: s1.splitlines(True)

Out[52]: ["I'm a super student.\n", "You're a super teacher."]

?

partition系，將字符串按分隔符分割成2段，返回這兩段和分隔符的元組；

partition(sep)-->(head,sep,tail)

rpartition(sep)，reverse partition，從右至左，適用于切路徑取文件名；

?

例：

In [55]: s1="I'm a super student"

In [56]: s1.partition('s')

Out[56]: ("I'm a ", 's', 'uper student')

In [56]: s1.partition('s')

Out[56]: ("I'm a ", 's', 'uper student')

In [57]: s1.partition('stu')

Out[57]: ("I'm a super ", 'stu', 'dent')

In [59]: s1.partition(' ')

Out[59]: ("I'm", ' ', 'a super student')

In [60]: s1.partition('abc')?? #找不到分隔符時，sep和tail為空

Out[60]: ("I'm a super student", '', '')

In [63]: s1=r'c:\windows\nt'

In [64]: s1.rpartition('\\')

Out[64]: ('c:\\windows', '\\', 'nt')

?

字符串大小寫：

upper()，全大寫；

lower()，全小寫，大小寫，作判斷的時候用；

swapcase()，交互大小寫，小-->大，大-->小；

?

例：

In [70]: s1='Test'

In [71]: s1.upper()

Out[71]: 'TEST'

In [72]: s1.lower()

Out[72]: 'test'

In [73]: s1.swapcase()

Out[73]: 'tEST'

?

字符串排版：

title()-->str，標題的每個單詞都大寫；

capitalize()-->str，首個單詞大寫；

center(width[,fillchar])-->str，width打印寬度，fillchar填充的字符；

zfill(width)-->str，zero fill，width打印寬度，居右，左邊用0填充；

ljust(width[,fillchar])-->str，左對齊；

rjust(width[,fillchar])-->str，右對齊；

?

例：

In [74]: s1='abc'

In [75]: s1.center(50)

Out[75]: '?????????????????????? abc??????????????????????? '

In [76]: s1.center(50,'#')

Out[76]: '#######################abc########################'

In [77]: s1.zfill(50)

Out[77]: '00000000000000000000000000000000000000000000000abc'

In [78]: s1.ljust(50,'#')

Out[78]: 'abc###############################################'

In [79]: s1.ljust(50,'#')

Out[79]: 'abc###############################################'

?

字符串修改：

replace(old,new[,count])-->str，字符串中找到舊字串替換為新字串，最終返回新字符串，count表示替換幾次，不指定即全部替換；

?

例：

In [80]: s1='www.magedu.com'

In [81]: s1.replace('www','ftp')

Out[81]: 'ftp.magedu.com'

In [82]: s1.replace('w','p',2)

Out[82]: 'ppw.magedu.com'

In [83]: s1.replace('ww','p',1)

Out[83]: 'pw.magedu.com'

In [84]: s1.replace('www','python',1)

Out[84]: 'python.magedu.com'

?

strip([chars])-->str，從字符串兩端去除指定的字符集chars中的所有字符；如果chars不指定，去除兩端的空白字符；

lstrip([chars])-->str，從左開始；

rstrip([chars])-->str，從右開始；

?

例：

In [85]: s1="I am very very sorry"

In [86]: s1.strip('r y')?? #3個字符

Out[86]: 'I am very very so'

?

字符串查找：

find(sub[,start[,end]])-->int，在指定的區間[start,end)，從左至右，查找子串sub，找到返回索引，沒找到返回-1；

rfind(sub[,start[end]])-->int，reverse find，在指定的區間[start,end)，從右至左，查找子串sub，找到返回索引，沒找到返回-1；

查找時最好用find，若用index，異常未捕獲到時程序全崩，而且異常未必能測試出來；

?

例：

In [87]: s1="I am very very sorry"

In [88]: s1.find('very')

Out[88]: 5

In [92]: s1.find('very',6,13)

Out[92]: -1

In [93]: s1.rfind('very',10)

Out[93]: 10

In [94]: s1.rfind('very',10,15)

Out[94]: 10

In [95]: s1.rfind('very',-10,-1)

Out[95]: 10

?

index(sub[,start[,end]])-->int，在指定的區間[start,end)，從左至右，查找子串sub，找到返回索引，沒找到拋異常ValueError；

rindex(sub[,start],end]])-->int，從右至左；

?

count(sub[,start],end]])-->int，在指定的區間[start,end)，從左至右，統計子串sub出現的次數；若查找某段文本中某個單詞的個數，用dict；

?

注：

index()和count()方法都是O(n)，隨著序列數據規模的增大而效率下降；

len(string)，返回字符串長度，即字符的個數，O(1)；

?

字符串判斷：

endswith(suffix[,start[,end]])-->bool，在指定的區間[start,end)，字符串是否是suffix結尾；

startswith([prefix[,start[,end]])-->bool，prefix開頭；

?

例：

In [96]: s1.startswith('very')

Out[96]: False

In [97]: s1.startswith('very',5,9)

Out[97]: True

In [99]: s1.endswith('very',5,9)

Out[99]: True

In [99]: s1.endswith('very',5,9)

Out[99]: True

In [100]: s1.endswith('very',5)

Out[100]: False

In [101]: s1.endswith('very',5,-1)

Out[101]: False

In [102]: s1.endswith('very',5,100)

Out[102]: False

In [104]: for x in s1:

???? ...:???? print(str(i)+x,end=' ')

???? ...:???? i+=1

???? ...:????

0I 1? 2a 3m 4? 5v 6e 7r 8y 9? 10v 11e 12r 13y 14? 15s 16o 17r 18r 19y

?

is系列：

isalnum()-->bool，是否是字母和數字組成；

isalpha()，是否是字母；

isdecimal()，是否只包含十進制數字；

isdigit()，是否全部是數字0-9；

isidentifier()，是否字母和下劃線開頭，其它都是字母、數字、下劃線，應用場景（昵稱是否與python的標識符一致）；

islower()，是否都是小寫；

isupper()，是否全部大寫；

isspace()，是否只包含空白字符；

?

字符串格式化：

字符串的格式化是一種拼接，字符串輸出樣式的手段，更靈活方便；

join拼接只能使用分隔符，且要求被拼接的是iterable對象；

+拼接字符串運算方便，但非字符串需要先轉換為字符串才能拼接；

2.5版本之前，只能使用printf-style風格的print輸出，printf-style formatting來自于C語言的printf函數，格式要求：

占位符，使用%和格式字符組成，如%s、%d等，s調用str()，r調用repr()，所有對象都可被這兩個轉換；

占位符中還可插入修飾字符，如%03d表示打印3個位置，不夠前面補0；

format % values，格式字符串和被格式的值之間用%分隔；

values只能是一個對象，或是一個和格式字符串占位符數目相等的元組，或一個字典；

%%，表示打印%；

?

例：

In [1]: 'I am %03d' % (20,)

Out[1]: 'I am 020'

In [2]: 'I like %s' % 'python'

Out[2]: 'I like python'

In [6]: 'I am %s%%' % 20

Out[6]: 'I am 20%'

In [8]: '%3.2f%%, 0x%x,0x%02X' % (89.7654,10,15)

Out[8]: '89.77%, 0xa,0x0F'

In [9]: 'I am %-5d' % (20,)?? #左對齊，默認右對齊

Out[9]: 'I am 20?? '

?

format()函數格式字符串語法（python鼓勵使用此種）：

'{} {xxx}'.format(*args,**kwargs)-->str

args是位置參數，是一個元組或列表；

kwargs是關鍵字參數，是一個字典；

花括號表示占位符；

{}表示按順序匹配位置參數，{n}表示取位置參數索引為n的值；

{xxx}表示在關鍵字參數中搜索名稱一致的；

{{}}表示打印花括號；

{:>{}}，表示右對齊；

{:<{}}，表示左對齊；

'{:.{}}'.format('xylophone', 7) ??#'xylopho'

print('{:.2f}'.format(2))?? #保留2位小數

?

例：

print('{:>{}}'.format(' '.join([str(j) for j in range(i,0,-1)]),width))

?

例：

In [10]: '{}:{}'.format('192.168.1.100',8888)?? #按位置順序用位置參數，替換到前面的格式字符串的占位符中

Out[10]: '192.168.1.100:8888'

In [12]: '{server} {1}:{0}'.format(8888,'192.168.1.100',server='web server info:')?? #關鍵字參數或命名參數，位置參數按序號匹配，關鍵字參數按名詞匹配；

Out[12]: 'web server info: 192.168.1.100:8888'

In [13]: '{0[0]}.{0[1]}'.format(('magedu','com'))?? #訪問元素

Out[13]: 'magedu.com'

In [15]: '{}'.format(('magedu','com'))

Out[15]: "('magedu', 'com')"

In [16]: '{}.{}'.format('magedu','com')

Out[16]: 'magedu.com'

In [17]: t=('magedu','com')

In [19]: '{}.{}'.format(t[0],t[1])?? #訪問元素

Out[19]: 'magedu.com'

?

例：

In [20]: from collections import namedtuple

In [21]: Point=namedtuple('Point','x y')

In [22]: p=Point(4,5)

In [23]: '{{{0.x},{0.y}}}'.format(p)?? #對象屬性訪問

Out[23]: '{4,5}'

?

In [24]: '{0}*{1}={2:<2}'.format(3,2,3*2)?? #對齊

Out[24]: '3*2=6 '

In [25]: '{}*{}={:<2}'.format(3,2,3*2)

Out[25]: '3*2=6 '

?

In [26]: '{:^30}'.format('centered')?? #^表示居中

Out[26]: '?????????? centered?????????? '

In [27]: '{:*^30}'.format('centered')?? #^前的字符為填充字符

Out[27]: '***********centered***********'

?

In [29]: 'int:{0:d};hex:{0:x};oct:{0:o};bin:{0:b}'.format(42)?? #進制

Out[29]: 'int:42;hex:2a;oct:52;bin:101010'

In [30]: 'int:{0:d};hex:{0:#x};oct:{0:#o};bin:{0:#b}'.format(42)

Out[30]: 'int:42;hex:0x2a;oct:0o52;bin:0b101010'

?

In [31]: ip=[192,168,0,1]

In [32]: '{:02x}{:02x}{:02x}{:02x}'.format(*ip)?? #點分四段十進制表示ipv4法，*ip參數解構

Out[32]: 'c0a80001'

In [33]: '{:02X}{:02X}{:02X}{:02X}'.format(*ip)

Out[33]: 'C0A80001'

?

?