您好,登录后才能下订单哦!
目录
tuple元组:... 1
字符串:... 3
字符串定义、初始化:... 3
字符串元素访问:... 3
字符串连接:... 4
字符串分割:... 5
字符串大小写:... 7
字符串排版:... 7
字符串修改:... 8
字符串查找:... 8
字符串判断:... 9
is系列:... 10
字符串格式化:... 10
内置数据结构
一个有序的元素组成的集合;
使用()小括号表示;
元组是不可变对象;
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
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'
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。