4内置数据结构_元组_字符串

创新互联建站是一家专注于成都做网站、成都网站设计、成都外贸网站建设与策划设计,廉江网站建设哪家好?创新互联建站做网站,专注于网站建设十载,网设计领域的专业建站公司;建站业务涵盖:廉江等地区。廉江做网站价格咨询:18980820575

目录

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)

in ()

----> 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)

in ()

----> 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'