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)
----> 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)
----> 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'
标题名称：4内置数据结构_元组_字符串
文章起源：http://myzitong.com/article/jpppde.html